Merge branch 'release/0.49.0'

Author: QuentinGruber

.dockerignore

@@ -1 +1,38 @@
-node_modules
+node_modules/
+out/
+
+scripts/
+benchmarks/
+tests/
+tests_out/
+plugins/
+
+.git/
+.github/
+
+.devcontainer/
+.vscode/
+.claude/
+
+oxlintrc.json
+prettier.config.js
+.prettierignore
+.eslintignore
+*.config.mjs
+
+README.md
+CODE_OF_CONDUCT.md
+CONTRIBUTING.md
+AUTHORS
+LICENSE
+signature-header.txt
+typedoc.json
+
+.npmignore
+.ignore
+.gitignore
+shell.nix
+pm2-configs/
+list.env
+config.yaml
+docker-compose.yml

.github/workflows/dev-test.yml

@@ -42,7 +42,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [24.x, 25.x]
+        node-version: [24.x, 25.x, 26.x]
     steps:
       - uses: actions/checkout@v3
       - name: Use Node.js ${{ matrix.node-version }}
@@ -56,7 +56,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [24.x, 25.x]
+        node-version: [24.x, 25.x, 26.x]
     steps:
       - uses: actions/checkout@v3
       - name: Use Node.js ${{ matrix.node-version }}
@@ -72,7 +72,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [24.x, 25.x]
+        node-version: [24.x, 25.x, 26.x]
     steps:
       - uses: actions/checkout@v3
       - name: Use Node.js ${{ matrix.node-version }}
@@ -86,7 +86,7 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        node-version: [24.x, 25.x]
+        node-version: [24.x, 25.x, 26.x]
     steps:
       - uses: actions/checkout@v3
       - name: Use Node.js ${{ matrix.node-version }}

.gitignore

@@ -6,4 +6,6 @@ tests_out
 benchmarks_out
 bin/*.exe
 .vs
-config.yaml
+config.yaml
+/navMeshDump.obj
+*.tsbuildinfo

benchmarks/src/npcAiStress/npc-ai-stress.ts

@@ -0,0 +1,311 @@
+// ======================================================================
+// NPC AI tick stress test — profiles zombie FSM + Recast navigation
+// at scale, with a configurable number of zombies and fake player targets.
+//
+// Run after `npm run build`:
+//   npm run stress-ai          — normal run
+//   npm run stress-ai-profile  — with --cpu-prof (writes cpuprofile file)
+//   npm run stress-ai-inspect  — with --inspect for DevTools
+// ======================================================================
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+export {};
+process.env["DISABLE_PLUGINS"] = "true";
+
+// ---- CONFIG (edit these) --------------------------------------------
+const CONFIG = {
+  /** Number of fake player characters placed in the zombie cluster (triggers chase/attack) */
+  playerCount: 100,
+  durationSeconds: 60,
+  /** Stats print interval in ms */
+  statsIntervalMs: 5000,
+  /** Sounds injected per fake player per AI tick (simulates weapon fire / footsteps) */
+  soundsPerPlayer: 1,
+  /** Radius of each injected sound */
+  soundRadius: 100,
+  /** Agitation value of each injected sound */
+  soundAgitation: 10,
+  /** Max metres a fake player drifts per tick (0 = static) */
+  playerDriftRadius: 5
+};
+// ---------------------------------------------------------------------
+
+const { ZoneServer2016 } = require("../../../h1z1-server");
+const { createFakeCharacter } = require("../../../out/utils/test.utils");
+
+// ---- Helpers --------------------------------------------------------
+
+function randomPosition(
+  cx: number,
+  cy: number,
+  cz: number,
+  radius: number
+): Float32Array {
+  const angle = Math.random() * Math.PI * 2;
+  const dist = Math.random() * radius;
+  return new Float32Array([
+    cx + Math.cos(angle) * dist,
+    cy,
+    cz + Math.sin(angle) * dist,
+    1
+  ]);
+}
+
+/** Rolling window of the last N samples */
+class RollingStats {
+  private samples: number[] = [];
+  constructor(private readonly window: number = 20) {}
+  push(v: number) {
+    this.samples.push(v);
+    if (this.samples.length > this.window) this.samples.shift();
+  }
+  avg() {
+    return this.samples.length === 0
+      ? 0
+      : this.samples.reduce((a, b) => a + b, 0) / this.samples.length;
+  }
+  max() {
+    return this.samples.length === 0 ? 0 : Math.max(...this.samples);
+  }
+}
+
+// ---- Main -----------------------------------------------------------
+
+async function main() {
+  console.log("=== H1Z1 NPC AI Tick Stress Test ===");
+  console.log(
+    `Config: ${CONFIG.playerCount} fake players` +
+      ` | ${CONFIG.durationSeconds}s | stats every ${CONFIG.statsIntervalMs / 1000}s` +
+      ` | ${CONFIG.soundsPerPlayer} sound(s)/player/tick r=${CONFIG.soundRadius} agit=${CONFIG.soundAgitation}` +
+      ` | drift=${CONFIG.playerDriftRadius}m`
+  );
+
+  const server = new ZoneServer2016(0);
+
+  console.log("Starting server (no network, no MongoDB)…");
+  await server.start();
+
+  // Stub out sendData — NPCs will try to broadcast movement/animation packets
+  // to connected clients; fake characters have no real UDP connection.
+  server.sendData = () => {};
+  server.sendUnbufferedData = () => {};
+  server.sendOrderedData = () => {};
+
+  // Known-good open area near the H1Z1 Z1 map centre, snapped to navmesh height.
+  // Positions outside the navmesh still work — agents park on the nearest valid point.
+  const CENTER_X = -600;
+  const CENTER_Y = 30;
+  const CENTER_Z = 700;
+  const SPAWN_RADIUS = 400;
+
+  // --- Wait for server default NPC spawn ------------------------------
+  console.log("Waiting for server default NPC spawn…");
+  const npcWaitStart = Date.now();
+  while (Object.keys(server._npcs).length === 0) {
+    if (Date.now() - npcWaitStart > 30_000) {
+      console.error("Timeout waiting for default NPC spawn");
+      break;
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  const npcCount = Object.keys(server._npcs).length;
+  console.log(`Default NPCs spawned: ${npcCount}`);
+
+  // --- Create fake players --------------------------------------------
+  // Place them among the default NPCs so they trigger chase/attack states,
+  // giving a realistic mixed-state distribution.
+  console.log(`Creating ${CONFIG.playerCount} fake player characters…`);
+  const fakePlayers: any[] = [];
+  for (let i = 0; i < CONFIG.playerCount; i++) {
+    const character = createFakeCharacter(server);
+    const pos = randomPosition(CENTER_X, CENTER_Y, CENTER_Z, SPAWN_RADIUS / 4);
+    if (!character.state) character.state = {};
+    character.state.position = pos;
+    fakePlayers.push(character);
+  }
+  console.log("Setup complete. Measuring AI tick performance…\n");
+
+  // --- Instrument updatePathfindingPositions --------------------------
+  let totalPathTicks = 0;
+  let totalPathMs = 0;
+  const pathStats = new RollingStats();
+
+  const origTick = server.updatePathfindingPositions.bind(server);
+  server.updatePathfindingPositions = () => {
+    const t0 = performance.now();
+    origTick();
+    const dt = performance.now() - t0;
+    pathStats.push(dt);
+    totalPathMs += dt;
+    totalPathTicks++;
+  };
+
+  // --- Instrument tickAi ---------------------------------------------
+  let totalAiTicks = 0;
+  let totalAiTickMs = 0;
+  const aiTickStats = new RollingStats();
+
+  const origTickAi = (server as any).tickAi.bind(server);
+  (server as any).tickAi = () => {
+    // Simulate per-player noise each tick (weapon fire / footsteps).
+    // Must happen before origTickAi, which runs tickNpcFsms then clears server.sounds.
+    for (const player of fakePlayers) {
+      for (let s = 0; s < CONFIG.soundsPerPlayer; s++) {
+        server.sounds.push({
+          position: player.state.position,
+          radius: CONFIG.soundRadius,
+          agitation: CONFIG.soundAgitation
+        });
+      }
+      if (CONFIG.playerDriftRadius > 0) {
+        const angle = Math.random() * Math.PI * 2;
+        const drift = Math.random() * CONFIG.playerDriftRadius;
+        player.state.position[0] += Math.cos(angle) * drift;
+        player.state.position[2] += Math.sin(angle) * drift;
+      }
+    }
+    const t0 = performance.now();
+    origTickAi();
+    const dt = performance.now() - t0;
+    aiTickStats.push(dt);
+    totalAiTickMs += dt;
+    totalAiTicks++;
+  };
+
+  // --- Stats loop -----------------------------------------------------
+  const startTime = Date.now();
+  const statRows: {
+    t: number;
+    aiAvgMs: number;
+    aiMaxMs: number;
+    pathAvgMs: number;
+    pathMaxMs: number;
+    memMB: number;
+    stateDist: Record<string, number>;
+  }[] = [];
+
+  const ZOMBIE_STATES = [
+    "idle",
+    "wander",
+    "investigate",
+    "chase",
+    "stumble",
+    "attack",
+    "attacking",
+    "feed",
+    "dead"
+  ];
+
+  function getStateDist(srv: any): Record<string, number> {
+    const dist: Record<string, number> = {};
+    for (const s of ZOMBIE_STATES) dist[s] = 0;
+    for (const k in srv._npcs) {
+      const npc = srv._npcs[k];
+      if (npc.fsm) {
+        const state: string = npc.fsm.state ?? "unknown";
+        dist[state] = (dist[state] ?? 0) + 1;
+      }
+    }
+    return dist;
+  }
+
+  const statsTimer = setInterval(() => {
+    const t = Math.round((Date.now() - startTime) / 1000);
+    const memMB = Math.round(process.memoryUsage().rss / 1024 / 1024);
+    const dist = getStateDist(server);
+
+    const aiAvg = aiTickStats.avg();
+    const aiMax = aiTickStats.max();
+    const pAvg = pathStats.avg();
+    const pMax = pathStats.max();
+
+    statRows.push({
+      t,
+      aiAvgMs: aiAvg,
+      aiMaxMs: aiMax,
+      pathAvgMs: pAvg,
+      pathMaxMs: pMax,
+      memMB,
+      stateDist: dist
+    });
+
+    const distStr = ZOMBIE_STATES.filter((s) => dist[s] > 0)
+      .map((s) => `${s}:${dist[s]}`)
+      .join(" ");
+
+    console.log(
+      `[${String(t).padStart(3)}s]` +
+        `  tickAI   avg=${aiAvg.toFixed(2).padStart(7)}ms  max=${aiMax.toFixed(2).padStart(7)}ms` +
+        `  |  pathfind avg=${pAvg.toFixed(2).padStart(7)}ms  max=${pMax.toFixed(2).padStart(7)}ms` +
+        `  mem=${memMB}MB  [${distStr}]`
+    );
+  }, CONFIG.statsIntervalMs);
+
+  // --- Shutdown -------------------------------------------------------
+  setTimeout(async () => {
+    clearInterval(statsTimer);
+
+    const elapsed = (Date.now() - startTime) / 1000;
+    const memPeak = statRows.length
+      ? Math.max(...statRows.map((r) => r.memMB))
+      : 0;
+    const memAvg = statRows.length
+      ? Math.round(statRows.reduce((a, r) => a + r.memMB, 0) / statRows.length)
+      : 0;
+
+    const wallMs = elapsed * 1000;
+
+    const aiAvgOverall =
+      totalAiTicks > 0 ? (totalAiTickMs / totalAiTicks).toFixed(2) : "0";
+    const aiPeak = statRows.length
+      ? Math.max(...statRows.map((r) => r.aiMaxMs)).toFixed(2)
+      : "0";
+    const aiCpuPct = ((totalAiTickMs / wallMs) * 100).toFixed(1);
+
+    const pathAvgOverall =
+      totalPathTicks > 0 ? (totalPathMs / totalPathTicks).toFixed(2) : "0";
+    const pathPeak = statRows.length
+      ? Math.max(...statRows.map((r) => r.pathMaxMs)).toFixed(2)
+      : "0";
+    const pathCpuPct = ((totalPathMs / wallMs) * 100).toFixed(1);
+
+    const finalDist = getStateDist(server);
+
+    console.log("\n=== FINAL REPORT ===");
+    console.log(`Duration:              ${elapsed.toFixed(1)}s`);
+    console.log(`Zombies:               ${npcCount}`);
+    console.log(`Fake players:          ${CONFIG.playerCount}`);
+    console.log(`Total AI ticks:        ${totalAiTicks}`);
+    console.log(
+      `tickAI avg:            ${aiAvgOverall}ms  peak: ${aiPeak}ms  (${aiCpuPct}% of wall time)`
+    );
+    console.log(`Total pathfind ticks:  ${totalPathTicks}`);
+    console.log(
+      `pathfind avg:          ${pathAvgOverall}ms  peak: ${pathPeak}ms  (${pathCpuPct}% of wall time)`
+    );
+    console.log(`Memory avg / peak:     ${memAvg}MB / ${memPeak}MB`);
+    console.log(`Final state dist:`);
+    for (const s of ZOMBIE_STATES) {
+      if (finalDist[s] > 0) {
+        const pct = ((finalDist[s] / npcCount) * 100).toFixed(1);
+        console.log(
+          `  ${s.padEnd(12)} ${String(finalDist[s]).padStart(5)} (${pct}%)`
+        );
+      }
+    }
+
+    if (process.execArgv.some((a: string) => a.startsWith("--cpu-prof"))) {
+      console.log(
+        "\nCPU profile written — open .cpuprofile in Chrome DevTools > Performance > Load profile"
+      );
+    }
+
+    await server.stop();
+    process.exit(0);
+  }, CONFIG.durationSeconds * 1000);
+}
+
+main().catch((err) => {
+  console.error("NPC AI stress test crashed:", err);
+  process.exit(1);
+});