@nayan-ui/games 1.19.0 → 1.20.0

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

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

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

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