@nativewrappers/fivem 0.0.80 → 0.0.81

package/Audio.d.ts

@@ -1,6 +1,6 @@
-import type { AudioFlag } from "./enums";
+import type { Vector3 } from "./common/utils/Vector";
+import type { AudioFlag } from "./enums/AudioFlag";
 import type { BaseEntity } from "./models/BaseEntity";
-import type { Vector3 } from "./utils";
 export declare abstract class Audio {
     static playSoundAt(position: Vector3, sound: string, set?: string, generateSoundId?: boolean): number;
     static playSoundFromEntity(entity: BaseEntity, sound: string, set?: string, generateSoundId?: boolean): number;

package/Audio.js

@@ -0,0 +1,99 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Audio {
+  static {
+    __name(this, "Audio");
+  }
+  static playSoundAt(position, sound, set, generateSoundId = true) {
+    const SOUND_ID = generateSoundId ? GetSoundId() : -1;
+    PlaySoundFromCoord(SOUND_ID, sound, position.x, position.y, position.z, set ?? "", false, 0, false);
+    return SOUND_ID;
+  }
+  static playSoundFromEntity(entity, sound, set, generateSoundId = true) {
+    const SOUND_ID = generateSoundId ? GetSoundId() : -1;
+    PlaySoundFromEntity(SOUND_ID, sound, entity.Handle, set ?? "", false, 0);
+    return SOUND_ID;
+  }
+  static playSoundFrontEnd(sound, set, generateSoundId = true) {
+    const SOUND_ID = generateSoundId ? GetSoundId() : -1;
+    PlaySoundFrontend(SOUND_ID, sound, set ?? "", false);
+    return SOUND_ID;
+  }
+  static stopSound(soundId) {
+    StopSound(soundId);
+  }
+  static releaseSound(soundId) {
+    ReleaseSoundId(soundId);
+  }
+  static hasSoundFinished(soundId) {
+    return HasSoundFinished(soundId);
+  }
+  static setAudioFlag(flag, toggle) {
+    if (typeof flag === "string") {
+      SetAudioFlag(flag, toggle);
+    } else {
+      SetAudioFlag(Audio.audioFlags[Number(flag)], toggle);
+    }
+  }
+  static playSound(soundFile, soundSet) {
+    Audio.releaseSound(Audio.playSoundFrontEnd(soundFile, soundSet));
+  }
+  static playMusic(musicFile) {
+    if (!Audio.cachedMusicFile) {
+      CancelMusicEvent(musicFile);
+    }
+    Audio.cachedMusicFile = musicFile;
+    TriggerMusicEvent(musicFile);
+  }
+  static stopMusic(musicFile) {
+    if (!musicFile) {
+      if (!Audio.cachedMusicFile) {
+        CancelMusicEvent(Audio.cachedMusicFile);
+        Audio.cachedMusicFile = "";
+      }
+    } else {
+      CancelMusicEvent(musicFile ?? "");
+    }
+  }
+  static cachedMusicFile;
+  static audioFlags = [
+    "ActivateSwitchWheelAudio",
+    "AllowCutsceneOverScreenFade",
+    "AllowForceRadioAfterRetune",
+    "AllowPainAndAmbientSpeechToPlayDuringCutscene",
+    "AllowPlayerAIOnMission",
+    "AllowPoliceScannerWhenPlayerHasNoControl",
+    "AllowRadioDuringSwitch",
+    "AllowRadioOverScreenFade",
+    "AllowScoreAndRadio",
+    "AllowScriptedSpeechInSlowMo",
+    "AvoidMissionCompleteDelay",
+    "DisableAbortConversationForDeathAndInjury",
+    "DisableAbortConversationForRagdoll",
+    "DisableBarks",
+    "DisableFlightMusic",
+    "DisableReplayScriptStreamRecording",
+    "EnableHeadsetBeep",
+    "ForceConversationInterrupt",
+    "ForceSeamlessRadioSwitch",
+    "ForceSniperAudio",
+    "FrontendRadioDisabled",
+    "HoldMissionCompleteWhenPrepared",
+    "IsDirectorModeActive",
+    "IsPlayerOnMissionForSpeech",
+    "ListenerReverbDisabled",
+    "LoadMPData",
+    "MobileRadioInGame",
+    "OnlyAllowScriptTriggerPoliceScanner",
+    "PlayMenuMusic",
+    "PoliceScannerDisabled",
+    "ScriptedConvListenerMaySpeak",
+    "SpeechDucksScore",
+    "SuppressPlayerScubaBreathing",
+    "WantedMusicDisabled",
+    "WantedMusicOnMission"
+  ];
+}
+export {
+  Audio
+};

package/Blip.d.ts

@@ -1,6 +1,7 @@
-import { Vector3 } from "./utils";
-import type { BlipColor, BlipSprite } from "./enums";
-import { BaseEntity, type Player } from "./models";
+import { Vector3 } from "./common/utils/Vector";
+import type { BlipColor, BlipSprite } from "./enums/Blip";
+import { BaseEntity } from "./models/BaseEntity";
+import type { Player } from "./models/Player";
 export declare class Blip {
     protected handle: number;
     constructor(handle: number);

package/Blip.js

@@ -0,0 +1,113 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./common/utils/Vector";
+import { BaseEntity } from "./models/BaseEntity";
+class Blip {
+  static {
+    __name(this, "Blip");
+  }
+  handle;
+  constructor(handle) {
+    this.handle = handle;
+  }
+  get Handle() {
+    return this.handle;
+  }
+  get Position() {
+    return Vector3.fromArray(GetBlipInfoIdCoord(this.handle));
+  }
+  set Position(location) {
+    SetBlipCoords(this.handle, location.x, location.y, location.z);
+  }
+  set Rotation(rotation) {
+    SetBlipRotation(this.handle, rotation);
+  }
+  set Scale(scale) {
+    SetBlipScale(this.handle, scale);
+  }
+  get Type() {
+    return GetBlipInfoIdType(this.handle);
+  }
+  get Alpha() {
+    return GetBlipAlpha(this.handle);
+  }
+  set Alpha(alpha) {
+    SetBlipAlpha(this.handle, alpha);
+  }
+  set Priority(priority) {
+    SetBlipPriority(this.handle, priority);
+  }
+  set NumberLabel(number) {
+    ShowNumberOnBlip(this.handle, number);
+  }
+  get Color() {
+    return GetBlipColour(this.handle);
+  }
+  set Color(color) {
+    SetBlipColour(this.handle, color);
+  }
+  get Sprite() {
+    return GetBlipSprite(this.handle);
+  }
+  set Sprite(sprite) {
+    SetBlipSprite(this.handle, sprite);
+  }
+  set Display(display) {
+    SetBlipDisplay(this.handle, display);
+  }
+  set Name(name) {
+    BeginTextCommandSetBlipName("STRING");
+    AddTextComponentSubstringPlayerName(name);
+    EndTextCommandSetBlipName(this.handle);
+  }
+  setNameToPlayerName(player) {
+    SetBlipNameToPlayerName(this.handle, player.Handle);
+  }
+  get Entity() {
+    return new BaseEntity(GetBlipInfoIdEntityIndex(this.handle));
+  }
+  set ShowHeadingIndicator(show) {
+    ShowHeadingIndicatorOnBlip(this.handle, show);
+  }
+  set ShowRoute(show) {
+    SetBlipRoute(this.handle, show);
+  }
+  set IsFriendly(friendly) {
+    SetBlipAsFriendly(this.handle, friendly);
+  }
+  set IsFriend(friend) {
+    SetBlipFriend(this.handle, friend);
+  }
+  set IsCrew(crew) {
+    SetBlipCrew(this.handle, crew);
+  }
+  get IsFlashing() {
+    return IsBlipFlashing(this.handle);
+  }
+  set IsFlashing(flashing) {
+    SetBlipFlashes(this.handle, flashing);
+  }
+  get IsOnMinimap() {
+    return IsBlipOnMinimap(this.handle);
+  }
+  get IsShortRange() {
+    return IsBlipShortRange(this.handle);
+  }
+  set IsShortRange(shortRange) {
+    SetBlipAsShortRange(this.handle, shortRange);
+  }
+  removeNumberLabel() {
+    HideNumberOnBlip(this.handle);
+  }
+  delete() {
+    if (this.exists()) {
+      RemoveBlip(this.handle);
+    }
+  }
+  exists() {
+    return DoesBlipExist(this.handle);
+  }
+}
+export {
+  Blip
+};

package/Camera.d.ts

@@ -1,7 +1,7 @@
-import type { CameraShake } from "./enums";
-import { PedBone } from "./models";
+import { Vector3 } from "./common/utils/Vector";
+import type { CameraShake } from "./enums/CameraShake";
 import { BaseEntity } from "./models/BaseEntity";
-import { Vector3 } from "./utils";
+import { PedBone } from "./models/PedBone";
 export declare class Camera {
     static readonly shakeNames: string[];
     private handle;

package/Camera.js

@@ -0,0 +1,190 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./common/utils/Vector";
+import { GameplayCamera } from "./GameplayCamera";
+import { BaseEntity } from "./models/BaseEntity";
+import { PedBone } from "./models/PedBone";
+import { LoadAnimDict } from "./utils/Animations";
+class Camera {
+  static {
+    __name(this, "Camera");
+  }
+  static shakeNames = [
+    "HAND_SHAKE",
+    "SMALL_EXPLOSION_SHAKE",
+    "MEDIUM_EXPLOSION_SHAKE",
+    "LARGE_EXPLOSION_SHAKE",
+    "JOLT_SHAKE",
+    "VIBRATE_SHAKE",
+    "ROAD_VIBRATION_SHAKE",
+    "DRUNK_SHAKE",
+    "SKY_DIVING_SHAKE",
+    "FAMILY5_DRUG_TRIP_SHAKE",
+    "DEATH_FAIL_IN_EFFECT_SHAKE"
+  ];
+  handle;
+  constructor(handle) {
+    this.handle = handle;
+  }
+  get Handle() {
+    return this.handle;
+  }
+  get IsActive() {
+    return IsCamActive(this.handle);
+  }
+  set IsActive(active) {
+    SetCamActive(this.handle, active);
+  }
+  get Position() {
+    return Vector3.fromArray(GetCamCoord(this.handle));
+  }
+  set Position(position) {
+    SetCamCoord(this.handle, position.x, position.y, position.z);
+  }
+  get Rotation() {
+    return Vector3.fromArray(GetCamRot(this.handle, 2));
+  }
+  set Rotation(rotation) {
+    SetCamRot(this.handle, rotation.x, rotation.y, rotation.z, 2);
+  }
+  // public get Matrix() : Matrix {}
+  /**
+   * Gets the direction the camera is facing. Same as ForwardVector
+   */
+  get Direction() {
+    return this.ForwardVector;
+  }
+  set Direction(direction) {
+    const dir = direction.normalize();
+    const vec1 = new Vector3(dir.x, dir.y, 0);
+    const vec2 = new Vector3(dir.z, vec1.distanceSquared(vec1), 0);
+    const vec3 = vec2.normalize();
+    this.Rotation = new Vector3(
+      Math.atan2(vec3.x, vec3.y) * 57.29577951308232,
+      this.Rotation.y,
+      Math.atan2(dir.x, dir.y) * -57.29577951308232
+    );
+  }
+  //   public get UpVector() : Vector3 {
+  //       return Matrix.Up;
+  //   }
+  get ForwardVector() {
+    const rotation = Vector3.multiply(GameplayCamera.Rotation, Math.PI / 180);
+    const normalized = Vector3.normalize(
+      new Vector3(
+        -Math.sin(rotation.z) * Math.abs(Math.cos(rotation.x)),
+        Math.cos(rotation.z) * Math.abs(Math.cos(rotation.x)),
+        Math.sin(rotation.x)
+      )
+    );
+    return new Vector3(normalized.x, normalized.y, normalized.z);
+  }
+  //   public get RightVector() : Vector3 {
+  //       return Matrix.Right;
+  //   }
+  // public Vector3 GetOffsetPosition(Vector3 offset) {
+  //     return Vector3.TransformCoordinate(offset, Matrix);
+  // }
+  // public Vector3 GetPositionOffset(Vector3 worldCoords) {
+  //     return Vector3.TransformCoordinate(worldCoords, Matrix.Invert(Matrix));
+  // }
+  get FieldOfView() {
+    return GetCamFov(this.handle);
+  }
+  set FieldOfView(fieldOfView) {
+    SetCamFov(this.handle, fieldOfView);
+  }
+  get NearClip() {
+    return GetCamNearClip(this.handle);
+  }
+  set NearClip(nearClip) {
+    SetCamNearClip(this.handle, nearClip);
+  }
+  get FarClip() {
+    return GetCamFarClip(this.handle);
+  }
+  set FarClip(farClip) {
+    SetCamFarClip(this.handle, farClip);
+  }
+  set NearDepthOfField(nearDepthOfField) {
+    SetCamNearDof(this.handle, nearDepthOfField);
+  }
+  get FarDepthOfField() {
+    return GetCamFarDof(this.handle);
+  }
+  set FarDepthOfField(farDepthOfField) {
+    SetCamFarDof(this.handle, farDepthOfField);
+  }
+  set DepthOfFieldStrength(strength) {
+    SetCamDofStrength(this.handle, strength);
+  }
+  set MotionBlurStrength(strength) {
+    SetCamMotionBlurStrength(this.handle, strength);
+  }
+  shake(shakeType, amplitude) {
+    ShakeCam(this.handle, Camera.shakeNames[Number(shakeType)], amplitude);
+  }
+  stopShaking() {
+    StopCamShaking(this.handle, true);
+  }
+  get IsShaking() {
+    return IsCamShaking(this.handle);
+  }
+  set ShakeAmplitude(amplitude) {
+    SetCamShakeAmplitude(this.handle, amplitude);
+  }
+  async playAnim(animName, animDict, position, rotation) {
+    await LoadAnimDict(animDict);
+    PlayCamAnim(
+      this.handle,
+      animName,
+      animDict,
+      position.x,
+      position.y,
+      position.z,
+      rotation.x,
+      rotation.y,
+      rotation.z,
+      false,
+      2
+    );
+    RemoveAnimDict(animDict);
+  }
+  pointAt(target, offset = new Vector3(0, 0, 0)) {
+    if (target instanceof BaseEntity) {
+      PointCamAtEntity(this.handle, target.Handle, offset.x, offset.y, offset.z, true);
+    } else if (target instanceof PedBone) {
+      PointCamAtPedBone(this.handle, target.Owner.Handle, target.Index, offset.x, offset.y, offset.z, true);
+    } else {
+      PointCamAtCoord(this.handle, target.x, target.y, target.z);
+    }
+  }
+  stopPointing() {
+    StopCamPointing(this.handle);
+  }
+  interpTo(to, duration, easePosition, easeRotation) {
+    SetCamActiveWithInterp(to.handle, this.handle, duration, Number(easePosition), Number(easeRotation));
+  }
+  get IsInterpolating() {
+    return IsCamInterpolating(this.handle);
+  }
+  attachTo(object, offset) {
+    if (object instanceof BaseEntity) {
+      AttachCamToEntity(this.handle, object.Handle, offset.x, offset.y, offset.z, true);
+    } else if (object instanceof PedBone) {
+      AttachCamToPedBone(this.handle, object.Owner.Handle, object.Index, offset.x, offset.y, offset.z, true);
+    }
+  }
+  detach() {
+    DetachCam(this.handle);
+  }
+  delete() {
+    DestroyCam(this.handle, false);
+  }
+  exists() {
+    return DoesCamExist(this.handle);
+  }
+}
+export {
+  Camera
+};

package/Checkpoint.d.ts

@@ -1,5 +1,5 @@
-import { CheckpointIcon } from "./enums";
-import { Vector3 } from "./utils";
+import { Vector3 } from "./common/utils/Vector";
+import { CheckpointIcon } from "./enums/Checkpoint";
 export declare class Checkpoint {
     private handle;
     private position;

package/Checkpoint.js

@@ -0,0 +1,51 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./common/utils/Vector";
+import { CheckpointIcon } from "./enums/Checkpoint";
+class Checkpoint {
+  static {
+    __name(this, "Checkpoint");
+  }
+  handle;
+  position = new Vector3(0, 0, 0);
+  targetPosition = new Vector3(0, 0, 0);
+  icon = CheckpointIcon.Empty;
+  radius = 0;
+  constructor(handle) {
+    this.handle = handle;
+  }
+  get Position() {
+    return this.position;
+  }
+  set Position(position) {
+    this.position = position;
+  }
+  get TargetPosition() {
+    return this.targetPosition;
+  }
+  set TargetPosition(targetPosition) {
+    this.targetPosition = targetPosition;
+  }
+  get Icon() {
+    return this.icon;
+  }
+  set Icon(icon) {
+    this.icon = icon;
+  }
+  // TODO
+  //   public get CustomIcon(): CheckpointIcon {
+  //     return this.icon;
+  //   }
+  //     public set CustomIcon(icon: CheckpointIcon) {
+  //     this.icon = icon;
+  //   }
+  get Radius() {
+    return this.radius;
+  }
+  set Radius(radius) {
+    this.radius = radius;
+  }
+}
+export {
+  Checkpoint
+};

package/Events.js

@@ -0,0 +1,80 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector2, Vector3, Vector4 } from "./common/utils/Vector";
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { BaseEntity } from "./models/BaseEntity";
+import { Ped } from "./models/Ped";
+import { Player } from "./models/Player";
+import { Prop } from "./models/Prop";
+import { Vehicle } from "./models/Vehicle";
+const getClassFromArguments = /* @__PURE__ */ __name((...args) => {
+  const newArgs = [];
+  for (const arg of args) {
+    if (!arg.type) {
+      newArgs.push(arg);
+      continue;
+    }
+    switch (arg.type) {
+      case ClassTypes.Vector2: {
+        newArgs.push(Vector2.fromObject(arg));
+        continue;
+      }
+      case ClassTypes.Vector3: {
+        newArgs.push(Vector3.fromObject(arg));
+        continue;
+      }
+      case ClassTypes.Vector4: {
+        newArgs.push(Vector4.fromObject(arg));
+        continue;
+      }
+      case ClassTypes.Ped: {
+        newArgs.push(Ped.fromNetworkId(arg.handle));
+        continue;
+      }
+      case ClassTypes.Player: {
+        newArgs.push(Player.fromServerId(arg.source));
+        continue;
+      }
+      case ClassTypes.Prop: {
+        newArgs.push(Prop.fromNetworkId(arg.handle));
+        continue;
+      }
+      case ClassTypes.Vehicle: {
+        newArgs.push(Vehicle.fromNetworkId(arg.netId));
+        continue;
+      }
+      case ClassTypes.Entity: {
+        newArgs.push(BaseEntity.fromNetworkId(arg.netId));
+        continue;
+      }
+      default: {
+        newArgs.push(arg);
+      }
+    }
+  }
+  return newArgs;
+}, "getClassFromArguments");
+class Events {
+  static {
+    __name(this, "Events");
+  }
+  /**
+   * An onNet wrapper that properly converts the type into the correct type
+   */
+  static onNet = /* @__PURE__ */ __name((eventName, event) => {
+    onNet(eventName, (...args) => {
+      event(...getClassFromArguments(...args));
+    });
+  }, "onNet");
+  /**
+   * An on wrapper that properly converts the classes
+   */
+  static on = /* @__PURE__ */ __name((eventName, event) => {
+    on(eventName, (...args) => {
+      event(...getClassFromArguments(...args));
+    });
+  }, "on");
+}
+export {
+  Events
+};

package/Game.d.ts

@@ -1,6 +1,13 @@
-import { Blip, Vector3 } from ".";
-import { type Control, InputMode, type Language, RadioStation } from "./enums";
-import { Ped, Player, Prop, Vehicle } from "./models";
+import { Vector3 } from "./common/utils/Vector";
+import { Blip } from "./Blip";
+import type { Control } from "./enums/Control";
+import { InputMode } from "./enums/InputMode";
+import type { Language } from "./enums/Language";
+import { RadioStation } from "./enums/RadioStation";
+import { Ped } from "./models/Ped";
+import { Prop } from "./models/Prop";
+import { Vehicle } from "./models/Vehicle";
+import { Player } from "./models/Player";
 export declare abstract class Game {
     static useHashCache: boolean;
     static hashCache: Map<string, number>;