rock-mod 0.21.0 → 0.23.0

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

@@ -6,7 +6,7 @@ export declare class CCMPCamera implements ICamera {
     private readonly _camera;
     constructor(_camera: CcmpCamera);
     get id(): number;
-    get remoteId(): number;
+    get remoteId(): number | null;
     get type(): BaseObjectType;
     get isExists(): boolean;
     get handle(): number;

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

@@ -8,7 +8,7 @@ export class CCMPCamera {
         return this._camera.id;
     }
     get remoteId() {
-        return 0;
+        return null;
     }
     get type() {
         return BaseObjectType.Camera;

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

@@ -39,7 +39,8 @@ export class CCMPCameraManager {
         return camera;
     }
     findByRemoteID(remoteId) {
-        return remoteId === 0 ? null : this.findByID(remoteId);
+        void remoteId;
+        return null;
     }
     deleteById(id) {
         const camera = this.getByID(id);

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

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

@@ -0,0 +1,31 @@
+import { type CCMPEventsManager } from "../../../net/ccmp/events/CCMPEventsManager";
+import { type ICircleColshapeCreateOptions, type IColshapesManager, type ICuboidColshapeCreateOptions, type ICylinderColshapeCreateOptions, type IRectangleColshapeCreateOptions, type ISphereColshapeCreateOptions } from "../../common/colshape/IColshapesManager";
+import { type IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { CCMPColshape } from "./CCMPColshape";
+export declare class CCMPColshapesManager implements IColshapesManager {
+    private readonly _events;
+    private readonly _colshapes;
+    private readonly _colshapesByRemoteId;
+    private readonly _iterator;
+    constructor(_events: CCMPEventsManager);
+    createCircle(options: ICircleColshapeCreateOptions): CCMPColshape;
+    createCuboid(options: ICuboidColshapeCreateOptions): CCMPColshape;
+    createCylinder(options: ICylinderColshapeCreateOptions): CCMPColshape;
+    createRectangle(options: IRectangleColshapeCreateOptions): CCMPColshape;
+    createSphere(options: ISphereColshapeCreateOptions): CCMPColshape;
+    syncWithMpPool(): void;
+    registerById(id: number): CCMPColshape;
+    unregisterById(id: number): CCMPColshape;
+    findByID(id: number): CCMPColshape | null;
+    getByID(id: number): CCMPColshape;
+    findByRemoteID(remoteId: number): CCMPColshape | null;
+    getByRemoteID(remoteId: number): CCMPColshape;
+    deleteById(id: number): CCMPColshape;
+    get iterator(): IWorldObjectsIterator<CCMPColshape>;
+    private _register;
+    private _unregister;
+    private _findRegistered;
+    private _registerLifecycleEvents;
+    private _filter;
+    private _pruneDestroyed;
+}