rock-mod 0.19.0 → 0.21.0

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPBlip = void 0;
+const CCMPWorldObject_1 = require("../worldObject/CCMPWorldObject");
+const shared_1 = require("../../../../shared");
+const Vectors_1 = require("../../../../shared/common/utils/math/Vectors");
+class CCMPBlip extends CCMPWorldObject_1.CCMPWorldObject {
+    _ccmpBlip;
+    _onDestroy;
+    get id() {
+        return this._ccmpBlip.id;
+    }
+    get type() {
+        return shared_1.BaseObjectType.Blip;
+    }
+    get isExists() {
+        return this._ccmpBlip.isExists;
+    }
+    get position() {
+        const p = this._ccmpBlip.position;
+        return new Vectors_1.Vector3D(p.x, p.y, p.z);
+    }
+    get dimension() {
+        return this._ccmpBlip.dimension;
+    }
+    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;
+    }
+    constructor(options) {
+        super();
+        this._ccmpBlip = options.ccmpBlip;
+        this._onDestroy = options.onDestroy;
+    }
+    destroy() {
+        if (!this._ccmpBlip.isExists)
+            return;
+        this._ccmpBlip.destroy();
+        this._onDestroy(this);
+    }
+    setPosition(value) {
+        this._ccmpBlip.position = { x: value.x, y: value.y, z: value.z };
+    }
+    setDimension(value) {
+        this._ccmpBlip.dimension = value;
+    }
+    setName(value) {
+        this._ccmpBlip.name = value;
+    }
+    setSprite(value) {
+        this._ccmpBlip.sprite = value;
+    }
+    setColor(value) {
+        this._ccmpBlip.color = value;
+    }
+    setAlpha(value) {
+        this._ccmpBlip.alpha = value;
+    }
+}
+exports.CCMPBlip = CCMPBlip;

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

@@ -0,0 +1,9 @@
+import { type IBlipCreateOptions, type IBlipsManager } from "../../common/blip/IBlipsManager";
+import { CCMPWorldObjectsManager } from "../worldObject/CCMPWorldObjectsManager";
+import { CCMPBlip } from "./CCMPBlip";
+export interface ICCMPBlipCreateOptions extends IBlipCreateOptions {
+}
+export declare class CCMPBlipsManager extends CCMPWorldObjectsManager<CCMPBlip> implements IBlipsManager {
+    constructor();
+    create(options: ICCMPBlipCreateOptions): CCMPBlip;
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPBlipsManager = void 0;
+const CCMPWorldObjectsManager_1 = require("../worldObject/CCMPWorldObjectsManager");
+const CCMPBlip_1 = require("./CCMPBlip");
+class CCMPBlipsManager extends CCMPWorldObjectsManager_1.CCMPWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "blip",
+        });
+    }
+    create(options) {
+        const { position, dimension, sprite, color = 0, scale = 1, alpha = 255, drawDistance = 0, name = "", rotation = 0, shortRange = false, } = options;
+        const ccmpBlip = ccmp.blips.create(sprite, position.x, position.y, position.z, color, scale, {
+            name,
+            alpha,
+            drawDistance,
+            shortRange,
+            rotation,
+            dimension,
+        });
+        if (!ccmpBlip) {
+            throw new Error("CCMPBlipsManager.create: ccmp.blips.create failed (server full?)");
+        }
+        const blip = new CCMPBlip_1.CCMPBlip({
+            ccmpBlip,
+            onDestroy: (b) => this.unregisterBaseObject(b),
+        });
+        this.registerBaseObject(blip);
+        return blip;
+    }
+}
+exports.CCMPBlipsManager = CCMPBlipsManager;

package/dist/server/entities/ccmp/colshape/CCMPCircleColshape.d.ts

@@ -0,0 +1,7 @@
+import { type ICCMPColshapeOptions, CCMPColshape } from "./CCMPColshape";
+import { type ICircleColshape } from "../../common/colshape/ICircleColshape";
+export interface ICCMPCircleColshapeOptions extends ICCMPColshapeOptions {
+}
+export declare class CCMPCircleColshape extends CCMPColshape implements ICircleColshape {
+    constructor(options: ICCMPCircleColshapeOptions);
+}

package/dist/server/entities/ccmp/colshape/CCMPCircleColshape.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPCircleColshape = void 0;
+const CCMPColshape_1 = require("./CCMPColshape");
+class CCMPCircleColshape extends CCMPColshape_1.CCMPColshape {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.CCMPCircleColshape = CCMPCircleColshape;

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

@@ -0,0 +1,23 @@
+import { type IColshape } from "../../common/colshape/IColshape";
+import { CCMPWorldObject } from "../worldObject/CCMPWorldObject";
+import { BaseObjectType } from "../../../../shared";
+import { type IVector3D } from "../../../../shared/common/utils/math/Vectors";
+import type { Colshape as CcmpColshape, Player as CcmpPlayer } from "@classic-mp/types/server";
+export interface ICCMPColshapeOptions {
+    ccmpColshape: CcmpColshape;
+    onDestroy: (colshape: CCMPColshape) => void;
+}
+export declare abstract class CCMPColshape extends CCMPWorldObject implements IColshape {
+    private readonly _ccmpColshape;
+    private readonly _onDestroy;
+    get id(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get position(): IVector3D;
+    get dimension(): number;
+    get playersInside(): readonly CcmpPlayer[];
+    protected constructor(options: ICCMPColshapeOptions);
+    destroy(): void;
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPColshape = void 0;
+const CCMPWorldObject_1 = require("../worldObject/CCMPWorldObject");
+const shared_1 = require("../../../../shared");
+const Vectors_1 = require("../../../../shared/common/utils/math/Vectors");
+class CCMPColshape extends CCMPWorldObject_1.CCMPWorldObject {
+    _ccmpColshape;
+    _onDestroy;
+    get id() {
+        return this._ccmpColshape.id;
+    }
+    get type() {
+        return shared_1.BaseObjectType.Colshape;
+    }
+    get isExists() {
+        return this._ccmpColshape.isExists;
+    }
+    get position() {
+        const p = this._ccmpColshape.position;
+        return new Vectors_1.Vector3D(p.x, p.y, p.z);
+    }
+    get dimension() {
+        return this._ccmpColshape.dimension;
+    }
+    get playersInside() {
+        return this._ccmpColshape.playersInside;
+    }
+    constructor(options) {
+        super();
+        this._ccmpColshape = options.ccmpColshape;
+        this._onDestroy = options.onDestroy;
+    }
+    destroy() {
+        if (!this._ccmpColshape.isExists)
+            return;
+        this._ccmpColshape.destroy();
+        this._onDestroy(this);
+    }
+    setPosition(value) {
+        this._ccmpColshape.position = { x: value.x, y: value.y, z: value.z };
+    }
+    setDimension(value) {
+        this._ccmpColshape.dimension = value;
+    }
+}
+exports.CCMPColshape = CCMPColshape;

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

@@ -0,0 +1,28 @@
+import { type ICircleColshapeCreateOptions, type IColshapesManager, type ICuboidColshapeCreateOptions, type ICylinderColshapeCreateOptions, type IRectangleColshapeCreateOptions, type ISphereColshapeCreateOptions } from "../../common/colshape/IColshapesManager";
+import { CCMPWorldObjectsManager } from "../worldObject/CCMPWorldObjectsManager";
+import { type CCMPColshape } from "./CCMPColshape";
+import { CCMPCircleColshape } from "./CCMPCircleColshape";
+import { CCMPCuboidColshape } from "./CCMPCuboidColshape";
+import { CCMPCylinderColshape } from "./CCMPCylinderColshape";
+import { type CCMPRectangleColshape } from "./CCMPRectangleColshape";
+import { CCMPSphereColshape } from "./CCMPSphereColshape";
+import { type CCMPPlayer } from "../player/CCMPPlayer";
+export interface ICCMPCircleColshapeCreateOptions extends ICircleColshapeCreateOptions {
+}
+export interface ICCMPCuboidColshapeCreateOptions extends ICuboidColshapeCreateOptions {
+}
+export interface ICCMPCylinderColshapeCreateOptions extends ICylinderColshapeCreateOptions {
+}
+export interface ICCMPRectangleColshapeCreateOptions extends IRectangleColshapeCreateOptions {
+}
+export interface ICCMPSphereColshapeCreateOptions extends ISphereColshapeCreateOptions {
+}
+export declare class CCMPColshapesManager extends CCMPWorldObjectsManager<CCMPColshape> implements IColshapesManager {
+    constructor();
+    createCircle(options: ICCMPCircleColshapeCreateOptions): CCMPCircleColshape;
+    createCuboid(options: ICCMPCuboidColshapeCreateOptions): CCMPCuboidColshape;
+    createCylinder(options: ICCMPCylinderColshapeCreateOptions): CCMPCylinderColshape;
+    createRectangle(_options: ICCMPRectangleColshapeCreateOptions): CCMPRectangleColshape;
+    createSphere(options: ICCMPSphereColshapeCreateOptions): CCMPSphereColshape;
+    getParticipants(colshape: CCMPColshape): Set<CCMPPlayer>;
+}

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPColshapesManager = void 0;
+const CCMPWorldObjectsManager_1 = require("../worldObject/CCMPWorldObjectsManager");
+const CCMPCircleColshape_1 = require("./CCMPCircleColshape");
+const CCMPCuboidColshape_1 = require("./CCMPCuboidColshape");
+const CCMPCylinderColshape_1 = require("./CCMPCylinderColshape");
+const CCMPSphereColshape_1 = require("./CCMPSphereColshape");
+const RockMod_1 = require("../../../RockMod");
+const types_1 = require("../../../net/common/events/types");
+class CCMPColshapesManager extends CCMPWorldObjectsManager_1.CCMPWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "colshape",
+        });
+        ccmp.on("playerEnterColshape", (ccmpPlayer, ccmpColshape) => {
+            if (!ccmpColshape)
+                return;
+            const colshape = this.findByID(ccmpColshape.id);
+            if (!colshape)
+                return;
+            const player = RockMod_1.RockMod.instance.players.findByID(ccmpPlayer.id);
+            if (!player)
+                return;
+            RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.PlayerEnteredColshape, player, colshape);
+        });
+        ccmp.on("playerExitColshape", (ccmpPlayer, ccmpColshape) => {
+            if (!ccmpColshape)
+                return;
+            const colshape = this.findByID(ccmpColshape.id);
+            if (!colshape)
+                return;
+            const player = RockMod_1.RockMod.instance.players.findByID(ccmpPlayer.id);
+            if (!player)
+                return;
+            RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.PlayerLeftColshape, player, colshape);
+        });
+    }
+    createCircle(options) {
+        const { position, range, dimension } = options;
+        const ccmpColshape = ccmp.colshapes.createCircle(position.x, position.y, position.z, range, { dimension });
+        if (!ccmpColshape) {
+            throw new Error("CCMPColshapesManager.createCircle: ccmp.colshapes.createCircle failed (server full?)");
+        }
+        const colshape = new CCMPCircleColshape_1.CCMPCircleColshape({
+            ccmpColshape,
+            onDestroy: (c) => this.unregisterBaseObject(c),
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCuboid(options) {
+        const { position, width, depth, height, dimension } = options;
+        // CCMP cube uses HALF-extents (centered at position); rock-mod options describe full sizes.
+        const ccmpColshape = ccmp.colshapes.createCube(position.x, position.y, position.z, width / 2, depth / 2, height / 2, { dimension });
+        if (!ccmpColshape) {
+            throw new Error("CCMPColshapesManager.createCuboid: ccmp.colshapes.createCube failed (server full?)");
+        }
+        const colshape = new CCMPCuboidColshape_1.CCMPCuboidColshape({
+            ccmpColshape,
+            onDestroy: (c) => this.unregisterBaseObject(c),
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCylinder(options) {
+        const { position, range, height, dimension } = options;
+        const ccmpColshape = ccmp.colshapes.createCylinder(position.x, position.y, position.z, range, height, {
+            dimension,
+        });
+        if (!ccmpColshape) {
+            throw new Error("CCMPColshapesManager.createCylinder: ccmp.colshapes.createCylinder failed (server full?)");
+        }
+        const colshape = new CCMPCylinderColshape_1.CCMPCylinderColshape({
+            ccmpColshape,
+            onDestroy: (c) => this.unregisterBaseObject(c),
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createRectangle(_options) {
+        throw new Error("CCMPColshapesManager.createRectangle: not supported by CCMP");
+    }
+    createSphere(options) {
+        const { position, range, dimension } = options;
+        const ccmpColshape = ccmp.colshapes.createSphere(position.x, position.y, position.z, range, { dimension });
+        if (!ccmpColshape) {
+            throw new Error("CCMPColshapesManager.createSphere: ccmp.colshapes.createSphere failed (server full?)");
+        }
+        const colshape = new CCMPSphereColshape_1.CCMPSphereColshape({
+            ccmpColshape,
+            onDestroy: (c) => this.unregisterBaseObject(c),
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    getParticipants(colshape) {
+        const participants = new Set();
+        for (const ccmpPlayer of colshape.playersInside) {
+            const player = RockMod_1.RockMod.instance.players.findByID(ccmpPlayer.id);
+            if (player) {
+                participants.add(player);
+            }
+        }
+        return participants;
+    }
+}
+exports.CCMPColshapesManager = CCMPColshapesManager;

package/dist/server/entities/ccmp/colshape/CCMPCuboidColshape.d.ts

@@ -0,0 +1,7 @@
+import { type ICCMPColshapeOptions, CCMPColshape } from "./CCMPColshape";
+import { type ICuboidColshape } from "../../common/colshape/ICuboidColshape";
+export interface ICCMPCuboidColshapeOptions extends ICCMPColshapeOptions {
+}
+export declare class CCMPCuboidColshape extends CCMPColshape implements ICuboidColshape {
+    constructor(options: ICCMPCuboidColshapeOptions);
+}

package/dist/server/entities/ccmp/colshape/CCMPCuboidColshape.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPCuboidColshape = void 0;
+const CCMPColshape_1 = require("./CCMPColshape");
+class CCMPCuboidColshape extends CCMPColshape_1.CCMPColshape {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.CCMPCuboidColshape = CCMPCuboidColshape;

package/dist/server/entities/ccmp/colshape/CCMPCylinderColshape.d.ts

@@ -0,0 +1,7 @@
+import { type ICCMPColshapeOptions, CCMPColshape } from "./CCMPColshape";
+import { type ICylinderColshape } from "../../common/colshape/ICylinderColshape";
+export interface ICCMPCylinderColshapeOptions extends ICCMPColshapeOptions {
+}
+export declare class CCMPCylinderColshape extends CCMPColshape implements ICylinderColshape {
+    constructor(options: ICCMPCylinderColshapeOptions);
+}

package/dist/server/entities/ccmp/colshape/CCMPCylinderColshape.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPCylinderColshape = void 0;
+const CCMPColshape_1 = require("./CCMPColshape");
+class CCMPCylinderColshape extends CCMPColshape_1.CCMPColshape {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.CCMPCylinderColshape = CCMPCylinderColshape;

package/dist/server/entities/ccmp/colshape/CCMPRectangleColshape.d.ts

@@ -0,0 +1,7 @@
+import { type ICCMPColshapeOptions, CCMPColshape } from "./CCMPColshape";
+import { type IRectangleColshape } from "../../common/colshape/IRectangleColshape";
+export interface ICCMPRectangleColshapeOptions extends ICCMPColshapeOptions {
+}
+export declare class CCMPRectangleColshape extends CCMPColshape implements IRectangleColshape {
+    constructor(options: ICCMPRectangleColshapeOptions);
+}

package/dist/server/entities/ccmp/colshape/CCMPRectangleColshape.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPRectangleColshape = void 0;
+const CCMPColshape_1 = require("./CCMPColshape");
+class CCMPRectangleColshape extends CCMPColshape_1.CCMPColshape {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.CCMPRectangleColshape = CCMPRectangleColshape;

package/dist/server/entities/ccmp/colshape/CCMPSphereColshape.d.ts

@@ -0,0 +1,7 @@
+import { type ICCMPColshapeOptions, CCMPColshape } from "./CCMPColshape";
+import { type ISphereColshape } from "../../common/colshape/ISphereColshape";
+export interface ICCMPSphereColshapeOptions extends ICCMPColshapeOptions {
+}
+export declare class CCMPSphereColshape extends CCMPColshape implements ISphereColshape {
+    constructor(options: ICCMPSphereColshapeOptions);
+}

package/dist/server/entities/ccmp/colshape/CCMPSphereColshape.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPSphereColshape = void 0;
+const CCMPColshape_1 = require("./CCMPColshape");
+class CCMPSphereColshape extends CCMPColshape_1.CCMPColshape {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.CCMPSphereColshape = CCMPSphereColshape;

package/dist/server/entities/ccmp/entity/CCMPEntitiesManager.d.ts

@@ -0,0 +1,8 @@
+import { type IEntitiesManager } from "../../common/entity/IEntitiesManager";
+import { type CCMPEntity } from "./CCMPEntity";
+import { type ICCMPWorldObjectsManagerOptions, CCMPWorldObjectsManager } from "../worldObject/CCMPWorldObjectsManager";
+export interface ICCMPEntitiesManagerOptions extends ICCMPWorldObjectsManagerOptions {
+}
+export declare abstract class CCMPEntitiesManager<T extends CCMPEntity> extends CCMPWorldObjectsManager<T> implements IEntitiesManager<T> {
+    protected constructor(options: ICCMPEntitiesManagerOptions);
+}

package/dist/server/entities/ccmp/entity/CCMPEntitiesManager.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPEntitiesManager = void 0;
+const CCMPWorldObjectsManager_1 = require("../worldObject/CCMPWorldObjectsManager");
+class CCMPEntitiesManager extends CCMPWorldObjectsManager_1.CCMPWorldObjectsManager {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.CCMPEntitiesManager = CCMPEntitiesManager;

package/dist/server/entities/ccmp/entity/CCMPEntity.d.ts

@@ -0,0 +1,13 @@
+import { type IEntity } from "../../common/entity/IEntity";
+import { CCMPWorldObject } from "../worldObject/CCMPWorldObject";
+import { type IVector3D } from "../../../../shared/common/utils/math/Vectors";
+import type { StreamSyncedMeta } from "@classic-mp/types/server";
+export declare abstract class CCMPEntity extends CCMPWorldObject implements IEntity {
+    protected abstract get ccmpMeta(): StreamSyncedMeta;
+    get model(): number;
+    get rotation(): IVector3D;
+    setModel(_value: string): void;
+    setRotation(_value: IVector3D): void;
+    getNetData(name: string): unknown;
+    setNetData(name: string, value: unknown): void;
+}

package/dist/server/entities/ccmp/entity/CCMPEntity.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPEntity = void 0;
+const CCMPWorldObject_1 = require("../worldObject/CCMPWorldObject");
+const notImplemented = (name) => {
+    throw new Error(`Not implemented yet: ${name}`);
+};
+class CCMPEntity extends CCMPWorldObject_1.CCMPWorldObject {
+    get model() {
+        return notImplemented("CCMPEntity.model");
+    }
+    get rotation() {
+        return notImplemented("CCMPEntity.rotation");
+    }
+    setModel(_value) {
+        notImplemented("CCMPEntity.setModel");
+    }
+    setRotation(_value) {
+        notImplemented("CCMPEntity.setRotation");
+    }
+    getNetData(name) {
+        return this.ccmpMeta.getStreamSyncedMeta(name);
+    }
+    setNetData(name, value) {
+        this.ccmpMeta.setStreamSyncedMeta(name, value);
+    }
+}
+exports.CCMPEntity = CCMPEntity;

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

@@ -0,0 +1,32 @@
+import { CCMPWorldObject } from "../worldObject/CCMPWorldObject";
+import { type IMarker } from "../../common/marker/IMarker";
+import { BaseObjectType, type IMarkerType } from "../../../../shared";
+import { type IVector3D } from "../../../../shared/common/utils/math/Vectors";
+import { type IRGBA } from "../../../../shared/common/utils/color/RGBA";
+import type { Marker as CcmpMarker } from "@classic-mp/types/server";
+export interface ICCMPMarkerOptions {
+    ccmpMarker: CcmpMarker;
+    onDestroy: (marker: CCMPMarker) => void;
+}
+export declare class CCMPMarker extends CCMPWorldObject implements IMarker {
+    private readonly _ccmpMarker;
+    private readonly _onDestroy;
+    get id(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get position(): IVector3D;
+    get dimension(): number;
+    get markerType(): IMarkerType;
+    get visible(): boolean;
+    get scale(): number;
+    get color(): IRGBA;
+    get rotation(): IVector3D;
+    constructor(options: ICCMPMarkerOptions);
+    destroy(): void;
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+    setVisible(value: boolean): void;
+    setScale(value: number): void;
+    setColor(value: IRGBA): void;
+    setRotation(value: IVector3D): void;
+}

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCMPMarker = void 0;
+const CCMPWorldObject_1 = require("../worldObject/CCMPWorldObject");
+const shared_1 = require("../../../../shared");
+const Vectors_1 = require("../../../../shared/common/utils/math/Vectors");
+const RGBA_1 = require("../../../../shared/common/utils/color/RGBA");
+class CCMPMarker extends CCMPWorldObject_1.CCMPWorldObject {
+    _ccmpMarker;
+    _onDestroy;
+    get id() {
+        return this._ccmpMarker.id;
+    }
+    get type() {
+        return shared_1.BaseObjectType.Marker;
+    }
+    get isExists() {
+        return this._ccmpMarker.isExists;
+    }
+    get position() {
+        const p = this._ccmpMarker.position;
+        return new Vectors_1.Vector3D(p.x, p.y, p.z);
+    }
+    get dimension() {
+        return this._ccmpMarker.dimension;
+    }
+    get markerType() {
+        return this._ccmpMarker.type;
+    }
+    get visible() {
+        return this._ccmpMarker.visible;
+    }
+    get scale() {
+        return this._ccmpMarker.scale;
+    }
+    get color() {
+        const c = this._ccmpMarker.color;
+        return new RGBA_1.RGBA(c.r, c.g, c.b, c.a);
+    }
+    get rotation() {
+        const r = this._ccmpMarker.rotation;
+        return new Vectors_1.Vector3D(r.x, r.y, r.z);
+    }
+    constructor(options) {
+        super();
+        this._ccmpMarker = options.ccmpMarker;
+        this._onDestroy = options.onDestroy;
+    }
+    destroy() {
+        if (!this._ccmpMarker.isExists)
+            return;
+        this._ccmpMarker.destroy();
+        this._onDestroy(this);
+    }
+    setPosition(value) {
+        this._ccmpMarker.position = { x: value.x, y: value.y, z: value.z };
+    }
+    setDimension(value) {
+        this._ccmpMarker.dimension = value;
+    }
+    setVisible(value) {
+        this._ccmpMarker.visible = value;
+    }
+    setScale(value) {
+        this._ccmpMarker.scale = value;
+    }
+    setColor(value) {
+        this._ccmpMarker.color = {
+            r: value.r,
+            g: value.g,
+            b: value.b,
+            a: value.a ?? 255,
+        };
+    }
+    setRotation(value) {
+        this._ccmpMarker.rotation = { x: value.x, y: value.y, z: value.z };
+    }
+}
+exports.CCMPMarker = CCMPMarker;

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

@@ -0,0 +1,9 @@
+import { type IMarkerCreateOptions, type IMarkersManager } from "../../common/marker/IMarkersManager";
+import { CCMPWorldObjectsManager } from "../worldObject/CCMPWorldObjectsManager";
+import { CCMPMarker } from "./CCMPMarker";
+export interface ICCMPMarkerCreateOptions extends IMarkerCreateOptions {
+}
+export declare class CCMPMarkersManager extends CCMPWorldObjectsManager<CCMPMarker> implements IMarkersManager {
+    constructor();
+    create(options: ICCMPMarkerCreateOptions): CCMPMarker;
+}

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;