rock-mod 0.7.3 → 0.8.1

package/README.md

@@ -1,6 +1,6 @@
 # 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.
+**Rock-Mod** is a versatile and powerful framework designed for cross-platform mod development for Grand Theft Auto (GTA) servers. It supports **RageMP**, **AltV**, and **Mock** multiplayer platforms, allowing you to build and manage mods seamlessly across these environments.
 
 ### Installation
 
@@ -16,10 +16,101 @@ On the server-side, initialize Rock-Mod with the appropriate multiplayer type:
 
 ```typescript
 const rockMod = await RockMod.create({
-  multiplayer: "RageMP", // or "AltV"
+  multiplayer: "RageMP", // or "AltV", or "Mock"
 });
 ```
 
+### Multiplayer Types
+
+Rock-Mod supports three multiplayer types:
+
+1. **RageMP** - For developing mods for RageMP servers
+2. **AltV** - For developing mods for AltV servers
+3. **Mock** - For testing and development without multiplayer dependencies
+
+### Mock Mode
+
+Mock mode provides a complete mock environment for testing your mods without requiring a multiplayer server. It includes:
+
+- Full entity hierarchy (BaseObject, WorldObject, Entity)
+- All entity types (Blip, Colshape, Marker, Object, Ped, Player, Vehicle)
+- Type-safe events and RPC system
+- In-memory state management
+- Player connection simulation
+
+Example using Mock mode for development:
+
+```typescript
+import { RockMod } from "rock-mod";
+
+// Initialize in Mock mode
+const rockMod = await RockMod.create({
+  multiplayer: "Mock",
+});
+
+// Subscribe to events
+rockMod.net.events.on({
+  "rm::playerConnected": (player) => {
+    console.log(`Player ${player.name} connected`);
+  },
+  "rm::playerDisconnected": (player) => {
+    console.log(`Player ${player.name} disconnected`);
+  },
+});
+
+// Register RPC handlers
+rockMod.net.rpc.register("getPlayerInfo", (player) => {
+  return {
+    id: player.id,
+    name: player.name,
+    position: player.position,
+  };
+});
+```
+
+Example using Mock mode for testing:
+
+```typescript
+import { TestRockMod } from "rock-mod/testing";
+
+// Initialize test environment
+const rockMod = await TestRockMod.create({
+  multiplayer: "Mock",
+});
+
+// Simulate player connection
+const player = rockMod.simulatePlayerConnect({
+  name: "TestPlayer",
+  position: { x: 0, y: 0, z: 0 },
+  health: 100,
+});
+
+// Test your mod logic here
+// ...
+
+// Simulate player disconnection
+rockMod.simulatePlayerDisconnect(player);
+```
+
+### Features
+
+- **Cross-Platform Support**: Write once, run on any supported platform
+- **Type Safety**: Full TypeScript support with proper type definitions
+- **Entity Management**: Unified API for managing game entities
+- **Networking**: Type-safe events and RPC system
+- **Testing**: Dedicated testing API through `rock-mod/testing`
+- **Modular Design**: Easy to extend and customize
+
+### Documentation
+
 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.
+
+### Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+### License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

package/dist/server/RockMod.d.ts

@@ -1,7 +1,8 @@
 import { INetManager } from "./net/common/INetManager";
 import { IBlipsManager, IColshapesManager, IMarkersManager, IObjectsManager, IPedsManager, IPlayersManager, IVehiclesManager } from "./entities";
 import { IUtilsManager } from "./utils";
-type MultiplayerType = "RageMP" | "AltV";
+import { IManagersFactory } from "./factories/common/IManagersFactory";
+type MultiplayerType = "RageMP" | "AltV" | "Mock";
 export interface RockModOptions {
     multiplayer: MultiplayerType;
 }
@@ -28,6 +29,6 @@ export declare class RockMod {
     get players(): IPlayersManager;
     get utils(): IUtilsManager;
     get vehicles(): IVehiclesManager;
-    private constructor();
+    protected constructor(managersFactory: IManagersFactory);
 }
 export {};

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