Apply player order to fresh Advanced Revival phases

This commit is contained in:
Quintine committed 2026-10-26 10:33:54 +11:00
1 parent fe6c41ba40
commit 011b6aa096
20 files changed
+1212 -46

No files matched your search

@@ -0,0 +1,225 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import { createElement } from 'react';
import { renderToStaticMarkup } from 'react-dom/server';
import { RevivalTurn, FinishRevivalTurn, finishRevivalTurnBlocked, revivalTurnOrderBlock } from '../components/revival-turn';
import { RevivalCommerce } from '../components/revival-commerce';
import { viewGame, type Action, type GameView } from '../game/engine';
import { createAdvancedRevivalOrderFixture, actAdvancedRevivalOrder } from './fixture-advanced-revival-order';
let original: ReturnType<typeof createAdvancedRevivalOrderFixture> | undefined;
function native() {
original ??= createAdvancedRevivalOrderFixture();
return { ...original, game: structuredClone(original.game) };
}
function projected() {
const source = native();
return viewGame(source.game, source.actor);
}
function markup(game: GameView, busy = false) {
return renderToStaticMarkup(createElement(RevivalTurn, { game, busy, act() {} }));
}
function commerce(game: GameView, busy = false) {
return renderToStaticMarkup(createElement(RevivalCommerce, { game, busy, act() {} }));
}
function button(html: string, label: string) {
const found = [...html.matchAll(/<button\b[^>]*>[\s\S]*?<\/button>/g)].map(match => match[0])
.find(value => value.includes(`>${label}</button>`));
assert.ok(found, `The ${label} button is visible`); return found;
}
function click(game: GameView, busy = false): Action[] {
const actions: Action[] = [];
FinishRevivalTurn({ game, busy, act(action) { actions.push(action); } }).props.onClick();
return actions;
}
function controlledCommerce(viewer: string, actor = viewer): GameView {
const source = native(), game = viewGame(source.game, viewer);
const originalOrder = [actor, ...game.players.map(player => player.id).filter(id => id !== actor)];
// Controlled personalized order/leader/negotiation cases supplement the
// native source below; they install no authoritative Game outcome or pieces.
game.revivalOrder = { version: 1, turn: game.turn, original: originalOrder,
remaining: [...originalOrder], completed: [], started: false };
game.active = actor;
game.revival.orderBlocked = actor === viewer ? null : 'Wait for the current Revival actor.';
return game;
}
void test('native first Revival renders persistent actor remaining completed and explicit force/leader grouping', () => {
const source = native(), game = viewGame(source.game, source.actor), before = structuredClone(game);
assert.deepEqual(game.revivalOrder!.original, source.originalOrder);
for (let render = 0; render < 3; render++) {
const html = markup(game);
assert.match(html, /aria-label="Revival turn order"/);
assert.ok(html.includes(`Current Revival actor: ${game.players.find(player => player.id === source.actor)!.name}.`));
assert.match(html, /Remaining Revival turns:/);
assert.match(html, /Completed Revival turns: None yet/);
for (const id of game.revivalOrder!.remaining) assert.ok(html.includes(game.players.find(player => player.id === id)!.name));
assert.match(html, /aria-label="Provisional Revival grouping"/);
assert.match(html, /force, leader and Kwisatz Haderach revival choices together/);
assert.match(html, /Tleilaxu can still answer another player’s requests/);
assert.doesNotMatch(button(html, 'Finish Revival turn'), /\sdisabled=/);
}
assert.deepEqual(game, before);
});
void test('the actual native Finish callback sends only ready and advances to the next original seat', () => {
const source = native(), game = viewGame(source.game, source.actor);
assert.deepEqual(click(game, true), []);
const actions = click(game);
assert.deepEqual(actions, [{ type: 'ready' }]);
const next = actAdvancedRevivalOrder(source.game, source.actor, actions[0]);
assert.equal(next.phase, 4);
assert.deepEqual(next.revivalOrder!.completed, [source.actor]);
assert.equal(next.active, next.revivalOrder!.remaining[0]);
const finished = viewGame(next, source.actor);
assert.match(markup(finished), /Your Revival turn is finished/);
assert.match(button(markup(finished), 'Finish Revival turn'), /\sdisabled=/);
assert.deepEqual(click(finished), []);
assert.deepEqual(click(viewGame(next, next.active!)), [{ type: 'ready' }]);
});
void test('each native seat can explicitly finish once and the last actual control leaves Revival', () => {
const source = native(); let game = source.game;
const actors: string[] = [];
while (game.phase === 4 && actors.length < source.originalOrder.length) {
const actor = game.revivalOrder!.remaining[0];
const actions = click(viewGame(game, actor));
assert.deepEqual(actions, [{ type: 'ready' }]);
actors.push(actor); game = actAdvancedRevivalOrder(game, actor, actions[0]);
}
assert.deepEqual(actors, source.originalOrder);
assert.equal(game.phase, 5);
assert.equal(markup(viewGame(game, source.owner)), '');
});
void test('genuine Basic and unstamped legacy Advanced views retain their existing controls without this component', () => {
const basic = createAdvancedRevivalOrderFixture({ advanced: false });
const basicView = viewGame(basic.game, basic.actor);
assert.equal(basicView.revivalOrder, null);
assert.equal(markup(basicView), '');
assert.deepEqual(click(basicView), []);
const legacy = projected(); legacy.revivalOrder = null;
assert.equal(markup(legacy), ''); assert.deepEqual(click(legacy), []);
assert.equal(revivalTurnOrderBlock(legacy), null);
});
void test('a different native viewer sees the current actor and a waiting reason while the actual callback is unavailable', () => {
const source = native(), game = viewGame(source.game, source.outOfTurn);
const html = markup(game);
assert.match(html, /Current Revival actor:/);
assert.ok(finishRevivalTurnBlocked(game));
assert.match(button(html, 'Finish Revival turn'), /\sdisabled=/);
assert.deepEqual(click(game), []);
game.revival.orderBlocked = '';
assert.deepEqual(click(game), [], 'Empty projected notices do not bypass the actual owner');
});
void test('busy finished and inconsistent current order projections guard the actual callback', () => {
const changes: ((game: GameView) => void)[] = [
game => { game.revivalOrder!.completed.push(game.me); },
game => { game.revivalOrder!.remaining = []; },
game => { game.revivalOrder!.turn++; },
game => { game.turn++; }, game => { game.phase = 5; },
game => { game.status = 'finished'; }, game => { game.active = null; },
game => { game.revival.orderBlocked = 'The current native turn is unavailable.'; },
];
for (const change of changes) {
const game = projected(); change(game);
assert.deepEqual(click(game), []);
assert.equal(FinishRevivalTurn({ game, busy: false, act() {} }).props.disabled, true);
}
assert.deepEqual(click(projected(), true), []);
const finished = projected(); finished.revivalOrder!.remaining = [];
assert.match(markup(finished), /All Revival turns are finished/);
});
void test('pending Revival response decision automatic action and owned autopilot prevent early finishing', () => {
const changes: ((game: GameView) => void)[] = [
game => { game.response = { kind: 'revivalIncome', owner: game.me, passed: [] }; },
game => { game.decision = { kind: 'revivalStop', player: game.me, recipient: game.me, revival: 'forces' }; },
game => { game.truthtrance = {} as NonNullable<GameView['truthtrance']>; },
game => { game.phaseOpening = { passed: [] }; },
game => { game.revival.pending = true; },
game => { game.automaticContinuationPending = true; },
game => { game.players.find(player => player.id === game.me)!.autopilot = 'Easy'; },
];
for (const change of changes) {
const game = projected(); change(game);
assert.deepEqual(click(game), []);
assert.match(button(markup(game), 'Finish Revival turn'), /\sdisabled=/);
}
});
void test('a stale actual callback cannot finish another actor or a new Revival round', () => {
for (const anotherRound of [false, true]) {
const game = projected(), actions: Action[] = [];
const leaf = FinishRevivalTurn({ game, busy: false, act(action) { actions.push(action); } });
assert.equal(leaf.props.disabled, false);
if (anotherRound) { game.turn++; game.revivalOrder!.turn++; }
else {
game.revivalOrder!.completed.push(game.me); game.revivalOrder!.remaining.shift();
game.active = game.revivalOrder!.remaining[0];
}
leaf.props.onClick(); assert.deepEqual(actions, []);
}
});
void test('an unaccepted negotiated request does not remove the current explicit Finish choice', () => {
const game = projected();
game.revivalRequests[game.me] = { leader: game.players.find(player => player.id === game.me)!.leaders[0].id, price: null };
assert.deepEqual(click(game), [{ type: 'ready' }]);
assert.doesNotMatch(button(markup(game), 'Finish Revival turn'), /\sdisabled=/);
});
void test('controlled native request accept and withdrawal controls follow own turn without disabling the entire commerce panel', () => {
const source = native();
for (const ownsTurn of [true, false]) {
const game = controlledCommerce(source.owner, ownsTurn ? source.owner : source.responder);
const me = game.players.find(player => player.id === game.me)!;
me.spice = 50; me.leaders[0].dead = true;
game.revivalRequests[game.me] = { leader: me.leaders[0].id, price: 2 };
const html = commerce(game);
for (const label of ['Accept revival price', 'Withdraw request']) {
if (ownsTurn) assert.doesNotMatch(button(html, label), /\sdisabled=/);
else assert.match(button(html, label), /\sdisabled=/);
}
delete game.revivalRequests[game.me];
const request = commerce(game);
const selector = request.match(/<select\b[^>]*id="revival-request-leader"[^>]*>/)?.[0];
assert.ok(selector);
if (ownsTurn) assert.doesNotMatch(selector, /\sdisabled=/);
else assert.match(selector, /\sdisabled=/);
}
});
void test('controlled out-of-turn Tleilaxu can quote decline and support others while their own foreign ghola remains unavailable', () => {
const source = native();
for (const ownsTurn of [true, false]) {
const game = controlledCommerce(source.responder, ownsTurn ? source.responder : source.owner);
const me = game.players.find(player => player.id === game.me)!;
const other = game.players.find(player => player.id === source.owner)!;
me.spice = 50; me.leaders[0].dead = true; me.ally = other.id; other.leaders[0].dead = true;
game.revivalRules.expanded = []; game.revivalRules.limitBlocked = false;
game.revivalRules.discountBlocked = false; game.revivalRules.allyDiscount = null;
game.revivalRequests[other.id] = { leader: other.leaders[0].id, price: null };
const html = commerce(game);
const ghola = [...html.matchAll(/<button\b[^>]*>[\s\S]*?<\/button>/g)].map(match => match[0]).find(value => value.includes('as a ghola'));
assert.ok(ghola);
if (ownsTurn) assert.doesNotMatch(ghola, /\sdisabled=/);
else assert.match(ghola, /\sdisabled=/);
for (const label of ['Quote this price', 'Decline request', 'Allow five revivals', 'Offer ally half-price revival'])
assert.doesNotMatch(button(html, label), /\sdisabled=/);
for (const label of ['Quote this price', 'Decline request', 'Allow five revivals', 'Offer ally half-price revival'])
assert.match(button(commerce(game, true), label), /\sdisabled=/);
}
});
void test('the order display and actual Finish callback read only public order actor names and owned action availability', () => {
const game = projected();
for (const player of game.players) for (const field of ['hand', 'traitors', 'faceDancers', 'spice', 'reserves', 'leaders', 'forces', 'tanks'])
Object.defineProperty(player, field, { get() { throw Error(`Revival order read unrelated ${player.id}.${field}`); } });
for (const field of ['homeworlds', 'revivalRequests', 'allLeaders'])
Object.defineProperty(game, field, { get() { throw Error(`Revival order read unrelated ${field}`); } });
assert.match(markup(game), /Current Revival actor:/);
assert.deepEqual(click(game), [{ type: 'ready' }]);
});