Respect storm sector for rides into mobile stronghold

tests/worm-ride-mobile-storm-runtime.test.ts

@@ -0,0 +1,133 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { applyAction, createGame, newPlayer, viewGame, type Action, type Game } from '../game/engine';
+import { botActions } from '../game/bots';
+import { DIFFICULTIES } from '../game/bot-profiles';
+import { MOBILE_LOCATION, MOBILE_STRONGHOLD, location, territory } from '../game/board';
+import { fremenCunningPublicDestinationBlock } from '../game/nexus-fremen-cunning';
+import { greatMakerRideAction } from '../game/great-maker-options';
+import { createFremenCunningModulesFixture, completeFremenCunningModules } from './fixture-fremen-cunning-modules';
+import { advanceNativeHomeworld, createNativeHomeworldDiscoveryProgramme } from './fixture-homeworld-native-e1e2-modules';
+
+const source = location('the_great_flat', territory('the_great_flat').sectors[0]);
+const ride = (destination: string): Action => ({ type: 'decision', accept: true,
+  territory: destination, sector: 0, forces: { [source]: 4 } });
+
+/** Conserved staged supplement to the real action path: Fremen, Ixians, and
+ * Emperor use Basic Ix, with a placed mobile stronghold and worm decision.
+ * The worm, placement and earlier chronology are staged, not replayed. */
+function fixture(pointer = 'arsunt:11', storm = 11): Game {
+  const game = createGame('WORMHMS', newPlayer('f', 'Fremen', 'fremen'), false, ['ix']);
+  game.players.push(newPlayer('i', 'Ixians', 'ixians'), newPlayer('e', 'Emperor', 'emperor'));
+  Object.assign(game, { status: 'playing', phase: 1, turn: 2, storm, active: 'f',
+    order: ['f', 'i', 'e'], spiceSequence: { pile: 1, skipped: [] }, wormRides: [],
+    decision: { kind: 'wormRide', player: 'f', territory: 'the_great_flat' },
+    mobileStronghold: { location: pointer } });
+  for (const player of game.players) Object.assign(player, { hand: [], forces: {}, reserves: 20, spice: 10 });
+  game.players[0].forces = { [source]: 4 };
+  game.players[0].reserves = 16;
+  return game;
+}
+
+void test('a worm ride cannot enter the mobile stronghold through its storm-covered pointer', () => {
+  const game = fixture(), before = structuredClone(game);
+  assert.throws(() => applyAction(game, 'f', ride(MOBILE_STRONGHOLD)), /storm/i);
+  assert.deepEqual(game, before, 'rejection preserves the pending ride and all counters');
+  const sink = applyAction(game, 'f', ride('polar_sink'));
+  assert.equal(sink.players[0].forces['polar_sink:0'], 4);
+  assert.equal(sink.players[0].reserves, 16);
+});
+
+void test('a clear pointed sector permits the ride, including a pointer at Polar Sink', () => {
+  for (const game of [fixture('arsunt:11', 12), fixture('polar_sink:0', 11)]) {
+    const next = applyAction(game, 'f', ride(MOBILE_STRONGHOLD));
+    assert.equal(next.players[0].forces[MOBILE_LOCATION], 4);
+    assert.equal(next.players[0].forces[source] ?? 0, 0);
+    assert.equal(next.players[0].reserves, 16);
+    assert.equal(next.mobileStronghold?.location, game.mobileStronghold?.location);
+  }
+});
+
+void test('all four bot profiles omit storm-blocked mobile arrivals and offer legal rides', () => {
+  for (const difficulty of DIFFICULTIES) {
+    for (const game of [fixture(), fixture('arsunt:11', 12)]) {
+      const view = viewGame(game, 'f');
+      view.players.find(player => player.id === 'f')!.bot = difficulty;
+      const before = structuredClone(view), actions = botActions(view);
+      assert.deepEqual(view, before);
+      const accepted = actions.filter(action => action.type === 'decision' && action.accept === true);
+      assert.ok(accepted.length, `${difficulty} needs a legal ride`);
+      assert.ok(actions.some(action => action.type === 'decision' && action.accept === false));
+      if (game.storm === 11)
+        assert.ok(accepted.every(action => action.territory !== MOBILE_STRONGHOLD), difficulty);
+      for (const action of actions)
+        assert.doesNotThrow(() => applyAction(game, 'f', action), `${difficulty}: ${JSON.stringify(action)}`);
+    }
+  }
+});
+
+void test('the native Fremen Cunning ride uses the same public storm quote for the placed Ixian stronghold', () => {
+  const native = createFremenCunningModulesFixture({ expansions: ['ix', 'ecaz'],
+    factions: ['fremen', 'guild', 'emperor', 'ixians'], hmsAtSource: true });
+  assert.equal(native.hmsPlacement?.after.mobileStronghold?.location, 'wind_pass:14');
+  const game = completeFremenCunningModules(native).beforeRide;
+  assert.equal(game.decision?.kind, 'nexusFremenCunningRide');
+  assert.equal(game.mobileStronghold?.location, 'wind_pass:14');
+  // Stage a conserved move within Wind Pass so the ride source remains clear
+  // while the stronghold's original pointing sector is under the storm. The
+  // worm, Cunning card and Ix placement come from the native chronology.
+  const staged = structuredClone(game), rider = staged.players.find(p => p.id === 'fremen')!;
+  const oldSource = native.sourceKey, newSource = 'wind_pass:16';
+  const count = rider.forces[oldSource], elite = rider.elites?.forces[oldSource] ?? 0;
+  assert.equal(count, 3); assert.equal(rider.forces[newSource] ?? 0, 0);
+  delete rider.forces[oldSource]; rider.forces[newSource] = count;
+  if (rider.elites && elite) {
+    delete rider.elites.forces[oldSource]; rider.elites.forces[newSource] = elite;
+  }
+  const blocked = structuredClone(staged), clear = structuredClone(staged);
+  blocked.storm = 14; clear.storm = 15;
+  const destination = { territory: MOBILE_STRONGHOLD, sector: 0 };
+  assert.match(fremenCunningPublicDestinationBlock(blocked, 'fremen', 'wind_pass', destination) ?? '', /storm/i);
+  assert.equal(fremenCunningPublicDestinationBlock(clear, 'fremen', 'wind_pass', destination), null);
+  assert.match(fremenCunningPublicDestinationBlock(viewGame(blocked, 'fremen'), 'fremen', 'wind_pass', destination) ?? '', /storm/i);
+  assert.equal(fremenCunningPublicDestinationBlock(viewGame(clear, 'fremen'), 'fremen', 'wind_pass', destination), null);
+  assert.ok(blocked.decision?.kind === 'nexusFremenCunningRide');
+  const action: Action = { type: 'decision', event: blocked.decision.event, accept: true,
+    source: 'wind_pass', forces: { [newSource]: { normal: count - elite, elite } },
+    territory: MOBILE_STRONGHOLD, sector: 0 };
+  const before = structuredClone(blocked);
+  assert.throws(() => applyAction(blocked, 'fremen', action), /storm/i);
+  assert.deepEqual(blocked, before);
+  const next = applyAction(clear, 'fremen', action);
+  const moved = next.players.find(p => p.id === 'fremen')!;
+  assert.equal(moved.forces[MOBILE_LOCATION], count);
+  assert.equal(moved.forces[newSource] ?? 0, 0);
+  assert.equal(moved.elites?.forces[MOBILE_LOCATION] ?? 0, elite);
+});
+
+void test('a native Great Maker ride hides the storm-covered mobile destination and rejects it at execution', () => {
+  const native = createNativeHomeworldDiscoveryProgramme({ maker: true, face: 'cistern', tech: true });
+  let game = advanceNativeHomeworld(native.game, state => state.decision?.kind === 'greatMakerVote');
+  while (game.decision?.kind === 'greatMakerVote')
+    game = applyAction(game, game.decision.player, { type: 'decision', event: game.decision.event, yes: false });
+  assert.equal(game.decision?.kind, 'greatMakerRide');
+  assert.ok(game.mobileStronghold?.location);
+  // The native encounter and votes are real. This comparison stages only the
+  // already-placed stronghold pointer and storm to isolate the shared gate.
+  const blocked = structuredClone(game), clear = structuredClone(game);
+  blocked.mobileStronghold!.location = 'arsunt:11'; blocked.storm = 11;
+  clear.mobileStronghold!.location = 'arsunt:11'; clear.storm = 12;
+  const blockedView = viewGame(blocked, 'fremen'), clearView = viewGame(clear, 'fremen');
+  assert.equal(blockedView.greatMaker!.ride!.destinations.some(d => d.territory === MOBILE_STRONGHOLD), false);
+  assert.equal(greatMakerRideAction(blockedView, MOBILE_STRONGHOLD, 0, 1, 0), null);
+  assert.ok(blocked.decision?.kind === 'greatMakerRide');
+  const forbidden: Action = { type: 'decision', event: blocked.decision.event, accept: true,
+    territory: MOBILE_STRONGHOLD, sector: 0, amount: 1, elite: 0 };
+  const before = structuredClone(blocked);
+  assert.throws(() => applyAction(blocked, 'fremen', forbidden));
+  assert.deepEqual(blocked, before);
+  assert.ok(clearView.greatMaker!.ride!.destinations.some(d => d.territory === MOBILE_STRONGHOLD));
+  const allowed = greatMakerRideAction(clearView, MOBILE_STRONGHOLD, 0, 1, 0); assert.ok(allowed);
+  const next = applyAction(clear, 'fremen', allowed);
+  assert.equal(next.players.find(p => p.id === 'fremen')!.forces[MOBILE_LOCATION], 1);
+});