241 lines
14 KiB
TypeScript
241 lines
14 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { createGame, joinGame, newPlayer, viewGame, type Action, type Game } from '../game/engine';
|
|
import { botActions } from '../game/bots';
|
|
import { DIFFICULTIES } from '../game/bot-profiles';
|
|
import { TERRITORIES, gameDistance, location, splitLocation } from '../game/board';
|
|
import { bribeAction } from '../game/bribe-options';
|
|
import { actTruthMovementNativeEarly as act, nextTruthMovementNativeEarlyStep } from './fixture-truth-movement-native-early';
|
|
import { truthMovementInventory } from './fixture-truth-movement';
|
|
|
|
type Kind = 'fremenMovement' | 'ixMovement' | 'choamMovement';
|
|
const seat = (g: Game, id: string) => { const p = g.players.find(p => p.id === id); assert.ok(p); return p; };
|
|
const clean = (g: Game) => !g.response && !g.decision && !g.phaseOpening && !g.truthtrance && !g.pendingTreacheryDiscard;
|
|
const reload = (g: Game): Game => JSON.parse(JSON.stringify(g));
|
|
const cards = (g: Game) => truthMovementInventory(g);
|
|
|
|
/** Select an existing physical card by a custody-preserving swap after the
|
|
* actual starting deal. This controls only who can answer the test window. */
|
|
function swapHeld(g: Game, id: string, predicate: (c: Game['deck'][number]) => boolean): string {
|
|
const target = seat(g, id);
|
|
const held = target.hand.find(predicate);
|
|
if (held) return held.id;
|
|
assert.ok(target.hand.length);
|
|
const index = g.deck.findIndex(predicate);
|
|
if (index >= 0) {
|
|
[target.hand[0], g.deck[index]] = [g.deck[index], target.hand[0]];
|
|
return target.hand[0].id;
|
|
}
|
|
for (const other of g.players) {
|
|
if (other.id === id) continue;
|
|
const at = other.hand.findIndex(predicate);
|
|
if (at >= 0) {
|
|
[target.hand[0], other.hand[at]] = [other.hand[at], target.hand[0]];
|
|
return target.hand[0].id;
|
|
}
|
|
}
|
|
throw Error('The original card must exist in the native deal or deck');
|
|
}
|
|
|
|
/** All pending movement/decisions come from actual player actions. The only
|
|
* controlled inputs are unopened Spice cards, first Storm dials and conserved
|
|
* card swaps. Richese's marker is actually shipped on its own turn. */
|
|
function fixture(kind: Kind, keepMarker: boolean) {
|
|
const value = 3, markerAtDestination = false;
|
|
assert.ok(!markerAtDestination || kind === 'fremenMovement');
|
|
const mover = kind === 'fremenMovement' ? 'fremen' : kind === 'ixMovement' ? 'ixians' : 'emperor';
|
|
const expansions = kind === 'ixMovement' ? ['choam', 'ix'] : ['choam'];
|
|
let g = createGame(`REVEAL-${kind}-${value}`, newPlayer('richese', 'Richese', 'richese'), false, expansions);
|
|
if (kind === 'choamMovement') joinGame(g, newPlayer('choam', 'CHOAM', 'choam'));
|
|
else joinGame(g, newPlayer(mover, mover, mover));
|
|
joinGame(g, newPlayer('emperor', 'Emperor', 'emperor'));
|
|
for (const p of g.players) g = act(g, p.id, {type:'ready'});
|
|
g = act(g, g.host, {type:'start'});
|
|
assert.equal(g.status, 'setup');
|
|
if (kind === 'ixMovement') {
|
|
// The native Ix setup driver chooses a Shield from the inspected packet.
|
|
// Move the original unopened card to its first draw position.
|
|
const shield = g.deck.findIndex(card => card.kind === 'shield');
|
|
assert.ok(shield >= 0);
|
|
[g.deck[0], g.deck[shield]] = [g.deck[shield], g.deck[0]];
|
|
}
|
|
const next = (state: Game) => {
|
|
const fremen = state.players.find(p => p.faction === 'fremen');
|
|
if (state.status === 'setup' && state.setupStage === 'forces' && fremen?.reserves === 20 &&
|
|
viewGame(state, fremen.id).setupPending.includes(fremen.id))
|
|
return {actor:fremen.id, action:{type:'fremenSetup', placements:{'sietch_tabr:14':10}} satisfies Action};
|
|
if (state.phase === 5 && state.active === 'richese' && clean(state) && !seat(state,'richese').shipped &&
|
|
!seat(state,'richese').noField?.deployed) {
|
|
const owner = seat(state,'richese'), marker = owner.noField!.tokens.find(t => t.value === value);
|
|
assert.ok(marker && owner.noFieldEvent);
|
|
const target = markerAtDestination
|
|
? TERRITORIES.filter(t => t.type === 'sand').flatMap(t => t.sectors.map(s => location(t.id,s)))
|
|
.find(key => splitLocation(key).sector > 7 && state.players.every(p => !(p.forces[key] > 0)) &&
|
|
gameDistance(state,'sietch_tabr:14',key,k => splitLocation(k).sector === state.storm) === 2 &&
|
|
gameDistance(state,'sietch_tabr:14',key,k => splitLocation(k).sector === (state.storm % 18) + 1) === 2)
|
|
: 'polar_sink:0';
|
|
assert.ok(target, 'The original Fremen position has a safe distance-two marker destination');
|
|
return {actor:'richese', action:{type:'ship', noField:marker.id, event:owner.noFieldEvent,
|
|
...splitLocation(target), allyPayment:0} satisfies Action};
|
|
}
|
|
if (kind === 'choamMovement' && state.turn === 1 && state.phase === 5 && state.active === 'choam' &&
|
|
clean(state) && !seat(state,'choam').shipped)
|
|
return {actor:'choam', action:{type:'ship', territory:'arrakeen', sector:10, amount:1, elite:0, allyPayment:0} satisfies Action};
|
|
if (state.phase === 5 && state.active === 'emperor' && clean(state))
|
|
return {actor:'emperor', action:{type:'endMovement'} satisfies Action};
|
|
const step = nextTruthMovementNativeEarlyStep(state);
|
|
assert.ok(step, `Missing native continuation ${state.status}/${state.turn}/${state.phase}/${state.decision?.kind}`);
|
|
if (step.action.type === 'stormDial' && state.turn === 1)
|
|
return {...step, action:{...step.action, amount:0}};
|
|
return step;
|
|
};
|
|
const reach = (until: (s: Game) => boolean) => {
|
|
for (let n = 0; n < 2400 && !until(g); n++) {
|
|
assert.notEqual(g.status, 'finished');
|
|
const step = next(g); g = act(g, step.actor, step.action);
|
|
}
|
|
assert.ok(until(g), 'The real game reached the requested native boundary');
|
|
};
|
|
reach(state => state.status === 'playing');
|
|
const karama = swapHeld(g, 'emperor', c => c.effect === 'karama');
|
|
const baliset = kind === 'choamMovement' ? swapHeld(g, 'choam', c => c.name === 'Baliset') : undefined;
|
|
for (let pos = 0; pos < 2; pos++) {
|
|
const at = g.spiceDeck.findIndex((c, index) => index >= pos && 'territory' in c && !c.discovery);
|
|
assert.ok(at >= pos); [g.spiceDeck[pos], g.spiceDeck[at]] = [g.spiceDeck[at], g.spiceDeck[pos]];
|
|
}
|
|
reach(state => state.turn === 2 && state.phase === 5 && state.active === mover && clean(state) &&
|
|
!!seat(state,'richese').noField?.deployed);
|
|
const marker = seat(g,'richese').noField!.deployed!.tokenId;
|
|
const event = seat(g,'richese').noFieldEvent; assert.ok(event);
|
|
let origin: string;
|
|
if (kind === 'fremenMovement') {
|
|
origin = 'sietch_tabr:14';
|
|
assert.ok((seat(g,mover).forces[origin] ?? 0) > 0);
|
|
} else if (kind === 'choamMovement') {
|
|
origin = 'carthag:11';
|
|
g = act(g,mover,{type:'ship', territory:'carthag', sector:11, amount:1, elite:0, allyPayment:0});
|
|
reach(clean);
|
|
assert.ok((seat(g,'choam').forces['arrakeen:10'] ?? 0) > 0);
|
|
} else {
|
|
origin = TERRITORIES.filter(t => t.type === 'sand').flatMap(t => t.sectors.map(s => location(t.id,s)))
|
|
.find(key => splitLocation(key).sector !== g.storm && g.players.every(p => !(p.forces[key] > 0)) &&
|
|
TERRITORIES.some(t => t.type === 'sand' && t.sectors.some(s => s !== g.storm &&
|
|
gameDistance(g,key,location(t.id,s),k => splitLocation(k).sector === g.storm) === 2)))!;
|
|
assert.ok(origin);
|
|
g = act(g,mover,{type:'ship', ...splitLocation(origin), amount:1, elite:1, allyPayment:0});
|
|
reach(clean);
|
|
}
|
|
const markerLocation = seat(g,'richese').noField!.deployed!.location;
|
|
const destination = markerAtDestination && 'territory' in markerLocation
|
|
? location(markerLocation.territory,markerLocation.sector)
|
|
: kind === 'choamMovement' ? 'arrakeen:10' :
|
|
TERRITORIES.filter(t => t.type === 'sand').flatMap(t => t.sectors.map(s => location(t.id,s)))
|
|
.find(key => splitLocation(key).sector !== g.storm && g.players.every(p => !(p.forces[key] > 0)) &&
|
|
gameDistance(g,origin,key,k => splitLocation(k).sector === g.storm) === 2)!;
|
|
assert.ok(destination);
|
|
// Also exercise movement without a deployed No-Field, using its real reveal.
|
|
if (!keepMarker) g = act(g,'richese',{type:'revealNoField', token:marker, event});
|
|
const beforeMove = structuredClone(g);
|
|
const move: Action = {type:'move', forces:{[origin]:1},
|
|
...(kind === 'ixMovement' ? {eliteForces:{[origin]:1}} : {}), ...splitLocation(destination)};
|
|
g = act(g,mover,move);
|
|
assert.equal(kind === 'choamMovement' ? g.decision?.kind : g.response?.kind, kind);
|
|
assert.deepEqual(seat(g,mover).forces, seat(beforeMove,mover).forces);
|
|
return {game:g, mover, marker, event, karama, baliset, value, origin, destination, beforeMove};
|
|
}
|
|
|
|
|
|
function finishPending(g: Game) {
|
|
for (let n = 0; n < 40; n++) {
|
|
if (g.pendingKull?.stage === 'offer') {
|
|
g = act(g,g.pendingKull.player,{type:'kullDecision',event:g.pendingKull.event,decline:true}); continue;
|
|
}
|
|
if (g.pendingTreacheryDiscard) {
|
|
const reaction = g.pendingTreacheryDiscard.reaction; assert.ok(reaction?.stage === 'offer');
|
|
const actor = g.players.find(p => !reaction.passed.includes(p.id)); assert.ok(actor);
|
|
g = act(g,actor.id,{type:'semutaPass',event:g.pendingTreacheryDiscard.batch.event}); continue;
|
|
}
|
|
if (g.response) {
|
|
const actor = g.players.find(p => !g.response!.passed.includes(p.id)); assert.ok(actor);
|
|
g = act(g,actor.id,{type:'passResponse'}); continue;
|
|
}
|
|
if (g.decision?.kind === 'choamMovement') {
|
|
g = act(g,g.decision.player,{type:'decision',decline:true}); continue;
|
|
}
|
|
return g;
|
|
}
|
|
throw Error('The original movement response did not finish');
|
|
}
|
|
|
|
const cached = new Map<string, ReturnType<typeof fixture>>();
|
|
function source(kind: Kind, keepMarker: boolean) {
|
|
const key = `${kind}:${keepMarker}`;
|
|
if (!cached.has(key)) cached.set(key,fixture(kind,keepMarker));
|
|
return cached.get(key)!;
|
|
}
|
|
function rejectUnchanged(game: Game, actor: string, action: Action) {
|
|
const before = structuredClone(game);
|
|
assert.throws(() => act(game,actor,action));
|
|
assert.deepEqual(game,before);
|
|
}
|
|
function pending(game: Game, kind: Kind) {
|
|
return kind === 'fremenMovement' ? game.pendingFremenMove :
|
|
kind === 'ixMovement' ? game.pendingIxMove : game.pendingChoamMove;
|
|
}
|
|
function pay(g: Game, kind: Kind) {
|
|
const payer = 'emperor', recipient = 'richese', before = structuredClone(g);
|
|
const options = viewGame(g,payer).bribeOptions;
|
|
assert.equal(options.blocked,null);
|
|
const candidate = options.targets.find(target => target.id === recipient);
|
|
assert.ok(candidate && candidate.maximum >= 1);
|
|
const action = bribeAction(options,recipient,1);
|
|
assert.deepEqual(action,{type:'bribe',target:recipient,amount:1});
|
|
rejectUnchanged(g,payer,{type:'bribe',target:payer,amount:1});
|
|
rejectUnchanged(g,payer,{type:'bribe',target:recipient,amount:options.available+1});
|
|
const after = act(g,payer,action!);
|
|
assert.deepEqual(pending(after,kind),pending(before,kind));
|
|
assert.deepEqual(after.response,before.response);
|
|
assert.deepEqual(after.decision,before.decision);
|
|
assert.equal(seat(after,payer).spice,seat(before,payer).spice-1);
|
|
assert.equal(seat(after,recipient).spice,seat(before,recipient).spice);
|
|
assert.equal(seat(after,recipient).bribes,seat(before,recipient).bribes+1);
|
|
assert.deepEqual(cards(after),cards(before));
|
|
if (candidate.maximum === options.available) {
|
|
const exhausted = act(before,payer,{type:'bribe',target:recipient,amount:candidate.maximum});
|
|
assert.equal(viewGame(exhausted,payer).bribeOptions.available,0);
|
|
rejectUnchanged(exhausted,payer,{type:'bribe',target:recipient,amount:1});
|
|
}
|
|
return after;
|
|
}
|
|
|
|
for (const kind of ['fremenMovement','ixMovement','choamMovement'] as const) {
|
|
for (const keepMarker of [false,true]) void test(`Basic ${kind} keeps the actual move through a bribe with ${keepMarker ? 'a deployed' : 'no deployed'} marker`, () => {
|
|
const f = source(kind,keepMarker), before = structuredClone(f.game);
|
|
assert.equal(!!seat(before,'richese').noField?.deployed,keepMarker);
|
|
const after = pay(before,kind);
|
|
assert.deepEqual(seat(after,f.mover).forces,seat(f.beforeMove,f.mover).forces);
|
|
const control = finishPending(reload(before)), done = finishPending(reload(after));
|
|
assert.deepEqual(seat(done,f.mover).forces,seat(control,f.mover).forces);
|
|
assert.equal(seat(done,f.mover).moved,seat(control,f.mover).moved);
|
|
assert.equal(seat(done,f.mover).forces[f.destination],(seat(f.beforeMove,f.mover).forces[f.destination] ?? 0)+1);
|
|
assert.equal(seat(done,f.mover).forces[f.origin] ?? 0,(seat(f.beforeMove,f.mover).forces[f.origin] ?? 0)-1);
|
|
assert.equal(seat(done,'richese').bribes,seat(before,'richese').bribes+1);
|
|
});
|
|
void test(`Basic ${kind} still allows the original cancellation and bot responses after a bribe`, () => {
|
|
const f = source(kind,true), before = structuredClone(f.game), after = pay(before,kind);
|
|
const actor = kind === 'choamMovement' ? 'choam' : 'emperor';
|
|
for (const difficulty of DIFFICULTIES) {
|
|
const view = viewGame(after,actor); view.players.find(p => p.id === actor)!.bot = difficulty;
|
|
const action = botActions(view)[0]; assert.ok(action,difficulty);
|
|
assert.doesNotThrow(() => act(reload(after),actor,action));
|
|
}
|
|
let cancelled = kind === 'choamMovement'
|
|
? act(after,'choam',{type:'card',card:f.baliset,mode:'choam',target:f.mover,territory:splitLocation(f.destination).territory})
|
|
: act(after,'emperor',{type:'card',card:f.karama,mode:'cancel'});
|
|
cancelled = finishPending(cancelled);
|
|
assert.deepEqual(seat(cancelled,f.mover).forces,seat(f.beforeMove,f.mover).forces);
|
|
assert.equal(seat(cancelled,f.mover).moved,seat(f.beforeMove,f.mover).moved);
|
|
assert.equal(seat(cancelled,'richese').bribes,seat(before,'richese').bribes+1);
|
|
});
|
|
}
|