@nayan-ui/games 1.20.0 → 1.21.0

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

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