255 lines
22 KiB
TypeScript
255 lines
22 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import { viewGame, type Action, type Game } from '../game/engine';
|
|
import type { MixedActionExpression } from '../game/mixed-action-question';
|
|
import type { TruthFact, TruthQuestion } from '../game/truthtrance';
|
|
import { buyDistransPrebidLot, createDistransPrebidFixture, distransPrebidInventory, distransPrebidUntouched, nextDistransPrebidStep,
|
|
type DistransPrebidCapacity } from './fixture-distrans-prebid';
|
|
import { actSaphoStartedMovement, createSaphoStartedMovementFixture, nextSaphoStartedMovementStep } from './fixture-sapho-started-movement';
|
|
import { truthTurnThumperSpice, truthTurnThumperTraitors } from './fixture-truth-turn-thumper';
|
|
|
|
export type TruthTransferOrderEffect = 'distrans' | 'juiceOfSapho';
|
|
export type TruthTransferOrderLeaf = { kind: 'cardPlay'; effect: TruthTransferOrderEffect } |
|
|
{ kind: 'payment'; recipient: string; minimum: number } | { kind: 'ship'; territory: string; minimum: number };
|
|
export type TruthTransferOrderExpression = MixedActionExpression<TruthTransferOrderLeaf>;
|
|
export type TruthTransferOrderStep = { actor: string; action: Action };
|
|
export const actTruthTransferOrderPlay = actSaphoStartedMovement;
|
|
export const truthTransferOrderPlayInventory = distransPrebidInventory;
|
|
export const truthTransferOrderPlaySpice = truthTurnThumperSpice;
|
|
export const truthTransferOrderPlayTraitors = truthTurnThumperTraitors;
|
|
export const truthTransferOrderPlayPlayer = (game: Game, actor: string) => {
|
|
const player = game.players.find(candidate => candidate.id === actor); assert.ok(player); return player;
|
|
};
|
|
export const truthTransferOrderPlayClean = (game: Game) => !game.phaseOpening && !game.response && !game.decision &&
|
|
!game.truthtrance && !game.pendingTreacheryDiscard && !game.pendingNullentropy && !game.pendingShipment && !game.currentAuctionSale;
|
|
export const truthTransferOrderPlayUse = (effect: TruthTransferOrderEffect): TruthTransferOrderExpression =>
|
|
({ kind: 'action', action: { kind: 'cardPlay', effect } });
|
|
export const truthTransferOrderPlayFact = (fact: TruthFact): TruthTransferOrderExpression => ({ kind: 'fact', fact });
|
|
export const truthTransferOrderPlayPayment = (recipient: string, minimum = 2): TruthTransferOrderExpression =>
|
|
({ kind: 'action', action: { kind: 'payment', recipient, minimum } });
|
|
export const truthTransferOrderPlayShip = (territory = 'polar_sink', minimum = 1): TruthTransferOrderExpression =>
|
|
({ kind: 'action', action: { kind: 'ship', territory, minimum } });
|
|
export const truthTransferOrderPlayGroup = (kind: 'and' | 'or', ...terms: TruthTransferOrderExpression[]): TruthTransferOrderExpression =>
|
|
({ kind, terms });
|
|
|
|
export function nextTruthTransferOrderPlayNative(game: Game): TruthTransferOrderStep | null {
|
|
if (game.truthtrance || game.pendingNullentropy) return null;
|
|
return game.players.some(player => player.id === 'r') ? nextDistransPrebidStep(game) : nextSaphoStartedMovementStep(game);
|
|
}
|
|
export function nextTruthTransferOrderPlay(game: Game): TruthTransferOrderStep | null {
|
|
if (game.truthtrance || game.pendingNullentropy) return null;
|
|
for (const player of game.players) {
|
|
const guide = viewGame(game, player.id).turnActionGuide;
|
|
if (guide) return { actor: player.id, action: guide.action };
|
|
}
|
|
return nextTruthTransferOrderPlayNative(game);
|
|
}
|
|
export function advanceTruthTransferOrderPlay(game: Game, until: (state: Game) => boolean,
|
|
actions: TruthTransferOrderStep[] = [], nativeOnly = false): Game {
|
|
for (let count = 0; count < 1800; count++) {
|
|
if (until(game)) return game;
|
|
assert.notEqual(game.status, 'finished', 'The original transfer/order source ended before its requested boundary');
|
|
const step = nativeOnly ? nextTruthTransferOrderPlayNative(game) : nextTruthTransferOrderPlay(game);
|
|
assert.ok(step, 'Supply the original Truthtrance, paid private selection or sealed native plan');
|
|
game = actTruthTransferOrderPlay(game, step.actor, step.action, actions);
|
|
}
|
|
throw Error('The original transfer/order source did not reach its finite boundary');
|
|
}
|
|
export function settleTruthTransferOrderPlay(game: Game, actions: TruthTransferOrderStep[] = []): Game {
|
|
return advanceTruthTransferOrderPlay(game, truthTransferOrderPlayClean, actions, true);
|
|
}
|
|
export function finishTruthTransferOrderPlay(game: Game, actions: TruthTransferOrderStep[] = []): Game {
|
|
const turn = game.turn;
|
|
return advanceTruthTransferOrderPlay(game, state => state.turn === turn + 1, actions, true);
|
|
}
|
|
|
|
/** Real public cache purchases plus original unopened Truth deals. The card
|
|
* question does not select a transfer recipient/card or an order option. */
|
|
export function createTruthTransferOrderPlayFixture(options: {
|
|
source?: 'distrans' | 'sapho'; advanced?: boolean; capacity?: DistransPrebidCapacity; guildTake?: boolean; recoveredDistrans?: boolean;
|
|
} = {}) {
|
|
const sourceKind = options.source ?? 'distrans', advanced = options.advanced ?? false;
|
|
const distrans = sourceKind === 'distrans' ? createDistransPrebidFixture({ advanced, capacity: options.capacity, truthFor: ['r', 'a'] }) : null;
|
|
const sapho = sourceKind === 'sapho' ? createSaphoStartedMovementFixture({ advanced, guildTake: options.guildTake,
|
|
truthFor: ['richese', 'guild'] }) : null;
|
|
const base = distrans ?? sapho!;
|
|
let game = structuredClone(base.game); const actions = structuredClone(base.actions);
|
|
const target = distrans ? distrans.holder : sapho!.owner, asker = distrans ? 'a' : 'richese', recipient = asker;
|
|
const selected = base.startingTruthSelection;
|
|
const ordered = [...selected].sort((left, right) => Number(right.actor === asker) - Number(left.actor === asker));
|
|
const truths = ordered.map(row => row.card), truthHolders = ordered.map(row => row.actor);
|
|
assert.equal(truths.length, 2); assert.equal(truthHolders[0], asker);
|
|
const effect: TruthTransferOrderEffect = distrans ? 'distrans' : 'juiceOfSapho', card = base.card;
|
|
const originalCards = truthTransferOrderPlayInventory(base.setup), originalSpice = truthTransferOrderPlaySpice(base.setup);
|
|
const originalTraitors = truthTransferOrderPlayTraitors(base.setup);
|
|
let recovery: { before: Game; firstPlay: TruthTransferOrderStep; box: string; acquisition: TruthTransferOrderStep[];
|
|
beforeRecovery: Game; paid: Game; afterRecovery: Game; outgoingPurchase: ReturnType<typeof buyDistransPrebidLot>['purchase']; after: Game } | null = null;
|
|
if (options.recoveredDistrans) {
|
|
assert.ok(distrans && distrans.capacity === 'ordinary', 'Use the original ordinary Distrans source for this one real replay');
|
|
const before = structuredClone(game), firstPlay: TruthTransferOrderStep = { actor: target, action: distrans.action };
|
|
game = settleTruthTransferOrderPlay(actTruthTransferOrderPlay(game, target, firstPlay.action, actions), actions);
|
|
const turn = game.turn;
|
|
game = advanceTruthTransferOrderPlay(game, state => state.turn === turn + 1 && !state.phaseOpening && !state.response &&
|
|
state.decision?.kind === 'richeseCache', actions, true);
|
|
const box = game.richeseCache?.find(held => held.effect === 'nullentropyBox'); assert.ok(box);
|
|
const from = actions.length;
|
|
game = actTruthTransferOrderPlay(game, game.decision!.player, { type: 'decision', event: game.richeseBidding!.event,
|
|
card: box.id, method: 'onceAround', direction: 'counterclockwise' }, actions);
|
|
for (let count = 0; count < 200 && !(truthTransferOrderPlayPlayer(game, target).hand.some(held => held.id === box.id) && distransPrebidUntouched(game)); count++) {
|
|
const lot = game.richeseAuction;
|
|
const step = truthTransferOrderPlayClean(game) && lot?.cardId === box.id && !lot.outcome && lot.active === target && lot.bid === 0
|
|
? { actor: target, action: { type: 'richeseBid', event: lot.event, amount: 1, allyPayment: 0 } satisfies Action }
|
|
: nextTruthTransferOrderPlayNative(game);
|
|
assert.ok(step); game = actTruthTransferOrderPlay(game, step.actor, step.action, actions);
|
|
}
|
|
assert.ok(distransPrebidUntouched(game)); assert.ok(truthTransferOrderPlayPlayer(game, target).hand.some(held => held.id === box.id));
|
|
const acquisition = structuredClone(actions.slice(from)), beforeRecovery = structuredClone(game);
|
|
assert.deepEqual(game.discard.map(held => held.id), [card]);
|
|
game = actTruthTransferOrderPlay(game, target, { type: 'card', card: box.id }, actions); const paid = structuredClone(game);
|
|
game = settleTruthTransferOrderPlay(game, actions); const afterRecovery = structuredClone(game);
|
|
assert.ok(truthTransferOrderPlayPlayer(game, target).hand.some(held => held.id === card));
|
|
assert.equal(truthTransferOrderPlayPlayer(beforeRecovery, target).spice - truthTransferOrderPlayPlayer(game, target).spice, 2);
|
|
const bought = buyDistransPrebidLot(game, target, actions); game = bought.game;
|
|
recovery = { before, firstPlay, box: box.id, acquisition, beforeRecovery, paid, afterRecovery,
|
|
outgoingPurchase: bought.purchase, after: structuredClone(game) };
|
|
}
|
|
for (const [index, truth] of truths.entries()) assert.ok(truthTransferOrderPlayPlayer(game, truthHolders[index]).hand.some(held => held.id === truth));
|
|
assert.ok(truthTransferOrderPlayPlayer(game, target).hand.some(held => held.id === card));
|
|
assert.ok(truthTransferOrderPlayClean(game)); assert.equal(!!game.semutaPreview, !advanced);
|
|
assert.equal(game.turnActionPromises?.length ?? 0, 0); assert.deepEqual(truthTransferOrderPlayInventory(game), originalCards);
|
|
assert.deepEqual(truthTransferOrderPlaySpice(game), originalSpice); assert.deepEqual(truthTransferOrderPlayTraitors(game), originalTraitors);
|
|
const spiceFact: TruthFact = { kind: 'spice', compare: 'eq', value: truthTransferOrderPlayPlayer(game, target).spice };
|
|
const mixed = truthTransferOrderPlayGroup('and', truthTransferOrderPlayUse(effect), truthTransferOrderPlayPayment(recipient));
|
|
const question: TruthQuestion = { kind: 'turnActions', target, turn: game.turn, mixed };
|
|
return { game, source: structuredClone(game), sourceKind, effect, advanced, base, distrans, sapho,
|
|
target, asker, recipient, truths, truthHolders, truth: truths[0], card, spiceFact, mixed, question,
|
|
give: recovery?.outgoingPurchase.card ?? distrans?.give ?? null, current: sapho?.current ?? null, recovery,
|
|
setup: base.setup, afterSetup: base.afterSetup, beforeStartingDeal: base.beforeStartingDeal,
|
|
originalCards, originalSpice, originalTraitors,
|
|
actions, sourceActions: actions, sourceActionCount: actions.length,
|
|
sourceCounts: { inherited: base.actions.length, nativeContinuation: actions.length - base.actions.length, selected: actions.length,
|
|
nativeCacheBids: actions.filter(step => step.actor === target && step.action.type === 'richeseBid' && step.action.amount === 1).length },
|
|
payment: { type: 'bribe', target: recipient, amount: 2 } satisfies Action,
|
|
shipment: { type: 'ship', territory: 'polar_sink', sector: 0, amount: 1, elite: 0, allyPayment: 0 } satisfies Action,
|
|
sourceDisclosure: base.staging.join(' ') + ' Optional original unopened starting deals supply the two physical Truths; ' +
|
|
'default base-fixture deals remain unchanged when those selectors are absent. Basic keeps its original Semuta marker and real discard acknowledgements. ' +
|
|
(distrans ? 'Guild actually purchases Distrans for1 and retains its original other card to transfer; no recipient consent or hidden recipient card is supplied. '
|
|
: 'Emperor actually purchases Sapho for1; the current foreign actor has already paid for one physical Polar Sink shipment and keeps its original ground move/end. ') +
|
|
(recovery ? 'The optional single replay source actually transfers/discards Distrans, buys the remaining original Box cache1 on turn2, pays its2-spice sole-card recovery, then buys one ordinary card1 as its new outgoing card. Both original Truths remain held until the later question. ' : '') +
|
|
'The future printed-play clause names no recipient, outgoing card, mode or order result. Only actual native accepted use counts. ' +
|
|
'No dealt hand, purse, army, phase, queue, receipt or marker is installed. Counts and inventories derive from actual arrays.',
|
|
};
|
|
}
|
|
export type TruthTransferOrderPlayFixture = ReturnType<typeof createTruthTransferOrderPlayFixture>;
|
|
export function declareTruthTransferOrderPlay(f: TruthTransferOrderPlayFixture, source = f.game, copy: 0 | 1 = 0,
|
|
actions: TruthTransferOrderStep[] = []) {
|
|
const asker = f.truthHolders[copy]; let game = actTruthTransferOrderPlay(source, asker, { type: 'card', card: f.truths[copy] }, actions);
|
|
while (game.truthtrance?.stage === 'priority') {
|
|
const actor = game.players.find(player => !game.truthtrance!.passed.includes(player.id)); assert.ok(actor);
|
|
game = actTruthTransferOrderPlay(game, actor.id, { type: 'truthPass' }, actions);
|
|
}
|
|
assert.equal(game.truthtrance?.stage, 'ask'); return { game, asker, actions };
|
|
}
|
|
export function askTruthTransferOrderPlay(game: Game, asker: string, question: TruthQuestion, actions: TruthTransferOrderStep[] = []): Game {
|
|
return actTruthTransferOrderPlay(game, asker, { type: 'truthAsk', question: structuredClone(question) }, actions);
|
|
}
|
|
export function answerTruthTransferOrderPlay(game: Game, target: string, answer: 'yes' | 'no', actions: TruthTransferOrderStep[] = []): Game {
|
|
return actTruthTransferOrderPlay(game, target, { type: 'truthAnswer', answer }, actions);
|
|
}
|
|
export function bindTruthTransferOrderPlay(f: TruthTransferOrderPlayFixture, answer: 'yes' | 'no' = 'yes', question: TruthQuestion = f.question,
|
|
source = f.game, copy: 0 | 1 = 0, actions: TruthTransferOrderStep[] = []) {
|
|
const declared = declareTruthTransferOrderPlay(f, source, copy, actions), asked = askTruthTransferOrderPlay(declared.game, declared.asker, question, actions);
|
|
return { game: answerTruthTransferOrderPlay(asked, f.target, answer, actions), declared, asked, actions };
|
|
}
|
|
export function truthTransferOrderPlayPromise(game: Game, target = game.turnActionPromises?.[0]?.player ?? game.players[0].id) {
|
|
const row = viewGame(game, target).turnActionPromises.findLast(promise => promise.player === target); assert.ok(row); return row;
|
|
}
|
|
export function truthTransferOrderDistransAction(game: Game, f: TruthTransferOrderPlayFixture, recipient = f.recipient, give = f.give): Action {
|
|
assert.equal(f.effect, 'distrans'); const quote = viewGame(game, f.target).distrans;
|
|
assert.ok(quote && !quote.blocked); const choice = quote.choices.find(choice => choice.recipient === recipient && !choice.blocked);
|
|
assert.ok(choice && choice.cards.some(card => card.id === give));
|
|
return { type: 'card', card: f.card, target: recipient, give: give! };
|
|
}
|
|
export function truthTransferOrderSaphoAction(game: Game, f: TruthTransferOrderPlayFixture, mode: 'first' | 'last'): Action {
|
|
assert.equal(f.effect, 'juiceOfSapho'); const option = viewGame(game, f.target).saphoOptions.find(option => option.scope === 'movement' && option.mode === mode);
|
|
assert.ok(option, 'Use one exact currently legal native Sapho option');
|
|
return { type: 'card', card: f.card, scope: option.scope, event: option.event, mode: option.mode };
|
|
}
|
|
|
|
/** One genuine Semuta cost composition. Original Distrans is actually spent
|
|
* before turn2; its owner then buys the still-original cached Semuta for1.
|
|
* Both unopened-deal Truths remain held for a later normal-lot answer. */
|
|
export function createTruthSemutaPrebidFixture(options: { firstBid?: boolean } = {}) {
|
|
const f = createTruthTransferOrderPlayFixture(), actions = structuredClone(f.actions), inherited = actions.length;
|
|
let game = settleTruthTransferOrderPlay(actTruthTransferOrderPlay(f.game, f.target,
|
|
truthTransferOrderDistransAction(f.game, f), actions), actions);
|
|
const earlierDistrans = structuredClone(game), turn = game.turn;
|
|
game = advanceTruthTransferOrderPlay(game, state => state.turn === turn + 1 && !state.phaseOpening && !state.response &&
|
|
state.decision?.kind === 'richeseCache', actions, true);
|
|
const semuta = game.richeseCache?.find(card => card.effect === 'semutaDrug'); assert.ok(semuta);
|
|
const acquisitionStart = actions.length, beforePurchase = structuredClone(game);
|
|
game = actTruthTransferOrderPlay(game, game.decision!.player, { type: 'decision', event: game.richeseBidding!.event,
|
|
card: semuta.id, method: 'onceAround', direction: 'counterclockwise' }, actions);
|
|
for (let count = 0; count < 200 && !(truthTransferOrderPlayPlayer(game, f.target).hand.some(card => card.id === semuta.id) && distransPrebidUntouched(game)); count++) {
|
|
const lot = game.richeseAuction;
|
|
const step = truthTransferOrderPlayClean(game) && lot?.cardId === semuta.id && !lot.outcome && lot.active === f.target && lot.bid === 0
|
|
? { actor: f.target, action: { type: 'richeseBid', event: lot.event, amount: 1, allyPayment: 0 } satisfies Action }
|
|
: nextTruthTransferOrderPlayNative(game);
|
|
assert.ok(step); game = actTruthTransferOrderPlay(game, step.actor, step.action, actions);
|
|
}
|
|
assert.ok(distransPrebidUntouched(game)); assert.ok(truthTransferOrderPlayPlayer(game, f.target).hand.some(card => card.id === semuta.id));
|
|
assert.equal(truthTransferOrderPlayPlayer(beforePurchase, f.target).spice - truthTransferOrderPlayPlayer(game, f.target).spice, 1);
|
|
const acquisition = { before: beforePurchase, steps: structuredClone(actions.slice(acquisitionStart)), after: structuredClone(game) };
|
|
let bid: TruthTransferOrderStep | null = null;
|
|
if (options.firstBid) {
|
|
bid = { actor: game.auction!.active, action: { type: 'bid', amount: 1, allyPayment: 0 } };
|
|
game = actTruthTransferOrderPlay(game, bid.actor, bid.action, actions);
|
|
assert.equal(game.auction!.bid, 1); assert.equal(game.auction!.bidder, bid.actor);
|
|
}
|
|
assert.ok(truthTransferOrderPlayClean(game)); assert.equal(game.semutaPreview, true);
|
|
assert.equal(game.discard.filter(card => card.id === f.card).length, 1);
|
|
assert.ok(!truthTransferOrderPlayPlayer(game, f.target).hand.some(card => card.id === f.card));
|
|
for (const [index, truth] of f.truths.entries()) assert.ok(truthTransferOrderPlayPlayer(game, f.truthHolders[index]).hand.some(card => card.id === truth));
|
|
assert.deepEqual(truthTransferOrderPlayInventory(game), f.originalCards);
|
|
assert.deepEqual(truthTransferOrderPlaySpice(game), f.originalSpice); assert.deepEqual(truthTransferOrderPlayTraitors(game), f.originalTraitors);
|
|
const mixed = truthTransferOrderPlayUse('distrans');
|
|
const question: TruthQuestion = { kind: 'turnActions', target: f.target, turn: game.turn, mixed };
|
|
return { ...f, game, source: structuredClone(game), mixed, question, semuta: semuta.id, earlierDistrans, acquisition, bid,
|
|
spiceFact: { kind: 'spice', compare: 'eq', value: truthTransferOrderPlayPlayer(game, f.target).spice } satisfies TruthFact,
|
|
actions, sourceActions: actions, sourceActionCount: actions.length,
|
|
sourceCounts: { inherited, nativeContinuation: actions.length - inherited, selected: actions.length,
|
|
nativeCacheBids: actions.filter(step => step.actor === f.target && step.action.type === 'richeseBid' && step.action.amount === 1).length },
|
|
sourceDisclosure: f.base.staging.join(' ') + ' Original unopened Richese/Atreides Truth deals remain held. ' +
|
|
'Guild actually transfers its original shield with Distrans, completes its native fresh-discard passes, then reaches the next original cache declaration. ' +
|
|
'Guild buys the original Semuta for1 and stops at the original normal lot, optionally after one actual first bid1. Distrans remains physically spent. ' +
|
|
'The later question concerns only future Distrans use; no future Semuta clause is introduced. No hand, purse, auction, phase, receipt or marker is installed. Counts derive from recorded actions.',
|
|
};
|
|
}
|
|
|
|
/** Earlier real Basic boundary, rather than an installed phase or queue.
|
|
* Retain only the exact acquisition prefix of the existing native source. */
|
|
export function createTruthEarlySaphoFixture() {
|
|
const f = createTruthTransferOrderPlayFixture({ source: 'sapho' }); assert.ok(f.sapho);
|
|
const bid = f.sapho.acquisition.bid;
|
|
const bidAt = f.actions.findIndex(step => step.actor === bid.actor && step.action.type === 'richeseBid' &&
|
|
step.action.event === bid.action.event && step.action.amount === bid.action.amount);
|
|
assert.ok(bidAt >= 0); const inherited = bidAt + f.sapho.acquisition.steps.length;
|
|
assert.deepEqual(f.actions.slice(bidAt, inherited), f.sapho.acquisition.steps);
|
|
const actions = structuredClone(f.actions.slice(0, inherited));
|
|
let game = structuredClone(f.sapho.acquired);
|
|
game = advanceTruthTransferOrderPlay(game, state => state.phase === 4 && truthTransferOrderPlayClean(state), actions, true);
|
|
assert.equal(game.advanced, false); assert.equal(game.semutaPreview, true);
|
|
assert.ok(truthTransferOrderPlayPlayer(game, f.target).hand.some(card => card.id === f.card));
|
|
assert.equal(truthTransferOrderPlayPlayer(game, f.target).shipped, false); assert.equal(truthTransferOrderPlayPlayer(game, f.target).moved, 0);
|
|
assert.ok(!actions.some(step => step.action.type === 'ship')); assert.deepEqual(truthTransferOrderPlayInventory(game), f.originalCards);
|
|
assert.deepEqual(truthTransferOrderPlaySpice(game), f.originalSpice); assert.deepEqual(truthTransferOrderPlayTraitors(game), f.originalTraitors);
|
|
return { ...f, game, source: structuredClone(game), current: null, early: true,
|
|
spiceFact: { kind: 'spice', compare: 'eq', value: truthTransferOrderPlayPlayer(game, f.target).spice } satisfies TruthFact,
|
|
actions, sourceActions: actions, sourceActionCount: actions.length,
|
|
sourceCounts: { inherited, nativeContinuation: actions.length - inherited, selected: actions.length,
|
|
nativeCacheBids: actions.filter(step => step.actor === f.target && step.action.type === 'richeseBid' && step.action.amount === 1).length },
|
|
sourceDisclosure: f.sapho.staging[0] + ' Select the two original unopened Richese/Guild Truth deals and use the exact actual acquired-Sapho snapshot. ' +
|
|
'Its prefix is acquisition bid index plus actual acquisition steps; subsequent native auction controls reach quiet Basic Revival before any shipment. ' +
|
|
'The owned future movement opportunity uses its ordinary public order, with no future income, played card, phase or queue installed. Counts derive from the exact prefix and native continuation.',
|
|
};
|
|
}
|