Initial commit

tests/moritani-retention.test.ts

@@ -0,0 +1,537 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  applyAction,
+  createGame,
+  newPlayer,
+  viewGame,
+  type Game,
+  type Action,
+} from '../game/engine';
+import { baseDeck, ixBattleCards, type Card } from '../game/cards';
+import { cashInCards } from '../game/choam-karama';
+import type { FactionId } from '../game/catalog';
+const cards = [...baseDeck(), ...ixBattleCards()];
+const card = (kind: Card['kind']) =>
+  structuredClone(cards.find((c) => c.kind === kind)!);
+const p = (g: Game, id: string) => g.players.find((p) => p.id === id)!;
+const reload = (g: Game): Game => JSON.parse(JSON.stringify(g));
+/** Fixture transfers use the one physical catalog inventory. Replaced setup
+ * cards return to its deck; no gameplay action or invalid snapshot is repaired. */
+function setHand(g: Game, id: string, selected: Card[]) {
+  const owner = p(g, id);
+  const keep = new Set(selected.map((c) => c.id));
+  assert.equal(keep.size, selected.length);
+  const previous = new Map(owner.hand.map((c) => [c.id, c]));
+  for (const held of owner.hand)
+    if (!keep.has(held.id)) {
+      assert.ok(!g.deck.some((c) => c.id === held.id));
+      g.deck.push(held);
+    }
+  owner.hand = selected.map((wanted) => {
+    if (previous.has(wanted.id)) return previous.get(wanted.id)!;
+    assert.ok(
+      !g.players.some(
+        (other) =>
+          other.id !== id && other.hand.some((c) => c.id === wanted.id),
+      ),
+    );
+    const at = g.deck.findIndex((c) => c.id === wanted.id);
+    assert.ok(
+      at >= 0,
+      `Physical fixture card ${wanted.id} must be in the deck`,
+    );
+    return g.deck.splice(at, 1)[0];
+  });
+}
+function replaceCard(g: Game, id: string, index: number, replacement: Card) {
+  setHand(
+    g,
+    id,
+    p(g, id).hand.map((held, at) => (at === index ? replacement : held)),
+  );
+}
+function fixture(loser: FactionId = 'guild', winner: FactionId = 'emperor') {
+  const g = createGame('MRETAIN1', newPlayer('w', 'Winner', winner));
+  g.players.push(
+    newPlayer('l', 'Defeated ally', loser),
+    newPlayer('m', 'Moritani', 'moritani'),
+  );
+  g.status = 'playing';
+  g.phase = 6;
+  g.turn = 2;
+  g.storm = 18;
+  g.order = ['w', 'l', 'm'];
+  g.active = 'w';
+  g.deck = structuredClone(cards);
+  for (const player of g.players) {
+    player.forces = player.id === 'm' ? {} : { 'arrakeen:10': 5 };
+    player.reserves = player.id === 'm' ? 20 : 15;
+    player.spice = 20;
+    player.hand = [];
+    player.traitors = [];
+    for (const l of player.leaders) l.strength = 0;
+  }
+  p(g, 'm').ally = 'l';
+  p(g, 'l').ally = 'm';
+  setHand(g, 'l', [card('projectile'), card('snooper'), card('worthless')]);
+  return g;
+}
+function allow(g: Game) {
+  for (let i = 0; g.response && i < 40; i++)
+    g = applyAction(
+      g,
+      g.players.find((p) => !g.response!.passed.includes(p.id))!.id,
+      { type: 'passResponse' },
+    );
+  assert.equal(g.response, null);
+  return g;
+}
+function fight(
+  state = fixture(),
+  opts: {
+    weapon?: string | null;
+    defense?: string | null;
+    hero?: string;
+    calls?: string[];
+    tooth?: boolean;
+    winnerWeapon?: string;
+    winnerDefense?: string;
+    winnerSupport?: number;
+  } = {},
+) {
+  let g = allow(
+    applyAction(state, 'w', {
+      type: 'chooseBattle',
+      territory: 'arrakeen',
+      target: 'l',
+    }),
+  );
+  for (let i = 0; g.battle?.preparation && i < 20; i++)
+    g = allow(
+      applyAction(g, g.battle.preparation.owner, {
+        type: 'declineBattlePower',
+      }),
+    );
+  g = applyAction(g, 'w', {
+    type: 'battlePlan',
+    dial: 3,
+    support: opts.winnerSupport ?? 3,
+    leader: p(g, 'w').leaders[0].id,
+    weapon: opts.winnerWeapon,
+    defense: opts.winnerDefense,
+  });
+  g = applyAction(g, 'l', {
+    type: 'battlePlan',
+    dial: 0,
+    support: 0,
+    leader: opts.hero ?? p(g, 'l').leaders[0].id,
+    weapon: opts.weapon === undefined ? p(g, 'l').hand[0].id : opts.weapon,
+    defense: opts.defense === undefined ? p(g, 'l').hand[1].id : opts.defense,
+  });
+  while (g.decision?.kind === 'poisonTooth')
+    g = applyAction(g, g.decision.player, {
+      type: 'decision',
+      activate: opts.tooth ?? false,
+    });
+  for (const id of ['w', 'l'])
+    if (g.battle)
+      g = applyAction(g, id, {
+        type: 'traitorCall',
+        call: opts.calls?.includes(id) ?? false,
+      });
+  return g;
+}
+function cleanup(g: Game) {
+  for (
+    let i = 0;
+    g.decision &&
+    ['battleLosses', 'battleCards', 'ixSubstitution'].includes(
+      g.decision.kind,
+    ) &&
+    i < 10;
+    i++
+  ) {
+    const d = g.decision;
+    g = applyAction(
+      g,
+      d.player,
+      d.kind === 'battleCards'
+        ? { type: 'decision', discard: [] }
+        : d.kind === 'ixSubstitution'
+          ? { type: 'decision', amount: 0 }
+          : { type: 'decision', choice: 0 },
+    );
+  }
+  return g;
+}
+function reject(g: Game, id: string, action: Action) {
+  const old = structuredClone(g);
+  assert.throws(() => applyAction(g, id, action));
+  assert.deepEqual(g, old);
+}
+function counts(g: Game) {
+  return g.players
+    .flatMap((p) => p.hand)
+    .concat(g.discard)
+    .map((c) => c.id)
+    .sort();
+}
+
+void test('unopposed defeated ally retains exactly one played card automatically through JSON recovery', () => {
+  for (const pick of [0, 1]) {
+    const before = fixture();
+    const inventory = counts(before);
+    let g = cleanup(fight(before));
+    assert.equal(g.decision?.kind, 'moritaniRetention');
+    assert.equal(g.decision?.player, 'l');
+    assert.equal(p(g, 'l').tanks, 5);
+    assert.equal(p(g, 'w').tanks, 3);
+    const played = g.moritaniRetention!.played;
+    const keep = played[pick];
+    assert.equal(played.length, 2);
+    assert.ok(played.every((id) => p(g, 'l').hand.some((c) => c.id === id)));
+    const settled = g.players.map((p) => ({
+      id: p.id,
+      spice: p.spice,
+      tanks: p.tanks,
+    }));
+    g = applyAction(reload(g), 'l', { type: 'decision', keep });
+    assert.equal(
+      g.response,
+      null,
+      'no eligible cancellation requires no pass clicks',
+    );
+    g = allow(reload(g));
+    assert.equal(g.moritaniRetention, null);
+    assert.equal(g.phase, 7);
+    assert.deepEqual(
+      g.players.map((p) => ({ id: p.id, spice: p.spice, tanks: p.tanks })),
+      settled,
+    );
+    assert.deepEqual(counts(g), inventory);
+    assert.ok(p(g, 'l').hand.some((c) => c.id === keep));
+    assert.equal(g.discard.filter((c) => played.includes(c.id)).length, 1);
+    reject(g, 'l', { type: 'decision', keep });
+  }
+});
+void test('declining needs no Karama window and keeps unrelated hand cards untouched', () => {
+  let g = cleanup(fight());
+  const unplayed = p(g, 'l').hand[2].id;
+  g = applyAction(g, 'l', { type: 'decision', keep: null });
+  assert.equal(g.response, null);
+  assert.deepEqual(
+    p(g, 'l').hand.map((c) => c.id),
+    [unplayed],
+  );
+  assert.equal(g.discard.length, 2);
+});
+void test('only the defeated ally may choose one eligible exact card', () => {
+  const g = cleanup(fight());
+  const id = g.moritaniRetention!.eligible[0];
+  reject(g, 'm', { type: 'decision', keep: id });
+  reject(g, 'w', { type: 'decision', keep: id });
+  for (const keep of [
+    undefined,
+    [],
+    [id],
+    p(g, 'l').hand[2].id,
+    'opposing-card',
+  ])
+    reject(g, 'l', { type: 'decision', keep });
+});
+void test('Karama cancels retention without reversing combat or duplicating disposal', () => {
+  let g = cleanup(fight());
+  const k = baseDeck().find((c) => c.effect === 'karama')!;
+  setHand(g, 'w', [k]);
+  const losses = g.players.map((p) => p.tanks);
+  g = applyAction(g, 'l', {
+    type: 'decision',
+    keep: g.moritaniRetention!.eligible[0],
+  });
+  g = applyAction(reload(g), 'w', { type: 'card', card: k.id, mode: 'cancel' });
+  assert.equal(g.moritaniRetention, null);
+  assert.deepEqual(
+    g.players.map((p) => p.tanks),
+    losses,
+  );
+  assert.equal(g.discard.length, 3);
+  assert.equal(p(g, 'l').hand.length, 1);
+  assert.equal(g.phase, 7);
+});
+void test('no alliance and Moritani itself do not receive the losing-ally benefit', () => {
+  const g = fixture();
+  p(g, 'm').ally = null;
+  p(g, 'l').ally = null;
+  assert.equal(cleanup(fight(g)).moritaniRetention, undefined);
+  const self = fixture('moritani');
+  p(self, 'm').faction = 'guild';
+  assert.equal(cleanup(fight(self)).moritaniRetention, undefined);
+});
+void test('a loss with no retainable played card skips the optional decision', () => {
+  for (const heroOnly of [false, true]) {
+    const g = fixture();
+    const hero = card('hero');
+    setHand(g, 'l', heroOnly ? [hero] : []);
+    const out = cleanup(
+      fight(g, {
+        weapon: null,
+        defense: null,
+        ...(heroOnly ? { hero: hero.id } : {}),
+      }),
+    );
+    assert.equal(out.moritaniRetention, undefined);
+    assert.equal(out.decision, null);
+    assert.equal(out.phase, 7);
+    assert.equal(p(out, 'l').hand.length, 0);
+    assert.equal(
+      out.discard.filter((c) => c.id === hero.id).length,
+      heroOnly ? 1 : 0,
+    );
+  }
+});
+void test('Cheap Hero cannot be retained but an eligible defense can', () => {
+  const g = fixture();
+  const hero = card('hero');
+  setHand(g, 'l', [...p(g, 'l').hand, hero]);
+  const out = cleanup(fight(g, { hero: hero.id }));
+  assert.ok(!out.moritaniRetention!.eligible.includes(hero.id));
+  const kept = allow(
+    applyAction(out, 'l', {
+      type: 'decision',
+      keep: out.moritaniRetention!.eligible[1],
+    }),
+  );
+  assert.equal(kept.discard.filter((c) => c.id === hero.id).length, 1);
+});
+void test('used Tooth and Artillery are excluded; unused Tooth remains eligible', () => {
+  for (const kind of ['poisonTooth', 'artillery'] as const)
+    for (const tooth of [false, true]) {
+      const g = fixture();
+      const special = card(kind);
+      replaceCard(g, 'l', 0, special);
+      const out = cleanup(fight(g, { tooth }));
+      assert.equal(
+        out.moritaniRetention!.eligible.includes(special.id),
+        kind === 'poisonTooth' && !tooth,
+      );
+    }
+});
+void test('single traitor creates retention; mutual traitors and actual explosions do not', () => {
+  const single = fixture();
+  p(single, 'w').traitors = [p(single, 'l').leaders[0].id];
+  assert.equal(
+    cleanup(fight(single, { calls: ['w'] })).decision?.kind,
+    'moritaniRetention',
+  );
+  const mutual = fixture();
+  p(mutual, 'w').traitors = [p(mutual, 'l').leaders[0].id];
+  p(mutual, 'l').traitors = [p(mutual, 'w').leaders[0].id];
+  assert.equal(
+    cleanup(fight(mutual, { calls: ['w', 'l'] })).moritaniRetention,
+    undefined,
+  );
+  const boom = fixture();
+  setHand(boom, 'w', [card('lasgun')]);
+  replaceCard(boom, 'l', 1, card('shield'));
+  assert.equal(
+    cleanup(fight(boom, { winnerWeapon: p(boom, 'w').hand[0].id }))
+      .moritaniRetention,
+    undefined,
+  );
+});
+void test('single traitor preempts explosion and Tooth effect-discard', () => {
+  const g = fixture();
+  p(g, 'w').traitors = [p(g, 'l').leaders[0].id];
+  setHand(g, 'w', [card('lasgun')]);
+  replaceCard(g, 'l', 1, card('shield'));
+  assert.equal(
+    cleanup(fight(g, { calls: ['w'], winnerWeapon: p(g, 'w').hand[0].id }))
+      .decision?.kind,
+    'moritaniRetention',
+  );
+  const tooth = fixture();
+  p(tooth, 'w').traitors = [p(tooth, 'l').leaders[0].id];
+  replaceCard(tooth, 'l', 0, card('poisonTooth'));
+  const out = cleanup(fight(tooth, { calls: ['w'], tooth: true }));
+  assert.ok(out.moritaniRetention!.eligible.includes(card('poisonTooth').id));
+});
+void test('reservation begins before winner casualty cleanup and blocks cash-in', () => {
+  const g = fixture();
+  g.advanced = true;
+  p(g, 'w').elites = {
+    reserves: 3,
+    tanks: 0,
+    forces: { 'arrakeen:10': 2 },
+    revived: 0,
+  };
+  const out = fight(g, { winnerSupport: 1 });
+  assert.equal(out.decision?.kind, 'battleLosses');
+  assert.ok(
+    out.decision?.kind === 'battleLosses' && out.decision.options.length > 1,
+  );
+  assert.equal(p(out, 'w').forces['arrakeen:10'], 5);
+  assert.equal(p(out, 'w').tanks, 0);
+  assert.ok(out.moritaniRetention);
+  const reserved = out.moritaniRetention!.played;
+  assert.ok(
+    cashInCards(out, p(out, 'l')).every((c) => !reserved.includes(c.id)),
+  );
+  const after = cleanup(reload(out));
+  assert.equal(after.decision?.kind, 'moritaniRetention');
+  assert.ok(p(after, 'w').tanks > 0);
+});
+void test('Bene Gesserit cannot convert a reserved Worthless card during retention', () => {
+  const g = fixture('beneGesserit');
+  g.advanced = true;
+  const w = card('worthless');
+  setHand(g, 'l', [w, card('snooper')]);
+  setHand(g, 'w', [baseDeck().find((c) => c.effect === 'karama')!]);
+  let out = cleanup(fight(g));
+  out = applyAction(out, 'l', { type: 'decision', keep: w.id });
+  reject(out, 'l', { type: 'card', mode: 'cancel', card: w.id });
+  assert.equal(out.moritaniRetention?.stage, 'response');
+  assert.ok(p(out, 'l').hand.some((c) => c.id === w.id));
+});
+void test('CHOAM cannot cash in any pending played card, including during winner cleanup', () => {
+  const g = fixture();
+  g.advanced = true;
+  let out = fight(g);
+  p(out, 'l').faction = 'choam';
+  const k = baseDeck().find((c) => c.effect === 'karama')!;
+  setHand(out, 'l', [...p(out, 'l').hand, k]);
+  reject(out, 'l', {
+    type: 'card',
+    mode: 'special',
+    card: k.id,
+    cards: [out.moritaniRetention!.played[0]],
+  });
+  out = cleanup(out);
+  reject(out, 'l', {
+    type: 'card',
+    mode: 'special',
+    card: k.id,
+    cards: [out.moritaniRetention!.played[0]],
+  });
+});
+void test('public retention data contains only revealed played cards and pure views do not leak unplayed hand', () => {
+  const g = cleanup(fight());
+  const before = structuredClone(g);
+  const unplayed = p(g, 'l').hand[2].id;
+  for (const id of ['w', 'm']) {
+    const view = viewGame(g, id);
+    assert.ok(!JSON.stringify(view.moritaniRetention).includes(unplayed));
+    assert.equal(view.players.find((p) => p.id === 'l')!.hand, undefined);
+  }
+  assert.deepEqual(g, before);
+});
+void test('Harkonnen capture and Face Dancer continuations wait until retention settles', () => {
+  const g = fixture('guild', 'harkonnen');
+  g.advanced = true;
+  g.players.push(newPlayer('t', 'Tleilaxu', 'tleilaxu'));
+  g.order.push('t');
+  let out = cleanup(fight(g));
+  assert.equal(out.decision?.kind, 'moritaniRetention');
+  assert.ok(out.pendingCapture);
+  assert.ok(out.pendingFaceDance);
+  out = applyAction(reload(out), 'l', { type: 'decision', keep: null });
+  assert.equal(out.decision?.kind, 'captureOffer');
+  out = applyAction(out, 'w', { type: 'decision', accept: false });
+  assert.equal(out.decision?.kind, 'faceDance');
+  out = applyAction(out, 't', { type: 'decision', reveal: false });
+  assert.equal(out.phase, 7);
+  assert.equal(out.pendingFaceDance, null);
+});
+
+void test('nested Worthless conversion preserves pending card custody whether conversion succeeds or is canceled', () => {
+  for (const cancelConversion of [false, true]) {
+    const g = fixture();
+    g.advanced = true;
+    g.players.push(newPlayer('b', 'Bene Gesserit', 'beneGesserit'));
+    g.order.push('b');
+    const worthless = baseDeck()
+      .filter((c) => c.kind === 'worthless')
+      .at(-1)!;
+    setHand(g, 'b', [worthless]);
+    const k = baseDeck().find((c) => c.effect === 'karama')!;
+    setHand(g, 'w', [k]);
+    let out = cleanup(fight(g));
+    const keep = out.moritaniRetention!.eligible[0];
+    const played = [...out.moritaniRetention!.played];
+    out = applyAction(out, 'l', { type: 'decision', keep });
+    out = applyAction(out, 'b', {
+      type: 'card',
+      card: worthless.id,
+      mode: 'cancel',
+    });
+    assert.equal(out.response?.kind, 'worthlessKarama');
+    assert.deepEqual(out.moritaniRetention!.played, played);
+    if (cancelConversion) {
+      out = applyAction(reload(out), 'w', {
+        type: 'card',
+        card: k.id,
+        mode: 'cancel',
+      });
+      assert.equal(
+        out.response,
+        null,
+        'exhausted nested blockers allow retention automatically',
+      );
+      assert.equal(out.moritaniRetention, null);
+      assert.ok(p(out, 'l').hand.some((c) => c.id === keep));
+    }
+    out = allow(reload(out));
+    assert.equal(out.moritaniRetention, null);
+    assert.equal(
+      p(out, 'l').hand.some((c) => c.id === keep),
+      cancelConversion,
+    );
+    for (const id of played)
+      assert.equal(
+        p(out, 'l').hand.filter((c) => c.id === id).length +
+          out.discard.filter((c) => c.id === id).length,
+        1,
+      );
+  }
+});
+
+void test('retention resumes the already calculated CHOAM combat income once', () => {
+  const g = fixture();
+  g.advanced = true;
+  g.players.push(newPlayer('c', 'CHOAM', 'choam'));
+  g.order.push('c');
+  let out = cleanup(fight(g));
+  assert.equal(out.decision?.kind, 'moritaniRetention');
+  const pending = out.pendingChoamBattleIncome;
+  assert.ok(pending);
+  const spice = p(out, 'c').spice;
+  out = applyAction(reload(out), 'l', { type: 'decision', keep: null });
+  assert.equal(
+    out.response,
+    null,
+    'unopposed combat income settles once after retention',
+  );
+  out = allow(reload(out));
+  assert.equal(p(out, 'c').spice, spice + pending.amount);
+  assert.equal(out.pendingChoamBattleIncome, null);
+});
+
+void test('Karama responders can inspect the declared already-revealed card without receiving the remaining hand', () => {
+  const initial = fixture();
+  setHand(initial, 'w', [baseDeck().find((c) => c.effect === 'karama')!]);
+  let g = cleanup(fight(initial));
+  assert.equal(viewGame(g, 'm').moritaniRetentionCard, null);
+  const keep = g.moritaniRetention!.eligible[0];
+  g = applyAction(g, 'l', { type: 'decision', keep });
+  for (const id of ['w', 'l', 'm'])
+    assert.deepEqual(
+      viewGame(g, id).moritaniRetentionCard,
+      p(g, 'l').hand.find((c) => c.id === keep),
+    );
+  assert.equal(
+    viewGame(g, 'w').players.find((p) => p.id === 'l')!.hand,
+    undefined,
+  );
+  g = allow(g);
+  assert.equal(viewGame(g, 'm').moritaniRetentionCard, null);
+});