Files
Dune/tests/recruits-replay.test.ts
T
Quintine de7fe7d64a
Verify and publish checkpoint container / container (push) Successful in 10m51s
Allow recovered Recruits replay and more bribe windows
2026-11-16 22:00:35 +11:00

88 lines
5.1 KiB
TypeScript

import assert from 'node:assert/strict';
import test from 'node:test';
import { applyAction, viewGame, type Game } from '../game/engine';
import { recruitsPlayAction, recruitsRevivalAllowance, type RecruitsRevivalFacts } from '../game/recruits';
import {
actSemutaRecruits as act, createSemutaRecruitsFixture as fixture,
semutaRecruitsInventory as inventory, semutaRecruitsPlayer as player,
} from './fixture-semuta-recruits';
const facts: RecruitsRevivalFacts = {
currentFreeRate: 2, currentLimit: 3, revived: 0, freeAllowanceUsed: 0, freeRateCap: 20,
};
void test('each actual Recruits use provisionally doubles the current native free rate, with one ordinary cap', () => {
const scope = (uses?: number) => ({ turn: 2, recruits: { turn: 2, ...(uses === undefined ? {} : { uses }) } });
assert.equal(recruitsRevivalAllowance(scope(), facts).freeRate, 4, 'old receipt means one use');
assert.equal(recruitsRevivalAllowance(scope(1), facts).freeRate, 4);
const second = recruitsRevivalAllowance(scope(2), facts);
assert.equal(second.freeRate, 7);
assert.equal(second.limit, 7, 'the normal seven-force limit does not multiply');
const used = recruitsRevivalAllowance(scope(2), { ...facts, revived: 3, freeAllowanceUsed: 2 });
assert.equal(used.remaining, 4);
assert.equal(used.freeRemaining, 4, 'earlier free and paid returns remain in their respective ledgers');
const unlimited = recruitsRevivalAllowance(scope(2), {
...facts, currentFreeRate: 4, currentLimit: 20,
});
assert.equal(unlimited.freeRate, 16);
assert.equal(unlimited.limit, 20);
assert.equal(recruitsRevivalAllowance(scope(100), { ...facts, currentLimit: 20 }).freeRate, 20);
assert.equal(recruitsRevivalAllowance(scope(100), { ...facts, currentFreeRate: 0 }).freeRate, 0);
assert.equal(recruitsRevivalAllowance(scope(2), { ...facts, freeBlocked: true }).freeRate, 0);
assert.equal(recruitsRevivalAllowance(scope(2), { ...facts, revivalBlocked: true }).freeRemaining, 0);
assert.equal(recruitsRevivalAllowance({ turn: 3, recruits: { turn: 2, uses: 2 } }, facts).freeRate, 2);
for (const uses of [0, -1, 1.5, Number.NaN, Number.MAX_SAFE_INTEGER + 1])
assert.throws(() => recruitsRevivalAllowance(scope(uses), facts), /positive safe integer/);
});
/** Genuine public Basic setup and normal auctions give the holder its real
* Semuta and the owner the physical Recruits. The real next Storm sends the
* owner's shipped group to the Tanks; no card or counter is injected. */
void test('Semuta acquires and replays the same physical Recruits, retaining the first use and actual revival', () => {
const f = fixture();
let game = act(f.game, f.owner, f.play);
let discard = game.pendingTreacheryDiscard;
assert.ok(discard?.reaction && discard.reaction.stage === 'offer');
const firstEvent = discard.batch.event;
game = act(game, f.holder, { type: 'semutaCommit', event: firstEvent });
if (game.pendingTreacheryDiscard?.reaction?.stage === 'select')
game = act(game, f.holder, { type: 'semutaSelect', event: firstEvent, card: 'ecaz-recruits' });
assert.equal(game.pendingTreacheryDiscard, null);
assert.ok(player(game, f.holder).hand.some(card => card.id === 'ecaz-recruits'));
assert.equal(viewGame(game, f.owner).revival.freeRemaining, 4);
const priorSpice = player(game, f.owner).spice;
game = act(game, f.owner, { type: 'revive', amount: 2, elite: 0 });
assert.equal(player(game, f.owner).freeForcesRevived, 2);
assert.equal(player(game, f.owner).spice, priorSpice);
const replay = recruitsPlayAction(viewGame(game, f.holder).recruitsPreview);
assert.deepEqual(replay, f.play);
const before = structuredClone(game);
assert.throws(() => applyAction(game, f.owner, f.play), 'only the actual card holder may replay it');
assert.deepEqual(game, before);
game = act(game, f.holder, f.play);
assert.equal(game.recruits?.uses, 2);
assert.equal(game.recruits?.player, f.holder);
discard = game.pendingTreacheryDiscard;
if (discard?.reaction?.stage === 'offer') {
const event = discard.batch.event;
assert.notEqual(event, firstEvent);
for (const seat of game.players) game = act(game, seat.id, { type: 'semutaPass', event });
}
assert.equal(game.pendingTreacheryDiscard, null);
assert.equal(viewGame(game, f.owner).revival.limit, 7);
assert.equal(viewGame(game, f.owner).revival.freeRemaining, 5);
assert.equal(viewGame(game, f.owner).recruitsPreview?.plays, 2);
assert.equal(player(game, f.owner).freeForcesRevived, 2);
assert.equal(player(game, f.owner).spice, priorSpice);
assert.equal(game.discard.filter(card => card.id === 'ecaz-recruits').length, 1);
assert.equal(game.players.flatMap(seat => seat.hand).filter(card => card.id === 'ecaz-recruits').length, 0);
assert.deepEqual(inventory(game), f.originalInventory);
const restored = JSON.parse(JSON.stringify(game)) as Game;
assert.equal(viewGame(restored, f.owner).revival.freeRemaining, 5);
assert.equal(viewGame(restored, f.owner).recruitsPreview?.plays, 2);
game = act(game, f.owner, { type: 'revive', amount: 1, elite: 0 });
assert.equal(player(game, f.owner).freeForcesRevived, 3);
assert.equal(player(game, f.owner).spice, priorSpice);
});