@nayan-ui/games 1.20.0 → 1.21.0

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

@@ -1,390 +0,0 @@
-// Tank 1990's battle rules, as plain functions on board points (x right, y down, from the board's
-// top-left): the map, moving, firing, bullets and what they hit, and the enemy AI. Ported step for step
-// from the original version's service and UI-thread loop (games/tank-1990), so the battle plays the same.
-// Times are the game's own clock in ms, so cooldowns and spawn shields pause with it.
-import {
-  BULLET_SIZE,
-  BULLET_SPEED,
-  type Direction,
-  ENEMY_AIM_TOLERANCE,
-  ENEMY_FIRE_COOLDOWN,
-  ENEMY_SPEED,
-  ENEMY_TURN_INTERVAL,
-  GRID_HEIGHT,
-  GRID_WIDTH,
-  HIT_TANK_SIZE,
-  PLAYER_FIRE_COOLDOWN,
-  REFERENCE_CELL,
-  SPAWN_PROTECTION,
-  TANK_RATIO,
-  type TileType
-} from './Tank1990Constants';
-
-export type Tank = {
-  id: number;
-  x: number;
-  y: number;
-  direction: Direction;
-  isPlayer: boolean;
-  isAlive: boolean;
-  lastFireTime: number;
-  spawnProtectionEndTime: number;
-  lastDirectionChangeTime: number;
-};
-export type Bullet = { id: number; x: number; y: number; direction: Direction; isPlayerBullet: boolean };
-export type Tile = { type: TileType; health: number };
-export type Board = { tiles: Tile[][]; cell: number; width: number; height: number };
-
-const DIRECTIONS: Direction[] = ['up', 'down', 'left', 'right'];
-const OPPOSITE: Record<Direction, Direction> = { up: 'down', down: 'up', left: 'right', right: 'left' };
-const STEP: Record<Direction, [number, number]> = { up: [0, -1], down: [0, 1], left: [-1, 0], right: [1, 0] };
-const solid = (t: Tile | undefined) => !!t && (t.type === 'brick' || t.type === 'steel' || t.type === 'base');
-
-let ids = 0;
-const nextId = () => ++ids;
-
-// ── The map ───────────────────────────────────────────────────────────
-
-export const BASE_X = Math.floor(GRID_WIDTH / 2);
-export const BASE_Y = GRID_HEIGHT - 3;
-
-/**
- * Hand-built arenas, 13 by 17 (`B` brick, `S` steel, `.` open), in the spirit of the original's stages:
- * brick columns, bunkers, mazes and crossings with steel strongpoints. The bottom rows (the base and the
- * player's start) and the enemies' spawn corners are cleared by createMap whatever a layout has there.
- */
-const LAYOUTS: readonly (readonly string[])[] = [
-  // Columns
-  [
-    '.............',
-    '.B.B.B.B.B.B.',
-    '.B.B.B.B.B.B.',
-    '.B.B.BSB.B.B.',
-    '.B.B.B.B.B.B.',
-    '.B.B.....B.B.',
-    '.....B.B.....',
-    'S.BB.....BB.S',
-    '.....B.B.....',
-    '.B.B.BBB.B.B.',
-    '.B.B.B.B.B.B.',
-    '.B.B.....B.B.',
-    '.B.B.BBB.B.B.',
-    '.............',
-    '.............',
-    '.............',
-    '.............'
-  ],
-  // Steel maze
-  [
-    '.............',
-    '..SS.....SS..',
-    '..S..BBB..S..',
-    'BB...B.B...BB',
-    '..SS.....SS..',
-    '.....SSS.....',
-    '.BBB.....BBB.',
-    '.B.B.BBB.B.B.',
-    '.BBB.B.B.BBB.',
-    '.....BBB.....',
-    'SS.........SS',
-    '..BBB.S.BBB..',
-    '..B.......B..',
-    '.............',
-    'BB.........BB',
-    '.............',
-    '.............'
-  ],
-  // Waves
-  [
-    '.............',
-    '..B.......B..',
-    '.BB.SS.SS.BB.',
-    'BB.........BB',
-    'B..BB...BB..B',
-    '..BB..S..BB..',
-    '.BB..BBB..BB.',
-    'BB..BB.BB..BB',
-    '...BB...BB...',
-    '.SBB..S..BBS.',
-    '..B..BBB..B..',
-    '.BB.B...B.BB.',
-    '....B.S.B....',
-    '.............',
-    'SS.........SS',
-    '.............',
-    '.............'
-  ],
-  // Bunkers
-  [
-    '.............',
-    '.BBB.....BBB.',
-    '.B.B.SSS.B.B.',
-    '.BBB.....BBB.',
-    '.............',
-    'SS.BBB.BBB.SS',
-    '...B.B.B.B...',
-    '...BBB.BBB...',
-    '.B.........B.',
-    '.BBB.SSS.BBB.',
-    '.B.B.....B.B.',
-    '.BBB.BBB.BBB.',
-    '.....B.B.....',
-    '.............',
-    '.BB.......BB.',
-    '.............',
-    '.............'
-  ],
-  // Crossroads
-  [
-    '.............',
-    '..B..B.B..B..',
-    '..B..B.B..B..',
-    'SSB..B.B..BSS',
-    '..B.......B..',
-    '..BBBB.BBBB..',
-    '......S......',
-    'BBBB.SSS.BBBB',
-    '......S......',
-    '..BBBB.BBBB..',
-    '..B.......B..',
-    'SSB.BBBBB.BSS',
-    '..B.......B..',
-    '.............',
-    '.B.........B.',
-    '.............',
-    '.............'
-  ],
-  // Rings
-  [
-    '.............',
-    '.BBBBB.BBBBB.',
-    '.B.........B.',
-    '.B.BBB.BBB.B.',
-    '.B.B.S.S.B.B.',
-    '...B.....B...',
-    'S..BBB.BBB..S',
-    '.............',
-    'BB.SS.B.SS.BB',
-    '.............',
-    'S..BBB.BBB..S',
-    '...B.....B...',
-    '.B.B.BBB.B.B.',
-    '.B.........B.',
-    '.BB.......BB.',
-    '.............',
-    '.............'
-  ]
-];
-
-/** A fresh map: one of the arenas (sometimes mirrored), the base walled in steel, the spawns and the player's start kept clear. */
-export function createMap(): Tile[][] {
-  const width = GRID_WIDTH;
-  const height = GRID_HEIGHT;
-  const layout = LAYOUTS[Math.floor(Math.random() * LAYOUTS.length)]!;
-  const mirror = Math.random() < 0.5;
-  const tiles: Tile[][] = Array.from({ length: height }, (_, y) =>
-    Array.from({ length: width }, (_, x): Tile => {
-      const ch = layout[y]?.[mirror ? width - 1 - x : x];
-      return ch === 'B' ? { type: 'brick', health: 2 } : ch === 'S' ? { type: 'steel', health: 0 } : { type: 'empty', health: 0 };
-    })
-  );
-  const clear = (x: number, y: number) => {
-    if (tiles[y]?.[x]) tiles[y]![x] = { type: 'empty', health: 0 };
-  };
-  // The enemies' spawn corners and middle, and the bottom two rows (the player drives along them)
-  for (const sx of [0, BASE_X, width - 1]) for (let dx = -1; dx <= 1; dx++) for (let y = 0; y <= 1; y++) clear(sx + dx, y);
-  for (let y = height - 2; y < height; y++) for (let x = 0; x < width; x++) clear(x, y);
-  // Around the base, then its steel walls
-  for (let y = BASE_Y - 2; y < height; y++) for (let x = BASE_X - 2; x <= BASE_X + 2; x++) clear(x, y);
-  tiles[BASE_Y]![BASE_X] = { type: 'base', health: 1 };
-  for (const [x, y] of [
-    [BASE_X - 1, BASE_Y - 1],
-    [BASE_X, BASE_Y - 1],
-    [BASE_X + 1, BASE_Y - 1],
-    [BASE_X - 1, BASE_Y],
-    [BASE_X + 1, BASE_Y]
-  ] as const)
-    tiles[y]![x] = { type: 'steel', health: 0 };
-  return tiles;
-}
-
-// ── Tanks ─────────────────────────────────────────────────────────────
-
-/** The player's tank, bottom left (away from the base), shielded for a moment. */
-export function createPlayer(cell: number, now: number): Tank {
-  return {
-    id: 0,
-    x: 2 * cell + cell / 2,
-    y: (GRID_HEIGHT - 1) * cell + cell / 2,
-    direction: 'up',
-    isPlayer: true,
-    isAlive: true,
-    lastFireTime: -Infinity,
-    spawnProtectionEndTime: now + SPAWN_PROTECTION,
-    lastDirectionChangeTime: 0
-  };
-}
-
-/** An enemy at the first free spawn point along the top (left, middle, right), or null if they're all taken. */
-export function createEnemy(cell: number, enemies: Tank[], now: number): Tank | null {
-  const near = (cell * 2) ** 2;
-  for (const col of [0, Math.floor(GRID_WIDTH / 2), GRID_WIDTH - 1]) {
-    const x = col * cell + cell / 2;
-    const y = cell / 2;
-    if (enemies.some((e) => (e.x - x) ** 2 + (e.y - y) ** 2 < near)) continue;
-    return {
-      id: nextId(),
-      x,
-      y,
-      direction: 'down',
-      isPlayer: false,
-      isAlive: true,
-      lastFireTime: -Infinity,
-      spawnProtectionEndTime: now + SPAWN_PROTECTION,
-      lastDirectionChangeTime: now
-    };
-  }
-  return null;
-}
-
-/** Where a tank would be one tick on in `direction`, or null if the edge, a wall or another tank is in the way. */
-function nextPosition(tank: Tank, direction: Direction, speed: number, b: Board, tanks: Tank[]): [number, number] | null {
-  const scaled = speed * (b.cell / REFERENCE_CELL);
-  const [sx, sy] = STEP[direction];
-  const x = tank.x + sx * scaled;
-  const y = tank.y + sy * scaled;
-  const size = b.cell * TANK_RATIO;
-  const half = size / 2;
-  if (x - half < 0 || x + half > b.width || y - half < 0 || y + half > b.height) return null;
-  for (const [cx, cy] of [
-    [x - half, y - half],
-    [x + half, y - half],
-    [x - half, y + half],
-    [x + half, y + half]
-  ] as const) {
-    if (solid(b.tiles[Math.floor(cy / b.cell)]?.[Math.floor(cx / b.cell)])) return null;
-  }
-  const sizeSq = size * size;
-  for (const other of tanks) {
-    if (other.id === tank.id || !other.isAlive) continue;
-    if ((x - other.x) ** 2 + (y - other.y) ** 2 < sizeSq) return null;
-  }
-  return [x, y];
-}
-
-/** A tank turned to `direction` and, if the way is clear, moved one tick along it. */
-export function moveTank(tank: Tank, direction: Direction, speed: number, b: Board, tanks: Tank[]): Tank {
-  const to = nextPosition(tank, direction, speed, b, tanks);
-  return to ? { ...tank, direction, x: to[0], y: to[1] } : { ...tank, direction };
-}
-
-/** A bullet from the tank's muzzle, if its gun has cooled down. */
-export function fire(tank: Tank, now: number): Bullet | null {
-  if (now - tank.lastFireTime < (tank.isPlayer ? PLAYER_FIRE_COOLDOWN : ENEMY_FIRE_COOLDOWN)) return null;
-  const [sx, sy] = STEP[tank.direction];
-  const offset = HIT_TANK_SIZE / 2 + 2;
-  return { id: nextId(), x: tank.x + sx * offset, y: tank.y + sy * offset, direction: tank.direction, isPlayerBullet: tank.isPlayer };
-}
-
-export function moveBullet(bullet: Bullet) {
-  const [sx, sy] = STEP[bullet.direction];
-  bullet.x += sx * BULLET_SPEED;
-  bullet.y += sy * BULLET_SPEED;
-}
-
-export type BulletHit = { hit: boolean; tile?: [number, number]; base?: boolean; tank?: Tank };
-
-/** What a bullet has hit: the edge, a wall (bricks and the base take damage), or an unshielded tank on the other side. */
-export function bulletHit(bullet: Bullet, b: Board, tanks: Tank[], now: number): BulletHit {
-  if (bullet.x < 0 || bullet.x > b.width || bullet.y < 0 || bullet.y > b.height) return { hit: true };
-  const tx = Math.floor(bullet.x / b.cell);
-  const ty = Math.floor(bullet.y / b.cell);
-  const tile = b.tiles[ty]?.[tx];
-  if (tile?.type === 'brick') return { hit: true, tile: [tx, ty] };
-  if (tile?.type === 'steel') return { hit: true };
-  // Only enemy fire can destroy the base; the player's stops against it
-  if (tile?.type === 'base') return bullet.isPlayerBullet ? { hit: true } : { hit: true, tile: [tx, ty], base: true };
-  const reachSq = ((BULLET_SIZE + HIT_TANK_SIZE) / 2) ** 2;
-  for (const tank of tanks) {
-    if (!tank.isAlive || bullet.isPlayerBullet === tank.isPlayer || now < tank.spawnProtectionEndTime) continue;
-    if ((bullet.x - tank.x) ** 2 + (bullet.y - tank.y) ** 2 < reachSq) return { hit: true, tank };
-  }
-  return { hit: false };
-}
-
-/** A hit on a tile: a brick loses a layer (two and it's gone); the base is destroyed. Returns its new state. */
-export function damageTile(tiles: Tile[][], x: number, y: number): Tile | null {
-  const tile = tiles[y]?.[x];
-  if (!tile || (tile.type !== 'brick' && tile.type !== 'base')) return null;
-  const next: Tile =
-    tile.type === 'brick' ? { type: tile.health - 1 <= 0 ? 'empty' : 'brick', health: tile.health - 1 } : { type: 'empty', health: tile.health };
-  tiles[y]![x] = next;
-  return next;
-}
-
-/** Opposing bullets that meet cancel out; returns the survivors and where each pair met. */
-export function bulletClashes(bullets: Bullet[]): { remaining: Bullet[]; points: [number, number][] } {
-  const gone = new Set<number>();
-  const points: [number, number][] = [];
-  const reachSq = (BULLET_SIZE * 2) ** 2;
-  for (let i = 0; i < bullets.length; i++)
-    for (let j = i + 1; j < bullets.length; j++) {
-      const a = bullets[i]!;
-      const c = bullets[j]!;
-      if (a.isPlayerBullet === c.isPlayerBullet) continue;
-      if ((a.x - c.x) ** 2 + (a.y - c.y) ** 2 < reachSq) {
-        gone.add(i);
-        gone.add(j);
-        points.push([(a.x + c.x) / 2, (a.y + c.y) / 2]);
-      }
-    }
-  return { remaining: gone.size ? bullets.filter((_, i) => !gone.has(i)) : bullets, points };
-}
-
-// ── Enemy AI ──────────────────────────────────────────────────────────
-
-const toward = (from: Tank, to: Tank): Direction => {
-  const dx = to.x - from.x;
-  const dy = to.y - from.y;
-  return Math.abs(dx) > Math.abs(dy) ? (dx > 0 ? 'right' : 'left') : dy > 0 ? 'down' : 'up';
-};
-
-/**
- * An enemy's heading: when blocked, a clear way (toward the player if that's one), or straight back;
- * otherwise, every 800 ms, toward the player (40%), on as it was (35%) or anywhere (25%).
- */
-export function enemyHeading(
-  enemy: Tank,
-  player: Tank,
-  b: Board,
-  tanks: Tank[],
-  blocked: boolean,
-  now: number
-): { direction: Direction; turned: boolean } {
-  if (blocked) {
-    const open = DIRECTIONS.filter((d) => d !== enemy.direction && nextPosition(enemy, d, ENEMY_SPEED, b, tanks));
-    if (open.length) {
-      const want = toward(enemy, player);
-      return { direction: open.includes(want) ? want : open[Math.floor(Math.random() * open.length)]!, turned: true };
-    }
-    return { direction: OPPOSITE[enemy.direction], turned: true };
-  }
-  if (now - enemy.lastDirectionChangeTime < ENEMY_TURN_INTERVAL) return { direction: enemy.direction, turned: false };
-  const roll = Math.random();
-  const direction = roll < 0.4 ? toward(enemy, player) : roll < 0.75 ? enemy.direction : DIRECTIONS[Math.floor(Math.random() * DIRECTIONS.length)]!;
-  return { direction, turned: true };
-}
-
-/** Whether an enemy pulls the trigger: always with the player ahead and nearly in line, otherwise 30% of the time. */
-export function enemyWantsToFire(enemy: Tank, player: Tank): boolean {
-  const t = ENEMY_AIM_TOLERANCE;
-  const ahead =
-    enemy.direction === 'up'
-      ? Math.abs(enemy.x - player.x) < t && enemy.y > player.y
-      : enemy.direction === 'down'
-        ? Math.abs(enemy.x - player.x) < t && enemy.y < player.y
-        : enemy.direction === 'left'
-          ? Math.abs(enemy.y - player.y) < t && enemy.x > player.x
-          : Math.abs(enemy.y - player.y) < t && enemy.x < player.x;
-  return ahead || Math.random() < 0.3;
-}