rock-mod 0.7.3 → 0.8.1

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockPlayer = void 0;
+const MockEntity_1 = require("../entity/MockEntity");
+const RockMod_1 = require("../../../RockMod");
+class MockPlayer extends MockEntity_1.MockEntity {
+    _playerData;
+    get name() {
+        return this._playerData.name;
+    }
+    get socialClub() {
+        return this._playerData.socialClub;
+    }
+    get heading() {
+        return this._playerData.heading;
+    }
+    get health() {
+        return this._playerData.health;
+    }
+    get armour() {
+        return this._playerData.armour;
+    }
+    get isDead() {
+        return this.health <= 0;
+    }
+    get ip() {
+        return this._playerData.ip;
+    }
+    get serial() {
+        return this._playerData.serial;
+    }
+    get vehicle() {
+        return null;
+    }
+    get seat() {
+        return -1;
+    }
+    get weapon() {
+        return this._playerData.weapon;
+    }
+    get weaponAmmo() {
+        return this._playerData.weaponAmmo;
+    }
+    get eyeColor() {
+        return 0;
+    }
+    get streamedPlayers() {
+        return [];
+    }
+    constructor(options) {
+        super(options);
+        const { name = "Mock Player", socialClub = "mock_club", health = 100, heading = 0, armour = 0, weapon = 0, weaponAmmo = 0, ip = "127.0.0.1", serial = "mock_serial", } = options;
+        this._playerData = {
+            name,
+            socialClub,
+            health,
+            heading,
+            armour,
+            weapon,
+            weaponAmmo,
+            ip,
+            serial,
+        };
+    }
+    emitEvent(eventName, ...args) {
+        return RockMod_1.RockMod.instance.net.events.emitClient(this, eventName, ...args);
+    }
+    emitRPC(rpcName, ...args) {
+        return RockMod_1.RockMod.instance.net.rpc.emitClient(this, rpcName, ...args);
+    }
+    spawn(position) {
+        this.setPosition(position);
+        this._playerData.health = 100;
+    }
+    setName(name) {
+        this._playerData.name = name;
+    }
+    setHeading(value) {
+        this._playerData.heading = value;
+    }
+    setHealth(value) {
+        this._playerData.health = Math.clamp(value, 0, 100);
+    }
+    setArmour(value) {
+        this._playerData.armour = Math.clamp(value, 0, 100);
+    }
+    setWeaponAmmo(weapon, ammo) {
+        this._playerData.weapon = RockMod_1.RockMod.instance.utils.hash(weapon);
+        this._playerData.weaponAmmo = ammo;
+    }
+    giveWeapon(weapon, ammo) {
+        this.setWeaponAmmo(weapon, ammo);
+    }
+    removeWeapon(weapon) {
+        if (this._playerData.weapon === RockMod_1.RockMod.instance.utils.hash(weapon)) {
+            this._playerData.weapon = 0;
+            this._playerData.weaponAmmo = 0;
+        }
+    }
+    enableVoiceTo(player) {
+        throw new Error(`${player.name}: Not implemented: enableVoiceTo`);
+    }
+    disableVoiceTo(player) {
+        throw new Error(`${player.name}: Not implemented: disableVoiceTo`);
+    }
+    putIntoVehicle(vehicle, seat) {
+        throw new Error(`${this.name}: ${vehicle.id} ${seat} putIntoVehicle`);
+    }
+    ejectFromVehicle() {
+        throw new Error("Not implemented: ejectFromVehicle");
+    }
+    setCustomization() {
+        throw new Error("Not implemented: setCustomization");
+    }
+    setHeadOverlay() {
+        throw new Error("Not implemented: setHeadOverlay");
+    }
+    setEyeColor() {
+        throw new Error("Not implemented: setEyeColor");
+    }
+    setProp() {
+        throw new Error("Not implemented: setProp");
+    }
+    setClothes() {
+        throw new Error("Not implemented: setClothes");
+    }
+    setHairColor() {
+        throw new Error("Not implemented: setHairColor");
+    }
+    kick() {
+        throw new Error("Not implemented: kick");
+    }
+}
+exports.MockPlayer = MockPlayer;

package/dist/server/entities/mock/player/MockPlayersManager.d.ts

@@ -0,0 +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

@@ -0,0 +1,79 @@
+"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);
+        if (!player) {
+            throw new Error(`Player with name ${name} not found`);
+        }
+        return player;
+    }
+    findByName(name) {
+        for (const player of this.iterator.all()) {
+            if (player.name === name) {
+                return player;
+            }
+        }
+        return null;
+    }
+    getBySocialClub(socialClub) {
+        const player = this.findBySocialClub(socialClub);
+        if (!player) {
+            throw new Error(`Player with socialClub ${socialClub} not found`);
+        }
+        return player;
+    }
+    findBySocialClub(socialClub) {
+        for (const player of this.iterator.all()) {
+            if (player.socialClub === socialClub) {
+                return player;
+            }
+        }
+        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/mock/vehicle/MockVehicle.d.ts

@@ -0,0 +1,42 @@
+import { IVehicle } from "../../common/vehicle/IVehicle";
+import { MockEntity, IMockEntityOptions } from "../entity/MockEntity";
+import { RGBA } from "../../../common/utils";
+import { MockPlayer } from "../player/MockPlayer";
+export interface IMockVehicleOptions extends IMockEntityOptions {
+    engine?: boolean;
+    locked?: boolean;
+}
+export declare class MockVehicle extends MockEntity implements IVehicle {
+    private _bodyHealth;
+    private _engineHealth;
+    private _numberPlate;
+    private _isLocked;
+    private _isDead;
+    private _primaryColor;
+    private _secondaryColor;
+    private _customPrimaryColor;
+    private _customSecondaryColor;
+    private _passengers;
+    get bodyHealth(): number;
+    get engineHealth(): number;
+    get numberPlate(): string;
+    get isLocked(): boolean;
+    get isDead(): boolean;
+    get primaryColor(): number;
+    get secondaryColor(): number;
+    get customPrimaryColor(): RGBA;
+    get customSecondaryColor(): RGBA;
+    get driver(): MockPlayer | null;
+    get passengers(): Set<MockPlayer>;
+    constructor(options: IMockVehicleOptions);
+    setBodyHealth(value: number): void;
+    setEngineHealth(value: number): void;
+    setNumberPlate(value: string): void;
+    setLocked(value: boolean): void;
+    setPrimaryColor(value: number): void;
+    setSecondaryColor(value: number): void;
+    setCustomPrimaryColor(value: RGBA): void;
+    setCustomSecondaryColor(value: RGBA): void;
+    explode(): void;
+    repair(): void;
+}

package/dist/server/entities/mock/vehicle/MockVehicle.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockVehicle = void 0;
+const MockEntity_1 = require("../entity/MockEntity");
+const utils_1 = require("../../../common/utils");
+class MockVehicle extends MockEntity_1.MockEntity {
+    _bodyHealth;
+    _engineHealth;
+    _numberPlate;
+    _isLocked;
+    _isDead;
+    _primaryColor;
+    _secondaryColor;
+    _customPrimaryColor;
+    _customSecondaryColor;
+    _passengers;
+    get bodyHealth() {
+        return this._bodyHealth;
+    }
+    get engineHealth() {
+        return this._engineHealth;
+    }
+    get numberPlate() {
+        return this._numberPlate;
+    }
+    get isLocked() {
+        return this._isLocked;
+    }
+    get isDead() {
+        return this._isDead;
+    }
+    get primaryColor() {
+        return this._primaryColor;
+    }
+    get secondaryColor() {
+        return this._secondaryColor;
+    }
+    get customPrimaryColor() {
+        const { r, g, b, a = 255 } = this._customPrimaryColor;
+        return new utils_1.RGBA(r, g, b, a);
+    }
+    get customSecondaryColor() {
+        const { r, g, b, a } = this._customSecondaryColor;
+        return new utils_1.RGBA(r, g, b, a);
+    }
+    get driver() {
+        for (const passenger of this._passengers.values()) {
+            if (passenger.seat === 0) {
+                return passenger;
+            }
+        }
+        return null;
+    }
+    get passengers() {
+        return this._passengers;
+    }
+    constructor(options) {
+        super(options);
+        this._bodyHealth = 1000;
+        this._engineHealth = 1000;
+        this._numberPlate = "";
+        this._isLocked = options.locked ?? false;
+        this._isDead = false;
+        this._primaryColor = 0;
+        this._secondaryColor = 0;
+        this._customPrimaryColor = new utils_1.RGBA(0, 0, 0);
+        this._customSecondaryColor = new utils_1.RGBA(0, 0, 0);
+        this._passengers = new Set();
+    }
+    setBodyHealth(value) {
+        this._bodyHealth = value;
+    }
+    setEngineHealth(value) {
+        this._engineHealth = Math.clamp(value, 0, 1000);
+    }
+    setNumberPlate(value) {
+        this._numberPlate = value;
+    }
+    setLocked(value) {
+        this._isLocked = value;
+    }
+    setPrimaryColor(value) {
+        this._primaryColor = value;
+    }
+    setSecondaryColor(value) {
+        this._secondaryColor = value;
+    }
+    setCustomPrimaryColor(value) {
+        this._customPrimaryColor = value;
+    }
+    setCustomSecondaryColor(value) {
+        this._customSecondaryColor = value;
+    }
+    explode() {
+        this.setBodyHealth(0);
+        this.setEngineHealth(0);
+    }
+    repair() {
+        this.setBodyHealth(1000);
+        this.setEngineHealth(1000);
+    }
+}
+exports.MockVehicle = MockVehicle;

package/dist/server/entities/mock/vehicle/MockVehiclesManager.d.ts

@@ -0,0 +1,10 @@
+import { IVehicleCreateOptions, IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+import { MockEntitiesManager } from "../entity/MockEntitiesManager";
+import { MockVehicle } from "./MockVehicle";
+export interface IMockVehicleCreateOptions extends IVehicleCreateOptions {
+}
+export declare class MockVehiclesManager extends MockEntitiesManager<MockVehicle> implements IVehiclesManager {
+    private _nextId;
+    constructor();
+    create(options: IMockVehicleCreateOptions): MockVehicle;
+}

package/dist/server/entities/mock/vehicle/MockVehiclesManager.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockVehiclesManager = void 0;
+const MockEntitiesManager_1 = require("../entity/MockEntitiesManager");
+const MockVehicle_1 = require("./MockVehicle");
+const RockMod_1 = require("../../../RockMod");
+const common_1 = require("../../common");
+class MockVehiclesManager extends MockEntitiesManager_1.MockEntitiesManager {
+    _nextId;
+    constructor() {
+        super({
+            baseObjectsType: "vehicle",
+        });
+        this._nextId = 0;
+    }
+    create(options) {
+        const { model, engine, locked, position, dimension, rotation } = options;
+        const vehicle = new MockVehicle_1.MockVehicle({
+            id: this._nextId++,
+            type: common_1.BaseObjectType.Vehicle,
+            model: RockMod_1.RockMod.instance.utils.hash(model),
+            engine,
+            locked,
+            position,
+            dimension,
+            rotation,
+        });
+        this.registerBaseObject(vehicle);
+        return vehicle;
+    }
+}
+exports.MockVehiclesManager = MockVehiclesManager;

package/dist/server/entities/mock/worldObject/MockWorldObject.d.ts

@@ -0,0 +1,12 @@
+import { IWorldObject } from "../../common/worldObject/IWorldObject";
+import { MockBaseObject, IMockBaseObjectOptions } from "../baseObject/MockBaseObject";
+import { IVector3D } from "../../../common/utils/math/Vectors";
+export interface IMockWorldObjectOptions extends IMockBaseObjectOptions {
+    position: IVector3D;
+    dimension: number;
+}
+export declare abstract class MockWorldObject extends MockBaseObject implements IWorldObject {
+    protected constructor(options: IMockWorldObjectOptions);
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+}

package/dist/server/entities/mock/worldObject/MockWorldObject.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWorldObject = void 0;
+const MockBaseObject_1 = require("../baseObject/MockBaseObject");
+class MockWorldObject extends MockBaseObject_1.MockBaseObject {
+    constructor(options) {
+        super(options);
+    }
+    setPosition(value) {
+        this.position = value;
+    }
+    setDimension(value) {
+        this.dimension = value;
+    }
+}
+exports.MockWorldObject = MockWorldObject;

package/dist/server/entities/mock/worldObject/MockWorldObjectsIterator.d.ts

@@ -0,0 +1,10 @@
+import { IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { MockWorldObject } from "./MockWorldObject";
+import { MockBaseObjectsIterator } from "../baseObject/MockBaseObjectsIterator";
+import { Vector2D, Vector3D } from "../../../common/utils/math/Vectors";
+export declare class MockWorldObjectsIterator<T extends MockWorldObject> extends MockBaseObjectsIterator<T> implements IWorldObjectsIterator<T> {
+    constructor(baseObjects: ReadonlyMap<number, T>);
+    dimension(value: number): IterableIterator<T>;
+    range2D(center: Vector2D, range: number): IterableIterator<T>;
+    range3D(center: Vector3D, range: number): IterableIterator<T>;
+}

package/dist/server/entities/mock/worldObject/MockWorldObjectsIterator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWorldObjectsIterator = void 0;
+const MockBaseObjectsIterator_1 = require("../baseObject/MockBaseObjectsIterator");
+class MockWorldObjectsIterator extends MockBaseObjectsIterator_1.MockBaseObjectsIterator {
+    constructor(baseObjects) {
+        super(baseObjects);
+    }
+    *dimension(value) {
+        for (const worldObject of this.all()) {
+            if (worldObject.dimension === value) {
+                yield worldObject;
+            }
+        }
+    }
+    *range2D(center, range) {
+        const rangeSquared = range * range;
+        for (const worldObject of this.all()) {
+            const { position } = worldObject;
+            const distanceSquared = (center.x - position.x) * (center.x - position.x) + (center.y - position.y) * (center.y - position.y);
+            if (distanceSquared <= rangeSquared) {
+                yield worldObject;
+            }
+        }
+    }
+    *range3D(center, range) {
+        const rangeSquared = range * range;
+        for (const worldObject of this.all()) {
+            const { position } = worldObject;
+            const distanceSquared = (center.x - position.x) * (center.x - position.x) +
+                (center.y - position.y) * (center.y - position.y) +
+                (center.z - position.z) * (center.z - position.z);
+            if (distanceSquared <= rangeSquared) {
+                yield worldObject;
+            }
+        }
+    }
+}
+exports.MockWorldObjectsIterator = MockWorldObjectsIterator;

package/dist/server/entities/mock/worldObject/MockWorldObjectsManager.d.ts

@@ -0,0 +1,11 @@
+import { IWorldObjectsManager } from "../../common/worldObject/IWorldObjectsManager";
+import { MockWorldObject } from "./MockWorldObject";
+import { IMockBaseObjectsManagerOptions, MockBaseObjectsManager } from "../baseObject/MockBaseObjectsManager";
+import { MockWorldObjectsIterator } from "./MockWorldObjectsIterator";
+export interface IMockWorldObjectsManagerOptions extends IMockBaseObjectsManagerOptions {
+}
+export declare abstract class MockWorldObjectsManager<T extends MockWorldObject> extends MockBaseObjectsManager<T> implements IWorldObjectsManager<T> {
+    protected readonly _iterator: MockWorldObjectsIterator<T>;
+    protected constructor(options: IMockWorldObjectsManagerOptions);
+    get iterator(): MockWorldObjectsIterator<T>;
+}

package/dist/server/entities/mock/worldObject/MockWorldObjectsManager.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWorldObjectsManager = void 0;
+const MockBaseObjectsManager_1 = require("../baseObject/MockBaseObjectsManager");
+const MockWorldObjectsIterator_1 = require("./MockWorldObjectsIterator");
+class MockWorldObjectsManager extends MockBaseObjectsManager_1.MockBaseObjectsManager {
+    _iterator;
+    constructor(options) {
+        super(options);
+        this._iterator = new MockWorldObjectsIterator_1.MockWorldObjectsIterator(this.baseObjects);
+    }
+    get iterator() {
+        return this._iterator;
+    }
+}
+exports.MockWorldObjectsManager = MockWorldObjectsManager;

package/dist/server/entities/ragemp/marker/RageMarker.d.ts

@@ -1,11 +1,17 @@
-import { IMarker } from "../../common";
+import { IMarker, IMarkerType } from "../../common";
 import { IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
+import { IRGBA, IVector3D } from "../../../common/utils";
 export interface IRageMarkerOptions extends IRageWorldObjectOptions<MarkerMp> {
 }
 export declare class RageMarker extends RageWorldObject<MarkerMp> implements IMarker {
+    get markerType(): IMarkerType;
     get visible(): boolean;
     get scale(): number;
+    get color(): IRGBA;
+    get rotation(): IVector3D;
     constructor(options: IRageMarkerOptions);
     setVisible(value: boolean): void;
     setScale(value: number): void;
+    setColor(value: IRGBA): void;
+    setRotation(value: IVector3D): void;
 }

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

@@ -2,13 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RageMarker = void 0;
 const RageWorldObject_1 = require("../worldObject/RageWorldObject");
+const utils_1 = require("../../../common/utils");
 class RageMarker extends RageWorldObject_1.RageWorldObject {
+    get markerType() {
+        return this.mpEntity.model;
+    }
     get visible() {
         return this.mpEntity.visible;
     }
     get scale() {
         return this.mpEntity.scale;
     }
+    get color() {
+        const [r, g, b, a] = this.mpEntity.getColor();
+        return new utils_1.RGBA(r, g, b, a ?? 255);
+    }
+    get rotation() {
+        const { x, y, z } = this.mpEntity.rotation;
+        return new utils_1.Vector3D(x, y, z);
+    }
     constructor(options) {
         super(options);
     }
@@ -18,5 +30,12 @@ class RageMarker extends RageWorldObject_1.RageWorldObject {
     setScale(value) {
         this.mpEntity.scale = value;
     }
+    setColor(value) {
+        const { r, g, b, a } = value;
+        this.mpEntity.setColor(r, g, b, a ?? 255);
+    }
+    setRotation(value) {
+        this.mpEntity.rotation = new mp.Vector3(value);
+    }
 }
 exports.RageMarker = RageMarker;

package/dist/server/entities/ragemp/player/RagePlayer.d.ts

@@ -12,6 +12,7 @@ export declare class RagePlayer extends RageEntity<PlayerMp> implements IPlayer
     get heading(): number;
     get health(): number;
     get armour(): number;
+    get isDead(): boolean;
     get ip(): string;
     get serial(): string;
     get vehicle(): RageVehicle | null;

package/dist/server/entities/ragemp/player/RagePlayer.js

@@ -19,6 +19,9 @@ class RagePlayer extends RageEntity_1.RageEntity {
     get armour() {
         return this.mpEntity.armour;
     }
+    get isDead() {
+        return this.mpEntity.health <= 0;
+    }
     get ip() {
         return this.mpEntity.ip;
     }

package/dist/server/factories/mock/MockManagersFactory.d.ts

@@ -0,0 +1,21 @@
+import { IManagersFactory } from "../common/IManagersFactory";
+import { MockNetManager } from "../../net/mock/MockNetManager";
+import { MockPlayersManager } from "../../entities/mock/player/MockPlayersManager";
+import { IUtilsManager } from "../../utils";
+import { MockBlipsManager } from "../../entities/mock/blip/MockBlipsManager";
+import { MockColshapesManager } from "../../entities/mock/colshape/MockColshapesManager";
+import { MockMarkersManager } from "../../entities/mock/marker/MockMarkersManager";
+import { MockObjectsManager } from "../../entities/mock/object/MockObjectsManager";
+import { MockPedsManager } from "../../entities/mock/ped/MockPedsManager";
+import { MockVehiclesManager } from "../../entities/mock/vehicle/MockVehiclesManager";
+export declare class MockManagersFactory implements IManagersFactory {
+    createNetManager(): MockNetManager;
+    createBlipsManager(): MockBlipsManager;
+    createColshapesManager(): MockColshapesManager;
+    createMarkersManager(): MockMarkersManager;
+    createObjectsManager(): MockObjectsManager;
+    createPedsManager(): MockPedsManager;
+    createPlayersManager(): MockPlayersManager;
+    createUtilsManager(): IUtilsManager;
+    createVehiclesManager(): MockVehiclesManager;
+}