rock-mod 0.3.0 → 0.5.1

package/README.md

@@ -1,25 +1,25 @@
-# Rock-Mod
-
-**Rock-Mod** is a versatile and powerful framework designed for cross-platform mod development for Grand Theft Auto (GTA) servers. It supports both **RageMP** and **AltV** multiplayer platforms, allowing you to build and manage mods seamlessly across these environments.
-
-### Installation
-
-To get started, simply install the package:
-
-```bash
-npm install rock-mod
-```
-
-### Usage
-
-On the server-side, initialize Rock-Mod with the appropriate multiplayer type:
-
-```typescript
-const rockMod = await RockMod.create({
-  multiplayer: "RageMP", // or "AltV"
-});
-```
-
-Please note that client-side implementation is not yet available in this version.
-
-Rock-Mod simplifies multiplayer mod development by providing unified tools for managing game entities, networking, and more across different platforms.
+# Rock-Mod
+
+**Rock-Mod** is a versatile and powerful framework designed for cross-platform mod development for Grand Theft Auto (GTA) servers. It supports both **RageMP** and **AltV** multiplayer platforms, allowing you to build and manage mods seamlessly across these environments.
+
+### Installation
+
+To get started, simply install the package:
+
+```bash
+npm install rock-mod
+```
+
+### Usage
+
+On the server-side, initialize Rock-Mod with the appropriate multiplayer type:
+
+```typescript
+const rockMod = await RockMod.create({
+  multiplayer: "RageMP", // or "AltV"
+});
+```
+
+Please note that client-side implementation is not yet available in this version.
+
+Rock-Mod simplifies multiplayer mod development by providing unified tools for managing game entities, networking, and more across different platforms.

package/dist/server/RockMod.d.ts

@@ -1,5 +1,6 @@
 import { INetManager } from "./net/common/INetManager";
-import { IBlipsManager, IObjectsManager, IPedsManager, IPlayersManager, IVehiclesManager } from "./entities";
+import { IBlipsManager, IColshapesManager, IMarkersManager, IObjectsManager, IPedsManager, IPlayersManager, IVehiclesManager } from "./entities";
+import { IUtilsManager } from "./utils";
 type MultiplayerType = "RageMP" | "AltV";
 export interface RockModOptions {
     multiplayer: MultiplayerType;
@@ -11,15 +12,21 @@ export declare class RockMod {
     private static _initManagersFactory;
     private readonly _net;
     private readonly _blips;
+    private readonly _colshapes;
+    private readonly _markers;
     private readonly _objects;
     private readonly _peds;
     private readonly _players;
+    private readonly _utils;
     private readonly _vehicles;
     get net(): INetManager;
     get blips(): IBlipsManager;
+    get colshapes(): IColshapesManager;
+    get markers(): IMarkersManager;
     get objects(): IObjectsManager;
     get peds(): IPedsManager;
     get players(): IPlayersManager;
+    get utils(): IUtilsManager;
     get vehicles(): IVehiclesManager;
     private constructor();
 }

package/dist/server/RockMod.js

@@ -55,9 +55,12 @@ class RockMod {
     }
     _net;
     _blips;
+    _colshapes;
+    _markers;
     _objects;
     _peds;
     _players;
+    _utils;
     _vehicles;
     get net() {
         return this._net;
@@ -65,6 +68,12 @@ class RockMod {
     get blips() {
         return this._blips;
     }
+    get colshapes() {
+        return this._colshapes;
+    }
+    get markers() {
+        return this._markers;
+    }
     get objects() {
         return this._objects;
     }
@@ -74,15 +83,21 @@ class RockMod {
     get players() {
         return this._players;
     }
+    get utils() {
+        return this._utils;
+    }
     get vehicles() {
         return this._vehicles;
     }
     constructor(managersFactory) {
         this._net = managersFactory.createNetManager();
         this._blips = managersFactory.createBlipsManager();
+        this._colshapes = managersFactory.createColshapesManager();
+        this._markers = managersFactory.createMarkersManager();
         this._objects = managersFactory.createObjectsManager();
         this._peds = managersFactory.createPedsManager();
-        this._players = managersFactory.createPlayersManager();
+        this._players = managersFactory.createPlayersManager(this._net);
+        this._utils = managersFactory.createUtilsManager();
         this._vehicles = managersFactory.createVehiclesManager();
     }
 }

package/dist/server/entities/altv/blip/AltVBlip.d.ts

@@ -3,13 +3,17 @@ import { IBlip, IBlipColor, IBlipSprite } from "../../common";
 export interface IAltVBlipOptions extends IAltVWorldObjectOptions<AltVServer.Blip> {
 }
 export declare class AltVBlip extends AltVWorldObject<AltVServer.Blip> implements IBlip {
-    get sprite(): IBlipSprite;
-    get alpha(): number;
     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: IAltVBlipOptions);
-    setSprite(value: IBlipSprite): void;
-    setAlpha(value: number): void;
     setName(value: string): void;
+    setSprite(value: IBlipSprite): void;
     setColor(value: IBlipColor): void;
+    setAlpha(value: number): void;
 }

package/dist/server/entities/altv/blip/AltVBlip.js

@@ -3,32 +3,45 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AltVBlip = void 0;
 const AltVWorldObject_1 = require("../worldObject/AltVWorldObject");
 class AltVBlip extends AltVWorldObject_1.AltVWorldObject {
+    get name() {
+        return this.mpEntity.name;
+    }
     get sprite() {
         return this.mpEntity.sprite;
     }
+    get color() {
+        return this.mpEntity.color;
+    }
     get alpha() {
         return this.mpEntity.alpha;
     }
-    get name() {
-        return this.mpEntity.name;
+    get scale() {
+        return this.mpEntity.scale;
     }
-    get color() {
-        return this.mpEntity.color;
+    get drawDistance() {
+        console.log("[RockMod] AltVBlip drawDistance is not implemented");
+        return 0;
     }
-    constructor(options) {
-        super(options);
+    get shortRange() {
+        return this.mpEntity.shortRange;
     }
-    setSprite(value) {
-        this.mpEntity.sprite = value;
+    get rotation() {
+        return this.mpEntity.heading;
     }
-    setAlpha(value) {
-        this.mpEntity.alpha = value;
+    constructor(options) {
+        super(options);
     }
     setName(value) {
         this.mpEntity.name = value;
     }
+    setSprite(value) {
+        this.mpEntity.sprite = value;
+    }
     setColor(value) {
         this.mpEntity.color = value;
     }
+    setAlpha(value) {
+        this.mpEntity.alpha = value;
+    }
 }
 exports.AltVBlip = AltVBlip;

package/dist/server/entities/altv/blip/AltVBlipsManager.js

@@ -12,11 +12,16 @@ class AltVBlipsManager extends AltVWorldObjectsManager_1.AltVWorldObjectsManager
         });
     }
     create(options) {
-        const { sprite, position, dimension, alpha } = options;
+        const { alpha, color, dimension, name, position, rotation, scale, shortRange, sprite } = options;
         const mpEntity = new PointBlip(new Vector3(position), true);
-        mpEntity.sprite = sprite;
+        mpEntity.alpha = alpha ?? 255;
+        mpEntity.color = color ?? 1;
         mpEntity.dimension = dimension;
-        mpEntity.alpha = alpha;
+        mpEntity.name = name ?? "";
+        mpEntity.heading = rotation ?? 0;
+        mpEntity.scale = scale ?? 1;
+        mpEntity.shortRange = shortRange ?? false;
+        mpEntity.sprite = sprite;
         const blip = new AltVBlip_1.AltVBlip({ mpEntity });
         this.registerBaseObject(blip);
         return blip;

package/dist/server/entities/altv/colshape/AltVCircleColshape.d.ts

@@ -0,0 +1,7 @@
+import { ICircleColshape } from "../../common";
+import { AltVColshape, IAltVColshapeOptions } from "./AltVColshape";
+export interface IAltVCircleColshapeOptions extends IAltVColshapeOptions {
+}
+export declare class AltVCircleColshape extends AltVColshape implements ICircleColshape {
+    constructor(options: IAltVCircleColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVCircleColshape.js

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

package/dist/server/entities/altv/colshape/AltVColshape.d.ts

@@ -0,0 +1,7 @@
+import { AltVWorldObject, IAltVWorldObjectOptions } from "../worldObject/AltVWorldObject";
+import Colshape = AltVServer.Colshape;
+export interface IAltVColshapeOptions extends IAltVWorldObjectOptions<Colshape> {
+}
+export declare abstract class AltVColshape extends AltVWorldObject<Colshape> {
+    protected constructor(options: IAltVColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVColshape.js

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

package/dist/server/entities/altv/colshape/AltVColshapesManager.d.ts

@@ -0,0 +1,26 @@
+import { ICircleColshapeCreateOptions, IColshapesManager, ICuboidColshapeCreateOptions, ICylinderColshapeCreateOptions, IRectangleColshapeCreateOptions, ISphereColshapeCreateOptions } from "../../common";
+import { AltVWorldObjectsManager } from "../worldObject/AltVWorldObjectsManager";
+import { AltVColshape } from "./AltVColshape";
+import { AltVCircleColshape } from "./AltVCircleColshape";
+import { AltVCuboidColshape } from "./AltVCuboidColshape";
+import { AltVCylinderColshape } from "./AltVCylinderColshape";
+import { AltVRectangleColshape } from "./AltVRectangleColshape";
+import { AltVSphereColshape } from "./AltVSphereColshape";
+export interface IAltVCircleColshapeCreateOptions extends ICircleColshapeCreateOptions {
+}
+export interface IAltVCuboidColshapeCreateOptions extends ICuboidColshapeCreateOptions {
+}
+export interface IAltVCylinderColshapeCreateOptions extends ICylinderColshapeCreateOptions {
+}
+export interface IAltVRectangleColshapeCreateOptions extends IRectangleColshapeCreateOptions {
+}
+export interface IAltVSphereColshapeCreateOptions extends ISphereColshapeCreateOptions {
+}
+export declare class AltVColshapesManager extends AltVWorldObjectsManager<AltVColshape> implements IColshapesManager {
+    constructor();
+    createCircle(options: IAltVCircleColshapeCreateOptions): AltVCircleColshape;
+    createCuboid(options: IAltVCuboidColshapeCreateOptions): AltVCuboidColshape;
+    createCylinder(options: IAltVCylinderColshapeCreateOptions): AltVCylinderColshape;
+    createRectangle(options: IAltVRectangleColshapeCreateOptions): AltVRectangleColshape;
+    createSphere(options: IAltVSphereColshapeCreateOptions): AltVSphereColshape;
+}

package/dist/server/entities/altv/colshape/AltVColshapesManager.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVColshapesManager = void 0;
+const AltVWorldObjectsManager_1 = require("../worldObject/AltVWorldObjectsManager");
+const AltVCircleColshape_1 = require("./AltVCircleColshape");
+const AltVCuboidColshape_1 = require("./AltVCuboidColshape");
+const AltVCylinderColshape_1 = require("./AltVCylinderColshape");
+const AltVRectangleColshape_1 = require("./AltVRectangleColshape");
+const AltVSphereColshape_1 = require("./AltVSphereColshape");
+var ColshapeCircle = AltVServer.ColshapeCircle;
+var ColshapeCuboid = AltVServer.ColshapeCuboid;
+var ColshapeCylinder = AltVServer.ColshapeCylinder;
+var ColshapeRectangle = AltVServer.ColshapeRectangle;
+var ColshapeSphere = AltVServer.ColshapeSphere;
+class AltVColshapesManager extends AltVWorldObjectsManager_1.AltVWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "colshape",
+        });
+    }
+    createCircle(options) {
+        const { range, position, dimension } = options;
+        const { x, y } = position;
+        const mpEntity = new ColshapeCircle(x, y, range);
+        mpEntity.dimension = dimension;
+        const colshape = new AltVCircleColshape_1.AltVCircleColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCuboid(options) {
+        const { width, depth, height, position, dimension } = options;
+        const { x, y, z } = position;
+        const mpEntity = new ColshapeCuboid(x, y, z, x + width, y + depth, z + height);
+        mpEntity.dimension = dimension;
+        const colshape = new AltVCuboidColshape_1.AltVCuboidColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCylinder(options) {
+        const { height, range, position, dimension } = options;
+        const { x, y, z } = position;
+        const mpEntity = new ColshapeCylinder(x, y, z, range, height);
+        mpEntity.dimension = dimension;
+        const colshape = new AltVCylinderColshape_1.AltVCylinderColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createRectangle(options) {
+        const { width, height, position, dimension } = options;
+        const { x, y } = position;
+        const mpEntity = new ColshapeRectangle(x, y, x + width, y + height);
+        mpEntity.dimension = dimension;
+        const colshape = new AltVRectangleColshape_1.AltVRectangleColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createSphere(options) {
+        const { range, position, dimension } = options;
+        const { x, y, z } = position;
+        const mpEntity = new ColshapeSphere(x, y, z, range);
+        mpEntity.dimension = dimension;
+        const colshape = new AltVSphereColshape_1.AltVSphereColshape({ mpEntity });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+}
+exports.AltVColshapesManager = AltVColshapesManager;

package/dist/server/entities/altv/colshape/AltVCuboidColshape.d.ts

@@ -0,0 +1,7 @@
+import { ICuboidColshape } from "../../common";
+import { AltVColshape, IAltVColshapeOptions } from "./AltVColshape";
+export interface IAltVCuboidColshapeOptions extends IAltVColshapeOptions {
+}
+export declare class AltVCuboidColshape extends AltVColshape implements ICuboidColshape {
+    constructor(options: IAltVCuboidColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVCuboidColshape.js

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

package/dist/server/entities/altv/colshape/AltVCylinderColshape.d.ts

@@ -0,0 +1,7 @@
+import { ICylinderColshape } from "../../common";
+import { AltVColshape, IAltVColshapeOptions } from "./AltVColshape";
+export interface IAltVCylinderColshapeOptions extends IAltVColshapeOptions {
+}
+export declare class AltVCylinderColshape extends AltVColshape implements ICylinderColshape {
+    constructor(options: IAltVCylinderColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVCylinderColshape.js

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

package/dist/server/entities/altv/colshape/AltVRectangleColshape.d.ts

@@ -0,0 +1,7 @@
+import { IRectangleColshape } from "../../common";
+import { AltVColshape, IAltVColshapeOptions } from "./AltVColshape";
+export interface IAltVRectangleColshapeOptions extends IAltVColshapeOptions {
+}
+export declare class AltVRectangleColshape extends AltVColshape implements IRectangleColshape {
+    constructor(options: IAltVRectangleColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVRectangleColshape.js

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

package/dist/server/entities/altv/colshape/AltVSphereColshape.d.ts

@@ -0,0 +1,7 @@
+import { ISphereColshape } from "../../common";
+import { AltVColshape, IAltVColshapeOptions } from "./AltVColshape";
+export interface IAltVSphereColshapeOptions extends IAltVColshapeOptions {
+}
+export declare class AltVSphereColshape extends AltVColshape implements ISphereColshape {
+    constructor(options: IAltVSphereColshapeOptions);
+}

package/dist/server/entities/altv/colshape/AltVSphereColshape.js

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

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVMarker = void 0;
+const AltVWorldObject_1 = require("../worldObject/AltVWorldObject");
+var Vector3 = AltVShared.Vector3;
+class AltVMarker extends AltVWorldObject_1.AltVWorldObject {
+    get visible() {
+        return this.mpEntity.visible;
+    }
+    get scale() {
+        return this.mpEntity.scale.z;
+    }
+    constructor(options) {
+        super(options);
+    }
+    setVisible(value) {
+        this.mpEntity.visible = value;
+    }
+    setScale(value) {
+        this.mpEntity.scale = new Vector3(0, 0, value);
+    }
+}
+exports.AltVMarker = AltVMarker;

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

@@ -0,0 +1,9 @@
+import { IMarkerCreateOptions, IMarkersManager } from "../../common";
+import { AltVWorldObjectsManager } from "../worldObject/AltVWorldObjectsManager";
+import { AltVMarker } from "./AltVMarker";
+export interface IAltVMarkerCreateOptions extends IMarkerCreateOptions {
+}
+export declare class AltVMarkersManager extends AltVWorldObjectsManager<AltVMarker> implements IMarkersManager {
+    constructor();
+    create(options: IAltVMarkerCreateOptions): AltVMarker;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVMarkersManager = void 0;
+const AltVWorldObjectsManager_1 = require("../worldObject/AltVWorldObjectsManager");
+const AltVMarker_1 = require("./AltVMarker");
+var alt = AltVServer;
+var Vector3 = AltVShared.Vector3;
+class AltVMarkersManager extends AltVWorldObjectsManager_1.AltVWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "marker",
+        });
+    }
+    create(options) {
+        const { type, scale, color, position, dimension, rotation } = options;
+        const mpEntity = new alt.Marker(type, new Vector3(position), color);
+        mpEntity.scale = new Vector3(scale, scale, scale);
+        mpEntity.dimension = dimension;
+        mpEntity.rot = new Vector3(rotation);
+        const marker = new AltVMarker_1.AltVMarker({ mpEntity });
+        this.registerBaseObject(marker);
+        return marker;
+    }
+}
+exports.AltVMarkersManager = AltVMarkersManager;

package/dist/server/entities/common/baseObject/IBaseObject.d.ts

@@ -1,6 +1,8 @@
 import BaseObject = AltVServer.BaseObject;
 export declare enum BaseObjectType {
     Blip = "blip",
+    Colshape = "colshape",
+    Marker = "marker",
     Object = "object",
     Ped = "ped",
     Player = "player",

package/dist/server/entities/common/baseObject/IBaseObject.js

@@ -4,6 +4,8 @@ exports.BaseObjectType = void 0;
 var BaseObjectType;
 (function (BaseObjectType) {
     BaseObjectType["Blip"] = "blip";
+    BaseObjectType["Colshape"] = "colshape";
+    BaseObjectType["Marker"] = "marker";
     BaseObjectType["Object"] = "object";
     BaseObjectType["Ped"] = "ped";
     BaseObjectType["Player"] = "player";

package/dist/server/entities/common/blip/IBlip.d.ts

@@ -800,12 +800,17 @@ export declare enum IBlipColor {
 export interface IBlipOptions extends IWorldObjectOptions {
 }
 export interface IBlip extends IWorldObject {
+    get name(): string;
     get sprite(): IBlipSprite;
+    get color(): number;
     get alpha(): number;
-    get name(): string;
-    get color(): IBlipColor;
-    setSprite(value: IBlipSprite): void;
-    setAlpha(value: number): void;
+    get scale(): number;
+    get drawDistance(): number;
+    get shortRange(): boolean;
+    get rotation(): number;
+    get dimension(): number;
     setName(value: string): void;
+    setSprite(value: IBlipSprite): void;
     setColor(value: IBlipColor): void;
+    setAlpha(value: number): void;
 }

package/dist/server/entities/common/blip/IBlipsManager.d.ts

@@ -1,8 +1,14 @@
 import { IWorldObjectCreateOptions, IWorldObjectsManager } from "../worldObject";
 import { IBlip } from "./IBlip";
 export interface IBlipCreateOptions extends IWorldObjectCreateOptions {
+    alpha?: number;
+    color?: number;
+    drawDistance?: number;
+    name?: string;
+    rotation?: number;
+    scale?: number;
+    shortRange?: boolean;
     sprite: number;
-    alpha: number;
 }
 export interface IBlipsManager extends IWorldObjectsManager<IBlip> {
     create(options: IBlipCreateOptions): IBlip;

package/dist/server/entities/common/colshape/ICircleColshape.d.ts

@@ -0,0 +1,5 @@
+import { IColshape, IColshapeOptions } from "./IColshape";
+export interface ICircleColshapeOptions extends IColshapeOptions {
+}
+export interface ICircleColshape extends IColshape {
+}

package/dist/server/entities/common/colshape/ICircleColshape.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/colshape/IColshape.d.ts

@@ -0,0 +1,5 @@
+import { IWorldObject, IWorldObjectOptions } from "../worldObject";
+export interface IColshapeOptions extends IWorldObjectOptions {
+}
+export interface IColshape extends IWorldObject {
+}

package/dist/server/entities/common/colshape/IColshape.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/colshape/IColshapesManager.d.ts

@@ -0,0 +1,35 @@
+import { IWorldObjectCreateOptions, IWorldObjectsManager } from "../worldObject";
+import { IColshape } from "./IColshape";
+import { IVector2D } from "../../../common/utils";
+import { ICircleColshape } from "./ICircleColshape";
+import { ICuboidColshape } from "./ICuboidColshape";
+import { ICylinderColshape } from "./ICylinderColshape";
+import { IRectangleColshape } from "./IRectangleColshape";
+import { ISphereColshape } from "./ISphereColshape";
+export interface ICircleColshapeCreateOptions extends Omit<IWorldObjectCreateOptions, "position"> {
+    position: IVector2D;
+    range: number;
+}
+export interface ICuboidColshapeCreateOptions extends IWorldObjectCreateOptions {
+    width: number;
+    depth: number;
+    height: number;
+}
+export interface ICylinderColshapeCreateOptions extends IWorldObjectCreateOptions {
+    range: number;
+    height: number;
+}
+export interface IRectangleColshapeCreateOptions extends IWorldObjectCreateOptions {
+    width: number;
+    height: number;
+}
+export interface ISphereColshapeCreateOptions extends IWorldObjectCreateOptions {
+    range: number;
+}
+export interface IColshapesManager extends IWorldObjectsManager<IColshape> {
+    createCircle(options: ICircleColshapeCreateOptions): ICircleColshape;
+    createCuboid(options: ICuboidColshapeCreateOptions): ICuboidColshape;
+    createCylinder(options: ICylinderColshapeCreateOptions): ICylinderColshape;
+    createRectangle(options: IRectangleColshapeCreateOptions): IRectangleColshape;
+    createSphere(options: ISphereColshapeCreateOptions): ISphereColshape;
+}

package/dist/server/entities/common/colshape/IColshapesManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/colshape/ICuboidColshape.d.ts

@@ -0,0 +1,5 @@
+import { IColshape, IColshapeOptions } from "./IColshape";
+export interface ICuboidColshapeOptions extends IColshapeOptions {
+}
+export interface ICuboidColshape extends IColshape {
+}