rock-mod 0.7.3 → 0.8.1

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockColshapesManager = void 0;
+const MockWorldObjectsManager_1 = require("../worldObject/MockWorldObjectsManager");
+const Vectors_1 = require("../../../common/utils/math/Vectors");
+const MockCircleColshape_1 = require("./MockCircleColshape");
+const MockCuboidColshape_1 = require("./MockCuboidColshape");
+const MockCylinderColshape_1 = require("./MockCylinderColshape");
+const MockRectangleColshape_1 = require("./MockRectangleColshape");
+const MockSphereColshape_1 = require("./MockSphereColshape");
+const IBaseObject_1 = require("../../common/baseObject/IBaseObject");
+class MockColshapesManager extends MockWorldObjectsManager_1.MockWorldObjectsManager {
+    _nextId;
+    constructor() {
+        super({
+            baseObjectsType: IBaseObject_1.BaseObjectType.Colshape,
+        });
+        this._nextId = 0;
+    }
+    createCircle(options) {
+        const { range, position, dimension } = options;
+        const { x, y } = position;
+        const colshape = new MockCircleColshape_1.MockCircleColshape({
+            id: this._nextId++,
+            type: IBaseObject_1.BaseObjectType.Colshape,
+            range,
+            position: new Vectors_1.Vector3D(x, y, 0),
+            dimension,
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCuboid(options) {
+        const { width, depth, height, position, dimension } = options;
+        const { x, y, z } = position;
+        const colshape = new MockCuboidColshape_1.MockCuboidColshape({
+            id: this._nextId++,
+            type: IBaseObject_1.BaseObjectType.Colshape,
+            width,
+            depth,
+            height,
+            position: new Vectors_1.Vector3D(x, y, z),
+            dimension,
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createCylinder(options) {
+        const { height, range, position, dimension } = options;
+        const { x, y, z } = position;
+        const colshape = new MockCylinderColshape_1.MockCylinderColshape({
+            id: this._nextId++,
+            type: IBaseObject_1.BaseObjectType.Colshape,
+            range,
+            height,
+            position: new Vectors_1.Vector3D(x, y, z),
+            dimension,
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createRectangle(options) {
+        const { width, height, position, dimension } = options;
+        const { x, y } = position;
+        const colshape = new MockRectangleColshape_1.MockRectangleColshape({
+            id: this._nextId++,
+            type: IBaseObject_1.BaseObjectType.Colshape,
+            width,
+            height,
+            position: new Vectors_1.Vector3D(x, y, 0),
+            dimension,
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+    createSphere(options) {
+        const { range, position, dimension } = options;
+        const { x, y, z } = position;
+        const colshape = new MockSphereColshape_1.MockSphereColshape({
+            id: this._nextId++,
+            type: IBaseObject_1.BaseObjectType.Colshape,
+            range,
+            position: new Vectors_1.Vector3D(x, y, z),
+            dimension,
+        });
+        this.registerBaseObject(colshape);
+        return colshape;
+    }
+}
+exports.MockColshapesManager = MockColshapesManager;

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

@@ -0,0 +1,10 @@
+import { ICuboidColshape } from "../../common";
+import { IMockColshapeOptions, MockColshape } from "./MockColshape";
+export interface IMockCuboidColshapeCreateOptions extends IMockColshapeOptions {
+    width: number;
+    depth: number;
+    height: number;
+}
+export declare class MockCuboidColshape extends MockColshape implements ICuboidColshape {
+    constructor(options: IMockCuboidColshapeCreateOptions);
+}

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

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

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

@@ -0,0 +1,9 @@
+import { ICylinderColshape } from "../../common";
+import { IMockColshapeOptions, MockColshape } from "./MockColshape";
+export interface IMockCylinderColshapeCreateOptions extends IMockColshapeOptions {
+    height: number;
+    range: number;
+}
+export declare class MockCylinderColshape extends MockColshape implements ICylinderColshape {
+    constructor(options: IMockCylinderColshapeCreateOptions);
+}

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

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

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

@@ -0,0 +1,9 @@
+import { IRectangleColshape } from "../../common";
+import { IMockColshapeOptions, MockColshape } from "./MockColshape";
+export interface IMockRectangleColshapeCreateOptions extends IMockColshapeOptions {
+    width: number;
+    height: number;
+}
+export declare class MockRectangleColshape extends MockColshape implements IRectangleColshape {
+    constructor(options: IMockRectangleColshapeCreateOptions);
+}

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