Complete Advanced Revival suspension and solo win ranking

This commit is contained in:
Quintine committed 2026-10-27 23:15:16 +11:00
1 parent 812657bb35
commit 3c62c284a7
17 files changed
+598 -47

No files matched your search

+81 -13
View File
@@ -16,10 +16,13 @@ export type SaphoRevivalOrderUse = {
mode: 'first' | 'last';
completed: string[];
started: boolean;
/** Version 3 only: the current started player voluntarily paused last. */
suspended?: true;
};
export type RevivalOrder = RevivalOrderFields & (
| { version: 1 }
| { version: 2; uses: SaphoRevivalOrderUse[] }
| { version: 3; uses: SaphoRevivalOrderUse[]; paused: string[] }
);
export type RevivalOrderContext = {
turn: number;
@@ -53,8 +56,10 @@ function validateContext(context: RevivalOrderContext): void {
function copy(frame: RevivalOrder): RevivalOrder {
const fields = { turn: frame.turn, original: [...frame.original],
remaining: [...frame.remaining], completed: [...frame.completed], started: frame.started };
return frame.version === 1 ? { version: 1, ...fields }
: { version: 2, ...fields, uses: frame.uses.map(use => ({ ...use, completed: [...use.completed] })) };
if (frame.version === 1) return { version: 1, ...fields };
const uses = frame.uses.map(use => ({ ...use, completed: [...use.completed] }));
return frame.version === 2 ? { version: 2, ...fields, uses }
: { version: 3, ...fields, uses, paused: [...frame.paused] };
}
export function createRevivalOrder(context: RevivalOrderContext): RevivalOrder {
@@ -67,9 +72,11 @@ export function createRevivalOrder(context: RevivalOrderContext): RevivalOrder {
export function validateRevivalOrder(context: RevivalOrderContext, frame: RevivalOrder): void {
validateContext(context);
requireOrder(record(frame) && (frame.version === 1 || frame.version === 2) &&
requireOrder(record(frame) && (frame.version === 1 || frame.version === 2 || frame.version === 3) &&
Object.keys(frame).sort().join(',') === (frame.version === 1
? 'completed,original,remaining,started,turn,version' : 'completed,original,remaining,started,turn,uses,version') &&
? 'completed,original,remaining,started,turn,version' : frame.version === 2
? 'completed,original,remaining,started,turn,uses,version'
: 'completed,original,paused,remaining,started,turn,uses,version') &&
Number.isSafeInteger(frame.turn) && frame.turn === context.turn &&
ids(frame.original) && ids(frame.remaining) && ids(frame.completed) && typeof frame.started === 'boolean',
'The current Revival order is malformed or belongs to another turn.');
@@ -78,7 +85,8 @@ export function validateRevivalOrder(context: RevivalOrderContext, frame: Reviva
if (frame.version === 1) requireOrder(same(frame.completed, frame.original.slice(0, frame.completed.length)) &&
same(frame.remaining, frame.original.slice(frame.completed.length)),
'The Revival order must retain the original public order and its completed prefix.');
else validateSaphoHistory(frame);
else if (frame.version === 2) validateSaphoHistory(frame);
else validateSuspendedSaphoHistory(frame);
requireOrder(frame.remaining.length > 0 || !frame.started,
'Completed Revival cannot retain a started opportunity.');
}
@@ -138,28 +146,84 @@ function validateSaphoHistory(frame: Extract<RevivalOrder, { version: 2 }>): voi
'The Revival frame contradicts its Sapho use history or unlocks a started opportunity.');
}
/** Version 3 extends the same public use history with a voluntary suspension.
* Pending native requests are checked by the engine before this quote. A
* suspended faction stays started, even if later uses reorder its position. */
function validateSuspendedSaphoHistory(frame: Extract<RevivalOrder, { version: 3 }>): void {
requireOrder(Array.isArray(frame.uses) && frame.uses.length > 0 && ids(frame.paused) &&
new Set(frame.paused).size === frame.paused.length,
'A suspended Revival needs its actual Sapho use history and unique paused factions.');
let remaining = [...frame.original], completed: string[] = [], started = false, paused: string[] = [];
const advance = (next: readonly string[]) => {
const advanced = advanceCompleted(remaining, completed, started, next);
const count = next.length - completed.length;
paused = paused.filter(player => !next.includes(player));
remaining = advanced.remaining;
completed = advanced.completed;
started = count === 0 ? advanced.started : !!remaining.length && paused.includes(remaining[0]);
};
for (const [index, use] of frame.uses.entries()) {
requireOrder(record(use) &&
(Object.keys(use).sort().join(',') === 'completed,event,mode,player,started' ||
Object.keys(use).sort().join(',') === 'completed,event,mode,player,started,suspended' && use.suspended === true) &&
typeof use.event === 'string' && id(use.player) && (use.mode === 'first' || use.mode === 'last') &&
ids(use.completed) && typeof use.started === 'boolean',
'The saved Sapho Revival use is malformed.');
advance(use.completed);
requireOrder(!started || use.started, 'A later Sapho use cannot unlock the current started Revival opportunity.');
requireOrder(!use.started || remaining.length > 0, 'Only a current Revival opportunity can have started.');
requireOrder(use.event === eventFor(frame.turn, frame.original, remaining, completed, use.started, index),
'The saved Sapho Revival use lost its original public boundary.');
if (use.suspended) {
requireOrder(use.started && use.player === remaining[0] && use.mode === 'last' && remaining.length > 1,
'Only the current started faction can suspend its own Revival turn last.');
if (!paused.includes(use.player)) paused.push(use.player);
remaining = [...remaining.slice(1), use.player];
started = paused.includes(remaining[0]);
} else {
remaining = reordered(frame.original, remaining, completed, use.started, use);
started = use.started || paused.includes(remaining[0]);
}
}
advance(frame.completed);
requireOrder(same(frame.remaining, remaining) && same(frame.paused, paused) && (!started || frame.started),
'The Revival frame contradicts its Sapho history or loses a suspended opportunity.');
requireOrder(frame.uses.some(use => use.suspended === true), 'Version 3 requires an actual suspended Revival turn.');
}
/** This boundary binds the actual public queue and every prior genuine use's
* revision. It grants no card ownership, payment or additional opportunity. */
export function saphoRevivalOrderEvent(context: RevivalOrderContext, frame: RevivalOrder): string {
validateRevivalOrder(context, frame);
return eventFor(frame.turn, frame.original, frame.remaining, frame.completed,
frame.started, frame.version === 2 ? frame.uses.length : 0);
frame.started, frame.version === 1 ? 0 : frame.uses.length);
}
export function reorderSaphoRevivalOrder(context: RevivalOrderContext, frame: RevivalOrder, request: {
event: string; player: string; mode: 'first' | 'last';
}): { order: RevivalOrder; afterCurrent?: string } {
}): { order: RevivalOrder; afterCurrent?: string; suspended?: string } {
validateRevivalOrder(context, frame);
const event = saphoRevivalOrderEvent(context, frame);
requireOrder(record(request) && Object.keys(request).sort().join(',') === 'event,mode,player' &&
request.event === event && id(request.player) && (request.mode === 'first' || request.mode === 'last'),
'Choose first or last at the current Sapho Revival opportunity.');
const remaining = reordered(frame.original, frame.remaining, frame.completed, frame.started, request);
const order: RevivalOrder = { version: 2, turn: frame.turn, original: [...frame.original], remaining,
completed: [...frame.completed], started: frame.started,
uses: [...(frame.version === 2 ? frame.uses.map(use => ({ ...use, completed: [...use.completed] })) : []),
{ event, player: request.player, mode: request.mode, completed: [...frame.completed], started: frame.started }] };
const suspended = frame.started && request.player === frame.remaining[0];
if (suspended) requireOrder(request.mode === 'last' && frame.remaining.length > 1,
'A started Revival turn can only be suspended last when another opportunity remains.');
const remaining = suspended ? [...frame.remaining.slice(1), request.player]
: reordered(frame.original, frame.remaining, frame.completed, frame.started, request);
const paused = frame.version === 3 ? [...frame.paused] : [];
if (suspended && !paused.includes(request.player)) paused.push(request.player);
const uses = [...(frame.version === 1 ? [] : frame.uses.map(use => ({ ...use, completed: [...use.completed] }))),
{ event, player: request.player, mode: request.mode, completed: [...frame.completed], started: frame.started,
...(suspended ? { suspended: true as const } : {}) }];
const fields = { turn: frame.turn, original: [...frame.original], remaining,
completed: [...frame.completed], started: suspended ? paused.includes(remaining[0]) : frame.started || paused.includes(remaining[0]) };
const order: RevivalOrder = frame.version === 3 || suspended
? { version: 3, ...fields, uses, paused }
: { version: 2, ...fields, uses };
validateRevivalOrder(context, order);
return { order, ...(frame.started ? { afterCurrent: frame.remaining[0] } : {}) };
return { order, ...(suspended ? { suspended: request.player } :
frame.started ? { afterCurrent: frame.remaining[0] } : {}) };
}
export function revivalOrderBlock(context: RevivalOrderContext, frame: RevivalOrder, player: string): string | null {
@@ -186,6 +250,10 @@ export function finishRevivalOrder(context: RevivalOrderContext, frame: RevivalO
requireOrder(!blocked, blocked ?? 'This Revival opportunity is unavailable.');
const next = { ...copy(frame), remaining: frame.remaining.slice(1),
completed: [...frame.completed, player], started: false };
if (next.version === 3) {
next.paused = next.paused.filter(id => id !== player);
next.started = next.remaining.length > 0 && next.paused.includes(next.remaining[0]);
}
validateRevivalOrder({ ...context, ready: [...context.ready, player] }, next);
return next;
}