164 lines
11 KiB
TypeScript
164 lines
11 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import { viewGame, type Action, type Game } from '../game/engine';
|
|
import { spiceDeck } from '../game/cards';
|
|
import { nativeShipmentSources } from '../game/homeworld-options';
|
|
import { homeworldGameIntegrity } from '../game/homeworld-game';
|
|
import { LEADER_SKILL_CARDS } from '../game/leader-skill-cards';
|
|
import {
|
|
actMixedPhaseModules, createMixedPhaseModulesFixture, mixedPhaseModulesClean,
|
|
mixedPhaseModulesInventory, mixedPhaseModulesPlayer, nextMixedPhaseModules,
|
|
type MixedPhaseModulesStep, type MixedPhaseModulesTransition,
|
|
} from './fixture-mixed-phase-modules';
|
|
import { beforeIxSpiceDraw, orderIxSpiceCards, type IxSpicePick } from './fixture-ix-spice-cards';
|
|
|
|
export type WorldSandtroutStep = MixedPhaseModulesStep;
|
|
export type WorldSandtroutTransition = MixedPhaseModulesTransition;
|
|
export const WORLD_SANDTROUT_TRAINING = { atreides: 'warmaster', emperor: 'spice-banker', ixians: 'mentat' } as const;
|
|
export const actWorldSandtrout = actMixedPhaseModules;
|
|
export const nextWorldSandtrout = nextMixedPhaseModules;
|
|
export const worldSandtroutClean = mixedPhaseModulesClean;
|
|
export const worldSandtroutPlayer = mixedPhaseModulesPlayer;
|
|
export const worldSandtroutInventory = mixedPhaseModulesInventory;
|
|
export function advanceWorldSandtrout(game: Game, until: (state: Game) => boolean,
|
|
actions: WorldSandtroutStep[] = []): Game {
|
|
for (let count = 0; count < 1800; count++) {
|
|
if (until(game)) return game;
|
|
assert.notEqual(game.status, 'finished', 'The original World Sandtrout source ended before its native control');
|
|
const next = nextWorldSandtrout(game); assert.ok(next);
|
|
game = actWorldSandtrout(game, next.actor, next.action, actions);
|
|
}
|
|
throw Error('The original World Sandtrout source did not reach its finite boundary');
|
|
}
|
|
export function finishWorldSandtrout(game: Game, actions: WorldSandtroutStep[] = []): Game {
|
|
const turn = game.turn;
|
|
return advanceWorldSandtrout(game, state => state.turn === turn && state.phase === 2 && worldSandtroutClean(state), actions);
|
|
}
|
|
export function worldSandtroutDeferred(game: Game, owner = 'emperor') {
|
|
return viewGame(game, owner).spiceBankerIncome?.deferred.find(row => row.owner === owner)?.amount ?? 0;
|
|
}
|
|
|
|
/** Sandtrout is set aside while active: count its live boolean once, then its
|
|
* physical discard once after suppression. Suppression annotates an original
|
|
* worm; it does not mint another Spice Card. */
|
|
export function worldSandtroutSpice(game: Game) {
|
|
const cards = [...game.spiceDeck, ...game.spiceDiscard.flat(), ...(game.spiceSequence?.skipped ?? [])]
|
|
.filter(card => !('worm' in card && card.thumper));
|
|
const inventory = cards.map(card => JSON.stringify('worm' in card ? { worm: true } : card));
|
|
if (game.sandtrout) inventory.push(JSON.stringify({ sandtrout: true }));
|
|
assert.equal(cards.filter(card => 'worm' in card).length, 6);
|
|
assert.equal(cards.filter(card => 'territory' in card).length, 15);
|
|
assert.equal(cards.filter(card => 'sandtrout' in card).length + Number(!!game.sandtrout), 1);
|
|
assert.deepEqual(inventory.sort(), spiceDeck(true).map(card => JSON.stringify(card)).sort());
|
|
return inventory.sort();
|
|
}
|
|
export function worldSandtroutSkills(game: Game) {
|
|
const skills = game.leaderSkills ? [...game.leaderSkills.deck,
|
|
...game.leaderSkills.assignments.map(assignment => assignment.skill),
|
|
...Object.values(game.leaderSkills.offers).flatMap(offer => offer.cards)].sort() : [];
|
|
if (game.leaderSkills) assert.deepEqual(skills, LEADER_SKILL_CARDS.map(card => card.id).sort());
|
|
return skills;
|
|
}
|
|
export function worldSandtroutStocks(game: Game) {
|
|
return game.players.map(player => ({ player: player.id, reserves: player.reserves, tanks: player.tanks,
|
|
forces: structuredClone(player.forces), eliteReserves: player.elites?.reserves ?? 0,
|
|
eliteTanks: player.elites?.tanks ?? 0, eliteForces: structuredClone(player.elites?.forces ?? {}) }));
|
|
}
|
|
|
|
/** Genuine public A/E/Ix +Ix World/Tech setup. Advanced additionally trains
|
|
* three original all14 offers and enables original Strongholds. Only the
|
|
* original scalar/Skill lottery and unopened Spice prefix are selected. No
|
|
* played Sandtrout flag, card, force, wallet, occupation or clock is installed.
|
|
* Stop at the actual first blow with Sandtrout physically waiting. */
|
|
export function createWorldSandtroutFixture(options: { advanced?: boolean; firstTurnWorm?: boolean } = {}) {
|
|
const advanced = options.advanced ?? false, firstTurnWorm = options.firstTurnWorm ?? false;
|
|
const source = createMixedPhaseModulesFixture({ factions: ['atreides', 'emperor', 'ixians'], expansions: ['ix'],
|
|
advanced, homeworlds: true, tech: true, strongholds: advanced, skills: advanced,
|
|
training: advanced ? WORLD_SANDTROUT_TRAINING : undefined });
|
|
let game = structuredClone(source.game);
|
|
const actions = [...source.actions];
|
|
assert.ok(beforeIxSpiceDraw(game));
|
|
const picks: IxSpicePick[] = ['sandtrout', ...(firstTurnWorm ? ['worm' as const] : []),
|
|
{ territory: 'broken_land' }, ...(advanced ? [{ territory: 'funeral_plain' }] : [])];
|
|
const spiceOrder = orderIxSpiceCards(game, picks);
|
|
const beforeDraw = structuredClone(game), from = actions.length;
|
|
game = advanceWorldSandtrout(game, state => !!state.spiceWindow && worldSandtroutClean(state), actions);
|
|
const draw: WorldSandtroutTransition = { before: beforeDraw, steps: structuredClone(actions.slice(from)), after: structuredClone(game) };
|
|
assert.equal(game.sandtrout, true); assert.equal(game.spiceWindow!.territory, 'broken_land');
|
|
assert.equal(game.nexus, false);
|
|
const originalSpice = worldSandtroutSpice(source.setup), originalSkills = worldSandtroutSkills(source.setup);
|
|
assert.deepEqual(worldSandtroutSpice(game), originalSpice);
|
|
assert.deepEqual(worldSandtroutInventory(game), source.originalInventory);
|
|
homeworldGameIntegrity(game);
|
|
return { ...source, game, sourceGame: structuredClone(game), advanced, firstTurnWorm,
|
|
actor: 'atreides', owner: 'atreides', action: { type: 'ready' } as Action, banker: advanced ? 'emperor' : null,
|
|
origin: 'homeworld:atreides', target: game.spiceWindow!.territory, targetSector: game.spiceWindow!.sector,
|
|
targetLocation: `${game.spiceWindow!.territory}:${game.spiceWindow!.sector}`,
|
|
spiceOrder, beforeDraw, draw, originalSpice, originalSkills,
|
|
training: advanced ? WORLD_SANDTROUT_TRAINING : null,
|
|
actions, sourceActions: structuredClone(actions), sourceActionCount: actions.length,
|
|
staging: [] as string[], sourceDisclosure: 'Original public A/E/Ix Worlds/Tech and optional Advanced all14/Strongholds use actual controls. Only original scalar/Skill lotteries and unopened Sandtrout/territory/worm positions are selected; no played flags, hands, armies, wallets, occupation state or turn is installed. First-turn ignoring and immediate-only doubling retain the provisional source policy in docs/IX_PROTOTYPE.md.' };
|
|
}
|
|
export type WorldSandtroutFixture = ReturnType<typeof createWorldSandtroutFixture>;
|
|
|
|
/** An actual paid native A2 arrival becomes the later worm's physical source.
|
|
* The active original Sandtrout survives real Collection, Mentat and Storm;
|
|
* the next drawn worm is suppressed and only its immediate territory doubles. */
|
|
export function completeWorldSandtrout(f: WorldSandtroutFixture, state = f.game) {
|
|
let game = state;
|
|
const actions: WorldSandtroutStep[] = [];
|
|
const act = (actor: string, action: Action) => { game = actWorldSandtrout(game, actor, action, actions); };
|
|
const reach = (until: (state: Game) => boolean) => { game = advanceWorldSandtrout(game, until, actions); };
|
|
const transition = (run: () => void): WorldSandtroutTransition => {
|
|
const before = structuredClone(game), from = actions.length; run();
|
|
return { before, steps: structuredClone(actions.slice(from)), after: structuredClone(game) };
|
|
};
|
|
const firstSpice = transition(() => { game = finishWorldSandtrout(game, actions); });
|
|
reach(state => state.turn === 1 && state.phase === 5 && state.active === f.actor && worldSandtroutClean(state));
|
|
const shipmentSources = nativeShipmentSources(viewGame(game, f.actor), 2, 0); assert.ok(shipmentSources);
|
|
const shipmentAction: Action = { type: 'ship', territory: f.target, sector: f.targetSector, amount: 2, elite: 0,
|
|
allyPayment: 0, homeworldSources: shipmentSources };
|
|
const shipment = transition(() => { act(f.actor, shipmentAction); reach(worldSandtroutClean); });
|
|
assert.equal(worldSandtroutPlayer(shipment.before, f.actor).spice - worldSandtroutPlayer(game, f.actor).spice, 4);
|
|
assert.equal(worldSandtroutPlayer(game, f.actor).forces[f.targetLocation], 2);
|
|
reach(state => state.phase === 5 && state.active === state.order.at(-1) && worldSandtroutClean(state));
|
|
const techOwner = game.techTokens!.heighliners.owner; assert.ok(techOwner);
|
|
const techAmount = game.techTokens!.heighliners.spice;
|
|
const collection = transition(() => {
|
|
act(game.active!, { type: 'endMovement' });
|
|
reach(state => state.phase === 7 && worldSandtroutClean(state));
|
|
});
|
|
assert.equal(game.sandtrout, true);
|
|
const mentat = transition(() => {
|
|
reach(state => state.turn === 2 && state.phase === 0 && worldSandtroutClean(state));
|
|
});
|
|
assert.equal(game.sandtrout, true);
|
|
const storm = transition(() => { reach(state => state.turn === 2 && beforeIxSpiceDraw(state)); });
|
|
assert.equal(game.sandtrout, true);
|
|
assert.equal(worldSandtroutPlayer(game, f.actor).forces[f.targetLocation], 2);
|
|
const secondSpiceOrder = orderIxSpiceCards(game, ['worm', { territory: 'hagga_basin' },
|
|
...(f.advanced ? [{ territory: 'rock_outcroppings' }] : [])]);
|
|
const beforeSuppression = structuredClone(game);
|
|
const suppression = transition(() => { reach(state => !!state.spiceWindow && worldSandtroutClean(state)); });
|
|
const revealed = structuredClone(game);
|
|
assert.equal(game.sandtrout, false); assert.equal(game.nexus, false);
|
|
assert.equal(game.spiceWindow!.territory, 'hagga_basin');
|
|
let secondWindow: Game | null = null;
|
|
if (f.advanced) {
|
|
reach(state => !!state.spiceWindow && state.spiceSequence?.pile === 1 && worldSandtroutClean(state));
|
|
secondWindow = structuredClone(game);
|
|
}
|
|
const finishedSpice = transition(() => { game = finishWorldSandtrout(game, actions); });
|
|
homeworldGameIntegrity(game);
|
|
assert.deepEqual(worldSandtroutSpice(game), f.originalSpice);
|
|
assert.deepEqual(worldSandtroutInventory(game), f.originalInventory);
|
|
assert.deepEqual(worldSandtroutSkills(game), f.originalSkills);
|
|
const bankerSource = shipment.after.spiceBankerIncome?.sources.find(receipt => receipt.source.kind === 'shipment' &&
|
|
receipt.source.bankLegs.some(leg => leg.payer === f.actor && leg.amount === 4)) ?? null;
|
|
const bankerCollection = bankerSource ? game.spiceBankerIncome?.collections.find(receipt =>
|
|
receipt.turn === 1 && receipt.grants.includes(bankerSource.cursor)) ?? null : null;
|
|
return { game, firstSpice, shipmentSources, shipmentAction, shipment, techOwner, techAmount,
|
|
collection, mentat, storm, secondSpiceOrder, beforeSuppression, suppression, revealed,
|
|
secondWindow, finishedSpice, bankerSource: structuredClone(bankerSource),
|
|
bankerCollection: structuredClone(bankerCollection), actions, actionCount: actions.length };
|
|
}
|