@nayan-ui/games 1.20.0 → 1.21.0

package/src/games/mob-control/MobControlRules.ts

@@ -1,522 +0,0 @@
-// Allocation-free fixed-step crowd simulation. Individual slots are recycled; at the visual cap,
-// existing soldiers carry additional strength, preserving gate arithmetic without spawning forever.
-import { type Barrier, type Base, type BoostPad, type Gate, MOB_CONFIG as C } from './MobControlConstants';
-
-export interface Events {
-  shots: number;
-  gates: number;
-  clashes: number;
-  hits: number;
-  breaches: number;
-  captured: number;
-  champion: boolean;
-  barrierBroken: number;
-  bossDefeated: boolean;
-  won: boolean;
-  lost: boolean;
-  effectCount: number;
-  effectX: Float32Array;
-  effectZ: Float32Array;
-  effectTeam: Uint8Array;
-}
-export interface Sim {
-  alive: Uint8Array;
-  x: Float32Array;
-  z: Float32Array;
-  previousX: Float32Array;
-  previousZ: Float32Array;
-  strength: Uint16Array;
-  gatesPassed: Uint8Array;
-  ticket: Uint32Array;
-  kind: Uint8Array; // 0 soldier, 1 allied champion, 2 enemy boss
-  boost: Float32Array;
-  flight: Float32Array;
-  next: Int16Array;
-  playerGrid: Int16Array;
-  enemyGrid: Int16Array;
-  freePlayer: Uint16Array;
-  freeEnemy: Uint16Array;
-  freePlayerCount: number;
-  freeEnemyCount: number;
-  playerCount: number;
-  enemyCount: number;
-  playerStrength: number;
-  enemyStrength: number;
-  championCount: number;
-  bossCount: number;
-  charge: number;
-  serial: number;
-  seed: number;
-  level: number;
-  elapsed: number;
-  battleClock: number;
-  fireClock: number;
-  cannonX: number;
-  targetX: number;
-  hp: number;
-  score: number;
-  finished: boolean;
-  won: boolean;
-  gates: Gate[];
-  bases: Base[];
-  barriers: Barrier[];
-  boostPad: BoostPad | null;
-  events: Events;
-  collisionVisits: number;
-}
-const clamp = (x: number, lo: number, hi: number) => Math.max(lo, Math.min(hi, x));
-function random(s: Sim) {
-  s.seed = (Math.imul(s.seed, 1664525) + 1013904223) >>> 0;
-  return s.seed / 4294967296;
-}
-export const isPlayer = (i: number) => i < C.PLAYER_SLOTS;
-
-export function createSim(seed = Math.floor(Math.random() * 0xffffffff), level = 1): Sim {
-  const s: Sim = {
-    alive: new Uint8Array(C.CAPACITY),
-    x: new Float32Array(C.CAPACITY),
-    z: new Float32Array(C.CAPACITY),
-    previousX: new Float32Array(C.CAPACITY),
-    previousZ: new Float32Array(C.CAPACITY),
-    strength: new Uint16Array(C.CAPACITY),
-    gatesPassed: new Uint8Array(C.CAPACITY),
-    ticket: new Uint32Array(C.CAPACITY),
-    kind: new Uint8Array(C.CAPACITY),
-    boost: new Float32Array(C.CAPACITY),
-    flight: new Float32Array(C.CAPACITY),
-    next: new Int16Array(C.CAPACITY),
-    playerGrid: new Int16Array(C.GRID_COLUMNS * C.GRID_ROWS),
-    enemyGrid: new Int16Array(C.GRID_COLUMNS * C.GRID_ROWS),
-    freePlayer: new Uint16Array(C.PLAYER_SLOTS),
-    freeEnemy: new Uint16Array(C.ENEMY_SLOTS),
-    freePlayerCount: 0,
-    freeEnemyCount: 0,
-    playerCount: 0,
-    enemyCount: 0,
-    playerStrength: 0,
-    enemyStrength: 0,
-    championCount: 0,
-    bossCount: 0,
-    charge: 0,
-    serial: 0,
-    seed: seed >>> 0,
-    level: Math.max(1, Math.floor(Number.isFinite(level) ? level : 1)),
-    elapsed: 0,
-    battleClock: 0,
-    fireClock: 0,
-    cannonX: 0,
-    targetX: 0,
-    hp: C.PLAYER_HP,
-    score: 0,
-    finished: false,
-    won: false,
-    gates: [],
-    bases: [],
-    barriers: [],
-    boostPad: null,
-    collisionVisits: 0,
-    events: {
-      shots: 0,
-      gates: 0,
-      clashes: 0,
-      hits: 0,
-      breaches: 0,
-      captured: 0,
-      champion: false,
-      barrierBroken: 0,
-      bossDefeated: false,
-      won: false,
-      lost: false,
-      effectCount: 0,
-      effectX: new Float32Array(C.MAX_EFFECTS),
-      effectZ: new Float32Array(C.MAX_EFFECTS),
-      effectTeam: new Uint8Array(C.MAX_EFFECTS)
-    }
-  };
-  prepareLevel(s);
-  return s;
-}
-function clearUnits(s: Sim) {
-  s.alive.fill(0);
-  s.strength.fill(0);
-  s.kind.fill(0);
-  s.boost.fill(0);
-  s.flight.fill(0);
-  s.freePlayerCount = C.PLAYER_SLOTS;
-  s.freeEnemyCount = C.ENEMY_SLOTS;
-  s.playerCount = s.enemyCount = s.playerStrength = s.enemyStrength = 0;
-  s.championCount = s.bossCount = 0;
-  for (let i = 0; i < C.PLAYER_SLOTS; i++) s.freePlayer[i] = C.PLAYER_SLOTS - 1 - i;
-  for (let i = 0; i < C.ENEMY_SLOTS; i++) s.freeEnemy[i] = C.CAPACITY - 1 - i;
-}
-function prepareLevel(s: Sim) {
-  clearUnits(s);
-  s.battleClock = 0;
-  s.fireClock = C.FIRE_INTERVAL;
-  s.charge = 0;
-  const swap = random(s) > 0.5;
-  const layout = ((s.level - 1) % 3) + 1;
-  const endurance = layout === 1 ? 1 : layout === 2 ? 2.5 : 3;
-  const factors = layout === 1 ? [1, 2, 3, 4] : layout === 2 ? [3, 4, -2, 5] : [4, 3, 6, 5];
-  s.gates = factors.map((factor, id) => {
-    const x = ((id % 2 === 0) !== swap ? -1 : 1) * 2.35;
-    const operation: Gate['operation'] = layout === 1 && id === 0 ? 'add' : factor < 0 ? 'divide' : 'multiply';
-    return { id, x, originX: x, z: id < 2 ? -8.5 : -16, halfWidth: 1.95, factor, operation, moving: layout > 1 && id >= 2, hits: 0, remainder: 0 };
-  });
-  s.bases = [-3.1, 0, 3.1].map((x, i) => {
-    const hp = (i === 1 ? C.CORE_HP : C.BASE_HP) * endurance;
-    return { x, z: C.BASE_Z - (i === 1 ? 1.2 : 0), hp, maxHp: hp, spawnClock: -0.4 - i * 0.32 };
-  });
-  s.barriers = layout === 1 ? [] : [-2.35, 2.35].map((x) => ({ x, z: -22.5, halfWidth: 1.5, hp: layout * 18, maxHp: layout * 18 }));
-  s.boostPad = layout === 1 ? null : { x: swap ? 2.35 : -2.35, z: -19.1, halfWidth: 1.55, halfLength: 1.15 };
-  if (layout === 3) spawn(s, false, 0, -26.5, C.BOSS_STRENGTH, 0, 2);
-}
-
-/** Pool pressure packs strength into an existing slot; it never silently deletes a multiplied army. */
-export function spawn(s: Sim, player: boolean, x: number, z: number, strength = 1, passed = 0, kind = 0, airborne = false): number {
-  const remaining = C.MAX_STRENGTH - (player ? s.playerStrength : s.enemyStrength);
-  const amount = Math.max(0, Math.min(strength, remaining));
-  if (amount === 0) return -1;
-  const free = player ? s.freePlayer : s.freeEnemy;
-  const n = player ? s.freePlayerCount : s.freeEnemyCount;
-  let i: number;
-  // Keep one allied slot available for a champion even when gates fill the soldier pool.
-  if (n === 0 || (player && kind === 0 && n === 1 && s.championCount === 0)) {
-    let nearest = -1,
-      distance = Infinity;
-    const start = player ? 0 : C.PLAYER_SLOTS,
-      end = player ? C.PLAYER_SLOTS : C.CAPACITY;
-    for (let j = start; j < end; j++) {
-      if (!s.alive[j] || s.gatesPassed[j] !== passed || s.kind[j] !== kind) continue;
-      const d = (s.x[j]! - x) ** 2 + (s.z[j]! - z) ** 2;
-      if (d < distance) {
-        distance = d;
-        nearest = j;
-      }
-    }
-    if (nearest < 0) return -1;
-    s.strength[nearest] = s.strength[nearest]! + amount;
-    if (player) s.playerStrength += amount;
-    else s.enemyStrength += amount;
-    return nearest;
-  }
-  i = free[n - 1]!;
-  if (player) {
-    s.freePlayerCount--;
-    s.playerCount++;
-    s.playerStrength += amount;
-  } else {
-    s.freeEnemyCount--;
-    s.enemyCount++;
-    s.enemyStrength += amount;
-  }
-  s.alive[i] = 1;
-  s.strength[i] = amount;
-  s.gatesPassed[i] = passed;
-  s.kind[i] = kind;
-  s.boost[i] = 0;
-  s.flight[i] = airborne ? C.FLIGHT_DURATION : 0;
-  if (kind === 1) s.championCount++;
-  if (kind === 2) s.bossCount++;
-  s.ticket[i] = ++s.serial;
-  s.x[i] = s.previousX[i] = clamp(x, -C.HALF_WIDTH + 0.3, C.HALF_WIDTH - 0.3);
-  s.z[i] = s.previousZ[i] = z;
-  return i;
-}
-function remove(s: Sim, i: number) {
-  if (!s.alive[i]) return;
-  s.alive[i] = 0;
-  if (s.kind[i] === 1) s.championCount--;
-  if (s.kind[i] === 2) {
-    s.bossCount--;
-    if (s.strength[i] === 0) s.events.bossDefeated = true;
-  }
-  if (isPlayer(i)) {
-    s.playerStrength -= s.strength[i]!;
-    s.freePlayer[s.freePlayerCount++] = i;
-    s.playerCount--;
-  } else {
-    s.enemyStrength -= s.strength[i]!;
-    s.freeEnemy[s.freeEnemyCount++] = i;
-    s.enemyCount--;
-  }
-  s.strength[i] = 0;
-}
-function effect(s: Sim, x: number, z: number, player: boolean) {
-  const e = s.events;
-  if (e.effectCount >= C.MAX_EFFECTS) return;
-  const i = e.effectCount++;
-  e.effectX[i] = x;
-  e.effectZ[i] = z;
-  e.effectTeam[i] = player ? 1 : 0;
-}
-function gridX(x: number) {
-  return clamp(Math.floor((x + C.HALF_WIDTH) / C.GRID_SIZE), 0, C.GRID_COLUMNS - 1);
-}
-function gridZ(z: number) {
-  return clamp(Math.floor(-z / C.GRID_SIZE), 0, C.GRID_ROWS - 1);
-}
-function grid(s: Sim) {
-  s.playerGrid.fill(-1);
-  s.enemyGrid.fill(-1);
-  for (let i = 0; i < C.CAPACITY; i++)
-    if (s.alive[i]) {
-      const heads = isPlayer(i) ? s.playerGrid : s.enemyGrid;
-      const cell = gridZ(s.z[i]!) * C.GRID_COLUMNS + gridX(s.x[i]!);
-      s.next[i] = heads[cell]!;
-      heads[cell] = i;
-    }
-}
-function move(s: Sim, dt: number) {
-  grid(s);
-  let boss = -1;
-  if (s.bossCount > 0)
-    for (let i = C.PLAYER_SLOTS; i < C.CAPACITY; i++)
-      if (s.alive[i] && s.kind[i] === 2) {
-        boss = i;
-        break;
-      }
-  const hasBases = s.bases.some((b) => b.hp > 0);
-  for (let i = 0; i < C.CAPACITY; i++) {
-    if (!s.alive[i]) continue;
-    const player = isPlayer(i),
-      x = s.x[i]!,
-      z = s.z[i]!;
-    s.previousX[i] = x;
-    s.previousZ[i] = z;
-    s.flight[i] = Math.max(0, s.flight[i]! - dt);
-    let targetX = x,
-      targetZ = player ? C.TARGET_LINE - 3 : C.BREACH_Z + 1;
-    const bossDistance = boss < 0 ? Infinity : Math.hypot(s.x[boss]! - x, s.z[boss]! - z);
-    if (player && (z < -18 || bossDistance < 8 || !hasBases)) {
-      let distance = Infinity;
-      for (const b of s.bases)
-        if (b.hp > 0) {
-          const d = Math.abs(b.x - x) + Math.abs(b.z - z) * 0.15;
-          if (d < distance) {
-            distance = d;
-            targetX = b.x;
-            targetZ = b.z;
-          }
-        }
-      // Once the boss reaches the front, nearby troops turn to intercept it; surviving mobs also
-      // pursue it after the towers fall rather than waiting at an empty enemy base.
-      if (boss >= 0 && (bossDistance < 8 || !hasBases || s.kind[i] === 1)) {
-        targetX = s.x[boss]!;
-        targetZ = s.z[boss]!;
-      }
-    } else if (!player) targetX = s.cannonX * 0.65;
-    const dx = targetX - x,
-      dz = targetZ - z,
-      length = Math.hypot(dx, dz) || 1;
-    const pad = s.boostPad;
-    if (player && pad && Math.abs(x - pad.x) <= pad.halfWidth && Math.abs(z - pad.z) <= pad.halfLength) s.boost[i] = C.BOOST_DURATION;
-    else s.boost[i] = Math.max(0, s.boost[i]! - dt);
-    const speed =
-      (s.kind[i] === 1 ? C.CHAMPION_SPEED : s.kind[i] === 2 ? C.BOSS_SPEED : player ? C.PLAYER_SPEED : C.ENEMY_SPEED) *
-      (s.boost[i]! > 0 ? C.BOOST_SPEED : 1);
-    let pushX = 0,
-      pushZ = 0,
-      visits = 0;
-    const heads = player ? s.playerGrid : s.enemyGrid,
-      gx = gridX(x),
-      gz = gridZ(z);
-    for (let oz = -1; oz <= 1 && visits < C.MAX_SEPARATION_VISITS; oz++)
-      for (let ox = -1; ox <= 1 && visits < C.MAX_SEPARATION_VISITS; ox++) {
-        const cx = gx + ox,
-          cz = gz + oz;
-        if (cx < 0 || cx >= C.GRID_COLUMNS || cz < 0 || cz >= C.GRID_ROWS) continue;
-        for (let j = heads[cz * C.GRID_COLUMNS + cx]!; j >= 0 && visits < C.MAX_SEPARATION_VISITS; j = s.next[j]!) {
-          if (j === i || !s.alive[j]) continue;
-          visits++;
-          const sx = x - s.x[j]!,
-            sz = z - s.z[j]!,
-            d2 = sx * sx + sz * sz;
-          if (d2 > 0.00001 && d2 < 0.24) {
-            const force = (0.49 - Math.sqrt(d2)) * 2.2;
-            const inv = 1 / Math.sqrt(d2);
-            pushX += sx * inv * force;
-            pushZ += sz * inv * force;
-          }
-        }
-      }
-    s.x[i] = clamp(x + ((dx / length) * speed + clamp(pushX, -1.1, 1.1)) * dt, -C.HALF_WIDTH + 0.3, C.HALF_WIDTH - 0.3);
-    s.z[i] = z + ((dz / length) * speed + clamp(pushZ, -0.5, 0.5)) * dt;
-  }
-}
-function gates(s: Sim) {
-  for (let i = 0; i < C.PLAYER_SLOTS; i++) {
-    if (!s.alive[i] || s.kind[i] === 1) continue;
-    for (const g of s.gates) {
-      const bit = 1 << g.id;
-      if (s.gatesPassed[i]! & bit || s.previousZ[i]! < g.z || s.z[i]! > g.z || Math.abs(s.x[i]! - g.x) > g.halfWidth) continue;
-      s.gatesPassed[i] = s.gatesPassed[i]! | bit;
-      const before = s.strength[i]!;
-      g.hits++;
-      s.events.gates++;
-      if (g.factor < 0) {
-        g.remainder += before / -g.factor;
-        const after = Math.floor(g.remainder);
-        g.remainder -= after;
-        s.playerStrength += after - before;
-        s.strength[i] = after;
-        if (!after) remove(s, i);
-      } else {
-        const total = Math.min(g.operation === 'add' ? g.factor : before * (g.factor - 1), C.MAX_STRENGTH - s.playerStrength);
-        // Spawn only below the gate; inherited bits prevent recursive re-multiplication.
-        for (let n = 0; n < total; n++) {
-          if (s.freePlayerCount <= (s.championCount === 0 ? 1 : 0)) {
-            s.strength[i] = s.strength[i]! + total - n;
-            s.playerStrength += total - n;
-            break;
-          }
-          const a = (s.serial + n) * 2.39996,
-            r = 0.16 + Math.sqrt(n + 1) * 0.11;
-          spawn(s, true, s.x[i]! + Math.cos(a) * r, g.z - 0.12 - Math.abs(Math.sin(a) * r), 1, s.gatesPassed[i]!);
-        }
-      }
-    }
-  }
-}
-function fight(s: Sim) {
-  grid(s);
-  s.collisionVisits = 0;
-  const radius2 = C.COLLISION_RADIUS * C.COLLISION_RADIUS;
-  for (let i = 0; i < C.PLAYER_SLOTS; i++) {
-    if (!s.alive[i]) continue;
-    const gx = gridX(s.x[i]!),
-      gz = gridZ(s.z[i]!);
-    let visits = 0;
-    for (let oz = -1; oz <= 1 && s.alive[i] && visits < C.MAX_COLLISION_VISITS; oz++)
-      for (let ox = -1; ox <= 1 && s.alive[i] && visits < C.MAX_COLLISION_VISITS; ox++) {
-        const cx = gx + ox,
-          cz = gz + oz;
-        if (cx < 0 || cx >= C.GRID_COLUMNS || cz < 0 || cz >= C.GRID_ROWS) continue;
-        for (let j = s.enemyGrid[cz * C.GRID_COLUMNS + cx]!; j >= 0 && s.alive[i] && visits < C.MAX_COLLISION_VISITS; j = s.next[j]!) {
-          visits++;
-          s.collisionVisits++;
-          if (!s.alive[j]) continue;
-          const dx = s.x[i]! - s.x[j]!,
-            dz = s.z[i]! - s.z[j]!;
-          const reach = s.kind[i] === 1 || s.kind[j] === 2 ? 0.75 ** 2 : radius2;
-          if (dx * dx + dz * dz > reach) continue;
-          const n = Math.min(s.strength[i]!, s.strength[j]!);
-          s.strength[i] = s.strength[i]! - n;
-          s.strength[j] = s.strength[j]! - n;
-          s.playerStrength -= n;
-          s.enemyStrength -= n;
-          s.score += n * C.KILL_POINTS;
-          s.events.clashes += n;
-          s.charge = Math.min(C.CHAMPION_CHARGE, s.charge + n * 0.12);
-          effect(s, (s.x[i]! + s.x[j]!) / 2, (s.z[i]! + s.z[j]!) / 2, false);
-          if (!s.strength[j]) remove(s, j);
-          if (!s.strength[i]) remove(s, i);
-        }
-      }
-  }
-}
-function outcomes(s: Sim) {
-  for (let i = 0; i < C.CAPACITY; i++) {
-    if (!s.alive[i]) continue;
-    if (isPlayer(i)) {
-      for (const barrier of s.barriers) {
-        if (barrier.hp <= 0 || s.previousZ[i]! < barrier.z || s.z[i]! > barrier.z || Math.abs(s.x[i]! - barrier.x) > barrier.halfWidth) continue;
-        const damage = Math.min(barrier.hp, s.strength[i]!);
-        barrier.hp -= damage;
-        s.strength[i] = s.strength[i]! - damage;
-        s.playerStrength -= damage;
-        s.events.hits += damage;
-        s.score += damage * 2;
-        effect(s, barrier.x, barrier.z, true);
-        if (barrier.hp === 0) s.events.barrierBroken++;
-        if (s.strength[i] === 0) remove(s, i);
-      }
-      if (!s.alive[i]) continue;
-    }
-    if (isPlayer(i) && s.z[i]! <= C.TARGET_LINE) {
-      let target: Base | null = null,
-        distance = Infinity;
-      for (const b of s.bases)
-        if (b.hp > 0) {
-          const d = Math.abs(b.x - s.x[i]!);
-          if (d < distance) {
-            target = b;
-            distance = d;
-          }
-        }
-      if (!target) continue;
-      if (distance > 0.9 || s.z[i]! > target.z + 1.25) continue;
-      const damage = Math.min(target.hp, s.strength[i]!);
-      target.hp -= damage;
-      s.score += damage * 2;
-      s.events.hits += damage;
-      effect(s, target.x, target.z, true);
-      s.strength[i] = s.strength[i]! - damage;
-      s.playerStrength -= damage;
-      if (!s.strength[i]) remove(s, i);
-      if (target.hp === 0) {
-        s.score += C.BASE_POINTS;
-        s.events.captured++;
-      }
-    } else if (!isPlayer(i) && s.z[i]! >= C.BREACH_Z) {
-      s.hp = s.kind[i] === 2 ? 0 : Math.max(0, s.hp - s.strength[i]!);
-      s.events.breaches += s.strength[i]!;
-      effect(s, s.x[i]!, 0, false);
-      remove(s, i);
-    }
-  }
-}
-export function step(s: Sim, dt: number): Events {
-  const e = s.events;
-  e.shots = e.gates = e.clashes = e.hits = e.breaches = e.captured = e.effectCount = e.barrierBroken = 0;
-  e.won = e.lost = e.champion = e.bossDefeated = false;
-  if (s.finished || dt <= 0 || !Number.isFinite(dt)) return e;
-  const difficulty = ((s.level - 1) % 3) + 1;
-  dt = Math.min(dt, C.STEP);
-  s.elapsed += dt;
-  s.battleClock += dt;
-  s.cannonX += (s.targetX - s.cannonX) * (1 - Math.exp(-dt * 15));
-  s.fireClock += dt;
-  if (s.fireClock >= C.FIRE_INTERVAL) {
-    s.fireClock -= C.FIRE_INTERVAL;
-    spawn(s, true, s.cannonX + (random(s) - 0.5) * 0.22, C.SPAWN_Z, 1, 0, 0, true);
-    s.charge = Math.min(C.CHAMPION_CHARGE, s.charge + C.CHAMPION_PER_SHOT);
-    e.shots++;
-  }
-  if (s.charge >= C.CHAMPION_CHARGE && s.championCount === 0) {
-    if (spawn(s, true, s.cannonX, C.SPAWN_Z, C.CHAMPION_STRENGTH + difficulty * 12, 0, 1, true) >= 0) {
-      s.charge = 0;
-      e.champion = true;
-    }
-  }
-  for (const g of s.gates) g.x = g.originX + (g.moving ? Math.sin(s.battleClock * 0.65 + g.id) * 0.28 : 0);
-  for (const b of s.bases)
-    if (b.hp > 0) {
-      b.spawnClock += dt;
-      const interval = C.ENEMY_WAVE_INTERVAL - (difficulty - 1) * 0.12;
-      if (b.spawnClock >= interval) {
-        b.spawnClock -= interval;
-        // Uncaptured spawners build pressure. Good gate choices break through before the next surge;
-        // leaving the cannon idle cannot hold the center forever with automatic champions.
-        const n = C.ENEMY_WAVE_SIZE + difficulty * 3 + Math.min(C.ENEMY_MAX_SURGE, Math.floor(s.battleClock / C.ENEMY_SURGE_INTERVAL) * 2);
-        for (let k = 0; k < n; k++) {
-          const a = s.serial * 2.39996,
-            r = Math.sqrt(k + 0.5) * 0.2;
-          spawn(s, false, b.x + Math.cos(a) * r, b.z + 1.1 + Math.sin(a) * r);
-        }
-      }
-    }
-  move(s, dt);
-  gates(s);
-  fight(s);
-  outcomes(s);
-  if (s.hp === 0) {
-    s.finished = true;
-    e.lost = true;
-  } else if (s.bossCount === 0 && s.bases.every((b) => b.hp === 0)) {
-    s.score += C.LEVEL_POINTS;
-    clearUnits(s);
-    s.finished = s.won = e.won = true;
-  }
-  return e;
-}