rock-mod 0.16.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/altv/vehicle/AltVVehicle.d.ts

@@ -29,6 +29,13 @@ export declare class AltVVehicle extends AltVEntity<Vehicle> implements IVehicle
     setSecondaryColor(value: number): void;
     setCustomPrimaryColor(value: RGBA): void;
     setCustomSecondaryColor(value: RGBA): void;
+    setMod(modType: number, modIndex: number): void;
+    getMod(modType: number): number;
+    setNeonEnabled(enabled: boolean): void;
+    setNeonColor(r: number, g: number, b: number): void;
+    setWindowTint(tintType: number): void;
+    setWheelType(wheelType: number): void;
+    setPlateType(plateType: number): void;
     explode(): void;
     repair(): void;
     private static _clampColorId;

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

@@ -85,6 +85,33 @@ class AltVVehicle extends AltVEntity_1.AltVEntity {
         const { r, g, b, a } = value;
         this.mpEntity.customSecondaryColor = new AltVShared.RGBA(r, g, b, a);
     }
+    setMod(modType, modIndex) {
+        this.mpEntity.setMod(modType, modIndex);
+    }
+    getMod(modType) {
+        return this.mpEntity.getMod(modType);
+    }
+    setNeonEnabled(enabled) {
+        this.mpEntity.neon = {
+            ...this.mpEntity.neon,
+            left: enabled,
+            right: enabled,
+            front: enabled,
+            back: enabled,
+        };
+    }
+    setNeonColor(r, g, b) {
+        this.mpEntity.neonColor = new AltVShared.RGBA(r, g, b);
+    }
+    setWindowTint(tintType) {
+        this.mpEntity.windowTint = tintType;
+    }
+    setWheelType(wheelType) {
+        this.mpEntity.setWheels(wheelType, 0);
+    }
+    setPlateType(plateType) {
+        this.mpEntity.numberPlateIndex = plateType;
+    }
     explode() {
         this.mpEntity.engineHealth = 0;
         this.mpEntity.bodyHealth = 0;

package/dist/server/entities/common/vehicle/IVehicle.d.ts

@@ -44,6 +44,13 @@ export interface IVehicle extends IEntity {
     setSecondaryColor(value: number): void;
     setCustomPrimaryColor(value: IRGBA): void;
     setCustomSecondaryColor(value: IRGBA): void;
+    setMod(modType: number, modIndex: number): void;
+    getMod(modType: number): number;
+    setNeonEnabled(enabled: boolean): void;
+    setNeonColor(r: number, g: number, b: number): void;
+    setWindowTint(tintType: number): void;
+    setWheelType(wheelType: number): void;
+    setPlateType(plateType: number): void;
     explode(): void;
     repair(): void;
 }

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

@@ -18,6 +18,12 @@ export declare class MockVehicle extends MockEntity implements IVehicle {
     private _customPrimaryColor;
     private _customSecondaryColor;
     private _passengers;
+    private _mods;
+    private _neonEnabled;
+    private _neonColor;
+    private _windowTint;
+    private _wheelType;
+    private _plateType;
     get bodyHealth(): number;
     get engineHealth(): number;
     get engineOn(): boolean;
@@ -28,6 +34,15 @@ export declare class MockVehicle extends MockEntity implements IVehicle {
     get secondaryColor(): number;
     get customPrimaryColor(): RGBA;
     get customSecondaryColor(): RGBA;
+    get neonEnabled(): boolean;
+    get neonColor(): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    get windowTint(): number;
+    get wheelType(): number;
+    get plateType(): number;
     get driver(): MockPlayer | null;
     get passengers(): Set<MockPlayer>;
     constructor(options: IMockVehicleOptions);
@@ -40,6 +55,13 @@ export declare class MockVehicle extends MockEntity implements IVehicle {
     setSecondaryColor(value: number): void;
     setCustomPrimaryColor(value: RGBA): void;
     setCustomSecondaryColor(value: RGBA): void;
+    setMod(modType: number, modIndex: number): void;
+    getMod(modType: number): number;
+    setNeonEnabled(enabled: boolean): void;
+    setNeonColor(r: number, g: number, b: number): void;
+    setWindowTint(tintType: number): void;
+    setWheelType(wheelType: number): void;
+    setPlateType(plateType: number): void;
     explode(): void;
     repair(): void;
 }

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

@@ -16,6 +16,12 @@ class MockVehicle extends MockEntity_1.MockEntity {
     _customPrimaryColor;
     _customSecondaryColor;
     _passengers;
+    _mods;
+    _neonEnabled;
+    _neonColor;
+    _windowTint;
+    _wheelType;
+    _plateType;
     get bodyHealth() {
         return this._bodyHealth;
     }
@@ -48,6 +54,21 @@ class MockVehicle extends MockEntity_1.MockEntity {
         const { r, g, b, a } = this._customSecondaryColor;
         return new utils_1.RGBA(r, g, b, a);
     }
+    get neonEnabled() {
+        return this._neonEnabled;
+    }
+    get neonColor() {
+        return this._neonColor;
+    }
+    get windowTint() {
+        return this._windowTint;
+    }
+    get wheelType() {
+        return this._wheelType;
+    }
+    get plateType() {
+        return this._plateType;
+    }
     get driver() {
         for (const passenger of this._passengers.values()) {
             if (passenger.seat === 0) {
@@ -72,6 +93,12 @@ class MockVehicle extends MockEntity_1.MockEntity {
         this._customPrimaryColor = new utils_1.RGBA(0, 0, 0);
         this._customSecondaryColor = new utils_1.RGBA(0, 0, 0);
         this._passengers = new Set();
+        this._mods = new Map();
+        this._neonEnabled = false;
+        this._neonColor = { r: 0, g: 0, b: 0 };
+        this._windowTint = 0;
+        this._wheelType = 0;
+        this._plateType = 0;
     }
     setBodyHealth(value) {
         this._bodyHealth = value;
@@ -100,6 +127,27 @@ class MockVehicle extends MockEntity_1.MockEntity {
     setCustomSecondaryColor(value) {
         this._customSecondaryColor = value;
     }
+    setMod(modType, modIndex) {
+        this._mods.set(modType, modIndex);
+    }
+    getMod(modType) {
+        return this._mods.get(modType) ?? -1;
+    }
+    setNeonEnabled(enabled) {
+        this._neonEnabled = enabled;
+    }
+    setNeonColor(r, g, b) {
+        this._neonColor = { r, g, b };
+    }
+    setWindowTint(tintType) {
+        this._windowTint = tintType;
+    }
+    setWheelType(wheelType) {
+        this._wheelType = wheelType;
+    }
+    setPlateType(plateType) {
+        this._plateType = plateType;
+    }
     explode() {
         this.setBodyHealth(0);
         this.setEngineHealth(0);

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/entities/ragemp/vehicle/RageVehicle.d.ts

@@ -28,6 +28,13 @@ export declare class RageVehicle extends RageEntity<VehicleMp> implements IVehic
     setSecondaryColor(value: number): void;
     setCustomPrimaryColor(value: RGBA): void;
     setCustomSecondaryColor(value: RGBA): void;
+    setMod(modType: number, modIndex: number): void;
+    getMod(modType: number): number;
+    setNeonEnabled(enabled: boolean): void;
+    setNeonColor(r: number, g: number, b: number): void;
+    setWindowTint(tintType: number): void;
+    setWheelType(wheelType: number): void;
+    setPlateType(plateType: number): void;
     explode(): void;
     repair(): void;
     private static _clampColorId;

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

@@ -82,6 +82,27 @@ class RageVehicle extends RageEntity_1.RageEntity {
     setCustomSecondaryColor(value) {
         this.mpEntity.setColorRGB(this.customPrimaryColor.r, this.customPrimaryColor.g, this.customPrimaryColor.b, value.r, value.g, value.b);
     }
+    setMod(modType, modIndex) {
+        this.mpEntity.setMod(modType, modIndex);
+    }
+    getMod(modType) {
+        return this.mpEntity.getMod(modType);
+    }
+    setNeonEnabled(enabled) {
+        this.mpEntity.neonEnabled = enabled;
+    }
+    setNeonColor(r, g, b) {
+        this.mpEntity.setNeonColor(r, g, b);
+    }
+    setWindowTint(tintType) {
+        this.mpEntity.windowTint = tintType;
+    }
+    setWheelType(wheelType) {
+        this.mpEntity.wheelType = wheelType;
+    }
+    setPlateType(plateType) {
+        this.mpEntity.numberPlateType = plateType;
+    }
     explode() {
         return this.mpEntity.explode();
     }

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) {