rock-mod 0.17.0 → 0.18.0

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

@@ -1,5 +1,8 @@
 import { RageEventsManager } from "./events/RageEventsManager";
+import { RageEventsBridge } from "./events/RageEventsBridge";
 import { RageRPCManager } from "./rpc/RageRPCManager";
+import { RageDataHandler } from "../../net/ragemp/dataHandler/RageDataHandler";
+import { RageEntityPoolRouter } from "../../entities/ragemp/router/RageEntityPoolRouter";
 export class RageNetManager {
     get events() {
         return this._eventsManager;
@@ -7,8 +10,16 @@ export class RageNetManager {
     get rpc() {
         return this._rpcManager;
     }
+    get dataHandler() {
+        return this._dataHandler;
+    }
     constructor() {
+        this._entityPoolRouter = new RageEntityPoolRouter();
         this._eventsManager = new RageEventsManager();
         this._rpcManager = new RageRPCManager();
+        this._eventsBridge = new RageEventsBridge(this._eventsManager, this._entityPoolRouter);
+        this._dataHandler = new RageDataHandler(this._entityPoolRouter);
+        this._eventsBridge.registerRawEvents();
+        this._eventsBridge.registerServerEvents();
     }
 }

package/dist/client/net/ragemp/dataHandler/RageDataHandler.d.ts

@@ -0,0 +1,7 @@
+import { type IEntity, type IEntityPoolRouter } from "../../../entities";
+import { type IDataHandler } from "../../../net/common/dataHandler/IDataHandler";
+export declare class RageDataHandler implements IDataHandler {
+    private readonly _entityPoolRouter;
+    constructor(entityPoolRouter: IEntityPoolRouter);
+    addDataHandler(key: string, callback: (entity: IEntity, value: unknown, oldValue?: unknown) => void): void;
+}

package/dist/client/net/ragemp/dataHandler/RageDataHandler.js

@@ -0,0 +1,14 @@
+export class RageDataHandler {
+    constructor(entityPoolRouter) {
+        this._entityPoolRouter = entityPoolRouter;
+    }
+    addDataHandler(key, callback) {
+        mp.events.addDataHandler(key, (mpEntity, value, oldValue) => {
+            const entity = this._entityPoolRouter.resolveFromMp(mpEntity);
+            if (!entity) {
+                return;
+            }
+            callback(entity, value, oldValue);
+        });
+    }
+}

package/dist/client/net/ragemp/events/RageEventsBridge.d.ts

@@ -0,0 +1,12 @@
+import { type IEntityPoolRouter } from "../../../entities/common";
+import { type IEventsBridge } from "../../../net/common/events/IEventsBridge";
+import { type IEventsManager } from "../../../net/common/events/IEventsManager";
+export declare class RageEventsBridge implements IEventsBridge {
+    private readonly _events;
+    private readonly _entityPoolRouter;
+    constructor(events: IEventsManager, entityPoolRouter: IEntityPoolRouter);
+    registerRawEvents(): void;
+    registerServerEvents(): void;
+    private get _rockMod();
+    private _syncEntityPools;
+}

package/dist/client/net/ragemp/events/RageEventsBridge.js

@@ -0,0 +1,137 @@
+import { ClientInternalEventName } from "../../../net/common/events/types";
+import { RockMod } from "../../../RockMod";
+import { ServerToClientEventName } from "../../../../shared/net/common/events/types";
+import { Vector3D } from "../../../../shared/common/utils";
+export class RageEventsBridge {
+    constructor(events, entityPoolRouter) {
+        this._events = events;
+        this._entityPoolRouter = entityPoolRouter;
+    }
+    registerRawEvents() {
+        this._events.onRaw({
+            playerReady: () => {
+                var _a;
+                const playersManager = (_a = this._rockMod) === null || _a === void 0 ? void 0 : _a.players;
+                if (!playersManager) {
+                    return;
+                }
+                playersManager.syncWithMpPool();
+                this._syncEntityPools();
+                const localPlayer = playersManager.findLocalPlayer();
+                if (!localPlayer) {
+                    return;
+                }
+                this._events.emitInternal(ClientInternalEventName.PlayerReady, localPlayer);
+            },
+            playerJoin: (mpPlayer) => {
+                const player = this._entityPoolRouter.registerFromMp(mpPlayer);
+                if (!player) {
+                    return;
+                }
+                this._events.emitInternal(ClientInternalEventName.PlayerConnected, player);
+            },
+            playerQuit: (mpPlayer) => {
+                var _a;
+                const playersManager = (_a = this._rockMod) === null || _a === void 0 ? void 0 : _a.players;
+                if (!playersManager) {
+                    return;
+                }
+                const player = playersManager.unregisterById(mpPlayer.id);
+                if (!player) {
+                    return;
+                }
+                this._events.emitInternal(ClientInternalEventName.PlayerDisconnected, player);
+            },
+            entityStreamIn: (mpEntity) => {
+                const entity = this._entityPoolRouter.resolveFromMp(mpEntity);
+                if (!entity) {
+                    return;
+                }
+                this._events.emitInternal(ClientInternalEventName.EntityStreamIn, entity);
+            },
+            entityStreamOut: (mpEntity) => {
+                const entity = this._entityPoolRouter.resolveFromMp(mpEntity);
+                if (!entity) {
+                    return;
+                }
+                this._events.emitInternal(ClientInternalEventName.EntityStreamOut, entity);
+            },
+            playerEnterVehicle: (mpVehicle, seat) => {
+                const vehicle = this._entityPoolRouter.registerFromMp(mpVehicle);
+                if (!vehicle) {
+                    return;
+                }
+                this._events.emitInternal(ClientInternalEventName.PlayerEnterVehicle, vehicle, seat);
+            },
+            playerLeaveVehicle: (mpVehicle, seat) => {
+                const vehicle = this._entityPoolRouter.resolveFromMp(mpVehicle);
+                if (!vehicle) {
+                    return;
+                }
+                this._events.emitInternal(ClientInternalEventName.PlayerLeaveVehicle, vehicle, seat);
+            },
+            playerDeath: (mpPlayer) => {
+                const player = this._entityPoolRouter.registerFromMp(mpPlayer);
+                if (!player) {
+                    return;
+                }
+                this._events.emitInternal(ClientInternalEventName.PlayerDeath, player);
+            },
+            playerSpawn: (mpPlayer) => {
+                const player = this._entityPoolRouter.registerFromMp(mpPlayer);
+                if (!player) {
+                    return;
+                }
+                this._events.emitInternal(ClientInternalEventName.PlayerSpawn, player);
+            },
+            playerWeaponShot: () => {
+                this._events.emitInternal(ClientInternalEventName.PlayerWeaponShot);
+            },
+            browserDomReady: () => {
+                this._events.emitInternal(ClientInternalEventName.BrowserDomReady);
+            },
+            render: () => {
+                this._events.emitInternal(ClientInternalEventName.Render);
+            },
+            click: (absoluteX, absoluteY, upOrDown, leftOrRight, relativeX, relativeY, worldPosition, hitEntity) => {
+                const clickedWorldPosition = worldPosition
+                    ? new Vector3D(worldPosition.x, worldPosition.y, worldPosition.z)
+                    : null;
+                this._events.emitInternal(ClientInternalEventName.Click, {
+                    absoluteX,
+                    absoluteY,
+                    upOrDown,
+                    leftOrRight,
+                    relativeX: relativeX !== null && relativeX !== void 0 ? relativeX : null,
+                    relativeY: relativeY !== null && relativeY !== void 0 ? relativeY : null,
+                    hitEntity: hitEntity !== null && hitEntity !== void 0 ? hitEntity : null,
+                    worldPosition: clickedWorldPosition,
+                });
+            },
+        });
+    }
+    registerServerEvents() {
+        this._events.onServer({
+            [ServerToClientEventName.EntityCreated]: (serverEntity) => {
+                this._entityPoolRouter.registerByDto(serverEntity);
+            },
+            [ServerToClientEventName.EntityDestroyed]: (serverEntity) => {
+                this._entityPoolRouter.unregisterByDto(serverEntity);
+            },
+        });
+    }
+    get _rockMod() {
+        try {
+            return RockMod.instance;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    _syncEntityPools() {
+        var _a, _b, _c;
+        (_a = this._rockMod) === null || _a === void 0 ? void 0 : _a.vehicles.syncWithMpPool();
+        (_b = this._rockMod) === null || _b === void 0 ? void 0 : _b.objects.syncWithMpPool();
+        (_c = this._rockMod) === null || _c === void 0 ? void 0 : _c.peds.syncWithMpPool();
+    }
+}

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

@@ -1,14 +1,15 @@
 import { type IEventsManager } from "../../common/events/IEventsManager";
-import { type IClientInternalEvents } from "@RockMod/client/net/common/events/types";
-import { type IClientToServerEvents, type IServerToClientEvents } from "@shared/net/common/events/types";
-interface IRageClientInternalEvents extends IClientInternalEvents, IClientEvents {
-}
+import { type IClientInternalEvents } from "../../../net/common/events/types";
+import { type IClientToServerEvents, type IServerToClientEvents } from "../../../../shared/net/common/events/types";
 export declare class RageEventsManager implements IEventsManager {
-    onInternal(events: Partial<IRageClientInternalEvents>): void;
-    offInternal<K extends keyof IRageClientInternalEvents>(eventName: K, listener: IRageClientInternalEvents[K]): void;
-    emitInternal<K extends keyof IRageClientInternalEvents>(eventName: K, ...args: Parameters<IRageClientInternalEvents[K]>): void;
+    onRaw(events: Partial<IClientEvents>): void;
+    offRaw<K extends keyof IClientEvents>(eventName: K, listener?: IClientEvents[K]): void;
+    onInternal(events: Partial<IClientInternalEvents>): void;
+    offInternal<K extends keyof IClientInternalEvents>(eventName: K, listener?: IClientInternalEvents[K]): void;
+    emitInternal<K extends keyof IClientInternalEvents>(eventName: K, ...args: Parameters<IClientInternalEvents[K]>): void;
     onServer(events: Partial<IServerToClientEvents>): void;
-    offServer<K extends keyof IServerToClientEvents>(eventName: K, listener: IServerToClientEvents[K]): void;
+    offServer<K extends keyof IServerToClientEvents>(eventName: K, listener?: IServerToClientEvents[K]): void;
     emitServer<K extends keyof IClientToServerEvents>(eventName: K, ...args: Parameters<IClientToServerEvents[K]>): void;
+    register(event: string, listener: (...args: unknown[]) => void): void;
+    unregister(event: string): void;
 }
-export {};

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

@@ -1,4 +1,10 @@
 export class RageEventsManager {
+    onRaw(events) {
+        mp.events.add(events);
+    }
+    offRaw(eventName, listener) {
+        mp.events.remove(eventName, listener);
+    }
     onInternal(events) {
         mp.events.add(events);
     }
@@ -17,4 +23,10 @@ export class RageEventsManager {
     emitServer(eventName, ...args) {
         return mp.events.callRemote(eventName, ...args);
     }
+    register(event, listener) {
+        mp.events.add(event, listener);
+    }
+    unregister(event) {
+        mp.events.remove(event);
+    }
 }

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

@@ -1,5 +1,5 @@
 import { type IRPCManager } from "../../common/rpc/IRPCManager";
-import { type IClientRPCList, type IServerRPCList } from "@shared/net/common/rpc/types";
+import { type IClientRPCList, type IServerRPCList } from "../../../../shared/net/common/rpc/types";
 export declare class RageRPCManager implements IRPCManager {
     register<K extends keyof IClientRPCList>(rpcName: K, handler: (...args: Parameters<IClientRPCList[K]>) => ReturnType<IClientRPCList[K]>): void;
     unregister<K extends keyof IClientRPCList>(rpcName: K): void;

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

@@ -14,4 +14,5 @@ export declare abstract class RageBaseObjectsManager<T extends RageBaseObject<En
     findByID(id: number): T | null;
     protected registerBaseObject(baseObject: T): void;
     protected unregisterBaseObject(baseObject: T): void;
+    private _toBaseObjectDto;
 }

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 shared_1 = require("../../../../shared");
 const types_1 = require("../../../net/common/events/types");
 class RageBaseObjectsManager {
     _baseObjects;
@@ -42,12 +43,20 @@ class RageBaseObjectsManager {
         }
         this._baseObjects.set(baseObject.id, baseObject);
         RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.EntityCreated, baseObject);
+        RockMod_1.RockMod.instance.net.events.emitAllClients(shared_1.ServerToClientEventName.EntityCreated, this._toBaseObjectDto(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.emitInternal(types_1.ServerInternalEventName.EntityCreated, baseObject);
+        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.EntityDestroyed, baseObject);
+        RockMod_1.RockMod.instance.net.events.emitAllClients(shared_1.ServerToClientEventName.EntityDestroyed, this._toBaseObjectDto(baseObject));
+    }
+    _toBaseObjectDto(baseObject) {
+        return {
+            type: baseObject.type,
+            remoteId: baseObject.id,
+        };
     }
 }
 exports.RageBaseObjectsManager = RageBaseObjectsManager;

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

@@ -11,5 +11,6 @@ export declare class AltVEventsManager implements IEventsManager {
     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;
+    emitAllClients<K extends keyof IServerToClientEvents>(eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }
 export {};

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

@@ -31,5 +31,8 @@ class AltVEventsManager {
         }
         return mpPlayer.emit(eventName, ...args);
     }
+    emitAllClients(eventName, ...args) {
+        Player.all.forEach((player) => player.emit(eventName, ...args));
+    }
 }
 exports.AltVEventsManager = AltVEventsManager;

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

@@ -8,4 +8,5 @@ export interface IEventsManager {
     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;
+    emitAllClients<K extends keyof IServerToClientEvents>(eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }

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

@@ -10,4 +10,5 @@ export declare class MockEventsManager implements IEventsManager {
     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;
+    emitAllClients<K extends keyof IServerToClientEvents>(eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }

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

@@ -26,5 +26,8 @@ class MockEventsManager {
     emitClient(player, eventName, ...args) {
         this._eventEmitter.emit(eventName, player, ...args);
     }
+    emitAllClients(eventName, ...args) {
+        this._eventEmitter.emit(eventName, ...args);
+    }
 }
 exports.MockEventsManager = MockEventsManager;

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

@@ -11,5 +11,6 @@ export declare class RageEventsManager implements IEventsManager {
     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;
+    emitAllClients<K extends keyof IServerToClientEvents>(eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
 }
 export {};

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

@@ -24,5 +24,10 @@ class RageEventsManager {
         }
         return mpPlayer.call(eventName, args);
     }
+    emitAllClients(eventName, ...args) {
+        mp.players.forEach((mpPlayer) => {
+            mpPlayer.call(eventName, args);
+        });
+    }
 }
 exports.RageEventsManager = RageEventsManager;

package/dist/shared/common/utils/color/RGBA.d.ts

@@ -1,7 +1,9 @@
-export interface IRGBA {
+export interface IRGB {
     get r(): number;
     get g(): number;
     get b(): number;
+}
+export interface IRGBA extends IRGB {
     get a(): number | undefined;
 }
 export declare class RGBA implements IRGBA {

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

@@ -5,5 +5,10 @@ export declare enum BaseObjectType {
     Object = "object",
     Ped = "ped",
     Player = "player",
-    Vehicle = "vehicle"
+    Vehicle = "vehicle",
+    Camera = "camera"
+}
+export interface IBaseObjectDto {
+    type: BaseObjectType;
+    remoteId: number;
 }

package/dist/shared/entities/IBaseObject.js

@@ -10,4 +10,5 @@ var BaseObjectType;
     BaseObjectType["Ped"] = "ped";
     BaseObjectType["Player"] = "player";
     BaseObjectType["Vehicle"] = "vehicle";
+    BaseObjectType["Camera"] = "camera";
 })(BaseObjectType || (exports.BaseObjectType = BaseObjectType = {}));

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

@@ -1,11 +1,16 @@
+import { type IBaseObjectDto } from "../../../entities";
 export declare enum ServerToClientEventName {
-    TestServerToClientEvent = "rm::testServerToClientEvent"
+    TestServerToClientEvent = "rm::testServerToClientEvent",
+    EntityCreated = "rm::serverEntityCreated",
+    EntityDestroyed = "rm::serverEntityDestroyed"
 }
 export declare enum ClientToServerEventName {
     TestClientToServerEvent = "rm::testClientToServerEvent"
 }
 export interface IServerToClientEvents {
     [ServerToClientEventName.TestServerToClientEvent]: () => void;
+    [ServerToClientEventName.EntityCreated]: (entity: IBaseObjectDto) => void;
+    [ServerToClientEventName.EntityDestroyed]: (entity: IBaseObjectDto) => void;
 }
 export interface IClientToServerEvents {
     [ClientToServerEventName.TestClientToServerEvent]: () => void;

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

@@ -4,6 +4,8 @@ exports.ClientToServerEventName = exports.ServerToClientEventName = void 0;
 var ServerToClientEventName;
 (function (ServerToClientEventName) {
     ServerToClientEventName["TestServerToClientEvent"] = "rm::testServerToClientEvent";
+    ServerToClientEventName["EntityCreated"] = "rm::serverEntityCreated";
+    ServerToClientEventName["EntityDestroyed"] = "rm::serverEntityDestroyed";
 })(ServerToClientEventName || (exports.ServerToClientEventName = ServerToClientEventName = {}));
 var ClientToServerEventName;
 (function (ClientToServerEventName) {