@nayan-ui/games 1.19.0 → 1.20.0

package/src/games/dino-jump/DinoJumpGame.ts

@@ -0,0 +1,344 @@
+// Dino Jump's rules and physics, with no React: build a run with `createGame`, give it a layout,
+// `start` it and `tick` it every frame. The dino runs across the desert; tap to jump the cacti coming
+// at it (no double jumps). Each one hit costs a life; a mushroom gives one back and 1,000 points. Every
+// second survived scores 200; last out the two minutes to win, lose all three lives and it's over. The
+// physics is the original version's, in fixed 60 Hz steps (its constants are per step).
+import { type Camera, type Color, type Entity, World } from '@nayan-ui/engine';
+import type { GameTheme } from '../../services/ThemeService';
+import { at, cameraFor, makeView, pointSize, sceneryTint, spawnWorld, type View3D } from '../shared/EngineMeadow';
+import {
+  DINO_HIT_HEIGHT,
+  DINO_HIT_WIDTH,
+  DINO_X,
+  DUST_INTERVAL,
+  FIRST_OBSTACLE,
+  GRAVITY,
+  JUMP_FORCE,
+  type Layout,
+  LIVES,
+  MAX_OBSTACLES,
+  MAX_PENDING,
+  MEADOW,
+  MIN_OBSTACLE_GAP,
+  MUSHROOM_CHANCE,
+  MUSHROOM_POINTS,
+  OBSTACLE_SIZE,
+  type ObstacleKind,
+  POINTS_PER_SECOND,
+  REMOVE_X,
+  rigFor,
+  RUN_SPEED,
+  SMALL_CHANCE,
+  SPAWN_MIN,
+  SPAWN_SPREAD,
+  STEP,
+  STEP_TOLERANCE,
+  TIME_LIMIT
+} from './DinoJumpConstants';
+import {
+  cheerDino,
+  dinoCentre,
+  type DinoView,
+  dust,
+  hitBurst,
+  hurtDino,
+  placeDesert,
+  placeDino,
+  placeObstacle,
+  removeDesert,
+  setGait,
+  spawnDesert,
+  spawnDino,
+  spawnObstacle,
+  type Tiles
+} from './DinoJumpScene';
+
+export type Phase = 'ready' | 'playing' | 'over';
+
+/** An obstacle: its box's left edge (screen points). */
+type Obstacle = { kind: ObstacleKind; x: number; root: Entity };
+
+const WORLD_CAPACITY = 900; // the sky and hills (~80), three desert tiles (~180), the dino, obstacles, dust
+
+export function createGame(theme: GameTheme) {
+  const world = new World(WORLD_CAPACITY);
+  // Placed for the view on the first layout; GameView reads this object every frame
+  const camera: Camera = { eye: [0, 1, 0], target: [0, 1, -1], fov: 0.9 };
+  const g = {
+    world,
+    camera,
+    theme,
+    tint: sceneryTint(theme) as Color,
+    layout: null as Layout | null,
+    view: null as View3D | null,
+    scenery: [] as Entity[],
+    desert: null as Tiles | null,
+    dino: null as DinoView | null,
+    phase: 'ready' as Phase,
+    /** 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;
+    },
+    get timeLeft() {
+      return world.scoreboard.shownSeconds;
+    },
+    won: false,
+    /** Game clock, seconds: drives the spawns and the dust (it pauses with the frame loop). */
+    time: 0,
+    pending: 0,
+    /** The dino's height above the ground (points, negative is up) and its vertical speed. */
+    jumpY: 0,
+    velocity: 0,
+    jumping: false,
+    /** How far the desert has scrolled, in points at the play plane. */
+    scroll: 0,
+    dustTimer: 0,
+    obstacles: [] as Obstacle[],
+    // UI hooks, set by the screen.
+    onPhase: (_p: Phase) => {},
+    onScore: (_s: number) => {},
+    onLives: (_n: number) => {},
+    onTime: (_t: number) => {},
+    onJump: () => {},
+    onHit: (_last: boolean) => {},
+    onCollect: () => {}
+  };
+  world.scoreboard.reset(LIVES, TIME_LIMIT);
+  world.scoreboard.handlers = {
+    // Each second survived scores
+    onSecond: (t) => {
+      if (g.phase !== 'playing') return;
+      g.onTime(t);
+      g.onScore(world.scoreboard.add(POINTS_PER_SECOND));
+    },
+    onTimeUp: () => g.phase === 'playing' && end(g, true)
+  };
+  return g;
+}
+export type Game = ReturnType<typeof createGame>;
+
+const after = (g: Game, seconds: number, run: () => void) => g.world.after(seconds, run);
+
+// ── Scene ─────────────────────────────────────────────────────────────
+
+/** Lays the world out for the view and header (the camera height follows the ground line). */
+export function setLayout(g: Game, l: Layout) {
+  const w = g.world;
+  for (const e of g.scenery) w.despawn(e);
+  if (g.desert) removeDesert(w, g.desert);
+  if (g.dino) w.despawn(g.dino.root);
+  clearObstacles(g);
+  g.layout = l;
+  const v = makeView(l.width, l.height, rigFor(l.height, l.offset));
+  g.view = v;
+  const cam = cameraFor(v);
+  g.camera.eye = cam.eye;
+  g.camera.target = cam.target;
+  g.camera.fov = cam.fov;
+  buildScenery(g);
+  g.dino = spawnDino(w, v, dinoCentre(DINO_X), l.groundY + g.jumpY, g.tint);
+  setGait(w, v, g.dino, g.phase === 'playing' ? (g.jumping ? 'air' : 'run') : 'stand');
+}
+
+function buildScenery(g: Game) {
+  const v = g.view!;
+  const l = g.layout!;
+  g.scenery = spawnWorld(g.world, v, g.theme, MEADOW);
+  // Where the dino runs: the depth at which the play plane meets the ground
+  g.desert = spawnDesert(g.world, g.theme, -at(v, 0, l.groundY)[2]);
+  placeDesert(g.world, g.desert, g.scroll * pointSize(v));
+}
+
+/** A new theme: day or night (the screen swaps the light); the run carries on. */
+export function setTheme(g: Game, theme: GameTheme) {
+  if (theme === g.theme && g.scenery.length) return;
+  g.theme = theme;
+  g.tint = sceneryTint(theme);
+  if (!g.view || !g.layout || g.world.isDisposed) return;
+  for (const e of g.scenery) g.world.despawn(e);
+  if (g.desert) removeDesert(g.world, g.desert);
+  buildScenery(g);
+  if (g.dino) for (const e of [g.dino.body, g.dino.near, g.dino.far]) g.world.set(e, { color: g.tint });
+  for (const o of g.obstacles) g.world.set(o.root, { color: g.tint });
+}
+
+function clearObstacles(g: Game) {
+  for (const o of g.obstacles) g.world.despawn(o.root);
+  g.obstacles = [];
+}
+
+// ── Run ───────────────────────────────────────────────────────────────
+
+export function start(g: Game) {
+  if (g.phase !== 'ready' || !g.view) return;
+  g.jumpY = 0;
+  g.velocity = 0;
+  g.jumping = false;
+  g.pending = 0;
+  g.phase = 'playing';
+  g.world.scoreboard.startCountdown(TIME_LIMIT);
+  if (g.dino) setGait(g.world, g.view, g.dino, 'run');
+  drawDino(g);
+  g.onPhase('playing');
+  after(g, FIRST_OBSTACLE, () => spawnLoop(g));
+}
+
+/** An obstacle now, and the next one 2.5 to 4.5 seconds later. */
+function spawnLoop(g: Game) {
+  if (g.phase !== 'playing') return;
+  spawn(g);
+  after(g, SPAWN_MIN + Math.random() * SPAWN_SPREAD, () => spawnLoop(g));
+}
+
+/** A mushroom now and then, otherwise a small or tall cactus, just past the right edge (if there's room). */
+function spawn(g: Game) {
+  const l = g.layout;
+  const v = g.view;
+  if (!l || !v || g.obstacles.length >= MAX_OBSTACLES) return;
+  if (g.obstacles.some((o) => o.x > l.width - MIN_OBSTACLE_GAP)) return;
+  const roll = Math.random();
+  const kind: ObstacleKind = roll < MUSHROOM_CHANCE ? 'mushroom' : roll < MUSHROOM_CHANCE + SMALL_CHANCE ? 'cactus_small' : 'cactus_large';
+  g.obstacles.push({ kind, x: l.width, root: spawnObstacle(g.world, v, l, kind, l.width, g.tint) });
+}
+
+/** A fresh run (Stop, Play Again): the dino back on the ground, standing. The world is kept. */
+export function reset(g: Game) {
+  g.world.cancelTimers();
+  clearObstacles(g);
+  g.jumpY = 0;
+  g.velocity = 0;
+  g.jumping = false;
+  g.pending = 0;
+  g.world.scoreboard.reset(LIVES, TIME_LIMIT);
+  g.won = false;
+  g.phase = 'ready';
+  if (g.dino && g.view) setGait(g.world, g.view, g.dino, 'stand');
+  drawDino(g);
+  g.onScore(0);
+  g.onLives(LIVES);
+  g.onTime(TIME_LIMIT);
+  g.onPhase('ready');
+}
+
+export function dispose(g: Game) {
+  g.world.cancelTimers();
+  g.world.dispose();
+}
+
+/** The run ends: everything freezes where it is, under the game-over card. */
+function end(g: Game, won: boolean) {
+  g.world.scoreboard.stop();
+  g.world.cancelTimers();
+  g.won = won;
+  g.phase = 'over';
+  if (g.dino && g.view) setGait(g.world, g.view, g.dino, g.jumping ? 'air' : 'stand');
+  g.onPhase('over');
+}
+
+export function tick(g: Game, dt: number) {
+  if (g.world.isDisposed) return;
+  g.time += dt;
+  if (g.phase === 'playing') {
+    g.pending = Math.min(g.pending + dt, MAX_PENDING);
+    let stepped = false;
+    while (g.pending >= STEP - STEP_TOLERANCE && g.phase === 'playing') {
+      g.pending -= STEP;
+      step(g);
+      stepped = true;
+    }
+    if (stepped) draw(g);
+    // A little sand kicked up behind the feet while running
+    g.dustTimer += dt;
+    if (g.phase === 'playing' && !g.jumping && g.dustTimer >= DUST_INTERVAL && g.view && g.layout) {
+      g.dustTimer = 0;
+      dust(g.world, g.view, DINO_X + 12, g.layout.groundY, false);
+    }
+  }
+  g.world.update(dt);
+}
+
+/** Finger down: jump, if on the ground. */
+export function jump(g: Game) {
+  if (g.phase !== 'playing' || g.jumping) return;
+  g.jumping = true;
+  g.velocity = JUMP_FORCE;
+  if (g.dino && g.view) setGait(g.world, g.view, g.dino, 'air');
+  g.onJump();
+}
+
+// ── Physics ───────────────────────────────────────────────────────────
+
+/** One 60 Hz step: the jump arc, the scroll, then at most one collision. */
+function step(g: Game) {
+  const l = g.layout!;
+  if (g.jumping) {
+    g.velocity += GRAVITY;
+    g.jumpY += g.velocity;
+    if (g.jumpY >= 0) {
+      g.jumpY = 0;
+      g.velocity = 0;
+      g.jumping = false;
+      if (g.dino && g.view) {
+        setGait(g.world, g.view, g.dino, 'run');
+        dust(g.world, g.view, dinoCentre(DINO_X), l.groundY, true);
+      }
+    }
+  }
+  g.scroll += RUN_SPEED;
+  g.obstacles = g.obstacles.filter((o) => {
+    o.x -= RUN_SPEED;
+    if (o.x < REMOVE_X) {
+      g.world.despawn(o.root);
+      return false;
+    }
+    return true;
+  });
+
+  const top = l.groundY - DINO_HIT_HEIGHT + g.jumpY;
+  const hit = g.obstacles.find((o) => {
+    const { width, height } = OBSTACLE_SIZE[o.kind];
+    const oy = l.groundY - height;
+    return DINO_X < o.x + width && DINO_X + DINO_HIT_WIDTH > o.x && top < oy + height && top + DINO_HIT_HEIGHT > oy;
+  });
+  if (!hit) return;
+  g.obstacles = g.obstacles.filter((o) => o !== hit);
+  g.world.despawn(hit.root);
+  const { width, height } = OBSTACLE_SIZE[hit.kind];
+  if (g.view) hitBurst(g.world, g.view, hit.x + width / 2, l.groundY - height / 2, hit.kind === 'mushroom');
+  if (hit.kind === 'mushroom') {
+    if (g.lives < LIVES) g.world.scoreboard.addLives(1);
+    g.onLives(g.lives);
+    g.onScore(g.world.scoreboard.add(MUSHROOM_POINTS));
+    if (g.dino) cheerDino(g.world, g.dino, g.tint);
+    g.onCollect();
+    return;
+  }
+  g.onLives(g.world.scoreboard.addLives(-1));
+  if (g.dino) hurtDino(g.world, g.dino, g.tint);
+  g.onHit(g.lives <= 0);
+  if (g.lives <= 0) {
+    draw(g);
+    end(g, false);
+  }
+}
+
+function drawDino(g: Game) {
+  const l = g.layout;
+  const v = g.view;
+  if (!l || !v || !g.dino) return;
+  placeDino(g.world, v, g.dino, dinoCentre(DINO_X), l.groundY + g.jumpY);
+}
+
+function draw(g: Game) {
+  const l = g.layout;
+  const v = g.view;
+  if (!l || !v) return;
+  const updates = g.world.transforms;
+  for (const o of g.obstacles) placeObstacle(g.world, v, l, o.root, o.kind, o.x, updates);
+  updates.flush();
+  if (g.desert) placeDesert(g.world, g.desert, g.scroll * pointSize(v));
+  drawDino(g);
+}