538 lines
18 KiB
TypeScript
538 lines
18 KiB
TypeScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {
|
|
applyAction,
|
|
createGame,
|
|
newPlayer,
|
|
normalizeAutomaticGame,
|
|
viewGame,
|
|
type Game,
|
|
type Action,
|
|
} from '../game/engine';
|
|
import { baseDeck, ixBattleCards, type Card } from '../game/cards';
|
|
import { createAuditorLeader, CHOAM_AUDITOR_ID } from '../game/choam-auditor';
|
|
import { richeseCards } from '../game/richese-cards';
|
|
import type { FactionId } from '../game/catalog';
|
|
|
|
const reload = (g: Game): Game => JSON.parse(JSON.stringify(g));
|
|
const player = (g: Game, id: string) => g.players.find((p) => p.id === id)!;
|
|
const send = (g: Game, id: string, action: Action) =>
|
|
applyAction(g, id, action);
|
|
function fixture(opponent: FactionId = 'guild', third?: FactionId) {
|
|
const g = createGame('AUDITENGINE', newPlayer('c', 'CHOAM', 'choam'), true, [
|
|
'choam',
|
|
]);
|
|
g.players.push(newPlayer('o', 'Opponent', opponent));
|
|
if (third) g.players.push(newPlayer('x', 'Third faction', third));
|
|
Object.assign(g, {
|
|
status: 'playing',
|
|
phase: 6,
|
|
turn: 2,
|
|
active: 'c',
|
|
storm: 18,
|
|
order: g.players.map((p) => p.id),
|
|
deck: [...baseDeck(), ...ixBattleCards()],
|
|
richeseCache: richeseCards(),
|
|
discard: [],
|
|
});
|
|
player(g, 'c').leaders.push(createAuditorLeader());
|
|
for (const p of g.players) {
|
|
p.hand = [];
|
|
p.traitors = [];
|
|
p.spice = 20;
|
|
p.forces = p.id === 'x' ? {} : { 'arrakeen:10': 10 };
|
|
p.reserves = p.id === 'x' ? 20 : 10;
|
|
delete p.elites;
|
|
}
|
|
return g;
|
|
}
|
|
function hold(g: Game, id: string, kind: Card['kind'], effect?: string) {
|
|
const source =
|
|
effect && g.richeseCache!.some((card) => card.effect === effect)
|
|
? g.richeseCache!
|
|
: g.deck;
|
|
const index = source.findIndex((card) =>
|
|
effect ? card.effect === effect : card.kind === kind,
|
|
);
|
|
assert.ok(index >= 0, effect ?? kind);
|
|
const card = source.splice(index, 1)[0];
|
|
player(g, id).hand.push(card);
|
|
return card.id;
|
|
}
|
|
function secrets(g: Game, n = 2) {
|
|
return ['shield', 'snooper', 'projectile', 'poison']
|
|
.slice(0, n)
|
|
.map((kind) => hold(g, 'o', kind as Card['kind']));
|
|
}
|
|
function passResponses(g: Game) {
|
|
for (let limit = 0; g.response && limit < 20; limit++) {
|
|
const id = g.players.find((p) => !g.response!.passed.includes(p.id))!.id;
|
|
g = send(g, id, { type: 'passResponse' });
|
|
}
|
|
assert.equal(g.response, null);
|
|
return g;
|
|
}
|
|
function begin(g: Game, defending = false) {
|
|
const first = defending ? 'o' : 'c';
|
|
g.order = [
|
|
first,
|
|
defending ? 'c' : 'o',
|
|
...g.order.filter((id) => id !== 'c' && id !== 'o'),
|
|
];
|
|
g.active = first;
|
|
g = send(g, first, {
|
|
type: 'chooseBattle',
|
|
territory: 'arrakeen',
|
|
target: defending ? 'c' : 'o',
|
|
});
|
|
for (let limit = 0; limit < 30; limit++) {
|
|
if (g.response) {
|
|
g = passResponses(g);
|
|
continue;
|
|
}
|
|
const b = g.battle!;
|
|
if (b.preLeader && !b.preLeader.closed) {
|
|
const id = [b.attacker, b.defender].find(
|
|
(id) => !b.preLeader!.ready.includes(id),
|
|
)!;
|
|
g = send(g, id, { type: 'battlePreparationReady', event: b.event });
|
|
} else if (b.preparation)
|
|
g = send(g, b.preparation.owner, { type: 'declineBattlePower' });
|
|
else if (g.decision?.kind === 'fullPlanOffer')
|
|
g = send(g, g.decision.player, { type: 'decision', decline: true });
|
|
else return g;
|
|
}
|
|
throw Error('Battle preparation stalled');
|
|
}
|
|
function plan(g: Game, id: string, extra: Partial<Action> = {}) {
|
|
return send(g, id, {
|
|
type: 'battlePlan',
|
|
leader: id === 'c' ? CHOAM_AUDITOR_ID : player(g, id).leaders[0].id,
|
|
dial: id === 'c' ? 6 : 0,
|
|
support: id === 'c' ? 6 : 0,
|
|
...extra,
|
|
});
|
|
}
|
|
function cleanup(g: Game) {
|
|
for (let limit = 0; limit < 30; limit++) {
|
|
if (g.response && g.response.kind !== 'choamAudit') {
|
|
g = passResponses(g);
|
|
continue;
|
|
}
|
|
const d = g.decision;
|
|
if (d?.kind === 'battleCards')
|
|
g = send(g, d.player, { type: 'decision', discard: [] });
|
|
else if (d?.kind === 'battleLosses')
|
|
g = send(g, d.player, { type: 'decision', choice: 0 });
|
|
else if (d?.kind === 'ixSubstitution')
|
|
g = send(g, d.player, { type: 'decision', amount: 0 });
|
|
else return g;
|
|
}
|
|
throw Error('Battle cleanup stalled');
|
|
}
|
|
function finish(g: Game, calls: string[] = []) {
|
|
for (const id of ['c', 'o'])
|
|
g = send(g, id, { type: 'traitorCall', call: calls.includes(id) });
|
|
return cleanup(g);
|
|
}
|
|
function offer(g: Game) {
|
|
assert.equal(g.decision?.kind, 'choamAudit');
|
|
return passResponses(
|
|
send(reload(g), 'c', {
|
|
type: 'decision',
|
|
event: g.pendingAuditor!.event,
|
|
audit: true,
|
|
}),
|
|
);
|
|
}
|
|
function allow(g: Game) {
|
|
if (g.decision?.kind === 'choamAuditPayment')
|
|
return send(reload(g), 'o', {
|
|
type: 'decision',
|
|
event: g.pendingAuditor!.event,
|
|
pay: false,
|
|
});
|
|
return g;
|
|
}
|
|
function closeMarket(g: Game) {
|
|
return g.decision?.kind === 'choamMarket'
|
|
? send(g, g.decision.player, { type: 'decision', done: true })
|
|
: g;
|
|
}
|
|
function inventory(g: Game) {
|
|
return [
|
|
...g.deck,
|
|
...g.discard,
|
|
...(g.richeseCache ?? []),
|
|
...g.players.flatMap((p) => p.hand),
|
|
]
|
|
.map((c) => c.id)
|
|
.sort();
|
|
}
|
|
function unchanged(g: Game, id: string, action: Action) {
|
|
const before = reload(g);
|
|
assert.throws(() => send(g, id, action));
|
|
assert.deepEqual(g, before);
|
|
}
|
|
|
|
void test('Auditor triggers on both battle sides and both outcomes; actual survival alone sets one or two cards', () => {
|
|
for (const defending of [false, true])
|
|
for (const won of [false, true])
|
|
for (const survived of [false, true]) {
|
|
let g = fixture();
|
|
const eligible = secrets(g);
|
|
const weapon = survived ? undefined : hold(g, 'o', 'projectile');
|
|
g = begin(g, defending);
|
|
g = plan(g, 'c', { dial: won ? 6 : 0, support: won ? 6 : 0 });
|
|
g = plan(g, 'o', {
|
|
dial: won ? 0 : 6,
|
|
support: won ? 0 : 6,
|
|
...(weapon ? { weapon } : {}),
|
|
});
|
|
g = finish(g);
|
|
assert.equal(g.decision?.kind, 'choamAudit');
|
|
assert.equal(g.pendingAuditor!.survived, survived);
|
|
assert.equal(
|
|
player(g, 'c').leaders.find((l) => l.id === CHOAM_AUDITOR_ID)!.dead,
|
|
!survived,
|
|
);
|
|
assert.equal(viewGame(g, 'c').auditor!.count, survived ? 2 : 1);
|
|
const before = inventory(g);
|
|
const hands = g.players.map((p) => p.hand);
|
|
const event = g.pendingAuditor!.event;
|
|
g = closeMarket(allow(offer(g)));
|
|
assert.equal(g.pendingAuditor, null);
|
|
assert.equal(
|
|
g.phase,
|
|
7,
|
|
'Final-battle insight survives the automatic phase transition',
|
|
);
|
|
assert.equal(g.auditorInsight!.event, event);
|
|
assert.equal(g.auditorInsight!.cards.length, survived ? 2 : 1);
|
|
assert.ok(
|
|
g.auditorInsight!.cards.every((c) => eligible.includes(c.id)),
|
|
);
|
|
assert.deepEqual(inventory(g), before);
|
|
assert.deepEqual(
|
|
g.players.map((p) => p.hand),
|
|
hands,
|
|
);
|
|
assert.equal(
|
|
g.log.filter((entry) =>
|
|
/privately inspected .*random opposing hand/.test(entry.text),
|
|
).length,
|
|
1,
|
|
);
|
|
}
|
|
});
|
|
|
|
void test('used hero, retained Worthless defense and late Portable are excluded by physical battle-use IDs', (t) => {
|
|
let g = fixture();
|
|
const secret = hold(g, 'o', 'shield');
|
|
const hero = hold(g, 'o', 'hero');
|
|
const worthless = hold(g, 'o', 'worthless');
|
|
const portable = hold(g, 'o', 'special', 'portableSnooper');
|
|
g = begin(g);
|
|
g = plan(g, 'c', { dial: 0, support: 0 });
|
|
g = plan(g, 'o', { leader: hero, defense: worthless, dial: 6, support: 6 });
|
|
g = send(g, 'o', {
|
|
type: 'portableSnooper',
|
|
card: portable,
|
|
event: g.battle!.event,
|
|
});
|
|
g = finish(g);
|
|
assert.deepEqual(
|
|
[...g.pendingAuditor!.usedCards].sort(),
|
|
[hero, worthless, portable].sort(),
|
|
);
|
|
assert.ok(player(g, 'o').hand.some((c) => c.id === worthless));
|
|
assert.ok(player(g, 'o').hand.some((c) => c.id === portable));
|
|
assert.equal(viewGame(g, 'c').auditor!.count, 1);
|
|
t.mock.method(crypto, 'getRandomValues', () => {
|
|
throw Error('Full eligible pool must not sample');
|
|
});
|
|
g = allow(offer(g));
|
|
assert.deepEqual(
|
|
g.auditorInsight!.cards.map((c) => c.id),
|
|
[secret],
|
|
);
|
|
});
|
|
|
|
void test('zero eligible cards skip the audit and optional decline changes no hands or spice', () => {
|
|
let empty = fixture();
|
|
empty = closeMarket(finish(plan(plan(begin(empty), 'c'), 'o')));
|
|
assert.equal(empty.pendingAuditor, null);
|
|
assert.equal(empty.auditorInsight ?? null, null);
|
|
assert.equal(empty.phase, 7);
|
|
let g = fixture();
|
|
secrets(g);
|
|
g = finish(plan(plan(begin(g), 'c'), 'o'));
|
|
const hands = g.players.map((p) => p.hand),
|
|
spice = g.players.map((p) => p.spice);
|
|
g = send(g, 'c', {
|
|
type: 'decision',
|
|
event: g.pendingAuditor!.event,
|
|
audit: false,
|
|
});
|
|
assert.equal(g.pendingAuditor, null);
|
|
assert.equal(g.auditorInsight ?? null, null);
|
|
assert.deepEqual(
|
|
g.players.map((p) => p.hand),
|
|
hands,
|
|
);
|
|
assert.deepEqual(
|
|
g.players.map((p) => p.spice),
|
|
spice,
|
|
);
|
|
});
|
|
|
|
void test('payment cancels the whole actual viewable count directly, rejects stale or partial choices, and short balance auto-allows', () => {
|
|
for (const count of [1, 2]) {
|
|
let g = fixture();
|
|
secrets(g, count);
|
|
g.inflation = {
|
|
side: 'double',
|
|
placedTurn: 1,
|
|
updatedTurn: 1,
|
|
flipped: false,
|
|
};
|
|
g = offer(finish(plan(plan(begin(g), 'c'), 'o')));
|
|
assert.equal(g.decision?.kind, 'choamAuditPayment');
|
|
const event = g.pendingAuditor!.event;
|
|
const before = reload(g);
|
|
for (const amount of [0, -1, count + 1, 0.5])
|
|
unchanged(g, 'o', { type: 'decision', event, pay: true, count: amount });
|
|
unchanged(g, 'c', { type: 'decision', event, pay: true, count });
|
|
unchanged(g, 'o', { type: 'decision', event: 'stale', pay: true, count });
|
|
unchanged(g, 'o', { type: 'decision', event, pay: false, count });
|
|
g = send(g, 'o', { type: 'decision', event, pay: true, count });
|
|
assert.equal(player(g, 'c').spice, player(before, 'c').spice + count);
|
|
assert.equal(player(g, 'o').spice, player(before, 'o').spice - count);
|
|
assert.deepEqual(
|
|
g.players.map((p) => p.bribes),
|
|
before.players.map((p) => p.bribes),
|
|
);
|
|
assert.deepEqual(g.aid, before.aid);
|
|
assert.equal(g.auditorInsight ?? null, null);
|
|
unchanged(g, 'o', { type: 'decision', event, pay: true, count });
|
|
}
|
|
let poor = fixture();
|
|
secrets(poor);
|
|
player(poor, 'o').spice = 0;
|
|
poor = offer(finish(plan(plan(begin(poor), 'c'), 'o')));
|
|
assert.equal(poor.pendingAuditor, null);
|
|
assert.equal(poor.auditorInsight!.cards.length, 2);
|
|
assert.equal(player(poor, 'o').spice, 0);
|
|
});
|
|
|
|
void test('successful traitors, double traitors, Artillery, Tooth, Stone and explosion preserve the audit trigger and survival count', () => {
|
|
for (const mode of [
|
|
'ownTraitor',
|
|
'opposingTraitor',
|
|
'bothTraitors',
|
|
'artillery',
|
|
'poisonTooth',
|
|
'stoneBurner',
|
|
'explosion',
|
|
]) {
|
|
let g = fixture();
|
|
secrets(g);
|
|
const calls: string[] = [];
|
|
if (mode === 'ownTraitor' || mode === 'bothTraitors') {
|
|
player(g, 'c').traitors = [player(g, 'o').leaders[0].id];
|
|
calls.push('c');
|
|
}
|
|
if (mode === 'opposingTraitor' || mode === 'bothTraitors') {
|
|
player(g, 'o').traitors = [CHOAM_AUDITOR_ID];
|
|
calls.push('o');
|
|
}
|
|
const weapon =
|
|
mode === 'artillery' || mode === 'poisonTooth'
|
|
? hold(g, 'o', mode)
|
|
: mode === 'stoneBurner'
|
|
? hold(g, 'o', 'special', 'stoneBurner')
|
|
: mode === 'explosion'
|
|
? hold(g, 'o', 'lasgun')
|
|
: null;
|
|
const defense = mode === 'explosion' ? hold(g, 'c', 'shield') : null;
|
|
g = begin(g);
|
|
g = plan(g, 'c', defense ? { defense } : {});
|
|
g = plan(g, 'o', weapon ? { weapon } : {});
|
|
if (mode === 'poisonTooth')
|
|
g = send(g, 'o', { type: 'decision', activate: true });
|
|
if (mode === 'stoneBurner')
|
|
g = send(g, 'o', {
|
|
type: 'decision',
|
|
event: g.battle!.event,
|
|
mode: 'kill',
|
|
});
|
|
g = finish(g, calls);
|
|
assert.equal(g.decision?.kind, 'choamAudit', mode);
|
|
assert.equal(g.pendingAuditor!.survived, mode === 'ownTraitor', mode);
|
|
assert.equal(
|
|
viewGame(g, 'c').auditor!.count,
|
|
mode === 'ownTraitor' ? 2 : 1,
|
|
mode,
|
|
);
|
|
g = allow(offer(g));
|
|
assert.equal(
|
|
g.auditorInsight!.cards.length,
|
|
mode === 'ownTraitor' ? 2 : 1,
|
|
mode,
|
|
);
|
|
}
|
|
});
|
|
|
|
void test('BG Worthless cancellation and counter-cancellation restore the original audit exactly once', () => {
|
|
for (const counter of [false, true]) {
|
|
let g = fixture('guild', 'beneGesserit');
|
|
secrets(g);
|
|
const worthless = hold(g, 'x', 'worthless');
|
|
hold(g, 'x', 'worthless');
|
|
const karama = hold(g, 'c', 'special', 'karama');
|
|
g = finish(plan(plan(begin(g), 'c'), 'o'));
|
|
const event = g.pendingAuditor!.event;
|
|
g = send(g, 'c', { type: 'decision', event, audit: true });
|
|
assert.equal(g.response?.kind, 'choamAudit');
|
|
const balances = g.players.map((p) => p.spice);
|
|
g = send(g, 'x', { type: 'card', card: worthless, mode: 'cancel' });
|
|
assert.equal(g.response?.kind, 'worthlessKarama');
|
|
assert.equal(g.pendingAuditor!.event, event);
|
|
assert.deepEqual(normalizeAutomaticGame(reload(g)), reload(g));
|
|
if (counter) {
|
|
g = send(reload(g), 'c', { type: 'card', card: karama, mode: 'cancel' });
|
|
assert.equal(g.response?.kind, 'choamAudit');
|
|
assert.equal(g.response?.intent, event);
|
|
g = allow(passResponses(g));
|
|
assert.equal(g.auditorInsight!.event, event);
|
|
assert.equal(g.auditorInsight!.cards.length, 2);
|
|
} else {
|
|
g = passResponses(g);
|
|
assert.equal(g.auditorInsight ?? null, null);
|
|
assert.equal(
|
|
player(g, 'c').hand.some((c) => c.id === karama),
|
|
true,
|
|
);
|
|
}
|
|
assert.equal(g.pendingAuditor, null);
|
|
assert.equal(g.pendingKarama, null);
|
|
assert.equal(g.discard.filter((c) => c.id === worthless).length, 1);
|
|
assert.equal(
|
|
g.discard.filter((c) => c.id === karama).length,
|
|
counter ? 1 : 0,
|
|
);
|
|
assert.deepEqual(
|
|
g.players.map((p) => p.spice),
|
|
balances,
|
|
);
|
|
}
|
|
});
|
|
|
|
void test('private audit snapshot survives reads, allies and phase7 without resampling, then expires when the next battle starts', (t) => {
|
|
let g = fixture('guild', 'emperor');
|
|
const eligible = secrets(g, 3);
|
|
player(g, 'c').ally = 'x';
|
|
player(g, 'x').ally = 'c';
|
|
g = closeMarket(allow(offer(finish(plan(plan(begin(g), 'c'), 'o')))));
|
|
const snapshot = reload(g),
|
|
insight = structuredClone(g.auditorInsight);
|
|
assert.equal(g.phase, 7);
|
|
assert.ok(insight!.cards.every((card) => eligible.includes(card.id)));
|
|
t.mock.method(crypto, 'getRandomValues', () => {
|
|
throw Error('Reads must not resample');
|
|
});
|
|
for (const id of ['c', 'o', 'x']) {
|
|
const view = viewGame(reload(g), id);
|
|
assert.deepEqual(view.auditorInsight, id === 'c' ? insight : null);
|
|
assert.equal(view.auditor, null);
|
|
assert.equal('pendingAuditor' in view, false);
|
|
}
|
|
assert.deepEqual(normalizeAutomaticGame(reload(g)), snapshot);
|
|
assert.deepEqual(g, snapshot);
|
|
t.mock.restoreAll();
|
|
// A second genuine battle in a seeded later Battle phase clears historical inspection.
|
|
g.phase = 6;
|
|
g.active = 'c';
|
|
player(g, 'o').forces = { 'arrakeen:10': 1 };
|
|
player(g, 'o').reserves--;
|
|
g = send(g, 'c', {
|
|
type: 'chooseBattle',
|
|
territory: 'arrakeen',
|
|
target: 'o',
|
|
});
|
|
assert.equal(g.auditorInsight, null);
|
|
});
|
|
|
|
void test('audit completes before Face Dance can kill the previously surviving Auditor', () => {
|
|
let g = fixture('guild', 'tleilaxu');
|
|
secrets(g);
|
|
player(g, 'x').faceDancers = [
|
|
{ leader: CHOAM_AUDITOR_ID, revealed: false },
|
|
{ leader: player(g, 'o').leaders[1].id, revealed: false },
|
|
];
|
|
g = finish(plan(plan(begin(g), 'c'), 'o'));
|
|
assert.equal(g.decision?.kind, 'choamAudit');
|
|
assert.equal(g.pendingAuditor!.survived, true);
|
|
assert.ok(g.pendingFaceDance);
|
|
g = allow(offer(g));
|
|
assert.equal(g.auditorInsight!.cards.length, 2);
|
|
assert.equal(g.decision?.kind, 'faceDance');
|
|
const snapshot = structuredClone(g.auditorInsight);
|
|
g = send(g, 'x', {
|
|
type: 'decision',
|
|
reveal: true,
|
|
sources: { reserves: 1 },
|
|
sector: 10,
|
|
});
|
|
assert.equal(
|
|
player(g, 'c').leaders.find((l) => l.id === CHOAM_AUDITOR_ID)!.dead,
|
|
true,
|
|
);
|
|
assert.deepEqual(g.auditorInsight, snapshot);
|
|
assert.equal(g.pendingAuditor, null);
|
|
});
|
|
|
|
void test('legal Distrans during audit payment recomputes the full quote and an emptied hand completes without payment or inspection', () => {
|
|
for (const remaining of [0, 1]) {
|
|
let g = fixture('guild', 'emperor');
|
|
player(g, 'o').ally = 'x';
|
|
player(g, 'x').ally = 'o';
|
|
const transfer = hold(g, 'o', 'shield');
|
|
const distrans = hold(g, 'o', 'special', 'distrans');
|
|
if (remaining) hold(g, 'o', 'snooper');
|
|
g = offer(finish(plan(plan(begin(g), 'c'), 'o')));
|
|
assert.equal(g.decision?.kind, 'choamAuditPayment');
|
|
assert.equal(viewGame(g, 'c').auditor!.count, 2);
|
|
const event = g.pendingAuditor!.event;
|
|
const before = reload(g);
|
|
g = send(reload(g), 'o', {
|
|
type: 'card',
|
|
card: distrans,
|
|
give: transfer,
|
|
target: 'x',
|
|
});
|
|
assert.equal(
|
|
player(g, 'x').hand.some((card) => card.id === transfer),
|
|
true,
|
|
);
|
|
assert.equal(g.discard.filter((card) => card.id === distrans).length, 1);
|
|
assert.deepEqual(inventory(g), inventory(before));
|
|
assert.deepEqual(
|
|
g.players.map((p) => p.spice),
|
|
before.players.map((p) => p.spice),
|
|
);
|
|
if (remaining) {
|
|
assert.equal(g.decision?.kind, 'choamAuditPayment');
|
|
assert.equal(viewGame(g, 'c').auditor!.count, 1);
|
|
unchanged(g, 'o', { type: 'decision', event, pay: true, count: 2 });
|
|
g = send(g, 'o', { type: 'decision', event, pay: true, count: 1 });
|
|
assert.equal(player(g, 'c').spice, player(before, 'c').spice + 1);
|
|
assert.equal(player(g, 'o').spice, player(before, 'o').spice - 1);
|
|
} else {
|
|
assert.equal(g.pendingAuditor, null);
|
|
unchanged(g, 'o', { type: 'decision', event, pay: true, count: 2 });
|
|
}
|
|
assert.equal(g.auditorInsight ?? null, null);
|
|
}
|
|
});
|