@nativewrappers/common-game 0.0.114

package/entities/CommonPlayer.js

@@ -0,0 +1,156 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonPed } from "./CommonPed";
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { GameConstants } from "common-game/CommonGameConstants";
+import cfx from "common-game/cfx/cfx";
+import { GetEntityClassFromHandle } from "./GetEntityClassIdFromHandle";
+class CommonPlayer {
+  static {
+    __name(this, "CommonPlayer");
+  }
+  handle;
+  ped;
+  pvp = false;
+  stateBagCookies = [];
+  source;
+  type = ClassTypes.Player;
+  static *AllPlayers(excludeLocalPlayer = true) {
+    for (const ply of GetActivePlayers()) {
+      if (excludeLocalPlayer && ply === GameConstants.PlayerId) {
+        continue;
+      }
+      yield new CommonPlayer(ply);
+    }
+  }
+  /**
+   * @param handle the handoe of the ped to get the player of
+   * @returns the player, or null if the player doesn't exist
+   */
+  static fromPedHandle(handle) {
+    const playerHandle = NetworkGetPlayerIndexFromPed(handle);
+    if (!handle) {
+      return null;
+    }
+    return new CommonPlayer(playerHandle);
+  }
+  /**
+   * @param serverId the server id to get the player of
+   * @returns the player, or null if the player doesn't exist
+   */
+  static fromServerId(serverId) {
+    const player = GetPlayerFromServerId(serverId);
+    if (player === -1) {
+      return null;
+    }
+    return new CommonPlayer(player);
+  }
+  /**
+   * @param [minimumDistance=Number.MAX_VALUE] the minimum distance this should check
+   * @param [fromPlayer=GameConstants.Player] the player to get the distance from
+   * @returns the closest player from {@param fromPlayer} and the distance the player was
+   */
+  static getClosestPlayerPedWithDistance(minimumDistance = Number.MAX_VALUE, fromPlayer = GameConstants.Player) {
+    const ped = fromPlayer.Ped;
+    const pos = ped.Position;
+    const data = [null, Number.MAX_VALUE];
+    for (const ply of CommonPlayer.AllPlayers(true)) {
+      const tgtPed = ply.Ped;
+      const dist = pos.distance(tgtPed.Position);
+      if (dist < data[1] && dist < minimumDistance) {
+        data[0] = tgtPed;
+        data[1] = dist;
+      }
+    }
+    return data;
+  }
+  /**
+   * @param [minimumDistance=Number.MAX_VALUE] the minimum distance this should check
+   * @param [fromPlayer=GameConstants.Player] the player to get the distance from
+   * @returns the closest player from {@param fromPlayer} and the distance the player was
+   */
+  static getClosestPlayerPed(minimumDistance = Number.MAX_VALUE, fromPlayer = GameConstants.Player) {
+    const data = this.getClosestPlayerPedWithDistance(minimumDistance, fromPlayer);
+    return data[0];
+  }
+  /**
+   * @param handle the player handle, or if on the server, their source.
+   */
+  constructor(handle = -1) {
+    this.handle = handle;
+    this.source = this.ServerId;
+  }
+  get Handle() {
+    return this.handle;
+  }
+  /**
+   * This is here for compatibility with older versions.
+   */
+  get Character() {
+    return this.Ped;
+  }
+  get Ped() {
+    const handle = GetPlayerPed(this.handle);
+    if (typeof this.ped === "undefined" || handle !== this.ped.Handle) {
+      this.ped = new CommonPed(handle);
+    }
+    return this.ped;
+  }
+  get ServerId() {
+    if (this.source) {
+      return this.source;
+    }
+    return GetPlayerServerId(this.handle);
+  }
+  get State() {
+    return cfx.Player(this.ServerId).state;
+  }
+  AddStateBagChangeHandler(keyFilter, handler) {
+    const cookie = AddStateBagChangeHandler(keyFilter, `player:${this.ServerId}`, handler);
+    this.stateBagCookies.push(cookie);
+    return cookie;
+  }
+  /**
+   * A short hand function for AddStateBagChangeHandler, this gets automatically cleaned up on entity deletion.
+   * @param keyFilter the key to filter for or null
+   * @param handler the function to handle the change
+   * @returns a cookie to be used in RemoveStateBagChangeHandler
+   */
+  listenForStateChange(keyFilter, handler) {
+    return this.AddStateBagChangeHandler(keyFilter, handler);
+  }
+  removeStateListener(tgtCookie) {
+    this.stateBagCookies = this.stateBagCookies.filter((cookie) => {
+      const isCookie = cookie === tgtCookie;
+      if (isCookie) RemoveStateBagChangeHandler(cookie);
+      return isCookie;
+    });
+  }
+  removeAllStateListeners() {
+    for (const cookie of this.stateBagCookies) {
+      RemoveStateBagChangeHandler(cookie);
+    }
+  }
+  get Name() {
+    return GetPlayerName(this.handle);
+  }
+  get IsDead() {
+    return IsPlayerDead(this.handle);
+  }
+  set DisableFiring(value) {
+    DisablePlayerFiring(this.handle, value);
+  }
+  get EntityPlayerIsAimingAt() {
+    const [entityHit, entity] = GetEntityPlayerIsFreeAimingAt(this.handle);
+    if (entityHit) {
+      return GetEntityClassFromHandle(entity);
+    }
+    return null;
+  }
+  get StealthNoise() {
+    return GetPlayerCurrentStealthNoise(this.handle);
+  }
+}
+export {
+  CommonPlayer
+};

package/entities/CommonProp.d.ts

@@ -0,0 +1,16 @@
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonEntityBoneCollection } from "./CommonEntityBoneCollection";
+import type { CommonEntity } from "./CommonEntityType";
+export declare class CommonProp extends CommonBaseEntity {
+    static exists(prop: CommonProp): boolean;
+    static fromHandle(handle: number): CommonProp | null;
+    static fromNetworkId(networkId: number): CommonProp | null;
+    protected type: ClassTypes;
+    protected bones?: CommonEntityBoneCollection | undefined;
+    constructor(handle: number);
+    exists(): boolean;
+    placeOnGround(): void;
+    getEntityAttachedTo(): CommonEntity;
+    get Bones(): CommonEntityBoneCollection;
+}

package/entities/CommonProp.js

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonEntityBoneCollection } from "./CommonEntityBoneCollection";
+import { GetEntityClassFromHandle } from "./GetEntityClassIdFromHandle";
+class CommonProp extends CommonBaseEntity {
+  static {
+    __name(this, "CommonProp");
+  }
+  static exists(prop) {
+    return typeof prop !== "undefined" && prop.exists();
+  }
+  static fromHandle(handle) {
+    return new this(handle);
+  }
+  static fromNetworkId(networkId) {
+    if (!NetworkDoesEntityExistWithNetworkId(networkId)) {
+      return null;
+    }
+    return new this(NetworkGetEntityFromNetworkId(networkId));
+  }
+  type = ClassTypes.Prop;
+  bones;
+  constructor(handle) {
+    super(handle);
+  }
+  exists() {
+    return super.exists() && GetEntityType(this.handle) === 3;
+  }
+  placeOnGround() {
+    PlaceObjectOnGroundProperly(this.handle);
+  }
+  getEntityAttachedTo() {
+    return GetEntityClassFromHandle(this.handle);
+  }
+  get Bones() {
+    if (!this.bones) {
+      this.bones = new CommonEntityBoneCollection(this);
+    }
+    return this.bones;
+  }
+}
+export {
+  CommonProp
+};

package/entities/CommonVehicle.d.ts

@@ -0,0 +1,12 @@
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonEntityBoneCollection } from "./CommonEntityBoneCollection";
+export declare class CommonVehicle extends CommonBaseEntity {
+    static exists(vehicle: CommonVehicle): boolean;
+    static fromHandle(handle: number): CommonVehicle | null;
+    static fromNetworkId(networkId: number): CommonVehicle | null;
+    protected type: ClassTypes;
+    protected bones?: CommonEntityBoneCollection;
+    constructor(handle: number);
+    get Bones(): CommonEntityBoneCollection;
+}

package/entities/CommonVehicle.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonEntityBoneCollection } from "./CommonEntityBoneCollection";
+class CommonVehicle extends CommonBaseEntity {
+  static {
+    __name(this, "CommonVehicle");
+  }
+  static exists(vehicle) {
+    return typeof vehicle !== "undefined" && vehicle.exists();
+  }
+  static fromHandle(handle) {
+    if (handle === 0 || !DoesEntityExist(handle)) {
+      return null;
+    }
+    return new this(handle);
+  }
+  static fromNetworkId(networkId) {
+    if (!NetworkDoesEntityExistWithNetworkId(networkId)) {
+      return null;
+    }
+    return new this(NetworkGetEntityFromNetworkId(networkId));
+  }
+  type = ClassTypes.Vehicle;
+  bones;
+  constructor(handle) {
+    super(handle);
+  }
+  get Bones() {
+    if (!this.bones) {
+      this.bones = new CommonEntityBoneCollection(this);
+    }
+    return this.bones;
+  }
+}
+export {
+  CommonVehicle
+};

package/entities/GetEntityClassIdFromHandle.d.ts

@@ -0,0 +1,2 @@
+import type { CommonEntity } from "./CommonEntityType";
+export declare function GetEntityClassFromHandle(entityId: number): CommonEntity;

package/entities/GetEntityClassIdFromHandle.js

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonPed } from "./CommonPed";
+import { CommonProp } from "./CommonProp";
+import { CommonVehicle } from "./CommonVehicle";
+function GetEntityClassFromHandle(entityId) {
+  switch (GetEntityType(entityId)) {
+    case 1: {
+      return CommonPed.fromHandle(entityId);
+    }
+    case 2: {
+      return CommonVehicle.fromHandle(entityId);
+    }
+    case 3: {
+      return CommonProp.fromHandle(entityId);
+    }
+  }
+  return null;
+}
+__name(GetEntityClassFromHandle, "GetEntityClassFromHandle");
+export {
+  GetEntityClassFromHandle
+};

package/enums/VehicleSeat.d.ts

@@ -0,0 +1,13 @@
+export declare enum VehicleSeat {
+    AnyPassenger = -2,
+    Driver = -1,
+    FrontRight = 0,
+    BackLeft = 1,
+    BackRight = 2,
+    ExtraLeft1 = 3,
+    ExtraRight1 = 4,
+    ExtraLeft2 = 5,
+    ExtraRight2 = 6,
+    ExtraLeft3 = 7,
+    ExtraRight3 = 8
+}

package/enums/VehicleSeat.js

@@ -0,0 +1,17 @@
+var VehicleSeat = /* @__PURE__ */ ((VehicleSeat2) => {
+  VehicleSeat2[VehicleSeat2["AnyPassenger"] = -2] = "AnyPassenger";
+  VehicleSeat2[VehicleSeat2["Driver"] = -1] = "Driver";
+  VehicleSeat2[VehicleSeat2["FrontRight"] = 0] = "FrontRight";
+  VehicleSeat2[VehicleSeat2["BackLeft"] = 1] = "BackLeft";
+  VehicleSeat2[VehicleSeat2["BackRight"] = 2] = "BackRight";
+  VehicleSeat2[VehicleSeat2["ExtraLeft1"] = 3] = "ExtraLeft1";
+  VehicleSeat2[VehicleSeat2["ExtraRight1"] = 4] = "ExtraRight1";
+  VehicleSeat2[VehicleSeat2["ExtraLeft2"] = 5] = "ExtraLeft2";
+  VehicleSeat2[VehicleSeat2["ExtraRight2"] = 6] = "ExtraRight2";
+  VehicleSeat2[VehicleSeat2["ExtraLeft3"] = 7] = "ExtraLeft3";
+  VehicleSeat2[VehicleSeat2["ExtraRight3"] = 8] = "ExtraRight3";
+  return VehicleSeat2;
+})(VehicleSeat || {});
+export {
+  VehicleSeat
+};

package/index.d.ts

@@ -0,0 +1,44 @@
+export * from "./CommonGameConstants";
+export * from "./CommonModel";
+export * from "./CommonTasks";
+export * from "./utils/Animations";
+export * from "./interfaces/Dimension";
+export * from "./enums/VehicleSeat";
+export * from "./entities/CommonBaseEntity";
+export * from "./entities/CommonBaseEntityBone";
+export * from "./entities/CommonBaseEntityBoneCollection";
+export * from "./entities/CommonEntityBone";
+export * from "./entities/CommonEntityBoneCollection";
+export * from "./entities/CommonEntityType";
+export * from "./entities/CommonPed";
+export * from "./entities/CommonPedBone";
+export * from "./entities/CommonPedBoneCollection";
+export * from "./entities/CommonPlayer";
+export * from "./entities/CommonProp";
+export * from "./entities/CommonVehicle";
+export * from "./entities/GetEntityClassIdFromHandle";
+export * from "./definitions/index.d";
+export * from "./definitions/redm.d";
+export * from "./common/Command";
+export * from "./common/Convar";
+export * from "./common/GlobalData";
+export * from "./common/Kvp";
+export * from "./common/Resource";
+export * from "./common/types";
+export * from "./common/utils/ClassTypes";
+export * from "./common/utils/Color";
+export * from "./common/utils/Delay";
+export * from "./common/utils/Maths";
+export * from "./common/utils/Point";
+export * from "./common/utils/PointF";
+export * from "./common/utils/Quaternion";
+export * from "./common/utils/Vector";
+export * from "./common/utils/cleanPlayerName";
+export * from "./common/utils/enumValues";
+export * from "./common/utils/getStringFromUInt8Array";
+export * from "./common/utils/getUInt32FromUint8Array";
+export * from "./common/utils/randomInt";
+export * from "./common/net/NetworkedMap";
+export * from "./common/decors/Events";
+export * from "./cfx/StateBagChangeHandler";
+export * from "./cfx/cfx";

package/index.js

@@ -0,0 +1,44 @@
+export * from "./CommonGameConstants";
+export * from "./CommonModel";
+export * from "./CommonTasks";
+export * from "./utils/Animations";
+export * from "./interfaces/Dimension";
+export * from "./enums/VehicleSeat";
+export * from "./entities/CommonBaseEntity";
+export * from "./entities/CommonBaseEntityBone";
+export * from "./entities/CommonBaseEntityBoneCollection";
+export * from "./entities/CommonEntityBone";
+export * from "./entities/CommonEntityBoneCollection";
+export * from "./entities/CommonEntityType";
+export * from "./entities/CommonPed";
+export * from "./entities/CommonPedBone";
+export * from "./entities/CommonPedBoneCollection";
+export * from "./entities/CommonPlayer";
+export * from "./entities/CommonProp";
+export * from "./entities/CommonVehicle";
+export * from "./entities/GetEntityClassIdFromHandle";
+export * from "./definitions/index.d";
+export * from "./definitions/redm.d";
+export * from "./common/Command";
+export * from "./common/Convar";
+export * from "./common/GlobalData";
+export * from "./common/Kvp";
+export * from "./common/Resource";
+export * from "./common/types";
+export * from "./common/utils/ClassTypes";
+export * from "./common/utils/Color";
+export * from "./common/utils/Delay";
+export * from "./common/utils/Maths";
+export * from "./common/utils/Point";
+export * from "./common/utils/PointF";
+export * from "./common/utils/Quaternion";
+export * from "./common/utils/Vector";
+export * from "./common/utils/cleanPlayerName";
+export * from "./common/utils/enumValues";
+export * from "./common/utils/getStringFromUInt8Array";
+export * from "./common/utils/getUInt32FromUint8Array";
+export * from "./common/utils/randomInt";
+export * from "./common/net/NetworkedMap";
+export * from "./common/decors/Events";
+export * from "./cfx/StateBagChangeHandler";
+export * from "./cfx/cfx";

package/interfaces/Dimension.d.ts

@@ -0,0 +1,5 @@
+import type { Vector3 } from "../common/utils/Vector";
+export interface Dimensions {
+    min: Vector3;
+    max: Vector3;
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@nativewrappers/common-game",
+  "description": "Native wrappers and utilities for use with Common Game.",
+  "contributors": [
+    "Remco Troost <d0p3t>",
+    "Dillon Skaggs <AvarianKnight>",
+    "Linden <thelindat>"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "version": "0.0.114",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nativewrappers/nativewrappers.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nativewrappers/nativewrappers/issues"
+  },
+  "homepage": "https://fivemjs.avarian.dev/",
+  "keywords": [
+    "fivem",
+    "wrapper",
+    "javascript",
+    "typescript",
+    "citizenfx"
+  ],
+  "files": [
+    "./**/*.js",
+    "./**/*.d.ts"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": "./index.js",
+    "./*": "./*"
+  }
+}

package/utils/Animations.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A utility to load an animation dictionary, anything that loads an animation should RemoveAnimDict after its finish being used.
+ * @param animDict the animation dictionary to load
+ * @param waitTime how long to wait for the dictionary to load
+ * @returns {boolean} if the animation successfully loaded
+ */
+export declare const LoadAnimDict: (animDict: string, waitTime?: number) => Promise<boolean>;
+/**
+ * A utility to load multiple animation dictionary, anything that loads an animation should RemoveAnimDict after its finish being used.
+ * @param animDict the animation dictionary to load
+ * @param waitTime how long to wait for the dictionary to load
+ * @returns if the animation successfully loaded, if the animation failed to load it will return an array of animations that failed to load
+ */
+export declare const LoadAnimDictArray: (animDict: string[], waitTime?: number) => Promise<[boolean, string[] | null]>;
+/**
+ * A utility to unload multiple animation dictionary
+ * @param animDict the animation dictionaries to unload
+ */
+export declare const RemoveAnimDictArray: (animDict: string[]) => void;

package/utils/Animations.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Delay } from "../common/utils/Delay";
+const LoadAnimDict = /* @__PURE__ */ __name(async (animDict, waitTime = 1e3) => {
+  const start = GetGameTimer();
+  if (!HasAnimDictLoaded(animDict)) {
+    RequestAnimDict(animDict);
+  }
+  while (!HasAnimDictLoaded(animDict)) {
+    if (GetGameTimer() - start >= waitTime) return false;
+    await Delay(0);
+  }
+  return true;
+}, "LoadAnimDict");
+const LoadAnimDictArray = /* @__PURE__ */ __name(async (animDict, waitTime = 1e3) => {
+  const start = GetGameTimer();
+  for (const dict of animDict) {
+    if (!HasAnimDictLoaded(dict)) {
+      RequestAnimDict(dict);
+    }
+  }
+  const animsLoaded = /* @__PURE__ */ new Set();
+  while (animsLoaded.size !== animDict.length) {
+    for (const dict of animDict) {
+      if (!animsLoaded.has(dict) && HasAnimDictLoaded(dict)) {
+        animsLoaded.add(dict);
+      }
+    }
+    if (GetGameTimer() - start >= waitTime) return [false, animDict.filter((dict) => !animsLoaded.has(dict))];
+    await Delay(0);
+  }
+  return [true, null];
+}, "LoadAnimDictArray");
+const RemoveAnimDictArray = /* @__PURE__ */ __name((animDict) => {
+  for (const dict of animDict) {
+    RemoveAnimDict(dict);
+  }
+}, "RemoveAnimDictArray");
+export {
+  LoadAnimDict,
+  LoadAnimDictArray,
+  RemoveAnimDictArray
+};