@nayan-ui/games 1.20.0 → 1.21.0

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

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

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