@nayan-ui/games 1.20.0 → 1.21.0

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

@@ -1,273 +0,0 @@
-// The supersport bike, built in code (as Penguin Run's penguin) rather than loaded from files: one
-// sleek full fairing from a sharp nose (slim LED eyes either side of a ram-air intake) back to a painted
-// belly pan, sweeping down behind the front wheel; a slim tank cut in for the knees; a thin upswept
-// tail; black split-spoke wheels on low-profile tyres; upside-down gold forks over twin drilled discs;
-// an aluminium swingarm with the shock, chain and sprocket; rearsets; and a compact titanium exhaust.
-// Model units are metres: it stands on y = 0 facing -z, 0.7 wide (bars) by about 1.04 tall by 2.04
-// long, its wheels at z = -0.72 and 0.72 (the rear tyre meets the road at REAR_CONTACT). Three meshes,
-// as a model: the bodywork (white, so each bike paints its own color), the screen, and the trim in its
-// own colors. The rider (BikeRacingScene) sits on it: seat, grips and pegs are where it expects them.
-import {
-  block,
-  type Color,
-  ellipsoid,
-  type GeometryPart,
-  lathe,
-  loft,
-  type LoftSection as Section,
-  merge,
-  type Model,
-  quat,
-  smoothCurve,
-  tube,
-  type Vec3
-} from '@nayan-ui/engine';
-import { AXLE_X, wheel } from '../car-racing/CarMeshes';
-import type { Footprint } from '../shared/EngineFootprint';
-import { cacheGameAsset, createGameMesh as createShape } from '../shared/EngineMeshes';
-
-const TAU = Math.PI * 2;
-const SMOKED: Color = [0.05, 0.065, 0.09];
-const BLACK: Color = [0.02, 0.02, 0.022];
-const SATIN: Color = [0.07, 0.07, 0.08];
-const CARBON: Color = [0.055, 0.055, 0.065];
-const ALUMINIUM: Color = [0.68, 0.7, 0.73];
-const CHROME: Color = [0.82, 0.83, 0.86];
-const GOLD: Color = [0.86, 0.62, 0.16];
-const STEEL: Color = [0.55, 0.56, 0.58];
-const TITANIUM: Color = [0.52, 0.54, 0.58];
-const HEADLIGHT: Color = [0.95, 0.97, 1];
-const DRL: Color = [1.4, 1.4, 1.45];
-const TAIL_LIGHT: Color = [0.85, 0.04, 0.04];
-const AMBER: Color = [1, 0.55, 0.08];
-const PLATE: Color = [0.9, 0.9, 0.88];
-const SPRING: Color = [0.95, 0.75, 0.1];
-const BURNT: Color = [0.3, 0.26, 0.3];
-
-const WHEEL_R = 0.3;
-const FRONT = -0.72;
-const REAR = 0.72;
-
-/**
- * The full fairing: a sharp nose, flanks wrapping the radiator, the lower edge clear of the front tyre
- * and then sweeping down behind it into the belly pan under the engine.
- */
-const FAIRING: Section[] = [
-  { z: -0.99, bottom: 0.64, top: 0.72, width: 0.04, square: 2.4 },
-  { z: -0.92, bottom: 0.6, top: 0.8, width: 0.15, square: 2.8 },
-  { z: -0.8, bottom: 0.63, top: 0.87, width: 0.22, square: 3 },
-  { z: -0.68, bottom: 0.66, top: 0.9, width: 0.26, square: 3 },
-  { z: -0.56, bottom: 0.6, top: 0.88, width: 0.27, square: 3 },
-  { z: -0.46, bottom: 0.47, top: 0.8, width: 0.26, square: 3.2 },
-  { z: -0.38, bottom: 0.26, top: 0.74, width: 0.25, square: 3.4 },
-  { z: -0.15, bottom: 0.21, top: 0.66, width: 0.22, square: 3.4 },
-  { z: 0.04, bottom: 0.23, top: 0.62, width: 0.18, square: 3.2 },
-  { z: 0.16, bottom: 0.32, top: 0.58, width: 0.12, square: 3 }
-];
-/** The tank: slim, peaking ahead of the rider, cut in at the knees. */
-const TANK: Section[] = [
-  { z: -0.54, bottom: 0.78, top: 0.86, width: 0.1, square: 3.4 },
-  { z: -0.42, bottom: 0.72, top: 0.915, width: 0.16, square: 3.6 },
-  { z: -0.22, bottom: 0.68, top: 0.915, width: 0.17, square: 3.6 },
-  { z: -0.04, bottom: 0.68, top: 0.87, width: 0.13, square: 3.4 },
-  { z: 0.1, bottom: 0.72, top: 0.83, width: 0.1, square: 3 }
-];
-/** The seat cowl and tail: down to meet the fairing under the seat, then thin and upswept to a sharp tip. */
-const TAIL: Section[] = [
-  { z: 0.02, bottom: 0.5, top: 0.79, width: 0.15, square: 3.4 },
-  { z: 0.2, bottom: 0.56, top: 0.82, width: 0.145, square: 3.4 },
-  { z: 0.4, bottom: 0.68, top: 0.85, width: 0.125, square: 3.2 },
-  { z: 0.6, bottom: 0.77, top: 0.89, width: 0.1, square: 3.2 },
-  { z: 0.85, bottom: 0.84, top: 0.925, width: 0.06, square: 3 },
-  { z: 0.985, bottom: 0.875, top: 0.92, width: 0.02, square: 2.6 }
-];
-
-const rod = (a: Vec3, b: Vec3, radius: number, color: Color, sides = 10): GeometryPart => ({
-  geometry: tube([a, b], { radius, sides, smoothness: 1 }),
-  color
-});
-/** Points on a circle of radius `r` about (y, z), around the x axis at `x`, from angle `a0` to `a1` (0 = forward, -z). */
-const arc = (x: number, y: number, z: number, r: number, a0: number, a1: number, n = 8): Vec3[] =>
-  Array.from({ length: n + 1 }, (_, i) => {
-    const a = a0 + ((a1 - a0) * i) / n;
-    return [x, y + Math.sin(a) * r, z - Math.cos(a) * r];
-  });
-
-/** A flat steel brake disc `r` across, drilled, on a gold carrier, around the y axis (turn it with AXLE_X). */
-const disc = (r: number, carrier: Color = GOLD) =>
-  lathe(
-    [
-      [0.001, 0.004],
-      [r, 0.004],
-      [r, -0.004],
-      [0.001, -0.004]
-    ],
-    {
-      segments: 36,
-      color: ({ u, position: [x, , z] }) => {
-        const d = Math.hypot(x, z);
-        if (d < r * 0.55) return Math.cos(u * TAU * 6) > 0.3 ? carrier : BLACK; // the carrier's arms
-        return Math.cos(u * TAU * 20) > 0.85 && d > r * 0.66 && d < r * 0.92 ? BLACK : STEEL;
-      }
-    }
-  );
-
-/**
- * The bike's outline from above, with its rider, for collisions: the narrow tyres at each end, the
- * fairing, the bars and grips at their widest, the rider's knees and boots, then the slim tail.
- */
-export const BIKE_FOOTPRINT: Footprint = {
-  length: 2.04,
-  halfWidth: smoothCurve([
-    [-1.02, 0.06],
-    [-0.9, 0.15],
-    [-0.7, 0.26],
-    [-0.47, 0.34], // the grips
-    [-0.3, 0.28],
-    [-0.06, 0.3], // knees
-    [0.13, 0.28], // boots on the pegs
-    [0.4, 0.17],
-    [0.7, 0.12],
-    [1.02, 0.08]
-  ])
-};
-
-export type BikeMeshes = { body: Model; trim: Model; glass: Model };
-let bike: BikeMeshes | null = null;
-
-/** The bike's three meshes, built once per app. */
-export function bikeMeshes(): BikeMeshes {
-  return cacheGameAsset('bike-racing/BikeMeshes:bikeMeshes', () => bikeMeshesUncached());
-}
-
-function bikeMeshesUncached(): BikeMeshes {
-  if (bike) return bike;
-  const body = createShape(
-    merge([
-      { geometry: loft(FAIRING, { around: 40, smoothness: 5 }) },
-      { geometry: loft(TANK, { around: 32, smoothness: 4 }) },
-      { geometry: loft(TAIL, { around: 28, smoothness: 4 }) }
-    ]),
-    { center: false, shine: 0.9 }
-  );
-  // A short screen raked back over the nose
-  const glass = createShape(merge([{ geometry: ellipsoid([0.17, 0.2, 0.016], SMOKED, 24), position: [0, 0.93, -0.66], rotation: quat.x(0.95) }]), {
-    center: false,
-    shine: 0.95
-  });
-
-  const wheelLook = { rim: 0.74, spokes: 5, rimColor: SATIN, spokeColor: SATIN, gapColor: BLACK };
-  const parts: GeometryPart[] = [
-    { geometry: wheel(WHEEL_R, 0.12, wheelLook), position: [0, WHEEL_R, FRONT], rotation: AXLE_X },
-    { geometry: wheel(WHEEL_R, 0.19, wheelLook), position: [0, WHEEL_R, REAR], rotation: AXLE_X },
-    { geometry: disc(0.15, STEEL), position: [0.105, WHEEL_R, REAR], rotation: AXLE_X }, // rear disc, right side
-    { geometry: disc(0.1, BLACK), position: [-0.11, WHEEL_R, REAR], rotation: AXLE_X }, // rear sprocket, left side
-    // The nose: slim LED eyes either side of the ram-air intake, a daytime-running-light brow over each
-    { geometry: block(0.07, 0.05, 0.04, 6, BLACK), position: [0, 0.665, -0.965] },
-    { geometry: block(0.18, 0.03, 0.12, 6, ALUMINIUM), position: [0, 0.885, -0.5] }, // top triple clamp
-    { geometry: block(0.26, 0.06, 0.4, 5, BLACK), position: [0, 0.83, 0.25] }, // rider's seat
-    { geometry: block(0.016, 0.26, 0.016, 4, CARBON), position: [0, 0.7, 0.95] }, // plate hanger
-    { geometry: block(0.16, 0.1, 0.012, 6, PLATE), position: [0, 0.57, 0.96] },
-    { geometry: block(0.08, 0.025, 0.02, 6, TAIL_LIGHT), position: [0, 0.895, 0.975] }, // tail light
-    // Rear shock between the swingarm and the frame: a yellow spring over the damper
-    {
-      geometry: tube(
-        [
-          [0, 0.42, 0.2],
-          [0, 0.68, 0.12]
-        ],
-        { radius: 0.038, sides: 12, smoothness: 1, color: ({ v }) => (Math.sin(v * TAU * 9) > 0 ? SPRING : BLACK) }
-      )
-    },
-    // Front mudguard and rear hugger, close over the tyres
-    {
-      geometry: tube(arc(0, WHEEL_R, FRONT, 0.335, 0.55, 2.3, 8), {
-        radius: 0.06,
-        shape: (a) => 0.25 + 0.75 * Math.abs(Math.cos(a * TAU)),
-        sides: 12,
-        smoothness: 3
-      }),
-      color: CARBON
-    },
-    {
-      geometry: tube(arc(0, WHEEL_R, REAR, 0.33, 0.6, 1.6, 6), {
-        radius: 0.09,
-        shape: (a) => 0.22 + 0.78 * Math.abs(Math.cos(a * TAU)),
-        sides: 12,
-        smoothness: 3
-      }),
-      color: CARBON
-    },
-    // Chain run on the left, between the sprockets
-    rod([-0.11, 0.37, 0.06], [-0.11, 0.39, REAR], 0.008, BLACK, 6),
-    rod([-0.11, 0.25, 0.08], [-0.11, 0.21, REAR], 0.008, BLACK, 6),
-    // Exhaust: the header under the belly pan into a short titanium can beside the rear wheel
-    {
-      geometry: tube(
-        [
-          [0.05, 0.26, -0.3],
-          [0.08, 0.25, 0.0],
-          [0.12, 0.26, 0.2],
-          [0.16, 0.3, 0.34]
-        ],
-        { radius: 0.025, sides: 10, smoothness: 4, color: BURNT }
-      )
-    },
-    {
-      geometry: tube(
-        [
-          [0.16, 0.3, 0.34],
-          [0.185, 0.4, 0.52],
-          [0.2, 0.47, 0.66]
-        ],
-        { radius: (t) => 0.048 + 0.008 * t, sides: 16, smoothness: 3, color: TITANIUM, capColor: CARBON }
-      )
-    }
-  ];
-  for (const s of [-1, 1]) {
-    parts.push(
-      { geometry: ellipsoid([0.075, 0.016, 0.05], HEADLIGHT), position: [s * 0.07, 0.705, -0.925], rotation: quat.y(-s * 0.45) },
-      { geometry: block(0.08, 0.008, 0.012, 6, DRL), position: [s * 0.075, 0.726, -0.915], rotation: quat.y(-s * 0.45) },
-      // Upside-down forks: slim chrome stanchions into gold outer tubes, clamped at the top
-      rod([s * 0.085, WHEEL_R, FRONT], [s * 0.085, 0.56, -0.62], 0.02, CHROME),
-      rod([s * 0.085, 0.54, -0.63], [s * 0.085, 0.9, -0.48], 0.03, GOLD),
-      { geometry: disc(0.2), position: [s * 0.075, WHEEL_R, FRONT], rotation: AXLE_X },
-      { geometry: block(0.04, 0.13, 0.07, 6, GOLD), position: [s * 0.11, 0.42, -0.64], rotation: quat.x(0.5) }, // radial calipers
-      // Vents in the fairing's flanks
-      ...[0.46, 0.52, 0.58].map((y): GeometryPart => ({
-        geometry: block(0.012, 0.018, 0.16, 6, BLACK),
-        position: [s * 0.247, y, -0.33 + (0.52 - y) * 0.5]
-      })),
-      // The frame's aluminium side plates around the swingarm pivot, under the seat
-      { geometry: block(0.03, 0.26, 0.24, 5, ALUMINIUM), position: [s * 0.135, 0.5, 0.1], rotation: quat.x(-0.25) },
-      // Aluminium swingarm to the rear axle
-      {
-        geometry: tube(
-          [
-            [s * 0.12, 0.42, 0.1],
-            [s * 0.12, 0.37, 0.4],
-            [s * 0.115, WHEEL_R, REAR]
-          ],
-          { radius: 0.035, shape: (a) => 0.6 + 0.4 * Math.abs(Math.sin(a * TAU)), sides: 12, smoothness: 3, color: ALUMINIUM }
-        )
-      },
-      // Clip-on bars and grips where the rider's gloves are
-      rod([s * 0.08, 0.86, -0.5], [s * 0.28, 0.79, -0.47], 0.016, ALUMINIUM),
-      rod([s * 0.27, 0.79, -0.47], [s * 0.345, 0.785, -0.465], 0.025, BLACK),
-      // Rearsets under the boots: peg, heel guard and lever
-      rod([s * 0.14, 0.38, 0.12], [s * 0.27, 0.38, 0.12], 0.014, ALUMINIUM),
-      { geometry: block(0.01, 0.12, 0.09, 6, ALUMINIUM), position: [s * 0.19, 0.42, 0.16] },
-      rod([s * 0.2, 0.38, 0.1], [s * 0.21, 0.35, -0.04], 0.008, ALUMINIUM, 6),
-      // Mirrors on the fairing, with indicators in them
-      rod([s * 0.2, 0.84, -0.7], [s * 0.26, 0.9, -0.68], 0.01, BLACK),
-      { geometry: ellipsoid([0.055, 0.03, 0.03], BLACK), position: [s * 0.28, 0.91, -0.68] },
-      { geometry: ellipsoid([0.02, 0.008, 0.01], AMBER), position: [s * 0.3, 0.905, -0.7] },
-      // Rear indicators on the plate hanger
-      rod([0, 0.64, 0.95], [s * 0.1, 0.64, 0.95], 0.008, BLACK),
-      { geometry: ellipsoid([0.025, 0.012, 0.012], AMBER), position: [s * 0.11, 0.64, 0.95] }
-    );
-  }
-  const trim = createShape(merge(parts), { center: false, shine: 0.5 });
-  bike = { body, trim, glass };
-  return bike;
-}

package/src/games/bike-racing/BikeRacing.tsx

@@ -1,211 +0,0 @@
-// Bike Racing's screen, on the Nayan engine (@nayan-ui/engine): loads the assets, builds a run, and draws
-// Playtura's scoreboard, controls and modals over the 3D view. The rules are in BikeRacingGame.ts, what
-// it draws in BikeRacingScene.ts (on Car Racing's road), tuning and assets in BikeRacingConstants.ts.
-//
-// The engine runs the simulation (physics, particles, audio, haptics) in its Rust core; GameView's
-// `onUpdate` advances the shared engine simulation and HUD once per frame.
-import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { type DragEvent, haptics } from '@nayan-ui/engine';
-import { resolveGameTheme } from '../../services/ThemeService';
-import { GAME_IDS, type GameProps } from '../../services/UtilsService';
-import { engineGame, EngineGameScreen } from '../shared/EngineGameScreen';
-import { livesColumn, scoreColumn, textColumn } from '../shared/EngineHud';
-import { GameLoading } from '../shared/GameLoading';
-import { GameLoadingTransition } from '../shared/GameLoadingTransition';
-import { useGameResource } from '../shared/useGameResource';
-import {
-  type Assets,
-  AUTOPLAY,
-  DAY_LIGHT,
-  EDGE,
-  getCachedAssets,
-  LIVES,
-  loadAssets,
-  NIGHT_LIGHT,
-  NIGHT_SKY,
-  SKY,
-  STEER_WIDTH,
-  TRACK_LENGTH
-} from './BikeRacingConstants';
-import { createGame, dispose, type Phase, setAudible, setNight, start, steer, tick } from './BikeRacingGame';
-
-export { preloadBikeRacing } from './BikeRacingConstants';
-
-const RESULTS_DELAY = 1200; // ms: the crash (or the finish) is seen before the modal covers it
-
-type RunProps = GameProps & { assets: Assets; night: boolean; onRestart: () => void };
-
-/** One run, from the start screen to the results. Restarting mounts a new one. */
-const Run = React.memo(
-  ({
-    assets,
-    night,
-    onRestart,
-    settings,
-    onSettingsChange,
-    onEndGame,
-    onReplayGame,
-    onShare,
-    onShareScreenshot,
-    onShowLeaderboard,
-    bannerAd
-  }: RunProps) => {
-    const initialNight = useRef(night);
-    const game = useGameResource(
-      () => createGame(assets, initialNight.current),
-      (value) => () => {
-        if (value.phase === 'playing') reportGameEnd('cancel');
-        dispose(value);
-      }
-    );
-    useEffect(() => {
-      setNight(game, night);
-    }, [game, night]);
-    const width = useRef(1);
-    const [phase, setPhase] = useState<Phase>('ready');
-    const [showResults, setShowResults] = useState(false);
-    const [score, setScore] = useState(0);
-    const [lives, setLives] = useState(LIVES);
-    const [left, setLeft] = useState(TRACK_LENGTH);
-    // Report each run once: win on crossing the finish line, lose on the last crash, cancel on stop.
-    const gameReportedRef = useRef(false);
-    const onEndGameRef = useRef(onEndGame);
-    onEndGameRef.current = onEndGame;
-    const reportGameEnd = useCallback(
-      (status: 'win' | 'lose' | 'cancel') => {
-        if (!onEndGameRef.current || gameReportedRef.current) return;
-        gameReportedRef.current = true;
-        onEndGameRef.current({ status, score: game.score.toString() });
-      },
-      [game]
-    );
-
-    useEffect(() => {
-      haptics.enabled = settings.enableHaptics;
-    }, [settings.enableHaptics]);
-
-    useEffect(() => {
-      game.onPhase = setPhase;
-      game.onLives = setLives;
-      game.onDistance = setLeft;
-      game.onScore = setScore;
-    }, [game]);
-
-    // Game over detection, in its own effect.
-    useEffect(() => {
-      if (phase !== 'over') return;
-      reportGameEnd(game.lives > 0 ? 'win' : 'lose');
-      const t = setTimeout(() => setShowResults(true), RESULTS_DELAY);
-      return () => clearTimeout(t);
-    }, [phase, game, reportGameEnd]);
-
-    // Autoplay (EXPO_PUBLIC_AUTOPLAY=1): start by itself and restart after a pause.
-    useEffect(() => {
-      if (!AUTOPLAY || phase === 'playing') return;
-      const t = setTimeout(phase === 'ready' ? () => start(game) : onRestart, phase === 'ready' ? 1500 : 3000);
-      return () => clearTimeout(t);
-    }, [phase, game, onRestart]);
-
-    const onAudioChange = useCallback((audible: boolean) => setAudible(game, audible), [game]);
-    const onUpdate = useCallback((dt: number) => tick(game, dt), [game]);
-
-    // Relative steering: wherever the swipe starts, the bike moves by how far the finger moves.
-    const onDrag = useCallback(({ phase: touch, dx }: DragEvent) => steer(game, touch, dx, (2 * EDGE) / (STEER_WIDTH * width.current)), [game]);
-
-    const handleStartGame = useCallback(() => {
-      gameReportedRef.current = false;
-      start(game);
-    }, [game]);
-
-    // Report before resetting, then a fresh run.
-    const handleStopGame = useCallback(() => {
-      reportGameEnd('cancel');
-      onRestart();
-    }, [reportGameEnd, onRestart]);
-
-    const handleResetGame = useCallback(() => {
-      onReplayGame?.();
-      onRestart();
-    }, [onReplayGame, onRestart]);
-
-    const won = lives > 0;
-    return (
-      <EngineGameScreen
-        onAudioChange={onAudioChange}
-        gameId={GAME_IDS.BIKE_RACING}
-        settings={settings}
-        onSettingsChange={onSettingsChange}
-        onShare={onShareScreenshot ?? onShare}
-        onShowLeaderboard={onShowLeaderboard}
-        bannerAd={bannerAd}
-        source={game.world}
-        feedback={game.hudFeedback}
-        camera={game.camera}
-        light={night ? NIGHT_LIGHT : DAY_LIGHT}
-        background={night ? NIGHT_SKY : SKY}
-        fog={0.0075}
-        onUpdate={onUpdate}
-        onDrag={onDrag}
-        onResize={(value) => {
-          width.current = value;
-        }}
-        columns={[scoreColumn(score), livesColumn(lives, LIVES), textColumn('TRACK', `${left} m`)]}
-        playing={phase === 'playing'}
-        subtext="Dodge traffic to score!"
-        onStart={handleStartGame}
-        onStop={handleStopGame}
-        gameOver={
-          showResults
-            ? {
-                title: won ? 'FINISHED!' : 'CRASHED!',
-                message: won
-                  ? `You crossed the finish line! Great riding!`
-                  : `Out of lives ${TRACK_LENGTH - left} m into the ${TRACK_LENGTH} m race.`,
-                scoreLabel: 'Final Score',
-                score,
-                buttonText: 'Race Again!',
-                onPlayAgain: handleResetGame,
-                onShare: onShareScreenshot
-              }
-            : null
-        }
-      />
-    );
-  }
-);
-
-Run.displayName = 'BikeRacingRun';
-
-export const BikeRacing = engineGame(GAME_IDS.BIKE_RACING, (props) => {
-  const settings = props.settings;
-  const theme = resolveGameTheme(settings.theme);
-  const [run, setRun] = useState(0);
-  const [assets, setAssets] = useState<Assets | null>(getCachedAssets);
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    if (assets) return;
-    let alive = true;
-    // Sounds don't hold up the scene: plays before they're decoded are skipped.
-    loadAssets()
-      .then((a) => alive && setAssets(a))
-      .catch((e: Error) => alive && setError(e.message));
-    return () => {
-      alive = false;
-    };
-  }, [assets]);
-
-  const restart = useCallback(() => setRun((r) => r + 1), []);
-
-  // Dark mode rides at night. A new theme rebuilds the scene, so it starts a fresh run.
-  const night = theme.isDark;
-  return (
-    <GameLoadingTransition
-      ready={!!assets}
-      loader={
-        <GameLoading gameId={GAME_IDS.BIKE_RACING} theme={settings.theme} offset={settings.offset} error={!!error} message={error ?? undefined} />
-      }>
-      {assets && <Run key={run} {...props} settings={settings} assets={assets} night={night} onRestart={restart} />}
-    </GameLoadingTransition>
-  );
-});

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

@@ -1,103 +0,0 @@
-// Bike Racing's rules, tuning, colors, and its models (loaded once, shared by every run). The road,
-// scenery, sounds and fire are Car Racing's (games/car-racing), shared rather than copied.
-import type { Color, Model, Vec3 } from '@nayan-ui/engine';
-import { type Assets as RoadAssets, loadAssets as loadRoadAssets } from '../car-racing/CarRacingConstants';
-import { bikeMeshes } from './BikeMeshes';
-
-export {
-  AUTOPLAY,
-  CAMERA_FOV,
-  DAY_LIGHT,
-  EDGE,
-  FINISH_CLEAR,
-  LANES,
-  LATERAL_SPEED,
-  NIGHT_LIGHT,
-  NIGHT_SKY,
-  ROAD_HALF,
-  SKY,
-  STEER_RESPONSE,
-  STEER_WIDTH,
-  TRACK_LENGTH,
-  getRacingSounds
-} from '../car-racing/CarRacingConstants';
-
-// ── Rules and tuning ──────────────────────────────────────────────────
-
-// A sprint from the start line to the finish gate (Car Racing's track, as Penguin Run's): 3 lives,
-// 500 points per bike passed, and every bike you run into nose first costs a life. Crossing the finish
-// wins ("FINISHED!"); losing the last life ends it ("CRASHED!").
-export const LIVES = 3;
-export const POINTS_PER_BIKE_PASSED = 500;
-
-// Faster than the cars: bikes are light.
-export const START_SPEED = 30; // m/s, held for the whole race
-export const TRAFFIC_SPEED = 16;
-export const SPAWN_AHEAD = 170; // hidden by fog
-export const CRASH_SLOWDOWN = 0.5;
-export const INVULNERABLE = 1.6; // seconds after a crash
-/** Passing a bike with this little between your middles (metres) counts as a near miss. */
-export const NEAR_MISS_GAP = 1.3;
-export const LEAN = 0.045; // radians of lean per m/s sideways
-export const MAX_LEAN = 0.5;
-
-/** The original game's bike colors: the player's orange, traffic in blue, green and magenta (and a few more). */
-export const PLAYER_PAINT: Color = [1, 0.4, 0];
-export const PAINTS: Color[] = [
-  [0, 0.4, 1],
-  [0, 0.85, 0.4],
-  [1, 0, 1],
-  [0.95, 0.95, 0.97],
-  [0.12, 0.12, 0.14],
-  [1, 0.82, 0.1]
-];
-export const SUIT: Color = [0.11, 0.12, 0.15];
-export const SUIT_TRIM: Color = [0.3, 0.32, 0.36];
-export const VISOR: Color = [0.05, 0.06, 0.09];
-
-// ── Assets ────────────────────────────────────────────────────────────
-
-/**
- * One bike for everyone, built in code (BikeMeshes). Its paint is white so each bike tints its own
- * color; the trim (frame, tyres, wheels, chrome, exhaust) and the smoked windscreen keep theirs. The
- * rider is built from the engine's shapes (BikeRacingScene).
- */
-export type BikeModel = { body: Model; trim: Model; glass: Model; size: Vec3 };
-export type Assets = RoadAssets & { bike: BikeModel };
-
-let assets: Promise<Assets> | undefined;
-let cachedAssets: Assets | null = null;
-export const getCachedAssets = (): Assets | null => cachedAssets;
-export function loadAssets(): Promise<Assets> {
-  assets ??= loadRoadAssets().then((road) => {
-    const { body, trim, glass } = bikeMeshes();
-    return {
-      ...road,
-      bike: {
-        body,
-        trim,
-        glass,
-        size: [Math.max(body.size[0], trim.size[0]), Math.max(body.size[1], trim.size[1]), Math.max(body.size[2], trim.size[2])] as Vec3
-      }
-    };
-  });
-  assets.then(
-    (value) => {
-      cachedAssets = value;
-    },
-    () => {}
-  );
-  assets.catch(() => (assets = undefined)); // a failed load is retried next time
-  return assets;
-}
-
-/** Starts loading the game's textures and building its models (they're cached), so opening it is quick. */
-export function preloadBikeRacing() {
-  loadAssets().catch(() => {}); // the game screen reports any error
-}
-
-/** Road assets are warmed by Car Racing first and reused here. */
-export function* warmAssets(): Iterable<() => unknown> {
-  yield bikeMeshes;
-  yield loadAssets;
-}