76 lines
4.7 KiB
TypeScript
76 lines
4.7 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import { viewGame, type Action, type Game } from '../game/engine';
|
|
import {
|
|
actTruthTraitorDecision, advanceTruthTraitorDecision, createTruthTraitorDecisionFixture,
|
|
truthTraitorDecisionClean, truthTraitorDecisionInventory, truthTraitorDecisionPlayer,
|
|
type TruthTraitorDecisionStep,
|
|
} from './fixture-truth-traitor-decision';
|
|
|
|
export const actFutureBattleLeader = actTruthTraitorDecision;
|
|
export const advanceFutureBattleLeader = advanceTruthTraitorDecision;
|
|
export const futureBattleLeaderClean = truthTraitorDecisionClean;
|
|
export const futureBattleLeaderInventory = truthTraitorDecisionInventory;
|
|
export const futureBattleLeaderPlayer = truthTraitorDecisionPlayer;
|
|
export type FutureBattleLeaderStep = TruthTraitorDecisionStep;
|
|
export type FutureBattleLeaderRecord = {
|
|
turn: number; asker: string; player: string; leader: string; answer: boolean;
|
|
battle?: string; status: 'waiting' | 'bound' | 'settled' | 'expired' | 'released';
|
|
};
|
|
export function futureBattleLeaderRecords(game: Game): FutureBattleLeaderRecord[] {
|
|
return (game as Game & { futureBattleLeaderPromises?: FutureBattleLeaderRecord[] }).futureBattleLeaderPromises ?? [];
|
|
}
|
|
|
|
/** Reuse the source's genuinely earned Basic Movement boundary. Only its
|
|
* original unopened card/spice order and existing scalar lotteries were
|
|
* selected; no battle, private plan or answer is installed. */
|
|
export function createFutureBattleLeaderFixture() {
|
|
const base = createTruthTraitorDecisionFixture();
|
|
const game = structuredClone(base.beforeShipment);
|
|
assert.equal(game.turn, 1); assert.equal(game.phase, 5); assert.equal(game.active, base.target);
|
|
assert.equal(game.advanced, false); assert.deepEqual(game.expansions, []);
|
|
assert.ok(!game.battle && futureBattleLeaderClean(game));
|
|
assert.ok(futureBattleLeaderPlayer(game, base.asker).hand.some(card => card.id === base.truth));
|
|
const leader = base.leaders.emperor;
|
|
const otherLeader = futureBattleLeaderPlayer(game, base.target).leaders.find(item => item.id !== leader && !item.dead && !item.usedAt);
|
|
assert.ok(otherLeader);
|
|
assert.deepEqual(futureBattleLeaderInventory(game), base.originalCards);
|
|
const question = { kind: 'futureBattleLeader', target: base.target, turn: game.turn, leader };
|
|
const ask = { type: 'truthAsk', question } as unknown as Action;
|
|
return { base, game, source: structuredClone(game), question, ask, leader, otherLeader: otherLeader.id,
|
|
asker: base.asker, target: base.target, truth: base.truth, originalCards: base.originalCards,
|
|
targetPlan: base.targetPlan, ownPlan: base.ownPlan, territory: base.territory,
|
|
shipmentStep: base.shipmentStep };
|
|
}
|
|
export type FutureBattleLeaderFixture = ReturnType<typeof createFutureBattleLeaderFixture>;
|
|
|
|
export function declareFutureBattleLeader(fixture: FutureBattleLeaderFixture): Game {
|
|
let game = actFutureBattleLeader(fixture.game, fixture.asker, { type: 'card', card: fixture.truth });
|
|
for (let count = 0; game.truthtrance?.stage === 'priority' && count < game.players.length; count++) {
|
|
const player = game.players.find(seat => !game.truthtrance!.passed.includes(seat.id)); assert.ok(player);
|
|
game = actFutureBattleLeader(game, player.id, { type: 'truthPass' });
|
|
}
|
|
assert.equal(game.truthtrance?.stage, 'ask');
|
|
return actFutureBattleLeader(game, fixture.asker, fixture.ask);
|
|
}
|
|
export function answerFutureBattleLeader(game: Game, fixture: FutureBattleLeaderFixture, answer: 'yes' | 'no'): Game {
|
|
return actFutureBattleLeader(game, fixture.target, { type: 'truthAnswer', answer });
|
|
}
|
|
|
|
/** Use the source's actual paid shipment, then the native choice and
|
|
* preparation controls; the caller alone seals plans and traitor votes. */
|
|
export function reachFutureBattle(game: Game, fixture: FutureBattleLeaderFixture): Game {
|
|
game = actFutureBattleLeader(game, fixture.shipmentStep.actor, fixture.shipmentStep.action);
|
|
game = advanceFutureBattleLeader(game, futureBattleLeaderClean);
|
|
game = actFutureBattleLeader(game, fixture.target, { type: 'endMovement' });
|
|
game = advanceFutureBattleLeader(game, state => state.phase === 6 && futureBattleLeaderClean(state) && !!state.active && !state.battle);
|
|
const chooser = game.active!;
|
|
const choice = viewGame(game, chooser).battleChoices.find(row => row.territory === fixture.territory &&
|
|
[row.attacker, row.defender].includes(fixture.target));
|
|
assert.ok(choice);
|
|
game = actFutureBattleLeader(game, choice.chooser, { type: 'chooseBattle', territory: choice.territory,
|
|
target: choice.attacker === choice.chooser ? choice.defender : choice.attacker });
|
|
assert.ok(game.battle?.event);
|
|
return advanceFutureBattleLeader(game, state => !!state.battle && futureBattleLeaderClean(state) &&
|
|
!state.battle.preparation && state.battle.preLeader?.closed !== false);
|
|
}
|