rock-mod 0.7.3 → 0.8.0

package/dist/server/entities/mock/colshape/MockRectangleColshape.js

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

package/dist/server/entities/mock/colshape/MockSphereColshape.d.ts

@@ -0,0 +1,8 @@
+import { ISphereColshape } from "../../common";
+import { IMockColshapeOptions, MockColshape } from "./MockColshape";
+export interface IMockSphereColshapeCreateOptions extends IMockColshapeOptions {
+    range: number;
+}
+export declare class MockSphereColshape extends MockColshape implements ISphereColshape {
+    constructor(options: IMockSphereColshapeCreateOptions);
+}

package/dist/server/entities/mock/colshape/MockSphereColshape.js

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

package/dist/server/entities/mock/common/IMockEntity.d.ts

@@ -0,0 +1,18 @@
+import { Vector3D } from "../../../common/utils/math/Vectors";
+export interface IMockEntity {
+    id: number;
+    model: number;
+    position: Vector3D;
+    rotation: Vector3D;
+    dimension: number;
+    exists: boolean;
+    type: string;
+    name?: string;
+    socialClub?: string;
+    health?: number;
+    armour?: number;
+    weapon?: number;
+    weaponAmmo?: number;
+    ip?: string;
+    serial?: string;
+}

package/dist/server/entities/mock/common/IMockEntity.js

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

package/dist/server/entities/mock/entity/MockEntitiesManager.d.ts

@@ -0,0 +1,8 @@
+import { IEntitiesManager } from "../../common/entity/IEntitiesManager";
+import { MockEntity } from "./MockEntity";
+import { IMockWorldObjectsManagerOptions, MockWorldObjectsManager } from "../worldObject/MockWorldObjectsManager";
+export interface IMockEntitiesManagerOptions extends IMockWorldObjectsManagerOptions {
+}
+export declare abstract class MockEntitiesManager<T extends MockEntity> extends MockWorldObjectsManager<T> implements IEntitiesManager<T> {
+    protected constructor(options: IMockEntitiesManagerOptions);
+}

package/dist/server/entities/mock/entity/MockEntitiesManager.js

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

package/dist/server/entities/mock/entity/MockEntity.d.ts

@@ -0,0 +1,16 @@
+import { IEntity } from "../../common/entity/IEntity";
+import { MockWorldObject, IMockWorldObjectOptions } from "../worldObject/MockWorldObject";
+import { IVector3D, Vector3D } from "../../../common/utils";
+export interface IMockEntityOptions extends IMockWorldObjectOptions {
+    model: number;
+    rotation: IVector3D;
+}
+export declare abstract class MockEntity extends MockWorldObject implements IEntity {
+    private _model;
+    private _rotation;
+    get model(): number;
+    get rotation(): Vector3D;
+    protected constructor(options: IMockEntityOptions);
+    setModel(value: string): void;
+    setRotation(value: Vector3D): void;
+}

package/dist/server/entities/mock/entity/MockEntity.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockEntity = void 0;
+const MockWorldObject_1 = require("../worldObject/MockWorldObject");
+const utils_1 = require("../../../common/utils");
+const RockMod_1 = require("../../../RockMod");
+class MockEntity extends MockWorldObject_1.MockWorldObject {
+    _model;
+    _rotation;
+    get model() {
+        return this._model;
+    }
+    get rotation() {
+        const { x, y, z } = this._rotation;
+        return new utils_1.Vector3D(x, y, z);
+    }
+    constructor(options) {
+        super(options);
+        this._model = options.model;
+        this._rotation = options.rotation;
+    }
+    setModel(value) {
+        this._model = RockMod_1.RockMod.instance.utils.hash(value);
+    }
+    setRotation(value) {
+        this._rotation = value;
+    }
+}
+exports.MockEntity = MockEntity;

package/dist/server/entities/mock/marker/MockMarker.d.ts

@@ -0,0 +1,27 @@
+import { IMarker } from "../../common/marker/IMarker";
+import { MockWorldObject, IMockWorldObjectOptions } from "../worldObject/MockWorldObject";
+import { IRGBA, IVector3D } from "../../../common/utils";
+import { IMarkerType } from "../../common";
+export interface IMockMarkerOptions extends IMockWorldObjectOptions {
+    markerType?: IMarkerType;
+    scale?: number;
+    color?: IRGBA;
+    rotation?: IVector3D;
+}
+export declare class MockMarker extends MockWorldObject implements IMarker {
+    private _markerType;
+    private _visible;
+    private _scale;
+    private _color;
+    private _rotation;
+    get markerType(): IMarkerType;
+    get visible(): boolean;
+    get scale(): number;
+    get color(): IRGBA;
+    get rotation(): IVector3D;
+    constructor(options: IMockMarkerOptions);
+    setVisible(value: boolean): void;
+    setScale(scale: number): void;
+    setColor(color: IRGBA): void;
+    setRotation(value: IVector3D): void;
+}

package/dist/server/entities/mock/marker/MockMarker.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockMarker = void 0;
+const MockWorldObject_1 = require("../worldObject/MockWorldObject");
+const utils_1 = require("../../../common/utils");
+const common_1 = require("../../common");
+class MockMarker extends MockWorldObject_1.MockWorldObject {
+    _markerType;
+    _visible;
+    _scale;
+    _color;
+    _rotation;
+    get markerType() {
+        return this._markerType;
+    }
+    get visible() {
+        return this._visible;
+    }
+    get scale() {
+        return this._scale;
+    }
+    get color() {
+        return this._color;
+    }
+    get rotation() {
+        return this._rotation;
+    }
+    constructor(options) {
+        super(options);
+        const { markerType = common_1.IMarkerType.MarkerArrow, scale = 1, color = new utils_1.RGBA(255, 255, 255), rotation = new utils_1.Vector3D(0, 0, 0), } = options;
+        this._markerType = markerType;
+        this._visible = true;
+        this._scale = scale;
+        this._color = color;
+        this._rotation = rotation;
+    }
+    setVisible(value) {
+        this._visible = value;
+    }
+    setScale(scale) {
+        this._scale = scale;
+    }
+    setColor(color) {
+        this._color = color;
+    }
+    setRotation(value) {
+        this._rotation = value;
+    }
+}
+exports.MockMarker = MockMarker;

package/dist/server/entities/mock/marker/MockMarkersManager.d.ts

@@ -0,0 +1,10 @@
+import { IMarkerCreateOptions, IMarkersManager } from "../../common/marker/IMarkersManager";
+import { MockWorldObjectsManager } from "../worldObject/MockWorldObjectsManager";
+import { MockMarker } from "./MockMarker";
+export interface IMockMarkerCreateOptions extends IMarkerCreateOptions {
+}
+export declare class MockMarkersManager extends MockWorldObjectsManager<MockMarker> implements IMarkersManager {
+    private _nextId;
+    constructor();
+    create(options: IMockMarkerCreateOptions): MockMarker;
+}

package/dist/server/entities/mock/marker/MockMarkersManager.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockMarkersManager = void 0;
+const MockWorldObjectsManager_1 = require("../worldObject/MockWorldObjectsManager");
+const MockMarker_1 = require("./MockMarker");
+const common_1 = require("../../common");
+class MockMarkersManager extends MockWorldObjectsManager_1.MockWorldObjectsManager {
+    _nextId;
+    constructor() {
+        super({
+            baseObjectsType: "marker",
+        });
+        this._nextId = 0;
+    }
+    create(options) {
+        const { type, scale, color, position, dimension, rotation } = options;
+        const marker = new MockMarker_1.MockMarker({
+            id: this._nextId++,
+            type: common_1.BaseObjectType.Marker,
+            markerType: type,
+            scale,
+            color,
+            position,
+            dimension,
+            rotation,
+        });
+        this.registerBaseObject(marker);
+        return marker;
+    }
+}
+exports.MockMarkersManager = MockMarkersManager;

package/dist/server/entities/mock/object/MockObject.d.ts

@@ -0,0 +1,11 @@
+import { IObject } from "../../common/object/IObject";
+import { MockEntity, IMockEntityOptions } from "../entity/MockEntity";
+export interface IMockObjectOptions extends IMockEntityOptions {
+    alpha?: number;
+}
+export declare class MockObject extends MockEntity implements IObject {
+    private _alpha;
+    get alpha(): number;
+    constructor(options: IMockObjectOptions);
+    setAlpha(alpha: number): void;
+}

package/dist/server/entities/mock/object/MockObject.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockObject = void 0;
+const MockEntity_1 = require("../entity/MockEntity");
+class MockObject extends MockEntity_1.MockEntity {
+    _alpha;
+    get alpha() {
+        return this._alpha;
+    }
+    constructor(options) {
+        super(options);
+        const { alpha = 255 } = options;
+        this._alpha = alpha;
+    }
+    setAlpha(alpha) {
+        this._alpha = alpha;
+    }
+}
+exports.MockObject = MockObject;

package/dist/server/entities/mock/object/MockObjectsManager.d.ts

@@ -0,0 +1,10 @@
+import { IObjectCreateOptions, IObjectsManager } from "../../common/object/IObjectsManager";
+import { MockEntitiesManager } from "../entity/MockEntitiesManager";
+import { MockObject } from "./MockObject";
+export interface IMockObjectCreateOptions extends IObjectCreateOptions {
+}
+export declare class MockObjectsManager extends MockEntitiesManager<MockObject> implements IObjectsManager {
+    private _nextId;
+    constructor();
+    create(options: IMockObjectCreateOptions): MockObject;
+}

package/dist/server/entities/mock/object/MockObjectsManager.js

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

package/dist/server/entities/mock/ped/MockPed.d.ts

@@ -0,0 +1,7 @@
+import { IPed } from "../../common/ped/IPed";
+import { MockEntity, IMockEntityOptions } from "../entity/MockEntity";
+export interface IMockPedOptions extends IMockEntityOptions {
+}
+export declare class MockPed extends MockEntity implements IPed {
+    constructor(options: IMockPedOptions);
+}

package/dist/server/entities/mock/ped/MockPed.js

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

package/dist/server/entities/mock/ped/MockPedsManager.d.ts

@@ -0,0 +1,10 @@
+import { IPedCreateOptions, IPedsManager } from "../../common/ped/IPedsManager";
+import { MockEntitiesManager } from "../entity/MockEntitiesManager";
+import { MockPed } from "./MockPed";
+export interface IMockPedCreateOptions extends IPedCreateOptions {
+}
+export declare class MockPedsManager extends MockEntitiesManager<MockPed> implements IPedsManager {
+    private _nextId;
+    constructor();
+    create(options: IMockPedCreateOptions): MockPed;
+}

package/dist/server/entities/mock/ped/MockPedsManager.js

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

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

@@ -0,0 +1,56 @@
+import { IPlayer } from "../../common/player/IPlayer";
+import { MockEntity, IMockEntityOptions } from "../entity/MockEntity";
+import { Vector3D } from "../../../common/utils/math/Vectors";
+import { RageVehicle } from "../../ragemp/vehicle/RageVehicle";
+import { IMockClientEvents } from "../../../net/mock/events/MockEventsManager";
+import { IMockClientRPC } from "../../../net/mock/rpc/MockRPCManager";
+export interface IMockPlayerOptions extends IMockEntityOptions {
+    name?: string;
+    socialClub?: string;
+    health?: number;
+    heading?: number;
+    armour?: number;
+    weapon?: number;
+    weaponAmmo?: number;
+    ip?: string;
+    serial?: string;
+}
+export declare class MockPlayer extends MockEntity implements IPlayer {
+    private readonly _playerData;
+    get name(): string;
+    get socialClub(): string;
+    get heading(): number;
+    get health(): number;
+    get armour(): number;
+    get isDead(): boolean;
+    get ip(): string;
+    get serial(): string;
+    get vehicle(): null;
+    get seat(): number;
+    get weapon(): number;
+    get weaponAmmo(): number;
+    get eyeColor(): number;
+    get streamedPlayers(): MockPlayer[];
+    constructor(options: IMockPlayerOptions);
+    emitEvent<K extends keyof IMockClientEvents>(eventName: K, ...args: Parameters<IMockClientEvents[K]>): void;
+    emitRPC<K extends keyof IMockClientRPC>(rpcName: K, ...args: Parameters<IMockClientRPC[K]>): Promise<ReturnType<IMockClientRPC[K]>>;
+    spawn(position: Vector3D): void;
+    setName(name: string): void;
+    setHeading(value: number): void;
+    setHealth(value: number): void;
+    setArmour(value: number): void;
+    setWeaponAmmo(weapon: string, ammo: number): void;
+    giveWeapon(weapon: string, ammo: number): void;
+    removeWeapon(weapon: string): void;
+    enableVoiceTo(player: MockPlayer): void;
+    disableVoiceTo(player: MockPlayer): void;
+    putIntoVehicle(vehicle: RageVehicle, seat?: number): void;
+    ejectFromVehicle(): void;
+    setCustomization(): void;
+    setHeadOverlay(): void;
+    setEyeColor(): void;
+    setProp(): void;
+    setClothes(): void;
+    setHairColor(): void;
+    kick(): void;
+}

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,10 @@
+import { IPlayersManager } from "../../common/player/IPlayersManager";
+import { MockPlayer } from "./MockPlayer";
+import { MockEntitiesManager } from "../entity/MockEntitiesManager";
+export declare class MockPlayersManager extends MockEntitiesManager<MockPlayer> implements IPlayersManager {
+    constructor();
+    getByName(name: string): MockPlayer;
+    findByName(name: string): MockPlayer | null;
+    getBySocialClub(socialClub: string): MockPlayer;
+    findBySocialClub(socialClub: string): MockPlayer | null;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockPlayersManager = void 0;
+const MockEntitiesManager_1 = require("../entity/MockEntitiesManager");
+class MockPlayersManager extends MockEntitiesManager_1.MockEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "player",
+        });
+    }
+    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;
+    }
+}
+exports.MockPlayersManager = MockPlayersManager;