@nativewrappers/redm-codegen 0.0.2 → 0.0.4

package/src/classes/PedTask.ts

@@ -20,98 +20,99 @@ export class PedTask extends BaseTask {
   }
 
   /**
-   * @param pos 
-   * @param speedMultiplier 
-   * @param timeout 
-   * @param stoppingRange 
-   * @param flags 
-   * @param p8 
-   * @param p9 
-   * @param p10 
-   * @param entity 
-   * @param unk 
+   * Baits: p_fishHook02x, p_baitBread01x, p_baitCorn01x, p_baitCheese01x, p_baitWorm01x, p_baitCricket01x, p_crawdad01x, p_finisheDragonfly01x, p_finisdFishlure01x, p_finishdCrawd01x, p_finisheDragonflyLegendary01x, p_finisdFishlureLegendary01x, p_finishdCrawdLegendary01x, p_lgoc_spinner_v4
+   *
+   * @param bait 
+   * @param withoutBuoy 
+   * @param instantly 
    */
-  followNavMeshToCoordAdvanced(pos: Vector3, speedMultiplier: number, timeout: number, stoppingRange: number, flags: number, p8: number, p9: number, p10: number, entity: Entity, unk: number): void {
-    inv<void>('0x17F58B88D085DBAC', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(speedMultiplier), timeout, f(stoppingRange), flags, f(p8), f(p9), f(p10), entity.handle, f(unk));
+  setFishingBait(bait: string | null, withoutBuoy: boolean, instantly: boolean): void {
+    inv<void>('0x9B0C7FA063E67629', this.entity.handle, bait, withoutBuoy, instantly);
   }
 
   /**
-   * @param radius 
-   * @param time 
-   * @param flags 
+   * Params: p3, p4, p5, p6: 0, 0, 0, -1.0f in R* Scripts
+   *
+   * @param item 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @returns guid
    */
-  combatHatedTargetsAroundPedTimed(radius: number, time: number, flags: number): void {
-    inv<void>('0x2BBA30B854534A0C', this.entity.handle, f(radius), time, flags);
+  itemInteraction3(item: string | number, p3: any, p4: any, p5: any, p6: number): number {
+    const result = inv<number>('0xD61D5E1AD9876DEB', this.entity.handle, _h(item), pvi(), p3, p4, p5, f(p6));
+    return result;
   }
 
   /**
-   * @returns
+   * @returns Returns `true` if the specified `ped` is currently in combat using a ranged weapon, and is ready to shoot (actively attempting to attack)
    */
-  isPedRunning(): boolean {
-    return inv<boolean>('0xC5286FFC176F28A2', this.entity.handle, rai());
+  getTaskCombatReadyToShoot(): boolean {
+    return inv<boolean>('0x5EA655F01D93667A', this.entity.handle, rai());
   }
 
   /**
-   * @returns
+   * @param vehicle 
+   * @param seat 
    */
-  isPedSprinting(): boolean {
-    return inv<boolean>('0x57E457CD2C0FC168', this.entity.handle, rai());
+  warpPedIntoVehicle(vehicle: Vehicle, seat: number): void {
+    inv<void>('0x9A7D091411C5F684', this.entity.handle, vehicle.handle, seat);
   }
 
   /**
-   * @param useSlidingSurfaces 
+   * ped = Ped you want to perform this task.
+   * target = the Entity they should aim at.
+   * distanceToStopAt = distance from the target, where the ped should stop to aim.
+   * StartAimingDist = distance where the ped should start to aim.
+   *
+   * @param target 
+   * @param distanceToStopAt 
+   * @param StartAimingDist 
    */
-  setPedPathMayUseSlidingSurfaces(useSlidingSurfaces: boolean): void {
-    inv<void>('0x06ECF3925BC2ABAE', this.entity.handle, useSlidingSurfaces);
+  gotoEntityAiming(target: Entity, distanceToStopAt: number, StartAimingDist: number): void {
+    inv<void>('0xA9DA48FAB8A76C12', this.entity.handle, target.handle, f(distanceToStopAt), f(StartAimingDist));
   }
 
   /**
-   * Force a ped that is already attacking to aim directly at the specified world coordinates.
-   *
-   * @param pos 
+   * @param p1 
+   * @param p2 
+   * @param p3 
    * @param p4 
    * @param p5 
    * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   * @param p13 
+   * @param p14 
    */
-  forcePointAimAtCoord(pos: Vector3, p4?: number, p5?: boolean, p6?: boolean): void {
-    inv<void>('0x41323F4E0C4AE94B', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), p4, p5, p6);
+  goToCoordWhileAimingAtEntityUsingCombatStyle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, p12: any, p13: any, p14: any): void {
+    inv<void>('0x78426D0982D083C9', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
   }
 
   /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   * @param p4 
+   * Used with 'P_BODYPARTARMFLOAT02X' model in fishing_core.c
+   *
+   * @param object 
    */
-  swapWeapon(p1: any, p2: any, p3: any, p4: any): void {
-    inv<void>('0xA21C51255B205245', this.entity.handle, p1, p2, p3, p4);
+  pedFishingrodHookObject(object: Prop): void {
+    inv<void>('0xCE71C2F9BAA3F975', this.entity.handle, object.handle);
   }
 
   /**
-   * @param p1 
+   * @param exitAnimation 
    * @param p2 
-   * @param p3 
-   * @param p4 
-   * @param p5 
-   * @param p6 
-   * @param p7 
-   * @param p8 
    */
-  gotoEntityOffsetXyz(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
-    inv<void>('0xFA6DA9D151769392', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
+  reactLookAtEnd(exitAnimation: number, p2: boolean): void {
+    inv<void>('0x541E5B41DCA45828', this.entity.handle, exitAnimation, p2);
   }
 
-  /**
-   * @param pos 
-   * @param distance 
-   * @param duration 
-   * @param p6 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   */
-  useNearestScenarioToCoordWarp(pos: Vector3, distance: number, duration: number, p6: boolean, p7: boolean, p8: boolean, p9: boolean): void {
-    inv<void>('0x58E2E0F23F6B76C3', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), duration, p6, p7, p8, p9);
+  clearDrivebyTaskUnderneathDrivingTask(): void {
+    inv<void>('0xC35B5CDB2824CF69', this.entity.handle);
   }
 
   /**
@@ -177,308 +178,179 @@ export class PedTask extends BaseTask {
   }
 
   /**
-   * fleeType: see TASK_FLEE_COORD
-   *
-   * @param fleeFromTarget 
-   * @param pos 
-   * @param distance 
-   * @param p6 
-   * @param p7 
-   * @param p8 
-   * @param targetPed 
+   * @param p1 
    */
-  fleeFromPed(fleeFromTarget: Ped, pos: Vector3, distance: number, p6: number, p7: number, p8: number, targetPed: Ped): void {
-    inv<void>('0x7B74D8EEDE9B5727', this.entity.handle, fleeFromTarget.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p6, p7, f(p8), targetPed.handle);
+  N_0xFFB520A3E16F7B7B(p1: number): void {
+    inv<void>('0xFFB520A3E16F7B7B', this.entity.handle, f(p1));
   }
 
-  /**
-   * @returns
-   */
-  isPedGettingUp(): boolean {
-    return inv<boolean>('0x2A74E1D5F2F00EEC', this.entity.handle, rai());
+  persistentCharacter(): void {
+    inv<void>('0x4391700CBD89C3D8', this.entity.handle);
   }
 
   /**
-   * @param time 
+   * @param speed 
+   * @param p2 
+   * @param p3 
+   * @param p4 
    */
-  duck(time: number): void {
-    inv<void>('0xA14B5FBF986BAC23', this.entity.handle, time);
+  waypointPlaybackOverrideSpeed(speed: number, p2: any, p3: any, p4: any): void {
+    inv<void>('0x7D7D2B47FA788E85', this.entity.handle, f(speed), p2, p3, p4);
   }
 
   /**
    * @param p1 
    * @param p2 
    * @param p3 
-   * @param p4 
    */
-  robPed(p1: any, p2: any, p3: any, p4: any): void {
-    inv<void>('0x7BB967F85D8CCBDB', this.entity.handle, p1, p2, p3, p4);
+  climbLadder(p1: number, p2: boolean, p3: boolean): void {
+    inv<void>('0xB6C987F9285A3814', this.entity.handle, f(p1), p2, p3);
   }
 
   /**
-   * getupSetHash: see nm_blend_out_sets.meta
+   * Makes a ped run away from another ped (fleeFromTarget) fleeDistance = ped will flee this distance
+   * fleeTime = ped will flee for this amount of time, set to "-1" to flee forever
+   * fleeType = can be 0, R* Scripts: fm_mission/race_controller: 66048; fme_escaped_convicts: 2260992, 2523136, 2359296; la_alligator/fox: 2097152; net_fetch: 17301536; net_stable_mount: 540928
+   * fleeSpeed = mostly 3f, rarely 1f in R* Scripts
    *
-   * @param flags 
-   * @param getupSetHash 
-   * @param p3 
-   * @param p4 
-   * @param p5 
+   * @param fleeFromTarget 
+   * @param fleeDistance 
+   * @param fleeTime 
+   * @param fleeType Refer to [enum: eFleeStyle]
+   * @param fleeSpeed 
+   * @param targetPed 
    */
-  unhogtiePed(flags: number, getupSetHash: string | number, p3: string | null, p4: string | null, p5: number): void {
-    inv<void>('0x79559BAD83CCD038', this.entity.handle, flags, _h(getupSetHash), p3, p4, f(p5));
+  smartFleePed(fleeFromTarget: Ped, fleeDistance: number, fleeTime: number, fleeType: number, fleeSpeed: number, targetPed: Ped): void {
+    inv<void>('0x22B0D0E37CCB840D', this.entity.handle, fleeFromTarget.handle, f(fleeDistance), fleeTime, fleeType, f(fleeSpeed), targetPed.handle);
   }
 
   /**
-   * hecks if the ped camera is directed at the given coord within the specified radius. https://www.youtube.com/watch?v=iLHXrWVvq_c
-   *
-   * @param coord The coord to check if they're looking at
-   * @param radius The radius of the frustum
-   * @returns Returns `true` if the ped camera is within the range of the frustum, `false` otherwise
+   * @param pos 
+   * @param time 
+   * @param p5 
+   * @param p6 
    */
-  isPedLookingAtCoord(coord: Vector3, radius: number): boolean {
-    return inv<boolean>('0x508F5053E3F6F0C4', this.entity.handle, f(coord.x), f(coord.y), f(coord.z), f(radius), rai());
+  aimGunAtCoord(pos: Vector3, time: number, p5: boolean, p6: boolean): void {
+    inv<void>('0x6671F3EEC681BDA1', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), time, p5, p6);
   }
 
   /**
-   * @param entity 
+   * @param targetPed 
    */
-  walkAway(entity: Entity): void {
-    inv<void>('0x04ACFAC71E6858F9', this.entity.handle, entity.handle);
+  cutFreeHogtiedTargetPed(targetPed: Ped): void {
+    inv<void>('0x81D16C4FF3A77ADF', this.entity.handle, targetPed.handle);
   }
 
   /**
-   * @returns
+   * @param signalName 
+   * @param value 
    */
-  getHogtieEscapeTimer(): number {
-    return inv<number>('0x4687E69D258BBE41', this.entity.handle, raf());
-  }
-
-  weapon(): void {
-    inv<void>('0x7157B82D60E4BC46', this.entity.handle);
+  setTaskMoveNetworkSignalFloat2(signalName: string | null, value: number): void {
+    inv<void>('0x099D4A855D53B03B', this.entity.handle, signalName, f(value));
   }
 
   /**
-   * @returns
+   * @param p1 
+   * @param p2 
    */
-  isPedWalking(): boolean {
-    return inv<boolean>('0xDE4C184B2B9B071A', this.entity.handle, rai());
-  }
-
-  clearLookAt(): void {
-    inv<void>('0x0F804F1DB19B9689', this.entity.handle);
+  ambientAnimalHunt(p1: any, p2: any): void {
+    inv<void>('0x4B39D8F9D0FE7749', this.entity.handle, p1, p2);
   }
 
   /**
-   * @param inputContext 
-   * @returns
+   * @param goToLocationX 
+   * @param goToLocationY 
+   * @param goToLocationZ 
+   * @param focusLocationX 
+   * @param focusLocationY 
+   * @param focusLocationZ 
+   * @param speed 
+   * @param shootAtEnemies 
+   * @param distanceToStopAt 
+   * @param noRoadsDistance 
+   * @param unkTrue 
+   * @param unkFlag 
+   * @param aimingFlag 
+   * @param firingPattern 
    */
-  getItemInteractionPromptProgress(inputContext: string | number): number {
-    return inv<number>('0xBC864A70AD55E0C1', this.entity.handle, _h(inputContext), raf());
+  goToCoordAndAimAtHatedEntitiesNearCoord(goToLocationX: number, goToLocationY: number, goToLocationZ: number, focusLocationX: number, focusLocationY: number, focusLocationZ: number, speed: number, shootAtEnemies: boolean, distanceToStopAt: number, noRoadsDistance: number, unkTrue: boolean, unkFlag: number, aimingFlag: number, firingPattern: string | number): void {
+    inv<void>('0xA55547801EB331FC', this.entity.handle, f(goToLocationX), f(goToLocationY), f(goToLocationZ), f(focusLocationX), f(focusLocationY), f(focusLocationZ), f(speed), shootAtEnemies, f(distanceToStopAt), f(noRoadsDistance), unkTrue, unkFlag, aimingFlag, _h(firingPattern));
   }
 
   /**
-   * @param p1 
+   * @param itemHash 
+   * @param interactionAnimHash 
+   * @param p3 
    * @returns
    */
-  N_0x2D657B10F211C572(p1: number): any {
-    return inv<number>('0x2D657B10F211C572', this.entity.handle, f(p1));
+  canStartItemInteraction(itemHash: string | number, interactionAnimHash: string | number, p3: number): any {
+    return inv<number>('0x2D19BC4DF626CBE7', this.entity.handle, _h(itemHash), _h(interactionAnimHash), p3);
   }
 
   /**
-   * Coords: volume coords used in R* Script smuggler2
-   * p4/p5 = 0 in R* Scripts previous name TASK_COMBAT_PED_3
-   *
-   * @param pos 
+   * @param targetPed 
+   * @param p2 
+   * @param p3 
    * @param p4 
    * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
    */
-  combatPedAtCoords(pos: Vector3, p4: number, p5: number): void {
-    inv<void>('0xC624414FA748B9BA', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), p4, p5);
+  followAndConverseWithPed(targetPed: Ped, p2: any, p3: any, p4: number, p5: number, p6: number, p7: any, p8: any, p9: number, p10: number): void {
+    inv<void>('0x489FFCCCE7392B55', this.entity.handle, targetPed.handle, p2, p3, f(p4), f(p5), p6, p7, p8, f(p9), f(p10));
   }
 
   /**
-   * Makes the specified ped stand still for (time) milliseconds.
-   *
-   * @param time 
-   */
-  standStill(time: number): void {
-    inv<void>('0x919BE13EED931959', this.entity.handle, time);
-  }
-
-  /**
-   * @param animDictionary 
-   * @param animationName 
-   * @param p3 
-   */
-  stopAnimTask(animDictionary: string | null, animationName: string | null, p3: number): void {
-    inv<void>('0x97FF36A1D40EA00A', this.entity.handle, animDictionary, animationName, f(p3));
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   */
-  turnToFaceClosestPed(p1: number, p2: number, p3: number): void {
-    inv<void>('0x84179419DBDD36F2', this.entity.handle, f(p1), f(p2), p3);
-  }
-
-  /**
-   * Fishing Research: https://pastebin.com/NmK5ZLVs
-   * Only used in R* Scripts fishing_core and av_fishing_river
-   *
-   * @returns p1
-   */
-  getTaskFishing(): [any, number] {
-    const result = inv<[number, number]>('0xF3735ACD11ACD500', this.entity.handle, pvi());
-    return [result[0], result[1]];
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   */
-  shockingEventReact(p1: any, p2: any): void {
-    inv<void>('0x452419CBD838065B', this.entity.handle, p1, p2);
-  }
-
-  /**
-   * @returns
-   */
-  N_0xB520DBDA7FCF573F(): boolean {
-    return inv<boolean>('0xB520DBDA7FCF573F', this.entity.handle, rai());
-  }
-
-  /**
-   * Baits: p_fishHook02x, p_baitBread01x, p_baitCorn01x, p_baitCheese01x, p_baitWorm01x, p_baitCricket01x, p_crawdad01x, p_finisheDragonfly01x, p_finisdFishlure01x, p_finishdCrawd01x, p_finisheDragonflyLegendary01x, p_finisdFishlureLegendary01x, p_finishdCrawdLegendary01x, p_lgoc_spinner_v4
-   *
-   * @param bait 
-   * @param withoutBuoy 
-   * @param instantly 
-   */
-  setFishingBait(bait: string | null, withoutBuoy: boolean, instantly: boolean): void {
-    inv<void>('0x9B0C7FA063E67629', this.entity.handle, bait, withoutBuoy, instantly);
-  }
-
-  /**
-   * Params: p3, p4, p5, p6: 0, 0, 0, -1.0f in R* Scripts
-   *
-   * @param item 
-   * @param p3 
-   * @param p4 
-   * @param p5 
-   * @param p6 
-   * @returns guid
-   */
-  itemInteraction3(item: string | number, p3: any, p4: any, p5: any, p6: number): number {
-    const result = inv<number>('0xD61D5E1AD9876DEB', this.entity.handle, _h(item), pvi(), p3, p4, p5, f(p6));
-    return result;
-  }
-
-  /**
-   * @returns Returns `true` if the specified `ped` is currently in combat using a ranged weapon, and is ready to shoot (actively attempting to attack)
-   */
-  getTaskCombatReadyToShoot(): boolean {
-    return inv<boolean>('0x5EA655F01D93667A', this.entity.handle, rai());
-  }
-
-  /**
-   * @param vehicle 
-   * @param seat 
-   */
-  warpPedIntoVehicle(vehicle: Vehicle, seat: number): void {
-    inv<void>('0x9A7D091411C5F684', this.entity.handle, vehicle.handle, seat);
-  }
-
-  /**
-   * ped = Ped you want to perform this task.
-   * target = the Entity they should aim at.
-   * distanceToStopAt = distance from the target, where the ped should stop to aim.
-   * StartAimingDist = distance where the ped should start to aim.
-   *
-   * @param target 
-   * @param distanceToStopAt 
-   * @param StartAimingDist 
-   */
-  gotoEntityAiming(target: Entity, distanceToStopAt: number, StartAimingDist: number): void {
-    inv<void>('0xA9DA48FAB8A76C12', this.entity.handle, target.handle, f(distanceToStopAt), f(StartAimingDist));
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   * @param p4 
+   * @param pos 
+   * @param distance 
    * @param p5 
    * @param p6 
    * @param p7 
    * @param p8 
-   * @param p9 
-   * @param p10 
-   * @param p11 
-   * @param p12 
-   * @param p13 
-   * @param p14 
    */
-  goToCoordWhileAimingAtEntityUsingCombatStyle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, p12: any, p13: any, p14: any): void {
-    inv<void>('0x78426D0982D083C9', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
+  useNearestScenarioChainToCoord(pos: Vector3, distance: number, p5: boolean, p6: boolean, p7: boolean, p8: boolean): void {
+    inv<void>('0x9FDA1B3D7E7028B3', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p5, p6, p7, p8);
   }
 
   /**
-   * Used with 'P_BODYPARTARMFLOAT02X' model in fishing_core.c
-   *
-   * @param object 
+   * @param eventName 
+   * @returns
    */
-  pedFishingrodHookObject(object: Prop): void {
-    inv<void>('0xCE71C2F9BAA3F975', this.entity.handle, object.handle);
+  getTaskMoveNetworkEvent(eventName: string | null): boolean {
+    return inv<boolean>('0xB4F47213DF45A64C', this.entity.handle, eventName, rai());
   }
 
   /**
-   * @param exitAnimation 
-   * @param p2 
+   * Baits: see 0x9B0C7FA063E67629
+   *
+   * @param bait 
+   * @param withoutBuoy 
    */
-  reactLookAtEnd(exitAnimation: number, p2: boolean): void {
-    inv<void>('0x541E5B41DCA45828', this.entity.handle, exitAnimation, p2);
-  }
-
-  clearDrivebyTaskUnderneathDrivingTask(): void {
-    inv<void>('0xC35B5CDB2824CF69', this.entity.handle);
+  swapFishingBait(bait: string | null, withoutBuoy: boolean): void {
+    inv<void>('0x2C28AC30A72722DA', this.entity.handle, bait, withoutBuoy);
   }
 
   /**
    * @returns
    */
-  getPedWaypointOverrideSpeed(): number {
-    return inv<number>('0xD39A2F3E7FCAFF08', this.entity.handle, raf());
+  isDrivebyTaskUnderneathDrivingTask(): boolean {
+    return inv<boolean>('0x8785E6E40C7A8818', this.entity.handle, rai());
   }
 
-  /**
-   * Climbs or vaults the nearest thing.
-   *
-   * @param unused 
-   */
-  climb(unused: boolean): void {
-    inv<void>('0x89D9FCC2435112F1', this.entity.handle, unused);
+  cuffPed(): void {
+    inv<void>('0x7981037A96E7D174', this.entity.handle);
   }
 
   /**
-   * Old name: _TASK_VEHICLE_DRIVE_TO_POINT
-   * flag: 524419 and 0 in shop_horse_shop R* Script
+   * This native allows to control the cruise speed of where you want the ped to go
+   * 3rd param might be the entity ped is in? like boat or wagon, 12th param might be the cruiseSpeed of the entity ped is in?
+   * EXAMPLE: TaskGoToCoordAnyMeansExtraParamsWithCruiseSpeed(PlayerPedId(), vector3(x, y, z), 3.0, entity, 1, 0, -1082130432, 0, 101004800, 520, 3.0, 1082130432, 0)
    *
-   * @param vehicle 
-   * @param pos 
-   * @param p5 
-   * @param p6 
-   * @param flag 
-   */
-  vehicleDriveStraightToPoint(vehicle: Vehicle, pos: Vector3, p5: number, p6: number, flag: number): void {
-    inv<void>('0x089FF2FB965F0A29', this.entity.handle, vehicle.handle, f(pos.x), f(pos.y), f(pos.z), f(p5), f(p6), flag);
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
+   * @param cruiseSpeed 
+   * @param entity 
    * @param p4 
    * @param p5 
    * @param p6 
@@ -487,399 +359,205 @@ export class PedTask extends BaseTask {
    * @param p9 
    * @param p10 
    * @param p11 
-   * @param p12 
+   * @param cruiseSpeed2 
    * @param p13 
    * @param p14 
-   * @param p15 
-   */
-  goToCoordWhileAimingAtCoordUsingCombatStyle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, p12: any, p13: any, p14: any, p15: any): void {
-    inv<void>('0x639C0425A0B4E77E', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
-  }
-
-  /**
-   * flags: 0 = HANDS_UP_NOTHING; 1 = HANDS_UP_STRAIGHT_TO_LOOP
-   *
-   * @param duration 
-   * @param facingPed 
-   * @param timeToFacePed 
-   * @param flags 
-   */
-  handsUp(duration: number, facingPed: Ped, timeToFacePed: number, flags: number): void {
-    inv<void>('0xF2EAB31979A7F910', this.entity.handle, duration, facingPed.handle, timeToFacePed, flags);
-  }
-
-  /**
-   * timer: in ms, if it reaches 0 it will auto warp the ped on the horse
-   * Flags will still apply to mountStyle
-   *
-   * @param mount 
-   * @param timer 
-   * @param seatIndex Refer to [enum: eVehicleSeat]
-   * @param pedSpeed 
-   * @param mountStyle 
-   * @param p6 
-   * @param p7 
+   * @returns gotoCoords
    */
-  mountAnimal(mount: Ped, timer: number, seatIndex: eVehicleSeat, pedSpeed: number, mountStyle: number, p6: any, p7: any): void {
-    inv<void>('0x92DB0739813C5186', this.entity.handle, mount.handle, timer, seatIndex, f(pedSpeed), mountStyle, p6, p7);
+  goToCoordAnyMeansExtraParamsWithCruiseSpeed(cruiseSpeed: number, entity: Entity, p4: number, p5: number, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, cruiseSpeed2: number, p13: any, p14: any): Vector3 {
+    const result = inv<number[]>('0xB8ECD61F531A7B02', this.entity.handle, pvv(), f(cruiseSpeed), entity.handle, p4, p5, p6, p7, p8, p9, p10, p11, f(cruiseSpeed2), p13, p14);
+    return Vector3.fromArray(result);
   }
 
   /**
    * @returns
    */
-  getPedIsIgnoringDeadBodies(): any {
-    return inv<number>('0x1948BBE561A2375A', this.entity.handle);
+  isTaskMoveNetworkReadyForTransition(): boolean {
+    return inv<boolean>('0x30ED88D5E0C56A37', this.entity.handle, rai());
   }
 
-  /**
-   * @param toggle 
-   */
-  setPedPathCanUseLadders(toggle: boolean): void {
-    inv<void>('0x77A5B103C87F476E', this.entity.handle, toggle);
+  clearDefensiveArea(): void {
+    inv<void>('0x95A6C46A31D1917D', this.entity.handle);
   }
 
   /**
-   * @param p1 
-   * @param p2 
+   * @param modifier 
    */
-  stopAnimPlayback(p1: number, p2: boolean): void {
-    inv<void>('0xEE08C992D238C5D1', this.entity.handle, p1, p2);
+  setPedPathDeepSnowCostModifier(modifier: number): void {
+    inv<void>('0xE8C296B75EACC357', this.entity.handle, f(modifier));
   }
 
   /**
-   * @param targetPed 
-   * @param p2 
    * @returns
    */
-  confront(targetPed: Ped, p2: number): any {
-    return inv<number>('0x3A2A2071DF5CC569', this.entity.handle, targetPed.handle, p2);
-  }
-
-  N_0x1F298C7BD30D1240(): void {
-    inv<void>('0x1F298C7BD30D1240', this.entity.handle);
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   */
-  setCrouchMovement(p1: boolean, p2: any, p3: boolean): void {
-    inv<void>('0x17293C633C8AC019', this.entity.handle, p1, p2, p3);
+  getItemInteractionItemId(): number {
+    return (inv<number>('0x804425C4BBD00883', this.entity.handle, rai())) & 0xFFFFFFFF;
   }
 
   /**
-   * Tells the ped to go to an offset coord from an entity, without using the navmesh. if timeBeforeTeleport is -1 the ped will never warp, p7 is 1 or 0 still unknown param
-   *
    * @param entity 
-   * @param offset 
-   * @param moveBlendRatio 
-   * @param timeBeforeTeleport 
-   * @param p7 
+   * @param mount 
+   * @param p3 
    */
-  goStraightToCoordRelativeToEntity(entity: Entity, offset: Vector3, moveBlendRatio: number, timeBeforeTeleport: number, p7: number): void {
-    inv<void>('0x61E360B7E040D12E', this.entity.handle, entity.handle, f(offset.x), f(offset.y), f(offset.z), moveBlendRatio, timeBeforeTeleport, p7);
+  placeCarriedEntityOnMount(entity: Entity, mount: Ped, p3: number): void {
+    inv<void>('0x6D3D87C57B3D52C7', this.entity.handle, entity.handle, mount.handle, f(p3));
   }
 
-  /**
-   * Sets the time it takes for a hogtied ped to escape
-   * -1.0f for ped to never escape
-   *
-   * @param time 
-   */
-  setHogtieEscapeTimer(time: number): void {
-    inv<void>('0xAB591AE6B48B913E', this.entity.handle, f(time));
+  detachCarriablePed(): void {
+    inv<void>('0x36D188AECB26094B', this.entity.handle);
   }
 
   /**
-   * Makes the ped run to take cover
+   * @returns
    */
-  stayInCover(): void {
-    inv<void>('0xE5DA8615A6180789', this.entity.handle);
+  getItemInteractionState(): number {
+    return (inv<number>('0x6AA3DCA2C6F5EB6D', this.entity.handle, rai())) & 0xFFFFFFFF;
   }
 
   /**
-   * @param p1 
+   * @returns
    */
-  followWaypointRecordingAdvanced(p1: any): void {
-    inv<void>('0x0CFC13EBC19BCA52', this.entity.handle, p1);
+  getIsPedAimingInTheAir(): any {
+    return inv<number>('0x8785E6E40C7A8819', this.entity.handle);
   }
 
   /**
-   * Tells the ped to go to a coord, without using the navemesh. if timeBeforeTeleport is -1 the ped will never warp, p8 is always 0 or 1 still unknown
+   * param3: duration in ms, use -1 to look forever
+   * param4: using 2048 is fine
+   * param5: using 3 is fine
    *
-   * @param pos 
-   * @param moveBlendRatio 
-   * @param timeBeforeTeleport 
-   * @param finalHeading 
-   * @param targetRadius 
-   * @param p8 
-   */
-  goStraightToCoord(pos: Vector3, moveBlendRatio: number, timeBeforeTeleport: number, finalHeading: number, targetRadius: number, p8: number): void {
-    inv<void>('0xD76B57B44F1E6F8B', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(moveBlendRatio), timeBeforeTeleport, f(finalHeading), f(targetRadius), p8);
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   * @param p4 
-   */
-  setSphereDefensiveArea(p1: number, p2: number, p3: number, p4: number): void {
-    inv<void>('0x933C06518B52A9A4', this.entity.handle, f(p1), f(p2), f(p3), f(p4));
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
+   * @param lookAtTarget 
+   * @param duration 
    * @param p3 
    * @param p4 
+   * @param p5 
    */
-  useRandomScenarioInGroup(p1: any, p2: any, p3: any, p4: any): void {
-    inv<void>('0x14747F4A5971DE4E', this.entity.handle, p1, p2, p3, p4);
-  }
-
-  /**
-   * enum eWhistleType
-   * {
-   * WHISTLE_MAIN,
-   * WHISTLE_SECONDARY,
-   * WHISTLE_DOUBLE,
-   * WHISTLE_URGENT,
-   * WHISTLE_LONG
-   * };
-   *
-   * @param p1 
-   * @param whistleType 
-   */
-  goToWhistle(p1: Ped, whistleType: number): void {
-    inv<void>('0xBAD6545608CECA6E', this.entity.handle, p1.handle, whistleType);
-  }
-
-  /**
-   * @param pos 
-   * @param duration 
-   * @param flags 
-   * @param p6 
-   * @param p7 
-   */
-  lookAtCoord(pos: Vector3, duration: number, flags: number, p6: number, p7: boolean): void {
-    inv<void>('0x6FA46612594F7973', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), duration, flags, p6, p7);
+  lookAtEntity(lookAtTarget: Entity, duration: number, p3: number, p4: number, p5: number): void {
+    inv<void>('0x69F4BE8C8CC4796C', this.entity.handle, lookAtTarget.handle, duration, p3, p4, p5);
   }
 
   /**
+   * @param taskIndex 
    * @returns
    */
-  isPedInHitReact(): any {
-    return inv<number>('0xF330A5C062B29BED', this.entity.handle);
+  getIsTaskActive(taskIndex: number): boolean {
+    return inv<boolean>('0xB0760331C7AA4155', this.entity.handle, taskIndex, rai());
   }
 
   /**
-   * @param p1 
-   * @param p2 
+   * grappleStyle: AR_GRAPPLE_STRUGGLE, AR_ALLIGATOR_LEG_GRAB_CHALLENGE_FAIL, AR_GRAPPLE_BACK_FROM_BACK, AR_GRAPPLE_BACK_DEFEND, AR_GRAPPLE_FRONT_FROM_FRONT
+   *
+   * @param grappleTarget 
+   * @param grappleStyle 
    * @param p3 
    * @param p4 
    * @param p5 
    * @param p6 
-   * @param p7 
-   * @param p8 
-   */
-  N_0x3FFCD7BBA074CC80(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
-    inv<void>('0x3FFCD7BBA074CC80', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
-  }
-
-  /**
-   * @returns
-   */
-  isMountedWeaponTaskUnderneathDrivingTask(): boolean {
-    return inv<boolean>('0xA320EF046186FA3B', this.entity.handle, rai());
-  }
-
-  /**
-   * flags: See TASK_ENTER_VEHICLE
-   *
-   * @param p1 
-   * @param flags Refer to [enum: eEnterExitVehicleFlags]
    */
-  disembarkNearestTrainCarriage(p1: number, flags: number): void {
-    inv<void>('0x0A11F3BDEC03ED5F', this.entity.handle, f(p1), flags);
+  putPedDirectlyIntoGrapple(grappleTarget: Ped, grappleStyle: string | number, p3: number, p4: number, p5: boolean, p6: number): void {
+    inv<void>('0xA05F3F20889D7A5B', this.entity.handle, grappleTarget.handle, _h(grappleStyle), f(p3), f(p4), p5, p6);
   }
 
   /**
    * @param p1 
+   * @param p2 
    */
-  N_0xFFB520A3E16F7B7B(p1: number): void {
-    inv<void>('0xFFB520A3E16F7B7B', this.entity.handle, f(p1));
-  }
-
-  persistentCharacter(): void {
-    inv<void>('0x4391700CBD89C3D8', this.entity.handle);
+  combatAnimalWarn(p1: any, p2: any): void {
+    inv<void>('0xF960F3D57B660E96', this.entity.handle, p1, p2);
   }
 
   /**
-   * @param speed 
-   * @param p2 
-   * @param p3 
-   * @param p4 
+   * @param toggle 
    */
-  waypointPlaybackOverrideSpeed(speed: number, p2: any, p3: any, p4: any): void {
-    inv<void>('0x7D7D2B47FA788E85', this.entity.handle, f(speed), p2, p3, p4);
+  setPedIgnoreDeadBodies(toggle: boolean): void {
+    inv<void>('0x013A7BA5015C1372', this.entity.handle, toggle);
   }
 
   /**
    * @param p1 
    * @param p2 
    * @param p3 
-   */
-  climbLadder(p1: number, p2: boolean, p3: boolean): void {
-    inv<void>('0xB6C987F9285A3814', this.entity.handle, f(p1), p2, p3);
-  }
-
-  /**
-   * Makes a ped run away from another ped (fleeFromTarget) fleeDistance = ped will flee this distance
-   * fleeTime = ped will flee for this amount of time, set to "-1" to flee forever
-   * fleeType = can be 0, R* Scripts: fm_mission/race_controller: 66048; fme_escaped_convicts: 2260992, 2523136, 2359296; la_alligator/fox: 2097152; net_fetch: 17301536; net_stable_mount: 540928
-   * fleeSpeed = mostly 3f, rarely 1f in R* Scripts
-   *
-   * @param fleeFromTarget 
-   * @param fleeDistance 
-   * @param fleeTime 
-   * @param fleeType Refer to [enum: eFleeStyle]
-   * @param fleeSpeed 
-   * @param targetPed 
-   */
-  smartFleePed(fleeFromTarget: Ped, fleeDistance: number, fleeTime: number, fleeType: number, fleeSpeed: number, targetPed: Ped): void {
-    inv<void>('0x22B0D0E37CCB840D', this.entity.handle, fleeFromTarget.handle, f(fleeDistance), fleeTime, fleeType, f(fleeSpeed), targetPed.handle);
-  }
-
-  /**
-   * @param pos 
-   * @param time 
+   * @param p4 
    * @param p5 
    * @param p6 
+   * @param p7 
    */
-  aimGunAtCoord(pos: Vector3, time: number, p5: boolean, p6: boolean): void {
-    inv<void>('0x6671F3EEC681BDA1', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), time, p5, p6);
-  }
-
-  /**
-   * @param targetPed 
-   */
-  cutFreeHogtiedTargetPed(targetPed: Ped): void {
-    inv<void>('0x81D16C4FF3A77ADF', this.entity.handle, targetPed.handle);
-  }
-
-  /**
-   * @param signalName 
-   * @param value 
-   */
-  setTaskMoveNetworkSignalFloat2(signalName: string | null, value: number): void {
-    inv<void>('0x099D4A855D53B03B', this.entity.handle, signalName, f(value));
+  moveInTrafficToDestination(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any): void {
+    inv<void>('0xDCA3A13F7A45338B', this.entity.handle, p1, p2, p3, p4, p5, p6, p7);
   }
 
   /**
-   * @param p1 
+   * @param attacker 
    * @param p2 
+   * @returns Returns `true` on success, or `false` if `attacker` doesn't exist, or is dead.
    */
-  ambientAnimalHunt(p1: any, p2: any): void {
-    inv<void>('0x4B39D8F9D0FE7749', this.entity.handle, p1, p2);
-  }
-
-  /**
-   * @param p1 
-   * @param taskFlag Refer to [enum: eEnterExitVehicleFlags]
-   */
-  leaveAnyVehicle(p1: number, taskFlag: number): void {
-    inv<void>('0x504D54DF3F6F2247', this.entity.handle, p1, taskFlag);
+  intimidated(attacker: Ped, p2: boolean): boolean {
+    return inv<boolean>('0x648B75D44930D6BD', this.entity.handle, attacker.handle, p2, rai());
   }
 
   /**
-   * @param targetPed 
-   * @param p2 
-   * @param p3 
+   * @returns
    */
-  combatPed(targetPed: Ped, p2: number, p3: number): void {
-    inv<void>('0xF166E48407BAC484', this.entity.handle, targetPed.handle, p2, p3);
+  waypointPlaybackGetIsShooting(): any {
+    return inv<number>('0xA5B94DF8AF058F46', this.entity.handle);
   }
 
   /**
-   * Params: p4 = -1.0f, p5 = -1, p6 = 0 in R* Scripts
-   *
-   * @param fleeFromTarget 
-   * @param fleeStyle Refer to [enum: eFleeStyle]
-   * @param flag 
-   * @param p4 
+   * @param pos 
+   * @param distance 
    * @param p5 
    * @param p6 
+   * @param p7 
+   * @param p8 
    */
-  fleePed(fleeFromTarget: Ped, fleeStyle: number, flag: number, p4: number, p5: number, p6: number): void {
-    inv<void>('0xFD45175A6DFD7CE9', this.entity.handle, fleeFromTarget.handle, fleeStyle, flag, f(p4), p5, p6);
+  useNearestScenarioChainToCoordWarp(pos: Vector3, distance: number, p5: boolean, p6: boolean, p7: boolean, p8: boolean): void {
+    inv<void>('0x97A28E63F0BA5631', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p5, p6, p7, p8);
   }
 
   /**
+   * returned values:
+   * 0 to 7 = task that's currently in progress, 0 meaning the first one.
+   * -1 no task sequence in progress.
+   *
    * @returns
    */
-  isPedLeadingHorse(): any {
-    return inv<number>('0xEFC4303DDC6E60D3', this.entity.handle);
-  }
-
-  /**
-   * @param entity 
-   * @param offset 
-   * @param movementSpeed 
-   * @param timeout 
-   * @param stoppingRange 
-   * @param persistFollowing 
-   * @param p9 
-   * @param walkOnly 
-   * @param p11 
-   * @param p12 
-   * @param p13 
-   */
-  followToOffsetOfEntity(entity: Entity, offset: Vector3, movementSpeed: number, timeout: number, stoppingRange: number, persistFollowing: boolean, p9: boolean, walkOnly: boolean, p11: boolean, p12: boolean, p13: boolean): void {
-    inv<void>('0x304AE42E357B8C7E', this.entity.handle, entity.handle, f(offset.x), f(offset.y), f(offset.z), f(movementSpeed), timeout, f(stoppingRange), persistFollowing, p9, walkOnly, p11, p12, p13);
+  getSequenceProgress(): number {
+    return inv<number>('0x00A9010CFE1E3533', this.entity.handle, rai());
   }
 
   /**
-   * duration: the amount of time in milliseconds to do the task. -1 will keep the task going until either another task is applied, or CLEAR_ALL_TASKS() is called with the ped
-   *
-   * @param targetEntity 
-   * @param duration 
-   * @param p3 
-   * @param p4 
+   * @returns
    */
-  aimGunAtEntity(targetEntity: Entity, duration: number, p3: boolean, p4: number): void {
-    inv<void>('0x9B53BB6E8943AF53', this.entity.handle, targetEntity.handle, duration, p3, p4);
+  waypointPlaybackGetIsAiming(): any {
+    return inv<number>('0xD73A5D1F0325C71C', this.entity.handle);
   }
 
   /**
-   * `_GET_ANIM_SCENE_FROM_PED_*` But in a strange way, it also seems to work with the butcher's meat-cutting animscene. This does not return AnimScenes in general — it seems restricted to
-   * SEARCH-related scenes (needs more research).
-   *
-   * @returns Returns the AnimScene handle currently associated with the given Ped, but only when the anim event "SEARCHSTART" has fired on that Ped.
+   * @param toggle 
    */
-  N_0x2C497BDEF897C6DF(): AnimScene | null {
-    return createFromHandle<AnimScene>('AnimScene', inv<number>('0x2C497BDEF897C6DF', this.entity.handle, rai()));
+  setPedPathCanUseLadders(toggle: boolean): void {
+    inv<void>('0x77A5B103C87F476E', this.entity.handle, toggle);
   }
 
   /**
    * @param p1 
-   * @returns
+   * @param p2 
    */
-  police(p1: boolean): any {
-    return inv<number>('0x87BE56724650408E', this.entity.handle, p1);
+  stopAnimPlayback(p1: number, p2: boolean): void {
+    inv<void>('0xEE08C992D238C5D1', this.entity.handle, p1, p2);
   }
 
   /**
-   * @param scenarioPoint 
-   * @param flag 
+   * @param targetPed 
+   * @param p2 
+   * @returns
    */
-  hitchAnimal(scenarioPoint: number, flag: number): void {
-    inv<void>('0x9030AD4B6207BFE8', this.entity.handle, scenarioPoint, flag);
+  confront(targetPed: Ped, p2: number): any {
+    return inv<number>('0x3A2A2071DF5CC569', this.entity.handle, targetPed.handle, p2);
   }
 
-  uncuffPed(): void {
-    inv<void>('0x67406F2C8F87FC4F', this.entity.handle);
+  N_0x1F298C7BD30D1240(): void {
+    inv<void>('0x1F298C7BD30D1240', this.entity.handle);
   }
 
   /**
@@ -887,101 +565,95 @@ export class PedTask extends BaseTask {
    * @param p2 
    * @param p3 
    */
-  waypointPlaybackPause(p1: any, p2: any, p3: any): void {
-    inv<void>('0x0F342546AA06FED5', this.entity.handle, p1, p2, p3);
+  setCrouchMovement(p1: boolean, p2: any, p3: boolean): void {
+    inv<void>('0x17293C633C8AC019', this.entity.handle, p1, p2, p3);
   }
 
   /**
-   * meleeStyles: AR_GRAPPLE_BACK_FROM_BACK, AR_GRAPPLE_MOUNT_FACEDOWN_FROM_FRONT, AR_ALLIGATOR_LEAPKILL, AR_ALLIGATOR_WAIST_AUTOKILL_FRONT
+   * Tells the ped to go to an offset coord from an entity, without using the navmesh. if timeBeforeTeleport is -1 the ped will never warp, p7 is 1 or 0 still unknown param
    *
-   * @param meleeTarget 
-   * @param meleeStyle 
-   * @param p3 
-   * @param animBlendRatio 
-   * @param p5 
-   * @param p6 
+   * @param entity 
+   * @param offset 
+   * @param moveBlendRatio 
+   * @param timeBeforeTeleport 
+   * @param p7 
    */
-  putPedDirectlyIntoMelee(meleeTarget: Ped, meleeStyle: string | number, p3: number, animBlendRatio: number, p5: boolean, p6: number): void {
-    inv<void>('0x1C6CD14A876FFE39', this.entity.handle, meleeTarget.handle, _h(meleeStyle), f(p3), f(animBlendRatio), p5, p6);
+  goStraightToCoordRelativeToEntity(entity: Entity, offset: Vector3, moveBlendRatio: number, timeBeforeTeleport: number, p7: number): void {
+    inv<void>('0x61E360B7E040D12E', this.entity.handle, entity.handle, f(offset.x), f(offset.y), f(offset.z), moveBlendRatio, timeBeforeTeleport, p7);
   }
 
   /**
-   * @param waypointRecording 
-   * @param p2 
-   * @param flag 
-   * @param p4 
-   * @param p5 
-   * @param p6 
-   * @param p7 
+   * Sets the time it takes for a hogtied ped to escape
+   * -1.0f for ped to never escape
+   *
+   * @param time 
    */
-  followWaypointRecording(waypointRecording: string | null, p2: number, flag: number, p4: number, p5: boolean, p6: any, p7: number): void {
-    inv<void>('0x0759591819534F7B', this.entity.handle, waypointRecording, p2, flag, p4, p5, p6, p7);
+  setHogtieEscapeTimer(time: number): void {
+    inv<void>('0xAB591AE6B48B913E', this.entity.handle, f(time));
   }
 
   /**
-   * @param targetPed 
+   * Makes the ped run to take cover
    */
-  hogtieTargetPed(targetPed: Ped): void {
-    inv<void>('0x27829AFD3E03AC1A', this.entity.handle, targetPed.handle);
+  stayInCover(): void {
+    inv<void>('0xE5DA8615A6180789', this.entity.handle);
   }
 
   /**
-   * shootatEntity:
-   * If true, peds will shoot at Entity till it is dead.
-   * If false, peds will just walk till they reach the entity and will cease shooting.
-   *
    * @param p1 
-   * @param p2 
-   * @param p3 
-   * @param p4 
-   * @param p5 
-   * @param p6 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   * @param p10 
    */
-  goToEntityWhileAimingAtEntity(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any): void {
-    inv<void>('0x97465886D35210E9', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
+  followWaypointRecordingAdvanced(p1: any): void {
+    inv<void>('0x0CFC13EBC19BCA52', this.entity.handle, p1);
   }
 
   /**
+   * Tells the ped to go to a coord, without using the navemesh. if timeBeforeTeleport is -1 the ped will never warp, p8 is always 0 or 1 still unknown
+   *
    * @param pos 
-   * @param distance 
+   * @param moveBlendRatio 
+   * @param timeBeforeTeleport 
+   * @param finalHeading 
+   * @param targetRadius 
+   * @param p8 
    */
-  useNearestTrainScenarioToCoordWarp(pos: Vector3, distance: number): void {
-    inv<void>('0x3774B03456DD6106', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance));
+  goStraightToCoord(pos: Vector3, moveBlendRatio: number, timeBeforeTeleport: number, finalHeading: number, targetRadius: number, p8: number): void {
+    inv<void>('0xD76B57B44F1E6F8B', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(moveBlendRatio), timeBeforeTeleport, f(finalHeading), f(targetRadius), p8);
   }
 
   /**
-   * @param p1 
+   * @returns
    */
-  wanderSwim(p1: any): void {
-    inv<void>('0x527EA3DB8BC7F03B', this.entity.handle, p1);
+  getPedWaypointOverrideSpeed(): number {
+    return inv<number>('0xD39A2F3E7FCAFF08', this.entity.handle, raf());
   }
 
   /**
-   * duration in milliseconds
+   * Climbs or vaults the nearest thing.
    *
-   * @param pos 
-   * @param duration 
+   * @param unused 
    */
-  turnPedToFaceCoord(pos: Vector3, duration: number): void {
-    inv<void>('0x1DDA930A0AC38571', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), duration);
+  climb(unused: boolean): void {
+    inv<void>('0x89D9FCC2435112F1', this.entity.handle, unused);
   }
 
   /**
-   * @param preferAvoidMud 
-   * @param p2 
+   * Old name: _TASK_VEHICLE_DRIVE_TO_POINT
+   * flag: 524419 and 0 in shop_horse_shop R* Script
+   *
+   * @param vehicle 
+   * @param pos 
+   * @param p5 
+   * @param p6 
+   * @param flag 
    */
-  setPedPathPreferToAvoidMud(preferAvoidMud: boolean, p2: number): void {
-    inv<void>('0x8BB283A7888AD1AD', this.entity.handle, preferAvoidMud, f(p2));
+  vehicleDriveStraightToPoint(vehicle: Vehicle, pos: Vector3, p5: number, p6: number, flag: number): void {
+    inv<void>('0x089FF2FB965F0A29', this.entity.handle, vehicle.handle, f(pos.x), f(pos.y), f(pos.z), f(p5), f(p6), flag);
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param entity 
+   * @param p1 
+   * @param p2 
+   * @param p3 
    * @param p4 
    * @param p5 
    * @param p6 
@@ -993,172 +665,142 @@ export class PedTask extends BaseTask {
    * @param p12 
    * @param p13 
    * @param p14 
+   * @param p15 
    */
-  playUpperAnimFacingEntity(animDict: string | null, animName: string | null, entity: Entity, p4: number, p5: number, p6: number, p7: number, p8: number, p9: boolean, p10: boolean, p11: number, p12: string | null, p13: number, p14: number): void {
-    inv<void>('0xAD67214236AB1CFE', this.entity.handle, animDict, animName, entity.handle, p4, f(p5), f(p6), p7, f(p8), p9, p10, f(p11), p12, p13, f(p14));
-  }
-
-  /**
-   * @param goToLocationX 
-   * @param goToLocationY 
-   * @param goToLocationZ 
-   * @param focusLocationX 
-   * @param focusLocationY 
-   * @param focusLocationZ 
-   * @param speed 
-   * @param shootAtEnemies 
-   * @param distanceToStopAt 
-   * @param noRoadsDistance 
-   * @param unkTrue 
-   * @param unkFlag 
-   * @param aimingFlag 
-   * @param firingPattern 
-   */
-  goToCoordAndAimAtHatedEntitiesNearCoord(goToLocationX: number, goToLocationY: number, goToLocationZ: number, focusLocationX: number, focusLocationY: number, focusLocationZ: number, speed: number, shootAtEnemies: boolean, distanceToStopAt: number, noRoadsDistance: number, unkTrue: boolean, unkFlag: number, aimingFlag: number, firingPattern: string | number): void {
-    inv<void>('0xA55547801EB331FC', this.entity.handle, f(goToLocationX), f(goToLocationY), f(goToLocationZ), f(focusLocationX), f(focusLocationY), f(focusLocationZ), f(speed), shootAtEnemies, f(distanceToStopAt), f(noRoadsDistance), unkTrue, unkFlag, aimingFlag, _h(firingPattern));
-  }
-
-  /**
-   * @param itemHash 
-   * @param interactionAnimHash 
-   * @param p3 
-   * @returns
-   */
-  canStartItemInteraction(itemHash: string | number, interactionAnimHash: string | number, p3: number): any {
-    return inv<number>('0x2D19BC4DF626CBE7', this.entity.handle, _h(itemHash), _h(interactionAnimHash), p3);
+  goToCoordWhileAimingAtCoordUsingCombatStyle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, p12: any, p13: any, p14: any, p15: any): void {
+    inv<void>('0x639C0425A0B4E77E', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
   }
 
   /**
-   * @param targetPed 
-   * @param p2 
-   * @param p3 
-   * @param p4 
-   * @param p5 
-   * @param p6 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   * @param p10 
+   * flags: 0 = HANDS_UP_NOTHING; 1 = HANDS_UP_STRAIGHT_TO_LOOP
+   *
+   * @param duration 
+   * @param facingPed 
+   * @param timeToFacePed 
+   * @param flags 
    */
-  followAndConverseWithPed(targetPed: Ped, p2: any, p3: any, p4: number, p5: number, p6: number, p7: any, p8: any, p9: number, p10: number): void {
-    inv<void>('0x489FFCCCE7392B55', this.entity.handle, targetPed.handle, p2, p3, f(p4), f(p5), p6, p7, p8, f(p9), f(p10));
+  handsUp(duration: number, facingPed: Ped, timeToFacePed: number, flags: number): void {
+    inv<void>('0xF2EAB31979A7F910', this.entity.handle, duration, facingPed.handle, timeToFacePed, flags);
   }
 
   /**
-   * @param pos 
-   * @param distance 
-   * @param p5 
+   * timer: in ms, if it reaches 0 it will auto warp the ped on the horse
+   * Flags will still apply to mountStyle
+   *
+   * @param mount 
+   * @param timer 
+   * @param seatIndex Refer to [enum: eVehicleSeat]
+   * @param pedSpeed 
+   * @param mountStyle 
    * @param p6 
    * @param p7 
-   * @param p8 
    */
-  useNearestScenarioChainToCoord(pos: Vector3, distance: number, p5: boolean, p6: boolean, p7: boolean, p8: boolean): void {
-    inv<void>('0x9FDA1B3D7E7028B3', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p5, p6, p7, p8);
+  mountAnimal(mount: Ped, timer: number, seatIndex: eVehicleSeat, pedSpeed: number, mountStyle: number, p6: any, p7: any): void {
+    inv<void>('0x92DB0739813C5186', this.entity.handle, mount.handle, timer, seatIndex, f(pedSpeed), mountStyle, p6, p7);
   }
 
   /**
-   * @param eventName 
    * @returns
    */
-  getTaskMoveNetworkEvent(eventName: string | null): boolean {
-    return inv<boolean>('0xB4F47213DF45A64C', this.entity.handle, eventName, rai());
-  }
-
-  /**
-   * Baits: see 0x9B0C7FA063E67629
-   *
-   * @param bait 
-   * @param withoutBuoy 
-   */
-  swapFishingBait(bait: string | null, withoutBuoy: boolean): void {
-    inv<void>('0x2C28AC30A72722DA', this.entity.handle, bait, withoutBuoy);
+  getPedIsIgnoringDeadBodies(): any {
+    return inv<number>('0x1948BBE561A2375A', this.entity.handle);
   }
 
   /**
-   * @returns
+   * @param p1 
+   * @param taskFlag Refer to [enum: eEnterExitVehicleFlags]
    */
-  isDrivebyTaskUnderneathDrivingTask(): boolean {
-    return inv<boolean>('0x8785E6E40C7A8818', this.entity.handle, rai());
+  leaveAnyVehicle(p1: number, taskFlag: number): void {
+    inv<void>('0x504D54DF3F6F2247', this.entity.handle, p1, taskFlag);
   }
 
-  cuffPed(): void {
-    inv<void>('0x7981037A96E7D174', this.entity.handle);
+  /**
+   * @param targetPed 
+   * @param p2 
+   * @param p3 
+   */
+  combatPed(targetPed: Ped, p2: number, p3: number): void {
+    inv<void>('0xF166E48407BAC484', this.entity.handle, targetPed.handle, p2, p3);
   }
 
   /**
-   * This native allows to control the cruise speed of where you want the ped to go
-   * 3rd param might be the entity ped is in? like boat or wagon, 12th param might be the cruiseSpeed of the entity ped is in?
-   * EXAMPLE: TaskGoToCoordAnyMeansExtraParamsWithCruiseSpeed(PlayerPedId(), vector3(x, y, z), 3.0, entity, 1, 0, -1082130432, 0, 101004800, 520, 3.0, 1082130432, 0)
+   * Params: p4 = -1.0f, p5 = -1, p6 = 0 in R* Scripts
    *
-   * @param cruiseSpeed 
-   * @param entity 
+   * @param fleeFromTarget 
+   * @param fleeStyle Refer to [enum: eFleeStyle]
+   * @param flag 
    * @param p4 
    * @param p5 
    * @param p6 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   * @param p10 
-   * @param p11 
-   * @param cruiseSpeed2 
-   * @param p13 
-   * @param p14 
-   * @returns gotoCoords
    */
-  goToCoordAnyMeansExtraParamsWithCruiseSpeed(cruiseSpeed: number, entity: Entity, p4: number, p5: number, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, cruiseSpeed2: number, p13: any, p14: any): Vector3 {
-    const result = inv<number[]>('0xB8ECD61F531A7B02', this.entity.handle, pvv(), f(cruiseSpeed), entity.handle, p4, p5, p6, p7, p8, p9, p10, p11, f(cruiseSpeed2), p13, p14);
-    return Vector3.fromArray(result);
+  fleePed(fleeFromTarget: Ped, fleeStyle: number, flag: number, p4: number, p5: number, p6: number): void {
+    inv<void>('0xFD45175A6DFD7CE9', this.entity.handle, fleeFromTarget.handle, fleeStyle, flag, f(p4), p5, p6);
   }
 
   /**
-   * @param radius 
+   * @returns
    */
-  combatHatedTargetsNoLosTest(radius: number): void {
-    inv<void>('0xB5BC69D9C4060BC3', this.entity.handle, f(radius));
+  isPedLeadingHorse(): any {
+    return inv<number>('0xEFC4303DDC6E60D3', this.entity.handle);
   }
 
   /**
-   * @param p1 
+   * @param entity 
+   * @param offset 
+   * @param movementSpeed 
+   * @param timeout 
+   * @param stoppingRange 
+   * @param persistFollowing 
+   * @param p9 
+   * @param walkOnly 
+   * @param p11 
+   * @param p12 
+   * @param p13 
    */
-  N_0x31BB338F64D5C861(p1: boolean): void {
-    inv<void>('0x31BB338F64D5C861', this.entity.handle, p1);
+  followToOffsetOfEntity(entity: Entity, offset: Vector3, movementSpeed: number, timeout: number, stoppingRange: number, persistFollowing: boolean, p9: boolean, walkOnly: boolean, p11: boolean, p12: boolean, p13: boolean): void {
+    inv<void>('0x304AE42E357B8C7E', this.entity.handle, entity.handle, f(offset.x), f(offset.y), f(offset.z), f(movementSpeed), timeout, f(stoppingRange), persistFollowing, p9, walkOnly, p11, p12, p13);
   }
 
   /**
-   * @param modifier 
+   * duration: the amount of time in milliseconds to do the task. -1 will keep the task going until either another task is applied, or CLEAR_ALL_TASKS() is called with the ped
+   *
+   * @param targetEntity 
+   * @param duration 
+   * @param p3 
+   * @param p4 
    */
-  setPedPathClimbCostModifier(modifier: number): void {
-    inv<void>('0x88E32DB8C1A4AA4B', this.entity.handle, f(modifier));
+  aimGunAtEntity(targetEntity: Entity, duration: number, p3: boolean, p4: number): void {
+    inv<void>('0x9B53BB6E8943AF53', this.entity.handle, targetEntity.handle, duration, p3, p4);
   }
 
   /**
-   * @param entity 
-   * @param duration 
-   * @param targetRadius 
-   * @param offset 
-   * @param moveBlendRatio 
-   * @param offsetFlags 
+   * `_GET_ANIM_SCENE_FROM_PED_*` But in a strange way, it also seems to work with the butcher's meat-cutting animscene. This does not return AnimScenes in general — it seems restricted to
+   * SEARCH-related scenes (needs more research).
+   *
+   * @returns Returns the AnimScene handle currently associated with the given Ped, but only when the anim event "SEARCHSTART" has fired on that Ped.
    */
-  gotoEntityOffsetXy(entity: Entity, duration: number, targetRadius: number, offset: Vector2, moveBlendRatio: number, offsetFlags: number): void {
-    inv<void>('0x338E7EF52B6095A9', this.entity.handle, entity.handle, duration, f(targetRadius), f(offset.x), f(offset.y), f(moveBlendRatio), offsetFlags);
+  N_0x2C497BDEF897C6DF(): AnimScene | null {
+    return createFromHandle<AnimScene>('AnimScene', inv<number>('0x2C497BDEF897C6DF', this.entity.handle, rai()));
   }
 
   /**
-   * Makes ped walk around the area the params p1 p2 seems to not affect anything but p2 is either 0 or 1 and p1 is mostly 1.0 or ped heading
-   *
-   * @param p2 
-   * @param p3 
+   * @param p1 
+   * @returns
    */
-  wanderStandard(p2: number, p3: number): void {
-    inv<void>('0xBB9CE077274F6A1B', this.entity.handle, f(p2), p3);
+  police(p1: boolean): any {
+    return inv<number>('0x87BE56724650408E', this.entity.handle, p1);
   }
 
   /**
-   * @param p1 
-   * @param p2 
+   * @param scenarioPoint 
+   * @param flag 
    */
-  clearPedTasks(p1: boolean, p2: boolean): void {
-    inv<void>('0xE1EF3C1216AFF2CD', this.entity.handle, p1, p2);
+  hitchAnimal(scenarioPoint: number, flag: number): void {
+    inv<void>('0x9030AD4B6207BFE8', this.entity.handle, scenarioPoint, flag);
+  }
+
+  uncuffPed(): void {
+    inv<void>('0x67406F2C8F87FC4F', this.entity.handle);
   }
 
   /**
@@ -1226,155 +868,10 @@ export class PedTask extends BaseTask {
   }
 
   /**
-   * @param avoidTraffic 
-   */
-  setPedPathAvoidTraffic(avoidTraffic: boolean): void {
-    inv<void>('0x7C015D8BCEC72CF4', this.entity.handle, avoidTraffic);
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   */
-  guard(p1: any, p2: any): void {
-    inv<void>('0xB9FB242EACCAF30F', this.entity.handle, p1, p2);
-  }
-
-  /**
-   * @param attacker 
-   * @param p2 
-   * @param unusedParam3 Unused by the native.
-   * @param unusedParam4 Unused by the native.
-   * @param everyFrame Removes the `0x1000` bitmask from `flag`
-   * @param p6 
-   * @param p7 Removes the `0x80000` bitmask from `flag`
-   * @param flag 
-   * @returns Returns `true` on success, `false` if it failed (whether due to `attacker` being invalid, or the `attacker` ped being dead)
-   */
-  intimidated2(attacker: Ped, p2: number, unusedParam3: boolean, unusedParam4: boolean, everyFrame: boolean, p6: boolean, p7: boolean, flag: number): boolean {
-    return inv<boolean>('0x933ACC1A1771A288', this.entity.handle, attacker.handle, p2, unusedParam3, unusedParam4, everyFrame, p6, p7, flag, rai());
-  }
-
-  /**
-   * @param avoidFire 
-   */
-  setPedPathAvoidFire(avoidFire: boolean): void {
-    inv<void>('0x4455517B28441E60', this.entity.handle, avoidFire);
-  }
-
-  /**
-   * @param reviver 
-   * @param tool 
-   */
-  reviveTarget(reviver: Ped, tool: string | number): void {
-    inv<void>('0x356088527D9EBAAD', this.entity.handle, reviver.handle, _h(tool));
-  }
-
-  /**
-   * https://github.com/femga/rdr3_discoveries/blob/master/animations/kit_emotes_list.lua
-   * emote: https://alloc8or.re/rdr3/doc/enums/eEmote.txt enum eEmoteType
-   * {
-   * EMOTE_TYPE_INVALID = -1,
-   * EMOTE_TYPE_REACT,
-   * EMOTE_TYPE_ACTION,
-   * EMOTE_TYPE_TAUNT,
-   * EMOTE_TYPE_GREET,
-   * EMOTE_TYPE_TWIRL_GUN,
-   * EMOTE_TYPE_DANCE_FLOOR
-   * }; enum eEmotePlaybackMode
-   * {
-   * EMOTE_PM_INVALID = -1,
-   * EMOTE_PM_UPPERBODY,
-   * EMOTE_PM_UPPERBODY_LOOP,
-   * EMOTE_PM_FULLBODY,
-   * };
-   *
-   * @param emoteType 
-   * @param playbackMode 
-   * @param emote 
-   * @param isSecondaryTask 
-   * @param canBreakOut 
-   * @param disableEarlyOutAnimTag 
-   * @param ignoreInvalidMainTask 
-   * @param destroyProps 
-   */
-  playEmoteWithHash(emoteType: number, playbackMode: number, emote: string | number, isSecondaryTask: boolean, canBreakOut: boolean, disableEarlyOutAnimTag: boolean, ignoreInvalidMainTask: boolean, destroyProps: boolean): void {
-    inv<void>('0xB31A277C1AC7B7FF', this.entity.handle, emoteType, playbackMode, _h(emote), isSecondaryTask, canBreakOut, disableEarlyOutAnimTag, ignoreInvalidMainTask, destroyProps);
-  }
-
-  /**
-   * @returns
-   */
-  isTaskMoveNetworkReadyForTransition(): boolean {
-    return inv<boolean>('0x30ED88D5E0C56A37', this.entity.handle, rai());
-  }
-
-  clearDefensiveArea(): void {
-    inv<void>('0x95A6C46A31D1917D', this.entity.handle);
-  }
-
-  /**
-   * @param modifier 
-   */
-  setPedPathDeepSnowCostModifier(modifier: number): void {
-    inv<void>('0xE8C296B75EACC357', this.entity.handle, f(modifier));
-  }
-
-  /**
-   * @returns
-   */
-  getItemInteractionItemId(): string | number {
-    return (inv<number>('0x804425C4BBD00883', this.entity.handle, rai())) & 0xFFFFFFFF;
-  }
-
-  /**
-   * @param entity 
-   * @param mount 
-   * @param p3 
-   */
-  placeCarriedEntityOnMount(entity: Entity, mount: Ped, p3: number): void {
-    inv<void>('0x6D3D87C57B3D52C7', this.entity.handle, entity.handle, mount.handle, f(p3));
-  }
-
-  detachCarriablePed(): void {
-    inv<void>('0x36D188AECB26094B', this.entity.handle);
-  }
-
-  /**
-   * @returns
-   */
-  getItemInteractionState(): string | number {
-    return (inv<number>('0x6AA3DCA2C6F5EB6D', this.entity.handle, rai())) & 0xFFFFFFFF;
-  }
-
-  /**
-   * @returns
-   */
-  getIsPedAimingInTheAir(): any {
-    return inv<number>('0x8785E6E40C7A8819', this.entity.handle);
-  }
-
-  /**
-   * param3: duration in ms, use -1 to look forever
-   * param4: using 2048 is fine
-   * param5: using 3 is fine
-   *
-   * @param lookAtTarget 
-   * @param duration 
-   * @param p3 
-   * @param p4 
-   * @param p5 
-   */
-  lookAtEntity(lookAtTarget: Entity, duration: number, p3: number, p4: number, p5: number): void {
-    inv<void>('0x69F4BE8C8CC4796C', this.entity.handle, lookAtTarget.handle, duration, p3, p4, p5);
-  }
-
-  /**
-   * @param taskIndex 
-   * @returns
+   * @param avoidTraffic 
    */
-  getIsTaskActive(taskIndex: number): boolean {
-    return inv<boolean>('0xB0760331C7AA4155', this.entity.handle, taskIndex, rai());
+  setPedPathAvoidTraffic(avoidTraffic: boolean): void {
+    inv<void>('0x7C015D8BCEC72CF4', this.entity.handle, avoidTraffic);
   }
 
   /**
@@ -1383,7 +880,7 @@ export class PedTask extends BaseTask {
    *
    * @returns
    */
-  getTaskMoveNetworkId(): string | number {
+  getTaskMoveNetworkId(): number {
     return (inv<number>('0xCACC2F9D994504B7', this.entity.handle, rai())) & 0xFFFFFFFF;
   }
 
@@ -1518,18 +1015,70 @@ export class PedTask extends BaseTask {
 
   /**
    * @param pos 
+   * @param speedMultiplier 
    * @param timeout 
-   * @param p5 
-   * @param p6 
-   * @param p7 
+   * @param stoppingRange 
+   * @param flags 
    * @param p8 
-   * @param coverpoint 
+   * @param p9 
    * @param p10 
-   * @param p11 
-   * @param p12 
+   * @param entity 
+   * @param unk 
    */
-  putPedDirectlyIntoCover(pos: Vector3, timeout: number, p5: boolean, p6: number, p7: any, p8: any, coverpoint: number, p10: boolean, p11: boolean, p12: any): void {
-    inv<void>('0x4172393E6BE1FECE', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), timeout, p5, f(p6), p7, p8, coverpoint, p10, p11, p12);
+  followNavMeshToCoordAdvanced(pos: Vector3, speedMultiplier: number, timeout: number, stoppingRange: number, flags: number, p8: number, p9: number, p10: number, entity: Entity, unk: number): void {
+    inv<void>('0x17F58B88D085DBAC', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(speedMultiplier), timeout, f(stoppingRange), flags, f(p8), f(p9), f(p10), entity.handle, f(unk));
+  }
+
+  /**
+   * @param radius 
+   * @param time 
+   * @param flags 
+   */
+  combatHatedTargetsAroundPedTimed(radius: number, time: number, flags: number): void {
+    inv<void>('0x2BBA30B854534A0C', this.entity.handle, f(radius), time, flags);
+  }
+
+  /**
+   * @returns
+   */
+  isPedRunning(): boolean {
+    return inv<boolean>('0xC5286FFC176F28A2', this.entity.handle, rai());
+  }
+
+  /**
+   * @returns
+   */
+  isPedSprinting(): boolean {
+    return inv<boolean>('0x57E457CD2C0FC168', this.entity.handle, rai());
+  }
+
+  /**
+   * @param useSlidingSurfaces 
+   */
+  setPedPathMayUseSlidingSurfaces(useSlidingSurfaces: boolean): void {
+    inv<void>('0x06ECF3925BC2ABAE', this.entity.handle, useSlidingSurfaces);
+  }
+
+  /**
+   * Force a ped that is already attacking to aim directly at the specified world coordinates.
+   *
+   * @param pos 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   */
+  forcePointAimAtCoord(pos: Vector3, p4?: number, p5?: boolean, p6?: boolean): void {
+    inv<void>('0x41323F4E0C4AE94B', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), p4, p5, p6);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  swapWeapon(p1: any, p2: any, p3: any, p4: any): void {
+    inv<void>('0xA21C51255B205245', this.entity.handle, p1, p2, p3, p4);
   }
 
   /**
@@ -1541,260 +1090,475 @@ export class PedTask extends BaseTask {
    * @param p6 
    * @param p7 
    * @param p8 
+   */
+  gotoEntityOffsetXyz(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
+    inv<void>('0xFA6DA9D151769392', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
+  }
+
+  /**
+   * @param pos 
+   * @param distance 
+   * @param duration 
+   * @param p6 
+   * @param p7 
+   * @param p8 
    * @param p9 
-   * @param p10 
-   * @param p11 
-   * @param p12 
-   * @param p13 
-   * @param p14 
    */
-  goToCoordAndAimAtHatedEntitiesNearCoordUsingCombatStyle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, p12: any, p13: any, p14: any): void {
-    inv<void>('0x87BD711FC31EA273', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
+  useNearestScenarioToCoordWarp(pos: Vector3, distance: number, duration: number, p6: boolean, p7: boolean, p8: boolean, p9: boolean): void {
+    inv<void>('0x58E2E0F23F6B76C3', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), duration, p6, p7, p8, p9);
   }
 
   /**
-   * @param target 
+   * @param p1 
+   * @returns
    */
-  arrestPed(target: Ped): void {
-    inv<void>('0xF3B9A78A178572B1', this.entity.handle, target.handle);
+  N_0x2D657B10F211C572(p1: number): any {
+    return inv<number>('0x2D657B10F211C572', this.entity.handle, f(p1));
+  }
+
+  /**
+   * Coords: volume coords used in R* Script smuggler2
+   * p4/p5 = 0 in R* Scripts previous name TASK_COMBAT_PED_3
+   *
+   * @param pos 
+   * @param p4 
+   * @param p5 
+   */
+  combatPedAtCoords(pos: Vector3, p4: number, p5: number): void {
+    inv<void>('0xC624414FA748B9BA', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), p4, p5);
+  }
+
+  /**
+   * Makes the specified ped stand still for (time) milliseconds.
+   *
+   * @param time 
+   */
+  standStill(time: number): void {
+    inv<void>('0x919BE13EED931959', this.entity.handle, time);
+  }
+
+  /**
+   * @param animDictionary 
+   * @param animationName 
+   * @param p3 
+   */
+  stopAnimTask(animDictionary: string | null, animationName: string | null, p3: number): void {
+    inv<void>('0x97FF36A1D40EA00A', this.entity.handle, animDictionary, animationName, f(p3));
   }
 
   /**
    * @param p1 
    * @param p2 
    * @param p3 
+   */
+  turnToFaceClosestPed(p1: number, p2: number, p3: number): void {
+    inv<void>('0x84179419DBDD36F2', this.entity.handle, f(p1), f(p2), p3);
+  }
+
+  /**
+   * Fishing Research: https://pastebin.com/NmK5ZLVs
+   * Only used in R* Scripts fishing_core and av_fishing_river
+   *
+   * @returns p1
+   */
+  getTaskFishing(): [any, number] {
+    const result = inv<[number, number]>('0xF3735ACD11ACD500', this.entity.handle, pvi());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  shockingEventReact(p1: any, p2: any): void {
+    inv<void>('0x452419CBD838065B', this.entity.handle, p1, p2);
+  }
+
+  /**
    * @returns
    */
-  setPedWaypointRouteOffset(p1: number, p2: number, p3: number): any {
-    return inv<number>('0xED98E10B0AFCE4B4', this.entity.handle, f(p1), f(p2), f(p3));
+  N_0xB520DBDA7FCF573F(): boolean {
+    return inv<boolean>('0xB520DBDA7FCF573F', this.entity.handle, rai());
+  }
+
+  /**
+   * fleeType: see TASK_FLEE_COORD
+   *
+   * @param fleeFromTarget 
+   * @param pos 
+   * @param distance 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param targetPed 
+   */
+  fleeFromPed(fleeFromTarget: Ped, pos: Vector3, distance: number, p6: number, p7: number, p8: number, targetPed: Ped): void {
+    inv<void>('0x7B74D8EEDE9B5727', this.entity.handle, fleeFromTarget.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p6, p7, f(p8), targetPed.handle);
   }
 
   /**
-   * @param waypointRecording 
    * @returns
    */
-  isWaypointPlaybackGoingOnForPed(waypointRecording: string | null): boolean {
-    return inv<boolean>('0xE03B3F2D3DC59B64', this.entity.handle, waypointRecording, rai());
+  isPedGettingUp(): boolean {
+    return inv<boolean>('0x2A74E1D5F2F00EEC', this.entity.handle, rai());
+  }
+
+  /**
+   * @param time 
+   */
+  duck(time: number): void {
+    inv<void>('0xA14B5FBF986BAC23', this.entity.handle, time);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  robPed(p1: any, p2: any, p3: any, p4: any): void {
+    inv<void>('0x7BB967F85D8CCBDB', this.entity.handle, p1, p2, p3, p4);
+  }
+
+  /**
+   * getupSetHash: see nm_blend_out_sets.meta
+   *
+   * @param flags 
+   * @param getupSetHash 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   */
+  unhogtiePed(flags: number, getupSetHash: string | number, p3: string | null, p4: string | null, p5: number): void {
+    inv<void>('0x79559BAD83CCD038', this.entity.handle, flags, _h(getupSetHash), p3, p4, f(p5));
+  }
+
+  /**
+   * hecks if the ped camera is directed at the given coord within the specified radius. https://www.youtube.com/watch?v=iLHXrWVvq_c
+   *
+   * @param coord The coord to check if they're looking at
+   * @param radius The radius of the frustum
+   * @returns Returns `true` if the ped camera is within the range of the frustum, `false` otherwise
+   */
+  isPedLookingAtCoord(coord: Vector3, radius: number): boolean {
+    return inv<boolean>('0x508F5053E3F6F0C4', this.entity.handle, f(coord.x), f(coord.y), f(coord.z), f(radius), rai());
+  }
+
+  /**
+   * @param entity 
+   */
+  walkAway(entity: Entity): void {
+    inv<void>('0x04ACFAC71E6858F9', this.entity.handle, entity.handle);
+  }
+
+  /**
+   * @returns
+   */
+  getHogtieEscapeTimer(): number {
+    return inv<number>('0x4687E69D258BBE41', this.entity.handle, raf());
+  }
+
+  weapon(): void {
+    inv<void>('0x7157B82D60E4BC46', this.entity.handle);
+  }
+
+  /**
+   * @returns
+   */
+  isPedWalking(): boolean {
+    return inv<boolean>('0xDE4C184B2B9B071A', this.entity.handle, rai());
   }
 
   /**
    * @param p1 
    * @param p2 
+   * @param p3 
+   */
+  waypointPlaybackPause(p1: any, p2: any, p3: any): void {
+    inv<void>('0x0F342546AA06FED5', this.entity.handle, p1, p2, p3);
+  }
+
+  /**
+   * meleeStyles: AR_GRAPPLE_BACK_FROM_BACK, AR_GRAPPLE_MOUNT_FACEDOWN_FROM_FRONT, AR_ALLIGATOR_LEAPKILL, AR_ALLIGATOR_WAIST_AUTOKILL_FRONT
+   *
+   * @param meleeTarget 
+   * @param meleeStyle 
+   * @param p3 
+   * @param animBlendRatio 
+   * @param p5 
+   * @param p6 
    */
-  animalWrithe(p1: any, p2: any): void {
-    inv<void>('0x8C038A39C4A4B6D6', this.entity.handle, p1, p2);
+  putPedDirectlyIntoMelee(meleeTarget: Ped, meleeStyle: string | number, p3: number, animBlendRatio: number, p5: boolean, p6: number): void {
+    inv<void>('0x1C6CD14A876FFE39', this.entity.handle, meleeTarget.handle, _h(meleeStyle), f(p3), f(animBlendRatio), p5, p6);
   }
 
   /**
-   * @param p1 
+   * @param waypointRecording 
    * @param p2 
-   * @param p3 
+   * @param flag 
    * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
    */
-  aimAtEntity(p1: any, p2: any, p3: any, p4: any): void {
-    inv<void>('0xCF7569BD0FB480A0', this.entity.handle, p1, p2, p3, p4);
+  followWaypointRecording(waypointRecording: string | null, p2: number, flag: number, p4: number, p5: boolean, p6: any, p7: number): void {
+    inv<void>('0x0759591819534F7B', this.entity.handle, waypointRecording, p2, flag, p4, p5, p6, p7);
   }
 
   /**
    * @param targetPed 
-   * @param p2 
-   * @param p3 
    */
-  combatPedTimed(targetPed: Ped, p2: number, p3: any): void {
-    inv<void>('0x944F30DCB7096BDE', this.entity.handle, targetPed.handle, p2, p3);
+  hogtieTargetPed(targetPed: Ped): void {
+    inv<void>('0x27829AFD3E03AC1A', this.entity.handle, targetPed.handle);
   }
 
   /**
+   * shootatEntity:
+   * If true, peds will shoot at Entity till it is dead.
+   * If false, peds will just walk till they reach the entity and will cease shooting.
+   *
    * @param p1 
    * @param p2 
    * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
    */
-  throwProjectile(p1: any, p2: any, p3: any): void {
-    inv<void>('0x7285951DBF6B5A51', this.entity.handle, p1, p2, p3);
+  goToEntityWhileAimingAtEntity(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any): void {
+    inv<void>('0x97465886D35210E9', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
   }
 
   /**
    * @param pos 
-   * @param heading 
-   * @param p5 
+   * @param distance 
    */
-  pedSlideToCoord(pos: Vector3, heading: number, p5: number): void {
-    inv<void>('0xD04FE6765D990A06', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(heading), f(p5));
+  useNearestTrainScenarioToCoordWarp(pos: Vector3, distance: number): void {
+    inv<void>('0x3774B03456DD6106', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance));
   }
 
   /**
-   * grappleStyle: AR_GRAPPLE_STRUGGLE, AR_ALLIGATOR_LEG_GRAB_CHALLENGE_FAIL, AR_GRAPPLE_BACK_FROM_BACK, AR_GRAPPLE_BACK_DEFEND, AR_GRAPPLE_FRONT_FROM_FRONT
-   *
-   * @param grappleTarget 
-   * @param grappleStyle 
-   * @param p3 
-   * @param p4 
-   * @param p5 
-   * @param p6 
+   * @param p1 
    */
-  putPedDirectlyIntoGrapple(grappleTarget: Ped, grappleStyle: string | number, p3: number, p4: number, p5: boolean, p6: number): void {
-    inv<void>('0xA05F3F20889D7A5B', this.entity.handle, grappleTarget.handle, _h(grappleStyle), f(p3), f(p4), p5, p6);
+  wanderSwim(p1: any): void {
+    inv<void>('0x527EA3DB8BC7F03B', this.entity.handle, p1);
   }
 
   /**
-   * @param p1 
-   * @param p2 
+   * duration in milliseconds
+   *
+   * @param pos 
+   * @param duration 
    */
-  combatAnimalWarn(p1: any, p2: any): void {
-    inv<void>('0xF960F3D57B660E96', this.entity.handle, p1, p2);
+  turnPedToFaceCoord(pos: Vector3, duration: number): void {
+    inv<void>('0x1DDA930A0AC38571', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), duration);
   }
 
   /**
-   * @param toggle 
+   * @param preferAvoidMud 
+   * @param p2 
    */
-  setPedIgnoreDeadBodies(toggle: boolean): void {
-    inv<void>('0x013A7BA5015C1372', this.entity.handle, toggle);
+  setPedPathPreferToAvoidMud(preferAvoidMud: boolean, p2: number): void {
+    inv<void>('0x8BB283A7888AD1AD', this.entity.handle, preferAvoidMud, f(p2));
   }
 
   /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
+   * @param animDict 
+   * @param animName 
+   * @param entity 
    * @param p4 
    * @param p5 
    * @param p6 
    * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   * @param p13 
+   * @param p14 
    */
-  moveInTrafficToDestination(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any): void {
-    inv<void>('0xDCA3A13F7A45338B', this.entity.handle, p1, p2, p3, p4, p5, p6, p7);
+  playUpperAnimFacingEntity(animDict: string | null, animName: string | null, entity: Entity, p4: number, p5: number, p6: number, p7: number, p8: number, p9: boolean, p10: boolean, p11: number, p12: string | null, p13: number, p14: number): void {
+    inv<void>('0xAD67214236AB1CFE', this.entity.handle, animDict, animName, entity.handle, p4, f(p5), f(p6), p7, f(p8), p9, p10, f(p11), p12, p13, f(p14));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  guard(p1: any, p2: any): void {
+    inv<void>('0xB9FB242EACCAF30F', this.entity.handle, p1, p2);
   }
 
   /**
    * @param attacker 
    * @param p2 
-   * @returns Returns `true` on success, or `false` if `attacker` doesn't exist, or is dead.
+   * @param unusedParam3 Unused by the native.
+   * @param unusedParam4 Unused by the native.
+   * @param everyFrame Removes the `0x1000` bitmask from `flag`
+   * @param p6 
+   * @param p7 Removes the `0x80000` bitmask from `flag`
+   * @param flag 
+   * @returns Returns `true` on success, `false` if it failed (whether due to `attacker` being invalid, or the `attacker` ped being dead)
    */
-  intimidated(attacker: Ped, p2: boolean): boolean {
-    return inv<boolean>('0x648B75D44930D6BD', this.entity.handle, attacker.handle, p2, rai());
+  intimidated2(attacker: Ped, p2: number, unusedParam3: boolean, unusedParam4: boolean, everyFrame: boolean, p6: boolean, p7: boolean, flag: number): boolean {
+    return inv<boolean>('0x933ACC1A1771A288', this.entity.handle, attacker.handle, p2, unusedParam3, unusedParam4, everyFrame, p6, p7, flag, rai());
   }
 
   /**
-   * @returns
+   * @param avoidFire 
    */
-  waypointPlaybackGetIsShooting(): any {
-    return inv<number>('0xA5B94DF8AF058F46', this.entity.handle);
+  setPedPathAvoidFire(avoidFire: boolean): void {
+    inv<void>('0x4455517B28441E60', this.entity.handle, avoidFire);
   }
 
   /**
-   * @param pos 
-   * @param distance 
-   * @param p5 
-   * @param p6 
-   * @param p7 
-   * @param p8 
+   * @param reviver 
+   * @param tool 
    */
-  useNearestScenarioChainToCoordWarp(pos: Vector3, distance: number, p5: boolean, p6: boolean, p7: boolean, p8: boolean): void {
-    inv<void>('0x97A28E63F0BA5631', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p5, p6, p7, p8);
+  reviveTarget(reviver: Ped, tool: string | number): void {
+    inv<void>('0x356088527D9EBAAD', this.entity.handle, reviver.handle, _h(tool));
   }
 
   /**
-   * returned values:
-   * 0 to 7 = task that's currently in progress, 0 meaning the first one.
-   * -1 no task sequence in progress.
+   * https://github.com/femga/rdr3_discoveries/blob/master/animations/kit_emotes_list.lua
+   * emote: https://alloc8or.re/rdr3/doc/enums/eEmote.txt enum eEmoteType
+   * {
+   * EMOTE_TYPE_INVALID = -1,
+   * EMOTE_TYPE_REACT,
+   * EMOTE_TYPE_ACTION,
+   * EMOTE_TYPE_TAUNT,
+   * EMOTE_TYPE_GREET,
+   * EMOTE_TYPE_TWIRL_GUN,
+   * EMOTE_TYPE_DANCE_FLOOR
+   * }; enum eEmotePlaybackMode
+   * {
+   * EMOTE_PM_INVALID = -1,
+   * EMOTE_PM_UPPERBODY,
+   * EMOTE_PM_UPPERBODY_LOOP,
+   * EMOTE_PM_FULLBODY,
+   * };
    *
-   * @returns
+   * @param emoteType 
+   * @param playbackMode 
+   * @param emote 
+   * @param isSecondaryTask 
+   * @param canBreakOut 
+   * @param disableEarlyOutAnimTag 
+   * @param ignoreInvalidMainTask 
+   * @param destroyProps 
    */
-  getSequenceProgress(): number {
-    return inv<number>('0x00A9010CFE1E3533', this.entity.handle, rai());
+  playEmoteWithHash(emoteType: number, playbackMode: number, emote: string | number, isSecondaryTask: boolean, canBreakOut: boolean, disableEarlyOutAnimTag: boolean, ignoreInvalidMainTask: boolean, destroyProps: boolean): void {
+    inv<void>('0xB31A277C1AC7B7FF', this.entity.handle, emoteType, playbackMode, _h(emote), isSecondaryTask, canBreakOut, disableEarlyOutAnimTag, ignoreInvalidMainTask, destroyProps);
   }
 
   /**
-   * @returns
+   * @param pos 
+   * @param timeout 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param coverpoint 
+   * @param p10 
+   * @param p11 
+   * @param p12 
    */
-  waypointPlaybackGetIsAiming(): any {
-    return inv<number>('0xD73A5D1F0325C71C', this.entity.handle);
+  putPedDirectlyIntoCover(pos: Vector3, timeout: number, p5: boolean, p6: number, p7: any, p8: any, coverpoint: number, p10: boolean, p11: boolean, p12: any): void {
+    inv<void>('0x4172393E6BE1FECE', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), timeout, p5, f(p6), p7, p8, coverpoint, p10, p11, p12);
   }
 
   /**
-   * @param signalName 
-   * @param value 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   * @param p13 
+   * @param p14 
    */
-  setTaskMoveNetworkSignalFloat(signalName: string | null, value: number): void {
-    inv<void>('0xD5BB4025AE449A4E', this.entity.handle, signalName, f(value));
+  goToCoordAndAimAtHatedEntitiesNearCoordUsingCombatStyle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, p12: any, p13: any, p14: any): void {
+    inv<void>('0x87BD711FC31EA273', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
   }
 
   /**
-   * @param taskSequenceId 
+   * @param target 
    */
-  performSequence(taskSequenceId: number): void {
-    inv<void>('0x5ABA3986D90D8A3B', this.entity.handle, taskSequenceId);
+  arrestPed(target: Ped): void {
+    inv<void>('0xF3B9A78A178572B1', this.entity.handle, target.handle);
   }
 
   /**
    * @param p1 
    * @param p2 
    * @param p3 
+   * @returns
    */
-  moveInTraffic(p1: any, p2: any, p3: any): void {
-    inv<void>('0x8AA1593AEC087A29', this.entity.handle, p1, p2, p3);
+  setPedWaypointRouteOffset(p1: number, p2: number, p3: number): any {
+    return inv<number>('0xED98E10B0AFCE4B4', this.entity.handle, f(p1), f(p2), f(p3));
   }
 
   /**
-   * @param p1 
-   * @param permanently 
+   * @param waypointRecording 
+   * @returns
    */
-  knockedOut(p1: number, permanently: boolean): void {
-    inv<void>('0xF90427F00A495A28', this.entity.handle, f(p1), permanently);
+  isWaypointPlaybackGoingOnForPed(waypointRecording: string | null): boolean {
+    return inv<boolean>('0xE03B3F2D3DC59B64', this.entity.handle, waypointRecording, rai());
   }
 
   /**
-   * @param duration 
+   * @param p1 
+   * @param p2 
    */
-  updateTaskHandsUpDuration(duration: number): void {
-    inv<void>('0xA98FCAFD7893C834', this.entity.handle, duration);
+  animalWrithe(p1: any, p2: any): void {
+    inv<void>('0x8C038A39C4A4B6D6', this.entity.handle, p1, p2);
   }
 
   /**
-   * Similar to 0xB31A277C1AC7B7FF but checks if the ped's inventory contains the specified emote kit.
-   *
-   * @param emoteType 
-   * @param playbackMode 
-   * @param emote 
-   * @param isSecondaryTask 
-   * @param canBreakOut 
-   * @param disableEarlyOutAnimTag 
-   * @param ignoreInvalidMainTask 
-   * @param destroyProps 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
    */
-  playEmote(emoteType: number, playbackMode: number, emote: string | number, isSecondaryTask: boolean, canBreakOut: boolean, disableEarlyOutAnimTag: boolean, ignoreInvalidMainTask: boolean, destroyProps: boolean): void {
-    inv<void>('0x884E3436CC1F41DD', this.entity.handle, emoteType, playbackMode, _h(emote), isSecondaryTask, canBreakOut, disableEarlyOutAnimTag, ignoreInvalidMainTask, destroyProps);
+  aimAtEntity(p1: any, p2: any, p3: any, p4: any): void {
+    inv<void>('0xCF7569BD0FB480A0', this.entity.handle, p1, p2, p3, p4);
   }
 
   /**
-   * @param boat 
+   * @param targetPed 
    * @param p2 
    * @param p3 
-   * @param pos 
-   * @param p7 
-   * @param maxSpeed 
-   * @param drivingStyle 
-   * @param p10 
-   * @param p11 
    */
-  boatMission(boat: Vehicle, p2: any, p3: any, pos: Vector3, p7: any, maxSpeed: number, drivingStyle: number, p10: number, p11: any): void {
-    inv<void>('0x15C86013127CE63F', this.entity.handle, boat.handle, p2, p3, f(pos.x), f(pos.y), f(pos.z), p7, f(maxSpeed), drivingStyle, f(p10), p11);
+  combatPedTimed(targetPed: Ped, p2: number, p3: any): void {
+    inv<void>('0x944F30DCB7096BDE', this.entity.handle, targetPed.handle, p2, p3);
   }
 
   /**
-   * @param useLimits If `true` the ped's viewing angle will be limited to the angle range given for `minAngle` and `maxAngle`, when set to `false` the player always fully faces the player
-   * @param minAngle The minimum viewing angle, requires `useLimits` to be `true`.
-   * @param maxAngle The maximum viewing angle, reuqeres `useLimits` to be `true`.
+   * @param p1 
+   * @param p2 
+   * @param p3 
    */
-  setIntimidatedFacingAngle(useLimits: boolean, minAngle: number, maxAngle: number): void {
-    inv<void>('0x0FE797DD9F70DFA6', this.entity.handle, useLimits, f(minAngle), f(maxAngle));
+  throwProjectile(p1: any, p2: any, p3: any): void {
+    inv<void>('0x7285951DBF6B5A51', this.entity.handle, p1, p2, p3);
   }
 
   /**
-   * @param targetPed 
-   * @param p2 
+   * @param pos 
+   * @param heading 
+   * @param p5 
    */
-  animalFlee(targetPed: Ped, p2: any): void {
-    inv<void>('0xA899B61C66F09134', this.entity.handle, targetPed.handle, p2);
+  pedSlideToCoord(pos: Vector3, heading: number, p5: number): void {
+    inv<void>('0xD04FE6765D990A06', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(heading), f(p5));
   }
 
   /**
@@ -3641,4 +3405,240 @@ export class PedTask extends BaseTask {
     inv<void>('0x7AA80209BDA643EB', this.entity.handle, vehicle.handle);
   }
 
+  clearLookAt(): void {
+    inv<void>('0x0F804F1DB19B9689', this.entity.handle);
+  }
+
+  /**
+   * @param inputContext 
+   * @returns
+   */
+  getItemInteractionPromptProgress(inputContext: string | number): number {
+    return inv<number>('0xBC864A70AD55E0C1', this.entity.handle, _h(inputContext), raf());
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  setSphereDefensiveArea(p1: number, p2: number, p3: number, p4: number): void {
+    inv<void>('0x933C06518B52A9A4', this.entity.handle, f(p1), f(p2), f(p3), f(p4));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  useRandomScenarioInGroup(p1: any, p2: any, p3: any, p4: any): void {
+    inv<void>('0x14747F4A5971DE4E', this.entity.handle, p1, p2, p3, p4);
+  }
+
+  /**
+   * enum eWhistleType
+   * {
+   * WHISTLE_MAIN,
+   * WHISTLE_SECONDARY,
+   * WHISTLE_DOUBLE,
+   * WHISTLE_URGENT,
+   * WHISTLE_LONG
+   * };
+   *
+   * @param p1 
+   * @param whistleType 
+   */
+  goToWhistle(p1: Ped, whistleType: number): void {
+    inv<void>('0xBAD6545608CECA6E', this.entity.handle, p1.handle, whistleType);
+  }
+
+  /**
+   * @param pos 
+   * @param duration 
+   * @param flags 
+   * @param p6 
+   * @param p7 
+   */
+  lookAtCoord(pos: Vector3, duration: number, flags: number, p6: number, p7: boolean): void {
+    inv<void>('0x6FA46612594F7973', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), duration, flags, p6, p7);
+  }
+
+  /**
+   * @returns
+   */
+  isPedInHitReact(): any {
+    return inv<number>('0xF330A5C062B29BED', this.entity.handle);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   */
+  N_0x3FFCD7BBA074CC80(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
+    inv<void>('0x3FFCD7BBA074CC80', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
+  }
+
+  /**
+   * @returns
+   */
+  isMountedWeaponTaskUnderneathDrivingTask(): boolean {
+    return inv<boolean>('0xA320EF046186FA3B', this.entity.handle, rai());
+  }
+
+  /**
+   * flags: See TASK_ENTER_VEHICLE
+   *
+   * @param p1 
+   * @param flags Refer to [enum: eEnterExitVehicleFlags]
+   */
+  disembarkNearestTrainCarriage(p1: number, flags: number): void {
+    inv<void>('0x0A11F3BDEC03ED5F', this.entity.handle, f(p1), flags);
+  }
+
+  /**
+   * @param radius 
+   */
+  combatHatedTargetsNoLosTest(radius: number): void {
+    inv<void>('0xB5BC69D9C4060BC3', this.entity.handle, f(radius));
+  }
+
+  /**
+   * @param p1 
+   */
+  N_0x31BB338F64D5C861(p1: boolean): void {
+    inv<void>('0x31BB338F64D5C861', this.entity.handle, p1);
+  }
+
+  /**
+   * @param modifier 
+   */
+  setPedPathClimbCostModifier(modifier: number): void {
+    inv<void>('0x88E32DB8C1A4AA4B', this.entity.handle, f(modifier));
+  }
+
+  /**
+   * @param entity 
+   * @param duration 
+   * @param targetRadius 
+   * @param offset 
+   * @param moveBlendRatio 
+   * @param offsetFlags 
+   */
+  gotoEntityOffsetXy(entity: Entity, duration: number, targetRadius: number, offset: Vector2, moveBlendRatio: number, offsetFlags: number): void {
+    inv<void>('0x338E7EF52B6095A9', this.entity.handle, entity.handle, duration, f(targetRadius), f(offset.x), f(offset.y), f(moveBlendRatio), offsetFlags);
+  }
+
+  /**
+   * Makes ped walk around the area the params p1 p2 seems to not affect anything but p2 is either 0 or 1 and p1 is mostly 1.0 or ped heading
+   *
+   * @param p2 
+   * @param p3 
+   */
+  wanderStandard(p2: number, p3: number): void {
+    inv<void>('0xBB9CE077274F6A1B', this.entity.handle, f(p2), p3);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  clearPedTasks(p1: boolean, p2: boolean): void {
+    inv<void>('0xE1EF3C1216AFF2CD', this.entity.handle, p1, p2);
+  }
+
+  /**
+   * @param signalName 
+   * @param value 
+   */
+  setTaskMoveNetworkSignalFloat(signalName: string | null, value: number): void {
+    inv<void>('0xD5BB4025AE449A4E', this.entity.handle, signalName, f(value));
+  }
+
+  /**
+   * @param taskSequenceId 
+   */
+  performSequence(taskSequenceId: number): void {
+    inv<void>('0x5ABA3986D90D8A3B', this.entity.handle, taskSequenceId);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   */
+  moveInTraffic(p1: any, p2: any, p3: any): void {
+    inv<void>('0x8AA1593AEC087A29', this.entity.handle, p1, p2, p3);
+  }
+
+  /**
+   * @param p1 
+   * @param permanently 
+   */
+  knockedOut(p1: number, permanently: boolean): void {
+    inv<void>('0xF90427F00A495A28', this.entity.handle, f(p1), permanently);
+  }
+
+  /**
+   * @param duration 
+   */
+  updateTaskHandsUpDuration(duration: number): void {
+    inv<void>('0xA98FCAFD7893C834', this.entity.handle, duration);
+  }
+
+  /**
+   * Similar to 0xB31A277C1AC7B7FF but checks if the ped's inventory contains the specified emote kit.
+   *
+   * @param emoteType 
+   * @param playbackMode 
+   * @param emote 
+   * @param isSecondaryTask 
+   * @param canBreakOut 
+   * @param disableEarlyOutAnimTag 
+   * @param ignoreInvalidMainTask 
+   * @param destroyProps 
+   */
+  playEmote(emoteType: number, playbackMode: number, emote: string | number, isSecondaryTask: boolean, canBreakOut: boolean, disableEarlyOutAnimTag: boolean, ignoreInvalidMainTask: boolean, destroyProps: boolean): void {
+    inv<void>('0x884E3436CC1F41DD', this.entity.handle, emoteType, playbackMode, _h(emote), isSecondaryTask, canBreakOut, disableEarlyOutAnimTag, ignoreInvalidMainTask, destroyProps);
+  }
+
+  /**
+   * @param boat 
+   * @param p2 
+   * @param p3 
+   * @param pos 
+   * @param p7 
+   * @param maxSpeed 
+   * @param drivingStyle 
+   * @param p10 
+   * @param p11 
+   */
+  boatMission(boat: Vehicle, p2: any, p3: any, pos: Vector3, p7: any, maxSpeed: number, drivingStyle: number, p10: number, p11: any): void {
+    inv<void>('0x15C86013127CE63F', this.entity.handle, boat.handle, p2, p3, f(pos.x), f(pos.y), f(pos.z), p7, f(maxSpeed), drivingStyle, f(p10), p11);
+  }
+
+  /**
+   * @param useLimits If `true` the ped's viewing angle will be limited to the angle range given for `minAngle` and `maxAngle`, when set to `false` the player always fully faces the player
+   * @param minAngle The minimum viewing angle, requires `useLimits` to be `true`.
+   * @param maxAngle The maximum viewing angle, reuqeres `useLimits` to be `true`.
+   */
+  setIntimidatedFacingAngle(useLimits: boolean, minAngle: number, maxAngle: number): void {
+    inv<void>('0x0FE797DD9F70DFA6', this.entity.handle, useLimits, f(minAngle), f(maxAngle));
+  }
+
+  /**
+   * @param targetPed 
+   * @param p2 
+   */
+  animalFlee(targetPed: Ped, p2: any): void {
+    inv<void>('0xA899B61C66F09134', this.entity.handle, targetPed.handle, p2);
+  }
+
 }