/** Binds the mode host to the real engine through its public API (shared/game/index.ts). */ import { DEFAULT_RULESET, parseRuleset, starterDeck, previewPool as engineLoaners, 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 engine's * frozen loaner cards (`previewPool(rules)`, derived with the mode's rules), one copy per round, * never exceeding the ruleset's per-page copy limit. Copies get distinct cardIds. */ export function previewPool(rules: Ruleset, seed: string, size: number): GameCard[] { const rng = Rng.fromSeed(`draft-pool:${seed}`); const loaners = engineLoaners(rules); const pool: GameCard[] = []; for (let copy = 0; pool.length < size && copy < rules.maxCopiesPerPage; copy++) { for (const card of rng.shuffle(loaners)) { if (pool.length >= size) break; pool.push({ ...card, cardId: `${card.cardId}:${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 = { 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), };