Honor group alliances in Truthtrance

tests/coalition-unlimited-worm-engine.test.ts

@@ -0,0 +1,146 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { baseDeck, spiceDeck } from '../game/cards';
+import { coalitionOf, emptyCoalitionState } from '../game/coalition-alliance';
+import { botActions } from '../game/bots';
+import { DIFFICULTIES } from '../game/bot-profiles';
+import { applyAction, createGame, newPlayer, viewGame, type Action, type Game } from '../game/engine';
+
+const act = (game: Game, id: string, action: Action) => applyAction(game, id, action);
+const seat = (game: Game, id: string) => game.players.find(player => player.id === id)!;
+const location = 'red_chasm:7';
+
+/** The unlimited ledger, Nexus and later Spice Blow are staged. All pair and
+ * group admissions, the worm draw and its choices/responses are actual engine
+ * actions. Physical forces and the actual Karama cards are conserved. */
+function source(entrantIds: readonly string[], fremenPresent = false) {
+  let game = createGame('UNLIMITEDWORM', newPlayer('f', 'Fremen', 'fremen'), false);
+  game.players.push(newPlayer('e', 'Emperor', 'emperor'), newPlayer('a', 'Atreides', 'atreides'),
+    newPlayer('h', 'Harkonnen', 'harkonnen'), newPlayer('g', 'Guild', 'guild'),
+    newPlayer('b', 'Bene Gesserit', 'beneGesserit'));
+  Object.assign(game, {status:'playing', phase:1, turn:2, nexus:true,
+    order:['f','e','a','h','g','b'], ready:[], response:null, decision:null,
+    phaseOpening:null, storm:18, deck:baseDeck()});
+  game.coalitionState = emptyCoalitionState('unlimited');
+  game = act(game, 'f', {type:'alliance', target:'e'});
+  game = act(game, 'e', {type:'alliance', target:'f'});
+  for (const entrant of entrantIds) {
+    const group = coalitionOf(game.players, game.coalitionState, 'f'); assert.ok(group);
+    game = act(game, 'f', {type:'coalitionPropose', groupId:group.id, entrant,
+      expectedRevision:game.coalitionState!.revision});
+    for (const id of [...group.members.filter(member => member !== 'f'), entrant]) {
+      const proposal = game.coalitionState!.proposal!;
+      game = act(game, id, {type:'coalitionAnswer', event:proposal.event, nexus:proposal.nexus,
+        turn:proposal.turn, accept:true, expectedRevision:game.coalitionState!.revision});
+    }
+  }
+  Object.assign(game, {phase:1, turn:3, nexus:false, ready:[], response:null, decision:null,
+    phaseOpening:null, storm:18, active:null, stormPending:null});
+  for (const player of game.players) {
+    player.hand = []; player.forces = {}; player.reserves = 20; player.tanks = 0;
+    player.traitors = []; player.traitorChoices = [];
+  }
+  const group = coalitionOf(game.players, game.coalitionState, 'f'); assert.ok(group);
+  const outsider = game.players.find(player => !group.members.includes(player.id)); assert.ok(outsider);
+  for (const id of [...group.members.filter(member => member !== 'f'), outsider.id,
+    ...(fremenPresent ? ['f'] : [])]) {
+    seat(game,id).forces = {[location]:3}; seat(game,id).reserves = 17;
+  }
+  const index = game.deck.findIndex(card => card.effect === 'karama'); assert.ok(index >= 0);
+  const [karama] = game.deck.splice(index,1); outsider.hand.push(karama);
+  // Keep a distinct physical counter available for the later survival
+  // response after the outsider spends the first Karama on one ally.
+  let survivalKarama: typeof karama | undefined;
+  if (fremenPresent) {
+    const counter = game.deck.findIndex(card => card.effect === 'karama'); assert.ok(counter >= 0);
+    [survivalKarama] = game.deck.splice(counter,1);
+    seat(game,'b').hand.push(survivalKarama);
+  }
+  const spice = spiceDeck();
+  const land = spice.find(card => 'territory' in card && card.territory === 'red_chasm');
+  const worm = spice.find(card => 'worm' in card); assert.ok(land && worm);
+  game.spiceDiscard = [[land], []];
+  game.spiceDeck = [worm, ...spice.filter(card => card !== land && card !== worm && 'territory' in card)];
+  game.spice = {[location]:8};
+  for (const player of game.players) game = act(game, player.id, {type:'ready'});
+  assert.equal(game.decision?.kind,'wormProtection');
+  return {game, karama, survivalKarama, outsider:outsider.id};
+}
+
+function pass(game: Game, kind: string): Game {
+  for (let count = 0; game.response?.kind === kind && count < 32; count++) {
+    const actor = game.players.find(player => !game.response!.passed.includes(player.id));
+    assert.ok(actor); game = act(game, actor.id, {type:'passResponse'});
+  }
+  assert.notEqual(game.response?.kind, kind);
+  return game;
+}
+function choose(game: Game, accept: boolean): Game {
+  assert.equal(game.decision?.kind,'wormProtection'); assert.ok(game.decision.event);
+  return act(game,'f',{type:'decision',accept,event:game.decision.event,ally:game.decision.ally});
+}
+function conserved(game: Game) {
+  for (const player of game.players)
+    assert.equal(player.reserves + player.tanks + Object.values(player.forces).reduce((a,b) => a+b,0),20);
+}
+
+void test('four-member group resolves three distinct worm protections before Fremen survival', () => {
+  const initial = source(['a','h'], true);
+  let {game} = initial;
+  assert.deepEqual(game.coalitionWormProtection?.order,['e','a','h']);
+  assert.equal(game.decision?.kind,'wormProtection'); assert.equal(game.decision.ally,'e');
+  game = pass(choose(game,true),'wormAllyProtection');
+  assert.equal(game.decision?.kind,'wormProtection'); assert.equal(game.decision.ally,'a');
+  game = choose(game,true);
+  assert.equal(game.response?.kind,'wormAllyProtection'); assert.equal(game.response.recipient,'a');
+  game = act(game, initial.outsider, {type:'card',mode:'cancel',card:initial.karama.id});
+  game = pass(game,'wormAllyProtection');
+  assert.equal(game.decision?.kind,'wormProtection'); assert.equal(game.decision.ally,'h');
+  game = choose(game,false);
+  assert.equal(game.response?.kind,'wormSurvival');
+  assert.deepEqual(game.coalitionWormProtection?.outcomes,[
+    {ally:'e',outcome:'allowed'}, {ally:'a',outcome:'canceled'}, {ally:'h',outcome:'declined'},
+  ]);
+  game = pass(game,'wormSurvival');
+  for (const id of ['e','f']) assert.equal(seat(game,id).forces[location],3);
+  for (const id of ['a','h',initial.outsider]) {
+    assert.equal(seat(game,id).forces[location] ?? 0,0); assert.equal(seat(game,id).tanks,3);
+  }
+  assert.equal(game.discard.filter(card => card.id === initial.karama.id).length,1);
+  assert.ok(initial.survivalKarama && seat(game,'b').hand.some(card => card.id === initial.survivalKarama!.id));
+  assert.equal(game.spice[location],undefined);
+  assert.deepEqual(game.wormRides,['red_chasm']);
+  assert.equal(game.coalitionWormProtection,undefined);
+  conserved(game);
+});
+
+void test('five-member group offers every threatened ally in order with legal bot choices', () => {
+  const initial = source(['a','h','g']);
+  let game = initial.game;
+  const {outsider} = initial;
+  assert.deepEqual(game.coalitionWormProtection?.order,['e','a','h','g']);
+  const seen:string[] = [];
+  let first:Action | undefined;
+  while (game.decision?.kind === 'wormProtection') {
+    const {ally,event} = game.decision; assert.ok(event); seen.push(ally);
+    for (const difficulty of DIFFICULTIES) {
+      const view = viewGame(game,'f');
+      view.players.find(player => player.id === 'f')!.bot = difficulty;
+      const action = botActions(view).find(candidate => candidate.type === 'decision' && typeof candidate.accept === 'boolean');
+      assert.ok(action, difficulty); assert.equal(action.event,event); assert.equal(action.ally,ally);
+      assert.doesNotThrow(() => act(game,'f',action));
+    }
+    if (first) {
+      const before = structuredClone(game);
+      assert.throws(() => act(game,'f',first!)); assert.deepEqual(game,before);
+    } else first = {type:'decision',accept:false,event,ally};
+    game = choose(game,ally === 'g');
+    game = pass(game,'wormAllyProtection');
+  }
+  assert.deepEqual(seen,['e','a','h','g']);
+  assert.equal(seat(game,'g').forces[location],3);
+  for (const id of ['e','a','h',outsider]) assert.equal(seat(game,id).tanks,3);
+  assert.equal(game.spice[location],undefined);
+  assert.equal(game.nexus,true);
+  conserved(game);
+});