rock-mod 0.2.0 → 0.3.0

package/README.md

@@ -1,3 +1,25 @@
-# rock-mod
-
-Rock-Mod is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.
+# 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,6 +1,5 @@
 import { INetManager } from "./net/common/INetManager";
-import { IPlayersManager } from "./entities/common/player/IPlayersManager";
-import { IVehiclesManager } from "./entities/common/vehicle/IVehiclesManager";
+import { IBlipsManager, IObjectsManager, IPedsManager, IPlayersManager, IVehiclesManager } from "./entities";
 type MultiplayerType = "RageMP" | "AltV";
 export interface RockModOptions {
     multiplayer: MultiplayerType;
@@ -10,14 +9,18 @@ export declare class RockMod {
     static create(options: RockModOptions): Promise<RockMod>;
     static get instance(): RockMod;
     private static _initManagersFactory;
-    private readonly _managersFactory;
     private readonly _net;
-    private _players;
-    private _vehicles;
+    private readonly _blips;
+    private readonly _objects;
+    private readonly _peds;
+    private readonly _players;
+    private readonly _vehicles;
     get net(): INetManager;
+    get blips(): IBlipsManager;
+    get objects(): IObjectsManager;
+    get peds(): IPedsManager;
     get players(): IPlayersManager;
     get vehicles(): IVehiclesManager;
     private constructor();
-    init(): void;
 }
 export {};

package/dist/server/RockMod.js

@@ -53,13 +53,24 @@ class RockMod {
             }
         }
     }
-    _managersFactory;
     _net;
+    _blips;
+    _objects;
+    _peds;
     _players;
     _vehicles;
     get net() {
         return this._net;
     }
+    get blips() {
+        return this._blips;
+    }
+    get objects() {
+        return this._objects;
+    }
+    get peds() {
+        return this._peds;
+    }
     get players() {
         return this._players;
     }
@@ -67,13 +78,12 @@ class RockMod {
         return this._vehicles;
     }
     constructor(managersFactory) {
-        this._managersFactory = managersFactory;
         this._net = managersFactory.createNetManager();
-    }
-    init() {
-        console.log("RockMod init");
-        this._players = this._managersFactory.createPlayersManager();
-        this._vehicles = this._managersFactory.createVehiclesManager();
+        this._blips = managersFactory.createBlipsManager();
+        this._objects = managersFactory.createObjectsManager();
+        this._peds = managersFactory.createPedsManager();
+        this._players = managersFactory.createPlayersManager();
+        this._vehicles = managersFactory.createVehiclesManager();
     }
 }
 exports.RockMod = RockMod;

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

@@ -0,0 +1,15 @@
+import { AltVWorldObject, IAltVWorldObjectOptions } from "../worldObject/AltVWorldObject";
+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 color(): IBlipColor;
+    constructor(options: IAltVBlipOptions);
+    setSprite(value: IBlipSprite): void;
+    setAlpha(value: number): void;
+    setName(value: string): void;
+    setColor(value: IBlipColor): void;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVBlip = void 0;
+const AltVWorldObject_1 = require("../worldObject/AltVWorldObject");
+class AltVBlip extends AltVWorldObject_1.AltVWorldObject {
+    get sprite() {
+        return this.mpEntity.sprite;
+    }
+    get alpha() {
+        return this.mpEntity.alpha;
+    }
+    get name() {
+        return this.mpEntity.name;
+    }
+    get color() {
+        return this.mpEntity.color;
+    }
+    constructor(options) {
+        super(options);
+    }
+    setSprite(value) {
+        this.mpEntity.sprite = value;
+    }
+    setAlpha(value) {
+        this.mpEntity.alpha = value;
+    }
+    setName(value) {
+        this.mpEntity.name = value;
+    }
+    setColor(value) {
+        this.mpEntity.color = value;
+    }
+}
+exports.AltVBlip = AltVBlip;

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

@@ -0,0 +1,9 @@
+import { IBlipCreateOptions, IBlipsManager } from "../../common";
+import { AltVWorldObjectsManager } from "../worldObject/AltVWorldObjectsManager";
+import { AltVBlip } from "./AltVBlip";
+export interface IAltVBlipCreateOptions extends IBlipCreateOptions {
+}
+export declare class AltVBlipsManager extends AltVWorldObjectsManager<AltVBlip> implements IBlipsManager {
+    constructor();
+    create(options: IAltVBlipCreateOptions): AltVBlip;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVBlipsManager = void 0;
+const AltVWorldObjectsManager_1 = require("../worldObject/AltVWorldObjectsManager");
+const AltVBlip_1 = require("./AltVBlip");
+var PointBlip = AltVServer.PointBlip;
+var Vector3 = AltVShared.Vector3;
+class AltVBlipsManager extends AltVWorldObjectsManager_1.AltVWorldObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "blip",
+        });
+    }
+    create(options) {
+        const { sprite, position, dimension, alpha } = options;
+        const mpEntity = new PointBlip(new Vector3(position), true);
+        mpEntity.sprite = sprite;
+        mpEntity.dimension = dimension;
+        mpEntity.alpha = alpha;
+        const blip = new AltVBlip_1.AltVBlip({ mpEntity });
+        this.registerBaseObject(blip);
+        return blip;
+    }
+}
+exports.AltVBlipsManager = AltVBlipsManager;

package/dist/server/entities/altv/object/AltVObject.d.ts

@@ -0,0 +1,9 @@
+import { AltVEntity, IAltVEntityOptions } from "../entity/AltVEntity";
+import { IObject } from "../../common/object/IObject";
+export interface IAltVObjectOptions extends IAltVEntityOptions<AltVServer.Object> {
+}
+export declare class AltVObject extends AltVEntity<AltVServer.Object> implements IObject {
+    get alpha(): number;
+    constructor(options: IAltVObjectOptions);
+    setAlpha(value: number): void;
+}

package/dist/server/entities/altv/object/AltVObject.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVObject = void 0;
+const AltVEntity_1 = require("../entity/AltVEntity");
+class AltVObject extends AltVEntity_1.AltVEntity {
+    get alpha() {
+        return this.mpEntity.alpha;
+    }
+    constructor(options) {
+        super(options);
+    }
+    setAlpha(value) {
+        this.mpEntity.alpha = value;
+    }
+}
+exports.AltVObject = AltVObject;

package/dist/server/entities/altv/object/AltVObjectsManager.d.ts

@@ -0,0 +1,9 @@
+import { IObjectCreateOptions, IObjectsManager } from "../../common/object/IObjectsManager";
+import { AltVEntitiesManager } from "../entity/AltVEntitiesManager";
+import { AltVObject } from "./AltVObject";
+export interface IAltVObjectCreateOptions extends IObjectCreateOptions {
+}
+export declare class AltVObjectsManager extends AltVEntitiesManager<AltVObject> implements IObjectsManager {
+    constructor();
+    create(options: IAltVObjectCreateOptions): AltVObject;
+}

package/dist/server/entities/altv/object/AltVObjectsManager.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVObjectsManager = void 0;
+const AltVEntitiesManager_1 = require("../entity/AltVEntitiesManager");
+const AltVObject_1 = require("./AltVObject");
+var alt = AltVServer;
+class AltVObjectsManager extends AltVEntitiesManager_1.AltVEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "object",
+        });
+    }
+    create(options) {
+        const { model, position, dimension, rotation, alpha } = options;
+        const mpEntity = new alt.Object(model, position, rotation, alpha);
+        mpEntity.dimension = dimension;
+        const object = new AltVObject_1.AltVObject({ mpEntity });
+        this.registerBaseObject(object);
+        return object;
+    }
+}
+exports.AltVObjectsManager = AltVObjectsManager;

package/dist/server/entities/altv/ped/AltVPed.d.ts

@@ -0,0 +1,8 @@
+import { AltVEntity, IAltVEntityOptions } from "../entity/AltVEntity";
+import Ped = AltVServer.Ped;
+import { IPed } from "../../common";
+export interface IAltVPedOptions extends IAltVEntityOptions<Ped> {
+}
+export declare class AltVPed extends AltVEntity<Ped> implements IPed {
+    constructor(options: IAltVPedOptions);
+}

package/dist/server/entities/altv/ped/AltVPed.js

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

package/dist/server/entities/altv/ped/AltVPedsManager.d.ts

@@ -0,0 +1,9 @@
+import { IPedCreateOptions, IPedsManager } from "../../common";
+import { AltVEntitiesManager } from "../entity/AltVEntitiesManager";
+import { AltVPed } from "./AltVPed";
+export interface IAltVPedCreateOptions extends IPedCreateOptions {
+}
+export declare class AltVPedsManager extends AltVEntitiesManager<AltVPed> implements IPedsManager {
+    constructor();
+    create(options: IAltVPedCreateOptions): AltVPed;
+}

package/dist/server/entities/altv/ped/AltVPedsManager.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVPedsManager = void 0;
+const AltVEntitiesManager_1 = require("../entity/AltVEntitiesManager");
+const AltVPed_1 = require("./AltVPed");
+var alt = AltVServer;
+class AltVPedsManager extends AltVEntitiesManager_1.AltVEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "ped",
+        });
+    }
+    create(options) {
+        const { model, position, dimension, rotation } = options;
+        const mpEntity = new alt.Ped(model, position, rotation);
+        mpEntity.dimension = dimension;
+        const ped = new AltVPed_1.AltVPed({ mpEntity });
+        this.registerBaseObject(ped);
+        return ped;
+    }
+}
+exports.AltVPedsManager = AltVPedsManager;

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

@@ -1,5 +1,8 @@
 import BaseObject = AltVServer.BaseObject;
 export declare enum BaseObjectType {
+    Blip = "blip",
+    Object = "object",
+    Ped = "ped",
     Player = "player",
     Vehicle = "vehicle"
 }

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

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseObjectType = void 0;
 var BaseObjectType;
 (function (BaseObjectType) {
+    BaseObjectType["Blip"] = "blip";
+    BaseObjectType["Object"] = "object";
+    BaseObjectType["Ped"] = "ped";
     BaseObjectType["Player"] = "player";
     BaseObjectType["Vehicle"] = "vehicle";
 })(BaseObjectType || (exports.BaseObjectType = BaseObjectType = {}));