rock-mod 0.20.0 → 0.22.0

package/dist/server/entities/ccmp/marker/CCMPMarkersManager.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPMarkersManager = void 0;
+const CCMPWorldObjectsManager_1 = require("../worldObject/CCMPWorldObjectsManager");
+const CCMPMarker_1 = require("./CCMPMarker");
+class CCMPMarkersManager extends CCMPWorldObjectsManager_1.CCMPWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "marker",
+        });
+    }
+    create(options) {
+        const { position, dimension, type, scale, color, rotation } = options;
+        const ccmpMarker = ccmp.markers.create(type, position.x, position.y, position.z, scale, {
+            color: { r: color.r, g: color.g, b: color.b, a: color.a ?? 255 },
+            rotation: { x: rotation.x, y: rotation.y, z: rotation.z },
+            dimension,
+        });
+        if (!ccmpMarker) {
+            throw new Error("CCMPMarkersManager.create: ccmp.markers.create failed (server full?)");
+        }
+        const marker = new CCMPMarker_1.CCMPMarker({
+            ccmpMarker,
+            onDestroy: (m) => this.unregisterBaseObject(m),
+        });
+        this.registerBaseObject(marker);
+        return marker;
+    }
+}
+exports.CCMPMarkersManager = CCMPMarkersManager;

package/dist/server/entities/ccmp/object/CCMPObject.d.ts

@@ -0,0 +1,48 @@
+import { CCMPEntity } from "../entity/CCMPEntity";
+import { type IObject } from "../../common/object/IObject";
+import { BaseObjectType } from "../../../../shared";
+import { type IVector3D } from "../../../../shared/common/utils/math/Vectors";
+import type { StreamSyncedMeta } from "@classic-mp/types/server";
+export interface ICCMPObjectNative extends StreamSyncedMeta {
+    id: number;
+    isExists: boolean;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    model: number;
+    dimension: number;
+    alpha: number;
+    destroy(): boolean;
+}
+export interface ICCMPObjectOptions {
+    ccmpObject: ICCMPObjectNative;
+    alpha: number;
+    onDestroy: (object: CCMPObject) => void;
+}
+export declare class CCMPObject extends CCMPEntity implements IObject {
+    private readonly _ccmpObject;
+    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 alpha(): number;
+    protected get ccmpMeta(): ICCMPObjectNative;
+    constructor(options: ICCMPObjectOptions);
+    destroy(): void;
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+    setModel(value: string): void;
+    setRotation(value: IVector3D): void;
+    setAlpha(value: number): void;
+}

package/dist/server/entities/ccmp/object/CCMPObject.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPObject = void 0;
+const CCMPEntity_1 = require("../entity/CCMPEntity");
+const shared_1 = require("../../../../shared");
+const Vectors_1 = require("../../../../shared/common/utils/math/Vectors");
+const RockMod_1 = require("../../../RockMod");
+class CCMPObject extends CCMPEntity_1.CCMPEntity {
+    _ccmpObject;
+    _onDestroy;
+    get id() {
+        return this._ccmpObject.id;
+    }
+    get type() {
+        return shared_1.BaseObjectType.Object;
+    }
+    get isExists() {
+        return this._ccmpObject.isExists;
+    }
+    get position() {
+        const p = this._ccmpObject.position;
+        return new Vectors_1.Vector3D(p.x, p.y, p.z);
+    }
+    get dimension() {
+        return this._ccmpObject.dimension;
+    }
+    get model() {
+        return this._ccmpObject.model;
+    }
+    get rotation() {
+        const r = this._ccmpObject.rotation;
+        return new Vectors_1.Vector3D(r.x, r.y, r.z);
+    }
+    get alpha() {
+        return this._ccmpObject.alpha;
+    }
+    get ccmpMeta() {
+        return this._ccmpObject;
+    }
+    constructor(options) {
+        super();
+        this._ccmpObject = options.ccmpObject;
+        this._ccmpObject.alpha = options.alpha;
+        this._onDestroy = options.onDestroy;
+    }
+    destroy() {
+        if (!this._ccmpObject.isExists)
+            return;
+        this._ccmpObject.destroy();
+        this._onDestroy(this);
+    }
+    setPosition(value) {
+        this._ccmpObject.position = { x: value.x, y: value.y, z: value.z };
+    }
+    setDimension(value) {
+        this._ccmpObject.dimension = value;
+    }
+    setModel(value) {
+        this._ccmpObject.model = RockMod_1.RockMod.instance.utils.hash(value);
+    }
+    setRotation(value) {
+        this._ccmpObject.rotation = { x: value.x, y: value.y, z: value.z };
+    }
+    setAlpha(value) {
+        this._ccmpObject.alpha = value;
+    }
+}
+exports.CCMPObject = CCMPObject;

package/dist/server/entities/ccmp/object/CCMPObjectsManager.d.ts

@@ -0,0 +1,9 @@
+import { type IObjectCreateOptions, type IObjectsManager } from "../../common/object/IObjectsManager";
+import { CCMPEntitiesManager } from "../entity/CCMPEntitiesManager";
+import { CCMPObject } from "./CCMPObject";
+export interface ICCMPObjectCreateOptions extends IObjectCreateOptions {
+}
+export declare class CCMPObjectsManager extends CCMPEntitiesManager<CCMPObject> implements IObjectsManager {
+    constructor();
+    create(options: ICCMPObjectCreateOptions): CCMPObject;
+}

package/dist/server/entities/ccmp/object/CCMPObjectsManager.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPObjectsManager = void 0;
+const CCMPEntitiesManager_1 = require("../entity/CCMPEntitiesManager");
+const CCMPObject_1 = require("./CCMPObject");
+class CCMPObjectsManager extends CCMPEntitiesManager_1.CCMPEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "object",
+        });
+    }
+    create(options) {
+        const { model, position, dimension, rotation, alpha } = options;
+        const ccmpObject = ccmp.objects.create(ccmp.hash(model), position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, { dimension, alpha });
+        if (!ccmpObject) {
+            throw new Error("CCMPObjectsManager.create: ccmp.objects.create failed (server full?)");
+        }
+        const object = new CCMPObject_1.CCMPObject({
+            ccmpObject,
+            alpha,
+            onDestroy: (o) => this.unregisterBaseObject(o),
+        });
+        this.registerBaseObject(object);
+        return object;
+    }
+}
+exports.CCMPObjectsManager = CCMPObjectsManager;

package/dist/server/entities/ccmp/ped/CCMPPed.d.ts

@@ -0,0 +1,33 @@
+import { CCMPEntity } from "../entity/CCMPEntity";
+import { type IPed } from "../../common/ped/IPed";
+import { BaseObjectType } from "../../../../shared";
+import { type IVector3D } from "../../../../shared/common/utils/math/Vectors";
+import type { Ped as CcmpPed } from "@classic-mp/types/server";
+export interface ICCMPPedOptions {
+    ccmpPed: CcmpPed;
+    onDestroy: (ped: CCMPPed) => void;
+}
+export declare class CCMPPed extends CCMPEntity implements IPed {
+    private readonly _ccmpPed;
+    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 heading(): number;
+    get health(): number;
+    get armour(): number;
+    protected get ccmpMeta(): CcmpPed;
+    constructor(options: ICCMPPedOptions);
+    destroy(): void;
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+    setModel(value: string): void;
+    setRotation(value: IVector3D): void;
+    setHeading(value: number): void;
+    setHealth(value: number): void;
+    setArmour(value: number): void;
+}

package/dist/server/entities/ccmp/ped/CCMPPed.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPPed = void 0;
+const CCMPEntity_1 = require("../entity/CCMPEntity");
+const shared_1 = require("../../../../shared");
+const Vectors_1 = require("../../../../shared/common/utils/math/Vectors");
+const Math_1 = require("../../../../shared/common/utils/math/Math");
+const RockMod_1 = require("../../../RockMod");
+class CCMPPed extends CCMPEntity_1.CCMPEntity {
+    _ccmpPed;
+    _onDestroy;
+    get id() {
+        return this._ccmpPed.id;
+    }
+    get type() {
+        return shared_1.BaseObjectType.Ped;
+    }
+    get isExists() {
+        return this._ccmpPed.isExists;
+    }
+    get position() {
+        const p = this._ccmpPed.position;
+        return new Vectors_1.Vector3D(p.x, p.y, p.z);
+    }
+    get dimension() {
+        return this._ccmpPed.dimension;
+    }
+    get model() {
+        return this._ccmpPed.model;
+    }
+    // CCMP exposes only heading; map it onto rotation.z.
+    get rotation() {
+        return new Vectors_1.Vector3D(0, 0, this._ccmpPed.heading);
+    }
+    get heading() {
+        return this._ccmpPed.heading;
+    }
+    get health() {
+        return this._ccmpPed.health;
+    }
+    get armour() {
+        return this._ccmpPed.armour;
+    }
+    get ccmpMeta() {
+        return this._ccmpPed;
+    }
+    constructor(options) {
+        super();
+        this._ccmpPed = options.ccmpPed;
+        this._onDestroy = options.onDestroy;
+    }
+    destroy() {
+        if (!this._ccmpPed.isExists)
+            return;
+        this._ccmpPed.destroy();
+        this._onDestroy(this);
+    }
+    setPosition(value) {
+        this._ccmpPed.teleport(value.x, value.y, value.z);
+    }
+    setDimension(value) {
+        this._ccmpPed.dimension = value;
+    }
+    setModel(value) {
+        // CCMP ped.model is u32; hash the name via the shared util before assignment.
+        this._ccmpPed.model = RockMod_1.RockMod.instance.utils.hash(value);
+    }
+    setRotation(value) {
+        // CCMP exposes only heading; pitch/roll (x/y) are silently dropped.
+        this._ccmpPed.heading = value.z;
+    }
+    setHeading(value) {
+        this._ccmpPed.heading = value;
+    }
+    setHealth(value) {
+        this._ccmpPed.health = (0, Math_1.MathClamp)(value, 0, 200);
+    }
+    setArmour(value) {
+        this._ccmpPed.armour = (0, Math_1.MathClamp)(value, 0, 100);
+    }
+}
+exports.CCMPPed = CCMPPed;

package/dist/server/entities/ccmp/ped/CCMPPedsManager.d.ts

@@ -0,0 +1,9 @@
+import { type IPedCreateOptions, type IPedsManager } from "../../common/ped/IPedsManager";
+import { CCMPEntitiesManager } from "../entity/CCMPEntitiesManager";
+import { CCMPPed } from "./CCMPPed";
+export interface ICCMPPedCreateOptions extends IPedCreateOptions {
+}
+export declare class CCMPPedsManager extends CCMPEntitiesManager<CCMPPed> implements IPedsManager {
+    constructor();
+    create(options: ICCMPPedCreateOptions): CCMPPed;
+}

package/dist/server/entities/ccmp/ped/CCMPPedsManager.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPPedsManager = void 0;
+const CCMPEntitiesManager_1 = require("../entity/CCMPEntitiesManager");
+const CCMPPed_1 = require("./CCMPPed");
+class CCMPPedsManager extends CCMPEntitiesManager_1.CCMPEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "ped",
+        });
+    }
+    create(options) {
+        const { model, position, rotation, dimension } = options;
+        // CCMP peds API does not yet support `frozen` — it is silently ignored.
+        const ccmpPed = ccmp.peds.create(ccmp.hash(model), position.x, position.y, position.z, rotation.z);
+        if (!ccmpPed) {
+            throw new Error("CCMPPedsManager.create: ccmp.peds.create failed (server full?)");
+        }
+        ccmpPed.dimension = dimension;
+        const ped = new CCMPPed_1.CCMPPed({
+            ccmpPed,
+            onDestroy: (p) => this.unregisterBaseObject(p),
+        });
+        this.registerBaseObject(ped);
+        return ped;
+    }
+}
+exports.CCMPPedsManager = CCMPPedsManager;

package/dist/server/entities/ccmp/player/CCMPPlayer.d.ts

@@ -0,0 +1,65 @@
+import { CCMPEntity } from "../entity/CCMPEntity";
+import { type ICustomization, type IPlayer } from "../../common/player/IPlayer";
+import { type CCMPVehicle } from "../vehicle/CCMPVehicle";
+import { BaseObjectType, type IServerToClientEvents } from "../../../../shared";
+import { type IClientRPCList } from "../../../../shared/net/common/rpc/types";
+import { type IVector3D, Vector3D } from "../../../../shared/common/utils/math/Vectors";
+import type { Player as CcmpPlayer } from "@classic-mp/types/server";
+export interface ICCMPPlayerOptions {
+    ccmpPlayer: CcmpPlayer;
+}
+export declare class CCMPPlayer extends CCMPEntity implements IPlayer {
+    private readonly _ccmpPlayer;
+    get id(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get position(): IVector3D;
+    get dimension(): number;
+    get model(): number;
+    get rotation(): IVector3D;
+    get name(): string;
+    get socialClub(): string;
+    get heading(): number;
+    get health(): number;
+    get armour(): number;
+    get isDead(): boolean;
+    get ip(): string;
+    get serial(): string;
+    get vehicle(): CCMPVehicle | null;
+    get seat(): number;
+    get weapon(): number;
+    get weaponAmmo(): number;
+    protected get ccmpMeta(): CcmpPlayer;
+    get eyeColor(): number;
+    get streamedPlayers(): CCMPPlayer[];
+    constructor(options: ICCMPPlayerOptions);
+    destroy(): void;
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+    setModel(value: string): void;
+    setRotation(value: IVector3D): void;
+    emitEvent<K extends keyof IServerToClientEvents>(eventName: K, ...args: Parameters<IServerToClientEvents[K]>): void;
+    emitRPC<K extends keyof IClientRPCList>(rpcName: K, ...args: Parameters<IClientRPCList[K]>): Promise<ReturnType<IClientRPCList[K]>>;
+    spawn(_position: Vector3D): void;
+    setName(name: string): void;
+    setHeading(value: number): void;
+    setHealth(value: number): void;
+    setArmour(value: number): void;
+    setWeaponAmmo(weapon: string, ammo: number): void;
+    giveWeapon(weapon: string, ammo: number): void;
+    removeWeapon(weapon: string): void;
+    enableVoiceTo(_player: CCMPPlayer): void;
+    disableVoiceTo(_player: CCMPPlayer): void;
+    putIntoVehicle(vehicle: CCMPVehicle, seat?: number): void;
+    ejectFromVehicle(): void;
+    setCustomization(_data: ICustomization): void;
+    setHeadOverlay(_overlayID: number, _index: number, _opacity: number, _firstColor: number, _secondColor: number): void;
+    setEyeColor(_colorID: number): void;
+    setProp(_propID: number, _drawableID: number, _textureID: number): void;
+    setClothes(_componentID: number, _drawableID: number, _textureID: number, _paletteID: number): void;
+    setHairColor(_colorID: number, _highlightColorID: number): void;
+    kick(reason?: string): void;
+    playAnimation(dictionary: string, name: string, speed: number, flag: number): void;
+    stopAnimation(): void;
+    removeFromVehicle(): void;
+}

package/dist/server/entities/ccmp/player/CCMPPlayer.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPPlayer = void 0;
+const CCMPEntity_1 = require("../entity/CCMPEntity");
+const shared_1 = require("../../../../shared");
+const Vectors_1 = require("../../../../shared/common/utils/math/Vectors");
+const Math_1 = require("../../../../shared/common/utils/math/Math");
+const RockMod_1 = require("../../../RockMod");
+const notImplemented = (name) => {
+    throw new Error(`Not implemented yet: ${name}`);
+};
+class CCMPPlayer extends CCMPEntity_1.CCMPEntity {
+    _ccmpPlayer;
+    get id() {
+        return this._ccmpPlayer.id;
+    }
+    get type() {
+        return shared_1.BaseObjectType.Player;
+    }
+    get isExists() {
+        return ccmp.players.getById(this._ccmpPlayer.id) !== null;
+    }
+    get position() {
+        const p = this._ccmpPlayer.position;
+        if (!p)
+            return new Vectors_1.Vector3D(0, 0, 0);
+        return new Vectors_1.Vector3D(p.x, p.y, p.z);
+    }
+    get dimension() {
+        return this._ccmpPlayer.dimension;
+    }
+    get model() {
+        return this._ccmpPlayer.model;
+    }
+    // CCMP exposes only heading; pitch/roll (x/y components) are silently dropped on setRotation.
+    get rotation() {
+        return new Vectors_1.Vector3D(0, 0, this._ccmpPlayer.heading);
+    }
+    get name() {
+        return this._ccmpPlayer.name;
+    }
+    get socialClub() {
+        return this._ccmpPlayer.socialClub;
+    }
+    get heading() {
+        return this._ccmpPlayer.heading;
+    }
+    get health() {
+        return this._ccmpPlayer.health;
+    }
+    get armour() {
+        return this._ccmpPlayer.armour;
+    }
+    get isDead() {
+        return this._ccmpPlayer.health <= 0;
+    }
+    get ip() {
+        return notImplemented("CCMPPlayer.ip");
+    }
+    get serial() {
+        return notImplemented("CCMPPlayer.serial");
+    }
+    get vehicle() {
+        const ccmpVehicle = this._ccmpPlayer.vehicle;
+        if (!ccmpVehicle)
+            return null;
+        return RockMod_1.RockMod.instance.vehicles.findByID(ccmpVehicle.id);
+    }
+    get seat() {
+        return this._ccmpPlayer.seat;
+    }
+    get weapon() {
+        return this._ccmpPlayer.currentWeapon;
+    }
+    get weaponAmmo() {
+        return this._ccmpPlayer.ammo;
+    }
+    get ccmpMeta() {
+        return this._ccmpPlayer;
+    }
+    get eyeColor() {
+        return notImplemented("CCMPPlayer.eyeColor");
+    }
+    get streamedPlayers() {
+        return notImplemented("CCMPPlayer.streamedPlayers");
+    }
+    constructor(options) {
+        super();
+        this._ccmpPlayer = options.ccmpPlayer;
+    }
+    destroy() {
+        notImplemented("CCMPPlayer.destroy");
+    }
+    setPosition(value) {
+        this._ccmpPlayer.teleport(value.x, value.y, value.z);
+    }
+    setDimension(value) {
+        this._ccmpPlayer.dimension = value;
+    }
+    setModel(value) {
+        // CCMP runtime accepts a string and JOAATs server-side via op_set_player_model.
+        this._ccmpPlayer.model = value;
+    }
+    setRotation(value) {
+        this._ccmpPlayer.heading = value.z;
+    }
+    emitEvent(eventName, ...args) {
+        return RockMod_1.RockMod.instance.net.events.emitClient(this, eventName, ...args);
+    }
+    emitRPC(rpcName, ...args) {
+        return RockMod_1.RockMod.instance.net.rpc.emitClient(this, rpcName, ...args);
+    }
+    spawn(_position) {
+        notImplemented("CCMPPlayer.spawn");
+    }
+    setName(name) {
+        this._ccmpPlayer.name = name;
+    }
+    setHeading(value) {
+        this._ccmpPlayer.heading = value;
+    }
+    setHealth(value) {
+        this._ccmpPlayer.health = (0, Math_1.MathClamp)(value, 0, 100);
+    }
+    setArmour(value) {
+        this._ccmpPlayer.armour = (0, Math_1.MathClamp)(value, 0, 100);
+    }
+    setWeaponAmmo(weapon, ammo) {
+        this._ccmpPlayer.setWeaponAmmo(RockMod_1.RockMod.instance.utils.hash(weapon), ammo);
+    }
+    giveWeapon(weapon, ammo) {
+        this._ccmpPlayer.giveWeapon(RockMod_1.RockMod.instance.utils.hash(weapon), ammo);
+    }
+    removeWeapon(weapon) {
+        this._ccmpPlayer.removeWeapon(RockMod_1.RockMod.instance.utils.hash(weapon));
+    }
+    enableVoiceTo(_player) {
+        notImplemented("CCMPPlayer.enableVoiceTo");
+    }
+    disableVoiceTo(_player) {
+        notImplemented("CCMPPlayer.disableVoiceTo");
+    }
+    putIntoVehicle(vehicle, seat) {
+        this._ccmpPlayer.putIntoVehicle(vehicle.id, seat);
+    }
+    ejectFromVehicle() {
+        this._ccmpPlayer.removeFromVehicle();
+    }
+    setCustomization(_data) {
+        notImplemented("CCMPPlayer.setCustomization");
+    }
+    setHeadOverlay(_overlayID, _index, _opacity, _firstColor, _secondColor) {
+        notImplemented("CCMPPlayer.setHeadOverlay");
+    }
+    setEyeColor(_colorID) {
+        notImplemented("CCMPPlayer.setEyeColor");
+    }
+    setProp(_propID, _drawableID, _textureID) {
+        notImplemented("CCMPPlayer.setProp");
+    }
+    setClothes(_componentID, _drawableID, _textureID, _paletteID) {
+        notImplemented("CCMPPlayer.setClothes");
+    }
+    setHairColor(_colorID, _highlightColorID) {
+        notImplemented("CCMPPlayer.setHairColor");
+    }
+    kick(reason) {
+        this._ccmpPlayer.kick(reason ?? "");
+    }
+    playAnimation(dictionary, name, speed, flag) {
+        this._ccmpPlayer.playAnimation(dictionary, name, speed, flag);
+    }
+    stopAnimation() {
+        this._ccmpPlayer.stopAnimation();
+    }
+    removeFromVehicle() {
+        this._ccmpPlayer.removeFromVehicle();
+    }
+}
+exports.CCMPPlayer = CCMPPlayer;

package/dist/server/entities/ccmp/player/CCMPPlayersManager.d.ts

@@ -0,0 +1,12 @@
+import { type IPlayersManager } from "../../common/player/IPlayersManager";
+import { CCMPEntitiesManager } from "../entity/CCMPEntitiesManager";
+import { CCMPPlayer } from "./CCMPPlayer";
+import { type CCMPNetManager } from "../../../net/ccmp/CCMPNetManager";
+export declare class CCMPPlayersManager extends CCMPEntitiesManager<CCMPPlayer> implements IPlayersManager {
+    constructor(net: CCMPNetManager);
+    getByName(name: string): CCMPPlayer;
+    findByName(name: string): CCMPPlayer | null;
+    getBySocialClub(socialClub: string): CCMPPlayer;
+    findBySocialClub(socialClub: string): CCMPPlayer | null;
+    private _init;
+}

package/dist/server/entities/ccmp/player/CCMPPlayersManager.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPPlayersManager = void 0;
+const CCMPEntitiesManager_1 = require("../entity/CCMPEntitiesManager");
+const CCMPPlayer_1 = require("./CCMPPlayer");
+const types_1 = require("../../../net/common/events/types");
+class CCMPPlayersManager extends CCMPEntitiesManager_1.CCMPEntitiesManager {
+    constructor(net) {
+        super({
+            baseObjectsType: "player",
+        });
+        this._init(net);
+    }
+    getByName(name) {
+        const player = this.findByName(name);
+        if (!player) {
+            throw new Error(`Player with name ${name} not found`);
+        }
+        return player;
+    }
+    findByName(name) {
+        for (const player of this.iterator.all()) {
+            if (player.name === name) {
+                return player;
+            }
+        }
+        return null;
+    }
+    getBySocialClub(socialClub) {
+        const player = this.findBySocialClub(socialClub);
+        if (!player) {
+            throw new Error(`Player with socialClub ${socialClub} not found`);
+        }
+        return player;
+    }
+    findBySocialClub(socialClub) {
+        for (const player of this.iterator.all()) {
+            if (player.socialClub === socialClub) {
+                return player;
+            }
+        }
+        return null;
+    }
+    _init(net) {
+        net.events.onInternal({
+            playerConnected: (ccmpPlayer) => {
+                const player = new CCMPPlayer_1.CCMPPlayer({ ccmpPlayer });
+                this.registerBaseObject(player);
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerConnected, player);
+            },
+            playerDisconnected: (ccmpPlayer) => {
+                const player = this.getByID(ccmpPlayer.id);
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerQuit, player, "disconnect", "");
+                this.unregisterBaseObject(player);
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerDisconnected, player);
+            },
+            playerDimensionChange: (ccmpPlayer, oldDim, newDim) => {
+                const player = this.findByID(ccmpPlayer.id);
+                if (!player)
+                    return;
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerDimensionChange, player, oldDim, newDim);
+            },
+        });
+    }
+}
+exports.CCMPPlayersManager = CCMPPlayersManager;