rock-mod 0.0.1 → 0.2.0

package/dist/server/entities/altv/player/AltVPlayer.js

@@ -2,30 +2,132 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVPlayer = void 0;
 const AltVEntity_1 = require("../entity/AltVEntity");
+const RockMod_1 = require("../../../RockMod");
+var Player = AltVServer.Player;
+var Vehicle = AltVServer.Vehicle;
+var Vector3 = AltVShared.Vector3;
+var hash = AltVShared.hash;
 class AltVPlayer extends AltVEntity_1.AltVEntity {
-    _name;
-    _socialClub;
-    _health;
     get name() {
-        return this._name;
+        return this.mpEntity.name;
     }
     get socialClub() {
-        return this._socialClub;
+        return this.mpEntity.socialClubName;
+    }
+    get heading() {
+        return this.mpEntity.headRot.z;
     }
     get health() {
-        return this._health;
+        return this.mpEntity.health;
+    }
+    get armour() {
+        return this.mpEntity.armour;
+    }
+    get ip() {
+        return this.mpEntity.ip;
+    }
+    get serial() {
+        return this.mpEntity.hwidHash;
+    }
+    get vehicle() {
+        const mpVehicle = this.mpEntity.vehicle;
+        if (!mpVehicle) {
+            return null;
+        }
+        return RockMod_1.RockMod.instance.vehicles.getByID(mpVehicle.id);
+    }
+    get seat() {
+        return this.mpEntity.seat;
+    }
+    get weapon() {
+        return this.mpEntity.currentWeapon;
+    }
+    get weaponAmmo() {
+        return this.mpEntity.getAmmo(this.weapon);
+    }
+    get eyeColor() {
+        return this.mpEntity.getEyeColor();
+    }
+    get streamedPlayers() {
+        const players = [];
+        for (const { entity } of this.mpEntity.streamedEntities) {
+            if (entity instanceof Player) {
+                players.push(RockMod_1.RockMod.instance.players.getByID(entity.id));
+            }
+        }
+        return players;
     }
     constructor(options) {
         super(options);
-        this._name = options.name;
-        this._socialClub = options.socialClub;
-        this._health = 100;
     }
-    setName(value) {
-        this._name = value;
+    emitEvent(eventName, ...args) {
+        return RockMod_1.RockMod.instance.net.events.emitClient(this, eventName, ...args);
+    }
+    emitRPC(rpcName, ...args) {
+        return RockMod_1.RockMod.instance.net.rpc.emitClient(this, rpcName, ...args);
+    }
+    spawn(position) {
+        return this.mpEntity.spawn(position);
+    }
+    setName(name) {
+        throw new Error(`Not implemented (setName: ${name})`);
+    }
+    setHeading(value) {
+        this.mpEntity.rot = new Vector3(0, 0, value);
     }
     setHealth(value) {
-        this._health = value;
+        this.mpEntity.health = Math.clamp(value, 0, 100);
+    }
+    setArmour(value) {
+        this.mpEntity.armour = Math.clamp(value, 0, 100);
+    }
+    setWeaponAmmo(weapon, ammo) {
+        return this.mpEntity.setWeaponAmmo(weapon, ammo);
+    }
+    giveWeapon(weapon, ammo) {
+        return this.mpEntity.giveWeapon(weapon, ammo, true);
+    }
+    removeWeapon(weapon) {
+        return this.mpEntity.removeWeapon(hash(weapon));
+    }
+    enableVoiceTo(player) {
+        throw new Error(`Not implemented (enableVoiceTo: ${this.id} -> ${player.id})`);
+    }
+    disableVoiceTo(player) {
+        throw new Error(`Not implemented (disableVoiceTo: ${this.id} -> ${player.id})`);
+    }
+    putIntoVehicle(vehicle, seat) {
+        const mpVehicle = Vehicle.getByID(vehicle.id);
+        if (!mpVehicle) {
+            throw new Error(`Multiplayer vehicle with id ${vehicle.id} not found`);
+        }
+        return this.mpEntity.setIntoVehicle(mpVehicle, seat ?? 0);
+    }
+    ejectFromVehicle() {
+        return this.mpEntity.clearTasks();
+    }
+    setCustomization(data) {
+        throw new Error(`Not implemented (setCustomization: ${data})`);
+    }
+    setHeadOverlay(overlayID, index, opacity, firstColor, secondColor) {
+        this.mpEntity.setHeadOverlayColor(overlayID, 1, firstColor, secondColor);
+        this.mpEntity.setHeadOverlay(overlayID, index, opacity);
+    }
+    setEyeColor(colorID) {
+        this.mpEntity.setEyeColor(colorID);
+    }
+    setProp(propID, drawableID, textureID) {
+        this.mpEntity.setProp(propID, drawableID, textureID);
+    }
+    setClothes(componentID, drawableID, textureID, paletteID) {
+        this.mpEntity.setClothes(componentID, drawableID, textureID, paletteID);
+    }
+    setHairColor(colorID, highlightColorID) {
+        this.mpEntity.setHairColor(colorID);
+        this.mpEntity.setHairHighlightColor(highlightColorID);
+    }
+    kick(reason) {
+        return this.mpEntity.kick(reason);
     }
 }
 exports.AltVPlayer = AltVPlayer;

package/dist/server/entities/altv/vehicle/AltVVehicle.d.ts

@@ -1,8 +1,31 @@
-import { AltVEntity } from "../entity/AltVEntity";
-import { IVehicle, IVehicleOptions } from "../../common/vehicle/IVehicle";
-export declare class AltVVehicle extends AltVEntity implements IVehicle {
-    private _bodyHealth;
+import { AltVEntity, IAltVEntityOptions } from "../entity/AltVEntity";
+import { IVehicle } from "../../common/vehicle/IVehicle";
+import Vehicle = AltVServer.Vehicle;
+import { RGBA } from "../../../common/utils";
+import { AltVPlayer } from "../player/AltVPlayer";
+export interface IAltVVehicleOptions extends IAltVEntityOptions<Vehicle> {
+}
+export declare class AltVVehicle extends AltVEntity<Vehicle> implements IVehicle {
     get bodyHealth(): number;
-    constructor(options: IVehicleOptions);
+    get engineHealth(): number;
+    get numberPlate(): string;
+    get isLocked(): boolean;
+    get isDead(): boolean;
+    get primaryColor(): number;
+    get secondaryColor(): number;
+    get customPrimaryColor(): RGBA;
+    get customSecondaryColor(): RGBA;
+    get driver(): AltVPlayer | null;
+    get passengers(): Set<AltVPlayer>;
+    constructor(options: IAltVVehicleOptions);
     setBodyHealth(value: number): void;
+    setEngineHealth(value: number): void;
+    setNumberPlate(value: string): void;
+    setLocked(value: boolean): void;
+    setPrimaryColor(value: number): void;
+    setSecondaryColor(value: number): void;
+    setCustomPrimaryColor(value: RGBA): void;
+    setCustomSecondaryColor(value: RGBA): void;
+    explode(): void;
+    repair(): void;
 }

package/dist/server/entities/altv/vehicle/AltVVehicle.js

@@ -2,17 +2,89 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVVehicle = void 0;
 const AltVEntity_1 = require("../entity/AltVEntity");
+var VehicleLockState = AltVShared.VehicleLockState;
+const utils_1 = require("../../../common/utils");
+const RockMod_1 = require("../../../RockMod");
 class AltVVehicle extends AltVEntity_1.AltVEntity {
-    _bodyHealth;
     get bodyHealth() {
-        return this._bodyHealth;
+        return this.mpEntity.bodyHealth;
+    }
+    get engineHealth() {
+        return this.mpEntity.engineHealth;
+    }
+    get numberPlate() {
+        return this.mpEntity.numberPlateText;
+    }
+    get isLocked() {
+        return this.mpEntity.lockState > 1;
+    }
+    get isDead() {
+        return this.mpEntity.destroyed;
+    }
+    get primaryColor() {
+        return this.mpEntity.primaryColor;
+    }
+    get secondaryColor() {
+        return this.mpEntity.secondaryColor;
+    }
+    get customPrimaryColor() {
+        const { r, g, b, a } = this.mpEntity.customPrimaryColor;
+        return new utils_1.RGBA(r, g, b, a);
+    }
+    get customSecondaryColor() {
+        const { r, g, b, a } = this.mpEntity.customSecondaryColor;
+        return new utils_1.RGBA(r, g, b, a);
+    }
+    get driver() {
+        const mpPlayer = this.mpEntity.driver;
+        if (!mpPlayer) {
+            return null;
+        }
+        return RockMod_1.RockMod.instance.players.getByID(mpPlayer.id);
+    }
+    get passengers() {
+        const players = new Set();
+        for (const mpPlayer of Object.values(this.mpEntity.passengers)) {
+            const player = RockMod_1.RockMod.instance.players.getByID(mpPlayer.id);
+            players.add(player);
+        }
+        return players;
     }
     constructor(options) {
         super(options);
-        this._bodyHealth = 100;
     }
     setBodyHealth(value) {
-        this._bodyHealth = value;
+        this.mpEntity.bodyHealth = value;
+    }
+    setEngineHealth(value) {
+        this.mpEntity.engineHealth = value;
+    }
+    setNumberPlate(value) {
+        this.mpEntity.numberPlateText = value;
+    }
+    setLocked(value) {
+        this.mpEntity.lockState = value ? VehicleLockState.Locked : VehicleLockState.Unlocked;
+    }
+    setPrimaryColor(value) {
+        this.mpEntity.primaryColor = value;
+    }
+    setSecondaryColor(value) {
+        this.mpEntity.secondaryColor = value;
+    }
+    setCustomPrimaryColor(value) {
+        const { r, g, b, a } = value;
+        this.mpEntity.customPrimaryColor = new AltVShared.RGBA(r, g, b, a);
+    }
+    setCustomSecondaryColor(value) {
+        const { r, g, b, a } = value;
+        this.mpEntity.customSecondaryColor = new AltVShared.RGBA(r, g, b, a);
+    }
+    explode() {
+        this.mpEntity.engineHealth = 0;
+        this.mpEntity.bodyHealth = 0;
+    }
+    repair() {
+        return this.mpEntity.repair();
     }
 }
 exports.AltVVehicle = AltVVehicle;

package/dist/server/entities/altv/vehicle/AltVVehiclesManager.d.ts

@@ -1,6 +1,10 @@
 import { AltVEntitiesManager } from "../entity/AltVEntitiesManager";
 import { AltVVehicle } from "./AltVVehicle";
-import { IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+import { IVehicleCreateOptions, IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+import { IVehicle } from "../../common/vehicle/IVehicle";
+export interface IAltVVehicleCreateOptions extends IVehicleCreateOptions {
+}
 export declare class AltVVehiclesManager extends AltVEntitiesManager<AltVVehicle> implements IVehiclesManager {
     constructor();
+    create(options: IAltVVehicleCreateOptions): IVehicle;
 }

package/dist/server/entities/altv/vehicle/AltVVehiclesManager.js

@@ -2,11 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVVehiclesManager = void 0;
 const AltVEntitiesManager_1 = require("../entity/AltVEntitiesManager");
+const AltVVehicle_1 = require("./AltVVehicle");
+var alt = AltVServer;
 class AltVVehiclesManager extends AltVEntitiesManager_1.AltVEntitiesManager {
     constructor() {
         super({
             baseObjectsType: "vehicle",
         });
     }
+    create(options) {
+        const { model, position, dimension, rotation, engine, locked } = options;
+        const mpEntity = new alt.Vehicle(model, position, rotation);
+        mpEntity.dimension = dimension;
+        mpEntity.engineOn = engine;
+        mpEntity.lockState = locked ? 2 : 1;
+        const vehicle = new AltVVehicle_1.AltVVehicle({ mpEntity });
+        this.registerBaseObject(vehicle);
+        return vehicle;
+    }
 }
 exports.AltVVehiclesManager = AltVVehiclesManager;

package/dist/server/entities/altv/worldObject/AltVWorldObject.d.ts

@@ -1,10 +1,13 @@
-import { IWorldObject, IWorldObjectOptions } from "../../common/worldObject/IWorldObject";
+import { IWorldObject } from "../../common/worldObject/IWorldObject";
 import { Vector3D } from "../../../common/utils/math/Vectors";
-import { AltVBaseObject } from "../baseObject/AltVBaseObject";
-export declare abstract class AltVWorldObject extends AltVBaseObject implements IWorldObject {
-    private readonly _position;
-    private readonly _dimension;
+import { AltVBaseObject, IAltVBaseObjectOptions } from "../baseObject/AltVBaseObject";
+import WorldObject = AltVServer.WorldObject;
+export interface IAltVWorldObjectOptions<T extends WorldObject> extends IAltVBaseObjectOptions<T> {
+}
+export declare abstract class AltVWorldObject<T extends WorldObject> extends AltVBaseObject<T> implements IWorldObject {
     get position(): Vector3D;
     get dimension(): number;
-    protected constructor(options: IWorldObjectOptions);
+    protected constructor(options: IAltVWorldObjectOptions<T>);
+    setPosition(value: Vector3D): void;
+    setDimension(value: number): void;
 }

package/dist/server/entities/altv/worldObject/AltVWorldObject.js

@@ -1,20 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVWorldObject = void 0;
+const Vectors_1 = require("../../../common/utils/math/Vectors");
 const AltVBaseObject_1 = require("../baseObject/AltVBaseObject");
+var Vector3 = AltVShared.Vector3;
 class AltVWorldObject extends AltVBaseObject_1.AltVBaseObject {
-    _position;
-    _dimension;
     get position() {
-        return this._position;
+        const { x, y, z } = this.mpEntity.pos;
+        return new Vectors_1.Vector3D(x, y, z);
     }
     get dimension() {
-        return this._dimension;
+        return this.mpEntity.dimension;
     }
     constructor(options) {
         super(options);
-        this._position = options.position;
-        this._dimension = options.dimension;
+    }
+    setPosition(value) {
+        this.mpEntity.pos = new Vector3(value);
+    }
+    setDimension(value) {
+        this.mpEntity.dimension = value;
     }
 }
 exports.AltVWorldObject = AltVWorldObject;

package/dist/server/entities/altv/worldObject/AltVWorldObjectsIterator.d.ts

@@ -2,7 +2,8 @@ import { IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIte
 import { AltVWorldObject } from "./AltVWorldObject";
 import { AltVBaseObjectsIterator } from "../baseObject/AltVBaseObjectsIterator";
 import { Vector2D, Vector3D } from "../../../common/utils/math/Vectors";
-export declare class AltVWorldObjectsIterator<T extends AltVWorldObject> extends AltVBaseObjectsIterator<T> implements IWorldObjectsIterator<T> {
+import WorldObject = AltVServer.WorldObject;
+export declare class AltVWorldObjectsIterator<T extends AltVWorldObject<WorldObject>> extends AltVBaseObjectsIterator<T> implements IWorldObjectsIterator<T> {
     constructor(baseObjects: ReadonlyMap<number, T>);
     dimension(value: number): IterableIterator<T>;
     range2D(center: Vector2D, range: number): IterableIterator<T>;

package/dist/server/entities/altv/worldObject/AltVWorldObjectsManager.d.ts

@@ -1,9 +1,12 @@
-import { IWorldObjectsManager, IWorldObjectsManagerOptions } from "../../common/worldObject/IWorldObjectsManager";
+import { IWorldObjectsManager } from "../../common/worldObject/IWorldObjectsManager";
 import { AltVWorldObject } from "./AltVWorldObject";
-import { AltVBaseObjectsManager } from "../baseObject/AltVBaseObjectsManager";
+import { AltVBaseObjectsManager, IAltVBaseObjectsManagerOptions } from "../baseObject/AltVBaseObjectsManager";
 import { AltVWorldObjectsIterator } from "./AltVWorldObjectsIterator";
-export declare abstract class AltVWorldObjectsManager<T extends AltVWorldObject> extends AltVBaseObjectsManager<T> implements IWorldObjectsManager<T> {
+import WorldObject = AltVServer.WorldObject;
+export interface IAltVWorldObjectsManagerOptions extends IAltVBaseObjectsManagerOptions {
+}
+export declare abstract class AltVWorldObjectsManager<T extends AltVWorldObject<WorldObject>> extends AltVBaseObjectsManager<T> implements IWorldObjectsManager<T> {
     protected readonly _iterator: AltVWorldObjectsIterator<T>;
     get iterator(): AltVWorldObjectsIterator<T>;
-    protected constructor(options: IWorldObjectsManagerOptions);
+    protected constructor(options: IAltVWorldObjectsManagerOptions);
 }

package/dist/server/entities/common/baseObject/IBaseObject.d.ts

@@ -1,13 +1,14 @@
+import BaseObject = AltVServer.BaseObject;
 export declare enum BaseObjectType {
     Player = "player",
     Vehicle = "vehicle"
 }
 export interface IBaseObjectOptions {
-    id: number;
-    type: BaseObjectType;
+    mpEntity: EntityMp | BaseObject;
 }
 export interface IBaseObject {
-    id: number;
-    type: BaseObjectType;
+    get id(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
     destroy(): void;
 }

package/dist/server/entities/common/baseObject/IBaseObjectsManager.d.ts

@@ -3,6 +3,8 @@ import { IBaseObjectsIterator } from "./IBaseObjectsIterator";
 export interface IBaseObjectsManagerOptions {
     baseObjectsType: `${BaseObjectType}`;
 }
+export interface IBaseObjectCreateOptions {
+}
 export interface IBaseObjectsManager<T extends IBaseObject> {
     get iterator(): IBaseObjectsIterator<T>;
     getByID(id: number): T;

package/dist/server/entities/common/baseObject/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IBaseObject";
+export * from "./IBaseObjectsIterator";
+export * from "./IBaseObjectsManager";

package/dist/server/entities/common/baseObject/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IBaseObject"), exports);
+__exportStar(require("./IBaseObjectsIterator"), exports);
+__exportStar(require("./IBaseObjectsManager"), exports);

package/dist/server/entities/common/entity/IEntitiesManager.d.ts

@@ -1,6 +1,11 @@
-import { IWorldObjectsManager, IWorldObjectsManagerOptions } from "../worldObject/IWorldObjectsManager";
+import { IWorldObjectCreateOptions, IWorldObjectsManager, IWorldObjectsManagerOptions } from "../worldObject/IWorldObjectsManager";
 import { IEntity } from "./IEntity";
+import { IVector3D } from "../../../common/utils";
 export interface IEntitiesManagerOptions extends IWorldObjectsManagerOptions {
 }
+export interface IEntityCreateOptions extends IWorldObjectCreateOptions {
+    model: string;
+    rotation: IVector3D;
+}
 export interface IEntitiesManager<T extends IEntity> extends IWorldObjectsManager<T> {
 }

package/dist/server/entities/common/entity/IEntity.d.ts

@@ -1,8 +1,10 @@
 import { IWorldObject, IWorldObjectOptions } from "../worldObject/IWorldObject";
+import { IVector3D } from "../../../common/utils";
 export interface IEntityOptions extends IWorldObjectOptions {
-    model: string;
 }
 export interface IEntity extends IWorldObject {
-    get model(): string;
+    get model(): number;
+    get rotation(): IVector3D;
     setModel(value: string): void;
+    setRotation(value: IVector3D): void;
 }

package/dist/server/entities/common/entity/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./IEntitiesManager";
+export * from "./IEntity";

package/dist/server/entities/common/entity/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IEntitiesManager"), exports);
+__exportStar(require("./IEntity"), exports);

package/dist/server/entities/common/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./baseObject";
+export * from "./entity";
+export * from "./player";
+export * from "./vehicle";
+export * from "./worldObject";

package/dist/server/entities/common/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./baseObject"), exports);
+__exportStar(require("./entity"), exports);
+__exportStar(require("./player"), exports);
+__exportStar(require("./vehicle"), exports);
+__exportStar(require("./worldObject"), exports);

package/dist/server/entities/common/player/IPlayer.d.ts

@@ -1,12 +1,59 @@
 import { IEntity, IEntityOptions } from "../entity/IEntity";
+import { IVehicle } from "../vehicle/IVehicle";
+import { IVector3D } from "../../../common/utils/math/Vectors";
+import { INetClientEvents } from "../../../net/common/events/IEventsManager";
+import { INetClientRPC } from "../../../net/common/rpc/IRPCManager";
+export interface ICustomization {
+    gender: boolean;
+    shapeFirst: number;
+    shapeSecond: number;
+    shapeThird: number;
+    skinFirst: number;
+    skinSecond: number;
+    skinThird: number;
+    shapeMix: number;
+    skinMix: number;
+    thirdMix: number;
+    eyeColor: number;
+    hairColor: number;
+    highlightColor: number;
+    faceFeatures: number[];
+}
 export interface IPlayerOptions extends IEntityOptions {
-    name: string;
-    socialClub: string;
 }
 export interface IPlayer extends IEntity {
     get name(): string;
     get socialClub(): string;
+    get heading(): number;
     get health(): number;
-    setName(value: string): void;
+    get armour(): number;
+    get ip(): string;
+    get serial(): string;
+    get vehicle(): IVehicle | null;
+    get seat(): number;
+    get weapon(): number;
+    get weaponAmmo(): number;
+    get eyeColor(): number;
+    get streamedPlayers(): IPlayer[];
+    emitEvent<K extends keyof INetClientEvents>(eventName: K, ...args: Parameters<INetClientEvents[K]>): void;
+    emitRPC<K extends keyof INetClientEvents>(rpcName: K, ...args: Parameters<INetClientEvents[K]>): Promise<ReturnType<INetClientRPC[K]>>;
+    spawn(position: IVector3D): void;
+    setName(name: string): void;
+    setHeading(value: number): void;
     setHealth(value: number): void;
+    setArmour(value: number): void;
+    setWeaponAmmo(weapon: string, ammo: number): void;
+    giveWeapon(weapon: string, ammo: number): void;
+    removeWeapon(weapon: string): void;
+    enableVoiceTo(player: IPlayer): void;
+    disableVoiceTo(player: IPlayer): void;
+    putIntoVehicle(vehicle: IVehicle, seat?: number): void;
+    ejectFromVehicle(): void;
+    setCustomization(data: ICustomization): void;
+    setHeadOverlay(overlayID: number, index: number, opacity: number, firstColor: number, secondColor: number): void;
+    setEyeColor(colorID: number): void;
+    setProp(propID: number, drawableID: number, textureID: number): void;
+    setClothes(componentID: number, drawableID: number, textureID: number, paletteID: number): void;
+    setHairColor(colorID: number, highlightColorID: number): void;
+    kick(reason?: string): void;
 }

package/dist/server/entities/common/player/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./IPlayer";
+export * from "./IPlayersManager";

package/dist/server/entities/common/player/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IPlayer"), exports);
+__exportStar(require("./IPlayersManager"), exports);