264 lines
16 KiB
TypeScript
264 lines
16 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { applyAction, createGame, joinGame, newPlayer, normalizeAutomaticGame, viewGame, type Action, type Game } from '../game/engine';
|
|
import { botActions } from '../game/bots';
|
|
import { DIFFICULTIES } from '../game/bot-profiles';
|
|
import { SEMUTA_DRUG_ID } from '../game/semuta-drug';
|
|
import { takeKullCard } from './fixture-choam-kull';
|
|
import { nextHarkonnenBetrayalNativeStep } from './fixture-nexus-harkonnen-betrayal';
|
|
import { nextRicheseStrongholdsNativeStep } from './fixture-richese-strongholds';
|
|
import { swapSemutaNexusTradeIdentity } from './fixture-semuta-nexus-trade';
|
|
|
|
const act = (game: Game, actor: string, action: Action) => applyAction(game, actor, action);
|
|
const seat = (game: Game, id: string) => { const player = game.players.find(row => row.id === id); assert.ok(player); return player; };
|
|
const clean = (game: Game) => !game.response && !game.decision && !game.phaseOpening;
|
|
function stock(game: Game): string[] {
|
|
return [...game.deck, ...game.discard, ...(game.richeseCache ?? []), ...(game.richeseRemoved ?? []),
|
|
...(game.auction?.cards.slice(game.auction.index + Number(game.currentAuctionSale?.origin === 'normal')) ?? []),
|
|
...(game.ixAuction?.cards ?? []), ...game.players.flatMap(player => player.hand)].map(card => card.id).sort();
|
|
}
|
|
function advance(game: Game, until: (game: Game) => boolean): Game {
|
|
let last: unknown;
|
|
for (let n = 0; n < 1800; n++) {
|
|
if (until(game)) return game;
|
|
assert.notEqual(game.status, 'finished');
|
|
if (game.pendingTreacheryDiscard?.reaction?.stage === 'offer') {
|
|
const pending = game.pendingTreacheryDiscard, reaction = pending.reaction;
|
|
assert.ok(reaction && reaction.stage === 'offer');
|
|
const actor = game.players.find(player => !reaction.passed.includes(player.id)); assert.ok(actor);
|
|
game = act(game, actor.id, {type:'semutaPass',event:pending.batch.event});
|
|
continue;
|
|
}
|
|
if (game.pendingGuildBetrayal) {
|
|
const pending = game.pendingGuildBetrayal, actor = pending.required.find(id => !pending.passed.includes(id)); assert.ok(actor);
|
|
game = act(game, actor, {type:'guildBetrayalPass',event:pending.invoice.event});
|
|
continue;
|
|
}
|
|
if (!game.response && !game.phaseOpening && game.decision?.kind === 'ecazPlacement') {
|
|
const token = game.ecazAmbassadors!.tokens.find(row => row.effect === 'ecaz' && row.zone === 'supply');
|
|
game = act(game, game.decision.player, token
|
|
? {type:'decision',token:token.id,territory:'arrakeen'} : {type:'decision',decline:true});
|
|
continue;
|
|
}
|
|
if (!game.response && !game.phaseOpening && game.decision?.kind === 'moritaniPlacement') {
|
|
const token = game.moritaniTerror!.tokens.find(row => row.kind === 'robbery' && row.status === 'available');
|
|
game = act(game, game.decision.player, token
|
|
? {type:'decision',token:token.id,territory:'carthag'} : {type:'decision',decline:true});
|
|
continue;
|
|
}
|
|
const next = !game.response && !game.phaseOpening &&
|
|
(game.decision?.kind.startsWith('richese') || game.richeseAuction && !game.richeseAuction.outcome)
|
|
? nextRicheseStrongholdsNativeStep(game)! : nextHarkonnenBetrayalNativeStep(game);
|
|
last = next;
|
|
try { game = act(game, next.actor, next.action); }
|
|
catch (error) { throw Error(`Native ${game.status}/${game.turn}/${game.phase}/${game.decision?.kind}: ${JSON.stringify(next)}: ${String(error)}`); }
|
|
}
|
|
throw Error(`Native three-expansion Nexus Kull journey stalled: ${game.turn}/${game.phase} ${JSON.stringify({last,stormPending:game.stormPending,stormDials:game.stormDials,stormDialers:game.stormDialers,phaseOpening:game.phaseOpening,response:game.response,decision:game.decision,ready:game.ready})}`);
|
|
}
|
|
function orderSpice(game: Game, kinds: readonly ('land'|'worm')[]): void {
|
|
for (const [position, kind] of kinds.entries()) {
|
|
const index = game.spiceDeck.findIndex((card, i) => i >= position &&
|
|
(kind === 'land' ? 'territory' in card : 'worm' in card && !card.greatMaker && !card.suppressed));
|
|
assert.ok(index >= position); game.spiceDeck.splice(position, 0, game.spiceDeck.splice(index, 1)[0]);
|
|
}
|
|
}
|
|
|
|
/** Public three-expansion native setup, real alliance and two earned Nexus draws. Unopened
|
|
* Spice order, identities of genuinely drawn Nexus cards, board positions and
|
|
* physical Treachery holdings are staged while conserving every component. */
|
|
function fixture(includeRichese = true) {
|
|
let game = createGame('NXKULLE3', newPlayer('ix','Ixians','ixians'), false, ['ix','choam','ecaz']);
|
|
const peers = [ ['m','moritani'], ['c','choam'], ['r',includeRichese ? 'richese' : 'guild'], ['a','atreides'], ['e','ecaz'] ] as const;
|
|
for (const [id,faction] of peers)
|
|
joinGame(game, newPlayer(id,faction,faction));
|
|
game = act(game,'ix',{type:'moduleOption',module:'nexusCards',enabled:true});
|
|
for (const player of game.players) game = act(game,player.id,{type:'ready'});
|
|
game = act(game,'ix',{type:'start'});
|
|
assert.equal(game.kullPreview,true); assert.equal(game.nexusKullPreview,true); assert.equal(game.semutaPreview === true,includeRichese);
|
|
assert.equal(game.nexusIxianBetrayalPreview,true);
|
|
game = advance(game,state => state.status === 'playing');
|
|
assert.equal(game.ecazOccupyPreview,true);
|
|
assert.equal(Object.values(seat(game,'e').forces).reduce((sum,n)=>sum+n,0),6);
|
|
const original = stock(game);
|
|
for (const player of game.players) {
|
|
player.reserves += Object.values(player.forces).reduce((sum,n)=>sum+n,0); player.forces = {};
|
|
if (player.elites) { player.elites.reserves += Object.values(player.elites.forces).reduce((sum,n)=>sum+n,0); player.elites.forces={}; }
|
|
}
|
|
orderSpice(game,['land','land']);
|
|
game = advance(game,state=>state.turn===2 && state.phase===1 && clean(state));
|
|
assert.ok(game.ecazAmbassadors!.tokens.some(row => row.effect === 'ecaz' && row.location === 'arrakeen'));
|
|
assert.ok(game.moritaniTerror!.tokens.some(row => row.kind === 'robbery' && row.location === 'carthag'));
|
|
orderSpice(game,['worm','land','land']);
|
|
game = advance(game,state=>state.nexus && !state.spiceWindow && !state.spiceResolution && clean(state));
|
|
game = act(game,'ix',{type:'alliance',target:'m'}); game = act(game,'m',{type:'alliance',target:'ix'});
|
|
game = advance(game,state=>state.nexusCards?.phase?.stage==='drawing' && clean(state));
|
|
for (const id of ['a','c']) {
|
|
assert.ok(game.nexusCards!.phase!.eligible.includes(id));
|
|
game = act(game,id,{type:'nexusCardChoice',turn:game.turn,card:null,choice:'draw',ownRedraws:0});
|
|
swapSemutaNexusTradeIdentity(game,id,id==='a'?'ixians':'choam');
|
|
}
|
|
game = advance(game,state=>state.phase===2 && clean(state));
|
|
for (const player of game.players) game.deck.push(...player.hand.splice(0));
|
|
const originalKarama = takeKullCard(game,'karama'); seat(game,'e').hand.push(originalKarama);
|
|
const counter = takeKullCard(game,'karama'); seat(game,'a').hand.push(counter);
|
|
game = advance(game,state=>state.response?.kind==='ixAuction');
|
|
assert.equal(game.ixAuction?.cards.length,0);
|
|
// Stage conserved held cards at the open native response, after CHOAM's
|
|
// earlier market opportunity cannot sell the intended physical Kull.
|
|
const printed = takeKullCard(game,'ix-kull-wahad'); seat(game,'c').hand.push(printed);
|
|
const fuel = takeKullCard(game,'ix-hunter-seeker'); seat(game,'c').hand.push(fuel);
|
|
const semuta = includeRichese ? takeKullCard(game,SEMUTA_DRUG_ID) : null;
|
|
if (semuta) seat(game,'r').hand.push(semuta);
|
|
assert.deepEqual(stock(game),original);
|
|
game = act(game,'e',{type:'card',mode:'cancel',card:originalKarama.id});
|
|
assert.ok(game.pendingKull); assert.equal(game.pendingKull.resume.response?.kind,'ixAuction');
|
|
return {game,original,printed:printed.id,fuel:fuel.id,karama:originalKarama.id,counter:counter.id,semuta:semuta?.id,event:game.pendingKull.event};
|
|
}
|
|
function passKullCounter(state: Game): Game {
|
|
let game=state;
|
|
while (game.pendingKull) {
|
|
const actor = game.players.find(player => { const controls=viewGame(game,player.id).responseControls;
|
|
return controls && !controls.hasPassed && controls.cancelCards.length > 0; });
|
|
game = actor ? act(game,actor.id,{type:'passResponse'}) : normalizeAutomaticGame(game);
|
|
}
|
|
return game;
|
|
}
|
|
|
|
function semutaReaction(state: Game, claim: boolean): Game {
|
|
let game = state;
|
|
const event = game.pendingTreacheryDiscard?.batch.event; assert.ok(event);
|
|
if (claim) {
|
|
game = act(game,'r',{type:'semutaCommit',event});
|
|
if (game.pendingTreacheryDiscard?.reaction?.stage === 'select')
|
|
game = act(game,'r',{type:'semutaSelect',event,card:game.pendingTreacheryDiscard.batch.entries[0].card.id});
|
|
} else while (game.pendingTreacheryDiscard?.batch.event === event && game.pendingTreacheryDiscard.reaction?.stage === 'offer') {
|
|
const reaction = game.pendingTreacheryDiscard.reaction;
|
|
const actor = game.players.find(player => !reaction.passed.includes(player.id)); assert.ok(actor);
|
|
game = act(game,actor.id,{type:'semutaPass',event});
|
|
}
|
|
assert.notEqual(game.pendingTreacheryDiscard?.batch.event,event);
|
|
return game;
|
|
}
|
|
|
|
for (const source of ['printed','nexus'] as const) for (const claim of [false,true]) void test(
|
|
`Basic Ecaz/Moritani/Richese/Ixian Nexus auction survives ${source} Kull and Semuta ${claim?'claim':'pass'}`, () => {
|
|
const f=fixture();
|
|
for (const difficulty of DIFFICULTIES) {
|
|
const view=viewGame(f.game,'c'); view.players.find(player=>player.id==='c')!.bot=difficulty;
|
|
const choice=botActions(view).find(action=>action.type==='kullDecision'); assert.ok(choice);
|
|
assert.doesNotThrow(()=>act(f.game,'c',choice));
|
|
}
|
|
assert.ok(viewGame(f.game,'c').kullReaction?.plays.some(play => play.source === source && play.card.id === (source === 'printed' ? f.printed : f.fuel)),
|
|
`Missing ${source} option; hand: ${seat(f.game,'c').hand.map(card=>card.id).join(', ')}; discard: ${f.game.discard.map(card=>card.id).join(', ')}`);
|
|
const cost = source === 'printed' ? f.printed : f.fuel;
|
|
let game=act(f.game,'c',{type:'kullDecision',event:f.event,source,card:cost});
|
|
game=passKullCounter(game);
|
|
assert.equal(game.pendingKull,null);
|
|
assert.equal(seat(game,'e').hand.some(card=>card.id===f.karama),true);
|
|
assert.equal(game.pendingTreacheryDiscard?.batch.entries[0].card.id,cost);
|
|
assert.equal(game.pendingTreacheryDiscard?.batch.entries[0].publicFace,source === 'printed');
|
|
game=semutaReaction(game,claim);
|
|
assert.equal(seat(game,'r').hand.some(card=>card.id===cost),claim);
|
|
assert.equal(game.nexusCards!.cards!.hands.c,source === 'printed' ? 'choam' : null);
|
|
game=advance(game,state=>!!state.pendingNexusIxianBetrayal);
|
|
const nexus=game.pendingNexusIxianBetrayal!;
|
|
assert.equal(viewGame(game,'a').nexusIxianBetrayalReaction?.canUse,true);
|
|
for (const use of [false,true]) {
|
|
let resumed = structuredClone(game);
|
|
if (use) resumed=act(resumed,'a',{type:'nexusIxianBetrayalUse',event:nexus.source.event});
|
|
else while (resumed.pendingNexusIxianBetrayal) {
|
|
const pending=resumed.pendingNexusIxianBetrayal;
|
|
const actor=pending.required.find(id=>!pending.passed.includes(id)); assert.ok(actor);
|
|
resumed=act(resumed,actor,{type:'nexusIxianBetrayalPass',event:pending.source.event});
|
|
}
|
|
assert.equal(resumed.pendingNexusIxianBetrayal,null);
|
|
if (!use) {
|
|
assert.equal(resumed.decision?.kind,'ixAuction'); assert.ok(resumed.ixAuction?.cards.length);
|
|
resumed=act(resumed,'ix',{type:'decision',card:resumed.ixAuction.cards[0].id,position:'top'});
|
|
}
|
|
assert.equal(resumed.ixAuction,null); assert.ok(resumed.auction);
|
|
assert.deepEqual(stock(resumed),f.original);
|
|
}
|
|
});
|
|
|
|
for (const claim of [false,true]) void test(
|
|
`Basic Ecaz/Moritani/Richese/Ixian Nexus auction resumes original cancellation after Kull counter and Semuta ${claim?'claim':'pass'}`, () => {
|
|
const f=fixture();
|
|
let game=act(f.game,'c',{type:'kullDecision',event:f.event,source:'nexus',card:f.fuel});
|
|
game=act(game,'a',{type:'card',mode:'cancel',card:f.counter});
|
|
assert.equal(game.pendingTreacheryDiscard?.batch.entries[0].card.id,f.counter);
|
|
game=semutaReaction(game,claim);
|
|
if (game.pendingTreacheryDiscard) {
|
|
assert.equal(game.pendingTreacheryDiscard.batch.entries[0].card.id,f.karama);
|
|
game=semutaReaction(game,false);
|
|
}
|
|
assert.equal(game.pendingKull,null); assert.equal(game.pendingNexusIxianBetrayal,null);
|
|
assert.equal(game.ixAuction,null); assert.ok(game.auction);
|
|
assert.equal(game.discard.some(card=>card.id===f.karama),true);
|
|
assert.equal(seat(game,'c').hand.some(card=>card.id===f.fuel),true);
|
|
assert.equal(game.nexusCards!.cards!.hands.c,null);
|
|
assert.deepEqual(stock(game),f.original);
|
|
});
|
|
|
|
for (const source of ['printed','nexus'] as const) void test(
|
|
`Basic three-expansion Nexus auction retains ${source} Kull without Richese`, () => {
|
|
const f = fixture(false), cost = source === 'printed' ? f.printed : f.fuel;
|
|
let game = act(f.game,'c',{type:'kullDecision',event:f.event,source,card:cost});
|
|
game = passKullCounter(game);
|
|
assert.equal(game.pendingKull,null);
|
|
assert.equal(game.pendingTreacheryDiscard ?? null,null);
|
|
assert.equal(game.discard.filter(card=>card.id===cost).length,1);
|
|
assert.equal(game.nexusCards!.cards!.hands.c,source === 'printed' ? 'choam' : null);
|
|
game = advance(game,state=>!!state.pendingNexusIxianBetrayal);
|
|
const pending = game.pendingNexusIxianBetrayal!;
|
|
game = act(game,'a',{type:'nexusIxianBetrayalUse',event:pending.source.event});
|
|
assert.equal(game.ixAuction,null);
|
|
assert.ok(game.auction);
|
|
assert.deepEqual(stock(game),f.original);
|
|
});
|
|
|
|
void test('Basic three-expansion Nexus keeps Semuta when the host opts out of Kull', () => {
|
|
let game = createGame('NXE3OPTOUT',newPlayer('ix','Ixians','ixians'),false,['ix','choam','ecaz']);
|
|
for (const [id,faction] of [['m','moritani'],['c','choam'],['r','richese'],['a','atreides'],['e','ecaz']] as const)
|
|
joinGame(game,newPlayer(id,faction,faction));
|
|
game = act(game,'ix',{type:'moduleOption',module:'nexusCards',enabled:true});
|
|
game = act(game,'ix',{type:'moduleOption',module:'kullPreview',enabled:false});
|
|
for (const player of game.players) game = act(game,player.id,{type:'ready'});
|
|
game = act(game,'ix',{type:'start'});
|
|
assert.equal(game.semutaPreview,true);
|
|
assert.notEqual(game.kullPreview,true);
|
|
assert.notEqual(game.nexusKullPreview,true);
|
|
game = advance(game,state=>state.status==='playing');
|
|
assert.equal(game.ecazOccupyPreview,true);
|
|
assert.equal(Object.values(seat(game,'e').forces).reduce((sum,n)=>sum+n,0),6);
|
|
const original = stock(game);
|
|
// Avoid unrelated battles while retaining every physical counter.
|
|
for (const player of game.players) {
|
|
player.reserves += Object.values(player.forces).reduce((sum,n)=>sum+n,0); player.forces={};
|
|
if (player.elites) {player.elites.reserves += Object.values(player.elites.forces).reduce((sum,n)=>sum+n,0); player.elites.forces={};}
|
|
}
|
|
orderSpice(game,['land','land']);
|
|
game = advance(game,state=>state.turn===2 && state.phase===1 && clean(state));
|
|
assert.ok(game.ecazAmbassadors!.tokens.some(row=>row.effect==='ecaz' && row.location==='arrakeen'));
|
|
assert.ok(game.moritaniTerror!.tokens.some(row=>row.kind==='robbery' && row.location==='carthag'));
|
|
orderSpice(game,['land','land']);
|
|
game = advance(game,state=>state.phase===5 && !!state.active && state.active!=='r' && clean(state));
|
|
const actor = game.active!;
|
|
// Move existing cards, preserving the original physical stock.
|
|
for (const player of game.players) game.deck.push(...player.hand.splice(0));
|
|
const hajr = takeKullCard(game,'hajr'); seat(game,actor).hand.push(hajr);
|
|
const semuta = takeKullCard(game,SEMUTA_DRUG_ID); seat(game,'r').hand.push(semuta);
|
|
assert.deepEqual(stock(game),original);
|
|
const pending = act(game,actor,{type:'card',card:hajr.id});
|
|
assert.equal(pending.pendingTreacheryDiscard?.batch.cause,'ordinary:hajr');
|
|
assert.equal(viewGame(pending,'r').semutaReaction?.canCommit,true);
|
|
for (const claim of [false,true]) {
|
|
const resumed = semutaReaction(structuredClone(pending),claim);
|
|
assert.equal(resumed.pendingTreacheryDiscard,null);
|
|
assert.ok(resumed.hajr.includes(actor));
|
|
assert.equal(seat(resumed,'r').hand.some(card=>card.id===hajr.id),claim);
|
|
assert.equal(resumed.discard.some(card=>card.id===semuta.id),claim);
|
|
assert.deepEqual(stock(resumed),original);
|
|
}
|
|
});
|