rock-mod 0.7.2 → 0.8.0

package/dist/server/RockMod.d.ts

@@ -1,7 +1,7 @@
 import { INetManager } from "./net/common/INetManager";
 import { IBlipsManager, IColshapesManager, IMarkersManager, IObjectsManager, IPedsManager, IPlayersManager, IVehiclesManager } from "./entities";
 import { IUtilsManager } from "./utils";
-type MultiplayerType = "RageMP" | "AltV";
+type MultiplayerType = "RageMP" | "AltV" | "Mock";
 export interface RockModOptions {
     multiplayer: MultiplayerType;
 }

package/dist/server/RockMod.js

@@ -36,7 +36,7 @@ class RockMod {
     }
     static get instance() {
         if (!this._instance) {
-            throw new Error("RockMod not created");
+            throw new Error("RockMod is not created");
         }
         return this._instance;
     }
@@ -51,6 +51,10 @@ class RockMod {
                 const { RageManagersFactory } = await Promise.resolve().then(() => __importStar(require("./factories/ragemp/RageManagersFactory")));
                 return new RageManagersFactory();
             }
+            case "Mock": {
+                const { MockManagersFactory } = await Promise.resolve().then(() => __importStar(require("./factories/mock/MockManagersFactory")));
+                return new MockManagersFactory();
+            }
         }
     }
     _net;

package/dist/server/entities/altv/marker/AltVMarker.d.ts

@@ -1,12 +1,18 @@
 import { AltVWorldObject, IAltVWorldObjectOptions } from "../worldObject/AltVWorldObject";
 import Marker = AltVServer.Marker;
-import { IMarker } from "../../common";
+import { IMarker, IMarkerType } from "../../common";
+import { IRGBA, IVector3D } from "../../../common/utils";
 export interface IAltVMarkerOptions extends IAltVWorldObjectOptions<Marker> {
 }
 export declare class AltVMarker extends AltVWorldObject<Marker> implements IMarker {
+    get markerType(): IMarkerType;
     get visible(): boolean;
     get scale(): number;
+    get color(): IRGBA;
+    get rotation(): IVector3D;
     constructor(options: IAltVMarkerOptions);
     setVisible(value: boolean): void;
     setScale(value: number): void;
+    setColor(value: IRGBA): void;
+    setRotation(value: IVector3D): void;
 }

package/dist/server/entities/altv/marker/AltVMarker.js

@@ -3,13 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVMarker = void 0;
 const AltVWorldObject_1 = require("../worldObject/AltVWorldObject");
 var Vector3 = AltVShared.Vector3;
+const utils_1 = require("../../../common/utils");
 class AltVMarker extends AltVWorldObject_1.AltVWorldObject {
+    get markerType() {
+        return this.mpEntity.markerType;
+    }
     get visible() {
         return this.mpEntity.visible;
     }
     get scale() {
         return this.mpEntity.scale.z;
     }
+    get color() {
+        const { r, g, b, a } = this.mpEntity.color;
+        return new utils_1.RGBA(r, g, b, a);
+    }
+    get rotation() {
+        const { x, y, z } = this.mpEntity.rot;
+        return new utils_1.Vector3D(x, y, z);
+    }
     constructor(options) {
         super(options);
     }
@@ -19,5 +31,12 @@ class AltVMarker extends AltVWorldObject_1.AltVWorldObject {
     setScale(value) {
         this.mpEntity.scale = new Vector3(0, 0, value);
     }
+    setColor(value) {
+        const { r, g, b, a } = value;
+        this.mpEntity.color = new AltVShared.RGBA(r, g, b, a);
+    }
+    setRotation(value) {
+        this.mpEntity.rot = new Vector3(value);
+    }
 }
 exports.AltVMarker = AltVMarker;

package/dist/server/entities/altv/player/AltVPlayer.d.ts

@@ -13,6 +13,7 @@ export declare class AltVPlayer extends AltVEntity<Player> implements IPlayer {
     get heading(): number;
     get health(): number;
     get armour(): number;
+    get isDead(): boolean;
     get ip(): string;
     get serial(): string;
     get vehicle(): AltVVehicle | null;

package/dist/server/entities/altv/player/AltVPlayer.js

@@ -23,6 +23,9 @@ class AltVPlayer extends AltVEntity_1.AltVEntity {
     get armour() {
         return this.mpEntity.armour;
     }
+    get isDead() {
+        return this.mpEntity.isDead;
+    }
     get ip() {
         return this.mpEntity.ip;
     }

package/dist/server/entities/common/marker/IMarker.d.ts

@@ -1,9 +1,20 @@
 import { IWorldObject, IWorldObjectOptions } from "../worldObject";
+import { IMarkerType } from "./IMarkersManager";
+import { IRGBA, IVector3D } from "../../../common/utils";
 export interface IMarkerOptions extends IWorldObjectOptions {
+    type: IMarkerType;
+    scale: number;
+    color: IRGBA;
+    rotation: IVector3D;
 }
 export interface IMarker extends IWorldObject {
+    get markerType(): IMarkerType;
     get visible(): boolean;
     get scale(): number;
+    get color(): IRGBA;
+    get rotation(): IVector3D;
     setVisible(value: boolean): void;
     setScale(value: number): void;
+    setColor(value: IRGBA): void;
+    setRotation(value: IVector3D): void;
 }

package/dist/server/entities/common/marker/IMarkersManager.d.ts

@@ -1,7 +1,6 @@
-import { IEntityCreateOptions } from "../entity";
 import { IMarker } from "./IMarker";
-import { IWorldObjectsManager } from "../worldObject";
-import { IRGBA } from "../../../common/utils";
+import { IWorldObjectCreateOptions, IWorldObjectsManager } from "../worldObject";
+import { IRGBA, IVector3D } from "../../../common/utils";
 export declare enum IMarkerType {
     MarkerCone = 0,
     MarkerCylinder = 1,
@@ -49,10 +48,11 @@ export declare enum IMarkerType {
     MarkerBoxes = 43,
     MarkerPitLane = 44
 }
-export interface IMarkerCreateOptions extends Omit<IEntityCreateOptions, "model"> {
+export interface IMarkerCreateOptions extends IWorldObjectCreateOptions {
     type: IMarkerType;
     scale: number;
     color: IRGBA;
+    rotation: IVector3D;
 }
 export interface IMarkersManager extends IWorldObjectsManager<IMarker> {
     create(options: IMarkerCreateOptions): IMarker;

package/dist/server/entities/common/ped/IPedsManager.d.ts

@@ -1,6 +1,7 @@
 import { IEntitiesManager, IEntityCreateOptions } from "../entity";
 import { IPed } from "./IPed";
 export interface IPedCreateOptions extends IEntityCreateOptions {
+    frozen: boolean;
 }
 export interface IPedsManager extends IEntitiesManager<IPed> {
     create(options: IPedCreateOptions): IPed;

package/dist/server/entities/common/player/IPlayer.d.ts

@@ -27,6 +27,7 @@ export interface IPlayer extends IEntity {
     get heading(): number;
     get health(): number;
     get armour(): number;
+    get isDead(): boolean;
     get ip(): string;
     get serial(): string;
     get vehicle(): IVehicle | null;

package/dist/server/entities/mock/baseObject/MockBaseObject.d.ts

@@ -0,0 +1,18 @@
+import { IBaseObject, BaseObjectType } from "../../common/baseObject/IBaseObject";
+import { IVector3D } from "../../../common/utils/math/Vectors";
+export interface IMockBaseObjectOptions {
+    id: number;
+    type: BaseObjectType;
+    position: IVector3D;
+    dimension?: number;
+}
+export declare abstract class MockBaseObject implements IBaseObject {
+    readonly id: number;
+    readonly type: BaseObjectType;
+    readonly position: IVector3D;
+    readonly dimension: number;
+    protected _exists: boolean;
+    protected constructor(options: IMockBaseObjectOptions);
+    get isExists(): boolean;
+    destroy(): void;
+}

package/dist/server/entities/mock/baseObject/MockBaseObject.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockBaseObject = void 0;
+class MockBaseObject {
+    id;
+    type;
+    position;
+    dimension;
+    _exists;
+    constructor(options) {
+        this.id = options.id;
+        this.type = options.type;
+        this.position = options.position;
+        this.dimension = options.dimension ?? 0;
+        this._exists = true;
+    }
+    get isExists() {
+        return this._exists;
+    }
+    destroy() {
+        this._exists = false;
+    }
+}
+exports.MockBaseObject = MockBaseObject;

package/dist/server/entities/mock/baseObject/MockBaseObjectsIterator.d.ts

@@ -0,0 +1,7 @@
+import { IBaseObjectsIterator } from "../../common/baseObject/IBaseObjectsIterator";
+import { MockBaseObject } from "./MockBaseObject";
+export declare class MockBaseObjectsIterator<T extends MockBaseObject> implements IBaseObjectsIterator<T> {
+    protected readonly _baseObjects: ReadonlyMap<number, T>;
+    constructor(baseObjects: ReadonlyMap<number, T>);
+    all(): IterableIterator<T>;
+}

package/dist/server/entities/mock/baseObject/MockBaseObjectsIterator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockBaseObjectsIterator = void 0;
+class MockBaseObjectsIterator {
+    _baseObjects;
+    constructor(baseObjects) {
+        this._baseObjects = baseObjects;
+    }
+    all() {
+        return this._baseObjects.values();
+    }
+}
+exports.MockBaseObjectsIterator = MockBaseObjectsIterator;

package/dist/server/entities/mock/baseObject/MockBaseObjectsManager.d.ts

@@ -0,0 +1,18 @@
+import { IBaseObjectsManager, IBaseObjectsManagerOptions } from "../../common/baseObject/IBaseObjectsManager";
+import { BaseObjectType } from "../../common/baseObject/IBaseObject";
+import { MockBaseObject } from "./MockBaseObject";
+import { MockBaseObjectsIterator } from "./MockBaseObjectsIterator";
+export interface IMockBaseObjectsManagerOptions extends IBaseObjectsManagerOptions {
+}
+export declare abstract class MockBaseObjectsManager<T extends MockBaseObject> implements IBaseObjectsManager<T> {
+    protected readonly _baseObjects: Map<number, T>;
+    protected readonly _baseObjectsType: `${BaseObjectType}`;
+    protected readonly _iterator: MockBaseObjectsIterator<T>;
+    protected get baseObjects(): ReadonlyMap<number, T>;
+    get iterator(): MockBaseObjectsIterator<T>;
+    protected constructor(options: IMockBaseObjectsManagerOptions);
+    getByID(id: number): T;
+    findByID(id: number): T | null;
+    protected registerBaseObject(baseObject: T): void;
+    protected unregisterBaseObject(baseObject: T): void;
+}

package/dist/server/entities/mock/baseObject/MockBaseObjectsManager.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockBaseObjectsManager = void 0;
+const MockBaseObjectsIterator_1 = require("./MockBaseObjectsIterator");
+const RockMod_1 = require("../../../RockMod");
+class MockBaseObjectsManager {
+    _baseObjects;
+    _baseObjectsType;
+    _iterator;
+    get baseObjects() {
+        return this._baseObjects;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    constructor(options) {
+        this._baseObjects = new Map();
+        this._baseObjectsType = options.baseObjectsType;
+        this._iterator = new MockBaseObjectsIterator_1.MockBaseObjectsIterator(this._baseObjects);
+    }
+    getByID(id) {
+        const baseObject = this.findByID(id);
+        if (!baseObject) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${id} not found`);
+        }
+        return baseObject;
+    }
+    findByID(id) {
+        const baseObject = this._baseObjects.get(id);
+        return baseObject ?? null;
+    }
+    registerBaseObject(baseObject) {
+        if (this._baseObjects.has(baseObject.id)) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} already exists`);
+        }
+        this._baseObjects.set(baseObject.id, baseObject);
+        RockMod_1.RockMod.instance.net.events.emit("rm::entityCreated", baseObject);
+    }
+    unregisterBaseObject(baseObject) {
+        if (!this._baseObjects.delete(baseObject.id)) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} not found`);
+        }
+        RockMod_1.RockMod.instance.net.events.emit("rm::entityDestroyed", baseObject);
+    }
+}
+exports.MockBaseObjectsManager = MockBaseObjectsManager;

package/dist/server/entities/mock/blip/MockBlip.d.ts

@@ -0,0 +1,35 @@
+import { IBlip, IBlipColor, IBlipSprite } from "../../common/blip/IBlip";
+import { MockWorldObject, IMockWorldObjectOptions } from "../worldObject/MockWorldObject";
+export interface IMockBlipOptions extends IMockWorldObjectOptions {
+    alpha: number;
+    color: number;
+    drawDistance: number;
+    name: string;
+    rotation: number;
+    scale: number;
+    shortRange: boolean;
+    sprite: number;
+}
+export declare class MockBlip extends MockWorldObject implements IBlip {
+    private _name;
+    private _sprite;
+    private _color;
+    private _alpha;
+    private readonly _scale;
+    private readonly _drawDistance;
+    private readonly _shortRange;
+    private readonly _rotation;
+    get name(): string;
+    get sprite(): IBlipSprite;
+    get color(): IBlipColor;
+    get alpha(): number;
+    get scale(): number;
+    get drawDistance(): number;
+    get shortRange(): boolean;
+    get rotation(): number;
+    constructor(options: IMockBlipOptions);
+    setName(value: string): void;
+    setSprite(value: IBlipSprite): void;
+    setColor(value: IBlipColor): void;
+    setAlpha(value: number): void;
+}

package/dist/server/entities/mock/blip/MockBlip.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockBlip = void 0;
+const MockWorldObject_1 = require("../worldObject/MockWorldObject");
+class MockBlip extends MockWorldObject_1.MockWorldObject {
+    _name;
+    _sprite;
+    _color;
+    _alpha;
+    _scale;
+    _drawDistance;
+    _shortRange;
+    _rotation;
+    get name() {
+        return this._name;
+    }
+    get sprite() {
+        return this._sprite;
+    }
+    get color() {
+        return this._color;
+    }
+    get alpha() {
+        return this._alpha;
+    }
+    get scale() {
+        return this._scale;
+    }
+    get drawDistance() {
+        return this._drawDistance;
+    }
+    get shortRange() {
+        return this._shortRange;
+    }
+    get rotation() {
+        return this._rotation;
+    }
+    constructor(options) {
+        super(options);
+        this._name = options.name;
+        this._sprite = options.sprite;
+        this._color = options.color;
+        this._alpha = options.alpha;
+        this._scale = options.scale;
+        this._drawDistance = options.drawDistance;
+        this._shortRange = options.shortRange;
+        this._rotation = options.rotation;
+    }
+    setName(value) {
+        this._name = value;
+    }
+    setSprite(value) {
+        this._sprite = value;
+    }
+    setColor(value) {
+        this._color = value;
+    }
+    setAlpha(value) {
+        this._alpha = value;
+    }
+}
+exports.MockBlip = MockBlip;

package/dist/server/entities/mock/blip/MockBlipsManager.d.ts

@@ -0,0 +1,9 @@
+import { IBlipCreateOptions, IBlipsManager } from "../../common/blip/IBlipsManager";
+import { MockWorldObjectsManager } from "../worldObject/MockWorldObjectsManager";
+import { MockBlip } from "./MockBlip";
+export interface IMockBlipCreateOptions extends IBlipCreateOptions {
+}
+export declare class MockBlipsManager extends MockWorldObjectsManager<MockBlip> implements IBlipsManager {
+    constructor();
+    create(options: IMockBlipCreateOptions): MockBlip;
+}

package/dist/server/entities/mock/blip/MockBlipsManager.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockBlipsManager = void 0;
+const MockWorldObjectsManager_1 = require("../worldObject/MockWorldObjectsManager");
+const MockBlip_1 = require("./MockBlip");
+const common_1 = require("../../common");
+class MockBlipsManager extends MockWorldObjectsManager_1.MockWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "blip",
+        });
+    }
+    create(options) {
+        const { alpha = 255, drawDistance = 30, shortRange = false, sprite, scale = 1, color = 1, name = "Blip", position, dimension, rotation = 0, } = options;
+        const blip = new MockBlip_1.MockBlip({
+            id: 0,
+            type: common_1.BaseObjectType.Blip,
+            alpha,
+            drawDistance,
+            shortRange,
+            sprite,
+            scale,
+            color,
+            name,
+            position,
+            dimension,
+            rotation,
+        });
+        this.registerBaseObject(blip);
+        return blip;
+    }
+}
+exports.MockBlipsManager = MockBlipsManager;

package/dist/server/entities/mock/colshape/MockCircleColshape.d.ts

@@ -0,0 +1,8 @@
+import { ICircleColshape } from "../../common";
+import { IMockColshapeOptions, MockColshape } from "./MockColshape";
+export interface IMockCircleColshapeCreateOptions extends IMockColshapeOptions {
+    range: number;
+}
+export declare class MockCircleColshape extends MockColshape implements ICircleColshape {
+    constructor(options: IMockCircleColshapeCreateOptions);
+}

package/dist/server/entities/mock/colshape/MockCircleColshape.js

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

package/dist/server/entities/mock/colshape/MockColshape.d.ts

@@ -0,0 +1,7 @@
+import { IColshape } from "../../common/colshape/IColshape";
+import { MockWorldObject, IMockWorldObjectOptions } from "../worldObject/MockWorldObject";
+export interface IMockColshapeOptions extends IMockWorldObjectOptions {
+}
+export declare abstract class MockColshape extends MockWorldObject implements IColshape {
+    protected constructor(options: IMockColshapeOptions);
+}

package/dist/server/entities/mock/colshape/MockColshape.js

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

package/dist/server/entities/mock/colshape/MockColshapesManager.d.ts

@@ -0,0 +1,27 @@
+import { ICircleColshapeCreateOptions, IColshapesManager, ICuboidColshapeCreateOptions, ICylinderColshapeCreateOptions, IRectangleColshapeCreateOptions, ISphereColshapeCreateOptions } from "../../common";
+import { MockWorldObjectsManager } from "../worldObject/MockWorldObjectsManager";
+import { MockCircleColshape } from "./MockCircleColshape";
+import { MockCuboidColshape } from "./MockCuboidColshape";
+import { MockCylinderColshape } from "./MockCylinderColshape";
+import { MockRectangleColshape } from "./MockRectangleColshape";
+import { MockSphereColshape } from "./MockSphereColshape";
+import { MockColshape } from "./MockColshape";
+export interface IMockCircleColshapeCreateOptions extends ICircleColshapeCreateOptions {
+}
+export interface IMockCuboidColshapeCreateOptions extends ICuboidColshapeCreateOptions {
+}
+export interface IMockCylinderColshapeCreateOptions extends ICylinderColshapeCreateOptions {
+}
+export interface IMockRectangleColshapeCreateOptions extends IRectangleColshapeCreateOptions {
+}
+export interface IMockSphereColshapeCreateOptions extends ISphereColshapeCreateOptions {
+}
+export declare class MockColshapesManager extends MockWorldObjectsManager<MockColshape> implements IColshapesManager {
+    private _nextId;
+    constructor();
+    createCircle(options: IMockCircleColshapeCreateOptions): MockCircleColshape;
+    createCuboid(options: IMockCuboidColshapeCreateOptions): MockCuboidColshape;
+    createCylinder(options: IMockCylinderColshapeCreateOptions): MockCylinderColshape;
+    createRectangle(options: IMockRectangleColshapeCreateOptions): MockRectangleColshape;
+    createSphere(options: IMockSphereColshapeCreateOptions): MockSphereColshape;
+}

package/dist/server/entities/mock/colshape/MockColshapesManager.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockColshapesManager = void 0;
+const MockWorldObjectsManager_1 = require("../worldObject/MockWorldObjectsManager");
+const Vectors_1 = require("../../../common/utils/math/Vectors");
+const MockCircleColshape_1 = require("./MockCircleColshape");
+const MockCuboidColshape_1 = require("./MockCuboidColshape");
+const MockCylinderColshape_1 = require("./MockCylinderColshape");
+const MockRectangleColshape_1 = require("./MockRectangleColshape");
+const MockSphereColshape_1 = require("./MockSphereColshape");
+const IBaseObject_1 = require("../../common/baseObject/IBaseObject");
+class MockColshapesManager extends MockWorldObjectsManager_1.MockWorldObjectsManager {
+    _nextId;
+    constructor() {
+        super({
+            baseObjectsType: IBaseObject_1.BaseObjectType.Colshape,
+        });
+        this._nextId = 0;
+    }
+    createCircle(options) {
+        const { range, position, dimension } = options;
+        const { x, y } = position;
+        const colshape = new MockCircleColshape_1.MockCircleColshape({
+            id: this._nextId++,
+            type: IBaseObject_1.BaseObjectType.Colshape,
+            range,
+            position: new Vectors_1.Vector3D(x, y, 0),
+            dimension,
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCuboid(options) {
+        const { width, depth, height, position, dimension } = options;
+        const { x, y, z } = position;
+        const colshape = new MockCuboidColshape_1.MockCuboidColshape({
+            id: this._nextId++,
+            type: IBaseObject_1.BaseObjectType.Colshape,
+            width,
+            depth,
+            height,
+            position: new Vectors_1.Vector3D(x, y, z),
+            dimension,
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCylinder(options) {
+        const { height, range, position, dimension } = options;
+        const { x, y, z } = position;
+        const colshape = new MockCylinderColshape_1.MockCylinderColshape({
+            id: this._nextId++,
+            type: IBaseObject_1.BaseObjectType.Colshape,
+            range,
+            height,
+            position: new Vectors_1.Vector3D(x, y, z),
+            dimension,
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createRectangle(options) {
+        const { width, height, position, dimension } = options;
+        const { x, y } = position;
+        const colshape = new MockRectangleColshape_1.MockRectangleColshape({
+            id: this._nextId++,
+            type: IBaseObject_1.BaseObjectType.Colshape,
+            width,
+            height,
+            position: new Vectors_1.Vector3D(x, y, 0),
+            dimension,
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createSphere(options) {
+        const { range, position, dimension } = options;
+        const { x, y, z } = position;
+        const colshape = new MockSphereColshape_1.MockSphereColshape({
+            id: this._nextId++,
+            type: IBaseObject_1.BaseObjectType.Colshape,
+            range,
+            position: new Vectors_1.Vector3D(x, y, z),
+            dimension,
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+}
+exports.MockColshapesManager = MockColshapesManager;

package/dist/server/entities/mock/colshape/MockCuboidColshape.d.ts

@@ -0,0 +1,10 @@
+import { ICuboidColshape } from "../../common";
+import { IMockColshapeOptions, MockColshape } from "./MockColshape";
+export interface IMockCuboidColshapeCreateOptions extends IMockColshapeOptions {
+    width: number;
+    depth: number;
+    height: number;
+}
+export declare class MockCuboidColshape extends MockColshape implements ICuboidColshape {
+    constructor(options: IMockCuboidColshapeCreateOptions);
+}

package/dist/server/entities/mock/colshape/MockCuboidColshape.js

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

package/dist/server/entities/mock/colshape/MockCylinderColshape.d.ts

@@ -0,0 +1,9 @@
+import { ICylinderColshape } from "../../common";
+import { IMockColshapeOptions, MockColshape } from "./MockColshape";
+export interface IMockCylinderColshapeCreateOptions extends IMockColshapeOptions {
+    height: number;
+    range: number;
+}
+export declare class MockCylinderColshape extends MockColshape implements ICylinderColshape {
+    constructor(options: IMockCylinderColshapeCreateOptions);
+}

package/dist/server/entities/mock/colshape/MockCylinderColshape.js

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