rock-mod 0.0.1 → 0.1.0

package/dist/index.d.ts

@@ -1 +1 @@
-export * from "./server/RockMod";
+export * from "./server";

package/dist/index.js

@@ -14,4 +14,4 @@ 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("./server/RockMod"), exports);
+__exportStar(require("./server"), exports);

package/dist/server/RockMod.d.ts

@@ -1,3 +1,4 @@
+import { INetManager } from "./net/common/INetManager";
 import { IPlayersManager } from "./entities/common/player/IPlayersManager";
 import { IVehiclesManager } from "./entities/common/vehicle/IVehiclesManager";
 type MultiplayerType = "RageMP" | "AltV";
@@ -5,13 +6,18 @@ export interface RockModOptions {
     multiplayer: MultiplayerType;
 }
 export declare class RockMod {
-    private readonly _options;
-    private readonly _players;
-    private readonly _vehicles;
+    private static _instance?;
+    static create(options: RockModOptions): Promise<RockMod>;
+    static get instance(): RockMod;
+    private static _initManagersFactory;
+    private readonly _managersFactory;
+    private readonly _net;
+    private _players;
+    private _vehicles;
+    get net(): INetManager;
     get players(): IPlayersManager;
     get vehicles(): IVehiclesManager;
-    constructor(options: RockModOptions);
+    private constructor();
     init(): void;
-    private _initManagersFactory;
 }
 export {};

package/dist/server/RockMod.js

@@ -1,37 +1,79 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RockMod = void 0;
-const AltVManagersFactory_1 = require("./entities/altv/AltVManagersFactory");
-const RageManagersFactory_1 = require("./entities/ragemp/RageManagersFactory");
 class RockMod {
-    _options;
+    static _instance;
+    static async create(options) {
+        if (this._instance) {
+            throw new Error("RockMod already created");
+        }
+        const managersFactory = await this._initManagersFactory(options);
+        this._instance = new RockMod(managersFactory);
+        return this._instance;
+    }
+    static get instance() {
+        if (!this._instance) {
+            throw new Error("RockMod not created");
+        }
+        return this._instance;
+    }
+    static async _initManagersFactory(options) {
+        const { multiplayer } = options;
+        switch (multiplayer) {
+            case "AltV": {
+                const { AltVManagersFactory } = await Promise.resolve().then(() => __importStar(require("./factories/altv/AltVManagersFactory")));
+                return new AltVManagersFactory();
+            }
+            case "RageMP": {
+                const { RageManagersFactory } = await Promise.resolve().then(() => __importStar(require("./factories/ragemp/RageManagersFactory")));
+                return new RageManagersFactory();
+            }
+        }
+    }
+    _managersFactory;
+    _net;
     _players;
     _vehicles;
+    get net() {
+        return this._net;
+    }
     get players() {
         return this._players;
     }
     get vehicles() {
         return this._vehicles;
     }
-    constructor(options) {
-        this._options = options;
-        const managersFactory = this._initManagersFactory();
-        this._players = managersFactory.createPlayersManager();
-        this._vehicles = managersFactory.createVehiclesManager();
+    constructor(managersFactory) {
+        this._managersFactory = managersFactory;
+        this._net = managersFactory.createNetManager();
     }
     init() {
         console.log("RockMod init");
-    }
-    _initManagersFactory() {
-        const { multiplayer } = this._options;
-        switch (multiplayer) {
-            case "AltV": {
-                return new AltVManagersFactory_1.AltVManagersFactory();
-            }
-            case "RageMP": {
-                return new RageManagersFactory_1.RageManagersFactory();
-            }
-        }
+        this._players = this._managersFactory.createPlayersManager();
+        this._vehicles = this._managersFactory.createVehiclesManager();
     }
 }
 exports.RockMod = RockMod;

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

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

package/dist/server/common/utils/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("./math"), exports);

package/dist/server/common/utils/math/Math.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    interface Math {
+        clamp(value: number, min: number, max: number): number;
+    }
+}
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/server/common/utils/math/Math.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clamp = clamp;
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+Math.clamp = clamp;

package/dist/server/common/utils/math/Vectors.d.ts

@@ -1,4 +1,17 @@
-export declare class Vector2D {
+export interface IVector2D {
+    get x(): number;
+    get y(): number;
+    distanceTo(position: IVector2D): number;
+    squaredDistanceTo(position: IVector2D): number;
+    isInRange(position: IVector2D, range: number): boolean;
+}
+export interface IVector3D extends IVector2D {
+    get z(): number;
+    distanceTo(position: IVector3D): number;
+    squaredDistanceTo(position: IVector3D): number;
+    isInRange(position: IVector3D, range: number): boolean;
+}
+export declare class Vector2D implements IVector2D {
     private readonly _x;
     private readonly _y;
     get x(): number;
@@ -8,7 +21,7 @@ export declare class Vector2D {
     squaredDistanceTo(position: Vector2D): number;
     isInRange(position: Vector2D, range: number): boolean;
 }
-export declare class Vector3D extends Vector2D {
+export declare class Vector3D extends Vector2D implements IVector3D {
     private readonly _z;
     get z(): number;
     constructor(x: number, y: number, z: number);

package/dist/server/common/utils/math/index.d.ts

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

package/dist/server/common/utils/math/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("./Vectors"), exports);

package/dist/server/entities/altv/baseObject/AltVBaseObject.d.ts

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

package/dist/server/entities/altv/baseObject/AltVBaseObject.js

@@ -1,18 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVBaseObject = void 0;
+const IBaseObject_1 = require("../../common/baseObject/IBaseObject");
+var BaseObjectTypeMP = AltVShared.BaseObjectType;
 class AltVBaseObject {
-    _id;
-    _type;
+    _mpEntity;
     get id() {
-        return this._id;
+        return this._mpEntity.id;
     }
     get type() {
-        return this._type;
+        switch (this._mpEntity.type) {
+            case BaseObjectTypeMP.Player: {
+                return IBaseObject_1.BaseObjectType.Player;
+            }
+            case BaseObjectTypeMP.Vehicle: {
+                return IBaseObject_1.BaseObjectType.Vehicle;
+            }
+        }
+        throw new Error(`BaseObject type ${this._mpEntity.type} not supported`);
+    }
+    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/altv/baseObject/AltVBaseObjectsIterator.d.ts

@@ -1,6 +1,7 @@
 import { AltVBaseObject } from "./AltVBaseObject";
 import { IBaseObjectsIterator } from "../../common/baseObject/IBaseObjectsIterator";
-export declare class AltVBaseObjectsIterator<T extends AltVBaseObject> implements IBaseObjectsIterator<T> {
+import BaseObject = AltVServer.BaseObject;
+export declare class AltVBaseObjectsIterator<T extends AltVBaseObject<BaseObject>> implements IBaseObjectsIterator<T> {
     private readonly _baseObjects;
     constructor(baseObjects: ReadonlyMap<number, T>);
     all(): IterableIterator<T>;

package/dist/server/entities/altv/baseObject/AltVBaseObjectsManager.d.ts

@@ -1,13 +1,18 @@
 import { IBaseObjectsManager, IBaseObjectsManagerOptions } from "../../common/baseObject/IBaseObjectsManager";
 import { AltVBaseObject } from "./AltVBaseObject";
 import { AltVBaseObjectsIterator } from "./AltVBaseObjectsIterator";
-export declare abstract class AltVBaseObjectsManager<T extends AltVBaseObject> implements IBaseObjectsManager<T> {
+import BaseObject = AltVServer.BaseObject;
+export interface IAltVBaseObjectsManagerOptions extends IBaseObjectsManagerOptions {
+}
+export declare abstract class AltVBaseObjectsManager<T extends AltVBaseObject<BaseObject>> implements IBaseObjectsManager<T> {
     private readonly _baseObjects;
     private readonly _baseObjectsType;
     protected readonly _iterator: AltVBaseObjectsIterator<T>;
     protected get baseObjects(): ReadonlyMap<number, T>;
     get iterator(): AltVBaseObjectsIterator<T>;
-    protected constructor(options: IBaseObjectsManagerOptions);
+    protected constructor(options: IAltVBaseObjectsManagerOptions);
     getByID(id: number): T;
     findByID(id: number): T | null;
+    protected registerBaseObject(baseObject: T): void;
+    protected unregisterBaseObject(baseObject: T): void;
 }

package/dist/server/entities/altv/baseObject/AltVBaseObjectsManager.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVBaseObjectsManager = void 0;
 const AltVBaseObjectsIterator_1 = require("./AltVBaseObjectsIterator");
+const RockMod_1 = require("../../../RockMod");
 class AltVBaseObjectsManager {
     _baseObjects;
     _baseObjectsType;
@@ -28,5 +29,18 @@ class AltVBaseObjectsManager {
         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("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("entityDestroyed", baseObject);
+    }
 }
 exports.AltVBaseObjectsManager = AltVBaseObjectsManager;

package/dist/server/entities/altv/entity/AltVEntitiesManager.d.ts

@@ -1,5 +1,6 @@
 import { IEntitiesManager } from "../../common/entity/IEntitiesManager";
 import { AltVEntity } from "./AltVEntity";
 import { AltVWorldObjectsManager } from "../worldObject/AltVWorldObjectsManager";
-export declare abstract class AltVEntitiesManager<T extends AltVEntity> extends AltVWorldObjectsManager<T> implements IEntitiesManager<T> {
+import Entity = AltVServer.Entity;
+export declare abstract class AltVEntitiesManager<T extends AltVEntity<Entity>> extends AltVWorldObjectsManager<T> implements IEntitiesManager<T> {
 }

package/dist/server/entities/altv/entity/AltVEntity.d.ts

@@ -1,8 +1,10 @@
-import { IEntity, IEntityOptions } from "../../common/entity/IEntity";
-import { AltVWorldObject } from "../worldObject/AltVWorldObject";
-export declare abstract class AltVEntity extends AltVWorldObject implements IEntity {
-    private _model;
-    get model(): string;
-    protected constructor(options: IEntityOptions);
+import { IEntity } from "../../common/entity/IEntity";
+import { AltVWorldObject, IAltVWorldObjectOptions } from "../worldObject/AltVWorldObject";
+import Entity = AltVServer.Entity;
+export interface IAltVEntityOptions<T extends Entity> extends IAltVWorldObjectOptions<T> {
+}
+export declare abstract class AltVEntity<T extends Entity> extends AltVWorldObject<T> implements IEntity {
+    get model(): number;
+    protected constructor(options: IAltVEntityOptions<T>);
     setModel(value: string): void;
 }

package/dist/server/entities/altv/entity/AltVEntity.js

@@ -2,17 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVEntity = void 0;
 const AltVWorldObject_1 = require("../worldObject/AltVWorldObject");
+var hash = AltVShared.hash;
 class AltVEntity extends AltVWorldObject_1.AltVWorldObject {
-    _model;
     get model() {
-        return this._model;
+        return this.mpEntity.model;
     }
     constructor(options) {
         super(options);
-        this._model = options.model;
     }
     setModel(value) {
-        this._model = value;
+        this.mpEntity.model = hash(value);
     }
 }
 exports.AltVEntity = AltVEntity;

package/dist/server/entities/altv/player/AltVPlayer.d.ts

@@ -1,13 +1,47 @@
-import { AltVEntity } from "../entity/AltVEntity";
-import { IPlayer, IPlayerOptions } from "../../common/player/IPlayer";
-export declare class AltVPlayer extends AltVEntity implements IPlayer {
-    private _name;
-    private readonly _socialClub;
-    private _health;
+import { AltVEntity, IAltVEntityOptions } from "../entity/AltVEntity";
+import { ICustomization, IPlayer } from "../../common/player/IPlayer";
+import { AltVPlayerNetManager } from "./AltVPlayerNetManager";
+import { AltVVehicle } from "../vehicle/AltVVehicle";
+import Player = AltVServer.Player;
+import { Vector3D } from "../../../common/utils/math/Vectors";
+interface AltVPlayerOptions extends IAltVEntityOptions<Player> {
+}
+export declare class AltVPlayer extends AltVEntity<Player> implements IPlayer {
+    private readonly _net;
+    get net(): AltVPlayerNetManager;
     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(): AltVVehicle | null;
+    get seat(): number;
+    get weapon(): number;
+    get weaponAmmo(): number;
+    get eyeColor(): number;
+    get streamedPlayers(): AltVPlayer[];
+    get isExists(): boolean;
+    constructor(options: AltVPlayerOptions);
+    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: AltVPlayer): void;
+    disableVoiceTo(player: AltVPlayer): void;
+    putIntoVehicle(vehicle: AltVVehicle, seat?: number): void;
+    ejectFromVehicle(): void;
+    setCustomization(data: Partial<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/altv/player/AltVPlayer.js

@@ -2,30 +2,135 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVPlayer = void 0;
 const AltVEntity_1 = require("../entity/AltVEntity");
+const AltVPlayerNetManager_1 = require("./AltVPlayerNetManager");
+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;
+    _net;
+    get net() {
+        return this._net;
+    }
     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;
+    }
+    get isExists() {
+        return this.mpEntity.valid;
     }
     constructor(options) {
         super(options);
-        this._name = options.name;
-        this._socialClub = options.socialClub;
-        this._health = 100;
+        this._net = new AltVPlayerNetManager_1.AltVPlayerNetManager(this.mpEntity);
     }
-    setName(value) {
-        this._name = value;
+    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/player/AltVPlayerNetManager.d.ts

@@ -0,0 +1,8 @@
+import { IPlayerNetManager } from "../../common/player/IPlayerNetManager";
+import Player = AltVServer.Player;
+export declare class AltVPlayerNetManager implements IPlayerNetManager {
+    private readonly _player;
+    constructor(player: Player);
+    callEvent(eventName: string, ...args: unknown[]): void;
+    callRPC(rpcName: string, ...args: unknown[]): Promise<unknown>;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVPlayerNetManager = void 0;
+class AltVPlayerNetManager {
+    _player;
+    constructor(player) {
+        this._player = player;
+    }
+    callEvent(eventName, ...args) {
+        return this._player.emit(eventName, ...args);
+    }
+    callRPC(rpcName, ...args) {
+        return this._player.emitRpc(rpcName, ...args);
+    }
+}
+exports.AltVPlayerNetManager = AltVPlayerNetManager;

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

@@ -1,8 +1,10 @@
-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;
+export interface IAltVVehicleOptions extends IAltVEntityOptions<Vehicle> {
+}
+export declare class AltVVehicle extends AltVEntity<Vehicle> implements IVehicle {
     get bodyHealth(): number;
-    constructor(options: IVehicleOptions);
+    constructor(options: IAltVVehicleOptions);
     setBodyHealth(value: number): void;
 }

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

@@ -3,16 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVVehicle = void 0;
 const AltVEntity_1 = require("../entity/AltVEntity");
 class AltVVehicle extends AltVEntity_1.AltVEntity {
-    _bodyHealth;
     get bodyHealth() {
-        return this._bodyHealth;
+        return this.mpEntity.bodyHealth;
     }
     constructor(options) {
         super(options);
-        this._bodyHealth = 100;
     }
     setBodyHealth(value) {
-        this._bodyHealth = value;
+        this.mpEntity.bodyHealth = value;
     }
 }
 exports.AltVVehicle = AltVVehicle;