490 lines
27 KiB
TypeScript
490 lines
27 KiB
TypeScript
import { baseDeck, leaders, type Card } from './cards';
|
|
import { ecazTreacheryCards } from './ecaz-cards';
|
|
import {
|
|
nexusCardMode, validateNexusCards, validateNexusPlayers,
|
|
type NexusPlayer, type NexusState,
|
|
} from './nexus-cards';
|
|
import { validateNexusTraitorSnapshot, type NexusTraitorSnapshot } from './nexus-traitor-exchange';
|
|
import {
|
|
validateTraitorDeclaration, type TraitorDeclaration, type TraitorDeclarationContext,
|
|
} from './traitor-declarations';
|
|
import { traitorDeck } from './traitors';
|
|
|
|
export type HarkonnenBetrayalAuthority = {
|
|
provider: string;
|
|
declaration: TraitorDeclaration;
|
|
nativeWindow: 'direct' | 'harkonnenTraitor';
|
|
nativeContext: string;
|
|
nativeRequired: readonly string[];
|
|
nativePassed: readonly string[];
|
|
};
|
|
type Battle = Omit<TraitorDeclarationContext, 'players'>;
|
|
export type HarkonnenBetrayalContext = {
|
|
status: string;
|
|
phase: number;
|
|
turn: number;
|
|
advanced: boolean;
|
|
sequence: number;
|
|
/** Public selection; absence retains the original base33 census. */
|
|
ecazTreachery?: boolean;
|
|
players: readonly NexusPlayer[];
|
|
cards: NexusState;
|
|
physicalCards: readonly Card[];
|
|
traitors: NexusTraitorSnapshot;
|
|
universe: readonly string[];
|
|
battle: Battle;
|
|
};
|
|
export type HarkonnenBetrayalSource = HarkonnenBetrayalAuthority & {
|
|
version: 1;
|
|
event: string;
|
|
turn: number;
|
|
phase: 6;
|
|
advanced: boolean;
|
|
sequence: number;
|
|
required: readonly string[];
|
|
eligible: string | null;
|
|
players: readonly NexusPlayer[];
|
|
battle: Battle;
|
|
universe: readonly string[];
|
|
/** Current committed census only, never a requirement on later custody. */
|
|
inventory: string;
|
|
parent: string;
|
|
signature: string;
|
|
};
|
|
export type HarkonnenBetrayalCursor = { sequence: number; signature: string };
|
|
export type HarkonnenBetrayalReceipt = {
|
|
source: HarkonnenBetrayalSource;
|
|
outcome: 'pass' | 'use';
|
|
holder: string | null;
|
|
previous: string;
|
|
signature: string;
|
|
};
|
|
export type HarkonnenBetrayalReplacement = {
|
|
version: 1;
|
|
event: string;
|
|
sequence: number;
|
|
provider: string;
|
|
turn: number;
|
|
identity: string;
|
|
/** Bounded head of the exact successful Use, not the latest cursor. */
|
|
receipt: string;
|
|
status: 'due' | 'drawn';
|
|
drawn: string | null;
|
|
signature: string;
|
|
};
|
|
export class HarkonnenBetrayalError extends Error {
|
|
constructor(message: string) {
|
|
super(message);
|
|
this.name = 'HarkonnenBetrayalError';
|
|
}
|
|
}
|
|
const genesis = 'harkonnen-betrayal:0';
|
|
const classic: Readonly<Record<string, true>> = {
|
|
atreides: true, harkonnen: true, emperor: true, fremen: true, guild: true, beneGesserit: true,
|
|
};
|
|
const canonicalCards = new Map(baseDeck().map(card => [card.id, card]));
|
|
const independentCards = new Map<string, Card>(ecazTreacheryCards().map(card => [card.id, card]));
|
|
const declarationKeys = ['event', 'voter', 'beneficiary', 'target', 'leader', 'identity', 'signature'] as const;
|
|
const plain = (value: unknown): value is Record<string, unknown> =>
|
|
value !== null && typeof value === 'object' && !Array.isArray(value) &&
|
|
[Object.prototype, null].includes(Object.getPrototypeOf(value));
|
|
const text = (value: unknown): value is string => typeof value === 'string' &&
|
|
value.trim().length > 0 && !['__proto__', 'constructor', 'prototype'].includes(value);
|
|
const whole = (value: unknown): value is number =>
|
|
typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
|
|
const array = (value: unknown): boolean => Array.isArray(value);
|
|
function requireBetrayal(value: unknown, message: string): asserts value {
|
|
if (!value) throw new HarkonnenBetrayalError(message);
|
|
}
|
|
function exact(value: unknown, keys: readonly string[]): value is Record<string, unknown> {
|
|
return plain(value) && Object.keys(value).sort().join(',') === [...keys].sort().join(',');
|
|
}
|
|
function members(value: unknown): value is readonly string[] {
|
|
return Array.isArray(value) && value.every(text) && new Set(value).size === value.length;
|
|
}
|
|
const equal = (one: unknown, two: unknown): boolean => JSON.stringify(one) === JSON.stringify(two);
|
|
function validateRoster(players: readonly NexusPlayer[]): void {
|
|
validateNexusPlayers(players);
|
|
requireBetrayal(players.every(player => Object.hasOwn(classic, player.faction)) &&
|
|
players.filter(player => player.faction === 'harkonnen').length === 1,
|
|
'Harkonnen Betrayal requires native Harkonnen and two through six classic seats.');
|
|
}
|
|
function roster(players: readonly NexusPlayer[]): NexusPlayer[] {
|
|
return players.map(({ id, faction, ally }) => ({ id, faction, ally: ally ?? null }));
|
|
}
|
|
function canonicalUniverse(players: readonly NexusPlayer[]): string[] {
|
|
return traitorDeck(players.map(player => ({ leaders: leaders(player.faction) })));
|
|
}
|
|
function validateUniverse(universe: readonly string[], players: readonly NexusPlayer[]): void {
|
|
const expected = canonicalUniverse(players);
|
|
requireBetrayal(members(universe) && universe.length === expected.length &&
|
|
universe.every(identity => expected.includes(identity)),
|
|
'Harkonnen Betrayal needs the original complete canonical classic Traitor universe.');
|
|
}
|
|
function validatePhysical(cards: readonly Card[], independent = false): void {
|
|
const count = canonicalCards.size + (independent ? independentCards.size : 0);
|
|
requireBetrayal(Array.isArray(cards) && cards.length === count &&
|
|
new Set(cards.map(card => card?.id)).size === count && cards.every(card => {
|
|
if (!plain(card) || !text(card.id)) return false;
|
|
const expected = canonicalCards.get(card.id) ?? (independent ? independentCards.get(card.id) : undefined);
|
|
return !!expected && exact(card, ['id', 'name', 'kind',
|
|
...(expected.effect === undefined ? [] : ['effect'])]) && card.name === expected.name &&
|
|
card.kind === expected.kind && card.effect === expected.effect;
|
|
}), 'Harkonnen Betrayal requires complete unique canonical selected Treachery custody.');
|
|
}
|
|
function validateBattle(battle: Battle): void {
|
|
requireBetrayal(exact(battle, ['event', 'attacker', 'defender', 'plans', 'heroLeaderIds']) &&
|
|
text(battle.event) && text(battle.attacker) && text(battle.defender) &&
|
|
battle.attacker !== battle.defender && exact(battle.plans, [battle.attacker, battle.defender]) &&
|
|
Array.isArray(battle.heroLeaderIds) && battle.heroLeaderIds.length === 0 &&
|
|
Object.values(battle.plans).every(plan => plain(plan) &&
|
|
exact(plan, ['leader', ...(Object.hasOwn(plan, 'kwisatz') ? ['kwisatz'] : [])]) &&
|
|
(plan.leader === null || text(plan.leader)) &&
|
|
(plan.kwisatz === undefined || typeof plan.kwisatz === 'boolean')),
|
|
'Harkonnen Betrayal requires original sealed classic battle plans, without Ix heroes.');
|
|
}
|
|
function declarationContext(
|
|
battle: Battle, players: readonly NexusPlayer[], traitors?: NexusTraitorSnapshot,
|
|
): TraitorDeclarationContext {
|
|
return { ...battle, players: players.map(player => ({ ...player,
|
|
traitors: traitors?.players.find(seat => seat.id === player.id)?.traitors ?? [],
|
|
})) };
|
|
}
|
|
function validateAuthority(
|
|
authority: HarkonnenBetrayalAuthority, players: readonly NexusPlayer[], battle: Battle,
|
|
): void {
|
|
requireBetrayal(exact(authority, ['provider', 'declaration', 'nativeWindow', 'nativeContext',
|
|
'nativeRequired', 'nativePassed']) && text(authority.provider) && text(authority.nativeContext) &&
|
|
members(authority.nativeRequired) && members(authority.nativePassed) &&
|
|
authority.nativeRequired.every(id => authority.nativePassed.includes(id)) &&
|
|
[...authority.nativeRequired, ...authority.nativePassed].every(id => players.some(p => p.id === id)) &&
|
|
players.find(player => player.id === authority.provider)?.faction === 'harkonnen' &&
|
|
authority.declaration?.voter === authority.provider,
|
|
'Harkonnen Betrayal must follow its original allowed native Harkonnen declaration.');
|
|
try {
|
|
validateTraitorDeclaration(declarationContext(battle, players), authority.declaration);
|
|
} catch {
|
|
throw new HarkonnenBetrayalError('Harkonnen Betrayal lost its canonical native declaration or roles.');
|
|
}
|
|
const direct = authority.declaration.beneficiary === authority.provider;
|
|
requireBetrayal(direct ? authority.nativeWindow === 'direct' &&
|
|
authority.nativeRequired.length === 0 && authority.nativePassed.length === 0 :
|
|
authority.nativeWindow === 'harkonnenTraitor',
|
|
'Harkonnen Betrayal cannot confuse personal calls with native allowed allied calls.');
|
|
requireBetrayal(players.some(player => leaders(player.faction).some(leader =>
|
|
leader.id === authority.declaration.leader)) && authority.declaration.identity === authority.declaration.leader,
|
|
'Harkonnen Betrayal requires the opposing canonical classic leader identity.');
|
|
}
|
|
export function harkonnenBetrayalResponders(cards: NexusState, players: readonly NexusPlayer[]): string[] {
|
|
validateRoster(players);
|
|
validateNexusCards(cards, players);
|
|
return players.filter(player => !player.ally && player.faction !== 'harkonnen' &&
|
|
cards.hands[player.id] !== null).map(player => player.id);
|
|
}
|
|
export function harkonnenBetrayalEligible(
|
|
cards: NexusState, players: readonly NexusPlayer[], holder: string,
|
|
): boolean {
|
|
validateRoster(players);
|
|
validateNexusCards(cards, players);
|
|
const player = players.find(seat => seat.id === holder);
|
|
return !!player && !player.ally && player.faction !== 'harkonnen' && cards.hands[holder] === 'harkonnen' &&
|
|
nexusCardMode('harkonnen', player.faction, players.map(seat => seat.faction)) === 'betrayal';
|
|
}
|
|
export function harkonnenBetrayalEvent(
|
|
turn: number, sequence: number, declaration: TraitorDeclaration, provider: string,
|
|
): string {
|
|
requireBetrayal(whole(turn) && turn > 0 && whole(sequence) && text(provider) &&
|
|
plain(declaration) && declarationKeys.every(key => text(declaration[key])) && declaration.voter === provider,
|
|
'Harkonnen Betrayal requires its original public declared-card event.');
|
|
return JSON.stringify(['nexusHarkonnenBetrayal', turn, sequence, declaration.event, provider,
|
|
declaration.beneficiary, declaration.target, declaration.leader, declaration.identity]);
|
|
}
|
|
function validateContext(ctx: HarkonnenBetrayalContext): void {
|
|
requireBetrayal(plain(ctx) && ctx.status === 'playing' && ctx.phase === 6 &&
|
|
whole(ctx.turn) && ctx.turn > 0 && whole(ctx.sequence) && typeof ctx.advanced === 'boolean' &&
|
|
(ctx.ecazTreachery === undefined || typeof ctx.ecazTreachery === 'boolean'),
|
|
'Harkonnen Betrayal requires its current Battle phase and independent cursor.');
|
|
validateRoster(ctx.players);
|
|
validateNexusCards(ctx.cards, ctx.players);
|
|
validatePhysical(ctx.physicalCards, ctx.ecazTreachery);
|
|
validateUniverse(ctx.universe, ctx.players);
|
|
validateNexusTraitorSnapshot(ctx.traitors, ctx.universe);
|
|
requireBetrayal(ctx.traitors.players.length === ctx.players.length &&
|
|
ctx.players.every(player => ctx.traitors.players.some(seat =>
|
|
seat.id === player.id && seat.faction === player.faction)),
|
|
'Harkonnen Betrayal physical Traitor custody must match its original roster.');
|
|
validateBattle(ctx.battle);
|
|
}
|
|
function sourceAuthority(source: HarkonnenBetrayalSource): HarkonnenBetrayalAuthority {
|
|
return { provider: source.provider, declaration: source.declaration, nativeWindow: source.nativeWindow,
|
|
nativeContext: source.nativeContext, nativeRequired: source.nativeRequired, nativePassed: source.nativePassed };
|
|
}
|
|
function inventory(ctx: HarkonnenBetrayalContext): string {
|
|
const census: unknown[] = [ctx.cards, ctx.traitors, ctx.physicalCards];
|
|
if (ctx.ecazTreachery) census.push(true);
|
|
return JSON.stringify(census);
|
|
}
|
|
function sourceSignature(source: HarkonnenBetrayalSource): string {
|
|
return JSON.stringify(['harkonnenBetrayalSource', source.version, source.event, source.turn,
|
|
source.phase, source.advanced, source.sequence, sourceAuthority(source), source.required,
|
|
source.eligible, source.players, source.battle, source.universe, source.inventory, source.parent]);
|
|
}
|
|
function validateSavedSource(value: unknown): asserts value is HarkonnenBetrayalSource {
|
|
requireBetrayal(exact(value, ['provider', 'declaration', 'nativeWindow', 'nativeContext',
|
|
'nativeRequired', 'nativePassed', 'version', 'event', 'turn', 'phase', 'advanced', 'sequence',
|
|
'required', 'eligible', 'players', 'battle', 'universe', 'inventory', 'parent', 'signature']) &&
|
|
value.version === 1 && whole(value.turn) && value.turn > 0 && value.phase === 6 &&
|
|
typeof value.advanced === 'boolean' && whole(value.sequence) && members(value.required) &&
|
|
(value.eligible === null || text(value.eligible)) && text(value.event) && text(value.parent) &&
|
|
text(value.signature) && text(value.inventory) && Array.isArray(value.players) &&
|
|
plain(value.battle) && members(value.universe),
|
|
'Harkonnen Betrayal lost its original canonical source.');
|
|
// Shape checked above; nested values are validated by their native protocols.
|
|
const source = value as HarkonnenBetrayalSource;
|
|
validateRoster(source.players);
|
|
requireBetrayal(source.players.every(player => exact(player, ['id', 'faction', 'ally'])),
|
|
'Harkonnen Betrayal history must retain only the original public seat roles.');
|
|
validateUniverse(source.universe, source.players);
|
|
validateBattle(source.battle);
|
|
validateAuthority(sourceAuthority(source), source.players, source.battle);
|
|
// This is the original census, not today's holdings. Returning or redrawing
|
|
// the declared card later cannot invalidate this historical declaration.
|
|
let stored: unknown;
|
|
try {
|
|
stored = JSON.parse(source.inventory);
|
|
} catch {
|
|
throw new HarkonnenBetrayalError('Harkonnen Betrayal lost its original physical census.');
|
|
}
|
|
requireBetrayal(Array.isArray(stored) && (stored.length === 3 || (stored.length === 4 && stored[3] === true)),
|
|
'Harkonnen Betrayal lost its original physical census.');
|
|
type SavedInventory = [NexusState, NexusTraitorSnapshot, readonly Card[], true?];
|
|
const [cards, traitors, physicalCards, independent] = stored as SavedInventory;
|
|
validateNexusCards(cards, source.players);
|
|
validateNexusTraitorSnapshot(traitors, source.universe);
|
|
validatePhysical(physicalCards, independent);
|
|
requireBetrayal(traitors.players.length === source.players.length &&
|
|
source.players.every(player => traitors.players.some(seat =>
|
|
seat.id === player.id && seat.faction === player.faction)) &&
|
|
traitors.players.find(player => player.id === source.provider)?.traitors.includes(source.declaration.identity) &&
|
|
equal(source.required, harkonnenBetrayalResponders(cards, source.players)) &&
|
|
source.eligible === (source.players.find(player =>
|
|
harkonnenBetrayalEligible(cards, source.players, player.id))?.id ?? null),
|
|
'Harkonnen Betrayal changed its original canonical custody or response eligibility.');
|
|
requireBetrayal(source.required.every(id => source.players.some(player => player.id === id &&
|
|
!player.ally && player.faction !== 'harkonnen')) &&
|
|
(source.eligible === null || source.required.includes(source.eligible)) &&
|
|
source.universe.includes(source.declaration.identity) &&
|
|
source.event === harkonnenBetrayalEvent(source.turn, source.sequence, source.declaration, source.provider) &&
|
|
source.signature === sourceSignature(source),
|
|
'Harkonnen Betrayal changed its original event, roles or native source.');
|
|
}
|
|
export function validateHarkonnenBetrayalSource(
|
|
ctx: HarkonnenBetrayalContext, source: HarkonnenBetrayalSource,
|
|
authority: HarkonnenBetrayalAuthority, parent: string,
|
|
): void {
|
|
validateSavedSource(source);
|
|
validateContext(ctx);
|
|
validateAuthority(authority, ctx.players, ctx.battle);
|
|
requireBetrayal(source.turn === ctx.turn && source.sequence === ctx.sequence &&
|
|
source.advanced === ctx.advanced && source.parent === parent && text(parent) &&
|
|
source.provider === authority.provider && source.nativeWindow === authority.nativeWindow &&
|
|
source.nativeContext === authority.nativeContext && equal(source.declaration, authority.declaration) &&
|
|
equal(source.nativeRequired, authority.nativeRequired) && equal(source.nativePassed, authority.nativePassed) &&
|
|
equal(source.players, roster(ctx.players)) &&
|
|
equal(source.battle, ctx.battle) && equal(source.universe, ctx.universe) &&
|
|
source.inventory === inventory(ctx) &&
|
|
ctx.traitors.players.find(player => player.id === source.provider)?.traitors.includes(source.declaration.identity) &&
|
|
equal(source.required, harkonnenBetrayalResponders(ctx.cards, ctx.players)) &&
|
|
source.eligible === (ctx.players.find(player => harkonnenBetrayalEligible(ctx.cards, ctx.players, player.id))?.id ?? null),
|
|
'Harkonnen Betrayal no longer matches its current native attempt, custody or public responders.');
|
|
}
|
|
export function createHarkonnenBetrayalSource(
|
|
ctx: HarkonnenBetrayalContext, authority: HarkonnenBetrayalAuthority, parent: string,
|
|
): HarkonnenBetrayalSource {
|
|
validateContext(ctx);
|
|
validateAuthority(authority, ctx.players, ctx.battle);
|
|
const source: HarkonnenBetrayalSource = {
|
|
...structuredClone(authority), version: 1,
|
|
event: harkonnenBetrayalEvent(ctx.turn, ctx.sequence, authority.declaration, authority.provider),
|
|
turn: ctx.turn, phase: 6, advanced: ctx.advanced, sequence: ctx.sequence,
|
|
required: harkonnenBetrayalResponders(ctx.cards, ctx.players),
|
|
eligible: ctx.players.find(player => harkonnenBetrayalEligible(ctx.cards, ctx.players, player.id))?.id ?? null,
|
|
players: roster(ctx.players), battle: structuredClone(ctx.battle), universe: [...ctx.universe],
|
|
inventory: inventory(ctx), parent, signature: '',
|
|
};
|
|
source.signature = sourceSignature(source);
|
|
validateHarkonnenBetrayalSource(ctx, source, authority, parent);
|
|
return source;
|
|
}
|
|
export function validateHarkonnenBetrayalFrame(
|
|
ctx: HarkonnenBetrayalContext, source: HarkonnenBetrayalSource,
|
|
authority: HarkonnenBetrayalAuthority, parent: string,
|
|
required: readonly string[], passed: readonly string[],
|
|
): void {
|
|
validateHarkonnenBetrayalSource(ctx, source, authority, parent);
|
|
requireBetrayal(members(required) && members(passed) && equal(required, source.required) &&
|
|
passed.every(id => required.includes(id)),
|
|
'Harkonnen Betrayal lost its exact public required or passed membership.');
|
|
}
|
|
export function initialHarkonnenBetrayalCursor(): HarkonnenBetrayalCursor {
|
|
return { sequence: 0, signature: genesis };
|
|
}
|
|
function validateCursor(value: unknown): asserts value is HarkonnenBetrayalCursor {
|
|
requireBetrayal(exact(value, ['sequence', 'signature']) && whole(value.sequence) && text(value.signature) &&
|
|
(value.sequence !== 0 || value.signature === genesis),
|
|
'Harkonnen Betrayal lost its independent closed-event cursor.');
|
|
if (value.sequence === 0) return;
|
|
let head: unknown, event: unknown;
|
|
try {
|
|
head = JSON.parse(value.signature);
|
|
if (Array.isArray(head) && typeof head[1] === 'string') event = JSON.parse(head[1]);
|
|
} catch {
|
|
throw new HarkonnenBetrayalError('Harkonnen Betrayal has a forged or recursive cursor head.');
|
|
}
|
|
requireBetrayal(Array.isArray(head) && head.length === 4 && head[0] === 'harkonnenBetrayalHead' &&
|
|
(head[2] === 'pass' ? head[3] === null : head[2] === 'use' && text(head[3])) &&
|
|
Array.isArray(event) && event.length === 9 && event[0] === 'nexusHarkonnenBetrayal' &&
|
|
whole(event[1]) && event[1] > 0 && event[2] === value.sequence - 1 && event.slice(3).every(text) &&
|
|
event[4] !== event[6] && event[5] !== event[6] && event[7] === event[8] &&
|
|
value.signature === JSON.stringify(head) && head[1] === JSON.stringify(event),
|
|
'Harkonnen Betrayal has a forged or recursive cursor head.');
|
|
}
|
|
function receiptSignature(receipt: HarkonnenBetrayalReceipt): string {
|
|
return JSON.stringify(['harkonnenBetrayalReceipt', receipt.source.signature,
|
|
receipt.outcome, receipt.holder, receipt.previous]);
|
|
}
|
|
function receiptHead(receipt: HarkonnenBetrayalReceipt): string {
|
|
return JSON.stringify(['harkonnenBetrayalHead', receipt.source.event, receipt.outcome, receipt.holder]);
|
|
}
|
|
export function closeHarkonnenBetrayalSource(
|
|
source: HarkonnenBetrayalSource, outcome: 'pass' | 'use', holder: string | null,
|
|
cursor: HarkonnenBetrayalCursor,
|
|
): { receipt: HarkonnenBetrayalReceipt; cursor: HarkonnenBetrayalCursor } {
|
|
validateSavedSource(source);
|
|
validateCursor(cursor);
|
|
requireBetrayal(source.sequence === cursor.sequence &&
|
|
cursor.sequence < Number.MAX_SAFE_INTEGER && (outcome === 'pass' ? holder === null :
|
|
outcome === 'use' && text(holder) && holder === source.eligible),
|
|
'Harkonnen Betrayal cannot close twice or lose its actual response outcome.');
|
|
const receipt: HarkonnenBetrayalReceipt = {
|
|
source: structuredClone(source), outcome, holder, previous: cursor.signature, signature: '',
|
|
};
|
|
receipt.signature = receiptSignature(receipt);
|
|
return { receipt, cursor: { sequence: cursor.sequence + 1, signature: receiptHead(receipt) } };
|
|
}
|
|
/** Historical declarations do not claim continued possession of recycled cards.
|
|
* Signatures establish consistency, not authentication of rewritten saves. */
|
|
export function validateHarkonnenBetrayalHistory(
|
|
history: readonly HarkonnenBetrayalReceipt[], cursor: HarkonnenBetrayalCursor,
|
|
universe?: readonly string[],
|
|
): void {
|
|
validateCursor(cursor);
|
|
requireBetrayal(array(history) && history.length === cursor.sequence,
|
|
'Harkonnen Betrayal history has missing or duplicated closed attempts.');
|
|
let previous = genesis, turn = 0;
|
|
let originalRoster: readonly NexusPlayer[] | undefined;
|
|
let originalUniverse: readonly string[] | undefined;
|
|
for (const [index, receipt] of history.entries()) {
|
|
requireBetrayal(exact(receipt, ['source', 'outcome', 'holder', 'previous', 'signature']),
|
|
'Harkonnen Betrayal history has a malformed receipt.');
|
|
validateSavedSource(receipt.source);
|
|
if (universe !== undefined) {
|
|
validateUniverse(universe, receipt.source.players);
|
|
requireBetrayal(equal(universe, receipt.source.universe), 'Harkonnen Betrayal changed its original universe.');
|
|
}
|
|
const identities = receipt.source.players.map(({ id, faction }) => ({ id, faction }));
|
|
requireBetrayal(receipt.source.sequence === index && receipt.source.turn >= turn &&
|
|
receipt.previous === previous &&
|
|
(originalRoster === undefined || equal(originalRoster, identities)) &&
|
|
(originalUniverse === undefined || equal(originalUniverse, receipt.source.universe)) &&
|
|
(receipt.outcome === 'pass' ? receipt.holder === null : receipt.outcome === 'use' &&
|
|
text(receipt.holder) && receipt.holder === receipt.source.eligible) &&
|
|
receipt.signature === receiptSignature(receipt),
|
|
'Harkonnen Betrayal history changed its native attempt, outcome or continuation chain.');
|
|
originalRoster = identities;
|
|
originalUniverse = receipt.source.universe;
|
|
previous = receiptHead(receipt);
|
|
turn = receipt.source.turn;
|
|
}
|
|
requireBetrayal(cursor.signature === previous,
|
|
'Harkonnen Betrayal history no longer matches its independent cursor.');
|
|
}
|
|
function replacementSignature(replacement: HarkonnenBetrayalReplacement): string {
|
|
return JSON.stringify(['harkonnenBetrayalReplacement', replacement.version, replacement.event,
|
|
replacement.sequence, replacement.provider, replacement.turn, replacement.identity,
|
|
replacement.receipt, replacement.status, replacement.drawn]);
|
|
}
|
|
export function createHarkonnenBetrayalReplacement(receipt: HarkonnenBetrayalReceipt): HarkonnenBetrayalReplacement {
|
|
requireBetrayal(exact(receipt, ['source', 'outcome', 'holder', 'previous', 'signature']),
|
|
'Harkonnen Betrayal replacement requires its exact closed native receipt.');
|
|
validateSavedSource(receipt.source);
|
|
validateCursor({ sequence: receipt.source.sequence, signature: receipt.previous });
|
|
requireBetrayal(receipt.outcome === 'use' && text(receipt.holder) && receipt.holder === receipt.source.eligible &&
|
|
text(receipt.previous) && receipt.signature === receiptSignature(receipt),
|
|
'Only a successful Harkonnen Betrayal Use creates a Mentat replacement obligation.');
|
|
const replacement: HarkonnenBetrayalReplacement = {
|
|
version: 1, event: receipt.source.event, sequence: receipt.source.sequence,
|
|
provider: receipt.source.provider, turn: receipt.source.turn, identity: receipt.source.declaration.identity,
|
|
receipt: receiptHead(receipt), status: 'due', drawn: null, signature: '',
|
|
};
|
|
replacement.signature = replacementSignature(replacement);
|
|
return replacement;
|
|
}
|
|
function validateReplacement(
|
|
replacement: HarkonnenBetrayalReplacement, history: readonly HarkonnenBetrayalReceipt[],
|
|
): void {
|
|
requireBetrayal(exact(replacement, ['version', 'event', 'sequence', 'provider', 'turn', 'identity',
|
|
'receipt', 'status', 'drawn', 'signature']) && replacement.version === 1 &&
|
|
whole(replacement.sequence) && whole(replacement.turn) && replacement.turn > 0 &&
|
|
text(replacement.event) && text(replacement.provider) && text(replacement.identity) &&
|
|
text(replacement.receipt) && text(replacement.signature) &&
|
|
(replacement.status === 'due' ? replacement.drawn === null :
|
|
replacement.status === 'drawn' && text(replacement.drawn)),
|
|
'Harkonnen Betrayal has a malformed or repeated Mentat replacement.');
|
|
const receipt = history[replacement.sequence];
|
|
requireBetrayal(receipt?.outcome === 'use' && replacement.receipt === receiptHead(receipt) &&
|
|
replacement.event === receipt.source.event && replacement.provider === receipt.source.provider &&
|
|
replacement.turn === receipt.source.turn && replacement.identity === receipt.source.declaration.identity &&
|
|
(replacement.drawn === null || receipt.source.universe.includes(replacement.drawn)) &&
|
|
replacement.signature === replacementSignature(replacement),
|
|
'Harkonnen Betrayal replacement lost its exact successful Use obligation or actual drawn identity.');
|
|
if (replacement.drawn !== null) {
|
|
const [, originalTraitors] = JSON.parse(receipt.source.inventory) as [unknown, NexusTraitorSnapshot];
|
|
requireBetrayal(!originalTraitors.removed?.includes(replacement.drawn),
|
|
'Permanently set-aside Traitor Cards cannot fund a Betrayal replacement.');
|
|
}
|
|
}
|
|
export function validateHarkonnenBetrayalReplacement(
|
|
replacement: HarkonnenBetrayalReplacement, history: readonly HarkonnenBetrayalReceipt[],
|
|
cursor: HarkonnenBetrayalCursor, universe?: readonly string[],
|
|
): void {
|
|
validateHarkonnenBetrayalHistory(history, cursor, universe);
|
|
validateReplacement(replacement, history);
|
|
}
|
|
export function drawHarkonnenBetrayalReplacement(
|
|
replacement: HarkonnenBetrayalReplacement, history: readonly HarkonnenBetrayalReceipt[],
|
|
cursor: HarkonnenBetrayalCursor, drawn: string, universe?: readonly string[],
|
|
): HarkonnenBetrayalReplacement {
|
|
validateHarkonnenBetrayalReplacement(replacement, history, cursor, universe);
|
|
requireBetrayal(replacement.status === 'due' && text(drawn) &&
|
|
history[replacement.sequence].source.universe.includes(drawn),
|
|
'Harkonnen Betrayal replacement draws exactly once from its actual canonical Traitor Deck.');
|
|
const result: HarkonnenBetrayalReplacement = { ...replacement, status: 'drawn', drawn, signature: '' };
|
|
result.signature = replacementSignature(result);
|
|
validateReplacement(result, history);
|
|
return result;
|
|
}
|
|
export function validateHarkonnenBetrayalReplacements(
|
|
history: readonly HarkonnenBetrayalReceipt[], cursor: HarkonnenBetrayalCursor,
|
|
replacements: readonly HarkonnenBetrayalReplacement[], universe?: readonly string[],
|
|
): void {
|
|
validateHarkonnenBetrayalHistory(history, cursor, universe);
|
|
requireBetrayal(Array.isArray(replacements), 'Harkonnen Betrayal lost its replacement provenance.');
|
|
for (const replacement of replacements) validateReplacement(replacement, history);
|
|
const used = history.filter(receipt => receipt.outcome === 'use');
|
|
requireBetrayal(replacements.length === used.length &&
|
|
new Set(replacements.map(replacement => replacement.sequence)).size === replacements.length &&
|
|
replacements.filter(replacement => replacement.status === 'due').length <= 1,
|
|
'Every successful Harkonnen Betrayal Use requires exactly one due or completed private draw.');
|
|
}
|