rock-mod 0.20.0 → 0.22.0

package/dist/server/net/ccmp/CCMPNetManager.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPNetManager = void 0;
+const CCMPEventsManager_1 = require("./events/CCMPEventsManager");
+const CCMPRPCManager_1 = require("./rpc/CCMPRPCManager");
+/**
+ * Имя cooperation-события для синтеза `rm::playerReady` на клиенте.
+ *
+ * Клиент шлёт это сразу после `connectionStateChanged.connected = true`;
+ * сервер отвечает тому же игроку этим же именем с `{ remoteId }`. Клиентский
+ * `CCMPEventsBridge` ловит ответ и эмитит `rm::playerReady`.
+ */
+const CLIENT_READY_EVENT = "rm::clientReady";
+/**
+ * Имя приватного события для зеркалирования клиентских `console.*` вызовов
+ * в серверный stdout. Реализация клиента — `CCMPConsoleForwarder`.
+ */
+const CLIENT_LOG_EVENT = "rm::clientLog";
+function isSerializedError(value) {
+    return typeof value === "object" && value !== null && value.__error === true;
+}
+function isSerializedToString(value) {
+    return (typeof value === "object" && value !== null && typeof value.__toString === "string");
+}
+function rehydrateArg(value) {
+    if (isSerializedError(value)) {
+        // Приоритет: stack -> name+message -> toString-репрезентация.
+        if (value.stack) {
+            return value.stack;
+        }
+        if (value.name && value.message) {
+            return `${value.name}: ${value.message}`;
+        }
+        if (value.message) {
+            return value.message;
+        }
+        if (value.toString) {
+            return value.toString;
+        }
+        return "<unknown error>";
+    }
+    if (isSerializedToString(value)) {
+        return value.__toString;
+    }
+    return value;
+}
+function pickConsoleSink(level) {
+    switch (level) {
+        case "error":
+            return console.error.bind(console);
+        case "warn":
+            return console.warn.bind(console);
+        case "info":
+            return console.info ? console.info.bind(console) : console.log.bind(console);
+        case "debug":
+            return console.debug ? console.debug.bind(console) : console.log.bind(console);
+        case "log":
+        default:
+            return console.log.bind(console);
+    }
+}
+class CCMPNetManager {
+    _eventsManager;
+    _rpcManager;
+    get events() {
+        return this._eventsManager;
+    }
+    get rpc() {
+        return this._rpcManager;
+    }
+    constructor() {
+        this._eventsManager = new CCMPEventsManager_1.CCMPEventsManager();
+        this._rpcManager = new CCMPRPCManager_1.CCMPRPCManager();
+        this._registerClientReadyCooperation();
+        this._registerClientLogForwarder();
+        // Маркер успешной загрузки актуального rock-mod на серверной стороне.
+        // Если эта строка не появилась в stdout при старте ccmp-server.exe —
+        // значит сервер всё ещё держит в памяти старую сборку rock-mod (не
+        // забыт перезапуск процесса).
+        console.log("[rock-mod] CCMP server net manager initialized");
+    }
+    _registerClientReadyCooperation() {
+        // Регистрируем напрямую через `ccmp.on` (а не через events.onClient),
+        // потому что событие не входит в `IClientToServerEvents` — это
+        // приватный rock-mod протокол.
+        ccmp.on(CLIENT_READY_EVENT, (player) => {
+            const ccmpPlayer = ccmp.players.getById(player.id);
+            if (!ccmpPlayer) {
+                return;
+            }
+            // Зеркалит контракт client-side `CCMPEventsManager`: payload всегда
+            // массивом, на клиенте развернётся обратно в позиционные аргументы.
+            ccmpPlayer.emit(CLIENT_READY_EVENT, [{ remoteId: player.id }]);
+        });
+    }
+    /**
+     * Принимает зеркалированные клиентские `console.*` вызовы и печатает в
+     * серверный stdout. Необходимо для отладки CCMP-клиента: иначе ошибки
+     * boot'а уходят в игровую консоль (F8), не видны разработчику.
+     *
+     * Парный клиент — `CCMPConsoleForwarder`.
+     */
+    _registerClientLogForwarder() {
+        ccmp.on(CLIENT_LOG_EVENT, (player, payload) => {
+            const level = payload?.level ?? "log";
+            const args = Array.isArray(payload?.args) ? payload.args : [];
+            const sink = pickConsoleSink(level);
+            sink(`[client:${player.id}]`, ...args.map(rehydrateArg));
+        });
+    }
+}
+exports.CCMPNetManager = CCMPNetManager;

package/dist/server/net/ccmp/events/CCMPEventsManager.d.ts

@@ -0,0 +1,17 @@
+import { type CcmpServerBuiltinEvents } from "@classic-mp/types/server";
+import { type IEventsManager } from "../../common/events/IEventsManager";
+import { type IServerInternalEvents } from "../../common/events/types";
+import { type IClientToServerEvents, type IServerToClientEvents } from "../../../../shared";
+import { type CCMPPlayer } from "../../../entities/ccmp/player/CCMPPlayer";
+export interface ICCMPServerInternalEvents extends IServerInternalEvents, CcmpServerBuiltinEvents {
+}
+export declare class CCMPEventsManager implements IEventsManager {
+    onInternal(events: Partial<ICCMPServerInternalEvents>): 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: CCMPPlayer, eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
+    emitAllClients<K extends keyof IServerToClientEvents>(eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
+    private _getRockModPlayer;
+}

package/dist/server/net/ccmp/events/CCMPEventsManager.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPEventsManager = void 0;
+const RockMod_1 = require("../../../RockMod");
+class CCMPEventsManager {
+    onInternal(events) {
+        for (const eventName of Object.keys(events)) {
+            // @ts-expect-error mixed CCMP built-in + rm:: keys typing
+            ccmp.on(eventName, events[eventName]);
+        }
+    }
+    offInternal(eventName, listener) {
+        ccmp.off(eventName, listener);
+    }
+    emitInternal(eventName, ...args) {
+        ccmp.emit(eventName, ...args);
+    }
+    onClient(events) {
+        for (const eventName of Object.keys(events)) {
+            // @ts-expect-error generic event typing
+            const handler = events[eventName];
+            // Клиент шлёт variadic args упакованными в массив через
+            // `ccmp.emitServer(name, args)` (см. client CCMPEventsManager.emitServer).
+            // Разворачиваем массив обратно в позиционные аргументы. Скалярные/объектные
+            // payload'ы прокидываем как единственный аргумент.
+            ccmp.on(eventName, (player, data) => {
+                const rockModPlayer = this._getRockModPlayer(player);
+                const args = Array.isArray(data) ? data : [data];
+                handler(rockModPlayer, ...args);
+            });
+        }
+    }
+    offClient(eventName, listener) {
+        ccmp.off(eventName, listener);
+    }
+    emitClient(player, eventName, ...args) {
+        const ccmpPlayer = ccmp.players.getById(player.id);
+        if (!ccmpPlayer) {
+            throw new Error(`Player with id ${player.id} not found`);
+        }
+        ccmpPlayer.emit(eventName, args);
+    }
+    emitAllClients(eventName, ...args) {
+        ccmp.emitAllClients(eventName, args);
+    }
+    _getRockModPlayer(player) {
+        const playerId = player?.id;
+        if (typeof playerId !== "number") {
+            throw new Error("CCMPEventsManager.onClient: event sender does not contain numeric player id");
+        }
+        return RockMod_1.RockMod.instance.players.getByID(playerId);
+    }
+}
+exports.CCMPEventsManager = CCMPEventsManager;

package/dist/server/net/ccmp/rpc/CCMPRPCManager.d.ts

@@ -0,0 +1,8 @@
+import { type IRPCManager } from "../../common/rpc/IRPCManager";
+import { type CCMPPlayer } from "../../../entities/ccmp/player/CCMPPlayer";
+import { type IClientRPCList, type IServerRPCList } from "../../../../shared/net/common/rpc/types";
+export declare class CCMPRPCManager implements IRPCManager {
+    register<K extends keyof IServerRPCList>(_rpcName: K, _handler: (player: CCMPPlayer, ...args: Parameters<IServerRPCList[K]>) => ReturnType<IServerRPCList[K]>): void;
+    unregister<K extends keyof IServerRPCList>(_rpcName: K): void;
+    emitClient<K extends keyof IClientRPCList>(_player: CCMPPlayer, _rpcName: K, ..._args: Parameters<IClientRPCList[K]>): Promise<ReturnType<IClientRPCList[K]>>;
+}

package/dist/server/net/ccmp/rpc/CCMPRPCManager.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPRPCManager = void 0;
+const notImplemented = (name) => {
+    throw new Error(`Not implemented yet: ${name}`);
+};
+class CCMPRPCManager {
+    register(_rpcName, _handler) {
+        notImplemented("CCMPRPCManager.register");
+    }
+    unregister(_rpcName) {
+        notImplemented("CCMPRPCManager.unregister");
+    }
+    emitClient(_player, _rpcName, ..._args) {
+        return notImplemented("CCMPRPCManager.emitClient");
+    }
+}
+exports.CCMPRPCManager = CCMPRPCManager;

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

@@ -9,6 +9,7 @@ export declare enum ServerInternalEventName {
     PlayerExitVehicle = "rm::playerExitVehicle",
     PlayerEnteredColshape = "rm::playerEnteredColshape",
     PlayerLeftColshape = "rm::playerLeftColshape",
+    PlayerDimensionChange = "rm::playerDimensionChange",
     EntityCreated = "rm::entityCreated",
     EntityDestroyed = "rm::entityDestroyed"
 }
@@ -22,6 +23,7 @@ export interface IServerInternalEvents {
     [ServerInternalEventName.PlayerExitVehicle]: (player: IPlayer, vehicle: IVehicle) => void;
     [ServerInternalEventName.PlayerEnteredColshape]: (player: IPlayer, colshape: IColshape) => void;
     [ServerInternalEventName.PlayerLeftColshape]: (player: IPlayer, colshape: IColshape) => void;
+    [ServerInternalEventName.PlayerDimensionChange]: (player: IPlayer, oldDimension: number, newDimension: number) => void;
     [ServerInternalEventName.EntityCreated]: (object: IBaseObject) => void;
     [ServerInternalEventName.EntityDestroyed]: (object: IBaseObject) => void;
 }

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

@@ -12,6 +12,7 @@ var ServerInternalEventName;
     ServerInternalEventName["PlayerExitVehicle"] = "rm::playerExitVehicle";
     ServerInternalEventName["PlayerEnteredColshape"] = "rm::playerEnteredColshape";
     ServerInternalEventName["PlayerLeftColshape"] = "rm::playerLeftColshape";
+    ServerInternalEventName["PlayerDimensionChange"] = "rm::playerDimensionChange";
     ServerInternalEventName["EntityCreated"] = "rm::entityCreated";
     ServerInternalEventName["EntityDestroyed"] = "rm::entityDestroyed";
 })(ServerInternalEventName || (exports.ServerInternalEventName = ServerInternalEventName = {}));

package/dist/server/utils/ccmp/CCMPUtilsManager.d.ts

@@ -0,0 +1,4 @@
+import { type IUtilsManager } from "../common";
+export declare class CCMPUtilsManager implements IUtilsManager {
+    hash(value: string): number;
+}

package/dist/server/utils/ccmp/CCMPUtilsManager.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPUtilsManager = void 0;
+class CCMPUtilsManager {
+    hash(value) {
+        return ccmp.hash(value);
+    }
+}
+exports.CCMPUtilsManager = CCMPUtilsManager;

package/dist/server/world/ccmp/CCMPWorldManager.d.ts

@@ -0,0 +1,10 @@
+import { type IWorldManager, type IWorldTime } from "../common";
+import type { WeatherTypeEnum } from "../../../shared/common/world";
+export declare class CCMPWorldManager implements IWorldManager {
+    get time(): IWorldTime;
+    get weather(): WeatherTypeEnum;
+    setTimeHour(value: number): void;
+    setTimeMinute(value: number): void;
+    setTimeSecond(value: number): void;
+    setWeather(value: WeatherTypeEnum): void;
+}

package/dist/server/world/ccmp/CCMPWorldManager.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPWorldManager = void 0;
+class CCMPWorldManager {
+    get time() {
+        return ccmp.world.time;
+    }
+    get weather() {
+        return ccmp.world.weather;
+    }
+    setTimeHour(value) {
+        ccmp.world.hour = value;
+    }
+    setTimeMinute(value) {
+        ccmp.world.minute = value;
+    }
+    setTimeSecond(value) {
+        ccmp.world.second = value;
+    }
+    setWeather(value) {
+        ccmp.world.weather = value;
+    }
+}
+exports.CCMPWorldManager = CCMPWorldManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rock-mod",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Rock-Mod is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,6 +37,7 @@
   },
   "scripts": {
     "start": "npx tsx src/server/index.ts",
+    "generate:natives": "node scripts/generate-native-dispatch.mjs",
     "build": "npm run build:shared && npm run build:server && npm run build:client",
     "build:shared": "tsc --project src/shared/tsconfig.json",
     "build:server": "tsc --project src/server/tsconfig.json",
@@ -86,6 +87,7 @@
     "@swc/helpers": "^0.5.15"
   },
   "devDependencies": {
+    "@classic-mp/types": "^1.6.0",
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-terser": "^0.4.4",