@nayan-ui/games 1.20.0 → 1.21.0

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

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

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

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