@nayan-ui/games 1.19.0 → 1.20.0

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

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

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