Support Advanced No-Field reveal interruptions
Verify and publish checkpoint container / container (push) Successful in 11m29s

This commit is contained in:
Quintine committed 2026-11-16 18:00:57 +11:00
1 parent 5e7f7b45e4
commit ee8ec0a84e
11 files changed
+607 -4

No files matched your search

@@ -0,0 +1,172 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import { botActions } from '../game/bots';
import { DIFFICULTIES } from '../game/bot-profiles';
import { createGame, joinGame, newPlayer, viewGame, type Action, type Game } from '../game/engine';
import { actTruthMovementNativeEarly as act, nextTruthMovementNativeEarlyStep } from './fixture-truth-movement-native-early';
import { truthMovementInventory as inventory } from './fixture-truth-movement';
const richese = 'richese', choam = 'choam', atreides = 'atreides';
function seat(g: Game, id: string) {
const p = g.players.find(row => row.id === id); assert.ok(p); return p;
}
const clean = (g: Game) => !g.response && !g.decision && !g.phaseOpening &&
!g.truthtrance && !g.pendingRevival && !g.pendingTreacheryDiscard;
function step(g: Game) {
if (g.turn === 1 && g.phase === 5 && g.active === richese && clean(g)) {
const p = seat(g, richese);
if (!p.shipped) {
const token = p.noField!.tokens.find(row => row.value === 3); assert.ok(token);
return {actor:richese, action:{type:'ship', noField:token.id, event:p.noFieldEvent,
territory:'polar_sink', sector:0, allyPayment:0} satisfies Action};
}
return {actor:richese, action:{type:'endMovement'} satisfies Action};
}
if (g.phase === 5 && g.active && clean(g))
return {actor:g.active, action:{type:'endMovement'} satisfies Action};
return nextTruthMovementNativeEarlyStep(g, {position:'first', method:'onceAround', direction:'clockwise'});
}
function reach(g: Game, until: (state: Game) => boolean): Game {
for (let i = 0; i < 2000; i++) {
if (until(g)) return g;
assert.notEqual(g.status, 'finished');
const next = step(g); assert.ok(next, `Supply a native action at ${g.turn}/${g.phase}/${g.decision?.kind}`);
g = act(g, next.actor, next.action);
}
throw Error('Native game did not reach its Revival control');
}
/** Genuine public Advanced preview, real paid marker shipment and ordered next-turn Revival.
* Only the original unopened Spice order, Worthless card location and selected
* recipient's physical casualty count are staged; each inventory is conserved. */
function source(recipient: string, oneReserve = false) {
let g = createGame('RICHESECHOAMREVIVAL', newPlayer(richese, 'Richese', 'richese'), true, ['choam']);
joinGame(g, newPlayer(choam, 'CHOAM', 'choam'));
joinGame(g, newPlayer(atreides, 'Atreides', 'atreides'));
for (const p of g.players) g = act(g, p.id, {type:'ready'});
g = act(g, g.host, {type:'start', advancedPreview:true});
g = reach(g, state => state.status === 'playing');
for (const position of [0, 1, 2, 3]) {
const from = g.spiceDeck.findIndex((card, index) => index >= position && 'territory' in card && !card.discovery);
assert.ok(from >= position);
[g.spiceDeck[position], g.spiceDeck[from]] = [g.spiceDeck[from], g.spiceDeck[position]];
}
g = reach(g, state => state.turn === 2 && state.phase === 4 && clean(state) && state.revivalOrder?.remaining[0] === recipient);
const owner = seat(g, richese), marker = owner.noField?.deployed, event = owner.noFieldEvent;
assert.ok(marker); assert.ok(event);
const p = seat(g, recipient); assert.ok(p.reserves >= 3);
p.reserves -= 3; p.tanks += 3;
if (oneReserve) {
assert.equal(recipient, richese); assert.ok(p.reserves > 1);
const staged = p.reserves - 1;
p.reserves -= staged;
p.forces['polar_sink:0'] = (p.forces['polar_sink:0'] ?? 0) + staged;
}
const physical = inventory(g);
const c = seat(g, choam);
if (!c.hand.some(card => card.name === 'La La La')) {
let card = g.deck.findIndex(row => row.name === 'La La La');
if (card >= 0) c.hand.push(g.deck.splice(card, 1)[0]);
else {
const holder = g.players.find(row => row.hand.some(held => held.name === 'La La La'));
if (holder) {
card = holder.hand.findIndex(held => held.name === 'La La La');
c.hand.push(holder.hand.splice(card, 1)[0]);
} else {
card = g.discard.findIndex(held => held.name === 'La La La'); assert.ok(card >= 0);
c.hand.push(g.discard.splice(card, 1)[0]);
}
}
}
assert.deepEqual(inventory(g), physical);
g = act(g, recipient, {type:'revive', amount:2, elite:0});
assert.ok(g.decision?.kind === 'choamFreeRevival');
assert.equal(g.decision.player, choam);
assert.equal(g.decision.recipient, recipient);
assert.equal(g.pendingRevival?.player, recipient);
return {g, token:marker.tokenId, event, physical};
}
for (const recipient of [richese, atreides]) for (const deny of [false, true]) void test(
`Advanced Richese reveal preserves ${recipient}'s ordered free Revival while CHOAM ${deny ? 'plays La La La' : 'allows'}`, () => {
const {g, token, event, physical} = source(recipient), before = structuredClone(g);
const reserves = seat(g, richese).reserves, field = seat(g, richese).forces['polar_sink:0'] ?? 0;
const tanks = seat(g, recipient).tanks, revived = seat(g, recipient).revived;
assert.equal(viewGame(g, richese).richeseNoField?.canReveal, true);
let next = act(g, richese, {type:'revealNoField', token, event});
assert.deepEqual(g, before);
assert.deepEqual(next.decision, before.decision);
assert.deepEqual(next.pendingRevival, before.pendingRevival);
assert.deepEqual(next.revivalOrder, before.revivalOrder);
assert.equal(seat(next, richese).noField?.deployed, null);
assert.equal(seat(next, richese).reserves, reserves - 3);
assert.equal(seat(next, richese).forces['polar_sink:0'], field + 3);
assert.equal(seat(next, recipient).tanks, tanks);
if (deny) {
const card = seat(next, choam).hand.find(row => row.name === 'La La La'); assert.ok(card);
next = act(next, choam, {type:'card', mode:'choam', card:card.id});
} else next = act(next, choam, {type:'decision', decline:true});
for (let i = 0; (next.response || next.pendingTreacheryDiscard) && i < 40; i++) {
if (next.pendingTreacheryDiscard?.reaction) {
const reaction = next.pendingTreacheryDiscard.reaction;
assert.ok(reaction.stage === 'offer');
const p = next.players.find(row => !reaction.passed.includes(row.id)); assert.ok(p);
next = act(next, p.id, {type:'semutaPass', event:next.pendingTreacheryDiscard.batch.event});
} else if (next.response) {
const p = next.players.find(row => !next.response!.passed.includes(row.id)); assert.ok(p);
next = act(next, p.id, {type:'passResponse'});
} else break;
}
assert.equal(next.pendingRevival, null);
assert.equal(next.revivalOrder?.remaining[0], recipient);
assert.equal(seat(next, recipient).tanks, tanks - (deny ? 0 : 2));
assert.equal(seat(next, recipient).revived, revived + (deny ? 0 : 2));
assert.equal(seat(next, richese).forces['polar_sink:0'], field + 3);
assert.deepEqual(inventory(next), physical);
},
);
void test('Advanced three-marker uses the one current reserve before the pending free return adds two', () => {
const {g, token, event, physical} = source(richese, true), before = seat(g, richese);
const field = before.forces['polar_sink:0'] ?? 0, tanks = before.tanks, revived = before.revived;
const forceCount = (game: Game) => {
const player = seat(game, richese);
return player.reserves + player.tanks + Object.values(player.forces).reduce((sum, n) => sum + n, 0);
};
assert.equal(before.reserves, 1);
assert.equal(forceCount(g), 20);
const pending = structuredClone(g.pendingRevival);
let next = act(g, richese, {type:'revealNoField', token, event});
assert.equal(seat(next, richese).reserves, 0);
assert.equal(seat(next, richese).forces['polar_sink:0'], field + 1);
assert.equal(seat(next, richese).tanks, tanks);
assert.deepEqual(next.pendingRevival, pending);
assert.equal(forceCount(next), 20);
next = act(next, choam, {type:'decision', decline:true});
assert.equal(next.pendingRevival, null);
assert.equal(seat(next, richese).reserves, 2);
assert.equal(seat(next, richese).tanks, tanks - 2);
assert.equal(seat(next, richese).revived, revived + 2);
assert.equal(seat(next, richese).forces['polar_sink:0'], field + 1);
assert.equal(forceCount(next), 20);
assert.deepEqual(inventory(next), physical);
});
void test('Advanced CHOAM La La La preserves completed Revival turns without a No-Field reveal', () => {
const {g} = source(atreides), before = structuredClone(g.revivalOrder);
assert.ok(g.ready.length > 0, 'The ordered phase already has completed factions');
const card = seat(g, choam).hand.find(row => row.name === 'La La La'); assert.ok(card);
const next = act(g, choam, {type:'card', mode:'choam', card:card.id});
assert.deepEqual(next.revivalOrder, before);
assert.deepEqual(next.ready, g.ready);
});
void test('all bot profiles can respond to the original Advanced CHOAM decision after a voluntary reveal', () => {
const {g, token, event} = source(atreides);
const revealed = act(g, richese, {type:'revealNoField', token, event});
for (const difficulty of DIFFICULTIES) {
const view = viewGame(revealed, choam); view.players.find(p => p.id === choam)!.bot = difficulty;
const action = botActions(view)[0]; assert.ok(action, difficulty);
assert.doesNotThrow(() => act(revealed, choam, action), difficulty);
}
});
@@ -0,0 +1,110 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import {readFileSync} from 'node:fs';
import {runInNewContext} from 'node:vm';
import {createElement, isValidElement, type ReactElement, type ReactNode} from 'react';
import {renderToStaticMarkup} from 'react-dom/server';
import * as jsxRuntime from 'react/jsx-runtime';
import ts from 'typescript';
import {RicheseNoFieldControls} from '../components/richese-no-field';
import {applyAction, createGame, joinGame, newPlayer, viewGame, type Action, type Game, type GameView} from '../game/engine';
import * as catalog from '../game/catalog';
import * as board from '../game/board';
import * as advisors from '../game/advisors';
import * as shipmentPrice from '../game/shipment-price';
import * as noField from '../game/richese-no-field';
import * as homeworldCards from '../game/homeworld-cards';
import * as smuggler from '../game/smuggler-no-field';
import * as homeworldShipment from '../game/richese-homeworld-shipment';
import {actTruthMovementNativeEarly as act, nextTruthMovementNativeEarlyStep} from './fixture-truth-movement-native-early';
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&&!game.truthtrance&&!game.pendingTreacheryDiscard;
function reach(game:Game,until:(state:Game)=>boolean):Game {
for(let n=0;n<2400;n++) {
if(until(game))return game;
assert.notEqual(game.status,'finished');
const step=nextTruthMovementNativeEarlyStep(game,{position:'first',method:'onceAround',direction:'clockwise',keepUnbid:false});
assert.ok(step,`Missing native action at ${game.turn}/${game.phase}/${game.decision?.kind}`);
game=act(game,step.actor,step.action);
}
throw Error('Advanced No-Field control source did not reach its economic decision');
}
/** Real public Advanced setup and paid original No-Field shipment; only
* unopened starting/Spice order and conserved initial board counters staged. */
function fixture() {
let game=createGame('ADVREVEALCONTROL',newPlayer('richese','Richese','richese'),true,['choam','ix']);
joinGame(game,newPlayer('atreides','Atreides','atreides'));
joinGame(game,newPlayer('choam','CHOAM','choam'));
for(const player of game.players)game=act(game,player.id,{type:'ready'});
game=act(game,'richese',{type:'start',advancedPreview:true});
const cards=game.deck.filter(card=>['projectile','poison','shield','snooper'].includes(card.kind)).slice(0,3);
assert.equal(cards.length,3);
for(const [position,card] of cards.entries()) {
const from=game.deck.findIndex(candidate=>candidate.id===card.id);assert.ok(from>=position);
[game.deck[position],game.deck[from]]=[game.deck[from],game.deck[position]];
}
game=reach(game,state=>state.status==='playing');
for(const player of game.players) {
player.reserves+=Object.values(player.forces).reduce((sum,n)=>sum+n,0);player.forces={};
}
for(const position of [0,1,2,3]) {
const from=game.spiceDeck.findIndex((card,index)=>index>=position&&'territory' in card&&!card.discovery);
assert.ok(from>=position);[game.spiceDeck[position],game.spiceDeck[from]]=[game.spiceDeck[from],game.spiceDeck[position]];
}
game=reach(game,state=>state.turn===1&&state.phase===5&&state.active==='richese'&&clean(state));
const token=seat(game,'richese').noField!.tokens.find(row=>row.value===3);assert.ok(token);
const event=seat(game,'richese').noFieldEvent;assert.ok(event);
game=act(game,'richese',{type:'ship',noField:token.id,event,territory:'polar_sink',sector:0,allyPayment:0});
game=reach(game,clean);game=act(game,'richese',{type:'endMovement'});
game=reach(game,state=>state.turn===2&&state.decision?.kind==='richeseDeclaration'&&!state.response&&!state.phaseOpening);
assert.equal(seat(game,'richese').noField?.deployed?.tokenId,token.id);
return {game,token:token.id};
}
type Element=ReactElement<{children?:ReactNode;[key:string]:unknown}>;
function elements(node:ReactNode):Element[] {
if(Array.isArray(node))return node.flatMap(elements);
if(!isValidElement<{children?:ReactNode;[key:string]:unknown}>(node))return [];
return [node,...elements(node.props.children)];
}
const props=(game:GameView,busy:boolean,act:(action:Action)=>void)=>
({game,busy,act,destination:'arrakeen',sector:10,allyPayment:''});
/** Invoke the real component using deterministic hooks so its click callback
* is exercised against the actual Advanced engine projection. */
function controls(game:GameView,busy:boolean,sent:Action[]) {
const exports:{RicheseNoFieldControls?:typeof RicheseNoFieldControls}={};
const code=ts.transpileModule(readFileSync(new URL('../components/richese-no-field.tsx',import.meta.url),'utf8'),{
compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2022,jsx:ts.JsxEmit.ReactJSX},
}).outputText;
runInNewContext(code,{exports,require(name:string){
const modules:Record<string,unknown>={
'react/jsx-runtime':jsxRuntime,react:{useId:()=> 'fixture',useState:(initial:unknown)=>[initial,()=>{}]},
'@/game/catalog':catalog,'@/game/board':board,'@/game/advisors':advisors,'@/game/shipment-price':shipmentPrice,
'@/game/richese-no-field':noField,'@/game/homeworld-cards':homeworldCards,'@/game/smuggler-no-field':smuggler,
'@/game/richese-homeworld-shipment':homeworldShipment,'./richese-homeworld-forces':{},'./shipment-quote':{},
'./ui/button':{Button:'button'},
};
if(!(name in modules))throw Error(`Unexpected component import ${name}`);
return modules[name];
}});
assert.ok(exports.RicheseNoFieldControls);
return elements(exports.RicheseNoFieldControls(props(game,busy,action=>sent.push(action))));
}
void test('real Advanced economic decision shows an owner-only reveal and its click performs the original action',()=>{
const f=fixture(),view=viewGame(f.game,'richese'),observer=viewGame(f.game,'atreides'),sent:Action[]=[];
assert.equal(f.game.decision?.kind,'richeseDeclaration');assert.equal(view.richeseNoField?.canReveal,true);
assert.equal(observer.richeseNoField?.private,null);
assert.match(renderToStaticMarkup(createElement(RicheseNoFieldControls,props(view,false,()=>{}))),/Reveal your No-Field/);
assert.equal(renderToStaticMarkup(createElement(RicheseNoFieldControls,props(observer,false,()=>{}))),'');
const button=controls(view,false,sent).find(element=>element.type==='button'&&element.props.children==='Reveal your No-Field');
assert.ok(button);assert.equal(button.props.disabled,false);(button.props.onClick as ()=>void)();
assert.deepEqual(JSON.parse(JSON.stringify(sent)),[{type:'revealNoField',event:view.richeseNoField!.event,token:f.token}]);
const parent=structuredClone(f.game.decision),after=applyAction(f.game,'richese',sent[0]);
assert.deepEqual(after.decision,parent);assert.equal(seat(after,'richese').forces['polar_sink:0'],3);
const busySent:Action[]=[];
const busyButton=controls(view,true,busySent).find(element=>element.type==='button'&&element.props.children==='Reveal your No-Field');
assert.ok(busyButton);assert.equal(busyButton.props.disabled,true);(busyButton.props.onClick as ()=>void)();
assert.deepEqual(busySent,[]);
});
@@ -0,0 +1,120 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import {applyAction, createGame, joinGame, newPlayer, viewGame, type Game} from '../game/engine';
import {botActions} from '../game/bots';
import {DIFFICULTIES} from '../game/bot-profiles';
import {actTruthMovementNativeEarly as act, nextTruthMovementNativeEarlyStep} from './fixture-truth-movement-native-early';
const owner='richese', observer='atreides', choam='choam';
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&&!game.truthtrance&&!game.pendingTreacheryDiscard;
function next(game:Game) {
return nextTruthMovementNativeEarlyStep(game,{position:'first',method:'onceAround',direction:'clockwise',keepUnbid:false});
}
function reach(game:Game,until:(state:Game)=>boolean):Game {
for(let count=0;count<2400;count++) {
if(until(game))return game;
assert.notEqual(game.status,'finished','Original Advanced game must reach its next requested window');
const step=next(game);assert.ok(step,`Missing native action at ${game.turn}/${game.phase}/${game.decision?.kind}`);
game=act(game,step.actor,step.action);
}
throw Error('Advanced native reveal programme did not reach its window');
}
/** Real public Advanced setup and paid No-Field shipment before turn two.
* Only unopened starting/Spice order and conserved board positions are staged;
* the auction-specific branch additionally stages its purse and Karama card. */
function source() {
let game=createGame('ADVREVEALECON',newPlayer(owner,'Richese','richese'),true,['choam','ix']);
joinGame(game,newPlayer(observer,'Atreides','atreides'));
joinGame(game,newPlayer(choam,'CHOAM','choam'));
for(const player of game.players)game=act(game,player.id,{type:'ready'});
game=act(game,owner,{type:'start',advancedPreview:true});
const ordinary=game.deck.filter(card=>['projectile','poison','shield','snooper'].includes(card.kind)).slice(0,3);
assert.equal(ordinary.length,3);
for(const [position,card] of ordinary.entries()) {
const from=game.deck.findIndex(candidate=>candidate.id===card.id);assert.ok(from>=position);
[game.deck[position],game.deck[from]]=[game.deck[from],game.deck[position]];
}
game=reach(game,state=>state.status==='playing');
for(const player of game.players) {
player.reserves+=Object.values(player.forces).reduce((sum,n)=>sum+n,0);
player.forces={};
}
for(const position of [0,1,2,3]) {
const from=game.spiceDeck.findIndex((card,index)=>index>=position&&'territory' in card&&!card.discovery);
assert.ok(from>=position);
[game.spiceDeck[position],game.spiceDeck[from]]=[game.spiceDeck[from],game.spiceDeck[position]];
}
game=reach(game,state=>state.turn===1&&state.phase===5&&state.active===owner&&clean(state));
const token=seat(game,owner).noField!.tokens.find(row=>row.value===3);assert.ok(token);
const event=seat(game,owner).noFieldEvent;assert.ok(event);
game=act(game,owner,{type:'ship',noField:token.id,event,territory:'polar_sink',sector:0,allyPayment:0});
game=reach(game,clean);
assert.equal(seat(game,owner).noField?.deployed?.tokenId,token.id);
game=act(game,owner,{type:'endMovement'});
game=reach(game,state=>state.turn===2&&state.phase===0&&!!state.phaseOpening&&!state.response&&!state.decision);
const revealEvent=seat(game,owner).noFieldEvent;assert.ok(revealEvent);
return {game,token:token.id,event:revealEvent};
}
let cached:ReturnType<typeof source>|undefined;
const fixture=()=>{const f=cached??=source();return {...f,game:structuredClone(f.game)};};
function reveal(game:Game,token:string,event:string) {
assert.equal(viewGame(game,owner).richeseNoField?.canReveal,true);
const before=structuredClone(game), next=applyAction(game,owner,{type:'revealNoField',token,event});
assert.equal(seat(next,owner).reserves,seat(before,owner).reserves-3);
assert.equal(seat(next,owner).forces['polar_sink:0'],(seat(before,owner).forces['polar_sink:0']??0)+3);
assert.equal(seat(next,owner).noField?.deployed,null);
assert.notEqual(seat(next,owner).noFieldEvent,event);
assert.throws(()=>applyAction(next,owner,{type:'revealNoField',token,event}));
return next;
}
void test('Advanced Ix opening preserves existing passes through a real voluntary No-Field reveal',()=>{
const f=fixture();let game=act(f.game,owner,{type:'ready'});
const opening=structuredClone(game.phaseOpening);assert.ok(opening?.passed.includes(owner));
game=reveal(game,f.token,f.event);
assert.deepEqual(game.phaseOpening,opening);assert.equal(game.turn,f.game.turn);assert.equal(game.phase,f.game.phase);
game=reach(game,state=>!state.phaseOpening);
assert.equal(seat(game,owner).forces['polar_sink:0'],3);
});
for(const kind of ['choamMarket','richeseDeclaration','richeseCache','richeseUnbid'] as const) void test(
`Advanced ${kind} preserves its original economic decision through a No-Field reveal`,()=>{
const f=fixture();
const before=reach(f.game,state=>state.turn===2&&state.decision?.kind===kind&&!state.response&&!state.phaseOpening);
const parent=structuredClone(before.decision),market=structuredClone(before.choamMarket??null),
bidding=structuredClone(before.richeseBidding??null),auction=structuredClone(before.auction??null);
let game=reveal(before,f.token,f.event);
assert.deepEqual(game.decision,parent);assert.deepEqual(game.choamMarket??null,market);
assert.deepEqual(game.richeseBidding??null,bidding);assert.deepEqual(game.auction??null,auction);
const step=next(game);assert.ok(step);assert.equal(step.actor,parent!.player);
if(kind==='richeseDeclaration')for(const difficulty of DIFFICULTIES) {
const view=viewGame(game,step.actor);view.players.find(player=>player.id===step.actor)!.bot=difficulty;
const choice=botActions(view).find(action=>action.type==='decision');assert.ok(choice,difficulty);
assert.doesNotThrow(()=>applyAction(game,step.actor,choice),difficulty);
}
game=act(game,step.actor,step.action);
assert.notDeepEqual(game.decision,parent);assert.equal(seat(game,owner).forces['polar_sink:0'],3);
});
void test('Advanced normal auction payment retains its paid lot and buyer decision through reveal',()=>{
const f=fixture();let game=reach(f.game,state=>state.turn===2&&state.phase===3&&!!state.auction&&clean(state));
// Ensure space for the real purchased card and a real Karama payment option.
for(const player of game.players)game.deck.push(...player.hand.splice(0));
const counter=game.deck.findIndex(card=>card.effect==='karama');assert.ok(counter>=0);
seat(game,observer).hand.push(...game.deck.splice(counter,1));seat(game,observer).spice=6;
while(game.auction!.active!==observer)game=act(game,game.auction!.active,{type:'passBid'});
const card=game.auction!.cards[game.auction!.index].id;
game=act(game,observer,{type:'bid',amount:3});
for(let n=0;game.auction&&!game.response&&!game.decision&&n<15;n++)game=act(game,game.auction.active,{type:'passBid'});
assert.equal(game.decision?.kind,'auctionPayment');
const parent=structuredClone(game.decision),auction=structuredClone(game.auction),aid=structuredClone(game.aid);
game=reveal(game,f.token,f.event);
assert.deepEqual(game.decision,parent);assert.deepEqual(game.auction,auction);assert.deepEqual(game.aid,aid);
game=act(game,observer,{type:'decision',karama:false});
while(game.response) {
const actor=game.players.find(player=>!game.response!.passed.includes(player.id));assert.ok(actor);
game=act(game,actor.id,{type:'passResponse'});
}
assert.ok(seat(game,observer).hand.some(row=>row.id===card));
});
@@ -0,0 +1,145 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import {applyAction, createGame, joinGame, newPlayer, viewGame, type Action, type Game} from '../game/engine';
import {botActions} from '../game/bots';
import {DIFFICULTIES} from '../game/bot-profiles';
import {territory} from '../game/board';
import {actTruthMovementNativeEarly as act, nextTruthMovementNativeEarlyStep} from './fixture-truth-movement-native-early';
import {truthMovementInventory as inventory} from './fixture-truth-movement';
import {beforeIxSpiceDraw, orderIxSpiceCards} from './fixture-ix-spice-cards';
const seat=(game:Game,id:string)=>{const player=game.players.find(row=>row.id===id);assert.ok(player);return player;};
const quiet=(game:Game)=>!game.response&&!game.decision&&!game.phaseOpening&&!game.truthtrance&&!game.pendingTreacheryDiscard;
function next(game:Game) {
if(game.decision?.kind==='richeseAllyOpportunity')
return {actor:game.decision.player,action:{type:'decision',decline:true} satisfies Action};
if(game.phase===5 && game.active && quiet(game)) {
const player=seat(game,game.active);
if(game.turn===1 && player.id==='richese' && !player.shipped) {
const token=player.noField!.tokens.find(row=>row.value===3);assert.ok(token&&player.noFieldEvent);
return {actor:player.id,action:{type:'ship',noField:token.id,event:player.noFieldEvent,
territory:'polar_sink',sector:0,allyPayment:0} satisfies Action};
}
return {actor:player.id,action:{type:'endMovement'} satisfies Action};
}
return nextTruthMovementNativeEarlyStep(game,{position:'first',method:'onceAround',direction:'clockwise',keepUnbid:false});
}
function reach(game:Game,until:(game:Game)=>boolean):Game {
for(let i=0;i<2500;i++) {
if(until(game)) return game;
assert.notEqual(game.status,'finished');
const step=next(game);assert.ok(step,`No native continuation at ${game.turn}/${game.phase}/${game.decision?.kind}`);
game=act(game,step.actor,step.action);
}
throw Error('Native Advanced response was not reached');
}
/** Genuine public Advanced four/five-seat start, actual paid first-turn marker,
* second-turn worm and reciprocal Emperor/Richese alliance. The unopened Spice
* order and two original Karamas' physical custody are staged. */
function base(withGuild=true) {
let game=createGame('ADVREVEALNATIVE',newPlayer('richese','Richese','richese'),true,['choam','ix']);
for(const id of ['tleilaxu','atreides','emperor',...(withGuild?['guild' as const]:[])] as const)joinGame(game,newPlayer(id,id,id));
for(const player of game.players)game=act(game,player.id,{type:'ready'});
game=act(game,game.host,{type:'start',advancedPreview:true});
game=reach(game,state=>state.status==='playing');
const cards=inventory(game);
for(const id of ['atreides','emperor'] as const) {
const recipient=seat(game,id);
if(recipient.hand.some(card=>card.effect==='karama')) continue;
const source=game.players.find(player=>!['atreides','emperor'].includes(player.id)&&player.hand.some(card=>card.effect==='karama'))?.hand??game.deck;
const index=source.findIndex(card=>card.effect==='karama');assert.ok(index>=0);
const [card]=source.splice(index,1);
if(recipient.hand.length>=4)source.push(recipient.hand.pop()!);
recipient.hand.push(card);
}
assert.deepEqual(inventory(game),cards);
game=reach(game,beforeIxSpiceDraw);orderIxSpiceCards(game,['land','land']);
game=reach(game,state=>state.turn===2&&beforeIxSpiceDraw(state));
assert.ok(seat(game,'richese').noField?.deployed,'The native first-turn shipment must have occurred');
orderIxSpiceCards(game,['worm','land','land']);
game=reach(game,state=>!!state.nexus&&!state.spiceWindow&&quiet(state));
game=act(game,'richese',{type:'alliance',target:'emperor'});
game=act(game,'emperor',{type:'alliance',target:'richese'});
assert.equal(seat(game,'richese').ally,'emperor');assert.equal(seat(game,'emperor').ally,'richese');
return {game,cards};
}
function reveal(before:Game) {
const owner=seat(before,'richese'), token=owner.noField?.deployed?.tokenId, event=owner.noFieldEvent;
assert.ok(token&&event);assert.equal(viewGame(before,'richese').richeseNoField?.canReveal,true);
const old=structuredClone(before),response=structuredClone(before.response);
const after=act(before,'richese',{type:'revealNoField',token,event});
assert.deepEqual(after.response,response);assert.deepEqual(after.decision,old.decision);
assert.equal(seat(after,'richese').reserves,seat(old,'richese').reserves-3);
assert.equal(seat(after,'richese').forces['polar_sink:0'],(seat(old,'richese').forces['polar_sink:0']??0)+3);
assert.deepEqual(inventory(after),inventory(old));
return after;
}
function passCurrent(game:Game,kind:string) {
for(let i=0;game.response?.kind===kind&&i<15;i++) {
const actor=game.players.find(player=>!game.response!.passed.includes(player.id));assert.ok(actor);
game=act(game,actor.id,{type:'passResponse'});
}
assert.notEqual(game.response?.kind,kind);return game;
}
void test('Advanced reveal preserves Atreides auction inspection and its original response',()=>{
let {game}=base();
game=reach(game,state=>state.turn===2&&state.phase===3&&state.response?.kind==='atreidesAuction'&&!!state.auction);
const cards=structuredClone(game.auction),old=structuredClone(game.response);
game=act(game,'richese',{type:'passResponse'});assert.equal(game.response?.kind,'atreidesAuction');
const before=structuredClone(game),after=reveal(game);
assert.notDeepEqual(old,after.response);assert.deepEqual(after.response,before.response);assert.deepEqual(after.auction,cards);
const continued=passCurrent(after,'atreidesAuction');
assert.ok(continued.auction);assert.deepEqual(continued.auction.cards,cards!.cards);
});
void test('Advanced reveal preserves the original Atreides Spice forecast and bot responses',()=>{
let {game}=base();
game=reach(game,state=>state.turn===2&&state.phase===5&&state.response?.kind==='atreidesSpice');
game=act(game,'richese',{type:'passResponse'});assert.equal(game.response?.kind,'atreidesSpice');
const before=structuredClone(game),after=reveal(game);
assert.deepEqual(after.spiceDeck,before.spiceDeck);
for(const difficulty of DIFFICULTIES) {
const view=viewGame(after,'emperor');view.players.find(player=>player.id==='emperor')!.bot=difficulty;
const choice=botActions(view).find(action=>action.type==='passResponse'||action.type==='card'&&action.mode==='cancel');
assert.ok(choice,difficulty);assert.doesNotThrow(()=>applyAction(after,'emperor',choice));
}
const continued=passCurrent(after,'atreidesSpice');
assert.deepEqual(continued.spiceDeck,before.spiceDeck);assert.equal(continued.spicePeekKnown,true);
});
void test('Advanced reveal preserves the original Emperor gift and transfers spice only once',()=>{
let {game}=base();
game=reach(game,state=>state.turn===2&&state.phase===5&&state.active==='emperor'&&quiet(state));
const emperor=seat(game,'emperor').spice,richese=seat(game,'richese').spice;
game=act(game,'emperor',{type:'emperorGift',amount:1});assert.equal(game.response?.kind,'emperorGift');
game=act(game,'richese',{type:'passResponse'});const after=reveal(game);
const continued=passCurrent(after,'emperorGift');
assert.equal(seat(continued,'emperor').spice,emperor-1);assert.equal(seat(continued,'richese').spice,richese+1);
});
void test('Advanced reveal after a real free revival preserves Tleilaxu income and ordered Revival',()=>{
let {game}=base();
game=reach(game,state=>state.turn===2&&state.phase===4&&quiet(state)&&state.revivalOrder?.remaining[0]==='richese');
// Staged casualties retain all physical counters; the actual return is native.
const owner=seat(game,'richese');assert.ok(owner.reserves>=3);owner.reserves-=3;owner.tanks+=3;
game=act(game,'richese',{type:'revive',amount:2,elite:0});
if(game.decision?.kind==='revivalStop')game=act(game,'tleilaxu',{type:'decision',decline:true});
assert.equal(game.response?.kind,'revivalIncome');assert.equal(game.response.owner,'tleilaxu');
const before=structuredClone(game),income=seat(game,'tleilaxu').spice,after=reveal(game);
assert.deepEqual(after.revivalOrder,before.revivalOrder);assert.equal(seat(after,'richese').tanks,seat(before,'richese').tanks);
const continued=passCurrent(after,'revivalIncome');
assert.equal(seat(continued,'tleilaxu').spice,income+1);
});
void test('Advanced reveal preserves the original Guild reserve rate and paid shipment',()=>{
let {game}=base();
game=reach(game,state=>state.turn===2&&state.phase===5&&state.active==='guild'&&quiet(state));
const sector=territory('arrakeen').sectors.find(value=>value!==game.storm);assert.notEqual(sector,undefined);
game=act(game,'guild',{type:'ship',territory:'arrakeen',sector,amount:2,allyPayment:0});
if(game.decision?.kind==='guildShipment')game=act(game,'guild',{type:'decision',allow:true});
assert.equal(game.response?.kind,'guildRate');const shipment=structuredClone(game.pendingShipment);
const after=reveal(game);assert.deepEqual(after.pendingShipment,shipment);
const continued=passCurrent(after,'guildRate');
assert.equal(continued.pendingShipment??null,null);assert.equal(seat(continued,'guild').shipped,true);
});
@@ -148,7 +148,7 @@ void test('a legacy table without public Truthtrance history keeps its earlier i
void test('profile and nested-interaction boundaries do not admit another parent or module', () => {
const patches: Array<Partial<Game>> = [
{advanced:true}, {status:'setup'}, {phase:6}, {phase:-1}, {turn:0},
{status:'setup'}, {phase:6}, {phase:-1}, {turn:0},
{expansions:['choam','unknown']}, {expansions:['ix']},
{response:{kind:'richeseAuction', owner:'r', passed:[]}},
{pendingNullentropy:{} as NonNullable<Game['pendingNullentropy']>},
@@ -176,6 +176,11 @@ void test('profile and nested-interaction boundaries do not admit another parent
e3.expansions = ['choam','ecaz']; assert.equal(supported(e3), true);
});
void test('an otherwise supported auction-payment parent admits Advanced reveal', () => {
const game = parent('auctionPayment'); game.advanced = true;
assert.equal(supported(game), true);
});
void test('live current-turn commitments block the interruption; settled and previous-turn records do not', () => {
const game = parent('auctionPayment');
game.shipmentPromises = [{turn:game.turn, player:'e', asker:'r', answer:true, territory:'carthag', minimum:3}];