@nativewrappers/fivem 0.0.40 → 0.0.41

package/client/TaskSequence.d.ts

@@ -1,6 +1,6 @@
 import { Tasks } from './Tasks';
 export declare class TaskSequence {
-    private static nullPed;
+    private static nullTask;
     private handle;
     private isClosed;
     private count;

package/client/TaskSequence.js

@@ -1,18 +1,19 @@
-import { Ped } from './models/Ped';
+import { Tasks } from './Tasks';
 // TODO: Figure out why this uses 'null ped'
 export class TaskSequence {
     constructor(handle) {
         this.handle = 0;
         handle === undefined ? this.create() : (this.handle = handle);
-        if (!TaskSequence.nullPed) {
-            TaskSequence.nullPed = new Ped(0);
+        if (!TaskSequence.nullTask) {
+            TaskSequence.nullTask = new Tasks(null);
         }
         this.isClosed = false;
         this.count = 0;
     }
     create() {
         // Docs generate this as 'void' even though it returns a number
-        this.handle = OpenSequenceTask(0);
+        // @ts-ignore ignore the fact that OpenSequenceTask expects a paramater
+        this.handle = OpenSequenceTask();
     }
     dispose() {
         ClearSequenceTask(this.handle);
@@ -33,7 +34,7 @@ export class TaskSequence {
             throw new Error("You can't add tasks to a closed sequence!");
         }
         this.count += 1;
-        return TaskSequence.nullPed.Task;
+        return TaskSequence.nullTask;
     }
     get IsClosed() {
         return this.isClosed;

package/client/Tasks.d.ts

@@ -5,7 +5,7 @@ import { TaskSequence } from './TaskSequence';
 import { Vector3 } from './utils';
 export declare class Tasks {
     private ped;
-    constructor(ped: Ped);
+    constructor(ped: Ped | null);
     achieveHeading(heading: number, timeout?: number): void;
     blockTemporaryEvents(block?: boolean): void;
     aimAt(target: BaseEntity | Vector3, duration: number): void;
@@ -27,7 +27,7 @@ export declare class Tasks {
     fleeFrom(pedOrPosition: Ped | Vector3, duration?: number): void;
     followPointRoute(points: Vector3[]): void;
     followToOffsetFromEntity(target: BaseEntity, offset: Vector3, timeout: number, stoppingRange: number, movementSpeed?: number, persistFollowing?: boolean): void;
-    goTo(position: Vector3, ignorePaths?: boolean, timeout?: number, speed?: number): 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;

package/client/Tasks.js

@@ -4,8 +4,12 @@ import { BaseEntity } from './models/BaseEntity';
 import { Vector3 } from './utils';
 import { LoadAnimDict } from './utils/Animations';
 export class Tasks {
+    // we take null because sequences have a null ped, if you pass null to this
+    // you betterk now what you're doing.
     constructor(ped) {
-        this.ped = ped;
+        const actualPed = ped ?? { handle: null };
+        // @ts-ignore
+        this.ped = actualPed;
     }
     achieveHeading(heading, timeout = 0) {
         TaskAchieveHeading(this.ped.Handle, heading, timeout);
@@ -90,12 +94,12 @@ export class Tasks {
     followToOffsetFromEntity(target, offset, timeout, stoppingRange, movementSpeed = 1, persistFollowing = true) {
         TaskFollowToOffsetOfEntity(this.ped.Handle, target.Handle, offset.x, offset.y, offset.z, movementSpeed, timeout, stoppingRange, persistFollowing);
     }
-    goTo(position, ignorePaths = false, timeout = -1, speed = 1) {
+    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, 0, 0);
+            TaskGoStraightToCoord(this.ped.Handle, position.x, position.y, position.z, speed, timeout, targetHeading, distanceToSlide);
         }
         else {
-            TaskFollowNavMeshToCoord(this.ped.Handle, position.x, position.y, position.z, speed, timeout, 0, 0, 0);
+            TaskFollowNavMeshToCoord(this.ped.Handle, position.x, position.y, position.z, speed, timeout, 0, flags, targetHeading);
         }
     }
     goToEntity(target, offset = null, timeout = -1) {
@@ -138,7 +142,7 @@ export class Tasks {
             sequence.close();
         }
         this.clearAll();
-        this.ped.BlockPermanentEvents = true;
+        // this.ped.BlockPermanentEvents = true;
         TaskPerformSequence(this.ped.Handle, sequence.Handle);
     }
     async playAnimation(animDict, animName, blendInSpeed, blendOutSpeed, duration, playbackRate, flags) {

package/client/enums/AnimationFlags.d.ts

@@ -1,9 +1,34 @@
 export declare enum AnimationFlags {
     None = 0,
-    Loop = 1,
-    StayInEndFrame = 2,
-    UpperBodyOnly = 16,
-    AllowRotation = 32,
-    CancelableWithMovement = 128,
-    RagdollOnCollision = 4194304
+    Looping = 1,
+    HoldLastFrame = 2,
+    RepositionWhenFinished = 4,
+    NotInterruptible = 8,
+    UpperBody = 16,
+    Secondary = 32,
+    ReorientWhenFinished = 64,
+    AbortOnPedMovement = 128,
+    Additive = 256,
+    TurnOffCollision = 512,
+    OverridePhysics = 1024,
+    IgnorePhysics = 2048,
+    ExtractInitialOffset = 4096,
+    ExitAfterInterrupted = 8192,
+    TagSyncIn = 16384,
+    TagSyncOut = 32768,
+    TagSyncContinous = 65536,
+    ForceStart = 131072,
+    UseKinematicPhysics = 262144,
+    UseMoverExtrations = 524288,
+    HideWeapon = 1048576,
+    EndsInDeadPose = 2097152,
+    ActivateRagdoolOnCollision = 4194304,
+    DontExitOnDeath = 8388608,
+    AbortOnWeaponDamage = 16777216,
+    DisableForcedPhysicsUpdate = 33554432,
+    ProcessAttachmentsOnStart = 67108864,
+    ExpandPedCapsuleFromSkeleton = 134217728,
+    UseAlternativeFpAnim = 268435456,
+    BlendOutWrtLastFrame = 536870912,
+    UseFullBlending = 1073741824
 }

package/client/enums/AnimationFlags.js

@@ -1,10 +1,35 @@
 export var AnimationFlags;
 (function (AnimationFlags) {
     AnimationFlags[AnimationFlags["None"] = 0] = "None";
-    AnimationFlags[AnimationFlags["Loop"] = 1] = "Loop";
-    AnimationFlags[AnimationFlags["StayInEndFrame"] = 2] = "StayInEndFrame";
-    AnimationFlags[AnimationFlags["UpperBodyOnly"] = 16] = "UpperBodyOnly";
-    AnimationFlags[AnimationFlags["AllowRotation"] = 32] = "AllowRotation";
-    AnimationFlags[AnimationFlags["CancelableWithMovement"] = 128] = "CancelableWithMovement";
-    AnimationFlags[AnimationFlags["RagdollOnCollision"] = 4194304] = "RagdollOnCollision";
+    AnimationFlags[AnimationFlags["Looping"] = 1] = "Looping";
+    AnimationFlags[AnimationFlags["HoldLastFrame"] = 2] = "HoldLastFrame";
+    AnimationFlags[AnimationFlags["RepositionWhenFinished"] = 4] = "RepositionWhenFinished";
+    AnimationFlags[AnimationFlags["NotInterruptible"] = 8] = "NotInterruptible";
+    AnimationFlags[AnimationFlags["UpperBody"] = 16] = "UpperBody";
+    AnimationFlags[AnimationFlags["Secondary"] = 32] = "Secondary";
+    AnimationFlags[AnimationFlags["ReorientWhenFinished"] = 64] = "ReorientWhenFinished";
+    AnimationFlags[AnimationFlags["AbortOnPedMovement"] = 128] = "AbortOnPedMovement";
+    AnimationFlags[AnimationFlags["Additive"] = 256] = "Additive";
+    AnimationFlags[AnimationFlags["TurnOffCollision"] = 512] = "TurnOffCollision";
+    AnimationFlags[AnimationFlags["OverridePhysics"] = 1024] = "OverridePhysics";
+    AnimationFlags[AnimationFlags["IgnorePhysics"] = 2048] = "IgnorePhysics";
+    AnimationFlags[AnimationFlags["ExtractInitialOffset"] = 4096] = "ExtractInitialOffset";
+    AnimationFlags[AnimationFlags["ExitAfterInterrupted"] = 8192] = "ExitAfterInterrupted";
+    AnimationFlags[AnimationFlags["TagSyncIn"] = 16384] = "TagSyncIn";
+    AnimationFlags[AnimationFlags["TagSyncOut"] = 32768] = "TagSyncOut";
+    AnimationFlags[AnimationFlags["TagSyncContinous"] = 65536] = "TagSyncContinous";
+    AnimationFlags[AnimationFlags["ForceStart"] = 131072] = "ForceStart";
+    AnimationFlags[AnimationFlags["UseKinematicPhysics"] = 262144] = "UseKinematicPhysics";
+    AnimationFlags[AnimationFlags["UseMoverExtrations"] = 524288] = "UseMoverExtrations";
+    AnimationFlags[AnimationFlags["HideWeapon"] = 1048576] = "HideWeapon";
+    AnimationFlags[AnimationFlags["EndsInDeadPose"] = 2097152] = "EndsInDeadPose";
+    AnimationFlags[AnimationFlags["ActivateRagdoolOnCollision"] = 4194304] = "ActivateRagdoolOnCollision";
+    AnimationFlags[AnimationFlags["DontExitOnDeath"] = 8388608] = "DontExitOnDeath";
+    AnimationFlags[AnimationFlags["AbortOnWeaponDamage"] = 16777216] = "AbortOnWeaponDamage";
+    AnimationFlags[AnimationFlags["DisableForcedPhysicsUpdate"] = 33554432] = "DisableForcedPhysicsUpdate";
+    AnimationFlags[AnimationFlags["ProcessAttachmentsOnStart"] = 67108864] = "ProcessAttachmentsOnStart";
+    AnimationFlags[AnimationFlags["ExpandPedCapsuleFromSkeleton"] = 134217728] = "ExpandPedCapsuleFromSkeleton";
+    AnimationFlags[AnimationFlags["UseAlternativeFpAnim"] = 268435456] = "UseAlternativeFpAnim";
+    AnimationFlags[AnimationFlags["BlendOutWrtLastFrame"] = 536870912] = "BlendOutWrtLastFrame";
+    AnimationFlags[AnimationFlags["UseFullBlending"] = 1073741824] = "UseFullBlending";
 })(AnimationFlags || (AnimationFlags = {}));

package/common/utils/Vector.js

@@ -307,9 +307,9 @@ export class Vector {
     *[Symbol.iterator]() {
         yield this.x;
         yield this.y;
-        if (this.z)
+        if (this.z !== undefined)
             yield this.z;
-        if (this.w)
+        if (this.w !== undefined)
             yield this.w;
     }
     toString() {

package/package.json

@@ -4,7 +4,7 @@
   "author": "Remco Troost <d0p3t>",
   "license": "MIT",
   "type": "module",
-  "version": "0.0.40",
+  "version": "0.0.41",
   "publishConfig": {
     "directory": "lib"
   },