@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/knife-hit/KnifeHitGame.ts

@@ -1,264 +0,0 @@
-// Knife Hit's play, with no React: build a game with `createGame`, give it a layout, `start` it and
-// `tick` it every frame. The log spins (now and then reversing); tap to throw a knife up into it. A
-// knife that lands too near another clashes and ends the round; one that sticks scores 1,500, and an
-// apple it passes through 1,000 more. Stick all eight to win; the two-minute clock running out loses.
-//
-// Ported from the original version's UI-thread physics and service, in the same order and at the same
-// fixed 60 Hz steps: the log turns, a flying knife rises, and on the step it reaches the log's bottom
-// its landing angle is read off the log's rotation.
-import { type Camera, World } from '@nayan-ui/engine';
-import type { GameTheme } from '../../services/ThemeService';
-import { aimTilted } from '../shared/EngineTilt';
-import {
-  APPLE_BONUS,
-  APPLE_CHANCE,
-  APPLE_REACH,
-  COLLISION_ANGLE,
-  FLIP_CHANCE,
-  KNIVES_PER_ROUND,
-  type Layout,
-  MAX_PENDING_MS,
-  normalizeAngle,
-  OBSTACLES,
-  POINTS_PER_KNIFE,
-  ROTATION_SPEED,
-  ROTATION_SPREAD,
-  STEP_MS,
-  STEP_TOLERANCE_MS,
-  THROW_SPEED,
-  TIME_LIMIT,
-  TURN_INTERVAL
-} from './KnifeHitConstants';
-import {
-  buildScene,
-  burstApple,
-  celebrate,
-  clash,
-  dressLog,
-  placeKnife,
-  removeScene,
-  type Scene,
-  setSceneTheme,
-  showCount,
-  spinLog,
-  stick
-} from './KnifeHitScene';
-
-export type Phase = 'ready' | 'playing' | 'over';
-/** throw: a knife left the hand; stick / apple / clash: how it landed. */
-export type GameEvent = 'throw' | 'stick' | 'apple' | 'clash';
-
-const WORLD_CAPACITY = 300; // the log and its knives, the counters, and the bursts
-
-/** Obstacle knives evenly round the log. */
-const obstacles = () => Array.from({ length: OBSTACLES }, (_, i) => (i / OBSTACLES) * Math.PI * 2);
-
-export function createGame(theme: GameTheme) {
-  const world = new World(WORLD_CAPACITY);
-  const camera: Camera = { eye: [0, 0, 240], target: [0, 0, 0], fov: 1, ortho: 1 };
-  const g = {
-    world,
-    camera,
-    theme,
-    layout: null as Layout | null,
-    scene: null as Scene | null,
-    phase: 'ready' as Phase,
-    /** The knives in the log (angles: the play area's, y down), the apple if there is one. */
-    stuck: obstacles(),
-    apple: null as number | null,
-    appleTaken: false,
-    rotation: 0,
-    speed: ROTATION_SPEED,
-    direction: 1,
-    turnTimer: 0,
-    turnInterval: 120,
-    /** The knife in flight: its tip's height in the play area, or null. */
-    flying: null as number | null,
-    knivesLeft: KNIVES_PER_ROUND,
-    /** Score and the countdown live in the engine (Rust), advanced by world.update. */
-    get score() {
-      return world.scoreboard.score;
-    },
-    get timeLeft() {
-      return world.scoreboard.shownSeconds;
-    },
-    won: false,
-    pending: 0,
-    // UI hooks, set by the screen.
-    onPhase: (_p: Phase) => {},
-    onScore: (_s: number) => {},
-    onTime: (_t: number) => {},
-    onKnives: (_n: number) => {},
-    onEvent: (_e: GameEvent) => {}
-  };
-  world.scoreboard.reset(0, TIME_LIMIT);
-  world.scoreboard.handlers = {
-    onSecond: (t) => g.onTime(t),
-    onTimeUp: () => g.phase === 'playing' && end(g, false)
-  };
-  return g;
-}
-export type Game = ReturnType<typeof createGame>;
-
-// ── Scene ─────────────────────────────────────────────────────────────
-
-/** Lays the log out for the view (first layout, header height, rotation): rebuilt from the round's state. */
-export function setLayout(g: Game, l: Layout) {
-  if (g.scene) removeScene(g.world, g.scene);
-  g.layout = l;
-  aimTilted(g.camera, l);
-  g.scene = buildScene(g.world, l, g.theme);
-  dressLog(g.world, l, g.scene, g.stuck, g.appleTaken ? null : g.apple);
-  spinLog(g.world, g.scene, g.rotation);
-  drawHand(g);
-}
-
-export function setTheme(g: Game, theme: GameTheme) {
-  g.theme = theme;
-  if (g.scene) setSceneTheme(g.world, g.scene, theme);
-}
-
-function drawHand(g: Game) {
-  const { layout: l, scene: s } = g;
-  if (!l || !s) return;
-  placeKnife(g.world, l, s, g.flying ?? l.knifeStartY, g.phase !== 'over' && (g.flying !== null || g.knivesLeft > 0));
-  showCount(g.world, s, g.knivesLeft);
-}
-
-// ── Run ───────────────────────────────────────────────────────────────
-
-/** A fresh round: three knives in the log, sometimes an apple, the log's speed and turns varied a little. */
-export function start(g: Game) {
-  if (g.phase !== 'ready') return;
-  g.stuck = obstacles();
-  g.apple = null;
-  if (Math.random() < APPLE_CHANCE) {
-    let a = Math.random() * Math.PI * 2;
-    for (let attempt = 0; attempt < 20; attempt++) {
-      if (g.stuck.every((k) => Math.abs(normalizeAngle(a - k)) >= COLLISION_ANGLE * 2)) break;
-      a = Math.random() * Math.PI * 2;
-    }
-    g.apple = a;
-  }
-  g.appleTaken = false;
-  g.rotation = 0;
-  g.speed = ROTATION_SPEED + (Math.random() - 0.5) * ROTATION_SPREAD;
-  g.direction = 1;
-  g.turnTimer = 0;
-  g.turnInterval = TURN_INTERVAL[0] + Math.floor(Math.random() * (TURN_INTERVAL[1] - TURN_INTERVAL[0]));
-  g.flying = null;
-  g.knivesLeft = KNIVES_PER_ROUND;
-  g.world.scoreboard.reset();
-  g.world.scoreboard.startCountdown(TIME_LIMIT);
-  g.pending = 0;
-  g.phase = 'playing';
-  if (g.layout && g.scene) dressLog(g.world, g.layout, g.scene, g.stuck, g.apple);
-  drawHand(g);
-  g.onScore(0);
-  g.onTime(TIME_LIMIT);
-  g.onKnives(KNIVES_PER_ROUND);
-  g.onPhase('playing');
-}
-
-/** Back to the still preview log (Stop, Play Again). The world, and the GPU view drawing it, are kept. */
-export function reset(g: Game) {
-  g.stuck = obstacles();
-  g.apple = null;
-  g.appleTaken = false;
-  g.rotation = 0;
-  g.flying = null;
-  g.knivesLeft = KNIVES_PER_ROUND;
-  g.world.scoreboard.reset(0, TIME_LIMIT);
-  g.won = false;
-  g.phase = 'ready';
-  if (g.layout && g.scene) dressLog(g.world, g.layout, g.scene, g.stuck, null);
-  drawHand(g);
-  g.onScore(0);
-  g.onTime(TIME_LIMIT);
-  g.onKnives(KNIVES_PER_ROUND);
-  g.onPhase('ready');
-}
-
-export function dispose(g: Game) {
-  g.world.dispose();
-}
-
-export function tick(g: Game, dt: number) {
-  if (g.world.isDisposed) return;
-  if (g.phase === 'playing') {
-    // Fixed 60 Hz steps; a long frame catches up at most a few
-    let pending = Math.min(g.pending + dt * 1000, MAX_PENDING_MS);
-    while (g.phase === 'playing' && pending >= STEP_MS - STEP_TOLERANCE_MS) {
-      pending -= STEP_MS;
-      step(g);
-    }
-    g.pending = pending;
-    if (g.scene) spinLog(g.world, g.scene, g.rotation);
-    if (g.phase === 'playing') drawHand(g);
-  }
-  g.world.update(dt);
-}
-
-function end(g: Game, won: boolean) {
-  g.world.scoreboard.stop();
-  g.won = won;
-  g.phase = 'over';
-  g.onPhase('over');
-}
-
-/** One 60 Hz tick: the log turns (and maybe reverses), a flying knife rises and maybe lands. */
-function step(g: Game) {
-  const l = g.layout;
-  if (!l) return;
-  g.rotation += g.speed * g.direction;
-  if (++g.turnTimer >= g.turnInterval) {
-    g.turnTimer = 0;
-    if (Math.random() < FLIP_CHANCE) g.direction *= -1;
-  }
-  if (g.flying === null) return;
-  const y = g.flying - THROW_SPEED;
-  if (y > l.logY + l.logRadius) {
-    g.flying = y;
-    return;
-  }
-  // Landed (shown where it last was, just short of the log): where on the log, by its turn
-  const tipY = g.flying;
-  g.flying = null;
-  const angle = normalizeAngle(Math.PI / 2 - g.rotation);
-  const { scene: s } = g;
-  if (g.stuck.some((k) => Math.abs(normalizeAngle(angle - k)) < COLLISION_ANGLE)) {
-    if (s) clash(g.world, l, s, tipY);
-    g.onEvent('clash');
-    end(g, false);
-    return;
-  }
-  if (g.apple !== null && !g.appleTaken && Math.abs(normalizeAngle(angle - g.apple)) < APPLE_REACH) {
-    g.appleTaken = true;
-    g.world.scoreboard.add(APPLE_BONUS);
-    if (s) burstApple(g.world, l, s);
-    g.onEvent('apple');
-  }
-  g.stuck.push(angle);
-  g.world.scoreboard.add(POINTS_PER_KNIFE);
-  if (s) stick(g.world, l, s, angle);
-  drawHand(g); // the next knife to hand (or none, after the last)
-  g.onScore(g.score);
-  g.onEvent('stick');
-  if (g.knivesLeft <= 0) {
-    if (s) celebrate(g.world, l);
-    end(g, true);
-  }
-}
-
-// ── The tap ───────────────────────────────────────────────────────────
-
-/** A finger down throws the next knife, if one's ready and none is in the air. */
-export function throwKnife(g: Game) {
-  const l = g.layout;
-  if (!l || g.phase !== 'playing' || g.flying !== null || g.knivesLeft <= 0) return;
-  g.flying = l.knifeStartY;
-  g.knivesLeft -= 1;
-  g.onKnives(g.knivesLeft);
-  g.onEvent('throw');
-  drawHand(g);
-}

package/src/games/knife-hit/KnifeHitScene.ts

@@ -1,360 +0,0 @@
-// Everything Knife Hit draws: a spinning log end-on (growth rings on its face, bark round its edge) with
-// knives stuck into its rim and sometimes an apple, the knife waiting to be thrown, and the round's
-// knives counted down the left. Seen from a little above and in front (shared/EngineTilt: an
-// orthographic camera tipped forward, one world unit per point). The log is a pivot carrying its mesh,
-// its knives and its apple, so one rotation spins them all. Every knife is the same mesh.
-//
-// The play area's points (x right, y down, from its top-left, as the rules use) map to the view as the
-// original canvas sat in it.
-import {
-  type Color,
-  effects,
-  type Entity,
-  extrude,
-  lathe,
-  merge,
-  type Model,
-  type MutableQuat,
-  Path,
-  quat,
-  shapeGeometry,
-  type Vec3,
-  type World
-} from '@nayan-ui/engine';
-import type { GameTheme } from '../../services/ThemeService';
-import { setBackdropTheme, spawnBackdrop } from '../shared/EngineBackdrop';
-import { getFruits } from '../shared/EngineFruits';
-import { noise } from '../shared/EngineMeadow';
-import { cacheGameAsset, createGameMesh as createShape } from '../shared/EngineMeshes';
-import { placeTiltedBackdrop, unproject } from '../shared/EngineTilt';
-import { toColor } from '../shared/EngineUtils';
-import { BOUNCE_TIME, KICK_POINTS, KNIVES_PER_ROUND, type Layout } from './KnifeHitConstants';
-
-const meshes = new Map<string, Model>();
-const cached = (key: string, build: () => Model) => {
-  let m = meshes.get(key);
-  if (!m) {
-    m = cacheGameAsset('knife-hit/KnifeHitScene:' + key, build);
-    meshes.set(key, m);
-  }
-  return m;
-};
-type RGB = [number, number, number];
-const rgb = (css: string): RGB => {
-  const [r, g, b] = toColor(css);
-  return [r, g, b];
-};
-const mix = (a: RGB, b: RGB, t: number): RGB => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
-const STAND_UP = quat.x(Math.PI / 2);
-const BACKDROP_DEPTH = 80;
-const KNIFE_SCALE = 1.15; // a knife mesh's length, of the knife length
-
-/** A play-area point (y down) in the world, at height z. */
-export function toWorld(l: Layout, x: number, y: number, z = 0): Vec3 {
-  const [wx, wy] = unproject(l, x, l.top + y, z);
-  return [wx, wy, z];
-}
-/** A point on the log at angle `a` (the play area's angles: y down), `r` from its centre, in the log's own frame. */
-const onLog = (a: number, r: number, z = 0): Vec3 => [Math.cos(a) * r, -Math.sin(a) * r, z];
-/** Points a knife (or anything built pointing +y) at the log's centre from angle `a`. */
-const inward = (a: number) => quat.z(Math.PI / 2 - a);
-
-// ── Meshes ────────────────────────────────────────────────────────────
-
-/** The log, one unit across and 0.6 deep: rings on its faces, bark round its side. */
-const logMesh = () =>
-  cached('kh-log', () => {
-    const inner = rgb('#795548');
-    const ring = rgb('#6D4C41');
-    const centre = rgb('#8D6E63');
-    const bark = rgb('#4E342E');
-    const dark = rgb('#3E2723');
-    return createShape(
-      lathe(
-        [
-          [0.001, 0.3],
-          [0.25, 0.3],
-          [0.44, 0.3],
-          [0.47, 0.29],
-          [0.5, 0.25],
-          [0.5, -0.25],
-          [0.47, -0.29],
-          [0.44, -0.3],
-          [0.001, -0.3]
-        ],
-        {
-          segments: 48,
-          color: ({ position: p, normal: n }) => {
-            const r = Math.hypot(p[0], p[2]);
-            if (Math.abs(n[1]) < 0.6) {
-              // Bark: dark and furrowed
-              const furrow = 0.5 + 0.5 * Math.sin(Math.atan2(p[2], p[0]) * 26 + noise(p[0] * 9, p[2] * 9) * 4);
-              return mix(dark, bark, furrow * 0.8);
-            }
-            if (r > 0.45) return bark;
-            // The face: growth rings out from a pale heart
-            const rings = 0.5 + 0.5 * Math.sin(r * 70 + noise(p[0] * 6, p[2] * 6) * 2);
-            return mix(mix(centre, inner, Math.min(1, r * 3)), ring, rings * 0.55);
-          }
-        }
-      ),
-      { shine: 0.1 }
-    );
-  });
-
-/**
- * A knife one unit long, its tip at the origin pointing +y: a steel blade curving up to its point from
- * a straight spine, a bright honed edge along it and a dark fuller down the flat, a gold guard, and a
- * wooden handle wrapped in grip bands ending in a gold pommel. (Paths run y down, away from the tip.)
- */
-const knifeMesh = () =>
-  cached('kh-knife-v2', () => {
-    const blade = extrude(
-      new Path()
-        .moveTo(0, 0)
-        .quadraticTo(0.1, 0.12, 0.1, 0.3)
-        .lineTo(0.1, 0.6)
-        .lineTo(-0.08, 0.6)
-        .lineTo(-0.08, 0.24)
-        .quadraticTo(-0.07, 0.09, 0, 0)
-        .close(),
-      { depth: 0.05 }
-    );
-    const edge = extrude(
-      new Path()
-        .moveTo(0.008, 0.03)
-        .quadraticTo(0.1, 0.13, 0.1, 0.3)
-        .lineTo(0.1, 0.58)
-        .lineTo(0.068, 0.58)
-        .lineTo(0.068, 0.3)
-        .quadraticTo(0.066, 0.16, 0.008, 0.03)
-        .close(),
-      { depth: 0.056 }
-    );
-    const gold = rgb('#FFC400');
-    const wood = rgb('#8D5A32');
-    const band = rgb('#3E2A1C');
-    return createShape(
-      merge([
-        { geometry: blade, color: [...rgb('#9EADB8'), 1] },
-        { geometry: edge, color: [...rgb('#F3F7FA'), 1] },
-        { geometry: shapeGeometry('cube'), position: [-0.025, -0.4, 0.027], scale: [0.025, 0.34, 0.005], color: [...rgb('#6F7F8A'), 1] },
-        { geometry: shapeGeometry('roundedBox'), position: [0, -0.625, 0], scale: [0.3, 0.055, 0.11], color: [...gold, 1] },
-        { geometry: shapeGeometry('roundedBox'), position: [0, -0.8, 0], scale: [0.15, 0.3, 0.12], color: [...wood, 1] },
-        ...[-0.7, -0.78, -0.86, -0.94].map((y) => ({
-          geometry: shapeGeometry('roundedBox'),
-          position: [0, y, 0] as Vec3,
-          scale: [0.162, 0.025, 0.13] as Vec3,
-          color: [...band, 1] as Color
-        })),
-        { geometry: shapeGeometry('sphere'), position: [0, -0.97, 0], scale: [0.17, 0.08, 0.13], color: [...gold, 1] }
-      ]),
-      { center: false, shine: 0.75 }
-    );
-  });
-
-// ── Spawning ──────────────────────────────────────────────────────────
-
-export type Scene = {
-  countShown?: number;
-  backdrop: Entity;
-  /** The log's pivot (spins), and what rides on it. */
-  pivot: Entity;
-  log: Entity;
-  stuck: Entity[];
-  apple: Entity | null;
-  /** The knife in hand. */
-  knife: Entity;
-  /** The round's knives, counted down the left. */
-  counters: Entity[];
-};
-
-export function buildScene(world: World, l: Layout, theme: GameTheme): Scene {
-  const backdrop = spawnBackdrop(world, l.width, l.height, -BACKDROP_DEPTH, theme);
-  placeTiltedBackdrop(world, backdrop, l, BACKDROP_DEPTH);
-  const pivot = world.spawn({ mesh: 'none', position: toWorld(l, l.logX, l.logY), pickable: false });
-  const log = world.spawn({ mesh: logMesh(), parent: pivot, rotation: STAND_UP, scale: l.logRadius * 2, pickable: false });
-  const knife = world.spawn({ mesh: knifeMesh(), position: toWorld(l, l.logX, l.knifeStartY), scale: l.knifeLength * KNIFE_SCALE, pickable: false });
-  const left = (l.width - l.gameWidth) / 2 + 22;
-  const counters = Array.from({ length: KNIVES_PER_ROUND }, (_, i) =>
-    world.spawn({ mesh: knifeMesh(), position: toWorld(l, left, l.areaHeight - 26 - i * 20), scale: 18, color: [1, 1, 1, 1], pickable: false })
-  );
-  return { backdrop, pivot, log, stuck: [], apple: null, knife, counters };
-}
-
-export function removeScene(world: World, s: Scene) {
-  for (const e of [s.backdrop, s.pivot, s.knife, ...s.counters]) world.despawn(e);
-}
-
-export function setSceneTheme(world: World, s: Scene, theme: GameTheme) {
-  setBackdropTheme(world, s.backdrop, theme);
-}
-
-/** The log's knives and apple for a round (or the preview), the log back at rest. */
-export function dressLog(world: World, l: Layout, s: Scene, angles: number[], apple: number | null) {
-  for (const e of s.stuck) world.despawn(e);
-  if (s.apple != null) world.despawn(s.apple);
-  world.stopAnimation(s.pivot);
-  world.set(s.pivot, { position: toWorld(l, l.logX, l.logY), rotation: quat.z(0) });
-  s.stuck = angles.map((a) => stickKnife(world, l, s, a));
-  s.apple = null;
-  if (apple !== null) {
-    const fruit = getFruits().apple;
-    const size = l.appleRadius * 2;
-    const at = onLog(apple, l.logRadius + l.appleRadius + 4);
-    s.apple = world.spawn({
-      mesh: fruit.whole,
-      parent: s.pivot,
-      position: [at[0] - fruit.center[0] * size, at[1] - fruit.center[1] * size, at[2] - fruit.center[2] * size],
-      scale: size,
-      pickable: false
-    });
-  }
-}
-
-function stickKnife(world: World, l: Layout, s: Scene, a: number): Entity {
-  return world.spawn({
-    mesh: knifeMesh(),
-    parent: s.pivot,
-    position: onLog(a, l.logRadius - l.tipLength * 0.5),
-    rotation: inward(a),
-    scale: l.knifeLength * KNIFE_SCALE,
-    pickable: false
-  });
-}
-
-// Scratch for the per-frame spin (world.set copies it).
-const SPIN: MutableQuat = [0, 0, 0, 1];
-
-/** The log turned to `rotation` (radians, clockwise on screen). */
-export function spinLog(world: World, s: Scene, rotation: number) {
-  world.set(s.pivot, { rotation: quat.z(-rotation, SPIN) });
-}
-
-/** The knife in hand, its tip at play-area height `y`; hidden when there's none to throw. */
-export function placeKnife(world: World, l: Layout, s: Scene, y: number, shown: boolean) {
-  world.stopAnimation(s.knife);
-  world.set(s.knife, { position: toWorld(l, l.logX, y), rotation: quat.z(0), scale: shown ? l.knifeLength * KNIFE_SCALE : 0, color: [1, 1, 1, 1] });
-}
-
-/** The count down the left: bright for knives left, dim for those thrown. */
-export function showCount(world: World, s: Scene, left: number) {
-  if (s.countShown === left) return;
-  s.countShown = left;
-  s.counters.forEach((e, i) => world.set(e, { color: i < left ? [1, 1, 1, 1] : [0.35, 0.35, 0.38, 0.45] }));
-}
-
-// ── Impacts ───────────────────────────────────────────────────────────
-
-/** A knife sinks into the rim: it joins the log, the log jumps a touch, chips fly. */
-export function stick(world: World, l: Layout, s: Scene, a: number) {
-  const knife = stickKnife(world, l, s, a);
-  s.stuck.push(knife);
-  // It quivers where it bit in, settling fast
-  world.animate(
-    knife,
-    [
-      { turn: [0, 0, 0.12], at: 0.15 },
-      { turn: [0, 0, -0.2], at: 0.4 },
-      { turn: [0, 0, 0.11], at: 0.65 },
-      { turn: [0, 0, -0.03], at: 1 }
-    ],
-    { duration: 0.32, easing: 'linear' }
-  );
-  // The face flashes pale where the blade struck
-  world.animate(s.log, [{ color: [1.25, 1.18, 1.1, 1], at: 0.15 }, { color: [1, 1, 1, 1] }], { duration: 0.22 });
-  const rest = toWorld(l, l.logX, l.logY);
-  world.animate(s.pivot, [{ position: [rest[0], rest[1] + KICK_POINTS, rest[2]], at: 0.3 }, { position: rest }], { duration: 0.18 });
-  // Chips at the point of impact, which (in the view) is always the log's bottom
-  effects.shatter(world, {
-    position: toWorld(l, l.logX, l.logY + l.logRadius, 4),
-    count: 7,
-    size: 3.5,
-    speed: 120,
-    direction: [0, -1, 0.6],
-    spread: 1.1,
-    lifetime: 0.4,
-    gravity: -900,
-    colors: [toColor('#C68A5B'), toColor('#8D6E63'), toColor('#5D4037')],
-    flash: false
-  });
-  // A puff of sawdust off the cut
-  effects.dust(world, {
-    position: toWorld(l, l.logX, l.logY + l.logRadius, 6),
-    count: 5,
-    size: 9,
-    speed: 60,
-    direction: [0, -1, 0.5],
-    spread: 1.4,
-    lifetime: 0.45,
-    color: [0.93, 0.8, 0.62, 0.6],
-    endSize: 2.2
-  });
-}
-
-/** A knife strikes another: sparks, the log shudders, the thrown knife spins away and falls. */
-export function clash(world: World, l: Layout, s: Scene, tipY: number) {
-  const at = toWorld(l, l.logX, tipY, 4);
-  effects.sparks(world, {
-    position: at,
-    count: 16,
-    size: 3,
-    speed: 220,
-    direction: [0, -1, 0.4],
-    spread: 1.3,
-    lifetime: 0.35,
-    gravity: -600,
-    colors: [
-      [1, 0.92, 0.6],
-      [1, 0.7, 0.25]
-    ]
-  });
-  world.animate(s.pivot, { shake: 6 }, { duration: 0.25 });
-  // A white-hot flash where steel met steel
-  effects.flash(world, {
-    position: at,
-    mesh: 'sphere',
-    size: 22,
-    lifetime: 0.14,
-    color: [2.2, 2, 1.5, 0.9],
-    endSize: 1.8,
-    endColor: [2, 1.6, 0.8, 0]
-  });
-  const side = Math.random() < 0.5 ? -1 : 1;
-  world.animate(s.knife, { position: toWorld(l, l.logX + side * 70, tipY + 220, 30) }, { duration: BOUNCE_TIME, easing: 'easeOut' });
-  world.animate(s.knife, { turn: [0, 0, side * Math.PI * 3] }, { duration: BOUNCE_TIME, easing: 'easeOut' });
-  world.animate(s.knife, { color: [1, 1, 1, 0] }, { duration: BOUNCE_TIME, easing: 'easeIn' });
-}
-
-/** The apple's hit: it bursts in a spray of juice. */
-export function burstApple(world: World, l: Layout, s: Scene) {
-  const e = s.apple;
-  if (e == null) return;
-  s.apple = null;
-  const size = l.appleRadius * 2;
-  world.animate(e, { scale: size * 1.7 }, { duration: 0.32, easing: 'easeOut' });
-  world.animate(e, { color: [1, 1, 1, 0] }, { duration: 0.32 });
-  effects.splash(world, {
-    // Knives land at the log's bottom, so that's where an apple is when it's hit
-    position: toWorld(l, l.logX, l.logY + l.logRadius + l.appleRadius, 6),
-    count: 16,
-    size: 3.5,
-    speed: 160,
-    lifetime: 0.5,
-    gravity: -500,
-    colors: [toColor('#D32F2F'), toColor('#EF5350'), toColor('#FFF3E0')]
-  });
-}
-
-/** Every knife in: a shower of confetti from the log. */
-export function celebrate(world: World, l: Layout) {
-  effects.confetti(world, {
-    position: toWorld(l, l.logX, l.logY, 20),
-    count: 50,
-    size: 5,
-    speed: 320,
-    lifetime: 1.2,
-    gravity: -600,
-    colors: ['#FFD600', '#D32F2F', '#4CAF50', '#90A4AE'].map((c) => toColor(c))
-  });
-}