rock-mod 0.8.0 → 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,6 +1,7 @@
 import { INetManager } from "./net/common/INetManager";
 import { IBlipsManager, IColshapesManager, IMarkersManager, IObjectsManager, IPedsManager, IPlayersManager, IVehiclesManager } from "./entities";
 import { IUtilsManager } from "./utils";
+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/entities/mock/player/MockPlayersManager.d.ts

@@ -1,10 +1,26 @@
 import { IPlayersManager } from "../../common/player/IPlayersManager";
 import { MockPlayer } from "./MockPlayer";
 import { MockEntitiesManager } from "../entity/MockEntitiesManager";
+import { Vector3D } from "../../../common/utils/math/Vectors";
+export interface IMockPlayerConnectOptions {
+    id?: number;
+    name?: string;
+    socialClub?: string;
+    position?: Vector3D;
+    dimension?: number;
+    health?: number;
+    armour?: number;
+    ip?: string;
+    serial?: string;
+}
 export declare class MockPlayersManager extends MockEntitiesManager<MockPlayer> implements IPlayersManager {
+    private _nextId;
     constructor();
     getByName(name: string): MockPlayer;
     findByName(name: string): MockPlayer | null;
     getBySocialClub(socialClub: string): MockPlayer;
     findBySocialClub(socialClub: string): MockPlayer | null;
+    createPlayer(options?: IMockPlayerConnectOptions): MockPlayer;
+    simulateConnect(options?: IMockPlayerConnectOptions): MockPlayer;
+    simulateDisconnect(player: MockPlayer): void;
 }

package/dist/server/entities/mock/player/MockPlayersManager.js

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockPlayersManager = void 0;
+const MockPlayer_1 = require("./MockPlayer");
 const MockEntitiesManager_1 = require("../entity/MockEntitiesManager");
+const RockMod_1 = require("../../../RockMod");
+const common_1 = require("../../common");
+const Vectors_1 = require("../../../common/utils/math/Vectors");
 class MockPlayersManager extends MockEntitiesManager_1.MockEntitiesManager {
+    _nextId;
     constructor() {
         super({
             baseObjectsType: "player",
         });
+        this._nextId = 0;
     }
     getByName(name) {
         const player = this.findByName(name);
@@ -38,5 +44,36 @@ class MockPlayersManager extends MockEntitiesManager_1.MockEntitiesManager {
         }
         return null;
     }
+    createPlayer(options = {}) {
+        const { id = this._nextId++, name = `Player${id}`, socialClub = `Player${id}`, position = new Vectors_1.Vector3D(0, 0, 0), dimension = 0, health = 100, armour = 0, ip = "127.0.0.1", serial = `MOCK_${id}`, } = options;
+        const player = new MockPlayer_1.MockPlayer({
+            id,
+            type: common_1.BaseObjectType.Player,
+            name,
+            socialClub,
+            position,
+            dimension,
+            health,
+            armour,
+            ip,
+            serial,
+            model: 0,
+            rotation: new Vectors_1.Vector3D(0, 0, 0),
+        });
+        this.registerBaseObject(player);
+        return player;
+    }
+    simulateConnect(options = {}) {
+        const player = this.createPlayer(options);
+        RockMod_1.RockMod.instance.net.events.emit("rm::playerConnected", player);
+        return player;
+    }
+    simulateDisconnect(player) {
+        if (!this._baseObjects.has(player.id)) {
+            throw new Error(`Player with id ${player.id} not found`);
+        }
+        RockMod_1.RockMod.instance.net.events.emit("rm::playerDisconnected", player);
+        this.unregisterBaseObject(player);
+    }
 }
 exports.MockPlayersManager = MockPlayersManager;

package/dist/server/entities/ragemp/marker/RageMarker.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageMarker = void 0;
 const RageWorldObject_1 = require("../worldObject/RageWorldObject");
 const utils_1 = require("../../../common/utils");
-var RGBA = AltVShared.RGBA;
 class RageMarker extends RageWorldObject_1.RageWorldObject {
     get markerType() {
         return this.mpEntity.model;
@@ -16,7 +15,7 @@ class RageMarker extends RageWorldObject_1.RageWorldObject {
     }
     get color() {
         const [r, g, b, a] = this.mpEntity.getColor();
-        return new RGBA(r, g, b, a ?? 255);
+        return new utils_1.RGBA(r, g, b, a ?? 255);
     }
     get rotation() {
         const { x, y, z } = this.mpEntity.rotation;

package/dist/server/factories/mock/MockManagersFactory.js

@@ -9,6 +9,7 @@ const MockMarkersManager_1 = require("../../entities/mock/marker/MockMarkersMana
 const MockObjectsManager_1 = require("../../entities/mock/object/MockObjectsManager");
 const MockPedsManager_1 = require("../../entities/mock/ped/MockPedsManager");
 const MockVehiclesManager_1 = require("../../entities/mock/vehicle/MockVehiclesManager");
+const MockUtilsManager_1 = require("../../utils/mock/MockUtilsManager");
 class MockManagersFactory {
     createNetManager() {
         return new MockNetManager_1.MockNetManager();
@@ -32,7 +33,7 @@ class MockManagersFactory {
         return new MockPlayersManager_1.MockPlayersManager();
     }
     createUtilsManager() {
-        throw new Error("Utils manager not implemented in mock mode");
+        return new MockUtilsManager_1.MockUtilsManager();
     }
     createVehiclesManager() {
         return new MockVehiclesManager_1.MockVehiclesManager();

package/dist/server/index.d.ts

@@ -3,3 +3,4 @@ export * from "./common/utils";
 export { BaseObjectType, IBaseObject as IRockModBaseObject, IBlip as IRockModBlip, IColshape as IRockModColshape, IEntity as IRockModEntity, IMarker as IRockModMarker, IObject as IRockModObject, IPed as IRockModPed, IPlayer as IRockModPlayer, IVehicle as IRockModVehicle, IWorldObject as IRockModWorldObject, } from "./entities";
 export { INetServerEvents, INetClientEvents } from "./net/common/events/IEventsManager";
 export { INetServerRPC, INetClientRPC } from "./net/common/rpc/IRPCManager";
+export * from "./testing";

package/dist/server/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./RockMod"), exports);
 __exportStar(require("./common/utils"), exports);
 var entities_1 = require("./entities");
 Object.defineProperty(exports, "BaseObjectType", { enumerable: true, get: function () { return entities_1.BaseObjectType; } });
+__exportStar(require("./testing"), exports);

package/dist/server/testing.d.ts

@@ -0,0 +1,8 @@
+import { MockPlayer } from "entities/mock/player/MockPlayer";
+import { IMockPlayerConnectOptions } from "./entities/mock/player/MockPlayersManager";
+export declare class RockModTesting {
+    static simulatePlayerConnect(options?: IMockPlayerConnectOptions): MockPlayer;
+    static simulatePlayerDisconnect(player: MockPlayer): void;
+    static createMockPlayerNow(options?: IMockPlayerConnectOptions): MockPlayer;
+}
+export { IMockPlayerConnectOptions, type MockPlayer };

package/dist/server/testing.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RockModTesting = void 0;
+const RockMod_1 = require("./RockMod");
+class RockModTesting {
+    static simulatePlayerConnect(options) {
+        const manager = RockMod_1.RockMod.instance.players;
+        return manager.simulateConnect(options);
+    }
+    static simulatePlayerDisconnect(player) {
+        const manager = RockMod_1.RockMod.instance.players;
+        return manager.simulateDisconnect(player);
+    }
+    static createMockPlayerNow(options) {
+        const manager = RockMod_1.RockMod.instance.players;
+        return manager.createPlayer(options);
+    }
+}
+exports.RockModTesting = RockModTesting;

package/dist/server/utils/mock/MockUtilsManager.d.ts

@@ -0,0 +1,4 @@
+import { IUtilsManager } from "../common";
+export declare class MockUtilsManager implements IUtilsManager {
+    hash(value: string): number;
+}

package/dist/server/utils/mock/MockUtilsManager.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockUtilsManager = void 0;
+class MockUtilsManager {
+    hash(value) {
+        // Simple hash function for mock mode
+        let hash = 0;
+        for (let i = 0; i < value.length; i++) {
+            const char = value.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+        return hash;
+    }
+}
+exports.MockUtilsManager = MockUtilsManager;

package/package.json

@@ -1,9 +1,26 @@
 {
   "name": "rock-mod",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Rock-Mod is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "testing": [
+        "./dist/testing.d.ts"
+      ]
+    }
+  },
   "scripts": {
     "start": "npx tsx src/server/index.ts",
     "build": "npm run build:server && npm run build:client",
@@ -16,7 +33,7 @@
     "lint:check": "npm run lint:server:check && npm run lint:client:check",
     "lint:fix": "npm run lint:server:fix && npm run lint:client:fix",
     "format:check": "prettier --check .",
-    "format:fix": "prettier --write .",
+    "format:fix": "prettier --write . --log-level=silent",
     "type:server:check": "tsc --noEmit --project src/server/tsconfig.json",
     "type:client:check": "tsc --noEmit --project src/client/tsconfig.json",
     "type:check": "npm run type:server:check && npm run type:client:check",