Connect Semuta with Nexus Kull in Basic games
Verify and publish checkpoint container / container (push) Successful in 10m47s
Verify and publish checkpoint container / container (push) Successful in 10m47s
This commit is contained in:
Quintine committed
1 parent
d4cd03afff
commit
e697d7f558
13 files changed
+558
-24
No files matched your search
@@ -12,6 +12,7 @@ void test('Basic CHOAM and classic Nexus lobby receives the same public Kull def
|
||||
assert.deepEqual(kullDefaultProfile(lobby), { eligible: true, reason: null });
|
||||
assert.equal(kullDefaultEligible({ ...lobby, players: [{ faction: 'choam' }] }), true);
|
||||
assert.equal(kullDefaultEligible({ ...lobby, players: [{ faction: 'choam' }, { faction: 'ixians' }, { faction: 'tleilaxu' }] }), true);
|
||||
assert.equal(kullDefaultEligible({ ...lobby, players: [{ faction: 'choam' }, { faction: 'richese' }] }), true);
|
||||
// GameView carries Nexus selection as a public boolean instead of Game state.
|
||||
assert.equal(kullDefaultEligible({ ...lobby, nexusCards: undefined, lobbyModules: { nexusCards: true } }), true);
|
||||
// The host's explicit opt-out belongs to the caller, not the eligibility quote.
|
||||
@@ -23,7 +24,6 @@ void test('Nexus Kull default retains its native roster and module boundaries',
|
||||
const unsupported: Partial<KullDefaultProfile>[] = [
|
||||
{ advanced: true }, { status: 'playing' },
|
||||
{ expansions: ['choam'] }, { expansions: ['choam', 'ix', 'ecaz'] },
|
||||
{ players: [{ faction: 'choam' }, { faction: 'richese' }] },
|
||||
{ players: [{ faction: 'choam' }, { faction: 'atreides' }, { faction: 'atreides' }] },
|
||||
{ players: [{ faction: 'atreides' }, { faction: 'guild' }] },
|
||||
{ lobbyOptions: { leaderSkills: true } }, { lobbyOptions: { ecazTreachery: true } },
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import { kullDefaultEligible, kullDefaultProfile, type KullDefaultProfile } from '../game/kull-default-profile';
|
||||
|
||||
const lobby: KullDefaultProfile = {
|
||||
status: 'lobby', advanced: false, expansions: ['choam', 'ix'],
|
||||
players: [{ faction: 'choam' }, { faction: 'richese' }, { faction: 'atreides' }],
|
||||
nexusCards: { cards: null, phase: null },
|
||||
};
|
||||
|
||||
void test('Basic Nexus Kull public quote admits Richese with either or both native Ix factions', () => {
|
||||
for (const factions of [[], ['ixians'], ['tleilaxu'], ['ixians', 'tleilaxu']]) {
|
||||
const selected = { ...lobby, players: [...lobby.players, ...factions.map(faction => ({ faction }))] };
|
||||
assert.deepEqual(kullDefaultProfile(selected), { eligible: true, reason: null });
|
||||
assert.equal(kullDefaultEligible({ ...selected, nexusCards: undefined, lobbyModules: { nexusCards: true } }), true);
|
||||
}
|
||||
// Explicit host opt-out is handled by the lobby caller, not eligibility.
|
||||
const optedOut = { leaderSkills: false, kullOptOut: true };
|
||||
assert.equal(kullDefaultEligible({ ...lobby, lobbyOptions: optedOut }), true);
|
||||
});
|
||||
|
||||
void test('Richese Nexus Kull retains independent Basic roster and module guards', () => {
|
||||
const invalid: Partial<KullDefaultProfile>[] = [
|
||||
{ advanced: true }, { status: 'playing' }, { expansions: ['choam'] },
|
||||
{ expansions: ['choam', 'ix', 'ecaz'] },
|
||||
{ players: [{ faction: 'richese' }, { faction: 'atreides' }] },
|
||||
{ players: [{ faction: 'choam' }, { faction: 'richese' }, { faction: 'richese' }] },
|
||||
{ players: [{ faction: 'choam' }, { faction: 'richese' }, { faction: 'ecaz' }] },
|
||||
{ lobbyOptions: { leaderSkills: true } }, { lobbyOptions: { ecazTreachery: true } },
|
||||
{ lobbyModules: { nexusCards: true, discoveries: true } }, { homeworlds: {} },
|
||||
{ techTokens: {} }, { strongholdCards: {} }, { discoveryEnabled: true },
|
||||
];
|
||||
for (const variant of invalid) {
|
||||
const result = kullDefaultProfile({ ...lobby, ...variant });
|
||||
assert.equal(result.eligible, false, JSON.stringify(variant));
|
||||
assert.ok(result.reason, 'Unavailable lobbies need a readable reason');
|
||||
}
|
||||
});
|
||||
|
||||
void test('Richese Nexus Kull quote reads no player hand or spice', () => {
|
||||
const richese = { faction: 'richese', get hand() { throw Error('private hand read'); },
|
||||
get spice() { throw Error('private spice read'); } };
|
||||
assert.equal(kullDefaultEligible({ ...lobby, players: [{ faction: 'choam' }, richese] }), true);
|
||||
});
|
||||
@@ -47,10 +47,13 @@ void test('fresh admission accepts exactly native classic CHOAM, physical CHOAM/
|
||||
assert.deepEqual(initialized.spiceDeck.map(card => JSON.stringify(card)).sort(),
|
||||
spiceDeck(true).map(card => JSON.stringify(card)).sort());
|
||||
assert.equal(initialized.spiceDeck.filter(card => 'sandtrout' in card).length, 1);
|
||||
const withRichese = lobby();
|
||||
withRichese.players[1] = newPlayer('e', 'Richese', 'richese'); withRichese.players[1].ready = true;
|
||||
const joint = initializeNexusKullGameForAudit(withRichese);
|
||||
assert.equal(joint.semutaPreview, true);
|
||||
for (const corrupt of [
|
||||
(g: Game) => { g.expansions = ['choam']; },
|
||||
(g: Game) => { g.nexusCards = undefined; },
|
||||
(g: Game) => { g.players[1] = newPlayer('e', 'Richese', 'richese'); g.players[1].ready = true; },
|
||||
(g: Game) => { g.semutaPreview = true; },
|
||||
(g: Game) => { g.kullSequence = 1; },
|
||||
(g: Game) => { g.turn = 2; },
|
||||
|
||||
@@ -0,0 +1,182 @@
|
||||
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;
|
||||
}
|
||||
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 Ixian 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 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'],['r','richese'],['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.semutaPreview,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);
|
||||
const semuta = takeKullCard(game,SEMUTA_DRUG_ID); seat(game,'r').hand.push(semuta);
|
||||
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,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 claim of [false,true]) void test(
|
||||
`Basic Richese/Ixian Nexus auction survives Nexus Kull and Semuta ${claim?'claim':'pass'}`, () => {
|
||||
const source = 'nexus' as const;
|
||||
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 === 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: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.pendingTreacheryDiscard?.batch.entries[0].card.id,f.fuel);
|
||||
assert.equal(game.pendingTreacheryDiscard?.batch.entries[0].publicFace,false);
|
||||
game=semutaReaction(game,claim);
|
||||
assert.equal(seat(game,'r').hand.some(card=>card.id===f.fuel),claim);
|
||||
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 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);
|
||||
});
|
||||
@@ -0,0 +1,229 @@
|
||||
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 { advanceSemutaNexusTrade, swapSemutaNexusTradeIdentity } from './fixture-semuta-nexus-trade';
|
||||
import { beforeIxSpiceDraw, orderIxSpiceCards } from './fixture-ix-spice-cards';
|
||||
|
||||
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.phaseOpening && !game.response && !game.decision && !game.truthtrance && !game.pendingGuildBetrayal;
|
||||
function inventory(game: Game): string[] {
|
||||
const cards = [...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();
|
||||
assert.equal(new Set(cards).size, cards.length, 'Each original physical card has one location');
|
||||
return cards;
|
||||
}
|
||||
|
||||
/** Fresh public Basic setup and a genuinely earned CHOAM Nexus. Unopened
|
||||
* Spice order, the earned Nexus identity, original card custody and starting
|
||||
* board counters are staged without creating physical components. */
|
||||
function fixture() {
|
||||
let game = createGame('NEXKULLSEMUTA', newPlayer('c', 'CHOAM', 'choam'), false, ['ix', 'choam']);
|
||||
for (const [id, faction] of [['r','richese'], ['a','atreides'], ['g','guild'], ['h','harkonnen']] as const)
|
||||
joinGame(game, newPlayer(id, faction, faction));
|
||||
game = act(game, 'c', {type:'moduleOption', module:'nexusCards', enabled:true});
|
||||
for (const player of game.players) game = act(game, player.id, {type:'ready'});
|
||||
game = act(game, 'c', {type:'start'});
|
||||
assert.equal(game.semutaPreview, true); assert.equal(game.kullPreview, true); assert.equal(game.nexusKullPreview, true);
|
||||
game = advanceSemutaNexusTrade(game, state => state.status === 'playing');
|
||||
assert.ok(Object.values(game.nexusCards!.cards!.hands).every(card => card === null));
|
||||
const original = inventory(game);
|
||||
for (const player of game.players) {
|
||||
player.reserves += Object.values(player.forces).reduce((sum, amount) => sum + amount, 0); player.forces = {};
|
||||
if (player.elites) { player.elites.reserves += Object.values(player.elites.forces).reduce((sum, amount) => sum + amount, 0); player.elites.forces = {}; }
|
||||
}
|
||||
game = advanceSemutaNexusTrade(game, beforeIxSpiceDraw); orderIxSpiceCards(game, ['land','land']);
|
||||
game = advanceSemutaNexusTrade(game, state => state.turn === 2 && beforeIxSpiceDraw(state));
|
||||
orderIxSpiceCards(game, ['worm','land','land']);
|
||||
game = advanceSemutaNexusTrade(game, state => !!state.nexus && !state.spiceWindow && clean(state));
|
||||
game = act(game, 'a', {type:'alliance', target:'h'}); game = act(game, 'h', {type:'alliance', target:'a'});
|
||||
game = advanceSemutaNexusTrade(game, state => state.nexusCards?.phase?.stage === 'drawing' && clean(state));
|
||||
assert.ok(game.nexusCards!.phase!.eligible.includes('c'));
|
||||
game = act(game, 'c', {type:'nexusCardChoice', turn:game.turn, card:null, choice:'draw', ownRedraws:0});
|
||||
swapSemutaNexusTradeIdentity(game, 'c', 'choam');
|
||||
game = advanceSemutaNexusTrade(game, state => state.phase === 5 && state.active === 'g' && clean(state));
|
||||
assert.equal(game.nexusCards!.cards!.hands.c, 'choam');
|
||||
// Move only original cards; stage after prior CHOAM market actions finish.
|
||||
for (const player of game.players) game.deck.push(...player.hand.splice(0));
|
||||
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 originalKarama = takeKullCard(game, 'karama'); seat(game, 'g').hand.push(originalKarama);
|
||||
const counter = takeKullCard(game, 'karama'); seat(game, 'h').hand.push(counter);
|
||||
const semuta = takeKullCard(game, SEMUTA_DRUG_ID); seat(game, 'r').hand.push(semuta);
|
||||
assert.deepEqual(inventory(game), original);
|
||||
game = act(game, 'g', {type:'card', mode:'shipment', card:originalKarama.id, target:'g'});
|
||||
assert.equal(game.pendingKull?.stage, 'offer');
|
||||
return {game, original, printed:printed.id, fuel:fuel.id, karama:originalKarama.id, counter:counter.id, semuta:semuta.id, event:game.pendingKull!.event};
|
||||
}
|
||||
|
||||
function finishCounter(state: Game): Game {
|
||||
let game = state;
|
||||
for (let n = 0; game.pendingKull && n < 20; n++) {
|
||||
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);
|
||||
}
|
||||
assert.equal(game.pendingKull, null); return game;
|
||||
}
|
||||
|
||||
function passFreshEvent(state: Game): Game {
|
||||
let game = state;
|
||||
const event = game.pendingTreacheryDiscard?.batch.event; assert.ok(event);
|
||||
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 public Richese Nexus ${source} Kull success offers Semuta ${claim ? 'claim' : 'pass'}`, () => {
|
||||
const f = fixture(), cost = source === 'printed' ? f.printed : f.fuel;
|
||||
const controls = viewGame(f.game, 'c').kullReaction!;
|
||||
assert.ok(controls.plays.some(row => row.source === source && row.card.id === cost));
|
||||
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));
|
||||
}
|
||||
const startLog = f.game.log.length;
|
||||
let game = act(f.game, 'c', {type:'kullDecision', event:f.event, source, card:cost});
|
||||
game = finishCounter(game);
|
||||
const pending = game.pendingTreacheryDiscard; assert.ok(pending);
|
||||
assert.equal(pending.reaction?.stage, 'offer');
|
||||
assert.deepEqual(pending.batch.entries.map(entry => ({id:entry.card.id, discardedBy:entry.discardedBy, publicFace:entry.publicFace})),
|
||||
[{id:cost, discardedBy:'c', publicFace:source === 'printed'}]);
|
||||
assert.equal(game.karamaShipping, null); assert.ok(seat(game, 'g').hand.some(card => card.id === f.karama));
|
||||
assert.equal(game.nexusCards!.cards!.hands.c, source === 'printed' ? 'choam' : null);
|
||||
assert.equal(game.nexusCards!.cards!.discard.filter(card => card === 'choam').length, Number(source === 'nexus'));
|
||||
if (source === 'nexus') {
|
||||
assert.deepEqual(viewGame(game, 'r').semutaReaction!.candidates, []);
|
||||
assert.deepEqual(viewGame(game, 'g').semutaReaction!.candidates, []);
|
||||
assert.equal(game.log.slice(startLog).some(row => row.text.includes('Hunter-Seeker')), false);
|
||||
assert.equal(game.nexusChoamHistory!.at(-1)!.stage, 'complete');
|
||||
}
|
||||
assert.equal(viewGame(game, 'r').semutaReaction!.canCommit, true);
|
||||
const event = pending.batch.event;
|
||||
if (claim) {
|
||||
game = act(game, 'r', {type:'semutaCommit', event});
|
||||
if (game.pendingTreacheryDiscard?.reaction?.stage === 'select') {
|
||||
assert.deepEqual(viewGame(game, 'r').semutaReaction!.candidates.map(card => card.id), [cost]);
|
||||
assert.deepEqual(viewGame(game, 'g').semutaReaction!.candidates, []);
|
||||
game = act(game, 'r', {type:'semutaSelect', event, card:cost});
|
||||
}
|
||||
} 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.equal(game.pendingTreacheryDiscard, null); assert.equal(game.pendingKull, null);
|
||||
assert.equal(game.karamaShipping, null); assert.ok(seat(game, 'g').hand.some(card => card.id === f.karama));
|
||||
assert.ok(viewGame(game, 'g').karamaBlocked);
|
||||
assert.equal(seat(game, 'r').hand.some(card => card.id === cost), claim);
|
||||
assert.equal(game.discard.some(card => card.id === cost), !claim);
|
||||
assert.equal(game.discard.some(card => card.id === f.semuta), claim);
|
||||
assert.deepEqual(inventory(game), f.original);
|
||||
});
|
||||
|
||||
for (const source of ['printed','nexus'] as const) for (const claim of [false,true]) void test(
|
||||
`Basic public Richese Nexus ${source} Kull counter offers its distinct Karama to Semuta ${claim ? 'claim' : 'pass'}`, () => {
|
||||
const f = fixture(), cost = source === 'printed' ? f.printed : f.fuel;
|
||||
let game = act(f.game, 'c', {type:'kullDecision', event:f.event, source, card:cost});
|
||||
assert.ok(viewGame(game, 'h').responseControls?.cancelCards.includes(f.counter));
|
||||
game = act(game, 'h', {type:'card', mode:'cancel', card:f.counter});
|
||||
const pending = game.pendingTreacheryDiscard; assert.ok(pending);
|
||||
assert.equal(pending.reaction?.stage, 'offer');
|
||||
assert.deepEqual(pending.batch.entries.map(entry => ({id:entry.card.id, discardedBy:entry.discardedBy, publicFace:entry.publicFace})),
|
||||
[{id:f.counter, discardedBy:'h', publicFace:true}]);
|
||||
assert.ok(seat(game, 'c').hand.some(card => card.id === cost));
|
||||
assert.ok(seat(game, 'g').hand.some(card => card.id === f.karama));
|
||||
assert.equal(game.nexusCards!.cards!.hands.c, source === 'printed' ? 'choam' : null);
|
||||
const event = pending.batch.event;
|
||||
if (claim) {
|
||||
game = act(game, 'r', {type:'semutaCommit', event});
|
||||
if (game.pendingTreacheryDiscard?.reaction?.stage === 'select')
|
||||
game = act(game, 'r', {type:'semutaSelect', event, card:f.counter});
|
||||
} 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});
|
||||
}
|
||||
// The original allowed Karama is a distinct fresh public discard after the
|
||||
// counter's own batch; acknowledge it before checking shipment continuation.
|
||||
assert.notEqual(game.pendingTreacheryDiscard?.batch.event, event);
|
||||
assert.equal(game.pendingTreacheryDiscard?.batch.entries[0].card.id, f.karama);
|
||||
game = passFreshEvent(game);
|
||||
assert.equal(game.pendingTreacheryDiscard, null); assert.equal(game.pendingKull, null);
|
||||
assert.equal(game.karamaShipping?.owner, 'g');
|
||||
assert.ok(seat(game, 'c').hand.some(card => card.id === cost));
|
||||
assert.equal(seat(game, 'r').hand.some(card => card.id === f.counter), claim);
|
||||
assert.equal(game.discard.some(card => card.id === f.counter), !claim);
|
||||
assert.equal(game.discard.some(card => card.id === f.semuta), claim);
|
||||
assert.equal(game.nexusCards!.cards!.discard.filter(card => card === 'choam').length, Number(source === 'nexus'));
|
||||
assert.deepEqual(inventory(game), f.original);
|
||||
});
|
||||
|
||||
void test('Basic public Richese Nexus Kull may decline without spending its cards', () => {
|
||||
const f = fixture();
|
||||
let game = act(f.game, 'c', {type:'kullDecision', event:f.event, decline:true});
|
||||
assert.equal(game.pendingTreacheryDiscard?.batch.entries[0].card.id, f.karama);
|
||||
game = passFreshEvent(game);
|
||||
assert.equal(game.pendingKull, null); assert.equal(game.karamaShipping?.owner, 'g');
|
||||
assert.equal(game.nexusCards!.cards!.hands.c, 'choam');
|
||||
assert.ok(seat(game, 'c').hand.some(card => card.id === f.printed));
|
||||
assert.ok(seat(game, 'c').hand.some(card => card.id === f.fuel));
|
||||
assert.ok(seat(game, 'r').hand.some(card => card.id === f.semuta));
|
||||
assert.deepEqual(inventory(game), f.original);
|
||||
});
|
||||
|
||||
void test('Basic public Richese Nexus keeps Semuta when the host opts out of Kull', () => {
|
||||
let game = createGame('NEXKULLOPTOUT', newPlayer('c', 'CHOAM', 'choam'), false, ['ix', 'choam']);
|
||||
for (const [id, faction] of [['r','richese'], ['a','atreides'], ['g','guild'], ['h','harkonnen']] as const)
|
||||
joinGame(game, newPlayer(id, faction, faction));
|
||||
game = act(game, 'c', {type:'moduleOption', module:'nexusCards', enabled:true});
|
||||
game = act(game, 'c', {type:'moduleOption', module:'kullPreview', enabled:false});
|
||||
for (const player of game.players) game = act(game, player.id, {type:'ready'});
|
||||
game = act(game, 'c', {type:'start'});
|
||||
assert.equal(game.semutaPreview, true);
|
||||
assert.notEqual(game.kullPreview, true); assert.notEqual(game.nexusKullPreview, true);
|
||||
game = advanceSemutaNexusTrade(game, state => state.status === 'playing');
|
||||
const original = inventory(game);
|
||||
for (const player of game.players) {
|
||||
player.reserves += Object.values(player.forces).reduce((sum, amount) => sum + amount, 0); player.forces = {};
|
||||
if (player.elites) { player.elites.reserves += Object.values(player.elites.forces).reduce((sum, amount) => sum + amount, 0); player.elites.forces = {}; }
|
||||
}
|
||||
game = advanceSemutaNexusTrade(game, beforeIxSpiceDraw); orderIxSpiceCards(game, ['land','land']);
|
||||
game = advanceSemutaNexusTrade(game, state => state.phase === 5 && state.active === 'g' && clean(state));
|
||||
// Conserved original hand/deck/cache cards; Hajr and Semuta are used by
|
||||
// their real owners after public setup and the actual movement opening.
|
||||
for (const player of game.players) game.deck.push(...player.hand.splice(0));
|
||||
const hajr = takeKullCard(game, 'hajr'); seat(game, 'g').hand.push(hajr);
|
||||
const semuta = takeKullCard(game, SEMUTA_DRUG_ID); seat(game, 'r').hand.push(semuta);
|
||||
assert.deepEqual(inventory(game), original);
|
||||
const pending = act(game, 'g', {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]) {
|
||||
let resumed = structuredClone(pending);
|
||||
const event = pending.pendingTreacheryDiscard!.batch.event;
|
||||
if (claim) {
|
||||
resumed = act(resumed, 'r', {type:'semutaCommit', event});
|
||||
if (resumed.pendingTreacheryDiscard?.reaction?.stage === 'select')
|
||||
resumed = act(resumed, 'r', {type:'semutaSelect', event, card:hajr.id});
|
||||
} else resumed = passFreshEvent(resumed);
|
||||
assert.equal(resumed.pendingTreacheryDiscard, null);
|
||||
assert.ok(resumed.hajr.includes('g'));
|
||||
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(inventory(resumed), original);
|
||||
resumed = act(resumed, 'g', {type:'ship', territory:'polar_sink', sector:0, amount:1});
|
||||
assert.equal((seat(resumed, 'g').forces.polar_sink ?? 0) + (seat(resumed, 'g').forces['polar_sink:0'] ?? 0), 1);
|
||||
}
|
||||
});
|
||||
Reference in new issue
Block a user