Apply ruled Grumman return and Cunning placement

tests/fixture-ruled-grumman.ts

@@ -0,0 +1,151 @@
+import assert from 'node:assert/strict';
+import {
+  applyAction, createGame, initializeHomeworldGameForAudit, initializeNexusGameForAudit,
+  joinGame, newPlayer, type Action, type Game,
+} from '../game/engine';
+import { territory } from '../game/board';
+import { treacheryDeck } from '../game/cards';
+import { homeworldGameIntegrity } from '../game/homeworld-game';
+import { NEXUS_FACTIONS, validateNexusCards } from '../game/nexus-cards';
+import { TERROR_KINDS } from '../game/moritani-terror';
+import { nextNativeE3HomeworldStep } from './fixture-homeworld-native-e3-modules';
+
+export type RuledGrummanStep = { actor: string; action: Action };
+export type RuledGrummanFixture = {
+  game: Game;
+  owner: string;
+  placed: string;
+  placedTerritory: string;
+  initial: Game;
+  afterSetup: Game;
+  beforePlacement: Game;
+  afterPlacement: Game;
+  previousCollection: Game;
+  beforeCollection: Game;
+  drawing: Game | null;
+  afterDraw: Game | null;
+  census: { treachery: string[]; terror: string[]; nexus: string[] };
+  actions: RuledGrummanStep[];
+};
+
+/** Select only the original undealt lotteries, retaining all native stock. */
+function initialize(game: Game, nexus: boolean): Game {
+  const descriptor = Object.getOwnPropertyDescriptor(crypto, 'getRandomValues');
+  crypto.getRandomValues = <T extends ArrayBufferView | null>(array: T): T => {
+    assert.ok(array);
+    new Uint8Array(array.buffer, array.byteOffset, array.byteLength).fill(255);
+    return array;
+  };
+  try { return nexus ? initializeNexusGameForAudit(game) : initializeHomeworldGameForAudit(game); }
+  finally {
+    if (descriptor) Object.defineProperty(crypto, 'getRandomValues', descriptor);
+    else Reflect.deleteProperty(crypto, 'getRandomValues');
+  }
+}
+
+/** Move only still-unplayed Spice cards; never empty or redeal the discard. */
+function frontSpice(game: Game, kinds: ('land' | 'worm')[]): void {
+  for (const [position, kind] of kinds.entries()) {
+    const index = game.spiceDeck.findIndex((card, at) => at >= position &&
+      (kind === 'land' ? 'territory' in card : 'worm' in card));
+    assert.ok(index >= position);
+    game.spiceDeck.splice(position, 0, game.spiceDeck.splice(index, 1)[0]);
+  }
+}
+
+export function assertRuledGrummanInventory(game: Game): void {
+  homeworldGameIntegrity(game);
+  for (const player of game.players) {
+    assert.equal(player.reserves + player.tanks + Object.values(player.forces).reduce((a, b) => a + b, 0), 20);
+    if (player.elites) assert.equal(player.elites.reserves + player.elites.tanks +
+      Object.values(player.elites.forces).reduce((a, b) => a + b, 0), 5);
+  }
+  assert.deepEqual([...game.deck, ...game.discard, ...game.players.flatMap(p => p.hand),
+    ...(game.auction?.cards.slice(game.auction.index) ?? [])].map(c => c.id).sort(),
+  treacheryDeck(game.expansions).map(c => c.id).sort());
+  assert.deepEqual(game.moritaniTerror!.tokens.map(t => t.kind).sort(), [...TERROR_KINDS].sort());
+  assert.equal(new Set(game.moritaniTerror!.tokens.map(t => t.id)).size, 6);
+  if (game.nexusCards) validateNexusCards(game.nexusCards.cards!, game.players);
+}
+
+/** Genuine setup → first Collection → Mentat placement → next Collection.
+ * No force, population, phase, turn, wallet, hand or earned receipt is staged.
+ * The Nexus variant plays an actual second-turn worm and original card draw. */
+export function createRuledGrummanFixture(options: { advanced?: boolean; nexus?: boolean } = {}): RuledGrummanFixture {
+  const owner = 'moritani', placedTerritory = 'arrakeen';
+  let game = createGame('RULEDGRUMMAN', newPlayer(owner, 'Moritani', 'moritani'), options.advanced ?? false, options.nexus ? ['ecaz'] : []);
+  joinGame(game, newPlayer('guild', 'Guild', 'guild'));
+  joinGame(game, newPlayer('emperor', 'Emperor', 'emperor'));
+  game = applyAction(game, owner, { type: 'homeworlds', enabled: true });
+  if (options.nexus) game.nexusCards = { cards: null, phase: null };
+  const initial = structuredClone(game), actions: RuledGrummanStep[] = [];
+  function act(step: RuledGrummanStep): void {
+    actions.push(structuredClone(step));
+    game = applyAction(game, step.actor, step.action);
+  }
+  for (const player of game.players) act({ actor: player.id, action: { type: 'ready' } });
+  game = initialize(game, !!options.nexus);
+  let afterSetup: Game | undefined, previousCollection: Game | undefined;
+  let beforePlacement: Game | undefined, afterPlacement: Game | undefined, beforeCollection: Game | undefined;
+  let drawing: Game | null = null, afterDraw: Game | null = null, placed: string | undefined;
+  let spiceTurn = 0;
+  for (let count = 0; count < 500; count++) {
+    if (game.status === 'playing' && !afterSetup) {
+      afterSetup = structuredClone(game);
+      if (options.nexus) {
+        const deck = game.nexusCards!.cards!.deck;
+        const at = deck.indexOf('moritani'); assert.ok(at >= 0);
+        deck.unshift(deck.splice(at, 1)[0]);
+      }
+    }
+    if (game.status === 'playing' && game.phase === 0 && spiceTurn !== game.turn) {
+      frontSpice(game, options.nexus && game.turn === 2 ? ['worm', 'land', 'land'] : ['land', 'land']);
+      spiceTurn = game.turn;
+    }
+    if (options.nexus && game.nexus && !game.spiceWindow && !game.spiceResolution &&
+      !game.response && !game.phaseOpening && !game.decision && !game.players.find(p => p.id === 'guild')!.ally) {
+      act({ actor: 'guild', action: { type: 'alliance', target: 'emperor' } });
+      act({ actor: 'emperor', action: { type: 'alliance', target: 'guild' } });
+    }
+    if (game.turn === 2 && game.decision?.kind === 'grummanCollection' && !game.response && !game.phaseOpening) break;
+    if (game.turn === 2 && game.phase === 5) beforeCollection = structuredClone(game);
+    const decision = game.decision;
+    let step: RuledGrummanStep | null;
+    if (!game.response && !game.phaseOpening && decision?.kind === 'moritaniSetup') {
+      step = { actor: owner, action: { type: 'decision', territory: 'habbanya_ridge_sietch', sector: territory('habbanya_ridge_sietch').sectors[0] } };
+    } else if (!game.response && !game.phaseOpening && decision?.kind === 'grummanCollection') {
+      previousCollection = structuredClone(game);
+      step = { actor: owner, action: { type: 'decision', event: game.grummanCollection!.event, decline: true } };
+    } else if (!game.response && !game.phaseOpening && decision?.kind === 'moritaniPlacement' && game.turn === 1) {
+      beforePlacement = structuredClone(game);
+      placed = game.moritaniTerror!.tokens.find(t => t.kind === 'robbery')!.id;
+      step = { actor: owner, action: { type: 'decision', token: placed, territory: placedTerritory } };
+    } else if (!game.response && !game.phaseOpening && !decision && game.nexusCards?.phase?.stage === 'drawing') {
+      const actor = game.nexusCards.phase.eligible.find(id => !game.nexusCards!.phase!.done.includes(id)); assert.ok(actor);
+      if (actor === owner) drawing = structuredClone(game);
+      step = { actor, action: { type: 'nexusCardChoice', turn: game.turn, card: game.nexusCards.cards!.hands[actor] ?? null,
+        choice: actor === owner ? 'draw' : 'keep', ownRedraws: 0 } };
+    } else step = nextNativeE3HomeworldStep(game);
+    assert.ok(step, `Native Grumman programme stalled at ${game.status}/${game.turn}/${game.phase}/${decision?.kind}`);
+    act(step);
+    if (beforePlacement && !afterPlacement && game.moritaniTerror!.tokens.some(t => t.id === placed && t.status === 'placed'))
+      afterPlacement = structuredClone(game);
+    if (drawing && !afterDraw && game.nexusCards!.cards!.hands[owner] === 'moritani') afterDraw = structuredClone(game);
+  }
+  assert.equal(game.turn, 2); assert.equal(game.phase, 7); assert.equal(game.decision?.kind, 'grummanCollection');
+  assert.ok(afterSetup && previousCollection && beforePlacement && afterPlacement && beforeCollection && placed);
+  assert.equal(game.players.find(p => p.id === owner)!.reserves, 14);
+  assert.ok(!game.players.find(p => p.id === owner)!.ally);
+  assert.equal(game.moritaniTerror!.placementTurn, 1);
+  assert.equal(game.moritaniTerror!.tokens.find(t => t.id === placed)!.location, placedTerritory);
+  assert.ok(game.moritaniTerror!.tokens.some(t => t.status === 'available'));
+  if (options.nexus) {
+    assert.ok(drawing && afterDraw, `Native Nexus draw missing: ${JSON.stringify({ phase: game.nexusCards?.phase, discards: game.spiceDiscard, actions: actions.filter(s => s.action.type === 'nexusCardChoice') })}`);
+    assert.equal(game.nexusCards!.cards!.hands[owner], 'moritani');
+  }
+  assertRuledGrummanInventory(game);
+  return { game, owner, placed, placedTerritory, initial, afterSetup, previousCollection, beforePlacement, afterPlacement,
+    beforeCollection, drawing, afterDraw, actions,
+    census: { treachery: treacheryDeck(game.expansions).map(c => c.id).sort(), terror: [...TERROR_KINDS].sort(),
+      nexus: options.nexus ? [...NEXUS_FACTIONS].sort() : [] } };
+}