@nativewrappers/redm 0.0.85 → 0.0.87

package/RawControls.d.ts

@@ -1,7 +1,28 @@
 import type { RawKeys } from "./enums/RawKeys";
 export declare class RawControls {
-    static IsKeyDown(rawKey: RawKeys): boolean;
-    static IsKeyPressed(rawKey: RawKeys): boolean;
-    static IsKeyReleased(rawKey: RawKeys): boolean;
-    static IsKeyUp(rawKey: RawKeys): boolean;
+    /**
+     * Disables the raw key this frame, making any calls return false even if they
+     * are currently pressed/released.
+     */
+    static DisableKeyThisFrame(rawKey: RawKeys): void;
+    /**
+     * If the raw key is was just pressed down, will return false if disabled with {@link DisableKeyThisFrame}
+     * and {@link canBeDisabled} is set to true
+     */
+    static WasJustPressed(rawKey: RawKeys, canBeDisabled?: boolean): boolean;
+    /**
+     * If the raw key is currently pressed down, will return false if disabled with {@link DisableKeyThisFrame}
+     * and {@link canBeDisabled} is set to true
+     */
+    static IsKeyPressed(rawKey: RawKeys, canBeDisabled?: boolean): boolean;
+    /**
+     * If the raw key is in its up state, will return false if disabled with {@link DisableKeyThisFrame}
+     * and {@link canBeDisabled} is set to true
+     */
+    static IsKeyReleased(rawKey: RawKeys, canBeDisabled?: boolean): boolean;
+    /**
+     * If the raw key is was just released, will return false if disabled with {@link DisableKeyThisFrame}
+     * and {@link canBeDisabled} is set to true
+     */
+    static WasJustReleased(rawKey: RawKeys, canBeDisabled?: boolean): boolean;
 }

package/RawControls.js

@@ -4,17 +4,40 @@ class RawControls {
   static {
     __name(this, "RawControls");
   }
-  static IsKeyDown(rawKey) {
-    return IsRawKeyDown(rawKey);
+  /**
+   * Disables the raw key this frame, making any calls return false even if they
+   * are currently pressed/released.
+   */
+  static DisableKeyThisFrame(rawKey) {
+    DisableRawKeyThisFrame(rawKey);
   }
-  static IsKeyPressed(rawKey) {
-    return IsRawKeyPressed(rawKey);
+  /**
+   * If the raw key is was just pressed down, will return false if disabled with {@link DisableKeyThisFrame}
+   * and {@link canBeDisabled} is set to true
+   */
+  static WasJustPressed(rawKey, canBeDisabled = true) {
+    return canBeDisabled ? IsRawKeyDown(rawKey) : IsDisabledRawKeyDown(rawKey);
   }
-  static IsKeyReleased(rawKey) {
-    return IsRawKeyReleased(rawKey);
+  /**
+   * If the raw key is currently pressed down, will return false if disabled with {@link DisableKeyThisFrame}
+   * and {@link canBeDisabled} is set to true
+   */
+  static IsKeyPressed(rawKey, canBeDisabled = true) {
+    return canBeDisabled ? IsRawKeyPressed(rawKey) : IsDisabledRawKeyPressed(rawKey);
   }
-  static IsKeyUp(rawKey) {
-    return IsRawKeyUp(rawKey);
+  /**
+   * If the raw key is in its up state, will return false if disabled with {@link DisableKeyThisFrame}
+   * and {@link canBeDisabled} is set to true
+   */
+  static IsKeyReleased(rawKey, canBeDisabled = true) {
+    return canBeDisabled ? IsRawKeyReleased(rawKey) : IsDisabledRawKeyReleased(rawKey);
+  }
+  /**
+   * If the raw key is was just released, will return false if disabled with {@link DisableKeyThisFrame}
+   * and {@link canBeDisabled} is set to true
+   */
+  static WasJustReleased(rawKey, canBeDisabled = true) {
+    return canBeDisabled ? IsRawKeyUp(rawKey) : IsDisabledRawKeyUp(rawKey);
   }
 }
 export {

package/RawKeymaps.d.ts

@@ -0,0 +1,49 @@
+import type { RawKeys } from "./enums/RawKeys";
+export type KeymapFunction = () => void;
+/**
+ * A builder for RawKeymap, you should call {@link finish} to actually register the raw keymap
+ * This should be usable across resource bounds, so you can create the keymap
+ * and pass the object to a manager to handle rebinding the maps with calls.
+ */
+export declare class RawKeymap {
+    #private;
+    /**
+     * @param keymapName the name of the keymap to register to, this should be unique across all resources.
+     * @param rawKey the key to bind to initially, this can be rebound with {@link setRawKey}
+     * @param canBeDisabled if the key can be disabled with {@link RawControls.DisableKeyThisFrame}
+     */
+    constructor(keymapName: string, rawKey: RawKeys, canBeDisabled: boolean);
+    getKeymapName: () => string;
+    /**
+     * Gets the current raw keymap
+     */
+    getRawKeymap: () => RawKeys;
+    /**
+     * Sets the function to be used onKeyUp
+     */
+    setOnKeyUp: (fn: KeymapFunction) => void;
+    /**
+     * Sets the function to be used on onKeyDown
+     */
+    setOnKeyDown: (fn: KeymapFunction) => void;
+    /**
+     * Remaps the current {@link RawKeymap}'s raw key to {@link key}
+     */
+    setRawKey: (key: RawKeys) => void;
+    /**
+     * Sets the function to be used on onKeyUp, if you need to use this across
+     * resource bounds you should use {@link setOnKeyUp}
+     */
+    set OnKeyUp(fn: KeymapFunction);
+    /**
+     * Sets the function to be used on onKeyDown, if you need to use this across
+     * resource bounds you should use {@link setOnKeyDown}
+     */
+    set OnKeyDown(fn: KeymapFunction);
+    /**
+     * Changes the {@link RawKeymap} to use the {@link key} for its keymap
+     */
+    set RawKey(key: RawKeys);
+    get KeymapName(): string;
+    finish(): void;
+}

package/RawKeymaps.js

@@ -0,0 +1,79 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class RawKeymap {
+  static {
+    __name(this, "RawKeymap");
+  }
+  #keymapName;
+  #rawKey;
+  #canBeDisabled;
+  #onKeyUp = null;
+  #onKeyDown = null;
+  /**
+   * @param keymapName the name of the keymap to register to, this should be unique across all resources.
+   * @param rawKey the key to bind to initially, this can be rebound with {@link setRawKey}
+   * @param canBeDisabled if the key can be disabled with {@link RawControls.DisableKeyThisFrame}
+   */
+  constructor(keymapName, rawKey, canBeDisabled) {
+    this.#keymapName = keymapName;
+    this.#rawKey = rawKey;
+    this.#canBeDisabled = canBeDisabled;
+  }
+  getKeymapName = /* @__PURE__ */ __name(() => {
+    return this.#keymapName;
+  }, "getKeymapName");
+  /**
+   * Gets the current raw keymap
+   */
+  getRawKeymap = /* @__PURE__ */ __name(() => {
+    return this.#rawKey;
+  }, "getRawKeymap");
+  /**
+   * Sets the function to be used onKeyUp
+   */
+  setOnKeyUp = /* @__PURE__ */ __name((fn) => {
+    this.#onKeyUp = fn;
+  }, "setOnKeyUp");
+  /**
+   * Sets the function to be used on onKeyDown
+   */
+  setOnKeyDown = /* @__PURE__ */ __name((fn) => {
+    this.#onKeyDown = fn;
+  }, "setOnKeyDown");
+  /**
+   * Remaps the current {@link RawKeymap}'s raw key to {@link key}
+   */
+  setRawKey = /* @__PURE__ */ __name((key) => {
+    this.#rawKey = key;
+    RemapRawKeymap(this.#keymapName, key);
+  }, "setRawKey");
+  /**
+   * Sets the function to be used on onKeyUp, if you need to use this across
+   * resource bounds you should use {@link setOnKeyUp}
+   */
+  set OnKeyUp(fn) {
+    this.#onKeyUp = fn;
+  }
+  /**
+   * Sets the function to be used on onKeyDown, if you need to use this across
+   * resource bounds you should use {@link setOnKeyDown}
+   */
+  set OnKeyDown(fn) {
+    this.#onKeyDown = fn;
+  }
+  /**
+   * Changes the {@link RawKeymap} to use the {@link key} for its keymap
+   */
+  set RawKey(key) {
+    this.setRawKey(key);
+  }
+  get KeymapName() {
+    return this.#keymapName;
+  }
+  finish() {
+    RegisterRawKeymap(this.#keymapName, this.#onKeyUp, this.#onKeyDown, this.#rawKey, this.#canBeDisabled);
+  }
+}
+export {
+  RawKeymap
+};

package/Task.d.ts

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

package/Task.js

@@ -0,0 +1,312 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./common/utils/Vector";
+import { BaseEntity } from "./entities/BaseEntity";
+import { Ped } from "./entities/Ped";
+import { DrivingStyle } from "./enums/Driving";
+import { FiringPatterns } from "./enums/FiringPatterns";
+import { VehicleSeat } from "./enums/VehicleSeat";
+import { LoadAnimDict } from "./utils/Animations";
+class Tasks {
+  static {
+    __name(this, "Tasks");
+  }
+  ped;
+  // we take null because sequences have a null ped, if you pass null to this
+  // you betterk 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 BaseEntity)
+      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);
+  }
+  // TODO: test and verify
+  // public climbLadder(): void {
+  //   TaskClimbLadder(this.ped.Handle, 0.0 1);
+  // }
+  //
+  // public cower(duration: number): void {
+  //   TaskCower(this.ped.Handle, duration);
+  // }
+  cruiseWithVehicle(vehicle, speed, drivingStyle = DrivingStyle.None) {
+    TaskVehicleDriveWander(this.ped.Handle, vehicle.Handle, speed, drivingStyle);
+  }
+  // public driveTo(
+  //   vehicle: Vehicle,
+  //   target: Vector3,
+  //   radius: number,
+  //   speed: number,
+  //   drivingstyle = DrivingStyle.None,
+  // ): void {
+  //   // Swap to TaskVehicleDriveToCoord
+  //   TaskVehicleDriveToCoordLongrange(
+  //     this.ped.Handle,
+  //     vehicle.Handle,
+  //     target.x,
+  //     target.y,
+  //     target.z,
+  //     speed,
+  //     drivingstyle,
+  //     radius,
+  //   );
+  // }
+  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 Ped) {
+      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
+      );
+    }
+  }
+  // public followPointRoute(points: Vector3[]): void {
+  //   TaskFlushRoute();
+  //
+  //   points.forEach((point) => TaskExtendRoute(point.x, point.y, point.z));
+  //
+  //   TaskFollowPointRoute(this.ped.Handle, 1, 0);
+  // }
+  // public followToOffsetFromEntity(
+  //   target: BaseEntity,
+  //   offset: Vector3,
+  //   timeout: number,
+  //   stoppingRange: number,
+  //   movementSpeed = 1,
+  //   persistFollowing = true,
+  // ): void {
+  //   TaskFollowToOffsetOfEntity(
+  //     this.ped.Handle,
+  //     target.Handle,
+  //     offset.x,
+  //     offset.y,
+  //     offset.z,
+  //     movementSpeed,
+  //     timeout,
+  //     stoppingRange,
+  //     persistFollowing,
+  //   );
+  // }
+  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 = null, timeout = -1) {
+    if (offset === null) {
+      offset = new Vector3(0, 0, 0);
+    }
+    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 BaseEntity) {
+      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);
+    }
+  }
+  // public performSequence(sequence: TaskSequence): void {
+  //   if (!sequence.IsClosed) {
+  //     sequence.close();
+  //   }
+  //
+  //   this.clearAll();
+  //   // this.ped.BlockPermanentEvents = true;
+  //
+  //   TaskPerformSequence(this.ped.Handle, sequence.Handle);
+  // }
+  async playAnimation(animDict, animName, blendInSpeed, blendOutSpeed, duration, playbackRate, animFlags, ikFlags) {
+    await LoadAnimDict(animDict);
+    TaskPlayAnim(
+      this.ped.Handle,
+      animDict,
+      animName,
+      blendInSpeed,
+      blendOutSpeed,
+      duration,
+      animFlags,
+      playbackRate,
+      false,
+      ikFlags,
+      false,
+      0,
+      false
+    );
+    RemoveAnimDict(animDict);
+  }
+  reloadWeapon() {
+    TaskReloadWeapon(this.ped.Handle, true);
+  }
+  shootAt(targetOrPosition, duration = -1, pattern = FiringPatterns.None, affectCockedState = false) {
+    if (targetOrPosition instanceof Ped) {
+      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);
+  }
+  // public startScenario(
+  //   name: string,
+  //   position: Vector3,
+  //   heading = 0,
+  //   duration = 0,
+  //   sittingScenario = false,
+  //   teleport = true,
+  // ): void {
+  //   TaskStartScenarioAtPosition(
+  //     this.ped.Handle,
+  //     name,
+  //     position.x,
+  //     position.y,
+  //     position.z,
+  //     heading,
+  //     duration,
+  //     sittingScenario,
+  //     teleport,
+  //   );
+  // }
+  // public swapWeapon(): void {
+  //   TaskSwapWeapon(this.ped.Handle, false);
+  // }
+  // public turnTo(targetOrPosition: BaseEntity | Vector3, duration = -1): void {
+  //   if (targetOrPosition instanceof BaseEntity)
+  //     TaskTurnPedToFaceEntity(this.ped.Handle, targetOrPosition.Handle, duration);
+  //   else TaskTurnPedToFaceCoord(this.ped.Handle, targetOrPosition.x, targetOrPosition.y, targetOrPosition.z, 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 {
+  Tasks
+};

package/Volume.d.ts

@@ -1,6 +1,10 @@
 import type { Vector3 } from "./common/utils/Vector";
+export declare enum VolumeType {
+    Cylinder = 0,
+    Box = 1
+}
 export declare class Volume {
     private handle;
-    constructor(coord: Vector3, rot: Vector3, scale: Vector3, customName?: string);
+    constructor(volumeType: VolumeType, coord: Vector3, rot: Vector3, scale: Vector3, customName?: string);
     get Handle(): number;
 }

package/Volume.js

@@ -1,32 +1,53 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var VolumeType = /* @__PURE__ */ ((VolumeType2) => {
+  VolumeType2[VolumeType2["Cylinder"] = 0] = "Cylinder";
+  VolumeType2[VolumeType2["Box"] = 1] = "Box";
+  return VolumeType2;
+})(VolumeType || {});
+function getVolumeFunctionFromType(volumeType, hasCustomName) {
+  if (hasCustomName) {
+    switch (volumeType) {
+      case 0 /* Cylinder */:
+        return CreateVolumeCylinderWithCustomName;
+      case 1 /* Box */:
+        return CreateVolumeBoxWithCustomName;
+    }
+  } else {
+    switch (volumeType) {
+      case 0 /* Cylinder */:
+        return CreateVolumeCylinder;
+      case 1 /* Box */:
+        return CreateVolumeBox;
+    }
+  }
+}
+__name(getVolumeFunctionFromType, "getVolumeFunctionFromType");
 class Volume {
   static {
     __name(this, "Volume");
   }
   handle;
-  constructor(coord, rot, scale, customName) {
-    if (customName) {
-      this.handle = CreateVolumeCylinderWithCustomName(
-        coord.x,
-        coord.y,
-        coord.z,
-        rot.x,
-        rot.y,
-        rot.z,
-        scale.x,
-        scale.y,
-        scale.z,
-        customName
-      );
-      return;
-    }
-    this.handle = CreateVolumeCylinder(coord.x, coord.y, coord.z, rot.x, rot.y, rot.z, scale.x, scale.y, scale.z);
+  constructor(volumeType, coord, rot, scale, customName) {
+    const fn = getVolumeFunctionFromType(volumeType, customName !== void 0);
+    this.handle = fn(
+      coord.x,
+      coord.y,
+      coord.z,
+      rot.x,
+      rot.y,
+      rot.z,
+      scale.x,
+      scale.y,
+      scale.z,
+      customName
+    );
   }
   get Handle() {
     return this.handle;
   }
 }
 export {
-  Volume
+  Volume,
+  VolumeType
 };

package/entities/BaseEntity.d.ts

@@ -35,6 +35,10 @@ export declare class BaseEntity {
      * @returns Returns true if the entity handle is not 0 and exists in the game engine
      */
     get Exists(): boolean;
+    /**
+     * @returns Returns true if the entity is dead
+     */
+    get IsDead(): boolean;
     /**
      * @returns The entitys current handle.
      */

package/entities/BaseEntity.js

@@ -50,6 +50,12 @@ class BaseEntity {
   get Exists() {
     return this.handle !== 0 && DoesEntityExist(this.Handle);
   }
+  /**
+   * @returns Returns true if the entity is dead
+   */
+  get IsDead() {
+    return IsEntityDead(this.handle);
+  }
   /**
    * @returns The entitys current handle.
    */

package/entities/Ped.d.ts

@@ -1,12 +1,14 @@
+import type { Vector3 } from "../common/utils/Vector";
+import { Tasks } from "../Task";
 import { Attributes } from "../Attribute";
-import type { eDamageCleanliness, KnockOffVehicle, TamingState } from "../enums/Ped";
+import type { KnockOffVehicle, TamingState, eDamageCleanliness } from "../enums/Ped";
 import type { VehicleSeat } from "../enums/VehicleSeat";
 import { BaseEntity } from "./BaseEntity";
-import { Vehicle } from "./Vehicle";
 import type { Player } from "./Player";
-import type { Vector3 } from "../common/utils/Vector";
+import { Vehicle } from "./Vehicle";
 export declare class Ped extends BaseEntity {
     private attributes;
+    private tasks;
     constructor(handle: number);
     /**
      * Blocks scenarios inbetween the specified vectors
@@ -22,6 +24,7 @@ export declare class Ped extends BaseEntity {
      * @param scenarioId the number returned from {@link blockScenariosInArea}
      */
     static removeScenarioBlock(scenarioId: number): void;
+    get Tasks(): Tasks;
     /**
      * While this increases the peds max health, if used on a player it wont increase the max core value on the hud
      */

package/entities/Ped.js

@@ -1,14 +1,16 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Tasks } from "../Task";
+import { _N } from "../utils/Native";
 import { Attributes } from "../Attribute";
 import { BaseEntity } from "./BaseEntity";
 import { Vehicle } from "./Vehicle";
-import { _N } from "../utils/Native";
 class Ped extends BaseEntity {
   static {
     __name(this, "Ped");
   }
   attributes;
+  tasks;
   constructor(handle) {
     super(handle);
   }
@@ -39,6 +41,13 @@ class Ped extends BaseEntity {
   static removeScenarioBlock(scenarioId) {
     RemoveScenarioBlockingArea(scenarioId, false);
   }
+  get Tasks() {
+    if (this.tasks) {
+      return this.tasks;
+    }
+    this.tasks = new Tasks(this);
+    return this.tasks;
+  }
   /**
    * While this increases the peds max health, if used on a player it wont increase the max core value on the hud
    */

package/entities/Pickup.d.ts

@@ -1,4 +1,5 @@
 export declare class Pickup {
     handle: number;
     constructor(handle: number);
+    get Handle(): number;
 }

package/entities/Pickup.js

@@ -8,6 +8,9 @@ class Pickup {
   constructor(handle) {
     this.handle = handle;
   }
+  get Handle() {
+    return this.handle;
+  }
 }
 export {
   Pickup

package/enums/AnimationFlags.d.ts

@@ -0,0 +1,67 @@
+export declare enum AnimationFlags {
+    Looping = 1,
+    HoldLastFrame = 2,
+    NotInterruptable = 4,
+    UpperBody = 8,
+    Secondary = 16,
+    AbortOnPedMovement = 32,
+    Additive = 64,
+    OverridePhysics = 128,
+    ExtractInitialOffset = 256,
+    ExitAfterInterrupted = 512,
+    TagSyncIn = 1024,
+    TagSyncOut = 2048,
+    TagSyncContinuous = 4096,
+    ForceStart = 8192,
+    UseKinematicPhysic = 16384,
+    UseMoverExtractions = 32768,
+    DontSuppressLoco = 65536,
+    EndsInDeadPose = 131072,
+    ActivateRagdollOnCollision = 262144,
+    DontExitOnDeath = 524288,
+    AbortOnWeaponDamage = 1048576,
+    DisableForcedPhysicsUpdate = 2097152,
+    Gesture = 4194304,
+    SkipIfBlockedByHigherPriorityTask = 8388608,
+    UseAbsoluteMover = 16777216,
+    _0xC57F16E7 = 33554432,
+    UpperBodyTags = 67108864,
+    ProcessAttachmentOnStart = 134217728,
+    ExpandPedCapsuleFromSkeleton = 268435456,
+    BlendoutWrtLastFrame = 536870912,
+    DisablePhysicalActivation = 1073741824,
+    DisableReleaseEvents = -2147483648
+}
+export declare enum IkControlFlags {
+    DisableLegIK = 1,
+    DisableArmIK = 2,
+    DisableHeadIK = 4,
+    DisableTorsoIK = 8,
+    DisableTorsoReact = 16,
+    UseLegAllowTags = 32,
+    UseLegBlockTags = 64,
+    UseArmAllowTags = 128,
+    UseArmBlockTags = 256,
+    ProcessWeaponHandGrip = 512,
+    UseFPArmLeft = 1024,
+    UseFPArmRight = 2048,
+    _0x88FF50BE = 4096,
+    DisableTorsoVehicleIK = 8192,
+    DisableProneIK = 16384,
+    UpperBody = 32768,
+    UpperBodyTags = 65536,
+    _0xFCDC149B = 131072,
+    _0x5465E64A = 262144,
+    DisableLegPostureIK = 524288,
+    _0x32939A0E = 1048576,
+    BlockNonAnimSceneLooks = 2097152,
+    _0x3CC5DD38 = 4194304,
+    _0xB819088C = 8388608,
+    DisableContourIk = 16777216,
+    _0xF9E28A5F = 33554432,
+    _0x983AE6C1 = 67108864,
+    _0x5B5D2BEF = 134217728,
+    _0xA4F64B54 = 268435456,
+    DisableTwoBokeIK = 536870912,
+    _0x0C1380EC = 1073741824
+}

package/enums/AnimationFlags.js

@@ -0,0 +1,73 @@
+var AnimationFlags = /* @__PURE__ */ ((AnimationFlags2) => {
+  AnimationFlags2[AnimationFlags2["Looping"] = 1] = "Looping";
+  AnimationFlags2[AnimationFlags2["HoldLastFrame"] = 2] = "HoldLastFrame";
+  AnimationFlags2[AnimationFlags2["NotInterruptable"] = 4] = "NotInterruptable";
+  AnimationFlags2[AnimationFlags2["UpperBody"] = 8] = "UpperBody";
+  AnimationFlags2[AnimationFlags2["Secondary"] = 16] = "Secondary";
+  AnimationFlags2[AnimationFlags2["AbortOnPedMovement"] = 32] = "AbortOnPedMovement";
+  AnimationFlags2[AnimationFlags2["Additive"] = 64] = "Additive";
+  AnimationFlags2[AnimationFlags2["OverridePhysics"] = 128] = "OverridePhysics";
+  AnimationFlags2[AnimationFlags2["ExtractInitialOffset"] = 256] = "ExtractInitialOffset";
+  AnimationFlags2[AnimationFlags2["ExitAfterInterrupted"] = 512] = "ExitAfterInterrupted";
+  AnimationFlags2[AnimationFlags2["TagSyncIn"] = 1024] = "TagSyncIn";
+  AnimationFlags2[AnimationFlags2["TagSyncOut"] = 2048] = "TagSyncOut";
+  AnimationFlags2[AnimationFlags2["TagSyncContinuous"] = 4096] = "TagSyncContinuous";
+  AnimationFlags2[AnimationFlags2["ForceStart"] = 8192] = "ForceStart";
+  AnimationFlags2[AnimationFlags2["UseKinematicPhysic"] = 16384] = "UseKinematicPhysic";
+  AnimationFlags2[AnimationFlags2["UseMoverExtractions"] = 32768] = "UseMoverExtractions";
+  AnimationFlags2[AnimationFlags2["DontSuppressLoco"] = 65536] = "DontSuppressLoco";
+  AnimationFlags2[AnimationFlags2["EndsInDeadPose"] = 131072] = "EndsInDeadPose";
+  AnimationFlags2[AnimationFlags2["ActivateRagdollOnCollision"] = 262144] = "ActivateRagdollOnCollision";
+  AnimationFlags2[AnimationFlags2["DontExitOnDeath"] = 524288] = "DontExitOnDeath";
+  AnimationFlags2[AnimationFlags2["AbortOnWeaponDamage"] = 1048576] = "AbortOnWeaponDamage";
+  AnimationFlags2[AnimationFlags2["DisableForcedPhysicsUpdate"] = 2097152] = "DisableForcedPhysicsUpdate";
+  AnimationFlags2[AnimationFlags2["Gesture"] = 4194304] = "Gesture";
+  AnimationFlags2[AnimationFlags2["SkipIfBlockedByHigherPriorityTask"] = 8388608] = "SkipIfBlockedByHigherPriorityTask";
+  AnimationFlags2[AnimationFlags2["UseAbsoluteMover"] = 16777216] = "UseAbsoluteMover";
+  AnimationFlags2[AnimationFlags2["_0xC57F16E7"] = 33554432] = "_0xC57F16E7";
+  AnimationFlags2[AnimationFlags2["UpperBodyTags"] = 67108864] = "UpperBodyTags";
+  AnimationFlags2[AnimationFlags2["ProcessAttachmentOnStart"] = 134217728] = "ProcessAttachmentOnStart";
+  AnimationFlags2[AnimationFlags2["ExpandPedCapsuleFromSkeleton"] = 268435456] = "ExpandPedCapsuleFromSkeleton";
+  AnimationFlags2[AnimationFlags2["BlendoutWrtLastFrame"] = 536870912] = "BlendoutWrtLastFrame";
+  AnimationFlags2[AnimationFlags2["DisablePhysicalActivation"] = 1073741824] = "DisablePhysicalActivation";
+  AnimationFlags2[AnimationFlags2["DisableReleaseEvents"] = -2147483648] = "DisableReleaseEvents";
+  return AnimationFlags2;
+})(AnimationFlags || {});
+var IkControlFlags = /* @__PURE__ */ ((IkControlFlags2) => {
+  IkControlFlags2[IkControlFlags2["DisableLegIK"] = 1] = "DisableLegIK";
+  IkControlFlags2[IkControlFlags2["DisableArmIK"] = 2] = "DisableArmIK";
+  IkControlFlags2[IkControlFlags2["DisableHeadIK"] = 4] = "DisableHeadIK";
+  IkControlFlags2[IkControlFlags2["DisableTorsoIK"] = 8] = "DisableTorsoIK";
+  IkControlFlags2[IkControlFlags2["DisableTorsoReact"] = 16] = "DisableTorsoReact";
+  IkControlFlags2[IkControlFlags2["UseLegAllowTags"] = 32] = "UseLegAllowTags";
+  IkControlFlags2[IkControlFlags2["UseLegBlockTags"] = 64] = "UseLegBlockTags";
+  IkControlFlags2[IkControlFlags2["UseArmAllowTags"] = 128] = "UseArmAllowTags";
+  IkControlFlags2[IkControlFlags2["UseArmBlockTags"] = 256] = "UseArmBlockTags";
+  IkControlFlags2[IkControlFlags2["ProcessWeaponHandGrip"] = 512] = "ProcessWeaponHandGrip";
+  IkControlFlags2[IkControlFlags2["UseFPArmLeft"] = 1024] = "UseFPArmLeft";
+  IkControlFlags2[IkControlFlags2["UseFPArmRight"] = 2048] = "UseFPArmRight";
+  IkControlFlags2[IkControlFlags2["_0x88FF50BE"] = 4096] = "_0x88FF50BE";
+  IkControlFlags2[IkControlFlags2["DisableTorsoVehicleIK"] = 8192] = "DisableTorsoVehicleIK";
+  IkControlFlags2[IkControlFlags2["DisableProneIK"] = 16384] = "DisableProneIK";
+  IkControlFlags2[IkControlFlags2["UpperBody"] = 32768] = "UpperBody";
+  IkControlFlags2[IkControlFlags2["UpperBodyTags"] = 65536] = "UpperBodyTags";
+  IkControlFlags2[IkControlFlags2["_0xFCDC149B"] = 131072] = "_0xFCDC149B";
+  IkControlFlags2[IkControlFlags2["_0x5465E64A"] = 262144] = "_0x5465E64A";
+  IkControlFlags2[IkControlFlags2["DisableLegPostureIK"] = 524288] = "DisableLegPostureIK";
+  IkControlFlags2[IkControlFlags2["_0x32939A0E"] = 1048576] = "_0x32939A0E";
+  IkControlFlags2[IkControlFlags2["BlockNonAnimSceneLooks"] = 2097152] = "BlockNonAnimSceneLooks";
+  IkControlFlags2[IkControlFlags2["_0x3CC5DD38"] = 4194304] = "_0x3CC5DD38";
+  IkControlFlags2[IkControlFlags2["_0xB819088C"] = 8388608] = "_0xB819088C";
+  IkControlFlags2[IkControlFlags2["DisableContourIk"] = 16777216] = "DisableContourIk";
+  IkControlFlags2[IkControlFlags2["_0xF9E28A5F"] = 33554432] = "_0xF9E28A5F";
+  IkControlFlags2[IkControlFlags2["_0x983AE6C1"] = 67108864] = "_0x983AE6C1";
+  IkControlFlags2[IkControlFlags2["_0x5B5D2BEF"] = 134217728] = "_0x5B5D2BEF";
+  IkControlFlags2[IkControlFlags2["_0xA4F64B54"] = 268435456] = "_0xA4F64B54";
+  IkControlFlags2[IkControlFlags2["DisableTwoBokeIK"] = 536870912] = "DisableTwoBokeIK";
+  IkControlFlags2[IkControlFlags2["_0x0C1380EC"] = 1073741824] = "_0x0C1380EC";
+  return IkControlFlags2;
+})(IkControlFlags || {});
+export {
+  AnimationFlags,
+  IkControlFlags
+};

package/enums/Driving.d.ts

@@ -0,0 +1,3 @@
+export declare enum DrivingStyle {
+    None = 0
+}

package/enums/Driving.js

@@ -0,0 +1,7 @@
+var DrivingStyle = /* @__PURE__ */ ((DrivingStyle2) => {
+  DrivingStyle2[DrivingStyle2["None"] = 0] = "None";
+  return DrivingStyle2;
+})(DrivingStyle || {});
+export {
+  DrivingStyle
+};

package/enums/EnterExitFlags.d.ts

@@ -0,0 +1,31 @@
+declare enum EnterExitVehicleFlags {
+    None = 0,
+    ResumeIfInterrupted = 1,
+    WarpEntryPoint = 2,
+    InterruptDuringGetIn = 4,
+    JackAnyone = 8,
+    WarpPed = 16,
+    InterruptDuringGetOut = 32,
+    DontWaitForVehicleToStop = 64,
+    AllowExteriorEntry = 128,
+    DontCloseDoor = 256,
+    WarpIfDoorIsBlocked = 512,
+    EnterUsingNavmesh = 1024,
+    JumpOut = 4096,
+    PreferDismountSideWithFewerPeds = 16384,
+    DontDefaultWarpIfDoorBlocked = 65536,
+    UseLeftEntry = 131072,
+    UseRightEntry = 262144,
+    JustPullPedOut = 524288,
+    BlockSeatShuffling = 1048576,
+    WarpIfShuffleLinkIsBlocked = 4194304,
+    DontJackAnyone = 8388608,
+    WaitForEntryPointToBeClear = 16777216,
+    UseHitchDismountVariant = 33554432,
+    ExitSeatOnToVehicle = 67108864,
+    AllowScriptedTaskAbort = 134217728,
+    WillShootAtTargetPeds = 268435456,
+    InterruptAlways = 536870912,
+    IgnoreEntryFromClosestPoint = 1073741824,
+    AllowJackPlayerPedOnLy = -2147483648
+}

package/enums/FiringPatterns.d.ts

@@ -0,0 +1,36 @@
+export declare enum FiringPatterns {
+    None = 0,
+    BurstFire = -687903391,
+    UNK1 = -753768974,
+    UNK2 = 1857128337,
+    BurstFireInCover = 40051185,
+    BurstFireMG = 432416687,
+    BurstFirePistol = -651807432,
+    BurstFirePumpShotgun = 12239771,
+    BurstFireRifle = -1670073338,
+    BurstFireSmg = -787632658,
+    UNK3 = 1575766855,
+    BurstSingleShot = -1413485146,
+    CompanionBill = -667771326,
+    CompanionDutch = -921847361,
+    CompanionHosea = 1173361664,
+    CompanionJohn = 1026597428,
+    CompanionMicah = -2017692654,
+    UNK4 = 2055493265,
+    UNK5 = -1725067907,
+    UNK6 = -2056883078,
+    ExConfederatesCombat = 517186037,
+    ExplosivesInCover = 365231505,
+    UNK7 = 577037782,
+    FullAuto = -957453492,
+    InCoverCompanionBill = 2047104079,
+    InCoverCompanionDutch = -887696719,
+    InCoverCompanionHosea = -938698330,
+    InCoverCompanionJohn = -451565453,
+    InCoverCompanionMicah = -1946394022,
+    UNK8 = 1836430378,
+    SingleShot = 1566631136,
+    SlowShot = -1422700276,
+    UNK9 = 1521641709,
+    ThrowInCover = -1795196902
+}

package/enums/FiringPatterns.js

@@ -0,0 +1,40 @@
+var FiringPatterns = /* @__PURE__ */ ((FiringPatterns2) => {
+  FiringPatterns2[FiringPatterns2["None"] = 0] = "None";
+  FiringPatterns2[FiringPatterns2["BurstFire"] = -687903391] = "BurstFire";
+  FiringPatterns2[FiringPatterns2["UNK1"] = -753768974] = "UNK1";
+  FiringPatterns2[FiringPatterns2["UNK2"] = 1857128337] = "UNK2";
+  FiringPatterns2[FiringPatterns2["BurstFireInCover"] = 40051185] = "BurstFireInCover";
+  FiringPatterns2[FiringPatterns2["BurstFireMG"] = 432416687] = "BurstFireMG";
+  FiringPatterns2[FiringPatterns2["BurstFirePistol"] = -651807432] = "BurstFirePistol";
+  FiringPatterns2[FiringPatterns2["BurstFirePumpShotgun"] = 12239771] = "BurstFirePumpShotgun";
+  FiringPatterns2[FiringPatterns2["BurstFireRifle"] = -1670073338] = "BurstFireRifle";
+  FiringPatterns2[FiringPatterns2["BurstFireSmg"] = -787632658] = "BurstFireSmg";
+  FiringPatterns2[FiringPatterns2["UNK3"] = 1575766855] = "UNK3";
+  FiringPatterns2[FiringPatterns2["BurstSingleShot"] = -1413485146] = "BurstSingleShot";
+  FiringPatterns2[FiringPatterns2["CompanionBill"] = -667771326] = "CompanionBill";
+  FiringPatterns2[FiringPatterns2["CompanionDutch"] = -921847361] = "CompanionDutch";
+  FiringPatterns2[FiringPatterns2["CompanionHosea"] = 1173361664] = "CompanionHosea";
+  FiringPatterns2[FiringPatterns2["CompanionJohn"] = 1026597428] = "CompanionJohn";
+  FiringPatterns2[FiringPatterns2["CompanionMicah"] = -2017692654] = "CompanionMicah";
+  FiringPatterns2[FiringPatterns2["UNK4"] = 2055493265] = "UNK4";
+  FiringPatterns2[FiringPatterns2["UNK5"] = -1725067907] = "UNK5";
+  FiringPatterns2[FiringPatterns2["UNK6"] = -2056883078] = "UNK6";
+  FiringPatterns2[FiringPatterns2["ExConfederatesCombat"] = 517186037] = "ExConfederatesCombat";
+  FiringPatterns2[FiringPatterns2["ExplosivesInCover"] = 365231505] = "ExplosivesInCover";
+  FiringPatterns2[FiringPatterns2["UNK7"] = 577037782] = "UNK7";
+  FiringPatterns2[FiringPatterns2["FullAuto"] = -957453492] = "FullAuto";
+  FiringPatterns2[FiringPatterns2["InCoverCompanionBill"] = 2047104079] = "InCoverCompanionBill";
+  FiringPatterns2[FiringPatterns2["InCoverCompanionDutch"] = -887696719] = "InCoverCompanionDutch";
+  FiringPatterns2[FiringPatterns2["InCoverCompanionHosea"] = -938698330] = "InCoverCompanionHosea";
+  FiringPatterns2[FiringPatterns2["InCoverCompanionJohn"] = -451565453] = "InCoverCompanionJohn";
+  FiringPatterns2[FiringPatterns2["InCoverCompanionMicah"] = -1946394022] = "InCoverCompanionMicah";
+  FiringPatterns2[FiringPatterns2["UNK8"] = 1836430378] = "UNK8";
+  FiringPatterns2[FiringPatterns2["SingleShot"] = 1566631136] = "SingleShot";
+  FiringPatterns2[FiringPatterns2["SlowShot"] = -1422700276] = "SlowShot";
+  FiringPatterns2[FiringPatterns2["UNK9"] = 1521641709] = "UNK9";
+  FiringPatterns2[FiringPatterns2["ThrowInCover"] = -1795196902] = "ThrowInCover";
+  return FiringPatterns2;
+})(FiringPatterns || {});
+export {
+  FiringPatterns
+};

package/index.d.ts

@@ -4,17 +4,24 @@ export * from "./Game";
 export * from "./GameConstants";
 export * from "./Model";
 export * from "./RawControls";
+export * from "./RawKeymaps";
 export * from "./RelationshipGroup";
+export * from "./Task";
 export * from "./Volume";
 export * from "./world/createDraftVehicle";
 export * from "./world/createPed";
 export * from "./world/createProp";
 export * from "./world/createVehicle";
+export * from "./utils/Animations";
 export * from "./utils/Native";
 export * from "./types/Throwable";
 export * from "./interfaces/Dimensions";
+export * from "./enums/AnimationFlags";
 export * from "./enums/Attributes";
+export * from "./enums/Driving";
+export * from "./enums/EnterExitFlags";
 export * from "./enums/Entity";
+export * from "./enums/FiringPatterns";
 export * from "./enums/Keys";
 export * from "./enums/Ped";
 export * from "./enums/RawKeys";

package/index.js

@@ -4,17 +4,24 @@ export * from "./Game";
 export * from "./GameConstants";
 export * from "./Model";
 export * from "./RawControls";
+export * from "./RawKeymaps";
 export * from "./RelationshipGroup";
+export * from "./Task";
 export * from "./Volume";
 export * from "./world/createDraftVehicle";
 export * from "./world/createPed";
 export * from "./world/createProp";
 export * from "./world/createVehicle";
+export * from "./utils/Animations";
 export * from "./utils/Native";
 export * from "./types/Throwable";
 export * from "./interfaces/Dimensions";
+export * from "./enums/AnimationFlags";
 export * from "./enums/Attributes";
+export * from "./enums/Driving";
+export * from "./enums/EnterExitFlags";
 export * from "./enums/Entity";
+export * from "./enums/FiringPatterns";
 export * from "./enums/Keys";
 export * from "./enums/Ped";
 export * from "./enums/RawKeys";

package/package.json

@@ -8,7 +8,7 @@
   ],
   "license": "MIT",
   "type": "module",
-  "version": "0.0.85",
+  "version": "0.0.87",
   "repository": {
     "type": "git",
     "url": "https://github.com/nativewrappers/nativewrappers.git"
@@ -28,6 +28,7 @@
     "./**/*.js",
     "./**/*.d.ts"
   ],
+  "sideEffects": false,
   "exports": {
     ".": "./index.js",
     "./*": "./*"

package/utils/Animations.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A utility to load an animation dictionary, anything that loads an animation should RemoveAnimDict after its finish being used.
+ * @param animDict the animation dictionary to load
+ * @param waitTime how long to wait for the dictionary to load
+ * @returns {boolean} if the animation successfully loaded
+ */
+export declare const LoadAnimDict: (animDict: string, waitTime?: number) => Promise<boolean>;
+/**
+ * A utility to load multiple animation dictionary, anything that loads an animation should RemoveAnimDict after its finish being used.
+ * @param animDict the animation dictionary to load
+ * @param waitTime how long to wait for the dictionary to load
+ * @returns if the animation successfully loaded, if the animation failed to load it will return an array of animations that failed to load
+ */
+export declare const LoadAnimDictArray: (animDict: string[], waitTime?: number) => Promise<[boolean, string[] | null]>;
+/**
+ * A utility to unload multiple animation dictionary
+ * @param animDict the animation dictionaries to unload
+ */
+export declare const RemoveAnimDictArray: (animDict: string[]) => void;

package/utils/Animations.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Delay } from "../common/utils/Delay";
+const LoadAnimDict = /* @__PURE__ */ __name(async (animDict, waitTime = 1e3) => {
+  const start = GetGameTimer();
+  if (!HasAnimDictLoaded(animDict)) {
+    RequestAnimDict(animDict);
+  }
+  while (!HasAnimDictLoaded(animDict)) {
+    if (GetGameTimer() - start >= waitTime) return false;
+    await Delay(0);
+  }
+  return true;
+}, "LoadAnimDict");
+const LoadAnimDictArray = /* @__PURE__ */ __name(async (animDict, waitTime = 1e3) => {
+  const start = GetGameTimer();
+  for (const dict of animDict) {
+    if (!HasAnimDictLoaded(dict)) {
+      RequestAnimDict(dict);
+    }
+  }
+  const animsLoaded = /* @__PURE__ */ new Set();
+  while (animsLoaded.size !== animDict.length) {
+    for (const dict of animDict) {
+      if (!animsLoaded.has(dict) && HasAnimDictLoaded(dict)) {
+        animsLoaded.add(dict);
+      }
+    }
+    if (GetGameTimer() - start >= waitTime) return [false, animDict.filter((dict) => !animsLoaded.has(dict))];
+    await Delay(0);
+  }
+  return [true, null];
+}, "LoadAnimDictArray");
+const RemoveAnimDictArray = /* @__PURE__ */ __name((animDict) => {
+  for (const dict of animDict) {
+    RemoveAnimDict(dict);
+  }
+}, "RemoveAnimDictArray");
+export {
+  LoadAnimDict,
+  LoadAnimDictArray,
+  RemoveAnimDictArray
+};