rock-mod 0.7.2 → 0.8.0

package/dist/server/entities/mock/vehicle/MockVehicle.d.ts

@@ -0,0 +1,42 @@
+import { IVehicle } from "../../common/vehicle/IVehicle";
+import { MockEntity, IMockEntityOptions } from "../entity/MockEntity";
+import { RGBA } from "../../../common/utils";
+import { MockPlayer } from "../player/MockPlayer";
+export interface IMockVehicleOptions extends IMockEntityOptions {
+    engine?: boolean;
+    locked?: boolean;
+}
+export declare class MockVehicle extends MockEntity implements IVehicle {
+    private _bodyHealth;
+    private _engineHealth;
+    private _numberPlate;
+    private _isLocked;
+    private _isDead;
+    private _primaryColor;
+    private _secondaryColor;
+    private _customPrimaryColor;
+    private _customSecondaryColor;
+    private _passengers;
+    get bodyHealth(): number;
+    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(): MockPlayer | null;
+    get passengers(): Set<MockPlayer>;
+    constructor(options: IMockVehicleOptions);
+    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/mock/vehicle/MockVehicle.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockVehicle = void 0;
+const MockEntity_1 = require("../entity/MockEntity");
+const utils_1 = require("../../../common/utils");
+class MockVehicle extends MockEntity_1.MockEntity {
+    _bodyHealth;
+    _engineHealth;
+    _numberPlate;
+    _isLocked;
+    _isDead;
+    _primaryColor;
+    _secondaryColor;
+    _customPrimaryColor;
+    _customSecondaryColor;
+    _passengers;
+    get bodyHealth() {
+        return this._bodyHealth;
+    }
+    get engineHealth() {
+        return this._engineHealth;
+    }
+    get numberPlate() {
+        return this._numberPlate;
+    }
+    get isLocked() {
+        return this._isLocked;
+    }
+    get isDead() {
+        return this._isDead;
+    }
+    get primaryColor() {
+        return this._primaryColor;
+    }
+    get secondaryColor() {
+        return this._secondaryColor;
+    }
+    get customPrimaryColor() {
+        const { r, g, b, a = 255 } = this._customPrimaryColor;
+        return new utils_1.RGBA(r, g, b, a);
+    }
+    get customSecondaryColor() {
+        const { r, g, b, a } = this._customSecondaryColor;
+        return new utils_1.RGBA(r, g, b, a);
+    }
+    get driver() {
+        for (const passenger of this._passengers.values()) {
+            if (passenger.seat === 0) {
+                return passenger;
+            }
+        }
+        return null;
+    }
+    get passengers() {
+        return this._passengers;
+    }
+    constructor(options) {
+        super(options);
+        this._bodyHealth = 1000;
+        this._engineHealth = 1000;
+        this._numberPlate = "";
+        this._isLocked = options.locked ?? false;
+        this._isDead = false;
+        this._primaryColor = 0;
+        this._secondaryColor = 0;
+        this._customPrimaryColor = new utils_1.RGBA(0, 0, 0);
+        this._customSecondaryColor = new utils_1.RGBA(0, 0, 0);
+        this._passengers = new Set();
+    }
+    setBodyHealth(value) {
+        this._bodyHealth = value;
+    }
+    setEngineHealth(value) {
+        this._engineHealth = Math.clamp(value, 0, 1000);
+    }
+    setNumberPlate(value) {
+        this._numberPlate = value;
+    }
+    setLocked(value) {
+        this._isLocked = value;
+    }
+    setPrimaryColor(value) {
+        this._primaryColor = value;
+    }
+    setSecondaryColor(value) {
+        this._secondaryColor = value;
+    }
+    setCustomPrimaryColor(value) {
+        this._customPrimaryColor = value;
+    }
+    setCustomSecondaryColor(value) {
+        this._customSecondaryColor = value;
+    }
+    explode() {
+        this.setBodyHealth(0);
+        this.setEngineHealth(0);
+    }
+    repair() {
+        this.setBodyHealth(1000);
+        this.setEngineHealth(1000);
+    }
+}
+exports.MockVehicle = MockVehicle;

package/dist/server/entities/mock/vehicle/MockVehiclesManager.d.ts

@@ -0,0 +1,10 @@
+import { IVehicleCreateOptions, IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+import { MockEntitiesManager } from "../entity/MockEntitiesManager";
+import { MockVehicle } from "./MockVehicle";
+export interface IMockVehicleCreateOptions extends IVehicleCreateOptions {
+}
+export declare class MockVehiclesManager extends MockEntitiesManager<MockVehicle> implements IVehiclesManager {
+    private _nextId;
+    constructor();
+    create(options: IMockVehicleCreateOptions): MockVehicle;
+}

package/dist/server/entities/mock/vehicle/MockVehiclesManager.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockVehiclesManager = void 0;
+const MockEntitiesManager_1 = require("../entity/MockEntitiesManager");
+const MockVehicle_1 = require("./MockVehicle");
+const RockMod_1 = require("../../../RockMod");
+const common_1 = require("../../common");
+class MockVehiclesManager extends MockEntitiesManager_1.MockEntitiesManager {
+    _nextId;
+    constructor() {
+        super({
+            baseObjectsType: "vehicle",
+        });
+        this._nextId = 0;
+    }
+    create(options) {
+        const { model, engine, locked, position, dimension, rotation } = options;
+        const vehicle = new MockVehicle_1.MockVehicle({
+            id: this._nextId++,
+            type: common_1.BaseObjectType.Vehicle,
+            model: RockMod_1.RockMod.instance.utils.hash(model),
+            engine,
+            locked,
+            position,
+            dimension,
+            rotation,
+        });
+        this.registerBaseObject(vehicle);
+        return vehicle;
+    }
+}
+exports.MockVehiclesManager = MockVehiclesManager;

package/dist/server/entities/mock/worldObject/MockWorldObject.d.ts

@@ -0,0 +1,12 @@
+import { IWorldObject } from "../../common/worldObject/IWorldObject";
+import { MockBaseObject, IMockBaseObjectOptions } from "../baseObject/MockBaseObject";
+import { IVector3D } from "../../../common/utils/math/Vectors";
+export interface IMockWorldObjectOptions extends IMockBaseObjectOptions {
+    position: IVector3D;
+    dimension: number;
+}
+export declare abstract class MockWorldObject extends MockBaseObject implements IWorldObject {
+    protected constructor(options: IMockWorldObjectOptions);
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+}

package/dist/server/entities/mock/worldObject/MockWorldObject.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWorldObject = void 0;
+const MockBaseObject_1 = require("../baseObject/MockBaseObject");
+class MockWorldObject extends MockBaseObject_1.MockBaseObject {
+    constructor(options) {
+        super(options);
+    }
+    setPosition(value) {
+        this.position = value;
+    }
+    setDimension(value) {
+        this.dimension = value;
+    }
+}
+exports.MockWorldObject = MockWorldObject;

package/dist/server/entities/mock/worldObject/MockWorldObjectsIterator.d.ts

@@ -0,0 +1,10 @@
+import { IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { MockWorldObject } from "./MockWorldObject";
+import { MockBaseObjectsIterator } from "../baseObject/MockBaseObjectsIterator";
+import { Vector2D, Vector3D } from "../../../common/utils/math/Vectors";
+export declare class MockWorldObjectsIterator<T extends MockWorldObject> extends MockBaseObjectsIterator<T> implements IWorldObjectsIterator<T> {
+    constructor(baseObjects: ReadonlyMap<number, T>);
+    dimension(value: number): IterableIterator<T>;
+    range2D(center: Vector2D, range: number): IterableIterator<T>;
+    range3D(center: Vector3D, range: number): IterableIterator<T>;
+}

package/dist/server/entities/mock/worldObject/MockWorldObjectsIterator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWorldObjectsIterator = void 0;
+const MockBaseObjectsIterator_1 = require("../baseObject/MockBaseObjectsIterator");
+class MockWorldObjectsIterator extends MockBaseObjectsIterator_1.MockBaseObjectsIterator {
+    constructor(baseObjects) {
+        super(baseObjects);
+    }
+    *dimension(value) {
+        for (const worldObject of this.all()) {
+            if (worldObject.dimension === value) {
+                yield worldObject;
+            }
+        }
+    }
+    *range2D(center, range) {
+        const rangeSquared = range * range;
+        for (const worldObject of this.all()) {
+            const { position } = worldObject;
+            const distanceSquared = (center.x - position.x) * (center.x - position.x) + (center.y - position.y) * (center.y - position.y);
+            if (distanceSquared <= rangeSquared) {
+                yield worldObject;
+            }
+        }
+    }
+    *range3D(center, range) {
+        const rangeSquared = range * range;
+        for (const worldObject of this.all()) {
+            const { position } = worldObject;
+            const distanceSquared = (center.x - position.x) * (center.x - position.x) +
+                (center.y - position.y) * (center.y - position.y) +
+                (center.z - position.z) * (center.z - position.z);
+            if (distanceSquared <= rangeSquared) {
+                yield worldObject;
+            }
+        }
+    }
+}
+exports.MockWorldObjectsIterator = MockWorldObjectsIterator;

package/dist/server/entities/mock/worldObject/MockWorldObjectsManager.d.ts

@@ -0,0 +1,11 @@
+import { IWorldObjectsManager } from "../../common/worldObject/IWorldObjectsManager";
+import { MockWorldObject } from "./MockWorldObject";
+import { IMockBaseObjectsManagerOptions, MockBaseObjectsManager } from "../baseObject/MockBaseObjectsManager";
+import { MockWorldObjectsIterator } from "./MockWorldObjectsIterator";
+export interface IMockWorldObjectsManagerOptions extends IMockBaseObjectsManagerOptions {
+}
+export declare abstract class MockWorldObjectsManager<T extends MockWorldObject> extends MockBaseObjectsManager<T> implements IWorldObjectsManager<T> {
+    protected readonly _iterator: MockWorldObjectsIterator<T>;
+    protected constructor(options: IMockWorldObjectsManagerOptions);
+    get iterator(): MockWorldObjectsIterator<T>;
+}

package/dist/server/entities/mock/worldObject/MockWorldObjectsManager.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWorldObjectsManager = void 0;
+const MockBaseObjectsManager_1 = require("../baseObject/MockBaseObjectsManager");
+const MockWorldObjectsIterator_1 = require("./MockWorldObjectsIterator");
+class MockWorldObjectsManager extends MockBaseObjectsManager_1.MockBaseObjectsManager {
+    _iterator;
+    constructor(options) {
+        super(options);
+        this._iterator = new MockWorldObjectsIterator_1.MockWorldObjectsIterator(this.baseObjects);
+    }
+    get iterator() {
+        return this._iterator;
+    }
+}
+exports.MockWorldObjectsManager = MockWorldObjectsManager;

package/dist/server/entities/ragemp/marker/RageMarker.d.ts

@@ -1,11 +1,17 @@
-import { IMarker } from "../../common";
+import { IMarker, IMarkerType } from "../../common";
 import { IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
+import { IRGBA, IVector3D } from "../../../common/utils";
 export interface IRageMarkerOptions extends IRageWorldObjectOptions<MarkerMp> {
 }
 export declare class RageMarker extends RageWorldObject<MarkerMp> implements IMarker {
+    get markerType(): IMarkerType;
     get visible(): boolean;
     get scale(): number;
+    get color(): IRGBA;
+    get rotation(): IVector3D;
     constructor(options: IRageMarkerOptions);
     setVisible(value: boolean): void;
     setScale(value: number): void;
+    setColor(value: IRGBA): void;
+    setRotation(value: IVector3D): void;
 }

package/dist/server/entities/ragemp/marker/RageMarker.js

@@ -2,13 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageMarker = void 0;
 const RageWorldObject_1 = require("../worldObject/RageWorldObject");
+const utils_1 = require("../../../common/utils");
+var RGBA = AltVShared.RGBA;
 class RageMarker extends RageWorldObject_1.RageWorldObject {
+    get markerType() {
+        return this.mpEntity.model;
+    }
     get visible() {
         return this.mpEntity.visible;
     }
     get scale() {
         return this.mpEntity.scale;
     }
+    get color() {
+        const [r, g, b, a] = this.mpEntity.getColor();
+        return new RGBA(r, g, b, a ?? 255);
+    }
+    get rotation() {
+        const { x, y, z } = this.mpEntity.rotation;
+        return new utils_1.Vector3D(x, y, z);
+    }
     constructor(options) {
         super(options);
     }
@@ -18,5 +31,12 @@ class RageMarker extends RageWorldObject_1.RageWorldObject {
     setScale(value) {
         this.mpEntity.scale = value;
     }
+    setColor(value) {
+        const { r, g, b, a } = value;
+        this.mpEntity.setColor(r, g, b, a ?? 255);
+    }
+    setRotation(value) {
+        this.mpEntity.rotation = new mp.Vector3(value);
+    }
 }
 exports.RageMarker = RageMarker;

package/dist/server/entities/ragemp/ped/RagePedsManager.js

@@ -10,10 +10,11 @@ class RagePedsManager extends RageEntitiesManager_1.RageEntitiesManager {
         });
     }
     create(options) {
-        const { model, position, dimension, rotation } = options;
+        const { model, frozen, position, dimension, rotation } = options;
         const mpEntity = mp.peds.new(mp.joaat(model), new mp.Vector3(position), {
             dimension,
             heading: rotation.z,
+            frozen,
         });
         mpEntity.isExists = () => mp.peds.exists(mpEntity);
         const ped = new RagePed_1.RagePed({ mpEntity });

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

@@ -12,6 +12,7 @@ export declare class RagePlayer extends RageEntity<PlayerMp> implements IPlayer
     get heading(): number;
     get health(): number;
     get armour(): number;
+    get isDead(): boolean;
     get ip(): string;
     get serial(): string;
     get vehicle(): RageVehicle | null;

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

@@ -19,6 +19,9 @@ class RagePlayer extends RageEntity_1.RageEntity {
     get armour() {
         return this.mpEntity.armour;
     }
+    get isDead() {
+        return this.mpEntity.health <= 0;
+    }
     get ip() {
         return this.mpEntity.ip;
     }

package/dist/server/factories/mock/MockManagersFactory.d.ts

@@ -0,0 +1,21 @@
+import { IManagersFactory } from "../common/IManagersFactory";
+import { MockNetManager } from "../../net/mock/MockNetManager";
+import { MockPlayersManager } from "../../entities/mock/player/MockPlayersManager";
+import { IUtilsManager } from "../../utils";
+import { MockBlipsManager } from "../../entities/mock/blip/MockBlipsManager";
+import { MockColshapesManager } from "../../entities/mock/colshape/MockColshapesManager";
+import { MockMarkersManager } from "../../entities/mock/marker/MockMarkersManager";
+import { MockObjectsManager } from "../../entities/mock/object/MockObjectsManager";
+import { MockPedsManager } from "../../entities/mock/ped/MockPedsManager";
+import { MockVehiclesManager } from "../../entities/mock/vehicle/MockVehiclesManager";
+export declare class MockManagersFactory implements IManagersFactory {
+    createNetManager(): MockNetManager;
+    createBlipsManager(): MockBlipsManager;
+    createColshapesManager(): MockColshapesManager;
+    createMarkersManager(): MockMarkersManager;
+    createObjectsManager(): MockObjectsManager;
+    createPedsManager(): MockPedsManager;
+    createPlayersManager(): MockPlayersManager;
+    createUtilsManager(): IUtilsManager;
+    createVehiclesManager(): MockVehiclesManager;
+}

package/dist/server/factories/mock/MockManagersFactory.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockManagersFactory = void 0;
+const MockNetManager_1 = require("../../net/mock/MockNetManager");
+const MockPlayersManager_1 = require("../../entities/mock/player/MockPlayersManager");
+const MockBlipsManager_1 = require("../../entities/mock/blip/MockBlipsManager");
+const MockColshapesManager_1 = require("../../entities/mock/colshape/MockColshapesManager");
+const MockMarkersManager_1 = require("../../entities/mock/marker/MockMarkersManager");
+const MockObjectsManager_1 = require("../../entities/mock/object/MockObjectsManager");
+const MockPedsManager_1 = require("../../entities/mock/ped/MockPedsManager");
+const MockVehiclesManager_1 = require("../../entities/mock/vehicle/MockVehiclesManager");
+class MockManagersFactory {
+    createNetManager() {
+        return new MockNetManager_1.MockNetManager();
+    }
+    createBlipsManager() {
+        return new MockBlipsManager_1.MockBlipsManager();
+    }
+    createColshapesManager() {
+        return new MockColshapesManager_1.MockColshapesManager();
+    }
+    createMarkersManager() {
+        return new MockMarkersManager_1.MockMarkersManager();
+    }
+    createObjectsManager() {
+        return new MockObjectsManager_1.MockObjectsManager();
+    }
+    createPedsManager() {
+        return new MockPedsManager_1.MockPedsManager();
+    }
+    createPlayersManager() {
+        return new MockPlayersManager_1.MockPlayersManager();
+    }
+    createUtilsManager() {
+        throw new Error("Utils manager not implemented in mock mode");
+    }
+    createVehiclesManager() {
+        return new MockVehiclesManager_1.MockVehiclesManager();
+    }
+}
+exports.MockManagersFactory = MockManagersFactory;

package/dist/server/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./RockMod";
-export * from "./entities";
 export * from "./common/utils";
+export { BaseObjectType, IBaseObject as IRockModBaseObject, IBlip as IRockModBlip, IColshape as IRockModColshape, IEntity as IRockModEntity, IMarker as IRockModMarker, IObject as IRockModObject, IPed as IRockModPed, IPlayer as IRockModPlayer, IVehicle as IRockModVehicle, IWorldObject as IRockModWorldObject, } from "./entities";
+export { INetServerEvents, INetClientEvents } from "./net/common/events/IEventsManager";
+export { INetServerRPC, INetClientRPC } from "./net/common/rpc/IRPCManager";

package/dist/server/index.js

@@ -14,6 +14,8 @@ 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 });
+exports.BaseObjectType = void 0;
 __exportStar(require("./RockMod"), exports);
-__exportStar(require("./entities"), exports);
 __exportStar(require("./common/utils"), exports);
+var entities_1 = require("./entities");
+Object.defineProperty(exports, "BaseObjectType", { enumerable: true, get: function () { return entities_1.BaseObjectType; } });

package/dist/server/net/mock/MockNetManager.d.ts

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

package/dist/server/net/mock/MockNetManager.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockNetManager = void 0;
+const MockEventsManager_1 = require("./events/MockEventsManager");
+const MockRPCManager_1 = require("./rpc/MockRPCManager");
+class MockNetManager {
+    _eventsManager;
+    _rpcManager;
+    get events() {
+        return this._eventsManager;
+    }
+    get rpc() {
+        return this._rpcManager;
+    }
+    constructor() {
+        this._eventsManager = new MockEventsManager_1.MockEventsManager();
+        this._rpcManager = new MockRPCManager_1.MockRPCManager();
+    }
+}
+exports.MockNetManager = MockNetManager;

package/dist/server/net/mock/events/MockEventsManager.d.ts

@@ -0,0 +1,18 @@
+import { IEventsManager, INetClientEvents, INetServerEvents } from "../../common/events/IEventsManager";
+import { MockPlayer } from "../../../entities/mock/player/MockPlayer";
+import { MockBaseObject } from "../../../entities/mock/baseObject/MockBaseObject";
+export interface IMockServerEvents extends INetServerEvents {
+    "rm::playerConnected"(player: MockPlayer): void;
+    "rm::playerDisconnected"(player: MockPlayer): void;
+    "rm::entityCreated"(entity: MockBaseObject): void;
+    "rm::entityDestroyed"(entity: MockBaseObject): void;
+}
+export interface IMockClientEvents extends INetClientEvents {
+}
+export declare class MockEventsManager implements IEventsManager {
+    private readonly _eventEmitter;
+    on<K extends keyof IMockServerEvents>(events: Record<K, (...args: Parameters<IMockServerEvents[K]>) => void>): void;
+    off<K extends keyof IMockServerEvents>(eventName: K, listener: (...args: Parameters<IMockServerEvents[K]>) => void): void;
+    emit<K extends keyof IMockServerEvents>(eventName: K, ...args: Parameters<IMockServerEvents[K]>): void;
+    emitClient(): void;
+}

package/dist/server/net/mock/events/MockEventsManager.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockEventsManager = void 0;
+const events_1 = require("events");
+class MockEventsManager {
+    _eventEmitter = new events_1.EventEmitter();
+    on(events) {
+        for (const [eventName, handler] of Object.entries(events)) {
+            this._eventEmitter.on(eventName, handler);
+        }
+    }
+    off(eventName, listener) {
+        this._eventEmitter.off(eventName, listener);
+    }
+    emit(eventName, ...args) {
+        this._eventEmitter.emit(eventName, ...args);
+    }
+    emitClient() {
+        throw new Error("Method not implemented");
+    }
+}
+exports.MockEventsManager = MockEventsManager;

package/dist/server/net/mock/rpc/MockRPCManager.d.ts

@@ -0,0 +1,13 @@
+import { INetClientRPC, INetServerRPC, IRPCManager } from "../../common/rpc/IRPCManager";
+import { IPlayer } from "../../../entities/common/player/IPlayer";
+import { MockPlayer } from "../../../entities/mock/player/MockPlayer";
+export interface IMockServerRPC extends INetServerRPC {
+}
+export interface IMockClientRPC extends INetClientRPC {
+}
+export declare class MockRPCManager implements IRPCManager {
+    private readonly _handlers;
+    register<K extends keyof IMockServerRPC>(rpcName: K, handler: (player: MockPlayer, ...args: Parameters<IMockServerRPC[K]>) => ReturnType<IMockServerRPC[K]>): void;
+    unregister<K extends keyof IMockServerRPC>(rpcName: K): void;
+    emitClient<K extends keyof IMockClientRPC>(player: IPlayer, rpcName: K, ...args: Parameters<IMockClientRPC[K]>): Promise<ReturnType<IMockClientRPC[K]>>;
+}

package/dist/server/net/mock/rpc/MockRPCManager.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockRPCManager = void 0;
+class MockRPCManager {
+    _handlers = new Map();
+    register(rpcName, handler) {
+        this._handlers.set(rpcName, handler);
+    }
+    unregister(rpcName) {
+        this._handlers.delete(rpcName);
+    }
+    emitClient(player, rpcName, ...args) {
+        const handler = this._handlers.get(rpcName);
+        if (handler) {
+            try {
+                const result = handler(player, ...args);
+                return Promise.resolve(result);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }
+        return Promise.resolve(null);
+    }
+}
+exports.MockRPCManager = MockRPCManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rock-mod",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Rock-Mod is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -57,6 +57,7 @@
     "husky": "^9.1.6",
     "lint-staged": "^15.2.10",
     "prettier": "^3.3.3",
-    "typescript": "^5.6.2"
+    "typescript": "^5.6.2",
+    "@types/node": "^20.10.4"
   }
 }