Initial commit

tests/choam-auditor-engine.test.ts

@@ -0,0 +1,537 @@
+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);
+  }
+});