Initial commit

tests/bot-plan-legality-review.test.ts

@@ -0,0 +1,304 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  applyAction,
+  createGame,
+  newPlayer,
+  viewGame,
+  type Game,
+  type Action,
+} from '../game/engine';
+import { botActions } from '../game/bots';
+import { DIFFICULTIES, type Difficulty } from '../game/bot-profiles';
+import { baseDeck, ixBattleCards, leaders, type Card } from '../game/cards';
+import { richeseCards } from '../game/richese-cards';
+
+type VoiceKind = NonNullable<NonNullable<Game['battle']>['voice']>['kind'];
+
+function fixture(advanced = false): Game {
+  const g = createGame(
+    'PLANLEGALREVIEW',
+    newPlayer('p', 'Planner', 'emperor'),
+    advanced,
+  );
+  g.players.push(newPlayer('o', 'Opponent', 'guild'));
+  Object.assign(g, {
+    status: 'playing',
+    phase: 6,
+    turn: 2,
+    storm: 18,
+    active: 'p',
+    order: ['p', 'o'],
+  });
+  for (const p of g.players)
+    Object.assign(p, {
+      forces: { 'arrakeen:10': 4 },
+      reserves: 16,
+      spice: 10,
+      hand: [],
+      traitors: [],
+    });
+  g.battle = {
+    territory: 'arrakeen',
+    attacker: 'p',
+    defender: 'o',
+    prepared: true,
+    plans: {},
+    revealed: false,
+    traitorCalls: {},
+  };
+  return g;
+}
+function card(kind: Card['kind']) {
+  const c = [...baseDeck(), ...ixBattleCards()].find((c) => c.kind === kind);
+  assert.ok(c, kind);
+  return c;
+}
+function unavailable(g: Game) {
+  g.players[0].leaders.forEach((l) => {
+    l.usedAt = 'carthag';
+  });
+}
+function projection(g: Game, difficulty: Difficulty) {
+  const v = viewGame(g, 'p');
+  v.players[0].bot = difficulty;
+  return v;
+}
+function plans(g: Game, difficulty: Difficulty) {
+  const v = projection(g, difficulty),
+    before = structuredClone(v);
+  const actions = botActions(v).filter((a) => a.type === 'battlePlan');
+  assert.ok(
+    actions.length > 0,
+    `${difficulty}: a legal battle must remain finishable`,
+  );
+  assert.deepEqual(
+    v,
+    before,
+    'Planning must not mutate the private projection.',
+  );
+  for (const action of actions) {
+    assert.doesNotThrow(
+      () => applyAction(g, 'p', action),
+      `${difficulty}: ${JSON.stringify(action)}`,
+    );
+    assert.ok(
+      !action.weapon || action.weapon !== action.defense,
+      'One physical card cannot occupy both slots.',
+    );
+  }
+  return actions;
+}
+
+void test('independent plan review: every profile uses available leaders and offers only empty slots when no leader can fight', () => {
+  for (const difficulty of DIFFICULTIES) {
+    const g = fixture();
+    g.players[0].hand = [card('projectile'), card('shield'), card('worthless')];
+    assert.ok(plans(g, difficulty).every((a) => a.leader));
+    unavailable(g);
+    const empty = plans(g, difficulty);
+    assert.ok(
+      empty.every((a) => !a.leader && !a.weapon && !a.defense && !a.kwisatz),
+    );
+    g.players[0].leaders[0].usedAt = 'arrakeen';
+    assert.ok(
+      plans(g, difficulty).every(
+        (a) => a.leader === g.players[0].leaders[0].id,
+      ),
+      'A disc used in this territory remains available.',
+    );
+  }
+});
+
+void test('independent plan review: a sole Cheap Hero is mandatory except when forbidden by Voice', () => {
+  for (const difficulty of DIFFICULTIES) {
+    const g = fixture();
+    unavailable(g);
+    const hero = card('hero');
+    g.players[0].hand = [hero, card('poison'), card('snooper')];
+    assert.ok(plans(g, difficulty).every((a) => a.leader === hero.id));
+    g.battle!.voice = { target: 'p', kind: 'hero', must: false };
+    assert.ok(
+      plans(g, difficulty).every((a) => !a.leader && !a.weapon && !a.defense),
+    );
+    g.players[0].leaders[0].usedAt = 'arrakeen';
+    assert.ok(
+      plans(g, difficulty).every(
+        (a) => a.leader === g.players[0].leaders[0].id,
+      ),
+    );
+    g.battle!.voice.must = true;
+    assert.ok(plans(g, difficulty).every((a) => a.leader === hero.id));
+  }
+});
+
+void test('independent plan review: Voice compulsion and prohibition use actual Weirding Way and Chemistry roles', () => {
+  const configurations: {
+    hand: Card[];
+    kind: VoiceKind;
+    must: boolean;
+    required: (a: Action) => boolean;
+    optional?: (a: Action) => boolean;
+  }[] = [
+    {
+      hand: [card('weirdingWay'), card('poison'), card('shield')],
+      kind: 'projectile',
+      must: true,
+      required: (a) => a.weapon === card('weirdingWay').id,
+    },
+    {
+      hand: [card('weirdingWay'), card('poison')],
+      kind: 'projectile',
+      must: false,
+      required: (a) => a.weapon !== card('weirdingWay').id,
+      optional: (a) => a.defense === card('weirdingWay').id,
+    },
+    {
+      hand: [card('weirdingWay'), card('poison')],
+      kind: 'shield',
+      must: true,
+      required: () => true,
+      optional: (a) => !a.defense,
+    },
+    {
+      hand: [card('chemistry'), card('shield')],
+      kind: 'snooper',
+      must: true,
+      required: (a) => a.defense === card('chemistry').id,
+    },
+    {
+      hand: [card('chemistry'), card('shield')],
+      kind: 'snooper',
+      must: false,
+      required: (a) => a.defense !== card('chemistry').id,
+      optional: (a) => a.weapon === card('chemistry').id,
+    },
+    {
+      hand: [card('chemistry'), card('shield')],
+      kind: 'poison',
+      must: true,
+      required: () => true,
+      optional: (a) => !a.weapon,
+    },
+    {
+      hand: [card('shieldSnooper')],
+      kind: 'snooper',
+      must: true,
+      required: (a) => a.defense === card('shieldSnooper').id,
+    },
+    {
+      hand: [card('poisonBlade')],
+      kind: 'projectile',
+      must: true,
+      required: (a) => a.weapon === card('poisonBlade').id,
+    },
+  ];
+  for (const difficulty of DIFFICULTIES)
+    for (const configuration of configurations) {
+      const g = fixture();
+      g.players[0].hand = configuration.hand;
+      g.battle!.voice = {
+        target: 'p',
+        kind: configuration.kind,
+        must: configuration.must,
+      };
+      const actions = plans(g, difficulty);
+      assert.ok(
+        actions.every(configuration.required),
+        `${difficulty} ${configuration.kind} ${configuration.must}`,
+      );
+      if (configuration.optional)
+        assert.ok(
+          actions.some(configuration.optional),
+          'Voice cannot force an alternate role or prohibit a different played role.',
+        );
+    }
+});
+
+void test('independent plan review: canonical Portable Snooper obeys ordinary Snooper Voice and an absent required type does not force cards', () => {
+  for (const difficulty of DIFFICULTIES) {
+    const g = fixture(),
+      portable = richeseCards().find((c) => c.effect === 'portableSnooper')!;
+    g.players[0].hand = [portable, card('projectile')];
+    g.battle!.voice = { target: 'p', kind: 'snooper', must: true };
+    assert.ok(plans(g, difficulty).every((a) => a.defense === portable.id));
+    g.battle!.voice.must = false;
+    assert.ok(plans(g, difficulty).every((a) => a.defense !== portable.id));
+    g.battle!.voice = { target: 'p', kind: 'hero', must: true };
+    assert.ok(plans(g, difficulty).some((a) => !a.weapon && !a.defense));
+    g.battle!.voice = { target: 'o', kind: 'projectile', must: false };
+    assert.ok(
+      plans(g, difficulty).some((a) => a.weapon === card('projectile').id),
+      'Voice targeting the opponent must not restrict this player.',
+    );
+  }
+});
+
+void test('independent plan review: captured and foreign ghola custody replace unavailable native discs without inventing ownership', () => {
+  for (const difficulty of DIFFICULTIES)
+    for (const custody of ['capturedBy', 'gholaBy'] as const) {
+      const g = fixture(true);
+      unavailable(g);
+      g.players[0].leaders[0].usedAt = undefined;
+      g.players[0].leaders[0].capturedBy = 'o';
+      const foreign = g.players[1].leaders[0];
+      foreign[custody] = 'p';
+      if (custody === 'capturedBy')
+        foreign.concealed = { captor: 'p', dead: false, deaths: 0 };
+      const actions = plans(g, difficulty);
+      assert.ok(actions.every((a) => a.leader === foreign.id));
+      foreign.usedAt = 'carthag';
+      assert.ok(plans(g, difficulty).every((a) => !a.leader));
+    }
+});
+
+void test('independent plan review: committed Cheap Hero and leaderless Prescience states recompute KH from the final leader', () => {
+  for (const difficulty of DIFFICULTIES) {
+    const g = fixture(true);
+    g.players[0].faction = 'atreides';
+    g.players[0].leaders = leaders('atreides');
+    g.players[0].battleLosses = 7;
+    g.players[0].kwisatz = { dead: false };
+    const hero = card('hero');
+    g.players[0].hand = [hero, card('shield')];
+    g.battle!.prescience = { player: 'o', field: 'leader', value: hero.id };
+    assert.ok(plans(g, difficulty).every((a) => a.leader === hero.id));
+    g.players[0].hand = [card('shield')];
+    unavailable(g);
+    g.battle!.prescience.value = null;
+    assert.ok(
+      plans(g, difficulty).every(
+        (a) => !a.leader && !a.weapon && !a.defense && !a.kwisatz,
+      ),
+    );
+  }
+});
+
+void test('independent plan review: uninspected opposing hand, balance and sealed plan cannot alter candidates', () => {
+  for (const difficulty of DIFFICULTIES) {
+    const g = fixture();
+    g.players[0].hand = [card('projectile'), card('shield'), card('worthless')];
+    g.players[1].hand = [card('poison')];
+    g.battle!.plans.o = {
+      dial: 0,
+      support: 0,
+      leader: 'guild-0',
+      weapon: null,
+      defense: null,
+    };
+    const before = botActions(projection(g, difficulty));
+    const changed = structuredClone(g);
+    changed.players[1].spice = 99999;
+    changed.players[1].hand = [card('snooper')];
+    changed.battle!.plans.o = {
+      dial: 4,
+      support: 0,
+      leader: 'guild-4',
+      weapon: null,
+      defense: card('snooper').id,
+    };
+    assert.deepEqual(botActions(projection(changed, difficulty)), before);
+    plans(g, difficulty);
+    plans(changed, difficulty);
+  }
+});