Quintine
9b67a780eb
During the existing public pre-plan opportunity, the holder can discard canonical unreserved Sapho to become aggressor before their readiness or any binding plan/Voice/inspection/Truthtrance commitment. Unchosen preparation prompts remain available. No new confirmation-only or holder-dependent response window is introduced. Later intervention and its allocation/privacy protocol remain unfinished. A battle/turn/revision-bound history and independent event list preserve accepted priority while keeping attacker, defender and chooser stable. Legitimately recovered cards can change priority again at a fresh event. Reads, actions and normalization reject corrupt histories/custody. Shared tie priority respects Habbanya in either physical slot and reaches pre-commit Stone/Voice checks, public views, bot calculations and actual ordinary/Stone resolution. The final quote previously assumed original attacker priority and now consumes the validated aggressor. Harkonnen capture still follows actual winner/loser. Owner controls, public aggressor/tie text, automatic notices and internal guidance are connected. Focused tests exercise actual tied results in Basic/Advanced, both Habbanya sides, mixed-force Stone finishability before opposing commitments, a real allied Prescience boundary, stale/late/cross-owner rejection, private rival noninterference, receipt corruption, saved recovered-card revision, actual policies at all four AI levels and authenticated SQLite races/seat restoration. Independent review found no material defect. A prior scheduling test now explicitly readies its human holder to save the card instead of allowing the new legal AI play. Types, lint and 4866 offline tests, production build and 43 HTTP/session tests pass on the unchanged source fingerprint below. Two genuine CHOAM/Richese samples completed with 1279 accepted actions, 34 periodic JSON restores and no rejected candidates. One movement Sapho play occurred; neither sample used aggressor. Targeted tests and browser evidence, not those samples, establish the new effect. Full expansion and module acceptance remain incomplete. In a new isolated browser room, genuine Advanced faction setup was followed by conserved battle staging. The human Guild used the actual aggressor button, restored the spent card and priority after refresh, readied, selected Master Bewt with zero dial/support, and declined a Traitor call. The staged Emperor opponent used real engine ready/plan/vote actions with Caid and zero dial/support. Guild won the 3-3 tie, retained four forces and 30 spice, and Emperor lost four forces. Final refresh and private JSON views restored the same outcome; the original seat row is unchanged. Screenshot capture timed out, so visual screenshot acceptance is not claimed. All 1072 original games and original seat/recovery/entry/handover records are unchanged; 1106 rooms remain including isolated QA and HTTP fixtures. SQLite quick-check and foreign keys pass. The healthy server was reused without reset/restart or automation. The Mirror audit now records why every genuine CHOAM/Richese setup includes unresolved copy candidates: an ordinary-copy-only gate would need hidden eligibility or altered inventory. Mirror stays gated pending the existing disposal ruling and copied-choice work. No mode/publication gate is opened. Verified source tree: 2fb3160efd713a3f7068aedb474868ba6863bccc420848a56e69e1df1d84441b
73 lines
3.5 KiB
TypeScript
73 lines
3.5 KiB
TypeScript
export type SaphoAggressorUse = { event: string; player: string };
|
|
export type SaphoAggressorState = {
|
|
version: 1;
|
|
battle: string;
|
|
turn: number;
|
|
attacker: string;
|
|
defender: string;
|
|
uses: SaphoAggressorUse[];
|
|
};
|
|
type BattleIdentity = { event?: string; attacker: string; defender: string };
|
|
export class SaphoAggressorError extends Error {}
|
|
function check(value: unknown, message: string): asserts value {
|
|
if (!value) throw new SaphoAggressorError(message);
|
|
}
|
|
/** Habbanya's printed exception applies to either stable combat slot. */
|
|
export function battleTieOwner(attacker: string, defender: string, aggressor: string,
|
|
habbanyaOwners: readonly string[]): string {
|
|
check(attacker !== defender && [attacker, defender].includes(aggressor) &&
|
|
habbanyaOwners.length <= 1 && habbanyaOwners.every(id => [attacker, defender].includes(id)),
|
|
'The battle tie priority needs distinct combatants and at most one Habbanya owner.');
|
|
return habbanyaOwners[0] ?? aggressor;
|
|
}
|
|
export function saphoAggressorEvent(battle: string, turn: number, revision: number) {
|
|
return `saphoAggressor:${JSON.stringify([battle, turn, revision])}`;
|
|
}
|
|
/** Preserve physical slots. Only explicit, battle-bound uses change tie priority. */
|
|
export function validateSaphoAggressor(
|
|
state: SaphoAggressorState | undefined,
|
|
events: readonly string[] | undefined,
|
|
battle: BattleIdentity,
|
|
turn: number,
|
|
): string {
|
|
check(!!state === !!events, 'The saved Sapho aggressor needs its independent use events.');
|
|
if (!state) return battle.attacker;
|
|
check(state && typeof state === 'object' && !Array.isArray(state) &&
|
|
Object.keys(state).sort().join(',') === 'attacker,battle,defender,turn,uses,version' &&
|
|
state.version === 1 && state.battle === battle.event &&
|
|
typeof state.battle === 'string' && state.battle.length > 0 &&
|
|
Number.isSafeInteger(turn) && turn >= 1 && state.turn === turn &&
|
|
state.attacker === battle.attacker && state.defender === battle.defender &&
|
|
typeof state.attacker === 'string' && state.attacker.length > 0 &&
|
|
typeof state.defender === 'string' && state.defender.length > 0 &&
|
|
state.attacker !== state.defender && Array.isArray(state.uses) && state.uses.length > 0 &&
|
|
Array.isArray(events) && events.length === state.uses.length,
|
|
'The saved Sapho aggressor does not match this battle.');
|
|
let aggressor = state.attacker;
|
|
for (const [index, use] of state.uses.entries()) {
|
|
check(use && typeof use === 'object' && !Array.isArray(use) &&
|
|
Object.keys(use).sort().join(',') === 'event,player' &&
|
|
use.event === saphoAggressorEvent(state.battle, turn, index) && events[index] === use.event &&
|
|
[state.attacker, state.defender].includes(use.player) && use.player !== aggressor,
|
|
'The saved Sapho aggressor use is stale or invalid.');
|
|
aggressor = use.player;
|
|
}
|
|
return aggressor;
|
|
}
|
|
export function changeSaphoAggressor(
|
|
state: SaphoAggressorState | undefined,
|
|
events: readonly string[] | undefined,
|
|
battle: BattleIdentity,
|
|
turn: number,
|
|
player: string,
|
|
event: string,
|
|
): SaphoAggressorState {
|
|
const aggressor = validateSaphoAggressor(state, events, battle, turn);
|
|
check(typeof battle.event === 'string' && battle.event.length > 0 &&
|
|
[battle.attacker, battle.defender].includes(player) && player !== aggressor &&
|
|
event === saphoAggressorEvent(battle.event, turn, state?.uses.length ?? 0),
|
|
'This Sapho aggressor opportunity is unavailable or expired.');
|
|
return { version: 1, battle: battle.event, turn, attacker: battle.attacker,
|
|
defender: battle.defender, uses: [...(state?.uses ?? []), { event, player }] };
|
|
}
|