Implement Nexus card ownership, private draws and full card reference
This commit is contained in:
1 parent
61689514a0
commit
d2a1d63517
20 files changed
+2477
-5
No files matched your search
@@ -0,0 +1,197 @@
|
||||
import {
|
||||
validateNexusCards,
|
||||
validateNexusPlayers,
|
||||
type NexusPlayer,
|
||||
type NexusState,
|
||||
} from './nexus-cards';
|
||||
|
||||
/** One closing opportunity for the whole Spice Blow and Nexus phase, including
|
||||
* both Advanced spice piles. Pre-draw own-faction policies resolve privately
|
||||
* within one action, so public progress never identifies a drawn card. */
|
||||
export type NexusCardPhase = {
|
||||
turn: number;
|
||||
occurred: boolean;
|
||||
stage: 'spice' | 'drawing' | 'complete';
|
||||
eligible: string[];
|
||||
done: string[];
|
||||
signature: string;
|
||||
};
|
||||
export type NexusCardChoice = 'draw' | 'replace' | 'keep';
|
||||
|
||||
function requireNexus(condition: unknown, message: string): asserts condition {
|
||||
if (!condition) throw new Error(message);
|
||||
}
|
||||
function signature(phase: Omit<NexusCardPhase, 'signature'>): string {
|
||||
return JSON.stringify([
|
||||
'nexusCardPhase',
|
||||
phase.turn,
|
||||
phase.occurred,
|
||||
phase.stage,
|
||||
phase.eligible,
|
||||
phase.done,
|
||||
]);
|
||||
}
|
||||
function validateFrame(phase: NexusCardPhase): void {
|
||||
requireNexus(
|
||||
phase &&
|
||||
typeof phase === 'object' &&
|
||||
!Array.isArray(phase) &&
|
||||
Object.keys(phase).sort().join(',') ===
|
||||
'done,eligible,occurred,signature,stage,turn' &&
|
||||
Number.isSafeInteger(phase.turn) &&
|
||||
phase.turn > 0 &&
|
||||
typeof phase.occurred === 'boolean' &&
|
||||
['spice', 'drawing', 'complete'].includes(phase.stage),
|
||||
'Invalid saved Nexus phase.',
|
||||
);
|
||||
for (const list of [phase.eligible, phase.done])
|
||||
requireNexus(
|
||||
Array.isArray(list) &&
|
||||
new Set(list).size === list.length &&
|
||||
list.every((id) => typeof id === 'string' && id.trim().length > 0),
|
||||
'Invalid Nexus decision owners.',
|
||||
);
|
||||
requireNexus(
|
||||
phase.done.every((id) => phase.eligible.includes(id)),
|
||||
'Nexus choices must belong to an eligible player.',
|
||||
);
|
||||
requireNexus(
|
||||
phase.signature === signature(phase),
|
||||
'The saved Nexus phase has lost its original progress.',
|
||||
);
|
||||
if (phase.stage === 'spice')
|
||||
requireNexus(
|
||||
!phase.eligible.length && !phase.done.length,
|
||||
'Nexus draws cannot precede the closing opportunity.',
|
||||
);
|
||||
if (!phase.occurred)
|
||||
requireNexus(
|
||||
!phase.eligible.length,
|
||||
'Nexus draws require an actual Nexus this phase.',
|
||||
);
|
||||
if (phase.stage === 'complete')
|
||||
requireNexus(
|
||||
phase.eligible.length === phase.done.length,
|
||||
'A completed Nexus opportunity cannot retain a choice.',
|
||||
);
|
||||
if (phase.stage === 'drawing')
|
||||
requireNexus(
|
||||
phase.eligible.some((id) => !phase.done.includes(id)),
|
||||
'A Nexus draw window needs an unfinished recipient.',
|
||||
);
|
||||
}
|
||||
function signed(phase: Omit<NexusCardPhase, 'signature'>): NexusCardPhase {
|
||||
return { ...phase, signature: signature(phase) };
|
||||
}
|
||||
export function createNexusCardPhase(turn: number): NexusCardPhase {
|
||||
requireNexus(
|
||||
Number.isSafeInteger(turn) && turn > 0,
|
||||
'Invalid Nexus phase turn.',
|
||||
);
|
||||
return signed({
|
||||
turn,
|
||||
occurred: false,
|
||||
stage: 'spice',
|
||||
eligible: [],
|
||||
done: [],
|
||||
});
|
||||
}
|
||||
export function markNexusCardOccurred(phase: NexusCardPhase): NexusCardPhase {
|
||||
validateFrame(phase);
|
||||
requireNexus(
|
||||
phase.stage === 'spice',
|
||||
'A Nexus occurrence needs its open Spice Blow phase.',
|
||||
);
|
||||
return signed({ ...structuredClone(phase), occurred: true });
|
||||
}
|
||||
export function validateNexusCardPhase(
|
||||
phase: NexusCardPhase,
|
||||
players: readonly NexusPlayer[],
|
||||
cards: NexusState,
|
||||
): void {
|
||||
validateFrame(phase);
|
||||
validateNexusCards(cards, players);
|
||||
requireNexus(
|
||||
phase.eligible.every((id) => players.some((player) => player.id === id)),
|
||||
'Invalid Nexus decision owners.',
|
||||
);
|
||||
if (phase.stage === 'drawing') {
|
||||
const unallied = players
|
||||
.filter((player) => !player.ally)
|
||||
.map((player) => player.id);
|
||||
requireNexus(
|
||||
players.some((player) => !!player.ally) &&
|
||||
phase.eligible.length === unallied.length &&
|
||||
unallied.every((id) => phase.eligible.includes(id)),
|
||||
'A Nexus draw window needs every unallied recipient and a settled alliance.',
|
||||
);
|
||||
}
|
||||
}
|
||||
export function closeNexusCardPhase(
|
||||
phase: NexusCardPhase,
|
||||
players: readonly NexusPlayer[],
|
||||
): NexusCardPhase {
|
||||
validateFrame(phase);
|
||||
validateNexusPlayers(players);
|
||||
requireNexus(
|
||||
phase.stage === 'spice',
|
||||
'This Nexus phase already reached its closing opportunity.',
|
||||
);
|
||||
const eligible =
|
||||
phase.occurred && players.some((player) => !!player.ally)
|
||||
? players.filter((player) => !player.ally).map((player) => player.id)
|
||||
: [];
|
||||
return signed({
|
||||
...structuredClone(phase),
|
||||
eligible,
|
||||
stage: eligible.length ? 'drawing' : 'complete',
|
||||
});
|
||||
}
|
||||
export function nexusCardChoices(
|
||||
phase: NexusCardPhase | null,
|
||||
cards: NexusState,
|
||||
player: string,
|
||||
): NexusCardChoice[] {
|
||||
if (!phase) return [];
|
||||
validateFrame(phase);
|
||||
if (
|
||||
phase.stage !== 'drawing' ||
|
||||
!phase.eligible.includes(player) ||
|
||||
phase.done.includes(player)
|
||||
)
|
||||
return [];
|
||||
return cards.hands[player] ? ['keep', 'replace'] : ['keep', 'draw'];
|
||||
}
|
||||
/** Called only after the selected physical operation (and any preauthorized
|
||||
* own-faction replacements) committed. No private card-dependent progress. */
|
||||
export function finishNexusCardChoice(
|
||||
phase: NexusCardPhase,
|
||||
players: readonly NexusPlayer[],
|
||||
cards: NexusState,
|
||||
player: string,
|
||||
choice: NexusCardChoice,
|
||||
): NexusCardPhase {
|
||||
validateNexusCardPhase(phase, players, cards);
|
||||
requireNexus(
|
||||
['draw', 'replace', 'keep'].includes(choice),
|
||||
'Choose a valid Nexus card operation.',
|
||||
);
|
||||
requireNexus(
|
||||
phase.stage === 'drawing' &&
|
||||
phase.eligible.includes(player) &&
|
||||
!phase.done.includes(player),
|
||||
'Your Nexus choice is already complete or unavailable.',
|
||||
);
|
||||
requireNexus(
|
||||
choice === 'keep' || cards.hands[player] !== null,
|
||||
'A completed Nexus draw must have its physical card.',
|
||||
);
|
||||
const done = [...phase.done, player];
|
||||
const next = signed({
|
||||
...structuredClone(phase),
|
||||
done,
|
||||
stage: done.length === phase.eligible.length ? 'complete' : 'drawing',
|
||||
});
|
||||
validateNexusCardPhase(next, players, cards);
|
||||
return next;
|
||||
}
|
||||
Reference in new issue
Block a user