@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/snake-3d/Snake3DRules.ts

@@ -1,116 +0,0 @@
-// Snake 3D's rules, with no React or engine: the 20 x 20 grid, the snake (head first), food, and one
-// move of the snake. Ported step for step from the original version's UI-thread physics
-// (games/snake-3d/Snake3DPhysics.ts), with the same random draws in the same order.
-
-export const GRID = 20;
-export const INITIAL_LENGTH = 3;
-/** Points per food: the original base points x its "medium" multiplier of 2. */
-export const POINTS_PER_FOOD = 1000;
-export const POINTS_PER_SPECIAL_FOOD = 2000;
-export const SPECIAL_FOOD_CHANCE = 0.15;
-export const SPECIAL_FOOD_DURATION = 10; // seconds before an uneaten bonus turns into normal food
-const MAX_FOOD_ATTEMPTS = 100;
-
-export type Direction = 'UP' | 'DOWN' | 'LEFT' | 'RIGHT';
-export const VECTORS: Record<Direction, [number, number]> = { UP: [0, -1], DOWN: [0, 1], LEFT: [-1, 0], RIGHT: [1, 0] };
-const OPPOSITE: Record<Direction, Direction> = { UP: 'DOWN', DOWN: 'UP', LEFT: 'RIGHT', RIGHT: 'LEFT' };
-
-/** expiresAt: game-clock seconds (bonus food only). */
-export type Food = { id: number; x: number; y: number; isSpecial: boolean; expiresAt?: number };
-
-/** The snake's cells, head first, flattened [x0, y0, x1, y1, …]. */
-export type Snake = number[];
-
-/** In the middle of the grid, heading right. */
-export function initialSnake(): Snake {
-  const c = Math.floor(GRID / 2);
-  const s: Snake = [];
-  for (let i = 0; i < INITIAL_LENGTH; i++) s.push(c - i, c);
-  return s;
-}
-
-const onSnake = (x: number, y: number, s: Snake) => {
-  for (let i = 0; i < s.length; i += 2) if (s[i] === x && s[i + 1] === y) return true;
-  return false;
-};
-
-/** A random cell off the snake (giving up after 100 tries, as before). */
-export function generateFood(s: Snake, isSpecial: boolean, id: number, now: number): Food {
-  let x = 0;
-  let y = 0;
-  let attempts = 0;
-  do {
-    x = Math.floor(Math.random() * GRID);
-    y = Math.floor(Math.random() * GRID);
-    attempts++;
-  } while (attempts < MAX_FOOD_ATTEMPTS && onSnake(x, y, s));
-  const food: Food = { id, x, y, isSpecial };
-  if (isSpecial) food.expiresAt = now + SPECIAL_FOOD_DURATION;
-  return food;
-}
-
-export type SnakeState = { snake: Snake; direction: Direction; nextDirection: Direction; turns: Direction[]; food: Food | null; nextFoodId: number };
-
-export const freshState = (): SnakeState => ({
-  snake: initialSnake(),
-  direction: 'RIGHT',
-  nextDirection: 'RIGHT',
-  turns: [],
-  food: null,
-  nextFoodId: 1
-});
-
-/** Buffer up to two turns in swipe order; refuse duplicates and reversals against the queued heading. */
-export function turn(st: SnakeState, d: Direction) {
-  const heading = st.turns[st.turns.length - 1] ?? st.direction;
-  if (st.turns.length >= 2 || d === heading || OPPOSITE[heading] === d) return;
-  st.turns.push(d);
-  st.nextDirection = st.turns[0]!;
-}
-
-export type StepResult = { crash: boolean; ate: Food | null; newFood: Food | null; grew: boolean };
-
-/** One move: the head steps on, the tail follows; walls and the body kill; food grows it by one. */
-export function step(st: SnakeState, now: number): StepResult {
-  const dir = st.nextDirection;
-  st.turns.shift();
-  st.nextDirection = st.turns[0] ?? dir;
-  const s = st.snake;
-  const [vx, vy] = VECTORS[dir];
-  const hx = s[0]! + vx;
-  const hy = s[1]! + vy;
-  const moved: Snake = new Array(s.length);
-  moved[0] = hx;
-  moved[1] = hy;
-  for (let i = 2; i < s.length; i++) moved[i] = s[i - 2]!;
-  // The head turns to face the fatal way even on a crash, as before
-  st.direction = dir;
-  const wall = hx < 0 || hx >= GRID || hy < 0 || hy >= GRID;
-  let self = false;
-  if (!wall)
-    for (let i = 2; i < moved.length; i += 2)
-      if (moved[i] === hx && moved[i + 1] === hy) {
-        self = true;
-        break;
-      }
-  if (wall || self) return { crash: true, ate: null, newFood: null, grew: false };
-
-  const food = st.food;
-  let next = moved;
-  let newFood: Food | null = null;
-  let ate: Food | null = null;
-  if (food && hx === food.x && hy === food.y) {
-    // Grow: a new tail segment on the tail's cell
-    next = moved.slice();
-    next.push(moved[moved.length - 2]!, moved[moved.length - 1]!);
-    ate = food;
-    const special = Math.random() < SPECIAL_FOOD_CHANCE;
-    newFood = generateFood(next, special, st.nextFoodId++, now);
-  } else if (food && food.isSpecial && food.expiresAt !== undefined && now > food.expiresAt) {
-    // An uneaten bonus turns into normal food somewhere else
-    newFood = generateFood(moved, false, st.nextFoodId++, now);
-  }
-  st.snake = next;
-  if (newFood) st.food = newFood;
-  return { crash: false, ate, newFood, grew: ate !== null };
-}

package/src/games/snake-3d/Snake3DScene.ts

@@ -1,322 +0,0 @@
-import {
-  type Camera,
-  type Color,
-  effects,
-  type Entity,
-  extrude,
-  merge,
-  type Model,
-  type MutableQuat,
-  Path,
-  quat,
-  shapeGeometry,
-  type Vec3,
-  type World
-} from '@nayan-ui/engine';
-import type { GameTheme } from '../../services/ThemeService';
-import { setBackdropTheme, spawnBackdrop } from '../shared/EngineBackdrop';
-import { getFruits } from '../shared/EngineFruits';
-import { cacheGameAsset, createGameMesh as createShape } from '../shared/EngineMeshes';
-import { placeTiltedBackdrop } from '../shared/EngineTilt';
-// Everything Snake 3D draws: the board (themed, as the original board) checkered and walled in by a raised
-// rim, the snake (glossy beads from a big head with eyes and a flicking tongue down to a thin tail,
-// joined so it reads as one body, gliding cell to cell), and the food: a red apple, or a spinning gold
-// star for a bonus. Seen from a little in front of straight down (shared/EngineTilt: an orthographic
-// camera leaning back, one world unit per point). Every bead is the built-in sphere (one instanced draw).
-import { toColor } from '../shared/EngineUtils';
-import { COLORS, gridPoint, type Layout } from './Snake3DConstants';
-import { sampleSnakeMotion } from './Snake3DMotion';
-import { type Direction, type Food, GRID } from './Snake3DRules';
-
-const meshes = new Map<string, Model>();
-const cached = (key: string, build: () => Model) => {
-  let m = meshes.get(key);
-  if (!m) {
-    m = cacheGameAsset('snake-3d/Snake3DScene:' + key, build);
-    meshes.set(key, m);
-  }
-  return m;
-};
-const BOARD_DEPTH = 10;
-const BACKDROP_DEPTH = 30;
-const STAND_UP = quat.x(Math.PI / 2);
-const headTurn: MutableQuat = [0, 0, 0, 1];
-const HEADING: Record<Direction, number> = { RIGHT: 0, UP: Math.PI / 2, LEFT: Math.PI, DOWN: -Math.PI / 2 };
-
-const panelMesh = (w: number, radius: number) =>
-  cached(`s3-panel:${w}:${radius}`, () =>
-    createShape(extrude(new Path().addRoundedRect(-w / 2, -w / 2, w, w, radius), { depth: BOARD_DEPTH }), { shine: 0.2 })
-  );
-/** Every other cell of the board, a hair above it: one mesh. */
-const checkerMesh = () =>
-  cached('s3-checker', () => {
-    const parts = [];
-    for (let y = 0; y < GRID; y++)
-      for (let x = 0; x < GRID; x++)
-        if ((x + y) % 2)
-          parts.push({ geometry: shapeGeometry('cube'), position: [x + 0.5 - GRID / 2, GRID / 2 - y - 0.5, 0] as Vec3, scale: [1, 1, 0.02] as Vec3 });
-    return createShape(merge(parts), { center: false });
-  });
-/** The walls as one continuous frame round the grid: a rounded outside, a square inside, `h` tall. */
-const rimMesh = (size: number, rim: number, radius: number, h: number) =>
-  cached(`s3-rim:${size.toFixed(1)}:${rim.toFixed(1)}:${radius}:${h.toFixed(1)}`, () => {
-    const outer = size + rim * 2;
-    return createShape(
-      extrude(new Path().addRoundedRect(-outer / 2, -outer / 2, outer, outer, radius).addRect(-size / 2, -size / 2, size, size), {
-        depth: h,
-        fillRule: 'evenodd'
-      }),
-      { shine: 0.2 }
-    );
-  });
-const starMesh = () => cached('s3-star', () => createShape(extrude(new Path().addStar(0, 0, 0.5, 0.22), { depth: 0.28 }), { shine: 0.7 }));
-
-// ── Spawning ──────────────────────────────────────────────────────────
-
-export type Scene = {
-  backdrop: Entity;
-  board: Entity[];
-  /** The head (eyes and tongue attached), the beads behind it, and the joints between them. */
-  head: Entity;
-  tongue: Entity;
-  beads: Entity[];
-  joints: Entity[];
-  food: Entity | null;
-  foodId: number;
-};
-
-const lerp = (a: number, b: number, t: number) => a + (b - a) * t;
-const mix = (a: Color, b: Color, t: number): Color => [lerp(a[0], b[0], t), lerp(a[1], b[1], t), lerp(a[2], b[2], t), 1];
-/** A bead's size (of a cell), from the head (0) to the tail (1): full through the body, tapering to a fine tail. */
-const beadSize = (t: number) => (t < 0.6 ? lerp(0.8, 0.72, t / 0.6) : lerp(0.72, 0.3, ((t - 0.6) / 0.4) ** 1.3));
-/** Its color: head to tail through the body color, with a dark scale band every third bead. */
-const beadColor = (t: number, i: number) => {
-  const c = t < 0.5 ? mix(toColor(COLORS.HEAD), toColor(COLORS.BODY), t * 2) : mix(toColor(COLORS.BODY), toColor(COLORS.TAIL), t * 2 - 1);
-  const k = i % 3 === 0 ? 0.68 : 1;
-  return [c[0] * k, c[1] * k, c[2] * k, 1] as Color;
-};
-/** The body's beads are a little flattened, as a snake lies low on the ground. */
-const FLAT = 0.72;
-const HEAD_SCALE = (d: number): Vec3 => [d * 1.25, d * 0.95, d * 0.62];
-
-function spawnBoard(world: World, l: Layout, theme: GameTheme): Entity[] {
-  const out: Entity[] = [];
-  const add = (o: Parameters<World['spawn']>[0]) => out.push(world.spawn({ pickable: false, ...o }));
-  const classic = theme.mode === 'classic';
-  const rim = l.cell * 0.5;
-  add({
-    mesh: panelMesh(l.size + rim * 2, classic ? 12 : 8),
-    position: [0, 0, -BOARD_DEPTH / 2],
-    color: toColor(classic ? COLORS.CLASSIC_BOARD : theme.BOARD.SURFACE)
-  });
-  add({ mesh: checkerMesh(), position: [0, 0, 0.05], scale: l.cell, color: toColor(classic ? COLORS.CLASSIC_DARK : theme.BOARD.CELL_EMPTY) });
-  // The walls: a low rim round the grid
-  const h = l.cell * 0.55;
-  const rimColor = toColor(classic ? COLORS.CLASSIC_RIM : theme.BOARD.BORDER);
-  add({ mesh: rimMesh(l.size, rim, classic ? 12 : 8, h), position: [0, 0, h / 2], color: rimColor });
-  return out;
-}
-
-export function buildScene(world: World, l: Layout, theme: GameTheme): Scene {
-  const backdrop = spawnBackdrop(world, l.width, l.height, -BACKDROP_DEPTH, theme);
-  placeTiltedBackdrop(world, backdrop, l, BACKDROP_DEPTH);
-  const d = l.cell * 0.9;
-  // A wide, flat head (pointing +x): in the head's own units it's one unit across
-  const head = world.spawn({ mesh: 'sphere', scale: HEAD_SCALE(d), color: toColor(COLORS.HEAD), pickable: false });
-  for (const s of [-1, 1]) {
-    // Eyes set on the sides of the head, with upright slit pupils
-    world.spawn({
-      mesh: 'sphere',
-      parent: head,
-      position: [0.12, s * 0.3, 0.26],
-      scale: [0.24, 0.2, 0.22],
-      color: toColor(COLORS.EYE),
-      pickable: false
-    });
-    world.spawn({
-      mesh: 'sphere',
-      parent: head,
-      position: [0.2, s * 0.33, 0.33],
-      scale: [0.05, 0.13, 0.1],
-      color: toColor(COLORS.PUPIL),
-      pickable: false
-    });
-    // Nostrils on the snout
-    world.spawn({
-      mesh: 'sphere',
-      parent: head,
-      position: [0.47, s * 0.09, 0.22],
-      scale: [0.05, 0.04, 0.03],
-      color: [0.05, 0.05, 0.05, 1],
-      pickable: false
-    });
-  }
-  // A forked tongue: a stem and two tips, hidden until it flicks
-  const tongue = world.spawn({ mesh: 'none', parent: head, position: [0.5, 0, -0.05], scale: [0, 1, 1], pickable: false });
-  const red = toColor(COLORS.TONGUE);
-  world.spawn({ mesh: 'cube', parent: tongue, position: [0.18, 0, 0], scale: [0.36, 0.05, 0.03], color: red, pickable: false });
-  for (const s of [-1, 1])
-    world.spawn({
-      mesh: 'cube',
-      parent: tongue,
-      position: [0.42, s * 0.05, 0],
-      rotation: quat.z(s * 0.5),
-      scale: [0.16, 0.04, 0.03],
-      color: red,
-      pickable: false
-    });
-  return { backdrop, board: spawnBoard(world, l, theme), head, tongue, beads: [], joints: [], food: null, foodId: -1 };
-}
-
-export function removeScene(world: World, s: Scene) {
-  for (const e of [s.backdrop, ...s.board, s.head, ...s.beads, ...s.joints, s.food]) if (e != null) world.despawn(e);
-}
-
-export function setSceneTheme(world: World, l: Layout, s: Scene, theme: GameTheme) {
-  setBackdropTheme(world, s.backdrop, theme);
-  for (const e of s.board) world.despawn(e);
-  s.board = spawnBoard(world, l, theme);
-}
-
-// ── The snake ─────────────────────────────────────────────────────────
-
-/**
- * Every bead follows the head's rounded turns between cells, `t` of the way (0..1).
- * `prev` and `cur` are the cells (flattened x, y), head first.
- */
-export function drawSnake(world: World, l: Layout, s: Scene, prev: number[], cur: number[], t: number) {
-  const updates = world.transforms;
-  const n = cur.length / 2;
-  // Enough beads and joints for the body (the head is its own)
-  while (s.beads.length < n - 1) s.beads.push(world.spawn({ mesh: 'sphere', pickable: false }));
-  while (s.joints.length < n - 1) s.joints.push(world.spawn({ mesh: 'sphere', pickable: false }));
-  for (let i = n - 1; i < s.beads.length; i++) updates.scale(s.beads[i]!, 0);
-  for (let i = n - 1; i < s.joints.length; i++) updates.scale(s.joints[i]!, 0);
-  let px = 0;
-  let py = 0;
-  let pr = 0;
-  for (let i = 0; i < n; i++) {
-    const [x, y, dx, dy] = sampleSnakeMotion(prev, cur, i, t);
-    const [wx, wy] = gridPoint(l, x + 0.5, y + 0.5);
-    const k = n > 1 ? i / (n - 1) : 0;
-    const r = (i === 0 ? 0.45 : beadSize(k) / 2) * l.cell;
-    if (i === 0) {
-      updates.position(s.head, wx, wy, r * 0.75);
-      if (dx || dy) {
-        const q = quat.z(Math.atan2(-dy, dx), headTurn);
-        updates.rotation(s.head, q[0], q[1], q[2], q[3]);
-      }
-    } else {
-      const bead = s.beads[i - 1]!;
-      const c = beadColor(k, i);
-      updates.position(bead, wx, wy, r * FLAT);
-      updates.scale(bead, r * 2, r * 2, r * 2 * FLAT);
-      updates.color(bead, c[0], c[1], c[2], c[3] ?? 1);
-      // A joint between this bead and the one ahead, so the body reads as one smooth length
-      const jr = (r + pr) / 2;
-      const joint = s.joints[i - 1]!;
-      const jc = beadColor(k, i + 1);
-      updates.position(joint, (wx + px) / 2, (wy + py) / 2, jr * FLAT * 0.95);
-      updates.scale(joint, jr * 2, jr * 2, jr * 2 * FLAT * 0.95);
-      updates.color(joint, jc[0], jc[1], jc[2], jc[3] ?? 1);
-    }
-    px = wx;
-    py = wy;
-    pr = r;
-  }
-  updates.flush();
-}
-
-/** The head turns to face the way it's heading. */
-export function faceHead(world: World, s: Scene, d: Direction) {
-  world.set(s.head, { rotation: quat.z(HEADING[d]) });
-}
-
-/** The tongue flicks out now and then while it's moving. */
-export function flick(world: World, s: Scene) {
-  world.animate(s.tongue, [{ scale: [1, 1, 1], at: 0.35 }, { scale: [0.85, 1, 1], at: 0.6 }, { scale: [0, 1, 1] }], { duration: 0.32 });
-}
-
-/** A fresh snake's look (a new game or the preview). */
-export function resetSnake(world: World, l: Layout, s: Scene) {
-  const d = l.cell * 0.9;
-  world.stopAnimation(s.head);
-  world.set(s.head, { scale: HEAD_SCALE(d), color: toColor(COLORS.HEAD), rotation: quat.z(0) });
-}
-
-/** Food eaten: the head gulps and the food bursts. */
-export function gulp(world: World, l: Layout, s: Scene, food: Food) {
-  const d = l.cell * 0.9;
-  const [hx, hy, hz] = HEAD_SCALE(d);
-  world.animate(s.head, [{ scale: [hx * 1.2, hy * 1.25, hz * 1.2], at: 0.3 }, { scale: HEAD_SCALE(d) }], { duration: 0.3 });
-  const [x, y] = gridPoint(l, food.x + 0.5, food.y + 0.5);
-  const position: Vec3 = [x, y, l.cell * 0.5];
-  if (food.isSpecial)
-    effects.sparkle(world, {
-      position,
-      count: 26,
-      size: l.cell * 0.14,
-      speed: l.cell * 5,
-      lifetime: 0.6,
-      gravity: -l.cell * 6,
-      colors: [toColor('#FFD54F'), toColor(COLORS.SPECIAL), [1, 1, 1, 1]]
-    });
-  else
-    effects.splash(world, {
-      position,
-      count: 14,
-      size: l.cell * 0.14,
-      speed: l.cell * 5,
-      lifetime: 0.5,
-      gravity: -l.cell * 10,
-      colors: [toColor('#E53935'), toColor('#FFCDD2')]
-    });
-}
-
-/** A crash: the snake flushes red, a jolt runs through the board. */
-export function crash(world: World, l: Layout, s: Scene, camera: Camera) {
-  const red = toColor(COLORS.CRASH);
-  world.animate(s.head, { color: red }, { duration: 0.2 });
-  for (const e of [...s.beads, ...s.joints]) world.animate(e, { color: red }, { duration: 0.35 });
-  world.animate(s.head, { shake: l.cell * 0.25 }, { duration: 0.4 });
-  camera.shake = l.cell * 0.35;
-}
-
-// ── Food ──────────────────────────────────────────────────────────────
-
-/** The food on the board (an apple, or a spinning gold star for a bonus), or none. */
-export function placeFood(world: World, l: Layout, s: Scene, food: Food | null) {
-  if (food && food.id === s.foodId) return;
-  if (s.food != null) world.despawn(s.food);
-  s.food = null;
-  s.foodId = food ? food.id : -1;
-  if (!food) return;
-  const [x, y] = gridPoint(l, food.x + 0.5, food.y + 0.5);
-  const size = l.cell * 0.8;
-  const root = world.spawn({
-    mesh: 'none',
-    position: [x, y, size / 2],
-    bob: { amplitude: [0, 0, l.cell * 0.12], speed: 4 },
-    spin: food.isSpecial ? [0, 0, 2.5] : [0, 0, 0],
-    pickable: false
-  });
-  if (food.isSpecial) {
-    world.spawn({ mesh: starMesh(), parent: root, rotation: STAND_UP, scale: size * 1.15, color: toColor(COLORS.SPECIAL), pickable: false });
-    world.spawn({ mesh: 'sphere', parent: root, scale: size * 0.55, color: [2, 1.6, 0.5, 0.35], pickable: false });
-  } else {
-    const fruit = getFruits().apple;
-    // The apple stands up off the board (its own y up becomes the board's z)
-    const c = fruit.center;
-    world.spawn({
-      mesh: fruit.whole,
-      parent: root,
-      rotation: STAND_UP,
-      position: [-c[0] * size, c[2] * size, -c[1] * size],
-      scale: size,
-      pickable: false
-    });
-  }
-  world.set(root, { scale: 0.01 });
-  world.animate(root, { scale: 1 }, { duration: 0.25, easing: 'back' });
-  s.food = root;
-}

package/src/games/snakes-and-ladders/SnakesAndLadders.tsx

@@ -1,87 +0,0 @@
-// Snakes and Ladders' screen, on the Nayan engine: the board, snakes, ladders, pawns and die are one 3D
-// scene (an orthographic camera leaning back over a wooden board), under Playtura's scoreboard,
-// controls and modals. The rules and turns are in SnakesAndLaddersGame.ts, what it draws in
-// SnakesAndLaddersScene.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. Hops, slides and the die 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 './SnakesAndLaddersConstants';
-import { createGame, dispose, type GameEvent, reset, setLayout, setTheme, start, tap, tick, type Turn } from './SnakesAndLaddersGame';
-
-const SOUNDS = GAME_SOUNDS.SNAKES_AND_LADDERS;
-
-/** 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 },
-  snake: { sound: 'SNAKE', haptic: HapticType.ERROR },
-  ladder: { sound: 'LADDER', haptic: HapticType.SUCCESS }
-};
-
-export const SnakesAndLadders = engineGame(GAME_IDS.SNAKES_AND_LADDERS, (props) => {
-  const [positions, setPositions] = useLiveState<[number, number]>([0, 0]);
-  const [turn, setTurn] = useLiveState<Turn>(0);
-  const [score, setScore] = useLiveState(0);
-
-  // Win or lose when someone reaches 100
-  const { status, screen, gameOver } = useEngineGame(props, {
-    gameId: GAME_IDS.SNAKES_AND_LADDERS,
-    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.onPositions = (you, ai) => setPositions([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(positions[0]), PLAYER_COLOR),
-        textColumn(turn === 0 ? 'YOUR TURN' : 'AI TURN', score.toLocaleString()),
-        textColumn('AI', String(positions[1]), AI_COLOR)
-      ]}
-      subtext="Race to 100!"
-      gameOver={gameOver({
-        title: status === 'win' ? 'YOU WON!' : 'YOU LOST!',
-        message: status === 'win' ? 'You reached 100 first!' : 'AI reached 100 first!',
-        scoreLabel: status === 'win' ? 'You Won!' : 'You Lost',
-        score,
-        buttonText: status === 'win' ? 'Play Again!' : 'Try Again!'
-      })}
-    />
-  );
-});

package/src/games/snakes-and-ladders/SnakesAndLaddersConstants.ts

@@ -1,136 +0,0 @@
-// Snakes and Ladders' rules, board, timings and layout. The board, rules and scoring match the original
-// version (games/snakes-and-ladders), so scores carry over.
-import { getScoreBoardTop } from '../shared/EngineHud';
-import { project } from '../shared/EngineTilt';
-import { frontLight, gameWidthFor } from '../shared/EngineUtils';
-
-// ── Rules ─────────────────────────────────────────────────────────────
-
-export const BOARD_SIZE = 10; // 10 x 10 cells
-export const WINNING_POSITION = 100;
-export const MAX_SIXES = 3; // three sixes in a row lose the turn
-
-export type SnakeData = { head: number; tail: number; color: string; accent: string; belly: string };
-export type LadderData = { bottom: number; top: number; color: string; highlight: string };
-
-/** Head (high) to tail (low): land on a head and slide down. */
-export const SNAKES: readonly SnakeData[] = [
-  { head: 16, tail: 6, color: '#43A047', accent: '#1B5E20', belly: '#C5E1A5' },
-  { head: 47, tail: 26, color: '#E53935', accent: '#8E1B1B', belly: '#FFCDD2' },
-  { head: 49, tail: 11, color: '#8E24AA', accent: '#4A148C', belly: '#E1BEE7' },
-  { head: 62, tail: 19, color: '#F9A825', accent: '#5D4037', belly: '#FFF59D' },
-  { head: 72, tail: 54, color: '#F4511E', accent: '#3E2723', belly: '#FFCCBC' },
-  { head: 87, tail: 24, color: '#5E35B1', accent: '#FBC02D', belly: '#D1C4E9' },
-  { head: 93, tail: 73, color: '#7CB342', accent: '#33691E', belly: '#F0F4C3' },
-  { head: 98, tail: 78, color: '#1E88E5', accent: '#0D47A1', belly: '#BBDEFB' }
-];
-
-/** Bottom (low) to top (high): land on a foot and climb. */
-export const LADDERS: readonly LadderData[] = [
-  { bottom: 1, top: 38, color: '#8D5A2B', highlight: '#C08A52' },
-  { bottom: 4, top: 14, color: '#7A4A22', highlight: '#B07A45' },
-  { bottom: 9, top: 31, color: '#8D5A2B', highlight: '#C08A52' },
-  { bottom: 21, top: 42, color: '#7A4A22', highlight: '#B07A45' },
-  { bottom: 28, top: 84, color: '#8D5A2B', highlight: '#C08A52' },
-  { bottom: 36, top: 44, color: '#7A4A22', highlight: '#B07A45' },
-  { bottom: 51, top: 67, color: '#8D5A2B', highlight: '#C08A52' },
-  { bottom: 71, top: 91, color: '#7A4A22', highlight: '#B07A45' },
-  { bottom: 80, top: 99, color: '#8D5A2B', highlight: '#C08A52' }
-];
-
-export const SNAKE_AT: ReadonlyMap<number, SnakeData> = new Map(SNAKES.map((s) => [s.head, s]));
-export const LADDER_AT: ReadonlyMap<number, LadderData> = new Map(LADDERS.map((l) => [l.bottom, l]));
-
-/** Where a roll from `from` ends: past 100 it doesn't move; a snake or ladder at the landing cell is taken. */
-export function landing(from: number, roll: number) {
-  const step = from + roll;
-  if (step > WINNING_POSITION) return { step: from, end: from };
-  return { step, end: SNAKE_AT.get(step)?.tail ?? LADDER_AT.get(step)?.top ?? step };
-}
-
-/** The player's score: 100 a cell, or 10,000 plus 50 for every cell the opponent is short of 100 on a win. */
-export function scoreFor(you: number, opponent: number) {
-  return you === WINNING_POSITION ? 10000 + Math.round((WINNING_POSITION - opponent) * 50) : you * 100;
-}
-
-// ── Colors ────────────────────────────────────────────────────────────
-
-/** Pastel cells, cycling along the diagonals as the original board did. */
-export const CELL_PALETTE = ['#FFF9C4', '#C8E6C9', '#BBDEFB', '#F8BBD0', '#FFE0B2', '#D1C4E9', '#B2EBF2', '#FFCCBC', '#DCEDC8', '#F0F4C3'];
-export const START_CELL = '#E8F5E9';
-export const FINISH_CELL = '#FFF3E0';
-export const NUMBER_COLOR = '#5B4E42';
-export const STAR_NUMBER_COLOR = '#F57F17';
-// The same green (you) and red (the AI) as Ludo King's pawns
-export const PLAYER_COLOR = '#43A047';
-export const AI_COLOR = '#E53935';
-
-// ── Timings (seconds, as the original version's turn) ─────────────────────
-
-export const ROLL_TIME = 0.9; // the die is tossed and bounces to rest
-export const MOVE_DELAY = 0.4; // after the roll, before the token sets off
-export const HOP_TIME = 0.17; // a cell
-export const SLIDE_PAUSE = 0.15; // on a snake's head or a ladder's foot
-export const NEXT_TURN_DELAY = 0.4;
-export const PENALTY_DELAY = 1;
-export const CANT_MOVE_DELAY = 0.5;
-export const AI_DELAY = 0.8;
-
-// ── The scene ─────────────────────────────────────────────────────────
-
-/** The camera leans back this far from straight down, so the board's depth, snakes and pawns read as 3D. */
-export const TILT = 0.35;
-/** Lit from the upper left; surfaces facing up off the board (+z) keep their exact color. */
-export const LIGHT = frontLight([-0.35, 0.3, 1], 0.5);
-
-/** In board units (the board's playing area is 1 across, centred on the origin, y up the board). */
-export const RIM = 0.014; // a slim wooden frame round the cells
-export const TILE_TOP = 0.013; // height of the cells' top face
-export const DIE_SIZE = 0.15;
-export const DIE_Y = -0.5 - RIM - 0.06 - DIE_SIZE / 2; // the die's place below the board
-export const START_X = -0.33; // the start pad, left of the die
-export const START_Z = 0.01; // the start pad's top, where the pawns wait
-export const TOKEN_HEIGHT = 0.062;
-
-// ── Layout (view points) ──────────────────────────────────────────────
-
-const SCOREBOARD_HEIGHT = 82;
-const CONTROLS_HEIGHT = 110;
-const TOP_EXTENT = 0.5 + RIM; // the board's far edge, in board units
-const BOTTOM_EXTENT = -DIE_Y + DIE_SIZE * 0.75; // the die's near edge
-
-export type Layout = {
-  width: number;
-  height: number;
-  /** Points per board unit. */
-  size: number;
-  /** Where the board's centre is in the view. */
-  centerY: number;
-};
-
-/** The board as wide as the game area, centred between the scoreboard and the controls, the die below it. */
-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);
-  // The whole board, its frame included, as wide as the other games' boards at most, and small enough
-  // that the die below it still clears the controls with the board centred
-  const size = Math.min(gameWidthFor(width) / (1 + RIM * 2), room / (2 * Math.max(TOP_EXTENT, BOTTOM_EXTENT) * cos));
-  const middle = top + room / 2;
-  // The board itself centred between the scoreboard and the controls (the die sits below it)
-  return { width, height, size, centerY: middle };
-}
-
-/** 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);
-}
-
-/** A cell's centre in board units: row 1 runs left to right along the bottom, then the rows snake upward. */
-export function cellCenter(cell: number): [number, number] {
-  const i = cell - 1;
-  const row = Math.floor(i / BOARD_SIZE);
-  const along = i % BOARD_SIZE;
-  const col = row % 2 === 0 ? along : BOARD_SIZE - 1 - along;
-  return [-0.5 + (col + 0.5) / BOARD_SIZE, -0.5 + (row + 0.5) / BOARD_SIZE];
-}