143 lines
8.7 KiB
TypeScript
143 lines
8.7 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 { takeKullCard } from './fixture-choam-kull';
|
|
import { nextHarkonnenBetrayalNativeStep } from './fixture-nexus-harkonnen-betrayal';
|
|
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.auction?.cards.slice(game.auction.index) ?? []),
|
|
...(game.ixAuction?.cards ?? []), ...game.players.flatMap(player => player.hand)].map(card => card.id).sort();
|
|
}
|
|
function advance(game: Game, until: (game: Game) => boolean): Game {
|
|
for (let n = 0; n < 1800; n++) {
|
|
if (until(game)) return game;
|
|
assert.notEqual(game.status, 'finished');
|
|
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;
|
|
}
|
|
const next = nextHarkonnenBetrayalNativeStep(game);
|
|
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 Ixian Nexus Kull journey stalled: ${game.turn}/${game.phase}`);
|
|
}
|
|
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 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() {
|
|
let game = createGame('NXKULLIX', newPlayer('ix','Ixians','ixians'), false, ['ix','choam']);
|
|
for (const [id,faction] of [['t','tleilaxu'],['c','choam'],['a','atreides'],['g','guild']] as const)
|
|
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.nexusIxianBetrayalPreview,true);
|
|
game = advance(game,state => state.status === 'playing');
|
|
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));
|
|
orderSpice(game,['worm','land','land']);
|
|
game = advance(game,state=>state.nexus && !state.spiceWindow && !state.spiceResolution && clean(state));
|
|
game = act(game,'ix',{type:'alliance',target:'t'}); game = act(game,'t',{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,'g').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);
|
|
assert.deepEqual(stock(game),original);
|
|
game = act(game,'g',{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,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;
|
|
}
|
|
|
|
for (const source of ['printed','nexus'] as const) void test(
|
|
`Basic native Ixian Nexus auction survives ${source} Kull success and original Nexus response`, () => {
|
|
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(', ')}`);
|
|
let game=act(f.game,'c',{type:'kullDecision',event:f.event,source,card:source==='printed'?f.printed:f.fuel});
|
|
game=passKullCounter(game);
|
|
assert.equal(game.pendingKull,null);
|
|
assert.equal(seat(game,'g').hand.some(card=>card.id===f.karama),true);
|
|
assert.equal(game.discard.filter(card=>card.id===(source==='printed'?f.printed:f.fuel)).length,1);
|
|
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 counter of [false,true]) void test(
|
|
`Basic native Ixian auction resumes original cancellation after Kull ${counter?'counter':'decline'}`, () => {
|
|
const f=fixture();
|
|
let game=counter ? act(f.game,'c',{type:'kullDecision',event:f.event,source:'nexus',card:f.fuel})
|
|
: act(f.game,'c',{type:'kullDecision',event:f.event,decline:true});
|
|
if (counter) game=act(game,'a',{type:'card',mode:'cancel',card:f.counter});
|
|
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,counter?null:'choam');
|
|
assert.deepEqual(stock(game),f.original);
|
|
});
|