@nativewrappers/fivem 0.0.80 → 0.0.82

package/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/utils/Size.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Size {
+  static {
+    __name(this, "Size");
+  }
+  width;
+  height;
+  constructor(w = 0, h = 0) {
+    this.width = w;
+    this.height = h;
+  }
+}
+export {
+  Size
+};

package/utils/String.d.ts

@@ -1,4 +1,4 @@
-import { Font } from "..";
+import { Font } from "fivem/enums/Font";
 export declare abstract class _String {
     static stringToArray(input: string): string[];
     static measureStringWidthNoConvert(input: string, font?: Font, scale?: number): number;

package/utils/String.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Font } from "fivem/enums/Font";
+import { Screen } from "fivem/ui/Screen";
+import { Text } from "fivem/ui/Text";
+import { Maths } from "./Maths";
+class _String {
+  static {
+    __name(this, "_String");
+  }
+  static stringToArray(input) {
+    let stringsNeeded = 1;
+    if (input.length > 99) {
+      stringsNeeded = Math.ceil(input.length / 99);
+    }
+    const outputString = new Array(stringsNeeded);
+    for (let i = 0; i < stringsNeeded; i++) {
+      outputString[i] = input.substring(i * 99, i * 99 + Maths.clamp(input.substring(i * 99).length, 0, 99));
+    }
+    return outputString;
+  }
+  static measureStringWidthNoConvert(input, font = Font.ChaletLondon, scale = 0) {
+    SetTextEntryForWidth("STRING");
+    Text.addLongString(input);
+    SetTextFont(font);
+    SetTextScale(1, scale);
+    return GetTextScreenWidth(false);
+  }
+  static measureString(str, font, scale, screenWidth = Screen.ScaledWidth) {
+    return this.measureStringWidthNoConvert(str, font, scale) * screenWidth;
+  }
+}
+export {
+  _String
+};

package/weapon/DlcWeaponData.d.ts

@@ -1,4 +1,4 @@
-import type { WeaponHash } from "../hashes";
+import type { WeaponHash } from "fivem/hashes/WeaponHash";
 /**
  * DlcWeaponData
  * refer1: https://github.com/citizenfx/fivem/blob/master/code/client/clrcore/External/DlcWeaponStructs.cs#L10

package/weapon/DlcWeaponData.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { getStringFromUInt8Array } from "../common/utils/getStringFromUInt8Array";
+import { getUInt32FromUint8Array } from "../common/utils/getUInt32FromUint8Array";
+const DlcWeaponData = /* @__PURE__ */ new Map();
+function initializeOnce() {
+  let isInitialized = false;
+  return () => {
+    if (isInitialized || IsDuplicityVersion()) {
+      return;
+    }
+    const intLength = 4;
+    const strLength = 64;
+    const weaponCount = GetNumDlcWeapons();
+    for (let i = 0; i < weaponCount; i++) {
+      const buffer = new Uint8Array(14 * intLength + 4 * strLength);
+      Citizen.invokeNative("0x79923CD21BECE14E", i, buffer, Citizen.returnResultAnyway());
+      const dlcWeaponData = {
+        validCheck: getUInt32FromUint8Array(buffer, 0 * intLength, 1 * intLength),
+        weaponHash: getUInt32FromUint8Array(buffer, 2 * intLength, 3 * intLength),
+        unk: getUInt32FromUint8Array(buffer, 4 * intLength, 5 * intLength),
+        weaponCost: getUInt32FromUint8Array(buffer, 6 * intLength, 7 * intLength),
+        ammoCost: getUInt32FromUint8Array(buffer, 8 * intLength, 9 * intLength),
+        ammoType: getUInt32FromUint8Array(buffer, 10 * intLength, 11 * intLength),
+        defaultClipSize: getUInt32FromUint8Array(buffer, 12 * intLength, 13 * intLength),
+        name: getStringFromUInt8Array(buffer, 14 * intLength, 14 * intLength + strLength),
+        desc: getStringFromUInt8Array(buffer, 14 * intLength + strLength, 14 * intLength + 2 * strLength),
+        simpleDesc: getStringFromUInt8Array(buffer, 14 * intLength + 2 * strLength, 14 * intLength + 3 * strLength),
+        upperCaseName: getStringFromUInt8Array(buffer, 14 * intLength + 3 * strLength, 14 * intLength + 4 * strLength)
+      };
+      DlcWeaponData.set(dlcWeaponData.weaponHash, dlcWeaponData);
+    }
+    isInitialized = true;
+  };
+}
+__name(initializeOnce, "initializeOnce");
+initializeOnce()();
+export {
+  DlcWeaponData
+};

package/weapon/Mk2WeaponHash.js

@@ -0,0 +1,18 @@
+var Mk2WeaponHash = /* @__PURE__ */ ((Mk2WeaponHash2) => {
+  Mk2WeaponHash2[Mk2WeaponHash2["PistolMk2"] = 3219281620] = "PistolMk2";
+  Mk2WeaponHash2[Mk2WeaponHash2["SNSPistolMk2"] = 2285322324] = "SNSPistolMk2";
+  Mk2WeaponHash2[Mk2WeaponHash2["RevolverMk2"] = 3415619887] = "RevolverMk2";
+  Mk2WeaponHash2[Mk2WeaponHash2["SMGMk2"] = 2024373456] = "SMGMk2";
+  Mk2WeaponHash2[Mk2WeaponHash2["PumpShotgunMk2"] = 1432025498] = "PumpShotgunMk2";
+  Mk2WeaponHash2[Mk2WeaponHash2["AssaultRifleMk2"] = 961495388] = "AssaultRifleMk2";
+  Mk2WeaponHash2[Mk2WeaponHash2["CarbineRifleMk2"] = 4208062921] = "CarbineRifleMk2";
+  Mk2WeaponHash2[Mk2WeaponHash2["SpecialCarbineMk2"] = 2526821735] = "SpecialCarbineMk2";
+  Mk2WeaponHash2[Mk2WeaponHash2["BullpupRifleMk2"] = 2228681469] = "BullpupRifleMk2";
+  Mk2WeaponHash2[Mk2WeaponHash2["CombatMGMk2"] = 3686625920] = "CombatMGMk2";
+  Mk2WeaponHash2[Mk2WeaponHash2["HeavySniperMk2"] = 177293209] = "HeavySniperMk2";
+  Mk2WeaponHash2[Mk2WeaponHash2["MarksmanRifleMk2"] = 1785463520] = "MarksmanRifleMk2";
+  return Mk2WeaponHash2;
+})(Mk2WeaponHash || {});
+export {
+  Mk2WeaponHash
+};

package/weapon/Weapon.d.ts

@@ -1,13 +1,13 @@
-import { WeaponComponentCollection } from "../weaponComponent/WeaponComponentCollection";
-import type { Ped } from "../models";
-import { type AmmoType, WeaponHash } from "../hashes";
-import { Model } from "../Model";
-import type { WeaponTint } from "./WeaponTint";
+import { WeaponHash, type AmmoType } from "fivem/hashes/WeaponHash";
+import { Model } from "fivem/Model";
+import type { Ped } from "fivem/models/Ped";
+import { WeaponComponentCollection } from "fivem/weaponComponent/WeaponComponentCollection";
+import type { WeaponComponentHash } from "fivem/weaponComponent/WeaponComponentHash";
 import type { WeaponGroup } from "./WeaponGroup";
+import { WeaponHudStats } from "./WeaponHudStats";
 import type { WeaponLivery } from "./WeaponLivery";
 import type { WeaponLiveryColor } from "./WeaponLiveryColor";
-import { WeaponHudStats } from "./WeaponHudStats";
-import type { WeaponComponentHash } from "../weaponComponent";
+import type { WeaponTint } from "./WeaponTint";
 /**
  * ped weapon
  *

package/weapon/Weapon.js

@@ -0,0 +1,276 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { enumValues } from "../common/utils/enumValues";
+import { Game } from "fivem/Game";
+import { WeaponHash } from "fivem/hashes/WeaponHash";
+import { Model } from "fivem/Model";
+import { WeaponComponentCollection } from "fivem/weaponComponent/WeaponComponentCollection";
+import { WeaponComponentHashesByWeaponHash } from "fivem/weaponComponent/WeaponComponentHashesByWeaponHash";
+import { Mk2WeaponHash } from "./Mk2WeaponHash";
+import { WeaponDisplayNameByHash } from "./WeaponDisplayNameByHash";
+import { WeaponHudStats } from "./WeaponHudStats";
+class Weapon {
+  static {
+    __name(this, "Weapon");
+  }
+  owner;
+  components;
+  hash;
+  constructor(owner, hash) {
+    this.owner = owner;
+    this.hash = hash;
+    this.components = new WeaponComponentCollection(this.owner, this);
+  }
+  /**
+   * weapon components
+   *
+   * @constructor
+   */
+  get Components() {
+    return this.components;
+  }
+  /**
+   * weapon hash
+   *
+   * @constructor
+   */
+  get Hash() {
+    return this.hash;
+  }
+  /**
+   * check ped is unarmed or not
+   *
+   * @constructor
+   */
+  get IsUnarmed() {
+    return this.hash === WeaponHash.Unarmed;
+  }
+  /**
+   * Check if the ped has the current weapon.
+   *
+   * @constructor
+   */
+  get IsPresent() {
+    if (this.IsUnarmed) {
+      return true;
+    }
+    return HasPedGotWeapon(this.owner.Handle, this.hash, false);
+  }
+  /**
+   * get weapon display name / label
+   *
+   * @constructor
+   */
+  get DisplayName() {
+    return Weapon.getDisplayNameFromHash(this.hash) ?? "WCT_INVALID";
+  }
+  /**
+   * get weapon localized name
+   *
+   * @constructor
+   */
+  get LocalizedName() {
+    return Game.getGXTEntry(this.DisplayName);
+  }
+  /**
+   * get weapon model
+   *
+   * @constructor
+   */
+  get Model() {
+    return new Model(GetWeapontypeModel(this.hash));
+  }
+  /**
+   * get weapon tint
+   *
+   * @constructor
+   */
+  get Tint() {
+    return GetPedWeaponTintIndex(this.owner.Handle, this.hash);
+  }
+  /**
+   * set weapon tint
+   *
+   * @param tint
+   * @constructor
+   */
+  set Tint(tint) {
+    SetPedWeaponTintIndex(this.owner.Handle, this.hash, tint);
+  }
+  /**
+   * get weapon group
+   *
+   * @constructor
+   */
+  get Group() {
+    return GetWeapontypeGroup(this.hash);
+  }
+  /**
+   * get weapon ammo type
+   *
+   * @constructor
+   */
+  get AmmoType() {
+    return GetPedAmmoTypeFromWeapon(this.owner.Handle, this.hash);
+  }
+  /**
+   * get weapon ammo count
+   *
+   * @constructor
+   */
+  get Ammo() {
+    if (this.IsUnarmed) {
+      return 1;
+    }
+    if (!this.IsPresent) {
+      return GetPedAmmoByType(this.owner.Handle, this.AmmoType);
+    }
+    return GetAmmoInPedWeapon(this.owner.Handle, this.hash);
+  }
+  /**
+   * set weapon ammo count
+   *
+   * @param count
+   * @constructor
+   */
+  set Ammo(count) {
+    if (this.IsUnarmed) {
+      return;
+    }
+    if (this.IsPresent) {
+      SetPedAmmo(this.owner.Handle, this.hash, count);
+    } else {
+      GiveWeaponToPed(this.owner.Handle, this.hash, count, false, true);
+    }
+  }
+  /**
+   * get weapon max ammo
+   *
+   * @constructor
+   */
+  get MaxAmmo() {
+    if (this.IsUnarmed) {
+      return 1;
+    }
+    const amount = Citizen.invokeNative(
+      "0xDC16122C7A20C933",
+      this.owner.Handle,
+      this.hash,
+      Citizen.pointerValueInt(),
+      Citizen.resultAsInteger()
+    );
+    return amount;
+  }
+  /**
+   * get weapon max ammo in clip
+   *
+   * @constructor
+   */
+  get MaxAmmoInClip() {
+    if (this.IsUnarmed) {
+      return 1;
+    }
+    if (!this.IsPresent) {
+      return 0;
+    }
+    return GetMaxAmmoInClip(this.owner.Handle, this.hash, true);
+  }
+  /**
+   * get weapon default clip size
+   *
+   * @constructor
+   */
+  get DefaultClipSize() {
+    return GetWeaponClipSize(this.hash);
+  }
+  /**
+   * toggle weapon infinite ammo
+   *
+   * @param toggle
+   * @constructor
+   */
+  set InfiniteAmmo(toggle) {
+    if (this.IsUnarmed) {
+      return;
+    }
+    SetPedInfiniteAmmo(this.owner.Handle, toggle, this.hash);
+  }
+  /**
+   * toggle ped infinite ammo clip on all weapons
+   *
+   * @param toggle
+   * @constructor
+   */
+  set InfiniteAmmoClip(toggle) {
+    SetPedInfiniteAmmoClip(this.owner.Handle, toggle);
+  }
+  /**
+   * check weapon can use on parachute
+   *
+   * @constructor
+   */
+  get CanUseOnParachute() {
+    return CanUseWeaponOnParachute(this.hash);
+  }
+  /**
+   * Check weapon is Mk2 or not
+   *
+   * @constructor
+   */
+  get IsMk2() {
+    return Array.from(enumValues(Mk2WeaponHash)).some((x) => x === this.hash);
+  }
+  /**
+   * set weapon livery, only work for Mk2 weapon
+   *
+   * @param liveryId
+   * @param colorId
+   */
+  setLivery(liveryId, colorId) {
+    if (!this.IsMk2) {
+      console.log(`[ERROR]${this.setLivery.name} failed. Reason: non-Mk2 weapon`);
+      return;
+    }
+    const component = this.Components.getMk2CamoComponent(liveryId);
+    if (component.IsInvalid) {
+      console.log(`[ERROR]${this.setLivery.name} failed. Reason: invalid liveryId/Component`);
+      return;
+    }
+    component.Active = true;
+    SetPedWeaponLiveryColor(this.owner.Handle, this.hash, component.ComponentHash, colorId);
+  }
+  /**
+   * get weapon hud stats
+   *
+   * @constructor
+   */
+  get HudStats() {
+    return WeaponHudStats.get(this.hash);
+  }
+  /**
+   * get weapon display name / label by hash
+   *
+   * @param hash
+   */
+  static getDisplayNameFromHash(hash) {
+    if (!hash) {
+      return "WT_INVALID";
+    }
+    return WeaponDisplayNameByHash.get(hash) ?? "WCT_INVALID";
+  }
+  /**
+   * get component hashes belongs to weapon
+   *
+   * @param hash
+   */
+  static getWeaponComponentHashes(hash) {
+    const hashes = WeaponComponentHashesByWeaponHash.get(hash);
+    if (!hashes) {
+      return [];
+    }
+    return [...hashes];
+  }
+}
+export {
+  Weapon
+};

package/weapon/WeaponAsset.d.ts

@@ -1,4 +1,4 @@
-import type { WeaponHash } from "../hashes";
+import type { WeaponHash } from "fivem/hashes/WeaponHash";
 /**
  * weapon asset
  *

package/weapon/WeaponAsset.js

@@ -0,0 +1,87 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Game } from "fivem/Game";
+import { Weapon } from "./Weapon";
+class WeaponAsset {
+  static {
+    __name(this, "WeaponAsset");
+  }
+  hash;
+  constructor(hash) {
+    this.hash = hash;
+  }
+  /**
+   * get weapon hash
+   *
+   * @constructor
+   */
+  get Hash() {
+    return this.hash;
+  }
+  /**
+   * check weapon is valid
+   *
+   * @constructor
+   */
+  get IsValid() {
+    return IsWeaponValid(this.hash);
+  }
+  /**
+   * check weapon assets is loaded
+   *
+   * @constructor
+   */
+  get IsLoaded() {
+    return HasWeaponAssetLoaded(this.hash);
+  }
+  /**
+   * request weapon asset
+   *
+   */
+  request() {
+    RequestWeaponAsset(this.hash, 31, 0);
+  }
+  /**
+   * request weapon asset async
+   *
+   * @param timeout
+   */
+  async requestAsync(timeout) {
+    this.request();
+    const start = GetGameTimer();
+    while (!this.IsLoaded) {
+      await Wait(100);
+      const now = GetGameTimer();
+      if (now - start >= timeout) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * unload weapon asset
+   *
+   */
+  dismiss() {
+    RemoveWeaponAsset(this.hash);
+  }
+  /**
+   * get weapon display name / label
+   *
+   * @constructor
+   */
+  get DisplayName() {
+    return Weapon.getDisplayNameFromHash(this.hash);
+  }
+  /**
+   * get weapon localized name
+   *
+   * @constructor
+   */
+  get LocalizedName() {
+    return Game.getGXTEntry(this.DisplayName);
+  }
+}
+export {
+  WeaponAsset
+};

package/weapon/WeaponCollection.d.ts

@@ -1,6 +1,7 @@
+import type { WeaponHash } from "fivem/hashes/WeaponHash";
+import type { Ped } from "fivem/models/Ped";
+import { Prop } from "fivem/models/Prop";
 import { Weapon } from "./Weapon";
-import { type Ped, Prop } from "../models";
-import type { WeaponHash } from "../hashes";
 /**
  * ped weapons
  *