170 lines
9.1 KiB
TypeScript
170 lines
9.1 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { botActions } from '../game/bots';
|
|
import { DIFFICULTIES } from '../game/bot-profiles';
|
|
import { viewGame, type Action, type Game } from '../game/engine';
|
|
import { beforeIxSpiceDraw, orderIxSpiceCards } from './fixture-ix-spice-cards';
|
|
import { createTruthTurnAmalFixture } from './fixture-truth-turn-amal';
|
|
import { actTruthCharityPayments as act, advanceTruthCharityPayments as advance,
|
|
createTruthCharityPaymentsFixture, truthCharityPaymentsClean as clean,
|
|
truthCharityPaymentsInventory as inventory, truthCharityPaymentsPlayer as player } from './fixture-truth-charity-payments';
|
|
import { actTruthtranceChoamPromises as actChoam,
|
|
createTruthtranceChoamPromisesFixture as choamFixture,
|
|
truthtranceChoamPromisesInventory as choamInventory,
|
|
truthtranceChoamPromisesPlayer as choamPlayer } from './fixture-truthtrance-choam-promises';
|
|
|
|
/** Genuine Advanced selected-Ix public start and original starting cards. Storm
|
|
* uses a quiet opening after real confirmations; Spice uses the actual Amal
|
|
* and unopened native Spice ordering. The Storm continuation selects a safe
|
|
* unopened Spice prefix. No wallet, readiness, promise or phase is installed. */
|
|
function fixture(phase:0|1) {
|
|
const base = phase === 0 ? createTruthTurnAmalFixture({phase:0,advanced:true})
|
|
: createTruthCharityPaymentsFixture({source:'afterAmal',advanced:true});
|
|
const game = phase === 0
|
|
? advance(structuredClone(base.game), state => state.phase === 0 && clean(state), [], true)
|
|
: structuredClone(base.game);
|
|
assert.equal(game.phase,phase); assert.equal(game.advanced,true); assert.ok(clean(game));
|
|
assert.equal(player(game,base.target).charityTurn,undefined);
|
|
assert.deepEqual(inventory(game),base.originalCards);
|
|
return {...base,game,initialPhase:phase,
|
|
charityQuestion:{kind:'charity' as const,target:base.target,turn:game.turn}};
|
|
}
|
|
function ask(f:ReturnType<typeof fixture>, source = f.game):Game {
|
|
let game = act(source,f.asker,{type:'card',card:f.truths[0]});
|
|
while (game.truthtrance?.stage === 'priority') {
|
|
const next = game.players.find(row => !game.truthtrance!.passed.includes(row.id)); assert.ok(next);
|
|
game = act(game,next.id,{type:'truthPass'});
|
|
}
|
|
assert.equal(game.truthtrance?.stage,'ask');
|
|
return act(game,f.asker,{type:'truthAsk',question:f.charityQuestion});
|
|
}
|
|
function bind(f:ReturnType<typeof fixture>, answer:'yes'|'no', source = f.game) {
|
|
const asked = ask(f,source);
|
|
assert.ok(viewGame(asked,f.target).truthCharityAnswers?.includes(answer));
|
|
return {asked, game:act(asked,f.target,{type:'truthAnswer',answer})};
|
|
}
|
|
|
|
void test('an early Advanced Charity answer preserves a real prior Spice Blow Ready', () => {
|
|
const f=fixture(1);
|
|
const blow=advance(f.game,state => !!state.spiceWindow && clean(state),[],true);
|
|
const ready=act(blow,f.target,{type:'ready'});
|
|
assert.ok(ready.ready.includes(f.target));
|
|
const {asked,game:bound}=bind(f,'yes',ready);
|
|
assert.ok(asked.ready.includes(f.target));
|
|
assert.deepEqual(bound.ready,asked.ready);
|
|
let game=reachCharity(bound);
|
|
assert.ok(game.charityOrder);
|
|
if (game.charityOrder.remaining[0]!==f.target) assert.equal(viewGame(game,f.target).truthCharityGuide,null);
|
|
game=ownTurn(game,f.target);
|
|
assert.ok(viewGame(game,f.target).truthCharityGuide);
|
|
assert.deepEqual(inventory(game),f.originalCards);
|
|
});
|
|
function reachCharity(source:Game):Game {
|
|
let game = source;
|
|
if (game.phase === 0) {
|
|
game = advance(game,beforeIxSpiceDraw,[],true);
|
|
orderIxSpiceCards(game,[{territory:'hagga_basin'},{territory:'broken_land'}]);
|
|
}
|
|
return advance(game,state => state.phase === 2 && !!state.charityOrder && clean(state),[],true);
|
|
}
|
|
function ownTurn(source:Game,target:string):Game {
|
|
let game=source;
|
|
for (let count=0; game.phase===2 && game.charityOrder?.remaining[0]!==target && count<6; count++) {
|
|
const actor=game.charityOrder?.remaining[0]; assert.ok(actor);
|
|
game=act(game,actor,{type:'ready'});
|
|
}
|
|
assert.equal(game.phase,2); assert.equal(game.charityOrder?.remaining[0],target);
|
|
return game;
|
|
}
|
|
function reject(game:Game,actor:string,action:Action) {
|
|
const before=structuredClone(game);
|
|
assert.throws(() => act(game,actor,action)); assert.deepEqual(game,before);
|
|
}
|
|
|
|
for (const phase of [0,1] as const) {
|
|
void test(`Advanced phase ${phase} Charity Yes survives openings and the ordered queue`, () => {
|
|
const f=fixture(phase), {asked,game:bound}=bind(f,'yes');
|
|
assert.deepEqual(bound.ready,asked.ready);
|
|
assert.equal(viewGame(bound,f.target).truthCharityGuide,null);
|
|
assert.ok(viewGame(bound,f.target).truthCharityPromises.some(row => row.answer && !row.fulfilled && !row.released));
|
|
assert.equal(bound.discard.filter(card => card.id===f.truths[0]).length,1);
|
|
let game=reachCharity(bound);
|
|
assert.equal(game.phase,2); assert.ok(game.charityOrder);
|
|
assert.ok(viewGame(game,f.target).truthCharityPromises.some(row => row.answer && !row.fulfilled && !row.released));
|
|
if (game.charityOrder.remaining[0]!==f.target) assert.equal(viewGame(game,f.target).truthCharityGuide,null);
|
|
game=ownTurn(game,f.target);
|
|
reject(game,f.target,{type:'ready'});
|
|
let guide=viewGame(game,f.target).truthCharityGuide; assert.ok(guide);
|
|
game=act(game,f.target,guide.action);
|
|
if (guide.action.type==='bribe') {
|
|
guide=viewGame(game,f.target).truthCharityGuide; assert.ok(guide);
|
|
assert.equal(guide.action.type,'charity'); game=act(game,f.target,guide.action);
|
|
}
|
|
assert.equal(player(game,f.target).charityTurn,game.turn);
|
|
assert.ok(viewGame(game,f.target).truthCharityPromises.some(row => row.answer && row.fulfilled));
|
|
assert.deepEqual(inventory(game),f.originalCards);
|
|
});
|
|
|
|
void test(`Advanced phase ${phase} Charity No remains until the respondent's ordered turn closes`, () => {
|
|
const f=fixture(phase), {asked,game:bound}=bind(f,'no');
|
|
assert.deepEqual(bound.ready,asked.ready);
|
|
assert.equal(viewGame(bound,f.target).truthCharityGuide,null);
|
|
let game=ownTurn(reachCharity(bound),f.target);
|
|
assert.ok(viewGame(game,f.target).truthCharityPromises.some(row => !row.answer && !row.fulfilled && !row.released));
|
|
const amount=player(game,f.target).spice-1;
|
|
if (amount>0) game=act(game,f.target,{type:'bribe',target:f.asker,amount});
|
|
assert.ok(player(game,f.target).spice<2);
|
|
reject(game,f.target,{type:'charity'});
|
|
game=act(game,f.target,{type:'ready'});
|
|
assert.ok(game.phase!==2 || !game.charityOrder?.remaining.includes(f.target));
|
|
assert.ok(viewGame(game,f.target).truthCharityPromises.some(row => !row.answer && row.fulfilled));
|
|
assert.deepEqual(inventory(game),f.originalCards);
|
|
});
|
|
}
|
|
|
|
void test('all four bots can answer before Advanced Charity and use the later legal guide', () => {
|
|
const f=fixture(1), asked=ask(f);
|
|
for (const difficulty of DIFFICULTIES) {
|
|
const response=viewGame(asked,f.target);
|
|
response.players.find(row => row.id===f.target)!.bot=difficulty;
|
|
const answer=botActions(response)[0]; assert.ok(answer);
|
|
assert.equal(answer.type,'truthAnswer');
|
|
assert.ok(response.truthCharityAnswers?.includes(answer.answer as 'yes'|'no'));
|
|
let game=act(structuredClone(asked),f.target,{type:'truthAnswer',answer:'yes'});
|
|
assert.equal(viewGame(game,f.target).truthCharityGuide,null);
|
|
game=ownTurn(reachCharity(game),f.target);
|
|
const own=viewGame(game,f.target); own.players.find(row => row.id===f.target)!.bot=difficulty;
|
|
const guide=own.truthCharityGuide; assert.ok(guide);
|
|
assert.deepEqual(botActions(own)[0],guide.action);
|
|
game=act(game,f.target,guide.action);
|
|
const claim=viewGame(game,f.target).truthCharityGuide;
|
|
if (claim) game=act(game,f.target,claim.action);
|
|
assert.equal(player(game,f.target).charityTurn,game.turn);
|
|
assert.deepEqual(inventory(game),f.originalCards);
|
|
}
|
|
});
|
|
|
|
void test('an early Advanced CHOAM question does not invent unresolved opening income', () => {
|
|
const f=choamFixture({advanced:true}), source=structuredClone(f.game);
|
|
assert.equal(source.phase,0); assert.equal(source.choamCharity,undefined);
|
|
assert.equal(choamPlayer(source,f.target).spice,f.rawCash);
|
|
let game=actChoam(source,f.asker,{type:'card',card:f.truth});
|
|
while (game.truthtrance?.stage==='priority') {
|
|
const actor=game.players.find(row => !game.truthtrance!.passed.includes(row.id)); assert.ok(actor);
|
|
game=actChoam(game,actor.id,{type:'truthPass'});
|
|
}
|
|
game=actChoam(game,f.asker,{type:'truthAsk',question:{kind:'charity',target:f.target,turn:game.turn}});
|
|
const own=viewGame(game,f.target);
|
|
assert.ok(own.truthCharityAnswers?.includes('no'));
|
|
assert.ok(own.truthCharityAnswers?.includes('unknown'));
|
|
assert.ok(!own.truthCharityAnswers?.includes('yes'));
|
|
const before=structuredClone(game);
|
|
assert.throws(() => actChoam(game,f.target,{type:'truthAnswer',answer:'yes'}));
|
|
assert.deepEqual(game,before);
|
|
game=actChoam(game,f.target,{type:'truthAnswer',answer:'no'});
|
|
assert.equal(choamPlayer(game,f.target).spice,f.rawCash);
|
|
assert.equal(game.choamCharity,undefined);
|
|
assert.ok(viewGame(game,f.target).truthCharityPromises.some(row => !row.answer && !row.fulfilled && !row.released));
|
|
assert.deepEqual(choamInventory(game),f.originalInventory);
|
|
});
|