@nativewrappers/fivem 0.0.80 → 0.0.82

package/Raycast.js

@@ -0,0 +1,132 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./common/utils/Vector";
+import { ShapeTestStatus } from "./enums/RaycastEnums";
+import { Game } from "./Game";
+import { Delay } from "./common/utils/Delay";
+class RaycastResult {
+  static {
+    __name(this, "RaycastResult");
+  }
+  /**
+   * Return the entity that was hit.
+   */
+  get HitEntity() {
+    return this.entityHandleArg;
+  }
+  /**
+   * Get the position of the entity that was hit.
+   */
+  get HitPosition() {
+    return this.hitPositionArg;
+  }
+  /**
+   * Return the vector perpendicular to the tangent plane.
+   */
+  get SurfaceNormal() {
+    return this.surfaceNormalArg;
+  }
+  /**
+   * Whether we hit anything.
+   */
+  get DidHit() {
+    return this.hitSomethingArg;
+  }
+  /**
+   * Whether the entity hit exists.
+   */
+  get DidHitEntity() {
+    return this.entityHandleArg !== null && this.entityHandleArg.Handle !== 0;
+  }
+  /**
+   * Material type that was hit.
+   */
+  get Material() {
+    return this.materialArg;
+  }
+  /**
+   * Raycast result's handle.
+   */
+  get Result() {
+    return this.result;
+  }
+  /**
+   * @returns if the shape test handle was already discarded
+   */
+  get WasDiscarded() {
+    return this.result === ShapeTestStatus.Discarded;
+  }
+  /**
+   * NOTE: These will not be updated unless polled by `resolve` or the shape
+   * test is synchronous
+   * @returns if the raycast has been marked as ready by the engine
+   */
+  get HasResolved() {
+    return this.result === ShapeTestStatus.Ready;
+  }
+  applyShapeTestResults() {
+    const [result, hit, endCoords, surfaceNormal, materialHash, entityHit] = GetShapeTestResultIncludingMaterial(
+      this.handle
+    );
+    this.result = result;
+    if (!this.HasResolved || this.WasDiscarded) return;
+    this.hitSomethingArg = hit;
+    this.hitPositionArg = Vector3.fromArray(endCoords);
+    this.surfaceNormalArg = Vector3.fromArray(surfaceNormal);
+    this.materialArg = materialHash;
+    if (entityHit !== 0) {
+      this.entityHandleArg = Game.entityFromHandle(entityHit);
+    }
+  }
+  handle;
+  hitPositionArg;
+  hitSomethingArg;
+  entityHandleArg;
+  surfaceNormalArg;
+  materialArg;
+  result;
+  /**
+   * Create a RaycastResult object that gets the results from a StartShapeTestRay()
+   *
+   * @param handle The handle returned from StartShapeTestRay()
+   */
+  constructor(handle) {
+    this.handle = handle;
+    this.hitPositionArg = new Vector3(0, 0, 0);
+    this.hitSomethingArg = false;
+    this.entityHandleArg = null;
+    this.surfaceNormalArg = new Vector3(0, 0, 0);
+    this.materialArg = 0;
+    this.result = ShapeTestStatus.NotReady;
+  }
+}
+class SynchronousRaycastResult extends RaycastResult {
+  static {
+    __name(this, "SynchronousRaycastResult");
+  }
+  constructor(handle) {
+    super(handle);
+    this.applyShapeTestResults();
+  }
+}
+class AsynchronousRaycastResult extends RaycastResult {
+  static {
+    __name(this, "AsynchronousRaycastResult");
+  }
+  /**
+   * waits until the shape test handle is valid and then sets the expected
+   * values on the RaycastResult
+   */
+  async resolve(timeoutInMs = 1e3) {
+    const timeout = GetGameTimer() + timeoutInMs;
+    while (!this.HasResolved && !this.WasDiscarded) {
+      this.applyShapeTestResults();
+      if (timeout < GetGameTimer()) break;
+      await Delay(0);
+    }
+  }
+}
+export {
+  AsynchronousRaycastResult,
+  SynchronousRaycastResult
+};

package/RelationshipGroup.d.ts

@@ -1,4 +1,4 @@
-import type { Relationship } from "./enums";
+import type { Relationship } from "./enums/Relationship";
 /**
  * Class to create and manage a relationship group. Useful to manage behavior between Peds.
  */

package/RelationshipGroup.js

@@ -0,0 +1,72 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class RelationshipGroup {
+  static {
+    __name(this, "RelationshipGroup");
+  }
+  /**
+   * The hash of the relationship group
+   */
+  hash;
+  /**
+   * Create a relationship group. Optionally pass a group hash.
+   *
+   * @param name Name of the relationship group.
+   */
+  constructor(name) {
+    const [, groupHash] = AddRelationshipGroup(name);
+    this.hash = groupHash;
+  }
+  /**
+   * Gets the hash of the relationship group.
+   *
+   * @returns The hash of this object.
+   */
+  get Hash() {
+    return this.hash;
+  }
+  /**
+   * Get the relationship between two relationship groups.
+   *
+   * @param targetGroup The other relationship group.
+   * @returns The relationship
+   */
+  getRelationshipBetweenGroups(targetGroup) {
+    return GetRelationshipBetweenGroups(this.Hash, targetGroup.Hash);
+  }
+  /**
+   * Set the relationship group between this relationship group and another one.
+   *
+   * @param targetGroup The other relationship group.
+   * @param relationship The desired relationship.
+   * @param biDirectionally If target group should have same relationship towards this.
+   */
+  setRelationshipBetweenGroups(targetGroup, relationship, biDirectionally = false) {
+    SetRelationshipBetweenGroups(Number(relationship), this.Hash, targetGroup.Hash);
+    if (biDirectionally) {
+      SetRelationshipBetweenGroups(Number(relationship), targetGroup.Hash, this.Hash);
+    }
+  }
+  /**
+   * Clear the relationship between this relationship group and another.
+   *
+   * @param targetGroup The other relationship group.
+   * @param relationship The desired relationship to clear.
+   * @param biDirectionally Whether the target group should also clear the relationship.
+   */
+  clearRelationshipBetweenGroups(targetGroup, relationship, biDirectionally = false) {
+    ClearRelationshipBetweenGroups(Number(relationship), this.Hash, targetGroup.Hash);
+    if (biDirectionally) {
+      ClearRelationshipBetweenGroups(Number(relationship), targetGroup.Hash, this.Hash);
+    }
+  }
+  /**
+   * Remove this relationship group from the game. This will not delete this object.
+   */
+  remove() {
+    RemoveRelationshipGroup(this.Hash);
+  }
+}
+export {
+  RelationshipGroup
+};

package/Rope.d.ts

@@ -1,5 +1,5 @@
+import { Vector3 } from "./common/utils/Vector";
 import type { BaseEntity } from "./models/BaseEntity";
-import { Vector3 } from "./utils";
 /**
  * Class to manage invisible ropes between entities.
  */

package/Rope.js

@@ -0,0 +1,149 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./common/utils/Vector";
+class Rope {
+  static {
+    __name(this, "Rope");
+  }
+  /**
+   * Id of rope entity.
+   */
+  handle;
+  /**
+   * Create a rope object based on an existing rope in the world.
+   *
+   * @param handle entity Id of rope.
+   */
+  constructor(handle) {
+    this.handle = handle;
+  }
+  get Handle() {
+    return this.handle;
+  }
+  /**
+   * Get the length of the rope.
+   *
+   * @returns The rope length.
+   */
+  get Length() {
+    return GetRopeLength(this.handle);
+  }
+  /**
+   * Sets the length of the rope.
+   *
+   * @param length Desired new length of rope.
+   */
+  set Length(length) {
+    RopeForceLength(this.handle, length);
+  }
+  /**
+   * Get the number of vertices on the rope.
+   *
+   * @returns Returns the number of vertices.
+   */
+  get VertexCount() {
+    return GetRopeVertexCount(this.handle);
+  }
+  /**
+   * Resets the length of the rope to it's length upon object creation or a length of 1.
+   *
+   * @param reset Whether to reset the length to it's original length or 1.
+   */
+  resetLength(reset) {
+    RopeResetLength(this.handle, reset ? 1 : this.Length);
+  }
+  /**
+   * Activates world physics on the rope object.
+   */
+  activatePhysics() {
+    ActivatePhysics(this.handle);
+  }
+  /**
+   * Attach the rope to an entity.
+   *
+   * @param entity Entity to attach the rope to.
+   * @param position Location where the rope is to be attached.
+   */
+  attachEntity(entity, position) {
+    AttachRopeToEntity(this.handle, entity.Handle, position.x, position.y, position.z, false);
+  }
+  /**
+   * Attach the rope between two entities at given locations on the entities.
+   *
+   * @param entityOne The first entity to attach to.
+   * @param positionOne Where on the first entity to attach the rope to.
+   * @param entityTwo The second entity to attach to.
+   * @param positionTwo Where on the second entity to attach the rope to.
+   * @param length The desired length of the rope between the two entities.
+   */
+  attachEntities(entityOne, positionOne, entityTwo, positionTwo, length) {
+    AttachEntitiesToRope(
+      this.handle,
+      entityOne.Handle,
+      entityTwo.Handle,
+      positionOne.x,
+      positionOne.y,
+      positionOne.z,
+      positionTwo.x,
+      positionTwo.y,
+      positionTwo.z,
+      length,
+      false,
+      false,
+      "",
+      ""
+    );
+  }
+  /**
+   * Detach the rope from an entity.
+   *
+   * @param entity Entity to detach the rope from.
+   */
+  detachEntity(entity) {
+    DetachRopeFromEntity(this.handle, entity.Handle);
+  }
+  /**
+   * Pin a vertex of the rope to a certain location.
+   *
+   * @param vertex Vertex to pin.
+   * @param position Location to pin the vertex to.
+   */
+  pinVertex(vertex, position) {
+    PinRopeVertex(this.handle, vertex, position.x, position.y, position.z);
+  }
+  /**
+   * Unpin a specified vertex from it's current pinned location (if any).
+   *
+   * @param vertex Vertex to unpin.
+   */
+  unpinVertex(vertex) {
+    UnpinRopeVertex(this.handle, vertex);
+  }
+  /**
+   * Return the world location of a specified vertex on the rope.
+   *
+   * @param vertex Vertex to get location from.
+   * @returns The vector location of the vertex.
+   */
+  getVertexCoord(vertex) {
+    return Vector3.fromArray(GetRopeVertexCoord(this.handle, vertex));
+  }
+  /**
+   * Delete the rope from the world. This does not delete the rope object.
+   */
+  delete() {
+    DeleteRope(this.handle);
+  }
+  /**
+   * Check if the rope still exists in the world based on it's handle.
+   *
+   * @returns Whether the rope exists or not.
+   */
+  exists() {
+    const [exists] = DoesRopeExist(this.handle);
+    return exists;
+  }
+}
+export {
+  Rope
+};

package/TaskSequence.js

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Tasks } from "./Tasks";
+class TaskSequence {
+  static {
+    __name(this, "TaskSequence");
+  }
+  static nullTask;
+  handle = 0;
+  isClosed;
+  count;
+  constructor(handle) {
+    handle === void 0 ? this.create() : this.handle = handle;
+    if (!TaskSequence.nullTask) {
+      TaskSequence.nullTask = new Tasks(null);
+    }
+    this.isClosed = false;
+    this.count = 0;
+  }
+  create() {
+    this.handle = OpenSequenceTask();
+  }
+  dispose() {
+    ClearSequenceTask(this.handle);
+    this.handle = 0;
+  }
+  close(repeat = false) {
+    if (this.isClosed) return;
+    SetSequenceToRepeat(this.handle, repeat);
+    CloseSequenceTask(this.handle);
+    this.isClosed = true;
+  }
+  get Handle() {
+    return this.handle;
+  }
+  get AddTask() {
+    if (this.isClosed) {
+      throw new Error("You can't add tasks to a closed sequence!");
+    }
+    this.count += 1;
+    return TaskSequence.nullTask;
+  }
+  get IsClosed() {
+    return this.isClosed;
+  }
+  get Count() {
+    return this.count;
+  }
+}
+export {
+  TaskSequence
+};

package/Tasks.d.ts

@@ -1,8 +1,13 @@
-import { type AnimationFlags, DrivingStyle, FiringPattern, type LeaveVehicleFlags, VehicleSeat } from "./enums";
-import { Ped, type Vehicle } from "./models";
+import { Vector3 } from "./common/utils/Vector";
+import type { AnimationFlags } from "./enums/AnimationFlags";
+import { DrivingStyle } from "./enums/Driving";
+import { FiringPattern } from "./enums/FiringPattern";
+import { VehicleSeat } from "./enums/Vehicle";
+import type { LeaveVehicleFlags } from "./enums/LeaveVehicleFlags";
 import { BaseEntity } from "./models/BaseEntity";
+import { Ped } from "./models/Ped";
+import type { Vehicle } from "./models/Vehicle";
 import type { TaskSequence } from "./TaskSequence";
-import { Vector3 } from "./utils";
 export declare class Tasks {
     private ped;
     constructor(ped: Ped | null);