Files
wikideck/server/game/engine-binding.ts
T

75 lines
4.0 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/** Binds the mode host to the real engine through its public API (shared/game/index.ts). */
import { DEFAULT_RULESET, parseRuleset, starterDeck, loanerCard, STARTER_POOL, validateDeck, createMatch,
legalActions, applyAction, isOver, result, viewFor, Rng,
type Action, type GameCard, type MatchState, type Ruleset } from '../../shared/game/index.ts';
import type { EnginePort, Seat } from './engine-port.ts';
/**
* Deterministic pool of loaner (non-NFT) cards for draft modes: seeded shuffles of the
* starter pool, one copy per round, never exceeding the ruleset's per-page copy limit.
*/
export function previewPool(rules: Ruleset, seed: string, size: number): GameCard[] {
const rng = Rng.fromSeed(`draft-pool:${seed}`);
const pool: GameCard[] = [];
for (let copy = 0; pool.length < size && copy < rules.maxCopiesPerPage; copy++) {
for (const spec of rng.shuffle(STARTER_POOL)) { if (pool.length >= size) break; pool.push(loanerCard(spec, copy)); }
}
return pool;
}
/**
* The engine's strict parseRuleset, plus host-side checks that keep a hosted mode playable
* (requested in review on #6). Anything that fails is rejected at startup, never passed on.
*/
export const UNSAFE_KEYWORDS: readonly string[] = ['obscure'];
export function parseModeRuleset(value: unknown): Ruleset {
const rules = parseRuleset(value);
const problems: string[] = [];
if (rules.distinctStats && rules.topicCount !== 3) problems.push('distinctStats requires topicCount 3');
if (rules.portalReveal.some(turn => turn > rules.turns)) problems.push('every portalReveal turn must be ≤ turns');
if (rules.energyByTurn.length < rules.turns) problems.push('energyByTurn needs one entry per turn');
if (rules.turns * rules.turnSeconds > 240) problems.push('turns × turnSeconds must be ≤ 240');
if (rules.powerByCost.length !== 7) problems.push('powerByCost needs 7 entries');
// Keywords whose hidden information viewFor doesn't mask yet would leak cards to the opponent (#6, #27).
for (const id of UNSAFE_KEYWORDS) if ((rules.keywordsEnabled as readonly string[]).includes(id)) problems.push(`keyword "${id}" is not hostable yet (viewFor does not mask it)`);
if (problems.length) throw new Error(`Invalid mode rules: ${problems.join('; ')}`);
return rules;
}
export const engineBinding: EnginePort<Ruleset, GameCard, MatchState, Action> = {
defaultRuleset: DEFAULT_RULESET,
parseRuleset: parseModeRuleset,
deckSize: rules => rules.deckSize,
starterDeck: (_rules, seed) => starterDeck(seed),
previewPool,
validateDeck: (rules, cards) => {
const problems = validateDeck(rules, cards);
if (problems.length) throw new Error(problems.slice(0, 3).join('; '));
},
cardPower: card => card.power,
withPower: (card, power) => ({ ...card, power: Math.min(30, Math.max(0, power)) }),
cardPageId: card => card.pageId,
cardSummary: card => ({ cardId: card.cardId, title: card.title, pageId: card.pageId, faction: card.faction,
cost: card.cost, power: card.power, home: card.home, trend: card.trend, keyword: card.keyword }),
createMatch: (rules, decks, seed) => createMatch(rules, decks, seed),
legalActions: (state, seat) => legalActions(state, seat),
applyAction: (state, seat: Seat, action) => {
if (action.player !== seat) throw new Error('Action for the wrong seat');
return applyAction(state, action);
},
concedeAction: seat => ({ type: 'concede', player: seat }),
timeoutAction: seat => ({ type: 'timeout', player: seat }),
turnSeconds: rules => rules.turnSeconds,
turnOf: state => state.turn,
// DESIGN §1.6: the live trend arrow, frozen at match start, using the ruleset's thresholds.
applyLive: (rules, card, live) => {
const t = live.trendPercent;
const trend = t === null || !Number.isFinite(t) ? 0 : t >= rules.trendUp ? 1 : t <= rules.trendDown ? -1 : 0;
return { ...card, trend };
},
isOver,
result: state => { const r = result(state); return { winner: r?.winner ?? null, reason: r?.reason ?? 'complete' }; },
viewFor: (state, seat) => viewFor(state, seat),
};