rock-mod 0.20.0 → 0.22.0

package/dist/client/RockMod.d.ts

@@ -4,7 +4,7 @@ import { type IUtilsManager } from "./utils";
 import { type IManagersFactory } from "./factories/common/IManagersFactory";
 import { type IGameManagers } from "./game";
 import { type IConsoleManager } from "./console";
-type MultiplayerType = "RageMP" | "AltV" | "Mock";
+type MultiplayerType = "RageMP" | "AltV" | "Mock" | "CCMP";
 export interface RockModOptions {
     multiplayer: MultiplayerType;
 }

package/dist/client/RockMod.js

@@ -20,6 +20,10 @@ export class RockMod {
                 const { RageManagersFactory } = await import("./factories/ragemp/RageManagersFactory");
                 return new RageManagersFactory();
             }
+            case "CCMP": {
+                const { CCMPManagersFactory } = await import("./factories/ccmp/CCMPManagersFactory");
+                return new CCMPManagersFactory();
+            }
             case "AltV":
             case "Mock": {
                 throw new Error("This multiplayer type is not implemented yet on client side");

package/dist/client/entities/ccmp/blip/CCMPBlip.d.ts

@@ -0,0 +1,38 @@
+import { type Blip as CcmpBlip } from "@classic-mp/types/client";
+import { BaseObjectType, type IBlipColor, type IBlipSprite } from "../../../../shared/entities";
+import { type IVector3D, Vector3D } from "../../../../shared/common/utils";
+import { type IBlip } from "../../common/blip/IBlip";
+export declare class CCMPBlip implements IBlip {
+    private readonly _ccmpBlip;
+    private readonly _onDestroy;
+    private _destroyed;
+    constructor(_ccmpBlip: CcmpBlip, _onDestroy?: (blip: CCMPBlip) => void);
+    get id(): number;
+    get remoteId(): number | null;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get handle(): number;
+    destroy(): void;
+    get position(): Vector3D;
+    get dimension(): number;
+    setPosition(_value: IVector3D): void;
+    setDimension(_value: number): void;
+    setCoords(_xPos: number, _yPos: number, _zPos: number, _xAxis: boolean, _yAxis: boolean, _zAxis: boolean, _clearArea: boolean): void;
+    get name(): string;
+    get sprite(): IBlipSprite;
+    get color(): number;
+    get alpha(): number;
+    get scale(): number;
+    get drawDistance(): number;
+    get shortRange(): boolean;
+    get rotation(): number;
+    getVariable(name: string): unknown | null;
+    getSyncedMeta(key: string): unknown | undefined;
+    hasSyncedMeta(key: string): boolean;
+    getSyncedMetaKeys(): readonly string[];
+    setSprite(_value: IBlipSprite): void;
+    setColor(_value: IBlipColor): void;
+    setAlpha(_value: number): void;
+    setShowHeadingIndicator(_value: boolean): void;
+    setRotation(_value: number): void;
+}

package/dist/client/entities/ccmp/blip/CCMPBlip.js

@@ -0,0 +1,118 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { Vector3D } from "../../../../shared/common/utils";
+const notImplemented = (memberName) => {
+    throw new Error(`CCMPBlip.${memberName}: not implemented`);
+};
+export class CCMPBlip {
+    constructor(_ccmpBlip, _onDestroy = () => { }) {
+        this._ccmpBlip = _ccmpBlip;
+        this._onDestroy = _onDestroy;
+        this._destroyed = false;
+    }
+    get id() {
+        return this._ccmpBlip.id;
+    }
+    get remoteId() {
+        return this._ccmpBlip.remoteId;
+    }
+    get type() {
+        return BaseObjectType.Blip;
+    }
+    get isExists() {
+        return !this._destroyed && this._ccmpBlip.isExists;
+    }
+    get handle() {
+        return this._ccmpBlip.handle;
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._ccmpBlip.destroy();
+        this._onDestroy(this);
+    }
+    get position() {
+        const { x, y, z } = this._ccmpBlip.position;
+        return new Vector3D(x, y, z);
+    }
+    get dimension() {
+        return this._ccmpBlip.dimension;
+    }
+    setPosition(_value) {
+        notImplemented("setPosition");
+    }
+    setDimension(_value) {
+        notImplemented("setDimension");
+    }
+    setCoords(_xPos, _yPos, _zPos, _xAxis, _yAxis, _zAxis, _clearArea) {
+        notImplemented("setCoords");
+    }
+    get name() {
+        return this._ccmpBlip.name;
+    }
+    get sprite() {
+        return this._ccmpBlip.sprite;
+    }
+    get color() {
+        return this._ccmpBlip.color;
+    }
+    get alpha() {
+        return this._ccmpBlip.alpha;
+    }
+    get scale() {
+        return this._ccmpBlip.scale;
+    }
+    get drawDistance() {
+        return this._ccmpBlip.drawDistance;
+    }
+    get shortRange() {
+        return this._ccmpBlip.shortRange;
+    }
+    get rotation() {
+        return this._ccmpBlip.rotation;
+    }
+    getVariable(name) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return null;
+        }
+        const value = ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Blip, remoteId, name);
+        return value === undefined ? null : value;
+    }
+    getSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return undefined;
+        }
+        return ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Blip, remoteId, key);
+    }
+    hasSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return false;
+        }
+        return ccmp.entities.hasStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Blip, remoteId, key);
+    }
+    getSyncedMetaKeys() {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return [];
+        }
+        return ccmp.entities.getStreamSyncedMetaKeys(ccmp.entities.ENTITY_TYPE.Blip, remoteId);
+    }
+    setSprite(_value) {
+        notImplemented("setSprite");
+    }
+    setColor(_value) {
+        notImplemented("setColor");
+    }
+    setAlpha(_value) {
+        notImplemented("setAlpha");
+    }
+    setShowHeadingIndicator(_value) {
+        notImplemented("setShowHeadingIndicator");
+    }
+    setRotation(_value) {
+        notImplemented("setRotation");
+    }
+}

package/dist/client/entities/ccmp/blip/CCMPBlipsManager.d.ts

@@ -0,0 +1,27 @@
+import { type CCMPEventsManager } from "../../../net/ccmp/events/CCMPEventsManager";
+import { type IBlipCreateOptions, type IBlipsManager } from "../../common/blip/IBlipsManager";
+import { type IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { CCMPBlip } from "./CCMPBlip";
+export declare class CCMPBlipsManager implements IBlipsManager {
+    private readonly _events;
+    private readonly _blips;
+    private readonly _blipsByRemoteId;
+    private readonly _iterator;
+    constructor(_events: CCMPEventsManager);
+    create(options: IBlipCreateOptions): CCMPBlip;
+    syncWithMpPool(): void;
+    registerById(id: number): CCMPBlip;
+    unregisterById(id: number): CCMPBlip;
+    findByID(id: number): CCMPBlip | null;
+    getByID(id: number): CCMPBlip;
+    findByRemoteID(remoteId: number): CCMPBlip | null;
+    getByRemoteID(remoteId: number): CCMPBlip;
+    deleteById(id: number): CCMPBlip;
+    get iterator(): IWorldObjectsIterator<CCMPBlip>;
+    private _register;
+    private _unregister;
+    private _findRegistered;
+    private _registerLifecycleEvents;
+    private _filter;
+    private _pruneDestroyed;
+}

package/dist/client/entities/ccmp/blip/CCMPBlipsManager.js

@@ -0,0 +1,191 @@
+import { ClientInternalEventName } from "../../../net/common/events/types";
+import { CCMPBlip } from "./CCMPBlip";
+export class CCMPBlipsManager {
+    constructor(_events) {
+        this._events = _events;
+        this._blips = new Map();
+        this._blipsByRemoteId = new Map();
+        this._iterator = {
+            all: () => this._filter(() => true),
+            dimension: (value) => this._filter((blip) => blip.dimension === value),
+            range2D: (center, range) => this._filter((blip) => {
+                const position = blip.position;
+                const squaredDistance = (position.x - center.x) ** 2 + (position.y - center.y) ** 2;
+                return squaredDistance <= range * range;
+            }),
+            range3D: (center, range) => this._filter((blip) => blip.position.isInRange(center, range)),
+        };
+        this._registerLifecycleEvents();
+        this.syncWithMpPool();
+    }
+    create(options) {
+        const createOptions = {
+            dimension: options.dimension,
+        };
+        if (options.alpha !== undefined)
+            createOptions.alpha = options.alpha;
+        if (options.color !== undefined)
+            createOptions.color = options.color;
+        if (options.drawDistance !== undefined)
+            createOptions.drawDistance = options.drawDistance;
+        if (options.name !== undefined)
+            createOptions.name = options.name;
+        if (options.rotation !== undefined)
+            createOptions.rotation = options.rotation;
+        if (options.scale !== undefined)
+            createOptions.scale = options.scale;
+        if (options.shortRange !== undefined)
+            createOptions.shortRange = options.shortRange;
+        const ccmpBlip = ccmp.blips.create(options.sprite, options.position, createOptions);
+        if (!ccmpBlip) {
+            throw new Error(`CCMPBlipsManager.create: ccmp.blips.create failed for sprite "${options.sprite}"`);
+        }
+        return this._register(ccmpBlip);
+    }
+    syncWithMpPool() {
+        this._pruneDestroyed();
+        for (const ccmpBlip of ccmp.blips.all) {
+            this._register(ccmpBlip);
+        }
+    }
+    registerById(id) {
+        const existingBlip = this.findByID(id);
+        if (existingBlip) {
+            return existingBlip;
+        }
+        const ccmpBlip = ccmp.blips.getById(id);
+        if (!ccmpBlip) {
+            throw new Error(`CCMPBlipsManager.registerById(${id}): blip not found.`);
+        }
+        return this._register(ccmpBlip);
+    }
+    unregisterById(id) {
+        return this.deleteById(id);
+    }
+    findByID(id) {
+        var _a;
+        const blip = (_a = this._blips.get(id)) !== null && _a !== void 0 ? _a : null;
+        if (blip && !blip.isExists) {
+            this._unregister(blip);
+        }
+        else if (blip) {
+            return blip;
+        }
+        const ccmpBlip = ccmp.blips.getById(id);
+        if (!ccmpBlip) {
+            return null;
+        }
+        return this._register(ccmpBlip);
+    }
+    getByID(id) {
+        const blip = this.findByID(id);
+        if (!blip) {
+            throw new Error(`CCMPBlipsManager.getByID(${id}): blip not found.`);
+        }
+        return blip;
+    }
+    findByRemoteID(remoteId) {
+        var _a;
+        const blip = (_a = this._blipsByRemoteId.get(remoteId)) !== null && _a !== void 0 ? _a : null;
+        if (blip && !blip.isExists) {
+            this._unregister(blip);
+        }
+        else if (blip) {
+            return blip;
+        }
+        const ccmpBlip = ccmp.blips.getByRemoteId(remoteId);
+        if (!ccmpBlip) {
+            return null;
+        }
+        return this._register(ccmpBlip);
+    }
+    getByRemoteID(remoteId) {
+        const blip = this.findByRemoteID(remoteId);
+        if (!blip) {
+            throw new Error(`CCMPBlipsManager.getByRemoteID(${remoteId}): blip not found.`);
+        }
+        return blip;
+    }
+    deleteById(id) {
+        const blip = this.getByID(id);
+        blip.destroy();
+        return blip;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    _register(ccmpBlip) {
+        const existingBlip = this._findRegistered(ccmpBlip);
+        if (existingBlip && existingBlip.isExists) {
+            return existingBlip;
+        }
+        if (existingBlip) {
+            this._unregister(existingBlip);
+        }
+        const blip = new CCMPBlip(ccmpBlip, (destroyedBlip) => {
+            this._unregister(destroyedBlip);
+        });
+        this._blips.set(blip.id, blip);
+        if (blip.remoteId !== null) {
+            this._blipsByRemoteId.set(blip.remoteId, blip);
+        }
+        return blip;
+    }
+    _unregister(blip) {
+        this._blips.delete(blip.id);
+        if (blip.remoteId !== null) {
+            this._blipsByRemoteId.delete(blip.remoteId);
+        }
+    }
+    _findRegistered(ccmpBlip) {
+        var _a, _b, _c;
+        return ((_c = (_b = (ccmpBlip.remoteId === null ? null : ((_a = this._blipsByRemoteId.get(ccmpBlip.remoteId)) !== null && _a !== void 0 ? _a : null))) !== null && _b !== void 0 ? _b : this._blips.get(ccmpBlip.id)) !== null && _c !== void 0 ? _c : null);
+    }
+    _registerLifecycleEvents() {
+        ccmp.on("blipCreated", (ccmpBlip) => {
+            if (!ccmpBlip)
+                return;
+            const blip = this._register(ccmpBlip);
+            this._events.emitInternal(ClientInternalEventName.EntityCreated, blip);
+        });
+        ccmp.on("blipDestroyed", (ccmpBlip) => {
+            var _a;
+            if (!ccmpBlip)
+                return;
+            const blip = (_a = this._findRegistered(ccmpBlip)) !== null && _a !== void 0 ? _a : this._register(ccmpBlip);
+            this._events.emitInternal(ClientInternalEventName.EntityDestroyed, blip);
+            this._unregister(blip);
+        });
+        ccmp.on("blipStreamIn", (ccmpBlip) => {
+            if (!ccmpBlip)
+                return;
+            const blip = this._register(ccmpBlip);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamIn, blip);
+        });
+        ccmp.on("blipStreamOut", (ccmpBlip) => {
+            var _a;
+            if (!ccmpBlip)
+                return;
+            const blip = (_a = this._findRegistered(ccmpBlip)) !== null && _a !== void 0 ? _a : this._register(ccmpBlip);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamOut, blip);
+        });
+    }
+    *_filter(predicate) {
+        for (const blip of this._blips.values()) {
+            if (!blip.isExists) {
+                this._unregister(blip);
+                continue;
+            }
+            if (predicate(blip)) {
+                yield blip;
+            }
+        }
+    }
+    _pruneDestroyed() {
+        for (const blip of this._blips.values()) {
+            if (!blip.isExists) {
+                this._unregister(blip);
+            }
+        }
+    }
+}

package/dist/client/entities/ccmp/camera/CCMPCamera.d.ts

@@ -0,0 +1,24 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { type Camera as CcmpCamera } from "@classic-mp/types/client";
+import { type ICamera } from "../../common/camera/ICamera";
+import { type IVector3D, Vector3D } from "../../../../shared/common/utils";
+export declare class CCMPCamera implements ICamera {
+    private readonly _camera;
+    constructor(_camera: CcmpCamera);
+    get id(): number;
+    get remoteId(): number | null;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get handle(): number;
+    destroy(): void;
+    get isActive(): boolean;
+    setIsActive(value: boolean): void;
+    get direction(): IVector3D;
+    get fov(): number;
+    setFov(value: number): void;
+    pointAtCoord(value: IVector3D): void;
+    setPosition(value: Vector3D): void;
+    get position(): Vector3D;
+    get rotation(): IVector3D;
+    setRotation(value: IVector3D): void;
+}

package/dist/client/entities/ccmp/camera/CCMPCamera.js

@@ -0,0 +1,58 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { Vector3D } from "../../../../shared/common/utils";
+export class CCMPCamera {
+    constructor(_camera) {
+        this._camera = _camera;
+    }
+    get id() {
+        return this._camera.id;
+    }
+    get remoteId() {
+        return null;
+    }
+    get type() {
+        return BaseObjectType.Camera;
+    }
+    get isExists() {
+        return this._camera.isAlive;
+    }
+    get handle() {
+        return this._camera.handle;
+    }
+    destroy() {
+        this._camera.destroy();
+    }
+    get isActive() {
+        return this._camera.isActive;
+    }
+    setIsActive(value) {
+        this._camera.setActive(value);
+    }
+    get direction() {
+        const { x, y, z } = this._camera.direction;
+        return new Vector3D(x, y, z);
+    }
+    get fov() {
+        return this._camera.fov;
+    }
+    setFov(value) {
+        this._camera.setFov(value);
+    }
+    pointAtCoord(value) {
+        this._camera.pointAtCoord(value);
+    }
+    setPosition(value) {
+        this._camera.setPosition(value);
+    }
+    get position() {
+        const { x, y, z } = this._camera.position;
+        return new Vector3D(x, y, z);
+    }
+    get rotation() {
+        const { x, y, z } = this._camera.rotation;
+        return new Vector3D(x, y, z);
+    }
+    setRotation(value) {
+        this._camera.setRotation(value);
+    }
+}

package/dist/client/entities/ccmp/camera/CCMPCameraManager.d.ts

@@ -0,0 +1,16 @@
+import { type IBaseObjectsIterator } from "../../common/baseObject/IBaseObjectsIterator";
+import { type ICameraCreateOptions, type ICameraManager } from "../../common/camera/ICameraManager";
+import { CCMPCamera } from "./CCMPCamera";
+export declare class CCMPCameraManager implements ICameraManager {
+    private readonly _cameras;
+    private readonly _iterator;
+    get iterator(): IBaseObjectsIterator<CCMPCamera>;
+    create(options: ICameraCreateOptions): CCMPCamera;
+    renderScriptCams(render: boolean, ease: boolean, easeTime: number, freezePreviousCamera: boolean): void;
+    getGameplayCamera(): CCMPCamera;
+    getByID(id: number): CCMPCamera;
+    findByID(id: number): CCMPCamera | null;
+    getByRemoteID(remoteId: number): CCMPCamera;
+    findByRemoteID(remoteId: number): CCMPCamera | null;
+    deleteById(id: number): CCMPCamera;
+}

package/dist/client/entities/ccmp/camera/CCMPCameraManager.js

@@ -0,0 +1,51 @@
+import { CCMPCamera } from "./CCMPCamera";
+export class CCMPCameraManager {
+    constructor() {
+        this._cameras = new Map();
+        this._iterator = {
+            all: () => this._cameras.values(),
+        };
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    create(options) {
+        const camera = new CCMPCamera(ccmp.cameras.create(options.name, options.position, options.rotation, options.fov));
+        this._cameras.set(camera.id, camera);
+        return camera;
+    }
+    renderScriptCams(render, ease, easeTime, freezePreviousCamera) {
+        ccmp.cameras.renderScriptCams(render, ease, easeTime, freezePreviousCamera);
+    }
+    getGameplayCamera() {
+        return new CCMPCamera(ccmp.cameras.getGameplayCamera());
+    }
+    getByID(id) {
+        const camera = this.findByID(id);
+        if (!camera) {
+            throw new Error(`CCMPCameraManager.getByID(${id}): camera not found.`);
+        }
+        return camera;
+    }
+    findByID(id) {
+        var _a;
+        return (_a = this._cameras.get(id)) !== null && _a !== void 0 ? _a : null;
+    }
+    getByRemoteID(remoteId) {
+        const camera = this.findByRemoteID(remoteId);
+        if (!camera) {
+            throw new Error(`CCMPCameraManager.getByRemoteID(${remoteId}): camera not found.`);
+        }
+        return camera;
+    }
+    findByRemoteID(remoteId) {
+        void remoteId;
+        return null;
+    }
+    deleteById(id) {
+        const camera = this.getByID(id);
+        camera.destroy();
+        this._cameras.delete(id);
+        return camera;
+    }
+}

package/dist/client/entities/ccmp/colshape/CCMPColshape.d.ts

@@ -0,0 +1,26 @@
+import { type Colshape as CcmpColshape } from "@classic-mp/types/client";
+import { BaseObjectType } from "../../../../shared/entities";
+import { type IVector3D, Vector3D } from "../../../../shared/common/utils";
+import { type IColshape } from "../../common/colshape/IColshape";
+export declare class CCMPColshape implements IColshape {
+    private readonly _ccmpColshape;
+    private readonly _onDestroy;
+    private _destroyed;
+    constructor(_ccmpColshape: CcmpColshape, _onDestroy?: (colshape: CCMPColshape) => void);
+    get id(): number;
+    get remoteId(): number | null;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get handle(): number;
+    destroy(): void;
+    get position(): Vector3D;
+    get dimension(): number;
+    get key(): string | undefined;
+    setPosition(_value: IVector3D): void;
+    setDimension(_value: number): void;
+    setCoords(_xPos: number, _yPos: number, _zPos: number, _xAxis: boolean, _yAxis: boolean, _zAxis: boolean, _clearArea: boolean): void;
+    getVariable(name: string): unknown | null;
+    getSyncedMeta(key: string): unknown | undefined;
+    hasSyncedMeta(key: string): boolean;
+    getSyncedMetaKeys(): readonly string[];
+}

package/dist/client/entities/ccmp/colshape/CCMPColshape.js

@@ -0,0 +1,83 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { Vector3D } from "../../../../shared/common/utils";
+const notImplemented = (memberName) => {
+    throw new Error(`CCMPColshape.${memberName}: not implemented`);
+};
+export class CCMPColshape {
+    constructor(_ccmpColshape, _onDestroy = () => { }) {
+        this._ccmpColshape = _ccmpColshape;
+        this._onDestroy = _onDestroy;
+        this._destroyed = false;
+    }
+    get id() {
+        return this._ccmpColshape.id;
+    }
+    get remoteId() {
+        return this._ccmpColshape.remoteId;
+    }
+    get type() {
+        return BaseObjectType.Colshape;
+    }
+    get isExists() {
+        return !this._destroyed && this._ccmpColshape.isExists;
+    }
+    get handle() {
+        return 0;
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._ccmpColshape.destroy();
+        this._onDestroy(this);
+    }
+    get position() {
+        const { x, y, z } = this._ccmpColshape.position;
+        return new Vector3D(x, y, z);
+    }
+    get dimension() {
+        return this._ccmpColshape.dimension;
+    }
+    get key() {
+        const value = this.getSyncedMeta("key");
+        return typeof value === "string" ? value : undefined;
+    }
+    setPosition(_value) {
+        notImplemented("setPosition");
+    }
+    setDimension(_value) {
+        notImplemented("setDimension");
+    }
+    setCoords(_xPos, _yPos, _zPos, _xAxis, _yAxis, _zAxis, _clearArea) {
+        notImplemented("setCoords");
+    }
+    getVariable(name) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return null;
+        }
+        const value = ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Colshape, remoteId, name);
+        return value === undefined ? null : value;
+    }
+    getSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return undefined;
+        }
+        return ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Colshape, remoteId, key);
+    }
+    hasSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return false;
+        }
+        return ccmp.entities.hasStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Colshape, remoteId, key);
+    }
+    getSyncedMetaKeys() {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return [];
+        }
+        return ccmp.entities.getStreamSyncedMetaKeys(ccmp.entities.ENTITY_TYPE.Colshape, remoteId);
+    }
+}