@nativewrappers/server 0.0.79 → 0.0.81

package/entities/BaseEntity.js

@@ -0,0 +1,141 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import cfx from "../cfx";
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { Vector3, Vector4 } from "../common/utils/Vector";
+class BaseEntity {
+  constructor(handle) {
+    this.handle = handle;
+  }
+  static {
+    __name(this, "BaseEntity");
+  }
+  type = ClassTypes.Entity;
+  // Replaces the current handle for the entity used on, this hsould be used sparringly, mainly
+  // in situations where you're going to reuse an entity over and over and don't want to make a
+  // new entity every time.
+  //
+  // **WARNING**: This does no checks, if you provide it an invalid entity it will use it
+  //
+  // ```ts
+  // const REUSABLE_ENTITY = new Entity(entityHandle);
+  //
+  // onNet("entityHandler", (entNetId: number) => {
+  //  // if no net entity we should ignore
+  //  const entId = NetworkGetEntityFromNetworkId(entNetId);
+  //  if (entId === 0) return;
+  //
+  //  // Reuse our entity so we don't have to initialize a new one
+  //  REUSABLE_ENTITY.replaceHandle(entId);
+  //  // Do something with REUSABLE_ENTITY entity
+  // })
+  // ```
+  replaceHandle(newHandle) {
+    this.handle = newHandle;
+  }
+  static fromNetworkId(networkId) {
+    const ent = NetworkGetEntityFromNetworkId(networkId);
+    if (ent === 0) return null;
+    return new BaseEntity(ent);
+  }
+  static fromStateBagName(stateBagName) {
+    const ent = GetEntityFromStateBagName(stateBagName);
+    if (ent === 0) return null;
+    return new BaseEntity(ent);
+  }
+  get State() {
+    return cfx.Entity(this.handle).state;
+  }
+  get Handle() {
+    return this.handle;
+  }
+  get Owner() {
+    return NetworkGetEntityOwner(this.handle);
+  }
+  get FirstOwner() {
+    return NetworkGetFirstEntityOwner(this.handle);
+  }
+  get Exists() {
+    return this.handle !== 0 && DoesEntityExist(this.handle);
+  }
+  /**
+   * @returns the entity that the calling entity is attached to, or null if
+   * there is none
+   */
+  get AttachedTo() {
+    const ent = GetEntityAttachedTo(this.handle);
+    if (ent === 0) return null;
+    return new BaseEntity(ent);
+  }
+  get Position() {
+    return Vector3.fromArray(GetEntityCoords(this.handle));
+  }
+  get Heading() {
+    return GetEntityHeading(this.handle);
+  }
+  get PositionAndHeading() {
+    return Vector4.fromArray([...GetEntityCoords(this.handle), GetEntityHeading(this.handle)]);
+  }
+  get Health() {
+    return GetEntityHealth(this.handle);
+  }
+  get MaxHealth() {
+    return GetEntityMaxHealth(this.handle);
+  }
+  get Model() {
+    return GetEntityModel(this.handle);
+  }
+  get PopulationType() {
+    return GetEntityPopulationType(this.handle);
+  }
+  get Rotation() {
+    return Vector3.fromArray(GetEntityRotation(this.handle));
+  }
+  get RotationVelocity() {
+    return Vector3.fromArray(GetEntityRotationVelocity(this.handle));
+  }
+  get RoutingBucket() {
+    return GetEntityRoutingBucket(this.handle);
+  }
+  /**
+   * @returns The script that made the entity
+   */
+  get Script() {
+    return GetEntityScript(this.handle);
+  }
+  get Speed() {
+    return GetEntitySpeed(this.handle);
+  }
+  get Type() {
+    return GetEntityType(this.handle);
+  }
+  /**
+   * @returns the entitys velocity, if the entity is a ped it will return Vector3(0, 0, 0)
+   */
+  get Velocity() {
+    return Vector3.fromArray(GetEntityVelocity(this.handle));
+  }
+  get IsVisible() {
+    return IsEntityVisible(this.handle);
+  }
+  get NetworkId() {
+    return NetworkGetNetworkIdFromEntity(this.handle);
+  }
+  get IsNoLongerNeeded() {
+    return HasEntityBeenMarkedAsNoLongerNeeded(this.handle);
+  }
+  get OrphanMode() {
+    return GetEntityOrphanMode(this.Handle);
+  }
+  set OrphanMode(orphanMode) {
+    SetEntityOrphanMode(this.Handle, orphanMode);
+  }
+  delete() {
+    if (this.Exists) {
+      DeleteEntity(this.handle);
+    }
+  }
+}
+export {
+  BaseEntity
+};

package/entities/Entity.js

@@ -0,0 +1,20 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { BaseEntity } from "./BaseEntity";
+class Entity extends BaseEntity {
+  static {
+    __name(this, "Entity");
+  }
+  constructor(handle) {
+    super(handle);
+  }
+  static fromNetworkId(netId) {
+    return new Entity(NetworkGetEntityFromNetworkId(netId));
+  }
+  static fromHandle(handle) {
+    return new Entity(handle);
+  }
+}
+export {
+  Entity
+};

package/entities/Ped.d.ts

@@ -1,4 +1,4 @@
-import { ClassTypes } from "../../common/utils/ClassTypes";
+import { ClassTypes } from "../common/utils/ClassTypes";
 import type { Hash } from "../type/Hash";
 import { BaseEntity } from "./BaseEntity";
 import { Vehicle } from "./Vehicle";

package/entities/Ped.js

@@ -0,0 +1,85 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { BaseEntity } from "./BaseEntity";
+import { Vehicle } from "./Vehicle";
+class Ped extends BaseEntity {
+  static {
+    __name(this, "Ped");
+  }
+  type = ClassTypes.Ped;
+  constructor(handle) {
+    super(handle);
+  }
+  /**
+   * Get an interable list of peds currently on the server
+   * @returns Iterable list of Peds.
+   */
+  static *AllPeds() {
+    for (const pedId of GetAllPeds()) {
+      yield new Ped(pedId);
+    }
+  }
+  static fromNetworkId(netId) {
+    const ent = NetworkGetEntityFromNetworkId(netId);
+    if (ent === 0) return null;
+    return new Ped(ent);
+  }
+  static fromStateBagName(stateBagName) {
+    const handle = GetEntityFromStateBagName(stateBagName);
+    if (handle === 0) return null;
+    return new Ped(handle);
+  }
+  static fromSource(source) {
+    return new Ped(GetPlayerPed(source));
+  }
+  get Armour() {
+    return GetPedArmour(this.handle);
+  }
+  get CauseOfDeath() {
+    return GetPedCauseOfDeath(this.handle);
+  }
+  get DesiredHeading() {
+    return GetPedDesiredHeading(this.handle);
+  }
+  get MaxHealth() {
+    return GetPedMaxHealth(this.handle);
+  }
+  get TaskCommand() {
+    return GetPedScriptTaskCommand(this.handle);
+  }
+  get TaskStage() {
+    return GetPedScriptTaskStage(this.handle);
+  }
+  get LastSourceOfDamage() {
+    return GetPedSourceOfDamage(this.handle);
+  }
+  get DeathCause() {
+    return GetPedCauseOfDeath(this.handle);
+  }
+  get Weapon() {
+    return GetSelectedPedWeapon(this.handle);
+  }
+  /**
+   * @returns the current vehicle the ped is in, or null if it doesn't exist
+   */
+  get CurrentVehicle() {
+    const vehicle = GetVehiclePedIsIn(this.handle, false);
+    if (vehicle === 0) return null;
+    return new Vehicle(vehicle);
+  }
+  get LastVehicle() {
+    const vehicle = GetVehiclePedIsIn(this.handle, false);
+    if (vehicle === 0) return null;
+    return new Vehicle(GetVehiclePedIsIn(this.handle, true));
+  }
+  get IsPlayer() {
+    return IsPedAPlayer(this.handle);
+  }
+  getSpecificTaskType(index) {
+    return GetPedSpecificTaskType(this.handle, index);
+  }
+}
+export {
+  Ped
+};

package/entities/Player.d.ts

@@ -1,6 +1,6 @@
 import { ClassTypes } from "../../common/utils/ClassTypes";
-import { Vector3 } from "../utils";
 import { Ped } from "./Ped";
+import { Vector3 } from "../common/utils/Vector";
 export declare class Player {
     private readonly source;
     protected type: ClassTypes;

package/entities/Player.js

@@ -0,0 +1,143 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import cfx from "../cfx";
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { Ped } from "./Ped";
+import { cleanPlayerName } from "../common/utils/cleanPlayerName";
+import { Vector3 } from "../common/utils/Vector";
+class Player {
+  constructor(source) {
+    this.source = source;
+  }
+  static {
+    __name(this, "Player");
+  }
+  type = ClassTypes.Player;
+  /**
+   * Get an interable list of players currently on the server
+   * @returns Iterable list of Players.
+   */
+  static *AllPlayers() {
+    const num = GetNumPlayerIndices();
+    for (let i = 0; i < num; i++) {
+      yield new Player(Number.parseInt(GetPlayerFromIndex(i)));
+    }
+  }
+  get Exists() {
+    return this.source !== 0;
+  }
+  get Source() {
+    return this.source;
+  }
+  get State() {
+    return cfx.Player(this.source).state;
+  }
+  /**
+   * Returns the player source casted as a string
+   */
+  get Src() {
+    return this.source;
+  }
+  get Ped() {
+    return new Ped(GetPlayerPed(this.Src));
+  }
+  get Tokens() {
+    return getPlayerTokens(this.source);
+  }
+  get Identifiers() {
+    return getPlayerIdentifiers(this.source);
+  }
+  get Endpoint() {
+    return GetPlayerEndpoint(this.Src);
+  }
+  get CamerRotation() {
+    return Vector3.fromArray(GetPlayerCameraRotation(this.Src));
+  }
+  /**
+   * Returns the time since the last player UDP message
+   */
+  get LastMessage() {
+    return GetPlayerLastMsg(this.Src);
+  }
+  get MaxArmour() {
+    return GetPlayerMaxArmour(this.Src);
+  }
+  get MaxHealth() {
+    return GetPlayerMaxHealth(this.Src);
+  }
+  get MeleeModifier() {
+    return GetPlayerMeleeWeaponDamageModifier(this.Src);
+  }
+  /**
+   * @returns the players name
+   */
+  get Name() {
+    return GetPlayerName(this.Src);
+  }
+  /**
+   * @returns the players name with any color code unicode, etc removed, this can lead to there being no name at all
+   */
+  filteredName() {
+    return cleanPlayerName(this.Name);
+  }
+  /**
+   * @returns the players round trip ping
+   */
+  get Ping() {
+    return GetPlayerPing(this.Src);
+  }
+  /**
+   * @returns the current routhing bucket the player is in, default is 0
+   */
+  get RoutingBucket() {
+    return GetPlayerRoutingBucket(this.Src);
+  }
+  get Team() {
+    return GetPlayerTeam(this.Src);
+  }
+  get WantedPosition() {
+    return Vector3.fromArray(GetPlayerWantedCentrePosition(this.Src));
+  }
+  get WantedLevel() {
+    return GetPlayerWantedLevel(this.Src);
+  }
+  get IsEvadingWanted() {
+    return IsPlayerEvadingWantedLevel(this.Src);
+  }
+  get WeaponDamageModifier() {
+    return GetPlayerWeaponDamageModifier(this.Src);
+  }
+  get WeaponDefenseModifier() {
+    return GetPlayerWeaponDefenseModifier(this.Src);
+  }
+  get WeaponDefenseModifier2() {
+    return GetPlayerWeaponDefenseModifier_2(this.Src);
+  }
+  get AirDragMultiplier() {
+    return GetAirDragMultiplierForPlayersVehicle(this.Src);
+  }
+  get IsUsingSuperJump() {
+    return IsPlayerUsingSuperJump(this.Src);
+  }
+  get IsMuted() {
+    return MumbleIsPlayerMuted(this.source);
+  }
+  set IsMuted(isMuted) {
+    MumbleSetPlayerMuted(this.source, isMuted);
+  }
+  isAceAllowed(object) {
+    return IsPlayerAceAllowed(this.Src, object);
+  }
+  timeInPersuit(lastPursuit = false) {
+    return GetPlayerTimeInPursuit(this.Src, lastPursuit);
+  }
+  drop(reason = "No reason specified") {
+    DropPlayer(this.Src, reason);
+  }
+  emit(eventName, ...args) {
+    TriggerClientEvent(eventName, this.source, ...args);
+  }
+}
+export {
+  Player
+};

package/entities/Prop.d.ts

@@ -1,4 +1,4 @@
-import { ClassTypes } from "../../common/utils/ClassTypes";
+import { ClassTypes } from "../common/utils/ClassTypes";
 import { BaseEntity } from "./BaseEntity";
 export declare class Prop extends BaseEntity {
     protected type: ClassTypes;

package/entities/Prop.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { BaseEntity } from "./BaseEntity";
+class Prop extends BaseEntity {
+  static {
+    __name(this, "Prop");
+  }
+  type = ClassTypes.Prop;
+  constructor(handle) {
+    super(handle);
+  }
+  /**
+   * Get an interable list of props currently on the server
+   * @returns Iterable list of Props.
+   */
+  static *AllProps() {
+    for (const prop of GetAllObjects()) {
+      yield new Prop(prop);
+    }
+  }
+  static fromNetworkId(networkId) {
+    const ent = NetworkGetEntityFromNetworkId(networkId);
+    if (ent === 0) return null;
+    return new Prop(ent);
+  }
+  static fromStateBagName(stateBagName) {
+    const ent = GetEntityFromStateBagName(stateBagName);
+    if (ent === 0) return null;
+    return new Prop(ent);
+  }
+  static fromHandle(handle) {
+    return new Prop(handle);
+  }
+}
+export {
+  Prop
+};

package/entities/Vehicle.d.ts

@@ -1,9 +1,9 @@
-import { ClassTypes } from "../../common/utils/ClassTypes";
+import { Color } from "../common/utils/Color";
 import type { VehicleLockStatus } from "../enum/VehicleLockStatus";
 import type { VehicleType } from "../enum/VehicleType";
 import type { Hash } from "../type/Hash";
-import { Color } from "../utils";
 import { BaseEntity } from "./BaseEntity";
+import { ClassTypes } from "../common/utils/ClassTypes";
 export declare class Vehicle extends BaseEntity {
     protected type: ClassTypes;
     constructor(handle: number);

package/entities/Vehicle.js

@@ -0,0 +1,181 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Color } from "../common/utils/Color";
+import { BaseEntity } from "./BaseEntity";
+import { ClassTypes } from "../common/utils/ClassTypes";
+class Vehicle extends BaseEntity {
+  static {
+    __name(this, "Vehicle");
+  }
+  type = ClassTypes.Vehicle;
+  constructor(handle) {
+    super(handle);
+  }
+  /**
+   * Get an interable list of vehicles currently on the server
+   * @returns Iterable list of Vehicles.
+   */
+  static *AllVehicles() {
+    for (const veh of GetAllVehicles()) {
+      yield new Vehicle(veh);
+    }
+  }
+  static fromNetworkId(networkId) {
+    const ent = NetworkGetEntityFromNetworkId(networkId);
+    if (ent === 0) return null;
+    return new Vehicle(ent);
+  }
+  static fromStateBagName(stateBageName) {
+    const ent = GetEntityFromStateBagName(stateBageName);
+    if (ent === 0) return null;
+    return new Vehicle(ent);
+  }
+  get IsEngineRunning() {
+    return GetIsVehicleEngineRunning(this.handle);
+  }
+  get IsPrimaryColourCustom() {
+    return GetIsVehiclePrimaryColourCustom(this.handle);
+  }
+  get IsSecondaryColourCustom() {
+    return GetIsVehicleSecondaryColourCustom(this.handle);
+  }
+  get BodyHealth() {
+    return GetVehicleBodyHealth(this.handle);
+  }
+  get VehicleColours() {
+    return GetVehicleColours(this.handle);
+  }
+  get CustomPrimaryColour() {
+    return Color.fromArray(GetVehicleCustomPrimaryColour(this.handle));
+  }
+  get CustomSecondaryColour() {
+    return Color.fromArray(GetVehicleCustomSecondaryColour(this.handle));
+  }
+  get DashboardColour() {
+    return GetVehicleDashboardColour(this.handle);
+  }
+  get DirtLevel() {
+    return GetVehicleDirtLevel(this.handle);
+  }
+  get LockStatus() {
+    return GetVehicleDoorLockStatus(this.handle);
+  }
+  getDoorStatus(doorIndex) {
+    return GetVehicleDoorStatus(this.handle, doorIndex);
+  }
+  get DoorsLockedForPlayer() {
+    return GetVehicleDoorsLockedForPlayer(this.handle);
+  }
+  get EngineHealth() {
+    return GetVehicleEngineHealth(this.handle);
+  }
+  get ExtraColours() {
+    return GetVehicleExtraColours(this.handle);
+  }
+  get FlightNozzlePosition() {
+    return GetVehicleFlightNozzlePosition(this.handle);
+  }
+  get Handbrake() {
+    return GetVehicleHandbrake(this.handle);
+  }
+  get HeadlightsColour() {
+    return GetVehicleHeadlightsColour(this.handle);
+  }
+  get HomingLockonState() {
+    return GetVehicleHomingLockonState(this.handle);
+  }
+  get InteriorColour() {
+    return GetVehicleInteriorColour(this.handle);
+  }
+  get LightsState() {
+    const [_, lightsOn, highbeansOn] = GetVehicleLightsState(this.handle);
+    return [lightsOn, highbeansOn];
+  }
+  get Livery() {
+    return GetVehicleLivery(this.handle);
+  }
+  get LockOnTarget() {
+    return new Vehicle(GetVehicleLockOnTarget(this.handle));
+  }
+  get Plate() {
+    return GetVehicleNumberPlateText(this.handle);
+  }
+  get PlateTrimmed() {
+    return this.Plate.trim();
+  }
+  get PlateIndex() {
+    return GetVehicleNumberPlateTextIndex(this.handle);
+  }
+  get PetrolTankHealth() {
+    return GetVehiclePetrolTankHealth(this.handle);
+  }
+  get RadioStation() {
+    return GetVehicleRadioStationIndex(this.handle);
+  }
+  get RoofLivery() {
+    return GetVehicleRoofLivery(this.handle);
+  }
+  get SteeringAngle() {
+    return GetVehicleSteeringAngle(this.handle);
+  }
+  get VehicleType() {
+    return GetVehicleType(this.handle);
+  }
+  get TyreSmokeColour() {
+    return Color.fromArray(GetVehicleTyreSmokeColor(this.handle));
+  }
+  get WheelType() {
+    return GetVehicleWheelType(this.handle);
+  }
+  get WindowTint() {
+    return GetVehicleWindowTint(this.handle);
+  }
+  get HasBeenOwnedByPlayer() {
+    return HasVehicleBeenOwnedByPlayer(this.handle);
+  }
+  get IsEngineStarting() {
+    return IsVehicleEngineStarting(this.handle);
+  }
+  get IsSirenOn() {
+    return IsVehicleSirenOn(this.handle);
+  }
+  get MaxHealth() {
+    return GetEntityMaxHealth(this.handle);
+  }
+  get ScriptTaskCommand() {
+    return GetPedScriptTaskCommand(this.handle);
+  }
+  get ScriptTaskStage() {
+    return GetPedScriptTaskStage(this.handle);
+  }
+  get MainRotorHealth() {
+    return GetHeliMainRotorHealth(this.handle);
+  }
+  get TailRotorHealth() {
+    return GetHeliTailRotorHealth(this.handle);
+  }
+  /**
+   * This might supposed to be TrainEngineHealth?
+   */
+  get TrainCarriageEngine() {
+    return GetTrainCarriageEngine(this.handle);
+  }
+  get TrainCarriageIndex() {
+    return GetTrainCarriageIndex(this.handle);
+  }
+  isTyreBurst(wheelId, completely) {
+    return IsVehicleTyreBurst(this.handle, wheelId, completely);
+  }
+  isExtraTurnedOn(extraId) {
+    return IsVehicleExtraTurnedOn(this.handle, extraId);
+  }
+  getPedInSeat(seatIndex) {
+    return GetPedInVehicleSeat(this.handle, seatIndex);
+  }
+  getLastPedInSeat(seatIndex) {
+    return GetLastPedInVehicleSeat(this.handle, seatIndex);
+  }
+}
+export {
+  Vehicle
+};

package/enum/OrphanMode.js

@@ -0,0 +1,9 @@
+var OrphanMode = /* @__PURE__ */ ((OrphanMode2) => {
+  OrphanMode2[OrphanMode2["DeleteWhenNotRelevant"] = 0] = "DeleteWhenNotRelevant";
+  OrphanMode2[OrphanMode2["DeleteOnOwnerDisconnect"] = 1] = "DeleteOnOwnerDisconnect";
+  OrphanMode2[OrphanMode2["KeepEntity"] = 2] = "KeepEntity";
+  return OrphanMode2;
+})(OrphanMode || {});
+export {
+  OrphanMode
+};

package/enum/PopulationType.js

@@ -0,0 +1,17 @@
+var PopulationType = /* @__PURE__ */ ((PopulationType2) => {
+  PopulationType2[PopulationType2["Unknown"] = 0] = "Unknown";
+  PopulationType2[PopulationType2["RandomPermanent"] = 1] = "RandomPermanent";
+  PopulationType2[PopulationType2["RandomParked"] = 2] = "RandomParked";
+  PopulationType2[PopulationType2["Randompatrol"] = 3] = "Randompatrol";
+  PopulationType2[PopulationType2["RandomScenario"] = 4] = "RandomScenario";
+  PopulationType2[PopulationType2["RandomAmbient"] = 5] = "RandomAmbient";
+  PopulationType2[PopulationType2["Permanent"] = 6] = "Permanent";
+  PopulationType2[PopulationType2["Mission"] = 7] = "Mission";
+  PopulationType2[PopulationType2["Replay"] = 8] = "Replay";
+  PopulationType2[PopulationType2["Cache"] = 9] = "Cache";
+  PopulationType2[PopulationType2["Tool"] = 10] = "Tool";
+  return PopulationType2;
+})(PopulationType || {});
+export {
+  PopulationType
+};

package/enum/VehicleLockStatus.js

@@ -0,0 +1,13 @@
+var VehicleLockStatus = /* @__PURE__ */ ((VehicleLockStatus2) => {
+  VehicleLockStatus2[VehicleLockStatus2["None"] = 0] = "None";
+  VehicleLockStatus2[VehicleLockStatus2["Locked"] = 2] = "Locked";
+  VehicleLockStatus2[VehicleLockStatus2["LockedForPlayer"] = 3] = "LockedForPlayer";
+  VehicleLockStatus2[VehicleLockStatus2["StickPlayerInside"] = 4] = "StickPlayerInside";
+  VehicleLockStatus2[VehicleLockStatus2["CanBeBrokenInto"] = 7] = "CanBeBrokenInto";
+  VehicleLockStatus2[VehicleLockStatus2["CanBeBrokenIntoPersist"] = 8] = "CanBeBrokenIntoPersist";
+  VehicleLockStatus2[VehicleLockStatus2["CannotBeTriedToEnter"] = 10] = "CannotBeTriedToEnter";
+  return VehicleLockStatus2;
+})(VehicleLockStatus || {});
+export {
+  VehicleLockStatus
+};