Expand Basic bribe windows and fix marker guidance

tests/basic-native-bribe-interruptions.test.ts

@@ -0,0 +1,204 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFileSync } from 'node:fs';
+import { runInNewContext } from 'node:vm';
+import { createElement, isValidElement, type ReactElement, type ReactNode } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import * as jsxRuntime from 'react/jsx-runtime';
+import ts from 'typescript';
+import * as catalog from '../game/catalog';
+import * as bribeOptions from '../game/bribe-options';
+import { createGame, joinGame, newPlayer, viewGame, type Action, type Game } from '../game/engine';
+import { botActions } from '../game/bots';
+import { DIFFICULTIES } from '../game/bot-profiles';
+import { bribeAction } from '../game/bribe-options';
+import { actTruthMovementNativeEarly as act, nextTruthMovementNativeEarlyStep } from './fixture-truth-movement-native-early';
+import { truthMovementInventory as inventory } from './fixture-truth-movement';
+
+const payer = 'richese', recipient = 'ecaz', atreides = 'atreides', fremen = 'fremen', emperor = 'emperor';
+const seat = (g: Game, id: string) => {
+  const player = g.players.find(p => p.id === id); assert.ok(player); return player;
+};
+const clean = (g: Game) => !g.response && !g.decision && !g.phaseOpening && !g.truthtrance && !g.pendingTreacheryDiscard;
+const reload = (g: Game): Game => JSON.parse(JSON.stringify(g));
+function next(g: Game) {
+  if (g.status === 'setup' && g.setupStage === 'forces' && seat(g, fremen).reserves === 20 &&
+      viewGame(g, fremen).setupPending.includes(fremen))
+    return {actor:fremen, action:{type:'fremenSetup', placements:{'sietch_tabr:14':10}} satisfies Action};
+  if (g.phase === 5 && g.active === emperor && clean(g))
+    return {actor:emperor, action:{type:'endMovement'} satisfies Action};
+  return nextTruthMovementNativeEarlyStep(g, {position:'first', method:'onceAround', direction:'clockwise'});
+}
+function reach(game: Game, until: (g: Game) => boolean): Game {
+  for (let count = 0; count < 2400; count++) {
+    if (until(game)) return game;
+    assert.notEqual(game.status, 'finished');
+    const step = next(game); assert.ok(step, `Native action required at ${game.turn}/${game.phase}/${game.decision?.kind}`);
+    game = act(game, step.actor, step.action);
+  }
+  throw Error('The native Basic mixed-faction control was not reached');
+}
+/** Genuine public mixed-deck setup. Only the original unopened starting order
+ * and a later conserved physical card swap are chosen to ensure an Emperor
+ * Karama keeps the native Atreides/Fremen response open. */
+function originalGame() {
+  let game = createGame('NATIVEBRIBES', newPlayer(atreides, 'Atreides', 'atreides'), false, ['ix','choam','ecaz']);
+  for (const faction of [fremen, emperor, payer, 'choam', recipient] as const)
+    joinGame(game, newPlayer(faction, faction, faction));
+  for (const p of game.players) game = act(game, p.id, {type:'ready'});
+  game = act(game, game.host, {type:'start'});
+  assert.equal(game.status, 'setup'); assert.equal(game.advanced, false);
+  const originalCards = inventory(game);
+  game = reach(game, state => state.status === 'playing');
+  assert.equal(game.semutaPreview, true);
+  const holder = seat(game, emperor);
+  if (!holder.hand.some(card => card.effect === 'karama')) {
+    const fromDeck = game.deck.findIndex(card => card.effect === 'karama');
+    assert.ok(holder.hand.length);
+    if (fromDeck >= 0) [holder.hand[0], game.deck[fromDeck]] = [game.deck[fromDeck], holder.hand[0]];
+    else {
+      const other = game.players.find(p => p.id !== emperor && p.hand.some(card => card.effect === 'karama'));
+      assert.ok(other);
+      const index = other.hand.findIndex(card => card.effect === 'karama');
+      [holder.hand[0], other.hand[index]] = [other.hand[index], holder.hand[0]];
+    }
+  }
+  assert.deepEqual(inventory(game), originalCards);
+  return {game, originalCards};
+}
+let saved: ReturnType<typeof originalGame> | undefined;
+const source = () => saved ??= originalGame();
+const payment: Action = {type:'bribe', target:recipient, amount:1};
+function reject(g: Game, actor: string, action: Action) {
+  const before = structuredClone(g); assert.throws(() => act(g, actor, action)); assert.deepEqual(g, before);
+}
+function paid(game: Game) {
+  const before = structuredClone(game), options = viewGame(game,payer).bribeOptions;
+  assert.equal(options.blocked,null);
+  assert.deepEqual(bribeAction(options,recipient,1),payment);
+  const after = act(game,payer,payment);
+  assert.deepEqual(after.response,before.response); assert.deepEqual(after.decision,before.decision);
+  assert.deepEqual(after.auction,before.auction); assert.deepEqual(after.pendingRevival,before.pendingRevival);
+  assert.equal(seat(after,payer).spice,seat(before,payer).spice-1);
+  assert.equal(seat(after,recipient).spice,seat(before,recipient).spice);
+  assert.equal(seat(after,recipient).bribes,seat(before,recipient).bribes+1);
+  assert.deepEqual(inventory(after),source().originalCards);
+  reject(game,payer,{type:'bribe',target:payer,amount:1});
+  return after;
+}
+function inspectSource() {
+  return reach(structuredClone(source().game), state => state.turn === 1 && state.phase === 3 &&
+    state.response?.kind === 'atreidesAuction' && !!state.auction && !state.richeseAuction);
+}
+function auctionSource() {
+  let g = inspectSource();
+  g = reach(g, state => state.phase === 3 && clean(state) && !!state.auction && state.auction.active === emperor);
+  g = act(g,emperor,{type:'bid',amount:1,allyPayment:0});
+  return reach(g, state => state.decision?.kind === 'auctionPayment' && state.decision.player === emperor);
+}
+function grantSource() {
+  let g = reach(structuredClone(source().game), state => state.turn === 1 && state.phase === 4 && clean(state));
+  // The response is opened by the real grant. Stage only an otherwise valid
+  // reciprocal alliance and one physically conserved casualty for its target.
+  seat(g,fremen).ally = atreides; seat(g,atreides).ally = fremen;
+  assert.ok(seat(g,atreides).reserves > 0);
+  seat(g,atreides).reserves--; seat(g,atreides).tanks++;
+  g = act(g,fremen,{type:'grantRevival'});
+  assert.equal(g.response?.kind,'fremenRevivalGrant');
+  return g;
+}
+
+void test('a mixed native faction table preserves Atreides inspection while a nonally pays a bribe', () => {
+  const before = inspectSource(), after = paid(before);
+  const control = act(before,emperor,{type:'passResponse'});
+  const done = act(after,emperor,{type:'passResponse'});
+  assert.deepEqual(done.auction,control.auction);
+  assert.notEqual(done.response?.kind,'atreidesAuction');
+  assert.equal(seat(done,recipient).bribes,seat(before,recipient).bribes+1);
+});
+
+void test('a mixed native faction table preserves a winning auction invoice and purchase through a bribe', () => {
+  const before = auctionSource(), lot = before.auction!.cards[before.auction!.index].id;
+  const after = paid(before), done = act(after,emperor,{type:'decision',karama:false});
+  const delivered = reach(done,state => seat(state,emperor).hand.some(card => card.id === lot));
+  assert.equal(seat(delivered,emperor).hand.filter(card => card.id === lot).length,1);
+  assert.equal(seat(delivered,recipient).bribes,seat(before,recipient).bribes+1);
+  assert.deepEqual(inventory(delivered),source().originalCards);
+});
+
+void test('a mixed native faction table preserves the actual Fremen grant response and its original result', () => {
+  const before = grantSource(), after = paid(before);
+  const control = act(before,emperor,{type:'passResponse'}), done = act(after,emperor,{type:'passResponse'});
+  assert.deepEqual(done.freeRevival,control.freeRevival);
+  assert.ok(done.freeRevival.includes(atreides));
+  assert.equal(seat(done,recipient).bribes,seat(before,recipient).bribes+1);
+});
+
+void test('the original human and bot responders retain legal choices after the bribe', () => {
+  for (const g of [inspectSource(),grantSource()]) {
+    const after = paid(g);
+    for (const difficulty of DIFFICULTIES) {
+      const view = viewGame(after,emperor);
+      view.players.find(p => p.id === emperor)!.bot = difficulty;
+      const action = botActions(view).find(choice => choice.type === 'passResponse' || choice.type === 'card' && choice.mode === 'cancel');
+      assert.ok(action,difficulty);
+      assert.doesNotThrow(() => act(reload(after),emperor,action));
+    }
+  }
+});
+
+void test('the rendered mixed-faction bribe control pays once and preserves the actual inspection', () => {
+  let game = inspectSource();
+  const original = structuredClone(game.response), before = seat(game,payer).spice;
+  const states: unknown[] = [], sent: Action[] = [];
+  let cursor = 0;
+  const exported: {Bribes?: (props: {game: ReturnType<typeof viewGame>; busy: boolean; act: (action: Action) => void}) => ReactNode} = {};
+  runInNewContext(ts.transpileModule(readFileSync(new URL('../components/bribes.tsx', import.meta.url), 'utf8'), {
+    compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2022,jsx:ts.JsxEmit.ReactJSX},
+  }).outputText, {exports:exported,require(name:string) {
+    if (name === 'react/jsx-runtime') return jsxRuntime;
+    if (name === 'react') return {useId:() => 'native-bribe',useState(initial:unknown) {
+      const index = cursor++;
+      if (!(index in states)) states[index] = typeof initial === 'function' ? initial() : initial;
+      return [states[index], (value:unknown) => {states[index] = typeof value === 'function' ? value(states[index]) : value;}];
+    }};
+    if (name === '@/game/catalog') return catalog;
+    if (name === '@/game/bribe-options') return bribeOptions;
+    if (name === '@/components/ui/button') return {Button:'button'};
+    throw Error(`Unexpected import ${name}`);
+  }});
+  assert.ok(exported.Bribes);
+  type Element = ReactElement<{children?: ReactNode; [key: string]: unknown}>;
+  const elements = (node: ReactNode): Element[] => {
+    if (Array.isArray(node)) return node.flatMap(elements);
+    if (!isValidElement<{children?: ReactNode; [key: string]: unknown}>(node)) return [];
+    return [node,...elements(node.props.children)];
+  };
+  const render = () => {
+    cursor = 0;
+    return exported.Bribes!({game:viewGame(game,payer),busy:false,act(action) {
+      sent.push(action); game = act(game,payer,action);
+    }});
+  };
+  let nodes = elements(render());
+  const select = nodes.find(node => node.type === 'select'); assert.ok(select);
+  assert.equal(select.props.disabled,false);
+  (select.props.onChange as (event: {target: {value: string}}) => void)({target:{value:recipient}});
+  nodes = elements(render());
+  const button = nodes.find(node => node.type === 'button'); assert.ok(button);
+  assert.equal(button.props.disabled,false);
+  assert.match(renderToStaticMarkup(createElement(() => render())),/Mentat Pause/);
+  (button.props.onClick as () => void)();
+  assert.deepEqual(JSON.parse(JSON.stringify(sent)),[payment]);
+  assert.equal(seat(game,payer).spice,before-1);
+  assert.deepEqual(game.response,original);
+  const done = act(game,emperor,{type:'passResponse'});
+  assert.notEqual(done.response?.kind,'atreidesAuction');
+});
+
+void test('an actual Ecaz placement keeps the bribe unavailable', () => {
+  const game = reach(structuredClone(source().game), state => state.phase === 4 &&
+    state.decision?.kind === 'ecazPlacement');
+  assert.ok(viewGame(game,payer).bribeOptions.blocked);
+  reject(game,payer,payment);
+});