From 9536c770627b71f4deccc4dacb808703a8206e9a Mon Sep 17 00:00:00 2001 From: Quintine <15965533+Quintine@users.noreply.github.com> Date: Mon, 16 Nov 2026 14:05:28 +1100 Subject: [PATCH] Compose Basic bid revival and shipment commitments --- docs/CURRENT_STATUS.md | 9 ++ docs/TRUTHTRANCE_BID_PROMISES.md | 28 ++++++ game/engine.ts | 47 +++++++--- tests/fixture-truthtrance-future-shipment.ts | 6 +- tests/truth-phase-bid-leader-joint.test.ts | 88 +++++++++++++++++++ ...h-phase-bid-revival-shipment-joint.test.ts | 81 +++++++++++++++++ tests/truth-phase-bid-shipment-joint.test.ts | 84 ++++++++++++++++++ 7 files changed, 328 insertions(+), 15 deletions(-) create mode 100644 tests/truth-phase-bid-leader-joint.test.ts create mode 100644 tests/truth-phase-bid-revival-shipment-joint.test.ts create mode 100644 tests/truth-phase-bid-shipment-joint.test.ts diff --git a/docs/CURRENT_STATUS.md b/docs/CURRENT_STATUS.md index f68dcc97..0bd4ae96 100644 --- a/docs/CURRENT_STATUS.md +++ b/docs/CURRENT_STATUS.md @@ -17,6 +17,15 @@ open mode gates. ## Current checkpoint and work +**Basic phase-bid, Revival and Shipment commitments — 16 November. Prototyped / +Partial.** The owned-cash witness now composes supported leader and grouped +Revival with Shipment; planned returns use the same actual purse and physical +reserves. Minimal bots follow the required bid guide. A future-Shipment fixture +now continues the Emperor's existing auction-gift window. Twenty related files +pass 157 cases; type checking and lint pass. Other timing, +factions and commitment envelopes remain provisional. +[Scope](TRUTHTRANCE_BID_PROMISES.md#basic-bid-with-revival-and-shipment--16-november-2026). + **Basic phase-bid and force Revival Truthtrance commitments — 16 November. Prototyped / Partial.** Both answer orders now use a shared owned-spice witness before Bidding; affordable commitments continue through actual bidding and diff --git a/docs/TRUTHTRANCE_BID_PROMISES.md b/docs/TRUTHTRANCE_BID_PROMISES.md index bebf4c58..e9c8e559 100644 --- a/docs/TRUTHTRANCE_BID_PROMISES.md +++ b/docs/TRUTHTRANCE_BID_PROMISES.md @@ -1,5 +1,33 @@ # Truthtrance ordinary bid commitments +## Basic bid with Revival and Shipment — 16 November 2026 + +**Prototyped / Partial.** The classic Basic pre-Bidding owned-cash witness +now also considers a named leader, supported grouped force-and-leader Revival, +and a later reserve Shipment. Required returns are materially applied to the +detached native Revival state before the shipment quote, so one purse and the +actual Tanks/reserves fund all three stages. It checks one specific bid amount, +assumes no Charity, income, allied pledge refund, ally payment or Karama, and +never treats a missing conservative witness as exhaustive impossibility. +Negative expressions which require additional Revival actions remain guarded +until their complete continuation can be materialized. + +Public Basic tests cover both answer orders, real paid bids, named-leader and +grouped force/leader returns, paid Shipment and unaffordable commitments. +The three-commitment test stages the earlier Shipment promise, because Basic +has only two physical Truthtrance cards; its later questions, payments and +force actions are real. The usual original leader/Tanks and unopened Spice +fixture supplements are explicit in the tests. Automated bidding now follows +the server's required bid guide instead of the Shipment policy's pass. The +future-Shipment test driver also acknowledges the existing Emperor auction +gift opportunity before resuming the parked payment. + +Evidence: [leader and expression](../tests/truth-phase-bid-leader-joint.test.ts), +[bid and Shipment](../tests/truth-phase-bid-shipment-joint.test.ts) and +[three commitments](../tests/truth-phase-bid-revival-shipment-joint.test.ts). +Advanced, expansion factions, Movement, bribes, Charity, other combined +promises, later lots, complete games and deployed acceptance remain open. + ## Basic phase-wide bid with force Revival — 16 November 2026 **Prototyped / Partial.** In a Basic classic-faction game before Bidding, diff --git a/game/engine.ts b/game/engine.ts index 247a0c0d..2d4ad3b7 100644 --- a/game/engine.ts +++ b/game/engine.ts @@ -18442,24 +18442,27 @@ function phaseBidHonorsTurnActions(g: Game, p: Player, lot: BidOpportunity, acti * promises awaits their combined planner; do not invent those resources. */ function phaseBidFuturePlannerUnsupported(g: Game, p: Player): boolean { return liveEarlyRicheseBidPromises(g.earlyRicheseBidPromises ?? [],p.id,g.turn).some(row => row.answer) || - liveShipmentPromises(g.shipmentPromises ?? [],p.id,g.turn).some(row => row.answer) || + liveShipmentPromises(g.shipmentPromises ?? [],p.id,g.turn).some(row => matchesShipment(row,null) !== row.answer) || hasMovementPromises(g,p.id,true) || liveRevivalPromises(g.revivalPromises ?? [],p.id,g.turn).some(row => row.answer) || liveLeaderRevivalPromises(g.leaderRevivalPromises ?? [],p.id,g.turn).some(row => row.answer) || - liveRevivalExpressionPromises(g.revivalExpressionPromises ?? [],p.id,g.turn).some(row => row.answer) || + liveRevivalExpressionPromises(g.revivalExpressionPromises ?? [],p.id,g.turn).length > 0 || liveTurnActionPromises(g.turnActionPromises ?? [],p.id,g.turn).length > 0 || (!!bidOpportunity(g) && hasBribePromises(g,p.id,true)); } /** A conservative owned-cash witness for a future Basic bid followed by - * ordinary force Revival. Other joint obligations keep their own guards. - * The detached forecast does not assume Charity, income, an ally, or a - * Karama payment; failure to find this witness is not proof of impossibility. */ -function phaseBidRevivalWitness(g: Game, p: Player, promises: readonly PhaseBidPromise[], + * native Revival and Shipment commitments. Other obligations keep their own + * guards. No pledged refund, Charity, income, ally or Karama is assumed; + * failure to find this witness is not proof of impossibility. */ +function phaseBidRevivalShipmentWitness(g: Game, p: Player, promises: readonly PhaseBidPromise[], witness: PhaseBidOpportunity): PhaseBidOpportunity | null { + const revivals = liveRevivalPromises(g.revivalPromises ?? [],p.id,g.turn); + const leaders = liveLeaderRevivalPromises(g.leaderRevivalPromises ?? [],p.id,g.turn); + const expressions = liveRevivalExpressionPromises(g.revivalExpressionPromises ?? [],p.id,g.turn); + const shipments = liveShipmentPromises(g.shipmentPromises ?? [],p.id,g.turn); if (g.advanced || g.expansions.length || g.phase >= 3 || g.auction || - !liveRevivalPromises(g.revivalPromises ?? [],p.id,g.turn).some(row => row.answer) || - liveLeaderRevivalPromises(g.leaderRevivalPromises ?? [],p.id,g.turn).length || - liveRevivalExpressionPromises(g.revivalExpressionPromises ?? [],p.id,g.turn).length || - liveShipmentPromises(g.shipmentPromises ?? [],p.id,g.turn).length || hasMovementPromises(g,p.id) || + (![...revivals,...leaders].some(row => row.answer) && !expressions.length && + !shipments.some(row => matchesShipment(row,null) !== row.answer)) || + hasMovementPromises(g,p.id) || liveEarlyRicheseBidPromises(g.earlyRicheseBidPromises ?? [],p.id,g.turn).length || hasBribePromises(g,p.id) || g.charityPromises?.some(row => row.player === p.id && row.turn === g.turn && !row.fulfilled && !row.released)) return null; const range = phaseBidCompletionRange(promises,witness); @@ -18467,13 +18470,28 @@ function phaseBidRevivalWitness(g: Game, p: Player, promises: readonly PhaseBidP const source = structuredClone(g); source.truthtrance = null; source.phaseBidPromises = (source.phaseBidPromises ?? []).filter(row => row.player !== p.id); + // The donor's pledged spice can be spent by its ally; an unknown refund is + // not personal cash available for this witness. This changes only the probe. + delete source.aid[p.id]; for (const seed of earlyRevivalCompletionSeeds(structuredClone(source),source,p.id)) { if (seed.early.length) continue; const owner = getPlayer(seed.game,p.id); if (owner.spice < range.minimum) continue; owner.spice -= range.minimum; - if (currentRevivalPromiseCompletion(seed.game,owner,seed.game.revivalPromises ?? [])) - return {...witness,minimum:range.minimum,maximum:range.minimum}; + const completed = completeTurnActionRevivalSeed(seed,p.id); + if (!completed || currentRevivalPromiseCompletion(completed.game,getPlayer(completed.game,p.id), + completed.game.revivalPromises ?? [])?.type !== 'ready') continue; + if (shipments.some(row => matchesShipment(row,null) !== row.answer)) { + const future = completed.game; + future.phase = 5; + future.ready = []; + delete future.revivalOrder; + resetGroundMovementForecast(future,p.id); + future.active = p.id; + const shipment = findShipmentCompletion(future,getPlayer(future,p.id),shipments); + if (!shipment || shipment.early?.length || shipment.actions.some(action => action.type !== 'ship')) continue; + } + return {...witness,minimum:range.minimum,maximum:range.minimum}; } return null; } @@ -18484,7 +18502,7 @@ function viablePhaseBidWitnesses(g: Game, p: Player, promises: readonly PhaseBid return phaseBidWitnesses(g,p).flatMap(witness => { if (witness.kind === 'future') { if (otherCommitments) { - const joint = phaseBidRevivalWitness(g,p,promises,witness); + const joint = phaseBidRevivalShipmentWitness(g,p,promises,witness); return joint ? [joint] : []; } if (hasBribePromises(g,p.id,true)) { @@ -34256,7 +34274,8 @@ function earlyShipmentGuidance(g: Game, p: Player): { preparation: { actions: Ac if (lot) return {preparation:null,policy:!lot.outcome && lot.eligible.includes(p.id) && (lot.method === 'silent' ? !Object.hasOwn(lot.sealed,p.id) : lot.active === p.id) ? [{type:'richeseBid',event:lot.event,amount:lot.method === 'silent' ? 0 : null,allyPayment:0}] : []}; - return { preparation: null, policy: g.auction?.active === p.id ? [{ type: 'passBid' }] : [] }; + const bidGuide = projectedPhaseBidGuide(g,p.id)?.action ?? projectedBidPromiseGuide(g,p.id)?.action; + return { preparation: null, policy: g.auction?.active === p.id ? [bidGuide ?? { type: 'passBid' }] : [] }; } if (g.phase === 4 && nativeRevivalOrderBlock(g,p.id)) return {preparation:null,policy:[]}; if (g.phase === 2 && nativeCharityOrderBlock(g,p.id)) return {preparation:null,policy:[]}; diff --git a/tests/fixture-truthtrance-future-shipment.ts b/tests/fixture-truthtrance-future-shipment.ts index b618fb2e..2efd3a60 100644 --- a/tests/fixture-truthtrance-future-shipment.ts +++ b/tests/fixture-truthtrance-future-shipment.ts @@ -10,7 +10,7 @@ export const futureShipmentPlayer = (game: Game, actor = 'emperor') => { const player = game.players.find(player => player.id === actor); assert.ok(player); return player; }; export const futureShipmentClean = (game: Game) => !game.response && !game.phaseOpening && - !game.decision && !game.truthtrance && !game.pendingTreacheryDiscard; + !game.decision && !game.truthtrance && !game.pendingTreacheryDiscard && !game.pendingEmperorAuctionGift; export function actFutureShipment(game: Game, actor: string, action: Action, actions: FutureShipmentStep[] = []): Game { const next = withClassicDiscoveryNexusLottery(() => applyAction(game, actor, action)); actions.push({ actor, action: structuredClone(action) }); return next; @@ -23,6 +23,10 @@ export function nextFutureShipmentStep(game: Game): FutureShipmentStep | null { const actor = game.players.find(player => !game.truthtrance!.passed.includes(player.id)); assert.ok(actor); return { actor: actor.id, action: { type: 'truthPass' } }; } + if (game.pendingEmperorAuctionGift && !game.response && !game.pendingKarama && !game.pendingKull) + return { actor: game.pendingEmperorAuctionGift.owner, action: { + type: 'emperorAuctionGiftContinue', event: game.pendingEmperorAuctionGift.event, + } }; if (!game.response && !game.phaseOpening && !game.pendingTreacheryDiscard && game.decision?.kind === 'guildTiming') return { actor: game.decision.player, action: { type: 'decision', take: false } }; return nextStrongholdFactionsNativeStep(game); diff --git a/tests/truth-phase-bid-leader-joint.test.ts b/tests/truth-phase-bid-leader-joint.test.ts new file mode 100644 index 00000000..7f69ba20 --- /dev/null +++ b/tests/truth-phase-bid-leader-joint.test.ts @@ -0,0 +1,88 @@ +import assert from 'node:assert/strict'; +import test from 'node:test'; +import { viewGame, type Game } from '../game/engine'; +import { actTruthBid as act, advanceTruthBid as advance, truthBidClean as clean, + truthBidInventory as inventory, truthBidPlayer as player } from './fixture-truth-bid'; +import { advanceTruthRevival, truthRevivalClean } from './fixture-truth-revival'; +import { createTruthTurnBidFixture } from './fixture-truth-turn-bid'; + +/** Real public Harkonnen/Atreides/Emperor setup. The unopened Spice order is + * staged; Emperor's existing leader discs are all moved to their first death + * cohort and three existing reserve forces to Tanks. */ +function fixture() { + const f = createTruthTurnBidFixture(); + let game = structuredClone(f.afterSetup); + for (const {position, from, card} of f.spiceOrder) { + const [selected] = game.spiceDeck.splice(from, 1); + assert.deepEqual(selected, card); + game.spiceDeck.splice(position, 0, selected); + } + game = advance(game, state => state.turn === 1 && state.phase === 2 && clean(state)); + const emperor = player(game, f.target); + assert.equal(emperor.spice, 10); + const leader = emperor.leaders.find(row => row.strength === 2); assert.ok(leader); + for (const disc of emperor.leaders) { disc.dead = true; disc.deaths = 1; } + emperor.reserves -= 3; emperor.tanks += 3; + assert.deepEqual(inventory(game), f.originalCards); + return { f, game, leader: leader.id }; +} + +function ask(game: Game, asker: string, card: string, question: object): Game { + game = act(game, asker, {type:'card', card}); + for (let count = 0; game.truthtrance?.stage === 'priority' && count < game.players.length; count++) { + const seat = game.players.find(row => !game.truthtrance!.passed.includes(row.id)); assert.ok(seat); + game = act(game, seat.id, {type:'truthPass'}); + } + assert.equal(game.truthtrance?.stage, 'ask'); + return act(game, asker, {type:'truthAsk', question}); +} + +for (const mode of ['leader', 'expression'] as const) + for (const first of ['bid', 'revival'] as const) + for (const affordable of [true, false]) { + void test(`Basic phase bid and ${mode} in ${first}-first order ${affordable ? 'share enough spice' : 'cannot overcommit spice'}`, () => { + const { f, game: initial, leader } = fixture(); + const minimum = (mode === 'leader' ? 8 : 4) + Number(!affordable); + const bid = {kind:'phaseBid', target:f.target, turn:initial.turn, minimum}; + const revival = mode === 'leader' + ? {kind:'leaderRevival', target:f.target, turn:initial.turn, leader} + : {kind:'revivalExpression', target:f.target, turn:initial.turn, claim: {kind:'and', terms:[ + {kind:'forces', counter:'total', minimum:3}, {kind:'leader', leader}, + ]}}; + const questions = first === 'bid' ? [bid, revival] : [revival, bid]; + const revivalAnswers = (state: Game) => mode === 'leader' + ? viewGame(state,f.target).truthLeaderRevivalAnswers + : viewGame(state,f.target).truthRevivalExpressionAnswers; + let game = ask(initial, f.asker, f.truths[0], questions[0]); + const firstAnswers = first === 'bid' ? viewGame(game,f.target).truthPhaseBidAnswers : revivalAnswers(game); + assert.ok(firstAnswers?.includes('yes'), 'Each single commitment is independently feasible'); + game = act(game,f.target,{type:'truthAnswer',answer:'yes'}); + game = ask(game,f.asker,f.truths[1],questions[1]); + const secondAnswers = first === 'bid' ? revivalAnswers(game) : viewGame(game,f.target).truthPhaseBidAnswers; + assert.ok(secondAnswers?.includes('no')); + assert.equal(secondAnswers?.includes('yes'), affordable, 'Bid and full return share the same owned spice'); + if (!affordable) { + const before = structuredClone(game); + assert.throws(() => act(game,f.target,{type:'truthAnswer',answer:'yes'})); + assert.deepEqual(game,before); + return; + } + game = act(game,f.target,{type:'truthAnswer',answer:'yes'}); + game = advance(game,state => clean(state) && state.phase === 3 && state.auction?.active === f.target); + game = act(game,f.target,{type:'bid',amount:minimum,allyPayment:0}); + game = advance(game,state => clean(state) && state.phase === 4); + assert.equal(player(game,f.target).spice, mode === 'leader' ? 2 : 6); + game = act(game,f.target,{type:'reviveLeader',leader}); + game = advanceTruthRevival(game,truthRevivalClean); + assert.equal(player(game,f.target).leaders.find(row => row.id === leader)?.dead,false); + if (mode === 'expression') { + game = act(game,f.target,{type:'revive',amount:3,elite:0}); + game = advanceTruthRevival(game,truthRevivalClean); + assert.ok(game.revivalExpressionPromises?.some(row => row.player === f.target && row.fulfilled)); + assert.equal(player(game,f.target).tanks,0); + } else assert.ok(game.leaderRevivalPromises?.some(row => row.player === f.target && row.fulfilled)); + assert.equal(player(game,f.target).spice,0); + assert.ok(game.phaseBidPromises?.some(row => row.player === f.target && row.fulfilled)); + assert.deepEqual(inventory(game),f.originalCards); + }); + } diff --git a/tests/truth-phase-bid-revival-shipment-joint.test.ts b/tests/truth-phase-bid-revival-shipment-joint.test.ts new file mode 100644 index 00000000..e6ddf2e5 --- /dev/null +++ b/tests/truth-phase-bid-revival-shipment-joint.test.ts @@ -0,0 +1,81 @@ +import assert from 'node:assert/strict'; +import test from 'node:test'; +import { viewGame, type Game } from '../game/engine'; +import { actTruthBid as act, advanceTruthBid as advance, truthBidClean as clean, + truthBidInventory as inventory, truthBidPlayer as player } from './fixture-truth-bid'; +import { advanceTruthRevival, truthRevivalClean } from './fixture-truth-revival'; +import { createTruthTurnBidFixture } from './fixture-truth-turn-bid'; + +/** Public H/A/E Basic setup and real turn-1 Charity. Because Basic has only + * two physical Truthtrances, one earlier shipment Yes is explicitly staged; + * the bid and revival commitments are asked and answered through real cards. + * Three existing reserves are moved to Tanks, and unopened Spice is ordered. */ +function fixture() { + const f = createTruthTurnBidFixture(); + let game = structuredClone(f.afterSetup); + for (const {position, from, card} of f.spiceOrder) { + const [selected] = game.spiceDeck.splice(from, 1); + assert.deepEqual(selected, card); + game.spiceDeck.splice(position, 0, selected); + } + game = advance(game,state => state.turn === 1 && state.phase === 2 && clean(state)); + const emperor = player(game,f.target); + assert.equal(emperor.spice,10); assert.ok(emperor.reserves >= 3); + emperor.reserves -= 3; emperor.tanks += 3; + game.shipmentPromises = [{turn:game.turn,player:f.target,asker:f.asker, + territory:'carthag',minimum:2,answer:true}]; + assert.deepEqual(inventory(game),f.originalCards); + return {f,game}; +} + +function ask(game: Game, asker: string, card: string, question: object): Game { + game = act(game,asker,{type:'card',card}); + for (let count = 0; game.truthtrance?.stage === 'priority' && count < game.players.length; count++) { + const seat = game.players.find(row => !game.truthtrance!.passed.includes(row.id)); assert.ok(seat); + game = act(game,seat.id,{type:'truthPass'}); + } + assert.equal(game.truthtrance?.stage,'ask'); + return act(game,asker,{type:'truthAsk',question}); +} + +for (const first of ['bid','revival'] as const) for (const affordable of [true,false]) { + void test(`Basic pre-Bidding bid, Revival and staged shipment share a purse in ${first}-first order (${affordable ? 'funded' : 'one short'})`, () => { + const {f,game:initial} = fixture(); + const minimum = affordable ? 4 : 5; + const bid = {kind:'phaseBid',target:f.target,turn:initial.turn,minimum}; + const revival = {kind:'revival',target:f.target,turn:initial.turn,counter:'total',minimum:3}; + const questions = first === 'bid' ? [bid,revival] : [revival,bid]; + let game = ask(initial,f.asker,f.truths[0],questions[0]); + const firstAnswers = first === 'bid' ? viewGame(game,f.target).truthPhaseBidAnswers : viewGame(game,f.target).truthRevivalAnswers; + assert.ok(firstAnswers?.includes('yes'), 'The first answer and earlier shipment fit the purse'); + game = act(game,f.target,{type:'truthAnswer',answer:'yes'}); + game = ask(game,f.asker,f.truths[1],questions[1]); + const answers = first === 'bid' ? viewGame(game,f.target).truthRevivalAnswers : viewGame(game,f.target).truthPhaseBidAnswers; + assert.ok(answers?.includes('no')); + assert.equal(answers?.includes('yes'),affordable, 'A bid, two paid returns and two shipped forces cost the same 10-spice purse'); + if (!affordable) { + const before = structuredClone(game); + assert.throws(() => act(game,f.target,{type:'truthAnswer',answer:'yes'})); + assert.deepEqual(game,before); + return; + } + game = act(game,f.target,{type:'truthAnswer',answer:'yes'}); + game = advance(game,state => clean(state) && state.phase === 3 && state.auction?.active === f.target); + game = act(game,f.target,{type:'bid',amount:4,allyPayment:0}); + assert.ok(game.phaseBidPromises?.some(row => row.player === f.target && row.fulfilled)); + game = advance(game,state => clean(state) && state.phase === 4); + assert.equal(player(game,f.target).spice,6); + game = act(game,f.target,{type:'revive',amount:3,elite:0}); + game = advanceTruthRevival(game,truthRevivalClean); + assert.equal(player(game,f.target).spice,2); + assert.ok(game.revivalPromises?.some(row => row.player === f.target && row.fulfilled)); + game = advance(game,state => clean(state) && state.phase === 5 && state.active === f.target); + const ship = viewGame(game,f.target).shipmentCompletion?.actions.at(-1); + assert.ok(ship && ship.type === 'ship'); assert.equal(ship.amount,2); + game = act(game,f.target,ship); + game = advance(game,state => clean(state) && !!state.shipmentPromises?.some(row => row.player === f.target && row.fulfilled)); + assert.equal(player(game,f.target).spice,0); + assert.equal(player(game,f.target).forces['carthag:11'],2); + assert.deepEqual(inventory(game),f.originalCards); + }); +} diff --git a/tests/truth-phase-bid-shipment-joint.test.ts b/tests/truth-phase-bid-shipment-joint.test.ts new file mode 100644 index 00000000..16164072 --- /dev/null +++ b/tests/truth-phase-bid-shipment-joint.test.ts @@ -0,0 +1,84 @@ +import assert from 'node:assert/strict'; +import test from 'node:test'; +import { applyAction, viewGame, type Game } from '../game/engine'; +import { botActions } from '../game/bots'; +import { DIFFICULTIES } from '../game/bot-profiles'; +import { actTruthBid as act, advanceTruthBid as advance, truthBidClean as clean, + truthBidInventory as inventory, truthBidPlayer as player } from './fixture-truth-bid'; +import { createTruthTurnBidFixture } from './fixture-truth-turn-bid'; + +/** Public Basic Harkonnen/Atreides/Emperor setup. The two Truthtrances and + * initial purses are genuinely dealt; only unopened Spice order is staged. */ +function fixture() { + const f = createTruthTurnBidFixture(); + let game = structuredClone(f.afterSetup); + for (const {position, from, card} of f.spiceOrder) { + const [selected] = game.spiceDeck.splice(from, 1); + assert.deepEqual(selected, card); + game.spiceDeck.splice(position, 0, selected); + } + game = advance(game, state => state.turn === 1 && state.phase === 2 && clean(state)); + assert.equal(player(game, f.target).spice, 10); + assert.ok(player(game, f.target).reserves >= 4); + assert.deepEqual(inventory(game), f.originalCards); + return {f, game}; +} + +function ask(game: Game, asker: string, card: string, question: object): Game { + game = act(game, asker, {type:'card', card}); + for (let count = 0; game.truthtrance?.stage === 'priority' && count < game.players.length; count++) { + const seat = game.players.find(row => !game.truthtrance!.passed.includes(row.id)); assert.ok(seat); + game = act(game, seat.id, {type:'truthPass'}); + } + assert.equal(game.truthtrance?.stage, 'ask'); + return act(game, asker, {type:'truthAsk', question}); +} + +for (const first of ['bid', 'shipment'] as const) for (const affordable of [true, false]) { + void test(`Basic phase bid and paid shipment in ${first}-first order ${affordable ? 'share enough spice' : 'cannot overcommit spice'}`, () => { + const {f, game: initial} = fixture(); + const bid = {kind:'phaseBid', target:f.target, turn:initial.turn, minimum:affordable ? 6 : 7}; + const shipment = {kind:'shipment', target:f.target, territory:'carthag', minimum:4}; + const questions = first === 'bid' ? [bid, shipment] : [shipment, bid]; + let game = ask(initial, f.asker, f.truths[0], questions[0]); + const firstAnswers = first === 'bid' ? viewGame(game, f.target).truthPhaseBidAnswers : viewGame(game, f.target).truthShipmentAnswers; + assert.ok(firstAnswers?.includes('yes'), 'Each single obligation is feasible by itself'); + game = act(game, f.target, {type:'truthAnswer', answer:'yes'}); + game = ask(game, f.asker, f.truths[1], questions[1]); + const secondAnswers = first === 'bid' ? viewGame(game, f.target).truthShipmentAnswers : viewGame(game, f.target).truthPhaseBidAnswers; + assert.ok(secondAnswers?.includes('no')); + assert.equal(secondAnswers?.includes('yes'), affordable, 'The same spice cannot fund the bid and shipment twice'); + if (!affordable) { + const before = structuredClone(game); + assert.throws(() => act(game, f.target, {type:'truthAnswer', answer:'yes'})); + assert.deepEqual(game, before); + return; + } + game = act(game, f.target, {type:'truthAnswer', answer:'yes'}); + assert.equal(game.truthtrance, null); + const withoutPromises = structuredClone(game); + withoutPromises.phaseBidPromises = []; + withoutPromises.shipmentPromises = []; + assert.doesNotThrow(() => act(withoutPromises, f.target, {type:'bribe', target:f.asker, amount:1})); + const beforeSpend = structuredClone(game); + assert.throws(() => act(game, f.target, {type:'bribe', target:f.asker, amount:1})); + assert.deepEqual(game, beforeSpend); + game = advance(game, state => clean(state) && state.phase === 3 && state.auction?.active === f.target); + for (const difficulty of DIFFICULTIES) { + const view = viewGame(game, f.target); view.players.find(row => row.id === f.target)!.bot = difficulty; + const action = botActions(view)[0]; assert.ok(action); + assert.doesNotThrow(() => applyAction(game, f.target, action), `${difficulty} retains a legal bid response`); + } + game = act(game, f.target, {type:'bid', amount:6, allyPayment:0}); + assert.ok(game.phaseBidPromises?.some(row => row.player === f.target && row.fulfilled)); + game = advance(game, state => clean(state) && state.phase === 5 && state.active === f.target); + assert.equal(player(game, f.target).spice, 4, 'The original winning bid is paid once'); + const action = viewGame(game, f.target).shipmentCompletion?.actions.at(-1); + assert.ok(action && action.type === 'ship'); assert.equal(action.amount, 4); + game = act(game, f.target, action); + game = advance(game, state => clean(state) && !!state.shipmentPromises?.some(row => row.player === f.target && row.fulfilled)); + assert.equal(player(game, f.target).spice, 0); + assert.equal(player(game, f.target).forces['carthag:11'], 4); + assert.deepEqual(inventory(game), f.originalCards); + }); +}