@nativewrappers/redm 0.0.80 → 0.0.81

package/Attribute.js

@@ -0,0 +1,143 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { _N } from "./utils/Native";
+class CoreAttribute {
+  static {
+    __name(this, "CoreAttribute");
+  }
+  handle;
+  attribute;
+  constructor(ped, attribute) {
+    this.handle = ped.Handle;
+    this.attribute = attribute;
+  }
+  /**
+   * This doesn't seem to actually do anything
+   * @todo maybe remove unless theres a valid use case
+   * @param amount
+   * @param makeSound
+   */
+  enableOverpower(amount, makeSound = false) {
+    _N("0x4AF5A4C7B9157D14", this.handle, this.attribute, amount, makeSound);
+  }
+  get Overpowered() {
+    return _N("0x200373A8DF081F22", this.attribute, Citizen.resultAsInteger());
+  }
+  /**
+   * @returns the amount of overpower time left in seconds
+   */
+  get OverpoweredTimeLeft() {
+    return _N("0xB429F58803D285B1", this.handle, this.attribute, Citizen.resultAsInteger());
+  }
+  /**
+   * Returns how full the core is
+   */
+  get CoreValue() {
+    return GetAttributeCoreValue(this.handle, this.attribute);
+  }
+  set CoreValue(amount) {
+    _N("0xC6258F41D86676E0", this.handle, this.attribute, amount);
+  }
+}
+class PedAttribute {
+  static {
+    __name(this, "PedAttribute");
+  }
+  handle;
+  attribute;
+  constructor(ped, attribute) {
+    this.handle = ped.Handle;
+    this.attribute = attribute;
+  }
+  /**
+   *
+   * @param amount the amount of points to add to the attribute
+   */
+  addPoints(amount) {
+    AddAttributePoints(this.handle, this.attribute, amount);
+  }
+  /**
+   * Disables the overpower state on this attribute, see {@link enableOverpower} on how to enable
+   */
+  disableOverpower() {
+    DisableAttributeOverpower(this.handle, this.attribute);
+  }
+  /**
+   *
+   * @param amount the amount to overpower this attribute by
+   * @param makeSound if activating the overpower should play sound
+   */
+  enableOverpower(amount, makeSound = false) {
+    _N("0xF6A7C08DF2E28B28", this.handle, this.attribute, amount, makeSound);
+  }
+  /**
+   * Gets the amount of attribute points the ped has
+   */
+  get Points() {
+    return GetAttributePoints(this.handle, this.attribute);
+  }
+  set Points(amount) {
+    SetAttributePoints(this.handle, this.attribute, amount);
+  }
+  get Rank() {
+    return GetAttributeRank(this.handle, this.attribute);
+  }
+  set BaseRank(amount) {
+    SetAttributeBaseRank(this.handle, this.attribute, amount);
+  }
+  get BaseRank() {
+    return GetAttributeBaseRank(this.handle, this.attribute);
+  }
+  set BonusRank(amount) {
+    SetAttributeBonusRank(this.handle, this.attribute, amount);
+  }
+  get BonusRank() {
+    return GetAttributeBonusRank(this.handle, this.attribute);
+  }
+  get MaxRank() {
+    return _N("0x704674A0535A471D", this.attribute, Citizen.resultAsInteger());
+  }
+  get Overpowered() {
+    return _N("0x103C2F885ABEB00B", this.attribute, Citizen.resultAsInteger());
+  }
+}
+class Attributes {
+  static {
+    __name(this, "Attributes");
+  }
+  pedAttributes = [];
+  coreAttributes = [];
+  constructor(ped) {
+    for (let i = 0; i <= 21; i++) {
+      this.pedAttributes[i] = new PedAttribute(ped, i);
+    }
+    for (let i = 0; i <= 2; i++) {
+      this.coreAttributes[i] = new CoreAttribute(ped, i);
+    }
+  }
+  getCore(attribute) {
+    if (attribute > 2) throw new RangeError("The max enum for CoreAttribute is 2");
+    if (attribute < 0) throw new RangeError("The minimum enum for CoreAttribute is 0");
+    return this.coreAttributes[attribute];
+  }
+  get(attribute) {
+    if (attribute > 22) throw new RangeError("The max enum for PedAttribute is 22");
+    if (attribute < 0) throw new RangeError("The minimum enum for PedAttribute is 0");
+    return this.pedAttributes[attribute];
+  }
+  set CoreIcon(status) {
+    if (status > 15) throw new RangeError("The max enum for StatusEffect is 15");
+    if (status < 0) throw new RangeError("The minimum enum for StatusEffect is 0");
+    _N("0xA4D3A1C008F250DF", status);
+  }
+  set PeriodicIcon(status) {
+    if (status > 15) throw new RangeError("The max enum for StatusEffect is 15!");
+    if (status < 0) throw new RangeError("The minimum enum for StatusEffect is 0");
+    _N("0xFB6E111908502871", status);
+  }
+}
+export {
+  Attributes,
+  CoreAttribute,
+  PedAttribute
+};

package/Controls.js

@@ -0,0 +1,22 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Controls {
+  static {
+    __name(this, "Controls");
+  }
+  static IsInputJustPressed(hash) {
+    return IsControlJustPressed(0, hash);
+  }
+  static IsInputPressed(hash) {
+    return IsControlPressed(0, hash);
+  }
+  static IsDisabledInputPressed(hash) {
+    return IsDisabledControlPressed(0, hash);
+  }
+  static DisableControl(hash) {
+    DisableControlAction(0, hash, false);
+  }
+}
+export {
+  Controls
+};

package/Game.d.ts

@@ -1,5 +1,5 @@
-import { Ped, Player } from "./entities";
+import { Ped } from "./entities/Ped";
 export declare class Game {
     static get PlayerPed(): Ped;
-    static get Player(): Player;
+    static get Player(): import("./entities/Player").Player;
 }

package/Game.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Ped } from "./entities/Ped";
+import { GameConstants } from "./GameConstants";
+class Game {
+  static {
+    __name(this, "Game");
+  }
+  static get PlayerPed() {
+    return new Ped(PlayerPedId());
+  }
+  static get Player() {
+    return GameConstants.Player;
+  }
+}
+export {
+  Game
+};

package/GameConstants.d.ts

@@ -1,4 +1,4 @@
-import { Player } from "./entities";
+import { Player } from "./entities/Player";
 export declare class GameConstants {
     private static player;
     static readonly PlayerId: number;

package/GameConstants.js

@@ -0,0 +1,24 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Player } from "./entities/Player";
+class GameConstants {
+  static {
+    __name(this, "GameConstants");
+  }
+  // the actual player object that will get initialized on the first call to the `get Player()`
+  static player = null;
+  // The player id of the local client
+  static PlayerId = PlayerId();
+  // The server id of the local client.
+  static ServerId = GetPlayerServerId(GameConstants.PlayerId);
+  // The player class of the local object
+  static get Player() {
+    if (GameConstants.player === null) {
+      GameConstants.player = new Player(GameConstants.PlayerId);
+    }
+    return GameConstants.player;
+  }
+}
+export {
+  GameConstants
+};

package/Model.js

@@ -0,0 +1,153 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "./common/utils/Vector";
+import { Delay } from "./common/utils/Delay";
+class Model {
+  static {
+    __name(this, "Model");
+  }
+  /**
+   * Hash of this model.
+   */
+  hash;
+  requestedModel = false;
+  /**
+   * Creates a model object based on the hash key or model string.
+   *
+   * @param hash A number or string of the model's hash. Example: "mp_m_freemode_01"
+   */
+  constructor(hash) {
+    if (typeof hash === "string") {
+      this.hash = GetHashKey(hash);
+    } else {
+      this.hash = hash;
+    }
+  }
+  [Symbol.dispose]() {
+    if (this.requestedModel) {
+      this.markAsNoLongerNeeded();
+    }
+  }
+  /**
+   * Gets the hash of the model.
+   *
+   * @returns The hash key.
+   */
+  get Hash() {
+    return this.hash;
+  }
+  /**
+   * Gets if the model is valid or not.
+   *
+   * @returns Whether this model is valid.
+   */
+  get IsValid() {
+    return IsModelValid(this.hash);
+  }
+  /**
+   * Gets if the model is in cd image or not.
+   *
+   * @returns Whether this model is in cd image.
+   */
+  get IsInCdImage() {
+    return IsModelInCdimage(this.hash);
+  }
+  /**
+   * Gets if the model is loaded or not.
+   *
+   * @returns Whether this model is loaded.
+   */
+  get IsLoaded() {
+    return HasModelLoaded(this.hash);
+  }
+  /**
+   * Gets if the model collision is loaded or not.
+   *
+   * @returns Whether this model collision is loaded.
+   */
+  get IsCollisionLoaded() {
+    return HasCollisionForModelLoaded(this.hash);
+  }
+  /**
+   * Gets if the model is a boat or not.
+   *
+   * @returns Whether this model is a boat.
+   */
+  get IsBoat() {
+    return IsThisModelABoat(this.hash);
+  }
+  /**
+   * Gets if the model is a Ped or not.
+   *
+   * @returns Whether this model is a Ped.
+   */
+  get IsPed() {
+    return IsModelAPed(this.hash);
+  }
+  /**
+   * Gets if the model is a prop or not.
+   *
+   * @returns Whether this model is a prop.
+   */
+  get IsProp() {
+    return this.IsValid && !this.IsPed && !this.IsVehicle && !IsWeaponValid(this.hash);
+  }
+  /**
+   * Gets if the model is a train or not.
+   *
+   * @returns Whether this model is a train.
+   */
+  get IsTrain() {
+    return IsThisModelATrain(this.hash);
+  }
+  /**
+   * Gets if the model is a Vehicle or not.
+   *
+   * @returns Whether this model is a Vehicle.
+   */
+  get IsVehicle() {
+    return IsModelAVehicle(this.hash);
+  }
+  /**
+   * Gets the model dimensions.
+   *
+   * @returns This model min & max dimensions.
+   */
+  get Dimensions() {
+    const [minArray, maxArray] = GetModelDimensions(this.hash);
+    const min = Vector3.fromArray(minArray);
+    const max = Vector3.fromArray(maxArray);
+    return { min, max };
+  }
+  /**
+   * Request and load the model with a specified timeout. Default timeout is 1000 (recommended).
+   * This function will not automatically set the model as no longer needed when
+   * done.
+   *
+   * @param timeoutMs Maximum allowed time for model to load.
+   */
+  async request(timeoutMs = 1e3) {
+    if (!this.IsInCdImage && !this.IsValid && !IsWeaponValid(this.hash)) {
+      return false;
+    }
+    if (this.IsLoaded) {
+      return true;
+    }
+    RequestModel(this.hash, false);
+    const timeout = GetGameTimer() + timeoutMs;
+    while (!this.IsLoaded && GetGameTimer() < timeout) {
+      await Delay(0);
+    }
+    this.requestedModel = true;
+    return this.IsLoaded;
+  }
+  /**
+   * Sets the model as no longer needed allowing the game engine to free memory.
+   */
+  markAsNoLongerNeeded() {
+    SetModelAsNoLongerNeeded(this.hash);
+  }
+}
+export {
+  Model
+};

package/RawControls.d.ts

@@ -1,4 +1,4 @@
-import type { RawKeys } from "./enums";
+import type { RawKeys } from "./enums/RawKeys";
 export declare class RawControls {
     static IsKeyDown(rawKey: RawKeys): boolean;
     static IsKeyPressed(rawKey: RawKeys): boolean;

package/RawControls.js

@@ -0,0 +1,22 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class RawControls {
+  static {
+    __name(this, "RawControls");
+  }
+  static IsKeyDown(rawKey) {
+    return IsRawKeyDown(rawKey);
+  }
+  static IsKeyPressed(rawKey) {
+    return IsRawKeyPressed(rawKey);
+  }
+  static IsKeyReleased(rawKey) {
+    return IsRawKeyReleased(rawKey);
+  }
+  static IsKeyUp(rawKey) {
+    return IsRawKeyUp(rawKey);
+  }
+}
+export {
+  RawControls
+};

package/RelationshipGroup.js

@@ -0,0 +1,72 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class RelationshipGroup {
+  static {
+    __name(this, "RelationshipGroup");
+  }
+  /**
+   * The hash of the relationship group
+   */
+  hash;
+  /**
+   * Create a relationship group. Optionally pass a group hash.
+   *
+   * @param name Name of the relationship group.
+   */
+  constructor(name) {
+    const [, groupHash] = AddRelationshipGroup(name);
+    this.hash = groupHash;
+  }
+  /**
+   * Gets the hash of the relationship group.
+   *
+   * @returns The hash of this object.
+   */
+  get Hash() {
+    return this.hash;
+  }
+  /**
+   * Get the relationship between two relationship groups.
+   *
+   * @param targetGroup The other relationship group.
+   * @returns The relationship
+   */
+  getRelationshipBetweenGroups(targetGroup) {
+    return GetRelationshipBetweenGroups(this.Hash, targetGroup.Hash);
+  }
+  /**
+   * Set the relationship group between this relationship group and another one.
+   *
+   * @param targetGroup The other relationship group.
+   * @param relationship The desired relationship.
+   * @param biDirectionally If target group should have same relationship towards this.
+   */
+  setRelationshipBetweenGroups(targetGroup, relationship, biDirectionally = false) {
+    SetRelationshipBetweenGroups(Number(relationship), this.Hash, targetGroup.Hash);
+    if (biDirectionally) {
+      SetRelationshipBetweenGroups(Number(relationship), targetGroup.Hash, this.Hash);
+    }
+  }
+  /**
+   * Clear the relationship between this relationship group and another.
+   *
+   * @param targetGroup The other relationship group.
+   * @param relationship The desired relationship to clear.
+   * @param biDirectionally Whether the target group should also clear the relationship.
+   */
+  clearRelationshipBetweenGroups(targetGroup, relationship, biDirectionally = false) {
+    ClearRelationshipBetweenGroups(Number(relationship), this.Hash, targetGroup.Hash);
+    if (biDirectionally) {
+      ClearRelationshipBetweenGroups(Number(relationship), targetGroup.Hash, this.Hash);
+    }
+  }
+  /**
+   * Remove this relationship group from the game. This will not delete this object.
+   */
+  remove() {
+    RemoveRelationshipGroup(this.Hash);
+  }
+}
+export {
+  RelationshipGroup
+};

package/Volume.d.ts

@@ -1,4 +1,4 @@
-import type { Vector3 } from "./common/utils/Vector3";
+import type { Vector3 } from "./common/utils/Vector";
 export declare class Volume {
     private handle;
     constructor(coord: Vector3, rot: Vector3, scale: Vector3, customName?: string);

package/Volume.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Volume {
+  static {
+    __name(this, "Volume");
+  }
+  handle;
+  constructor(coord, rot, scale, customName) {
+    if (customName) {
+      this.handle = CreateVolumeCylinderWithCustomName(
+        coord.x,
+        coord.y,
+        coord.z,
+        rot.x,
+        rot.y,
+        rot.z,
+        scale.x,
+        scale.y,
+        scale.z,
+        customName
+      );
+      return;
+    }
+    this.handle = CreateVolumeCylinder(coord.x, coord.y, coord.z, rot.x, rot.y, rot.z, scale.x, scale.y, scale.z);
+  }
+  get Handle() {
+    return this.handle;
+  }
+}
+export {
+  Volume
+};

package/common/Command.js

@@ -0,0 +1,111 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const commands = [];
+$SERVER: {
+  on("playerJoining", () => emitNet("chat:addSuggestions", source, commands));
+}
+function registerCommand(name, commandHandler, restricted) {
+  if (Array.isArray(name)) {
+    for (const command of name) {
+      registerCommand(command, commandHandler, restricted);
+    }
+    return;
+  }
+  RegisterCommand(name, commandHandler, !!restricted);
+  $SERVER: {
+    const ace = `command.${name}`;
+    if (typeof restricted === "string") {
+      if (IsPrincipalAceAllowed(restricted, ace)) return;
+      return ExecuteCommand(`add_ace ${restricted} ${ace} allow`);
+    }
+    if (Array.isArray(restricted)) {
+      for (const principal of restricted) {
+        if (!IsPrincipalAceAllowed(principal, ace)) ExecuteCommand(`add_ace ${restricted} ${ace} allow`);
+      }
+    }
+  }
+}
+__name(registerCommand, "registerCommand");
+class Command {
+  constructor(name, help, handler, params, restricted = true) {
+    this.name = name;
+    this.help = help;
+    this.params = params;
+    this.#handler = handler;
+    this.name = `/${name}`;
+    registerCommand(name, (source2, args, raw) => this.call(source2, args, raw), restricted);
+    if (params) {
+      for (const parameter of params) {
+        if (parameter.type) {
+          parameter.help = parameter.help ? `${parameter.help} (type: ${parameter.type})` : `(type: ${parameter.type})`;
+        }
+      }
+      setTimeout(() => {
+        $SERVER: {
+          commands.push(this);
+          emitNet("chat:addSuggestions", -1, this);
+        }
+        $CLIENT: {
+          emit("chat:addSuggestion", this);
+        }
+      }, 100);
+    }
+  }
+  static {
+    __name(this, "Command");
+  }
+  #handler;
+  mapArguments(source2, args, raw) {
+    const mapped = {
+      source: source2,
+      raw
+    };
+    if (!this.params) return mapped;
+    const result = this.params.every((param, index) => {
+      const arg = args[index];
+      let value = arg;
+      switch (param.type) {
+        case "number":
+          value = +arg;
+          break;
+        case "string":
+          value = !Number(arg) ? arg : false;
+          break;
+        case "playerId":
+          $SERVER: {
+            value = arg === "me" ? source2 : +arg;
+            if (!value || !DoesPlayerExist(value.toString())) value = void 0;
+          }
+          $CLIENT: {
+            value = arg === "me" ? GetPlayerServerId(PlayerId()) : +arg;
+            if (!value || GetPlayerFromServerId(value) === -1) value = void 0;
+          }
+          break;
+        case "longString":
+          value = raw.substring(raw.indexOf(arg));
+          break;
+      }
+      if (value === void 0 && (!param.optional || param.optional && arg)) {
+        return Citizen.trace(
+          `^1command '${raw.split(" ")[0] || raw}' received an invalid ${param.type} for argument ${index + 1} (${param.name}), received '${arg}'^0`
+        );
+      }
+      mapped[param.name] = value;
+      return true;
+    });
+    return result ? mapped : null;
+  }
+  async call(source2, args, raw = args.join(" ")) {
+    const parsed = this.mapArguments(source2, args, raw);
+    if (!parsed) return;
+    try {
+      await this.#handler(parsed);
+    } catch (err) {
+      Citizen.trace(`^1command '${raw.split(" ")[0] || raw}' failed to execute!^0
+${err.message}`);
+    }
+  }
+}
+export {
+  Command
+};

package/common/Convar.js

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GlobalData } from "./GlobalData";
+class Convar {
+  static {
+    __name(this, "Convar");
+  }
+  /**
+   * @returns the current console buffer
+   */
+  buffer() {
+    $CLIENT: {
+      if (GlobalData.IS_CLIENT) {
+        throw new Error("This function isn't available on the client");
+      }
+    }
+    return GetConsoleBuffer();
+  }
+  get(variable, defaultVar) {
+    return GetConvar(variable, defaultVar);
+  }
+  getInt(variable, defaultVar) {
+    return GetConvarInt(variable, defaultVar);
+  }
+  getFloat(varName, defaultVar) {
+    return GetConvarFloat(varName, defaultVar);
+  }
+  getBool(varName, defaultVar) {
+    return GetConvarBool(varName, defaultVar);
+  }
+  set(variable, value) {
+    $CLIENT: {
+      if (GlobalData.IS_CLIENT) {
+        throw new Error("This function isn't available on the client");
+      }
+    }
+    SetConvar(variable, value);
+  }
+  setReplicated(variable, value) {
+    $CLIENT: {
+      if (GlobalData.IS_CLIENT) {
+        throw new Error("This function isn't available on the client");
+      }
+    }
+    SetConvarReplicated(variable, value);
+  }
+  setServerInfo(variable, value) {
+    $CLIENT: {
+      if (GlobalData.IS_CLIENT) {
+        throw new Error("This function isn't available on the client");
+      }
+    }
+    SetConvarServerInfo(variable, value);
+  }
+}
+export {
+  Convar
+};