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,280 @@
|
||||
import { FACTIONS, type FactionId } from './catalog';
|
||||
|
||||
/** Physical inventory is independent of seated factions and enabled modules. */
|
||||
export const NEXUS_FACTIONS: readonly FactionId[] = Object.freeze(
|
||||
FACTIONS.map((faction) => faction.id),
|
||||
);
|
||||
export type NexusPlayer = {
|
||||
id: string;
|
||||
faction: FactionId;
|
||||
ally?: string | null;
|
||||
};
|
||||
export type NexusState = {
|
||||
version: 1;
|
||||
deck: FactionId[];
|
||||
discard: FactionId[];
|
||||
hands: Record<string, FactionId | null>;
|
||||
};
|
||||
export type NexusCardMode = 'cunning' | 'betrayal' | 'secretAlly';
|
||||
export type NexusCardsView = {
|
||||
card: FactionId | null;
|
||||
deckCount: number;
|
||||
discardCount: number;
|
||||
held: Record<string, boolean>;
|
||||
};
|
||||
export class NexusCardsError extends Error {
|
||||
constructor(message: string) {
|
||||
super(message);
|
||||
this.name = 'NexusCardsError';
|
||||
}
|
||||
}
|
||||
function requireCards(condition: unknown, message: string): asserts condition {
|
||||
if (!condition) throw new NexusCardsError(message);
|
||||
}
|
||||
const faction = (value: unknown): value is FactionId =>
|
||||
NEXUS_FACTIONS.includes(value as FactionId);
|
||||
const identifier = (value: unknown): value is string =>
|
||||
typeof value === 'string' &&
|
||||
value.trim().length > 0 &&
|
||||
!['__proto__', 'constructor', 'prototype'].includes(value);
|
||||
function plain(value: unknown): value is Record<string, unknown> {
|
||||
if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
|
||||
const prototype: unknown = Object.getPrototypeOf(value);
|
||||
return prototype === Object.prototype || prototype === null;
|
||||
}
|
||||
export function validateNexusPlayers(players: readonly NexusPlayer[]): void {
|
||||
requireCards(
|
||||
Array.isArray(players) && players.length >= 2 && players.length <= 6,
|
||||
'Nexus custody needs two through six seated players.',
|
||||
);
|
||||
const ids = new Set<string>(),
|
||||
factions = new Set<FactionId>();
|
||||
for (const player of players) {
|
||||
requireCards(
|
||||
plain(player) &&
|
||||
identifier(player.id) &&
|
||||
faction(player.faction) &&
|
||||
!ids.has(player.id) &&
|
||||
!factions.has(player.faction),
|
||||
'Nexus custody needs distinct valid seated identities and factions.',
|
||||
);
|
||||
ids.add(player.id);
|
||||
factions.add(player.faction);
|
||||
}
|
||||
for (const player of players)
|
||||
requireCards(
|
||||
player.ally === undefined ||
|
||||
player.ally === null ||
|
||||
(identifier(player.ally) &&
|
||||
player.ally !== player.id &&
|
||||
ids.has(player.ally)),
|
||||
'A Nexus player has an invalid seated alliance partner.',
|
||||
);
|
||||
for (const player of players)
|
||||
requireCards(
|
||||
player.ally === undefined ||
|
||||
player.ally === null ||
|
||||
players.find((partner) => partner.id === player.ally)!.ally ===
|
||||
player.id,
|
||||
'Nexus alliances must identify reciprocal seated partners.',
|
||||
);
|
||||
}
|
||||
|
||||
/** No alias zones, unknown card, missing seat, duplicated identity or extra
|
||||
* private fields may be reconstructed or silently normalized on read. */
|
||||
export function validateNexusCards(
|
||||
state: NexusState,
|
||||
players: readonly NexusPlayer[],
|
||||
): void {
|
||||
validateNexusPlayers(players);
|
||||
requireCards(
|
||||
plain(state) &&
|
||||
Object.keys(state).length === 4 &&
|
||||
['version', 'deck', 'discard', 'hands'].every((key) =>
|
||||
Object.hasOwn(state, key),
|
||||
) &&
|
||||
state.version === 1 &&
|
||||
Array.isArray(state.deck) &&
|
||||
Array.isArray(state.discard) &&
|
||||
plain(state.hands),
|
||||
'The saved Nexus inventory has an invalid shape.',
|
||||
);
|
||||
requireCards(
|
||||
Object.keys(state.hands).length === players.length &&
|
||||
players.every((player) => Object.hasOwn(state.hands, player.id)),
|
||||
'Nexus hands must match the complete seated roster.',
|
||||
);
|
||||
const physical: FactionId[] = [];
|
||||
for (const pile of [state.deck, state.discard])
|
||||
for (const card of pile) {
|
||||
requireCards(
|
||||
faction(card),
|
||||
'The Nexus inventory contains an unknown physical card.',
|
||||
);
|
||||
physical.push(card);
|
||||
}
|
||||
for (const player of players) {
|
||||
const card = state.hands[player.id];
|
||||
requireCards(
|
||||
card === null || faction(card),
|
||||
'Each Nexus hand holds at most one physical card.',
|
||||
);
|
||||
if (card !== null) physical.push(card);
|
||||
}
|
||||
requireCards(
|
||||
physical.length === NEXUS_FACTIONS.length &&
|
||||
new Set(physical).size === NEXUS_FACTIONS.length,
|
||||
'The Nexus inventory must conserve exactly one card for each of the twelve factions.',
|
||||
);
|
||||
}
|
||||
function shuffle(
|
||||
cards: readonly FactionId[],
|
||||
random: () => number,
|
||||
): FactionId[] {
|
||||
requireCards(
|
||||
typeof random === 'function',
|
||||
'Nexus shuffling needs server randomness.',
|
||||
);
|
||||
const result = [...cards];
|
||||
for (let index = result.length - 1; index > 0; index--) {
|
||||
const value = random();
|
||||
requireCards(
|
||||
Number.isFinite(value) && value >= 0 && value < 1,
|
||||
'Nexus random draws must be finite from zero inclusive to one exclusive.',
|
||||
);
|
||||
const selected = Math.floor(value * (index + 1));
|
||||
[result[index], result[selected]] = [result[selected], result[index]];
|
||||
}
|
||||
return result;
|
||||
}
|
||||
export function createNexusCards(
|
||||
players: readonly NexusPlayer[],
|
||||
random: () => number,
|
||||
): NexusState {
|
||||
validateNexusPlayers(players);
|
||||
return {
|
||||
version: 1,
|
||||
deck: shuffle(NEXUS_FACTIONS, random),
|
||||
discard: [],
|
||||
hands: Object.fromEntries(players.map((player) => [player.id, null])),
|
||||
};
|
||||
}
|
||||
function owner(
|
||||
state: NexusState,
|
||||
player: string,
|
||||
players: readonly NexusPlayer[],
|
||||
): NexusPlayer {
|
||||
validateNexusCards(state, players);
|
||||
const seat = players.find((candidate) => candidate.id === player);
|
||||
requireCards(seat && identifier(player), 'Choose a seated Nexus card owner.');
|
||||
return seat;
|
||||
}
|
||||
function requireUnallied(player: NexusPlayer): void {
|
||||
requireCards(
|
||||
player.ally === undefined || player.ally === null,
|
||||
'An allied player cannot draw or replace a Nexus card.',
|
||||
);
|
||||
}
|
||||
function drawInto(
|
||||
state: NexusState,
|
||||
player: string,
|
||||
random: () => number,
|
||||
): void {
|
||||
if (!state.deck.length) {
|
||||
requireCards(
|
||||
state.discard.length > 0,
|
||||
'There is no physical Nexus card to draw.',
|
||||
);
|
||||
state.deck = shuffle(state.discard, random);
|
||||
state.discard = [];
|
||||
}
|
||||
state.hands[player] = state.deck.shift()!;
|
||||
}
|
||||
|
||||
/** The engine authorizes the phase opportunity or immediate own-faction redraw.
|
||||
* Drawing one's faction never discards it automatically in either rules mode. */
|
||||
export function drawNexusCard(
|
||||
state: NexusState,
|
||||
player: string,
|
||||
players: readonly NexusPlayer[],
|
||||
random: () => number,
|
||||
): NexusState {
|
||||
requireUnallied(owner(state, player, players));
|
||||
requireCards(
|
||||
state.hands[player] === null,
|
||||
'Discard a held Nexus card before drawing its replacement.',
|
||||
);
|
||||
const result = structuredClone(state);
|
||||
drawInto(result, player, random);
|
||||
return result;
|
||||
}
|
||||
export function replaceNexusCard(
|
||||
state: NexusState,
|
||||
player: string,
|
||||
players: readonly NexusPlayer[],
|
||||
random: () => number,
|
||||
): NexusState {
|
||||
requireUnallied(owner(state, player, players));
|
||||
requireCards(
|
||||
state.hands[player] !== null,
|
||||
'Hold a Nexus card before replacing it.',
|
||||
);
|
||||
const result = structuredClone(state);
|
||||
result.discard.push(result.hands[player]!);
|
||||
result.hands[player] = null;
|
||||
drawInto(result, player, random);
|
||||
return result;
|
||||
}
|
||||
/** Used cards and cards forfeited upon joining any alliance take the same
|
||||
* physical route. The caller separately proves which discard is mandatory. */
|
||||
export function discardNexusCard(
|
||||
state: NexusState,
|
||||
player: string,
|
||||
players: readonly NexusPlayer[],
|
||||
): NexusState {
|
||||
owner(state, player, players);
|
||||
requireCards(
|
||||
state.hands[player] !== null,
|
||||
'Hold a Nexus card before discarding it.',
|
||||
);
|
||||
const result = structuredClone(state);
|
||||
result.discard.push(result.hands[player]!);
|
||||
result.hands[player] = null;
|
||||
return result;
|
||||
}
|
||||
|
||||
export function nexusCardMode(
|
||||
card: FactionId,
|
||||
ownerFaction: FactionId,
|
||||
seatedFactions: readonly FactionId[],
|
||||
): NexusCardMode {
|
||||
requireCards(
|
||||
faction(card) &&
|
||||
faction(ownerFaction) &&
|
||||
Array.isArray(seatedFactions) &&
|
||||
seatedFactions.every(faction) &&
|
||||
new Set(seatedFactions).size === seatedFactions.length &&
|
||||
seatedFactions.includes(ownerFaction),
|
||||
'Nexus effects need a known card and its actual seated faction roster.',
|
||||
);
|
||||
return card === ownerFaction
|
||||
? 'cunning'
|
||||
: seatedFactions.includes(card)
|
||||
? 'betrayal'
|
||||
: 'secretAlly';
|
||||
}
|
||||
export function projectNexusCards(
|
||||
state: NexusState,
|
||||
viewer: string,
|
||||
players: readonly NexusPlayer[],
|
||||
): NexusCardsView {
|
||||
owner(state, viewer, players);
|
||||
return {
|
||||
card: state.hands[viewer],
|
||||
deckCount: state.deck.length,
|
||||
discardCount: state.discard.length,
|
||||
held: Object.fromEntries(
|
||||
players.map((player) => [player.id, state.hands[player.id] !== null]),
|
||||
),
|
||||
};
|
||||
}
|
||||
Reference in new issue
Block a user