@nativewrappers/fivem 0.0.80 → 0.0.82

package/interfaces/Dimensions.d.ts

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

package/models/BaseEntity.d.ts

@@ -1,12 +1,14 @@
-import { Blip } from "../Blip";
-import { ForceType } from "../enums";
-import type { MaterialHash, WeaponHash } from "../hashes";
-import { Model } from "../Model";
-import { Quaternion, Vector3 } from "../utils";
-import { EntityBoneCollection } from "./";
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { Vector3 } from "../common/utils/Vector";
+import { ForceType } from "fivem/enums/ForceType";
+import type { MaterialHash } from "fivem/hashes/MaterialHash";
+import type { WeaponHash } from "fivem/hashes/WeaponHash";
+import { Model } from "fivem/Model";
 import type { EntityBone } from "./EntityBone";
-import { type StateBagChangeHandler } from "../cfx";
-import { ClassTypes } from "../../common/utils/ClassTypes";
+import { Blip } from "../Blip";
+import { EntityBoneCollection } from "./EntityBoneCollection";
+import { type StateBagChangeHandler } from "fivem/cfx";
+import { Quaternion } from "../common/utils/Quaternion";
 export declare class BaseEntity {
     static fromNetworkId(networkId: number): BaseEntity | null;
     static fromStateBagName(stateBagName: string): BaseEntity | null;

package/models/BaseEntity.js

@@ -0,0 +1,576 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { Vector3 } from "../common/utils/Vector";
+import { ForceType } from "fivem/enums/ForceType";
+import { Model } from "fivem/Model";
+import { Blip } from "../Blip";
+import { EntityBoneCollection } from "./EntityBoneCollection";
+import cfx from "fivem/cfx";
+import { Quaternion } from "../common/utils/Quaternion";
+class BaseEntity {
+  static {
+    __name(this, "BaseEntity");
+  }
+  static fromNetworkId(networkId) {
+    return new BaseEntity(NetworkGetEntityFromNetworkId(networkId));
+  }
+  static fromStateBagName(stateBagName) {
+    const entity = GetEntityFromStateBagName(stateBagName);
+    if (entity === 0) return null;
+    return new BaseEntity(entity);
+  }
+  handle;
+  bones;
+  stateBagCookies = [];
+  netId = null;
+  type = ClassTypes.Entity;
+  constructor(handle) {
+    this.handle = handle;
+    if (this.IsNetworked) {
+      this.netId = this.NetworkId;
+    }
+  }
+  get Handle() {
+    return this.handle;
+  }
+  /**
+   * @returns if the entity is a networked entity or local entity
+   */
+  get IsNetworked() {
+    return NetworkGetEntityIsNetworked(this.handle);
+  }
+  set IsNetworked(networked) {
+    if (networked) {
+      NetworkRegisterEntityAsNetworked(this.handle);
+    } else {
+      NetworkUnregisterNetworkedEntity(this.handle);
+    }
+  }
+  get NetworkId() {
+    if (this.netId) {
+      return this.netId;
+    }
+    return NetworkGetNetworkIdFromEntity(this.handle);
+  }
+  get IsNetworkConcealed() {
+    return NetworkIsEntityConcealed(this.handle);
+  }
+  set IsNetworkConcealed(concealed) {
+    NetworkConcealEntity(this.handle, concealed);
+  }
+  get State() {
+    return cfx.Entity(this.handle).state;
+  }
+  AddStateBagChangeHandler(keyFilter, handler) {
+    const stateBagName = this.IsNetworked ? `entity:${this.NetworkId}` : `localEntity:${this.handle}`;
+    const cookie = AddStateBagChangeHandler(keyFilter, stateBagName, 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;
+    });
+  }
+  get Owner() {
+    return NetworkGetEntityOwner(this.handle);
+  }
+  // public isPlayerOwner(player: Player): boolean {
+  //     return this.Owner === player.Handle;
+  // }
+  get Speed() {
+    return GetEntitySpeed(this.handle);
+  }
+  getSpeedVector(isRelative = false) {
+    return Vector3.fromArray(GetEntitySpeedVector(this.handle, isRelative));
+  }
+  get ForwardVector() {
+    return Vector3.fromArray(GetEntityForwardVector(this.handle));
+  }
+  get Matrix() {
+    return Vector3.fromArrays(GetEntityMatrix(this.handle));
+  }
+  set Matrix(vectors) {
+    if (vectors.length !== 4) throw Error(`Expected 4 Vectors, got ${vectors.length}`);
+    const [forward, right, up, pos] = vectors;
+    SetEntityMatrix(
+      this.handle,
+      forward.x,
+      forward.y,
+      forward.z,
+      right.x,
+      right.y,
+      right.z,
+      up.x,
+      up.y,
+      up.z,
+      pos.x,
+      pos.y,
+      pos.z
+    );
+  }
+  get Health() {
+    return GetEntityHealth(this.handle);
+  }
+  set Health(amount) {
+    SetEntityHealth(this.handle, amount);
+  }
+  get MaxHealth() {
+    return GetEntityMaxHealth(this.handle);
+  }
+  set MaxHealth(amount) {
+    SetEntityMaxHealth(this.handle, amount);
+  }
+  set IsDead(value) {
+    if (value) {
+      SetEntityHealth(this.handle, 0);
+    } else {
+      SetEntityHealth(this.handle, 200);
+    }
+  }
+  get IsDead() {
+    return IsEntityDead(this.handle);
+  }
+  get IsAlive() {
+    return !IsEntityDead(this.handle);
+  }
+  /**
+   * @deprecated use [[IsDead]] instead
+   */
+  isDead() {
+    return IsEntityDead(this.handle);
+  }
+  /**
+   * @deprecated use [[IsAlive]] instead
+   */
+  isAlive() {
+    return !this.isDead();
+  }
+  get Model() {
+    return new Model(GetEntityModel(this.handle));
+  }
+  /**
+   * Returns if the entity is set as a mission entity and will not be cleaned up by the engine
+   */
+  get IsMissionEntity() {
+    return IsEntityAMissionEntity(this.handle);
+  }
+  /**
+   * Sets if the entity is a mission entity and will not be cleaned up by the engine
+   */
+  set IsMissionEntity(value) {
+    if (value) {
+      SetEntityAsMissionEntity(this.handle, false, false);
+    } else {
+      SetEntityAsNoLongerNeeded(this.handle);
+    }
+  }
+  get Position() {
+    return Vector3.fromArray(GetEntityCoords(this.handle, false));
+  }
+  set Position(position) {
+    SetEntityCoords(this.handle, position.x, position.y, position.z, false, false, false, true);
+  }
+  set PositionNoOffset(position) {
+    SetEntityCoordsNoOffset(this.handle, position.x, position.y, position.z, true, true, true);
+  }
+  get Rotation() {
+    return Vector3.fromArray(GetEntityRotation(this.handle, 2));
+  }
+  set Rotation(rotation) {
+    SetEntityRotation(this.handle, rotation.x, rotation.y, rotation.z, 2, true);
+  }
+  get Quaternion() {
+    const quaternion = GetEntityQuaternion(this.handle);
+    return new Quaternion(quaternion[0], quaternion[1], quaternion[2], quaternion[3]);
+  }
+  set Quaternion(quaternion) {
+    SetEntityQuaternion(this.handle, quaternion.x, quaternion.y, quaternion.z, quaternion.w);
+  }
+  get Heading() {
+    return GetEntityHeading(this.handle);
+  }
+  set Heading(heading) {
+    SetEntityHeading(this.handle, heading);
+  }
+  get IsPositionFrozen() {
+    return IsEntityPositionFrozen(this.handle);
+  }
+  set IsPositionFrozen(value) {
+    FreezeEntityPosition(this.handle, value);
+  }
+  get Velocity() {
+    return Vector3.fromArray(GetEntityVelocity(this.handle));
+  }
+  set Velocity(velocity) {
+    SetEntityVelocity(this.handle, velocity.x, velocity.y, velocity.z);
+  }
+  get RotationVelocity() {
+    return Vector3.fromArray(GetEntityRotationVelocity(this.handle));
+  }
+  set MaxSpeed(value) {
+    SetEntityMaxSpeed(this.handle, value);
+  }
+  set HasGravity(value) {
+    SetEntityHasGravity(this.handle, value);
+  }
+  get HeightAboveGround() {
+    return GetEntityHeightAboveGround(this.handle);
+  }
+  get SubmersionLevel() {
+    return GetEntitySubmergedLevel(this.handle);
+  }
+  get LodDistance() {
+    return GetEntityLodDist(this.handle);
+  }
+  set LodDistance(value) {
+    SetEntityLodDist(this.handle, value);
+  }
+  get IsVisible() {
+    return IsEntityVisible(this.handle);
+  }
+  set IsVisible(value) {
+    SetEntityVisible(this.handle, value, false);
+  }
+  get IsOccluded() {
+    return IsEntityOccluded(this.handle);
+  }
+  get IsOnScreen() {
+    return IsEntityOnScreen(this.handle);
+  }
+  get IsUpright() {
+    return IsEntityUpright(this.handle, 0);
+  }
+  get IsUpsideDown() {
+    return IsEntityUpsidedown(this.handle);
+  }
+  get IsInAir() {
+    return IsEntityInAir(this.handle);
+  }
+  get IsInWater() {
+    return IsEntityInWater(this.handle);
+  }
+  /**
+   * @deprecated use [[IsMissionEntity]] instead as its more obvious as what it does
+   */
+  get IsPersistent() {
+    return IsEntityAMissionEntity(this.handle);
+  }
+  /**
+   * @deprecated use [[IsMissionEntity]] instead as its more obvious as what it does
+   */
+  set IsPersistent(value) {
+    if (value) {
+      SetEntityAsMissionEntity(this.handle, true, false);
+    } else {
+      SetEntityAsNoLongerNeeded(this.handle);
+    }
+  }
+  get IsOnFire() {
+    return IsEntityOnFire(this.handle);
+  }
+  set IsInvincible(value) {
+    SetEntityInvincible(this.handle, value);
+  }
+  set IsOnlyDamagedByPlayer(value) {
+    SetEntityOnlyDamagedByPlayer(this.handle, value);
+  }
+  get Opacity() {
+    return GetEntityAlpha(this.handle);
+  }
+  /**
+   * Sets how transparent an entity is, if you want to reset the alpha level use [[resetOpacity]] instead;
+   */
+  set Opacity(value) {
+    SetEntityAlpha(this.handle, value, false);
+  }
+  resetOpacity() {
+    ResetEntityAlpha(this.handle);
+  }
+  get HasCollided() {
+    return HasEntityCollidedWithAnything(this.handle);
+  }
+  get MaterialCollidingWith() {
+    return GetLastMaterialHitByEntity(this.handle);
+  }
+  get IsCollisionEnabled() {
+    return !GetEntityCollisonDisabled(this.handle);
+  }
+  set IsCollisionEnabled(value) {
+    SetEntityCollision(this.handle, value, false);
+  }
+  set IsRecordingCollisions(value) {
+    SetEntityRecordsCollisions(this.handle, value);
+  }
+  get Bones() {
+    if (!this.bones) {
+      this.bones = new EntityBoneCollection(this);
+    }
+    return this.bones;
+  }
+  get AttachedBlip() {
+    const handle = GetBlipFromEntity(this.handle);
+    if (DoesBlipExist(handle)) {
+      return new Blip(handle);
+    }
+    return null;
+  }
+  attachBlip() {
+    return new Blip(AddBlipForEntity(this.handle));
+  }
+  setNoCollision(entity, toggle) {
+    SetEntityNoCollisionEntity(this.handle, entity.Handle, toggle);
+  }
+  hasClearLosToEntity(entity, traceType = 17) {
+    return HasEntityClearLosToEntity(this.handle, entity.Handle, traceType);
+  }
+  hasClearLosToEntityInFront(entity) {
+    return HasEntityClearLosToEntityInFront(this.handle, entity.Handle);
+  }
+  hasBeenDamagedBy(entity) {
+    return HasEntityBeenDamagedByEntity(this.handle, entity.Handle, true);
+  }
+  hasBeenDamagedByWeapon(weapon) {
+    return HasEntityBeenDamagedByWeapon(this.handle, Number(weapon), 0);
+  }
+  hasBeenDamagedByAnyWeapon() {
+    return HasEntityBeenDamagedByWeapon(this.handle, 0, 2);
+  }
+  hasBeenDamagedByAnyMeleeWeapon() {
+    return HasEntityBeenDamagedByWeapon(this.handle, 0, 1);
+  }
+  clearLastWeaponDamage() {
+    ClearEntityLastWeaponDamage(this.handle);
+  }
+  isInArea(minBounds, maxBounds) {
+    return IsEntityInArea(
+      this.handle,
+      minBounds.x,
+      minBounds.y,
+      minBounds.z,
+      maxBounds.x,
+      maxBounds.y,
+      maxBounds.z,
+      false,
+      false,
+      0
+    );
+  }
+  isInAngledArea(origin, edge, angle) {
+    return IsEntityInAngledArea(
+      this.handle,
+      origin.x,
+      origin.y,
+      origin.z,
+      edge.x,
+      edge.y,
+      edge.z,
+      angle,
+      false,
+      true,
+      0
+    );
+  }
+  isInRangeOf(position, range) {
+    const v = Vector3.subtract(this.Position, position);
+    return v.dotProduct(v) < range * range;
+  }
+  isNearEntity(entity, bounds) {
+    return IsEntityAtEntity(this.handle, entity.Handle, bounds.x, bounds.y, bounds.z, false, true, 0);
+  }
+  isTouching(entity) {
+    return IsEntityTouchingEntity(this.handle, entity.Handle);
+  }
+  isTouchingModel(model) {
+    return IsEntityTouchingModel(this.handle, model.Hash);
+  }
+  /**
+   * @param offset: the amount to offset from the entity
+   * @returns the offset position from the entity in world coords
+   */
+  getOffsetInRelativeCoords(worldCoords) {
+    return Vector3.fromArray(
+      GetOffsetFromEntityGivenWorldCoords(this.handle, worldCoords.x, worldCoords.y, worldCoords.z)
+    );
+  }
+  // TODO: Better example
+  /**
+   * @example
+   * ```typescript
+   * const ply = Game.PlayerPed;
+   * const plyPos = ply.Position;
+   * const bag = await World.createProp(new Model('ba_prop_battle_bag_01b'), plyPos, true, true, true);
+   * bag.attachToBone(
+   *     ply.Bones.getBone(64113),
+   *     new Vector3(0.12, -0.25, 0.0),
+   *     new Vector3(105.0, 50.0, 190.0)
+   * )
+   * const offset = bag.getRelativePositionOffset(plyPos);
+   * ```
+   * @param worldCoords: the offset given the world coords
+   * @returns the offset position from the entity in relative coords
+   */
+  getOffsetInWorldCoords(offset) {
+    return Vector3.fromArray(GetOffsetFromEntityInWorldCoords(this.handle, offset.x, offset.y, offset.z));
+  }
+  /**
+   * @deprecated use [[getOffsetInRelativeCoords]] instead
+   */
+  getPositionOffset(worldCoords) {
+    return this.getOffsetInRelativeCoords(worldCoords);
+  }
+  /**
+   * @deprecated use [[getOffsetInWorldCoords]]
+   */
+  getOffsetPosition(offset) {
+    return this.getOffsetInWorldCoords(offset);
+  }
+  attachTo(entity, position, rotation, collisions = false, unk9 = true, useSoftPinning = true, rotationOrder = 1) {
+    if (this.handle === entity.Handle) {
+      throw new Error("You cannot attach an entity to the same entity this will result in a crash!");
+    }
+    AttachEntityToEntity(
+      this.handle,
+      entity.Handle,
+      -1,
+      position.x,
+      position.y,
+      position.z,
+      rotation.x,
+      rotation.y,
+      rotation.z,
+      unk9,
+      useSoftPinning,
+      collisions,
+      IsEntityAPed(entity.Handle),
+      rotationOrder,
+      true
+    );
+  }
+  /*
+   * Attaches an entity to another entity via a bone
+   * @example
+   * ```typescript
+   * const ply = Game.PlayerPed;
+   * const bag = await World.createProp(new Model('ba_prop_battle_bag_01b'), ply.Position, true, true, true);
+   * bag.attachToBone(
+   *     ply.Bones.getBone(64113),
+   *     new Vector3(0.12, -0.25, 0.0),
+   *     new Vector3(105.0, 50.0, 190.0)
+   * )
+   * ```
+   */
+  attachToBone(entityBone, position, rotation, collisions = false, unk9 = true, useSoftPinning = true, rotationOrder = 1) {
+    if (this.handle === entityBone.Owner.Handle) {
+      throw new Error("You cannot attach an entity to the same entity this will result in a crash!");
+    }
+    AttachEntityToEntity(
+      this.handle,
+      entityBone.Owner.Handle,
+      entityBone.Index,
+      position.x,
+      position.y,
+      position.z,
+      rotation.x,
+      rotation.y,
+      rotation.z,
+      unk9,
+      useSoftPinning,
+      collisions,
+      IsEntityAPed(entityBone.Owner.Handle),
+      rotationOrder,
+      true
+    );
+  }
+  detach() {
+    DetachEntity(this.handle, true, true);
+  }
+  isAttached() {
+    return IsEntityAttached(this.handle);
+  }
+  isAttachedTo(entity) {
+    return IsEntityAttachedToEntity(this.handle, entity.Handle);
+  }
+  getEntityAttachedTo() {
+    return new BaseEntity(GetEntityAttachedTo(this.handle));
+  }
+  applyForce(direction, rotation, forceType = ForceType.MaxForceRot2) {
+    ApplyForceToEntity(
+      this.handle,
+      Number(forceType),
+      direction.x,
+      direction.y,
+      direction.z,
+      rotation.x,
+      rotation.y,
+      rotation.z,
+      0,
+      false,
+      true,
+      true,
+      false,
+      true
+    );
+  }
+  applyForceRelative(direction, rotation, forceType = ForceType.MaxForceRot2) {
+    ApplyForceToEntity(
+      this.handle,
+      Number(forceType),
+      direction.x,
+      direction.y,
+      direction.z,
+      rotation.x,
+      rotation.y,
+      rotation.z,
+      0,
+      true,
+      true,
+      true,
+      false,
+      true
+    );
+  }
+  /**
+   * Removes all particle effects from the entity
+   */
+  removePtfxEffects() {
+    RemoveParticleFxFromEntity(this.handle);
+  }
+  /**
+   * @deprecated use [[removePtfxEffects]]
+   */
+  removeAllParticleEffects() {
+    this.removePtfxEffects();
+  }
+  exists() {
+    return DoesEntityExist(this.handle);
+  }
+  delete() {
+    this.IsMissionEntity = true;
+    DeleteEntity(this.handle);
+    for (const cookie of this.stateBagCookies) {
+      RemoveStateBagChangeHandler(cookie);
+    }
+  }
+  /**
+   * @deprecated use [[IsMissionEntity]] setter as false instead.
+   */
+  markAsNoLongerNeeded() {
+    SetEntityAsNoLongerNeeded(this.Handle);
+  }
+}
+export {
+  BaseEntity
+};

package/models/Entity.d.ts

@@ -1 +0,0 @@
-export {};

package/models/EntityBone.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from "../utils";
+import { Vector3 } from "../common/utils/Vector";
 import type { BaseEntity } from "./BaseEntity";
 export declare class EntityBone {
     get Index(): number;

package/models/EntityBone.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "../common/utils/Vector";
+class EntityBone {
+  static {
+    __name(this, "EntityBone");
+  }
+  get Index() {
+    return this.index;
+  }
+  get Owner() {
+    return this.owner;
+  }
+  get Position() {
+    return Vector3.fromArray(GetWorldPositionOfEntityBone(this.owner.Handle, this.index));
+  }
+  get Rotation() {
+    return Vector3.fromArray(GetEntityBoneRotation(this.owner.Handle, this.index));
+  }
+  get IsValid() {
+    return this.owner.exists() && this.index !== -1;
+  }
+  owner;
+  index;
+  constructor(owner, boneIndex, boneName) {
+    this.owner = owner;
+    this.index = boneIndex ? boneIndex : GetEntityBoneIndexByName(this.owner.Handle, boneName ?? "");
+  }
+}
+export {
+  EntityBone
+};

package/models/EntityBoneCollection.d.ts

@@ -1,5 +1,5 @@
-import { EntityBone } from "./";
 import type { BaseEntity } from "./BaseEntity";
+import { EntityBone } from "./EntityBone";
 export declare class EntityBoneCollection {
     protected readonly owner: BaseEntity;
     constructor(owner: BaseEntity);

package/models/EntityBoneCollection.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { EntityBone } from "./EntityBone";
+class EntityBoneCollection {
+  static {
+    __name(this, "EntityBoneCollection");
+  }
+  owner;
+  constructor(owner) {
+    this.owner = owner;
+  }
+  hasBone(name) {
+    return GetEntityBoneIndexByName(this.owner.Handle, name) !== -1;
+  }
+  getBone(boneIndex, boneName) {
+    return new EntityBone(
+      this.owner,
+      boneIndex ? boneIndex : GetEntityBoneIndexByName(this.owner.Handle, boneName ?? "")
+    );
+  }
+  get Core() {
+    return new EntityBone(this.owner, -1);
+  }
+}
+export {
+  EntityBoneCollection
+};