@nayan-ui/games 1.19.0 → 1.20.0

package/src/games/bike-racing/BikeRacingGame.ts

@@ -0,0 +1,557 @@
+// Bike Racing's rules, with no React: build a run with `createGame`, then `start` it and `tick` it every
+// frame. Traffic, crashes, scoring, the autoplay bot and the camera. The screen listens through the
+// `on…` hooks. Built as Car Racing is (games/car-racing), on its track and roadside.
+import { audio, type Camera, effects, type Entity, haptics, type Vec3, type Voice, World } from '@nayan-ui/engine';
+import { playBankSound } from '../../services/SoundsService';
+import {
+  buildHorizon,
+  buildRoad,
+  burn,
+  burning,
+  clamp,
+  explode,
+  type Fire,
+  forwardOf,
+  newSample,
+  orient,
+  pick,
+  placeAt,
+  placeSegment,
+  rand,
+  recycleRoad,
+  rightOf,
+  setHorizonNight,
+  spawnProps,
+  spawnRaceMarkers,
+  Track
+} from '../car-racing/CarRacingScene';
+import { frontHit, overlapAcross } from '../shared/EngineFootprint';
+import type { HudFeedback } from '../shared/EngineHud';
+import { createChase, updateChase } from '../shared/EngineRacingChase';
+import { sideImpactSpeed, smoothSteeringPose, stepSteering } from '../shared/EngineRacingHandling';
+import { BIKE_FOOTPRINT } from './BikeMeshes';
+import {
+  type Assets,
+  AUTOPLAY,
+  CAMERA_FOV,
+  CRASH_SLOWDOWN,
+  EDGE,
+  FINISH_CLEAR,
+  getRacingSounds,
+  INVULNERABLE,
+  LANES,
+  LATERAL_SPEED,
+  LEAN,
+  LIVES,
+  MAX_LEAN,
+  NEAR_MISS_GAP,
+  PAINTS,
+  PLAYER_PAINT,
+  POINTS_PER_BIKE_PASSED,
+  ROAD_HALF,
+  SPAWN_AHEAD,
+  START_SPEED,
+  STEER_RESPONSE,
+  TRACK_LENGTH,
+  TRAFFIC_SPEED
+} from './BikeRacingConstants';
+import { leanBike, setBikeNight, spawnBike } from './BikeRacingScene';
+
+export type Phase = 'ready' | 'playing' | 'over';
+
+const WHEELIE = 0.38; // radians: the nose comes up as the run starts
+const WHEELIE_TIME = 1.1; // seconds
+
+// Reused per frame, so the game loop doesn't allocate.
+const tmp: [number, number, number] = [0, 0, 0];
+const driveRotation: [number, number, number, number] = [0, 0, 0, 1];
+const at: [number, number, number] = [0, 0, 0];
+const sample = newSample();
+const look = newSample();
+
+export function createGame(a: Assets, night: boolean) {
+  const world = new World(2600);
+  const camera: Camera = { eye: [5, 2.5, 5], target: [0, 0.6, 0], fov: CAMERA_FOV };
+  const segments = buildRoad(world, a);
+  const horizon = buildHorizon(world, night);
+  const player = spawnBike(world, a, PLAYER_PAINT, [0, a.bike.size[1] / 2, 0], night);
+  world.listener = player.root;
+
+  const g = {
+    world,
+    night,
+    track: new Track(),
+    chase: createChase(),
+    assets: a,
+    camera,
+    player,
+    horizon,
+    segments,
+    traffic: [] as Bike[],
+    /** Wrecks on fire. */
+    burning: [] as Fire[],
+    phase: 'ready' as Phase,
+    time: 0,
+    s: 0,
+    d: 0,
+    target: 0, // where the finger wants the bike across the road
+    dragX: 0, // the finger's last dx, so each move steers by its own distance
+    speed: 0,
+    lateral: 0,
+    steeringGoal: 0,
+    steeringPose: { yaw: 0, roll: 0 },
+    spawnTimer: 0.5,
+    invulnerable: 0,
+    scrape: 0,
+    orbit: 0,
+    /** Seconds left of the start's wheelie, and of the wobble after a crash. */
+    wheelie: 0,
+    wobble: 0,
+    /** Score, lives and the countdown live in the engine (Rust), advanced by world.update. */
+    get score() {
+      return world.scoreboard.score;
+    },
+    get lives() {
+      return world.scoreboard.lives;
+    },
+    /** Metres left to the finish gate. */
+    left: TRACK_LENGTH,
+    shake: 0,
+    engine: null as Voice | null,
+    audible: true,
+    // UI hooks, set by the screen.
+    onPhase: (_p: Phase) => {},
+    onScore: (_s: number) => {},
+    onLives: (_l: number) => {},
+    onDistance: (_metres: number) => {},
+    hudFeedback: {} as HudFeedback
+  };
+  for (const seg of segments) {
+    placeSegment(g, seg);
+    spawnProps(g, seg);
+  }
+  world.scoreboard.reset(LIVES);
+  spawnRaceMarkers(world, g.track, 0, TRACK_LENGTH, a.font);
+  return g;
+}
+export type Game = ReturnType<typeof createGame>;
+
+const ENGINE = { volume: 0.3, loop: true, pitch: 1.45 }; // a bike's engine revs higher than the car's
+
+export function start(g: Game) {
+  if (g.world.isDisposed || g.phase !== 'ready') return;
+  g.phase = 'playing';
+  g.speed = START_SPEED * 0.55;
+  g.wheelie = WHEELIE_TIME;
+  // Fill the road ahead, so the first bikes arrive within seconds.
+  for (let ahead = 45; ahead < Math.min(SPAWN_AHEAD, TRACK_LENGTH - FINISH_CLEAR); ahead += rand(16, 24)) spawnTraffic(g, ahead);
+  g.engine = g.audible ? getRacingSounds().play('engine', ENGINE) : null;
+  // Sounds load alongside the scene; if they're still decoding, the engine starts once they're in.
+  if (!g.engine) {
+    getRacingSounds().ready.then(() => {
+      if (!g.world.isDisposed && g.audible && g.phase === 'playing' && !g.engine) g.engine = getRacingSounds().play('engine', ENGINE);
+    });
+  }
+  g.onPhase('playing');
+  playBankSound(getRacingSounds(), 'nitro', { volume: 0.6, pitch: 1.2 });
+  haptics.impact(0.6, 0.4);
+}
+
+/** Mirrors the shared screen's audible state without letting an engine loop leak to another screen. */
+export function setAudible(g: Game, enabled: boolean) {
+  g.audible = enabled;
+  if (!enabled) {
+    audio.stop(g.engine);
+    g.engine = null;
+    return;
+  }
+  if (g.phase !== 'playing' || g.engine || g.world.isDisposed) return;
+  const resume = () => {
+    if (!g.world.isDisposed && g.audible && g.phase === 'playing' && !g.engine) g.engine = getRacingSounds().play('engine', ENGINE);
+  };
+  resume();
+  if (!g.engine) void getRacingSounds().ready.then(resume);
+}
+
+/** Change the scene in place when the host theme changes. */
+export function setNight(g: Game, night: boolean) {
+  if (g.world.isDisposed || g.night === night) return;
+  g.night = night;
+  setHorizonNight(g.world, g.horizon, night);
+  setBikeNight(g.world, g.player, night);
+  for (const bike of g.traffic) setBikeNight(g.world, bike, night);
+  for (const segment of g.segments) for (const lamp of segment.lights) g.world.set(lamp.entity, { color: night ? lamp.night : lamp.day });
+}
+
+/** Steers toward the finger: `dx` is the drag's distance so far, `metresPerPoint` how far that moves the bike. */
+export function steer(g: Game, phase: 'start' | 'move' | 'end', dx: number, metresPerPoint: number) {
+  if (g.phase !== 'playing') return;
+  if (phase === 'start') g.dragX = 0;
+  if (phase === 'end') return;
+  g.target = clamp(g.target + (dx - g.dragX) * metresPerPoint, -EDGE - 0.6, EDGE + 0.6);
+  g.dragX = dx;
+}
+
+/** Stops the run's sounds and frees its world (the screen unmounting). */
+export function dispose(g: Game) {
+  audio.stop(g.engine);
+  g.world.dispose();
+}
+
+/** Present the integrated pose once; only independent wrecks use native velocity. */
+function drive(g: Game, root: Entity, s: number, d: number, h: number, yaw = 0) {
+  const t = g.track.sample(s, sample);
+  placeAt(t, d, h, at);
+  g.world.set(root, { position: at, velocity: [0, 0, 0], rotation: orient(t.heading, t.pitch, yaw, 0, driveRotation) });
+}
+
+/** Running into a bike: it's thrown down the road, burning, and a life is lost. */
+function crash(g: Game, bike: Bike, damagePlayer = true) {
+  bike.crashed = true;
+  bike.passed = true; // no points for a bike you hit
+  const t = g.track.sample(bike.s, sample);
+  const right = rightOf(t.heading);
+  const side = Math.sign(bike.d - g.d) || (Math.random() < 0.5 ? -1 : 1);
+  const size = g.assets.bike.size;
+  g.world.set(bike.root, {
+    physics: { type: 'dynamic', size: [0.6, size[1] + 0.4, size[2] * 0.95], layer: 8, mask: 4 | 8, bounce: 0.3, friction: 0.5, density: 0.3 },
+    spin: [rand(-4, 4), rand(-6, 6), -side * rand(4, 8)],
+    impact: { sound: getRacingSounds().get('bump'), minSpeed: 2, maxSpeed: 14, volume: 0.7, haptic: 0.3 },
+    lifetime: 3.4
+  });
+  // Thrown on ahead at about the player's new speed, tumbling and sliding along in view, burning.
+  g.speed = damagePlayer ? Math.max(START_SPEED * 0.55, g.speed * CRASH_SLOWDOWN) : g.speed * 0.9;
+  const ahead = g.speed * 1.1;
+  const a = g.track.sample(bike.s, sample);
+  const ax = a.x;
+  const az = a.z;
+  const b = g.track.sample(bike.s + 1, sample);
+  const len = Math.hypot(b.x - ax, b.z - az) || 1;
+  const along: Vec3 = [(b.x - ax) / len, 0, (b.z - az) / len];
+  g.world.set(bike.root, { velocity: [along[0] * ahead + right[0] * side * 4, 4.5, along[2] * ahead + right[2] * side * 4] });
+  const p = g.world.position(bike.root);
+  if (p) explode(g.world, p);
+  g.burning.push(burning(bike.root, g.time + 3));
+
+  g.shake = 0.45;
+  g.wobble = 0.9;
+  if (damagePlayer) g.onLives(g.world.scoreboard.addLives(-1));
+  g.hudFeedback.flash = true;
+  playBankSound(getRacingSounds(), 'hit', { volume: 1 });
+  haptics.impact(1, 0.8);
+  if (g.lives <= 0) {
+    g.burning.push(burning(g.player.root, Infinity));
+    end(g);
+    return;
+  }
+  g.invulnerable = INVULNERABLE; // a moment's grace, so one pile-up doesn't cost two lives
+}
+
+/**
+ * A sideswipe: no life lost. The other bike is shoved sideways (leaning away as it slides), the player
+ * bounces back a little with a wobble, and the two are pushed apart so the contact doesn't repeat.
+ */
+function sideswipe(g: Game, bike: Bike, overlap: number) {
+  const trafficLateral = Math.cos(bike.phase) * bike.weave * bike.weaveSpeed + bike.vshove;
+  if (sideImpactSpeed(g.lateral, trafficLateral, bike.d - g.d) >= 2.5) {
+    bike.bumped = true;
+    g.lateral *= 0.55;
+    crash(g, bike, false);
+    return;
+  }
+  const away = Math.sign(bike.d - g.d) || 1;
+  bike.shove += away * overlap * 0.7;
+  g.d -= away * overlap * 0.3;
+  bike.vshove = away * (3 + Math.abs(g.lateral) * 0.7);
+  g.lateral = -away * Math.abs(g.lateral) * 0.3;
+  bike.bumped = true;
+  g.speed *= 0.98;
+  g.wobble = Math.max(g.wobble, 0.35);
+  g.shake = Math.max(g.shake, 0.12);
+  if (bike.bumpCooldown > 0) return;
+  bike.bumpCooldown = 0.3;
+  const t = g.track.sample((bike.s + g.s) / 2, sample);
+  placeAt(t, (bike.d + g.d) / 2, 0.5, at);
+  effects.sparks(g.world, {
+    position: [at[0], at[1], at[2]],
+    count: 12,
+    speed: 6,
+    size: 0.06,
+    lifetime: 0.35,
+    gravity: -9.81,
+    colors: [
+      [1, 0.9, 0.4],
+      [1, 0.65, 0.2]
+    ]
+  });
+  playBankSound(getRacingSounds(), 'bump', { volume: 0.85 });
+  haptics.impact(0.55, 0.7);
+}
+
+function end(g: Game) {
+  if (g.phase !== 'playing') return;
+  g.world.scoreboard.stop();
+  g.phase = 'over';
+  audio.stop(g.engine);
+  g.engine = null;
+  if (g.lives > 0) {
+    playBankSound(getRacingSounds(), 'win', { volume: 0.8 });
+    haptics.notify('success');
+  } else {
+    playBankSound(getRacingSounds(), 'die', { volume: 0.8 });
+    haptics.notify('error');
+  }
+  g.onPhase('over');
+}
+
+export function tick(g: Game, dt: number) {
+  if (g.world.isDisposed) return;
+  dt = Math.max(0, Math.min(dt, 0.05));
+  g.time += dt;
+  const playing = g.phase === 'playing';
+
+  if (playing) {
+    // One cruising speed for the whole race: the launch and crash recoveries ease back up to it
+    g.speed += (START_SPEED - g.speed) * (1 - Math.exp(-dt * 1.4));
+    g.invulnerable = Math.max(0, g.invulnerable - dt);
+    g.spawnTimer -= dt;
+    if (g.spawnTimer <= 0) {
+      g.spawnTimer = Math.max(0.35, 0.9 - (g.speed - START_SPEED) * 0.018) * rand(0.8, 1.2);
+      spawnTraffic(g);
+    }
+    if (AUTOPLAY) autopilot(g);
+  } else if (g.phase === 'over') {
+    g.speed = Math.max(0, g.speed - 25 * dt); // roll to a stop
+  }
+
+  // Steering: slide toward the finger, scraping along the rail at the edges.
+  const goal = clamp(g.target, -EDGE - 0.6, EDGE + 0.6);
+  stepSteering(g, playing ? goal : g.d, dt, LATERAL_SPEED, STEER_RESPONSE, playing);
+  g.scrape -= dt;
+  if (Math.abs(g.d) > EDGE) {
+    g.d = Math.sign(g.d) * EDGE;
+    if (Math.sign(g.lateral) === Math.sign(g.d)) g.lateral = 0;
+    if (playing && Math.abs(goal) > EDGE + 0.2 && g.scrape <= 0) {
+      g.scrape = 0.06;
+      g.speed *= 0.985;
+      const t = g.track.sample(g.s + 0.8, sample);
+      placeAt(t, Math.sign(g.d) * (ROAD_HALF + 0.9), 0.5, at);
+      effects.sparks(g.world, {
+        position: [at[0], at[1], at[2]],
+        count: 6,
+        speed: 6,
+        size: 0.07,
+        lifetime: 0.35,
+        gravity: -9.81,
+        colors: [
+          [1, 0.85, 0.3],
+          [1, 0.55, 0.1]
+        ],
+        flash: false
+      });
+      haptics.impact(0.25, 1);
+    }
+  }
+
+  g.s += g.speed * dt;
+  // The distance left to the finish gate; crossing it wins
+  if (g.phase === 'playing') {
+    const left = Math.max(0, Math.ceil(TRACK_LENGTH - g.s));
+    if (left !== g.left) {
+      g.left = left;
+      g.onDistance(left);
+    }
+    if (g.s >= TRACK_LENGTH) end(g);
+  }
+  const size = g.assets.bike.size;
+  smoothSteeringPose(g.steeringPose, g.lateral, g.speed, dt);
+  drive(g, g.player.root, g.s, g.d, size[1] / 2, g.steeringPose.yaw);
+  // The bike leans into the turn (and wobbles after a crash); the start pulls a wheelie
+  g.wheelie = Math.max(0, g.wheelie - dt);
+  g.wobble = Math.max(0, g.wobble - dt);
+  const wheelie = playing && g.wheelie > 0 ? WHEELIE * Math.sin((g.wheelie / WHEELIE_TIME) * Math.PI) : 0;
+  const wobble = g.wobble > 0 ? Math.sin(g.time * 30) * 0.18 * g.wobble : 0;
+  leanBike(g.world, g.player.lean, -size[1] / 2, clamp(g.lateral * LEAN, -MAX_LEAN, MAX_LEAN) + wobble, wheelie);
+
+  // Traffic rides along its lane; scored once behind the player, gone once far behind.
+  for (let i = g.traffic.length - 1; i >= 0; i--) {
+    const bike = g.traffic[i]!;
+    if (bike.crashed) {
+      if (!g.world.has(bike.root)) g.traffic.splice(i, 1); // its lifetime ended
+      continue;
+    }
+    // A gentle weave within its lane, leaning with it
+    bike.phase += dt * bike.weaveSpeed;
+    // A shove from a sideswipe slides it out of its line, fading; the rails bounce it back.
+    bike.bumpCooldown -= dt;
+    bike.shove += bike.vshove * dt;
+    bike.vshove *= Math.exp(-dt * 2.5);
+    const vd = Math.cos(bike.phase) * bike.weave * bike.weaveSpeed + bike.vshove;
+    bike.s += TRAFFIC_SPEED * dt;
+    let d = bike.lane + Math.sin(bike.phase) * bike.weave + bike.shove;
+    if (Math.abs(d) > EDGE) {
+      bike.shove -= d - Math.sign(d) * EDGE;
+      bike.vshove = -bike.vshove * 0.3;
+      d = Math.sign(d) * EDGE;
+    }
+    bike.d = d;
+    drive(g, bike.root, bike.s, d, size[1] / 2, Math.atan2(vd, TRAFFIC_SPEED) * 0.7);
+    leanBike(g.world, bike.lean, -size[1] / 2, clamp(vd * LEAN * 2, -0.45, 0.45));
+    const ds = bike.s - g.s;
+    const reach = BIKE_FOOTPRINT.length;
+    const gap = Math.abs(bike.d - g.d);
+    if (Math.abs(ds) < reach) bike.closest = Math.min(bike.closest, gap);
+    // Touching is the bikes' and riders' outlines overlapping, not their lanes. How they met says what
+    // happens: front wheel into the other's tail (still apart lengthways a moment ago) is a crash;
+    // already alongside, a sideswipe that shoves the other bike away.
+    const depth = overlapAcross(BIKE_FOOTPRINT, BIKE_FOOTPRINT, ds, gap);
+    if (g.phase === 'playing' && depth > 0) {
+      if (!bike.touching && frontHit(BIKE_FOOTPRINT, BIKE_FOOTPRINT, bike.wasAhead, ds, 0.35)) bike.headOn = true;
+      bike.touching = true;
+      if (!bike.headOn) {
+        sideswipe(g, bike, depth);
+      } else if (g.invulnerable <= 0) {
+        crash(g, bike);
+        continue;
+      }
+    } else {
+      bike.touching = false;
+      bike.headOn = false;
+    }
+    bike.wasAhead = ds;
+    if (!bike.passed && g.phase === 'playing' && ds < -reach) {
+      bike.passed = true;
+      g.onScore(g.world.scoreboard.add(POINTS_PER_BIKE_PASSED));
+      playBankSound(getRacingSounds(), 'point', { volume: 0.5 });
+      haptics.impact(0.25, 0.9);
+      if (bike.closest < NEAR_MISS_GAP && !bike.bumped) g.hudFeedback.message = 'NEAR MISS!';
+    }
+    if (ds < -30) {
+      g.world.despawn(bike.root);
+      g.traffic.splice(i, 1);
+    }
+  }
+
+  burn(g.world, g.camera, g.burning, g.time, dt);
+  g.world.update(dt);
+  recycleRoad(g, g.segments, g.s);
+  followCamera(g, dt);
+}
+
+/** Camera: orbiting the bike on the start screen, then low behind the rider, looking down the road. */
+function followCamera(g: Game, dt: number) {
+  const drawn = g.world.worldPosition(g.player.root, tmp);
+  if (!drawn) return;
+  const t = g.track.sample(g.s, look);
+  const fwd = forwardOf(t.heading);
+  if (g.phase === 'ready') {
+    g.orbit += dt * 0.35;
+    const angle = g.orbit + 0.9;
+    updateChase(g.chase, g.camera, drawn, [Math.sin(angle) * 5, 1.6, Math.cos(angle) * 5], [0, 0.35, 0], dt);
+  } else {
+    updateChase(
+      g.chase,
+      g.camera,
+      drawn,
+      [-fwd[0] * 5.4, 1.9 + Math.max(0, -t.pitch) * 3, -fwd[2] * 5.4],
+      [fwd[0] * 12, 0.6 + Math.tan(t.pitch) * 12, fwd[2] * 12],
+      dt
+    );
+  }
+  g.camera.fov = CAMERA_FOV;
+  g.shake *= Math.exp(-dt * 6);
+  g.world.set(g.horizon, { position: [drawn[0], 0, drawn[2]] });
+}
+
+// ── Traffic ───────────────────────────────────────────────────────────
+
+export type Bike = {
+  root: Entity;
+  lean: Entity;
+  lights: Entity[];
+  s: number;
+  d: number;
+  /** Its lane's centre, and which lane (0..2). */
+  lane: number;
+  laneIndex: number;
+  /** A gentle weave about the lane's centre. */
+  weave: number;
+  weaveSpeed: number;
+  phase: number;
+  /** How far a sideswipe has shoved it out of its line, and how fast it's still sliding. */
+  shove: number;
+  vshove: number;
+  passed: boolean;
+  crashed: boolean;
+  /** It was sideswiped (no near-miss bonus for it). */
+  bumped: boolean;
+  /** Seconds until another sideswipe makes a sound again. */
+  bumpCooldown: number;
+  /** Closest it came beside the player, for near misses. */
+  closest: number;
+  /** How far ahead of the player it was last frame, and whether it's touching (and met nose to tail). */
+  wasAhead: number;
+  touching: boolean;
+  headOn: boolean;
+};
+
+const spawnSample = newSample();
+const spawnAt: [number, number, number] = [0, 0, 0];
+
+/** Traffic ahead, in a lane that doesn't close the road: bikes close together always leave a lane open. */
+export function spawnTraffic(g: Game, ahead = SPAWN_AHEAD) {
+  const s = g.s + ahead;
+  if (s > TRACK_LENGTH - FINISH_CLEAR) return; // the run-in to the finish stays clear
+  const window = 12 + g.speed * 0.32;
+  const blocked = new Set<number>();
+  for (const bike of g.traffic) if (!bike.crashed && Math.abs(bike.s - s) < window) blocked.add(bike.laneIndex);
+  const open = [0, 1, 2].filter((l) => !blocked.has(l));
+  if (open.length <= 1) return;
+  const laneIndex = pick(open);
+  const lane = LANES[laneIndex]!;
+  const t = g.track.sample(s, spawnSample);
+  placeAt(t, lane, g.assets.bike.size[1] / 2, spawnAt);
+  const { root, lean, lights } = spawnBike(g.world, g.assets, pick(PAINTS), [spawnAt[0], spawnAt[1], spawnAt[2]], g.night);
+  g.world.set(root, { rotation: orient(t.heading, t.pitch) });
+  g.traffic.push({
+    root,
+    lean,
+    lights,
+    s,
+    d: lane,
+    lane,
+    laneIndex,
+    weave: rand(0.1, 0.35),
+    weaveSpeed: rand(0.6, 1.2),
+    phase: rand(0, Math.PI * 2),
+    shove: 0,
+    vshove: 0,
+    passed: false,
+    crashed: false,
+    bumped: false,
+    bumpCooldown: 0,
+    closest: Infinity,
+    wasAhead: ahead,
+    touching: false,
+    headOn: false
+  });
+}
+
+/** Demo bot: head for the lane whose next bike is furthest away. */
+export function autopilot(g: Game) {
+  const nearest = [Infinity, Infinity, Infinity];
+  for (const bike of g.traffic) {
+    if (bike.crashed) continue;
+    const ahead = bike.s - g.s;
+    if (ahead > -4) nearest[bike.laneIndex] = Math.min(nearest[bike.laneIndex]!, ahead);
+  }
+  let current = 0;
+  for (let l = 1; l < 3; l++) if (Math.abs(LANES[l]! - g.d) < Math.abs(LANES[current]! - g.d)) current = l;
+  let lane = current;
+  if (nearest[current]! < 40) {
+    for (const l of [current - 1, current + 1]) {
+      if (l >= 0 && l < 3 && nearest[l]! > nearest[lane]! + 6) lane = l;
+    }
+  }
+  g.target = LANES[lane]!;
+}

package/src/games/bike-racing/BikeRacingScene.ts

@@ -0,0 +1,119 @@
+// What Bike Racing draws besides Car Racing's road, scenery, horizon and fire (shared from
+// games/car-racing): the sport bikes, each with its rider tucked down over the tank in a racing
+// crouch, leaning into the turns.
+import {
+  type Color,
+  type Entity,
+  type GeometryPart,
+  merge,
+  type Model,
+  type MutableQuat,
+  quat,
+  shapeGeometry,
+  tube,
+  type Vec3,
+  type World
+} from '@nayan-ui/engine';
+import { cacheGameAsset, createGameMesh as createShape } from '../shared/EngineMeshes';
+import { type Assets, SUIT, SUIT_TRIM, VISOR } from './BikeRacingConstants';
+
+let riderModel: Model | undefined;
+
+/** The rider, in the bike's frame (y up, nose toward -z, wheels on y = 0): one mesh, its suit, gloves and boots. */
+function riderMesh(): Model {
+  return cacheGameAsset('bike-racing/BikeRacingScene:riderMesh', () => riderMeshUncached());
+}
+
+function riderMeshUncached(): Model {
+  if (riderModel) return riderModel;
+  const limb = (a: Vec3, b: Vec3, r0: number, r1: number, color: Color): GeometryPart => ({
+    geometry: tube([a, b], { radius: (t) => r0 + (r1 - r0) * t, sides: 12, smoothness: 2, caps: true }),
+    color
+  });
+  const ball = (at: Vec3, scale: Vec3 | number, color: Color): GeometryPart => ({ geometry: shapeGeometry('sphere'), position: at, scale, color });
+  const parts: GeometryPart[] = [
+    // Torso, tucked flat over the tank (rounded at the hips and shoulders), and the neck
+    limb([0, 0.86, 0.26], [0, 1.05, -0.12], 0.16, 0.14, SUIT),
+    ball([0, 0.86, 0.26], [0.3, 0.26, 0.28], SUIT),
+    ball([0, 1.04, -0.11], [0.32, 0.24, 0.24], SUIT),
+    limb([0, 1.07, -0.15], [0, 1.1, -0.21], 0.06, 0.06, SUIT),
+    // A stripe down the back
+    limb([0, 0.98, 0.2], [0, 1.17, -0.08], 0.035, 0.03, SUIT_TRIM)
+  ];
+  for (const s of [-1, 1]) {
+    // Arms out to the clip-ons, gloves on the grips
+    parts.push(ball([s * 0.18, 1.04, -0.12], 0.13, SUIT));
+    parts.push(limb([s * 0.18, 1.04, -0.12], [s * 0.29, 0.93, -0.3], 0.06, 0.055, SUIT));
+    parts.push(ball([s * 0.29, 0.93, -0.3], 0.11, SUIT));
+    parts.push(limb([s * 0.29, 0.93, -0.3], [s * 0.32, 0.79, -0.46], 0.055, 0.045, SUIT));
+    parts.push(ball([s * 0.32, 0.785, -0.465], 0.1, SUIT_TRIM));
+    // Legs: knees tucked against the tank, boots on the pegs
+    parts.push(limb([s * 0.12, 0.84, 0.26], [s * 0.25, 0.78, -0.06], 0.085, 0.07, SUIT));
+    parts.push(ball([s * 0.25, 0.78, -0.06], 0.14, SUIT));
+    parts.push(limb([s * 0.25, 0.78, -0.06], [s * 0.23, 0.4, 0.1], 0.065, 0.055, SUIT));
+    parts.push(ball([s * 0.23, 0.38, 0.13], [0.09, 0.08, 0.2], SUIT_TRIM));
+  }
+  riderModel = createShape(merge(parts), { center: false, shine: 0.45 });
+  return riderModel;
+}
+
+/**
+ * A bike: an invisible root at its middle (the collider's centre once wrecked), a lean pivot where the
+ * tyres touch the road, and on it the body (painted), tyres, rider and helmet (in the bike's color).
+ */
+export function spawnBike(world: World, a: Assets, paint: Color, position: Vec3, night: boolean) {
+  const model = a.bike;
+  const root = world.spawn({ mesh: 'none', position });
+  const lean = world.spawn({ mesh: 'none', parent: root, position: [0, -model.size[1] / 2, 0] });
+  const part = (o: Parameters<World['spawn']>[0]) => world.spawn({ parent: lean, pickable: false, ...o });
+  part({ mesh: model.body, color: paint });
+  part({ mesh: model.trim });
+  part({ mesh: model.glass });
+  part({ mesh: riderMesh() });
+  // The helmet in the bike's color, its visor smoked
+  part({ mesh: 'sphere', position: [0, 1.14, -0.29], scale: [0.29, 0.28, 0.32], color: paint });
+  part({ mesh: 'sphere', position: [0, 1.13, -0.39], scale: [0.24, 0.11, 0.15], color: VISOR });
+  const bike = { root, lean, lights: [] as Entity[] };
+  setBikeNight(world, bike, night);
+  return bike;
+}
+
+/** Repaint lights without rebuilding the bike or disturbing its lean and wheelie. */
+export function setBikeNight(world: World, bike: { root: Entity; lean: Entity; lights: Entity[] }, night: boolean) {
+  for (const light of bike.lights) world.despawn(light);
+  bike.lights.length = 0;
+  if (!night || !world.has(bike.root)) return;
+  bike.lights.push(
+    world.spawn({ mesh: 'sphere', parent: bike.lean, pickable: false, position: [0, 0.71, -0.93], scale: [0.24, 0.05, 0.05], color: [2, 1.95, 1.7] }),
+    world.spawn({ mesh: 'cube', parent: bike.lean, pickable: false, position: [0, 0.895, 0.985], scale: [0.09, 0.03, 0.02], color: [2, 0.16, 0.1] })
+  );
+}
+
+const REAR_CONTACT = 0.73; // where the rear tyre meets the road (z), the pivot of a wheelie
+
+const leanRotation: MutableQuat = [0, 0, 0, 1];
+const rollRotation: MutableQuat = [0, 0, 0, 1];
+const wheelieRotation: MutableQuat = [0, 0, 0, 1];
+const leanPosition: [number, number, number] = [0, 0, 0];
+
+/**
+ * Leans a bike `roll` radians into a turn (positive to the right) about where its tyres touch the
+ * road, and lifts its nose `wheelie` radians about the rear tyre. `ground` is the pivot's place under
+ * the root (half the bike's height down).
+ */
+export function leanBike(world: World, lean: Entity, ground: number, roll: number, wheelie = 0) {
+  // The wheelie's pitch first, then the roll
+  quat.multiply(quat.z(-roll, rollRotation), quat.x(wheelie, wheelieRotation), leanRotation);
+  leanPosition[1] = ground + REAR_CONTACT * Math.sin(wheelie);
+  leanPosition[2] = REAR_CONTACT * (1 - Math.cos(wheelie));
+  world.set(lean, {
+    rotation: leanRotation,
+    // Keep the rear tyre on the road while the nose comes up
+    position: leanPosition
+  });
+}
+
+/** Reusable assets; the game loader advances one builder per frame. */
+export function* warmAssets(): Iterable<() => unknown> {
+  yield riderMesh;
+}