@table-games-engine/game-kit 0.0.0-stage → 0.1.1

package/template/client/main.ts

@@ -0,0 +1,31 @@
+import { connectBridge, type StatePayload } from '@table-games-engine/game-kit/bridge';
+
+const STRINGS = {
+  en: { you: 'You', opponent: 'Opponent', yourTurn: 'Your turn', waiting: 'Waiting for opponent…', won: 'You won!', lost: 'You lost.', cast: 'Cast Fire Bolt', rejected: 'That move is no longer legal.' },
+} as const;
+const locale = new URLSearchParams(location.search).get('locale') ?? 'en';
+const t = STRINGS[locale as keyof typeof STRINGS] ?? STRINGS.en;
+const app = document.getElementById('app')!;
+
+const bridge = connectBridge(render, (kind) => {
+  if (kind === 'rejected') app.insertAdjacentHTML('beforeend', `<p>${t.rejected}</p>`);
+});
+
+function render(s: StatePayload): void {
+  const me = s.view.viewerId;
+  const rows = Object.values(s.view.players).map((p) => {
+    const life = (p as { resources?: Record<string, number> }).resources?.['life'] ?? '?';
+    return `<div class="row"><span>${p.playerId === me ? t.you : t.opponent}</span><span>${life} ♥</span></div>`;
+  });
+  const status =
+    s.status === 'finished'
+      ? (s.result?.winners.includes(me) ? t.won : t.lost)
+      : s.legalMoves.length > 0 ? t.yourTurn : t.waiting;
+  app.innerHTML = `${rows.join('')}<p>${status}</p>`;
+  for (const move of s.legalMoves) {
+    const button = document.createElement('button');
+    button.textContent = t.cast;
+    button.onclick = () => bridge.send(move);
+    app.appendChild(button);
+  }
+}

package/template/game.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "./node_modules/@table-games-engine/game-kit/schema/game.schema.json",
+  "slug": "__SLUG__",
+  "name": "__NAME__",
+  "version": "0.1.0",
+  "engine": "^0.1.1",
+  "players": { "min": 2, "max": 2 },
+  "locales": ["en"],
+  "description": "Two wizards take turns casting Fire Bolt until one drops to 0 life.",
+  "rules": { "en": "rules.md" },
+  "tags": ["duel"],
+  "authors": ["replace-me"],
+  "credits": "",
+  "listed": false,
+  "client": { "kind": "iframe", "entry": "client/dist/index.html" },
+  "presets": [
+    { "id": "standard", "name": "Standard (5 life)", "config": { "life": 5 } },
+    { "id": "quick", "name": "Quick (3 life)", "config": { "life": 3 } }
+  ],
+  "simulation": { "maxSteps": 200 }
+}

package/template/gitignore

@@ -0,0 +1,3 @@
+node_modules
+client/dist
+.game-kit

package/template/logic/index.ts

@@ -0,0 +1,119 @@
+/**
+ * Template store game: a two-player Fire Bolt duel.
+ * Replace manifest, setup, handlers, win checker and legalMoves with your game.
+ */
+import {
+  ok,
+  reject,
+  resolved,
+  type ActionHandler,
+  type ActionTypeId,
+  type GameId,
+  type GameManifest,
+  type GamePlugin,
+  type PhaseId,
+  type PlayerState,
+  type SeatIndex,
+  type SemanticVersion,
+} from '@table-games-engine/core';
+
+export const FIRE_BOLT = 'fire-bolt' as ActionTypeId;
+const MAIN = 'main' as PhaseId;
+
+const manifest = {
+  id: '__SLUG__',
+  name: '__NAME__',
+  version: '0.1.0',
+  minPlayers: 2,
+  maxPlayers: 2,
+  phases: {
+    entryPhase: MAIN,
+    phases: {
+      main: {
+        id: MAIN,
+        name: 'Main',
+        startingPriority: 'active-player',
+        legalActions: [FIRE_BOLT],
+        exitCondition: 'manual',
+        perPlayer: false,
+        onEnter: [],
+        onExit: [],
+      },
+    },
+    transitions: [],
+  },
+  actions: {
+    actions: {
+      [FIRE_BOLT]: {
+        id: FIRE_BOLT,
+        name: 'Fire Bolt',
+        speed: 'sorcery',
+        usesStack: true,
+        canTargetStack: false,
+        effects: [],
+        payloadSchema: { type: 'object', properties: {} },
+      },
+    },
+  },
+  triggers: { triggers: {} },
+  zones: { zones: {} },
+  winConditions: [],
+  configSchema: { type: 'object', properties: {} },
+  defaultConfig: {},
+  requiredMechanics: [],
+} as unknown as GameManifest;
+
+const fireBolt: ActionHandler = (ctx, frame) => {
+  const actor = 'actor' in frame ? frame.actor : frame.controller;
+  const target = ctx.getActivePlayers().find((p) => p !== actor);
+  // An illegal move: the server rejects the input and nothing changes.
+  if (!target) return reject('rule-violation');
+  return resolved([
+    { domain: 'player', operation: { type: 'add-resource', playerId: target, resource: 'life', delta: -2 } },
+    // Ending the turn is the handler's job: the engine then gives priority to the next player.
+    { domain: 'turn', operation: { type: 'advance' } },
+  ]);
+};
+
+const plugin: GamePlugin = {
+  id: '__SLUG__' as GameId,
+  version: '0.1.0' as SemanticVersion,
+  manifest,
+  requiredMechanics: [],
+  setup: (ctx, config, seats) => {
+    const life = typeof config['life'] === 'number' ? config['life'] : 5;
+    const players = Object.fromEntries(
+      seats.map((s) => [
+        s.playerId,
+        {
+          playerId: s.playerId,
+          seatIndex: s.seatIndex as SeatIndex,
+          status: 'active',
+          zones: {},
+          resources: { life },
+          counters: {},
+          flags: {},
+          custom: {},
+        } satisfies PlayerState,
+      ]),
+    );
+    // ctx.state is a valid empty state for this manifest (seats in turn order, first seat has priority); build on it.
+    return ok({ state: { ...ctx.state, players } });
+  },
+  actionHandlers: { [FIRE_BOLT]: fireBolt },
+  winConditionChecker: (ctx) => {
+    const fallen = Object.values(ctx.state.players).find((p) => (p.resources['life'] ?? 0) <= 0);
+    if (!fallen) return { gameOver: false };
+    return {
+      gameOver: true,
+      winners: Object.values(ctx.state.players).filter((p) => p.playerId !== fallen.playerId).map((p) => p.playerId),
+      reason: 'life',
+    };
+  },
+  legalMoves: (state, playerId) =>
+    state.result || state.priority.holder !== playerId
+      ? []
+      : [{ playerId, type: 'action', data: { type: 'action', actionTypeId: FIRE_BOLT, targets: {}, payload: {} } }],
+};
+
+export default plugin;

package/template/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "__SLUG__",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "check": "game-kit check",
+    "test": "game-kit test",
+    "simulate": "game-kit simulate",
+    "preview": "game-kit preview"
+  },
+  "devDependencies": {
+    "@table-games-engine/core": "^0.1.1",
+    "@table-games-engine/game-kit": "^0.1.1",
+    "typescript": "^5.4.0",
+    "vite": "^5.4.0",
+    "vitest": "^2.0.0"
+  }
+}

package/template/rules.md

@@ -0,0 +1,5 @@
+# __NAME__
+
+Two players start with the life set by the match preset (5 on *Standard*, 3 on *Quick*).
+On your turn you cast **Fire Bolt**: your opponent loses 2 life and the turn passes.
+The first player at 0 life or below loses.

package/template/tests/game.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { driveAction, rulesFromPlugin, setupMatch, type LegalMove, type PlayerId } from '@table-games-engine/core';
+import plugin, { FIRE_BOLT } from '../logic/index';
+
+const P1 = 'p1' as PlayerId;
+const P2 = 'p2' as PlayerId;
+
+/** Typed access to a move's action fields (actionTypeId, payload): no casts needed. */
+const actionOf = (m: LegalMove) => (m.data.type === 'action' ? m.data : null);
+
+describe('fire duel', () => {
+  it('the first player wins the straight race on the standard preset', () => {
+    let state = setupMatch(plugin, { playerIds: [P1, P2], config: { life: 5 }, seed: 'test' });
+    const rules = rulesFromPlugin(plugin);
+    for (let step = 0; !state.result && step < 10; step++) {
+      const move = plugin.legalMoves!(state, state.priority.holder!).find((m) => actionOf(m)?.actionTypeId === FIRE_BOLT);
+      const r = driveAction(rules, state, { ...move!, clientId: `t${step}`, stateVersion: state.version as unknown as number });
+      if (!r.ok) throw new Error(JSON.stringify(r.error));
+      state = r.state;
+    }
+    expect(state.result?.winners).toEqual([P1]);
+  });
+});

package/template/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "target": "ES2022", "module": "ESNext", "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM"], "strict": true, "noEmit": true, "skipLibCheck": true
+  },
+  "include": ["logic/**/*.ts", "client/**/*.ts", "tests/**/*.ts"]
+}