rock-mod 0.21.0 → 0.23.0

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

@@ -0,0 +1,193 @@
+import { ClientInternalEventName } from "../../../net/common/events/types";
+import { CCMPColshape } from "./CCMPColshape";
+export class CCMPColshapesManager {
+    constructor(_events) {
+        this._events = _events;
+        this._colshapes = new Map();
+        this._colshapesByRemoteId = new Map();
+        this._iterator = {
+            all: () => this._filter(() => true),
+            dimension: (value) => this._filter((colshape) => colshape.dimension === value),
+            range2D: (center, range) => this._filter((colshape) => {
+                const position = colshape.position;
+                const squaredDistance = (position.x - center.x) ** 2 + (position.y - center.y) ** 2;
+                return squaredDistance <= range * range;
+            }),
+            range3D: (center, range) => this._filter((colshape) => colshape.position.isInRange(center, range)),
+        };
+        this._registerLifecycleEvents();
+        this.syncWithMpPool();
+    }
+    createCircle(options) {
+        const ccmpColshape = ccmp.colshapes.createCircle(options.position, options.range, {
+            dimension: options.dimension,
+        });
+        return this._register(ccmpColshape);
+    }
+    createCuboid(options) {
+        const ccmpColshape = ccmp.colshapes.createCuboid(options.position, { x: options.width, y: options.depth, z: options.height }, { dimension: options.dimension });
+        return this._register(ccmpColshape);
+    }
+    createCylinder(options) {
+        const ccmpColshape = ccmp.colshapes.createCylinder(options.position, options.range, options.height, {
+            dimension: options.dimension,
+        });
+        return this._register(ccmpColshape);
+    }
+    createRectangle(options) {
+        void options;
+        throw new Error("CCMPColshapesManager.createRectangle: not supported by CCMP");
+    }
+    createSphere(options) {
+        const ccmpColshape = ccmp.colshapes.createSphere(options.position, options.range, {
+            dimension: options.dimension,
+        });
+        return this._register(ccmpColshape);
+    }
+    syncWithMpPool() {
+        this._pruneDestroyed();
+        for (const ccmpColshape of ccmp.colshapes.all) {
+            this._register(ccmpColshape);
+        }
+    }
+    registerById(id) {
+        const existingColshape = this.findByID(id);
+        if (existingColshape) {
+            return existingColshape;
+        }
+        const ccmpColshape = ccmp.colshapes.getById(id);
+        if (!ccmpColshape) {
+            throw new Error(`CCMPColshapesManager.registerById(${id}): colshape not found.`);
+        }
+        return this._register(ccmpColshape);
+    }
+    unregisterById(id) {
+        return this.deleteById(id);
+    }
+    findByID(id) {
+        var _a;
+        const colshape = (_a = this._colshapes.get(id)) !== null && _a !== void 0 ? _a : null;
+        if (colshape && !colshape.isExists) {
+            this._unregister(colshape);
+        }
+        else if (colshape) {
+            return colshape;
+        }
+        const ccmpColshape = ccmp.colshapes.getById(id);
+        if (!ccmpColshape) {
+            return null;
+        }
+        return this._register(ccmpColshape);
+    }
+    getByID(id) {
+        const colshape = this.findByID(id);
+        if (!colshape) {
+            throw new Error(`CCMPColshapesManager.getByID(${id}): colshape not found.`);
+        }
+        return colshape;
+    }
+    findByRemoteID(remoteId) {
+        var _a;
+        const colshape = (_a = this._colshapesByRemoteId.get(remoteId)) !== null && _a !== void 0 ? _a : null;
+        if (colshape && !colshape.isExists) {
+            this._unregister(colshape);
+        }
+        else if (colshape) {
+            return colshape;
+        }
+        const ccmpColshape = ccmp.colshapes.getByRemoteId(remoteId);
+        if (!ccmpColshape) {
+            return null;
+        }
+        return this._register(ccmpColshape);
+    }
+    getByRemoteID(remoteId) {
+        const colshape = this.findByRemoteID(remoteId);
+        if (!colshape) {
+            throw new Error(`CCMPColshapesManager.getByRemoteID(${remoteId}): colshape not found.`);
+        }
+        return colshape;
+    }
+    deleteById(id) {
+        const colshape = this.getByID(id);
+        colshape.destroy();
+        return colshape;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    _register(ccmpColshape) {
+        const existingColshape = this._findRegistered(ccmpColshape);
+        if (existingColshape && existingColshape.isExists) {
+            return existingColshape;
+        }
+        if (existingColshape) {
+            this._unregister(existingColshape);
+        }
+        const colshape = new CCMPColshape(ccmpColshape, (destroyedColshape) => {
+            this._unregister(destroyedColshape);
+        });
+        this._colshapes.set(colshape.id, colshape);
+        if (colshape.remoteId !== null) {
+            this._colshapesByRemoteId.set(colshape.remoteId, colshape);
+        }
+        return colshape;
+    }
+    _unregister(colshape) {
+        this._colshapes.delete(colshape.id);
+        if (colshape.remoteId !== null) {
+            this._colshapesByRemoteId.delete(colshape.remoteId);
+        }
+    }
+    _findRegistered(ccmpColshape) {
+        var _a, _b, _c;
+        return ((_c = (_b = (ccmpColshape.remoteId === null ? null : ((_a = this._colshapesByRemoteId.get(ccmpColshape.remoteId)) !== null && _a !== void 0 ? _a : null))) !== null && _b !== void 0 ? _b : this._colshapes.get(ccmpColshape.id)) !== null && _c !== void 0 ? _c : null);
+    }
+    _registerLifecycleEvents() {
+        ccmp.on("colshapeCreated", (ccmpColshape) => {
+            if (!ccmpColshape)
+                return;
+            const colshape = this._register(ccmpColshape);
+            this._events.emitInternal(ClientInternalEventName.EntityCreated, colshape);
+        });
+        ccmp.on("colshapeDestroyed", (ccmpColshape) => {
+            var _a;
+            if (!ccmpColshape)
+                return;
+            const colshape = (_a = this._findRegistered(ccmpColshape)) !== null && _a !== void 0 ? _a : this._register(ccmpColshape);
+            this._events.emitInternal(ClientInternalEventName.EntityDestroyed, colshape);
+            this._unregister(colshape);
+        });
+        ccmp.on("colshapeStreamIn", (ccmpColshape) => {
+            if (!ccmpColshape)
+                return;
+            const colshape = this._register(ccmpColshape);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamIn, colshape);
+        });
+        ccmp.on("colshapeStreamOut", (ccmpColshape) => {
+            var _a;
+            if (!ccmpColshape)
+                return;
+            const colshape = (_a = this._findRegistered(ccmpColshape)) !== null && _a !== void 0 ? _a : this._register(ccmpColshape);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamOut, colshape);
+        });
+    }
+    *_filter(predicate) {
+        for (const colshape of this._colshapes.values()) {
+            if (!colshape.isExists) {
+                this._unregister(colshape);
+                continue;
+            }
+            if (predicate(colshape)) {
+                yield colshape;
+            }
+        }
+    }
+    _pruneDestroyed() {
+        for (const colshape of this._colshapes.values()) {
+            if (!colshape.isExists) {
+                this._unregister(colshape);
+            }
+        }
+    }
+}

package/dist/client/entities/ccmp/marker/CCMPMarker.d.ts

@@ -0,0 +1,34 @@
+import { BaseObjectType, type IMarkerType } from "../../../../shared/entities";
+import { type IRGBA, type IVector3D, Vector3D } from "../../../../shared/common/utils";
+import { type Marker as CcmpMarker } from "@classic-mp/types/client";
+import { type IMarker } from "../../common/marker/IMarker";
+export declare class CCMPMarker implements IMarker {
+    private readonly _ccmpMarker;
+    private readonly _onDestroy;
+    private _destroyed;
+    constructor(_ccmpMarker: CcmpMarker, _onDestroy?: (marker: CCMPMarker) => 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 markerType(): IMarkerType;
+    get visible(): boolean;
+    get rotation(): Vector3D;
+    getVariable(name: string): unknown | null;
+    getSyncedMeta(key: string): unknown | undefined;
+    hasSyncedMeta(key: string): boolean;
+    getSyncedMetaKeys(): readonly string[];
+    setVisible(_value: boolean): void;
+    setRotation(_value: IVector3D): void;
+    get scale(): number;
+    setScale(_value: number): void;
+    get color(): IRGBA;
+    setColor(_value: IRGBA): void;
+}

package/dist/client/entities/ccmp/marker/CCMPMarker.js

@@ -0,0 +1,109 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { BaseObjectType } from "../../../../shared/entities";
+import { RGBA, Vector3D } from "../../../../shared/common/utils";
+const notImplemented = (memberName) => {
+    throw new Error(`CCMPMarker.${memberName}: not implemented`);
+};
+export class CCMPMarker {
+    constructor(_ccmpMarker, _onDestroy = () => { }) {
+        this._ccmpMarker = _ccmpMarker;
+        this._onDestroy = _onDestroy;
+        this._destroyed = false;
+    }
+    get id() {
+        return this._ccmpMarker.id;
+    }
+    get remoteId() {
+        return this._ccmpMarker.remoteId;
+    }
+    get type() {
+        return BaseObjectType.Marker;
+    }
+    get isExists() {
+        return !this._destroyed && this._ccmpMarker.isExists;
+    }
+    get handle() {
+        return 0;
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._ccmpMarker.destroy();
+        this._onDestroy(this);
+    }
+    get position() {
+        const { x, y, z } = this._ccmpMarker.position;
+        return new Vector3D(x, y, z);
+    }
+    get dimension() {
+        return this._ccmpMarker.dimension;
+    }
+    setPosition(_value) {
+        notImplemented("setPosition");
+    }
+    setDimension(_value) {
+        notImplemented("setDimension");
+    }
+    setCoords(_xPos, _yPos, _zPos, _xAxis, _yAxis, _zAxis, _clearArea) {
+        notImplemented("setCoords");
+    }
+    get markerType() {
+        return this._ccmpMarker.markerType;
+    }
+    get visible() {
+        return this._ccmpMarker.visible;
+    }
+    get rotation() {
+        const { x, y, z } = this._ccmpMarker.rotation;
+        return new Vector3D(x, y, z);
+    }
+    getVariable(name) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return null;
+        }
+        const value = ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Marker, 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.Marker, remoteId, key);
+    }
+    hasSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return false;
+        }
+        return ccmp.entities.hasStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Marker, remoteId, key);
+    }
+    getSyncedMetaKeys() {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return [];
+        }
+        return ccmp.entities.getStreamSyncedMetaKeys(ccmp.entities.ENTITY_TYPE.Marker, remoteId);
+    }
+    setVisible(_value) {
+        notImplemented("setVisible");
+    }
+    setRotation(_value) {
+        notImplemented("setRotation");
+    }
+    get scale() {
+        return this._ccmpMarker.scale;
+    }
+    setScale(_value) {
+        notImplemented("setScale");
+    }
+    get color() {
+        const { r, g, b, a } = this._ccmpMarker.color;
+        return new RGBA(r, g, b, a);
+    }
+    setColor(_value) {
+        notImplemented("setColor");
+    }
+}

package/dist/client/entities/ccmp/marker/CCMPMarkersManager.d.ts

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

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

@@ -0,0 +1,180 @@
+import { ClientInternalEventName } from "../../../net/common/events/types";
+import { CCMPMarker } from "./CCMPMarker";
+export class CCMPMarkersManager {
+    constructor(_events) {
+        this._events = _events;
+        this._markers = new Map();
+        this._markersByRemoteId = new Map();
+        this._iterator = {
+            all: () => this._filter(() => true),
+            dimension: (value) => this._filter((marker) => marker.dimension === value),
+            range2D: (center, range) => this._filter((marker) => {
+                const position = marker.position;
+                const squaredDistance = (position.x - center.x) ** 2 + (position.y - center.y) ** 2;
+                return squaredDistance <= range * range;
+            }),
+            range3D: (center, range) => this._filter((marker) => marker.position.isInRange(center, range)),
+        };
+        this._registerLifecycleEvents();
+        this.syncWithMpPool();
+    }
+    create(options) {
+        const { r, g, b, a } = options.color;
+        const ccmpMarker = ccmp.markers.create(options.type, options.position, {
+            dimension: options.dimension,
+            rotation: options.rotation,
+            scale: options.scale,
+            color: { r, g, b, a: a !== null && a !== void 0 ? a : 255 },
+        });
+        if (!ccmpMarker) {
+            throw new Error(`CCMPMarkersManager.create: ccmp.markers.create failed for marker type "${options.type}"`);
+        }
+        return this._register(ccmpMarker);
+    }
+    syncWithMpPool() {
+        this._pruneDestroyed();
+        for (const ccmpMarker of ccmp.markers.all) {
+            this._register(ccmpMarker);
+        }
+    }
+    registerById(id) {
+        const existingMarker = this.findByID(id);
+        if (existingMarker) {
+            return existingMarker;
+        }
+        const ccmpMarker = ccmp.markers.getById(id);
+        if (!ccmpMarker) {
+            throw new Error(`CCMPMarkersManager.registerById(${id}): marker not found.`);
+        }
+        return this._register(ccmpMarker);
+    }
+    unregisterById(id) {
+        return this.deleteById(id);
+    }
+    findByID(id) {
+        var _a;
+        const marker = (_a = this._markers.get(id)) !== null && _a !== void 0 ? _a : null;
+        if (marker && !marker.isExists) {
+            this._unregister(marker);
+        }
+        else if (marker) {
+            return marker;
+        }
+        const ccmpMarker = ccmp.markers.getById(id);
+        if (!ccmpMarker) {
+            return null;
+        }
+        return this._register(ccmpMarker);
+    }
+    getByID(id) {
+        const marker = this.findByID(id);
+        if (!marker) {
+            throw new Error(`CCMPMarkersManager.getByID(${id}): marker not found.`);
+        }
+        return marker;
+    }
+    findByRemoteID(remoteId) {
+        var _a;
+        const marker = (_a = this._markersByRemoteId.get(remoteId)) !== null && _a !== void 0 ? _a : null;
+        if (marker && !marker.isExists) {
+            this._unregister(marker);
+        }
+        else if (marker) {
+            return marker;
+        }
+        const ccmpMarker = ccmp.markers.getByRemoteId(remoteId);
+        if (!ccmpMarker) {
+            return null;
+        }
+        return this._register(ccmpMarker);
+    }
+    getByRemoteID(remoteId) {
+        const marker = this.findByRemoteID(remoteId);
+        if (!marker) {
+            throw new Error(`CCMPMarkersManager.getByRemoteID(${remoteId}): marker not found.`);
+        }
+        return marker;
+    }
+    deleteById(id) {
+        const marker = this.getByID(id);
+        marker.destroy();
+        return marker;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    _register(ccmpMarker) {
+        const existingMarker = this._findRegistered(ccmpMarker);
+        if (existingMarker && existingMarker.isExists) {
+            return existingMarker;
+        }
+        if (existingMarker) {
+            this._unregister(existingMarker);
+        }
+        const marker = new CCMPMarker(ccmpMarker, (destroyedMarker) => {
+            this._unregister(destroyedMarker);
+        });
+        this._markers.set(marker.id, marker);
+        if (marker.remoteId !== null) {
+            this._markersByRemoteId.set(marker.remoteId, marker);
+        }
+        return marker;
+    }
+    _unregister(marker) {
+        this._markers.delete(marker.id);
+        if (marker.remoteId !== null) {
+            this._markersByRemoteId.delete(marker.remoteId);
+        }
+    }
+    _findRegistered(ccmpMarker) {
+        var _a, _b, _c;
+        return ((_c = (_b = (ccmpMarker.remoteId === null ? null : ((_a = this._markersByRemoteId.get(ccmpMarker.remoteId)) !== null && _a !== void 0 ? _a : null))) !== null && _b !== void 0 ? _b : this._markers.get(ccmpMarker.id)) !== null && _c !== void 0 ? _c : null);
+    }
+    _registerLifecycleEvents() {
+        ccmp.on("markerCreated", (ccmpMarker) => {
+            if (!ccmpMarker)
+                return;
+            const marker = this._register(ccmpMarker);
+            this._events.emitInternal(ClientInternalEventName.EntityCreated, marker);
+        });
+        ccmp.on("markerDestroyed", (ccmpMarker) => {
+            var _a;
+            if (!ccmpMarker)
+                return;
+            const marker = (_a = this._findRegistered(ccmpMarker)) !== null && _a !== void 0 ? _a : this._register(ccmpMarker);
+            this._events.emitInternal(ClientInternalEventName.EntityDestroyed, marker);
+            this._unregister(marker);
+        });
+        ccmp.on("markerStreamIn", (ccmpMarker) => {
+            if (!ccmpMarker)
+                return;
+            const marker = this._register(ccmpMarker);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamIn, marker);
+        });
+        ccmp.on("markerStreamOut", (ccmpMarker) => {
+            var _a;
+            if (!ccmpMarker)
+                return;
+            const marker = (_a = this._findRegistered(ccmpMarker)) !== null && _a !== void 0 ? _a : this._register(ccmpMarker);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamOut, marker);
+        });
+    }
+    *_filter(predicate) {
+        for (const marker of this._markers.values()) {
+            if (!marker.isExists) {
+                this._unregister(marker);
+                continue;
+            }
+            if (predicate(marker)) {
+                yield marker;
+            }
+        }
+    }
+    _pruneDestroyed() {
+        for (const marker of this._markers.values()) {
+            if (!marker.isExists) {
+                this._unregister(marker);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+import { type Object as CcmpObject } from "@classic-mp/types/client";
+import { BaseObjectType } from "../../../../shared/entities";
+import { type IVector3D, Vector3D } from "../../../../shared/common/utils";
+import { type IBaseObject } from "../../common/baseObject/IBaseObject";
+import { type IObject } from "../../common/object/IObject";
+export declare class CCMPObject implements IObject {
+    private readonly _ccmpObject;
+    private readonly _onDestroy;
+    private _destroyed;
+    constructor(_ccmpObject: CcmpObject, _onDestroy?: (object: CCMPObject) => 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 model(): number;
+    get heading(): number;
+    setHeading(heading: number): void;
+    setModel(value: string): void;
+    get rotation(): Vector3D;
+    get forwardVector(): Vector3D;
+    setRotation(value: IVector3D): void;
+    freezePosition(freeze: boolean): void;
+    setCollision(collision: boolean, keepPhysics: boolean): void;
+    setInvincible(invincible: boolean): void;
+    setVisible(visible: boolean): void;
+    setAlpha(alpha: number): void;
+    get alpha(): number;
+    resetAlpha(): void;
+    getOffsetFromInWorldCoords(offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    getBoneIndexByName(boneName: string): number;
+    getWorldPositionOfBone(boneIndex: number): IVector3D;
+    getVariable(name: string): unknown | null;
+    getSyncedMeta(key: string): unknown | undefined;
+    hasSyncedMeta(key: string): boolean;
+    getSyncedMetaKeys(): readonly string[];
+    attachTo(entity: Handle, boneIndex: number, xPos: number, yPos: number, zPos: number, xRot: number, yRot: number, zRot: number, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean): void;
+    isAttachedTo(entity: number): boolean;
+    attachToEntity(target: IBaseObject, boneIndex: number, offset: IVector3D, rotation: IVector3D, p9: boolean, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean): void;
+    detach(useDetachVelocity: boolean, collision: boolean): void;
+    getSpeed(): number;
+    isPlayingAnim(dictionary: string, name: string, taskFlag: number): boolean;
+    private _normalizeHandle;
+}