Connect native Guild and BG own-arrival continuations
This commit is contained in:
1 parent
e265af3cb3
commit
c10fe0b48c
19 files changed
+1051
-268
No files matched your search
@@ -0,0 +1,219 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import {
|
||||
applyAction, createGame, initializeFactionExpansionsGameForAudit, joinGame,
|
||||
newPlayer, type Action, type Game,
|
||||
} from '../game/engine';
|
||||
import { nextRicheseSkillsTechNativeStep } from './fixture-richese-skills-tech';
|
||||
|
||||
export type BgAmbassadorArrivalStep = { actor: string; action: Action };
|
||||
export type BgAmbassadorArrivalFixture = {
|
||||
initial: Game;
|
||||
afterSetup: Game;
|
||||
beforePlacement: Game;
|
||||
beforeShipment: Game;
|
||||
game: Game;
|
||||
actions: BgAmbassadorArrivalStep[];
|
||||
owner: string;
|
||||
advisor: string;
|
||||
entrant: string;
|
||||
territory: string;
|
||||
location: string;
|
||||
token: string;
|
||||
fighters: boolean;
|
||||
shipmentAction: Action;
|
||||
movementAction: Action;
|
||||
staging: string[];
|
||||
};
|
||||
|
||||
export function bgAmbassadorArrivalPlayer(game: Game, actor: string) {
|
||||
const player = game.players.find(player => player.id === actor);
|
||||
assert.ok(player, `Missing original BG arrival seat ${actor}`);
|
||||
return player;
|
||||
}
|
||||
const clean = (game: Game) => !game.phaseOpening && !game.response && !game.decision && !game.pendingTreacheryDiscard;
|
||||
|
||||
/** Native entropy only: original shuffles/deals retain their physical inventories.
|
||||
* No hand, force, wallet, stance, turn, receipt or decision is assigned. */
|
||||
function entropy<T>(run: () => T): T {
|
||||
const descriptor = Object.getOwnPropertyDescriptor(crypto, 'getRandomValues');
|
||||
crypto.getRandomValues = <V extends ArrayBufferView | null>(array: V): V => {
|
||||
assert.ok(array);
|
||||
new Uint8Array(array.buffer, array.byteOffset, array.byteLength).fill(255);
|
||||
return array;
|
||||
};
|
||||
try { return run(); }
|
||||
finally {
|
||||
if (descriptor) Object.defineProperty(crypto, 'getRandomValues', descriptor);
|
||||
else Reflect.deleteProperty(crypto, 'getRandomValues');
|
||||
}
|
||||
}
|
||||
|
||||
/** Original no-spend/no-call driver, including the native owned BG controls. */
|
||||
export function nextBgAmbassadorArrivalStep(game: Game): BgAmbassadorArrivalStep {
|
||||
if (!game.phaseOpening && !game.response) {
|
||||
const bg = game.players.find(player => player.faction === 'beneGesserit')!;
|
||||
const ecaz = game.players.find(player => player.faction === 'ecaz')!;
|
||||
if (game.status === 'setup' && game.setupStage === 'prediction')
|
||||
return { actor: bg.id, action: { type: 'predict', faction: 'emperor', turn: 10 } };
|
||||
if (game.status === 'setup' && game.setupStage === 'forces') {
|
||||
if (ecaz.reserves === 20)
|
||||
return { actor: ecaz.id, action: { type: 'ecazSetup', placements: { 'imperial_basin:10': 6 } } };
|
||||
if (!bg.advisorSetup)
|
||||
return { actor: bg.id, action: { type: 'advisorSetup', territory: 'imperial_basin', sector: 10 } };
|
||||
}
|
||||
const decision = game.decision;
|
||||
if (decision?.kind === 'ecazPlacement')
|
||||
return { actor: decision.player, action: { type: 'decision', decline: true } };
|
||||
if (decision?.kind === 'advisor' || decision?.kind === 'intrusion' || decision?.kind === 'advisorBattle')
|
||||
return { actor: decision.player, action: { type: 'decision', accept: false } };
|
||||
if (decision?.kind === 'ecazAmbassador') {
|
||||
assert.ok(game.pendingAmbassador);
|
||||
return { actor: decision.player, action: { type: 'decision', event: game.pendingAmbassador.event, decline: true } };
|
||||
}
|
||||
}
|
||||
const step = nextRicheseSkillsTechNativeStep(game);
|
||||
if (step.action.type === 'stormDial') step.action.amount = 0;
|
||||
return step;
|
||||
}
|
||||
|
||||
export function applyBgAmbassadorArrivalStep(
|
||||
game: Game, step: BgAmbassadorArrivalStep, actions?: BgAmbassadorArrivalStep[],
|
||||
): Game {
|
||||
actions?.push(structuredClone(step));
|
||||
return entropy(() => applyAction(game, step.actor, step.action));
|
||||
}
|
||||
|
||||
function advance(game: Game, until: (state: Game) => boolean, actions: BgAmbassadorArrivalStep[]): Game {
|
||||
for (let n = 0; n < 2400; n++) {
|
||||
if (until(game)) return game;
|
||||
assert.notEqual(game.status, 'finished', 'Original BG arrival must remain in its native game');
|
||||
game = applyBgAmbassadorArrivalStep(game, nextBgAmbassadorArrivalStep(game), actions);
|
||||
}
|
||||
throw Error('Original native BG arrival did not reach the requested boundary');
|
||||
}
|
||||
|
||||
/** Finish only original response/acknowledgement windows. In particular this
|
||||
* never silently chooses Intrusion, accompaniment or the Ambassador offer. */
|
||||
export function settleBgAmbassadorArrivalControls(game: Game, actions: BgAmbassadorArrivalStep[] = []): Game {
|
||||
return advance(game, state => !state.response && !state.phaseOpening && !state.pendingTreacheryDiscard, actions);
|
||||
}
|
||||
|
||||
function orderLandBlows(game: Game, staging: string[]) {
|
||||
for (let at = 0; at < 2; at++) {
|
||||
const index = game.spiceDeck.findIndex((card, index) => index >= at && 'territory' in card &&
|
||||
!['imperial_basin', 'carthag'].includes(card.territory));
|
||||
assert.ok(index >= at, 'Two original undealt land blows must remain');
|
||||
const card = game.spiceDeck.splice(index, 1)[0];
|
||||
game.spiceDeck.splice(at, 0, card);
|
||||
assert.ok('territory' in card);
|
||||
staging.push(`Turn ${game.turn}: original undealt ${card.territory} land blow moved to slot ${at + 1}.`);
|
||||
}
|
||||
}
|
||||
|
||||
/** Original Advanced Ecaz/BG/Emperor setup and paid entry, stopped BEFORE ship.
|
||||
* In the fighter variant the original Imperial Basin advisor actually moves to
|
||||
* empty Carthag on turn one, becoming a fighter by the native automatic rule.
|
||||
* Ecaz leaves turn-one placement unused, then marks Carthag on turn two: no
|
||||
* preceding BG Ambassador trigger or fabricated fighter group is needed.
|
||||
* The only controlled values are producer entropy, a conserved undealt Karama
|
||||
* starting-deal slot and unplayed Spice order. Supplied fresh lobbies retain
|
||||
* their original seat identities; no HTTP authentication claim is made. */
|
||||
export function createBgAmbassadorArrivalFixture(options: { initial?: Game; fighters?: boolean } = {}): BgAmbassadorArrivalFixture {
|
||||
let game = options.initial ? structuredClone(options.initial)
|
||||
: createGame('BGAMBASSADORARRIVAL', newPlayer('bg', 'Bene Gesserit', 'beneGesserit'), true, ['ecaz']);
|
||||
if (!options.initial) {
|
||||
joinGame(game, newPlayer('ecaz', 'Ecaz', 'ecaz'));
|
||||
joinGame(game, newPlayer('emperor', 'Emperor', 'emperor'));
|
||||
}
|
||||
assert.equal(game.status, 'lobby', 'Only an original undealt lobby can enter');
|
||||
assert.equal(game.advanced, true);
|
||||
assert.deepEqual(game.expansions, ['ecaz']);
|
||||
assert.equal(game.players.length, 3);
|
||||
const owner = game.players.find(player => player.faction === 'ecaz')?.id;
|
||||
const advisor = game.players.find(player => player.faction === 'beneGesserit')?.id;
|
||||
const entrant = game.players.find(player => player.faction === 'emperor')?.id;
|
||||
assert.ok(owner && advisor && entrant, 'Original seats must be Ecaz, Bene Gesserit and Emperor');
|
||||
const initial = structuredClone(game), actions: BgAmbassadorArrivalStep[] = [], staging: string[] = [];
|
||||
for (const player of game.players)
|
||||
if (!player.ready) game = applyBgAmbassadorArrivalStep(game, { actor: player.id, action: { type: 'ready' } }, actions);
|
||||
game = entropy(() => initializeFactionExpansionsGameForAudit(game));
|
||||
// Give Ecaz a real cancellation opportunity through its ORIGINAL starting
|
||||
// deal, not a card transfer into an already dealt hand.
|
||||
const dealSlot = game.players.findIndex(player => player.id === owner);
|
||||
const karamaIndex = game.deck.findIndex(card => card.effect === 'karama');
|
||||
assert.ok(karamaIndex >= 0 && game.players.every(player => !player.hand.length));
|
||||
const karama = game.deck[karamaIndex].id;
|
||||
[game.deck[dealSlot], game.deck[karamaIndex]] = [game.deck[karamaIndex], game.deck[dealSlot]];
|
||||
staging.push(`Original undealt ${karama} swapped into Ecaz's starting-deal slot ${dealSlot + 1}; no dealt hand is changed.`);
|
||||
game = advance(game, state => state.status === 'playing', actions);
|
||||
const afterSetup = structuredClone(game);
|
||||
assert.ok(bgAmbassadorArrivalPlayer(game, owner).hand.some(card => card.id === karama));
|
||||
assert.equal(bgAmbassadorArrivalPlayer(game, advisor).forces['imperial_basin:10'], 1);
|
||||
assert.ok(bgAmbassadorArrivalPlayer(game, advisor).advisors?.imperial_basin);
|
||||
game = advance(game, state => state.phase === 1 && clean(state), actions);
|
||||
orderLandBlows(game, staging);
|
||||
const fighters = options.fighters ?? false;
|
||||
if (fighters) {
|
||||
game = advance(game, state => state.phase === 5 && state.active === advisor && clean(state), actions);
|
||||
game = applyBgAmbassadorArrivalStep(game, { actor: advisor, action: {
|
||||
type: 'move', from: 'imperial_basin:10', territory: 'carthag', sector: 11, amount: 1,
|
||||
} }, actions);
|
||||
game = settleBgAmbassadorArrivalControls(game, actions);
|
||||
assert.ok(clean(game));
|
||||
assert.equal(bgAmbassadorArrivalPlayer(game, advisor).forces['carthag:11'], 1);
|
||||
assert.equal(bgAmbassadorArrivalPlayer(game, advisor).advisors?.carthag, undefined);
|
||||
game = advance(game, state => state.turn === 2 && state.phase === 1 && clean(state), actions);
|
||||
orderLandBlows(game, staging);
|
||||
}
|
||||
game = advance(game, state => state.phase === 4 && state.decision?.kind === 'ecazPlacement', actions);
|
||||
const beforePlacement = structuredClone(game);
|
||||
const token = game.ecazAmbassadors!.tokens.find(token => token.effect === 'ecaz')!;
|
||||
assert.equal(token.zone, 'supply');
|
||||
const placementWallet = bgAmbassadorArrivalPlayer(game, owner).spice;
|
||||
game = applyBgAmbassadorArrivalStep(game, { actor: owner, action: {
|
||||
type: 'decision', token: token.id, territory: 'carthag',
|
||||
} }, actions);
|
||||
game = settleBgAmbassadorArrivalControls(game, actions);
|
||||
assert.equal(bgAmbassadorArrivalPlayer(game, owner).spice, placementWallet - 1);
|
||||
assert.equal(game.ecazAmbassadors!.tokens.find(candidate => candidate.id === token.id)!.location, 'carthag');
|
||||
assert.equal(game.decision?.kind, 'ecazPlacement');
|
||||
game = applyBgAmbassadorArrivalStep(game, { actor: owner, action: { type: 'decision', decline: true } }, actions);
|
||||
game = advance(game, state => state.phase === 5 && state.active === entrant && clean(state), actions);
|
||||
assert.equal(bgAmbassadorArrivalPlayer(game, advisor).forces['carthag:11'] ?? 0, fighters ? 1 : 0);
|
||||
assert.ok(!game.pendingAmbassador && !game.pendingArrivalReaction?.length);
|
||||
const beforeShipment = structuredClone(game);
|
||||
return {
|
||||
initial, afterSetup, beforePlacement, beforeShipment, game, actions, owner, advisor, entrant,
|
||||
territory: 'carthag', location: 'carthag:11', token: token.id, fighters, staging,
|
||||
shipmentAction: { type: 'ship', territory: 'carthag', sector: 11, amount: 1, elite: 0, allyPayment: 0 },
|
||||
movementAction: { type: 'move', from: 'carthag:11', territory: 'arsunt', sector: 11, amount: 1 },
|
||||
};
|
||||
}
|
||||
|
||||
/** First bad transition is intentionally outside the original builder. */
|
||||
export function beginBgAmbassadorArrival(fixture: BgAmbassadorArrivalFixture): Game {
|
||||
return settleBgAmbassadorArrivalControls(applyBgAmbassadorArrivalStep(fixture.game, {
|
||||
actor: fixture.entrant, action: fixture.shipmentAction,
|
||||
}));
|
||||
}
|
||||
|
||||
export function bgAmbassadorAccompanimentAction(accept: boolean, accompany = true): Action {
|
||||
return accept ? { type: 'decision', accept: true, accompany, amount: 1 }
|
||||
: { type: 'decision', accept: false };
|
||||
}
|
||||
export function bgAmbassadorIntrusionAction(accept: boolean): Action {
|
||||
return { type: 'decision', accept };
|
||||
}
|
||||
export function bgAmbassadorOfferAction(game: Game, trigger = false): Action {
|
||||
const entry = game.pendingAmbassador;
|
||||
assert.ok(entry);
|
||||
return trigger ? { type: 'decision', event: entry.event, trigger: true, beneficiary: entry.owner, choice: 'duke' }
|
||||
: { type: 'decision', event: entry.event, decline: true };
|
||||
}
|
||||
export function finishBgAmbassadorArrival(game: Game, trigger = false): Game {
|
||||
const entry = game.pendingAmbassador;
|
||||
assert.ok(entry);
|
||||
return settleBgAmbassadorArrivalControls(applyBgAmbassadorArrivalStep(game, {
|
||||
actor: entry.owner, action: bgAmbassadorOfferAction(game, trigger),
|
||||
}));
|
||||
}
|
||||
Reference in new issue
Block a user