@nativewrappers/fivem 0.0.1

package/lib/client/ParticleEffectAsset.js

@@ -0,0 +1,104 @@
+import { InvertAxisFlags } from './enums';
+import { Vector3 } from './utils';
+/**
+ * UNFINISHED! Class that represents a particle effect asset.
+ */
+export class ParticleEffectAsset {
+    /**
+     * Returns the name of the asset. Same as AssetName.
+     */
+    get Asset() {
+        return this.assetName;
+    }
+    constructor(assetName) {
+        this.assetName = assetName;
+    }
+    /**
+     * Get the name of the particle effect.
+     */
+    get AssetName() {
+        return this.assetName;
+    }
+    /**
+     * Get whether the particle effect has loaded into game memory.
+     */
+    get IsLoaded() {
+        return HasNamedPtfxAssetLoaded(this.assetName);
+    }
+    /**
+     * Start a particle effect at a world position.
+     *
+     * @param effectName Name of effect.
+     * @param rot Rotation from entity position.
+     * @param scale Size of the effect.
+     * @param invertAxis Which axis to invert (default none).
+     */
+    startNonLoopedAtCoord(effectName, pos, rot = new Vector3(0, 0, 0), scale = 1.0, invertAxis = { flags: InvertAxisFlags.None }) {
+        if (!this.setNextCall()) {
+            return false;
+        }
+        const invertAxisFlags = invertAxis.flags;
+        SetPtfxAssetNextCall(this.assetName);
+        return (StartParticleFxLoopedAtCoord(effectName, pos.x, pos.y, pos.z, rot.x, rot.y, rot.z, scale, !!(invertAxisFlags & InvertAxisFlags.X), !!(invertAxisFlags & InvertAxisFlags.Y), !!(invertAxisFlags & InvertAxisFlags.Z), false) > 0);
+    }
+    /**
+     * Start a particle effect on an entity
+     *
+     * @param effectName Name of effect.
+     * @param entity Entity to use effect on.
+     * @param off Offset from entity position.
+     * @param rot Rotation from entity position.
+     * @param scale Size of the effect.
+     * @param invertAxis Which axis to invert (default none).
+     */
+    startNonLoopedOnEntity(effectName, entity, off = new Vector3(0, 0, 0), rot = new Vector3(0, 0, 0), scale = 1.0, invertAxis = { flags: InvertAxisFlags.None }) {
+        if (!this.setNextCall()) {
+            return false;
+        }
+        const invertAxisFlags = invertAxis.flags;
+        SetPtfxAssetNextCall(this.assetName);
+        // This still returns
+        return !!StartParticleFxLoopedOnEntity(effectName, entity.Handle, off.x, off.y, off.z, rot.x, rot.y, rot.z, scale, !!(invertAxisFlags & InvertAxisFlags.X), !!(invertAxisFlags & InvertAxisFlags.Y), !!(invertAxisFlags & InvertAxisFlags.Z));
+    }
+    /**
+     * Load a particle effect into the game memory.
+     *
+     * @param timeout Max time to load Particle Effect
+     */
+    request(timeout) {
+        return new Promise(resolve => {
+            if (!this.IsLoaded) {
+                RequestNamedPtfxAsset(this.assetName);
+                const start = GetGameTimer();
+                const interval = setInterval(() => {
+                    if (this.IsLoaded || GetGameTimer() - start >= timeout) {
+                        clearInterval(interval);
+                        resolve(this.IsLoaded);
+                    }
+                }, 0);
+            }
+            else {
+                resolve(this.IsLoaded);
+            }
+        });
+    }
+    /**
+     * Allow game engine to safely unload particle effect model from memory.
+     */
+    markAsNoLongerNeeded() {
+        RemoveNamedPtfxAsset(this.assetName);
+    }
+    toString() {
+        return this.assetName;
+    }
+    setNextCall() {
+        if (!this.IsLoaded) {
+            RequestNamedPtfxAsset(this.assetName);
+        }
+        else {
+            SetPtfxAssetNextCall(this.assetName);
+            return true;
+        }
+        return false;
+    }
+}

package/lib/client/Pickup.d.ts

@@ -0,0 +1,9 @@
+import { Vector3 } from './utils';
+export declare class Pickup {
+    private handle;
+    constructor(handle: number);
+    get Position(): Vector3;
+    get IsCollected(): boolean;
+    delete(): void;
+    exists(): boolean;
+}

package/lib/client/Pickup.js

@@ -0,0 +1,18 @@
+import { Vector3 } from './utils';
+export class Pickup {
+    constructor(handle) {
+        this.handle = handle;
+    }
+    get Position() {
+        return Vector3.fromArray(GetPickupCoords(this.handle));
+    }
+    get IsCollected() {
+        return HasPickupBeenCollected(this.handle);
+    }
+    delete() {
+        RemovePickup(this.handle);
+    }
+    exists() {
+        return DoesPickupExist(this.handle);
+    }
+}

package/lib/client/Raycast.d.ts

@@ -0,0 +1,49 @@
+import { MaterialHash } from './hashes';
+import { Ped, Prop, Vehicle } from './models';
+import { Vector3 } from './utils';
+/**
+ * Class that represents the result of a raycast.
+ */
+export declare class RaycastResult {
+    /**
+     * Return the entity that was hit.
+     */
+    get HitEntity(): Ped | Vehicle | Prop | null;
+    /**
+     * Get the position of the entity that was hit.
+     */
+    get HitPosition(): Vector3;
+    /**
+     * Return the vector perpendicular to the tangent plane.
+     */
+    get SurfaceNormal(): Vector3;
+    /**
+     * Whether we hit anything.
+     */
+    get DidHit(): boolean;
+    /**
+     * Whether the entity hit exists.
+     */
+    get DidHitEntity(): boolean;
+    /**
+     * Material type that was hit.
+     */
+    get Material(): MaterialHash;
+    /**
+     * Raycast result's handle.
+     */
+    get Result(): number;
+    private handle;
+    private hitPositionArg;
+    private hitSomethingArg;
+    private entityHandleArg;
+    private surfaceNormalArg;
+    private materialArg;
+    private result;
+    /**
+     * Create a RaycastResult object that gets the results from a StartShapeTestRay()
+     *
+     * @param handle The handle returned from StartShapeTestRay()
+     */
+    constructor(handle: number);
+}

package/lib/client/Raycast.js

@@ -0,0 +1,70 @@
+import { Game } from './Game';
+import { Vector3 } from './utils';
+/**
+ * Class that represents the result of a raycast.
+ */
+export class 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?.Handle !== 0;
+    }
+    /**
+     * Material type that was hit.
+     */
+    get Material() {
+        return this.materialArg;
+    }
+    /**
+     * Raycast result's handle.
+     */
+    get Result() {
+        return this.result;
+    }
+    // FIXME: This only works with StartExpensiveSynchronousShapeTestLosProbe, this should have some getter you have to await afterwards for all of the data
+    /**
+     * 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;
+        const [result, hit, endCoords, surfaceNormal, materialHash, entityHit] = GetShapeTestResultIncludingMaterial(this.handle);
+        this.hitSomethingArg = hit;
+        this.hitPositionArg = Vector3.fromArray(endCoords);
+        this.surfaceNormalArg = Vector3.fromArray(surfaceNormal);
+        this.materialArg = materialHash;
+        this.entityHandleArg = Game.entityFromHandle(entityHit);
+        this.result = result;
+    }
+}

package/lib/client/RelationshipGroup.d.ts

@@ -0,0 +1,49 @@
+import { Relationship } from './enums';
+/**
+ * Class to create and manage a relationship group. Useful to manage behavior between Peds.
+ */
+export declare class RelationshipGroup {
+    /**
+     * The hash of the relationship group
+     */
+    private hash;
+    /**
+     * Create a relationship group. Optionally pass a group hash.
+     *
+     * @param name Name of the relationship group.
+     */
+    constructor(name: string);
+    /**
+     * Gets the hash of the relationship group.
+     *
+     * @returns The hash of this object.
+     */
+    get Hash(): number;
+    /**
+     * Get the relationship between two relationship groups.
+     *
+     * @param targetGroup The other relationship group.
+     * @returns The relationship
+     */
+    getRelationshipBetweenGroups(targetGroup: RelationshipGroup): Relationship;
+    /**
+     * 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: RelationshipGroup, relationship: Relationship, biDirectionally?: boolean): void;
+    /**
+     * 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: RelationshipGroup, relationship: Relationship, biDirectionally?: boolean): void;
+    /**
+     * Remove this relationship group from the game. This will not delete this object.
+     */
+    remove(): void;
+}

package/lib/client/RelationshipGroup.js

@@ -0,0 +1,63 @@
+/**
+ * Class to create and manage a relationship group. Useful to manage behavior between Peds.
+ */
+export class RelationshipGroup {
+    /**
+     * 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);
+    }
+}

package/lib/client/Rope.d.ts

@@ -0,0 +1,99 @@
+import type { BaseEntity } from './models/BaseEntity';
+import { Vector3 } from './utils';
+/**
+ * Class to manage invisible ropes between entities.
+ */
+export declare class Rope {
+    /**
+     * Id of rope entity.
+     */
+    private readonly handle;
+    /**
+     * Create a rope object based on an existing rope in the world.
+     *
+     * @param handle entity Id of rope.
+     */
+    constructor(handle: number);
+    get Handle(): number;
+    /**
+     * Get the length of the rope.
+     *
+     * @returns The rope length.
+     */
+    get Length(): number;
+    /**
+     * Sets the length of the rope.
+     *
+     * @param length Desired new length of rope.
+     */
+    set Length(length: number);
+    /**
+     * Get the number of vertices on the rope.
+     *
+     * @returns Returns the number of vertices.
+     */
+    get VertexCount(): number;
+    /**
+     * 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: boolean): void;
+    /**
+     * Activates world physics on the rope object.
+     */
+    activatePhysics(): void;
+    /**
+     * 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: BaseEntity, position: Vector3): void;
+    /**
+     * 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: BaseEntity, positionOne: Vector3, entityTwo: BaseEntity, positionTwo: Vector3, length: number): void;
+    /**
+     * Detach the rope from an entity.
+     *
+     * @param entity Entity to detach the rope from.
+     */
+    detachEntity(entity: BaseEntity): void;
+    /**
+     * 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: number, position: Vector3): void;
+    /**
+     * Unpin a specified vertex from it's current pinned location (if any).
+     *
+     * @param vertex Vertex to unpin.
+     */
+    unpinVertex(vertex: number): void;
+    /**
+     * 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: number): Vector3;
+    /**
+     * Delete the rope from the world. This does not delete the rope object.
+     */
+    delete(): void;
+    /**
+     * Check if the rope still exists in the world based on it's handle.
+     *
+     * @returns Whether the rope exists or not.
+     */
+    exists(): boolean;
+}

package/lib/client/Rope.js

@@ -0,0 +1,125 @@
+import { Vector3 } from './utils';
+/**
+ * Class to manage invisible ropes between entities.
+ */
+export class Rope {
+    /**
+     * 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;
+    }
+}

package/lib/client/TaskSequence.d.ts

@@ -0,0 +1,15 @@
+import { Tasks } from './Tasks';
+export declare class TaskSequence {
+    private static nullPed;
+    private handle;
+    private isClosed;
+    private count;
+    constructor(handle?: number);
+    private create;
+    dispose(): void;
+    close(repeat?: boolean): void;
+    get Handle(): number;
+    get AddTask(): Tasks | null | undefined;
+    get IsClosed(): boolean;
+    get Count(): number;
+}

package/lib/client/TaskSequence.js

@@ -0,0 +1,43 @@
+import { Ped } from './models/Ped';
+export class TaskSequence {
+    constructor(handle) {
+        this.handle = 0;
+        handle === undefined ? this.create() : (this.handle = handle);
+        if (!TaskSequence.nullPed) {
+            TaskSequence.nullPed = new Ped(0);
+        }
+        this.isClosed = false;
+        this.count = 0;
+    }
+    create() {
+        // Docs generate this as 'void' even though it returns a number
+        this.handle = OpenSequenceTask(0);
+    }
+    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.nullPed?.Task;
+    }
+    get IsClosed() {
+        return this.isClosed;
+    }
+    get Count() {
+        return this.count;
+    }
+}