@nayan-ui/games 1.19.0 → 1.20.0

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

@@ -0,0 +1,252 @@
+// Pure 500 m course generation, swept landings and three-life runner rules.
+import {
+  BASE_SPEED,
+  COLOR_GRACE,
+  type Config,
+  COYOTE_TIME,
+  HURT_INVULNERABLE,
+  JUMP_BUFFER,
+  MAX_JUMPS,
+  MAX_LIVES,
+  POINTS_PER_METRE,
+  type RunColor,
+  STAR_POINTS,
+  TRACK_LENGTH
+} from './ChameleonRunConstants';
+
+export interface Platform {
+  id: number;
+  start: number;
+  end: number;
+  height: number;
+  color: RunColor | null;
+  star: boolean;
+  starCollected: boolean;
+}
+
+export type Failure = 'fall' | 'color';
+export type JumpKind = 'jump' | 'double';
+
+export interface Run {
+  seed: number;
+  platforms: Platform[];
+  seq: number;
+  distance: number;
+  y: number;
+  vy: number;
+  onGround: boolean;
+  jumpsUsed: number;
+  currentPlatformId: number;
+  color: RunColor;
+  coyote: number;
+  jumpBuffer: number;
+  mismatchTime: number;
+  score: number;
+  stars: number;
+  combo: number;
+  bestCombo: number;
+  lives: number;
+  invulnerable: number;
+  failure: Failure | null;
+  finished: boolean;
+}
+
+// Readable phrases: neutral rest islands, same-color runs, alternating jumps and stairs.
+// The opening stays gentle; a new seed changes the gaps, heights and color phrases each attempt.
+const PHRASES: readonly (readonly (RunColor | null)[])[] = [
+  [null, 'yellow', 'yellow', 'pink', 'pink', null],
+  ['yellow', 'pink', 'yellow', 'pink', null, 'yellow'],
+  ['pink', 'pink', 'yellow', null, 'pink', 'yellow']
+];
+const noise = (n: number) => {
+  const x = Math.sin(n * 127.1 + 19.7) * 43758.5453;
+  return x - Math.floor(x);
+};
+
+/** Single-jump range at the slowest speed; generation keeps an extra reaction margin. */
+export function jumpReach(c: Config, rise: number) {
+  const disc = c.jump * c.jump - 2 * c.gravity * rise;
+  return disc <= 0 ? 0 : (BASE_SPEED * (c.jump + Math.sqrt(disc))) / c.gravity;
+}
+
+export function ensureAhead(c: Config, r: Run) {
+  let last = r.platforms[r.platforms.length - 1]!;
+  while (last.end < Math.min(TRACK_LENGTH + 18, r.distance + c.lookAhead)) {
+    const id = r.seq++;
+    const difficulty = Math.min(1, last.end / TRACK_LENGTH);
+    const rise = id < 4 ? 0 : (noise(id + 4 + r.seed) - 0.5) * (0.35 + difficulty * 0.5);
+    const height = Math.max(-0.45, Math.min(0.9, last.height + rise));
+    const gap = Math.min(1.7 + noise(id + 1 + r.seed) * (0.6 + difficulty * 0.9), jumpReach(c, height - last.height) - 1.8);
+    let start = last.end + gap;
+    let end = start + (id < 4 ? 11 : 7.5 + noise(id + 2 + r.seed) * 4.5 - difficulty);
+    let color: RunColor | null = PHRASES[(Math.floor(id / 6) + (id < 4 ? 0 : r.seed)) % PHRASES.length]![id % 6] ?? null;
+    if (end >= TRACK_LENGTH - 20) {
+      start = Math.min(start, TRACK_LENGTH - 20);
+      end = TRACK_LENGTH + 18;
+      color = null;
+    }
+    r.platforms.push({ id, start, end, height, color, star: id > 1 && color !== null, starCollected: false });
+    last = r.platforms[r.platforms.length - 1]!;
+  }
+}
+
+export function newRun(c: Config, seed = Math.floor(Math.random() * 1e9)): Run {
+  const r: Run = {
+    seed,
+    platforms: [{ id: 0, start: -10, end: 12, height: 0, color: null, star: false, starCollected: false }],
+    seq: 1,
+    distance: 0,
+    y: 0,
+    vy: 0,
+    onGround: true,
+    jumpsUsed: 0,
+    currentPlatformId: 0,
+    color: 'yellow',
+    coyote: COYOTE_TIME,
+    jumpBuffer: 0,
+    mismatchTime: 0,
+    score: 0,
+    stars: 0,
+    combo: 0,
+    bestCombo: 0,
+    lives: MAX_LIVES,
+    invulnerable: 0,
+    failure: null,
+    finished: false
+  };
+  ensureAhead(c, r);
+  return r;
+}
+
+export const platformUnder = (r: Run, distance = r.distance) => r.platforms.find((p) => distance >= p.start && distance <= p.end) ?? null;
+// Keep the landing target visible while flying over its leading edge.
+export const nextPlatform = (r: Run) => r.platforms.find((p) => p.end >= r.distance && p.id !== r.currentPlatformId) ?? null;
+
+export function switchColor(r: Run) {
+  if (r.failure || r.finished) return;
+  r.color = r.color === 'yellow' ? 'pink' : 'yellow';
+  r.mismatchTime = 0;
+}
+
+export function jump(c: Config, r: Run): JumpKind | null {
+  if (r.failure || r.finished) return null;
+  if (r.jumpsUsed >= MAX_JUMPS) {
+    r.jumpBuffer = JUMP_BUFFER;
+    return null;
+  }
+  const first = r.onGround || (r.coyote > 0 && r.jumpsUsed === 0);
+  r.vy = first ? c.jump : c.doubleJump;
+  r.jumpsUsed = first ? 1 : MAX_JUMPS;
+  r.onGround = false;
+  r.coyote = 0;
+  r.jumpBuffer = 0;
+  r.mismatchTime = 0;
+  return first ? 'jump' : 'double';
+}
+
+export interface StepEvents {
+  landed: Platform | null;
+  star: Platform | null;
+  jumped: JumpKind | null;
+  failure: Failure | null;
+  hurt: Failure | null;
+  won: boolean;
+}
+
+export function step(c: Config, r: Run, dt: number): StepEvents {
+  const ev: StepEvents = { landed: null, star: null, jumped: null, failure: null, hurt: null, won: false };
+  if (dt <= 0 || r.failure || r.finished) return ev;
+  const previousDistance = r.distance;
+  const previousY = r.y;
+  r.jumpBuffer = Math.max(0, r.jumpBuffer - dt);
+  r.coyote = Math.max(0, r.coyote - dt);
+  r.invulnerable = Math.max(0, r.invulnerable - dt);
+  r.distance = Math.min(TRACK_LENGTH, r.distance + BASE_SPEED * dt);
+  let under = platformUnder(r);
+  if (r.onGround && !under) {
+    r.onGround = false;
+    r.coyote = COYOTE_TIME;
+    r.vy = 0;
+  }
+  if (!r.onGround) {
+    r.vy -= c.gravity * dt;
+    r.y += r.vy * dt;
+    if (r.vy <= 0) {
+      // Intersect the falling feet with each platform's top along this step's motion.
+      for (const p of r.platforms) {
+        if (previousY < p.height || r.y > p.height) continue;
+        const fraction = (previousY - p.height) / Math.max(0.000001, previousY - r.y);
+        const atLanding = previousDistance + (r.distance - previousDistance) * fraction;
+        if (atLanding < p.start || atLanding > p.end || r.distance > p.end) continue;
+        r.y = p.height;
+        r.vy = 0;
+        r.onGround = true;
+        r.coyote = COYOTE_TIME;
+        r.jumpsUsed = 0;
+        r.currentPlatformId = p.id;
+        ev.landed = p;
+        under = p;
+        break;
+      }
+    }
+  }
+  if (r.onGround && under?.color && under.color !== r.color && r.invulnerable === 0) {
+    r.mismatchTime += dt;
+  } else r.mismatchTime = 0;
+  // A buffered jump swipe fires only on a safe landing.
+  if (ev.landed && r.jumpBuffer > 0 && (!ev.landed.color || ev.landed.color === r.color)) ev.jumped = jump(c, r);
+
+  for (const p of r.platforms) {
+    const starDistance = (p.start + p.end) / 2;
+    if (p.star && !p.starCollected && Math.abs(r.distance - starDistance) < 0.7 && Math.abs(r.y + 0.5 - (p.height + 1.05)) < 0.95 && !r.failure) {
+      p.starCollected = true;
+      r.stars++;
+      r.combo = Math.min(5, r.combo + 1);
+      r.bestCombo = Math.max(r.bestCombo, r.combo);
+      r.score += STAR_POINTS * r.combo;
+      ev.star = p;
+    }
+    if (p.star && !p.starCollected && previousDistance <= starDistance + 0.7 && r.distance > starDistance + 0.7) r.combo = 0;
+  }
+  const fault: Failure | null = r.y < c.fallY ? 'fall' : r.mismatchTime >= COLOR_GRACE ? 'color' : null;
+  if (fault) {
+    if (r.invulnerable === 0) {
+      r.lives = Math.max(0, r.lives - 1);
+      r.combo = 0;
+      r.mismatchTime = 0;
+      if (r.lives === 0) r.failure = fault;
+      else {
+        r.invulnerable = HURT_INVULNERABLE;
+        ev.hurt = fault;
+      }
+    }
+    // Penguin Run continues through a gap after a nonfatal hit. Here, restore the feet
+    // to the next safe surface so the physical fall cannot drain another life.
+    if (fault === 'fall' && !r.failure) recover(r);
+  }
+  // Resolve the hit first: losing the final life at the line is never a win.
+  if (r.failure) ev.failure = r.failure;
+  else if (r.distance >= TRACK_LENGTH) {
+    r.finished = true;
+    ev.won = true;
+  }
+  r.score += (Math.floor(r.distance) - Math.floor(previousDistance)) * POINTS_PER_METRE;
+  ensureAhead(c, r);
+  while (r.platforms.length > 1 && r.platforms[0]!.end < r.distance - 18) r.platforms.shift();
+  return ev;
+}
+
+/** Recover on the current island, or at the next island's leading edge if still above a gap. */
+function recover(r: Run) {
+  const target = platformUnder(r) ?? nextPlatform(r);
+  if (!target) return;
+  r.distance = Math.min(TRACK_LENGTH, Math.max(r.distance, target.start + 0.5));
+  r.y = target.height;
+  r.vy = 0;
+  r.onGround = true;
+  r.jumpsUsed = 0;
+  r.jumpBuffer = 0;
+  r.coyote = COYOTE_TIME;
+  r.currentPlatformId = target.id;
+  if (target.color) r.color = target.color;
+}

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

@@ -0,0 +1,310 @@
+// A forward-moving 3D sky course. Only the course root scrolls; the chase camera and player
+// stay near the origin so long runs retain precision. All geometry is cached, all animation native.
+import { type Camera, type Color, effects, type Entity, type Quat, quat, type Vec3, type World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { popAndBurst } from '../shared/EngineBlasts';
+import { sceneryTint } from '../shared/EngineMeadow';
+import { toColor } from '../shared/EngineUtils';
+import { type Backdrop, removeBackdrop, spawnBackdrop } from './ChameleonRunBackdrop';
+import { COLORS, type Config, RUN_COLORS, type RunColor, TRACK_LENGTH } from './ChameleonRunConstants';
+import { bodyMesh, detailsMesh, eyeDetailsMesh, eyeMesh, legMesh, LIMBS, starMesh, tailMesh } from './ChameleonRunMeshes';
+import { type Platform, platformUnder, type Run } from './ChameleonRunRules';
+
+const FORWARD = quat.y(Math.PI / 2);
+const WHITE: Color = [1, 1, 1, 1];
+const NEUTRAL = toColor(COLORS.NEUTRAL);
+interface PlatformView {
+  root: Entity;
+  star: Entity | null;
+}
+export interface Scene {
+  syncedFirst?: number;
+  syncedLast?: number;
+  syncedCount?: number;
+  backdrop: Backdrop;
+  field: Entity;
+  chameleon: Entity;
+  skin: Entity[];
+  legs: Entity[];
+  tail: Entity;
+  shadow: Entity;
+  platforms: Map<number, PlatformView>;
+  tint: Color;
+  color: RunColor;
+  stride: boolean;
+}
+
+const shade = (color: Color, tint: Color): Color => [color[0] * tint[0], color[1] * tint[1], color[2] * tint[2], color[3] ?? 1];
+const surfaceColor = (p: Platform): Color => (p.color ? toColor(RUN_COLORS[p.color]) : NEUTRAL);
+export const starPosition = (p: Platform, distance: number): Vec3 => [0, p.height + 1.05, distance - (p.start + p.end) / 2];
+
+/** A centered chase camera keeps the runner and course on the screen centerline. */
+export function frameCamera(camera: Camera, c: Config, lift = 0) {
+  camera.eye = [0, 3.1 + lift, 5.4];
+  camera.target = [0, 1.1 + lift, -6];
+  camera.fov = c.width / Math.max(1, c.height) < 0.7 ? 1 : 0.85;
+}
+
+export function buildScene(world: World, theme: GameTheme): Scene {
+  const backdrop = spawnBackdrop(world, theme);
+  const tint = sceneryTint(theme);
+  const field = world.spawn({ mesh: 'none', pickable: false });
+  const chameleon = world.spawn({ mesh: 'none', rotation: FORWARD, pickable: false });
+  const skinColor = toColor(RUN_COLORS.yellow);
+  const bodyModel = bodyMesh();
+  const body = world.spawn({ mesh: bodyModel, parent: chameleon, color: skinColor, bob: { amplitude: [0, 0.004, 0], speed: 2.2 }, pickable: false });
+  world.spawn({ mesh: detailsMesh(), parent: chameleon, pickable: false });
+  const tailModel = tailMesh();
+  const tail = world.spawn({ mesh: tailModel, parent: chameleon, position: [-0.5, -0.015, 0], color: skinColor, pickable: false });
+  const eyeLids: Entity[] = [];
+  for (const side of [-1, 1]) {
+    const yaw = side > 0 ? 0.27 : Math.PI - 0.27;
+    const eye = world.spawn({
+      mesh: 'none',
+      parent: chameleon,
+      position: [0.575, 0.205, side * 0.125],
+      rotation: quat.y(yaw),
+      pickable: false
+    });
+    const eyeModel = eyeMesh();
+    const lid = world.spawn({ mesh: eyeModel, parent: eye, color: skinColor, pickable: false });
+    eyeLids.push(lid);
+    world.spawn({ mesh: eyeDetailsMesh(), parent: eye, pickable: false });
+    // Separate native tracks give the eyes independent, subtle scanning motion.
+    world.animate(
+      eye,
+      { rotation: quat.y(yaw + side * 0.13) },
+      { duration: side > 0 ? 2.7 : 3.4, repeat: 'forever', yoyo: true, easing: 'easeInOut' }
+    );
+  }
+  const legs: Entity[] = [];
+  for (const limb of LIMBS) {
+    const mesh = legMesh(limb.side, limb.hind);
+    const entity = world.spawn({ mesh, parent: chameleon, position: [limb.x, limb.y, limb.side * 0.13], color: skinColor, pickable: false });
+    legs.push(entity);
+  }
+  const shadow = world.spawn({ mesh: 'sphere', scale: [0.72, 0.012, 1.8], color: [0.12, 0.19, 0.25, 0.22], pickable: false });
+  const scene: Scene = {
+    backdrop,
+    field,
+    chameleon,
+    skin: [body, tail, ...legs, ...eyeLids],
+    legs,
+    tail,
+    shadow,
+    platforms: new Map(),
+    tint,
+    color: 'yellow',
+    stride: false
+  };
+  return scene;
+}
+
+export function removeScene(world: World, s: Scene) {
+  removeBackdrop(world, s.backdrop);
+  for (const e of [s.field, s.chameleon, s.shadow]) world.despawn(e);
+}
+
+export function syncPlatforms(world: World, c: Config, s: Scene, platforms: Platform[]) {
+  const first = platforms[0]?.id,
+    last = platforms[platforms.length - 1]?.id;
+  if (s.syncedFirst === first && s.syncedLast === last && s.syncedCount === platforms.length) return;
+  s.syncedFirst = first;
+  s.syncedLast = last;
+  s.syncedCount = platforms.length;
+  const live = new Set(platforms.map((p) => p.id));
+  for (const p of platforms) {
+    if (s.platforms.has(p.id)) continue;
+    const length = p.end - p.start;
+    const root = world.spawn({ mesh: 'none', parent: s.field, position: [0, p.height, -(p.start + p.end) / 2], pickable: false });
+    const spawn = (mesh: 'roundedBox' | 'sphere' | 'cube', position: Vec3, scale: Vec3, color: Color, rotation?: Quat) =>
+      world.spawn({ mesh, parent: root, position, scale, color: shade(color, s.tint), rotation, pickable: false });
+    spawn('roundedBox', [0, -0.65, 0], [c.trackWidth, 1.2, length], toColor(COLORS.STONE));
+    spawn('roundedBox', [0, -1.4, 0], [c.trackWidth * 0.8, 0.7, length * 0.94], toColor(COLORS.STONE_DARK));
+    spawn('roundedBox', [0, -0.105, 0], [c.trackWidth + 0.08, 0.21, length + 0.025], surfaceColor(p));
+    // Two edge rails sit below the running surface, leaving take-off and landing unobstructed.
+    for (const side of [-1, 1]) spawn('roundedBox', [side * (c.trackWidth / 2 - 0.08), -0.22, 0], [0.08, 0.08, length], toColor(COLORS.RIM));
+    // Stripes vs dots distinguish colors even without hue; both repeat to the far end.
+    const marks = Math.max(2, Math.floor(length / 1.5));
+    for (let j = 0; j < marks; j++) {
+      const z = -length / 2 + 0.75 + j * 1.5;
+      if (p.color === 'yellow') spawn('roundedBox', [-c.trackWidth * 0.32, 0.012, z], [0.55, 0.018, 0.12], [1, 0.98, 0.8]);
+      if (p.color === 'pink')
+        for (const x of [-0.16, 0.16]) spawn('sphere', [-c.trackWidth * 0.32 + x, 0.018, z], [0.16, 0.025, 0.16], [1, 0.85, 0.96]);
+    }
+    // Take-off line and forward arrow on each island.
+    spawn('roundedBox', [0, 0.015, -length / 2 + 0.35], [c.trackWidth * 0.8, 0.018, 0.09], WHITE);
+    for (const side of [-1, 1]) spawn('roundedBox', [side * 0.18, 0.018, length / 2 - 1.2], [0.1, 0.025, 0.55], WHITE, quat.y(side * -0.65));
+    let star: Entity | null = null;
+    if (p.star && !p.starCollected) {
+      star = world.spawn({
+        mesh: starMesh(),
+        parent: root,
+        position: [0, 1.05, 0],
+        scale: 0.68,
+        color: [1.6, 1.35, 0.48, 1],
+        spin: [0, 2.2, 0],
+        bob: { amplitude: [0, 0.09, 0], speed: 3.2 },
+        pickable: false
+      });
+    }
+    if (p.end > TRACK_LENGTH) {
+      const z = (p.start + p.end) / 2 - TRACK_LENGTH;
+      for (const side of [-1, 1]) spawn('roundedBox', [side * (c.trackWidth / 2 + 0.1), 1.7, z], [0.22, 3.4, 0.3], WHITE);
+      spawn('roundedBox', [0, 3.25, z], [c.trackWidth + 0.5, 0.55, 0.3], toColor('#20354A'));
+      for (let j = 0; j < 10; j++) spawn('cube', [(j - 4.5) * 0.36, 3.25, z + 0.16], [0.35, 0.36, 0.02], j % 2 ? WHITE : toColor('#20354A'));
+    }
+    s.platforms.set(p.id, { root, star });
+  }
+  for (const [id, pv] of s.platforms)
+    if (!live.has(id)) {
+      world.despawn(pv.root);
+      s.platforms.delete(id);
+    }
+}
+
+export function drawScene(world: World, c: Config, s: Scene, r: Run) {
+  const updates = world.transforms;
+  updates.position(s.field, 0, 0, r.distance);
+  updates.position(s.chameleon, 0, r.y + 0.5, 0);
+  const under = platformUnder(r);
+  const altitude = under ? Math.max(0, r.y - under.height) : 0;
+  updates.position(s.shadow, 0, (under?.height ?? -10) + 0.018, 0.15);
+  updates.scale(s.shadow, 0.72 + altitude * 0.08, 0.012, 1.8 + altitude * 0.12);
+  updates.color(s.shadow, 0.12, 0.19, 0.25, under ? 0.2 / (1 + altitude) : 0);
+  updates.flush();
+  syncPlatforms(world, c, s, r.platforms);
+}
+
+export function setStride(world: World, s: Scene, running: boolean) {
+  if (s.stride === running) return;
+  s.stride = running;
+  world.set(s.chameleon, { bob: running ? { amplitude: [0, 0.009, 0], speed: 16 } : null });
+  s.legs.forEach((leg, i) => {
+    world.stopAnimation(leg);
+    const sign = i === 0 || i === 3 ? 1 : -1;
+    if (running) {
+      world.set(leg, { rotation: quat.z(-0.28 * sign) });
+      world.animate(leg, { rotation: quat.z(0.28 * sign) }, { duration: 0.2, easing: 'easeInOut', repeat: 'forever', yoyo: true });
+    } else world.animate(leg, { rotation: quat.z(sign * 0.18) }, { duration: 0.12 });
+  });
+  world.stopAnimation(s.tail);
+  world.animate(s.tail, { rotation: quat.x(running ? 0.1 : 0.035) }, { duration: 0.32, repeat: 'forever', yoyo: true, easing: 'easeInOut' });
+}
+
+export function tintChameleon(world: World, s: Scene, color: RunColor, y = 0) {
+  if (color === s.color) return;
+  s.color = color;
+  for (const e of s.skin) world.set(e, { color: toColor(RUN_COLORS[color]) });
+  effects.sparkle(world, {
+    position: [0, y + 0.65, 0],
+    colors: toColor(RUN_COLORS[color]),
+    size: 0.06,
+    speed: 1.3,
+    count: 7,
+    lifetime: 0.22,
+    flash: false
+  });
+}
+
+export function hop(world: World, s: Scene, double: boolean) {
+  world.animate(s.chameleon, [{ scale: [0.97, 1.06, 0.97], at: 0.3 }, { scale: 1 }], { duration: 0.25 });
+  if (double) {
+    world.set(s.chameleon, { rotation: FORWARD });
+    world.animate(s.chameleon, { turn: [0, 0, -Math.PI * 2] }, { duration: 0.4, easing: 'easeOut' });
+  }
+}
+
+export function land(world: World, s: Scene, p: Platform) {
+  world.stopAnimation(s.chameleon);
+  world.set(s.chameleon, { rotation: FORWARD, scale: 1 });
+  world.animate(s.chameleon, [{ scale: [1.04, 0.94, 1.03], at: 0.25 }, { scale: 1 }], { duration: 0.2 });
+  effects.dust(world, {
+    position: [0, p.height + 0.05, 0],
+    count: 7,
+    size: 0.13,
+    speed: 1.5,
+    lifetime: 0.3,
+    color: [0.85, 0.93, 1, 0.45],
+    endSize: 1.8,
+    direction: [0, 1, 0],
+    spread: 1.4
+  });
+}
+
+export function collectStar(world: World, s: Scene, p: Platform, distance: number) {
+  const pv = s.platforms.get(p.id);
+  if (pv?.star == null) return;
+  const star = pv.star;
+  pv.star = null;
+  // Detach before popping so resetting or recycling the course cannot move the effect.
+  const position = starPosition(p, distance);
+  world.set(star, { parent: null, position, bob: null, spin: [0, 0, 0] });
+  popAndBurst(
+    world,
+    star,
+    { scale: 0.68, color: [1.6, 1.35, 0.48, 1], duration: 0.3 },
+    { position, size: 0.5, color: toColor(COLORS.STAR), count: 12 }
+  ).then(() => {
+    if (world.has(star)) world.despawn(star);
+  });
+}
+
+/** A nonfatal stumble; the course keeps moving while the player is invulnerable. */
+export function stumble(world: World, s: Scene, r: Run) {
+  world.animate(s.chameleon, { shake: 0.12 }, { duration: 0.4 });
+  effects.sparkle(world, {
+    position: [0, r.y + 0.4, 0],
+    colors: [toColor(RUN_COLORS[r.color]), WHITE],
+    size: 0.08,
+    speed: 2,
+    count: 10,
+    lifetime: 0.35
+  });
+}
+
+export function tumble(world: World, s: Scene, r: Run) {
+  setStride(world, s, false);
+  world.animate(s.chameleon, { moveBy: [0, -2.8, 0], turn: [1.2, 0, 0.7], scale: 0.25 }, { duration: 0.65, easing: 'easeIn' });
+  if (r.failure === 'color')
+    effects.sparkle(world, {
+      position: [0, r.y + 0.4, 0],
+      colors: [toColor(RUN_COLORS[r.color]), WHITE],
+      size: 0.1,
+      speed: 3.2,
+      count: 20,
+      lifetime: 0.45
+    });
+}
+
+export function cheer(world: World, s: Scene, r: Run) {
+  setStride(world, s, false);
+  effects.confetti(world, {
+    position: [0, r.y + 1, 0],
+    colors: [toColor(RUN_COLORS.pink), toColor(RUN_COLORS.yellow), WHITE],
+    count: 55,
+    size: 0.1,
+    speed: 4,
+    gravity: -3,
+    lifetime: 1.6
+  });
+  world.animate(s.chameleon, [{ moveBy: [0, 0.35, 0], at: 0.5 }, { moveBy: [0, 0, 0] }], { duration: 0.65, repeat: 3 });
+  world.animate(s.chameleon, { rotation: quat.y(-Math.PI / 2) }, { duration: 0.5, delay: 0.5, easing: 'easeInOut' });
+}
+
+export function clearPlatforms(world: World, s: Scene) {
+  for (const pv of s.platforms.values()) world.despawn(pv.root);
+  s.platforms.clear();
+  s.syncedCount = undefined;
+}
+
+export function resetChameleon(world: World, s: Scene) {
+  world.stopAnimation(s.chameleon);
+  setStride(world, s, false);
+  world.set(s.chameleon, { scale: 1, rotation: FORWARD, bob: null });
+  s.color = 'yellow';
+  for (const e of s.skin) {
+    world.stopAnimation(e);
+    world.set(e, { color: toColor(RUN_COLORS.yellow) });
+  }
+}

package/src/games/checkers/Checkers.tsx

@@ -0,0 +1,83 @@
+// Checkers' screen, on the Nayan engine: the board, pieces and hints are one 3D scene (an orthographic
+// camera directly above the flat board), under Playtura's scoreboard, controls and modals. The play is in
+// CheckersGame.ts (the rules in CheckersRules.ts, the robot in CheckersAI.ts), what it draws in
+// CheckersScene.ts.
+//
+// One world serves the whole visit: Start, Stop and Play Again set the board up again in place and a
+// theme change rebuilds just the board, so the GPU view is never rebuilt. Pieces slide, hop and are
+// crowned in the engine's Rust core; JS reads the finger and steps the clock and the robot.
+import { HapticType } from '../../services/HapticsService';
+import { GAME_SOUNDS } from '../../services/SoundsService';
+import { GAME_IDS } from '../../services/UtilsService';
+import { engineGame, EngineGameScreen } from '../shared/EngineGameScreen';
+import { scoreColumn, textColumn, timerColumn } from '../shared/EngineHud';
+import { useEngineGame } from '../shared/useEngineGame';
+import { useLiveState } from '../shared/useLiveState';
+import { BOARD_BORDER_WIDTH, GAME_DURATION, getLayout, LIGHT } from './CheckersConstants';
+import { createGame, dispose, drag, type GameEvent, reset, setLayout, setTheme, start, tick } from './CheckersGame';
+import { HUMAN, PIECES_PER_SIDE } from './CheckersRules';
+
+const SOUNDS = GAME_SOUNDS.CHECKERS;
+
+/** Selection, moves, captures, promotion and results each have their own feedback. */
+const FEEDBACK: Record<GameEvent, { sound?: (typeof SOUNDS)[keyof typeof SOUNDS]; haptic?: HapticType }> = {
+  select: { sound: SOUNDS.SELECT, haptic: HapticType.LIGHT },
+  move: { sound: SOUNDS.MOVE, haptic: HapticType.LIGHT },
+  capture: { sound: SOUNDS.CAPTURE, haptic: HapticType.MEDIUM },
+  king: { sound: SOUNDS.KING },
+  win: { sound: SOUNDS.WIN, haptic: HapticType.SUCCESS },
+  lose: { sound: SOUNDS.LOSE, haptic: HapticType.ERROR }
+};
+
+export const Checkers = engineGame(GAME_IDS.CHECKERS, (props) => {
+  const [score, setScore] = useLiveState(0);
+  const [captured, setCaptured] = useLiveState(0);
+  const [time, setTime] = useLiveState(GAME_DURATION);
+
+  // Win or lose (a timeout loses) as it ends
+  const { game, theme, status, screen, gameOver } = useEngineGame(props, {
+    gameId: GAME_IDS.CHECKERS,
+    create: createGame,
+    start,
+    reset,
+    dispose,
+    tick,
+    setTheme,
+    resize: (g, width, height, offset) => {
+      const l = getLayout(width, height, offset);
+      setLayout(g, l);
+      return l.size + BOARD_BORDER_WIDTH * 2;
+    },
+    drag,
+    outcome: (g) => (g.winner === HUMAN ? 'win' : 'lose'),
+    sounds: SOUNDS,
+    onStart: (fx) => fx(SOUNDS.START, HapticType.MEDIUM),
+    onOver: (fx, _status, g) => {
+      if (g.timedOut) fx(SOUNDS.TIME_UP, HapticType.ERROR);
+    },
+    wire: (g, fx) => {
+      g.onScore = setScore;
+      g.onCaptured = setCaptured;
+      g.onTime = setTime;
+      g.onEvent = (event) => fx(FEEDBACK[event].sound, FEEDBACK[event].haptic);
+    }
+  });
+
+  const timedOut = game.timedOut;
+
+  return (
+    <EngineGameScreen
+      {...screen}
+      light={LIGHT}
+      columns={[scoreColumn(score), textColumn('CAPTURED', `${captured}/${PIECES_PER_SIDE}`), timerColumn(time, theme)]}
+      subtext="Capture the robot's pieces!"
+      gameOver={gameOver({
+        title: status === 'win' ? 'YOU WON!' : timedOut ? 'TIME UP!' : 'YOU LOST!',
+        message: status === 'win' ? 'You beat the robot!' : timedOut ? 'You ran out of time!' : 'The robot wins this round!',
+        scoreLabel: 'Score',
+        score,
+        buttonText: 'Play Again!'
+      })}
+    />
+  );
+});