h1z1-server 0.47.2-9 → 0.47.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "h1z1-server",
-  "version": "0.47.2-9",
+  "version": "0.47.2",
   "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/shared.ts

@@ -1188,10 +1188,10 @@ export function packVehicleReferenceData(obj: any) {
 }
 
 export function generateOldInteractionComponent() {
-  const raw = [
-    0x00, 0x00, 0xa0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-  ];
-  return Buffer.from(raw);
+  const floatBuf = Buffer.allocUnsafe(4);
+  floatBuf.writeFloatLE(3.0, 0);
+  const raw = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+  return Buffer.concat([floatBuf, Buffer.from(raw)]);
 }
 export function generateOldNpcComponent() {
   const old = [
@@ -1214,18 +1214,19 @@ export function generateOldNpcComponent() {
   ];
   return Buffer.from([...old, ...raw]);
 }
-export function generateWorldItemRepData() {
+export function generateWorldItemRepData(nameId: number = 0) {
+  const data = Buffer.allocUnsafe(16);
+  data.writeUintLE(nameId, 12, 4);
   const raw = [
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x01
-    //                             /\  Set isWorldItem byte
+    0x00, 0x01
+    //     /\  Set isWorldItem byte
   ];
-  return Buffer.from(raw);
+  return Buffer.concat([data, Buffer.from(raw)]);
 }
 export function packComponentNameString(name: string) {
   const stringBuffer = Buffer.from(name, "ascii");

package/src/servers/LoginZoneConnection/shared/baselzconnection.ts

@@ -19,6 +19,7 @@ import dgram, { RemoteInfo } from "node:dgram";
 const debug = require("debug")("LZConnection");
 
 export abstract class BaseLZConnection extends EventEmitter {
+  _serverAddress: string;
   _serverPort?: number;
   _protocol: LZConnectionProtocol;
   _udpLength: number = 512;
@@ -29,6 +30,7 @@ export abstract class BaseLZConnection extends EventEmitter {
   _pingTimer!: NodeJS.Timeout;
   protected constructor(serverPort?: number) {
     super();
+    this._serverAddress = process.env.SERVER_BIND_ADDRESS || "0.0.0.0";
     this._serverPort = serverPort;
     this._protocol = new LZConnectionProtocol();
     this._connection = dgram.createSocket("udp4");
@@ -72,7 +74,7 @@ export abstract class BaseLZConnection extends EventEmitter {
     );
 
     return await new Promise((resolve) => {
-      this._connection.bind(this._serverPort, undefined, () => {
+      this._connection.bind(this._serverPort, this._serverAddress, () => {
         resolve();
       });
     });

package/src/servers/SoeServer/soeserver.ts

@@ -25,6 +25,8 @@ import { PacketsQueue } from "./PacketsQueue";
 const debug = require("debug")("SOEServer");
 
 export class SOEServer extends EventEmitter {
+  _serverAddress: string;
+  _serverAddressV6: string;
   _serverPort: number;
   _cryptoKey: Uint8Array;
   _protocol!: Soeprotocol;
@@ -50,6 +52,8 @@ export class SOEServer extends EventEmitter {
     const oneMb = 1024 * 1024;
     Buffer.poolSize = oneMb;
     this._serverPort = serverPort;
+    this._serverAddress = process.env.SERVER_BIND_ADDRESS || "0.0.0.0";
+    this._serverAddressV6 = process.env.SERVER_BIND_ADDRESS_V6 || "::";
     this._cryptoKey = cryptoKey;
     this._maxMultiBufferSize = this._udpLength - 4 - this._crcLength;
     this._connection = dgram.createSocket({
@@ -463,9 +467,9 @@ export class SOEServer extends EventEmitter {
     this._connectionv6.on("message", (data, remote) => {
       this.onMessage(data, remote);
     });
-    this._connection.bind(this._serverPort);
+    this._connection.bind(this._serverPort, this._serverAddress);
     if (!process.env.DISABLE_IPV6) {
-      this._connectionv6.bind(this._serverPort);
+      this._connectionv6.bind(this._serverPort, this._serverAddressV6);
     }
   }
 

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

@@ -119,6 +119,10 @@ export abstract class BaseFullCharacter extends BaseLightweightCharacter {
   gender: number;
   hoodState: string = "Up";
 
+  // Updates from constructionPermissionsManager, avoids checking all buildings every inventory access.
+  /** The guid of the building the character is inside of */
+  insideBuilding: string = "";
+
   /** The default items that will spawn on and with the BaseFullCharacter */
   defaultLoadout: LoadoutKit = [];
   constructor(

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

@@ -287,6 +287,10 @@ export class ConstructionChildEntity extends BaseLightweightCharacter {
         const p = position[1] + 2.4;
         this.boundsOn = getCubeBounds(position, 5, 5, angle, p, p + 1.8);
 
+        break;
+      case Items.METAL_DOORWAY:
+      case Items.METAL_WALL:
+        this.fixedPosition = movePoint(position, -(rotation[1] + 1.575), 2.5);
         break;
     }
 

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

@@ -17,7 +17,12 @@ import { ZoneServer2016 } from "../zoneserver";
 import { BaseItem } from "../classes/baseItem";
 import { BaseLightweightCharacter } from "./baselightweightcharacter";
 import { ZoneClient2016 } from "../classes/zoneclient";
-import { randomIntFromInterval } from "../../../utils/utils";
+import {
+  checkLineThroughDoorway,
+  randomIntFromInterval,
+  rotateAroundPivot,
+  wallInterceptsLine
+} from "../../../utils/utils";
 import {
   AddLightweightNpc,
   ClientUpdateProximateItems
@@ -25,6 +30,9 @@ import {
 import { LoadoutContainer } from "../classes/loadoutcontainer";
 import { BaseFullCharacter } from "./basefullcharacter";
 import { LOADOUT_CONTAINER_GUID } from "../../../utils/constants";
+import { ConstructionDoor } from "./constructiondoor";
+import { ConstructionParentEntity } from "./constructionparententity";
+import { ConstructionChildEntity } from "./constructionchildentity";
 
 // TODO find a better way to handle items not inside containers
 function transferItemObject(
@@ -129,6 +137,7 @@ export class ItemObject extends BaseLightweightCharacter {
   npcRenderDistance = 25;
   spawnerId = 0;
   item: BaseItem;
+  insideBuilding: string = "";
   isWorldItem: boolean = false;
   creationTime: number = 0;
   triggerExplosionShots = Math.floor(Math.random() * 3) + 2; // random number 2-4 neccesary shots
@@ -224,6 +233,130 @@ export class ItemObject extends BaseLightweightCharacter {
     }
   }
 
+  checkBuildingObstruct(
+    server: ZoneServer2016,
+    character: Float32Array,
+    foundation: ConstructionParentEntity | undefined
+  ): boolean {
+    const charPos = new Float32Array(character);
+
+    const itemPos = this.state.position;
+    charPos[1] += 1.8;
+
+    const charInFoundation: boolean =
+      foundation instanceof ConstructionParentEntity;
+
+    if (!charInFoundation) {
+      foundation =
+        server._constructionFoundations[this.insideBuilding] ??
+        server._constructionSimple[this.insideBuilding]?.getParent(server);
+    }
+
+    if (!foundation) return false;
+
+    if (
+      foundation.itemDefinitionId == Items.SHACK ||
+      foundation.itemDefinitionId == Items.SHACK_BASIC || // TODO
+      foundation.itemDefinitionId == Items.SHACK_SMALL
+    ) {
+      if (!foundation.isSecured) return false;
+
+      if (charInFoundation && foundation.isInside(itemPos)) return false;
+
+      return true;
+    }
+
+    if (
+      foundation.itemDefinitionId != Items.FOUNDATION_EXPANSION &&
+      foundation.itemDefinitionId != Items.FOUNDATION &&
+      foundation.itemDefinitionId != Items.GROUND_TAMPER
+    ) {
+      return false;
+    }
+
+    if (foundation.itemDefinitionId == Items.FOUNDATION_EXPANSION)
+      foundation = foundation.getParentFoundation(server);
+
+    if (!foundation) return false;
+
+    const allShelters = {
+      ...foundation.occupiedShelterSlots,
+      ...Object.assign(
+        {},
+        ...Object.values(foundation.occupiedExpansionSlots).map(
+          (exp) => exp.occupiedShelterSlots
+        )
+      )
+    };
+
+    const allWalls = {
+      ...foundation.occupiedWallSlots,
+      ...Object.assign(
+        {},
+        ...Object.values(foundation.occupiedExpansionSlots).map(
+          (exp) => exp.occupiedWallSlots
+        )
+      )
+    };
+
+    for (const w in allWalls) {
+      const wall = allWalls[w];
+      const wallStart = new Float32Array<ArrayBufferLike>(wall.state.position);
+      let wallEnd = new Float32Array(wall.fixedPosition);
+
+      wallEnd[0] = 2 * wallEnd[0] - wallStart[0]; // doorEnd is currently the midpoint
+      wallEnd[2] = 2 * wallEnd[2] - wallStart[2]; // extend it to the end
+      wallEnd[1] += 3.5;
+
+      if (wall instanceof ConstructionDoor && wall.isOpen)
+        wallEnd = rotateAroundPivot(wallStart, wallEnd, -Math.PI / 2);
+
+      if (wallInterceptsLine(charPos, itemPos, wallStart, wallEnd)) {
+        if (
+          wall.itemDefinitionId == Items.METAL_DOORWAY &&
+          checkLineThroughDoorway(charPos, itemPos, wall)
+        )
+          continue;
+        else return true;
+      }
+    }
+
+    for (const s in allShelters) {
+      const shelter: ConstructionChildEntity = allShelters[s];
+
+      if (!shelter.cubebounds) continue;
+      const walls: [Float32Array, Float32Array][] = [
+        [
+          new Float32Array(shelter.cubebounds[0]),
+          new Float32Array(shelter.cubebounds[5])
+        ],
+
+        [
+          new Float32Array(shelter.cubebounds[1]),
+          new Float32Array(shelter.cubebounds[6])
+        ],
+
+        [
+          new Float32Array(shelter.cubebounds[2]),
+          new Float32Array(shelter.cubebounds[7])
+        ],
+
+        [
+          new Float32Array(shelter.cubebounds[3]),
+          new Float32Array(shelter.cubebounds[4])
+        ]
+      ];
+
+      for (const wall of walls) {
+        if (wallInterceptsLine(charPos, itemPos, ...wall)) {
+          return !checkLineThroughDoorway(charPos, itemPos, shelter);
+        }
+      }
+    }
+
+    return false;
+  }
+
   OnInteractionString(server: ZoneServer2016, client: ZoneClient2016): void {
     server.sendData(client, "Command.InteractionString", {
       guid: this.characterId,

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

@@ -2418,9 +2418,11 @@ export class ConstructionManager {
     client: Client
   ) {
     let hide = false;
-
+    client.character.insideBuilding = "";
     for (const object of client.spawnedEntities) {
       if (object instanceof ConstructionParentEntity) {
+        if (object.isInside(client.character.state.position))
+          client.character.insideBuilding = object.characterId;
         if (this.checkFoundationPermission(server, client, object)) {
           hide = true;
           continue;
@@ -2428,6 +2430,8 @@ export class ConstructionManager {
       }
 
       if (object instanceof ConstructionChildEntity) {
+        if (object.isInside(client.character.state.position))
+          client.character.insideBuilding = object.characterId;
         if (
           this.checkConstructionChildEntityPermission(server, client, object)
         ) {

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

@@ -21,6 +21,7 @@ import { BaseItem } from "../classes/baseItem";
 import { BaseLootableEntity } from "../entities/baselootableentity";
 import { ChallengeType } from "./challengemanager";
 import { ItemObject } from "../entities/itemobject";
+import { ClientUpdateProximateItems } from "types/zone2016packets";
 const debug = require("debug")("ZoneServer");
 
 interface CraftComponentDSEntry {
@@ -179,6 +180,13 @@ export class CraftManager {
     const entity = server.getEntity(item.ownerCharacterId);
     if (entity instanceof ItemObject) {
       entity.item.stackCount -= count;
+      const client = server.getClientByCharId(itemDS.character.characterId);
+      if (!client) return true;
+      server.sendData<ClientUpdateProximateItems>(
+        client,
+        "ClientUpdate.ProximateItems",
+        server.getProximityItems(client)
+      );
       return true;
     }
 

package/src/servers/ZoneServer2016/zoneserver.ts

@@ -261,6 +261,7 @@ import { ChallengeManager, ChallengeType } from "./managers/challengemanager";
 import { RandomEventsManager } from "./managers/randomeventsmanager";
 import { AiManager } from "./managers/aimanager";
 import { AirdropManager } from "./managers/airdropmanager";
+import { generateWorldItemRepData } from "../../packets/ClientProtocol/ClientProtocol_1080/shared";
 //import { TaskManager } from "./managers/tasksmanager";
 
 const spawnLocations2 = require("../../../data/2016/zoneData/Z1_gridSpawns.json"),
@@ -1297,17 +1298,37 @@ export class ZoneServer2016 extends EventEmitter {
 
   getProximityItems(client: Client): ClientUpdateProximateItems {
     const proximityItems: ClientUpdateProximateItems = { items: [] };
+    let foundation: ConstructionParentEntity | undefined =
+      this._constructionFoundations[client.character.insideBuilding] ??
+      this._constructionSimple[
+        client.character.insideBuilding
+      ]?.getParentFoundation(this);
 
     for (const object of client.spawnedEntities) {
       if (object instanceof ItemObject) {
+        let yDistance = 1;
+        if (
+          client.character.state.position[1] <
+          object.state.position[1] - 0.5
+        ) {
+          yDistance = 1.8;
+        }
         if (
           isPosInRadiusWithY(
             this.proximityItemsDistance,
             client.character.state.position,
             object.state.position,
-            1
+            yDistance
           )
         ) {
+          if (
+            object.checkBuildingObstruct(
+              this,
+              client.character.state.position,
+              foundation
+            )
+          )
+            continue;
           const proximityItem = {
             itemDefinitionId: object.item.itemDefinitionId,
             associatedCharacterGuid: object.characterId,
@@ -4100,7 +4121,11 @@ export class ZoneServer2016 extends EventEmitter {
         transientId: entity.transientId,
         stringSize: "ClientNpcComponent".length,
         componentName: "ClientNpcComponent",
-        properties: [{}]
+        properties: [
+          {
+            bufferData: generateWorldItemRepData(entity.nameId)
+          }
+        ]
       }
     );
   }
@@ -6712,6 +6737,7 @@ export class ZoneServer2016 extends EventEmitter {
     );
 
     if (!obj) return;
+    obj.insideBuilding = character.insideBuilding;
     this.executeFuncForAllReadyClientsInRange((c) => {
       c.spawnedEntities.add(obj);
       this.addLightweightNpc(c, obj);

package/src/utils/utils.ts

@@ -33,6 +33,7 @@ import { Resolver } from "node:dns";
 import { ZoneClient2016 } from "servers/ZoneServer2016/classes/zoneclient";
 import * as crypto from "crypto";
 import { ZoneClient } from "servers/ZoneServer2015/classes/zoneclient";
+import { ConstructionDoor } from "../servers/ZoneServer2016/entities/constructiondoor";
 
 const startTime = Date.now();
 
@@ -319,6 +320,108 @@ export function getAngle(position1: Float32Array, position2: Float32Array) {
   return angle;
 }
 
+/**
+ * Rotates point around pivot by angle
+ *
+ * @param pivot - The pivot to rotate around
+ * @param point - The point that will be rotated
+ * @param angle - The angle to rotate
+ * @returns - A new point at the new position
+ */
+export function rotateAroundPivot(
+  pivot: Float32Array,
+  point: Float32Array,
+  angle: number
+): Float32Array {
+  // Calculate the vector from pivot
+  const vX = point[0] - pivot[0];
+  const vY = point[1] - pivot[1];
+  const vZ = point[2] - pivot[2];
+
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+
+  // Do matrix rotation and then add back the pivot
+  return new Float32Array([
+    pivot[0] + vX * cos - vZ * sin,
+    pivot[1] + vY,
+    pivot[2] + vX * sin + vZ * cos
+  ]);
+}
+
+/**
+ * Checks if a line goes through a open or missing door slot.
+ *
+ * @param a1 - The first point of the line
+ * @param a2 - The second point of the line
+ * @param doorway - The construction entity that has a door.
+ * @returns - Boolean if the line passes through a open door or a door slot with no door.
+ */
+export function checkLineThroughDoorway(
+  a1: Float32Array,
+  a2: Float32Array,
+  doorway: ConstructionChildEntity
+): boolean {
+  const door = doorway.occupiedWallSlots[1];
+  if (door && door instanceof ConstructionDoor && !door.isOpen) return false;
+  let doorEnd: Float32Array;
+  let doorStart: Float32Array;
+
+  if (door instanceof ConstructionDoor && door.isOpen) {
+    doorEnd = new Float32Array(door.fixedPosition);
+    doorStart = new Float32Array(door.state.position);
+  } else {
+    // No door, calculate the door slot
+    const rotation = doorway.getSlotRotation(1, doorway.wallSlots);
+    doorStart = new Float32Array(
+      doorway.getSlotPosition(1, doorway.wallSlots)!
+    );
+    doorEnd = movePoint(doorStart!, -(rotation![1] + 1.575), 0.625);
+  }
+
+  doorEnd[0] = 2 * doorEnd[0] - doorStart[0]; // doorEnd is currently the midpoint
+  doorEnd[2] = 2 * doorEnd[2] - doorStart[2]; // extend it to the end
+  doorEnd[1] += 2;
+  doorStart![1] -= 0.5;
+  return wallInterceptsLine(a1, a2, doorStart!, doorEnd);
+}
+
+/**
+ * Check if the wall defined by b1, b2 is between the line a1, a2
+ *
+ * @param a1 - The first point of the line
+ * @param a2 - The second point of the line
+ * @param b1 - The bottom left corner of the wall
+ * @param b2 - The top right corner of the wall
+ * @returns - A boolean if the line is intercepted by the wall
+ */
+export function wallInterceptsLine(
+  a1: Float32Array,
+  a2: Float32Array,
+  b1: Float32Array,
+  b2: Float32Array
+): boolean {
+  b1[1] -= 0.5; // extend the plane down a bit
+
+  const orient = (p: Float32Array, q: Float32Array, r: Float32Array) =>
+    (q[0] - p[0]) * (r[2] - p[2]) - (q[2] - p[2]) * (r[0] - p[0]);
+
+  const o1 = orient(a1, a2, b1);
+  const o2 = orient(a1, a2, b2);
+  const o3 = orient(b1, b2, a1);
+  const o4 = orient(b1, b2, a2);
+
+  const intersects2D = o1 * o2 < 0 && o3 * o4 < 0;
+  if (!intersects2D) return false;
+
+  const lineMinY = Math.min(a1[1], a2[1]);
+  const lineMaxY = Math.max(a1[1], a2[1]);
+  const wallMinY = Math.min(b1[1], b2[1]);
+  const wallMaxY = Math.max(b1[1], b2[1]);
+
+  return lineMaxY >= wallMinY && lineMinY <= wallMaxY;
+}
+
 /**
  * Shuts down the zone server with a countdown timer and performs necessary cleanup operations.
  *