@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/tank-1990/Tank1990Constants.ts

@@ -1,81 +0,0 @@
-// Tank 1990's rules, physics, timings and layout. Rules, speeds (per 60 Hz tick, in board points) and
-// scoring match the original version (games/tank-1990, at its medium difficulty), so scores and feel carry
-// over, including its mix of sizes: tank movement and bodies scale with the cell, bullets and the
-// fixed sizes below don't.
-import { getScoreBoardTop } from '../shared/EngineHud';
-import type { TiltView } from '../shared/EngineTilt';
-import { frontLight, gameWidthFor } from '../shared/EngineUtils';
-
-export type Direction = 'up' | 'down' | 'left' | 'right';
-export type TileType = 'empty' | 'brick' | 'steel' | 'base';
-
-// ── Rules ─────────────────────────────────────────────────────────────
-
-export const GRID_WIDTH = 13;
-export const GRID_HEIGHT = 17;
-export const LIVES = 3;
-export const POINTS_PER_ENEMY = 1000;
-export const POINTS_PER_LEVEL = 2000;
-export const ENEMIES_PER_LEVEL = 15;
-export const MAX_ENEMIES = 4;
-
-// ── Physics (points per 60 Hz tick; times in ms) ──────────────────────
-
-export const STEP_MS = 1000 / 60;
-export const STEP_TOLERANCE_MS = 2; // absorbs vsync jitter, so a 16.5 ms frame still takes its step
-export const MAX_PENDING_MS = 50; // a long frame catches up at most ~3 steps, never a fast-forward
-
-export const REFERENCE_CELL = 24; // tank speeds are per this cell size, scaled to the real one
-export const PLAYER_SPEED = 2;
-export const ENEMY_SPEED = 1;
-export const TANK_RATIO = 0.8; // a tank's body, of a cell
-export const HIT_TANK_SIZE = 20; // bullets hit tanks within (BULLET_SIZE + this) / 2
-export const BULLET_SPEED = 6;
-export const BULLET_SIZE = 4;
-export const PLAYER_FIRE_COOLDOWN = 300;
-export const ENEMY_FIRE_COOLDOWN = 1500;
-export const SPAWN_PROTECTION = 2000;
-export const ENEMY_TURN_INTERVAL = 800; // an enemy only reconsiders its heading this often
-export const ENEMY_AIM_TOLERANCE = REFERENCE_CELL * 3; // how near in line the player must be for an aimed shot
-export const FIRST_ENEMY = 1000;
-export const ENEMY_SPAWN_INTERVAL = 5000;
-export const SWIPE_THRESHOLD = 5; // points a finger moves before it steers
-
-// ── Feel (seconds) ────────────────────────────────────────────────────
-
-export const TURN_TIME = 0.08; // a tank swings round to its new heading
-export const EXPLOSION_TIME = 0.5;
-
-// ── The scene ─────────────────────────────────────────────────────────
-
-/** The camera leans back from straight down, so the walls, tanks and turrets stand up off the field. */
-export const TILT = 0.42;
-/** Lit from the upper left; surfaces facing up off the field (+z) keep their exact color. */
-export const LIGHT = frontLight([-0.45, 0.5, 1], 0.45);
-export const CLASSIC_FIELD = 'rgba(255, 255, 255, 0.30)';
-export const GRID_LINE = 'rgba(0, 0, 0, 0.10)';
-
-// ── Layout (view points) ──────────────────────────────────────────────
-
-const SCOREBOARD_HEIGHT = 82;
-const CONTROLS_HEIGHT = 110;
-/** The steel frame round the field (at most this wide, half a cell on tiny boards): it counts toward the max width. */
-export const FRAME = 10;
-
-export type Layout = TiltView & {
-  /** Whole points, as the original board used. */
-  cell: number;
-  boardWidth: number;
-  boardHeight: number;
-};
-
-/** A whole-point cell as wide as the game area allows with the frame round it, smaller if the screen is short. */
-export function getLayout(width: number, height: number, offset: number): Layout {
-  const gameWidth = gameWidthFor(width);
-  const top = getScoreBoardTop(offset) + SCOREBOARD_HEIGHT;
-  const room = Math.max(240, height - top - CONTROLS_HEIGHT);
-  // The field foreshortened by the tilt, plus the walls standing up at its far edge
-  const fitHeight = (room - FRAME * 2 * Math.cos(TILT)) / (GRID_HEIGHT * Math.cos(TILT) + 0.8 * Math.sin(TILT));
-  const cell = Math.max(8, Math.floor(Math.min((gameWidth - FRAME * 2) / GRID_WIDTH, fitHeight)));
-  return { width, height, tilt: TILT, centerY: top + room / 2, cell, boardWidth: cell * GRID_WIDTH, boardHeight: cell * GRID_HEIGHT };
-}

package/src/games/tank-1990/Tank1990Game.ts

@@ -1,331 +0,0 @@
-// Tank 1990's battle, with no React: build a game with `createGame` (it deals a map), give it a layout,
-// `start` it and `tick` it every frame. Hold a swipe to drive your tank (it fires on its own); enemies
-// roll in from the top, the first after a second and then one every five, at most four at a time and
-// fifteen in all. Destroy them all to win; lose all three lives, or let a shell reach your base, and it's
-// over.
-//
-// The battle steps in fixed 60 Hz ticks, in the same order as the original version's loop, on the game's own
-// clock (ms), so cooldowns, spawn shields and the AI's turns pause with it. Each frame then puts the
-// tanks and shells where the battle has them.
-import { type Camera, type DragEvent, World } from '@nayan-ui/engine';
-import type { GameTheme } from '../../services/ThemeService';
-import { aimTilted } from '../shared/EngineTilt';
-import {
-  type Direction,
-  ENEMIES_PER_LEVEL,
-  ENEMY_SPAWN_INTERVAL,
-  ENEMY_SPEED,
-  FIRST_ENEMY,
-  type Layout,
-  LIVES,
-  MAX_ENEMIES,
-  MAX_PENDING_MS,
-  PLAYER_SPEED,
-  POINTS_PER_ENEMY,
-  POINTS_PER_LEVEL,
-  STEP_MS,
-  STEP_TOLERANCE_MS,
-  SWIPE_THRESHOLD
-} from './Tank1990Constants';
-import {
-  type Board,
-  type Bullet,
-  bulletClashes,
-  bulletHit,
-  createEnemy,
-  createMap,
-  createPlayer,
-  damageTile,
-  enemyHeading,
-  enemyWantsToFire,
-  fire,
-  moveBullet,
-  moveTank,
-  type Tank,
-  type Tile
-} from './Tank1990Rules';
-import { buildScene, explode, muzzleFlash, rebuildWalls, removeScene, type Scene, setSceneTheme, syncUnits, updateWall } from './Tank1990Scene';
-
-export type Phase = 'ready' | 'playing' | 'over';
-/** fire: a shot of yours; kill: an enemy destroyed; hit: you were hit. */
-export type GameEvent = 'fire' | 'kill' | 'hit';
-
-const WORLD_CAPACITY = 1200; // up to ~150 walls, tanks and shells, and the bursts of a busy fight
-
-export function createGame(theme: GameTheme) {
-  const world = new World(WORLD_CAPACITY);
-  const camera: Camera = { eye: [0, 0, 240], target: [0, 0, 0], fov: 1, ortho: 1 };
-  const g = {
-    world,
-    camera,
-    theme,
-    layout: null as Layout | null,
-    scene: null as Scene | null,
-    phase: 'ready' as Phase,
-    tiles: createMap(),
-    player: null as Tank | null,
-    enemies: [] as Tank[],
-    bullets: [] as Bullet[],
-    /** Score and lives live in the engine (Rust). */
-    get lives() {
-      return world.scoreboard.lives;
-    },
-    get score() {
-      return world.scoreboard.score;
-    },
-    /** Enemies still to roll in this level. */
-    enemiesRemaining: ENEMIES_PER_LEVEL,
-    won: false,
-    /** Where the held swipe is steering, if anywhere. */
-    direction: null as Direction | null,
-    /** The game clock (ms), the fixed-step remainder, and the enemy roll-ins: a first one, then a steady interval from the start. */
-    now: 0,
-    pending: 0,
-    firstSpawn: null as number | null,
-    nextSpawn: 0,
-    // UI hooks, set by the screen.
-    onPhase: (_p: Phase) => {},
-    onScore: (_s: number) => {},
-    onLives: (_n: number) => {},
-    onEnemies: (_n: number) => {},
-    onEvent: (_e: GameEvent) => {}
-  };
-  world.scoreboard.reset(LIVES);
-  return g;
-}
-export type Game = ReturnType<typeof createGame>;
-
-const board = (g: Game): Board | null => {
-  const l = g.layout;
-  return l ? { tiles: g.tiles, cell: l.cell, width: l.boardWidth, height: l.boardHeight } : null;
-};
-
-// ── Scene ─────────────────────────────────────────────────────────────
-
-/** Lays the battle out for the view (first layout, header height, rotation); a new cell size rescales the tanks and shells. */
-export function setLayout(g: Game, l: Layout) {
-  const old = g.layout;
-  if (g.scene) removeScene(g.world, g.scene);
-  g.layout = l;
-  aimTilted(g.camera, l);
-  if (old && old.cell !== l.cell) {
-    const k = l.cell / old.cell;
-    for (const t of [...(g.player ? [g.player] : []), ...g.enemies]) {
-      t.x *= k;
-      t.y *= k;
-    }
-    for (const b of g.bullets) {
-      b.x *= k;
-      b.y *= k;
-    }
-  }
-  if (!g.player) g.player = createPlayer(l.cell, g.now);
-  g.scene = buildScene(g.world, l, g.theme, g.tiles);
-  sync(g);
-}
-
-export function setTheme(g: Game, theme: GameTheme) {
-  g.theme = theme;
-  if (g.layout && g.scene) setSceneTheme(g.world, g.layout, g.scene, theme);
-}
-
-function sync(g: Game) {
-  const { layout: l, scene: s } = g;
-  if (!l || !s) return;
-  syncUnits(g.world, l, s, [...(g.player ? [g.player] : []), ...g.enemies], g.bullets, g.now);
-}
-
-// ── Run ───────────────────────────────────────────────────────────────
-
-/** Plays the map that's showing, your tank freshly shielded. */
-export function start(g: Game) {
-  if (g.phase !== 'ready' || !g.layout) return;
-  g.phase = 'playing';
-  g.pending = 0;
-  g.firstSpawn = g.now + FIRST_ENEMY;
-  g.nextSpawn = g.now + ENEMY_SPAWN_INTERVAL;
-  g.player = createPlayer(g.layout.cell, g.now);
-  g.onPhase('playing');
-}
-
-/** A new map, not started (Stop, Play Again). The world, and the GPU view drawing it, are kept. */
-export function reset(g: Game) {
-  g.tiles = createMap();
-  g.enemies = [];
-  g.bullets = [];
-  g.world.scoreboard.reset(LIVES);
-  g.enemiesRemaining = ENEMIES_PER_LEVEL;
-  g.won = false;
-  g.direction = null;
-  g.firstSpawn = null;
-  g.phase = 'ready';
-  g.player = g.layout ? createPlayer(g.layout.cell, g.now) : null;
-  if (g.layout && g.scene) rebuildWalls(g.world, g.layout, g.scene, g.tiles);
-  sync(g);
-  g.onScore(0);
-  g.onLives(LIVES);
-  g.onEnemies(ENEMIES_PER_LEVEL);
-  g.onPhase('ready');
-}
-
-export function dispose(g: Game) {
-  g.world.dispose();
-}
-
-export function tick(g: Game, dt: number) {
-  if (g.world.isDisposed) return;
-  if (g.phase === 'playing') {
-    // Fixed 60 Hz steps; a long frame catches up at most a few
-    let pending = Math.min(g.pending + dt * 1000, MAX_PENDING_MS);
-    while (g.phase === 'playing' && pending >= STEP_MS - STEP_TOLERANCE_MS) {
-      pending -= STEP_MS;
-      g.now += STEP_MS;
-      if (g.firstSpawn !== null && g.now >= g.firstSpawn) {
-        g.firstSpawn = null;
-        spawnEnemy(g);
-      }
-      if (g.now >= g.nextSpawn) {
-        g.nextSpawn += ENEMY_SPAWN_INTERVAL;
-        spawnEnemy(g);
-      }
-      step(g);
-    }
-    g.pending = pending;
-  } else {
-    g.now += Math.min(dt, 0.25) * 1000;
-  }
-  sync(g);
-  g.world.update(dt);
-}
-
-/** An enemy at a free spawn point, while fewer than four are out and some are still to come. */
-function spawnEnemy(g: Game) {
-  const l = g.layout;
-  if (!l || g.enemies.length >= MAX_ENEMIES || g.enemiesRemaining <= 0) return;
-  const enemy = createEnemy(l.cell, g.enemies, g.now);
-  if (!enemy) return;
-  g.enemies.push(enemy);
-  g.enemiesRemaining -= 1;
-  g.onEnemies(g.enemiesRemaining);
-}
-
-/** One 60 Hz tick of the battle, in the original loop's order. */
-function step(g: Game) {
-  const b = board(g);
-  const l = g.layout;
-  let player = g.player;
-  if (!b || !l || !player) return;
-  const now = g.now;
-  const tanks = [player, ...g.enemies];
-
-  // You drive while a swipe is held, and fire whenever the gun's ready
-  if (g.direction && player.isAlive) {
-    player = moveTank(player, g.direction, PLAYER_SPEED, b, tanks);
-    tanks[0] = player;
-  }
-  const bullets = g.bullets.slice();
-  if (player.isAlive) {
-    const shot = fire(player, now);
-    if (shot) {
-      bullets.push(shot);
-      muzzleFlash(g.world, l, player);
-      player = { ...player, lastFireTime: now };
-      tanks[0] = player;
-      g.onEvent('fire');
-    }
-  }
-
-  // Each enemy: turn if blocked (or now and then), move, maybe fire
-  const aim = player;
-  let enemies = g.enemies.map((enemy) => {
-    if (!enemy.isAlive) return enemy;
-    const test = moveTank(enemy, enemy.direction, ENEMY_SPEED, b, tanks);
-    const blocked = test.x === enemy.x && test.y === enemy.y;
-    const { direction, turned } = enemyHeading(enemy, aim, b, tanks, blocked, now);
-    const moved = moveTank(enemy, direction, ENEMY_SPEED, b, tanks);
-    if (turned) moved.lastDirectionChangeTime = now;
-    if (enemyWantsToFire(moved, aim)) {
-      const shot = fire(moved, now);
-      if (shot) {
-        bullets.push(shot);
-        muzzleFlash(g.world, l, moved);
-        moved.lastFireTime = now;
-      }
-    }
-    return moved;
-  });
-
-  // Shells fly; opposing ones that meet cancel out
-  for (const shot of bullets) moveBullet(shot);
-  const clash = bulletClashes(bullets);
-  for (const [x, y] of clash.points) explode(g.world, l, x, y, false);
-
-  // ...then hit walls, the edge, or tanks
-  let lives = g.lives;
-  let baseDestroyed = false;
-  const hitTanks = [player!, ...enemies];
-  const flying = clash.remaining.filter((shot) => {
-    const hit = bulletHit(shot, b, hitTanks, now);
-    if (!hit.hit) return true;
-    if (hit.tile) {
-      const [tx, ty] = hit.tile;
-      const was = g.tiles[ty]![tx]!.type;
-      const next = damageTile(g.tiles, tx, ty);
-      if (next && g.scene) updateWall(g.world, l, g.scene, tx, ty, next as Tile, was);
-      explode(g.world, l, (tx + 0.5) * l.cell, (ty + 0.5) * l.cell, false);
-    }
-    if (hit.base) {
-      baseDestroyed = true;
-      explode(g.world, l, shot.x, shot.y, true);
-    }
-    const tank = hit.tank;
-    if (tank) {
-      explode(g.world, l, tank.x, tank.y, true);
-      if (tank.isPlayer) {
-        lives -= 1;
-        g.onEvent('hit');
-        player = lives > 0 ? createPlayer(l.cell, now) : { ...player!, isAlive: false };
-        hitTanks[0] = player;
-      } else {
-        enemies = enemies.map((e) => (e.id === tank.id ? { ...e, isAlive: false } : e));
-        for (let i = 0; i < enemies.length; i++) hitTanks[i + 1] = enemies[i]!;
-        g.onScore(g.world.scoreboard.add(POINTS_PER_ENEMY));
-        g.onEvent('kill');
-      }
-    }
-    return false;
-  });
-
-  g.player = player;
-  g.enemies = enemies.filter((e) => e.isAlive);
-  g.bullets = flying;
-  if (lives !== g.lives) {
-    g.world.scoreboard.setLives(lives);
-    g.onLives(lives);
-  }
-  if (baseDestroyed || lives <= 0) end(g, false);
-  else if (g.enemiesRemaining <= 0 && g.enemies.length === 0) end(g, true);
-}
-
-function end(g: Game, won: boolean) {
-  g.won = won;
-  if (won) {
-    g.onScore(g.world.scoreboard.add(POINTS_PER_LEVEL));
-  }
-  g.direction = null;
-  g.phase = 'over';
-  g.onPhase('over');
-}
-
-// ── The finger ────────────────────────────────────────────────────────
-
-/** Hold a swipe to drive: the way it's moved furthest from where it started; let go to stop. */
-export function drag(g: Game, { phase, dx, dy }: DragEvent) {
-  if (phase === 'end') {
-    g.direction = null;
-    return;
-  }
-  if (phase !== 'move' || g.phase !== 'playing') return;
-  if (Math.abs(dx) < SWIPE_THRESHOLD && Math.abs(dy) < SWIPE_THRESHOLD) return;
-  g.direction = Math.abs(dx) > Math.abs(dy) ? (dx > 0 ? 'right' : 'left') : dy > 0 ? 'down' : 'up';
-}