h1z1-server 0.47.2-0 → 0.47.2-1

package/package.json

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

package/src/packets/ClientProtocol/ClientProtocol_1080/base.ts

@@ -2221,10 +2221,14 @@ export const basePackets: PacketStructures = [
   ],
   ["ClientMetrics", 0x45, {}],
   [
-    "Command.TogglePlayerInterfaces",
+    "FirstTimeEvent.NotifySystem",
     0x4601,
     {
-      fields: []
+      fields: [
+        { name: "unknownDword1", type: "int32", defaultValue: 0 },
+        { name: "unknownBoolean1", type: "boolean", defaultValue: false },
+        { name: "displayElement", type: "int32", defaultValue: 0 }
+      ]
     }
   ],
   [

package/src/packets/ClientProtocol/ClientProtocol_1080/referenceData.ts

@@ -273,7 +273,7 @@ const weaponDefinitionSchema: PacketFields = [
                 defaultValue: 0
               },
               { name: "FIRE_DETECT_RANGE", type: "uint16", defaultValue: 0 },
-              { name: "EFFECT_GROUP", type: "float", defaultValue: 0 },
+              { name: "EFFECT_GROUP", type: "uint32", defaultValue: 0 },
               { name: "PLAYER_STATE_GROUP_ID", type: "float", defaultValue: 0 },
               { name: "MOVEMENT_MODIFIER", type: "float", defaultValue: 0 },
               { name: "TURN_MODIFIER", type: "float", defaultValue: 0 },

package/src/servers/GatewayServer/gatewayserver.ts

@@ -21,7 +21,7 @@ import { SOEOutputChannels } from "servers/SoeServer/soeoutputstream";
 const debug = require("debug")("GatewayServer");
 
 export class GatewayServer extends EventEmitter {
-  private _soeServer: SOEServer;
+  public _soeServer: SOEServer;
   private _protocol: GatewayProtocol;
   private _crcLength: crc_length_options;
   private _udpLength: number;

package/src/servers/SoeServer/soeclient.ts

@@ -40,6 +40,7 @@ export default class SOEClient {
   waitingQueue: PacketsQueue = new PacketsQueue();
   protocolName: string = "unset";
   unAckData: Map<number, number> = new Map();
+  lostPackets: number[] = [];
   lastAckSend: wrappedUint16 = new wrappedUint16(-1);
   inputStream: SOEInputStream;
   outputStream: SOEOutputStream;
@@ -58,6 +59,8 @@ export default class SOEClient {
   sendingTimer: NodeJS.Timeout | null = null;
   private _statsResetTimer: NodeJS.Timer;
   delayedLogicalPackets: LogicalPacket[] = [];
+  finishedLoading: boolean = false;
+  statsResettedRecently: boolean = false;
   constructor(remote: RemoteInfo, crcSeed: number, cryptoKey: Uint8Array) {
     this.soeClientId = SOEClient.getClientId(remote);
     this.address = remote.address;
@@ -71,7 +74,7 @@ export default class SOEClient {
     } else {
       this.outputStream = new SOEOutputStream(cryptoKey);
     }
-    this._statsResetTimer = setInterval(() => this._resetStats(), 60000);
+    this._statsResetTimer = setInterval(() => this._resetStats(), 10000);
   }
   static getClientId(remote: RemoteInfo): string {
     return remote.address + ":" + remote.port;
@@ -80,26 +83,78 @@ export default class SOEClient {
     // wierd stuff with the new global Symbol used with the using keyword, skipping that headache for now
     clearInterval(this._statsResetTimer as unknown as number);
   }
+  private getDynamicWaitTime(): number {
+    if (!this.finishedLoading) return 30;
+
+    const ping = this.avgPing || 0;
+    const minPing = 50;
+    const maxPing = 250;
+    const minWait = 4;
+    const maxWait = 12;
+
+    // Calculate ratio (0–1) and clamp to range
+    const ratio = Math.max(
+      0,
+      Math.min(1, (ping - minPing) / (maxPing - minPing))
+    );
+
+    // Calculate wait time in the range 4–12 ms
+    const waitTime = minWait + ratio * (maxWait - minWait);
+
+    return Math.round(waitTime);
+  }
   private _resetStats() {
+    // Reset network statistics and set a temporary flag
     this.stats.totalPhysicalPacketSent = 0;
     this.stats.packetsOutOfOrder = 0;
     this.stats.packetResend = 0;
     this.stats.totalLogicalPacketSent = 0;
+    this.statsResettedRecently = true;
+    setTimeout(() => {
+      this.statsResettedRecently = false;
+    }, 5000);
+  }
+
+  seqDiff(a: number, b: number): number {
+    // Difference with uint16 (65536) overflow handling
+    return (a - b + 65536) % 65536;
+  }
+
+  getNetworkQuality(): number {
+    const lastAckSeq = this.outputStream.lastAck.get();
+    let packetLoss = 0;
+
+    // Count lost packets within the last 100 sequence numbers
+    for (const sequence of this.lostPackets) {
+      if (this.seqDiff(lastAckSeq, sequence) <= 100) {
+        packetLoss++;
+      }
+    }
+
+    return packetLoss;
   }
   getNetworkStats(): string[] {
-    const {
-      totalPhysicalPacketSent: totalPacketSent,
-      packetResend,
-      packetsOutOfOrder
-    } = this.stats;
-    const packetLossRate =
-      Number((packetResend / totalPacketSent).toFixed(3)) * 100;
+    const { totalLogicalPacketSent, packetResend, packetsOutOfOrder } =
+      this.stats;
+    const totalPackets = totalLogicalPacketSent + packetResend;
+
     const packetOutOfOrderRate =
-      Number((packetsOutOfOrder / totalPacketSent).toFixed(3)) * 100;
+      totalPackets > 0
+        ? Number(((packetsOutOfOrder / totalPackets) * 100).toFixed(1))
+        : 0;
+
+    const lastAckSeq = this.outputStream.lastAck.get();
+    let packetLoss = 0;
+
+    for (const sequence of this.lostPackets) {
+      if (this.seqDiff(lastAckSeq, sequence) <= 100) packetLoss++;
+    }
+
     return [
-      `Packet loss rate ${packetLossRate}%`,
-      `Packet outOfOrder rate ${packetOutOfOrderRate}%`,
-      `Avg ping ${this.avgPing}ms`
+      `Packet loss rate: ${packetLoss}%`,
+      `Out-of-order rate: ${packetOutOfOrderRate}%`,
+      `Avg ping: ${this.avgPing}ms`,
+      `Wait Time: ${this.getDynamicWaitTime().toFixed(2)}ms`
     ];
   }
   addPing(ping: number) {

package/src/servers/SoeServer/soeserver.ts

@@ -35,8 +35,8 @@ export class SOEServer extends EventEmitter {
   private _connectionv6: dgram.Socket;
   private readonly _crcSeed: number = Math.floor(Math.random() * 255);
   private _crcLength: crc_length_options = 2;
-  _waitTimeMs: number = 24;
-  keepAliveTimeoutTime: number = 40000;
+  _waitTimeMs: number = 2;
+  keepAliveTimeoutTime: number = 30000;
   private readonly _maxMultiBufferSize: number;
   private _resendTimeout: number = 250;
   private _maxResentTries: number = 24;
@@ -95,6 +95,25 @@ export class SOEServer extends EventEmitter {
     }
   }
 
+  private getDynamicWaitTime(client: SOEClient): number {
+    if (!client.finishedLoading) return 30;
+
+    const ping = client.avgPing || 0;
+    const minPing = 50;
+    const maxPing = 250;
+    const minWait = 4;
+    const maxWait = 12;
+
+    // Calculate ratio (0–1) and clamp to range
+    const ratio = Math.max(
+      0,
+      Math.min(1, (ping - minPing) / (maxPing - minPing))
+    );
+
+    // Calculate wait time in the range 4–12 ms
+    return Math.round(minWait + ratio * (maxWait - minWait));
+  }
+
   getNetworkStats() {
     const avgServerLag =
       this.avgEventLoopLag > 1
@@ -136,48 +155,50 @@ export class SOEServer extends EventEmitter {
     }
   }
 
-  // Get an array of packet that we need to resend
+  // Get an array of packets that need to be resent
   getResends(client: Client): LogicalPacket[] {
     const currentTime = Date.now();
     const resends: LogicalPacket[] = [];
-    const resendedSequences: Set<number> = new Set();
+    const resendedSequences = new Set<number>();
+    const lastAck = client.outputStream.lastAck.get();
+
+    // Helper to calculate resend timeout
+    const getResendTimeout = () =>
+      Math.min(Math.max(client.avgPing + this._resendTimeout, 100), 400);
+
+    // Track lost packets for this round to avoid duplicates
+    const lostPacketsSet = new Set(client.lostPackets);
+
     for (const [sequence, time] of client.unAckData) {
-      // if the packet is too old then we resend it
-      if (time + this._resendTimeout + client.avgPing < currentTime) {
+      if (time + getResendTimeout() < currentTime) {
         const dataCache = client.outputStream.getDataCache(sequence);
         if (dataCache) {
-          if (dataCache.resendCounter >= this._maxResentTries) {
-            continue;
-          }
+          if (dataCache.resendCounter >= this._maxResentTries) continue;
           dataCache.resendCounter++;
           client.stats.packetResend++;
           const logicalPacket = this.createLogicalPacket(
             dataCache.fragment ? SoeOpcode.DataFragment : SoeOpcode.Data,
-            { sequence: sequence, data: dataCache.data }
+            { sequence, data: dataCache.data }
           );
           if (logicalPacket) {
             resendedSequences.add(sequence);
             resends.push(logicalPacket);
+            if (
+              logicalPacket.sequence !== undefined &&
+              !lostPacketsSet.has(logicalPacket.sequence)
+            ) {
+              client.lostPackets.push(logicalPacket.sequence);
+              lostPacketsSet.add(logicalPacket.sequence);
+            }
           }
-        } else {
-          // If the data cache is not found it means that the packet has been acked
         }
       }
     }
 
-    // check for possible accerated resends
+    // Accelerated resends for out-of-order packets
     for (const sequence of client.outputStream.outOfOrder) {
-      if (sequence < client.outputStream.lastAck.get()) {
-        continue;
-      }
-
-      // resend every packets between the last ack and the out of order packet
-      for (
-        let index = client.outputStream.lastAck.get();
-        index < sequence;
-        index++
-      ) {
-        // If that sequence has been out of order acked or resended then we don't resend it again
+      if (sequence < lastAck) continue;
+      for (let index = lastAck; index < sequence; index++) {
         if (
           client.outputStream.outOfOrder.has(index) ||
           resendedSequences.has(index)
@@ -193,16 +214,13 @@ export class SOEServer extends EventEmitter {
           if (logicalPacket) {
             resendedSequences.add(index);
             resends.push(logicalPacket);
+            client.stats.packetsOutOfOrder++;
           }
-        } else {
-          // well if it's not in the cache then it means that it has been acked
         }
       }
     }
 
-    // clear out of order array
     client.outputStream.outOfOrder.clear();
-
     return resends;
   }
 
@@ -296,9 +314,10 @@ export class SOEServer extends EventEmitter {
   // activate the sending timer if it's not already activated
   private _activateSendingTimer(client: SOEClient, additonalTime: number = 0) {
     if (!client.sendingTimer) {
+      const waitTime = this.getDynamicWaitTime(client) + additonalTime;
       client.sendingTimer = setTimeout(() => {
         this.sendingProcess(client);
-      }, this._waitTimeMs + additonalTime);
+      }, waitTime);
     }
   }
 
@@ -376,7 +395,6 @@ export class SOEServer extends EventEmitter {
         );
         break;
       case "OutOfOrder":
-        client.stats.packetsOutOfOrder++;
         client.outputStream.outOfOrder.add(packet.sequence);
         //client.outputStream.singleAck(packet.sequence, client.unAckData)
         break;
@@ -567,18 +585,17 @@ export class SOEServer extends EventEmitter {
     return appPackets;
   }
   private sendingProcess(client: Client) {
-    // If there is a pending sending timer then we clear it
+    // Clear any pending sending timer
     this._clearSendingTimer(client);
-    if (client.isDeleted) {
-      return;
-    }
+    if (client.isDeleted) return;
+
     const resends = this.getResends(client);
     for (const resend of resends) {
       client.stats.totalLogicalPacketSent++;
       if (this._canBeBufferedIntoQueue(resend, client.waitingQueue)) {
         client.waitingQueue.addPacket(resend);
       } else {
-        const waitingQueuePacket = this.getClientWaitQueuePacket(
+        let waitingQueuePacket = this.getClientWaitQueuePacket(
           client,
           client.waitingQueue
         );
@@ -588,7 +605,6 @@ export class SOEServer extends EventEmitter {
         if (this._canBeBufferedIntoQueue(resend, client.waitingQueue)) {
           client.waitingQueue.addPacket(resend);
         } else {
-          // if it still can't be buffered it means that the packet is too big so we send it directly
           this._sendAndBuildPhysicalPacket(client, resend);
         }
       }
@@ -599,55 +615,48 @@ export class SOEServer extends EventEmitter {
       client.delayedLogicalPackets.push(...appPackets);
     }
 
-    if (client.delayedLogicalPackets.length > 0) {
-      for (
-        let index = 0;
-        index < client.delayedLogicalPackets.length;
-        index++
-      ) {
-        const packet = client.delayedLogicalPackets.shift();
-        if (!packet) {
-          break;
+    // Process delayed logical packets
+    while (client.delayedLogicalPackets.length > 0) {
+      const packet = client.delayedLogicalPackets.shift();
+      if (!packet) break;
+      if (this._canBeBufferedIntoQueue(packet, client.waitingQueue)) {
+        client.waitingQueue.addPacket(packet);
+      } else {
+        let waitingQueuePacket = this.getClientWaitQueuePacket(
+          client,
+          client.waitingQueue
+        );
+        if (waitingQueuePacket) {
+          this._sendAndBuildPhysicalPacket(client, waitingQueuePacket);
         }
         if (this._canBeBufferedIntoQueue(packet, client.waitingQueue)) {
           client.waitingQueue.addPacket(packet);
         } else {
-          // sends the already buffered packets
-          const waitingQueuePacket = this.getClientWaitQueuePacket(
-            client,
-            client.waitingQueue
-          );
-          if (waitingQueuePacket) {
-            this._sendAndBuildPhysicalPacket(client, waitingQueuePacket);
-          }
-          if (this._canBeBufferedIntoQueue(packet, client.waitingQueue)) {
-            client.waitingQueue.addPacket(packet);
-          } else {
-            // if it still can't be buffered it means that the packet is too big so we send it directly
-            this._sendAndBuildPhysicalPacket(client, packet);
-          }
+          this._sendAndBuildPhysicalPacket(client, packet);
         }
       }
     }
+    // Handle ack packet
     const ackPacket = this.getAck(client);
     if (ackPacket) {
       client.stats.totalLogicalPacketSent++;
       if (this._canBeBufferedIntoQueue(ackPacket, client.waitingQueue)) {
         client.waitingQueue.addPacket(ackPacket);
       } else {
-        const waitingQueuePacket = this.getClientWaitQueuePacket(
+        let waitingQueuePacket = this.getClientWaitQueuePacket(
           client,
           client.waitingQueue
         );
         if (waitingQueuePacket) {
           this._sendAndBuildPhysicalPacket(client, waitingQueuePacket);
         }
-        // no additionnal check needed here because ack packets have a fixed size
+        // Ack packets are always small enough to fit after clearing
         client.waitingQueue.addPacket(ackPacket);
       }
     }
-    // if there is still some packets in the queue then we send them
-    const waitingQueuePacket = this.getClientWaitQueuePacket(
+
+    // Send any remaining packets in the waiting queue
+    let waitingQueuePacket = this.getClientWaitQueuePacket(
       client,
       client.waitingQueue
     );
@@ -655,6 +664,11 @@ export class SOEServer extends EventEmitter {
       this._sendAndBuildPhysicalPacket(client, waitingQueuePacket);
     }
 
+    // Trim lostPackets to last 100 if needed
+    if (client.lostPackets.length > 100) {
+      client.lostPackets.splice(0, client.lostPackets.length - 100);
+    }
+
     if (client.unAckData.size > 0) {
       this._activateSendingTimer(client);
     }

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

@@ -83,6 +83,7 @@ export class ZoneClient2016 {
   avgPingLen: number = 4;
   pingWarnings: number = 0;
   isWeaponLock: boolean = false;
+  lastMovementImpared: number = 0;
   avgPingReady: boolean = false;
   chunkRenderDistance: number = 400;
   routineCounter: number = 0;

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

@@ -48,7 +48,7 @@ function getRenderDistance(actorModelId: number) {
       range = 1000;
       break;
   }
-  return range ? range : undefined;
+  return range ? range : 1000;
 }
 
 export abstract class BaseEntity {

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

@@ -944,20 +944,29 @@ export abstract class BaseFullCharacter extends BaseLightweightCharacter {
 
   pGetAttachmentSlot(slotId: number) {
     const slot = this._equipment[slotId];
-    return slot
-      ? {
-          modelName: slot.modelName.replace(
-            /Up|Down/g,
-            this.hoodState == "Down" ? "Up" : "Down"
-          ),
-          effectId: slot.effectId || 0,
-          textureAlias: slot.textureAlias || "",
-          tintAlias: slot.tintAlias || "Default",
-          decalAlias: slot.decalAlias || "#",
-          slotId: slot.slotId,
-          SHADER_PARAMETER_GROUP: slot?.SHADER_PARAMETER_GROUP ?? []
-        }
-      : undefined;
+    if (!slot) return undefined;
+
+    const shaderGroup = slot.SHADER_PARAMETER_GROUP ?? [];
+    let shaderParams = shaderGroup;
+
+    if (slotId == 3 && shaderGroup.length == 4) {
+      shaderParams =
+        this.hoodState == "Down"
+          ? [shaderGroup[0], shaderGroup[1]]
+          : [shaderGroup[2], shaderGroup[3]];
+    }
+
+    const hoodReplace = this.hoodState == "Down" ? "Up" : "Down";
+
+    return {
+      modelName: slot.modelName.replace(/Up|Down/g, hoodReplace),
+      effectId: slot.effectId || 0,
+      textureAlias: slot.textureAlias || "",
+      tintAlias: slot.tintAlias || "Default",
+      decalAlias: slot.decalAlias || "#",
+      slotId: slot.slotId,
+      SHADER_PARAMETER_GROUP: shaderParams
+    };
   }
 
   pGetAttachmentSlots() {

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

@@ -115,7 +115,7 @@ export class Character2016 extends BaseFullCharacter {
   /** Used to update the status of the players resources */
   resourcesUpdater?: any;
   factionId = 2;
-  //isInInventory: boolean = false;
+  isInInventory: boolean = false;
   playTime: number = 0;
   lastDropPlaytime: number = 0;
   set godMode(state: boolean) {

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

@@ -45,7 +45,7 @@ function getRenderDistance(itemDefinitionId: number) {
       range = 420;
       break;
   }
-  return range;
+  return range ? range : 1000;
 }
 
 import { BaseLightweightCharacter } from "./baselightweightcharacter";

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

@@ -42,7 +42,7 @@ import { LoadoutContainer } from "../classes/loadoutcontainer";
 
 export class Npc extends BaseFullCharacter {
   health: number;
-  npcRenderDistance = 80;
+  npcRenderDistance = 100;
   spawnerId: number;
   deathTime: number = 0;
   npcId: number = 0;

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

@@ -90,7 +90,7 @@ export class TrapEntity extends BaseSimpleNpc {
       case Items.PUNJI_STICK_ROW:
         this.server.aiManager.addEntity(this);
         this.cooldown = 500;
-        this.triggerRadiusX = 1;
+        this.triggerRadiusX = 0.8;
         this.triggerRadiusY = 0.5;
         break;
       case Items.SNARE:

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

@@ -373,6 +373,7 @@ export class Vehicle2016 extends BaseLootableEntity {
         break;
       }
     }
+    server.aiManager.addEntity(this);
   }
 
   getSeatCount() {
@@ -1344,6 +1345,7 @@ export class Vehicle2016 extends BaseLootableEntity {
     // TODO: Have to revisit when the heightmap is implemented server side.
     // fix floating vehicle lootbags
     server.worldObjectManager.createLootbag(server, this);
+    server.aiManager.removeEntity(this);
     return deleted;
   }
 

package/src/servers/ZoneServer2016/handlers/commands/commands.ts

@@ -124,6 +124,7 @@ export const commands: Array<Command> = [
       client: Client,
       args: Array<string>
     ) => {
+      if (server._soloMode) return;
       const collection = server._db.collection(DB_COLLECTIONS.KILLS);
       const query = await collection
         .aggregate([
@@ -343,6 +344,74 @@ export const commands: Array<Command> = [
       );
     }
   },
+  {
+    name: "findloot",
+    permissionLevel: PermissionLevels.MODERATOR,
+    execute: (server: ZoneServer2016, client: Client, args: Array<string>) => {
+      if (!args[0] || !args[1]) {
+        server.sendChatText(client, "[ERROR] Usage /findloot [itemId] [range]");
+        return;
+      }
+      let totalCount = 0;
+      for (const a in server._lootableConstruction) {
+        const lootableConstrucion = server._lootableConstruction[a];
+        if (
+          !isPosInRadius(
+            Number(args[1]),
+            client.character.state.position,
+            lootableConstrucion.state.position
+          )
+        )
+          continue;
+        let count = 0;
+        for (const b in lootableConstrucion._containers) {
+          const container = lootableConstrucion._containers[b];
+          for (const c in container.items) {
+            const item = container.items[c];
+            if (item.itemDefinitionId == Number(args[0])) {
+              count += item.stackCount;
+              totalCount += item.stackCount;
+            }
+          }
+        }
+        if (count) {
+          server.sendChatText(
+            client,
+            `COUNT: ${count} POSITION: [ ${lootableConstrucion.state.position[0]} ${lootableConstrucion.state.position[1]} ${lootableConstrucion.state.position[2]} ]`
+          );
+        }
+      }
+      for (const a in server._worldLootableConstruction) {
+        const lootableConstrucion = server._worldLootableConstruction[a];
+        if (
+          !isPosInRadius(
+            Number(args[1]),
+            client.character.state.position,
+            lootableConstrucion.state.position
+          )
+        )
+          continue;
+        let count = 0;
+        for (const b in lootableConstrucion._containers) {
+          const container = lootableConstrucion._containers[b];
+          for (const c in container.items) {
+            const item = container.items[c];
+            if (item.itemDefinitionId == Number(args[0])) {
+              count += item.stackCount;
+              totalCount += item.stackCount;
+            }
+          }
+        }
+        if (count) {
+          server.sendChatText(
+            client,
+            `COUNT: ${count} POSITION: [ ${lootableConstrucion.state.position[0]} ${lootableConstrucion.state.position[1]} ${lootableConstrucion.state.position[2]} ]`
+          );
+        }
+      }
+      server.sendChatText(client, `TOTAL COUNT: ${totalCount}`);
+    }
+  },
   {
     name: "netstats",
     permissionLevel: PermissionLevels.DEFAULT,

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

@@ -171,14 +171,15 @@ export class CraftManager {
       return true;
 
     const item: any = itemDS.item;
-    if (item?.stackCount - count <= 0) {
+    const remainder = item?.stackCount - count;
+    if (remainder <= 0) {
       return server.deleteEntity(item.ownerCharacterId, server._spawnedItems);
-    } else if (item?.stackCount) {
-      const e = server.getEntity(item.ownerCharacterId);
-      if (e && e instanceof ItemObject) {
-        e.item.stackCount -= count;
-        return true;
-      }
+    }
+
+    const entity = server.getEntity(item.ownerCharacterId);
+    if (entity instanceof ItemObject) {
+      entity.item.stackCount -= count;
+      return true;
     }
 
     return false;