@nativewrappers/common-game 0.0.125 → 0.0.127

package/common/net/NetworkedMap.js

@@ -0,0 +1,225 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GlobalData } from "../GlobalData";
+class NetworkedMapEventManager {
+  static {
+    __name(this, "NetworkedMapEventManager");
+  }
+  #syncedCalls = /* @__PURE__ */ new Map();
+  constructor() {
+    $SERVER: if (GlobalData.IS_SERVER) {
+      on("playerDropped", () => {
+        const src = source;
+        for (const [_k, map] of this.#syncedCalls) {
+          map.removeSubscriber(src);
+        }
+      });
+      return;
+    }
+    $CLIENT: {
+      RegisterResourceAsEventHandler(`${GlobalData.CurrentResource}:syncChanges`);
+      addRawEventListener(`${GlobalData.CurrentResource}:syncChanges`, (msgpack_data) => {
+        const data = msgpack_unpack(msgpack_data);
+        const syncName = data[0];
+        const syncData = data[1];
+        const map = this.#syncedCalls.get(syncName);
+        if (!map) {
+          throw new Error(`Tried to sync changes for a networked map but ${syncName} does't exist.`);
+        }
+        map.handleSync(syncData);
+      });
+    }
+  }
+  addNetworkedMap(map) {
+    this.#syncedCalls.set(map.SyncName, map);
+  }
+  removeNetworkedMap(syncName) {
+    this.#syncedCalls.delete(syncName);
+  }
+}
+const netManager = new NetworkedMapEventManager();
+class NetworkedMap extends Map {
+  static {
+    __name(this, "NetworkedMap");
+  }
+  #syncName;
+  #queuedChanges = [];
+  #changeListeners = /* @__PURE__ */ new Map();
+  #subscribers = /* @__PURE__ */ new Set();
+  constructor(syncName, initialValue) {
+    super(initialValue);
+    this.#syncName = syncName;
+    GlobalData.NetworkedTicks.push(this);
+    netManager.addNetworkedMap(this);
+    $SERVER: {
+      if (!GlobalData.NetworkTick && GlobalData.IS_SERVER) {
+        GlobalData.NetworkTick = setTick(() => {
+          for (const networkedThis of GlobalData.NetworkedTicks) {
+            networkedThis.networkTick();
+          }
+        });
+      }
+    }
+  }
+  get SyncName() {
+    return this.#syncName;
+  }
+  // handles removing the player from the map whenever they're dropped
+  onPlayerDropped() {
+    this.removeSubscriber(source);
+  }
+  /*
+   * Resyncs the entire map to the client, useful for if there's a mismatch in the clients map (when multiple players change things, in cases like inventories)
+   *
+   * NOTE: This doesn't check that the player is already subscribed to the map, you should do your own due-diligence to only call this for players already subscribed
+   */
+  resync(source2) {
+    const packed_data = msgpack_pack([this.#syncName, [[4 /* Init */, this.size === 0 ? [] : Array.from(this)]]]);
+    TriggerClientEventInternal(
+      `${GlobalData.CurrentResource}:syncChanges`,
+      source2,
+      packed_data,
+      packed_data.length
+    );
+  }
+  /*
+   * Adds a new subscriber to the map
+   */
+  addSubscriber(source2) {
+    this.#subscribers.add(source2);
+    this.resync(source2);
+  }
+  removeSubscriber(sub) {
+    return this.#subscribers.delete(sub);
+  }
+  hasSubscriber(sub) {
+    return this.#subscribers.has(sub);
+  }
+  subscriberCount() {
+    return this.#subscribers.size;
+  }
+  handleSync(data) {
+    for (const [change_type, key, value, possibly_undefined_subvalue] of data) {
+      switch (change_type) {
+        case 1 /* Add */: {
+          this.set(key, value);
+          continue;
+        }
+        case 2 /* Remove */: {
+          super.delete(key);
+          continue;
+        }
+        case 3 /* Reset */: {
+          super.clear();
+          continue;
+        }
+        case 4 /* Init */: {
+          super.clear();
+          const key_value = key;
+          for (const [k, v] of key_value) {
+            this.set(k, v);
+          }
+          continue;
+        }
+        case 0 /* SubValueChanged */: {
+          const data2 = this.get(key);
+          data2[value] = possibly_undefined_subvalue;
+          continue;
+        }
+      }
+    }
+  }
+  /*
+   * Listens for the change on the specified key, it will get the resulting
+   * value on the change
+   */
+  listenForChange(key, fn) {
+    const listener = this.#changeListeners.get(key);
+    listener ? listener.push(fn) : this.#changeListeners.set(key, [fn]);
+  }
+  #triggerEventForSubscribers(data) {
+    const packed_data = msgpack_pack([this.#syncName, data]);
+    for (const sub of this.#subscribers) {
+      TriggerClientEventInternal(
+        `${GlobalData.CurrentResource}:syncChanges`,
+        sub,
+        packed_data,
+        packed_data.length
+      );
+    }
+  }
+  #pushChangeForListener(key, value) {
+    const listener = this.#changeListeners.get(key);
+    if (!listener) return;
+    for (const ln of listener) {
+      ln(value);
+    }
+  }
+  set(key, value) {
+    let v = value;
+    if (value instanceof Object) {
+      const curMap = this;
+      const objectChangeHandler = {
+        get(target, prop, reciever) {
+          return Reflect.get(target, prop, reciever);
+        },
+        set(target, p, newValue, receiver) {
+          const success = Reflect.set(target, p, newValue, receiver);
+          if (success) {
+            curMap.#pushChangeForListener(key, target);
+            $SERVER: {
+              curMap.#queuedChanges.push([0 /* SubValueChanged */, key, p, newValue]);
+            }
+          }
+          return success;
+        }
+      };
+      v = new Proxy(v, objectChangeHandler);
+    }
+    super.set(key, v);
+    this.#pushChangeForListener(key, v);
+    $SERVER: {
+      this.#queuedChanges.push([1 /* Add */, key, v]);
+    }
+    return this;
+  }
+  /*
+   * Resets the map to its default state
+   */
+  clear() {
+    $CLIENT: if (GlobalData.IS_CLIENT) throw new Error(`Cannot call 'clear' on client`);
+    this.#queuedChanges = [];
+    this.#queuedChanges.push([3 /* Reset */]);
+    super.clear();
+  }
+  delete(key) {
+    $CLIENT: if (GlobalData.IS_CLIENT) throw new Error(`Cannot call 'delete' on client`);
+    this.#queuedChanges.push([2 /* Remove */, key]);
+    return super.delete(key);
+  }
+  networkTick() {
+    if (this.#queuedChanges.length !== 0) {
+      this.#triggerEventForSubscribers(this.#queuedChanges);
+      this.#queuedChanges = [];
+    }
+  }
+  [Symbol.dispose]() {
+    this.#subscribers.clear();
+    this.#changeListeners.clear();
+    this.#queuedChanges = [];
+    netManager.removeNetworkedMap(this.#syncName);
+    GlobalData.NetworkedTicks.filter((v) => v !== this);
+  }
+  /**
+   * Unregisters from the tick handler and removes the event listener
+   */
+  dispose() {
+    this[Symbol.dispose]();
+  }
+  get [Symbol.toStringTag]() {
+    return "NetworkedMap";
+  }
+}
+export {
+  NetworkedMap
+};

package/common/types.d.ts

@@ -0,0 +1,5 @@
+import type { Buffer } from "buffer";
+export type MsgpackBuffer = {
+    buffer: Buffer;
+    type: number;
+};

package/common/utils/ClassTypes.d.ts

@@ -0,0 +1,11 @@
+export declare enum ClassTypes {
+    Ped = 0,
+    Prop = 1,
+    Vehicle = 2,
+    Entity = 3,
+    Player = 4,
+    Vector2 = 5,
+    Vector3 = 6,
+    Vector4 = 7,
+    Quanterion = 8
+}

package/common/utils/ClassTypes.js

@@ -0,0 +1,15 @@
+var ClassTypes = /* @__PURE__ */ ((ClassTypes2) => {
+  ClassTypes2[ClassTypes2["Ped"] = 0] = "Ped";
+  ClassTypes2[ClassTypes2["Prop"] = 1] = "Prop";
+  ClassTypes2[ClassTypes2["Vehicle"] = 2] = "Vehicle";
+  ClassTypes2[ClassTypes2["Entity"] = 3] = "Entity";
+  ClassTypes2[ClassTypes2["Player"] = 4] = "Player";
+  ClassTypes2[ClassTypes2["Vector2"] = 5] = "Vector2";
+  ClassTypes2[ClassTypes2["Vector3"] = 6] = "Vector3";
+  ClassTypes2[ClassTypes2["Vector4"] = 7] = "Vector4";
+  ClassTypes2[ClassTypes2["Quanterion"] = 8] = "Quanterion";
+  return ClassTypes2;
+})(ClassTypes || {});
+export {
+  ClassTypes
+};

package/common/utils/Color.d.ts

@@ -0,0 +1,14 @@
+export declare class Color {
+    static Transparent: Color;
+    static Black: Color;
+    static White: Color;
+    static WhiteSmoke: Color;
+    static fromArgb(a: number, r: number, g: number, b: number): Color;
+    static fromRgb(r: number, g: number, b: number): Color;
+    static fromArray(primitive: [number, number, number] | number[]): Color;
+    a: number;
+    r: number;
+    g: number;
+    b: number;
+    constructor(r: number, g: number, b: number, a?: number);
+}

package/common/utils/Color.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Color {
+  static {
+    __name(this, "Color");
+  }
+  static Transparent = new Color(0, 0, 0, 0);
+  static Black = new Color(0, 0, 0);
+  static White = new Color(255, 255, 255);
+  static WhiteSmoke = new Color(245, 245, 245);
+  static fromArgb(a, r, g, b) {
+    return new Color(r, g, b, a);
+  }
+  static fromRgb(r, g, b) {
+    return new Color(r, g, b);
+  }
+  static fromArray(primitive) {
+    return new Color(primitive[0], primitive[1], primitive[2], 255);
+  }
+  a;
+  r;
+  g;
+  b;
+  constructor(r, g, b, a = 255) {
+    this.r = r;
+    this.g = g;
+    this.b = b;
+    this.a = a;
+  }
+}
+export {
+  Color
+};

package/common/utils/Delay.d.ts

@@ -0,0 +1 @@
+export declare const Delay: (ms: number) => Promise<void>;

package/common/utils/Delay.js

@@ -0,0 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const Delay = /* @__PURE__ */ __name((ms) => new Promise((res) => setTimeout(res, ms)), "Delay");
+export {
+  Delay
+};

package/common/utils/Maths.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class Maths {
+    static clamp(num: number, min: number, max: number): number;
+    static getRandomInt(min: number, max: number): number;
+}

package/common/utils/Maths.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Maths {
+  static {
+    __name(this, "Maths");
+  }
+  static clamp(num, min, max) {
+    return num <= min ? min : num >= max ? max : num;
+  }
+  static getRandomInt(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min)) + min;
+  }
+}
+export {
+  Maths
+};

package/common/utils/Point.d.ts

@@ -0,0 +1,9 @@
+export declare class Point {
+    static parse(arg: [number, number] | {
+        X: number;
+        Y: number;
+    } | string): Point;
+    X: number;
+    Y: number;
+    constructor(x?: number, y?: number);
+}

package/common/utils/Point.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Point {
+  static {
+    __name(this, "Point");
+  }
+  static parse(arg) {
+    let point = new Point();
+    if (arg) {
+      if (typeof arg === "object") {
+        if (Array.isArray(arg)) {
+          if (arg.length === 2) {
+            point = new Point(arg[0], arg[1]);
+          }
+        } else if (arg.X && arg.Y) {
+          point = new Point(arg.X, arg.Y);
+        }
+      } else {
+        if (arg.indexOf(",") !== -1) {
+          const arr = arg.split(",");
+          point = new Point(Number.parseFloat(arr[0]), Number.parseFloat(arr[1]));
+        }
+      }
+    }
+    return point;
+  }
+  X;
+  Y;
+  constructor(x = 0, y = 0) {
+    this.X = x;
+    this.Y = y;
+  }
+}
+export {
+  Point
+};

package/common/utils/PointF.d.ts

@@ -0,0 +1,7 @@
+export declare class PointF {
+    x: number;
+    y: number;
+    z: number;
+    static empty(): PointF;
+    constructor(x: number, y: number, z: number);
+}

package/common/utils/PointF.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class PointF {
+  constructor(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  static {
+    __name(this, "PointF");
+  }
+  static empty() {
+    return new PointF(0, 0, 0);
+  }
+}
+export {
+  PointF
+};

package/common/utils/Quaternion.d.ts

@@ -0,0 +1,10 @@
+import { Vector3 } from "./Vector";
+export declare class Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(value: number);
+    constructor(vector: Vector3, w: number);
+    constructor(x: number, y: number, z: number, w: number);
+}

package/common/utils/Quaternion.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./Vector";
+class Quaternion {
+  static {
+    __name(this, "Quaternion");
+  }
+  x;
+  y;
+  z;
+  w;
+  constructor(valueXOrVector, yOrW, z, w) {
+    if (valueXOrVector instanceof Vector3) {
+      this.x = valueXOrVector.x;
+      this.y = valueXOrVector.y;
+      this.z = valueXOrVector.z;
+      this.w = yOrW ?? 0;
+    } else if (yOrW === void 0) {
+      this.x = valueXOrVector;
+      this.y = valueXOrVector;
+      this.z = valueXOrVector;
+      this.w = valueXOrVector;
+    } else {
+      this.x = valueXOrVector;
+      this.y = yOrW;
+      this.z = z ?? 0;
+      this.w = w ?? 0;
+    }
+  }
+}
+export {
+  Quaternion
+};