Compose native Ecaz and Moritani Stronghold rule paths
This commit is contained in:
1 parent
50808aed5e
commit
39e2954ab4
15 files changed
+1010
-91
No files matched your search
@@ -0,0 +1,205 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import { applyAction, createGame, initializeStrongholdFactionsGameForAudit, joinGame, newPlayer, viewGame, type Game } from '../game/engine';
|
||||
import { botActions } from '../game/bots';
|
||||
import type { Difficulty } from '../game/bot-profiles';
|
||||
import { territory } from '../game/board';
|
||||
import type { Card } from '../game/cards';
|
||||
import type { StrongholdId } from '../game/stronghold-cards';
|
||||
import { nextStrongholdFactionsNativeStep, type StrongholdFactionsNativeStep } from './fixture-stronghold-factions';
|
||||
|
||||
export type MoritaniStrongholdsOptions = {
|
||||
initial?: Game;
|
||||
kind?: 'tueks_sietch' | 'sietch_tabr' | 'carthag';
|
||||
holder?: 'moritani' | 'guild';
|
||||
normalCall?: boolean;
|
||||
};
|
||||
export type MoritaniStrongholdsFixture = {
|
||||
initial: Game; afterSetup: Game; beforePlacement: Game; afterPlacement: Game;
|
||||
beforeFirstMentat: Game; firstMentatStep: StrongholdFactionsNativeStep; afterFirstMentat: Game;
|
||||
beforeBattle: Game; game: Game; revealed: Game; pending: Game;
|
||||
moritani: string; opponent: string; holder: string; kind: StrongholdId;
|
||||
target: string; moritaniLeader: string; opponentLeader: string;
|
||||
moritaniCards: string[]; opponentCards: string[];
|
||||
battleAction: StrongholdFactionsNativeStep; planActions: StrongholdFactionsNativeStep[];
|
||||
sourceActions: StrongholdFactionsNativeStep[]; staging: string[];
|
||||
};
|
||||
export const moritaniStrongholdsPlayer = (game: Game, id: string) => {
|
||||
const player = game.players.find(p => p.id === id); assert.ok(player, `Missing original seat ${id}`); return player;
|
||||
};
|
||||
export function moritaniStrongholdsPolicy(game: Game, actor: string, difficulty: Difficulty = 'Easy') {
|
||||
const view = viewGame(game, actor); view.players.find(p => p.id === actor)!.bot = difficulty;
|
||||
return botActions(view);
|
||||
}
|
||||
/** Use original owner-projected decisions; no invented Terror charge, card claim,
|
||||
* assassination opportunity or hand/leader-skill overlay. */
|
||||
export function nextMoritaniStrongholdsStep(game: Game): StrongholdFactionsNativeStep | null {
|
||||
if (game.decision && ['moritaniSetup', 'moritaniPlacement', 'moritaniTerror', 'moritaniRetention', 'moritaniAssassinate'].includes(game.decision.kind)) {
|
||||
const actor = game.decision.player, action = moritaniStrongholdsPolicy(game, actor)[0]; assert.ok(action);
|
||||
return { actor, action };
|
||||
}
|
||||
return nextStrongholdFactionsNativeStep(game);
|
||||
}
|
||||
function run(game: Game, action: StrongholdFactionsNativeStep, actions: StrongholdFactionsNativeStep[]) {
|
||||
actions.push(structuredClone(action)); return applyAction(game, action.actor, action.action);
|
||||
}
|
||||
export function advanceMoritaniStrongholds(game: Game, until: (state: Game) => boolean, actions: StrongholdFactionsNativeStep[] = []): Game {
|
||||
for (let count = 0; count < 1800; count++) {
|
||||
if (until(game)) return game;
|
||||
assert.notEqual(game.status, 'finished');
|
||||
const next = nextMoritaniStrongholdsStep(game); assert.ok(next, 'A real sealed Battle Plan is required');
|
||||
game = run(game, next, actions);
|
||||
}
|
||||
throw Error('Original native Moritani Stronghold continuation did not reach its boundary');
|
||||
}
|
||||
const clean = (game: Game) => !game.phaseOpening && !game.response && !game.decision;
|
||||
const key = (kind: StrongholdId) => `${kind}:${territory(kind).sectors[0]}`;
|
||||
function reserveBoard(game: Game) {
|
||||
for (const player of game.players) {
|
||||
player.reserves += Object.values(player.forces).reduce((sum, n) => sum + n, 0); player.forces = {};
|
||||
if (player.elites) {
|
||||
player.elites.reserves += Object.values(player.elites.forces).reduce((sum, n) => sum + n, 0); player.elites.forces = {};
|
||||
}
|
||||
if (player.advisors) player.advisors = {};
|
||||
}
|
||||
}
|
||||
function place(game: Game, id: string, kind: StrongholdId, count: number) {
|
||||
const player = moritaniStrongholdsPlayer(game, id); assert.ok(player.reserves >= count);
|
||||
player.reserves -= count; player.forces[key(kind)] = count;
|
||||
}
|
||||
function heldCard(game: Game, id: string, kind: Card['kind'], staging: string[], excluded: string[] = []) {
|
||||
const player = moritaniStrongholdsPlayer(game, id);
|
||||
const held = player.hand.find(c => c.kind === kind && !excluded.includes(c.id)); if (held) return held.id;
|
||||
const index = game.deck.findIndex(c => c.kind === kind && !excluded.includes(c.id)); assert.ok(index >= 0);
|
||||
assert.ok(player.hand.length < 4);
|
||||
const card = game.deck.splice(index, 1)[0]; player.hand.push(card);
|
||||
staging.push(`Conserved ${card.id}: remaining exact native ecaz deck → ${id}'s hand`); return card.id;
|
||||
}
|
||||
export function holdMoritaniStrongholdsTraitor(game: Game, owner: string, identity: string, staging: string[] = []) {
|
||||
const player = moritaniStrongholdsPlayer(game, owner), old = player.traitors[0]; assert.ok(old);
|
||||
if (old === identity) return;
|
||||
const donor = game.players.find(p => p.id !== owner && p.traitors.includes(identity));
|
||||
if (donor) donor.traitors[donor.traitors.indexOf(identity)] = old;
|
||||
else {
|
||||
const index = game.traitorReserve!.indexOf(identity); assert.ok(index >= 0);
|
||||
game.traitorReserve![index] = old;
|
||||
}
|
||||
player.traitors[0] = identity;
|
||||
staging.push(`Conserved physical traitor ${identity}: native ${donor?.id ?? 'reserve'} custody exchanged for ${old}`);
|
||||
}
|
||||
/** Deterministic battle positions only AFTER real setup and actual Mentat claim.
|
||||
* No assignment to phases, turn, storm, owners, plans or native pending state. */
|
||||
export function stageMoritaniStrongholdsBattle(game: Game, moritani: string, opponent: string, kind: StrongholdId, staging: string[] = []) {
|
||||
assert.equal(game.phase, 5); assert.ok(clean(game));
|
||||
reserveBoard(game); place(game, moritani, kind, 6); place(game, opponent, kind, 6);
|
||||
// Explicitly isolate battle/assassination bank legs from board Collection.
|
||||
game.spice = {};
|
||||
staging.push('Before genuine movement completion: conserved six original counters per combatant and empty board deposits; preserve original native wallets and actual prior Mentat card holders.');
|
||||
return game;
|
||||
}
|
||||
function reveal(game: Game, plans: StrongholdFactionsNativeStep[], actions: StrongholdFactionsNativeStep[]) {
|
||||
for (const plan of plans) {
|
||||
game = run(game, plan, actions);
|
||||
while (game.response || game.decision?.kind === 'fullPlanOffer') {
|
||||
const next = nextMoritaniStrongholdsStep(game); assert.ok(next); game = run(game, next, actions);
|
||||
}
|
||||
}
|
||||
assert.ok(game.battle?.revealed); return game;
|
||||
}
|
||||
export function resolveMoritaniStrongholdsBattle(game: Game, moritani: string, normalCall = false, actions: StrongholdFactionsNativeStep[] = []) {
|
||||
for (let count = 0; count < 160; count++) {
|
||||
if (game.decision?.kind === 'moritaniAssassinate' || !game.battle && !game.decision && !game.response && !game.pendingTreacheryDiscard) return game;
|
||||
const next = nextMoritaniStrongholdsStep(game); assert.ok(next);
|
||||
if (next.action.type === 'traitorCall') next.action.call = normalCall && next.actor === moritani;
|
||||
game = run(game, next, actions);
|
||||
}
|
||||
throw Error('Original Moritani battle suffix did not finish');
|
||||
}
|
||||
export function createMoritaniStrongholdsFixture(options: MoritaniStrongholdsOptions = {}): MoritaniStrongholdsFixture {
|
||||
const actions: StrongholdFactionsNativeStep[] = [], staging: string[] = [];
|
||||
const kind = options.kind ?? 'tueks_sietch';
|
||||
let game: Game;
|
||||
if (options.initial) {
|
||||
game = structuredClone(options.initial);
|
||||
assert.ok(game.status === 'lobby' || game.status === 'setup' && game.turn === 1 && game.phase === 0 && game.players.every(p => p.hand.length === 0));
|
||||
assert.equal(game.advanced, true); assert.deepEqual(game.expansions, ['ecaz']);
|
||||
} else {
|
||||
game = createGame('MORITANISTRONGHOLDS', newPlayer('moritani', 'Moritani', 'moritani'), true, ['ecaz']);
|
||||
joinGame(game, newPlayer('guild', 'Guild', 'guild')); joinGame(game, newPlayer('emperor', 'Emperor', 'emperor'));
|
||||
}
|
||||
assert.equal(game.players.filter(p => p.faction === 'moritani').length, 1);
|
||||
assert.ok(game.players.some(p => p.faction === 'guild'));
|
||||
assert.ok(game.players.every(p => ['moritani', 'atreides', 'bene_gesserit', 'emperor', 'fremen', 'guild'].includes(p.faction)));
|
||||
if (game.status === 'lobby') {
|
||||
for (const player of game.players) if (!player.ready) game = run(game, { actor: player.id, action: { type: 'ready' } }, actions);
|
||||
game = initializeStrongholdFactionsGameForAudit(game);
|
||||
}
|
||||
const initial = structuredClone(game);
|
||||
assert.ok(game.moritaniAssassinate, 'Fresh eligible E3 profile initializes the original assassination state');
|
||||
assert.equal(game.strongholdCards!.claimedTurn, 0);
|
||||
assert.ok(Object.values(game.strongholdCards!.owners).every(owner => owner === null));
|
||||
for (let count = 0; game.status === 'setup' && count < 200; count++) {
|
||||
const next = nextMoritaniStrongholdsStep(game); assert.ok(next); game = run(game, next, actions);
|
||||
}
|
||||
assert.equal(game.status, 'playing');
|
||||
const afterSetup = structuredClone(game);
|
||||
const moritani = game.players.find(p => p.faction === 'moritani')!.id;
|
||||
const opponent = game.players.find(p => p.faction === 'guild')!.id;
|
||||
const holder = options.holder === 'guild' ? opponent : moritani;
|
||||
for (let count = 0; !(game.phase === 8 && game.decision?.kind === 'moritaniPlacement') && count < 1800; count++) {
|
||||
const next = nextMoritaniStrongholdsStep(game); assert.ok(next);
|
||||
// Real first Storm dials keep the printed battle sector outside every
|
||||
// possible native turn-two storm advance; the storm field is never assigned.
|
||||
if (next.action.type === 'stormDial' && game.turn === 1) next.action.amount = kind === 'tueks_sietch' ? 4 : 0;
|
||||
game = run(game, next, actions);
|
||||
}
|
||||
assert.equal(game.decision?.kind, 'moritaniPlacement');
|
||||
const beforePlacement = structuredClone(game);
|
||||
// Real native placement; choose a different stronghold so subsequent conserved
|
||||
// battle staging neither fabricates an entry nor invokes an unrelated token.
|
||||
const token = game.moritaniTerror!.tokens.find(t => t.status === 'available')!; assert.ok(token);
|
||||
game = run(game, { actor: moritani, action: { type: 'decision', token: token.id, territory: 'arrakeen' } }, actions);
|
||||
game = advanceMoritaniStrongholds(game, state => state.phase === 8 && clean(state), actions);
|
||||
const afterPlacement = structuredClone(game);
|
||||
reserveBoard(game); place(game, holder, kind, 1);
|
||||
const other = kind === 'carthag' ? 'sietch_tabr' : 'carthag'; place(game, holder === moritani ? opponent : moritani, other, 1);
|
||||
staging.push('Before actual first END Mentat: conserve original counters through reserves, one controlled Stronghold per combatant, no three-hold victory or assigned custody.');
|
||||
let beforeFirstMentat: Game | undefined, firstMentatStep: StrongholdFactionsNativeStep | undefined;
|
||||
for (let count = 0; game.turn === 1 && count < 200; count++) {
|
||||
const next = nextMoritaniStrongholdsStep(game); assert.ok(next);
|
||||
const before = structuredClone(game); game = run(game, next, actions);
|
||||
if (game.turn === 2) { beforeFirstMentat = before; firstMentatStep = next; }
|
||||
}
|
||||
assert.ok(beforeFirstMentat && firstMentatStep); assert.equal(game.turn, 2);
|
||||
assert.equal(game.strongholdCards!.owners[kind], holder);
|
||||
const afterFirstMentat = structuredClone(game);
|
||||
game = advanceMoritaniStrongholds(game, state => state.phase === 5 && clean(state), actions);
|
||||
stageMoritaniStrongholdsBattle(game, moritani, opponent, kind, staging);
|
||||
const m = moritaniStrongholdsPlayer(game, moritani), guild = moritaniStrongholdsPlayer(game, opponent);
|
||||
const ownLeader = m.leaders.filter(l => !l.dead).sort((a, b) => a.strength - b.strength)[0];
|
||||
const enemyLeader = guild.leaders.filter(l => !l.dead).sort((a, b) => b.strength - a.strength)[0];
|
||||
assert.ok(ownLeader && enemyLeader);
|
||||
const target = guild.leaders.find(l => !l.dead && l.id !== enemyLeader.id)!; assert.ok(target);
|
||||
holdMoritaniStrongholdsTraitor(game, moritani, options.normalCall ? enemyLeader.id : target.id, staging);
|
||||
const moritaniCards: string[] = [], opponentCards: string[] = [];
|
||||
if (kind === 'carthag') {
|
||||
moritaniCards.push(heldCard(game, moritani, 'shield', staging));
|
||||
opponentCards.push(heldCard(game, opponent, 'poison', staging));
|
||||
} else if (kind === 'tueks_sietch') {
|
||||
moritaniCards.push(heldCard(game, moritani, 'worthless', staging));
|
||||
moritaniCards.push(heldCard(game, moritani, 'worthless', staging, moritaniCards));
|
||||
opponentCards.push(heldCard(game, opponent, 'worthless', staging));
|
||||
}
|
||||
game = advanceMoritaniStrongholds(game, state => state.phase === 6 && clean(state), actions);
|
||||
const beforeBattle = structuredClone(game), actor = game.active!; assert.ok([moritani, opponent].includes(actor));
|
||||
const battleAction: StrongholdFactionsNativeStep = { actor, action: { type: 'chooseBattle', territory: kind, target: actor === moritani ? opponent : moritani } };
|
||||
game = run(game, battleAction, actions);
|
||||
game = advanceMoritaniStrongholds(game, state => !!state.battle && !state.battle.revealed && !nextMoritaniStrongholdsStep(state), actions);
|
||||
const planActions: StrongholdFactionsNativeStep[] = [
|
||||
{ actor: moritani, action: { type: 'battlePlan', leader: ownLeader.id, dial: 1, support: 1, weapon: kind === 'tueks_sietch' ? moritaniCards[0] : null, defense: kind === 'tueks_sietch' ? moritaniCards[1] : kind === 'carthag' ? moritaniCards[0] : null } },
|
||||
{ actor: opponent, action: { type: 'battlePlan', leader: enemyLeader.id, dial: 3, support: 3, weapon: opponentCards[0] ?? null, defense: null } },
|
||||
];
|
||||
const prepared = structuredClone(game), revealed = reveal(game, planActions, actions);
|
||||
const pending = resolveMoritaniStrongholdsBattle(structuredClone(revealed), moritani, options.normalCall, actions);
|
||||
return { initial, afterSetup, beforePlacement, afterPlacement, beforeFirstMentat, firstMentatStep, afterFirstMentat, beforeBattle, game: prepared, revealed, pending,
|
||||
moritani, opponent, holder, kind, target: target.id, moritaniLeader: ownLeader.id, opponentLeader: enemyLeader.id, moritaniCards, opponentCards, battleAction, planActions, sourceActions: actions, staging };
|
||||
}
|
||||
Reference in new issue
Block a user