rock-mod 0.17.0 → 0.19.0

package/dist/client/game/ragemp/browser/RageBrowserManager.d.ts

@@ -0,0 +1,7 @@
+import { type IBrowserManager } from "../../../game/common/browser/IBrowserManager";
+export declare class RageBrowserManager implements IBrowserManager {
+    private _browser;
+    create(url: string): void;
+    destroy(): void;
+    execute(code: string): void;
+}

package/dist/client/game/ragemp/browser/RageBrowserManager.js

@@ -0,0 +1,19 @@
+export class RageBrowserManager {
+    constructor() {
+        this._browser = null;
+    }
+    create(url) {
+        this._browser = mp.browsers.new(url);
+    }
+    destroy() {
+        if (this._browser) {
+            this._browser.destroy();
+            this._browser = null;
+        }
+    }
+    execute(code) {
+        if (this._browser) {
+            this._browser.execute(code);
+        }
+    }
+}

package/dist/client/game/ragemp/camera/RageGameCameraManager.d.ts

@@ -0,0 +1,5 @@
+import { type IGameCameraManager } from "../../../game";
+export declare class RageGameCameraManager implements IGameCameraManager {
+    screenFadeIn(duration: number): void;
+    screenFadeOut(duration: number): void;
+}

package/dist/client/game/ragemp/camera/RageGameCameraManager.js

@@ -0,0 +1,8 @@
+export class RageGameCameraManager {
+    screenFadeIn(duration) {
+        mp.game.cam.doScreenFadeIn(duration);
+    }
+    screenFadeOut(duration) {
+        mp.game.cam.doScreenFadeOut(duration);
+    }
+}

package/dist/client/game/ragemp/chat/RageChatManager.d.ts

@@ -0,0 +1,5 @@
+import { type IChatManager } from "../../../game";
+export declare class RageChatManager implements IChatManager {
+    activate(state: boolean): void;
+    show(state: boolean): void;
+}

package/dist/client/game/ragemp/chat/RageChatManager.js

@@ -0,0 +1,8 @@
+export class RageChatManager {
+    activate(state) {
+        mp.gui.chat.activate(state);
+    }
+    show(state) {
+        mp.gui.chat.show(state);
+    }
+}

package/dist/client/game/ragemp/controls/RageControlsManager.d.ts

@@ -0,0 +1,7 @@
+import { type IControlsManager } from "../../../game";
+export declare class RageControlsManager implements IControlsManager {
+    disableControlAction(padIndex: number, control: number, disable: boolean): void;
+    isDisabledControlPressed(padIndex: number, control: number): boolean;
+    isControlPressed(padIndex: number, control: number): boolean;
+    getDisabledControlNormal(padIndex: number, control: number): number;
+}

package/dist/client/game/ragemp/controls/RageControlsManager.js

@@ -0,0 +1,14 @@
+export class RageControlsManager {
+    disableControlAction(padIndex, control, disable) {
+        mp.game.controls.disableControlAction(padIndex, control, disable);
+    }
+    isDisabledControlPressed(padIndex, control) {
+        return mp.game.controls.isDisabledControlPressed(padIndex, control);
+    }
+    isControlPressed(padIndex, control) {
+        return mp.game.controls.isControlPressed(padIndex, control);
+    }
+    getDisabledControlNormal(padIndex, control) {
+        return mp.game.controls.getDisabledControlNormal(padIndex, control);
+    }
+}

package/dist/client/game/ragemp/cursor/RageCursorManager.d.ts

@@ -0,0 +1,6 @@
+import { type ICursorManager } from "../../../game";
+import { Vector2D } from "../../../../shared/common/utils";
+export declare class RageCursorManager implements ICursorManager {
+    show(freezeControls: boolean, state: boolean): void;
+    getPosition(): Vector2D;
+}

package/dist/client/game/ragemp/cursor/RageCursorManager.js

@@ -0,0 +1,10 @@
+import { Vector2D } from "../../../../shared/common/utils";
+export class RageCursorManager {
+    show(freezeControls, state) {
+        mp.gui.cursor.show(freezeControls, state);
+    }
+    getPosition() {
+        const [x, y] = mp.gui.cursor.position;
+        return new Vector2D(x, y);
+    }
+}

package/dist/client/game/ragemp/gameplay/RageGameplayManager.d.ts

@@ -0,0 +1,6 @@
+import { type IGameplayManager } from "../../../game";
+import { type IVector3D } from "../../../../shared/common/utils";
+export declare class RageGameplayManager implements IGameplayManager {
+    setFadeOutAfterDeath(toggle: boolean): void;
+    getGroundZFor3dCoord(position: IVector3D, ignoreWater: boolean, waterLevelCheck: boolean): number;
+}

package/dist/client/game/ragemp/gameplay/RageGameplayManager.js

@@ -0,0 +1,8 @@
+export class RageGameplayManager {
+    setFadeOutAfterDeath(toggle) {
+        mp.game.gameplay.setFadeOutAfterDeath(toggle);
+    }
+    getGroundZFor3dCoord(position, ignoreWater, waterLevelCheck) {
+        return mp.game.gameplay.getGroundZFor3dCoord(position.x, position.y, position.z, ignoreWater, waterLevelCheck);
+    }
+}

package/dist/client/game/ragemp/graphics/RageGraphicsManager.d.ts

@@ -0,0 +1,8 @@
+import { type IGraphicsManager, type IScreenTextOptions } from "../../../game";
+import { type IVector3D, type IVector2D } from "../../../../shared/index";
+export declare class RageGraphicsManager implements IGraphicsManager {
+    drawText(text: string, position: IVector2D, options?: IScreenTextOptions): void;
+    world3dToScreen2d(position: IVector3D): IVector2D | null;
+    startScreenEffect(effectName: string, duration: number, looped: boolean): void;
+    stopScreenEffect(effectName: string): void;
+}

package/dist/client/game/ragemp/graphics/RageGraphicsManager.js

@@ -0,0 +1,30 @@
+import { Vector2D } from "../../../../shared/index";
+export class RageGraphicsManager {
+    drawText(text, position, options) {
+        var _a, _b, _c, _d, _e;
+        const arrayColor = (options === null || options === void 0 ? void 0 : options.color)
+            ? [options.color.r, options.color.g, options.color.b, (_a = options.color.a) !== null && _a !== void 0 ? _a : 255]
+            : [255, 255, 255, 255];
+        mp.game.graphics.drawText(text, [position.x, position.y], {
+            font: (_b = options === null || options === void 0 ? void 0 : options.font) !== null && _b !== void 0 ? _b : 0,
+            color: arrayColor,
+            scale: (_c = options === null || options === void 0 ? void 0 : options.scale) !== null && _c !== void 0 ? _c : [0.3, 0.3],
+            outline: (_d = options === null || options === void 0 ? void 0 : options.outline) !== null && _d !== void 0 ? _d : true,
+            centre: (_e = options === null || options === void 0 ? void 0 : options.centre) !== null && _e !== void 0 ? _e : false,
+        });
+    }
+    world3dToScreen2d(position) {
+        const { x, y, z } = position;
+        const result = mp.game.graphics.world3dToScreen2d(new mp.Vector3(x, y, z));
+        if (!result) {
+            return null;
+        }
+        return new Vector2D(result.x, result.y);
+    }
+    startScreenEffect(effectName, duration, looped) {
+        mp.game.graphics.startScreenEffect(effectName, duration, looped);
+    }
+    stopScreenEffect(effectName) {
+        mp.game.graphics.stopScreenEffect(effectName);
+    }
+}

package/dist/client/game/ragemp/gui/RageGuiManager.d.ts

@@ -0,0 +1,4 @@
+import { type IGuiManager } from "../../../game";
+export declare class RageGuiManager implements IGuiManager {
+    takeScreenshot(name: string, type: number, quality: number, compressionQuality: number): void;
+}

package/dist/client/game/ragemp/gui/RageGuiManager.js

@@ -0,0 +1,5 @@
+export class RageGuiManager {
+    takeScreenshot(name, type, quality, compressionQuality) {
+        mp.gui.takeScreenshot(name, type, quality, compressionQuality);
+    }
+}

package/dist/client/game/ragemp/keys/RageKeysManager.d.ts

@@ -0,0 +1,7 @@
+import { type IKeysManager } from "../../../game";
+export declare class RageKeysManager implements IKeysManager {
+    isDown(key: number): boolean;
+    isUp(key: number): boolean;
+    bind(key: number, keyHold: boolean, handler: () => void): void;
+    unbind(key: number, keyHold: boolean, handler?: () => void): void;
+}

package/dist/client/game/ragemp/keys/RageKeysManager.js

@@ -0,0 +1,14 @@
+export class RageKeysManager {
+    isDown(key) {
+        return mp.keys.isDown(key);
+    }
+    isUp(key) {
+        return mp.keys.isUp(key);
+    }
+    bind(key, keyHold, handler) {
+        mp.keys.bind(key, keyHold, handler);
+    }
+    unbind(key, keyHold, handler) {
+        mp.keys.unbind(key, keyHold, handler);
+    }
+}

package/dist/client/game/ragemp/localPlayer/RageLocalPlayerManager.d.ts

@@ -0,0 +1,5 @@
+import { type ILocalPlayerManager } from "../../../game";
+export declare class RageLocalPlayerManager implements ILocalPlayerManager {
+    setRunSprintMultiplierFor(value: number): void;
+    setSwimMultiplierFor(value: number): void;
+}

package/dist/client/game/ragemp/localPlayer/RageLocalPlayerManager.js

@@ -0,0 +1,8 @@
+export class RageLocalPlayerManager {
+    setRunSprintMultiplierFor(value) {
+        mp.game.player.setRunSprintMultiplierFor(value);
+    }
+    setSwimMultiplierFor(value) {
+        mp.game.player.setSwimMultiplierFor(value);
+    }
+}

package/dist/client/game/ragemp/nametags/RageNametagsManager.d.ts

@@ -0,0 +1,4 @@
+import { type INametagsManager } from "../../../game";
+export declare class RageNametagsManager implements INametagsManager {
+    setEnabled(enabled: boolean): void;
+}

package/dist/client/game/ragemp/nametags/RageNametagsManager.js

@@ -0,0 +1,5 @@
+export class RageNametagsManager {
+    setEnabled(enabled) {
+        mp.nametags.enabled = enabled;
+    }
+}

package/dist/client/game/ragemp/native/RageNativeCallerManager.d.ts

@@ -0,0 +1,4 @@
+import { type INativeCallerManager } from "../../../game";
+export declare class RageNativeCallerManager implements INativeCallerManager {
+    callNative(hash: string, ...args: unknown[]): unknown;
+}

package/dist/client/game/ragemp/native/RageNativeCallerManager.js

@@ -0,0 +1,5 @@
+export class RageNativeCallerManager {
+    callNative(hash, ...args) {
+        return mp.game.invoke(hash, ...args);
+    }
+}

package/dist/client/game/ragemp/object/RageGameObjectManager.d.ts

@@ -0,0 +1,4 @@
+import { type IGameObjectManager } from "../../../game";
+export declare class RageGameObjectManager implements IGameObjectManager {
+    doorControl(modelHash: number, x: number, y: number, z: number, locked: boolean, xRotMult: number, yRotMult: number, zRotMult: number): void;
+}

package/dist/client/game/ragemp/object/RageGameObjectManager.js

@@ -0,0 +1,5 @@
+export class RageGameObjectManager {
+    doorControl(modelHash, x, y, z, locked, xRotMult, yRotMult, zRotMult) {
+        mp.game.object.doorControl(modelHash, x, y, z, locked, xRotMult, yRotMult, zRotMult);
+    }
+}

package/dist/client/game/ragemp/pathfind/RagePathfindManager.d.ts

@@ -0,0 +1,5 @@
+import { type IPathfindManager, type IStreetNameHash } from "../../../game";
+import { type IVector3D } from "../../../../shared/common/utils";
+export declare class RagePathfindManager implements IPathfindManager {
+    getStreetNameAtCoord(position: IVector3D): IStreetNameHash;
+}

package/dist/client/game/ragemp/pathfind/RagePathfindManager.js

@@ -0,0 +1,5 @@
+export class RagePathfindManager {
+    getStreetNameAtCoord(position) {
+        return mp.game.pathfind.getStreetNameAtCoord(position.x, position.y, position.z);
+    }
+}

package/dist/client/game/ragemp/raycasting/RageRaycastingManager.d.ts

@@ -0,0 +1,8 @@
+import { type IRaycastResult, type IRaycastingManager } from "../../../game";
+import { type IVector3D } from "../../../../shared/common/utils";
+import { type TIgnoreEntityType } from "../../../game/common/raycasting/IRaycastingManager";
+export declare class RageRaycastingManager implements IRaycastingManager {
+    testPointToPoint(startPos: IVector3D, endPos: IVector3D, ignoreEntity?: TIgnoreEntityType, flags?: number | number[]): IRaycastResult | null;
+    private _resolveIgnoreEntity;
+    private _resolveMpEntity;
+}

package/dist/client/game/ragemp/raycasting/RageRaycastingManager.js

@@ -0,0 +1,41 @@
+import { Vector3D } from "../../../../shared/common/utils";
+import { BaseObjectType } from "../../../../shared/entities";
+export class RageRaycastingManager {
+    testPointToPoint(startPos, endPos, ignoreEntity, flags) {
+        const result = mp.raycasting.testPointToPoint(new mp.Vector3(startPos.x, startPos.y, startPos.z), new mp.Vector3(endPos.x, endPos.y, endPos.z), this._resolveIgnoreEntity(ignoreEntity), flags);
+        if (!result) {
+            return null;
+        }
+        return {
+            entityHandle: typeof result.entity === "number" ? result.entity : result.entity.handle,
+            position: new Vector3D(result.position.x, result.position.y, result.position.z),
+            surfaceNormal: new Vector3D(result.surfaceNormal.x, result.surfaceNormal.y, result.surfaceNormal.z),
+        };
+    }
+    _resolveIgnoreEntity(ignoreEntity) {
+        if (!ignoreEntity) {
+            return undefined;
+        }
+        if (Array.isArray(ignoreEntity)) {
+            const entities = ignoreEntity
+                .map((entity) => this._resolveMpEntity(entity))
+                .filter((entity) => Boolean(entity));
+            return entities.length > 0 ? entities : undefined;
+        }
+        return this._resolveMpEntity(ignoreEntity);
+    }
+    _resolveMpEntity(entity) {
+        switch (entity.type) {
+            case BaseObjectType.Player:
+                return mp.players.atHandle(entity.handle);
+            case BaseObjectType.Vehicle:
+                return mp.vehicles.atHandle(entity.handle);
+            case BaseObjectType.Object:
+                return mp.objects.atHandle(entity.handle);
+            case BaseObjectType.Ped:
+                return mp.peds.atHandle(entity.handle);
+            default:
+                return undefined;
+        }
+    }
+}

package/dist/client/game/ragemp/storage/RageStorageManager.d.ts

@@ -0,0 +1,7 @@
+import { type IStorageManager } from "../../../game";
+export declare class RageStorageManager implements IStorageManager {
+    getData<T>(key: string): T | null;
+    setData<T>(key: string, value: T): void;
+    removeData(key: string): void;
+    clearData(prefix?: string): void;
+}

package/dist/client/game/ragemp/storage/RageStorageManager.js

@@ -0,0 +1,20 @@
+export class RageStorageManager {
+    getData(key) {
+        const value = mp.storage.data[key];
+        return value !== null && value !== void 0 ? value : null;
+    }
+    setData(key, value) {
+        mp.storage.data[key] = value;
+    }
+    removeData(key) {
+        delete mp.storage.data[key];
+    }
+    clearData(prefix) {
+        const keys = Object.keys(mp.storage.data);
+        keys.forEach((key) => {
+            if (!prefix || key.startsWith(prefix)) {
+                delete mp.storage.data[key];
+            }
+        });
+    }
+}

package/dist/client/game/ragemp/streaming/RageStreamingManager.d.ts

@@ -0,0 +1,13 @@
+import { type IStreamingManager } from "../../../game";
+import { type IVector3D } from "../../../../shared/common/utils";
+export declare class RageStreamingManager implements IStreamingManager {
+    requestAnimationDictionary(dictionary: string): void;
+    hasAnimationDictionaryLoaded(dictionary: string): boolean;
+    removeAnimationDictionary(dictionary: string): void;
+    isModelInCdimage(model: string): boolean;
+    requestIpl(iplName: string): void;
+    removeIpl(iplName: string): void;
+    setFocusArea(position: IVector3D, offset: IVector3D): void;
+    clearFocus(): void;
+    setFocusEntity(entityHandle: number): void;
+}

package/dist/client/game/ragemp/streaming/RageStreamingManager.js

@@ -0,0 +1,30 @@
+export class RageStreamingManager {
+    requestAnimationDictionary(dictionary) {
+        mp.game.streaming.requestAnimDict(dictionary);
+    }
+    hasAnimationDictionaryLoaded(dictionary) {
+        return mp.game.streaming.hasAnimDictLoaded(dictionary);
+    }
+    removeAnimationDictionary(dictionary) {
+        mp.game.streaming.removeAnimDict(dictionary);
+    }
+    isModelInCdimage(model) {
+        const modelHash = mp.game.joaat(model);
+        return mp.game.streaming.isModelInCdimage(modelHash);
+    }
+    requestIpl(iplName) {
+        mp.game.streaming.requestIpl(iplName);
+    }
+    removeIpl(iplName) {
+        mp.game.streaming.removeIpl(iplName);
+    }
+    setFocusArea(position, offset) {
+        mp.game.streaming.setFocusArea(position.x, position.y, position.z, offset.x, offset.y, offset.z);
+    }
+    clearFocus() {
+        mp.game.streaming.clearFocus();
+    }
+    setFocusEntity(entityHandle) {
+        mp.game.streaming.setFocusEntity(entityHandle);
+    }
+}

package/dist/client/game/ragemp/ui/RageUiManager.d.ts

@@ -0,0 +1,12 @@
+import { type IUiManager } from "../../../game";
+import { type IVector3D } from "../../../../shared/common/utils";
+export declare class RageUiManager implements IUiManager {
+    getStreetNameFromHashKey(hash: number): string;
+    getLabelText(labelName: string): string;
+    hideHudComponentThisFrame(componentIndex: number): void;
+    displayRadar(display: boolean): void;
+    setPauseMenuActive(toggle: boolean): void;
+    setWaypoint(x: number, y: number): void;
+    deleteWaypoint(): void;
+    getBlipInfoIdCoord(blip: number): IVector3D;
+}

package/dist/client/game/ragemp/ui/RageUiManager.js

@@ -0,0 +1,28 @@
+import { Vector3D } from "../../../../shared/common/utils";
+export class RageUiManager {
+    getStreetNameFromHashKey(hash) {
+        return mp.game.ui.getStreetNameFromHashKey(hash);
+    }
+    getLabelText(labelName) {
+        return mp.game.ui.getLabelText(labelName);
+    }
+    hideHudComponentThisFrame(componentIndex) {
+        mp.game.ui.hideHudComponentThisFrame(componentIndex);
+    }
+    displayRadar(display) {
+        mp.game.ui.displayRadar(display);
+    }
+    setPauseMenuActive(toggle) {
+        mp.game.ui.setPauseMenuActive(toggle);
+    }
+    setWaypoint(x, y) {
+        mp.game.ui.setNewWaypoint(x, y);
+    }
+    deleteWaypoint() {
+        mp.game.ui.deleteWaypoint();
+    }
+    getBlipInfoIdCoord(blip) {
+        const { x, y, z } = mp.game.ui.getBlipInfoIdCoord(blip);
+        return new Vector3D(x, y, z);
+    }
+}

package/dist/client/game/ragemp/voiceChat/RageVoiceChatManager.d.ts

@@ -0,0 +1,5 @@
+import { type IVoiceChatManager } from "../../../game";
+export declare class RageVoiceChatManager implements IVoiceChatManager {
+    getMuted(): boolean;
+    setMuted(value: boolean): void;
+}

package/dist/client/game/ragemp/voiceChat/RageVoiceChatManager.js

@@ -0,0 +1,8 @@
+export class RageVoiceChatManager {
+    getMuted() {
+        return mp.voiceChat.muted;
+    }
+    setMuted(value) {
+        mp.voiceChat.muted = value;
+    }
+}

package/dist/client/game/ragemp/weapon/RageWeaponManager.d.ts

@@ -0,0 +1,4 @@
+import { type IWeaponManager } from "../../../game";
+export declare class RageWeaponManager implements IWeaponManager {
+    getWeaponClipSize(weapon: number): number;
+}

package/dist/client/game/ragemp/weapon/RageWeaponManager.js

@@ -0,0 +1,5 @@
+export class RageWeaponManager {
+    getWeaponClipSize(weapon) {
+        return mp.game.weapon.getWeaponClipSize(weapon);
+    }
+}

package/dist/client/game/ragemp/zone/RageZoneManager.d.ts

@@ -0,0 +1,5 @@
+import { type IZoneManager } from "../../../game";
+import { type IVector3D } from "../../../../shared/common/utils";
+export declare class RageZoneManager implements IZoneManager {
+    getNameOfZone(position: IVector3D): string;
+}

package/dist/client/game/ragemp/zone/RageZoneManager.js

@@ -0,0 +1,5 @@
+export class RageZoneManager {
+    getNameOfZone(position) {
+        return mp.game.zone.getNameOfZone(position.x, position.y, position.z);
+    }
+}

package/dist/client/index.d.ts

@@ -1,2 +1,5 @@
 import { RockMod } from "./RockMod";
 export { RockMod };
+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, ICamera as IRockModCamera, } from "./entities";
+export * from "./game";
+export * from "./console";

package/dist/client/index.js

@@ -1,2 +1,4 @@
 import { RockMod } from "./RockMod";
 export { RockMod };
+export * from "./game";
+export * from "./console";

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

@@ -1,6 +1,8 @@
 import { type IEventsManager } from "./events/IEventsManager";
 import { type IRPCManager } from "./rpc/IRPCManager";
+import { type IDataHandler } from "../../net/common/dataHandler/IDataHandler";
 export interface INetManager {
     get events(): IEventsManager;
     get rpc(): IRPCManager;
+    get dataHandler(): IDataHandler;
 }

package/dist/client/net/common/dataHandler/IDataHandler.d.ts

@@ -0,0 +1,4 @@
+import { type IEntity } from "../../../entities";
+export interface IDataHandler {
+    addDataHandler(key: string, callback: (entity: IEntity, value: unknown, oldValue?: unknown) => void): void;
+}

package/dist/client/net/common/dataHandler/IDataHandler.js

@@ -0,0 +1 @@
+export {};

package/dist/client/net/common/events/IEventsBridge.d.ts

@@ -0,0 +1,4 @@
+export interface IEventsBridge {
+    registerRawEvents(): void;
+    registerServerEvents(): void;
+}

package/dist/client/net/common/events/IEventsBridge.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,10 +1,14 @@
-import { type IServerToClientEvents, type IClientToServerEvents } from "@shared/net/common/events/types";
+import { type IServerToClientEvents, type IClientToServerEvents } from "../../../../shared/net/common/events/types";
 import { type IClientInternalEvents } from "./types";
 export interface IEventsManager {
+    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;
+    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;
 }

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

@@ -1,13 +1,46 @@
-import { type IBaseObject, type IPlayer } from "@RockMod/client/entities";
+import { type IBaseObject, type IEntity, type IPlayer, type IVehicle } from "../../../entities";
+import { type IVector3D } from "../../../../shared/common/utils";
 export declare enum ClientInternalEventName {
     PlayerConnected = "rm::playerConnected",
     PlayerDisconnected = "rm::playerDisconnected",
     EntityCreated = "rm::entityCreated",
-    EntityDestroyed = "rm::entityDestroyed"
+    EntityDestroyed = "rm::entityDestroyed",
+    PlayerReady = "rm::playerReady",
+    BrowserDomReady = "rm::browserDomReady",
+    EntityStreamIn = "rm::entityStreamIn",
+    EntityStreamOut = "rm::entityStreamOut",
+    PlayerEnterVehicle = "rm::playerEnterVehicle",
+    PlayerLeaveVehicle = "rm::playerLeaveVehicle",
+    PlayerDeath = "rm::playerDeath",
+    PlayerSpawn = "rm::playerSpawn",
+    PlayerWeaponShot = "rm::playerWeaponShot",
+    Render = "rm::render",
+    Click = "rm::click"
+}
+export interface IClickOptions {
+    absoluteX: number;
+    absoluteY: number;
+    upOrDown: "up" | "down";
+    leftOrRight: "left" | "right";
+    relativeX: number | null;
+    relativeY: number | null;
+    worldPosition: IVector3D | null;
+    hitEntity: number | null;
 }
 export interface IClientInternalEvents {
     [ClientInternalEventName.PlayerConnected]: (player: IPlayer) => void;
     [ClientInternalEventName.PlayerDisconnected]: (player: IPlayer) => void;
     [ClientInternalEventName.EntityCreated]: (object: IBaseObject) => void;
     [ClientInternalEventName.EntityDestroyed]: (object: IBaseObject) => void;
+    [ClientInternalEventName.PlayerReady]: (localPlayer: IPlayer) => void;
+    [ClientInternalEventName.BrowserDomReady]: () => void;
+    [ClientInternalEventName.EntityStreamIn]: (entity: IEntity) => void;
+    [ClientInternalEventName.EntityStreamOut]: (entity: IEntity) => void;
+    [ClientInternalEventName.PlayerEnterVehicle]: (vehicle: IVehicle, seat: number) => void;
+    [ClientInternalEventName.PlayerLeaveVehicle]: (vehicle: IVehicle, seat: number) => void;
+    [ClientInternalEventName.PlayerDeath]: (player: IPlayer) => void;
+    [ClientInternalEventName.PlayerSpawn]: (player: IPlayer) => void;
+    [ClientInternalEventName.PlayerWeaponShot]: () => void;
+    [ClientInternalEventName.Render]: () => void;
+    [ClientInternalEventName.Click]: (options: IClickOptions) => void;
 }

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

@@ -4,4 +4,15 @@ export var ClientInternalEventName;
     ClientInternalEventName["PlayerDisconnected"] = "rm::playerDisconnected";
     ClientInternalEventName["EntityCreated"] = "rm::entityCreated";
     ClientInternalEventName["EntityDestroyed"] = "rm::entityDestroyed";
+    ClientInternalEventName["PlayerReady"] = "rm::playerReady";
+    ClientInternalEventName["BrowserDomReady"] = "rm::browserDomReady";
+    ClientInternalEventName["EntityStreamIn"] = "rm::entityStreamIn";
+    ClientInternalEventName["EntityStreamOut"] = "rm::entityStreamOut";
+    ClientInternalEventName["PlayerEnterVehicle"] = "rm::playerEnterVehicle";
+    ClientInternalEventName["PlayerLeaveVehicle"] = "rm::playerLeaveVehicle";
+    ClientInternalEventName["PlayerDeath"] = "rm::playerDeath";
+    ClientInternalEventName["PlayerSpawn"] = "rm::playerSpawn";
+    ClientInternalEventName["PlayerWeaponShot"] = "rm::playerWeaponShot";
+    ClientInternalEventName["Render"] = "rm::render";
+    ClientInternalEventName["Click"] = "rm::click";
 })(ClientInternalEventName || (ClientInternalEventName = {}));

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

@@ -1,4 +1,4 @@
-import { type IClientRPCList, type IServerRPCList } from "@shared/net/common/rpc/types";
+import { type IClientRPCList, type IServerRPCList } from "../../../../shared/net/common/rpc/types";
 export interface 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;