h1z1-server 0.48.0 → 0.48.1-1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "h1z1-server",
-  "version": "0.48.0",
+  "version": "0.48.1-1",
   "description": "Library for emulating h1z1 servers",
   "author": "Quentin Gruber <quentingruber@gmail.com> (http://github.com/quentingruber)",
   "license": "GPL-3.0-only",

package/src/servers/ZoneServer2016/classes/gridcell.ts

@@ -10,6 +10,9 @@ export class GridCell {
   width: number;
   height: number;
   availableScrap: number;
+  /** Timestamp of the last time an entity was added to this cell.
+   *  Used to skip re-scanning cells that haven't changed since the client's last heavy-scan pass. */
+  lastModified = 0;
   constructor(
     server: ZoneServer2016,
     x: number,

package/src/servers/ZoneServer2016/entities/explosiveentity.ts

@@ -42,6 +42,8 @@ export class ExplosiveEntity extends BaseLightweightCharacter {
 
   isAwaitingExplosion: boolean = false;
 
+  isArmed: boolean = false;
+
   constructor(
     characterId: string,
     transientId: number,
@@ -109,6 +111,7 @@ export class ExplosiveEntity extends BaseLightweightCharacter {
   async arm(server: ZoneServer2016) {
     // Wait 10 seconds before activating the trap
     await scheduler.wait(10_000);
+    this.isArmed = true;
     server.aiManager.addEntity(this);
   }
 

package/src/servers/ZoneServer2016/entities/watersource.ts

@@ -204,7 +204,6 @@ export class WaterSource extends TaskProp {
       weaponId = weapon?.itemDefinitionId,
       activatableItems = [
         Items.WEAPON_WRENCH,
-        Items.WEAPON_BRANCH,
         Items.WEAPON_HAMMER,
         Items.WEAPON_HAMMER_DEMOLITION
       ];

package/src/servers/ZoneServer2016/managers/aimanager.ts

@@ -113,6 +113,7 @@ export class AiManager {
       for (const cell of cells) {
         for (const obj of cell.objects) {
           if (!(obj instanceof ExplosiveEntity)) continue;
+          if (!obj.isArmed) continue;
           if (
             isPosInRadiusWithY(
               EXPLOSIVE_TRIGGER_RADIUS,

package/src/servers/ZoneServer2016/managers/worlddatamanager.ts

@@ -208,13 +208,16 @@ export class WorldDataManager {
   }
 
   async fetchWorldData(): Promise<FetchedWorldData> {
-    const vehicles = (await this.loadVehiclesData()) as FullVehicleSaveData[];
-    const constructionParents =
-      (await this.loadConstructionData()) as ConstructionParentSaveData[];
-    const freeplace =
-      (await this.loadWorldFreeplaceConstruction()) as LootableConstructionSaveData[];
-    const crops = (await this.loadCropData()) as PlantingDiameterSaveData[];
-    const traps = (await this.loadTrapData()) as TrapSaveData[];
+    const [vehicles, constructionParents, freeplace, crops, traps] =
+      await Promise.all([
+        this.loadVehiclesData() as Promise<FullVehicleSaveData[]>,
+        this.loadConstructionData() as Promise<ConstructionParentSaveData[]>,
+        this.loadWorldFreeplaceConstruction() as Promise<
+          LootableConstructionSaveData[]
+        >,
+        this.loadCropData() as Promise<PlantingDiameterSaveData[]>,
+        this.loadTrapData() as Promise<TrapSaveData[]>
+      ]);
     debug("World fetched!");
     return {
       constructionParents,
@@ -255,27 +258,28 @@ export class WorldDataManager {
   }
 
   async deleteWorld() {
-    await this.deleteServerData();
-    await this.deleteCharacters();
+    await Promise.all([this.deleteServerData(), this.deleteCharacters()]);
     debug("World deleted!");
   }
 
   async saveWorld(world: WorldArg) {
     console.time("WDM: saveWorld");
-    await this.saveVehicles(
-      world.vehicles.filter(
-        (vehicle) =>
-          ![VehicleIds.SPECTATE, VehicleIds.PARACHUTE].includes(
-            vehicle.vehicleId
-          )
-      )
-    );
-    await this.saveServerData(world.lastGuidItem);
-    await this.saveCharacters(world.characters);
-    await this.saveConstructionData(world.constructions);
-    await this.saveWorldFreeplaceConstruction(world.worldConstructions);
-    await this.saveCropData(world.crops);
-    await this.saveTrapData(world.traps);
+    await Promise.all([
+      this.saveVehicles(
+        world.vehicles.filter(
+          (vehicle) =>
+            ![VehicleIds.SPECTATE, VehicleIds.PARACHUTE].includes(
+              vehicle.vehicleId
+            )
+        )
+      ),
+      this.saveServerData(world.lastGuidItem),
+      this.saveCharacters(world.characters),
+      this.saveConstructionData(world.constructions),
+      this.saveWorldFreeplaceConstruction(world.worldConstructions),
+      this.saveCropData(world.crops),
+      this.saveTrapData(world.traps)
+    ]);
     console.timeEnd("WDM: saveWorld");
   }
 

package/src/servers/ZoneServer2016/managers/worldobjectmanager.ts

@@ -228,20 +228,26 @@ export class WorldObjectManager {
           if (this.gridScrapLimitEnabled) {
             this.refillScrapInChunks(server);
           }
+          const lootSpan = transaction?.startSpan("createLoot");
           await this.createLootThreaded(server);
           await this.createContainerLootThreaded(server);
+          lootSpan?.end();
           this._lastLootRespawnTime = Date.now();
           server.divideLargeCells(700);
         }
         if (this._lastNpcRespawnTime + this.npcRespawnTimer <= Date.now()) {
+          const npcSpan = transaction?.startSpan("createNpcs");
           await this.createNpcsThreaded(server);
+          npcSpan?.end();
           this._lastNpcRespawnTime = Date.now();
         }
         if (
           this._lastVehicleRespawnTime + this.vehicleRespawnTimer <=
           Date.now()
         ) {
+          const vehicleSpan = transaction?.startSpan("createVehicles");
           this.createVehicles(server);
+          vehicleSpan?.end();
           this._lastVehicleRespawnTime = Date.now();
         }
         if (
@@ -256,7 +262,9 @@ export class WorldObjectManager {
       }
 
       if (server.isSurvival()) {
+        const despawnSpan = transaction?.startSpan("despawnEntities");
         await this.despawnEntities(server);
+        despawnSpan?.end();
       }
     } finally {
       transaction.end();
@@ -1201,45 +1209,50 @@ export class WorldObjectManager {
       "WorldObjectManager::createVehicles",
       "custom"
     );
-    if (_.size(server._vehicles) >= this.vehicleSpawnCap) return;
-    const respawnAmount = Math.ceil(
-      (this.vehicleSpawnCap - _.size(server._vehicles)) / 8
-    );
-    for (let x = 0; x < respawnAmount; x++) {
-      const dataVehicle =
-        Z1_vehicles[randomIntFromInterval(0, Z1_vehicles.length - 1)];
-      let spawn = true;
-      Object.values(server._vehicles).forEach((spawnedVehicle: Vehicle2016) => {
-        if (!spawn) return;
-        if (
-          isPosInRadius(
-            this.vehicleSpawnRadius,
-            dataVehicle.position,
-            spawnedVehicle.state.position
-          )
-        ) {
-          spawn = false;
+    try {
+      if (_.size(server._vehicles) >= this.vehicleSpawnCap) return;
+      const respawnAmount = Math.ceil(
+        (this.vehicleSpawnCap - _.size(server._vehicles)) / 8
+      );
+      for (let x = 0; x < respawnAmount; x++) {
+        const dataVehicle =
+          Z1_vehicles[randomIntFromInterval(0, Z1_vehicles.length - 1)];
+        let spawn = true;
+        Object.values(server._vehicles).forEach(
+          (spawnedVehicle: Vehicle2016) => {
+            if (!spawn) return;
+            if (
+              isPosInRadius(
+                this.vehicleSpawnRadius,
+                dataVehicle.position,
+                spawnedVehicle.state.position
+              )
+            ) {
+              spawn = false;
+            }
+          }
+        );
+        if (!spawn) {
+          continue;
         }
-      });
-      if (!spawn) {
-        continue;
+        const characterId = generateRandomGuid(),
+          vehicleData = new Vehicle2016(
+            characterId,
+            server.getTransientId(characterId),
+            0,
+            new Float32Array(dataVehicle.position),
+            new Float32Array(dataVehicle.rotation),
+            server,
+            getCurrentServerTimeWrapper().getTruncatedU32(),
+            dataVehicle.vehicleId
+          );
+        vehicleData.positionUpdate.orientation = dataVehicle.orientation;
+        this.createVehicle(server, vehicleData, maxSpawnChance); // save vehicle
       }
-      const characterId = generateRandomGuid(),
-        vehicleData = new Vehicle2016(
-          characterId,
-          server.getTransientId(characterId),
-          0,
-          new Float32Array(dataVehicle.position),
-          new Float32Array(dataVehicle.rotation),
-          server,
-          getCurrentServerTimeWrapper().getTruncatedU32(),
-          dataVehicle.vehicleId
-        );
-      vehicleData.positionUpdate.orientation = dataVehicle.orientation;
-      this.createVehicle(server, vehicleData, maxSpawnChance); // save vehicle
+    } finally {
+      transaction.end();
+      debug("All vehicles created");
     }
-    transaction.end();
-    debug("All vehicles created");
   }
 
   private async createNpcs(server: ZoneServer2016) {

package/src/servers/ZoneServer2016/zonepackethandlers.ts

@@ -168,6 +168,7 @@ import { LoadoutItem } from "./classes/loadoutItem";
 import { BaseItem } from "./classes/baseItem";
 import { Collection } from "mongodb";
 import { ItemObject } from "./entities/itemobject";
+import { ExplosiveEntity } from "./entities/explosiveentity";
 
 function getStanceFlags(num: number): StanceFlags {
   function getBit(bin: string, bit: number) {
@@ -1500,20 +1501,10 @@ export class ZonePacketHandlers {
     if (stance) {
       const stanceFlags = getStanceFlags(stance);
 
-      if (stanceFlags.SITTING) {
-        server.sendData<CommandRunSpeed>(client, "Command.RunSpeed", {
-          runSpeed: 0.1
-        });
-        setTimeout(() => {
-          server.sendData<CommandRunSpeed>(client, "Command.RunSpeed", {
-            runSpeed: 0
-          });
-        }, 2000);
-      }
-
       // Detect movements based on stance
       server.fairPlayManager.detectJumpXSMovement(server, client, stanceFlags);
       server.fairPlayManager.detectDroneMovement(server, client, stanceFlags);
+      server.detectSnaking(server, client, stanceFlags);
       server.detectEnasMovement(server, client, stanceFlags);
 
       // Handle jump logic
@@ -1622,6 +1613,20 @@ export class ZonePacketHandlers {
       }
       client.character.state.position = position;
 
+      // Check if player stepped on an armed landmine
+      if (server.aiManager.explosiveEntities.size > 0) {
+        const landmineCells = server.getGridCellsInRadius(position, 0.6);
+        for (const cell of landmineCells) {
+          for (const obj of cell.objects) {
+            if (!(obj instanceof ExplosiveEntity)) continue;
+            if (!obj.isArmed) continue;
+            if (isPosInRadiusWithY(0.6, position, obj.state.position, 0.5)) {
+              obj.detonate(client.character.characterId);
+            }
+          }
+        }
+      }
+
       // Stop HUD timer if position is out of radius
       if (
         client.hudTimer &&

package/src/servers/ZoneServer2016/zoneserver.ts

@@ -13,6 +13,7 @@
 
 const debugName = "ZoneServer",
   debug = require("debug")(debugName);
+const apm = require("elastic-apm-node");
 
 import { EventEmitter } from "node:events";
 import { H1Z1Protocol } from "../../protocols/h1z1protocol";
@@ -762,26 +763,57 @@ export class ZoneServer2016 extends EventEmitter {
         //   // If there is a lot of packet to process, it's better, if there is none then we only add like some µsec
         //   await scheduler.yield();
         // }
-        const packet = this._protocol.parse(data, flags);
 
-        // for reversing new packets
-        /*
-        if(
-          packet?.name == ""
-        ) {
-          let hexString = '';
-          for (let i = 0; i < data.length; i++) {
-              const byte = data[i].toString(16).padStart(2, '0');
-              hexString += byte + ' ';
-          }
-          console.log(`<Buffer ${hexString.trim()}>`);
-        }
-        */
+        // Position broadcasts are relayed as-is and fire hundreds of times per second —
+        // not worth the per-packet transaction overhead.
+        const isPositionUpdate = flags === GatewayChannels.UpdatePosition;
+        let transaction = isPositionUpdate
+          ? null
+          : apm.startTransaction("PacketReceive", "game");
 
-        if (packet) {
-          this.onZoneDataEvent(this._clients[soeClientSessionId], packet);
-        } else {
-          debug("zonefailed : ", data);
+        try {
+          const parseSpan = transaction?.startSpan("parse");
+          const packet = this._protocol.parse(data, flags);
+          parseSpan?.end();
+
+          // for reversing new packets
+          /*
+          if(
+            packet?.name == ""
+          ) {
+            let hexString = '';
+            for (let i = 0; i < data.length; i++) {
+                const byte = data[i].toString(16).padStart(2, '0');
+                hexString += byte + ' ';
+            }
+            console.log(`<Buffer ${hexString.trim()}>`);
+          }
+          */
+
+          if (packet) {
+            if (transaction) {
+              if (packet.name === "PlayerUpdateManagedPosition") {
+                // Same reasoning as UpdatePosition flag — high-frequency relay,
+                // not worth the per-packet transaction overhead.
+                transaction.end();
+                transaction = null;
+              } else {
+                transaction.name = `Packet::${packet.name}`;
+                const client = this._clients[soeClientSessionId];
+                if (client?.character?.characterId) {
+                  transaction.addLabels({
+                    character_id: client.character.characterId,
+                    packet_name: packet.name
+                  });
+                }
+              }
+            }
+            this.onZoneDataEvent(this._clients[soeClientSessionId], packet);
+          } else {
+            debug("zonefailed : ", data);
+          }
+        } finally {
+          transaction?.end();
         }
       }
     );
@@ -1225,12 +1257,15 @@ export class ZoneServer2016 extends EventEmitter {
     }
 
     try {
+      const processSpan = apm.currentTransaction?.startSpan("processPacket");
       this._packetHandlers.processPacket(
         this,
         client,
         packet as ReceivedPacket<any>
       );
+      processSpan?.end();
     } catch (error) {
+      apm.currentTransaction?.setOutcome("failure");
       console.error(error);
       console.error(`An error occurred while processing a packet : `, packet);
       logVersion();
@@ -2649,6 +2684,7 @@ export class ZoneServer2016 extends EventEmitter {
               pz <= cell.position[2] + cell.height
             ) {
               cell.objects.push(obj);
+              cell.lastModified = Date.now();
               setImmediate(() => this.onEntityAddedToCell(obj, cell));
               break;
             }
@@ -2696,6 +2732,7 @@ export class ZoneServer2016 extends EventEmitter {
     const gridCell = this._gridLookup[col * this._gridNumCols + row];
     if (!gridCell || gridCell.objects.includes(obj)) return;
     gridCell.objects.push(obj);
+    gridCell.lastModified = Date.now();
     setImmediate(() => this.onEntityAddedToCell(obj, gridCell));
   }
 
@@ -2726,14 +2763,22 @@ export class ZoneServer2016 extends EventEmitter {
 
   private async worldRoutine() {
     if (!this.hookManager.checkHook("OnWorldRoutine")) return;
-    else {
+    const transaction = apm.startTransaction("worldRoutine", "game");
+    try {
       if (this._ready) {
+        const plantSpan = transaction?.startSpan("plantManager");
         this.constructionManager.plantManager(this);
+        plantSpan?.end();
         await scheduler.yield();
+
         await this.worldObjectManager.run(this);
         await scheduler.yield();
+
+        const vehicleSpan = transaction?.startSpan("checkVehiclesInMapBounds");
         this.checkVehiclesInMapBounds();
+        vehicleSpan?.end();
         await scheduler.yield();
+
         this.updateSyncTeleport();
         await scheduler.yield();
         this.updateSpectatorMap();
@@ -2745,8 +2790,10 @@ export class ZoneServer2016 extends EventEmitter {
           this.saveWorld();
         }
       }
+    } finally {
+      transaction?.end();
+      this.worldRoutineTimer.refresh();
     }
-    this.worldRoutineTimer.refresh();
   }
 
   async deleteClient(client: Client) {
@@ -4916,7 +4963,9 @@ export class ZoneServer2016 extends EventEmitter {
       default:
         debug("send data", packetName);
     }
+    const packSpan = apm.currentTransaction?.startSpan(`pack::${packetName}`);
     const data = this._protocol.pack(packetName, obj);
+    packSpan?.end();
     if (data) {
       this._gatewayServer.sendTunnelData(client.soeClientId, data, channel);
     }
@@ -9274,6 +9323,19 @@ export class ZoneServer2016 extends EventEmitter {
     }
   }
 
+  detectSnaking(
+    server: ZoneServer2016,
+    client: Client,
+    stanceFlags: StanceFlags
+  ) {
+    if (stanceFlags.SITTING) {
+      server.multiplyMovementModifier(client, 0.2);
+      setTimeout(() => {
+        server.divideMovementModifier(client, 0.2);
+      }, 2000);
+    }
+  }
+
   //#endregion
 
   async reloadZonePacketHandlers() {
@@ -9405,29 +9467,39 @@ export class ZoneServer2016 extends EventEmitter {
   }
 
   /** Runs the world-state update for a single client based on their current
-   *  known position. Called from the server tick — NOT from packet handlers. */
-  private runClientTick(client: Client) {
-    if (client.isLoading) return;
+   *  known position. Called from the server tick — NOT from packet handlers.  */
+  private runClientTick(client: Client): [number, number, number] {
+    if (client.isLoading) return [0, 0, 0];
     const pos = client.character.state.position;
+    let constPermMs = 0,
+      heavyScanMs = 0,
+      spawnCharsMs = 0;
 
     // Construction permissions: run when player has moved 3+ units
     if (getDistance2d(pos, client.posAtLastPermissionCheck) >= 3) {
+      const t = Date.now();
       this.constructionManager.constructionPermissionsManager(this, client);
+      constPermMs = Date.now() - t;
       client.posAtLastPermissionCheck = pos.slice() as Float32Array;
     }
 
     // Heavy world scans: run when player has moved 10+ units
     if (getDistance2d(pos, client.posAtLastRoutine) >= 10) {
+      const t = Date.now();
       if (!this.disableMapBoundsCheck) this.checkInMapBounds(client);
       this.assignChunkRenderDistance(client);
       if (!this.disablePOIManager) this.POIManager(client);
       this.vehicleManager(client);
 
-      // Spawn any entities in already-subscribed cells that weren't in render
-      // range when first subscribed — e.g. NPCs that spawned nearby.
+      // Re-scan only cells that received new entities since this client's last
+      // heavy-scan pass. Cells unchanged since then are skipped entirely, keeping
+      // this O(dirty cells) instead of O(all subscribed cells × all objects).
       for (const cell of client.subscribedCells) {
-        this.spawnCellObjectsForClient(client, cell);
+        if (cell.lastModified > client.lastRoutineTime) {
+          this.spawnCellObjectsForClient(client, cell);
+        }
       }
+      heavyScanMs = Date.now() - t;
 
       client.posAtLastRoutine = pos.slice() as Float32Array;
       client.lastRoutineTime = Date.now();
@@ -9441,7 +9513,11 @@ export class ZoneServer2016 extends EventEmitter {
       void this.updateClientSubscriptions(client);
     }
 
+    const t = Date.now();
     this.spawnCharacters(client);
+    spawnCharsMs = Date.now() - t;
+
+    return [constPermMs, heavyScanMs, spawnCharsMs];
   }
 
   private _worldTickTimer?: NodeJS.Timeout;
@@ -9465,17 +9541,56 @@ export class ZoneServer2016 extends EventEmitter {
     }
   }
 
+  private _lastTickTime = 0;
+
   startWorldTick() {
     const tick = () => {
       if (!this._ready) {
+        this._lastTickTime = Date.now();
         this._worldTickTimer = setTimeout(tick, ZoneServer2016.WORLD_TICK_MS);
         return;
       }
-      this._rebuildSpatialMaps();
-      for (const sessionId in this._clients) {
-        this.runClientTick(this._clients[sessionId]);
+      const now = Date.now();
+      const tickLagMs = this._lastTickTime
+        ? Math.max(0, now - this._lastTickTime - ZoneServer2016.WORLD_TICK_MS)
+        : 0;
+      this._lastTickTime = now;
+
+      const transaction = apm.startTransaction("WorldTick", "game");
+      try {
+        transaction?.addLabels({
+          client_count: Object.keys(this._clients).length,
+          npc_count: Object.keys(this._npcs).length,
+          vehicle_count: Object.keys(this._vehicles).length,
+          loot_count: Object.keys(this._lootableProps).length,
+          construction_count: Object.keys(this._constructionSimple).length,
+          tick_lag_ms: tickLagMs
+        });
+
+        const spatialSpan = transaction?.startSpan("rebuildSpatialMaps");
+        this._rebuildSpatialMaps();
+        spatialSpan?.end();
+
+        const clientTickSpan = transaction?.startSpan("clientTick");
+        let constPermMs = 0,
+          heavyScanMs = 0,
+          spawnCharsMs = 0;
+        for (const sessionId in this._clients) {
+          const [cp, hs, sc] = this.runClientTick(this._clients[sessionId]);
+          constPermMs += cp;
+          heavyScanMs += hs;
+          spawnCharsMs += sc;
+        }
+        clientTickSpan?.addLabels({
+          constPerm_ms: constPermMs,
+          heavyScan_ms: heavyScanMs,
+          spawnChars_ms: spawnCharsMs
+        });
+        clientTickSpan?.end();
+      } finally {
+        transaction?.end();
+        this._worldTickTimer = setTimeout(tick, ZoneServer2016.WORLD_TICK_MS);
       }
-      this._worldTickTimer = setTimeout(tick, ZoneServer2016.WORLD_TICK_MS);
     };
     this._worldTickTimer = setTimeout(tick, ZoneServer2016.WORLD_TICK_MS);
   }