182 lines
12 KiB
TypeScript
182 lines
12 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import { createGame, joinGame, newPlayer, viewGame, type Action, type Game } from '../game/engine';
|
|
import { validateNexusCards, NEXUS_FACTIONS } from '../game/nexus-cards';
|
|
import { residualPoisonCandidates } from '../game/residual-poison';
|
|
import { CAPTURE_RESIDUAL_POISON, actResidualPoisonCapture,
|
|
type ResidualPoisonCaptureStep } from './fixture-residual-poison-capture';
|
|
import { nextRicheseStrongholdsNativeStep } from './fixture-richese-strongholds';
|
|
import { semutaGuildIncomeInventory } from './fixture-semuta-guild-income';
|
|
|
|
export type ResidualCunningStep = ResidualPoisonCaptureStep;
|
|
export const actResidualCunning = actResidualPoisonCapture;
|
|
export const residualCunningClean = (game: Game) => !game.response && !game.phaseOpening &&
|
|
!game.decision && !game.truthtrance && !game.pendingTreacheryDiscard;
|
|
export function residualCunningPlayer(game: Game, id: string) {
|
|
const player = game.players.find(player => player.id === id);
|
|
assert.ok(player, `The original ${id} seat must remain present`);
|
|
return player;
|
|
}
|
|
export function residualCunningInventory(game: Game) {
|
|
const treachery = semutaGuildIncomeInventory(game);
|
|
assert.ok(game.nexusCards?.cards);
|
|
const cards = game.nexusCards.cards;
|
|
validateNexusCards(cards, game.players);
|
|
const nexus = [...cards.deck, ...cards.discard, ...Object.values(cards.hands).filter(card => card !== null)].sort();
|
|
assert.deepEqual(nexus, [...NEXUS_FACTIONS].sort());
|
|
return { treachery, nexus };
|
|
}
|
|
export function residualCunningPhysical(game: Game) {
|
|
return game.players.map(player => ({ id: player.id, spice: player.spice, reserves: player.reserves,
|
|
tanks: player.tanks, forces: structuredClone(player.forces), elites: structuredClone(player.elites),
|
|
moved: player.moved, shipped: player.shipped }));
|
|
}
|
|
/** Native setup, no-spend ordinary controls and a genuine one-spice cache bid.
|
|
* The inspected answer itself and sealed plans are explicit owned choices. */
|
|
export function nextResidualCunningStep(game: Game): ResidualCunningStep | null {
|
|
if (residualCunningClean(game) && game.nexusCards?.phase?.stage === 'drawing') {
|
|
const actor = game.nexusCards.phase.eligible.find(id => !game.nexusCards!.phase!.done.includes(id));
|
|
assert.ok(actor);
|
|
return { actor, action: { type: 'nexusCardChoice', turn: game.turn,
|
|
card: game.nexusCards.cards!.hands[actor], choice: 'keep', ownRedraws: 0 } };
|
|
}
|
|
if (!game.response && !game.phaseOpening && !game.pendingTreacheryDiscard) {
|
|
if (game.decision?.kind === 'richeseCache' && game.richeseCache?.some(card => card.id === CAPTURE_RESIDUAL_POISON))
|
|
return { actor: game.decision.player, action: { type: 'decision', event: game.richeseBidding!.event,
|
|
card: CAPTURE_RESIDUAL_POISON, method: 'onceAround', direction: 'counterclockwise' } };
|
|
if (residualCunningClean(game) && game.richeseAuction?.cardId === CAPTURE_RESIDUAL_POISON &&
|
|
!game.richeseAuction.outcome && game.richeseAuction.active === 'a' && game.richeseAuction.bid === 0)
|
|
return { actor: 'a', action: { type: 'richeseBid', event: game.richeseAuction.event, amount: 1, allyPayment: 0 } };
|
|
}
|
|
return nextRicheseStrongholdsNativeStep(game);
|
|
}
|
|
export function advanceResidualCunning(game: Game, until: (state: Game) => boolean,
|
|
actions: ResidualCunningStep[] = []): Game {
|
|
for (let count = 0; count < 1800; count++) {
|
|
if (until(game)) return game;
|
|
assert.notEqual(game.status, 'finished', 'The original Residual/Cunning source ended before its owned boundary');
|
|
const step = nextResidualCunningStep(game);
|
|
assert.ok(step, `The native ${game.turn}/${game.phase}/${game.decision?.kind} requires an explicit owned action`);
|
|
game = actResidualCunning(game, step.actor, step.action, actions);
|
|
}
|
|
throw Error('The native Residual/Cunning source did not reach its finite boundary');
|
|
}
|
|
function orderSpice(game: Game, names: readonly string[]) {
|
|
const cards = names.map(name => {
|
|
const at = game.spiceDeck.findIndex(card => name === 'worm'
|
|
? 'worm' in card && !card.greatMaker && !card.thumper && !card.suppressed
|
|
: 'territory' in card && !card.discovery && card.territory === name);
|
|
assert.ok(at >= 0, `The original ${name} Spice Card must remain unopened`);
|
|
return game.spiceDeck.splice(at, 1)[0];
|
|
});
|
|
game.spiceDeck.unshift(...cards);
|
|
}
|
|
|
|
/** Fresh public native start, paid cache purchase, actual natural Nexus and
|
|
* own-faction draw, real opposing shipment, and two actual inspected answers.
|
|
* Only unopened Spice/Nexus positions and scalar lotteries are selected. */
|
|
export function createResidualCunningFixture(options: { advanced?: boolean } = {}) {
|
|
const advanced = options.advanced ?? false;
|
|
let game = createGame('RESIDUALCUNNING', newPlayer('r', 'Richese', 'richese'), advanced, ['choam']);
|
|
for (const [id, name, faction] of [['a', 'Atreides', 'atreides'], ['e', 'Emperor', 'emperor'],
|
|
['g', 'Guild', 'guild']] as const) joinGame(game, newPlayer(id, name, faction));
|
|
const actions: ResidualCunningStep[] = [];
|
|
const act = (actor: string, action: Action) => { game = actResidualCunning(game, actor, action, actions); };
|
|
const reach = (until: (state: Game) => boolean) => { game = advanceResidualCunning(game, until, actions); };
|
|
act(game.host, { type: 'moduleOption', module: 'nexusCards', enabled: true });
|
|
for (const player of game.players) act(player.id, { type: 'ready' });
|
|
const initial = structuredClone(game);
|
|
act(game.host, advanced ? { type: 'start', advancedPreview: true } : { type: 'start' });
|
|
const setup = structuredClone(game);
|
|
reach(state => state.status === 'playing');
|
|
const afterSetup = structuredClone(game), originalInventory = residualCunningInventory(game);
|
|
orderSpice(game, ['broken_land', ...(advanced ? ['south_mesa'] : [])]);
|
|
reach(state => state.decision?.kind === 'richeseCache');
|
|
const beforePurchase = structuredClone(game), purchaseStart = actions.length;
|
|
reach(state => residualCunningPlayer(state, 'a').hand.some(card => card.id === CAPTURE_RESIDUAL_POISON) && residualCunningClean(state));
|
|
const acquisition = { before: beforePurchase, actions: structuredClone(actions.slice(purchaseStart)), after: structuredClone(game) };
|
|
reach(state => state.turn === 2 && state.phase === 1 && residualCunningClean(state));
|
|
const afterFirstTurn = structuredClone(game);
|
|
orderSpice(game, ['worm', 'hagga_basin', ...(advanced ? ['red_chasm'] : [])]);
|
|
reach(state => state.nexus && !state.spiceWindow && !state.spiceResolution && residualCunningClean(state));
|
|
const beforeAlliance = structuredClone(game);
|
|
act('e', { type: 'alliance', target: 'g' });
|
|
act('g', { type: 'alliance', target: 'e' });
|
|
reach(state => state.nexusCards?.phase?.stage === 'drawing' && residualCunningClean(state));
|
|
const cards = game.nexusCards!.cards!, at = cards.deck.indexOf('atreides');
|
|
assert.ok(at >= 0, 'The native Atreides Nexus singleton must remain undrawn');
|
|
cards.deck.unshift(cards.deck.splice(at, 1)[0]);
|
|
const beforeDraw = structuredClone(game), drawStart = actions.length;
|
|
for (const actor of game.nexusCards!.phase!.eligible) {
|
|
act(actor, { type: 'nexusCardChoice', turn: game.turn, card: game.nexusCards!.cards!.hands[actor],
|
|
choice: actor === 'a' ? 'draw' : 'keep', ownRedraws: 0 });
|
|
}
|
|
const afterDraw = structuredClone(game), drawActions = structuredClone(actions.slice(drawStart));
|
|
assert.equal(game.nexusCards!.cards!.hands.a, 'atreides');
|
|
reach(state => state.turn === 2 && state.phase === 5 && state.active === 'r' && residualCunningClean(state));
|
|
const beforeShipment = structuredClone(game), shipment: ResidualCunningStep = { actor: 'r',
|
|
action: { type: 'ship', territory: 'arrakeen', sector: 10, amount: 1, elite: 0, allyPayment: 0 } };
|
|
act(shipment.actor, shipment.action); reach(residualCunningClean);
|
|
const afterShipment = structuredClone(game);
|
|
reach(state => state.phase === 6 && residualCunningClean(state));
|
|
assert.ok(game.active === 'r' || game.active === 'a');
|
|
const beforeBattle = structuredClone(game), chooser = game.active, target = chooser === 'r' ? 'a' : 'r';
|
|
const choice: ResidualCunningStep = { actor: chooser,
|
|
action: { type: 'chooseBattle', territory: 'arrakeen', target } };
|
|
act(choice.actor, choice.action);
|
|
reach(state => state.battle?.preparation?.kind === 'prescience' && !state.response && !state.phaseOpening && !state.decision);
|
|
const beforeNative = structuredClone(game), nativeStart = actions.length;
|
|
act('a', { type: 'prescience', field: 'dial' });
|
|
reach(state => !state.response && state.battle?.preparation?.kind === 'prescienceAnswer');
|
|
act('r', { type: 'prescienceAnswer', value: 0 });
|
|
reach(state => !!state.battle?.preLeader?.closed && !state.battle.preparation && residualCunningClean(state));
|
|
const afterNative = structuredClone(game), nativeActions = structuredClone(actions.slice(nativeStart));
|
|
const event = game.battle!.event!, cunningStart = actions.length;
|
|
const cunning: Action = { type: 'nexusAtreides', event, mode: 'cunning', field: 'weapon' };
|
|
act('a', cunning);
|
|
reach(state => !state.response && state.battle?.preparation?.kind === 'nexusPrescienceAnswer');
|
|
act('r', { type: 'nexusPrescienceAnswer', event, value: null });
|
|
const cunningActions = structuredClone(actions.slice(cunningStart));
|
|
assert.equal(game.battle!.nexusInspection!.stage, 'answered');
|
|
assert.deepEqual(game.battle!.nexusInspection!.answers, [null]);
|
|
assert.deepEqual(game.battle!.plans, {});
|
|
assert.equal(game.battle!.preparation ?? null, null);
|
|
assert.ok(residualPoisonCandidates(residualCunningPlayer(game, 'r').leaders, 'arrakeen').length > 1);
|
|
const option = viewGame(game, 'a').residualPoison;
|
|
assert.ok(option && !option.blocked, option?.blocked ?? 'The earned answered-Cunning window must permit the original card');
|
|
const action: Action = { type: 'card', card: CAPTURE_RESIDUAL_POISON, target: 'r', event };
|
|
return { game, advanced, holder: 'a', target: 'r', card: CAPTURE_RESIDUAL_POISON, event, action,
|
|
initial, setup, afterSetup, acquisition, afterFirstTurn, beforeAlliance, beforeDraw, afterDraw, drawActions,
|
|
beforeShipment, shipment, afterShipment, beforeBattle, choice, beforeNative, afterNative, nativeActions,
|
|
cunning, cunningActions, originalInventory, originalPhysical: residualCunningPhysical(game),
|
|
originalPrescience: structuredClone(game.battle!.prescience),
|
|
originalInspection: structuredClone(game.battle!.nexusInspection),
|
|
originalLeaders: structuredClone(residualCunningPlayer(game, 'r').leaders),
|
|
actions, sourceActionCount: actions.length,
|
|
staging: ['Only unopened original Spice/Nexus positions and scalar lotteries are selected. The public start, paid Residual1 lot, E/G alliance, native Atreides own-card draw, Richese1 Arrakeen shipment, battle, native dial0, shared readiness and Cunning weapon-null answer are actual actions.'] };
|
|
}
|
|
export type ResidualCunningFixture = ReturnType<typeof createResidualCunningFixture>;
|
|
export function playResidualCunning(fixture: ResidualCunningFixture, game = structuredClone(fixture.game),
|
|
actions: ResidualCunningStep[] = []) {
|
|
return actResidualCunning(game, fixture.holder, fixture.action, actions);
|
|
}
|
|
/** Seal real legal surviving native leaders and resolve only this battle's
|
|
* existing votes/disposal/aftermath. No plan, result or later phase is staged. */
|
|
export function finishResidualCunning(fixture: ResidualCunningFixture, game: Game,
|
|
actions: ResidualCunningStep[] = []) {
|
|
game = advanceResidualCunning(game, state => !!state.battle?.preLeader?.closed &&
|
|
!state.battle.preparation && residualCunningClean(state), actions);
|
|
const target = residualPoisonCandidates(residualCunningPlayer(game, fixture.target).leaders, 'arrakeen')
|
|
.sort((a, b) => a.strength - b.strength)[0];
|
|
const owner = residualPoisonCandidates(residualCunningPlayer(game, fixture.holder).leaders, 'arrakeen')
|
|
.sort((a, b) => b.strength - a.strength)[0];
|
|
assert.ok(target && owner && owner.strength > target.strength);
|
|
const plans: ResidualCunningStep[] = [
|
|
{ actor: fixture.target, action: { type: 'battlePlan', leader: target.id, dial: 0, support: 0 } },
|
|
{ actor: fixture.holder, action: { type: 'battlePlan', leader: owner.id, dial: 0, support: 0 } },
|
|
];
|
|
for (const step of plans) game = actResidualCunning(game, step.actor, step.action, actions);
|
|
const sealed = structuredClone(game);
|
|
game = advanceResidualCunning(game, state => !state.battle && residualCunningClean(state), actions);
|
|
return { game, sealed, plans, actions };
|
|
}
|