rock-mod 0.8.2 → 0.9.0

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

@@ -1,4 +1,5 @@
-import { BaseObjectType, IBaseObject, IBaseObjectOptions } from "../../common/baseObject/IBaseObject";
+import { IBaseObject, IBaseObjectOptions } from "../../common/baseObject/IBaseObject";
+import { BaseObjectType } from "../../../../shared";
 export interface IRageBaseObjectOptions<T extends EntityMp> extends IBaseObjectOptions {
     mpEntity: T;
 }

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageBaseObject = void 0;
 // RAGEMP BUG: event 'entityDestroyed' is not callable
-const unsupportedRageEntityTypes = new Set(["blip", "colshape", "object"]);
+const unsupportedRageEntityTypes = new Set(["blip", "colshape", "object", "vehicle"]);
 class RageBaseObject {
     _mpEntity;
     get id() {

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageBaseObjectsManager = void 0;
 const RageBaseObjectsIterator_1 = require("./RageBaseObjectsIterator");
 const RockMod_1 = require("../../../RockMod");
+const types_1 = require("../../../net/common/events/types");
 class RageBaseObjectsManager {
     _baseObjects;
     _baseObjectsType;
@@ -40,13 +41,13 @@ class RageBaseObjectsManager {
             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);
+        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.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);
+        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.EntityCreated, baseObject);
     }
 }
 exports.RageBaseObjectsManager = RageBaseObjectsManager;

package/dist/server/entities/ragemp/blip/RageBlip.d.ts

@@ -1,5 +1,6 @@
 import { IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
-import { IBlip, IBlipColor, IBlipSprite } from "../../common";
+import { IBlip } from "../../common";
+import { IBlipColor, IBlipSprite } from "../../../../shared";
 export interface IRageBlipOptions extends IRageWorldObjectOptions<EntityMp> {
 }
 export declare class RageBlip extends RageWorldObject<EntityMp> implements IBlip {

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

@@ -1,6 +1,6 @@
 import { IEntity } from "../../common/entity/IEntity";
 import { IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
-import { Vector3D } from "../../../common/utils";
+import { Vector3D } from "../../../../shared/common/utils";
 export interface IRageEntityOptions<T extends EntityMp> extends IRageWorldObjectOptions<T> {
 }
 export declare abstract class RageEntity<T extends EntityMp> extends RageWorldObject<T> implements IEntity {

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageEntity = void 0;
 const RageWorldObject_1 = require("../worldObject/RageWorldObject");
-const utils_1 = require("../../../common/utils");
+const utils_1 = require("../../../../shared/common/utils");
 class RageEntity extends RageWorldObject_1.RageWorldObject {
     get model() {
         return this.mpEntity.model;

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

@@ -1,6 +1,7 @@
-import { IMarker, IMarkerType } from "../../common";
+import { IMarker } from "../../common";
 import { IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
-import { IRGBA, IVector3D } from "../../../common/utils";
+import { IRGBA, IVector3D } from "../../../../shared/common/utils";
+import { IMarkerType } from "../../../../shared";
 export interface IRageMarkerOptions extends IRageWorldObjectOptions<MarkerMp> {
 }
 export declare class RageMarker extends RageWorldObject<MarkerMp> implements IMarker {

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageMarker = void 0;
 const RageWorldObject_1 = require("../worldObject/RageWorldObject");
-const utils_1 = require("../../../common/utils");
+const utils_1 = require("../../../../shared/common/utils");
 class RageMarker extends RageWorldObject_1.RageWorldObject {
     get markerType() {
         return this.mpEntity.model;

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

@@ -16,7 +16,7 @@ class RageMarkersManager extends RageWorldObjectsManager_1.RageWorldObjectsManag
             dimension,
             rotation: new mp.Vector3(rotation),
         });
-        mpEntity.isExists = () => mp.objects.exists(mpEntity);
+        mpEntity.isExists = () => mp.markers.exists(mpEntity);
         const marker = new RageMarker_1.RageMarker({ mpEntity });
         this.registerBaseObject(marker);
         return marker;

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

@@ -1,9 +1,8 @@
 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";
+import { IServerToClientEvents, Vector3D } from "../../../../shared";
+import { IClientRPCList } from "../../../../shared/net/common/rpc/types";
 interface IRagePlayerOptions extends IRageEntityOptions<PlayerMp> {
 }
 export declare class RagePlayer extends RageEntity<PlayerMp> implements IPlayer {
@@ -22,8 +21,8 @@ export declare class RagePlayer extends RageEntity<PlayerMp> implements IPlayer
     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]>>;
+    emitEvent<K extends keyof IServerToClientEvents>(eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
+    emitRPC<K extends keyof IClientRPCList>(rpcName: K, ...args: Parameters<IClientRPCList[K]>): Promise<ReturnType<IClientRPCList[K]>>;
     spawn(position: Vector3D): void;
     setName(name: string): void;
     setHeading(value: number): void;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RagePlayer = void 0;
 const RageEntity_1 = require("../entity/RageEntity");
 const RockMod_1 = require("../../../RockMod");
+const Math_1 = require("../../../../shared/common/utils/math/Math");
 class RagePlayer extends RageEntity_1.RageEntity {
     get name() {
         return this.mpEntity.name;
@@ -73,10 +74,10 @@ class RagePlayer extends RageEntity_1.RageEntity {
         this.mpEntity.heading = value;
     }
     setHealth(value) {
-        this.mpEntity.health = Math.clamp(value, 0, 100);
+        this.mpEntity.health = (0, Math_1.MathClamp)(value, 0, 100);
     }
     setArmour(value) {
-        this.mpEntity.armour = Math.clamp(value, 0, 100);
+        this.mpEntity.armour = (0, Math_1.MathClamp)(value, 0, 100);
     }
     setWeaponAmmo(weapon, ammo) {
         return this.mpEntity.setWeaponAmmo(mp.joaat(weapon), ammo);

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

@@ -3,7 +3,7 @@ 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");
+const types_1 = require("../../../net/common/events/types");
 class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
     constructor(net) {
         super({
@@ -42,19 +42,19 @@ class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
         return null;
     }
     _init(net) {
-        net.events.on({
+        net.events.onInternal({
             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);
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerConnected, player);
             },
             playerQuit: (mpPlayer) => {
                 const player = this.getByID(mpPlayer.id);
                 this.unregisterBaseObject(player);
-                net.events.emit("rm::playerDisconnected", player);
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerDisconnected, player);
             },
         });
     }

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

@@ -1,6 +1,6 @@
 import { IRageEntityOptions, RageEntity } from "../entity/RageEntity";
 import { IVehicle } from "../../common/vehicle/IVehicle";
-import { RGBA } from "../../../common/utils";
+import { RGBA } from "../../../../shared/common/utils";
 import { RagePlayer } from "../player/RagePlayer";
 export interface IRageVehicleOptions extends IRageEntityOptions<VehicleMp> {
 }

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageVehicle = void 0;
 const RageEntity_1 = require("../entity/RageEntity");
-const utils_1 = require("../../../common/utils");
+const utils_1 = require("../../../../shared/common/utils");
 const RockMod_1 = require("../../../RockMod");
 class RageVehicle extends RageEntity_1.RageEntity {
     get bodyHealth() {

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

@@ -1,6 +1,6 @@
 import { IWorldObject } from "../../common/worldObject/IWorldObject";
 import { IRageBaseObjectOptions, RageBaseObject } from "../baseObject/RageBaseObject";
-import { Vector3D } from "../../../common/utils/math/Vectors";
+import { Vector3D } from "../../../../shared/common/utils/math/Vectors";
 export interface IRageWorldObjectOptions<T extends EntityMp> extends IRageBaseObjectOptions<T> {
 }
 export declare abstract class RageWorldObject<T extends EntityMp> extends RageBaseObject<T> implements IWorldObject {

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageWorldObject = void 0;
 const RageBaseObject_1 = require("../baseObject/RageBaseObject");
-const Vectors_1 = require("../../../common/utils/math/Vectors");
+const Vectors_1 = require("../../../../shared/common/utils/math/Vectors");
 class RageWorldObject extends RageBaseObject_1.RageBaseObject {
     get position() {
         const { x, y, z } = this.mpEntity.position;

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

@@ -1,7 +1,7 @@
 import { RageWorldObject } from "./RageWorldObject";
 import { RageBaseObjectsIterator } from "../baseObject/RageBaseObjectsIterator";
 import { IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
-import { Vector2D, Vector3D } from "../../../common/utils/math/Vectors";
+import { Vector2D, Vector3D } from "../../../../shared/common/utils/math/Vectors";
 export declare class RageWorldObjectsIterator<T extends RageWorldObject<EntityMp>> extends RageBaseObjectsIterator<T> implements IWorldObjectsIterator<T> {
     constructor(baseObjects: ReadonlyMap<number, T>);
     dimension(value: number): IterableIterator<T>;

package/dist/server/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./RockMod";
-export { IRGBA as IRockModRGBA, RGBA as RockModRGBA } from "./common/utils/color";
-export { IVector2D as IRockModVector2D, IVector3D as IRockModVector3D, Vector2D as RockModVector2D, Vector3D as RockModVector3D, } from "./common/utils/math";
-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";
+export { IRGBA as IRockModRGBA, RGBA as RockModRGBA } from "../shared/common/utils/color";
+export { IVector2D as IRockModVector2D, IVector3D as IRockModVector3D, Vector2D as RockModVector2D, Vector3D as RockModVector3D, } from "../shared/common/utils/math";
+export { BaseObjectType as RockModBaseObjectType } from "../shared/entities/IBaseObject";
+export { 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 * from "./testing";

package/dist/server/index.js

@@ -14,13 +14,13 @@ 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 = exports.RockModVector3D = exports.RockModVector2D = exports.RockModRGBA = void 0;
+exports.RockModBaseObjectType = exports.RockModVector3D = exports.RockModVector2D = exports.RockModRGBA = void 0;
 __exportStar(require("./RockMod"), exports);
-var color_1 = require("./common/utils/color");
+var color_1 = require("../shared/common/utils/color");
 Object.defineProperty(exports, "RockModRGBA", { enumerable: true, get: function () { return color_1.RGBA; } });
-var math_1 = require("./common/utils/math");
+var math_1 = require("../shared/common/utils/math");
 Object.defineProperty(exports, "RockModVector2D", { enumerable: true, get: function () { return math_1.Vector2D; } });
 Object.defineProperty(exports, "RockModVector3D", { enumerable: true, get: function () { return math_1.Vector3D; } });
-var entities_1 = require("./entities");
-Object.defineProperty(exports, "BaseObjectType", { enumerable: true, get: function () { return entities_1.BaseObjectType; } });
+var IBaseObject_1 = require("../shared/entities/IBaseObject");
+Object.defineProperty(exports, "RockModBaseObjectType", { enumerable: true, get: function () { return IBaseObject_1.BaseObjectType; } });
 __exportStar(require("./testing"), exports);

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

@@ -1,16 +1,15 @@
-import { IEventsManager, INetClientEvents, INetServerEvents } from "../../common/events/IEventsManager";
+import { IEventsManager } from "../../common/events/IEventsManager";
+import { IServerInternalEvents } from "../../common/events/types";
+import { IClientToServerEvents, IServerToClientEvents } from "../../../../shared";
 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 {
+interface IAltVServerInternalEvents extends IServerInternalEvents, AltVServer.IServerEvent {
 }
 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;
+    onInternal(events: Partial<IAltVServerInternalEvents>): void;
+    offInternal<K extends keyof IServerInternalEvents>(eventName: K, listener: IServerInternalEvents[K]): void;
+    emitInternal<K extends keyof IServerInternalEvents>(eventName: K, ...args: Parameters<IServerInternalEvents[K]>): void;
+    onClient(events: Partial<IClientToServerEvents>): void;
+    offClient<K extends keyof IClientToServerEvents>(eventName: K, listener: IClientToServerEvents[K]): void;
+    emitClient<K extends keyof IServerToClientEvents>(player: AltVPlayer, eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }
+export {};

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

@@ -1,21 +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) {
+    onInternal(events) {
         for (const eventName of Object.keys(events)) {
-            alt.on(eventName, events[eventName]);
+            // @ts-expect-error Add types
+            AltVServer.on(eventName, events[eventName]);
         }
     }
-    off(eventName, listener) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        return alt.off(eventName, listener);
+    offInternal(eventName, listener) {
+        AltVServer.off(eventName, listener);
     }
-    emit(eventName, ...args) {
-        return alt.emit(eventName, ...args);
+    emitInternal(eventName, ...args) {
+        AltVServer.emit(eventName, ...args);
+    }
+    onClient(events) {
+        for (const eventName of Object.keys(events)) {
+            // @ts-expect-error Add types
+            AltVServer.onClient(eventName, events[eventName]);
+        }
+    }
+    offClient(eventName, listener) {
+        AltVServer.offClient(eventName, listener);
     }
     emitClient(player, eventName, ...args) {
         const mpPlayer = Player.getByID(player.id);

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

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

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

@@ -1,16 +1,11 @@
-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 {
-}
+import { IClientToServerEvents, IServerToClientEvents } from "../../../../shared";
+import { IServerInternalEvents } from "./types";
+import { IPlayer } from "../../../entities";
 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;
+    onInternal(events: Partial<IServerInternalEvents>): void;
+    offInternal<K extends keyof IServerInternalEvents>(eventName: K, listener: IServerInternalEvents[K]): void;
+    emitInternal<K extends keyof IServerInternalEvents>(eventName: K, ...args: Parameters<IServerInternalEvents[K]>): void;
+    onClient(events: Partial<IClientToServerEvents>): void;
+    offClient<K extends keyof IClientToServerEvents>(eventName: K, listener: IClientToServerEvents[K]): void;
+    emitClient<K extends keyof IServerToClientEvents>(player: IPlayer, eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }

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

@@ -0,0 +1,13 @@
+import { IBaseObject, IPlayer } from "../../../entities";
+export declare enum ServerInternalEventName {
+    PlayerConnected = "rm::playerConnected",
+    PlayerDisconnected = "rm::playerDisconnected",
+    EntityCreated = "rm::entityCreated",
+    EntityDestroyed = "rm::entityDestroyed"
+}
+export interface IServerInternalEvents {
+    [ServerInternalEventName.PlayerConnected]: (player: IPlayer) => void;
+    [ServerInternalEventName.PlayerDisconnected]: (player: IPlayer) => void;
+    [ServerInternalEventName.EntityCreated]: (object: IBaseObject) => void;
+    [ServerInternalEventName.EntityDestroyed]: (object: IBaseObject) => void;
+}

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerInternalEventName = void 0;
+var ServerInternalEventName;
+(function (ServerInternalEventName) {
+    ServerInternalEventName["PlayerConnected"] = "rm::playerConnected";
+    ServerInternalEventName["PlayerDisconnected"] = "rm::playerDisconnected";
+    ServerInternalEventName["EntityCreated"] = "rm::entityCreated";
+    ServerInternalEventName["EntityDestroyed"] = "rm::entityDestroyed";
+})(ServerInternalEventName || (exports.ServerInternalEventName = ServerInternalEventName = {}));

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

@@ -1,10 +1,7 @@
 import { IPlayer } from "../../../entities/common/player/IPlayer";
-export interface INetServerRPC {
-}
-export interface INetClientRPC {
-}
+import { IClientRPCList, IServerRPCList } from "../../../../shared/net/common/rpc/types";
 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]>>;
+    register<K extends keyof IServerRPCList>(rpcName: K, handler: (player: IPlayer, ...args: Parameters<IServerRPCList[K]>) => ReturnType<IServerRPCList[K]>): void;
+    unregister<K extends keyof IServerRPCList>(rpcName: K): void;
+    emitClient<K extends keyof IClientRPCList>(player: IPlayer, rpcName: K, ...args: Parameters<IClientRPCList[K]>): Promise<ReturnType<IClientRPCList[K]>>;
 }

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

@@ -1,18 +1,13 @@
-import { IEventsManager, INetClientEvents, INetServerEvents } from "../../common/events/IEventsManager";
+import { IEventsManager } from "../../common/events/IEventsManager";
+import { IServerInternalEvents } from "../../common/events/types";
+import { IClientToServerEvents, IServerToClientEvents } from "../../../../shared";
 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;
+    onInternal(events: Partial<IServerInternalEvents>): void;
+    offInternal<K extends keyof IServerInternalEvents>(eventName: K, listener: IServerInternalEvents[K]): void;
+    emitInternal<K extends keyof IServerInternalEvents>(eventName: K, ...args: Parameters<IServerInternalEvents[K]>): void;
+    onClient(events: Partial<IClientToServerEvents>): void;
+    offClient<K extends keyof IClientToServerEvents>(eventName: K, listener: IClientToServerEvents[K]): void;
+    emitClient<K extends keyof IServerToClientEvents>(player: MockPlayer, eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }

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

@@ -4,19 +4,27 @@ exports.MockEventsManager = void 0;
 const events_1 = require("events");
 class MockEventsManager {
     _eventEmitter = new events_1.EventEmitter();
-    on(events) {
+    onInternal(events) {
         for (const [eventName, handler] of Object.entries(events)) {
             this._eventEmitter.on(eventName, handler);
         }
     }
-    off(eventName, listener) {
+    offInternal(eventName, listener) {
         this._eventEmitter.off(eventName, listener);
     }
-    emit(eventName, ...args) {
+    emitInternal(eventName, ...args) {
         this._eventEmitter.emit(eventName, ...args);
     }
-    emitClient() {
-        throw new Error("Method not implemented");
+    onClient(events) {
+        for (const [eventName, handler] of Object.entries(events)) {
+            this._eventEmitter.on(eventName, handler);
+        }
+    }
+    offClient(eventName, listener) {
+        this._eventEmitter.off(eventName, listener);
+    }
+    emitClient(player, eventName, ...args) {
+        this._eventEmitter.emit(eventName, player, ...args);
     }
 }
 exports.MockEventsManager = MockEventsManager;

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

@@ -1,9 +1,10 @@
-import { INetClientRPC, INetServerRPC, IRPCManager } from "../../common/rpc/IRPCManager";
+import { IRPCManager } from "../../common/rpc/IRPCManager";
 import { IPlayer } from "../../../entities/common/player/IPlayer";
 import { MockPlayer } from "../../../entities/mock/player/MockPlayer";
-export interface IMockServerRPC extends INetServerRPC {
+import { IClientRPCList, IServerRPCList } from "../../../../shared/net/common/rpc/types";
+export interface IMockServerRPC extends IServerRPCList {
 }
-export interface IMockClientRPC extends INetClientRPC {
+export interface IMockClientRPC extends IClientRPCList {
 }
 export declare class MockRPCManager implements IRPCManager {
     private readonly _handlers;

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

@@ -1,19 +1,15 @@
-import { IEventsManager, INetClientEvents, INetServerEvents } from "../../common/events/IEventsManager";
+import { IEventsManager } from "../../common/events/IEventsManager";
+import { IServerInternalEvents } from "../../common/events/types";
+import { IClientToServerEvents, IServerToClientEvents } from "../../../../shared";
 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 {
+interface IRageServerInternalEvents extends IServerInternalEvents, IServerEvents {
 }
 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;
+    onInternal(events: Partial<IRageServerInternalEvents>): void;
+    offInternal<K extends keyof IRageServerInternalEvents>(eventName: K): void;
+    emitInternal<K extends keyof IRageServerInternalEvents>(eventName: K, ...args: Parameters<IRageServerInternalEvents[K]>): void;
+    onClient(events: Partial<IClientToServerEvents>): void;
+    offClient<K extends keyof IClientToServerEvents>(eventName: K): void;
+    emitClient<K extends keyof IServerToClientEvents>(player: RagePlayer, eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }
+export {};

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

@@ -2,16 +2,20 @@
 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]);
-        }
+    onInternal(events) {
+        mp.events.add(events);
+    }
+    offInternal(eventName) {
+        mp.events.remove(eventName);
+    }
+    emitInternal(eventName, ...args) {
+        mp.events.call(eventName, ...args);
     }
-    off(eventName, listener) {
-        return mp.events.remove(eventName, listener);
+    onClient(events) {
+        mp.events.add(events);
     }
-    emit(eventName, ...args) {
-        return mp.events.call(eventName, ...args);
+    offClient(eventName) {
+        mp.events.remove(eventName);
     }
     emitClient(player, eventName, ...args) {
         const mpPlayer = mp.players.at(player.id);

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

@@ -1,11 +1,8 @@
-import { INetClientRPC, INetServerRPC, IRPCManager } from "../../common/rpc/IRPCManager";
+import { IRPCManager } from "../../common/rpc/IRPCManager";
 import { RagePlayer } from "../../../entities/ragemp/player/RagePlayer";
-export interface IRageServerRPC extends INetServerRPC {
-}
-export interface IRageClientRPC extends INetClientRPC {
-}
+import { IClientRPCList, IServerRPCList } from "../../../../shared/net/common/rpc/types";
 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]>>;
+    register<K extends keyof IServerRPCList>(rpcName: K, handler: (player: RagePlayer, ...args: Parameters<IServerRPCList[K]>) => ReturnType<IServerRPCList[K]>): void;
+    unregister<K extends keyof IServerRPCList>(rpcName: K): void;
+    emitClient<K extends keyof IClientRPCList>(player: RagePlayer, rpcName: K, ...args: Parameters<IClientRPCList[K]>): Promise<ReturnType<IClientRPCList[K]>>;
 }

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

@@ -0,0 +1 @@
+export declare function MathClamp(value: number, min: number, max: number): number;

package/dist/{server → shared}/common/utils/math/Math.js

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

package/dist/shared/entities/IBaseObject.d.ts

@@ -0,0 +1,9 @@
+export declare enum BaseObjectType {
+    Blip = "blip",
+    Colshape = "colshape",
+    Marker = "marker",
+    Object = "object",
+    Ped = "ped",
+    Player = "player",
+    Vehicle = "vehicle"
+}