86 lines
4.3 KiB
TypeScript
86 lines
4.3 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import {
|
|
applyAction, createGame, initializeLeaderSkillsGameForAudit,
|
|
joinGame, newPlayer, viewGame, type Game, type Action,
|
|
} from '../game/engine';
|
|
import { validateLeaderSkills } from '../game/leader-skills';
|
|
import { createTechTokens } from '../game/tech-tokens';
|
|
import { createStrongholdCards } from '../game/stronghold-cards';
|
|
import { withSpiceBankerIncomeSetupRandomness } from './fixture-spice-banker-income';
|
|
import { nextClassicNexusSkillsPaymentsNativeStep } from './fixture-classic-nexus-skills-payments';
|
|
|
|
export const nexusBankerPlayer = (game: Game, id: string) => {
|
|
const player = game.players.find(p => p.id === id);
|
|
assert.ok(player);
|
|
return player;
|
|
};
|
|
export const nexusBankerClean = (game: Game) => !game.phaseOpening && !game.response && !game.decision;
|
|
export function nexusBankerStep(game: Game): Game {
|
|
const step = nextClassicNexusSkillsPaymentsNativeStep(game);
|
|
assert.ok(step, 'The original Nexus/Skills continuation must retain a legal participant');
|
|
return applyAction(game, step.actor, step.action);
|
|
}
|
|
export function advanceNexusBanker(state: Game, until: (game: Game) => boolean): Game {
|
|
let game = state;
|
|
for (let n = 0; n < 1200; n++) {
|
|
if (until(game)) return game;
|
|
assert.notEqual(game.status, 'finished');
|
|
game = nexusBankerStep(game);
|
|
}
|
|
throw Error('Native Nexus Banker continuation missed its requested boundary');
|
|
}
|
|
|
|
/** Original fresh lobby selection, genuine offers and native shipment timing.
|
|
* Only the original Skill shuffle is controlled to give the first seat Banker.
|
|
* No wallet, force, phase, receipt, plan or Nexus hand is manufactured. */
|
|
export function createClassicNexusBankerFixture(options: {
|
|
advanced?: boolean; amount?: number; payer?: 'g' | 'e'; tech?: boolean; strongholds?: boolean;
|
|
} = {}) {
|
|
const { advanced = false, payer = 'g', amount = payer === 'g' ? 4 : 2, tech = false, strongholds = false } = options;
|
|
let game = createGame('CLASSICNEXUSBANKER', newPlayer('a', 'Atreides', 'atreides'), advanced, []);
|
|
joinGame(game, newPlayer('g', 'Guild', 'guild'));
|
|
joinGame(game, newPlayer('e', 'Emperor', 'emperor'));
|
|
game.nexusCards = { cards: null, phase: null };
|
|
if (tech) game.techTokens = createTechTokens();
|
|
if (strongholds) game.strongholdCards = createStrongholdCards();
|
|
for (const player of game.players) game = applyAction(game, player.id, { type: 'ready' });
|
|
const lobby = structuredClone(game);
|
|
game = withSpiceBankerIncomeSetupRandomness(() => initializeLeaderSkillsGameForAudit(game));
|
|
const started = structuredClone(game);
|
|
while (game.status === 'setup') {
|
|
if (game.setupStage === 'leaderSkills') {
|
|
const actor = Object.keys(game.leaderSkills!.offers)[0];
|
|
const skills = viewGame(game, actor).leaderSkills!;
|
|
const skill = actor === 'a' ? 'spice-banker' : skills.offer!.cards.find(id => !skills.unavailableSkills?.[id]);
|
|
assert.ok(skill && skills.offer!.cards.includes(skill));
|
|
game = applyAction(game, actor, { type: 'leaderSkill', event: skills.offer!.event,
|
|
skill, leader: skills.eligibleLeaders[0].id });
|
|
} else game = nexusBankerStep(game);
|
|
}
|
|
validateLeaderSkills(game.leaderSkills!, game.players);
|
|
const setup = structuredClone(game);
|
|
game = advanceNexusBanker(game, g => g.turn === 1 && g.phase === 5 && g.active === payer && nexusBankerClean(g));
|
|
const action: Action = { type: 'ship', territory: 'polar_sink', sector: 0, amount, elite: 0 };
|
|
const beforePayment = structuredClone(game);
|
|
game = applyAction(game, payer, action);
|
|
game = advanceNexusBanker(game, nexusBankerClean);
|
|
return { lobby, started, setup, beforePayment, paid: game, payer, amount, action, owner: 'a' };
|
|
}
|
|
|
|
/** Stop around the actual phase transition so the separate Mentat grant is
|
|
* never mistaken for ordinary Arrakeen/Tech/Collection income. */
|
|
export function collectClassicNexusBanker(state: Game) {
|
|
let game = state;
|
|
let beforeMentat: Game | undefined;
|
|
for (let n = 0; n < 1200; n++) {
|
|
if (game.phase === 8 && nexusBankerClean(game)) {
|
|
assert.ok(beforeMentat);
|
|
return { beforeMentat, collected: game };
|
|
}
|
|
const next = nexusBankerStep(game);
|
|
if (game.phase !== 8 && next.phase === 8) beforeMentat = structuredClone(game);
|
|
game = next;
|
|
}
|
|
throw Error('Native Nexus Banker did not reach actual Mentat');
|
|
}
|