@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/fruit-ninja/FruitNinjaConstants.ts

@@ -1,107 +0,0 @@
-import { isTablet } from '../../services/UtilsService';
-// Fruit Ninja's rules, physics, timings and layout. Rules, scoring, physics and layout match the original
-// version (games/fruit-ninja), so scores and feel carry over.
-import type { FruitKind } from '../shared/EngineFruits';
-import { gameWidthFor } from '../shared/EngineUtils';
-
-// ── Rules ─────────────────────────────────────────────────────────────
-
-export const TIME_LIMIT = 120; // seconds; lasting it out counts as a win
-export const MAX_LIVES = 3;
-export const POINTS_PER_FRUIT = 100;
-export const POINTS_PER_STAR = 500; // and a life back
-export const BOMB_CHANCE = 0.18;
-export const STAR_CHANCE = 0.07;
-
-/** The fruits that fly, as the original version's set (all modelled in EngineFruits). */
-export const FRUIT_KINDS: readonly FruitKind[] = [
-  'apple',
-  'orange',
-  'banana',
-  'grapes',
-  'kiwi',
-  'strawberry',
-  'mango',
-  'peach',
-  'cherries',
-  'pineapple',
-  'watermelon',
-  'pomegranate',
-  'papaya'
-];
-
-// ── Spawning (seconds) ────────────────────────────────────────────────
-
-export const FIRST_WAVE = 1;
-export const WAVE_SIZE = 2;
-export const WAVE_STAGGER = 0.7; // between the items of a wave
-export const WAVE_INTERVAL = 1.8; // ± WAVE_JITTER / 2, at least WAVE_MIN
-export const WAVE_JITTER = 0.4;
-export const WAVE_MIN = 0.5;
-
-// ── Physics (points per 60 fps frame, as the original version) ───────────
-
-export const FRAME_TIME = 1 / 60;
-export const MAX_FRAMES = 2;
-export const FRUIT_SIZE = isTablet ? 90 : 60;
-/** Mesh detail for fruit this small (EngineFruits: 0.35 still looks round at 60 points); about level² the vertices of full detail. */
-export const FRUIT_DETAIL = isTablet ? 0.7 : 0.5;
-/** Fruit built back to back when the screen opens (enough to play); the rest follow one every FRUIT_BUILD_GAP ms. */
-export const FIRST_FRUITS = 3;
-export const FRUIT_BUILD_GAP = 300;
-const GRAVITY = isTablet ? 0.15 : 0.12;
-const VX_RANGE = isTablet ? 1.5 : 1;
-const SPAWN_ABOVE_BOTTOM = 50;
-const PEAK = 0.15; // fruit arcs up to the top 15% of the screen
-export const WALL_BOUNCE = 0.8;
-export const SPIN_RANGE = 0.2; // radians per frame, ± half
-export const BLADE_WINDOW = 0.07; // seconds: only this recent a stroke cuts, so the fading trail can't
-export const BLADE_POINTS = 10;
-
-// ── Feel (seconds) ────────────────────────────────────────────────────
-
-export const SPAWN_FROM = 0.55; // a fruit pops up to full size as it's thrown
-export const SPAWN_SPRING = { damping: 11, stiffness: 220 };
-export const TRAIL_FADE = 0.22;
-export const PIECE_LIFETIME = 1.1;
-export const PIECE_SPREAD = 2.5; // points per frame the halves part at
-
-// ── Look ──────────────────────────────────────────────────────────────
-
-export const BOMB_COLORS = ['#1f2937', '#374151', '#f97316', '#fde047'] as const;
-export const STAR_COLORS = ['#fbbf24', '#f59e0b', '#fef3c7', '#ffffff'] as const;
-
-// ── Layout (points) ───────────────────────────────────────────────────
-
-export type Layout = {
-  /** The GameView's size: the whole screen, as the original game area. */
-  width: number;
-  height: number;
-  offset: number;
-  /** Fruits fly within the game area's width, centred (the original version used its left part). */
-  fieldLeft: number;
-  fieldWidth: number;
-  size: number;
-  gravity: number;
-  /** Launch speed up, so a fruit peaks near the top on any screen height. */
-  launchVy: number;
-  launchVxRange: number;
-  spawnY: number;
-};
-
-export function getLayout(width: number, height: number, offset: number): Layout {
-  const fieldWidth = gameWidthFor(width);
-  const rise = height * (1 - PEAK) - SPAWN_ABOVE_BOTTOM;
-  return {
-    width,
-    height,
-    offset,
-    fieldLeft: (width - fieldWidth) / 2,
-    fieldWidth,
-    size: FRUIT_SIZE,
-    gravity: GRAVITY,
-    launchVy: -Math.sqrt(2 * GRAVITY * rise),
-    launchVxRange: VX_RANGE,
-    spawnY: height - SPAWN_ABOVE_BOTTOM
-  };
-}

package/src/games/fruit-ninja/FruitNinjaGame.ts

@@ -1,391 +0,0 @@
-// Fruit Ninja's rules and physics, with no React: build a run with `createGame`, hand it the models
-// and a layout, `start` it and `tick` it every frame. Fruit, bombs and stars are thrown up from the
-// bottom in waves of two. Swipe through them: a fruit scores 100, a star 500 and a life back, a bomb
-// costs a life. Last out the timer to win; lose all three lives and it's over. Missed fruit cost
-// nothing. The physics and blade are the original version's: moves are per 60 fps frame, scaled by the
-// frame's length, and a stroke only cuts for 70 ms after it's drawn.
-import { type Camera, type Entity, World } from '@nayan-ui/engine';
-import type { GameTheme } from '../../services/ThemeService';
-import type { Fruit, FruitKind } from '../shared/EngineFruits';
-import {
-  BLADE_POINTS,
-  BLADE_WINDOW,
-  BOMB_CHANCE,
-  FIRST_WAVE,
-  FRAME_TIME,
-  type Layout,
-  MAX_FRAMES,
-  MAX_LIVES,
-  POINTS_PER_FRUIT,
-  POINTS_PER_STAR,
-  SPIN_RANGE,
-  STAR_CHANCE,
-  TIME_LIMIT,
-  WALL_BOUNCE,
-  WAVE_INTERVAL,
-  WAVE_JITTER,
-  WAVE_MIN,
-  WAVE_SIZE,
-  WAVE_STAGGER
-} from './FruitNinjaConstants';
-import {
-  buildModels,
-  drawTrail,
-  fadeTrail,
-  hideTrail,
-  type ItemKind,
-  type Models,
-  placeItem,
-  removeTrail,
-  sliceItem,
-  spawnItem,
-  spawnTrail,
-  type Trail
-} from './FruitNinjaScene';
-import { cameraFor, makeView, spawnWorld, type View3D } from './FruitNinjaWorld';
-
-export type Phase = 'ready' | 'playing' | 'over';
-
-/** A thrown item: its box's top-left (field points across, screen points down) and its velocity per frame. */
-type Item = { what: ItemKind; x: number; y: number; vx: number; vy: number; root: Entity };
-
-const WORLD_CAPACITY = 1400; // the world's scenery (~450), a few items, sliced halves, the trail, splashes and bursts
-
-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.6, 0], target: [0, 1.6, -1], fov: 0.9 };
-  const g = {
-    world,
-    camera,
-    theme,
-    layout: null as Layout | null,
-    view: null as View3D | null,
-    /** Everything in the world around the play area (sky, hills, trees, ...). */
-    scenery: [] as Entity[],
-    models: null as Models | null,
-    trail: null as Trail | 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 waves and the blade's window (they pause with the frame loop). */
-    time: 0,
-    items: [] as Item[],
-    /** The fruit built so far (whole and halves): only these are thrown, so a throw or a cut never builds a mesh. */
-    kinds: [] as FruitKind[],
-    /** The blade's recent touch points (screen x, y and the game time, oldest first), in fixed buffers. */
-    bladeX: new Float64Array(BLADE_POINTS),
-    bladeY: new Float64Array(BLADE_POINTS),
-    bladeT: new Float64Array(BLADE_POINTS),
-    bladeLen: 0,
-    /** A finger is down: moves extend the stroke (after it lifts, the stroke only cuts for BLADE_WINDOW). */
-    touching: false,
-    /** The trail needs drawing: touches mark it, the next tick draws it once. */
-    trailDirty: false,
-    // UI hooks, set by the screen.
-    onPhase: (_p: Phase) => {},
-    onScore: (_s: number) => {},
-    onLives: (_n: number) => {},
-    onTime: (_t: number) => {},
-    onTouch: () => {},
-    onSlice: () => {},
-    onBomb: () => {},
-    onWin: () => {},
-    onLose: () => {}
-  };
-  world.scoreboard.reset(MAX_LIVES, TIME_LIMIT);
-  world.scoreboard.handlers = {
-    onSecond: (t) => g.onTime(t),
-    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 ─────────────────────────────────────────────────────────────
-
-/** The fruit models are ready (built once per app, after the screen has opened). */
-export function setModels(g: Game, fruits: Record<FruitKind, Fruit>) {
-  g.models = buildModels(fruits);
-  if (g.layout && !g.trail) g.trail = spawnTrail(g.world);
-}
-
-/** A fruit is built (whole and halves) and can be thrown from now on. */
-export function addFruit(g: Game, kind: FruitKind) {
-  if (!g.kinds.includes(kind)) g.kinds.push(kind);
-}
-
-/** Lays the scene out for the view (first layout, header height, rotation). Items in the air are cleared. */
-export function setLayout(g: Game, l: Layout) {
-  const w = g.world;
-  clearItems(g);
-  for (const e of g.scenery) w.despawn(e);
-  if (g.trail) removeTrail(w, g.trail);
-  g.layout = l;
-  const v = makeView(l.width, l.height);
-  g.view = v;
-  const cam = cameraFor(v);
-  g.camera.eye = cam.eye;
-  g.camera.target = cam.target;
-  g.camera.fov = cam.fov;
-  g.scenery = spawnWorld(w, v, g.theme);
-  g.trail = g.models ? spawnTrail(w) : null;
-}
-
-/** A new theme: day or night outside (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;
-  const v = g.view;
-  if (!v || g.world.isDisposed) return;
-  for (const e of g.scenery) g.world.despawn(e);
-  g.scenery = spawnWorld(g.world, v, theme);
-}
-
-function clearItems(g: Game) {
-  for (const it of g.items) g.world.despawn(it.root);
-  g.items = [];
-}
-
-// ── Run ───────────────────────────────────────────────────────────────
-
-export function start(g: Game) {
-  if (g.phase !== 'ready') return;
-  g.phase = 'playing';
-  g.world.scoreboard.startCountdown(TIME_LIMIT);
-  g.onPhase('playing');
-  after(g, FIRST_WAVE, () => wave(g));
-}
-
-/** Two items a little apart, then the next wave after about 1.8 s. */
-function wave(g: Game) {
-  if (g.phase !== 'playing') return;
-  for (let i = 0; i < WAVE_SIZE; i++) after(g, i * WAVE_STAGGER, () => throwItem(g));
-  after(g, Math.max(WAVE_MIN, WAVE_INTERVAL + (Math.random() - 0.5) * WAVE_JITTER), () => wave(g));
-}
-
-/** 18% a bomb, 7% a star, otherwise a random fruit, thrown up from the bottom. */
-function throwItem(g: Game) {
-  const l = g.layout;
-  const v = g.view;
-  const m = g.models;
-  if (!l || !v || !m || g.phase !== 'playing') return;
-  const roll = Math.random();
-  const what: ItemKind =
-    roll < BOMB_CHANCE
-      ? { kind: 'bomb' }
-      : roll < BOMB_CHANCE + STAR_CHANCE
-        ? { kind: 'star' }
-        : g.kinds.length
-          ? { kind: 'fruit', fruit: g.kinds[Math.floor(Math.random() * g.kinds.length)]! }
-          : { kind: 'star' };
-  const x = Math.random() * (l.fieldWidth - l.size);
-  const y = l.spawnY;
-  const half = l.size / 2;
-  g.items.push({
-    what,
-    x,
-    y,
-    vx: (Math.random() - 0.5) * l.launchVxRange,
-    vy: l.launchVy + (Math.random() - 0.5),
-    root: spawnItem(g.world, v, l, m, what, l.fieldLeft + x + half, y + half, (Math.random() - 0.5) * SPIN_RANGE)
-  });
-}
-
-/** A fresh run (Stop, Play Again). The world, and the GPU view drawing it, are kept. */
-export function reset(g: Game) {
-  g.world.cancelTimers();
-  clearItems(g);
-  endStroke(g);
-  g.bladeLen = 0;
-  g.world.scoreboard.reset(MAX_LIVES, TIME_LIMIT);
-  g.won = false;
-  g.phase = 'ready';
-  g.onScore(0);
-  g.onLives(MAX_LIVES);
-  g.onTime(TIME_LIMIT);
-  g.onPhase('ready');
-}
-
-export function dispose(g: Game) {
-  g.world.cancelTimers();
-  g.world.dispose();
-}
-
-/** Time up (a win) or out of lives: the waves stop and what's in the air is cleared. */
-function end(g: Game, won: boolean) {
-  g.world.scoreboard.stop();
-  g.world.cancelTimers();
-  clearItems(g);
-  g.bladeLen = 0;
-  g.touching = false;
-  g.trailDirty = false;
-  if (g.trail) hideTrail(g.world, g.trail);
-  g.won = won;
-  g.phase = 'over';
-  if (won) g.onWin();
-  else g.onLose();
-  g.onPhase('over');
-}
-
-export function tick(g: Game, dt: number) {
-  if (g.world.isDisposed) return;
-  g.time += dt;
-  if (g.phase === 'playing' && g.items.length) step(g, Math.min(dt / FRAME_TIME, MAX_FRAMES));
-  if (g.trailDirty) {
-    g.trailDirty = false;
-    if (g.view && g.trail) drawTrail(g.world, g.view, g.trail, g.bladeX, g.bladeY, g.bladeLen);
-  }
-  g.world.update(dt);
-}
-
-// ── Blade ─────────────────────────────────────────────────────────────
-
-/** Finger down: the blade starts here. */
-export function touchStart(g: Game, x: number, y: number) {
-  if (g.phase !== 'playing') return;
-  g.bladeLen = 0;
-  g.touching = true;
-  addPoint(g, x, y);
-  g.onTouch();
-}
-
-export function touchMove(g: Game, x: number, y: number) {
-  if (g.phase !== 'playing' || !g.touching) return;
-  // Several moves can arrive in one frame; a point that hasn't moved adds nothing to the cut or the trail
-  const last = g.bladeLen - 1;
-  if (last >= 0 && g.bladeX[last] === x && g.bladeY[last] === y) return;
-  addPoint(g, x, y);
-}
-
-/** Appends a point, dropping the oldest once the buffers are full (shifted in place: no allocation). */
-function addPoint(g: Game, x: number, y: number) {
-  if (g.bladeLen === BLADE_POINTS) {
-    g.bladeX.copyWithin(0, 1);
-    g.bladeY.copyWithin(0, 1);
-    g.bladeT.copyWithin(0, 1);
-    g.bladeLen--;
-  }
-  g.bladeX[g.bladeLen] = x;
-  g.bladeY[g.bladeLen] = y;
-  g.bladeT[g.bladeLen] = g.time;
-  g.bladeLen++;
-  g.trailDirty = true;
-}
-
-/** Finger up: the trail fades; the stroke can still cut for its last few milliseconds. */
-export function touchEnd(g: Game) {
-  endStroke(g);
-}
-
-function endStroke(g: Game) {
-  g.touching = false;
-  if (!g.trail) return;
-  // A pending redraw goes first, so a quick swipe that lifts within a frame still fades from where it ended
-  if (g.trailDirty && g.view) drawTrail(g.world, g.view, g.trail, g.bladeX, g.bladeY, g.bladeLen);
-  g.trailDirty = false;
-  if (g.bladeLen > 1) fadeTrail(g.world, g.trail);
-  else hideTrail(g.world, g.trail);
-}
-
-const segmentDistSq = (px: number, py: number, ax: number, ay: number, bx: number, by: number) => {
-  const dx = bx - ax;
-  const dy = by - ay;
-  const lenSq = dx * dx + dy * dy;
-  const t = lenSq > 0 ? Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / lenSq)) : 0;
-  return (ax + dx * t - px) ** 2 + (ay + dy * t - py) ** 2;
-};
-
-/** The recent stroke segment that passes within a fruit's radius of (cx, cy), as its direction, or null. */
-function cutBy(g: Game, cx: number, cy: number, radius: number): [number, number] | null {
-  const { bladeX: xs, bladeY: ys, bladeT: ts, bladeLen: n } = g;
-  const cutoff = g.time - BLADE_WINDOW;
-  const r2 = radius * radius;
-  if (n === 1) return ts[0]! >= cutoff && (xs[0]! - cx) ** 2 + (ys[0]! - cy) ** 2 <= r2 ? [1, 0] : null;
-  // Newest segments last: skip straight to the ones still inside the cutting window
-  for (let i = n - 2; i >= 0; i--) {
-    if (ts[i + 1]! < cutoff) break;
-    if (segmentDistSq(cx, cy, xs[i]!, ys[i]!, xs[i + 1]!, ys[i + 1]!) <= r2) return [xs[i + 1]! - xs[i]!, ys[i + 1]! - ys[i]!];
-  }
-  return null;
-}
-
-// ── Physics ───────────────────────────────────────────────────────────
-
-/** One step of `dt` 60 fps frames: the blade cuts, then everything in the air moves (as the original version). */
-function step(g: Game, dt: number) {
-  const l = g.layout!;
-  const half = l.size / 2;
-  const right = l.fieldWidth - l.size;
-  const items = g.items;
-  const updates = g.world.transforms;
-  let kept = 0;
-  for (const it of items) {
-    const cx = l.fieldLeft + it.x + half;
-    const cy = it.y + half;
-    const cut = cutBy(g, cx, cy, half);
-    if (cut) {
-      slice(g, it, cx, cy, cut);
-      if (g.phase !== 'playing') {
-        updates.clear();
-        return;
-      } // the bomb took the last life
-      continue;
-    }
-    it.vy += l.gravity * dt;
-    let x = it.x + it.vx * dt;
-    let y = it.y + it.vy * dt;
-    // Fell off the bottom: gone, no penalty
-    if (y > l.height + 100) {
-      g.world.despawn(it.root);
-      continue;
-    }
-    // Kept from flying off the top, and bounced off the field's sides
-    if (y < -50) {
-      it.vy = Math.max(it.vy, 0.5);
-      y = -50;
-    } else if (x <= 0) {
-      x = 0;
-      it.vx = Math.abs(it.vx) * WALL_BOUNCE;
-    } else if (x >= right) {
-      x = right;
-      it.vx = -Math.abs(it.vx) * WALL_BOUNCE;
-    }
-    it.x = x;
-    it.y = y;
-    placeItem(g.world, g.view!, it.root, l.fieldLeft + x + half, y + half, updates);
-    items[kept++] = it;
-  }
-  items.length = kept;
-  updates.flush();
-}
-
-function slice(g: Game, it: Item, cx: number, cy: number, [dx, dy]: [number, number]) {
-  sliceItem(g.world, g.view!, g.layout!, g.models!, it.root, it.what, cx, cy, it.vx, it.vy, dx, dy);
-  if (it.what.kind === 'bomb') {
-    g.onBomb();
-    g.onLives(g.world.scoreboard.addLives(-1));
-    if (g.lives <= 0) end(g, false);
-    return;
-  }
-  g.onSlice();
-  if (it.what.kind === 'star') {
-    g.world.scoreboard.setLives(Math.min(g.lives + 1, MAX_LIVES));
-    g.onLives(g.lives);
-    g.world.scoreboard.add(POINTS_PER_STAR);
-  } else {
-    g.world.scoreboard.add(POINTS_PER_FRUIT);
-  }
-  g.onScore(g.score);
-}