@nativewrappers/fivem 0.0.80 → 0.0.81

package/models/PedBone.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { EntityBone } from "./EntityBone";
+import { Ped } from "./Ped";
+class PedBone extends EntityBone {
+  static {
+    __name(this, "PedBone");
+  }
+  constructor(owner, boneId) {
+    super(owner, GetPedBoneIndex(owner.Handle, Number(boneId)));
+  }
+  get IsValid() {
+    return Ped.exists(this.Owner) && this.Index !== -1;
+  }
+}
+export {
+  PedBone
+};

package/models/PedBoneCollection.d.ts

@@ -1,4 +1,6 @@
-import { EntityBoneCollection, type Ped, PedBone } from "./";
+import { EntityBoneCollection } from "./EntityBoneCollection";
+import type { Ped } from "./Ped";
+import { PedBone } from "./PedBone";
 export declare class PedBoneCollection extends EntityBoneCollection {
     constructor(owner: Ped);
     get Core(): PedBone;

package/models/PedBoneCollection.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { EntityBoneCollection } from "./EntityBoneCollection";
+import { PedBone } from "./PedBone";
+class PedBoneCollection extends EntityBoneCollection {
+  static {
+    __name(this, "PedBoneCollection");
+  }
+  constructor(owner) {
+    super(owner);
+  }
+  get Core() {
+    return new PedBone(this.owner, -1);
+  }
+  get LastDamaged() {
+    const [, outBone] = GetPedLastDamageBone(this.owner.Handle, 0);
+    return PedBone[outBone];
+  }
+  clearLastDamaged() {
+    ClearPedLastDamageBone(this.owner.Handle);
+  }
+  getBone(boneIndex, boneName) {
+    return new PedBone(
+      this.owner,
+      boneIndex ? boneIndex : GetEntityBoneIndexByName(this.owner.Handle, boneName ?? "")
+    );
+  }
+}
+export {
+  PedBoneCollection
+};

package/models/Player.d.ts

@@ -1,6 +1,8 @@
-import { Model, Color } from "..";
 import { type StateBagChangeHandler } from "../cfx";
-import { BaseEntity, Ped } from "./";
+import { Color } from "../common/utils/Color";
+import { Model } from "fivem/Model";
+import { BaseEntity } from "./BaseEntity";
+import { Ped } from "./Ped";
 export declare class Player {
     private handle;
     private ped?;

package/models/Player.js

@@ -0,0 +1,188 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import cfx from "../cfx";
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { Color } from "../common/utils/Color";
+import { Model } from "fivem/Model";
+import { BaseEntity } from "./BaseEntity";
+import { Ped } from "./Ped";
+class Player {
+  static {
+    __name(this, "Player");
+  }
+  handle;
+  ped;
+  pvp = false;
+  stateBagCookies = [];
+  source;
+  type = ClassTypes.Player;
+  static fromPedHandle(handle) {
+    return new Player(NetworkGetPlayerIndexFromPed(handle));
+  }
+  static fromServerId(serverId) {
+    return new Player(GetPlayerFromServerId(serverId));
+  }
+  /**
+   * @param handle the player handle, or if on the server, their source.
+   */
+  constructor(handle = -1) {
+    this.handle = handle;
+    this.source = this.ServerId;
+    if (!IsDuplicityVersion()) {
+      this.PvPEnabled = true;
+    }
+  }
+  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 Ped(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 PvPEnabled() {
+    return this.pvp;
+  }
+  set PvPEnabled(value) {
+    NetworkSetFriendlyFireOption(value);
+    SetCanAttackFriendly(this.Character.Handle, value, value);
+    this.pvp = value;
+  }
+  get IsDead() {
+    return IsPlayerDead(this.handle);
+  }
+  set DisableFiring(value) {
+    DisablePlayerFiring(this.handle, value);
+  }
+  set Ghosted(isGhosted) {
+    if (this.Handle === 128) {
+      SetLocalPlayerAsGhost(isGhosted);
+    } else {
+      SetRelationshipToPlayer(this.handle, isGhosted);
+    }
+  }
+  get EntityPlayerIsAimingAt() {
+    const [entityHit, entity] = GetEntityPlayerIsFreeAimingAt(this.handle);
+    if (entityHit) {
+      return new BaseEntity(entity);
+    }
+    return null;
+  }
+  get StealthNoise() {
+    return GetPlayerCurrentStealthNoise(this.handle);
+  }
+  get FakeWantedLevel() {
+    return GetPlayerFakeWantedLevel(this.handle);
+  }
+  get PlayerGroup() {
+    return GetPlayerGroup(this.handle);
+  }
+  get HasReserveParachute() {
+    return GetPlayerHasReserveParachute(this.handle);
+  }
+  get HealthRechargeLimit() {
+    return GetPlayerHealthRechargeLimit(this.handle);
+  }
+  get IsInvincible() {
+    if (IsDuplicityVersion()) {
+      return GetPlayerInvincible(this.handle);
+    }
+    return GetPlayerInvincible_2(this.handle);
+  }
+  get MaxArmor() {
+    return GetPlayerMaxArmour(this.handle);
+  }
+  get ParachuteModelOverride() {
+    return new Model(GetPlayerParachuteModelOverride(this.handle));
+  }
+  get ParachutePackTintIndex() {
+    return GetPlayerParachutePackTintIndex(this.handle);
+  }
+  get ParachuteTintIndex() {
+    return GetPlayerParachuteTintIndex(this.handle);
+  }
+  get ParachuteColorTrailColor() {
+    return Color.fromArray(GetPlayerParachuteSmokeTrailColor(this.handle));
+  }
+  get ReserveParachuteModelOverride() {
+    return new Model(GetPlayerReserveParachuteModelOverride(this.handle));
+  }
+  get ReserveParachuteTintIndex() {
+    return GetPlayerReserveParachuteTintIndex(this.handle);
+  }
+  get PlayerRgbColour() {
+    return Color.fromArray(GetPlayerRgbColour(this.handle));
+  }
+  get Stamina() {
+    return GetPlayerSprintStaminaRemaining(this.handle);
+  }
+  get SprintTimeRemaining() {
+    return GetPlayerSprintStaminaRemaining(this.handle);
+  }
+  /**
+   * The players melee target?
+   */
+  get TargetEntity() {
+    const [entityHit, entity] = GetPlayerTargetEntity(this.handle);
+    if (entityHit) {
+      return new BaseEntity(entity);
+    }
+    return null;
+  }
+  get Team() {
+    return GetPlayerTeam(this.handle);
+  }
+  // GetPlayerUnderwaterTimeRemaining
+  CanPedHearPlayer(ped) {
+    return CanPedHearPlayer(this.handle, ped.Handle);
+  }
+}
+export {
+  Player
+};

package/models/Prop.d.ts

@@ -1,4 +1,4 @@
-import { ClassTypes } from "../../common/utils/ClassTypes";
+import { ClassTypes } from "../common/utils/ClassTypes";
 import { BaseEntity } from "./BaseEntity";
 export declare class Prop extends BaseEntity {
     static exists(prop: Prop): boolean;

package/models/Prop.js

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

package/models/Vehicle.d.ts

@@ -1,9 +1,14 @@
-import { Ped, VehicleDoorCollection, VehicleModCollection, VehicleWheelCollection, VehicleWindowCollection } from "./";
-import { type RadioStation, type VehicleClass, type VehicleLandingGearState, type VehicleLockStatus, VehicleRoofState, VehicleSeat } from "../enums";
-import type { Model } from "../Model";
-import { Vector3 } from "../utils";
+import { Vector3 } from "../common/utils/Vector";
+import type { RadioStation } from "fivem/enums/RadioStation";
+import { type VehicleClass, type VehicleLandingGearState, VehicleRoofState, type VehicleLockStatus, VehicleSeat } from "fivem/enums/Vehicle";
+import type { Model } from "fivem/Model";
 import { ClassTypes } from "../../common/utils/ClassTypes";
 import { BaseEntity } from "./BaseEntity";
+import { Ped } from "./Ped";
+import { VehicleDoorCollection } from "./VehicleDoorCollection";
+import { VehicleModCollection } from "./VehicleModCollection";
+import { VehicleWheelCollection } from "./VehicleWheelCollection";
+import { VehicleWindowCollection } from "./VehicleWindowCollection";
 export declare class Vehicle extends BaseEntity {
     static getModelDisplayName(vehicleModel: Model): string;
     static getModelClass(vehicleModel: Model): VehicleClass;