forked from WikiDeck/wikideck
45 lines
2.8 KiB
TypeScript
45 lines
2.8 KiB
TypeScript
// A tiny deterministic stand-in for the real engine, implementing the EnginePort used by
|
|
// server/game. Each turn both seats play one card; after `turns` turns, higher total power wins.
|
|
import { z } from 'zod';
|
|
import type { EnginePort, Seat } from '../server/game/engine-port.ts';
|
|
|
|
export type StubCard = { id: string; pageId: number | null; power: number };
|
|
type Rules = { deckSize: number; turns: number; scoring: { tieBreak: 'draw' | 'first' } };
|
|
type State = { rules: Rules; turn: number; hands: StubCard[][]; staged: (number | null)[]; totals: number[] };
|
|
|
|
const RulesSchema = z.object({ deckSize: z.number().int().min(2).max(20), turns: z.number().int().min(1).max(10),
|
|
scoring: z.object({ tieBreak: z.enum(['draw', 'first']) }).strict() }).strict();
|
|
function rng(seed: string) { let h = 2166136261; for (const c of seed) h = Math.imul(h ^ c.charCodeAt(0), 16777619);
|
|
return () => { h ^= h << 13; h ^= h >>> 17; h ^= h << 5; return (h >>> 0) / 2 ** 32; }; }
|
|
const pool = (seed: string, n: number) => { const r = rng(seed);
|
|
return Array.from({ length: n }, (_, i) => ({ id: `${seed}-${i}`, pageId: 1000 + i, power: 1 + Math.floor(r() * 9) })); };
|
|
|
|
export const stubEngine: EnginePort<Rules, StubCard, State, { type: 'play'; card: number }> = {
|
|
defaultRuleset: { deckSize: 4, turns: 3, scoring: { tieBreak: 'draw' } },
|
|
parseRuleset: v => RulesSchema.parse(v),
|
|
deckSize: r => r.deckSize,
|
|
starterDeck: (r, seed) => pool(seed, r.deckSize),
|
|
previewPool: (_r, seed, n) => pool(seed, n),
|
|
validateDeck: (r, cards) => { if (cards.length !== r.deckSize) throw new Error('wrong deck size');
|
|
for (const c of cards) if (!Number.isInteger(c.power) || c.power < 0 || c.power > 20) throw new Error('bad card'); },
|
|
cardPower: c => c.power,
|
|
withPower: (c, power) => ({ ...c, power }),
|
|
cardPageId: c => c.pageId,
|
|
cardSummary: c => ({ id: c.id, power: c.power }),
|
|
createMatch: (rules, decks) => ({ rules, turn: 0, hands: decks.map(d => d.map(c => ({ ...c }))), staged: [null, null], totals: [0, 0] }),
|
|
legalActions: (s, seat) => s.turn >= s.rules.turns || s.staged[seat] !== null ? [] :
|
|
s.hands[seat]!.map((_, card) => ({ type: 'play' as const, card })),
|
|
applyAction: (s, seat, a) => {
|
|
const n: State = structuredClone(s);
|
|
n.staged[seat] = a.card;
|
|
if (n.staged[0] !== null && n.staged[1] !== null) {
|
|
for (const p of [0, 1] as Seat[]) { const [c] = n.hands[p]!.splice(n.staged[p]!, 1); n.totals[p]! += c!.power; }
|
|
n.staged = [null, null]; n.turn++;
|
|
}
|
|
return n;
|
|
},
|
|
isOver: s => s.turn >= s.rules.turns,
|
|
result: s => ({ winner: s.totals[0]! > s.totals[1]! ? 0 : s.totals[1]! > s.totals[0]! ? 1 : s.rules.scoring.tieBreak === 'first' ? 0 : null }),
|
|
viewFor: (s, seat) => ({ turn: s.turn, hand: s.hands[seat], opponentCards: s.hands[1 - seat]!.length, totals: s.totals, staged: s.staged[seat] }),
|
|
};
|