forked from WikiDeck/wikideck
Live/trending presets freeze the engine's trend arrow from cached live data; the host turn timer uses the ruleset's turnSeconds and applies the engine's timeout action (logged, replayable AFK forfeits). Non-draft modes whose rules make starter decks illegal are rejected at startup. HOSTING.md updated. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
55 lines
2.7 KiB
TypeScript
55 lines
2.7 KiB
TypeScript
/** 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;
|
|
}
|
|
|
|
export const engineBinding: EnginePort<Ruleset, GameCard, MatchState, Action> = {
|
|
defaultRuleset: DEFAULT_RULESET,
|
|
parseRuleset,
|
|
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),
|
|
};
|