Initial commit

tests/truthtrance-card-count.test.ts

@@ -0,0 +1,375 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { baseDeck } from '../game/cards';
+import {
+  applyAction,
+  createGame,
+  newPlayer,
+  viewGame,
+  type Game,
+} from '../game/engine';
+import { botActions } from '../game/bots';
+import { DIFFICULTIES } from '../game/bot-profiles';
+import { type TruthFact } from '../game/truthtrance';
+import {
+  parseCardCountFact,
+  cardCountFactMatches,
+  cardCountFactText,
+  type CardCountFact,
+} from '../game/truthtrance-card-count';
+
+const names = [...new Set(baseDeck().map((card) => card.name))];
+
+void test('named-card counts distinguish multiple physical copies and compare zero through large thresholds', () => {
+  const shields = baseDeck().filter((card) => card.name === 'Shield');
+  assert.equal(shields.length, 4);
+  assert.equal(new Set(shields.map((card) => card.id)).size, 4);
+  for (let held = 0; held <= shields.length; held++) {
+    const hand = shields.slice(0, held);
+    for (const value of [0, 1, 2, 3, 4, 5, 41, Number.MAX_SAFE_INTEGER])
+      for (const compare of ['eq', 'gte', 'lte'] as const) {
+        const fact = parseCardCountFact(
+          { kind: 'handCount', name: 'Shield', compare, value },
+          names,
+        );
+        assert.equal(
+          cardCountFactMatches(hand, fact),
+          compare === 'eq'
+            ? held === value
+            : compare === 'gte'
+              ? held >= value
+              : held <= value,
+        );
+      }
+  }
+});
+
+void test('exact named custody excludes similarly named defenses and remains a current fact after a legal custody change', () => {
+  const hand = [
+    { id: 's1', name: 'Shield' },
+    { id: 's2', name: 'Shield' },
+    { id: 'ss', name: 'Shield Snooper' },
+    { id: 'p', name: 'Portable Snooper' },
+  ];
+  const before = structuredClone(hand);
+  const fact = parseCardCountFact(
+    { kind: 'handCount', name: 'Shield', compare: 'gte', value: 2 },
+    names,
+  );
+  assert.equal(cardCountFactMatches(hand, fact), true);
+  assert.deepEqual(hand, before);
+  assert.equal(cardCountFactMatches(hand.slice(1), fact), false);
+  assert.equal(
+    cardCountFactMatches([...hand, { id: 'unknown', name: 'shield' }], {
+      ...fact,
+      compare: 'eq',
+    }),
+    true,
+  );
+  assert.deepEqual(fact, {
+    kind: 'handCount',
+    name: 'Shield',
+    compare: 'gte',
+    value: 2,
+  });
+});
+
+void test('parser normalizes facts and rejects malformed names, comparisons and nonintegral counts without mutation', () => {
+  const valid = {
+    kind: 'handCount',
+    name: 'Shield',
+    compare: 'eq',
+    value: 2,
+    secret: 'ignored',
+  };
+  const before = structuredClone(valid);
+  assert.deepEqual(parseCardCountFact(valid, names), {
+    kind: 'handCount',
+    name: 'Shield',
+    compare: 'eq',
+    value: 2,
+  });
+  assert.deepEqual(valid, before);
+  for (const value of [
+    -1,
+    0.5,
+    NaN,
+    Infinity,
+    Number.MAX_SAFE_INTEGER + 1,
+    '2',
+    null,
+    undefined,
+  ])
+    assert.throws(
+      () => parseCardCountFact({ ...valid, value }, names),
+      /whole card count/,
+    );
+  for (const compare of ['gt', 'lt', '=', 1, null, undefined])
+    assert.throws(
+      () => parseCardCountFact({ ...valid, compare }, names),
+      /Compare held cards/,
+    );
+  for (const name of ['shield', 'Not a card', '', 1, null, undefined])
+    assert.throws(
+      () => parseCardCountFact({ ...valid, name }, names),
+      /known treachery/,
+    );
+  assert.throws(
+    () => parseCardCountFact({ ...valid, kind: 'hand' }, names),
+    /known treachery/,
+  );
+});
+
+void test('question text states the selected current comparison and never adds hidden inventory', () => {
+  assert.equal(
+    cardCountFactText({
+      kind: 'handCount',
+      name: 'Shield',
+      compare: 'gte',
+      value: 2,
+    }),
+    'you currently hold at least 2 cards named Shield',
+  );
+  assert.equal(
+    cardCountFactText({
+      kind: 'handCount',
+      name: 'Shield',
+      compare: 'eq',
+      value: 1,
+    }),
+    'you currently hold exactly 1 card named Shield',
+  );
+  assert.equal(
+    cardCountFactText({
+      kind: 'handCount',
+      name: 'Shield',
+      compare: 'lte',
+      value: 0,
+    }),
+    'you currently hold at most 0 cards named Shield',
+  );
+});
+
+function hold(g: Game, id: string, name: string) {
+  const index = g.deck.findIndex((c) => c.name === name);
+  assert.ok(index >= 0);
+  const card = g.deck.splice(index, 1)[0];
+  g.players.find((p) => p.id === id)!.hand.push(card);
+  return card.id;
+}
+function fixture(shields = 2) {
+  const g = createGame('COUNTTRUTH', newPlayer('a', 'Asker', 'atreides'));
+  g.players.push(
+    newPlayer('e', 'Target', 'emperor'),
+    newPlayer('h', 'Observer', 'harkonnen'),
+  );
+  Object.assign(g, {
+    status: 'playing',
+    turn: 2,
+    phase: 4,
+    order: ['h', 'e', 'a'],
+    deck: baseDeck(),
+  });
+  for (const p of g.players) {
+    p.spice = 20;
+    p.traitors = [p.leaders[0].id];
+  }
+  const selected = new Set(g.players.flatMap((p) => p.traitors));
+  g.traitorReserve = g.players
+    .flatMap((p) => p.leaders.map((l) => l.id))
+    .filter((id) => !selected.has(id));
+  hold(g, 'a', 'Truthtrance');
+  hold(g, 'h', 'Truthtrance');
+  hold(g, 'h', 'Snooper');
+  for (let i = 0; i < shields; i++) hold(g, 'e', 'Shield');
+  return g;
+}
+function priority(g: Game) {
+  g = applyAction(g, 'a', { type: 'card', card: g.players[0].hand[0].id });
+  for (let n = 0; n < 10 && g.truthtrance?.stage === 'priority'; n++)
+    g = applyAction(
+      g,
+      g.players.find((p) => !g.truthtrance!.passed.includes(p.id))!.id,
+      { type: 'truthPass' },
+    );
+  assert.equal(g.truthtrance?.stage, 'ask');
+  return g;
+}
+function ask(g: Game, fact: TruthFact) {
+  return applyAction(g, 'a', {
+    type: 'truthAsk',
+    question: { kind: 'fact', target: 'e', fact },
+  });
+}
+const countFact = (
+  compare: CardCountFact['compare'],
+  value: number,
+): CardCountFact => ({ kind: 'handCount', name: 'Shield', compare, value });
+const cardIds = (g: Game) =>
+  [...g.deck, ...g.discard, ...g.players.flatMap((p) => p.hand)]
+    .map((c) => c.id)
+    .sort();
+
+void test('real Truthtrance count questions enforce truthful answers and discard exactly once across comparator boundaries', () => {
+  for (let held = 0; held <= 4; held++)
+    for (const value of [0, 1, 2, 4, 41])
+      for (const compare of ['eq', 'gte', 'lte'] as const) {
+        const initial = fixture(held);
+        const originalCards = cardIds(initial);
+        const fact = countFact(compare, value);
+        const expected = cardCountFactMatches(initial.players[1].hand, fact)
+          ? 'yes'
+          : 'no';
+        const g = ask(priority(initial), fact);
+        assert.equal(viewGame(g, 'e').truthAnswer, expected);
+        assert.equal(viewGame(g, 'a').truthAnswer, null);
+        assert.equal(viewGame(g, 'h').truthAnswer, null);
+        const before = structuredClone(g);
+        for (const answer of [expected === 'yes' ? 'no' : 'yes', 'unknown'])
+          assert.throws(() =>
+            applyAction(g, 'e', { type: 'truthAnswer', answer }),
+          );
+        assert.throws(() =>
+          applyAction(g, 'h', { type: 'truthAnswer', answer: expected }),
+        );
+        assert.deepEqual(g, before);
+        const done = applyAction(JSON.parse(JSON.stringify(g)), 'e', {
+          type: 'truthAnswer',
+          answer: expected,
+        });
+        assert.equal(done.truthtrance, null);
+        assert.equal(done.truthHistory!.at(-1)!.answer, expected);
+        assert.deepEqual(done.truthHistory!.at(-1)!.question, {
+          kind: 'fact',
+          target: 'e',
+          fact,
+        });
+        assert.deepEqual(cardIds(done), originalCards);
+        assert.deepEqual(done.players[1].hand, initial.players[1].hand);
+        assert.equal(
+          done.discard.filter((c) => c.id === initial.players[0].hand[0].id)
+            .length,
+          1,
+        );
+        assert.throws(() =>
+          applyAction(done, 'e', { type: 'truthAnswer', answer: expected }),
+        );
+      }
+});
+
+void test('engine rejects malformed count clauses atomically even when another OR clause already determines the answer', () => {
+  const g = priority(fixture());
+  const invalid = [
+    { ...countFact('gte', 2), value: -1 },
+    { ...countFact('gte', 2), value: 1.5 },
+    { ...countFact('gte', 2), value: '2' },
+    { ...countFact('gte', 2), compare: 'gt' },
+    { ...countFact('gte', 2), name: 'not a card' },
+  ];
+  for (const leaf of invalid) {
+    const before = structuredClone(g);
+    assert.throws(() =>
+      applyAction(g, 'a', {
+        type: 'truthAsk',
+        question: {
+          kind: 'fact',
+          target: 'e',
+          fact: { kind: 'or', terms: [{ kind: 'hand', name: 'Shield' }, leaf] },
+        },
+      }),
+    );
+    assert.deepEqual(g, before);
+  }
+});
+
+void test('composed current counts disclose only the aggregate answer and preserve unknown traitor semantics', () => {
+  const initial = fixture();
+  initial.players[1].traitorChoices = ['atreides-1'];
+  initial.traitorReserve = initial.traitorReserve!.filter(
+    (id) => id !== 'atreides-1',
+  );
+  const scenarios: [TruthFact, 'yes' | 'no' | 'unknown'][] = [
+    [
+      {
+        kind: 'and',
+        terms: [
+          countFact('gte', 2),
+          { kind: 'spice', compare: 'eq', value: 20 },
+        ],
+      },
+      'yes',
+    ],
+    [
+      {
+        kind: 'and',
+        terms: [countFact('gte', 3), { kind: 'traitor', leader: 'atreides-1' }],
+      },
+      'no',
+    ],
+    [
+      {
+        kind: 'and',
+        terms: [countFact('eq', 2), { kind: 'traitor', leader: 'atreides-1' }],
+      },
+      'unknown',
+    ],
+    [
+      {
+        kind: 'or',
+        terms: [countFact('eq', 2), { kind: 'traitor', leader: 'atreides-1' }],
+      },
+      'yes',
+    ],
+  ];
+  for (const [fact, expected] of scenarios) {
+    const g = ask(priority(initial), fact);
+    assert.equal(viewGame(g, 'e').truthAnswer, expected);
+    for (const id of ['a', 'h']) {
+      const view = viewGame(g, id);
+      assert.equal(view.truthAnswer, null);
+      assert.equal(view.players.find((p) => p.id === 'e')!.hand, undefined);
+      assert.equal(
+        view.players.find((p) => p.id === 'e')!.traitorChoices,
+        undefined,
+      );
+    }
+    const done = applyAction(g, 'e', { type: 'truthAnswer', answer: expected });
+    assert.equal(done.truthHistory!.at(-1)!.answer, expected);
+  }
+});
+
+void test('all four AI profiles answer current card counts from target-only projections with foreign-hand noninterference', () => {
+  for (const difficulty of DIFFICULTIES)
+    for (const fact of [
+      countFact('eq', 2),
+      countFact('gte', 3),
+      countFact('lte', 0),
+      countFact('gte', 0),
+    ]) {
+      const initial = fixture();
+      initial.players[1].bot = difficulty;
+      const g = ask(priority(initial), fact);
+      const view = viewGame(g, 'e');
+      const snapshot = structuredClone(view);
+      const expected = cardCountFactMatches(g.players[1].hand, fact)
+        ? 'yes'
+        : 'no';
+      const actions = botActions(view);
+      assert.deepEqual(view, snapshot);
+      assert.deepEqual(actions, [{ type: 'truthAnswer', answer: expected }]);
+      assert.deepEqual(botActions(viewGame(g, 'h')), []);
+      const altered = structuredClone(g);
+      const observer = altered.players[2];
+      const snooperIndex = observer.hand.findIndex((c) => c.name === 'Snooper');
+      altered.deck.push(observer.hand.splice(snooperIndex, 1)[0]);
+      hold(altered, 'h', 'Gom Jabbar');
+      altered.players[0].spice = 999;
+      assert.deepEqual(viewGame(altered, 'e'), view);
+      assert.deepEqual(botActions(viewGame(altered, 'e')), actions);
+      for (const input of [g, altered]) {
+        const done = applyAction(input, 'e', actions[0]);
+        assert.equal(done.truthHistory!.at(-1)!.answer, expected);
+        assert.equal(done.truthtrance, null);
+      }
+    }
+});