@nayan-ui/games 1.19.0 → 1.20.0

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

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