rock-mod 0.0.1 → 0.2.0

package/dist/server/entities/ragemp/vehicle/RageVehicle.js

@@ -2,17 +2,85 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageVehicle = void 0;
 const RageEntity_1 = require("../entity/RageEntity");
+const utils_1 = require("../../../common/utils");
+const RockMod_1 = require("../../../RockMod");
 class RageVehicle extends RageEntity_1.RageEntity {
-    _bodyHealth;
     get bodyHealth() {
-        return this._bodyHealth;
+        return this.mpEntity.bodyHealth;
+    }
+    get engineHealth() {
+        return this.mpEntity.engineHealth;
+    }
+    get numberPlate() {
+        return this.mpEntity.numberPlate;
+    }
+    get isLocked() {
+        return this.mpEntity.locked;
+    }
+    get isDead() {
+        return this.mpEntity.dead;
+    }
+    get primaryColor() {
+        return this.mpEntity.getColor(0);
+    }
+    get secondaryColor() {
+        return this.mpEntity.getColor(1);
+    }
+    get customPrimaryColor() {
+        const [r, g, b] = this.mpEntity.getColorRGB(0);
+        return new utils_1.RGBA(r, g, b);
+    }
+    get customSecondaryColor() {
+        const [r, g, b] = this.mpEntity.getColorRGB(1);
+        return new utils_1.RGBA(r, g, b);
+    }
+    get driver() {
+        const mpPlayer = this.mpEntity.getOccupant(0);
+        if (!mpPlayer) {
+            return null;
+        }
+        return RockMod_1.RockMod.instance.players.getByID(mpPlayer.id);
+    }
+    get passengers() {
+        const players = new Set();
+        for (const mpPlayer of this.mpEntity.getOccupants()) {
+            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) {
+        throw new Error(`Not implemented (setEngineHealth: ${value})`);
+    }
+    setNumberPlate(value) {
+        this.mpEntity.numberPlate = value;
+    }
+    setLocked(value) {
+        this.mpEntity.locked = value;
+    }
+    setPrimaryColor(value) {
+        return this.mpEntity.setColor(value, this.secondaryColor);
+    }
+    setSecondaryColor(value) {
+        return this.mpEntity.setColor(this.primaryColor, value);
+    }
+    setCustomPrimaryColor(value) {
+        this.mpEntity.setColorRGB(value.r, value.g, value.b, this.customSecondaryColor.r, this.customSecondaryColor.g, this.customSecondaryColor.b);
+    }
+    setCustomSecondaryColor(value) {
+        this.mpEntity.setColorRGB(this.customPrimaryColor.r, this.customPrimaryColor.g, this.customPrimaryColor.b, value.r, value.g, value.b);
+    }
+    explode() {
+        return this.mpEntity.explode();
+    }
+    repair() {
+        return this.mpEntity.repair();
     }
 }
 exports.RageVehicle = RageVehicle;

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

@@ -1,6 +1,9 @@
 import { RageEntitiesManager } from "../entity/RageEntitiesManager";
 import { RageVehicle } from "./RageVehicle";
-import { IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+import { IVehicleCreateOptions, IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+export interface IRageVehicleCreateOptions extends IVehicleCreateOptions {
+}
 export declare class RageVehiclesManager extends RageEntitiesManager<RageVehicle> implements IVehiclesManager {
     constructor();
+    create(options: IRageVehicleCreateOptions): RageVehicle;
 }

package/dist/server/entities/ragemp/vehicle/RageVehiclesManager.js

@@ -2,11 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageVehiclesManager = void 0;
 const RageEntitiesManager_1 = require("../entity/RageEntitiesManager");
+const RageVehicle_1 = require("./RageVehicle");
 class RageVehiclesManager extends RageEntitiesManager_1.RageEntitiesManager {
     constructor() {
         super({
             baseObjectsType: "vehicle",
         });
     }
+    create(options) {
+        const { model, position, dimension, rotation, engine, locked } = options;
+        const mpEntity = mp.vehicles.new(model, new mp.Vector3(position), {
+            dimension,
+            heading: rotation.z,
+            engine,
+            locked,
+        });
+        mpEntity.rotation = new mp.Vector3(rotation);
+        const vehicle = new RageVehicle_1.RageVehicle({ mpEntity });
+        this.registerBaseObject(vehicle);
+        return vehicle;
+    }
 }
 exports.RageVehiclesManager = RageVehiclesManager;

package/dist/server/entities/ragemp/worldObject/RageWorldObject.d.ts

@@ -1,10 +1,12 @@
-import { IWorldObject, IWorldObjectOptions } from "../../common/worldObject/IWorldObject";
-import { RageBaseObject } from "../baseObject/RageBaseObject";
+import { IWorldObject } from "../../common/worldObject/IWorldObject";
+import { IRageBaseObjectOptions, RageBaseObject } from "../baseObject/RageBaseObject";
 import { Vector3D } from "../../../common/utils/math/Vectors";
-export declare abstract class RageWorldObject extends RageBaseObject implements IWorldObject {
-    private readonly _position;
-    private readonly _dimension;
+export interface IRageWorldObjectOptions<T extends EntityMp> extends IRageBaseObjectOptions<T> {
+}
+export declare abstract class RageWorldObject<T extends EntityMp> extends RageBaseObject<T> implements IWorldObject {
     get position(): Vector3D;
     get dimension(): number;
-    protected constructor(options: IWorldObjectOptions);
+    protected constructor(options: IRageWorldObjectOptions<T>);
+    setPosition(value: Vector3D): void;
+    setDimension(value: number): void;
 }

package/dist/server/entities/ragemp/worldObject/RageWorldObject.js

@@ -2,19 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageWorldObject = void 0;
 const RageBaseObject_1 = require("../baseObject/RageBaseObject");
+const Vectors_1 = require("../../../common/utils/math/Vectors");
 class RageWorldObject extends RageBaseObject_1.RageBaseObject {
-    _position;
-    _dimension;
     get position() {
-        return this._position;
+        const { x, y, z } = this.mpEntity.position;
+        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.position = new mp.Vector3(value);
+    }
+    setDimension(value) {
+        this.mpEntity.dimension = value;
     }
 }
 exports.RageWorldObject = RageWorldObject;

package/dist/server/entities/ragemp/worldObject/RageWorldObjectsIterator.d.ts

@@ -2,7 +2,7 @@ import { RageWorldObject } from "./RageWorldObject";
 import { RageBaseObjectsIterator } from "../baseObject/RageBaseObjectsIterator";
 import { IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
 import { Vector2D, Vector3D } from "../../../common/utils/math/Vectors";
-export declare class RageWorldObjectsIterator<T extends RageWorldObject> extends RageBaseObjectsIterator<T> implements IWorldObjectsIterator<T> {
+export declare class RageWorldObjectsIterator<T extends RageWorldObject<EntityMp>> extends RageBaseObjectsIterator<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/ragemp/worldObject/RageWorldObjectsManager.d.ts

@@ -1,9 +1,11 @@
-import { IWorldObjectsManager, IWorldObjectsManagerOptions } from "../../common/worldObject/IWorldObjectsManager";
-import { RageBaseObjectsManager } from "../baseObject/RageBaseObjectsManager";
+import { IWorldObjectsManager } from "../../common/worldObject/IWorldObjectsManager";
+import { IRageBaseObjectsManagerOptions, RageBaseObjectsManager } from "../baseObject/RageBaseObjectsManager";
 import { RageWorldObject } from "./RageWorldObject";
 import { RageWorldObjectsIterator } from "./RageWorldObjectsIterator";
-export declare abstract class RageWorldObjectsManager<T extends RageWorldObject> extends RageBaseObjectsManager<T> implements IWorldObjectsManager<T> {
+export interface IRageWorldObjectsManagerOptions extends IRageBaseObjectsManagerOptions {
+}
+export declare abstract class RageWorldObjectsManager<T extends RageWorldObject<EntityMp>> extends RageBaseObjectsManager<T> implements IWorldObjectsManager<T> {
     protected readonly _iterator: RageWorldObjectsIterator<T>;
     get iterator(): RageWorldObjectsIterator<T>;
-    protected constructor(options: IWorldObjectsManagerOptions);
+    protected constructor(options: IRageWorldObjectsManagerOptions);
 }

package/dist/server/factories/altv/AltVManagersFactory.d.ts

@@ -0,0 +1,9 @@
+import { IManagersFactory } from "../common/IManagersFactory";
+import { AltVNetManager } from "../../net/altv/AltVNetManager";
+import { AltVPlayersManager } from "../../entities/altv/player/AltVPlayersManager";
+import { AltVVehiclesManager } from "../../entities/altv/vehicle/AltVVehiclesManager";
+export declare class AltVManagersFactory implements IManagersFactory {
+    createNetManager(): AltVNetManager;
+    createPlayersManager(): AltVPlayersManager;
+    createVehiclesManager(): AltVVehiclesManager;
+}

package/dist/server/{entities → factories}/altv/AltVManagersFactory.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVManagersFactory = void 0;
-const AltVPlayersManager_1 = require("./player/AltVPlayersManager");
-const AltVVehiclesManager_1 = require("./vehicle/AltVVehiclesManager");
+const AltVNetManager_1 = require("../../net/altv/AltVNetManager");
+const AltVPlayersManager_1 = require("../../entities/altv/player/AltVPlayersManager");
+const AltVVehiclesManager_1 = require("../../entities/altv/vehicle/AltVVehiclesManager");
 class AltVManagersFactory {
+    createNetManager() {
+        return new AltVNetManager_1.AltVNetManager();
+    }
     createPlayersManager() {
         return new AltVPlayersManager_1.AltVPlayersManager();
     }

package/dist/server/factories/common/IManagersFactory.d.ts

@@ -0,0 +1,8 @@
+import { INetManager } from "../../net/common/INetManager";
+import { IPlayersManager } from "../../entities/common/player/IPlayersManager";
+import { IVehiclesManager } from "../../entities/common/vehicle/IVehiclesManager";
+export interface IManagersFactory {
+    createNetManager(): INetManager;
+    createPlayersManager(): IPlayersManager;
+    createVehiclesManager(): IVehiclesManager;
+}

package/dist/server/factories/ragemp/RageManagersFactory.d.ts

@@ -0,0 +1,9 @@
+import { IManagersFactory } from "../common/IManagersFactory";
+import { RageNetManager } from "../../net/ragemp/RageNetManager";
+import { RagePlayersManager } from "../../entities/ragemp/player/RagePlayersManager";
+import { RageVehiclesManager } from "../../entities/ragemp/vehicle/RageVehiclesManager";
+export declare class RageManagersFactory implements IManagersFactory {
+    createNetManager(): RageNetManager;
+    createPlayersManager(): RagePlayersManager;
+    createVehiclesManager(): RageVehiclesManager;
+}

package/dist/server/{entities → factories}/ragemp/RageManagersFactory.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageManagersFactory = void 0;
-const RagePlayersManager_1 = require("./player/RagePlayersManager");
-const RageVehiclesManager_1 = require("./vehicle/RageVehiclesManager");
+const RageNetManager_1 = require("../../net/ragemp/RageNetManager");
+const RagePlayersManager_1 = require("../../entities/ragemp/player/RagePlayersManager");
+const RageVehiclesManager_1 = require("../../entities/ragemp/vehicle/RageVehiclesManager");
 class RageManagersFactory {
+    createNetManager() {
+        return new RageNetManager_1.RageNetManager();
+    }
     createPlayersManager() {
         return new RagePlayersManager_1.RagePlayersManager();
     }

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./RockMod";
+export * from "./entities";
+export * from "./common/utils";

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

package/dist/server/net/altv/AltVNetManager.d.ts

@@ -0,0 +1,10 @@
+import { INetManager } from "../common/INetManager";
+import { AltVEventsManager } from "./events/AltVEventsManager";
+import { AltVRPCManager } from "./rpc/AltVRPCManager";
+export declare class AltVNetManager implements INetManager {
+    private readonly _eventsManager;
+    private readonly _rpcManager;
+    get events(): AltVEventsManager;
+    get rpc(): AltVRPCManager;
+    constructor();
+}

package/dist/server/net/altv/AltVNetManager.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVNetManager = void 0;
+const AltVEventsManager_1 = require("./events/AltVEventsManager");
+const AltVRPCManager_1 = require("./rpc/AltVRPCManager");
+class AltVNetManager {
+    _eventsManager;
+    _rpcManager;
+    get events() {
+        return this._eventsManager;
+    }
+    get rpc() {
+        return this._rpcManager;
+    }
+    constructor() {
+        this._eventsManager = new AltVEventsManager_1.AltVEventsManager();
+        this._rpcManager = new AltVRPCManager_1.AltVRPCManager();
+    }
+}
+exports.AltVNetManager = AltVNetManager;

package/dist/server/net/altv/events/AltVEventsManager.d.ts

@@ -0,0 +1,16 @@
+import { IEventsManager, INetClientEvents, INetServerEvents } from "../../common/events/IEventsManager";
+import { AltVPlayer } from "../../../entities/altv/player/AltVPlayer";
+import alt = AltVServer;
+import { AltVBaseObject } from "../../../entities/altv/baseObject/AltVBaseObject";
+export interface IAltVServerEvents extends alt.IServerEvent, INetServerEvents {
+    "rm::entityCreated"(baseObject: AltVBaseObject<alt.BaseObject>): void;
+    "rm::entityDestroyed"(baseObject: AltVBaseObject<alt.BaseObject>): void;
+}
+export interface IAltVClientEvents extends INetClientEvents {
+}
+export declare class AltVEventsManager implements IEventsManager {
+    on<K extends keyof IAltVServerEvents>(events: Record<K, (...args: Parameters<IAltVServerEvents[K]>) => void>): void;
+    off<K extends keyof IAltVServerEvents>(eventName: K, listener: (...args: Parameters<IAltVServerEvents[K]>) => void): void;
+    emit<K extends keyof IAltVServerEvents>(eventName: K, ...args: Parameters<IAltVServerEvents[K]>): void;
+    emitClient<K extends keyof IAltVClientEvents>(player: AltVPlayer, eventName: K, ...args: Parameters<IAltVClientEvents[K]>): void;
+}

package/dist/server/net/altv/events/AltVEventsManager.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVEventsManager = void 0;
+var alt = AltVServer;
+var Player = AltVServer.Player;
+class AltVEventsManager {
+    on(events) {
+        for (const eventName of Object.keys(events)) {
+            alt.on(eventName, events[eventName]);
+        }
+    }
+    off(eventName, listener) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return alt.off(eventName, listener);
+    }
+    emit(eventName, ...args) {
+        return alt.emit(eventName, ...args);
+    }
+    emitClient(player, eventName, ...args) {
+        const mpPlayer = Player.getByID(player.id);
+        if (!mpPlayer) {
+            throw new Error(`Player with id ${player.id} not found`);
+        }
+        return mpPlayer.emit(eventName, ...args);
+    }
+}
+exports.AltVEventsManager = AltVEventsManager;

package/dist/server/net/altv/rpc/AltVRPCManager.d.ts

@@ -0,0 +1,12 @@
+import { INetClientRPC, INetServerRPC, IRPCManager } from "../../common/rpc/IRPCManager";
+import { AltVPlayer } from "../../../entities/altv/player/AltVPlayer";
+import shared = AltVShared;
+export interface IAltVServerRPC extends shared.ICustomClientServerRpc, INetServerRPC {
+}
+export interface IAltVClientRPC extends shared.ICustomServerClientRpc, INetClientRPC {
+}
+export declare class AltVRPCManager implements IRPCManager {
+    register<K extends keyof IAltVServerRPC>(rpcName: K, handler: (player: AltVPlayer, ...args: Parameters<IAltVServerRPC[K]>) => ReturnType<IAltVServerRPC[K]>): void;
+    unregister<K extends keyof IAltVServerRPC>(rpcName: K): void;
+    emitClient<K extends keyof IAltVClientRPC>(player: AltVPlayer, rpcName: K, ...args: Parameters<IAltVClientRPC[K]>): Promise<ReturnType<IAltVClientRPC[K]>>;
+}

package/dist/server/net/altv/rpc/AltVRPCManager.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVRPCManager = void 0;
+var alt = AltVServer;
+var Player = AltVServer.Player;
+class AltVRPCManager {
+    register(rpcName, handler) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return alt.onRpc(rpcName, handler);
+    }
+    unregister(rpcName) {
+        return alt.offRpc(rpcName);
+    }
+    emitClient(player, rpcName, ...args) {
+        const mpPlayer = Player.getByID(player.id);
+        if (!mpPlayer) {
+            throw new Error(`Player with id ${player.id} not found`);
+        }
+        return mpPlayer.emitRpc(rpcName, ...args);
+    }
+}
+exports.AltVRPCManager = AltVRPCManager;

package/dist/server/net/common/INetManager.d.ts

@@ -0,0 +1,6 @@
+import { IEventsManager } from "./events/IEventsManager";
+import { IRPCManager } from "./rpc/IRPCManager";
+export interface INetManager {
+    get events(): IEventsManager;
+    get rpc(): IRPCManager;
+}

package/dist/server/net/common/INetManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/net/common/events/IEventsManager.d.ts

@@ -0,0 +1,16 @@
+import { IPlayer } from "../../../entities/common/player/IPlayer";
+import { IBaseObject } from "../../../entities/common/baseObject/IBaseObject";
+export interface INetServerEvents {
+    "rm::playerConnected"(player: IPlayer): void;
+    "rm::playerDisconnected"(player: IPlayer): void;
+    "rm::entityCreated"(entity: IBaseObject): void;
+    "rm::entityDestroyed"(entity: IBaseObject): void;
+}
+export interface INetClientEvents {
+}
+export interface IEventsManager {
+    on<K extends keyof INetServerEvents>(events: Record<K, (...args: Parameters<INetServerEvents[K]>) => void>): void;
+    off<K extends keyof INetServerEvents>(eventName: K, listener: (...args: Parameters<INetServerEvents[K]>) => void): void;
+    emit<K extends keyof INetServerEvents>(eventName: K, ...args: Parameters<INetServerEvents[K]>): void;
+    emitClient<K extends keyof INetClientEvents>(player: IPlayer, eventName: K, ...args: Parameters<INetClientEvents[K]>): void;
+}

package/dist/server/net/common/events/IEventsManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/net/common/rpc/IRPCManager.d.ts

@@ -0,0 +1,10 @@
+import { IPlayer } from "../../../entities/common/player/IPlayer";
+export interface INetServerRPC {
+}
+export interface INetClientRPC {
+}
+export interface IRPCManager {
+    register<K extends keyof INetServerRPC>(rpcName: K, handler: (player: IPlayer, ...args: Parameters<INetServerRPC[K]>) => ReturnType<INetServerRPC[K]>): void;
+    unregister<K extends keyof INetServerRPC>(rpcName: K): void;
+    emitClient<K extends keyof INetClientRPC>(player: IPlayer, rpcName: K, ...args: Parameters<INetClientRPC[K]>): Promise<ReturnType<INetClientRPC[K]>>;
+}

package/dist/server/net/common/rpc/IRPCManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/net/ragemp/RageNetManager.d.ts

@@ -0,0 +1,10 @@
+import { INetManager } from "../common/INetManager";
+import { RageEventsManager } from "./events/RageEventsManager";
+import { RageRPCManager } from "./rpc/RageRPCManager";
+export declare class RageNetManager implements INetManager {
+    private readonly _eventsManager;
+    private readonly _rpcManager;
+    get events(): RageEventsManager;
+    get rpc(): RageRPCManager;
+    constructor();
+}

package/dist/server/net/ragemp/RageNetManager.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageNetManager = void 0;
+const RageEventsManager_1 = require("./events/RageEventsManager");
+const RageRPCManager_1 = require("./rpc/RageRPCManager");
+class RageNetManager {
+    _eventsManager;
+    _rpcManager;
+    get events() {
+        return this._eventsManager;
+    }
+    get rpc() {
+        return this._rpcManager;
+    }
+    constructor() {
+        this._eventsManager = new RageEventsManager_1.RageEventsManager();
+        this._rpcManager = new RageRPCManager_1.RageRPCManager();
+    }
+}
+exports.RageNetManager = RageNetManager;

package/dist/server/net/ragemp/events/RageEventsManager.d.ts

@@ -0,0 +1,19 @@
+import { IEventsManager, INetClientEvents, INetServerEvents } from "../../common/events/IEventsManager";
+import { RagePlayer } from "../../../entities/ragemp/player/RagePlayer";
+import { RageBaseObject } from "../../../entities/ragemp/baseObject/RageBaseObject";
+export interface IRageServerEvents extends IServerEvents, INetServerEvents {
+    "rm::playerConnected"(player: RagePlayer): void;
+    "rm::playerDisconnected"(player: RagePlayer): void;
+    "rm::entityCreated"(entity: RageBaseObject): void;
+    "rm::entityDestroyed"(entity: RageBaseObject): void;
+    playerJoin(player: PlayerMp): void;
+    playerQuit(player: PlayerMp): void;
+}
+export interface IRageClientEvents extends INetClientEvents {
+}
+export declare class RageEventsManager implements IEventsManager {
+    on<K extends keyof IRageServerEvents>(events: Record<K, (...args: Parameters<IRageServerEvents[K]>) => void>): void;
+    off<K extends keyof IRageServerEvents>(eventName: K, listener: (...args: Parameters<IRageServerEvents[K]>) => void): void;
+    emit<K extends keyof IRageServerEvents>(eventName: K, ...args: Parameters<IRageServerEvents[K]>): void;
+    emitClient<K extends keyof IRageClientEvents>(player: RagePlayer, eventName: K, ...args: Parameters<IRageClientEvents[K]>): void;
+}

package/dist/server/net/ragemp/events/RageEventsManager.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageEventsManager = void 0;
+class RageEventsManager {
+    on(events) {
+        for (const eventName of Object.keys(events)) {
+            mp.events.add(eventName, events[eventName]);
+        }
+    }
+    off(eventName, listener) {
+        return mp.events.remove(eventName, listener);
+    }
+    emit(eventName, ...args) {
+        return mp.events.call(eventName, ...args);
+    }
+    emitClient(player, eventName, ...args) {
+        const mpPlayer = mp.players.at(player.id);
+        if (!mpPlayer) {
+            throw new Error(`Player with id ${player.id} not found`);
+        }
+        return mpPlayer.call(eventName, args);
+    }
+}
+exports.RageEventsManager = RageEventsManager;

package/dist/server/net/ragemp/rpc/RageRPCManager.d.ts

@@ -0,0 +1,11 @@
+import { INetClientRPC, INetServerRPC, IRPCManager } from "../../common/rpc/IRPCManager";
+import { RagePlayer } from "../../../entities/ragemp/player/RagePlayer";
+export interface IRageServerRPC extends INetServerRPC {
+}
+export interface IRageClientRPC extends INetClientRPC {
+}
+export declare class RageRPCManager implements IRPCManager {
+    register<K extends keyof IRageServerRPC>(rpcName: K, handler: (player: RagePlayer, ...args: Parameters<IRageServerRPC[K]>) => ReturnType<IRageServerRPC[K]>): void;
+    unregister<K extends keyof IRageServerRPC>(rpcName: K): void;
+    emitClient<K extends keyof IRageClientRPC>(player: RagePlayer, rpcName: K, ...args: Parameters<IRageClientRPC[K]>): Promise<ReturnType<IRageClientRPC[K]>>;
+}

package/dist/server/net/ragemp/rpc/RageRPCManager.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageRPCManager = void 0;
+class RageRPCManager {
+    register(rpcName, handler) {
+        return mp.events.addProc(rpcName, handler);
+    }
+    unregister(rpcName) {
+        return mp.events.remove(rpcName);
+    }
+    emitClient(player, rpcName, ...args) {
+        const mpPlayer = mp.players.at(player.id);
+        if (!mpPlayer) {
+            throw new Error(`Player with id ${player.id} not found`);
+        }
+        return mpPlayer.callProc(rpcName, args);
+    }
+}
+exports.RageRPCManager = RageRPCManager;