Connect clean native family Reinforcements battles
This commit is contained in:
1 parent
c64c08af89
commit
4313983a5c
14 files changed
+1306
-44
No files matched your search
@@ -0,0 +1,259 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import {
|
||||
applyAction, createGame, initializeEcazTreacheryGameForAudit, joinGame, newPlayer,
|
||||
viewGame, type Action, type Game,
|
||||
} from '../game/engine';
|
||||
import { MOBILE_LOCATION, territory } from '../game/board';
|
||||
import { isAuditorLeader, treacheryDeck } from '../game/cards';
|
||||
import { ecazTreacheryCards } from '../game/ecaz-cards';
|
||||
import { REINFORCEMENTS_CARD } from '../game/reinforcements';
|
||||
import { traitorDeck } from '../game/traitors';
|
||||
import { nextStrongholdFactionsNativeStep } from './fixture-stronghold-factions';
|
||||
|
||||
export type NativeFamilyReinforcementsStep = { actor: string; action: Action };
|
||||
export type NativeFamilyReinforcementsOptions = {
|
||||
faction?: 'ixians' | 'tleilaxu' | 'choam';
|
||||
advanced?: boolean;
|
||||
expansions?: ('ix' | 'choam')[];
|
||||
slot?: 'weapon' | 'defense';
|
||||
outcome?: 'winner' | 'loser' | 'traitor' | 'explosion';
|
||||
/** Nine legally paid suboids leave one suboid and four cyborgs in reserve. */
|
||||
mixedFee?: boolean;
|
||||
initial?: Game;
|
||||
seatIds?: [string, string];
|
||||
};
|
||||
export type NativeFamilyReinforcementsFixture = {
|
||||
initial: Game;
|
||||
afterSetup: Game;
|
||||
beforeBattle: Game;
|
||||
game: Game;
|
||||
owner: string;
|
||||
opponent: string;
|
||||
territory: string;
|
||||
location: string;
|
||||
shipments: { before: Game; step: NativeFamilyReinforcementsStep; after: Game }[];
|
||||
battleStep: NativeFamilyReinforcementsStep;
|
||||
planActions: [NativeFamilyReinforcementsStep, NativeFamilyReinforcementsStep];
|
||||
nativeSteps: NativeFamilyReinforcementsStep[];
|
||||
staging: string[];
|
||||
fee: { normal: number; elite: number };
|
||||
};
|
||||
export function nativeFamilyReinforcementsPlayer(game: Game, actor: string) {
|
||||
const player = game.players.find(p => p.id === actor); assert.ok(player); return player;
|
||||
}
|
||||
export const nativeFamilyReinforcementsClean = (game: Game) =>
|
||||
!game.phaseOpening && !game.response && !game.decision && !game.pendingTreacheryDiscard;
|
||||
|
||||
/** Original native controls are consumed, not removed: HMS placement, Face
|
||||
* Dancers, cyborg substitution and Auditor inspection remain ordinary decisions. */
|
||||
export function nextNativeFamilyReinforcementsStep(game: Game): NativeFamilyReinforcementsStep | null {
|
||||
if (!game.phaseOpening && !game.response && game.decision?.kind === 'faceDance')
|
||||
return { actor: game.decision.player, action: { type: 'decision', reveal: false } };
|
||||
return nextStrongholdFactionsNativeStep(game);
|
||||
}
|
||||
export function advanceNativeFamilyReinforcements(state: Game, until: (game: Game) => boolean,
|
||||
actions: NativeFamilyReinforcementsStep[] = []): Game {
|
||||
let game = state;
|
||||
for (let n = 0; n < 600; n++) {
|
||||
if (until(game)) return game;
|
||||
assert.notEqual(game.status, 'finished');
|
||||
const step = nextNativeFamilyReinforcementsStep(game);
|
||||
assert.ok(step, 'Seal the actual human Battle Plans before continuing');
|
||||
actions.push(structuredClone(step)); game = applyAction(game, step.actor, step.action);
|
||||
}
|
||||
throw Error('Native family programme did not reach its requested boundary');
|
||||
}
|
||||
function initialize(game: Game): Game {
|
||||
const descriptor = Object.getOwnPropertyDescriptor(crypto, 'getRandomValues');
|
||||
crypto.getRandomValues = <T extends ArrayBufferView | null>(array: T): T => {
|
||||
assert.ok(array); new Uint8Array(array.buffer, array.byteOffset, array.byteLength).fill(255); return array;
|
||||
};
|
||||
try { return initializeEcazTreacheryGameForAudit(game); }
|
||||
finally {
|
||||
if (descriptor) Object.defineProperty(crypto, 'getRandomValues', descriptor);
|
||||
else Reflect.deleteProperty(crypto, 'getRandomValues');
|
||||
}
|
||||
}
|
||||
function exchangeTraitor(game: Game, actor: string, leader: string, staging: string[]) {
|
||||
const player = nativeFamilyReinforcementsPlayer(game, actor);
|
||||
if (player.traitors.includes(leader)) return;
|
||||
const returned = player.traitors[0]; assert.ok(returned);
|
||||
const at = game.traitorReserve!.indexOf(leader);
|
||||
const donor = game.players.find(p => p.traitors.includes(leader));
|
||||
const dancer = game.players.flatMap(p => p.faceDancers ?? []).find(c => c.leader === leader && !c.revealed);
|
||||
assert.ok(at >= 0 || donor || dancer);
|
||||
if (at >= 0) game.traitorReserve![at] = returned;
|
||||
else if (donor) donor.traitors[donor.traitors.indexOf(leader)] = returned;
|
||||
else dancer!.leader = returned;
|
||||
player.traitors[0] = leader;
|
||||
staging.push(`Conserved original Traitor ${leader} exchanged for ${returned} into ${actor}'s hand.`);
|
||||
}
|
||||
|
||||
/** Fresh selected-family lobby → independent-card initializer → every original
|
||||
* setup choice → real phase readiness → paid native shipments → chooseBattle.
|
||||
* Only conserved hands/Traitors and unopened first-Blow card positions are
|
||||
* staged. No force, wallet, phase, history or preview marker is assigned. */
|
||||
export function createNativeFamilyReinforcementsFixture(
|
||||
options: NativeFamilyReinforcementsOptions = {},
|
||||
): NativeFamilyReinforcementsFixture {
|
||||
const faction = options.faction ?? 'ixians', advanced = options.advanced ?? options.initial?.advanced ?? false;
|
||||
const expansions = options.expansions ?? options.initial?.expansions ?? [faction === 'choam' ? 'choam' : 'ix'];
|
||||
assert.ok(expansions.length > 0 && expansions.every(id => id === 'ix' || id === 'choam'));
|
||||
assert.equal(new Set(expansions).size, expansions.length);
|
||||
assert.ok(expansions.includes(faction === 'choam' ? 'choam' : 'ix'));
|
||||
assert.ok(!options.mixedFee || faction === 'ixians');
|
||||
const ids = options.seatIds ?? [faction, 'guild'];
|
||||
let game = options.initial ? structuredClone(options.initial) :
|
||||
createGame('NATIVEFAMILYREINFORCEMENTS', newPlayer(ids[0], faction, faction), advanced, expansions);
|
||||
if (!options.initial) joinGame(game, newPlayer(ids[1], 'Guild', 'guild'));
|
||||
assert.equal(game.status, 'lobby', 'Supply the original undealt native lobby');
|
||||
assert.equal(game.advanced, advanced);
|
||||
assert.deepEqual([...game.expansions].sort(), [...expansions].sort());
|
||||
assert.deepEqual(game.players.map(p => p.faction).sort(), [faction, 'guild'].sort());
|
||||
assert.ok(!game.ecazTreachery && !game.homeworlds && !game.nexusCards && !game.leaderSkills &&
|
||||
!game.techTokens && !game.strongholdCards && !game.discoveryEnabled && !game.discoveries);
|
||||
const owner = game.players.find(p => p.faction === faction)!.id;
|
||||
const opponent = game.players.find(p => p.faction === 'guild')!.id;
|
||||
const nativeSteps: NativeFamilyReinforcementsStep[] = [];
|
||||
const act = (step: NativeFamilyReinforcementsStep) => {
|
||||
nativeSteps.push(structuredClone(step)); game = applyAction(game, step.actor, step.action);
|
||||
};
|
||||
for (const p of game.players) if (!p.ready) act({ actor: p.id, action: { type: 'ready' } });
|
||||
const initial = structuredClone(game);
|
||||
// This initializer selects independent cards before native setup and deals
|
||||
// exactly the selected physical inventory; never retrofit a module flag.
|
||||
game = initialize(game);
|
||||
game = advanceNativeFamilyReinforcements(game, g => g.status === 'playing', nativeSteps);
|
||||
const afterSetup = structuredClone(game);
|
||||
const staging = ['Independent cards selected by the original initializer before native setup; original HMS army, Face Dancers and Advanced Auditor retained.'];
|
||||
for (let i = 0; i < (advanced ? 4 : 2); i++) {
|
||||
const at = game.spiceDeck.findIndex((c, index) => index >= i && 'territory' in c && !c.discovery);
|
||||
assert.ok(at >= i); game.spiceDeck.splice(i, 0, game.spiceDeck.splice(at, 1)[0]);
|
||||
}
|
||||
staging.push('Position unopened original non-worm first-Blow cards; no phase or draw is assigned.');
|
||||
const reach = (until: (g: Game) => boolean) => {
|
||||
game = advanceNativeFamilyReinforcements(game, until, nativeSteps);
|
||||
};
|
||||
const kind = 'arrakeen', sector = territory(kind).sectors[0], location = `${kind}:${sector}`;
|
||||
const shipments: NativeFamilyReinforcementsFixture['shipments'] = [];
|
||||
const waiting = new Set([owner, opponent]);
|
||||
reach(g => g.phase === 5 && nativeFamilyReinforcementsClean(g));
|
||||
while (waiting.size) {
|
||||
const actor = game.active!; assert.ok(waiting.has(actor));
|
||||
const amount = actor === owner && options.mixedFee ? 9 : 3;
|
||||
const elite = actor === owner && faction === 'ixians' && !options.mixedFee ? 2 : 0;
|
||||
const step: NativeFamilyReinforcementsStep = { actor, action: {
|
||||
type: 'ship', territory: kind, sector, amount, elite, allyPayment: 0,
|
||||
} };
|
||||
const before = structuredClone(game); act(step); reach(nativeFamilyReinforcementsClean);
|
||||
shipments.push({ before, step, after: structuredClone(game) });
|
||||
waiting.delete(actor); act({ actor, action: { type: 'endMovement' } });
|
||||
reach(g => (g.phase === 5 || g.phase === 6) && nativeFamilyReinforcementsClean(g));
|
||||
}
|
||||
reach(g => g.phase === 6 && nativeFamilyReinforcementsClean(g));
|
||||
for (const p of game.players) game.deck.push(...p.hand.splice(0));
|
||||
const take = (actor: string, id: string) => {
|
||||
const at = game.deck.findIndex(c => c.id === id); assert.ok(at >= 0);
|
||||
const player = nativeFamilyReinforcementsPlayer(game, actor);
|
||||
assert.ok(player.hand.length < (player.faction === 'choam' ? 5 : 4));
|
||||
player.hand.push(game.deck.splice(at, 1)[0]); return id;
|
||||
};
|
||||
take(owner, REINFORCEMENTS_CARD);
|
||||
if (faction === 'choam' && advanced) {
|
||||
take(opponent, game.deck.find(c => c.kind === 'projectile')!.id);
|
||||
staging.push('Conserve one unused opposing projectile card so the original Advanced Auditor inspection control has a real target.');
|
||||
}
|
||||
const outcome = options.outcome ?? 'winner';
|
||||
let laser: string | null = null, shield: string | null = null;
|
||||
if (outcome === 'explosion') {
|
||||
laser = take(opponent, game.deck.find(c => c.kind === 'lasgun')!.id);
|
||||
shield = take(opponent, game.deck.find(c => c.kind === 'shield')!.id);
|
||||
}
|
||||
staging.push('Return original hands to undealt stock and conserve physical Reinforcements (plus opposing Lasgun/Shield only for explosion) into legal hands.');
|
||||
const own = nativeFamilyReinforcementsPlayer(game, owner);
|
||||
const ownLeader = faction === 'ixians' ? own.leaders.find(l => l.strength === (options.mixedFee ? 4 : 1))!
|
||||
: faction === 'choam' && advanced ? own.leaders.find(isAuditorLeader)!
|
||||
: own.leaders.find(l => l.strength === 2)!;
|
||||
const otherLeader = nativeFamilyReinforcementsPlayer(game, opponent).leaders.find(l => l.strength === 5)!;
|
||||
assert.ok(ownLeader && otherLeader);
|
||||
if (faction === 'tleilaxu' && outcome === 'loser' &&
|
||||
!own.faceDancers!.some(c => c.leader === otherLeader.id)) {
|
||||
const dancer = own.faceDancers![0], returned = dancer.leader;
|
||||
const at = game.traitorReserve!.indexOf(otherLeader.id);
|
||||
const donor = game.players.find(p => p.traitors.includes(otherLeader.id));
|
||||
assert.ok(at >= 0 || donor);
|
||||
if (at >= 0) game.traitorReserve![at] = returned;
|
||||
else donor!.traitors[donor!.traitors.indexOf(otherLeader.id)] = returned;
|
||||
dancer.leader = otherLeader.id;
|
||||
staging.push(`Conserved original Face Dancer ${otherLeader.id} exchanged for ${returned}; the actual post-victory native window remains available.`);
|
||||
}
|
||||
if (outcome === 'traitor') exchangeTraitor(game, opponent, ownLeader.id, staging);
|
||||
const beforeBattle = structuredClone(game);
|
||||
const choice = viewGame(game, game.active!).battleChoices.find(c => c.territory === kind); assert.ok(choice);
|
||||
const battleStep: NativeFamilyReinforcementsStep = { actor: choice.chooser, action: {
|
||||
type: 'chooseBattle', territory: kind,
|
||||
target: choice.attacker === choice.chooser ? choice.defender : choice.attacker,
|
||||
} };
|
||||
act(battleStep);
|
||||
reach(g => !!g.battle && nativeFamilyReinforcementsClean(g) && !g.battle.preparation && g.battle.preLeader?.closed !== false);
|
||||
const slot = options.slot ?? 'weapon';
|
||||
const dial = faction === 'ixians' ? options.mixedFee ? 0.5 : 2.5 : 2;
|
||||
const support = advanced ? faction === 'ixians' ? options.mixedFee ? 0 : 1 : 2 : 0;
|
||||
const planActions: NativeFamilyReinforcementsFixture['planActions'] = [
|
||||
{ actor: owner, action: { type: 'battlePlan', dial, support, leader: ownLeader.id,
|
||||
weapon: slot === 'weapon' ? REINFORCEMENTS_CARD : null,
|
||||
defense: slot === 'defense' ? REINFORCEMENTS_CARD : null } },
|
||||
{ actor: opponent, action: { type: 'battlePlan', dial: outcome === 'loser' ? 3 : 0,
|
||||
support: outcome === 'loser' && advanced ? 3 : 0, leader: otherLeader.id,
|
||||
weapon: laser, defense: shield } },
|
||||
];
|
||||
const normal = Math.min(3, own.reserves - (own.elites?.reserves ?? 0));
|
||||
const fee = { normal, elite: 3 - normal };
|
||||
assertNativeFamilyReinforcementsInventory(game);
|
||||
return { initial, afterSetup, beforeBattle, game, owner, opponent, territory: kind, location,
|
||||
shipments, battleStep, planActions, nativeSteps, staging, fee };
|
||||
}
|
||||
export function sealNativeFamilyReinforcementsPlan(state: Game, step: NativeFamilyReinforcementsStep): Game {
|
||||
return advanceNativeFamilyReinforcements(applyAction(state, step.actor, step.action), g =>
|
||||
!g.response && !g.phaseOpening && (!g.decision || g.decision.kind !== 'fullPlanOffer'));
|
||||
}
|
||||
export function revealNativeFamilyReinforcementsBattle(fixture: NativeFamilyReinforcementsFixture): Game {
|
||||
let game = structuredClone(fixture.game);
|
||||
for (const step of fixture.planActions) game = sealNativeFamilyReinforcementsPlan(game, step);
|
||||
assert.ok(game.battle?.revealed); return game;
|
||||
}
|
||||
export function finishNativeFamilyReinforcementsBattle(state: Game, options: {
|
||||
callers?: string[];
|
||||
actions?: NativeFamilyReinforcementsStep[];
|
||||
} = {}): Game {
|
||||
let game = state;
|
||||
for (let n = 0; n < 240; n++) {
|
||||
if (!game.battle && nativeFamilyReinforcementsClean(game)) return game;
|
||||
const step = nextNativeFamilyReinforcementsStep(game); assert.ok(step);
|
||||
if (step.action.type === 'traitorCall') step.action.call = options.callers?.includes(step.actor) ?? false;
|
||||
options.actions?.push(structuredClone(step)); game = applyAction(game, step.actor, step.action);
|
||||
}
|
||||
throw Error('Native Reinforcements aftermath did not finish');
|
||||
}
|
||||
export function assertNativeFamilyReinforcementsInventory(game: Game): void {
|
||||
const cards = [...game.deck, ...game.discard, ...game.players.flatMap(p => p.hand),
|
||||
...(game.ixSetupCards ?? []), ...(game.ixAuction?.cards ?? [])];
|
||||
assert.deepEqual(cards.map(c => c.id).sort(),
|
||||
[...treacheryDeck(game.expansions), ...ecazTreacheryCards()].map(c => c.id).sort());
|
||||
assert.equal(cards.length, game.expansions.includes('ix') ? 50 : 38);
|
||||
assert.deepEqual([...game.traitorReserve!, ...game.players.flatMap(p =>
|
||||
[...p.traitors, ...p.traitorChoices, ...(p.faceDancers ?? []).map(c => c.leader)])].sort(),
|
||||
traitorDeck(game.players, game.expansions.includes('ix')).sort());
|
||||
for (const p of game.players) {
|
||||
assert.equal(p.reserves + p.tanks + Object.values(p.forces).reduce((a, b) => a + b, 0), 20);
|
||||
assert.ok(p.hand.length <= (p.faction === 'choam' ? 5 : 4));
|
||||
if (p.elites) assert.equal(p.elites.reserves + p.elites.tanks +
|
||||
Object.values(p.elites.forces).reduce((a, b) => a + b, 0), p.faction === 'ixians' ? 7 : p.faction === 'emperor' ? 5 : 3);
|
||||
if (p.faction === 'ixians') {
|
||||
assert.equal(p.forces[MOBILE_LOCATION], 6, 'Original HMS army is never repositioned by the fixture');
|
||||
assert.equal(p.elites!.forces[MOBILE_LOCATION], 3);
|
||||
}
|
||||
if (p.faction === 'tleilaxu') assert.equal(p.faceDancers!.length, 3);
|
||||
if (p.faction === 'choam' && game.advanced) assert.ok(p.leaders.some(isAuditorLeader));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user