@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/chameleon-run/ChameleonRunGame.ts

@@ -1,309 +0,0 @@
-import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
-import type { GameTheme } from '../../services/ThemeService';
-import {
-  BASE_SPEED,
-  type Config,
-  configFor,
-  DRAG_THRESHOLD,
-  MAX_FRAME_SECONDS,
-  MAX_LIVES,
-  type RunColor,
-  SCORE_SYNC,
-  STEP_SECONDS,
-  TRACK_LENGTH
-} from './ChameleonRunConstants';
-import { type Failure, jump, newRun, nextPlatform, platformUnder, type Run, step, switchColor } from './ChameleonRunRules';
-import {
-  buildScene,
-  cheer,
-  clearPlatforms,
-  collectStar,
-  drawScene,
-  frameCamera,
-  hop,
-  land,
-  removeScene,
-  resetChameleon,
-  type Scene,
-  setStride,
-  stumble,
-  tintChameleon,
-  tumble
-} from './ChameleonRunScene';
-
-export type Phase = 'ready' | 'playing' | 'over';
-export type GameEvent = 'jump' | 'land' | 'star' | 'swap' | 'hurt' | 'fall' | 'win';
-export interface RunHud {
-  color: RunColor;
-  next: RunColor | null;
-  combo: number;
-  jumps: number;
-  progress: number;
-  failure: Failure | null;
-}
-export const INITIAL_HUD: RunHud = { color: 'yellow', next: 'yellow', combo: 0, jumps: 2, progress: 0, failure: null };
-
-export function createGame(theme: GameTheme) {
-  const camera: Camera = { eye: [0, 3.1, 5.4], target: [0, 1.1, -6], fov: 0.85 };
-  return {
-    world: new World(1100),
-    camera,
-    theme,
-    config: null as Config | null,
-    scene: null as Scene | null,
-    run: null as Run | null,
-    phase: 'ready' as Phase,
-    running: false,
-    won: false,
-    active: true,
-    pending: 0,
-    clock: 0,
-    lastScoreSync: -1,
-    syncedScore: -1,
-    shownDistance: 0,
-    shownLives: MAX_LIVES,
-    finishSpeed: 0,
-    coast: 0,
-    dragFired: false,
-    hudKey: '',
-    cameraLift: 0,
-    onPhase: (_p: Phase) => {},
-    onScore: (_s: number) => {},
-    onStars: (_n: number) => {},
-    onDistance: (_metres: number) => {},
-    onLives: (_lives: number) => {},
-    onHud: (_hud: RunHud) => {},
-    onEvent: (_e: GameEvent) => {}
-  };
-}
-export type Game = ReturnType<typeof createGame>;
-
-export function setLayout(g: Game, width: number, height: number) {
-  if (width <= 0 || height <= 0 || g.world.isDisposed) return;
-  if (g.scene && g.config?.width === width && g.config.height === height) return;
-  // Camera/layout changes never regenerate the course or reset the result.
-  const config = configFor(width, height);
-  if (g.scene && g.config?.trackWidth !== config.trackWidth) clearPlatforms(g.world, g.scene);
-  g.config = config;
-  if (!g.run) g.run = newRun(g.config);
-  g.scene ??= buildScene(g.world, g.theme);
-  frameCamera(g.camera, g.config, g.cameraLift);
-  draw(g);
-  if (g.run.color !== 'yellow') tintChameleon(g.world, g.scene, g.run.color, g.run.y);
-  setStride(g.world, g.scene, g.running && g.run.onGround);
-  syncHud(g);
-}
-
-export function setTheme(g: Game, theme: GameTheme) {
-  if (theme === g.theme || g.world.isDisposed) return;
-  g.theme = theme;
-  if (g.scene) removeScene(g.world, g.scene);
-  g.scene = null;
-  if (g.config) setLayout(g, g.config.width, g.config.height);
-}
-
-function draw(g: Game) {
-  if (g.config && g.scene && g.run) drawScene(g.world, g.config, g.scene, g.run);
-}
-
-function syncHud(g: Game) {
-  const r = g.run;
-  if (!r) return;
-  const next = nextPlatform(r)?.color ?? null;
-  const progress = Math.min(100, Math.floor((r.distance / TRACK_LENGTH) * 100));
-  const hud: RunHud = { color: r.color, next, combo: r.combo, jumps: 2 - r.jumpsUsed, progress, failure: r.failure };
-  const key = `${hud.color}/${next}/${hud.combo}/${hud.jumps}/${progress}/${r.failure}`;
-  if (key !== g.hudKey) {
-    g.hudKey = key;
-    g.onHud(hud);
-  }
-}
-
-function fresh(g: Game) {
-  g.world.cancelTimers();
-  g.running = false;
-  g.won = false;
-  g.pending = 0;
-  g.syncedScore = 0;
-  g.shownDistance = 0;
-  g.shownLives = MAX_LIVES;
-  g.finishSpeed = 0;
-  g.coast = 0;
-  g.dragFired = false;
-  g.camera.shake = 0;
-  g.cameraLift = 0;
-  g.hudKey = '';
-  if (!g.config) return;
-  g.run = newRun(g.config);
-  if (g.scene) {
-    clearPlatforms(g.world, g.scene);
-    resetChameleon(g.world, g.scene);
-  }
-  frameCamera(g.camera, g.config);
-  draw(g);
-  g.onScore(0);
-  g.onStars(0);
-  g.onDistance(0);
-  g.onLives(MAX_LIVES);
-  syncHud(g);
-}
-
-export function start(g: Game) {
-  if (g.phase !== 'ready' || !g.config || !g.run || g.world.isDisposed) return;
-  // Keep the course shown in the preview, as Penguin Run does. Reset/replay builds the next one.
-  g.pending = 0;
-  g.dragFired = false;
-  g.lastScoreSync = g.clock;
-  g.running = true;
-  g.phase = 'playing';
-  if (g.scene) setStride(g.world, g.scene, true);
-  g.onPhase('playing');
-}
-
-export function reset(g: Game) {
-  if (g.world.isDisposed) return;
-  fresh(g);
-  g.phase = 'ready';
-  g.onPhase('ready');
-}
-
-export function dispose(g: Game) {
-  if (g.scene) removeScene(g.world, g.scene);
-  g.scene = null;
-  g.world.dispose();
-}
-
-export function setActive(g: Game, active: boolean) {
-  g.active = active;
-  g.pending = 0;
-}
-
-function syncScore(g: Game, force = false) {
-  if (!g.run || g.run.score === g.syncedScore || (!force && g.clock - g.lastScoreSync < SCORE_SYNC)) return;
-  g.lastScoreSync = g.clock;
-  g.syncedScore = g.run.score;
-  g.onScore(g.run.score);
-}
-
-export function tick(g: Game, dt: number) {
-  if (g.world.isDisposed || !g.active || !Number.isFinite(dt) || dt <= 0) return;
-  const elapsed = Math.min(dt, MAX_FRAME_SECONDS);
-  g.clock += elapsed;
-  if (g.running && g.config && g.run && g.scene) {
-    g.pending = Math.min(g.pending + elapsed, MAX_FRAME_SECONDS);
-    while (g.running && g.pending + 1e-9 >= STEP_SECONDS) {
-      g.pending = Math.max(0, g.pending - STEP_SECONDS);
-      stepOnce(g);
-    }
-    draw(g);
-    syncScore(g);
-    syncHud(g);
-    // Follow platform elevations gently, without bouncing with every jump.
-    const groundHeight = platformUnder(g.run)?.height ?? g.cameraLift;
-    g.cameraLift += (groundHeight - g.cameraLift) * Math.min(1, elapsed * 2);
-    frameCamera(g.camera, g.config, Math.max(-0.5, Math.min(1.5, g.cameraLift)));
-  }
-  if (g.phase === 'over' && g.won && g.scene && g.run && g.finishSpeed > 0) {
-    // As in Penguin Run, crossing the line ends scoring while the runner coasts to a stop.
-    g.finishSpeed = Math.max(0, g.finishSpeed - 22 * elapsed);
-    g.coast += g.finishSpeed * elapsed;
-    g.world.set(g.scene.field, { position: [0, 0, g.run.distance + g.coast] });
-  }
-  g.world.update(elapsed);
-}
-
-function stepOnce(g: Game) {
-  const { config: c, run: r, scene: s } = g;
-  if (!c || !r || !s) return;
-  const ev = step(c, r, STEP_SECONDS);
-  const metres = Math.min(TRACK_LENGTH, Math.floor(r.distance));
-  if (metres !== g.shownDistance) {
-    g.shownDistance = metres;
-    g.onDistance(metres);
-  }
-  if (r.lives !== g.shownLives) {
-    g.shownLives = r.lives;
-    g.onLives(r.lives);
-  }
-  if (ev.hurt) {
-    tintChameleon(g.world, s, r.color, r.y);
-    stumble(g.world, s, r);
-    g.camera.shake = 0.22;
-    g.onEvent('hurt');
-  }
-  // Effects use the current course offset, including on multi-step frames.
-  g.world.set(s.field, { position: [0, 0, r.distance] });
-  if (ev.landed) {
-    land(g.world, s, ev.landed);
-    g.onEvent('land');
-  }
-  if (ev.jumped) {
-    hop(g.world, s, ev.jumped === 'double');
-    g.onEvent('jump');
-  }
-  if (ev.star) {
-    collectStar(g.world, s, ev.star, r.distance);
-    g.onStars(r.stars);
-    syncScore(g, true);
-    g.onEvent('star');
-  }
-  setStride(g.world, s, r.onGround);
-  if (ev.failure || ev.won) {
-    g.running = false;
-    g.won = ev.won;
-    g.finishSpeed = ev.won ? BASE_SPEED : 0;
-    syncScore(g, true);
-    syncHud(g);
-    // Put the final pose in place before its native ending animation begins.
-    draw(g);
-    if (ev.won) {
-      cheer(g.world, s, r);
-      g.onEvent('win');
-    } else {
-      tumble(g.world, s, r);
-      g.onEvent('fall');
-    }
-    // Report immediately; useEngineGame delays only the card, so leaving during the effect
-    // cannot turn a completed run into a cancellation.
-    g.phase = 'over';
-    g.onPhase('over');
-  }
-}
-
-export function tap(g: Game) {
-  if (!g.active || !g.running || !g.config || !g.run || !g.scene) return;
-  const kind = jump(g.config, g.run);
-  if (!kind) return;
-  setStride(g.world, g.scene, false);
-  hop(g.world, g.scene, kind === 'double');
-  syncHud(g);
-  g.onEvent('jump');
-}
-
-export function swap(g: Game) {
-  if (!g.active || !g.running || !g.run || !g.scene) return;
-  switchColor(g.run);
-  tintChameleon(g.world, g.scene, g.run.color, g.run.y);
-  syncHud(g);
-  g.onEvent('swap');
-}
-
-/** Penguin Run's mid-stroke response: one jump as soon as an upward swipe passes 18 points. */
-export function steer(g: Game, e: DragEvent) {
-  if (e.phase === 'start') {
-    g.dragFired = false;
-    return;
-  }
-  if (e.cancelled) {
-    g.dragFired = true;
-    return;
-  }
-  if (e.phase !== 'move' || g.dragFired || e.dy > -DRAG_THRESHOLD || Math.abs(e.dy) <= Math.abs(e.dx)) return;
-  g.dragFired = true;
-  tap(g);
-}
-
-/** A stroke that already jumped must never also switch color when its finger is released. */
-export function changeColor(g: Game) {
-  if (!g.dragFired) swap(g);
-}

package/src/games/chameleon-run/ChameleonRunMeshes.ts

@@ -1,305 +0,0 @@
-// A veiled-chameleon sculpt: compressed flanks, a raised casque, granular skin, turret eyes,
-// opposed toe groups and a continuous prehensile coil. Skin stays neutral so gameplay can tint it.
-import {
-  type Color,
-  ellipsoid,
-  extrude,
-  type Geometry,
-  type GeometryPart,
-  loft,
-  type LoftSection as Section,
-  merge,
-  type Model,
-  Path,
-  smoothCurve,
-  tube,
-  type Vec3
-} from '@nayan-ui/engine';
-import { cacheGameAsset, createGameMesh as createShape } from '../shared/EngineMeshes';
-
-const meshes = new Map<string, Model>();
-const cached = (key: string, build: () => Model) => {
-  let model = meshes.get(key);
-  if (!model) {
-    model = cacheGameAsset('chameleon-run/ChameleonRunMeshes:' + key, build);
-    meshes.set(key, model);
-  }
-  return model;
-};
-const clamp = (x: number, lo: number, hi: number) => Math.max(lo, Math.min(hi, x));
-const hash = (x: number, y: number, z: number) => {
-  const n = Math.sin(x * 127.1 + y * 311.7 + z * 74.7) * 43758.5453;
-  return n - Math.floor(n);
-};
-const normalize = (v: Vec3): Vec3 => {
-  const length = Math.hypot(...v) || 1;
-  return [v[0] / length, v[1] / length, v[2] / length];
-};
-const cross = (a: Vec3, b: Vec3): Vec3 => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
-const ball = (position: Vec3, radii: Vec3, color: Color = [1, 1, 1], around = 20): GeometryPart => ({
-  geometry: ellipsoid(radii, color, around),
-  position
-});
-
-/** Gentle banding and irregular scale color, baked into vertices rather than separate entities. */
-function skin(g: Geometry, bands = false): Geometry {
-  const v = g.vertices;
-  for (let i = 0; i < v.length; i += 11) {
-    const x = v[i]!;
-    const y = v[i + 1]!;
-    const z = v[i + 2]!;
-    const grain = hash(Math.floor(x * 95), Math.floor(y * 95), Math.floor(z * 95));
-    const mottling = hash(Math.floor(x * 24), Math.floor(y * 24), Math.floor(z * 24));
-    const band = bands ? Math.exp(-(Math.sin((x + 0.08) * 12 + y * 2.5) ** 2) / 0.12) : 0;
-    const tone = clamp(0.94 + mottling * 0.06 + (grain - 0.5) * 0.025 - band * 0.15, 0.75, 1);
-    v[i + 6] = tone;
-    v[i + 7] = tone * 0.985;
-    v[i + 8] = tone * 0.94;
-    v[i + 9] = 0;
-    v[i + 10] = 0;
-  }
-  return g;
-}
-
-/** Small raised, six-sided scales catch highlights without a shiny plastic material. */
-function granules(g: Geometry, stride = 4, radius = 0.0065, rise = 0.0012): Geometry {
-  const vertices: number[] = [];
-  const indices: number[] = [];
-  for (let i = 0; i < g.vertices.length; i += 11 * stride) {
-    const v = g.vertices;
-    const p: Vec3 = [v[i]!, v[i + 1]!, v[i + 2]!];
-    const n = normalize([v[i + 3]!, v[i + 4]!, v[i + 5]!]);
-    const tangent = normalize(cross(n, Math.abs(n[1]) > 0.9 ? [1, 0, 0] : [0, 1, 0]));
-    const bitangent = cross(n, tangent);
-    const size = radius * (0.7 + hash(...p) * 0.6);
-    const base = vertices.length / 11;
-    const color: Vec3 = [v[i + 6]! * 1.025, v[i + 7]! * 1.025, v[i + 8]! * 1.025];
-    vertices.push(p[0] + n[0] * rise, p[1] + n[1] * rise, p[2] + n[2] * rise, ...n, ...color, v[i + 9]!, v[i + 10]!);
-    for (let j = 0; j < 6; j++) {
-      const a = (j * Math.PI) / 3;
-      const offset: Vec3 = [0, 1, 2].map((k) => (tangent[k]! * Math.cos(a) + bitangent[k]! * Math.sin(a)) * size) as unknown as Vec3;
-      const normal = normalize([n[0] + (offset[0] / size) * 0.22, n[1] + (offset[1] / size) * 0.22, n[2] + (offset[2] / size) * 0.22]);
-      vertices.push(p[0] + offset[0], p[1] + offset[1], p[2] + offset[2], ...normal, color[0] * 0.86, color[1] * 0.86, color[2] * 0.86, 0, 0);
-      indices.push(base, base + 1 + j, base + 1 + ((j + 1) % 6));
-    }
-  }
-  return { vertices: Float32Array.from(vertices), indices: Uint32Array.from(indices) };
-}
-
-/** Loft along +x; the shared loft builder supplies smooth normals and closed ends. */
-function alongBody(sections: readonly Section[]): Geometry {
-  const g = loft(sections, { around: 36, smoothness: 4 });
-  for (let i = 0; i < g.vertices.length; i += 11) {
-    const x = g.vertices[i]!;
-    const nx = g.vertices[i + 3]!;
-    g.vertices[i] = g.vertices[i + 2]!;
-    g.vertices[i + 2] = -x;
-    g.vertices[i + 3] = g.vertices[i + 5]!;
-    g.vertices[i + 5] = -nx;
-  }
-  return skin(g, true);
-}
-
-/** A small triangular dorsal scale, merged into the body's mesh. */
-function crestTooth(x: number, y: number, size: number): GeometryPart {
-  const height = Math.abs(size);
-  const g = loft(
-    [
-      { z: -0.013, bottom: 0, top: height * 0.15, width: height * 0.46, square: 2 },
-      { z: 0, bottom: 0, top: height, width: height * 0.36, topWidth: 0.001, square: 2 },
-      { z: 0.013, bottom: 0, top: height * 0.15, width: height * 0.46, square: 2 }
-    ],
-    { around: 10, smoothness: 1, color: [0.66, 0.68, 0.62] }
-  );
-  return { geometry: g, position: [x, y, 0], rotation: size < 0 ? [0, 0, 1, 0] : [0, 0, 0, 1] };
-}
-
-/** Facing +x, with the feet at -0.5. Shape and pigment remain readable from the chase camera. */
-export const bodyMesh = () =>
-  cached('body-realistic', () => {
-    const bodySections: Section[] = [
-      { z: -0.54, bottom: -0.07, top: 0.08, width: 0.035, square: 2 },
-      { z: -0.43, bottom: -0.17, top: 0.2, width: 0.105, square: 2 },
-      { z: -0.22, bottom: -0.25, top: 0.3, width: 0.165, square: 2 },
-      { z: 0.02, bottom: -0.24, top: 0.33, width: 0.175, square: 2 },
-      { z: 0.21, bottom: -0.18, top: 0.27, width: 0.14, square: 2 },
-      { z: 0.36, bottom: -0.1, top: 0.19, width: 0.105, square: 2 },
-      { z: 0.44, bottom: -0.055, top: 0.15, width: 0.08, square: 2 }
-    ];
-    const body = alongBody(bodySections);
-    const topAt = smoothCurve(bodySections.map((section) => [section.z, section.top] as const));
-    const head = alongBody([
-      { z: 0.29, bottom: -0.02, top: 0.18, width: 0.075, square: 2.2 },
-      { z: 0.36, bottom: -0.065, top: 0.33, width: 0.125, topWidth: 0.035, square: 2.2 },
-      { z: 0.44, bottom: -0.075, top: 0.59, width: 0.14, topWidth: 0.016, square: 2.4 },
-      { z: 0.5, bottom: -0.075, top: 0.65, width: 0.135, topWidth: 0.014, square: 2.4 },
-      { z: 0.56, bottom: -0.07, top: 0.39, width: 0.14, topWidth: 0.055, square: 2.2 },
-      { z: 0.66, bottom: -0.06, top: 0.2, width: 0.125, square: 2 },
-      { z: 0.78, bottom: -0.03, top: 0.13, width: 0.08, square: 2 },
-      { z: 0.835, bottom: 0.005, top: 0.08, width: 0.015, square: 2 }
-    ]);
-    const parts: GeometryPart[] = [
-      { geometry: body },
-      { geometry: granules(body, 3) },
-      { geometry: head },
-      { geometry: granules(head, 3, 0.003, 0.0008) }
-    ];
-    for (let i = 0; i < 17; i++) {
-      const x = -0.44 + i * 0.044;
-      const top = topAt(x) - 0.014;
-      parts.push(crestTooth(x, top, 0.033 + Math.sin((i / 16) * Math.PI) * 0.022));
-    }
-    return createShape(merge(parts), { center: false, shine: 0.14 });
-  });
-
-/** Restrained throat folds, a closed jaw seam and tiny nostrils; no smile or cartoon eye whites. */
-export const detailsMesh = () =>
-  cached('details-realistic', () => {
-    const parts: GeometryPart[] = [
-      ball([-0.01, -0.225, 0], [0.31, 0.038, 0.12], [0.58, 0.59, 0.45], 28),
-      ball([0.46, -0.06, 0], [0.15, 0.035, 0.075], [0.64, 0.63, 0.49])
-    ];
-    for (const side of [-1, 1]) {
-      parts.push({
-        geometry: tube(
-          [
-            [0.4, -0.015, side * 0.123],
-            [0.54, -0.016, side * 0.14],
-            [0.69, 0.002, side * 0.113],
-            [0.815, 0.026, side * 0.045]
-          ],
-          { radius: 0.0038, sides: 5, smoothness: 3, color: [0.18, 0.2, 0.14] }
-        )
-      });
-      parts.push(ball([0.758, 0.098, side * 0.074], [0.012, 0.008, 0.006], [0.13, 0.16, 0.11], 12));
-      // A fine, irregular lateral stripe follows the compressed flank instead of raised spots.
-      parts.push({
-        geometry: tube(
-          [
-            [-0.41, -0.045, side * 0.108],
-            [-0.22, -0.058, side * 0.163],
-            [0.01, -0.045, side * 0.177],
-            [0.19, -0.03, side * 0.14],
-            [0.31, 0.015, side * 0.113]
-          ],
-          { radius: (t) => 0.004 + Math.sin(t * Math.PI) * 0.004, sides: 5, smoothness: 3, color: [0.77, 0.76, 0.6] }
-        )
-      });
-    }
-    for (let i = 0; i < 6; i++) parts.push(crestTooth(0.35 + i * 0.047, -0.062, -0.018));
-    return createShape(merge(parts), { center: false, shine: 0.12 });
-  });
-
-/** Scaly turret eyelids with only a small forward-facing opening. Local +z is the gaze direction. */
-export const eyeMesh = () =>
-  cached('eye-lid-realistic', () => {
-    const lid = skin(ellipsoid([0.086, 0.086, 0.074], undefined, 32));
-    const ring: Vec3[] = [];
-    for (let i = 0; i <= 24; i++) {
-      const a = (i / 24) * Math.PI * 2;
-      ring.push([Math.cos(a) * 0.027, Math.sin(a) * 0.027, 0.071]);
-    }
-    return createShape(
-      merge([
-        { geometry: lid },
-        { geometry: granules(lid, 3, 0.0024, 0.0006) },
-        { geometry: tube(ring, { radius: 0.003, sides: 5, smoothness: 1, color: [0.62, 0.65, 0.56] }) }
-      ]),
-      { center: false, shine: 0.15 }
-    );
-  });
-
-export const eyeDetailsMesh = () =>
-  cached('eye-aperture-realistic', () =>
-    createShape(
-      merge([
-        ball([0, 0, 0.074], [0.025, 0.025, 0.006], [0.39, 0.32, 0.15], 24),
-        ball([0.002, 0, 0.08], [0.011, 0.011, 0.003], [0.025, 0.035, 0.02], 24),
-        ball([0.005, 0.005, 0.083], [0.003, 0.003, 0.001], [1.1, 1.1, 1.05], 12)
-      ]),
-      { center: false, shine: 0.5 }
-    )
-  );
-
-export const tailMesh = () =>
-  cached('tail-realistic', () => {
-    const points: Vec3[] = [
-      [0, 0, 0],
-      [-0.16, -0.015, 0],
-      [-0.29, 0.03, 0]
-    ];
-    for (let i = 0; i <= 48; i++) {
-      const t = i / 48;
-      const a = Math.PI / 2 + t * Math.PI * 2.5;
-      const r = 0.26 * (1 - t * 0.83);
-      points.push([-0.42 + Math.cos(a) * r, -0.2 + Math.sin(a) * r, 0]);
-    }
-    const tail = skin(tube(points, { radius: (t) => 0.068 * (1 - t) ** 1.15 + 0.008, sides: 12, smoothness: 2, caps: true }), true);
-    return createShape(merge([{ geometry: tail }, { geometry: granules(tail, 10, 0.0025, 0.0007) }]), { center: false, shine: 0.13 });
-  });
-
-export interface LimbDefinition {
-  x: number;
-  y: number;
-  side: -1 | 1;
-  hind: boolean;
-}
-export const LIMBS: readonly LimbDefinition[] = [
-  { x: 0.28, y: -0.1, side: 1, hind: false },
-  { x: 0.28, y: -0.1, side: -1, hind: false },
-  { x: -0.3, y: -0.09, side: 1, hind: true },
-  { x: -0.3, y: -0.09, side: -1, hind: true }
-];
-
-export const legMesh = (side: number, hind = false) =>
-  cached(`leg-realistic-${side}-${hind}`, () => {
-    const elbow: Vec3 = [hind ? 0.12 : -0.1, -0.16, side * 0.16];
-    const wrist: Vec3 = [hind ? -0.065 : 0.07, -0.36, side * 0.14];
-    const limb = skin(tube([[0, 0, 0], elbow, wrist], { radius: (t) => 0.054 - t * 0.03, sides: 12, smoothness: 5, caps: true }), false);
-    const parts: GeometryPart[] = [
-      { geometry: limb },
-      { geometry: granules(limb, 5, 0.0025, 0.0007) },
-      ball(elbow, [0.041, 0.046, 0.043], [0.84, 0.85, 0.78]),
-      ball([wrist[0], -0.374, wrist[2]], [0.052, 0.023, 0.041], [0.87, 0.88, 0.8])
-    ];
-    // Five toes form two opposed gripping groups; forefeet and hindfeet reverse the 2/3 split.
-    for (const group of [-1, 1]) {
-      const count = (group === side) !== hind ? 2 : 3;
-      for (let i = 0; i < count; i++) {
-        const spread = (i - (count - 1) / 2) * 0.019;
-        const tip: Vec3 = [wrist[0] + 0.047 + spread, -0.385, wrist[2] + group * 0.048];
-        parts.push({
-          geometry: tube([[wrist[0], -0.37, wrist[2]], [wrist[0] + 0.025 + spread, -0.372, wrist[2] + group * 0.035], tip], {
-            radius: (t) => 0.013 - t * 0.006,
-            sides: 6,
-            smoothness: 2,
-            caps: true,
-            color: [0.85, 0.86, 0.77]
-          })
-        });
-        parts.push({
-          geometry: tube([tip, [tip[0] + 0.016, -0.399, tip[2] - group * 0.008]], {
-            radius: (t) => 0.006 * (1 - t) + 0.001,
-            sides: 5,
-            smoothness: 1,
-            color: [0.3, 0.27, 0.19]
-          })
-        });
-      }
-    }
-    return createShape(merge(parts), { center: false, shine: 0.12 });
-  });
-
-export const starMesh = () =>
-  cached('star', () => createShape(extrude(new Path().addStar(0, 0, 0.5, 0.23), { depth: 0.18 }), { fit: 1, shine: 0.85 }));
-
-/** Reusable assets; the game loader advances one builder per frame. */
-export function* warmAssets(): Iterable<() => unknown> {
-  yield bodyMesh;
-  yield detailsMesh;
-  yield eyeMesh;
-  yield eyeDetailsMesh;
-  yield tailMesh;
-  yield starMesh;
-  for (const side of [-1, 1]) for (const hind of [false, true]) yield () => legMesh(side, hind);
-}