rock-mod 0.20.0 → 0.22.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 this._ccmpVehicle.numberPlateText;
+    }
+    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) {
+        this._ccmpVehicle.numberPlateText = value;
+    }
+    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) {
+        this._ccmpVehicle.numberPlateType = plateType;
+    }
+    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/entities/ragemp/entity/RageEntity.d.ts

@@ -1,9 +1,11 @@
 import { type IEntity } from "../../common/entity/IEntity";
 import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
-import { Vector3D } from "../../../../shared/common/utils";
+import { type IVector3D, Vector3D } from "../../../../shared/common/utils";
 export interface IRageEntityOptions<T extends EntityMp> extends IRageWorldObjectOptions<T> {
+    rotation?: IVector3D;
 }
 export declare abstract class RageEntity<T extends EntityMp> extends RageWorldObject<T> implements IEntity {
+    private _rotation;
     get model(): number;
     get rotation(): Vector3D;
     protected constructor(options: IRageEntityOptions<T>);
@@ -11,4 +13,6 @@ export declare abstract class RageEntity<T extends EntityMp> extends RageWorldOb
     setRotation(value: Vector3D): void;
     getNetData(name: string): unknown;
     setNetData(name: string, value: unknown): void;
+    private _getEntityRotationProperty;
+    private _isVectorLike;
 }

package/dist/server/entities/ragemp/entity/RageEntity.js

@@ -4,20 +4,23 @@ exports.RageEntity = void 0;
 const RageWorldObject_1 = require("../worldObject/RageWorldObject");
 const utils_1 = require("../../../../shared/common/utils");
 class RageEntity extends RageWorldObject_1.RageWorldObject {
+    _rotation;
     get model() {
         return this.mpEntity.model;
     }
     get rotation() {
-        const { x, y, z } = this.mpEntity.rotation;
+        const { x, y, z } = this._getEntityRotationProperty() ?? this._rotation ?? new utils_1.Vector3D(0, 0, 0);
         return new utils_1.Vector3D(x, y, z);
     }
     constructor(options) {
         super(options);
+        this._rotation = options.rotation;
     }
     setModel(value) {
         this.mpEntity.model = mp.joaat(value);
     }
     setRotation(value) {
+        this._rotation = value;
         this.mpEntity.rotation = new mp.Vector3(value);
     }
     getNetData(name) {
@@ -26,5 +29,18 @@ class RageEntity extends RageWorldObject_1.RageWorldObject {
     setNetData(name, value) {
         this.mpEntity.setVariable(name, value);
     }
+    _getEntityRotationProperty() {
+        const rotation = this.mpEntity.rotation;
+        if (!this._isVectorLike(rotation))
+            return null;
+        return rotation;
+    }
+    _isVectorLike(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            typeof value.x === "number" &&
+            typeof value.y === "number" &&
+            typeof value.z === "number");
+    }
 }
 exports.RageEntity = RageEntity;

package/dist/server/entities/ragemp/object/RageObjectsManager.js

@@ -17,7 +17,7 @@ class RageObjectsManager extends RageEntitiesManager_1.RageEntitiesManager {
             alpha,
         });
         mpEntity.isExists = () => mp.objects.exists(mpEntity);
-        const object = new RageObject_1.RageObject({ mpEntity });
+        const object = new RageObject_1.RageObject({ mpEntity, rotation });
         this.registerBaseObject(object);
         return object;
     }

package/dist/server/entities/ragemp/ped/RagePedsManager.js

@@ -17,7 +17,7 @@ class RagePedsManager extends RageEntitiesManager_1.RageEntitiesManager {
             frozen,
         });
         mpEntity.isExists = () => mp.peds.exists(mpEntity);
-        const ped = new RagePed_1.RagePed({ mpEntity });
+        const ped = new RagePed_1.RagePed({ mpEntity, rotation });
         this.registerBaseObject(ped);
         return ped;
     }

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

@@ -19,7 +19,7 @@ class RageVehiclesManager extends RageEntitiesManager_1.RageEntitiesManager {
         });
         mpEntity.rotation = new mp.Vector3(rotation);
         mpEntity.isExists = () => mp.vehicles.exists(mpEntity);
-        const vehicle = new RageVehicle_1.RageVehicle({ mpEntity });
+        const vehicle = new RageVehicle_1.RageVehicle({ mpEntity, rotation });
         this.registerBaseObject(vehicle);
         return vehicle;
     }

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