rock-mod 0.19.0 → 0.21.0

package/dist/server/entities/ccmp/vehicle/CCMPVehicle.d.ts

@@ -0,0 +1,58 @@
+import { CCMPEntity } from "../entity/CCMPEntity";
+import { type IVehicle } from "../../common/vehicle/IVehicle";
+import { type IRGBA } from "../../../../shared/common/utils";
+import { type IVector3D } from "../../../../shared/common/utils/math/Vectors";
+import { BaseObjectType } from "../../../../shared";
+import { type CCMPPlayer } from "../player/CCMPPlayer";
+import type { Vehicle as CcmpVehicle } from "@classic-mp/types/server";
+export interface ICCMPVehicleOptions {
+    ccmpVehicle: CcmpVehicle;
+    onDestroy: (vehicle: CCMPVehicle) => void;
+}
+export declare class CCMPVehicle extends CCMPEntity implements IVehicle {
+    private readonly _ccmpVehicle;
+    private readonly _onDestroy;
+    get id(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get position(): IVector3D;
+    get dimension(): number;
+    get model(): number;
+    get rotation(): IVector3D;
+    get bodyHealth(): number;
+    get engineHealth(): number;
+    get numberPlate(): string;
+    get isLocked(): boolean;
+    get isDead(): boolean;
+    get primaryColor(): number;
+    get secondaryColor(): number;
+    get customPrimaryColor(): IRGBA;
+    get customSecondaryColor(): IRGBA;
+    get driver(): CCMPPlayer | null;
+    get passengers(): Set<CCMPPlayer>;
+    protected get ccmpMeta(): CcmpVehicle;
+    constructor(options: ICCMPVehicleOptions);
+    destroy(): void;
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+    setModel(value: string): void;
+    setRotation(value: IVector3D): void;
+    setBodyHealth(_value: number): void;
+    setEngineHealth(_value: number): void;
+    setEngineOn(value: boolean): void;
+    setNumberPlate(_value: string): void;
+    setLocked(_value: boolean): void;
+    setPrimaryColor(_value: number): void;
+    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/ccmp/vehicle/CCMPVehicle.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPVehicle = void 0;
+const CCMPEntity_1 = require("../entity/CCMPEntity");
+const Vectors_1 = require("../../../../shared/common/utils/math/Vectors");
+const shared_1 = require("../../../../shared");
+const RockMod_1 = require("../../../RockMod");
+const notImplemented = (name) => {
+    throw new Error(`Not implemented yet: ${name}`);
+};
+class CCMPVehicle extends CCMPEntity_1.CCMPEntity {
+    _ccmpVehicle;
+    _onDestroy;
+    get id() {
+        return this._ccmpVehicle.id;
+    }
+    get type() {
+        return shared_1.BaseObjectType.Vehicle;
+    }
+    get isExists() {
+        return this._ccmpVehicle.isExists;
+    }
+    get position() {
+        const p = this._ccmpVehicle.position;
+        return new Vectors_1.Vector3D(p.x, p.y, p.z);
+    }
+    get dimension() {
+        return this._ccmpVehicle.dimension;
+    }
+    get model() {
+        return this._ccmpVehicle.model;
+    }
+    get rotation() {
+        const r = this._ccmpVehicle.rotation;
+        return new Vectors_1.Vector3D(r.x, r.y, r.z);
+    }
+    get bodyHealth() {
+        return notImplemented("CCMPVehicle.bodyHealth");
+    }
+    get engineHealth() {
+        return notImplemented("CCMPVehicle.engineHealth");
+    }
+    get numberPlate() {
+        return notImplemented("CCMPVehicle.numberPlate");
+    }
+    get isLocked() {
+        return notImplemented("CCMPVehicle.isLocked");
+    }
+    get isDead() {
+        return notImplemented("CCMPVehicle.isDead");
+    }
+    get primaryColor() {
+        return notImplemented("CCMPVehicle.primaryColor");
+    }
+    get secondaryColor() {
+        return notImplemented("CCMPVehicle.secondaryColor");
+    }
+    get customPrimaryColor() {
+        return notImplemented("CCMPVehicle.customPrimaryColor");
+    }
+    get customSecondaryColor() {
+        return notImplemented("CCMPVehicle.customSecondaryColor");
+    }
+    get driver() {
+        const ccmpDriver = this._ccmpVehicle.driver;
+        if (!ccmpDriver)
+            return null;
+        return RockMod_1.RockMod.instance.players.findByID(ccmpDriver.id);
+    }
+    get passengers() {
+        const passengers = new Set();
+        for (const ccmpPassenger of this._ccmpVehicle.passengers) {
+            const player = RockMod_1.RockMod.instance.players.findByID(ccmpPassenger.id);
+            if (player) {
+                passengers.add(player);
+            }
+        }
+        return passengers;
+    }
+    get ccmpMeta() {
+        return this._ccmpVehicle;
+    }
+    constructor(options) {
+        super();
+        this._ccmpVehicle = options.ccmpVehicle;
+        this._onDestroy = options.onDestroy;
+    }
+    destroy() {
+        if (!this._ccmpVehicle.isExists)
+            return;
+        this._ccmpVehicle.destroy();
+        this._onDestroy(this);
+    }
+    setPosition(value) {
+        this._ccmpVehicle.position = { x: value.x, y: value.y, z: value.z };
+    }
+    setDimension(value) {
+        this._ccmpVehicle.dimension = value;
+    }
+    setModel(value) {
+        this._ccmpVehicle.model = RockMod_1.RockMod.instance.utils.hash(value);
+    }
+    setRotation(value) {
+        this._ccmpVehicle.rotation = { x: value.x, y: value.y, z: value.z };
+    }
+    setBodyHealth(_value) {
+        notImplemented("CCMPVehicle.setBodyHealth");
+    }
+    setEngineHealth(_value) {
+        notImplemented("CCMPVehicle.setEngineHealth");
+    }
+    setEngineOn(value) {
+        this._ccmpVehicle.engineOn = value;
+    }
+    setNumberPlate(_value) {
+        notImplemented("CCMPVehicle.setNumberPlate");
+    }
+    setLocked(_value) {
+        notImplemented("CCMPVehicle.setLocked");
+    }
+    setPrimaryColor(_value) {
+        notImplemented("CCMPVehicle.setPrimaryColor");
+    }
+    setSecondaryColor(_value) {
+        notImplemented("CCMPVehicle.setSecondaryColor");
+    }
+    setCustomPrimaryColor(_value) {
+        notImplemented("CCMPVehicle.setCustomPrimaryColor");
+    }
+    setCustomSecondaryColor(_value) {
+        notImplemented("CCMPVehicle.setCustomSecondaryColor");
+    }
+    setMod(_modType, _modIndex) {
+        notImplemented("CCMPVehicle.setMod");
+    }
+    getMod(_modType) {
+        return notImplemented("CCMPVehicle.getMod");
+    }
+    setNeonEnabled(_enabled) {
+        notImplemented("CCMPVehicle.setNeonEnabled");
+    }
+    setNeonColor(_r, _g, _b) {
+        notImplemented("CCMPVehicle.setNeonColor");
+    }
+    setWindowTint(_tintType) {
+        notImplemented("CCMPVehicle.setWindowTint");
+    }
+    setWheelType(_wheelType) {
+        notImplemented("CCMPVehicle.setWheelType");
+    }
+    setPlateType(_plateType) {
+        notImplemented("CCMPVehicle.setPlateType");
+    }
+    explode() {
+        notImplemented("CCMPVehicle.explode");
+    }
+    repair() {
+        notImplemented("CCMPVehicle.repair");
+    }
+}
+exports.CCMPVehicle = CCMPVehicle;

package/dist/server/entities/ccmp/vehicle/CCMPVehiclesManager.d.ts

@@ -0,0 +1,9 @@
+import { type IVehicleCreateOptions, type IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+import { CCMPEntitiesManager } from "../entity/CCMPEntitiesManager";
+import { CCMPVehicle } from "./CCMPVehicle";
+export interface ICCMPVehicleCreateOptions extends IVehicleCreateOptions {
+}
+export declare class CCMPVehiclesManager extends CCMPEntitiesManager<CCMPVehicle> implements IVehiclesManager {
+    constructor();
+    create(options: ICCMPVehicleCreateOptions): CCMPVehicle;
+}

package/dist/server/entities/ccmp/vehicle/CCMPVehiclesManager.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPVehiclesManager = void 0;
+const CCMPEntitiesManager_1 = require("../entity/CCMPEntitiesManager");
+const CCMPVehicle_1 = require("./CCMPVehicle");
+class CCMPVehiclesManager extends CCMPEntitiesManager_1.CCMPEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "vehicle",
+        });
+    }
+    create(options) {
+        const { model, position, rotation, engine, dimension } = options;
+        // CCMP vehicles API has no `locked` field yet — it is silently ignored.
+        const ccmpVehicle = ccmp.vehicles.create(ccmp.hash(model), position.x, position.y, position.z, rotation.z);
+        if (!ccmpVehicle) {
+            throw new Error("CCMPVehiclesManager.create: ccmp.vehicles.create failed (server full?)");
+        }
+        ccmpVehicle.dimension = dimension;
+        if (engine) {
+            ccmpVehicle.engineOn = true;
+        }
+        const vehicle = new CCMPVehicle_1.CCMPVehicle({
+            ccmpVehicle,
+            onDestroy: (v) => this.unregisterBaseObject(v),
+        });
+        this.registerBaseObject(vehicle);
+        return vehicle;
+    }
+}
+exports.CCMPVehiclesManager = CCMPVehiclesManager;

package/dist/server/entities/ccmp/worldObject/CCMPWorldObject.d.ts

@@ -0,0 +1,9 @@
+import { type IWorldObject } from "../../common/worldObject/IWorldObject";
+import { CCMPBaseObject } from "../baseObject/CCMPBaseObject";
+import { type IVector3D } from "../../../../shared/common/utils/math/Vectors";
+export declare abstract class CCMPWorldObject extends CCMPBaseObject implements IWorldObject {
+    abstract get position(): IVector3D;
+    abstract get dimension(): number;
+    abstract setPosition(value: IVector3D): void;
+    abstract setDimension(value: number): void;
+}

package/dist/server/entities/ccmp/worldObject/CCMPWorldObject.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPWorldObject = void 0;
+const CCMPBaseObject_1 = require("../baseObject/CCMPBaseObject");
+class CCMPWorldObject extends CCMPBaseObject_1.CCMPBaseObject {
+}
+exports.CCMPWorldObject = CCMPWorldObject;

package/dist/server/entities/ccmp/worldObject/CCMPWorldObjectsIterator.d.ts

@@ -0,0 +1,10 @@
+import { type IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { type CCMPWorldObject } from "./CCMPWorldObject";
+import { CCMPBaseObjectsIterator } from "../baseObject/CCMPBaseObjectsIterator";
+import { type Vector2D, type Vector3D } from "../../../../shared/common/utils/math/Vectors";
+export declare class CCMPWorldObjectsIterator<T extends CCMPWorldObject> extends CCMPBaseObjectsIterator<T> implements IWorldObjectsIterator<T> {
+    constructor(baseObjects: ReadonlyMap<number, T>);
+    dimension(value: number): IterableIterator<T>;
+    range2D(center: Vector2D, range: number): IterableIterator<T>;
+    range3D(center: Vector3D, range: number): IterableIterator<T>;
+}

package/dist/server/entities/ccmp/worldObject/CCMPWorldObjectsIterator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPWorldObjectsIterator = void 0;
+const CCMPBaseObjectsIterator_1 = require("../baseObject/CCMPBaseObjectsIterator");
+class CCMPWorldObjectsIterator extends CCMPBaseObjectsIterator_1.CCMPBaseObjectsIterator {
+    constructor(baseObjects) {
+        super(baseObjects);
+    }
+    *dimension(value) {
+        for (const worldObject of this.all()) {
+            if (worldObject.dimension === value) {
+                yield worldObject;
+            }
+        }
+    }
+    *range2D(center, range) {
+        const rangeSquared = range * range;
+        for (const worldObject of this.all()) {
+            const { x, y } = worldObject.position;
+            const dx = center.x - x;
+            const dy = center.y - y;
+            if (dx * dx + dy * dy <= rangeSquared) {
+                yield worldObject;
+            }
+        }
+    }
+    *range3D(center, range) {
+        const rangeSquared = range * range;
+        for (const worldObject of this.all()) {
+            const { x, y, z } = worldObject.position;
+            const dx = center.x - x;
+            const dy = center.y - y;
+            const dz = center.z - z;
+            if (dx * dx + dy * dy + dz * dz <= rangeSquared) {
+                yield worldObject;
+            }
+        }
+    }
+}
+exports.CCMPWorldObjectsIterator = CCMPWorldObjectsIterator;

package/dist/server/entities/ccmp/worldObject/CCMPWorldObjectsManager.d.ts

@@ -0,0 +1,11 @@
+import { type IWorldObjectsManager } from "../../common/worldObject/IWorldObjectsManager";
+import { type ICCMPBaseObjectsManagerOptions, CCMPBaseObjectsManager } from "../baseObject/CCMPBaseObjectsManager";
+import { type CCMPWorldObject } from "./CCMPWorldObject";
+import { CCMPWorldObjectsIterator } from "./CCMPWorldObjectsIterator";
+export interface ICCMPWorldObjectsManagerOptions extends ICCMPBaseObjectsManagerOptions {
+}
+export declare abstract class CCMPWorldObjectsManager<T extends CCMPWorldObject> extends CCMPBaseObjectsManager<T> implements IWorldObjectsManager<T> {
+    protected readonly _iterator: CCMPWorldObjectsIterator<T>;
+    get iterator(): CCMPWorldObjectsIterator<T>;
+    protected constructor(options: ICCMPWorldObjectsManagerOptions);
+}

package/dist/server/entities/ccmp/worldObject/CCMPWorldObjectsManager.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPWorldObjectsManager = void 0;
+const CCMPBaseObjectsManager_1 = require("../baseObject/CCMPBaseObjectsManager");
+const CCMPWorldObjectsIterator_1 = require("./CCMPWorldObjectsIterator");
+class CCMPWorldObjectsManager extends CCMPBaseObjectsManager_1.CCMPBaseObjectsManager {
+    _iterator;
+    get iterator() {
+        return this._iterator;
+    }
+    constructor(options) {
+        super(options);
+        this._iterator = new CCMPWorldObjectsIterator_1.CCMPWorldObjectsIterator(this.baseObjects);
+    }
+}
+exports.CCMPWorldObjectsManager = CCMPWorldObjectsManager;

package/dist/server/entities/mock/player/MockPlayersManager.js

@@ -73,8 +73,9 @@ class MockPlayersManager extends MockEntitiesManager_1.MockEntitiesManager {
         if (!this._baseObjects.has(player.id)) {
             throw new Error(`Player with id ${player.id} not found`);
         }
-        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.PlayerDisconnected, player);
+        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.PlayerQuit, player, "disconnect", "");
         this.unregisterBaseObject(player);
+        RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.PlayerDisconnected, player);
     }
 }
 exports.MockPlayersManager = MockPlayersManager;

package/dist/server/factories/ccmp/CCMPManagersFactory.d.ts

@@ -0,0 +1,23 @@
+import { type IManagersFactory } from "../common/IManagersFactory";
+import { CCMPNetManager } from "../../net/ccmp/CCMPNetManager";
+import { CCMPBlipsManager } from "../../entities/ccmp/blip/CCMPBlipsManager";
+import { CCMPColshapesManager } from "../../entities/ccmp/colshape/CCMPColshapesManager";
+import { CCMPMarkersManager } from "../../entities/ccmp/marker/CCMPMarkersManager";
+import { CCMPObjectsManager } from "../../entities/ccmp/object/CCMPObjectsManager";
+import { CCMPPedsManager } from "../../entities/ccmp/ped/CCMPPedsManager";
+import { CCMPPlayersManager } from "../../entities/ccmp/player/CCMPPlayersManager";
+import { CCMPUtilsManager } from "../../utils/ccmp/CCMPUtilsManager";
+import { CCMPVehiclesManager } from "../../entities/ccmp/vehicle/CCMPVehiclesManager";
+import { CCMPWorldManager } from "../../world/ccmp/CCMPWorldManager";
+export declare class CCMPManagersFactory implements IManagersFactory {
+    createNetManager(): CCMPNetManager;
+    createBlipsManager(): CCMPBlipsManager;
+    createColshapesManager(): CCMPColshapesManager;
+    createMarkersManager(): CCMPMarkersManager;
+    createObjectsManager(): CCMPObjectsManager;
+    createPedsManager(): CCMPPedsManager;
+    createPlayersManager(net: CCMPNetManager): CCMPPlayersManager;
+    createUtilsManager(): CCMPUtilsManager;
+    createVehiclesManager(): CCMPVehiclesManager;
+    createWorldManager(): CCMPWorldManager;
+}

package/dist/server/factories/ccmp/CCMPManagersFactory.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPManagersFactory = void 0;
+const CCMPNetManager_1 = require("../../net/ccmp/CCMPNetManager");
+const CCMPBlipsManager_1 = require("../../entities/ccmp/blip/CCMPBlipsManager");
+const CCMPColshapesManager_1 = require("../../entities/ccmp/colshape/CCMPColshapesManager");
+const CCMPMarkersManager_1 = require("../../entities/ccmp/marker/CCMPMarkersManager");
+const CCMPObjectsManager_1 = require("../../entities/ccmp/object/CCMPObjectsManager");
+const CCMPPedsManager_1 = require("../../entities/ccmp/ped/CCMPPedsManager");
+const CCMPPlayersManager_1 = require("../../entities/ccmp/player/CCMPPlayersManager");
+const CCMPUtilsManager_1 = require("../../utils/ccmp/CCMPUtilsManager");
+const CCMPVehiclesManager_1 = require("../../entities/ccmp/vehicle/CCMPVehiclesManager");
+const CCMPWorldManager_1 = require("../../world/ccmp/CCMPWorldManager");
+class CCMPManagersFactory {
+    createNetManager() {
+        return new CCMPNetManager_1.CCMPNetManager();
+    }
+    createBlipsManager() {
+        return new CCMPBlipsManager_1.CCMPBlipsManager();
+    }
+    createColshapesManager() {
+        return new CCMPColshapesManager_1.CCMPColshapesManager();
+    }
+    createMarkersManager() {
+        return new CCMPMarkersManager_1.CCMPMarkersManager();
+    }
+    createObjectsManager() {
+        return new CCMPObjectsManager_1.CCMPObjectsManager();
+    }
+    createPedsManager() {
+        return new CCMPPedsManager_1.CCMPPedsManager();
+    }
+    createPlayersManager(net) {
+        return new CCMPPlayersManager_1.CCMPPlayersManager(net);
+    }
+    createUtilsManager() {
+        return new CCMPUtilsManager_1.CCMPUtilsManager();
+    }
+    createVehiclesManager() {
+        return new CCMPVehiclesManager_1.CCMPVehiclesManager();
+    }
+    createWorldManager() {
+        return new CCMPWorldManager_1.CCMPWorldManager();
+    }
+}
+exports.CCMPManagersFactory = CCMPManagersFactory;

package/dist/server/net/ccmp/CCMPNetManager.d.ts

@@ -0,0 +1,19 @@
+import { type INetManager } from "../common/INetManager";
+import { CCMPEventsManager } from "./events/CCMPEventsManager";
+import { CCMPRPCManager } from "./rpc/CCMPRPCManager";
+export declare class CCMPNetManager implements INetManager {
+    private readonly _eventsManager;
+    private readonly _rpcManager;
+    get events(): CCMPEventsManager;
+    get rpc(): CCMPRPCManager;
+    constructor();
+    private _registerClientReadyCooperation;
+    /**
+     * Принимает зеркалированные клиентские `console.*` вызовы и печатает в
+     * серверный stdout. Необходимо для отладки CCMP-клиента: иначе ошибки
+     * boot'а уходят в игровую консоль (F8), не видны разработчику.
+     *
+     * Парный клиент — `CCMPConsoleForwarder`.
+     */
+    private _registerClientLogForwarder;
+}

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]>>;
+}