Support current battle choice promises and persistent notices
Verify and publish checkpoint container / container (push) Successful in 11m42s

This commit is contained in:
Quintine committed 2026-11-16 21:49:48 +11:00
1 parent 77d02b3231
commit bd8377d87b
16 files changed
+684 -32

No files matched your search

+48 -1
View File
@@ -55,6 +55,7 @@ import { TurnActionError, liveTurnActionPromises, turnActionBranches, recordTurn
closeTurnActionRevival, settleTurnActionAlliance, recordTurnActionPlan, recordTurnActionTraitor, closeTurnActionCombat,
recordTurnActionBattlePower, closeTurnActionBattlePower,
recordTurnActionWindowCardPlay, closeTurnActionWindowCardPlay,
recordTurnActionBattleChoice, closeTurnActionBattleChoice,
recordTurnActionStormDial, closeTurnActionStormDial, turnActionStormDialChoices,
turnActionPromiseModeSupported, type TurnActionPlanValue, type TurnActionCombat, type TurnActionClaim, type TurnActionPromise, type TurnActionBranchLeaf, type TurnActionPreparation, type TurnActionWindowCards } from './turn-action-promises';
import { TravelPromiseError, liveTravelPromises, travelBranches, recordTravelShipment, recordTravelMovement,
@@ -24302,6 +24303,16 @@ function turnActionTargetAvailable(g: Game, actor: string): boolean {
!bribeTimingBlock({ ...context, truthtrance: null, response: battleCancel ? null : context.response,
inflation: context.inflation?.side === 'double' ? null : context.inflation });
}
/** The current chooser's real unresolved pairs; independent of the private
* Truthtrance window, which may temporarily suspend this public opportunity. */
function turnActionBattleChoiceOpportunity(g: Game, actor: string) {
if (g.status !== 'playing' || g.phase !== 6 || g.battle || g.active !== actor) return null;
const source = battleChooserEvent(g.turn, battleOrderAfterBattle(g), g.battleOrder?.uses.length ?? 0);
const choices = battleOrderQuote(g).choices.filter(choice => choice.chooser === actor).map(choice => ({
territory:choice.territory,target:choice.attacker === actor ? choice.defender : choice.attacker,
}));
return choices.length ? {source,choices} : null;
}
/** Whole native commitments retain the existing Semuta discard continuation.
* This does not expand the separate legacy bribe or Kull/module envelopes. */
function turnActionPromiseTurn(g: Game): boolean {
@@ -24542,7 +24553,7 @@ function turnActionAllianceCanClose(g: Game, player: Player): boolean {
return !!turnActionCompletion(source, player.id);
} catch (error) { if (error instanceof RuleError) return false; throw error; }
}
type TurnActionCompletion = MovementCompletion & { stormDial?: Action; payments: Action[]; paymentsAfterPreparations?: boolean; bid?: Action; revival?: RevivalPromisePlan; alliance?: Action[]; battlePlan?: BattleCompletion; traitor?: Action; cardPreparations?: Action[]; battlePower?: Action; freshDiscard?: Action };
type TurnActionCompletion = MovementCompletion & { stormDial?: Action; payments: Action[]; paymentsAfterPreparations?: boolean; bid?: Action; revival?: RevivalPromisePlan; alliance?: Action[]; battleChoice?: Action; battlePlan?: BattleCompletion; traitor?: Action; cardPreparations?: Action[]; battlePower?: Action; freshDiscard?: Action };
/** Forecast deterministic opening work only. Auction/deck draws and foreign
* choices stay at the real table; fixed Mentat receipts arrive after Amal. */
function projectTurnActionOpeningEnd(g: Game) {
@@ -24708,6 +24719,7 @@ function turnActionCompletionAfterFreshDiscard(source: Game, actor: string, unkn
return null;
}
const dialLeaves = leaves.filter((leaf): leaf is Extract<TurnActionBranchLeaf, { kind: 'stormDial' }> => leaf.kind === 'stormDial');
const choiceLeaves = leaves.filter((leaf): leaf is Extract<TurnActionBranchLeaf, { kind: 'battleChoice' }> => leaf.kind === 'battleChoice');
const dialOpportunity = dialLeaves.length ? nativeStormDialOpportunity(source, actor) : null;
if (dialLeaves.length && (!dialOpportunity || dialLeaves.some(leaf => leaf.source !== dialOpportunity.source))) return null;
const dialValues = dialOpportunity ? turnActionStormDialChoices(dialLeaves, dialOpportunity.source) : [];
@@ -24840,6 +24852,11 @@ function turnActionCompletionAfterFreshDiscard(source: Game, actor: string, unkn
source.phaseOpening ? windowRequirements.filter(required => required.effect !== 'amal') : windowRequirements, prepareAlliance)) {
const funded = cardSeed.game, payer = getPlayer(funded, actor);
try {
const opportunity = choiceLeaves.length ? turnActionBattleChoiceOpportunity(funded,actor) : null;
if (choiceLeaves.length && (!opportunity || choiceLeaves.some(leaf => leaf.source !== opportunity.source))) continue;
const choice = opportunity?.choices.find(candidate => choiceLeaves.every(leaf =>
(candidate.territory === leaf.territory && candidate.target === leaf.target) === leaf.answer));
if (choiceLeaves.length && !choice) continue;
reconcileBattlePromises(funded, voluntary);
const battle = funded.battle;
const needsPlan = !!battle && !battle.revealed && [battle.attacker, battle.defender].includes(actor) &&
@@ -24885,6 +24902,7 @@ function turnActionCompletionAfterFreshDiscard(source: Game, actor: string, unkn
return { ...completion, ...(dialOpportunity ? { stormDial: { type: 'stormDial', amount: dialValues[0] } } : {}),
...(cardPreparations.length ? { cardPreparations } : {}),
...(cardSeed.cardsFirst ? { paymentsAfterPreparations: true } : {}), ...(bid ? { bid } : {}), ...(revival ? { revival } : {}),
...(choice ? { battleChoice: {type:'chooseBattle',...choice} } : {}),
...(battlePlan ? { battlePlan } : {}), ...(traitor ? { traitor } : {}),
...(power.action ? { battlePower: power.action } : {}),
...(alliancePlan ? { alliance: alliancePlan.steps.map(step => step.kind === 'groupLeave'
@@ -24911,6 +24929,7 @@ function turnActionPromise(g: Game, p: Player, claim: TurnActionClaim, answer: b
const powers = new Set<NativeBattlePower>();
const windowCards: TurnActionWindowCards = {};
let stormDialSource: string | undefined;
let battleChoiceSource: string | undefined;
const visit = (node: TurnActionClaim['mixed']): void => {
if (node.kind === 'action') {
if (node.action.kind === 'bid') bid = true;
@@ -24919,6 +24938,14 @@ function turnActionPromise(g: Game, p: Player, claim: TurnActionClaim, answer: b
stormDialSource = node.action.source;
}
if (node.action.kind === 'alliance') alliance = true;
if (node.action.kind === 'battleChoice') {
const opportunity = turnActionBattleChoiceOpportunity(g,p.id), selection = node.action;
requireRule(opportunity && selection.source === opportunity.source &&
(!battleChoiceSource || battleChoiceSource === selection.source) &&
opportunity.choices.some(choice => choice.territory === selection.territory && choice.target === selection.target),
'Retain the current chooser and an actual available battle.');
battleChoiceSource = selection.source;
}
if (node.action.kind === 'battlePlan') plan = true;
if (node.action.kind === 'traitorCall') traitor = true;
if (node.action.kind === 'battlePower') powers.add(battlePowerOf(node.action.claim));
@@ -24958,6 +24985,7 @@ function turnActionPromise(g: Game, p: Player, claim: TurnActionClaim, answer: b
traitor: context ? { beneficiary: context.beneficiary, target: context.target, leader: context.leader,
closed: false, call: null } : null } : undefined;
let promise: TurnActionPromise = { turn: claim.turn, mixed: structuredClone(claim.mixed), event, player: p.id, asker, answer, compiled,
...(battleChoiceSource ? { battleChoice: {source:battleChoiceSource,closed:false,selected:null} } : {}),
...(Object.keys(windowCards).length ? { windowCards } : {}),
...(dial ? { stormDial: { source: dial.source, closed: false, actual: null } } : {}),
...(printedCards.size ? { cardPlays: { hajr: printedCards.has('hajr') ? { played: false, closed: !open } : null,
@@ -25058,6 +25086,18 @@ function reconcileTurnActionPromises(g: Game, actor?: string, action?: Action, s
if (g.pendingKull || suspendedKull) return;
reconcileTurnActionCombat(g);
reconcileTurnActionWindowCards(g);
for (const row of g.turnActionPromises ?? []) {
if (!row.battleChoice || row.battleChoice.closed || row.fulfilled || row.released ||
turnActionBattleChoiceOpportunity(g,row.player)?.source === row.battleChoice.source) continue;
g.turnActionPromises = turnActionRule(() => closeTurnActionBattleChoice(g.turnActionPromises!,
row.player,row.turn,row.battleChoice!.source));
const closed = g.turnActionPromises.find(promise => promise.event === row.event);
if (closed && !closed.fulfilled && !closed.released && turnActionRule(() => turnActionBranches(closed).next().done)) {
requireRule(actor !== closed.player, 'You cannot voluntarily close your required battle-choice answer.');
closed.released = true;
log(g, `${getPlayer(g,closed.player).name} can no longer fulfill an accepted Truthtrance commitment; that answer is no longer binding.`);
}
}
for (const row of g.turnActionPromises ?? []) {
if (!row.stormDial || row.stormDial.closed || row.fulfilled || row.released ||
nativeStormDialOpportunity(g, row.player, row.stormDial.source)) continue;
@@ -25268,6 +25308,8 @@ function projectedTurnActionGuide(g: Game, player: Player): { event: string; act
} else if (!action && g.phase === 5 && g.active === player.id && !promise.transportClosed)
action = completion.actions[0] ?? { type: 'endMovement' };
}
if (!action && g.phase === 6 && !g.battle && g.active === player.id && completion.battleChoice)
action = completion.battleChoice;
if (!action && g.phase === 6 && g.battle) {
const battle = g.battle;
if (completion.battlePower) action = completion.battlePower;
@@ -50056,6 +50098,11 @@ function applyActionInner(
(b.attacker === id ? b.defender : b.attacker) === action.target,
);
requireRule(choice, 'Choose one of your unresolved battles.');
if (g.turnActionPromises) {
const source = battleChooserEvent(g.turn,battleOrderAfterBattle(g),g.battleOrder?.uses.length ?? 0);
g.turnActionPromises = turnActionRule(() => recordTurnActionBattleChoice(g.turnActionPromises!,id,g.turn,source,
{territory:choice.territory,target:choice.attacker === id ? choice.defender : choice.attacker}));
}
g.auditorInsight = null;
retireNexusChoamInsight(g);
const ecaz = byFaction(g, 'ecaz');
+1
View File
@@ -3376,6 +3376,7 @@ export const RULE_TOPICS: RuleTopic[] = [
'Ordinary force Revival clauses accumulate future total, normal or elite physical returns. Personal native leader clauses include eligible Advanced Atreides Kwisatz. Prior returns, Ghola, foreign leaders and special returns do not count. Original costs, slots, cycles and actual return controls remain.',
'Basic Revival No lasts to phase close; ordered Advanced finishes at the respondent’s actual own turn end. Own Ready must retain a whole completion, including a funded later payment alternative. An owned Karama invoice guide appears only at the actual payment decision, never while another bidder is active.',
'A battle-plan condition names an atomic part of your actual plan in this current battle. An open condition settles when both original plans reveal; a plan already sealed fixes its value at the answer. The human guide fills your existing plan for review before sealing. Native leaders, physical cards, Voice, costs and ordered preparation still apply.',
'A current battle-choice condition names the actual chooser, territory and opponent at this original battle-order opportunity. Yes requires the choice while possible; No forbids it. Combined and separate commitments share the native legal guide; a later choice is a different opportunity. This online interpretation is provisional.',
'A Traitor condition describes the original eligible voter’s Reveal or Decline declaration in this revealed battle, before any later Karama prevention. A prevented Reveal stays a declared Reveal. No missing battle or declaration is invented as a zero plan or Decline, and an absent matching Traitor never creates one.',
'A future storm-dial condition names a current Basic dialer who has not submitted and asks whether their value will be exactly, at least or at most a chosen threshold. Turn 1 permits 0–20; later Basic turns permit 1–3. Yes and No bind the whole answer; multiple conditions share the same native choice. The other dial remains sealed, and the normal sum is revealed only after both dialers submit.',
'A native-power condition names your original Voice or Prescience opportunity in this battle. Ask about actual use or explicit Decline, an exact Voice category and require/forbid command, or the requested Prescience field. A requested field is not the inspected answer. The declaration counts before later Karama prevention.',
+12 -1
View File
@@ -63,7 +63,8 @@ import {
} from './battle-promises';
import { gameTerritories } from './board';
import { leaders } from './cards';
import { combatLocationName } from './combat-location';
import { combatLocationName, quoteCombatBoard } from './combat-location';
import { battleChooserEvent, quoteBattleChoosers } from './battle-chooser-order';
import { parseForceCountFact, forceCountFactMatches, forceCountFactText, forceCountCounterError, type ForceCountFact, type ForceCountPlayer } from './truthtrance-force-count';
import type { Action, Game, Player } from './engine';
import { coalitionAllies } from './coalition-alliance';
@@ -536,6 +537,15 @@ function parseQuestion(g: Game, asker: string, value: unknown): TruthQuestion {
const respondent = g.players.find(player => player.id === v.target)!;
const mixed = parseMixedActionExpression(v.mixed, fact => parseFact(g, fact, respondent), input => {
const action = parseTurnActionLeaf(input);
if (action.kind === 'battleChoice') {
const source = battleChooserEvent(g.turn, g.lastBattleContext?.turn === g.turn ? g.lastBattleContext.event : null,
g.battleOrder?.uses.length ?? 0);
const choices = quoteBattleChoosers(quoteCombatBoard(g).battles,g.order,g.battleOrder?.priority).choices;
check(g.phase === 6 && !g.battle && g.active === respondent.id && action.source === source &&
choices.some(choice => choice.chooser === respondent.id && choice.territory === action.territory &&
(choice.attacker === respondent.id ? choice.defender : choice.attacker) === action.target),
'Choose the current player’s original available battle and opponent.');
}
if (battleCancel) check(action.kind === 'windowCardPlay' && action.effect === 'karamaBattleCancel' &&
action.source === battleCancel.source, 'Ask only about the current printed Karama cancellation in this response.');
if (action.kind === 'stormDial') {
@@ -991,6 +1001,7 @@ export function truthQuestionText(
};
if (q.kind === 'turnActions') return `Is it true that ${mixedActionExpressionText(q.mixed, clause,
action => {
if (action.kind === 'battleChoice') return `you choose the battle against ${playerName(action.target)} in ${locationName(action.territory)} at this battle-choice opportunity`;
if (action.kind === 'stormDial') return `you submit ${action.compare === 'gte' ? 'at least' : action.compare === 'lte' ? 'at most' : 'exactly'} ${action.value} on your original storm dial this turn`;
if (action.kind === 'windowCardPlay') {
if (action.effect === 'karamaHarkonnenSpecial')
+89 -1
View File
@@ -42,6 +42,7 @@ export function turnActionPromiseModeSupported(game: NativePromiseScope & {
export type TurnActionLeaf = TravelActionClaim | StormDialClaim | { kind: 'payment'; recipient: string; minimum: number } |
{ kind: 'bid'; lot: number; minimum: number } | RevivalActionClaim | { kind: 'alliance'; partner: string } |
{ kind: 'battleChoice'; source: string; territory: string; target: string } |
{ kind: 'battlePlan'; battle: string; territory: string; claim: MixedBattleActionClaim } |
{ kind: 'traitorCall'; battle: string; territory: string; call: boolean } |
{ kind: 'cardPlay'; effect: PrintedCardEffect } |
@@ -56,6 +57,7 @@ export type TurnActionBranchLeaf = TravelBranchLeaf |
{ kind: 'forces'; counter: 'total' | 'normal' | 'elite'; minimum: number; progress: number; answer: boolean } |
{ kind: 'leader'; leader: string; answer: boolean } |
{ kind: 'alliance'; partner: string; source: string; answer: boolean } |
{ kind: 'battleChoice'; source: string; territory: string; target: string; answer: boolean } |
{ kind: 'battlePlan'; battle: string; territory: string; claim: MixedBattleActionClaim; answer: boolean } |
{ kind: 'traitorCall'; battle: string; territory: string; call: boolean; answer: boolean;
beneficiary: string; target: string; leader: string | null } |
@@ -114,6 +116,8 @@ export type TurnActionPromise = TurnActionClaim & {
windowCards?: TurnActionWindowCards;
/** A submitted dial is private to its respondent until the native reveal. */
stormDial?: { source: string; closed: boolean; actual: number | null };
/** Only the original chooser opportunity and its one actual native choice. */
battleChoice?: { source: string; closed: boolean; selected: { territory: string; target: string } | null };
};
export class TurnActionError extends Error {
@@ -141,6 +145,19 @@ const printedTerritory = (value: unknown): value is string =>
typeof value === 'string' && TERRITORIES.some(destination => destination.id === value);
const windowEffect = (value: unknown): value is WindowCardEffect => WINDOW_CARD_EFFECTS.some(effect => effect === value);
/** Decode the exact existing public battle-chooser event, without inventing
* a competing event grammar or accepting a client-selected turn. */
function battleChoiceSource(value: unknown): { turn: number } | null {
if (!identifier(value) || !value.startsWith('battleOrder:')) return null;
try {
const tuple: unknown = JSON.parse(value.slice('battleOrder:'.length));
if (!Array.isArray(tuple) || tuple.length !== 3 || !positive(tuple[0]) ||
!(tuple[1] === null || identifier(tuple[1])) || !whole(tuple[2]) ||
value !== `battleOrder:${JSON.stringify(tuple)}`) return null;
return {turn:tuple[0]};
} catch { return null; }
}
/** Identity membership is decoded by Truthtrance; here retain one strict atom. */
function parseCombatClaim(value: unknown): MixedBattleActionClaim {
try {
@@ -189,6 +206,12 @@ export function parseTurnActionLeaf(value: unknown): TurnActionLeaf {
'Choose only a supported printed-card play after this answer.');
return { kind: 'cardPlay', effect: value.effect as PrintedCardEffect };
}
if (value.kind === 'battleChoice') {
check(keys(value, 'kind,source,target,territory') && !!battleChoiceSource(value.source) &&
identifier(value.territory) && identifier(value.target),
'Choose the original battle-selection opportunity, destination and opponent.');
return {kind:'battleChoice',source:value.source as string,territory:value.territory,target:value.target};
}
if (value.kind === 'battlePlan' || value.kind === 'traitorCall') {
check(keys(value, value.kind === 'battlePlan' ? 'battle,claim,kind,territory' : 'battle,call,kind,territory') &&
identifier(value.battle) && identifier(value.territory), 'Retain the exact original current battle and native location.');
@@ -235,6 +258,7 @@ function storedFact(value: unknown, depth = 0): TruthFact {
}
function actionKey(action: TurnActionLeaf): string {
if (action.kind === 'battleChoice') return JSON.stringify([action.kind,action.source,action.territory,action.target]);
if (action.kind === 'stormDial') return JSON.stringify(action.compare && action.compare !== 'eq'
? [action.kind, action.source, action.value, action.compare] : [action.kind, action.source, action.value]);
if (action.kind === 'windowCardPlay') return JSON.stringify([action.kind, action.effect, action.source]);
@@ -300,6 +324,7 @@ function readPromise(promise: TurnActionPromise): CompiledMixedAction<TurnAction
if ('cardPlays' in promise) fields.push('cardPlays');
if ('windowCards' in promise) fields.push('windowCards');
if ('stormDial' in promise) fields.push('stormDial');
if ('battleChoice' in promise) fields.push('battleChoice');
check(keys(promise, fields.sort().join(',')) &&
positive(promise.turn) && identifier(promise.event) && identifier(promise.player) && identifier(promise.asker),
'Retain the complete original turn-action commitment and its metadata.');
@@ -326,6 +351,7 @@ function readPromise(promise: TurnActionPromise): CompiledMixedAction<TurnAction
const cardEffects = new Set<PrintedCardEffect>();
const windowSources = new Map<WindowCardEffect, Set<string>>();
const stormSources = new Set<string>();
const choiceSources = new Set<string>();
const visit = (node: MixedActionExpression<TurnActionLeaf>): void => {
if (node.kind === 'action') {
originals.add(actionKey(node.action));
@@ -343,6 +369,7 @@ function readPromise(promise: TurnActionPromise): CompiledMixedAction<TurnAction
if (node.action.kind === 'traitorCall') hasTraitor = true;
if (node.action.kind === 'cardPlay') cardEffects.add(node.action.effect);
if (node.action.kind === 'stormDial') stormSources.add(node.action.source);
if (node.action.kind === 'battleChoice') choiceSources.add(node.action.source);
if (node.action.kind === 'battlePower') powerClaims[battlePowerOf(node.action.claim)].add(powerKey(node.action.claim));
if (node.action.kind === 'windowCardPlay') {
const sources = windowSources.get(node.action.effect) ?? new Set<string>();
@@ -360,6 +387,16 @@ function readPromise(promise: TurnActionPromise): CompiledMixedAction<TurnAction
for (const power of ['voice', 'prescience'] as const) check(!powerClaims[power].size || !!promise.combat?.powers?.[power],
'Retain the original private native battle-power stage, including folded original clauses.');
check(!stormSources.size || !!promise.stormDial, 'Retain the original native storm-dial interval, including folded clauses.');
check(!choiceSources.size || !!promise.battleChoice, 'Retain the original native battle-selection interval.');
if ('battleChoice' in promise) {
const stage = promise.battleChoice, source = stage && battleChoiceSource(stage.source);
check(object(stage) && keys(stage, 'closed,selected,source') && source && source.turn === promise.turn &&
choiceSources.size === 1 && choiceSources.has(stage.source) && typeof stage.closed === 'boolean' &&
(stage.selected === null || object(stage.selected) && keys(stage.selected, 'target,territory') &&
identifier(stage.selected.target) && stage.selected.target !== promise.player && identifier(stage.selected.territory)) &&
(stage.closed || stage.selected === null),
'Retain one original chooser source and only its actual selected battle after closure.');
}
if ('stormDial' in promise) {
const stage = promise.stormDial;
const source = stage && parseStormDialSource(stage.source);
@@ -535,6 +572,9 @@ function readPromise(promise: TurnActionPromise): CompiledMixedAction<TurnAction
}
function actionValue(action: TurnActionLeaf, promise: TurnActionPromise): boolean {
if (action.kind === 'battleChoice') return !!promise.battleChoice?.closed &&
promise.battleChoice.source === action.source && promise.battleChoice.selected?.territory === action.territory &&
promise.battleChoice.selected?.target === action.target;
if (action.kind === 'stormDial') return promise.stormDial?.source === action.source &&
promise.stormDial.actual !== null && stormDialMatches(action, promise.stormDial.actual);
if (action.kind === 'windowCardPlay') return promise.windowCards?.[action.effect]?.played ?? false;
@@ -569,6 +609,7 @@ function evaluate(node: CompiledMixedAction<TurnActionLeaf>, promise: TurnAction
}
function actionClosed(action: TurnActionLeaf, promise: TurnActionPromise): boolean {
if (action.kind === 'battleChoice') return promise.battleChoice!.closed;
if (action.kind === 'stormDial') return promise.stormDial!.closed;
if (action.kind === 'windowCardPlay') return promise.windowCards![action.effect]!.closed;
if (action.kind === 'battlePower') return promise.combat!.powers![battlePowerOf(action.claim)]!.closed;
@@ -612,6 +653,8 @@ export function liveTurnActionPromises<T extends TurnActionPromise>(promises: re
function sameAction(left: TurnActionBranchLeaf, right: TurnActionBranchLeaf): boolean {
if (left.kind !== right.kind) return false;
if (left.kind === 'battleChoice') return right.kind === 'battleChoice' && left.source === right.source &&
left.territory === right.territory && left.target === right.target;
if (left.kind === 'stormDial') return right.kind === 'stormDial' && left.source === right.source &&
left.value === right.value && (left.compare ?? 'eq') === (right.compare ?? 'eq');
if (left.kind === 'windowCardPlay') return right.kind === 'windowCardPlay' && left.effect === right.effect && left.source === right.source;
@@ -650,6 +693,14 @@ export function turnActionStormDialChoices(leaves: readonly TurnActionBranchLeaf
function mergeBranches(left: TurnActionBranchLeaf[], right: TurnActionBranchLeaf[]): TurnActionBranchLeaf[] | null {
const merged = left.map(leaf => ({ ...leaf }));
for (const leaf of right) {
if (leaf.kind === 'battleChoice') {
const prior = merged.find(other => sameAction(other,leaf));
if (prior && prior.answer !== leaf.answer) return null;
if (leaf.answer && merged.some(other => other.kind === 'battleChoice' && other.source === leaf.source &&
other.answer && (other.territory !== leaf.territory || other.target !== leaf.target))) return null;
if (!prior) merged.push({...leaf});
continue;
}
if (leaf.kind === 'traitorCall') {
const prior = merged.find(other => other.kind === 'traitorCall' && other.battle === leaf.battle &&
other.territory === leaf.territory && other.beneficiary === leaf.beneficiary && other.target === leaf.target && other.leader === leaf.leader);
@@ -747,6 +798,39 @@ function settle<T extends TurnActionPromise>(promise: T, update: T): T {
? { ...update, fulfilled: true } : update;
}
/** Record exactly the native chooser's accepted territory/opponent once.
* The engine owns candidate legality and reconciles external impossibility. */
export function recordTurnActionBattleChoice<T extends TurnActionPromise>(promises: readonly T[], player: string,
turn: number, source: string, selected: {territory:string; target:string}): T[] {
const identity = battleChoiceSource(source);
check(identity && identity.turn === turn && object(selected) && keys(selected, 'target,territory') &&
identifier(selected.territory) && identifier(selected.target) && selected.target !== player,
'Retain the original chooser opportunity and actual different opponent.');
const updates = new Map<T,T>();
for (const promise of liveTurnActionPromises(promises,player,turn)) {
readPromise(promise);
const stage = promise.battleChoice;
if (!stage || stage.closed || stage.source !== source) continue;
updates.set(promise,settle(promise,{...promise,battleChoice:{...stage,closed:true,selected:{...selected}}}));
}
return promises.map(promise => updates.get(promise) ?? promise);
}
/** A lost or closed chooser source has no synthetic selected battle. */
export function closeTurnActionBattleChoice<T extends TurnActionPromise>(promises: readonly T[], player: string,
turn: number, source: string): T[] {
const identity = battleChoiceSource(source);
check(identity && identity.turn === turn, 'Retain the original current-turn battle chooser source.');
const updates = new Map<T,T>();
for (const promise of liveTurnActionPromises(promises,player,turn)) {
readPromise(promise);
const stage = promise.battleChoice;
if (!stage || stage.closed || stage.source !== source) continue;
updates.set(promise,settle(promise,{...promise,battleChoice:{...stage,closed:true}}));
}
return promises.map(promise => updates.get(promise) ?? promise);
}
/** Record one actual sealed native dial against its exact original source.
* Closing the stage never publishes its private numeric receipt. */
export function recordTurnActionStormDial<T extends TurnActionPromise>(promises: readonly T[], player: string,
@@ -1169,6 +1253,7 @@ export function finishTurnActionTurn<T extends TurnActionPromise>(promises: read
.filter(effect => Object.hasOwn(promise.cardPlays!, effect)).map(effect => [effect, promise.cardPlays![effect]
? { ...promise.cardPlays![effect]!, closed: true } : null])) as TurnActionCardPlays } : {}),
...(promise.windowCards ? { windowCards } : {}),
...(promise.battleChoice ? { battleChoice: { ...promise.battleChoice, closed: true } } : {}),
...(promise.stormDial ? { stormDial: { ...promise.stormDial, closed: true } } : {}) };
const unresolvedCombat = promise.combat && (promise.combat.plan && !promise.combat.plan.closed ||
promise.combat.traitor && !promise.combat.traitor.closed || promise.combat.powers?.voice && !promise.combat.powers.voice.closed ||
@@ -1193,15 +1278,18 @@ export function validateTurnActionPromises(promises: readonly TurnActionPromise[
(!promise.combat?.traitor || promise.combat.traitor.closed) &&
(!promise.combat?.powers?.voice || promise.combat.powers.voice.closed) &&
(!promise.combat?.powers?.prescience || promise.combat.powers.prescience.closed) &&
(!promise.battleChoice || promise.battleChoice.closed) &&
WINDOW_CARD_EFFECTS.every(effect => promise.windowCards?.[effect]?.closed ?? true) &&
(!promise.stormDial || promise.stormDial.closed) &&
PRINTED_CARD_EFFECTS.every(effect => promise.cardPlays?.[effect]?.closed ?? true);
const recipientsValid = (node: MixedActionExpression<TurnActionLeaf>): boolean => node.kind === 'action'
? node.action.kind === 'alliance' ? players.includes(node.action.partner) && node.action.partner !== promise.player :
? node.action.kind === 'battleChoice' ? players.includes(node.action.target) && node.action.target !== promise.player :
node.action.kind === 'alliance' ? players.includes(node.action.partner) && node.action.partner !== promise.player :
node.action.kind !== 'payment' || players.includes(node.action.recipient) && node.action.recipient !== promise.player
: node.kind === 'fact' || node.terms.every(recipientsValid);
check(!events.has(promise.event) && players.includes(promise.player) && players.includes(promise.asker) &&
promise.player !== promise.asker && recipientsValid(promise.mixed) &&
(!promise.battleChoice?.selected || players.includes(promise.battleChoice.selected.target)) &&
(!promise.alliance || promise.alliance.partner === null || players.includes(promise.alliance.partner)) &&
(!promise.combat?.traitor || players.includes(promise.combat.traitor.beneficiary) &&
players.includes(promise.combat.traitor.target) && promise.combat.traitor.target !== promise.player) &&