rock-mod 0.0.1 → 0.2.0

package/dist/server/entities/common/vehicle/IVehicle.d.ts

@@ -1,7 +1,48 @@
 import { IEntity, IEntityOptions } from "../entity/IEntity";
+import { IRGBA } from "../../../common/utils";
+import { IPlayer } from "../player";
+export declare enum VehicleSeat {
+    NONE = 255,
+    DRIVER = 256,
+    PASSENGER_1 = 257,
+    PASSENGER_2 = 258,
+    PASSENGER_3 = 259,
+    PASSENGER_4 = 260,
+    PASSENGER_5 = 261,
+    PASSENGER_6 = 262,
+    PASSENGER_7 = 263,
+    PASSENGER_8 = 264,
+    PASSENGER_9 = 265,
+    PASSENGER_10 = 266,
+    PASSENGER_11 = 267,
+    PASSENGER_12 = 268,
+    PASSENGER_13 = 269,
+    PASSENGER_14 = 270,
+    PASSENGER_15 = 271,
+    PASSENGER_16 = 272
+}
 export interface IVehicleOptions extends IEntityOptions {
 }
 export interface IVehicle extends IEntity {
     get bodyHealth(): number;
+    get engineHealth(): number;
+    get numberPlate(): string;
+    get isLocked(): boolean;
+    get isDead(): boolean;
+    get primaryColor(): number;
+    get secondaryColor(): number;
+    get customPrimaryColor(): IRGBA;
+    get customSecondaryColor(): IRGBA;
+    get driver(): IPlayer | null;
+    get passengers(): Set<IPlayer>;
     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: IRGBA): void;
+    setCustomSecondaryColor(value: IRGBA): void;
+    explode(): void;
+    repair(): void;
 }

package/dist/server/entities/common/vehicle/IVehicle.js

@@ -1,2 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.VehicleSeat = void 0;
+var VehicleSeat;
+(function (VehicleSeat) {
+    VehicleSeat[VehicleSeat["NONE"] = 255] = "NONE";
+    VehicleSeat[VehicleSeat["DRIVER"] = 256] = "DRIVER";
+    VehicleSeat[VehicleSeat["PASSENGER_1"] = 257] = "PASSENGER_1";
+    VehicleSeat[VehicleSeat["PASSENGER_2"] = 258] = "PASSENGER_2";
+    VehicleSeat[VehicleSeat["PASSENGER_3"] = 259] = "PASSENGER_3";
+    VehicleSeat[VehicleSeat["PASSENGER_4"] = 260] = "PASSENGER_4";
+    VehicleSeat[VehicleSeat["PASSENGER_5"] = 261] = "PASSENGER_5";
+    VehicleSeat[VehicleSeat["PASSENGER_6"] = 262] = "PASSENGER_6";
+    VehicleSeat[VehicleSeat["PASSENGER_7"] = 263] = "PASSENGER_7";
+    VehicleSeat[VehicleSeat["PASSENGER_8"] = 264] = "PASSENGER_8";
+    VehicleSeat[VehicleSeat["PASSENGER_9"] = 265] = "PASSENGER_9";
+    VehicleSeat[VehicleSeat["PASSENGER_10"] = 266] = "PASSENGER_10";
+    VehicleSeat[VehicleSeat["PASSENGER_11"] = 267] = "PASSENGER_11";
+    VehicleSeat[VehicleSeat["PASSENGER_12"] = 268] = "PASSENGER_12";
+    VehicleSeat[VehicleSeat["PASSENGER_13"] = 269] = "PASSENGER_13";
+    VehicleSeat[VehicleSeat["PASSENGER_14"] = 270] = "PASSENGER_14";
+    VehicleSeat[VehicleSeat["PASSENGER_15"] = 271] = "PASSENGER_15";
+    VehicleSeat[VehicleSeat["PASSENGER_16"] = 272] = "PASSENGER_16";
+})(VehicleSeat || (exports.VehicleSeat = VehicleSeat = {}));

package/dist/server/entities/common/vehicle/IVehiclesManager.d.ts

@@ -1,4 +1,9 @@
-import { IEntitiesManager } from "../entity/IEntitiesManager";
+import { IEntitiesManager, IEntityCreateOptions } from "../entity/IEntitiesManager";
 import { IVehicle } from "./IVehicle";
+export interface IVehicleCreateOptions extends IEntityCreateOptions {
+    engine: boolean;
+    locked: boolean;
+}
 export interface IVehiclesManager extends IEntitiesManager<IVehicle> {
+    create(options: IVehicleCreateOptions): IVehicle;
 }

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

@@ -0,0 +1,2 @@
+export * from "./IVehicle";
+export * from "./IVehiclesManager";

package/dist/server/entities/common/vehicle/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("./IVehicle"), exports);
+__exportStar(require("./IVehiclesManager"), exports);

package/dist/server/entities/common/worldObject/IWorldObject.d.ts

@@ -1,10 +1,10 @@
 import { IBaseObject, IBaseObjectOptions } from "../baseObject/IBaseObject";
-import { Vector3D } from "../../../common/utils/math/Vectors";
+import { IVector3D } from "../../../common/utils/math/Vectors";
 export interface IWorldObjectOptions extends IBaseObjectOptions {
-    position: Vector3D;
-    dimension: number;
 }
 export interface IWorldObject extends IBaseObject {
-    position: Vector3D;
-    dimension: number;
+    get position(): IVector3D;
+    get dimension(): number;
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
 }

package/dist/server/entities/common/worldObject/IWorldObjectsManager.d.ts

@@ -1,8 +1,13 @@
-import { IBaseObjectsManager, IBaseObjectsManagerOptions } from "../baseObject/IBaseObjectsManager";
+import { IBaseObjectCreateOptions, IBaseObjectsManager, IBaseObjectsManagerOptions } from "../baseObject/IBaseObjectsManager";
 import { IWorldObject } from "./IWorldObject";
 import { IWorldObjectsIterator } from "./IWorldObjectsIterator";
+import { IVector3D } from "../../../common/utils";
 export interface IWorldObjectsManagerOptions extends IBaseObjectsManagerOptions {
 }
+export interface IWorldObjectCreateOptions extends IBaseObjectCreateOptions {
+    position: IVector3D;
+    dimension: number;
+}
 export interface IWorldObjectsManager<T extends IWorldObject> extends IBaseObjectsManager<T> {
     get iterator(): IWorldObjectsIterator<T>;
 }

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

@@ -0,0 +1,3 @@
+export * from "./IWorldObject";
+export * from "./IWorldObjectsIterator";
+export * from "./IWorldObjectsManager";

package/dist/server/entities/common/worldObject/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("./IWorldObject"), exports);
+__exportStar(require("./IWorldObjectsIterator"), exports);
+__exportStar(require("./IWorldObjectsManager"), exports);

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

@@ -0,0 +1 @@
+export * from "./common";

package/dist/server/entities/index.js

@@ -0,0 +1,17 @@
+"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("./common"), exports);

package/dist/server/entities/ragemp/baseObject/RageBaseObject.d.ts

@@ -1,9 +1,13 @@
 import { BaseObjectType, IBaseObject, IBaseObjectOptions } from "../../common/baseObject/IBaseObject";
-export declare abstract class RageBaseObject implements IBaseObject {
-    private readonly _id;
-    private readonly _type;
+export interface IRageBaseObjectOptions<T extends EntityMp> extends IBaseObjectOptions {
+    mpEntity: T;
+}
+export declare abstract class RageBaseObject<T extends EntityMp = EntityMp> implements IBaseObject {
+    private readonly _mpEntity;
     get id(): number;
     get type(): BaseObjectType;
-    protected constructor(options: IBaseObjectOptions);
+    get isExists(): boolean;
+    protected get mpEntity(): T;
+    protected constructor(options: IRageBaseObjectOptions<T>);
     destroy(): void;
 }

package/dist/server/entities/ragemp/baseObject/RageBaseObject.js

@@ -2,17 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageBaseObject = void 0;
 class RageBaseObject {
-    _id;
-    _type;
+    _mpEntity;
     get id() {
-        return this._id;
+        return this._mpEntity.id;
     }
     get type() {
-        return this._type;
+        return this._mpEntity.type;
+    }
+    get isExists() {
+        return this._mpEntity.isExists();
+    }
+    get mpEntity() {
+        return this._mpEntity;
     }
     constructor(options) {
-        this._id = options.id;
-        this._type = options.type;
+        this._mpEntity = options.mpEntity;
     }
     destroy() {
         console.log("destroy");

package/dist/server/entities/ragemp/baseObject/RageBaseObjectsManager.d.ts

@@ -1,13 +1,17 @@
 import { IBaseObjectsManager, IBaseObjectsManagerOptions } from "../../common/baseObject/IBaseObjectsManager";
 import { RageBaseObject } from "./RageBaseObject";
 import { RageBaseObjectsIterator } from "./RageBaseObjectsIterator";
-export declare abstract class RageBaseObjectsManager<T extends RageBaseObject> implements IBaseObjectsManager<RageBaseObject> {
+export interface IRageBaseObjectsManagerOptions extends IBaseObjectsManagerOptions {
+}
+export declare abstract class RageBaseObjectsManager<T extends RageBaseObject<EntityMp>> implements IBaseObjectsManager<RageBaseObject<EntityMp>> {
     private readonly _baseObjects;
     private readonly _baseObjectsType;
     protected readonly _iterator: RageBaseObjectsIterator<T>;
     protected get baseObjects(): ReadonlyMap<number, T>;
     get iterator(): RageBaseObjectsIterator<T>;
-    protected constructor(options: IBaseObjectsManagerOptions);
+    protected constructor(options: IRageBaseObjectsManagerOptions);
     getByID(id: number): T;
     findByID(id: number): T | null;
+    protected registerBaseObject(baseObject: T): void;
+    protected unregisterBaseObject(baseObject: T): void;
 }

package/dist/server/entities/ragemp/baseObject/RageBaseObjectsManager.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageBaseObjectsManager = void 0;
 const RageBaseObjectsIterator_1 = require("./RageBaseObjectsIterator");
+const RockMod_1 = require("../../../RockMod");
 class RageBaseObjectsManager {
     _baseObjects;
     _baseObjectsType;
@@ -28,5 +29,18 @@ class RageBaseObjectsManager {
         const baseObject = this._baseObjects.get(id);
         return baseObject ?? null;
     }
+    registerBaseObject(baseObject) {
+        if (this._baseObjects.has(baseObject.id)) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} already exists`);
+        }
+        this._baseObjects.set(baseObject.id, baseObject);
+        RockMod_1.RockMod.instance.net.events.emit("rm::entityCreated", baseObject);
+    }
+    unregisterBaseObject(baseObject) {
+        if (!this._baseObjects.delete(baseObject.id)) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} not found`);
+        }
+        RockMod_1.RockMod.instance.net.events.emit("rm::entityDestroyed", baseObject);
+    }
 }
 exports.RageBaseObjectsManager = RageBaseObjectsManager;

package/dist/server/entities/ragemp/entity/RageEntitiesManager.d.ts

@@ -1,6 +1,8 @@
-import { IEntitiesManager, IEntitiesManagerOptions } from "../../common/entity/IEntitiesManager";
+import { IEntitiesManager } from "../../common/entity/IEntitiesManager";
 import { RageEntity } from "./RageEntity";
-import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
-export declare abstract class RageEntitiesManager<T extends RageEntity> extends RageWorldObjectsManager<T> implements IEntitiesManager<T> {
-    protected constructor(options: IEntitiesManagerOptions);
+import { IRageWorldObjectsManagerOptions, RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
+export interface IRageEntitiesManagerOptions extends IRageWorldObjectsManagerOptions {
+}
+export declare abstract class RageEntitiesManager<T extends RageEntity<EntityMp>> extends RageWorldObjectsManager<T> implements IEntitiesManager<T> {
+    protected constructor(options: IRageEntitiesManagerOptions);
 }

package/dist/server/entities/ragemp/entity/RageEntity.d.ts

@@ -1,8 +1,12 @@
-import { IEntity, IEntityOptions } from "../../common/entity/IEntity";
-import { RageWorldObject } from "../worldObject/RageWorldObject";
-export declare abstract class RageEntity extends RageWorldObject implements IEntity {
-    private _model;
-    get model(): string;
-    protected constructor(options: IEntityOptions);
+import { IEntity } from "../../common/entity/IEntity";
+import { IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
+import { Vector3D } from "../../../common/utils";
+export interface IRageEntityOptions<T extends EntityMp> extends IRageWorldObjectOptions<T> {
+}
+export declare abstract class RageEntity<T extends EntityMp> extends RageWorldObject<T> implements IEntity {
+    get model(): number;
+    get rotation(): Vector3D;
+    protected constructor(options: IRageEntityOptions<T>);
     setModel(value: string): void;
+    setRotation(value: Vector3D): void;
 }

package/dist/server/entities/ragemp/entity/RageEntity.js

@@ -2,17 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageEntity = void 0;
 const RageWorldObject_1 = require("../worldObject/RageWorldObject");
+const utils_1 = require("../../../common/utils");
 class RageEntity extends RageWorldObject_1.RageWorldObject {
-    _model;
     get model() {
-        return this._model;
+        return this.mpEntity.model;
+    }
+    get rotation() {
+        const { x, y, z } = this.mpEntity.rotation;
+        return new utils_1.Vector3D(x, y, z);
     }
     constructor(options) {
         super(options);
-        this._model = options.model;
     }
     setModel(value) {
-        this._model = value;
+        this.mpEntity.model = mp.joaat(value);
+    }
+    setRotation(value) {
+        this.mpEntity.rotation = new mp.Vector3(value);
     }
 }
 exports.RageEntity = RageEntity;

package/dist/server/entities/ragemp/player/RagePlayer.d.ts

@@ -1,13 +1,46 @@
-import { RageEntity } from "../entity/RageEntity";
-import { IPlayer, IPlayerOptions } from "../../common/player/IPlayer";
-export declare class RagePlayer extends RageEntity implements IPlayer {
-    private _name;
-    private readonly _socialClub;
-    private _health;
+import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { ICustomization, IPlayer } from "../../common/player/IPlayer";
+import { RageVehicle } from "../vehicle/RageVehicle";
+import { Vector3D } from "../../../common/utils/math/Vectors";
+import { IRageClientEvents } from "../../../net/ragemp/events/RageEventsManager";
+import { IRageClientRPC } from "../../../net/ragemp/rpc/RageRPCManager";
+interface IRagePlayerOptions extends IRageEntityOptions<PlayerMp> {
+}
+export declare class RagePlayer extends RageEntity<PlayerMp> implements IPlayer {
     get name(): string;
     get socialClub(): string;
+    get heading(): number;
     get health(): number;
-    constructor(options: IPlayerOptions);
-    setName(value: string): void;
+    get armour(): number;
+    get ip(): string;
+    get serial(): string;
+    get vehicle(): RageVehicle | null;
+    get seat(): number;
+    get weapon(): number;
+    get weaponAmmo(): number;
+    get eyeColor(): number;
+    get streamedPlayers(): RagePlayer[];
+    constructor(options: IRagePlayerOptions);
+    emitEvent<K extends keyof IRageClientEvents>(eventName: K, ...args: Parameters<IRageClientEvents[K]>): void;
+    emitRPC<K extends keyof IRageClientRPC>(rpcName: K, ...args: Parameters<IRageClientRPC[K]>): Promise<ReturnType<IRageClientRPC[K]>>;
+    spawn(position: Vector3D): 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: RagePlayer): void;
+    disableVoiceTo(player: RagePlayer): void;
+    putIntoVehicle(vehicle: RageVehicle, 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;
 }
+export {};

package/dist/server/entities/ragemp/player/RagePlayer.js

@@ -2,30 +2,124 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RagePlayer = void 0;
 const RageEntity_1 = require("../entity/RageEntity");
+const RockMod_1 = require("../../../RockMod");
 class RagePlayer extends RageEntity_1.RageEntity {
-    _name;
-    _socialClub;
-    _health;
     get name() {
-        return this._name;
+        return this.mpEntity.name;
     }
     get socialClub() {
-        return this._socialClub;
+        return this.mpEntity.socialClub;
+    }
+    get heading() {
+        return this.mpEntity.heading;
     }
     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.serial;
+    }
+    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.weapon;
+    }
+    get weaponAmmo() {
+        return this.mpEntity.weaponAmmo;
+    }
+    get eyeColor() {
+        return this.mpEntity.eyeColor;
+    }
+    get streamedPlayers() {
+        const players = [];
+        for (const mpEntity of this.mpEntity.streamedPlayers) {
+            players.push(RockMod_1.RockMod.instance.players.getByID(mpEntity.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(new mp.Vector3(position));
+    }
+    setName(name) {
+        this.mpEntity.name = name;
+    }
+    setHeading(value) {
+        this.mpEntity.heading = 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(mp.joaat(weapon), ammo);
+    }
+    giveWeapon(weapon, ammo) {
+        return this.mpEntity.giveWeapon(weapon, ammo);
+    }
+    removeWeapon(weapon) {
+        return this.mpEntity.removeWeapon(weapon);
+    }
+    enableVoiceTo(player) {
+        const mpPlayer = mp.players.at(player.id);
+        return this.mpEntity.enableVoiceTo(mpPlayer);
+    }
+    disableVoiceTo(player) {
+        const mpPlayer = mp.players.at(player.id);
+        return this.mpEntity.disableVoiceTo(mpPlayer);
+    }
+    putIntoVehicle(vehicle, seat) {
+        const mpVehicle = mp.vehicles.at(vehicle.id);
+        return this.mpEntity.putIntoVehicle(mpVehicle, seat || 0);
+    }
+    ejectFromVehicle() {
+        return this.mpEntity.removeFromVehicle();
+    }
+    setCustomization(data) {
+        const { gender, shapeFirst, shapeSecond, shapeThird, skinFirst, skinSecond, skinThird, shapeMix, skinMix, thirdMix, eyeColor, hairColor, highlightColor, faceFeatures, } = data;
+        return this.mpEntity.setCustomization(gender, shapeFirst, shapeSecond, shapeThird, skinFirst, skinSecond, skinThird, shapeMix, skinMix, thirdMix, eyeColor, hairColor, highlightColor, faceFeatures);
+    }
+    setHeadOverlay(overlayID, index, opacity, firstColor, secondColor) {
+        return this.mpEntity.setHeadOverlay(overlayID, [index, opacity, firstColor, secondColor]);
+    }
+    setEyeColor(colorID) {
+        this.mpEntity.eyeColor = colorID;
+    }
+    setProp(propID, drawableID, textureID) {
+        return this.mpEntity.setProp(propID, drawableID, textureID);
+    }
+    setClothes(componentID, drawableID, textureID, paletteID) {
+        return this.mpEntity.setClothes(componentID, drawableID, textureID, paletteID);
+    }
+    setHairColor(colorID, highlightColorID) {
+        return this.mpEntity.setHairColor(colorID, highlightColorID);
+    }
+    kick(reason) {
+        return this.mpEntity.kick(reason ?? "");
     }
 }
 exports.RagePlayer = RagePlayer;

package/dist/server/entities/ragemp/player/RagePlayersManager.d.ts

@@ -7,4 +7,5 @@ export declare class RagePlayersManager extends RageEntitiesManager<RagePlayer>
     findByName(name: string): RagePlayer | null;
     getBySocialClub(socialClub: string): RagePlayer;
     findBySocialClub(socialClub: string): RagePlayer | null;
+    private _init;
 }

package/dist/server/entities/ragemp/player/RagePlayersManager.js

@@ -2,11 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RagePlayersManager = void 0;
 const RageEntitiesManager_1 = require("../entity/RageEntitiesManager");
+const RagePlayer_1 = require("./RagePlayer");
+const RockMod_1 = require("../../../RockMod");
 class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
     constructor() {
         super({
             baseObjectsType: "player",
         });
+        this._init();
     }
     getByName(name) {
         const player = this.findByName(name);
@@ -38,5 +41,23 @@ class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
         }
         return null;
     }
+    _init() {
+        const net = RockMod_1.RockMod.instance.net;
+        net.events.on({
+            playerJoin: (mpPlayer) => {
+                mpPlayer.isExists = () => mp.players.exists(mpPlayer);
+                const player = new RagePlayer_1.RagePlayer({
+                    mpEntity: mpPlayer,
+                });
+                this.registerBaseObject(player);
+                RockMod_1.RockMod.instance.net.events.emit("rm::playerConnected", player);
+            },
+            playerQuit: (mpPlayer) => {
+                const player = this.getByID(mpPlayer.id);
+                this.unregisterBaseObject(player);
+                net.events.emit("rm::playerDisconnected", player);
+            },
+        });
+    }
 }
 exports.RagePlayersManager = RagePlayersManager;

package/dist/server/entities/ragemp/vehicle/RageVehicle.d.ts

@@ -1,8 +1,30 @@
-import { RageEntity } from "../entity/RageEntity";
-import { IVehicle, IVehicleOptions } from "../../common/vehicle/IVehicle";
-export declare class RageVehicle extends RageEntity implements IVehicle {
-    private _bodyHealth;
+import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
+import { IVehicle } from "../../common/vehicle/IVehicle";
+import { RGBA } from "../../../common/utils";
+import { RagePlayer } from "../player/RagePlayer";
+export interface IRageVehicleOptions extends IRageEntityOptions<VehicleMp> {
+}
+export declare class RageVehicle extends RageEntity<VehicleMp> 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(): RagePlayer | null;
+    get passengers(): Set<RagePlayer>;
+    constructor(options: IRageVehicleOptions);
     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;
 }