@nativewrappers/redm-codegen 0.0.2

package/src/classes/VehicleModel.ts

@@ -0,0 +1,22 @@
+import { Vector2 } from '../types/Vector2';
+import { Vector3 } from '../types/Vector3';
+import { Vector4 } from '../types/Vector4';
+import { Color } from '../types/Color';
+import { BaseModel } from './BaseModel';
+import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f } from '../types/NativeAliases';
+
+export class VehicleModel extends BaseModel {
+  constructor(hash: number) {
+    super(hash);
+  }
+
+  /**
+   * Returns whether the specified model represents a vehicle.
+   *
+   * @returns
+   */
+  isModelAVehicle(): boolean {
+    return inv<boolean>('0x354F62672DE7DB0A', this.hash, rai());
+  }
+
+}

package/src/classes/VehicleTask.ts

@@ -0,0 +1,143 @@
+import type { eVehicleSeat } from '../enums/eVehicleSeat';
+import { Vector2 } from '../types/Vector2';
+import { Vector3 } from '../types/Vector3';
+import { Vector4 } from '../types/Vector4';
+import { Color } from '../types/Color';
+import { BaseTask } from './BaseTask';
+import type { Vehicle } from './Vehicle';
+import { createFromHandle } from '../types/HandleRegistry';
+import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f } from '../types/NativeAliases';
+
+export class VehicleTask extends BaseTask {
+  constructor(entity: Vehicle) {
+    super(entity);
+  }
+
+  /**
+   * Vehicle Auto Drive (?)
+   * p1/p2/p3: usually 1f, 1f, 0f or 0f, 0f, 0f
+   * Speed: usually 8f
+   * Types: 1148979456 (task with flee), 1148979587 (dismissing the vehicle)
+   *
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param speed 
+   * @param type 
+   */
+  vehicleFleeOnCleanup(p1: number, p2: number, p3: number, speed: number, type: string | number): void {
+    inv<void>('0x55CD5FDDD4335C1E', this.entity.handle, f(p1), f(p2), f(p3), f(speed), _h(type));
+  }
+
+  /**
+   * @param speed 
+   */
+  vehicleWaypointPlaybackOverrideSpeed(speed: number): void {
+    inv<void>('0x121F0593E0A431D7', this.entity.handle, f(speed));
+  }
+
+  /**
+   * @param p1 
+   */
+  everyoneLeaveVehicleInOrder(p1: boolean): void {
+    inv<void>('0x6F1C49F275BD25B3', this.entity.handle, p1);
+  }
+
+  /**
+   * @returns
+   */
+  getVehicleWaypointProgress(): number {
+    return inv<number>('0x9824CFF8FC66E159', this.entity.handle, rai());
+  }
+
+  /**
+   * Clears the vehicle's **primary** AI task slot (e.g., scripted drive/nav tasks).
+   */
+  clearVehicleTasks(): void {
+    inv<void>('0x141BC64C8D7C5529', this.entity.handle);
+  }
+
+  /**
+   * Sets which seat index acts as the "driver seat" for driving tasks. https://www.youtube.com/watch?v=bjXrHOTgtu0&feature=youtu.be
+   *
+   * @param seatIndex The [enum: eVehicleSeat] to assign as the driving seat
+   */
+  setDrivingSeat(seatIndex?: eVehicleSeat): void {
+    inv<void>('0x4BA972D0E5AD8122', this.entity.handle, seatIndex);
+  }
+
+  /**
+   * @returns Returns the [enum: eSeatSeat]
+   */
+  getDrivingSeat(): number {
+    return inv<number>('0xE62754D09354F6CF', this.entity.handle, rai());
+  }
+
+  /**
+   * Works exactly like [native: TASK_VEHICLE_DRIVE_TO_DESTINATION] except that it take a ped parameter (it doesn't give its driver a task), and it removes `p10`.
+   *
+   * @param pos 
+   * @param speed 
+   * @param drivingFlags 
+   * @param p6 
+   * @param stoppingRange1 
+   * @param stoppingRange2 
+   */
+  vehicleDriveToDestination2(pos: Vector3, speed: number, drivingFlags: number, p6: number, stoppingRange1: number, stoppingRange2: number): void {
+    inv<void>('0x391073B9D3CCE2BA', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(speed), drivingFlags, p6, f(stoppingRange1), f(stoppingRange2));
+  }
+
+  /**
+   * @returns
+   */
+  getActiveVehicleMissionType(): number {
+    return inv<number>('0x534AEBA6E5ED4CAB', this.entity.handle, rai());
+  }
+
+  /**
+   * @param destination 
+   * @returns
+   */
+  vehicleIsAtDestination(destination: Vector3): boolean {
+    return inv<boolean>('0x583AE9AF9CEE0958', this.entity.handle, f(destination.x), f(destination.y), f(destination.z), rai());
+  }
+
+  /**
+   * @returns
+   */
+  getVehicleWaypointTargetPoint(): number {
+    return inv<number>('0x416B62AC8B9E5BBD', this.entity.handle, rai());
+  }
+
+  vehicleWaypointPlaybackPause(): void {
+    inv<void>('0x8A4E6AC373666BC5', this.entity.handle);
+  }
+
+  /**
+   * Params: p4 = 3.f or 8.f, p5 = 0.25f, p6 = 0 in R* Scripts
+   *
+   * @param pos 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   */
+  vehicleDriveToPoint2(pos: Vector3, p4: number, p5: number, p6: any): void {
+    inv<void>('0x6524A8981E8BE7C9', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(p4), f(p5), p6);
+  }
+
+  vehicleWaypointPlaybackUseDefaultSpeed(): void {
+    inv<void>('0x5CEB25A7D2848963', this.entity.handle);
+  }
+
+  /**
+   * Clears the vehicle's **secondary/aux** AI task slot (aux behaviors/overlays).
+   */
+  clearVehicleTasksSecondary(): void {
+    inv<void>('0xEBA2081E0A5F4D17', this.entity.handle);
+  }
+
+  vehicleWaypointPlaybackResume(): void {
+    inv<void>('0xDC04FCAA7839D492', this.entity.handle);
+  }
+
+}

package/src/classes/Volume.ts

@@ -0,0 +1,225 @@
+import type { PersChar } from '../classes/PersChar';
+import { Vector2 } from '../types/Vector2';
+import { Vector3 } from '../types/Vector3';
+import { Vector4 } from '../types/Vector4';
+import { Color } from '../types/Color';
+import { IHandle } from '../types/IHandle';
+import { registerHandle, createFromHandle } from '../types/HandleRegistry';
+import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f } from '../types/NativeAliases';
+
+export class Volume implements IHandle {
+  constructor(public handle: number) {}
+
+  static fromHandle(handle: number): Volume | null {
+    return handle === 0 ? null : new Volume(handle);
+  }
+
+  /**
+   * @param typeHash 
+   * @param pos 
+   * @param rot 
+   * @param scale 
+   */
+  addToVolumeAggregate(typeHash: string | number, pos: Vector3, rot: Vector3, scale: Vector3): void {
+    inv<void>('0x12FCAA23F2320422', this.handle, _h(typeHash), f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(scale.x), f(scale.y), f(scale.z));
+  }
+
+  /**
+   * @param rot 
+   * @returns
+   */
+  setRotation(rot: Vector3): any {
+    return inv<number>('0xA07CF1B21B56F041', this.handle, f(rot.x), f(rot.y), f(rot.z));
+  }
+
+  /**
+   * @returns
+   */
+  getRotation(): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x18675BC914891122', this.handle, rav()));
+  }
+
+  deleteVolume(): void {
+    inv<void>('0x43F867EF5C463A53', this.handle);
+  }
+
+  /**
+   * @param p1 
+   */
+  N_0xD460135C98940274(p1: any): void {
+    inv<void>('0xD460135C98940274', this.handle, p1);
+  }
+
+  /**
+   * @param toggle 
+   */
+  setAntiGriefBlocksPlayer(toggle: boolean): void {
+    inv<void>('0x5B23DFF8E0948BB2', this.handle, toggle);
+  }
+
+  /**
+   * @param scale 
+   * @returns
+   */
+  setScale(scale: Vector3): any {
+    return inv<number>('0xA46E98BDC407E23D', this.handle, f(scale.x), f(scale.y), f(scale.z));
+  }
+
+  /**
+   * @param persChar 
+   * @param p2 
+   */
+  setOwnerPersistentCharacter(persChar: PersChar, p2: boolean): void {
+    inv<void>('0xE2BE6FFA4A13CBB0', this.handle, persChar.handle, p2);
+  }
+
+  /**
+   * @returns min; max
+   */
+  getBounds(): [Vector3, Vector3] {
+    const result = inv<[number[], number[]]>('0x5737199AF2DC609F', this.handle, pvv(), pvv());
+    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1])];
+  }
+
+  /**
+   * _ADD_R* - _ADD_V(OLUME?)*
+   *
+   * @param aggregate 
+   */
+  addBoundsToAggregateVolume(aggregate: Volume): void {
+    inv<void>('0x6E0D3C3F828DA773', this.handle, aggregate.handle);
+  }
+
+  /**
+   * @returns
+   */
+  isAggregateVolume(): any {
+    return inv<number>('0xFEFF01B5725BCD22', this.handle);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   */
+  addBoxToVolumeAggregate(p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: number, p9: number): void {
+    inv<void>('0x39816F6F94F385AD', this.handle, f(p1), f(p2), f(p3), f(p4), f(p5), f(p6), f(p7), f(p8), f(p9));
+  }
+
+  /**
+   * @param p1 
+   */
+  N_0xB440F4E35393FC39(p1: any): void {
+    inv<void>('0xB440F4E35393FC39', this.handle, p1);
+  }
+
+  /**
+   * @returns
+   */
+  doesExist(): any {
+    return inv<number>('0x92A78D0BEDB332A3', this.handle);
+  }
+
+  /**
+   * Returns relationshipGroup Hash
+   *
+   * @returns
+   */
+  getRelationship(): string | number {
+    return (inv<number>('0x666C2F53ABEFC952', this.handle, rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * @param toggle 
+   */
+  setAntiGriefBlocksHorse(toggle: boolean): void {
+    inv<void>('0xBE551C2CC421185D', this.handle, toggle);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   */
+  addSphereToVolumeAggregate(p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: number, p9: number): void {
+    inv<void>('0x5B7D7BF36D2DE18B', this.handle, f(p1), f(p2), f(p3), f(p4), f(p5), f(p6), f(p7), f(p8), f(p9));
+  }
+
+  /**
+   * _REMOVE_E* - _REMOVE_R*
+   *
+   * @param aggregate 
+   */
+  removeBoundsFromAggregateVolume(aggregate: Volume): void {
+    inv<void>('0xF92FA8890DECECF6', this.handle, aggregate.handle);
+  }
+
+  /**
+   * @param relationshipGroup 
+   */
+  setRelationship(relationshipGroup: string | number): void {
+    inv<void>('0xFD010A2154B40676', this.handle, _h(relationshipGroup));
+  }
+
+  /**
+   * @returns
+   */
+  getCoords(): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xF70F00013A62F866', this.handle, rav()));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   */
+  addCylinderToVolumeAggregate(p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: number, p9: number): void {
+    inv<void>('0xBCE668AAF83608BE', this.handle, f(p1), f(p2), f(p3), f(p4), f(p5), f(p6), f(p7), f(p8), f(p9));
+  }
+
+  /**
+   * Old name: _IS_POSITION_INSIDE_VOLUME
+   *
+   * @param pos 
+   * @returns
+   */
+  isPointInVolume(pos: Vector3): any {
+    return inv<number>('0xF256A75210C5C0EB', this.handle, f(pos.x), f(pos.y), f(pos.z));
+  }
+
+  /**
+   * @param pos 
+   * @returns
+   */
+  setCoords(pos: Vector3): any {
+    return inv<number>('0x541B8576615C33DE', this.handle, f(pos.x), f(pos.y), f(pos.z));
+  }
+
+  /**
+   * @returns
+   */
+  getScale(): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x3E2A25B2416DD67E', this.handle, rav()));
+  }
+
+}
+
+registerHandle('Volume', Volume);