@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/car-racing/CarRacingConstants.ts

@@ -1,167 +0,0 @@
-// Car Racing's rules, tuning, colors, and its models, textures and sounds (loaded once, shared by every run).
-import {
-  audio,
-  type Color,
-  type Font,
-  type Light,
-  loadTexture,
-  type Model,
-  type SoundBank,
-  type Texture,
-  type Vec3,
-  warmUpEngine
-} from '@nayan-ui/engine';
-import { loadHudFonts } from '../shared/EngineHud';
-import { carMeshes, treeMesh } from './CarMeshes';
-import { type SceneryMeshes, sceneryMeshes } from './CarRacingScenery';
-
-// ── Rules and tuning ──────────────────────────────────────────────────
-
-// A sprint from the start line to the finish gate, as Penguin Run's track: 3 lives, 500 points per car
-// passed. Crossing the finish wins ("FINISHED!"); losing the last life ends it ("CRASHED!").
-export const TRACK_LENGTH = 2000; // metres, shared by Car Racing and Bike Racing
-export const LIVES = 3;
-export const POINTS_PER_CAR_PASSED = 500;
-/** No traffic is spawned this close to the finish, so the line is clear to cross. */
-export const FINISH_CLEAR = 30;
-
-// The road is a track that curves and climbs. Everything on it is placed by distance along it (s)
-// and offset across it (d, metres to the right of the centre line).
-export const LANE_W = 3.4;
-export const LANES = [-LANE_W, 0, LANE_W];
-export const ROAD_HALF = LANE_W * 1.5;
-export const EDGE = ROAD_HALF - 1.05; // furthest a car's centre goes before scraping the rail
-export const START_SPEED = 20; // m/s, held for the whole race
-export const CAMERA_FOV = 0.95; // Fixed perspective, matching the working engine example
-export const LATERAL_SPEED = 9; // m/s across the road
-export const STEER_RESPONSE = 10.5; // how quickly the sideways speed eases toward what the finger asks for
-export const STEER_WIDTH = 0.6; // a swipe across this much of the screen crosses the whole road
-export const TRAFFIC_SPEED = 12; // one speed: cars keep the gaps they spawned with, so no wall forms later
-export const SPAWN_AHEAD = 170; // hidden by fog
-export const CRASH_SLOWDOWN = 0.55;
-export const INVULNERABLE = 1.6; // seconds after a crash
-export const SEG_LEN = 6;
-export const SEGMENTS = 42;
-export const RS = 0.2; // road segment roots sit this far below the surface: their colliders are 0.4 thick
-export const BEHIND = 8; // segments kept behind the player, so neither camera sees where the road ends
-
-export const SKY = [0.62, 0.78, 0.95] as const;
-// Dark mode drives at night, as Playtura repaints its outdoor scenes (NIGHT_SCENE): its night sky,
-// dim bluish moonlight, and glowing lamps, lights and billboards (colors above 1 glow).
-export const NIGHT_SKY = [0.227, 0.192, 0.376] as const; // NIGHT_SCENE.SKY's lightest, at the horizon: #3A3160
-export const DAY_LIGHT: Light = { direction: [0.45, 0.85, 0.3], ambient: 0.5, shadowExtent: 26 };
-export const NIGHT_LIGHT: Light = { direction: [0.25, 0.9, 0.35], ambient: 0.66, shadowExtent: 26, color: [0.84, 0.88, 1] };
-export const LAMP: Color = [1, 0.97, 0.82];
-export const LAMP_LIT: Color = [2, 1.85, 1.3];
-export const LINE: Color = [0.95, 0.95, 0.9];
-export const RAIL: Color = [0.72, 0.74, 0.78];
-export const PAINTS: Color[] = [
-  [0.15, 0.32, 0.95],
-  [0.1, 0.75, 0.35],
-  [1, 0.8, 0.15],
-  [0.92, 0.92, 0.95],
-  [0.12, 0.12, 0.14],
-  [0.95, 0.45, 0.1],
-  [0.55, 0.2, 0.75]
-];
-export const PLAYER_PAINT: Color = [0.92, 0.08, 0.1];
-
-// Demo / QA mode: a bot drives and restarts. Run Metro with EXPO_PUBLIC_AUTOPLAY=1.
-export const AUTOPLAY = process.env.EXPO_PUBLIC_AUTOPLAY === '1';
-
-// ── Assets ────────────────────────────────────────────────────────────
-
-// Decode only when a race opens, including when the catalog is imported by a web server.
-let racingSounds: SoundBank<'engine' | 'nitro' | 'point' | 'hit' | 'win' | 'die' | 'bump'> | undefined;
-export const getRacingSounds = () =>
-  (racingSounds ??= audio.load({
-    engine: require('../../assets/sfx/engine.wav'),
-    nitro: require('../../assets/sfx/nitro.wav'),
-    point: require('../../assets/sfx/point.wav'),
-    hit: require('../../assets/sfx/hit.wav'),
-    win: require('../../assets/sfx/win.wav'),
-    die: require('../../assets/sfx/die.wav'),
-    bump: require('../../assets/sfx/bump.wav')
-  }));
-
-/**
- * One car for everyone, built in code (CarMeshes): a glossy white body each entity paints its own
- * color, the windows, and untinted trim (tyres, lights).
- */
-export type CarModel = { body: Model; glass: Model; trim: Model; size: Vec3 };
-export type Assets = {
-  car: CarModel;
-  asphalt: Texture;
-  facade: Texture;
-  grass: Texture;
-  ads: Texture[];
-  tree: Model;
-  scenery: SceneryMeshes;
-  font: Font;
-};
-
-let assets: Promise<Assets> | undefined;
-let cachedAssets: Assets | null = null;
-export const getCachedAssets = (): Assets | null => cachedAssets;
-export function loadAssets(): Promise<Assets> {
-  assets ??= warmUpEngine()
-    .then(() =>
-      Promise.all([
-        loadHudFonts(),
-        loadTexture(require('../../assets/textures/asphalt.png')),
-        loadTexture(require('../../assets/textures/facade.png')),
-        loadTexture(require('../../assets/textures/grass.png')),
-        Promise.all([
-          loadTexture(require('../../assets/textures/ad_chevrons.png')),
-          loadTexture(require('../../assets/textures/ad_bubbles.png')),
-          loadTexture(require('../../assets/textures/ad_bolt.png'))
-        ])
-      ])
-    )
-    .then(([fonts, asphalt, facade, grass, ads]) => {
-      const { body, glass, trim } = carMeshes();
-      return {
-        car: {
-          body,
-          glass,
-          trim,
-          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
-        },
-        asphalt,
-        facade,
-        grass,
-        ads,
-        tree: treeMesh(),
-        scenery: sceneryMeshes(),
-        font: fonts.semi
-      };
-    });
-  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 preloadRacing() {
-  loadAssets().catch(() => {}); // the game screen reports any error
-}
-
-/** Decode one texture per job before the asset bundle's cached assembly. */
-export function* warmAssets(): Iterable<() => unknown> {
-  yield carMeshes;
-  yield treeMesh;
-  yield sceneryMeshes;
-  yield () => loadTexture(require('../../assets/textures/asphalt.png'));
-  yield () => loadTexture(require('../../assets/textures/facade.png'));
-  yield () => loadTexture(require('../../assets/textures/grass.png'));
-  yield () => loadTexture(require('../../assets/textures/ad_chevrons.png'));
-  yield () => loadTexture(require('../../assets/textures/ad_bubbles.png'));
-  yield () => loadTexture(require('../../assets/textures/ad_bolt.png'));
-  yield loadAssets;
-  yield () => getRacingSounds().ready;
-}

package/src/games/car-racing/CarRacingFacade.ts

@@ -1,40 +0,0 @@
-import type { Vec3 } from '@nayan-ui/engine';
-
-// The bundled 64x128 facade has 8-pixel columns and 10-pixel rows. The final row is clipped;
-// these masks identify the complete warm-lit windows in that exact texture (top row first).
-const LIT_ROWS = [18, 132, 131, 192, 101, 130, 43, 0, 112, 144, 21, 32];
-
-// Match the engine cube's UV basis on each vertical face. V=0 is at the top of the building.
-const FACES: { normal: Vec3; right: Vec3 }[] = [
-  { normal: [1, 0, 0], right: [0, 0, -1] },
-  { normal: [-1, 0, 0], right: [0, 0, 1] },
-  { normal: [0, 0, 1], right: [1, 0, 0] },
-  { normal: [0, 0, -1], right: [-1, 0, 0] }
-];
-
-export function* facadeWindowQuads(): Iterable<{
-  corners: [Vec3, Vec3, Vec3, Vec3];
-  normal: Vec3;
-}> {
-  for (const face of FACES) {
-    const point = (u: number, v: number): Vec3 => [
-      face.normal[0] * 0.5005 + face.right[0] * (u - 0.5),
-      0.5 - v,
-      face.normal[2] * 0.5005 + face.right[2] * (u - 0.5)
-    ];
-    for (let row = 0; row < LIT_ROWS.length; row++) {
-      for (let col = 0; col < 8; col++) {
-        if (!(LIT_ROWS[row]! & (1 << col))) continue;
-        // Half-texel inset keeps the light inside the glass, clear of filtering at the concrete edge.
-        const u0 = (col * 8 + 2.5) / 64,
-          u1 = (col * 8 + 6.5) / 64;
-        const v0 = (row * 10 + 3.5) / 128,
-          v1 = (row * 10 + 8.5) / 128;
-        yield {
-          normal: face.normal,
-          corners: [point(u0, v0), point(u1, v0), point(u1, v1), point(u0, v1)]
-        };
-      }
-    }
-  }
-}