Preserve purchased price through Semuta without duplicate stop refund

tests/semuta-shipment-price.test.ts

@@ -0,0 +1,110 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { applyAction, viewGame, type Action, type Game } from '../game/engine';
+import {
+  createSemutaShipmentPrice, reactSemutaShipmentPrice,
+  semutaPurchasedShipment, allowSemutaPurchasedShipment,
+} from './fixture-semuta-shipment-price';
+
+const player = (game: Game, actor: string) => game.players.find(p => p.id === actor)!;
+function reject(game: Game, actor: string, action: Action) {
+  const before = structuredClone(game);
+  assert.throws(() => applyAction(game, actor, action));
+  assert.deepEqual(game, before);
+}
+
+for (const advanced of [false, true]) for (const homeworlds of [false, true])
+  void test(`${advanced ? 'Advanced' : 'Basic'} ${homeworlds ? 'typed world' : 'reserve'} price survives Semuta claim or decline and pays only bank once`, () => {
+    for (const claim of [false, true]) {
+      const f = createSemutaShipmentPrice({ advanced, homeworlds });
+      const beneficiary = player(f.game, f.beneficiary);
+      const spice = beneficiary.spice, reserves = beneficiary.reserves;
+      const guildSpice = player(f.game, f.guild).spice;
+      assert.equal(f.game.karamaShipping, null);
+      assert.equal(beneficiary.shipped, false);
+      reject(f.game, f.beneficiary, { type: 'endMovement' });
+      let game = reactSemutaShipmentPrice(f.game, claim);
+      assert.equal(viewGame(game, f.beneficiary).karamaShipping!.owner, f.owner);
+      assert.equal(player(game, f.holder).hand.some(card => card.id === f.karama), claim);
+      assert.equal(player(game, f.holder).hand.some(card => card.id === f.semuta), !claim);
+      assert.equal(player(game, f.beneficiary).spice, spice);
+      assert.equal(player(game, f.beneficiary).reserves, reserves);
+      const shipment = semutaPurchasedShipment(game, homeworlds);
+      game = applyAction(game, f.beneficiary, shipment.action);
+      game = allowSemutaPurchasedShipment(game);
+      assert.equal(player(game, f.beneficiary).spice, spice - shipment.cost);
+      assert.equal(player(game, f.beneficiary).reserves, reserves - 3);
+      assert.equal(player(game, f.guild).spice, guildSpice);
+      assert.equal(player(game, f.beneficiary).shipped, true);
+      assert.equal(player(game, f.beneficiary).moved, 0);
+      if (homeworlds) assert.deepEqual(game.homeworlds!.custody!.visitors[shipment.target][f.beneficiary], { normal: 3, elite: 0 });
+      else assert.equal(player(game, f.beneficiary).forces[shipment.target], 3);
+      assert.equal(game.karamaShipping, null);
+      assert.equal(player(game, f.holder).hand.some(card => card.id === f.karama), claim);
+      assert.equal(game.discard.filter(card => card.id === f.semuta).length, claim ? 1 : 0);
+      reject(game, f.beneficiary, shipment.action);
+    }
+  });
+
+for (const homeworlds of [false, true])
+  void test(`the SAME recovered price card can stop ${homeworlds ? 'typed world' : 'reserve'} shipment without being refunded to its former owner`, () => {
+    const f = createSemutaShipmentPrice({ homeworlds });
+    let game = reactSemutaShipmentPrice(f.game, true);
+    const original = structuredClone(player(game, f.beneficiary));
+    const shipment = semutaPurchasedShipment(game, homeworlds);
+    game = applyAction(game, f.beneficiary, shipment.action);
+    game = applyAction(game, f.guild, { type: 'card', card: f.karama, mode: 'special' });
+    const shipper = player(game, f.beneficiary);
+    assert.equal(shipper.spice, original.spice);
+    assert.equal(shipper.reserves, original.reserves);
+    assert.deepEqual(shipper.forces, original.forces);
+    assert.equal(shipper.shipped, true);
+    assert.equal(shipper.moved, 0);
+    assert.equal(player(game, f.owner).hand.some(card => card.id === f.karama), false);
+    assert.equal(player(game, f.guild).hand.some(card => card.id === f.karama), false);
+    assert.equal(game.discard.filter(card => card.id === f.karama).length, 1);
+    assert.equal(game.discard.filter(card => card.id === f.semuta).length, 1);
+    assert.equal(game.karamaShipping, null);
+    if (homeworlds) assert.equal(game.homeworlds!.custody!.visitors[shipment.target]?.[f.beneficiary], undefined);
+    else assert.equal(shipper.forces[shipment.target] ?? 0, 0);
+    game = applyAction(game, f.beneficiary, { type: 'endMovement' });
+    assert.notEqual(game.active, f.beneficiary);
+  });
+
+void test('declining the price cost retains its existing exact-card refund when another physical card pays the stop', () => {
+  for (const homeworlds of [false, true]) {
+    const f = createSemutaShipmentPrice({ homeworlds });
+    let game = reactSemutaShipmentPrice(f.game, false);
+    // CONTROLLED second-card acquisition, not an original-action producer.
+    // The original price and actual Guild stop still use distinct physical IDs.
+    const at = game.deck.findIndex(card => card.effect === 'karama'); assert.ok(at >= 0);
+    const stop = game.deck.splice(at, 1)[0]; player(game, f.guild).hand.push(stop);
+    const before = structuredClone(player(game, f.beneficiary));
+    const shipment = semutaPurchasedShipment(game, homeworlds);
+    game = applyAction(game, f.beneficiary, shipment.action);
+    game = applyAction(game, f.guild, { type: 'card', card: stop.id, mode: 'special' });
+    assert.equal(player(game, f.beneficiary).spice, before.spice);
+    assert.equal(player(game, f.beneficiary).reserves, before.reserves);
+    assert.equal(player(game, f.beneficiary).shipped, true);
+    assert.equal(player(game, f.owner).hand.filter(card => card.id === f.karama).length, 1);
+    assert.equal(game.discard.some(card => card.id === f.karama), false);
+    assert.equal(game.discard.filter(card => card.id === stop.id).length, 1);
+    assert.ok(player(game, f.holder).hand.some(card => card.id === f.semuta));
+    assert.equal(game.karamaShipping, null);
+  }
+});
+
+void test('wrong claimant and stale price-cost events cannot activate, duplicate or replace the original benefit', () => {
+  const f = createSemutaShipmentPrice();
+  const event = f.game.pendingTreacheryDiscard!.batch.event;
+  reject(f.game, f.owner, { type: 'semutaCommit', event });
+  reject(f.game, f.holder, { type: 'semutaCommit', event: 'old' });
+  reject(f.game, f.owner, f.action);
+  const game = reactSemutaShipmentPrice(f.game, true);
+  reject(game, f.holder, { type: 'semutaCommit', event });
+  reject(game, f.holder, { type: 'card', card: f.karama, mode: 'shipment', target: f.beneficiary });
+  const shipment = semutaPurchasedShipment(game);
+  const done = allowSemutaPurchasedShipment(applyAction(game, f.beneficiary, shipment.action));
+  assert.equal(player(done, f.beneficiary).spice, 7);
+  assert.equal(player(done, f.beneficiary).forces[shipment.target], 3);
+});