Begin Hnefatafl from the game kit

src/lib/game/index.ts

@@ -0,0 +1,94 @@
+// The demo game, "High Card": every round each seat names a number from one
+// to five; the highest number named by exactly one seat scores it a point,
+// and the first to three points wins. It exists to show the shape of a game
+// this kit can run: simultaneous hidden moves, a seeded bot, a view that
+// withholds the round in progress, and a rules revision. Replace this file
+// with your own game and keep the GameSpec shape.
+
+import { SPECTATOR, type GameSpec, type Outcome, type SeatId, type TableOptions } from './spec';
+
+export const CURRENT_RULES = 1;
+export const TARGET = 3;
+export const HIGHEST = 5;
+
+export interface Player {
+	id: SeatId;
+	name: string;
+	points: number;
+}
+
+export interface Round {
+	picks: Record<SeatId, number>;
+	scorer: SeatId | null;
+}
+
+export interface State {
+	rules: number;
+	seats: SeatId[];
+	players: Record<SeatId, Player>;
+	rounds: Round[];
+	over: Outcome | null;
+	rng: number;
+}
+
+export type Input = { pick: number };
+
+/** Mulberry32 on a seed: a small generator, so a game replays to the same bot picks. */
+function random(seed: number): number {
+	let t = (seed + 0x6d2b79f5) >>> 0;
+	t = Math.imul(t ^ (t >>> 15), t | 1);
+	t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+	return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+}
+
+export function createGame(names: Record<SeatId, string>, seed = Date.now(), rules = CURRENT_RULES, _options?: TableOptions): State {
+	const seats = Object.keys(names);
+	return {
+		rules,
+		seats,
+		players: Object.fromEntries(seats.map((id) => [id, { id, name: names[id], points: 0 }])),
+		rounds: [],
+		over: null,
+		rng: seed >>> 0 || 1
+	};
+}
+
+export function resolveRound(previous: State, inputs: Record<SeatId, Input>): State {
+	const state = structuredClone(previous);
+	if (state.over) return state;
+	const picks: Record<SeatId, number> = {};
+	for (const id of state.seats) picks[id] = inputs[id]?.pick ?? 1;
+	const counts = new Map<number, SeatId[]>();
+	for (const id of state.seats) counts.set(picks[id], [...(counts.get(picks[id]) ?? []), id]);
+	let scorer: SeatId | null = null;
+	for (let n = HIGHEST; n >= 1 && !scorer; n--) {
+		const who = counts.get(n);
+		if (who?.length === 1) scorer = who[0];
+	}
+	if (scorer) state.players[scorer].points += 1;
+	state.rounds.push({ picks, scorer });
+	if (scorer && state.players[scorer].points >= TARGET) {
+		state.over = { winner: scorer, reason: `${state.players[scorer].name} reached ${TARGET} points.` };
+	}
+	return state;
+}
+
+export const game: GameSpec<State, Input> = {
+	seatIds: 'ABCDEFGH'.split(''),
+	minSeats: 2,
+	botNames: ['Aldric', 'Morwenna', 'Thessaly', 'Gandric', 'Ysolde', 'Ormund', 'Corwin', 'Isaura'],
+	currentRules: CURRENT_RULES,
+	create: createGame,
+	resolve: resolveRound,
+	needsInput: (state) => !state.over,
+	over: (state) => state.over,
+	turn: (state) => state.rounds.length + 1,
+	// Every finished round is public; nothing is hidden, so the gallery sees what a seat sees.
+	view: (state, viewer) => (viewer === SPECTATOR ? structuredClone(state) : structuredClone(state)),
+	// A function of the state alone: the seed, the round and the seat, so a replay draws the same pick.
+	botInput: (state, seat) => ({ pick: 1 + Math.floor(random(state.rng + state.rounds.length * 7919 + state.seats.indexOf(seat)) * HIGHEST) }),
+	cleanInput: (raw) => ({ pick: Number((raw as { pick?: unknown })?.pick) }),
+	validate: (_state, _seat, input) =>
+		Number.isInteger(input.pick) && input.pick >= 1 && input.pick <= HIGHEST ? null : `Name a number from 1 to ${HIGHEST}.`,
+	nameOf: (state, seat) => state.players[seat]?.name ?? seat
+};