h1z1-server 0.47.2-3 → 0.47.2-4

package/data/2016/dataSources/AllowedFileHashes.json

@@ -1025,21 +1025,26 @@
   },
   {
     "file_name": "Assets_256.pack",
-    "crc32_hash": "600179b5",
-    "old_crc32_hash": "47ce5604"
+    "crc32_hash": "396f3599"
   },
   {
     "file_name": "Assets_257.pack",
-    "crc32_hash": "329599bc",
-    "old_crc32_hash": "bc999532"
+    "crc32_hash": "bc999532"
   },
   {
     "file_name": "Assets_258.pack",
-    "crc32_hash": "7f2a6b5b",
-    "old_crc32_hash": "5b6b2a7f"
+    "crc32_hash": "5b6b2a7f"
   },
   {
     "file_name": "Assets_259.pack",
-    "crc32_hash": "83625ea7"
+    "crc32_hash": "a75e6283"
+  },
+  {
+    "file_name": "Assets_260.pack",
+    "crc32_hash": "7b106055"
+  },
+  {
+    "file_name": "Assets_261.pack",
+    "crc32_hash": "bfdc08a2"
   }
 ]

package/data/2016/zoneData/Z1_POIs.json

@@ -28,7 +28,32 @@
         [ -640.54, -887.64 ],
         [ -390.89, -589.56 ],
         [ -320.35, -672.29 ]
+      ],
+      [
+        [ -645.47, -1064.84 ],
+        [ -608.10, -1129.32 ],
+        [ -497.60, -1098.69 ],
+        [ -643.53, -1001.91 ]
+      ],
+      [
+        [ -663.98, -1029.62 ],
+        [ -508.54, -1076.45 ],
+        [ -510.59, -943.35 ],
+        [ -632.18, -914.25 ]
+      ],
+      [
+        [ -186.76, -257.98 ],
+        [ -275.67, -258.77 ],
+        [ -290.84, -384.00 ],
+        [ -228.99, -432.44 ]
+      ],
+      [
+        [ -171.77, -361.53 ],
+        [ -180.44, -261.37 ],
+        [ 278.91, -261.43 ],
+        [ 317.98, -370.07 ]
       ]
+
     ],
     "position": [
       -33.53,
@@ -68,7 +93,14 @@
         [ -577.3099975585938, -1889.8499755859375 ],
         [ -577.2699890136719, -1423.489990234375 ],
         [ -802.4400024414062, -1423.9599609375 ]
+      ],
+      [
+        [ -760.92, -1881.45 ],
+        [ -668.07, -1883.43 ],
+        [ -670.22, -1949.24 ],
+        [ -754.64, -1953.45 ]
       ]
+
     ],
     "shackBounds": [
       [
@@ -96,6 +128,18 @@
         [ -1547.49, 1569.51 ],
         [ -1572.25, 2142.52 ],
         [ -1020.29, 2169.41 ]
+      ],
+      [
+        [ -1533.59, 2196.56 ],
+        [ -1647.51, 2192.82 ],
+        [ -1685.52, 2027.15 ],
+        [ -1533.23, 1970.22 ]
+      ],
+      [
+        [ -1528.96, 1971.86 ],
+        [ -1522.09, 1722.79 ],
+        [ -1661.44, 1715.26 ],
+        [ -1680.73, 2059.90 ]
       ]
     ],
     "position": [
@@ -156,7 +200,14 @@
         [ 998.58, 3052.92 ],
         [ 772.8, 3238.51 ],
         [ 893.14, 3351.8 ]
+      ],
+      [
+        [ 2126.06, -969.45 ],
+        [ 2125.57, -1064.08 ],
+        [ 2104.45, -1062.47 ],
+        [ 2104.54, -964.39 ]
       ]
+
     ],
     "position": [
       903.74,
@@ -306,6 +357,12 @@
         [ 2538.46, 2625.97 ],
         [ 2534.93, 2524.98 ],
         [ 2679.31, 2521.07 ]
+      ],
+      [
+        [ 2021.53, 2063.35 ],
+        [ 2025.37, 1999.75 ],
+        [ 1902.34, 1996.83 ],
+        [ 1899.32, 2065.72 ]
       ]
 
     ],
@@ -369,8 +426,14 @@
       [
         [ 2013.54, -2982.74 ],
         [ 1966.49, -2661.38 ],
-        [ 1600.39, -2674.76],
+        [ 1600.39, -2674.76 ],
         [ 1615.91, -2992.76 ]
+      ],
+      [
+        [ 1081.65, -2732.82 ],
+        [ 1017.16, -2729.49 ],
+        [ 1012.64, -2604.85 ],
+        [ 1088.91, -2589.99 ]
       ]
     ],
     "position": [
@@ -411,7 +474,11 @@
         [ -2966.89990234375, -2243.929931640625 ],
         [ -3218.27001953125, -2242.27001953125 ],
         [ -3198.72998046875, -1979.6300048828125 ]
-      ]
+      ],
+        [ 2260.40, -1096.56 ],
+        [ 2064.92, -1095.95 ],
+        [ 2062.23, -930.79 ],
+        [ 2266.02, -932.53 ]
     ],
     "position": [
       -3102.32,
@@ -452,4 +519,5 @@
       1
     ]
   }
+
 ]

package/package.json

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

package/src/servers/SoeServer/soeclient.ts

@@ -40,7 +40,6 @@ 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;
@@ -59,8 +58,6 @@ 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;
@@ -74,7 +71,7 @@ export default class SOEClient {
     } else {
       this.outputStream = new SOEOutputStream(cryptoKey);
     }
-    this._statsResetTimer = setInterval(() => this._resetStats(), 10000);
+    this._statsResetTimer = setInterval(() => this._resetStats(), 60000);
   }
   static getClientId(remote: RemoteInfo): string {
     return remote.address + ":" + remote.port;
@@ -83,78 +80,26 @@ 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 { totalLogicalPacketSent, packetResend, packetsOutOfOrder } =
-      this.stats;
-    const totalPackets = totalLogicalPacketSent + packetResend;
-
+    const {
+      totalPhysicalPacketSent: totalPacketSent,
+      packetResend,
+      packetsOutOfOrder
+    } = this.stats;
+    const packetLossRate =
+      Number((packetResend / totalPacketSent).toFixed(3)) * 100;
     const packetOutOfOrderRate =
-      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++;
-    }
-
+      Number((packetsOutOfOrder / totalPacketSent).toFixed(3)) * 100;
     return [
-      `Packet loss rate: ${packetLoss}%`,
-      `Out-of-order rate: ${packetOutOfOrderRate}%`,
-      `Avg ping: ${this.avgPing}ms`,
-      `Wait Time: ${this.getDynamicWaitTime().toFixed(2)}ms`
+      `Packet loss rate ${packetLossRate}%`,
+      `Packet outOfOrder rate ${packetOutOfOrderRate}%`,
+      `Avg ping ${this.avgPing}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 = 2;
-  keepAliveTimeoutTime: number = 30000;
+  _waitTimeMs: number = 24;
+  keepAliveTimeoutTime: number = 40000;
   private readonly _maxMultiBufferSize: number;
   private _resendTimeout: number = 250;
   private _maxResentTries: number = 24;
@@ -95,25 +95,6 @@ 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
@@ -155,50 +136,48 @@ export class SOEServer extends EventEmitter {
     }
   }
 
-  // Get an array of packets that need to be resent
+  // Get an array of packet that we need to resend
   getResends(client: Client): LogicalPacket[] {
     const currentTime = Date.now();
     const resends: LogicalPacket[] = [];
-    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);
-
+    const resendedSequences: Set<number> = new Set();
     for (const [sequence, time] of client.unAckData) {
-      if (time + getResendTimeout() < currentTime) {
+      // if the packet is too old then we resend it
+      if (time + this._resendTimeout + client.avgPing < 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, data: dataCache.data }
+            { sequence: 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
         }
       }
     }
 
-    // Accelerated resends for out-of-order packets
+    // check for possible accerated resends
     for (const sequence of client.outputStream.outOfOrder) {
-      if (sequence < lastAck) continue;
-      for (let index = lastAck; index < sequence; index++) {
+      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 (
           client.outputStream.outOfOrder.has(index) ||
           resendedSequences.has(index)
@@ -214,13 +193,16 @@ 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;
   }
 
@@ -314,10 +296,9 @@ 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);
-      }, waitTime);
+      }, this._waitTimeMs + additonalTime);
     }
   }
 
@@ -395,6 +376,7 @@ 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;
@@ -585,17 +567,18 @@ export class SOEServer extends EventEmitter {
     return appPackets;
   }
   private sendingProcess(client: Client) {
-    // Clear any pending sending timer
+    // If there is a pending sending timer then we clear it
     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 {
-        let waitingQueuePacket = this.getClientWaitQueuePacket(
+        const waitingQueuePacket = this.getClientWaitQueuePacket(
           client,
           client.waitingQueue
         );
@@ -605,6 +588,7 @@ 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);
         }
       }
@@ -615,48 +599,55 @@ export class SOEServer extends EventEmitter {
       client.delayedLogicalPackets.push(...appPackets);
     }
 
-    // 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 (client.delayedLogicalPackets.length > 0) {
+      for (
+        let index = 0;
+        index < client.delayedLogicalPackets.length;
+        index++
+      ) {
+        const packet = client.delayedLogicalPackets.shift();
+        if (!packet) {
+          break;
         }
         if (this._canBeBufferedIntoQueue(packet, client.waitingQueue)) {
           client.waitingQueue.addPacket(packet);
         } else {
-          this._sendAndBuildPhysicalPacket(client, packet);
+          // 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);
+          }
         }
       }
     }
-    // Handle ack packet
     const ackPacket = this.getAck(client);
     if (ackPacket) {
       client.stats.totalLogicalPacketSent++;
       if (this._canBeBufferedIntoQueue(ackPacket, client.waitingQueue)) {
         client.waitingQueue.addPacket(ackPacket);
       } else {
-        let waitingQueuePacket = this.getClientWaitQueuePacket(
+        const waitingQueuePacket = this.getClientWaitQueuePacket(
           client,
           client.waitingQueue
         );
         if (waitingQueuePacket) {
           this._sendAndBuildPhysicalPacket(client, waitingQueuePacket);
         }
-        // Ack packets are always small enough to fit after clearing
+        // no additionnal check needed here because ack packets have a fixed size
         client.waitingQueue.addPacket(ackPacket);
       }
     }
-
-    // Send any remaining packets in the waiting queue
-    let waitingQueuePacket = this.getClientWaitQueuePacket(
+    // if there is still some packets in the queue then we send them
+    const waitingQueuePacket = this.getClientWaitQueuePacket(
       client,
       client.waitingQueue
     );
@@ -664,11 +655,6 @@ 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/handlers/commands/commands.ts

@@ -1554,6 +1554,8 @@ export const commands: Array<Command> = [
     execute: (server: ZoneServer2016, client: Client, args: Array<string>) => {
       const direction = (args[0] || "up").toLowerCase(); // Default direction is "up"
       const heightInput = args[1];
+      const playerName = args[2]; // Optional player name
+
       const height = heightInput !== undefined ? parseFloat(heightInput) : 50;
       if (isNaN(height)) {
         server.sendChatText(
@@ -1562,7 +1564,24 @@ export const commands: Array<Command> = [
         );
         return;
       }
-      const newPosition = new Float32Array(client.character.state.position);
+
+      // Determine target client
+      let targetClient = client;
+      if (playerName) {
+        const foundClient = server.getClientByNameOrLoginSession(playerName);
+        if (server.playerNotFound(client, playerName, foundClient)) {
+          return;
+        }
+        if (!foundClient || !(foundClient instanceof Client)) {
+          server.sendChatText(client, "Client not found.");
+          return;
+        }
+        targetClient = foundClient;
+      }
+
+      const newPosition = new Float32Array(
+        targetClient.character.state.position
+      );
       switch (direction) {
         case "up":
           newPosition[1] += height;
@@ -1577,11 +1596,20 @@ export const commands: Array<Command> = [
           );
           return;
       }
-      server.sendData(client, "ClientUpdate.UpdateLocation", {
+
+      server.sendData(targetClient, "ClientUpdate.UpdateLocation", {
         position: newPosition,
         triggerLoadingScreen: false
       });
-      server.sendChatText(client, `Moved ${direction} by ${height}`);
+
+      if (targetClient === client) {
+        server.sendChatText(client, `Moved ${direction} by ${height}`);
+      } else {
+        server.sendChatText(
+          client,
+          `Moved ${targetClient.character.name} ${direction} by ${height}`
+        );
+      }
     }
   },
   {

package/src/servers/ZoneServer2016/zonepackethandlers.ts

@@ -324,18 +324,6 @@ export class ZonePacketHandlers {
     if (!server.hookManager.checkHook("OnClientFinishedLoading", client)) {
       return;
     }
-
-    if (!client.firstLoading) {
-      setTimeout(() => {
-        const soeClient = server._gatewayServer._soeServer.getSoeClient(
-          client.soeClientId
-        );
-        if (soeClient) {
-          soeClient.finishedLoading = true;
-        }
-      }, 5000);
-    }
-
     if (client.character.awaitingTeleportLocation) {
       const awaitingPos = client.character.awaitingTeleportLocation;
       setTimeout(() => {
@@ -903,59 +891,43 @@ export class ZonePacketHandlers {
     client: Client,
     packet: ReceivedPacket<ClientUpdateMonitorTimeDrift>
   ) {
-    const soeClient = server._gatewayServer._soeServer.getSoeClient(
-      client.soeClientId
-    );
-    if (!soeClient) return;
-
-    const packetLoss = soeClient.getNetworkQuality();
-    if (packetLoss == undefined) return;
-
-    const name = client.character.name;
-
-    // Lock weapon if packet loss is too high
+    /*const message = packet.data.message || "";
     if (
-      !client.isWeaponLock &&
-      packetLoss >= server.maxPacketLoss &&
-      !server.isSaving
+      packet.data.file ===
+        server.fairPlayManager.fairPlayValues?.requiredFile2 &&
+      //!client.clientLogs.includes(packet.data.message) && TODO: FIX THIS SINCE IT NEVER WORKED -Meme
+      !client.isAdmin
     ) {
-      client.isWeaponLock = true;
-      server.sendAlert(
-        client,
-        "Your network quality falls below acceptable standards. Your shots will not register"
-      );
-      for (const c of Object.values(server._clients)) {
-        if (c.isAdmin && c.isDebugMode) {
-          server.chatManager.sendChatText(
-            server,
-            c,
-            `Fairplay: ${name} network quality falls below acceptable standards`,
-            false
-          );
-        }
-      }
-      return;
-    }
-
-    // Unlock weapon if packet loss has improved
-    if (client.isWeaponLock && packetLoss < server.maxPacketLoss) {
-      if (soeClient.statsResettedRecently) return;
-      client.isWeaponLock = false;
-      server.sendAlert(
-        client,
-        "Your network quality has improved. Your shots will now register properly"
-      );
-      for (const c of Object.values(server._clients)) {
-        if (c.isAdmin && c.isDebugMode) {
-          server.chatManager.sendChatText(
-            server,
-            c,
-            `Fairplay: ${name} network quality has improved`,
+      const obj = { log: message, isSuspicious: false };
+      for (let x = 0; x < server.fairPlayManager._suspiciousList.length; x++) {
+        if (
+          message
+            .toLowerCase()
+            .includes(server.fairPlayManager._suspiciousList[x].toLowerCase())
+        ) {
+          obj.isSuspicious = true;
+          if (!server._soloMode) {
+            logClientActionToMongo(
+              server._db?.collection(DB_COLLECTIONS.FAIRPLAY) as Collection,
+              client,
+              server._worldId,
+              {
+                type: "suspicious software",
+                suspicious: server.fairPlayManager._suspiciousList[x]
+              }
+            );
+          }
+          server.sendChatTextToAdmins(
+            `FairPlay: kicking ${client.character.name} for using suspicious software - ${server.fairPlayManager._suspiciousList[x]}`,
             false
           );
+          server.kickPlayer(client);
+          break;
         }
       }
+      client.clientLogs.push(obj);
     }
+    debug(packet);*/
   }
   ClientLog(
     server: ZoneServer2016,