@nativewrappers/common 0.0.125 → 0.0.127

package/common-game/CommonGameConstants.d.ts

@@ -0,0 +1,7 @@
+import { CommonPlayer } from "./entities/CommonPlayer";
+export declare class GameConstants {
+    private static player;
+    static readonly PlayerId: number;
+    static readonly ServerId: number;
+    static get Player(): CommonPlayer;
+}

package/common-game/CommonGameConstants.js

@@ -0,0 +1,24 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonPlayer } from "./entities/CommonPlayer";
+class GameConstants {
+  static {
+    __name(this, "GameConstants");
+  }
+  // the actual player object that will get initialized on the first call to the `get Player()`
+  static player = null;
+  // The player id of the local client
+  static PlayerId = PlayerId();
+  // The server id of the local client.
+  static ServerId = GetPlayerServerId(GameConstants.PlayerId);
+  // The player class of the local object
+  static get Player() {
+    if (GameConstants.player === null) {
+      GameConstants.player = new CommonPlayer(GameConstants.PlayerId);
+    }
+    return GameConstants.player;
+  }
+}
+export {
+  GameConstants
+};

package/common-game/CommonModel.d.ts

@@ -0,0 +1,99 @@
+import type { Dimensions } from "./interfaces/Dimension";
+export declare class CommonModel implements Disposable {
+    /**
+     * Hash of this model.
+     */
+    protected hash: number;
+    protected requestCount: number;
+    /**
+     * Returns the amount of times this model has been requested from the client, useful for finding situations where the client fails to release the ref
+     */
+    get RequestCount(): number;
+    /**
+     * 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: number | string);
+    [Symbol.dispose](): void;
+    /**
+     * Gets the hash of the model.
+     *
+     * @returns The hash key.
+     */
+    get Hash(): number;
+    /**
+     * Gets if the model is valid or not.
+     *
+     * @returns Whether this model is valid.
+     */
+    get IsValid(): boolean;
+    /**
+     * Gets if the model is in cd image or not.
+     *
+     * @returns Whether this model is in cd image.
+     */
+    get IsInCdImage(): boolean;
+    /**
+     * Gets if the model is loaded or not.
+     *
+     * @returns Whether this model is loaded.
+     */
+    get IsLoaded(): boolean;
+    /**
+     * Gets if the model collision is loaded or not.
+     *
+     * @returns Whether this model collision is loaded.
+     */
+    get IsCollisionLoaded(): boolean;
+    /**
+     * Gets if the model is a boat or not.
+     *
+     * @returns Whether this model is a boat.
+     */
+    get IsBoat(): boolean;
+    /**
+     * Gets if the model is a Ped or not.
+     *
+     * @returns Whether this model is a Ped.
+     */
+    get IsPed(): boolean;
+    /**
+     * Gets if the model is a prop or not.
+     *
+     * @returns Whether this model is a prop.
+     */
+    get IsProp(): boolean;
+    /**
+     * Gets if the model is a train or not.
+     *
+     * @returns Whether this model is a train.
+     */
+    get IsTrain(): boolean;
+    /**
+     * Gets if the model is a Vehicle or not.
+     *
+     * @returns Whether this model is a Vehicle.
+     */
+    get IsVehicle(): boolean;
+    get IsWeapon(): boolean;
+    /**
+     * Gets the model dimensions.
+     *
+     * @returns This model min & max dimensions.
+     */
+    get Dimensions(): Dimensions;
+    requestModel(): void;
+    /**
+     * 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.
+     */
+    request(timeoutMs?: number): Promise<boolean>;
+    /**
+     * Sets the model as no longer needed allowing the game engine to free memory.
+     */
+    markAsNoLongerNeeded(): void;
+}

package/common-game/CommonModel.js

@@ -0,0 +1,172 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Delay } from "./common/utils/Delay";
+import { Vector3 } from "./common/utils/Vector";
+class CommonModel {
+  static {
+    __name(this, "CommonModel");
+  }
+  /**
+   * Hash of this model.
+   */
+  hash;
+  requestCount = 0;
+  /**
+   * Returns the amount of times this model has been requested from the client, useful for finding situations where the client fails to release the ref
+   */
+  get RequestCount() {
+    return this.requestCount;
+  }
+  /**
+   * 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 = GetHashKey(hash);
+    } else {
+      this.hash = hash;
+    }
+  }
+  [Symbol.dispose]() {
+    if (this.requestCount > 0) {
+      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() {
+    if (this.IsWeapon) {
+      return Citizen.invokeNative("0xFF07CF465F48B830", this.hash);
+    }
+    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 boat or not.
+   *
+   * @returns Whether this model is a boat.
+   */
+  get IsBoat() {
+    return IsThisModelABoat(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 prop or not.
+   *
+   * @returns Whether this model is a prop.
+   */
+  get IsProp() {
+    return this.IsValid && !this.IsPed && !this.IsVehicle && !this.IsWeapon;
+  }
+  /**
+   * 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);
+  }
+  get IsWeapon() {
+    return IsWeaponValid(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 };
+  }
+  // TODO: Metaped stuff too at some point
+  requestModel() {
+    RequestModel(this.hash, false);
+    this.requestCount++;
+  }
+  /**
+   * 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 && !this.IsWeapon) {
+      return false;
+    }
+    if (this.IsLoaded) {
+      return true;
+    }
+    this.requestModel();
+    const timeout = GetGameTimer() + timeoutMs;
+    while (!this.IsLoaded && GetGameTimer() < timeout) {
+      await Delay(0);
+    }
+    if (!this.IsLoaded) {
+      this.markAsNoLongerNeeded();
+    }
+    return this.IsLoaded;
+  }
+  /**
+   * Sets the model as no longer needed allowing the game engine to free memory.
+   */
+  markAsNoLongerNeeded() {
+    SetModelAsNoLongerNeeded(this.hash);
+  }
+}
+export {
+  CommonModel
+};

package/common-game/CommonTasks.d.ts

@@ -0,0 +1,44 @@
+import { Vector3 } from "./common/utils/Vector";
+import { CommonBaseEntity } from "./entities/CommonBaseEntity";
+import { CommonPed } from "./entities/CommonPed";
+import type { CommonVehicle } from "./entities/CommonVehicle";
+import { VehicleSeat } from "./enums/VehicleSeat";
+import { IHandle } from "./entities/IHandle";
+export declare class CommonTasks {
+    protected ped: IHandle;
+    constructor(ped: IHandle | null);
+    achieveHeading(heading: number, timeout?: number): void;
+    blockTemporaryEvents(block?: boolean): void;
+    aimAt(target: CommonBaseEntity | Vector3, duration: number): void;
+    arrest(ped: CommonPed): void;
+    jump(): void;
+    climb(): void;
+    cruiseWithVehicle(vehicle: CommonVehicle, speed: number, drivingStyle?: number): void;
+    enterAnyVehicle(seat?: VehicleSeat, timeout?: number, speed?: number, flag?: number): void;
+    static everyoneLeaveVehicle(vehicle: CommonVehicle): void;
+    fightAgainst(target: CommonPed, duration?: number): void;
+    fightAgainstHatedTargets(radius: number, duration?: number): void;
+    fleeFrom(pedOrPosition: CommonPed | Vector3, distance?: number, duration?: number, fleeType?: number, fleeSpeed?: number, fleeFrom?: IHandle): void;
+    goTo(position: Vector3, ignorePaths?: boolean, timeout?: number, speed?: number, targetHeading?: number, distanceToSlide?: number, flags?: number): void;
+    goToEntity(target: CommonBaseEntity, offset?: Vector3, timeout?: number): void;
+    guardCurrentPosition(): void;
+    handsUp(duration: number): void;
+    lookAt(targetOrPosition: CommonBaseEntity | Vector3, duration?: number): void;
+    playAnimation(animDict: string, animName: string, blendInSpeed: number, blendOutSpeed: number, duration: number, playbackRate: number, animFlags: number, ikFlags?: number): Promise<void>;
+    reloadWeapon(): void;
+    shootAt(targetOrPosition: IHandle | Vector3, duration?: number, pattern?: number, affectCockedState?: boolean): void;
+    shuffleToNextVehicleSeat(vehicle: CommonVehicle): void;
+    slideTo(position: Vector3, heading: number, duration?: number): void;
+    standStill(duration: number): void;
+    vehicleShootAtPed(target: CommonPed): void;
+    wait(duration: number): void;
+    wanderAround(position?: Vector3, radius?: number): void;
+    warpIntoVehicle(vehicle: CommonVehicle, seat: VehicleSeat): void;
+    warpOutOfVehicle(vehicle: CommonVehicle, flags: number): void;
+    isPlayingAnim(dict: string, anim: string, taskFlag?: number): boolean;
+    clearAll(): void;
+    clearAllImmediately(): void;
+    clearLookAt(): void;
+    clearSecondary(): void;
+    clearAnimation(animDict: string, animName: string): void;
+}

package/common-game/CommonTasks.js

@@ -0,0 +1,233 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./common/utils/Vector";
+import { CommonBaseEntity } from "./entities/CommonBaseEntity";
+import { CommonPed } from "./entities/CommonPed";
+import { VehicleSeat } from "./enums/VehicleSeat";
+import { LoadAnimDict } from "./utils/Animations";
+import { GlobalData } from "./common/GlobalData";
+import { IHandle } from "./entities/IHandle";
+class CommonTasks {
+  static {
+    __name(this, "CommonTasks");
+  }
+  ped;
+  // we take null because sequences have a null ped, if you pass null to this
+  // you better now what you're doing.
+  constructor(ped) {
+    const actualPed = ped ?? { handle: null };
+    this.ped = actualPed;
+  }
+  achieveHeading(heading, timeout = 0) {
+    TaskAchieveHeading(this.ped.Handle, heading, timeout);
+  }
+  blockTemporaryEvents(block = true) {
+    TaskSetBlockingOfNonTemporaryEvents(this.ped.Handle, block);
+  }
+  aimAt(target, duration) {
+    if (target instanceof CommonBaseEntity)
+      TaskAimGunAtEntity(this.ped.Handle, target.Handle, duration, false, false);
+    else TaskAimGunAtCoord(this.ped.Handle, target.x, target.y, target.z, duration, false, false);
+  }
+  arrest(ped) {
+    TaskArrestPed(this.ped.Handle, ped.Handle);
+  }
+  jump() {
+    TaskJump(this.ped.Handle, true);
+  }
+  climb() {
+    TaskClimb(this.ped.Handle, true);
+  }
+  cruiseWithVehicle(vehicle, speed, drivingStyle = 0) {
+    TaskVehicleDriveWander(this.ped.Handle, vehicle.Handle, speed, drivingStyle);
+  }
+  enterAnyVehicle(seat = VehicleSeat.AnyPassenger, timeout = -1, speed = 0, flag = 0) {
+    TaskEnterVehicle(this.ped.Handle, 0, timeout, seat, speed, flag, 0);
+  }
+  static everyoneLeaveVehicle(vehicle) {
+    TaskEveryoneLeaveVehicle(vehicle.Handle, 0);
+  }
+  fightAgainst(target, duration) {
+    if (duration) {
+      TaskCombatPedTimed(this.ped.Handle, target.Handle, duration, 0);
+    } else {
+      TaskCombatPed(this.ped.Handle, target.Handle, 0, 16);
+    }
+  }
+  fightAgainstHatedTargets(radius, duration) {
+    if (duration) {
+      TaskCombatHatedTargetsAroundPedTimed(this.ped.Handle, radius, duration, 0);
+    } else {
+      TaskCombatHatedTargetsAroundPed(this.ped.Handle, radius, 0, 0);
+    }
+  }
+  fleeFrom(pedOrPosition, distance = 100, duration = -1, fleeType = 0, fleeSpeed = 3, fleeFrom) {
+    if (pedOrPosition instanceof CommonPed) {
+      TaskSmartFleePed(
+        this.ped.Handle,
+        pedOrPosition.Handle,
+        distance,
+        duration,
+        fleeType,
+        fleeSpeed,
+        fleeFrom ? fleeFrom.Handle : 0
+      );
+    } else {
+      TaskSmartFleeCoord(
+        this.ped.Handle,
+        pedOrPosition.x,
+        pedOrPosition.y,
+        pedOrPosition.z,
+        distance,
+        duration,
+        fleeType,
+        fleeSpeed
+      );
+    }
+  }
+  goTo(position, ignorePaths = false, timeout = -1, speed = 1, targetHeading = 0, distanceToSlide = 0, flags = 0) {
+    if (ignorePaths) {
+      TaskGoStraightToCoord(
+        this.ped.Handle,
+        position.x,
+        position.y,
+        position.z,
+        speed,
+        timeout,
+        targetHeading,
+        distanceToSlide,
+        0
+      );
+    } else {
+      TaskFollowNavMeshToCoord(
+        this.ped.Handle,
+        position.x,
+        position.y,
+        position.z,
+        speed,
+        timeout,
+        0,
+        flags,
+        targetHeading
+      );
+    }
+  }
+  goToEntity(target, offset = new Vector3(0), timeout = -1) {
+    TaskGotoEntityOffsetXy(this.ped.Handle, target.Handle, timeout, offset.x, offset.y, offset.z, 1, true);
+  }
+  guardCurrentPosition() {
+    TaskGuardCurrentPosition(this.ped.Handle, 15, 10, true);
+  }
+  handsUp(duration) {
+    TaskHandsUp(this.ped.Handle, duration, 0, -1, false);
+  }
+  lookAt(targetOrPosition, duration = -1) {
+    if (targetOrPosition instanceof CommonBaseEntity) {
+      TaskLookAtEntity(this.ped.Handle, targetOrPosition.Handle, duration, 2048, 31, 0);
+    } else {
+      TaskLookAtCoord(this.ped.Handle, targetOrPosition.x, targetOrPosition.y, targetOrPosition.z, duration, 0, 51, 0);
+    }
+  }
+  async playAnimation(animDict, animName, blendInSpeed, blendOutSpeed, duration, playbackRate, animFlags, ikFlags) {
+    await LoadAnimDict(animDict);
+    if (GlobalData.GameName === "redm") {
+      TaskPlayAnim(
+        this.ped.Handle,
+        animDict,
+        animName,
+        blendInSpeed,
+        blendOutSpeed,
+        duration,
+        animFlags,
+        playbackRate,
+        false,
+        ikFlags,
+        false,
+        0,
+        false
+      );
+    } else {
+      TaskPlayAnim(
+        this.ped.Handle,
+        animDict,
+        animName,
+        blendInSpeed,
+        blendOutSpeed,
+        duration,
+        animFlags,
+        playbackRate,
+        false,
+        false,
+        false
+      );
+    }
+    RemoveAnimDict(animDict);
+  }
+  reloadWeapon() {
+    TaskReloadWeapon(this.ped.Handle, true);
+  }
+  shootAt(targetOrPosition, duration = -1, pattern = 0, affectCockedState = false) {
+    if (targetOrPosition instanceof IHandle) {
+      TaskShootAtEntity(this.ped.Handle, targetOrPosition.Handle, duration, pattern, affectCockedState);
+    } else {
+      TaskShootAtCoord(
+        this.ped.Handle,
+        targetOrPosition.x,
+        targetOrPosition.y,
+        targetOrPosition.z,
+        duration,
+        pattern,
+        0
+      );
+    }
+  }
+  shuffleToNextVehicleSeat(vehicle) {
+    TaskShuffleToNextVehicleSeat(this.ped.Handle, vehicle.Handle);
+  }
+  slideTo(position, heading, duration = 0.7) {
+    TaskPedSlideToCoord(this.ped.Handle, position.x, position.y, position.z, heading, duration);
+  }
+  standStill(duration) {
+    TaskStandStill(this.ped.Handle, duration);
+  }
+  vehicleShootAtPed(target) {
+    TaskVehicleShootAtPed(this.ped.Handle, target.Handle, 20);
+  }
+  wait(duration) {
+    TaskPause(this.ped.Handle, duration);
+  }
+  wanderAround(position, radius) {
+    if (position && radius) {
+      TaskWanderInArea(this.ped.Handle, position.x, position.y, position.z, radius, 0, 0, 0);
+    } else {
+      TaskWanderStandard(this.ped.Handle, 0, 0);
+    }
+  }
+  warpIntoVehicle(vehicle, seat) {
+    TaskWarpPedIntoVehicle(this.ped.Handle, vehicle.Handle, seat);
+  }
+  warpOutOfVehicle(vehicle, flags) {
+    TaskLeaveVehicle(this.ped.Handle, vehicle.Handle, flags, 0);
+  }
+  isPlayingAnim(dict, anim, taskFlag = 3) {
+    return IsEntityPlayingAnim(this.ped.Handle, dict, anim, taskFlag);
+  }
+  clearAll() {
+    ClearPedTasks(this.ped.Handle, true, false);
+  }
+  clearAllImmediately() {
+    ClearPedTasksImmediately(this.ped.Handle, true, false);
+  }
+  clearLookAt() {
+    TaskClearLookAt(this.ped.Handle);
+  }
+  clearSecondary() {
+    ClearPedSecondaryTask(this.ped.Handle);
+  }
+  clearAnimation(animDict, animName) {
+    StopAnimTask(this.ped.Handle, animDict, animName, -4);
+  }
+}
+export {
+  CommonTasks
+};

package/common-game/cfx/StateBagChangeHandler.d.ts

@@ -0,0 +1 @@
+export type StateBagChangeHandler<T> = (bagName: string, key: string, value: T, reserved: number, replicated: boolean) => void;

package/common-game/cfx/cfx.d.ts

@@ -0,0 +1,6 @@
+export type { StateBagChangeHandler } from "./StateBagChangeHandler";
+declare const _default: {
+    Entity: typeof Entity;
+    Player: typeof Player;
+};
+export default _default;

package/common-game/cfx/cfx.js

@@ -0,0 +1,4 @@
+var cfx_default = { Entity, Player };
+export {
+  cfx_default as default
+};

package/common-game/common/Command.d.ts

@@ -0,0 +1,77 @@
+type Restricted = boolean | string | string[];
+interface ParameterTypes {
+    number: number;
+    playerId: number;
+    string: string;
+    longString: string;
+}
+interface Parameter {
+    name: string;
+    type: keyof ParameterTypes;
+    defaultValue?: any;
+    help?: string;
+    optional?: boolean;
+}
+type MappedParameters<T extends Parameter[]> = {
+    [K in T[number] as K["name"]]: ParameterTypes[K["type"]];
+} & {
+    source: number;
+    raw: string;
+};
+type CommandHandler<T extends Parameter[]> = (args: MappedParameters<T>) => void | Promise<void>;
+/**
+ * ```typescript
+ * new Command(["do", "deleteobjects"], async ({source, radius}) => {
+ *   const entities = Prop.AllProps();
+ *   const ply = new Player(source);
+ *   const pos = ply.Ped.Position
+ *   for (const ent of entities) {
+ *     // if they're outside of the range of our specified radius just continue to next
+ *     if (ent.Position.distance(pos) > radius) continue;
+ *     ent.delete();
+ *   }
+ * }, "Deletes all objects in the specified range", [
+ *   {
+ *      name: "radius",
+ *      type: "number",
+ *      help: "The radius to delete the entities in",
+ *      defaultValue: 5.0
+ *   }
+ * ] as const, "group.moderator")
+ *  ```
+ */
+export declare class Command<T extends Parameter[] = Parameter[]> {
+    #private;
+    readonly name: string | string[];
+    readonly help?: string | undefined;
+    readonly params?: T | undefined;
+    /**
+     * Registers a new executable command with optional parameter validation and permission restrictions.
+     * @param name The unique identifier(s) for the command, either as a single string or an array of strings.
+     * @param handler The function to execute when the command is executed.
+     * @param help A description of the command, displayed as a chat suggestion.
+     * @param params An optional array of parameter definitions specifying the command's expected arguments,
+     *               including their names, types, and descriptive help text for chat suggestions.
+     * @param restricted Determines the command's access permissions:
+     *                   - Defaults to `true`, restricting usage to users with the "command.commandName" ACE permission.
+     *                   - A string such as `"group.admin"` grants the command permission to the specified principal.
+     *                   - An array of strings grants permission to multiple principals.
+     */
+    constructor(name: string | string[], handler: CommandHandler<T>, help?: string | undefined, params?: T | undefined, restricted?: Restricted);
+    /**
+     * Maps the arguments received from a command call to the defined parameters while validating the argument types.
+     * @param source The client that executed the command, or -1 if executed by the server.
+     * @param args The arguments passed to the command.
+     * @param raw The raw input string passed to the command.
+     * @returns A mapped object containing parsed parameters.
+     */
+    private mapArguments;
+    /**
+     * Executes the command with the given arguments and source, validating and mapping the arguments before calling the handler.
+     * @param source The client that executed the command.
+     * @param args The arguments passed to the command.
+     * @param raw The raw input string passed to the command.
+     */
+    call(source: number, args: string[], raw?: string): Promise<void>;
+}
+export {};