@nativewrappers/fivem 0.0.1

package/lib/client/models/PedBoneCollection.js

@@ -0,0 +1,19 @@
+import { EntityBoneCollection, PedBone } from './';
+export class PedBoneCollection extends EntityBoneCollection {
+    constructor(owner) {
+        super(owner);
+    }
+    get Core() {
+        return new PedBone(this.owner, -1);
+    }
+    get LastDamaged() {
+        const [, outBone] = GetPedLastDamageBone(this.owner.Handle, 0);
+        return PedBone[outBone];
+    }
+    clearLastDamaged() {
+        ClearPedLastDamageBone(this.owner.Handle);
+    }
+    getBone(boneIndex, boneName) {
+        return new PedBone(this.owner, boneIndex ? boneIndex : GetEntityBoneIndexByName(this.owner.Handle, boneName ?? ''));
+    }
+}

package/lib/client/models/Player.d.ts

@@ -0,0 +1,63 @@
+/// <reference types="@citizenfx/client" />
+import { Prop, Vehicle, Model, Color } from '..';
+import { StateBagChangeHandler } from '../cfx';
+import { Ped } from './';
+export declare class Player {
+    private handle;
+    private ped;
+    private pvp;
+    private stateBagCookies;
+    private source;
+    private type;
+    static fromPedHandle(handle: number): Player;
+    static fromServerId(serverId: number): Player;
+    /**
+     * @param handle the player handle, or if on the server, their source.
+     */
+    constructor(handle?: number);
+    get Handle(): number;
+    /**
+     * This is here for compatibility with older versions.
+     */
+    get Character(): Ped;
+    get Ped(): Ped;
+    get ServerId(): number;
+    get State(): StateBagInterface;
+    AddStateBagChangeHandler(keyFilter: string | null, handler: StateBagChangeHandler): number;
+    /**
+     * A short hand function for AddStateBagChangeHandler, this gets automatically cleaned up on entity deletion.
+     * @param keyFilter the key to filter for or null
+     * @param handler the function to handle the change
+     * @returns a cookie to be used in RemoveStateBagChangeHandler
+     */
+    listenForStateChange(keyFilter: string | null, handler: StateBagChangeHandler): number;
+    removeStateListener(tgtCookie: number): void;
+    removeAllStateListeners(): void;
+    get Name(): string;
+    get PvPEnabled(): boolean;
+    set PvPEnabled(value: boolean);
+    get IsDead(): boolean;
+    get EntityPlayerIsAimingAt(): Ped | Vehicle | Prop | null;
+    get StealthNoise(): number;
+    get FakeWantedLevel(): number;
+    get PlayerGroup(): number;
+    get HasReserveParachute(): boolean;
+    get HealthRechargeLimit(): number;
+    get IsInvincible(): boolean;
+    get MaxArmor(): number;
+    get ParachuteModelOverride(): Model;
+    get ParachutePackTintIndex(): number;
+    get ParachuteTintIndex(): number;
+    get ParachuteColorTrailColor(): Color;
+    get ReserveParachuteModelOverride(): Model;
+    get ReserveParachuteTintIndex(): number;
+    get PlayerRgbColour(): Color;
+    get Stamina(): number;
+    get SprintTimeRemaining(): number;
+    /**
+     * The players melee target?
+     */
+    get TargetEntity(): Ped | Vehicle | Prop | null;
+    get Team(): number;
+    CanPedHearPlayer(ped: Ped): boolean;
+}

package/lib/client/models/Player.js

@@ -0,0 +1,174 @@
+import { Entity, Model, Color } from '..';
+import cfx from '../cfx';
+import { ClassTypes } from '../enums/ClassTypes';
+import { Ped } from './';
+export class Player {
+    static fromPedHandle(handle) {
+        return new Player(NetworkGetPlayerIndexFromPed(handle));
+    }
+    static fromServerId(serverId) {
+        return new Player(GetPlayerFromServerId(serverId));
+    }
+    /**
+     * @param handle the player handle, or if on the server, their source.
+     */
+    constructor(handle = -1) {
+        this.pvp = false;
+        this.stateBagCookies = [];
+        this.type = ClassTypes.Player;
+        this.handle = handle;
+        this.source = this.ServerId;
+        if (!IsDuplicityVersion()) {
+            this.PvPEnabled = true;
+        }
+    }
+    get Handle() {
+        return this.handle;
+    }
+    /**
+     * This is here for compatibility with older versions.
+     */
+    get Character() {
+        return this.Ped;
+    }
+    get Ped() {
+        const handle = GetPlayerPed(this.handle);
+        if (typeof this.ped === 'undefined' || handle !== this.ped.Handle) {
+            this.ped = new Ped(handle);
+        }
+        return this.ped;
+    }
+    get ServerId() {
+        if (this.source) {
+            return this.source;
+        }
+        return GetPlayerServerId(this.handle);
+    }
+    get State() {
+        return cfx.Player(this.ServerId).state;
+    }
+    AddStateBagChangeHandler(keyFilter, handler) {
+        // keyFilter is casted to any because it can take a null value.
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        const cookie = AddStateBagChangeHandler(keyFilter, `player:${this.ServerId}`, handler);
+        this.stateBagCookies.push(cookie);
+        return cookie;
+    }
+    /**
+     * A short hand function for AddStateBagChangeHandler, this gets automatically cleaned up on entity deletion.
+     * @param keyFilter the key to filter for or null
+     * @param handler the function to handle the change
+     * @returns a cookie to be used in RemoveStateBagChangeHandler
+     */
+    listenForStateChange(keyFilter, handler) {
+        return this.AddStateBagChangeHandler(keyFilter, handler);
+    }
+    removeStateListener(tgtCookie) {
+        this.stateBagCookies = this.stateBagCookies.filter(cookie => {
+            const isCookie = cookie == tgtCookie;
+            if (isCookie)
+                RemoveStateBagChangeHandler(cookie);
+            return isCookie;
+        });
+    }
+    removeAllStateListeners() {
+        for (const cookie of this.stateBagCookies) {
+            RemoveStateBagChangeHandler(cookie);
+        }
+    }
+    get Name() {
+        return GetPlayerName(this.handle);
+    }
+    get PvPEnabled() {
+        return this.pvp;
+    }
+    set PvPEnabled(value) {
+        NetworkSetFriendlyFireOption(value);
+        SetCanAttackFriendly(this.Character.Handle, value, value);
+        this.pvp = value;
+    }
+    get IsDead() {
+        return IsPlayerDead(this.handle);
+    }
+    // Should this even be here?
+    // public set DisableFiring(value: boolean) {
+    //   DisablePlayerFiring(this.handle, value);
+    // }
+    get EntityPlayerIsAimingAt() {
+        const [entityHit, entity] = GetEntityPlayerIsFreeAimingAt(this.handle);
+        if (entityHit) {
+            return Entity.fromHandle(entity);
+        }
+        return null;
+    }
+    get StealthNoise() {
+        return GetPlayerCurrentStealthNoise(this.handle);
+    }
+    get FakeWantedLevel() {
+        return GetPlayerFakeWantedLevel(this.handle);
+    }
+    get PlayerGroup() {
+        return GetPlayerGroup(this.handle);
+    }
+    get HasReserveParachute() {
+        return GetPlayerHasReserveParachute(this.handle);
+    }
+    get HealthRechargeLimit() {
+        return GetPlayerHealthRechargeLimit(this.handle);
+    }
+    get IsInvincible() {
+        if (IsDuplicityVersion()) {
+            return GetPlayerInvincible(this.handle);
+        }
+        else {
+            return GetPlayerInvincible_2(this.handle);
+        }
+    }
+    get MaxArmor() {
+        return GetPlayerMaxArmour(this.handle);
+    }
+    get ParachuteModelOverride() {
+        return new Model(GetPlayerParachuteModelOverride(this.handle));
+    }
+    get ParachutePackTintIndex() {
+        return GetPlayerParachutePackTintIndex(this.handle);
+    }
+    get ParachuteTintIndex() {
+        return GetPlayerParachuteTintIndex(this.handle);
+    }
+    get ParachuteColorTrailColor() {
+        return Color.fromArray(GetPlayerParachuteSmokeTrailColor(this.handle));
+    }
+    get ReserveParachuteModelOverride() {
+        return new Model(GetPlayerReserveParachuteModelOverride(this.handle));
+    }
+    get ReserveParachuteTintIndex() {
+        return GetPlayerReserveParachuteTintIndex(this.handle);
+    }
+    get PlayerRgbColour() {
+        return Color.fromArray(GetPlayerRgbColour(this.handle));
+    }
+    get Stamina() {
+        return GetPlayerSprintStaminaRemaining(this.handle);
+    }
+    get SprintTimeRemaining() {
+        return GetPlayerSprintStaminaRemaining(this.handle);
+    }
+    /**
+     * The players melee target?
+     */
+    get TargetEntity() {
+        const [entityHit, entity] = GetPlayerTargetEntity(this.handle);
+        if (entityHit) {
+            return Entity.fromHandle(entity);
+        }
+        return null;
+    }
+    get Team() {
+        return GetPlayerTeam(this.handle);
+    }
+    // GetPlayerUnderwaterTimeRemaining
+    CanPedHearPlayer(ped) {
+        return CanPedHearPlayer(this.handle, ped.Handle);
+    }
+}

package/lib/client/models/Prop.d.ts

@@ -0,0 +1,11 @@
+import { ClassTypes } from '../enums/ClassTypes';
+import { BaseEntity } from './BaseEntity';
+export declare class Prop extends BaseEntity {
+    static exists(prop: Prop): boolean;
+    static fromHandle(handle: number): Prop | null;
+    static fromNetworkId(networkId: number, errorOnInvalid?: boolean): Prop | null;
+    protected type: ClassTypes;
+    constructor(handle: number);
+    exists(): boolean;
+    placeOnGround(): void;
+}

package/lib/client/models/Prop.js

@@ -0,0 +1,26 @@
+import { ClassTypes } from '../enums/ClassTypes';
+import { BaseEntity } from './BaseEntity';
+export class Prop extends BaseEntity {
+    static exists(prop) {
+        return typeof prop !== 'undefined' && prop.exists();
+    }
+    static fromHandle(handle) {
+        return new Prop(handle);
+    }
+    static fromNetworkId(networkId, errorOnInvalid = false) {
+        if (errorOnInvalid && NetworkDoesEntityExistWithNetworkId(networkId)) {
+            throw new Error(`Entity with ${networkId} doesn't exist`);
+        }
+        return new Prop(NetworkGetEntityFromNetworkId(networkId));
+    }
+    constructor(handle) {
+        super(handle);
+        this.type = ClassTypes.Prop;
+    }
+    exists() {
+        return super.exists() && GetEntityType(this.handle) === 3;
+    }
+    placeOnGround() {
+        PlaceObjectOnGroundProperly(this.handle);
+    }
+}

package/lib/client/models/Vehicle.d.ts

@@ -0,0 +1,171 @@
+import { Ped, VehicleDoorCollection, VehicleModCollection, VehicleWheelCollection, VehicleWindowCollection } from './';
+import { RadioStation, VehicleClass, VehicleLandingGearState, VehicleLockStatus, VehicleRoofState, VehicleSeat } from '../enums';
+import { Model } from '../Model';
+import { Vector3 } from '../utils';
+import { ClassTypes } from '../enums/ClassTypes';
+import { BaseEntity } from './BaseEntity';
+export declare class Vehicle extends BaseEntity {
+    static getModelDisplayName(vehicleModel: Model): string;
+    static getModelClass(vehicleModel: Model): VehicleClass;
+    static getClassDisplayName(vehicleClass: VehicleClass): string;
+    static exists(vehicle: Vehicle): boolean;
+    static fromHandle(handle: number): Vehicle | null;
+    static fromNetworkId(networkId: number, errorOnInvalid?: boolean): Vehicle | null;
+    private _doors;
+    private _mods;
+    private _wheels;
+    private _windows;
+    protected type: ClassTypes;
+    constructor(handle: number);
+    exists(): boolean;
+    get DisplayName(): string;
+    get ClassDisplayName(): string;
+    get NumberPlate(): string;
+    set NumberPlate(value: string);
+    get ClassType(): VehicleClass;
+    get BodyHealth(): number;
+    set BodyHealth(value: number);
+    get EngineHealth(): number;
+    set EngineHealth(value: number);
+    get PetrolTankHealth(): number;
+    set PetrolTankHealth(value: number);
+    get FuelLevel(): number;
+    set FuelLevel(value: number);
+    get OilLevel(): number;
+    set OilLevel(value: number);
+    get Gravity(): number;
+    set Gravity(value: number);
+    get IsEngineRunning(): boolean;
+    set IsEngineRunning(value: boolean);
+    get IsEngineStarting(): boolean;
+    set IsEngineStarting(value: boolean);
+    get IsRadioEnabled(): boolean;
+    set IsRadioEnabled(value: boolean);
+    set RadioStation(value: RadioStation);
+    set Speed(value: number);
+    get WheelSpeed(): number;
+    get EstimatedMaxSpeed(): number;
+    get Acceleration(): number;
+    get CurrentRPM(): number;
+    set CurrentRPM(value: number);
+    get HighGear(): number;
+    set HighGear(value: number);
+    get CurrentGear(): number;
+    get SteeringAngle(): number;
+    set SteeringAngle(value: number);
+    get SteeringScale(): number;
+    set SteeringScale(value: number);
+    get IsAlarmSet(): boolean;
+    set IsAlarmSet(value: boolean);
+    get IsAlarmSounding(): boolean;
+    get AlarmTimeLeft(): number;
+    set AlarmTimeLeft(value: number);
+    startAlarm(): void;
+    get IsSirenActive(): boolean;
+    set IsSirenActive(value: boolean);
+    set HasMutedSirens(value: boolean);
+    /**
+     * @deprecated use {@HasMutedSirens} instead.
+     */
+    set IsSirenSilent(value: boolean);
+    soundHorn(duration: number): void;
+    get IsWanted(): boolean;
+    set IsWanted(value: boolean);
+    set ProvidesCover(value: boolean);
+    set DropsMoneyOnExplosion(value: boolean);
+    get PreviouslyOwnedByPlayer(): boolean;
+    set PreviouslyOwnedByPlayer(value: boolean);
+    get NeedsToBeHotwired(): boolean;
+    set NeedsToBeHotwired(value: boolean);
+    get AreLightsOn(): boolean;
+    set AreLightsOn(value: boolean);
+    get AreHighBeamsOn(): boolean;
+    set AreHighBeamsOn(value: boolean);
+    get IsInteriorLightOn(): boolean;
+    set IsInteriorLightOn(value: boolean);
+    get IsSearchLightOn(): boolean;
+    set IsSearchLightOn(value: boolean);
+    get IsTaxiLightOn(): boolean;
+    set IsTaxiLightOn(value: boolean);
+    get IsLeftIndicatorLightOn(): boolean;
+    set IsLeftIndicatorLightOn(value: boolean);
+    get IsRightIndicatorLightOn(): boolean;
+    set IsRightIndicatorLightOn(value: boolean);
+    get IsHandbrakeForcedOn(): boolean;
+    set IsHandbrakeForcedOn(value: boolean);
+    set AreBrakeLightsOn(value: boolean);
+    set LightsMultiplier(value: number);
+    set CanBeVisiblyDamaged(value: boolean);
+    set Strong(toggle: boolean);
+    set CanBreak(toggle: boolean);
+    get IsDamaged(): boolean;
+    get IsDriveable(): boolean;
+    set IsDriveable(value: boolean);
+    get IsEngineOnFire(): boolean;
+    get HasRoof(): boolean;
+    get IsLeftHeadLightBroken(): boolean;
+    get IsRightHeadLightBroken(): boolean;
+    get IsRearBumperBrokenOff(): boolean;
+    get IsFrontBumperBrokenOff(): boolean;
+    set IsAxlesStrong(value: boolean);
+    set CanEngineDegrade(value: boolean);
+    set EnginePowerMultiplier(value: number);
+    set EngineTorqueMultiplier(value: number);
+    get LandingGearState(): VehicleLandingGearState;
+    set LandingGearState(value: VehicleLandingGearState);
+    get RoofState(): VehicleRoofState;
+    set RoofState(value: VehicleRoofState);
+    get LockStatus(): VehicleLockStatus;
+    set LockStatus(value: VehicleLockStatus);
+    get MaxBraking(): number;
+    get MaxTraction(): number;
+    get IsOnAllWheels(): boolean;
+    get IsStopped(): boolean;
+    get IsStoppedAtTrafficLights(): boolean;
+    get IsStolen(): boolean;
+    set IsStolen(value: boolean);
+    get IsConvertible(): boolean;
+    set IsBurnoutForced(value: boolean);
+    get IsInBurnout(): boolean;
+    get Driver(): Ped;
+    get Occupants(): Ped[];
+    get Passengers(): Ped[];
+    get Doors(): VehicleDoorCollection;
+    get Mods(): VehicleModCollection;
+    get Wheels(): VehicleWheelCollection;
+    get Windows(): VehicleWindowCollection;
+    extraExists(extra: number): boolean;
+    isExtraOn(extra: number): boolean;
+    toggleExtra(extra: number, toggle: boolean): void;
+    getPedOnSeat(seat: VehicleSeat): Ped;
+    isSeatFree(seat: VehicleSeat): boolean;
+    wash(): void;
+    get DirtLevel(): number;
+    set DirtLevel(value: number);
+    placeOnGround(): void;
+    repair(): void;
+    explode(): void;
+    explodeNetworked(): void;
+    get CanTiresBurst(): boolean;
+    set CanTiresBurst(value: boolean);
+    set CanWheelsBreak(value: boolean);
+    set CanDeformWheels(value: boolean);
+    get HasBombBay(): boolean;
+    openBombBay(): void;
+    closeBombBay(): void;
+    setHeliYawPitchRollMult(mult: number): void;
+    set TowingCraneRaisedAmount(value: number);
+    get TowedVehicle(): Vehicle;
+    towVehicle(vehicle: Vehicle, rear: boolean): void;
+    detachFromTowTruck(): void;
+    detachTowedVehicle(): void;
+    deform(position: Vector3, damageAmount: number, radius: number): void;
+    get PassengerCapacity(): number;
+    get PassengerCount(): number;
+    set RespotTimer(time: number);
+    getHandlingFloat(fieldName: string): number;
+    setHandlingFloat(fieldName: string, value: number): void;
+    getHandlingInt(fieldName: string): number;
+    setHandlingInt(fieldName: string, value: number): void;
+    getHandlingVector(fieldName: string): Vector3;
+}