Files
Dune/tests/truth-early-richese-advanced-market-release.test.ts
T
Quintine 225b2174ad
Verify and publish checkpoint container / container (push) Successful in 11m48s
Support Advanced early cache bid promises
2026-11-16 20:34:43 +11:00

95 lines
5.6 KiB
TypeScript

import assert from 'node:assert/strict';
import test from 'node:test';
import { viewGame, type Game } from '../game/engine';
import {
actTruthtranceRichesePromises as act,
advanceTruthtranceRichesePromises as advance,
createTruthtranceRichesePromisesFixture as fixture,
passTruthRicheseFreshDiscard,
truthtranceRichesePromisesInventory as inventory,
truthtranceRichesePromisesPlayer as player,
type TruthtranceRichesePromisesFixture,
} from './fixture-truthtrance-richese-promises';
/** Real public Advanced R/A/E setup and real native Black Market. Two original
* cards move from unopened zones: the second Truthtrance to Atreides, Semuta
* to Richese. Richese actually reclaims the first discarded Truthtrance with
* Semuta to ask the third question; no extra physical card is invented. */
function source() {
const f = fixture({advanced:true}), game = structuredClone(f.earlySource);
const truthAt = game.deck.findIndex(card => card.effect === 'truthtrance' && card.id !== f.truth);
assert.ok(truthAt >= 0); const [second] = game.deck.splice(truthAt,1);
player(game,f.asker).hand.push(second);
const semutaAt = game.richeseCache!.findIndex(card => card.effect === 'semutaDrug');
assert.ok(semutaAt >= 0); const [semuta] = game.richeseCache!.splice(semutaAt,1);
player(game,f.richese).hand.push(semuta);
assert.deepEqual(inventory(game),f.originalCards);
return {f,game,second:second.id,semuta:semuta.id};
}
function ask(game:Game, f:TruthtranceRichesePromisesFixture, asker:string, card:string,
kind:'phaseAnyBid'|'earlyRicheseBid', minimum:number, answer:'yes'|'no', claim = false) {
game = act(game,asker,{type:'card',card});
game = advance(game,state => state.truthtrance?.stage === 'ask');
game = act(game,asker,{type:'truthAsk',question:{kind,target:f.emperor,turn:game.turn,minimum}});
const view = viewGame(game,f.emperor);
const options = kind === 'phaseAnyBid' ? view.truthPhaseAnyBidAnswers : view.truthEarlyRicheseBidAnswers;
assert.ok(options?.includes(answer),`${kind} ${answer} must retain its native witness`);
game = act(game,f.emperor,{type:'truthAnswer',answer});
if (!claim) return passTruthRicheseFreshDiscard(game);
const pending = game.pendingTreacheryDiscard; assert.ok(pending?.reaction);
assert.equal(viewGame(game,f.richese).semutaReaction?.canCommit,true);
game = act(game,f.richese,{type:'semutaCommit',event:pending.batch.event});
assert.equal(game.pendingTreacheryDiscard,null);
assert.ok(player(game,f.richese).hand.some(item => item.id === card));
return game;
}
void test('Advanced unresolved Black Market releases only the phase Yes made impossible by an external shortfall', () => {
const s = source();
let game = ask(s.game,s.f,s.f.asker,s.f.truth,'phaseAnyBid',4,'yes',true);
assert.ok(game.discard.some(card => card.id === s.semuta));
game = ask(game,s.f,s.f.asker,s.second,'phaseAnyBid',8,'yes');
game = ask(game,s.f,s.f.richese,s.f.truth,'earlyRicheseBid',4,'no');
assert.equal(player(game,s.f.emperor).spice,10);
const phase4 = game.phaseAnyBidPromises?.find(row => row.player === s.f.emperor && row.minimum === 4);
const phase8 = game.phaseAnyBidPromises?.find(row => row.player === s.f.emperor && row.minimum === 8);
const early = game.earlyRicheseBidPromises?.find(row => row.player === s.f.emperor);
assert.ok(phase4 && phase8 && early && !early.answer);
assert.deepEqual(inventory(game),s.f.originalCards);
game = advance(game,state => state.decision?.kind === 'richeseBlackMarket');
game = act(game,s.f.richese,{type:'decision',event:game.richeseBidding!.event,
card:s.f.targetCard,method:'silent'});
while (game.response) {
const actor = game.players.find(seat => !game.response!.passed.includes(seat.id)); assert.ok(actor);
game = act(game,actor.id,{type:'passResponse'});
}
assert.equal(game.richeseAuction?.source,'blackMarket');
const event = game.richeseAuction!.event;
// Controlled external-loss supplement: the three answers and the actual
// market are native; this models another effect reducing the target's cash
// before a different player's real sealed decline. No card/receipt changes.
game = structuredClone(game);
player(game,s.f.emperor).spice = 5;
const before = structuredClone(game), actor = s.f.asker;
assert.notEqual(actor,s.f.emperor);
game = act(game,actor,{type:'richeseBid',event,amount:0,allyPayment:0});
assert.equal(player(before,s.f.emperor).spice,5);
const lower = game.phaseAnyBidPromises?.find(row => row.event === phase4.event);
const higher = game.phaseAnyBidPromises?.find(row => row.event === phase8.event);
assert.ok(lower && higher);
assert.equal(!!lower.fulfilled,false); assert.equal(!!lower.released,false,
'The affordable four-spice Black Market declaration remains available');
assert.equal(!!higher.fulfilled,false); assert.equal(!!higher.released,true,
'Only the independently impossible eight-spice answer releases');
assert.ok(game.earlyRicheseBidPromises?.some(row => row.id === early.id && !row.released && !row.boundEvent));
assert.equal(game.richeseAuction?.event,event);
assert.equal(viewGame(game,s.f.richese).richeseAuction?.revealedBids,null);
const guide = viewGame(game,s.f.emperor).phaseAnyBidGuide?.action; assert.ok(guide);
assert.equal(guide.type,'richeseBid'); assert.equal(guide.event,event); assert.equal(guide.amount,4);
game = act(game,s.f.emperor,guide);
assert.ok(game.phaseAnyBidPromises?.some(row => row.event === phase4.event && row.fulfilled));
assert.ok(game.phaseAnyBidPromises?.some(row => row.event === phase8.event && row.released));
assert.deepEqual(inventory(game),s.f.originalCards);
});