Preserve Emperor gift opportunity before bot phase pass
Verify and publish checkpoint container / container (push) Successful in 10m48s

This commit is contained in:
Quintine committed 2026-11-16 13:32:27 +11:00
1 parent 021a8c3e7f
commit 0c64d320ea
10 files changed
+238 -5

No files matched your search

@@ -0,0 +1,101 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import {applyAction, viewGame, type Action, type Game} from '../game/engine';
import {botActions, runBots} from '../game/bots';
import {DIFFICULTIES} from '../game/bot-profiles';
import {createTruthTurnAmalFixture} from './fixture-truth-turn-amal';
const act=(g:Game,id:string,action:Action)=>applyAction(g,id,action);
const player=(g:Game,id:string)=>{const p=g.players.find(row=>row.id===id);assert.ok(p);return p;};
function fixture(autopilot=false, spice=10) {
let game=createTruthTurnAmalFixture().game;
player(game,'emperor').ally='atreides';player(game,'atreides').ally='emperor';
player(game,'emperor').spice=spice;
const h=player(game,'harkonnen');
for(const card of h.hand.filter(row=>row.effect==='amal')) game.deck.push(card);
h.hand=h.hand.filter(row=>row.effect!=='amal');
game=act(game,'emperor',{type:'ready'});game=act(game,'atreides',{type:'ready'});
if(autopilot)player(game,'harkonnen').autopilot='Easy';else player(game,'harkonnen').bot='Easy';
return game;
}
function allow(game:Game) {
for(let n=0;game.response&&n<20;n++) {
const responder=game.players.find(p=>!game.response!.passed.includes(p.id));assert.ok(responder);
game=act(game,responder.id,{type:'passResponse'});
}
return game;
}
for(const autopilot of [false,true]) void test(`Basic human Emperor precedes final ${autopilot?'autopilot':'bot'} opening pass`,()=>{
let game=fixture(autopilot);
const original=structuredClone(game.phaseOpening);
const priority=viewGame(game,'emperor').emperorPhaseOpeningPriority;assert.ok(priority?.canContinue);
assert.deepEqual(viewGame(game,'harkonnen').emperorPhaseOpeningPriority,{...priority,canContinue:false});
for(const level of DIFFICULTIES) {
const view=viewGame(game,'harkonnen'),p=view.players.find(row=>row.id==='harkonnen')!;
if(autopilot)p.autopilot=level;else p.bot=level;
assert.ok(!botActions(view).some(action=>action.type==='ready'));
}
const before=structuredClone(game);
assert.throws(()=>act(game,'harkonnen',{type:'ready'}));
assert.throws(()=>act(game,'atreides',{type:'emperorPhaseOpeningContinue',event:priority.event}));
assert.throws(()=>act(game,'emperor',{type:'emperorPhaseOpeningContinue',event:'stale'}));
assert.deepEqual(game,before);
game=runBots(game,5);assert.deepEqual(game.phaseOpening,original);
game=act(game,'emperor',{type:'emperorGift',amount:2});game=allow(game);
assert.deepEqual(game.phaseOpening,original);
assert.equal(player(game,'atreides').spice,player(before,'atreides').spice+2);
const waiting=viewGame(game,'emperor').emperorPhaseOpeningPriority;assert.ok(waiting?.canContinue);
game=act(game,'emperor',{type:'emperorPhaseOpeningContinue',event:waiting.event});
assert.equal(viewGame(game,'emperor').emperorPhaseOpeningPriority,null);
assert.ok(botActions(viewGame(game,'harkonnen')).some(action=>action.type==='ready'));
game=runBots(game,1);assert.equal(game.phaseOpening,null);
});
void test('a zero-spice Emperor retains the same public opening opportunity',()=>{
const game=fixture(false,0),priority=viewGame(game,'atreides').emperorPhaseOpeningPriority;
assert.ok(priority);assert.equal(priority.canContinue,false);
assert.equal(viewGame(game,'emperor').emperorPhaseOpeningGift,null);
const done=act(game,'emperor',{type:'emperorPhaseOpeningContinue',event:priority.event});
assert.equal(viewGame(done,'emperor').emperorPhaseOpeningPriority,null);
});
void test('a canceled gift returns to the same automated opening opportunity',()=>{
let game=fixture();
const h=player(game,'harkonnen');let card=h.hand.find(row=>row.effect==='karama');
if(!card) {
const source=[game.deck,...game.players.filter(p=>p.id!=='harkonnen').map(p=>p.hand)].find(zone=>zone.some(row=>row.effect==='karama'));assert.ok(source);
[card]=source.splice(source.findIndex(row=>row.effect==='karama'),1);h.hand.push(card);
}
const opening=structuredClone(game.phaseOpening),wallet=player(game,'emperor').spice;
game=act(game,'emperor',{type:'emperorGift',amount:1});
game=act(game,'harkonnen',{type:'card',mode:'cancel',card:card.id});
assert.deepEqual(game.phaseOpening,opening);assert.equal(player(game,'emperor').spice,wallet);
assert.ok(viewGame(game,'emperor').emperorPhaseOpeningPriority?.canContinue);
assert.deepEqual(runBots(game,4).phaseOpening,opening);
});
void test('playing Amal after Continue creates a fresh opening and invalidates the old release',()=>{
let game=fixture();const h=player(game,'harkonnen');
const source=[game.deck,...game.players.filter(p=>p.id!=='harkonnen').map(p=>p.hand)].find(zone=>zone.some(row=>row.effect==='amal'));assert.ok(source);
const [amal]=source.splice(source.findIndex(row=>row.effect==='amal'),1);h.hand.push(amal);
const old=viewGame(game,'emperor').emperorPhaseOpeningPriority!;
game=act(game,'emperor',{type:'emperorPhaseOpeningContinue',event:old.event});
game=act(game,'harkonnen',{type:'card',card:amal.id});
assert.deepEqual(game.phaseOpening?.passed,[]);
game=act(game,'emperor',{type:'ready'});game=act(game,'atreides',{type:'ready'});
const fresh=viewGame(game,'emperor').emperorPhaseOpeningPriority;assert.ok(fresh);
assert.notEqual(fresh.event,old.event);
assert.throws(()=>act(game,'emperor',{type:'emperorPhaseOpeningContinue',event:old.event}));
game=act(game,'emperor',{type:'emperorPhaseOpeningContinue',event:fresh.event});
game=act(game,'harkonnen',{type:'ready'});assert.equal(game.phaseOpening,null);
});
void test('unallied games and a bot Emperor do not create a human gift wait',()=>{
for(const variant of ['unallied','automated-emperor'] as const) {
const game=fixture();
if(variant==='unallied') {player(game,'emperor').ally=null;player(game,'atreides').ally=null;}
else player(game,'emperor').bot='Easy';
assert.equal(viewGame(game,'harkonnen').emperorPhaseOpeningPriority,null);
assert.ok(botActions(viewGame(game,'harkonnen')).some(action=>action.type==='ready'));
assert.equal(act(game,'harkonnen',{type:'ready'}).phaseOpening,null);
}
});