88 lines
5.1 KiB
TypeScript
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);
|
|
});
|