@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/shared/EngineDice.ts

@@ -1,250 +0,0 @@
-// The die the board games roll (Snakes and Ladders, Ludo King): an ivory cube with softly rounded
-// edges, flat pips set into its faces and a big red 1, and its roll: tossed up off the board, it
-// tumbles and lands with two smaller bounces, drifting a little and coming back to its spot, landing on
-// the rolled face (no snap at the end). Its shadow shrinks and fades while it's in the air, and each
-// landing kicks up a little dust. The board is the xy plane with z up; the die stands on it.
-import {
-  type Color,
-  effects,
-  type Entity,
-  type GeometryPart,
-  loft,
-  type LoftSection as Section,
-  merge,
-  type Model,
-  type Quat,
-  quat,
-  shapeGeometry,
-  type Vec3,
-  type World
-} from '@nayan-ui/engine';
-import { cacheGameAsset, createGameMesh as createShape } from './EngineMeshes';
-
-type RGB = [number, number, number];
-const IVORY: RGB = [0.98, 0.965, 0.925];
-const IVORY_EDGE: RGB = [0.86, 0.83, 0.77];
-const PIP: Color = [0.11, 0.11, 0.16, 1];
-const RED_PIP: Color = [0.84, 0.16, 0.16, 1];
-
-// ── Mesh ──────────────────────────────────────────────────────────────
-
-/** Each face's outward normal and two in-face axes, for faces 1..6 (1 opposite 6, 2 opposite 5, 3 opposite 4). */
-const FACES: { n: Vec3; a: Vec3; b: Vec3 }[] = [
-  { n: [0, 0, 1], a: [1, 0, 0], b: [0, 1, 0] },
-  { n: [0, 1, 0], a: [1, 0, 0], b: [0, 0, 1] },
-  { n: [1, 0, 0], a: [0, 1, 0], b: [0, 0, 1] },
-  { n: [-1, 0, 0], a: [0, 1, 0], b: [0, 0, 1] },
-  { n: [0, -1, 0], a: [1, 0, 0], b: [0, 0, 1] },
-  { n: [0, 0, -1], a: [1, 0, 0], b: [0, 1, 0] }
-];
-const C = 0.24;
-const PIPS: [number, number][][] = [
-  [[0, 0]],
-  [
-    [-C, C],
-    [C, -C]
-  ],
-  [
-    [-C, C],
-    [0, 0],
-    [C, -C]
-  ],
-  [
-    [-C, C],
-    [C, C],
-    [-C, -C],
-    [C, -C]
-  ],
-  [
-    [-C, C],
-    [C, C],
-    [0, 0],
-    [-C, -C],
-    [C, -C]
-  ],
-  [
-    [-C, C],
-    [C, C],
-    [-C, 0],
-    [C, 0],
-    [-C, -C],
-    [C, -C]
-  ]
-];
-
-/** How round the cube's edges are (its half-size is 0.5). */
-const EDGE = 0.12;
-
-let die: Model | null = null;
-
-/** The die, one unit across, centred. Made once per app. */
-export function dieMesh(): Model {
-  return cacheGameAsset('shared/EngineDice:dieMesh', () => dieMeshUncached());
-}
-
-function dieMeshUncached(): Model {
-  if (die) return die;
-  // A rounded cube: square-cornered sections (superellipses) along z, easing in round the top and bottom edges
-  const zs = [0, 0.25, 0.5, 0.7, 0.85, 0.95, 1].map((t) => 0.5 - EDGE + t * EDGE);
-  const half = (z: number) => {
-    const d = Math.abs(z) - (0.5 - EDGE);
-    return d <= 0 ? 0.5 : 0.5 - EDGE + Math.sqrt(Math.max(0, EDGE * EDGE - d * d));
-  };
-  const sections: Section[] = [...zs.map((z) => -z).reverse(), ...zs].map((z) => {
-    const w = Math.max(0.02, half(z));
-    return { z, bottom: -w, top: w, width: w, square: 9 };
-  });
-  const body = loft(sections, {
-    around: 48,
-    smoothness: 1,
-    // Ivory, a little deeper on the rounded edges and corners so the cube's shape reads
-    color: (_, n) => {
-      const flat = Math.max(Math.abs(n[0]), Math.abs(n[1]), Math.abs(n[2])) ** 6;
-      return [
-        IVORY_EDGE[0] + (IVORY[0] - IVORY_EDGE[0]) * flat,
-        IVORY_EDGE[1] + (IVORY[1] - IVORY_EDGE[1]) * flat,
-        IVORY_EDGE[2] + (IVORY[2] - IVORY_EDGE[2]) * flat,
-        1
-      ];
-    }
-  });
-  const parts: GeometryPart[] = [{ geometry: body }];
-  const pip = shapeGeometry('sphere');
-  FACES.forEach(({ n, a, b }, f) => {
-    const one = f === 0;
-    const size = one ? 0.28 : 0.17;
-    for (const [pa, pb] of PIPS[f]!) {
-      parts.push({
-        geometry: pip,
-        // Set into the face: a flat dot just proud of it
-        position: [0, 1, 2].map((k) => n[k]! * 0.488 + a[k]! * pa + b[k]! * pb) as unknown as Vec3,
-        scale: [0, 1, 2].map((k) => (n[k] ? 0.035 : size)) as unknown as Vec3,
-        color: one ? RED_PIP : PIP
-      });
-    }
-  });
-  die = createShape(merge(parts), { shine: 0.45 });
-  return die;
-}
-
-// ── Orientation ───────────────────────────────────────────────────────
-
-/** Rotation around any axis (normalized here: tumble axes aren't unit length). */
-const axisAngle = (x: number, y: number, z: number, angle: number): Quat => {
-  const l = Math.hypot(x, y, z) || 1;
-  return quat.axisAngle(x / l, y / l, z / l, angle);
-};
-const mul = quat.multiply;
-/** Turns face `value` up (+z). */
-const FACE_UP: Quat[] = [
-  axisAngle(1, 0, 0, 0),
-  axisAngle(1, 0, 0, Math.PI / 2),
-  axisAngle(0, 1, 0, -Math.PI / 2),
-  axisAngle(0, 1, 0, Math.PI / 2),
-  axisAngle(1, 0, 0, -Math.PI / 2),
-  axisAngle(0, 1, 0, Math.PI)
-];
-
-/** The die showing `value` toward a camera leaning back by `tilt`, turned `twist` round its up axis. */
-export const dieRotation = (tilt: number, value: number, twist = 0): Quat =>
-  mul(axisAngle(1, 0, 0, tilt), mul(axisAngle(0, 0, 1, twist), FACE_UP[value - 1]!));
-
-// ── The roll ──────────────────────────────────────────────────────────
-
-export type DieRoll = {
-  die: Entity;
-  shadow: Entity;
-  /** Where the die rests (its centre), and its shadow's place and size there. */
-  rest: Vec3;
-  shadowAt: Vec3;
-  shadowScale: Vec3;
-  /** The die's edge, in world units. */
-  size: number;
-  /** The camera's lean (the rolled face ends up facing it). */
-  tilt: number;
-  value: number;
-  /** Seconds, from the toss to the die at rest. */
-  duration: number;
-  /** For delayed effects (the landing dust): whether the scene is gone. */
-  disposed?: () => boolean;
-};
-
-// The bounces: when (fraction of the roll) the die is at the top of each hop and lands, and how high (in die sizes)
-const HOPS = [
-  { up: 0.2, down: 0.44, height: 1.7 },
-  { up: 0.555, down: 0.67, height: 0.55 },
-  { up: 0.735, down: 0.8, height: 0.16 }
-];
-
-/** Rolls the die to `value`: tossed up, tumbling, bouncing to rest on its spot showing `value`. */
-export function rollDie(world: World, r: DieRoll) {
-  const { die, shadow, rest, size, duration } = r;
-  world.stopAnimation(die);
-  world.stopAnimation(shadow);
-  // A little drift on the board while it bounces, back to its spot by the end
-  const angle = Math.random() * Math.PI * 2;
-  const drift = (k: number): [number, number] => [Math.cos(angle) * size * k, Math.sin(angle) * size * k * 0.6];
-  const lands = [0.35, -0.2, 0.06];
-  const frames: { position: Vec3; at: number }[] = [];
-  const shadowFrames: { position: Vec3; scale: Vec3; color: Color; at: number }[] = [];
-  const shadowPos = (dx: number, dy: number): Vec3 => [r.shadowAt[0] + dx, r.shadowAt[1] + dy, r.shadowAt[2]];
-  const shadowAt = (k: number, lift: number, at: number) => {
-    const [dx, dy] = drift(k);
-    const shrink = 1 - Math.min(0.55, lift * 0.3);
-    shadowFrames.push({
-      position: shadowPos(dx, dy),
-      scale: [r.shadowScale[0] * shrink, r.shadowScale[1] * shrink, r.shadowScale[2]],
-      color: [0, 0, 0, 0.22 * shrink],
-      at
-    });
-  };
-  let from = 0;
-  HOPS.forEach((hop, i) => {
-    const to = lands[i]!;
-    const mid = (from + to) / 2;
-    const [ax, ay] = drift(mid);
-    frames.push({ position: [rest[0] + ax, rest[1] + ay, rest[2] + hop.height * size], at: hop.up });
-    shadowAt(mid, hop.height, hop.up);
-    const [lx, ly] = drift(to);
-    frames.push({ position: [rest[0] + lx, rest[1] + ly, rest[2]], at: hop.down });
-    shadowAt(to, 0, hop.down);
-    from = to;
-  });
-  frames.push({ position: rest, at: 1 });
-  shadowFrames.push({ position: r.shadowAt, scale: r.shadowScale, color: [0, 0, 0, 0.22], at: 1 });
-  world.animate(die, frames, { duration, path: 'smooth', easing: 'linear' });
-  world.animate(shadow, shadowFrames, { duration, easing: 'linear' });
-
-  // Tumbling: a few big random turns on the way, slowing with the bounces, landing on the rolled face
-  const finalTwist = (Math.round(Math.random() * 4) - 2) * (Math.PI / 2) + (Math.random() - 0.5) * 0.3;
-  const final = dieRotation(r.tilt, r.value, finalTwist);
-  const turns = [2.4, 2.1, 1.6, 0.9];
-  const spins: { rotation: Quat; at: number }[] = [];
-  let q = final;
-  // Built backwards from the landing, so the last turn ends exactly on the rolled face
-  for (let i = turns.length - 1; i >= 0; i--) {
-    const axis: Vec3 = [Math.random() - 0.5, Math.random() - 0.5, Math.random() - 0.5];
-    q = mul(axisAngle(axis[0], axis[1], axis[2], -turns[i]!), q);
-    spins.unshift({ rotation: q, at: [0.12, 0.3, 0.5, 0.64][i]! });
-  }
-  spins.push({ rotation: final, at: HOPS[1]!.down });
-  spins.push({ rotation: final, at: 1 });
-  world.animate(die, spins, { duration, easing: 'linear' });
-
-  // A puff of dust where it lands, smaller each bounce
-  HOPS.slice(0, 2).forEach((hop, i) =>
-    world.after(hop.down * duration, () => {
-      if (r.disposed?.()) return;
-      const [lx, ly] = drift(lands[i]!);
-      effects.dust(world, {
-        position: [rest[0] + lx, rest[1] + ly, rest[2] - size * 0.45],
-        count: i ? 3 : 6,
-        size: size * (i ? 0.35 : 0.5),
-        speed: size * 2.5,
-        lifetime: 0.4,
-        color: [1, 1, 1, 0.45],
-        endSize: 1.8
-      });
-    })
-  );
-}

package/src/games/shared/EngineFootprint.ts

@@ -1,35 +0,0 @@
-// Vehicle footprints for the racing games: each vehicle's outline seen from above, so traffic collides
-// with the body itself (a car's tapered nose and waist, a bike's narrow tyres and wider bars) rather
-// than with a box the width of its lane.
-
-/** A vehicle's outline from above: its length, and its half width at each point along it (model z, front at -length / 2). */
-export type Footprint = { length: number; halfWidth: (z: number) => number };
-
-/**
- * How far two footprints overlap sideways (> 0 when they touch): `b` is `ahead` metres in front of
- * `a` along the road and `gap` across it, both facing down the road. Sampled along the stretch where
- * they overlap lengthways; -Infinity when they don't.
- */
-export function overlapAcross(a: Footprint, b: Footprint, ahead: number, gap: number, samples = 9): number {
-  const lo = Math.max(-a.length / 2, ahead - b.length / 2);
-  const hi = Math.min(a.length / 2, ahead + b.length / 2);
-  if (hi <= lo) return -Infinity;
-  let deepest = -Infinity;
-  for (let i = 0; i < samples; i++) {
-    const s = lo + ((hi - lo) * i) / (samples - 1);
-    // A point `s` ahead of a vehicle's middle is at model z = -s (models face -z).
-    deepest = Math.max(deepest, a.halfWidth(-s) + b.halfWidth(-(s - ahead)) - Math.abs(gap));
-  }
-  return deepest;
-}
-
-/**
- * Whether a contact that just began was nose to tail (a front hit) rather than side by side: they were
- * still (almost) clear lengthways a frame ago. `wasAhead` and `ahead` are the gap along the road then
- * and now. Allows for how far they closed in the frame and for tapered noses and tails.
- */
-export function frontHit(a: Footprint, b: Footprint, wasAhead: number, ahead: number, taper = 0.5): boolean {
-  const overlapBefore = (a.length + b.length) / 2 - Math.abs(wasAhead);
-  const closed = Math.max(0, Math.abs(wasAhead) - Math.abs(ahead));
-  return overlapBefore < taper + closed;
-}