Allow Sapho order behind a started turn

This commit is contained in:
Quintine committed 2026-10-25 23:33:04 +11:00
1 parent 3bf7d26e80
commit 8e6602633d
17 files changed
+1121 -62

No files matched your search

+200
View File
@@ -0,0 +1,200 @@
import assert from 'node:assert/strict';
import { createGame, joinGame, newPlayer, viewGame, type Action, type Game } from '../game/engine';
import { nativeShipmentSources } from '../game/homeworld-options';
import {
GUILD_FIRST_SAPHO, actSaphoGuildFirst, nextSaphoGuildFirstStep,
type SaphoGuildFirstStep,
} from './fixture-sapho-guild-first';
import { createSemutaHomeworldSaphoFixture } from './fixture-semuta-homeworld-sapho';
import { advanceSemutaHomeworldChoam, applySemutaHomeworldChoamStep } from './fixture-semuta-homeworld-choam';
export const STARTED_MOVEMENT_SAPHO = GUILD_FIRST_SAPHO;
export type SaphoStartedMovementStep = SaphoGuildFirstStep;
export const actSaphoStartedMovement = actSaphoGuildFirst;
export const nextSaphoStartedMovementStep = nextSaphoGuildFirstStep;
export const saphoStartedMovementPlayer = (game: Game, actor = 'emperor') => {
const player = game.players.find(player => player.id === actor); assert.ok(player); return player;
};
export const saphoStartedMovementClean = (game: Game) => !game.response && !game.phaseOpening &&
!game.decision && !game.truthtrance && !game.pendingTreacheryDiscard && !game.pendingShipment &&
!game.pendingKarama && !game.currentAuctionSale;
/** Count physical zones once, excluding historical ordinary-auction aliases. */
export function saphoStartedMovementInventory(game: Game) {
const ids = [...game.deck, ...game.discard, ...(game.richeseCache ?? []), ...(game.richeseRemoved ?? []),
...game.players.flatMap(player => player.hand),
...(game.auction?.cards.slice(game.auction.index + Number(game.currentAuctionSale?.origin === 'normal')) ?? [])]
.map(card => card.id).sort();
assert.equal(new Set(ids).size, ids.length); return ids;
}
export function advanceSaphoStartedMovement(game: Game, until: (state: Game) => boolean,
actions: SaphoStartedMovementStep[] = []): Game {
for (let count = 0; count < 1800; count++) {
if (until(game)) return game;
assert.notEqual(game.status, 'finished');
const step = nextSaphoStartedMovementStep(game); assert.ok(step, 'Complete the original owned control first');
game = actSaphoStartedMovement(game, step.actor, step.action, actions);
}
throw Error('The native Sapho programme did not reach its finite boundary');
}
/** Original public Basic or Advanced setup, actual cache1 purchase and positive
* shipment. Only unopened original deal/Spice ordering and original scalar
* lotteries are selected; no played custody, resources, phase or queue is set. */
export function createSaphoStartedMovementFixture(options: { advanced?: boolean; guildTake?: boolean } = {}) {
const advanced = options.advanced ?? false, guildTake = options.guildTake ?? false;
assert.ok(!guildTake || advanced, 'Flexible Guild TAKE is an original Advanced rule');
const owner = 'emperor', guild = 'guild', canceler = 'atreides';
let game = createGame('SAPHOSTARTEDMOVEMENT', newPlayer('richese', 'Richese', 'richese'), advanced, ['choam']);
for (const faction of ['atreides', 'emperor', 'guild'] as const) joinGame(game, newPlayer(faction, faction, faction));
const actions: SaphoStartedMovementStep[] = [];
const act = (actor: string, action: Action) => { game = actSaphoStartedMovement(game, actor, action, actions); };
const reach = (until: (state: Game) => boolean) => { game = advanceSaphoStartedMovement(game, until, actions); };
for (const player of game.players) act(player.id, { type: 'ready' });
const lobby = structuredClone(game);
act(game.host, advanced ? { type: 'start', advancedPreview: true } : { type: 'start' });
const setup = structuredClone(game);
assert.equal(game.status, 'setup'); assert.equal(game.advanced, advanced);
assert.ok(game.players.every(player => player.hand.length === 0));
const originalInventory = saphoStartedMovementInventory(game); assert.equal(originalInventory.length, 45);
const index = game.deck.findIndex(card => card.effect === 'karama'); assert.ok(index >= 0);
const counter = game.deck[index].id;
[game.deck[1], game.deck[index]] = [game.deck[index], game.deck[1]];
const beforeStartingDeal = structuredClone(game);
reach(state => state.status === 'playing');
const afterSetup = structuredClone(game), front: Game['spiceDeck'] = [];
assert.ok(saphoStartedMovementPlayer(game, canceler).hand.some(card => card.id === counter));
const spiceInventory = game.spiceDeck.map(card => JSON.stringify(card)).sort();
for (let count = 0; count < (advanced ? 2 : 1); count++) {
const at = game.spiceDeck.findIndex(card => 'territory' in card && !card.discovery); assert.ok(at >= 0);
front.push(game.spiceDeck.splice(at, 1)[0]);
}
game.spiceDeck.unshift(...front);
assert.deepEqual(game.spiceDeck.map(card => JSON.stringify(card)).sort(), spiceInventory);
let beforeBid: Game | undefined, bidStep: SaphoStartedMovementStep | undefined, bidAt = -1;
for (let count = 0; count < 900 && !saphoStartedMovementPlayer(game, owner).hand.some(card => card.id === STARTED_MOVEMENT_SAPHO); count++) {
const step = nextSaphoStartedMovementStep(game); assert.ok(step);
if (step.actor === owner && step.action.type === 'richeseBid' && step.action.amount === 1) {
beforeBid = structuredClone(game); bidStep = structuredClone(step); bidAt = actions.length;
}
act(step.actor, step.action);
}
assert.ok(beforeBid && bidStep && bidAt >= 0);
assert.ok(saphoStartedMovementPlayer(game, owner).hand.some(card => card.id === STARTED_MOVEMENT_SAPHO));
const acquired = structuredClone(game), acquisition = {
before: beforeBid, bid: bidStep, steps: structuredClone(actions.slice(bidAt)), after: acquired,
};
assert.equal(saphoStartedMovementPlayer(beforeBid, owner).spice - saphoStartedMovementPlayer(game, owner).spice, 1);
assert.equal(saphoStartedMovementPlayer(game, 'richese').spice - saphoStartedMovementPlayer(beforeBid, 'richese').spice, 1);
const timing: { before: Game; step: SaphoStartedMovementStep; declared: Game; after: Game }[] = [];
if (advanced) {
reach(state => state.phase === 5 && !state.response && !state.phaseOpening && state.decision?.kind === 'guildTiming');
const before = structuredClone(game), step: SaphoStartedMovementStep = { actor: guild,
action: { type: 'decision', take: guildTake } };
act(step.actor, step.action); const declared = structuredClone(game); reach(saphoStartedMovementClean);
timing.push({ before, step, declared, after: structuredClone(game) });
} else reach(state => state.phase === 5 && saphoStartedMovementClean(state));
const beforeShipment = structuredClone(game), current = game.active; assert.ok(current && current !== owner);
assert.equal(current, guildTake ? guild : 'richese');
const step: SaphoStartedMovementStep = { actor: current,
action: { type: 'ship', territory: 'polar_sink', sector: 0, amount: 1, elite: 0, allyPayment: 0 } };
const shipmentAt = actions.length;
act(step.actor, step.action); const declared = structuredClone(game); reach(saphoStartedMovementClean);
const shipment = { before: beforeShipment, step, declared,
steps: structuredClone(actions.slice(shipmentAt)), after: structuredClone(game) };
assert.equal(game.active, current); assert.equal(saphoStartedMovementPlayer(game, current).shipped, true);
assert.equal(saphoStartedMovementPlayer(game, current).moved, 0);
assert.equal(saphoStartedMovementPlayer(beforeShipment, current).spice - saphoStartedMovementPlayer(game, current).spice,
current === guild ? 1 : 2);
assert.equal(saphoStartedMovementPlayer(beforeShipment, current).reserves - saphoStartedMovementPlayer(game, current).reserves, 1);
assert.equal(saphoStartedMovementPlayer(game, current).forces['polar_sink:0'], 1);
assert.equal(saphoStartedMovementPlayer(game, owner).shipped, false);
assert.equal(saphoStartedMovementPlayer(game, owner).moved, 0);
assert.ok(saphoStartedMovementPlayer(game, canceler).hand.some(card => card.id === counter));
assert.deepEqual(saphoStartedMovementInventory(game), originalInventory);
const source = structuredClone(game);
return { game, source, advanced, guildTake, owner, guild, canceler, counter, karama: counter,
card: STARTED_MOVEMENT_SAPHO, current, actor: current, beforeShipment, shipment,
lobby, setup, beforeStartingDeal, afterSetup, acquired, acquisition, timing,
originalInventory, originalCards: originalInventory, actions, steps: actions, sourceActionCount: actions.length,
staging: [
'Actual public ready/start (Advanced uses the original preview acknowledgement), original setup and paid cache1 purchase give Emperor the physical Sapho. Only an unopened original Atreides Karama deal position, one Basic/two Advanced original land Spice positions and scoped scalar lotteries are selected.',
`The original ${advanced ? guildTake ? 'Guild TAKE' : 'Guild WAIT' : 'Basic in-order turn'} is followed by an actual one-force Polar Sink shipment costing ${current === guild ? 1 : 2}. The source stops after all original shipment responses settle, before Sapho or the current actor’s ground move/end. No dealt hand, balance, force, phase, queue, timing grant or pending receipt is installed.`,
] };
}
export type SaphoStartedMovementFixture = ReturnType<typeof createSaphoStartedMovementFixture>;
/** afterCurrent is projected explanation, never an action field. */
export function saphoStartedMovementAction(game: Game, mode: 'first' | 'last', owner = 'emperor'): Action {
const option = viewGame(game, owner).saphoOptions.find(option => option.scope === 'movement' && option.mode === mode);
assert.ok(option, `The actual waiting tail must offer Sapho ${mode}`);
return { type: 'card', card: STARTED_MOVEMENT_SAPHO, scope: option.scope, event: option.event, mode: option.mode };
}
/** LABELLED supplemental source: the borrowed canonical fixture physically
* conserves Sapho/Semuta custody rather than earning their acquisition. Its
* setup, current shipment, subsequent card disposal and continuation are real.
* No further card, resource, profile, phase or queue assignment is made here. */
export function createSaphoStartedSemutaFixture(advanced = false) {
const inherited = createSemutaHomeworldSaphoFixture('movement', 'last', advanced);
let game = structuredClone(inherited.game);
const actions: SaphoStartedMovementStep[] = [];
const beforeShipment = structuredClone(game), current = game.active; assert.ok(current && current !== inherited.owner);
const sources = nativeShipmentSources(viewGame(game, current), 1, 0); assert.ok(sources);
const step: SaphoStartedMovementStep = { actor: current, action: { type: 'ship', territory: 'polar_sink',
sector: 0, amount: 1, elite: 0, homeworldSources: sources, allyPayment: 0 } };
game = applySemutaHomeworldChoamStep(game, step.actor, step.action, actions);
game = advanceSemutaHomeworldChoam(game, saphoStartedMovementClean, actions);
assert.equal(game.active, current); assert.equal(saphoStartedMovementPlayer(game, current).shipped, true);
assert.equal(saphoStartedMovementPlayer(beforeShipment, current).spice - saphoStartedMovementPlayer(game, current).spice, 2);
const shipment = { before: beforeShipment, step, after: structuredClone(game), steps: structuredClone(actions) };
const option = viewGame(game, inherited.owner).saphoOptions.find(option => option.scope === 'movement' && option.mode === 'last');
assert.ok(option, 'The original owner changes last position in this waiting tail');
const action: Action = { type: 'card', card: inherited.card, scope: option.scope, event: option.event, mode: option.mode };
const originalInventory = saphoStartedMovementInventory(inherited.game);
assert.deepEqual(saphoStartedMovementInventory(game), originalInventory);
return { ...inherited, game, source: structuredClone(game), current, actor: current, action, event: option.event,
advanced, beforeShipment, shipment, originalInventory,
sourceActionCount: inherited.actions.length + actions.length, actions: [...inherited.actions, ...actions],
nativeAcquisition: false,
staging: [...inherited.staging,
'Inherited CONTROLLED conserved Sapho/Semuta custody is supplemental, not a native purchase claim. This new branch actually pays two spice to ship one original Homeworld force to Polar Sink before queued LAST, with no added played-state assignments.'] };
}
/** Finish each actual combined turn once. Following Emperor/Guild turns make
* real paid shipments; an already shipped current actor only completes its
* original turn. Native Guild choices/response controls remain real actions. */
export function finishSaphoStartedMovement(state: Game, fixture: Pick<SaphoStartedMovementFixture, 'owner' | 'guild'>,
options: { guildTake?: boolean; shipFollowing?: boolean } = {}, actions: SaphoStartedMovementStep[] = []) {
let game = state;
const turns: { actor: string; before: Game; shipment: SaphoStartedMovementStep | null;
afterShipment: Game; end: SaphoStartedMovementStep; afterEnd: Game }[] = [];
const timing: { before: Game; step: SaphoStartedMovementStep; declared: Game; after: Game }[] = [];
const act = (actor: string, action: Action) => { game = actSaphoStartedMovement(game, actor, action, actions); };
for (let count = 0; game.phase === 5 && count < 160; count++) {
if (!saphoStartedMovementClean(game)) {
if (!game.response && !game.phaseOpening && game.decision?.kind === 'guildTiming') {
const before = structuredClone(game), step: SaphoStartedMovementStep = { actor: fixture.guild,
action: { type: 'decision', take: options.guildTake ?? false } };
act(step.actor, step.action); const declared = structuredClone(game);
game = advanceSaphoStartedMovement(game, saphoStartedMovementClean, actions);
timing.push({ before, step, declared, after: structuredClone(game) });
} else {
const step = nextSaphoStartedMovementStep(game); assert.ok(step); act(step.actor, step.action);
}
continue;
}
const actor = game.active; assert.ok(actor && !turns.some(turn => turn.actor === actor));
const before = structuredClone(game);
const shipment: SaphoStartedMovementStep | null = options.shipFollowing !== false &&
(actor === fixture.owner || actor === fixture.guild) && !saphoStartedMovementPlayer(game, actor).shipped
? { actor, action: { type: 'ship', territory: actor === fixture.owner ? 'imperial_basin' : 'carthag',
sector: actor === fixture.owner ? 9 : 11, amount: 1, elite: 0, allyPayment: 0 } } : null;
if (shipment) {
act(shipment.actor, shipment.action); game = advanceSaphoStartedMovement(game, saphoStartedMovementClean, actions);
}
const afterShipment = structuredClone(game), end: SaphoStartedMovementStep = { actor, action: { type: 'endMovement' } };
act(end.actor, end.action); turns.push({ actor, before, shipment, afterShipment, end, afterEnd: structuredClone(game) });
}
assert.notEqual(game.phase, 5, 'Every original combined turn must finish finitely');
return { game, turns, timing, actions };
}