@nativewrappers/fivem 0.0.80 → 0.0.82

package/Model.js

@@ -0,0 +1,210 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./common/utils/Vector";
+import { Game } from "./Game";
+import { VehicleHash } from "./hashes/VehicleHash";
+class Model {
+  static {
+    __name(this, "Model");
+  }
+  /**
+   * Hash of this model.
+   */
+  hash;
+  requestedModel = false;
+  /**
+   * Creates a model object based on the hash key or model string.
+   *
+   * @param hash A number or string of the model's hash. Example: "mp_m_freemode_01"
+   */
+  constructor(hash) {
+    if (typeof hash === "string") {
+      this.hash = Game.generateHash(hash);
+    } else {
+      this.hash = hash;
+    }
+  }
+  [Symbol.dispose]() {
+    if (this.requestedModel) {
+      this.markAsNoLongerNeeded();
+    }
+  }
+  /**
+   * Gets the hash of the model.
+   *
+   * @returns The hash key.
+   */
+  get Hash() {
+    return this.hash;
+  }
+  /**
+   * Gets if the model is valid or not.
+   *
+   * @returns Whether this model is valid.
+   */
+  get IsValid() {
+    return IsModelValid(this.hash);
+  }
+  /**
+   * Gets if the model is in cd image or not.
+   *
+   * @returns Whether this model is in cd image.
+   */
+  get IsInCdImage() {
+    return IsModelInCdimage(this.hash);
+  }
+  /**
+   * Gets if the model is loaded or not.
+   *
+   * @returns Whether this model is loaded.
+   */
+  get IsLoaded() {
+    return HasModelLoaded(this.hash);
+  }
+  /**
+   * Gets if the model collision is loaded or not.
+   *
+   * @returns Whether this model collision is loaded.
+   */
+  get IsCollisionLoaded() {
+    return HasCollisionForModelLoaded(this.hash);
+  }
+  /**
+   * Gets if the model is a bicycle or not.
+   *
+   * @returns Whether this model is a bicycle.
+   */
+  get IsBicycle() {
+    return IsThisModelABicycle(this.hash);
+  }
+  /**
+   * Gets if the model is a motorbike or not.
+   *
+   * @returns Whether this model is a motorbike.
+   */
+  get IsBike() {
+    return IsThisModelABike(this.hash);
+  }
+  /**
+   * Gets if the model is a boat or not.
+   *
+   * @returns Whether this model is a boat.
+   */
+  get IsBoat() {
+    return IsThisModelABoat(this.hash);
+  }
+  /**
+   * Gets if the model is a car or not.
+   *
+   * @returns Whether this model is a car.
+   */
+  get IsCar() {
+    return IsThisModelACar(this.hash);
+  }
+  /**
+   * Gets if the model is a cargobob or not.
+   *
+   * @returns Whether this model is a cargobob.
+   */
+  get IsCargobob() {
+    return this.hash === VehicleHash.Cargobob || this.hash === VehicleHash.Cargobob2 || this.hash === VehicleHash.Cargobob3 || this.hash === VehicleHash.Cargobob4;
+  }
+  /**
+   * Gets if the model is a helicopter or not.
+   *
+   * @returns Whether this model is a helicopter.
+   */
+  get IsHelicopter() {
+    return IsThisModelAHeli(this.hash);
+  }
+  /**
+   * Gets if the model is a Ped or not.
+   *
+   * @returns Whether this model is a Ped.
+   */
+  get IsPed() {
+    return IsModelAPed(this.hash);
+  }
+  /**
+   * Gets if the model is a plane or not.
+   *
+   * @returns Whether this model is a plane.
+   */
+  get IsPlane() {
+    return IsThisModelAPlane(this.hash);
+  }
+  /**
+   * Gets if the model is a prop or not.
+   *
+   * @returns Whether this model is a prop.
+   */
+  get IsProp() {
+    return this.IsValid && !this.IsPed && !this.IsVehicle && !IsWeaponValid(this.hash);
+  }
+  /**
+   * Gets if the model is a quadbike or not.
+   *
+   * @returns Whether this model is a quadbike.
+   */
+  get IsQuadbike() {
+    return IsThisModelAQuadbike(this.hash);
+  }
+  /**
+   * Gets if the model is a train or not.
+   *
+   * @returns Whether this model is a train.
+   */
+  get IsTrain() {
+    return IsThisModelATrain(this.hash);
+  }
+  /**
+   * Gets if the model is a Vehicle or not.
+   *
+   * @returns Whether this model is a Vehicle.
+   */
+  get IsVehicle() {
+    return IsModelAVehicle(this.hash);
+  }
+  /**
+   * Gets the model dimensions.
+   *
+   * @returns This model min & max dimensions.
+   */
+  get Dimensions() {
+    const [minArray, maxArray] = GetModelDimensions(this.hash);
+    const min = Vector3.fromArray(minArray);
+    const max = Vector3.fromArray(maxArray);
+    return { min, max };
+  }
+  /**
+   * Request and load the model with a specified timeout. Default timeout is 1000 (recommended).
+   * This function will not automatically set the model as no longer needed when
+   * done.
+   *
+   * @param timeoutMs Maximum allowed time for model to load.
+   */
+  async request(timeoutMs = 1e3) {
+    if (!this.IsInCdImage && !this.IsValid && !IsWeaponValid(this.hash)) {
+      return false;
+    }
+    if (this.IsLoaded) {
+      return true;
+    }
+    RequestModel(this.hash);
+    const timeout = GetGameTimer() + timeoutMs;
+    while (!this.IsLoaded && GetGameTimer() < timeout) {
+      await Wait(0);
+    }
+    this.requestedModel = true;
+    return this.IsLoaded;
+  }
+  /**
+   * Sets the model as no longer needed allowing the game engine to free memory.
+   */
+  markAsNoLongerNeeded() {
+    SetModelAsNoLongerNeeded(this.hash);
+  }
+}
+export {
+  Model
+};

package/NetworkedScene.d.ts

@@ -1,5 +1,6 @@
-import type { Ped, Vector3 } from ".";
+import type { Vector3 } from "./common/utils/Vector";
 import type { BaseEntity } from "./models/BaseEntity";
+import type { Ped } from "./models/Ped";
 export declare class NetworkedScene {
     private scene;
     constructor(pos: Vector3, rot: Vector3, rotationOrder: number, holdLastFrame: boolean, looped: boolean, sceneHash: number, animTime: number, animSpeed: number);

package/NetworkedScene.js

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class NetworkedScene {
+  static {
+    __name(this, "NetworkedScene");
+  }
+  scene;
+  constructor(pos, rot, rotationOrder, holdLastFrame, looped, sceneHash, animTime, animSpeed) {
+    this.scene = NetworkCreateSynchronisedScene(
+      pos.x,
+      pos.y,
+      pos.z,
+      rot.x,
+      rot.y,
+      rot.z,
+      rotationOrder,
+      holdLastFrame,
+      looped,
+      sceneHash,
+      animTime + 0,
+      animSpeed + 0
+    );
+  }
+  addPed(ped, animDict, animName, blendInSpeed, blendOutSpeed, duration, flag, playbackRate, p9) {
+    NetworkAddPedToSynchronisedScene(
+      ped.Handle,
+      this.scene,
+      animDict,
+      animName,
+      blendInSpeed,
+      blendOutSpeed,
+      duration,
+      flag,
+      playbackRate,
+      p9
+    );
+  }
+  addEntity(entity, animDict, animName, speed, speedMultiplier, flag) {
+    NetworkAddEntityToSynchronisedScene(entity.Handle, this.scene, animDict, animName, speed, speedMultiplier, flag);
+  }
+  start() {
+    NetworkStartSynchronisedScene(this.scene);
+  }
+  stop() {
+    NetworkStopSynchronisedScene(this.scene);
+  }
+}
+export {
+  NetworkedScene
+};

package/ParticleEffect.d.ts

@@ -1,6 +1,7 @@
-import type { ParticleEffectAsset } from "./";
-import { type InvertAxis } from "./enums";
-import { Color, Vector3 } from "./utils";
+import { Color } from "./common/utils/Color";
+import { Vector3 } from "./common/utils/Vector";
+import { type InvertAxis } from "./enums/InvertAxis";
+import type { ParticleEffectAsset } from "./ParticleEffectAsset";
 /**
  * UNFINISHED! Class to manage particle effects.
  */

package/ParticleEffect.js

@@ -0,0 +1,128 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Color } from "./common/utils/Color";
+import { Vector3 } from "./common/utils/Vector";
+import { InvertAxisFlags } from "./enums/InvertAxis";
+class ParticleEffect {
+  static {
+    __name(this, "ParticleEffect");
+  }
+  asset;
+  effectName;
+  offset = new Vector3(0, 0, 0);
+  rotation = new Vector3(0, 0, 0);
+  color = Color.Transparent;
+  scale = 1;
+  range = 1;
+  invertAxis = { flags: InvertAxisFlags.None };
+  handle;
+  /**
+   * Creates a particle effect.
+   *
+   * @param asset Particle effect asset.
+   * @param effectName Name of effect.
+   */
+  constructor(asset, effectName) {
+    this.handle = -1;
+    this.asset = asset;
+    this.effectName = effectName;
+  }
+  /**
+   * Get the particle effect handle.
+   */
+  get Handle() {
+    return this.handle;
+  }
+  /**
+   * Get whether particle effect is currently active.
+   */
+  get IsActive() {
+    return this.Handle !== -1 && DoesParticleFxLoopedExist(this.Handle);
+  }
+  /**
+   * Stop a particle effect.
+   */
+  stop() {
+    if (this.IsActive) {
+      RemoveParticleFx(this.Handle, false);
+    }
+    this.handle = -1;
+  }
+  /**
+   * Get the rotation of the particle effect.
+   */
+  get Rotation() {
+    return this.rotation;
+  }
+  /**
+   * Set the rotation of the particle effect.
+   */
+  set Rotation(rotation) {
+    this.rotation = rotation;
+    if (this.IsActive) {
+      const off = this.offset;
+      SetParticleFxLoopedOffsets(this.Handle, off.x, off.y, off.z, rotation.x, rotation.y, rotation.z);
+    }
+  }
+  /**
+   * Get the range of the particle effect.
+   */
+  get Range() {
+    return this.range;
+  }
+  /**
+   * Set the range of the particle effect.
+   */
+  set Range(range) {
+    this.range = range;
+    SetParticleFxLoopedRange(this.Handle, range);
+  }
+  /**
+   * Get the invert axis flag of the particle effect.
+   */
+  get InvertAxis() {
+    return this.invertAxis;
+  }
+  /**
+   * Set the inverted axis of the particle effect.
+   */
+  set InvertAxis(invertAxis) {
+    this.invertAxis = invertAxis;
+    if (this.IsActive) {
+      this.stop();
+      this.start();
+    }
+  }
+  /**
+   * Set a paramaeter of a particle effect.
+   *
+   * @param parameterName Name of parameter.
+   * @param value Value of parameter.
+   */
+  setParameter(parameterName, value) {
+    if (this.IsActive) {
+      SetParticleFxLoopedEvolution(this.Handle, parameterName, value, false);
+    }
+  }
+  /**
+   * Get the name of the particle effect asset. Same as ParticleEffect.AssetName.
+   */
+  get AssetName() {
+    return this.asset.AssetName;
+  }
+  /**
+   * Get the name of the particle effect.
+   */
+  get EffectName() {
+    return this.effectName;
+  }
+  /**
+   * Return the particle effect as string. `AssetName`\\`EffectName`.
+   */
+  toString() {
+    return `${this.AssetName}\\${this.EffectName}`;
+  }
+}
+export {
+  ParticleEffect
+};

package/ParticleEffectAsset.d.ts

@@ -1,6 +1,6 @@
-import { type InvertAxis } from "./enums";
+import { Vector3 } from "./common/utils/Vector";
+import { type InvertAxis } from "./enums/InvertAxis";
 import type { BaseEntity } from "./models/BaseEntity";
-import { Vector3 } from "./utils";
 /**
  * UNFINISHED! Class that represents a particle effect asset.
  */

package/ParticleEffectAsset.js

@@ -0,0 +1,133 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./common/utils/Vector";
+import { InvertAxisFlags } from "./enums/InvertAxis";
+class ParticleEffectAsset {
+  static {
+    __name(this, "ParticleEffectAsset");
+  }
+  /**
+   * Returns the name of the asset. Same as AssetName.
+   */
+  get Asset() {
+    return this.assetName;
+  }
+  assetName;
+  constructor(assetName) {
+    this.assetName = assetName;
+  }
+  /**
+   * Get the name of the particle effect.
+   */
+  get AssetName() {
+    return this.assetName;
+  }
+  /**
+   * Get whether the particle effect has loaded into game memory.
+   */
+  get IsLoaded() {
+    return HasNamedPtfxAssetLoaded(this.assetName);
+  }
+  /**
+   * Start a particle effect at a world position.
+   *
+   * @param effectName Name of effect.
+   * @param rot Rotation from entity position.
+   * @param scale Size of the effect.
+   * @param invertAxis Which axis to invert (default none).
+   */
+  startNonLoopedAtCoord(effectName, pos, rot = new Vector3(0, 0, 0), scale = 1, invertAxis = { flags: InvertAxisFlags.None }) {
+    if (!this.setNextCall()) {
+      return false;
+    }
+    const invertAxisFlags = invertAxis.flags;
+    SetPtfxAssetNextCall(this.assetName);
+    return StartParticleFxLoopedAtCoord(
+      effectName,
+      pos.x,
+      pos.y,
+      pos.z,
+      rot.x,
+      rot.y,
+      rot.z,
+      scale,
+      !!(invertAxisFlags & InvertAxisFlags.X),
+      !!(invertAxisFlags & InvertAxisFlags.Y),
+      !!(invertAxisFlags & InvertAxisFlags.Z),
+      false
+    ) > 0;
+  }
+  /**
+   * Start a particle effect on an entity
+   *
+   * @param effectName Name of effect.
+   * @param entity Entity to use effect on.
+   * @param off Offset from entity position.
+   * @param rot Rotation from entity position.
+   * @param scale Size of the effect.
+   * @param invertAxis Which axis to invert (default none).
+   */
+  startNonLoopedOnEntity(effectName, entity, off = new Vector3(0, 0, 0), rot = new Vector3(0, 0, 0), scale = 1, invertAxis = { flags: InvertAxisFlags.None }) {
+    if (!this.setNextCall()) {
+      return false;
+    }
+    const invertAxisFlags = invertAxis.flags;
+    SetPtfxAssetNextCall(this.assetName);
+    return !!StartParticleFxLoopedOnEntity(
+      effectName,
+      entity.Handle,
+      off.x,
+      off.y,
+      off.z,
+      rot.x,
+      rot.y,
+      rot.z,
+      scale,
+      !!(invertAxisFlags & InvertAxisFlags.X),
+      !!(invertAxisFlags & InvertAxisFlags.Y),
+      !!(invertAxisFlags & InvertAxisFlags.Z)
+    );
+  }
+  /**
+   * Load a particle effect into the game memory.
+   *
+   * @param timeout Max time to load Particle Effect
+   */
+  request(timeout) {
+    return new Promise((resolve) => {
+      if (!this.IsLoaded) {
+        RequestNamedPtfxAsset(this.assetName);
+        const start = GetGameTimer();
+        const interval = setInterval(() => {
+          if (this.IsLoaded || GetGameTimer() - start >= timeout) {
+            clearInterval(interval);
+            resolve(this.IsLoaded);
+          }
+        }, 0);
+      } else {
+        resolve(this.IsLoaded);
+      }
+    });
+  }
+  /**
+   * Allow game engine to safely unload particle effect model from memory.
+   */
+  markAsNoLongerNeeded() {
+    RemoveNamedPtfxAsset(this.assetName);
+  }
+  toString() {
+    return this.assetName;
+  }
+  setNextCall() {
+    if (!this.IsLoaded) {
+      RequestNamedPtfxAsset(this.assetName);
+    } else {
+      SetPtfxAssetNextCall(this.assetName);
+      return true;
+    }
+    return false;
+  }
+}
+export {
+  ParticleEffectAsset
+};

package/Pickup.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from "./utils";
+import { Vector3 } from "./common/utils/Vector";
 export declare class Pickup {
     private handle;
     constructor(handle: number);

package/Pickup.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./common/utils/Vector";
+class Pickup {
+  static {
+    __name(this, "Pickup");
+  }
+  handle;
+  constructor(handle) {
+    this.handle = handle;
+  }
+  get Position() {
+    return Vector3.fromArray(GetPickupCoords(this.handle));
+  }
+  get IsCollected() {
+    return HasPickupBeenCollected(this.handle);
+  }
+  delete() {
+    RemovePickup(this.handle);
+  }
+  exists() {
+    return DoesPickupExist(this.handle);
+  }
+}
+export {
+  Pickup
+};

package/Raycast.d.ts

@@ -1,6 +1,8 @@
-import type { MaterialHash } from "./hashes";
-import type { Ped, Prop, Vehicle } from "./models";
-import { Vector3 } from "./utils";
+import { Vector3 } from "./common/utils/Vector";
+import type { MaterialHash } from "./hashes/MaterialHash";
+import type { Ped } from "./models/Ped";
+import type { Prop } from "./models/Prop";
+import type { Vehicle } from "./models/Vehicle";
 /**
  * Class that represents the result of a raycast.
  */