@nayan-ui/games 1.19.0 → 1.20.0

package/src/games/ludo-king/LudoKing.tsx

@@ -0,0 +1,86 @@
+// Ludo King's screen, on the Nayan engine: the board, four homes, pawns and die are one 3D scene (an
+// orthographic camera leaning back over the cross board), under Playtura's scoreboard, controls and
+// modals. The rules are in LudoKingRules.ts, the turns in LudoKingGame.ts, what it draws in
+// LudoKingScene.ts.
+//
+// One world serves the whole visit: Start, Stop and Play Again reset it in place and a theme change
+// repaints the backdrop, so the GPU view is never rebuilt. Rolls, hops and captures animate in the
+// engine's Rust core; JS steps the turn's clock and the world once a frame.
+import { HapticType } from '../../services/HapticsService';
+import { GAME_SOUNDS } from '../../services/SoundsService';
+import { GAME_IDS } from '../../services/UtilsService';
+import { engineGame, EngineGameScreen } from '../shared/EngineGameScreen';
+import { textColumn } from '../shared/EngineHud';
+import { useEngineGame } from '../shared/useEngineGame';
+import { useLiveState } from '../shared/useLiveState';
+import { AI_COLOR, getLayout, LIGHT, PLAYER_COLOR, RIM } from './LudoKingConstants';
+import { createGame, dispose, type GameEvent, reset, setLayout, setTheme, start, tap, tick, type Turn } from './LudoKingGame';
+
+const SOUNDS = GAME_SOUNDS.LUDO_KING;
+
+/** Each turn event's sound and haptic; the AI's quieter ones skip what only made sense for your own move. */
+const FEEDBACK: Record<GameEvent, { sound?: keyof typeof SOUNDS; haptic?: HapticType; youOnly?: boolean }> = {
+  tap: { sound: 'TAP', haptic: HapticType.MEDIUM },
+  roll: { sound: 'ROLL' },
+  six: { sound: 'SIX', haptic: HapticType.SUCCESS },
+  penalty: { sound: 'PENALTY', haptic: HapticType.ERROR },
+  cantMove: { sound: 'CANT_MOVE', haptic: HapticType.WARNING, youOnly: true },
+  move: { sound: 'MOVE', haptic: HapticType.LIGHT },
+  capture: { sound: 'CAPTURE', haptic: HapticType.SUCCESS },
+  finish: { sound: 'FINISH', haptic: HapticType.SUCCESS }
+};
+
+export const LudoKing = engineGame(GAME_IDS.LUDO_KING, (props) => {
+  const [home, setHome] = useLiveState<[number, number]>([0, 0]);
+  const [turn, setTurn] = useLiveState<Turn>(0);
+  const [score, setScore] = useLiveState(0);
+
+  const { status, screen, gameOver } = useEngineGame(props, {
+    gameId: GAME_IDS.LUDO_KING,
+    create: createGame,
+    start,
+    reset,
+    dispose,
+    tick,
+    setTheme,
+    resize: (g, width, height, offset) => {
+      const l = getLayout(width, height, offset);
+      setLayout(g, l);
+      return l.size * (1 + RIM * 2);
+    },
+    tap,
+    sounds: SOUNDS,
+    onStart: (fx) => fx(SOUNDS.START, HapticType.MEDIUM),
+    onOver: (fx, s) => fx(s === 'win' ? SOUNDS.WIN : SOUNDS.GAME_OVER, s === 'win' ? HapticType.SUCCESS : HapticType.HEAVY),
+    wire: (g, fx) => {
+      g.onFinished = (you, ai) => setHome([you, ai]);
+      g.onScore = setScore;
+      g.onTurn = setTurn;
+      g.onEvent = (event, who) => {
+        const f = FEEDBACK[event];
+        if (f.youOnly && who !== 0) return;
+        fx(f.sound ? SOUNDS[f.sound] : null, f.haptic);
+      };
+    }
+  });
+
+  return (
+    <EngineGameScreen
+      {...screen}
+      light={LIGHT}
+      columns={[
+        textColumn('YOU', String(home[0]), PLAYER_COLOR),
+        textColumn(turn === 0 ? 'YOUR TURN' : 'AI TURN', score.toLocaleString()),
+        textColumn('AI', String(home[1]), AI_COLOR)
+      ]}
+      subtext="Roll dice, move tokens!"
+      gameOver={gameOver({
+        title: status === 'win' ? 'YOU WON!' : 'YOU LOST!',
+        message: status === 'win' ? 'All your tokens made it home!' : 'The AI got all four home first!',
+        scoreLabel: status === 'win' ? 'You Won!' : 'You Lost',
+        score,
+        buttonText: status === 'win' ? 'Play Again!' : 'Try Again!'
+      })}
+    />
+  );
+});

package/src/games/ludo-king/LudoKingConstants.ts

@@ -0,0 +1,212 @@
+// Ludo King's board, rules, timings and layout, on the Nayan engine. You play green (bottom-left), the
+// AI plays red (top-right). Roll the die, bring tokens out on a six, race them round the cross and up
+// your home column; land on an opponent to send it back. First to get all four tokens home wins. The
+// scoring (3,000 a finished token, plus progress) matches the original version so scores carry over.
+import { getScoreBoardTop } from '../shared/EngineHud';
+import { project } from '../shared/EngineTilt';
+import { frontLight, gameWidthFor } from '../shared/EngineUtils';
+
+export type PlayerColor = 'red' | 'green' | 'yellow' | 'blue';
+
+export const GRID = 15;
+export const TOKENS_PER_PLAYER = 4;
+export const TRACK_LENGTH = 56; // steps from a token's entry to home (land on it exactly to finish)
+export const MAX_SIXES = 3;
+
+// ── Colors ────────────────────────────────────────────────────────────
+
+export const PLAYER_COLORS: Record<PlayerColor, string> = {
+  red: '#E53935',
+  green: '#43A047',
+  yellow: '#D4A017',
+  blue: '#1E88E5'
+};
+export const BOARD_WHITE = '#FBF7EC';
+export const BOARD_FRAME = '#2A2550';
+export const STAR_COLOR = '#8A8AA0';
+export const PLAYER_COLOR = PLAYER_COLORS.green; // you
+export const AI_COLOR = PLAYER_COLORS.red; // the AI
+
+// ── Timings (seconds) ─────────────────────────────────────────────────
+
+export const ROLL_TIME = 0.9; // the die is tossed and bounces to rest
+export const MOVE_DELAY = 0.35;
+export const HOP_TIME = 0.14; // a cell
+export const NEXT_TURN_DELAY = 0.45;
+export const PENALTY_DELAY = 0.9;
+export const CANT_MOVE_DELAY = 0.6;
+export const AI_THINK = 0.7;
+
+// ── The scene ─────────────────────────────────────────────────────────
+
+export const TILT = 0.35;
+export const LIGHT = frontLight([-0.35, 0.3, 1], 0.5);
+
+export const RIM = 0.014; // a slim frame round the board, in board units
+export const TILE_TOP = 0.012;
+export const DIE_SIZE = 0.15;
+export const DIE_Y = -0.5 - RIM - 0.06 - DIE_SIZE / 2;
+export const TOKEN_HEIGHT = 0.07;
+
+// ── Entry points, safe cells and the paths (as the original version) ──────
+
+/** Absolute index on MAIN_PATH where each player joins. */
+export const ENTRY: Record<PlayerColor, number> = { blue: 1, red: 14, yellow: 27, green: 40 };
+/** Entry cells and stars: no capture here. */
+export const SAFE_POSITIONS = [1, 9, 14, 22, 27, 35, 40, 48];
+
+/** The 52 shared cells, clockwise, as {row, col} on the 15 x 15 grid. */
+export const MAIN_PATH: { row: number; col: number }[] = [
+  { row: 6, col: 0 },
+  { row: 6, col: 1 },
+  { row: 6, col: 2 },
+  { row: 6, col: 3 },
+  { row: 6, col: 4 },
+  { row: 6, col: 5 },
+  { row: 5, col: 6 },
+  { row: 4, col: 6 },
+  { row: 3, col: 6 },
+  { row: 2, col: 6 },
+  { row: 1, col: 6 },
+  { row: 0, col: 6 },
+  { row: 0, col: 7 },
+  { row: 0, col: 8 },
+  { row: 1, col: 8 },
+  { row: 2, col: 8 },
+  { row: 3, col: 8 },
+  { row: 4, col: 8 },
+  { row: 5, col: 8 },
+  { row: 6, col: 9 },
+  { row: 6, col: 10 },
+  { row: 6, col: 11 },
+  { row: 6, col: 12 },
+  { row: 6, col: 13 },
+  { row: 6, col: 14 },
+  { row: 7, col: 14 },
+  { row: 8, col: 14 },
+  { row: 8, col: 13 },
+  { row: 8, col: 12 },
+  { row: 8, col: 11 },
+  { row: 8, col: 10 },
+  { row: 8, col: 9 },
+  { row: 9, col: 8 },
+  { row: 10, col: 8 },
+  { row: 11, col: 8 },
+  { row: 12, col: 8 },
+  { row: 13, col: 8 },
+  { row: 14, col: 8 },
+  { row: 14, col: 7 },
+  { row: 14, col: 6 },
+  { row: 13, col: 6 },
+  { row: 12, col: 6 },
+  { row: 11, col: 6 },
+  { row: 10, col: 6 },
+  { row: 9, col: 6 },
+  { row: 8, col: 5 },
+  { row: 8, col: 4 },
+  { row: 8, col: 3 },
+  { row: 8, col: 2 },
+  { row: 8, col: 1 },
+  { row: 8, col: 0 },
+  { row: 7, col: 0 }
+];
+
+/** Each player's 6 home-stretch cells, from the first inside the arm to the centre. */
+export const HOME_STRETCH: Record<PlayerColor, { row: number; col: number }[]> = {
+  blue: [
+    { row: 7, col: 1 },
+    { row: 7, col: 2 },
+    { row: 7, col: 3 },
+    { row: 7, col: 4 },
+    { row: 7, col: 5 },
+    { row: 7, col: 6 }
+  ],
+  red: [
+    { row: 1, col: 7 },
+    { row: 2, col: 7 },
+    { row: 3, col: 7 },
+    { row: 4, col: 7 },
+    { row: 5, col: 7 },
+    { row: 6, col: 7 }
+  ],
+  yellow: [
+    { row: 7, col: 13 },
+    { row: 7, col: 12 },
+    { row: 7, col: 11 },
+    { row: 7, col: 10 },
+    { row: 7, col: 9 },
+    { row: 7, col: 8 }
+  ],
+  green: [
+    { row: 13, col: 7 },
+    { row: 12, col: 7 },
+    { row: 11, col: 7 },
+    { row: 10, col: 7 },
+    { row: 9, col: 7 },
+    { row: 8, col: 7 }
+  ]
+};
+
+/** The four token yards in each player's home base. */
+export const HOME_YARDS: Record<PlayerColor, { row: number; col: number }[]> = {
+  blue: [
+    { row: 1.5, col: 1.5 },
+    { row: 1.5, col: 4.5 },
+    { row: 4.5, col: 1.5 },
+    { row: 4.5, col: 4.5 }
+  ],
+  red: [
+    { row: 1.5, col: 10.5 },
+    { row: 1.5, col: 13.5 },
+    { row: 4.5, col: 10.5 },
+    { row: 4.5, col: 13.5 }
+  ],
+  green: [
+    { row: 10.5, col: 1.5 },
+    { row: 10.5, col: 4.5 },
+    { row: 13.5, col: 1.5 },
+    { row: 13.5, col: 4.5 }
+  ],
+  yellow: [
+    { row: 10.5, col: 10.5 },
+    { row: 10.5, col: 13.5 },
+    { row: 13.5, col: 10.5 },
+    { row: 13.5, col: 13.5 }
+  ]
+};
+
+export const CENTER = { row: 7, col: 7 };
+
+// ── Grid → board units ────────────────────────────────────────────────
+
+/** A grid cell (row, col; may be fractional for yards) as a board-unit point (x right, y up, centred). */
+export function cellPoint(row: number, col: number): [number, number] {
+  return [-0.5 + (col + 0.5) / GRID, 0.5 - (row + 0.5) / GRID];
+}
+
+// ── Layout (view points) ──────────────────────────────────────────────
+
+const SCOREBOARD_HEIGHT = 82;
+const CONTROLS_HEIGHT = 110;
+const TOP_EXTENT = 0.5 + RIM;
+const BOTTOM_EXTENT = -DIE_Y + DIE_SIZE * 0.75;
+
+export type Layout = { width: number; height: number; size: number; centerY: number };
+
+export function getLayout(width: number, height: number, offset: number): Layout {
+  const cos = Math.cos(TILT);
+  const top = getScoreBoardTop(offset) + SCOREBOARD_HEIGHT;
+  const room = Math.max(200, height - top - CONTROLS_HEIGHT);
+  // Follow the shared game width, including side margins and the board's frame.
+  const boardWidth = gameWidthFor(width);
+  const size = Math.min(boardWidth / (1 + RIM * 2), room / ((TOP_EXTENT + BOTTOM_EXTENT) * cos));
+  const middle = top + room / 2;
+  // On screen the board's far edge is TOP_EXTENT above its centre and the die's edge BOTTOM_EXTENT below,
+  // so the centre sits above the middle by half their difference
+  return { width, height, size, centerY: middle - ((BOTTOM_EXTENT - TOP_EXTENT) / 2) * size * cos };
+}
+
+/** Where a point on (or `z` above) the board, in board units, appears in the view. */
+export function toView(l: Layout, x: number, y: number, z = 0): [number, number] {
+  return project({ width: l.width, height: l.height, centerY: l.centerY, tilt: TILT }, x * l.size, y * l.size, z * l.size);
+}

package/src/games/ludo-king/LudoKingGame.ts

@@ -0,0 +1,326 @@
+// Ludo King's play, with no React: build a game with `createGame`, give it a layout, `start` it and
+// `tick` it every frame. You (green) tap the die to roll, then tap a token to move it; the AI (red)
+// takes its turn on the game's own clock. A six, a capture or getting a token home earns another roll;
+// three sixes lose the turn. First to get all four tokens home wins.
+import { type Camera, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import {
+  AI_THINK,
+  CANT_MOVE_DELAY,
+  HOME_YARDS,
+  HOP_TIME,
+  type Layout,
+  MAX_SIXES,
+  MOVE_DELAY,
+  NEXT_TURN_DELAY,
+  PENALTY_DELAY,
+  type PlayerColor,
+  ROLL_TIME
+} from './LudoKingConstants';
+import {
+  calculateScore,
+  canMove,
+  createPlayers,
+  getWinner,
+  isFinished,
+  isGameOver,
+  journey,
+  movableTokens,
+  moveToken,
+  type Player,
+  rollDice,
+  selectAIMove,
+  type Token,
+  tokenCell
+} from './LudoKingRules';
+import {
+  aimCamera,
+  bobToken,
+  buildScene,
+  captureBurst,
+  confetti,
+  finishBurst,
+  hopToken,
+  placeToken,
+  removeScene,
+  rollDie,
+  type Scene,
+  setSceneTheme,
+  showHints,
+  showRollHint
+} from './LudoKingScene';
+
+export type Phase = 'ready' | 'playing' | 'over';
+export type Turn = 0 | 1;
+/** 'rolling' waits for your die tap, 'await' for your token tap, others animate or are the AI's. */
+type Stage = 'rolling' | 'await' | 'busy' | 'thinking';
+export type GameEvent = 'tap' | 'roll' | 'six' | 'penalty' | 'cantMove' | 'move' | 'capture' | 'finish';
+
+const WORLD_CAPACITY = 700;
+const MAX_STEP = 0.1;
+
+export function createGame(theme: GameTheme) {
+  const world = new World(WORLD_CAPACITY);
+  const camera: Camera = { eye: [0, 0, 240], target: [0, 0, 0], fov: 1, ortho: 1 };
+  const players = createPlayers('green', ['red']);
+  const g = {
+    world,
+    camera,
+    theme,
+    layout: null as Layout | null,
+    scene: null as Scene | null,
+    phase: 'ready' as Phase,
+    players,
+    turn: 0 as Turn,
+    dice: 0,
+    stage: 'rolling' as Stage,
+    sixes: 0,
+    /** The score lives in the engine (Rust). */
+    get score() {
+      return world.scoreboard.score;
+    },
+    won: false,
+    onPhase: (_p: Phase) => {},
+    onFinished: (_you: number, _ai: number) => {},
+    onScore: (_s: number) => {},
+    onTurn: (_t: Turn) => {},
+    onEvent: (_e: GameEvent, _who: Turn) => {}
+  };
+  world.scoreboard.reset();
+  return g;
+}
+export type Game = ReturnType<typeof createGame>;
+
+const after = (g: Game, seconds: number, run: () => void) => g.world.after(seconds, run);
+const current = (g: Game) => g.players[g.turn]!;
+
+const tokenIdsOf = (players: Player[]) => players.flatMap((p) => p.tokens.map((t) => ({ id: t.id, color: p.color })));
+
+// ── Scene ─────────────────────────────────────────────────────────────
+
+export function setLayout(g: Game, l: Layout) {
+  if (g.scene) removeScene(g.world, g.scene);
+  g.layout = l;
+  aimCamera(g.camera, l);
+  g.scene = buildScene(g.world, l, g.theme, tokenIdsOf(g.players));
+  arrange(g);
+  idle(g);
+}
+
+export function setTheme(g: Game, theme: GameTheme) {
+  g.theme = theme;
+  if (g.scene) setSceneTheme(g.world, g.scene, theme);
+}
+
+/** Snaps every token to its cell, nudging those that share one apart. */
+function arrange(g: Game) {
+  const { layout: l, scene: s } = g;
+  if (!l || !s) return;
+  const groups = new Map<string, { id: string }[]>();
+  for (const p of g.players)
+    for (const t of p.tokens) {
+      const c = tokenCell(t);
+      const key = `${c.row},${c.col}`;
+      (groups.get(key) ?? groups.set(key, []).get(key)!).push({ id: t.id });
+    }
+  for (const [key, members] of groups) {
+    const [row, col] = key.split(',').map(Number) as [number, number];
+    members.forEach((m, i) => placeToken(g.world, l, s, m.id, { row, col }, members.length > 1 ? (i - (members.length - 1) / 2) * 0.022 : 0));
+  }
+}
+
+/** Shows the roll hint and bobs the player to move. */
+function idle(g: Game) {
+  const { layout: l, scene: s } = g;
+  if (!l || !s) return;
+  const playing = g.phase === 'playing';
+  showRollHint(g.world, l, s, playing && g.stage === 'rolling' && g.turn === 0);
+  if (playing && (g.stage === 'rolling' || g.stage === 'thinking' || g.stage === 'await'))
+    bobToken(
+      g.world,
+      l,
+      s,
+      current(g).tokens.map((t) => t.id)
+    );
+  else bobToken(g.world, l, s, []);
+  if (playing && g.stage === 'await' && g.turn === 0) {
+    const cells = movableTokens(current(g), g.dice).map((t) => tokenCell(t));
+    showHints(g.world, l, s, cells);
+  } else showHints(g.world, l, s, []);
+}
+
+// ── Run ───────────────────────────────────────────────────────────────
+
+export function start(g: Game) {
+  if (g.phase !== 'ready') return;
+  g.phase = 'playing';
+  g.onPhase('playing');
+  beginTurn(g);
+}
+
+export function reset(g: Game) {
+  g.world.cancelTimers();
+  g.players = createPlayers('green', ['red']);
+  g.turn = 0;
+  g.dice = 0;
+  g.stage = 'rolling';
+  g.sixes = 0;
+  g.world.scoreboard.reset();
+  g.won = false;
+  g.phase = 'ready';
+  arrange(g);
+  idle(g);
+  g.onFinished(0, 0);
+  g.onScore(0);
+  g.onTurn(0);
+  g.onPhase('ready');
+}
+
+export function dispose(g: Game) {
+  g.world.dispose();
+}
+
+export function tick(g: Game, dt: number) {
+  if (g.world.isDisposed) return;
+  g.world.update(Math.min(dt, MAX_STEP));
+}
+
+// ── Taps ──────────────────────────────────────────────────────────────
+
+export function tap(g: Game, x: number, y: number) {
+  if (g.phase !== 'playing' || !g.scene) return;
+  const hit = g.world.pick(x, y);
+  if (!hit) return;
+  if (hit.entity === g.scene.die) {
+    if (g.stage === 'rolling' && g.turn === 0) {
+      g.onEvent('tap', 0);
+      roll(g);
+    }
+    return;
+  }
+  const id = g.scene.tokenAt.get(hit.entity);
+  if (!id || g.stage !== 'await' || g.turn !== 0) return;
+  const token = current(g).tokens.find((t) => t.id === id);
+  if (token && canMove(token, g.dice)) applyMove(g, token);
+}
+
+// ── A turn ────────────────────────────────────────────────────────────
+
+function beginTurn(g: Game) {
+  g.dice = 0;
+  if (current(g).isAI) {
+    g.stage = 'thinking';
+    idle(g);
+    after(g, AI_THINK, () => roll(g));
+  } else {
+    g.stage = 'rolling';
+    idle(g);
+  }
+}
+
+function roll(g: Game) {
+  const { layout: l, scene: s } = g;
+  if (!l || !s) return;
+  g.stage = 'busy';
+  idle(g);
+  const value = rollDice();
+  g.onEvent('roll', g.turn);
+  rollDie(g.world, l, s, value, ROLL_TIME, () => g.world.isDisposed);
+  after(g, ROLL_TIME, () => rolled(g, value));
+}
+
+function rolled(g: Game, value: number) {
+  g.dice = value;
+  g.sixes = value === 6 ? g.sixes + 1 : 0;
+  if (g.sixes >= MAX_SIXES) {
+    g.onEvent('penalty', g.turn);
+    g.sixes = 0;
+    after(g, PENALTY_DELAY, () => passTurn(g));
+    return;
+  }
+  if (value === 6) g.onEvent('six', g.turn);
+  const movable = movableTokens(current(g), value);
+  if (!movable.length) {
+    if (g.turn === 0) g.onEvent('cantMove', 0);
+    after(g, CANT_MOVE_DELAY, () => passTurn(g));
+    return;
+  }
+  if (current(g).isAI) {
+    after(g, MOVE_DELAY, () => {
+      const pick = selectAIMove(current(g), value, g.players);
+      if (pick) applyMove(g, pick);
+      else passTurn(g);
+    });
+  } else {
+    g.stage = 'await';
+    idle(g);
+  }
+}
+
+function applyMove(g: Game, token: Token) {
+  const { layout: l, scene: s } = g;
+  if (!l || !s) return;
+  g.stage = 'busy';
+  const who = g.turn;
+  const value = g.dice;
+  const { moved, captured } = moveToken(token, value, g.players);
+  const justFinished = isFinished(moved) && !isFinished(token);
+  const capturedCell = captured ? tokenCell(captured) : null;
+
+  const player = current(g);
+  player.tokens = player.tokens.map((t) => (t.id === token.id ? moved : t));
+  player.finishedTokens = player.tokens.filter(isFinished).length;
+  if (captured) {
+    const opp = g.players.find((p) => p.color === captured.player)!;
+    opp.tokens = opp.tokens.map((t) => (t.id === captured.id ? { ...t, progress: -1 } : t));
+  }
+  g.world.scoreboard.set(calculateScore(g.players[0]!));
+  g.onScore(g.score);
+  g.onFinished(g.players[0]!.finishedTokens, g.players[1]!.finishedTokens);
+
+  const cells = journey(token, value);
+  const time = Math.max(1, cells.length - 1) * HOP_TIME;
+  showHints(g.world, l, s, []);
+  bobToken(g.world, l, s, []);
+  hopToken(g.world, l, s, token.id, cells, time);
+  g.onEvent(captured ? 'capture' : justFinished ? 'finish' : 'move', who);
+
+  after(g, time, () => {
+    const scn = g.scene;
+    const lay = g.layout;
+    if (!scn || !lay) return;
+    if (captured && capturedCell) {
+      captureBurst(g.world, lay, capturedCell);
+      const yardIdx = Number(captured.id.split('-')[1]);
+      const yard = HOME_YARDS[captured.player as PlayerColor][yardIdx]!;
+      placeToken(g.world, lay, scn, captured.id, yard, 0);
+    }
+    if (justFinished) finishBurst(g.world, lay);
+    arrange(g);
+
+    if (isGameOver(g.players)) {
+      const winner = getWinner(g.players);
+      g.won = winner?.color === 'green';
+      end(g);
+      if (winner) confetti(g.world, lay, winner.color);
+      return;
+    }
+    const extra = value === 6 || justFinished || !!captured;
+    after(g, NEXT_TURN_DELAY, () => (extra ? beginTurn(g) : passTurn(g)));
+  });
+}
+
+function passTurn(g: Game) {
+  if (g.phase !== 'playing') return;
+  g.turn = (g.turn === 0 ? 1 : 0) as Turn;
+  g.sixes = 0;
+  g.onTurn(g.turn);
+  beginTurn(g);
+}
+
+function end(g: Game) {
+  g.phase = 'over';
+  g.stage = 'busy';
+  idle(g);
+  g.onPhase('over');
+}