@nativewrappers/common-game 0.0.114

package/entities/CommonBaseEntity.d.ts

@@ -0,0 +1,66 @@
+import type { ClassTypes } from "../common/utils/ClassTypes";
+import { Quaternion } from "../common/utils/Quaternion";
+import { Vector3 } from "../common/utils/Vector";
+import type { CommonBaseEntityBoneCollection } from "./CommonBaseEntityBoneCollection";
+import type { StateBagChangeHandler } from "common-game/cfx/StateBagChangeHandler";
+import { CommonModel } from "common-game/CommonModel";
+export declare abstract class CommonBaseEntity {
+    protected handle: number;
+    protected stateBagCookies: number[];
+    protected netId: number | null;
+    protected abstract type: ClassTypes;
+    protected abstract bones?: CommonBaseEntityBoneCollection;
+    constructor(handle: number);
+    get Handle(): number;
+    /**
+     * @returns if the entity is a networked entity or local entity
+     */
+    get IsNetworked(): boolean;
+    set IsNetworked(networked: boolean);
+    get NetworkId(): number;
+    get State(): StateBagInterface;
+    AddStateBagChangeHandler(keyFilter: string | null, handler: StateBagChangeHandler<unknown>): number;
+    /**
+     * 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: string | null, handler: StateBagChangeHandler<unknown>): number;
+    removeStateListener(tgtCookie: number): void;
+    get Owner(): number;
+    get Speed(): number;
+    getSpeedVector(isRelative?: boolean): Vector3;
+    get ForwardVector(): Vector3;
+    get Matrix(): Vector3[];
+    get Health(): number;
+    set Health(amount: number);
+    get MaxHealth(): number;
+    set MaxHealth(amount: number);
+    set IsDead(value: boolean);
+    get IsDead(): boolean;
+    get IsAlive(): boolean;
+    get Model(): CommonModel;
+    /**
+     * Returns if the entity is set as a mission entity and will not be cleaned up by the engine
+     */
+    get IsMissionEntity(): boolean;
+    /**
+     * Sets if the entity is a mission entity and will not be cleaned up by the engine
+     */
+    set IsMissionEntity(value: boolean);
+    get Position(): Vector3;
+    set Position(position: Vector3);
+    set PositionNoOffset(position: Vector3);
+    get Rotation(): Vector3;
+    set Rotation(rotation: Vector3);
+    set Quaternion(quaternion: Quaternion);
+    get Heading(): number;
+    set Heading(heading: number);
+    get IsPositionFrozen(): boolean;
+    set IsPositionFrozen(value: boolean);
+    get Velocity(): Vector3;
+    set Velocity(velocity: Vector3);
+    exists(): boolean;
+    delete(): void;
+}

package/entities/CommonBaseEntity.js

@@ -0,0 +1,180 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Quaternion } from "../common/utils/Quaternion";
+import { Vector3 } from "../common/utils/Vector";
+import cfx from "common-game/cfx/cfx";
+import { CommonModel } from "common-game/CommonModel";
+import { GlobalData } from "../common/GlobalData";
+class CommonBaseEntity {
+  static {
+    __name(this, "CommonBaseEntity");
+  }
+  handle;
+  stateBagCookies = [];
+  netId = null;
+  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 {
+      if (GlobalData.GameName === "redm") {
+        Citizen.invokeNative("0xE31A04513237DC89", this.handle);
+      } else {
+        NetworkUnregisterNetworkedEntity(this.handle);
+      }
+    }
+  }
+  get NetworkId() {
+    if (this.netId) {
+      return this.netId;
+    }
+    return NetworkGetNetworkIdFromEntity(this.handle);
+  }
+  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);
+  }
+  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));
+  }
+  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);
+  }
+  get Model() {
+    return new CommonModel(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);
+  }
+  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);
+  }
+  exists() {
+    return DoesEntityExist(this.handle);
+  }
+  delete() {
+    this.IsMissionEntity = true;
+    DeleteEntity(this.handle);
+    for (const cookie of this.stateBagCookies) {
+      RemoveStateBagChangeHandler(cookie);
+    }
+  }
+}
+export {
+  CommonBaseEntity
+};

package/entities/CommonBaseEntityBone.d.ts

@@ -0,0 +1,11 @@
+import { Vector3 } from "../common/utils/Vector";
+import type { CommonBaseEntity } from "./CommonBaseEntity";
+export declare abstract class CommonBaseEntityBone {
+    get Index(): number;
+    get Owner(): CommonBaseEntity;
+    get Position(): Vector3;
+    get IsValid(): boolean;
+    protected readonly owner: CommonBaseEntity;
+    protected readonly index: number;
+    constructor(owner: CommonBaseEntity, boneIndex?: number, boneName?: string);
+}

package/entities/CommonBaseEntityBone.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 CommonBaseEntityBone {
+  static {
+    __name(this, "CommonBaseEntityBone");
+  }
+  get Index() {
+    return this.index;
+  }
+  get Owner() {
+    return this.owner;
+  }
+  get Position() {
+    return Vector3.fromArray(GetWorldPositionOfEntityBone(this.owner.Handle, this.index));
+  }
+  // public get Rotation(): Vector3 {
+  //   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 {
+  CommonBaseEntityBone
+};

package/entities/CommonBaseEntityBoneCollection.d.ts

@@ -0,0 +1,9 @@
+import type { CommonBaseEntity } from "./CommonBaseEntity";
+import type { CommonBaseEntityBone } from "./CommonBaseEntityBone";
+export declare abstract class CommonBaseEntityBoneCollection {
+    protected readonly owner: CommonBaseEntity;
+    constructor(owner: CommonBaseEntity);
+    hasBone(name: string): boolean;
+    abstract getBone(boneIndex?: number, boneName?: string): CommonBaseEntityBone;
+    abstract get Core(): CommonBaseEntityBone;
+}

package/entities/CommonBaseEntityBoneCollection.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class CommonBaseEntityBoneCollection {
+  static {
+    __name(this, "CommonBaseEntityBoneCollection");
+  }
+  owner;
+  constructor(owner) {
+    this.owner = owner;
+  }
+  hasBone(name) {
+    return GetEntityBoneIndexByName(this.owner.Handle, name) !== -1;
+  }
+}
+export {
+  CommonBaseEntityBoneCollection
+};

package/entities/CommonEntityBone.d.ts

@@ -0,0 +1,5 @@
+import type { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonBaseEntityBone } from "./CommonBaseEntityBone";
+export declare class CommonEntityBone extends CommonBaseEntityBone {
+    constructor(owner: CommonBaseEntity, boneIndex?: number, boneName?: string);
+}

package/entities/CommonEntityBone.js

@@ -0,0 +1,14 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonBaseEntityBone } from "./CommonBaseEntityBone";
+class CommonEntityBone extends CommonBaseEntityBone {
+  static {
+    __name(this, "CommonEntityBone");
+  }
+  constructor(owner, boneIndex, boneName) {
+    super(owner, boneIndex, boneName);
+  }
+}
+export {
+  CommonEntityBone
+};

package/entities/CommonEntityBoneCollection.d.ts

@@ -0,0 +1,9 @@
+import type { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonBaseEntityBoneCollection } from "./CommonBaseEntityBoneCollection";
+import { CommonEntityBone } from "./CommonEntityBone";
+export declare class CommonEntityBoneCollection extends CommonBaseEntityBoneCollection {
+    constructor(owner: CommonBaseEntity);
+    getBone(boneIndex: number): CommonEntityBone;
+    getBone(boneName: string): CommonEntityBone;
+    get Core(): CommonEntityBone;
+}

package/entities/CommonEntityBoneCollection.js

@@ -0,0 +1,24 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonBaseEntityBoneCollection } from "./CommonBaseEntityBoneCollection";
+import { CommonEntityBone } from "./CommonEntityBone";
+class CommonEntityBoneCollection extends CommonBaseEntityBoneCollection {
+  static {
+    __name(this, "CommonEntityBoneCollection");
+  }
+  constructor(owner) {
+    super(owner);
+  }
+  getBone(bone) {
+    return new CommonEntityBone(
+      this.owner,
+      typeof bone === "number" ? bone : GetEntityBoneIndexByName(this.owner.Handle, bone ?? "")
+    );
+  }
+  get Core() {
+    return new CommonEntityBone(this.owner, -1);
+  }
+}
+export {
+  CommonEntityBoneCollection
+};

package/entities/CommonEntityType.d.ts

@@ -0,0 +1,4 @@
+import { CommonPed } from "./CommonPed";
+import { CommonProp } from "./CommonProp";
+import { CommonVehicle } from "./CommonVehicle";
+export type CommonEntity = CommonProp | CommonPed | CommonVehicle | null;

package/entities/CommonEntityType.js

@@ -0,0 +1,3 @@
+import { CommonPed } from "./CommonPed";
+import { CommonProp } from "./CommonProp";
+import { CommonVehicle } from "./CommonVehicle";

package/entities/CommonPed.d.ts

@@ -0,0 +1,17 @@
+import { CommonTasks } from "common-game/CommonTasks";
+import { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonPlayer } from "./CommonPlayer";
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { CommonPedBoneCollection } from "./CommonPedBoneCollection";
+export declare class CommonPed extends CommonBaseEntity {
+    private tasks;
+    protected type: ClassTypes;
+    protected bones?: CommonPedBoneCollection;
+    static exists(ped: CommonPed): boolean;
+    static fromHandle(handle: number): CommonPed | null;
+    static fromNetworkId(networkId: number): CommonPed | null;
+    constructor(handle: number);
+    get Player(): CommonPlayer | null;
+    get Task(): CommonTasks;
+    get Bones(): CommonPedBoneCollection;
+}

package/entities/CommonPed.js

@@ -0,0 +1,55 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonTasks } from "common-game/CommonTasks";
+import { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonPlayer } from "./CommonPlayer";
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { CommonPedBoneCollection } from "./CommonPedBoneCollection";
+class CommonPed extends CommonBaseEntity {
+  static {
+    __name(this, "CommonPed");
+  }
+  tasks;
+  type = ClassTypes.Ped;
+  bones;
+  static exists(ped) {
+    return typeof ped !== "undefined" && ped.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));
+  }
+  constructor(handle) {
+    super(handle);
+  }
+  get Player() {
+    const playerIndex = NetworkGetPlayerIndexFromPed(this.handle);
+    if (playerIndex === -1) {
+      return null;
+    }
+    return new CommonPlayer(playerIndex);
+  }
+  get Task() {
+    if (!this.tasks) {
+      this.tasks = new CommonTasks(this);
+    }
+    return this.tasks;
+  }
+  get Bones() {
+    if (!this.bones) {
+      this.bones = new CommonPedBoneCollection(this);
+    }
+    return this.bones;
+  }
+}
+export {
+  CommonPed
+};

package/entities/CommonPedBone.d.ts

@@ -0,0 +1,6 @@
+import { CommonBaseEntityBone } from "./CommonBaseEntityBone";
+import type { CommonPed } from "./CommonPed";
+export declare class CommonPedBone extends CommonBaseEntityBone {
+    constructor(owner: CommonPed, boneId: number);
+    get IsValid(): boolean;
+}

package/entities/CommonPedBone.js

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

package/entities/CommonPedBoneCollection.d.ts

@@ -0,0 +1,10 @@
+import { CommonBaseEntityBoneCollection } from "./CommonBaseEntityBoneCollection";
+import type { CommonPed } from "./CommonPed";
+import { CommonPedBone } from "./CommonPedBone";
+export declare class CommonPedBoneCollection extends CommonBaseEntityBoneCollection {
+    constructor(owner: CommonPed);
+    get Core(): CommonPedBone;
+    get LastDamaged(): CommonPedBone;
+    clearLastDamaged(): void;
+    getBone(boneIndex?: number, boneName?: string): CommonPedBone;
+}

package/entities/CommonPedBoneCollection.js

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

package/entities/CommonPlayer.d.ts

@@ -0,0 +1,61 @@
+import type { StateBagChangeHandler } from "common-game/cfx/StateBagChangeHandler";
+import { CommonPed } from "./CommonPed";
+import type { CommonEntity } from "./CommonEntityType";
+export declare class CommonPlayer {
+    private handle;
+    private ped?;
+    private pvp;
+    private stateBagCookies;
+    private source;
+    private type;
+    static AllPlayers(excludeLocalPlayer?: boolean): IterableIterator<CommonPlayer>;
+    /**
+     * @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: number): CommonPlayer | null;
+    /**
+     * @param serverId the server id to get the player of
+     * @returns the player, or null if the player doesn't exist
+     */
+    static fromServerId(serverId: number): CommonPlayer | null;
+    /**
+     * @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, fromPlayer?: CommonPlayer): [CommonPed | null, number];
+    /**
+     * @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, fromPlayer?: CommonPlayer): CommonPed | null;
+    /**
+     * @param handle the player handle, or if on the server, their source.
+     */
+    constructor(handle?: number);
+    get Handle(): number;
+    /**
+     * This is here for compatibility with older versions.
+     */
+    get Character(): CommonPed;
+    get Ped(): CommonPed;
+    get ServerId(): number;
+    get State(): StateBagInterface;
+    AddStateBagChangeHandler(keyFilter: string | null, handler: StateBagChangeHandler<unknown>): number;
+    /**
+     * 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: string | null, handler: StateBagChangeHandler<unknown>): number;
+    removeStateListener(tgtCookie: number): void;
+    removeAllStateListeners(): void;
+    get Name(): string;
+    get IsDead(): boolean;
+    set DisableFiring(value: boolean);
+    get EntityPlayerIsAimingAt(): CommonEntity | null;
+    get StealthNoise(): number;
+}