Compose Discovery Strongholds and repair mandatory Ecaz battles
This commit is contained in:
1 parent
e798914aab
commit
b0267827b5
19 files changed
+1243
-39
No files matched your search
@@ -0,0 +1,318 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import {
|
||||
applyAction, createGame, handLimit, initializeDiscoveryGameForAudit, joinGame, newPlayer,
|
||||
viewGame, type Action, type Game, type Player,
|
||||
} from '../game/engine';
|
||||
import { MOBILE_LOCATION, MOBILE_STRONGHOLD, gameTerritories, territory } from '../game/board';
|
||||
import { isAuditorLeader, treacheryDeck, type Card } from '../game/cards';
|
||||
import { DISCOVERY_CARD_PLACEMENTS, validateDiscoveryState } from '../game/discoveries';
|
||||
import { richeseCards } from '../game/richese-cards';
|
||||
import { validateRicheseNoField } from '../game/richese-no-field';
|
||||
import { createStrongholdCards, strongholdControllers } from '../game/stronghold-cards';
|
||||
import { traitorDeck } from '../game/traitors';
|
||||
import { nextStrongholdFactionsNativeStep } from './fixture-stronghold-factions';
|
||||
import { nextDiscoveryNativeMarkerStep } from './fixture-discovery-native-marker';
|
||||
|
||||
export type DiscoveryNativeStrongholdStep = { actor: string; action: Action };
|
||||
export type DiscoveryNativeStrongholdKind = 'ix-hms-invoice' | 'richese-nested-defense';
|
||||
export type DiscoveryNativeStrongholdOptions = {
|
||||
/** Authenticated fresh lobby or original undealt Discovery/Stronghold audit setup. */
|
||||
initial?: Game;
|
||||
kind?: DiscoveryNativeStrongholdKind;
|
||||
tech?: boolean;
|
||||
};
|
||||
export type DiscoveryNativeStrongholdFixture = {
|
||||
initial: Game;
|
||||
setup: Game;
|
||||
afterSetup: Game;
|
||||
beforeBlow: Game;
|
||||
afterBlow: Game;
|
||||
beforeReveal: Game;
|
||||
afterReveal: Game;
|
||||
beforeFirstMentat: Game;
|
||||
firstMentatStep: DiscoveryNativeStrongholdStep;
|
||||
afterFirstMentat: Game;
|
||||
entry: { before: Game; step: DiscoveryNativeStrongholdStep; after: Game };
|
||||
shipment: { before: Game; step: DiscoveryNativeStrongholdStep; after: Game };
|
||||
markerReveal: { before: Game; step: DiscoveryNativeStrongholdStep; after: Game } | null;
|
||||
beforeBattle: Game;
|
||||
battleStep: DiscoveryNativeStrongholdStep;
|
||||
copyStep: DiscoveryNativeStrongholdStep | null;
|
||||
game: Game;
|
||||
kind: DiscoveryNativeStrongholdKind;
|
||||
owner: string;
|
||||
collector: string;
|
||||
opponent: string;
|
||||
choam: string;
|
||||
token: string;
|
||||
parent: string;
|
||||
source: string;
|
||||
location: string;
|
||||
leader: string;
|
||||
opponentLeader: string;
|
||||
defense: string | null;
|
||||
weapon: string | null;
|
||||
plans: DiscoveryNativeStrongholdStep[];
|
||||
actions: DiscoveryNativeStrongholdStep[];
|
||||
staging: string[];
|
||||
};
|
||||
export const discoveryNativeStrongholdReload = (game: Game): Game => JSON.parse(JSON.stringify(game));
|
||||
export function discoveryNativeStrongholdPlayer(game: Game, actor: string): Player {
|
||||
const p = game.players.find(player => player.id === actor); assert.ok(p); return p;
|
||||
}
|
||||
export function assertDiscoveryNativeStrongholdCustody(game: Game): void {
|
||||
const cards = [...game.deck, ...game.discard, ...game.players.flatMap(p => p.hand),
|
||||
...(game.ixSetupCards ?? []), ...(game.ixAuction?.cards ?? []),
|
||||
...(game.auction?.cards.slice(game.auction.index) ?? []),
|
||||
...(game.richeseCache ?? []), ...(game.richeseRemoved ?? [])];
|
||||
assert.deepEqual(cards.map(c => c.id).sort(), [...treacheryDeck(game.expansions),
|
||||
...(game.players.some(p => p.faction === 'richese') ? richeseCards() : [])].map(c => c.id).sort());
|
||||
assert.equal(new Set(cards.map(c => c.id)).size, cards.length);
|
||||
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, p.faction);
|
||||
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 === 'fremen' ? 3 : 5);
|
||||
assert.ok(p.elites.reserves <= p.reserves && p.elites.tanks <= p.tanks);
|
||||
for (const [key, count] of Object.entries(p.elites.forces)) assert.ok(count >= 0 && count <= (p.forces[key] ?? 0));
|
||||
}
|
||||
if (p.noField) validateRicheseNoField(p.noField);
|
||||
}
|
||||
validateDiscoveryState(game.discoveries!);
|
||||
}
|
||||
export const discoveryNativeStrongholdClean = (game: Game) => !game.phaseOpening && !game.response && !game.decision;
|
||||
/** Existing native policies; leave declarations and unsealed plans to the caller. */
|
||||
export function nextDiscoveryNativeStrongholdStep(game: Game): DiscoveryNativeStrongholdStep | null {
|
||||
if (game.decision?.kind === 'discoveryEntry') return { actor: game.decision.player,
|
||||
action: { type: 'decision', event: game.decision.event, accept: false } };
|
||||
if (game.decision?.kind === 'techToken') return { actor: game.decision.player,
|
||||
action: { type: 'decision', token: game.decision.choices[0] } };
|
||||
if (game.decision?.kind === 'strongholdCopy' || game.decision?.kind === 'faceDance') return null;
|
||||
if (game.battle) return nextStrongholdFactionsNativeStep(game);
|
||||
return game.players.some(p => p.faction === 'richese')
|
||||
? nextDiscoveryNativeMarkerStep(game) : nextStrongholdFactionsNativeStep(game);
|
||||
}
|
||||
function entropy<T>(operation: () => T, scalar?: number): T {
|
||||
const descriptor = Object.getOwnPropertyDescriptor(crypto, 'getRandomValues');
|
||||
const original = crypto.getRandomValues.bind(crypto);
|
||||
crypto.getRandomValues = <V extends ArrayBufferView | null>(array: V): V => {
|
||||
if (array instanceof Uint32Array) array.fill(scalar ?? 0xffffffff);
|
||||
else Reflect.apply(original, crypto, [array]);
|
||||
return array;
|
||||
};
|
||||
try { return operation(); }
|
||||
finally {
|
||||
if (descriptor) Object.defineProperty(crypto, 'getRandomValues', descriptor);
|
||||
else Reflect.deleteProperty(crypto, 'getRandomValues');
|
||||
}
|
||||
}
|
||||
function act(game: Game, step: DiscoveryNativeStrongholdStep, actions?: DiscoveryNativeStrongholdStep[], scalar?: number): Game {
|
||||
actions?.push(structuredClone(step));
|
||||
return entropy(() => applyAction(game, step.actor, step.action), scalar);
|
||||
}
|
||||
export function advanceDiscoveryNativeStronghold(state: Game, until: (g: Game) => boolean,
|
||||
actions?: DiscoveryNativeStrongholdStep[], scalar?: number): Game {
|
||||
let game = state;
|
||||
for (let n = 0; n < 1800; n++) {
|
||||
if (until(game)) return game;
|
||||
assert.notEqual(game.status, 'finished');
|
||||
const step = nextDiscoveryNativeStrongholdStep(game); assert.ok(step, 'A real human declaration or plan is required');
|
||||
game = act(game, step, actions, scalar);
|
||||
}
|
||||
throw Error('Native Discovery/Stronghold policy did not reach its requested original window');
|
||||
}
|
||||
function place(game: Game, actor: string, location: string, amount: number, elite = 0): void {
|
||||
const p = discoveryNativeStrongholdPlayer(game, actor);
|
||||
assert.ok(p.reserves - (p.elites?.reserves ?? 0) >= amount - elite && amount >= elite);
|
||||
assert.ok((p.elites?.reserves ?? 0) >= elite);
|
||||
p.reserves -= amount; p.forces[location] = (p.forces[location] ?? 0) + amount;
|
||||
if (elite) { p.elites!.reserves -= elite; p.elites!.forces[location] = (p.elites!.forces[location] ?? 0) + elite; }
|
||||
}
|
||||
function reserveOtherLocations(game: Game, kept: string[]): void {
|
||||
for (const p of game.players) for (const [key, amount] of Object.entries(p.forces)) {
|
||||
if (kept.includes(key)) continue;
|
||||
p.reserves += amount; delete p.forces[key];
|
||||
if (p.elites) { p.elites.reserves += p.elites.forces[key] ?? 0; delete p.elites.forces[key]; }
|
||||
}
|
||||
}
|
||||
function held(game: Game, actor: string, kind: Card['kind'], staging: string[]): string {
|
||||
const p = discoveryNativeStrongholdPlayer(game, actor), owned = p.hand.find(c => c.kind === kind);
|
||||
if (owned) return owned.id;
|
||||
const index = game.deck.findIndex(c => c.kind === kind);
|
||||
assert.ok(index >= 0 && p.hand.length < handLimit(p));
|
||||
const card = game.deck.splice(index, 1)[0]; p.hand.push(card);
|
||||
staging.push(`Conserved ${card.id}: original undealt native deck → ${actor}'s hand.`);
|
||||
return card.id;
|
||||
}
|
||||
/** Original Advanced E1+E2 or E2 setup, printed Hagga Basin blow, actual
|
||||
* inspection/reveal, first END Mentat claim, original free entry and paid shipment.
|
||||
* Entropy controls only original deals/remainder shuffles and the physical token
|
||||
* lottery. No held-card owner, paid continuation, phase or timestamp is forged. */
|
||||
export function createDiscoveryNativeStrongholdFixture(options: DiscoveryNativeStrongholdOptions = {}): DiscoveryNativeStrongholdFixture {
|
||||
const kind = options.kind ?? 'ix-hms-invoice', ix = kind === 'ix-hms-invoice';
|
||||
const factions = ix ? ['ixians', 'choam', 'guild'] as const : ['richese', 'choam', 'guild'] as const;
|
||||
const expansions = ix ? ['ix', 'choam'] : ['choam'];
|
||||
let game = options.initial ? structuredClone(options.initial)
|
||||
: createGame('DISCOVERYNATIVEHELD', newPlayer(factions[0], factions[0], factions[0]), true, expansions);
|
||||
if (!options.initial) for (const faction of factions.slice(1)) joinGame(game, newPlayer(faction, faction, faction));
|
||||
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].sort(), [...expansions].sort());
|
||||
assert.deepEqual(game.players.map(p => p.faction).sort(), [...factions].sort());
|
||||
assert.ok(!game.leaderSkills && !game.nexusCards && !game.homeworlds);
|
||||
if (game.status === 'lobby') {
|
||||
if (options.tech && !game.techTokens) game = applyAction(game, game.host, { type: 'techTokens', enabled: true });
|
||||
game.discoveryEnabled = true;
|
||||
if (!game.strongholdCards) game.strongholdCards = createStrongholdCards();
|
||||
for (const p of game.players) if (!p.ready) game = applyAction(game, p.id, { type: 'ready' });
|
||||
}
|
||||
const initial = structuredClone(game);
|
||||
if (game.status === 'lobby') game = entropy(() => initializeDiscoveryGameForAudit(game));
|
||||
const setup = structuredClone(game);
|
||||
assert.equal(game.strongholdCards!.claimedTurn, 0);
|
||||
assert.ok(Object.values(game.strongholdCards!.owners).every(owner => owner === null));
|
||||
const actions: DiscoveryNativeStrongholdStep[] = [], staging = [
|
||||
'Controlled only original native deal/remainder entropy; selected the actual Shrine token placement lottery.',
|
||||
'Reordered four original unplayed Spice Cards: printed Hagga Basin Discovery, then three ordinary blows.',
|
||||
];
|
||||
game = advanceDiscoveryNativeStronghold(game, g => g.status === 'playing', actions);
|
||||
const afterSetup = structuredClone(game);
|
||||
const owner = game.players.find(p => p.faction === factions[0])!.id;
|
||||
const opponent = game.players.find(p => p.faction === 'guild')!.id;
|
||||
const choam = game.players.find(p => p.faction === 'choam')!.id, collector = ix ? owner : opponent;
|
||||
const printed = 'discovery-hagga-basin', placement = DISCOVERY_CARD_PLACEMENTS[printed];
|
||||
const source = `${placement.territory}:${placement.sector}`;
|
||||
const cardIndex = game.spiceDeck.findIndex(c => 'territory' in c && c.discovery === printed); assert.ok(cardIndex >= 0);
|
||||
game.spiceDeck.unshift(game.spiceDeck.splice(cardIndex, 1)[0]);
|
||||
for (let position = 1; position < 4; position++) {
|
||||
const index = game.spiceDeck.findIndex((c, i) => i >= position && 'territory' in c && !c.discovery);
|
||||
assert.ok(index >= position); game.spiceDeck.splice(position, 0, game.spiceDeck.splice(index, 1)[0]);
|
||||
}
|
||||
game = advanceDiscoveryNativeStronghold(game, g => g.phase === 1 && discoveryNativeStrongholdClean(g), actions);
|
||||
// Actual blow destroys conserved typed counters in its PRINTED territory;
|
||||
// placement is the separate printed Gara Kulon destination, not the blow site.
|
||||
const blowLocation = 'hagga_basin:12';
|
||||
place(game, owner, blowLocation, 2, ix ? 1 : 0);
|
||||
staging.push(`Conserved original reserves → ${blowLocation}: two ${factions[0]} counters${ix ? ', including one Cyborg' : ''} before the actual blow.`);
|
||||
const beforeBlow = structuredClone(game);
|
||||
const eligible = game.discoveries!.tokens.filter(t => t.status === 'supply' && t.type === 'hiereg');
|
||||
const selected = eligible.findIndex(t => t.face === 'shrine'); assert.ok(selected >= 0);
|
||||
game = advanceDiscoveryNativeStronghold(game,
|
||||
g => g.discoveries!.tokens.some(t => t.face === 'shrine' && t.status === 'placed'), actions,
|
||||
Math.floor((selected + 0.5) / eligible.length * 0x100000000));
|
||||
const afterBlow = structuredClone(game), token = game.discoveries!.tokens.find(t => t.face === 'shrine')!;
|
||||
game = advanceDiscoveryNativeStronghold(game, g => g.phase === 5 && g.active === collector && discoveryNativeStrongholdClean(g), actions);
|
||||
game = act(game, { actor: collector, action: { type: 'ship', territory: placement.territory,
|
||||
sector: placement.sector, amount: ix ? 3 : 1, elite: ix ? 1 : 0, allyPayment: 0 } }, actions);
|
||||
game = advanceDiscoveryNativeStronghold(game, g => g.phase === 7 && discoveryNativeStrongholdClean(g), actions);
|
||||
const beforeReveal = structuredClone(game);
|
||||
assert.ok(viewGame(game, collector).discoveries!.canInspect.includes(token.id));
|
||||
game = act(game, { actor: collector, action: { type: 'discovery', token: token.id, reveal: false } }, actions);
|
||||
game = act(game, { actor: collector, action: { type: 'discovery', token: token.id, reveal: true } }, actions);
|
||||
const afterReveal = structuredClone(game);
|
||||
game = advanceDiscoveryNativeStronghold(game, g => g.phase === 8 && discoveryNativeStrongholdClean(g), actions);
|
||||
reserveOtherLocations(game, [source, ...(ix ? [MOBILE_LOCATION] : [])]);
|
||||
const claim = ix ? 'arrakeen' : 'carthag';
|
||||
place(game, owner, `${claim}:${territory(claim).sectors[0]}`, 1);
|
||||
staging.push('Before actual first END Mentat: return unrelated original board counters to their own reserves, preserve native HMS/Discovery garrisons, and place one conserved claim counter.');
|
||||
let beforeFirstMentat: Game | undefined, firstMentatStep: DiscoveryNativeStrongholdStep | undefined;
|
||||
for (let n = 0; game.turn === 1 && n < 100; n++) {
|
||||
const step = nextDiscoveryNativeStrongholdStep(game); assert.ok(step);
|
||||
const before = structuredClone(game); game = act(game, step, actions);
|
||||
if (game.turn === 2) { beforeFirstMentat = before; firstMentatStep = step; }
|
||||
}
|
||||
assert.ok(beforeFirstMentat && firstMentatStep);
|
||||
const afterFirstMentat = structuredClone(game);
|
||||
assert.equal(game.strongholdCards!.owners[claim], owner);
|
||||
assert.deepEqual(game.strongholdCards!.owners, strongholdControllers(beforeFirstMentat.players, ix));
|
||||
game = advanceDiscoveryNativeStronghold(game, g => g.decision?.kind === 'discoveryEntry', actions);
|
||||
assert.equal(game.decision!.player, collector);
|
||||
const entryBefore = structuredClone(game), offer = viewGame(game, collector).discoveryEntry!;
|
||||
const entryStep: DiscoveryNativeStrongholdStep = { actor: collector, action: ix
|
||||
? { type: 'decision', event: offer.event, accept: true, groups: [{ source, normal: 1, elite: 1 }] }
|
||||
: { type: 'decision', event: offer.event, accept: false } };
|
||||
game = act(game, entryStep, actions);
|
||||
game = advanceDiscoveryNativeStronghold(game, g => !g.discoveryEntry && !g.decision && !g.response, actions);
|
||||
const entry = { before: entryBefore, step: entryStep, after: structuredClone(game) };
|
||||
game = advanceDiscoveryNativeStronghold(game, g => g.phase === 5 && g.active === owner && discoveryNativeStrongholdClean(g), actions);
|
||||
const shipmentBefore = structuredClone(game), player = discoveryNativeStrongholdPlayer(game, owner);
|
||||
const noField = player.noField?.tokens.find(t => t.value === 5);
|
||||
const shipmentStep: DiscoveryNativeStrongholdStep = { actor: owner, action: ix
|
||||
? { type: 'ship', territory: 'shrine', sector: 0, amount: 2, elite: 1, allyPayment: 0 }
|
||||
: { type: 'ship', territory: 'shrine', sector: 0, noField: noField!.id, event: player.noFieldEvent, allyPayment: 0 } };
|
||||
game = act(game, shipmentStep, actions);
|
||||
game = advanceDiscoveryNativeStronghold(game, g => !g.pendingShipment && discoveryNativeStrongholdClean(g), actions);
|
||||
const shipment = { before: shipmentBefore, step: shipmentStep, after: structuredClone(game) };
|
||||
let markerReveal: DiscoveryNativeStrongholdFixture['markerReveal'] = null;
|
||||
if (!ix) {
|
||||
const before = structuredClone(game);
|
||||
const step: DiscoveryNativeStrongholdStep = { actor: owner, action: { type: 'revealNoField',
|
||||
token: noField!.id, event: discoveryNativeStrongholdPlayer(game, owner).noFieldEvent } };
|
||||
game = act(game, step, actions); markerReveal = { before, step, after: structuredClone(game) };
|
||||
}
|
||||
if (ix) {
|
||||
place(game, owner, `sietch_tabr:${territory('sietch_tabr').sectors[0]}`, 1);
|
||||
staging.push('After earned first-Mentat custody: one conserved Ixian reserve counter → Sietch Tabr, giving a second CURRENT copy choice without claiming its unheld card.');
|
||||
}
|
||||
const location = ix ? MOBILE_LOCATION : 'shrine:0', battleTerritory = ix ? MOBILE_STRONGHOLD : 'shrine';
|
||||
place(game, opponent, location, 6);
|
||||
// A second actual conflict keeps Battle open so bank/Tech custody can be
|
||||
// inspected before unrelated Collection or the next Mentat checkpoint.
|
||||
const other = gameTerritories(game).find(t => t.type === 'sand' && t.id !== placement.territory && t.sectors.some(s => s >= 9));
|
||||
assert.ok(other); const otherLocation = `${other.id}:${other.sectors.find(s => s >= 9)!}`;
|
||||
place(game, owner, otherLocation, 1); place(game, opponent, otherLocation, 1);
|
||||
staging.push(`Conserved opponent reserve counters → ${location} (six); one counter per combatant → ${otherLocation} for a second original conflict. Retain earned first-Mentat cards and all paid/free arrivals.`);
|
||||
const defense = !ix ? held(game, owner, 'shield', staging) : null;
|
||||
const weapon = !ix ? held(game, opponent, 'poison', staging) : null;
|
||||
const leader = discoveryNativeStrongholdPlayer(game, owner).leaders.filter(l => !l.dead && !isAuditorLeader(l)).sort((a, b) => b.strength - a.strength)[0];
|
||||
const opponentLeader = discoveryNativeStrongholdPlayer(game, opponent).leaders.filter(l => !l.dead && !isAuditorLeader(l)).sort((a, b) => a.strength - b.strength)[0];
|
||||
assert.ok(leader && opponentLeader);
|
||||
game = advanceDiscoveryNativeStronghold(game, g => g.phase === 6 && discoveryNativeStrongholdClean(g), actions);
|
||||
const beforeBattle = structuredClone(game), actor = game.active!;
|
||||
assert.ok(actor === owner || actor === opponent);
|
||||
const battleStep: DiscoveryNativeStrongholdStep = { actor, action: { type: 'chooseBattle', territory: battleTerritory, target: actor === owner ? opponent : owner } };
|
||||
game = act(game, battleStep, actions);
|
||||
for (let n = 0; n < 120; n++) {
|
||||
if (game.decision?.kind === 'strongholdCopy') break;
|
||||
const step = nextDiscoveryNativeStrongholdStep(game); if (!step) break;
|
||||
game = act(game, step, actions);
|
||||
}
|
||||
const copyStep: DiscoveryNativeStrongholdStep | null = game.decision?.kind === 'strongholdCopy'
|
||||
? { actor: owner, action: { type: 'decision', event: game.decision.event, stronghold: 'arrakeen' } } : null;
|
||||
assert.equal(Boolean(copyStep), ix);
|
||||
const plans: DiscoveryNativeStrongholdStep[] = [
|
||||
{ actor: owner, action: { type: 'battlePlan', leader: leader.id, dial: ix ? 6 : 0, support: ix ? 3 : 0, weapon: null, defense } },
|
||||
{ actor: opponent, action: { type: 'battlePlan', leader: opponentLeader.id, dial: 0, support: 0, weapon, defense: null } },
|
||||
];
|
||||
assertDiscoveryNativeStrongholdCustody(game);
|
||||
return { initial, setup, afterSetup, beforeBlow, afterBlow, beforeReveal, afterReveal,
|
||||
beforeFirstMentat, firstMentatStep, afterFirstMentat, entry, shipment, markerReveal,
|
||||
beforeBattle, battleStep, copyStep, game, kind, owner, collector, opponent, choam,
|
||||
token: token.id, parent: placement.territory, source, location, leader: leader.id,
|
||||
opponentLeader: opponentLeader.id, defense, weapon, plans, actions, staging };
|
||||
}
|
||||
export function prepareDiscoveryNativeStrongholdBattle(fixture: DiscoveryNativeStrongholdFixture): Game {
|
||||
let game = discoveryNativeStrongholdReload(fixture.game);
|
||||
if (fixture.copyStep) game = act(game, fixture.copyStep);
|
||||
for (let n = 0; n < 120; n++) {
|
||||
const step = nextDiscoveryNativeStrongholdStep(game);
|
||||
if (!step) { assert.ok(game.battle && !game.battle.revealed); return game; }
|
||||
game = act(game, step);
|
||||
}
|
||||
throw Error('Original native pre-plan window did not close');
|
||||
}
|
||||
export function revealDiscoveryNativeStrongholdBattle(fixture: DiscoveryNativeStrongholdFixture): Game {
|
||||
let game = prepareDiscoveryNativeStrongholdBattle(fixture);
|
||||
for (const plan of fixture.plans) {
|
||||
game = act(game, plan);
|
||||
while (game.response || game.decision?.kind === 'fullPlanOffer') {
|
||||
const next = nextDiscoveryNativeStrongholdStep(game); assert.ok(next); game = act(game, next);
|
||||
}
|
||||
}
|
||||
assert.ok(game.battle?.revealed); return game;
|
||||
}
|
||||
export function finishDiscoveryNativeStrongholdBattle(state: Game): Game {
|
||||
return advanceDiscoveryNativeStronghold(state, g => !g.battle && !g.decision && !g.response && !g.pendingTreacheryDiscard);
|
||||
}
|
||||
Reference in new issue
Block a user