@nayan-ui/games 1.19.0 → 1.20.0

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

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

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