@nayan-ui/games 1.20.0 → 1.21.0

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

@@ -1,86 +0,0 @@
-// 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

@@ -1,212 +0,0 @@
-// 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

@@ -1,326 +0,0 @@
-// 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');
-}