rock-mod 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Carter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# rock-mod
+
+Rock-Mod is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.

package/dist/client/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/server/RockMod.d.ts

@@ -0,0 +1,17 @@
+import { IPlayersManager } from "./entities/common/player/IPlayersManager";
+import { IVehiclesManager } from "./entities/common/vehicle/IVehiclesManager";
+type MultiplayerType = "RageMP" | "AltV";
+export interface RockModOptions {
+    multiplayer: MultiplayerType;
+}
+export declare class RockMod {
+    private readonly _options;
+    private readonly _players;
+    private readonly _vehicles;
+    get players(): IPlayersManager;
+    get vehicles(): IVehiclesManager;
+    constructor(options: RockModOptions);
+    init(): void;
+    private _initManagersFactory;
+}
+export {};

package/dist/server/RockMod.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RockMod = void 0;
+const AltVManagersFactory_1 = require("./entities/altv/AltVManagersFactory");
+const RageManagersFactory_1 = require("./entities/ragemp/RageManagersFactory");
+class RockMod {
+    _options;
+    _players;
+    _vehicles;
+    get players() {
+        return this._players;
+    }
+    get vehicles() {
+        return this._vehicles;
+    }
+    constructor(options) {
+        this._options = options;
+        const managersFactory = this._initManagersFactory();
+        this._players = managersFactory.createPlayersManager();
+        this._vehicles = managersFactory.createVehiclesManager();
+    }
+    init() {
+        console.log("RockMod init");
+    }
+    _initManagersFactory() {
+        const { multiplayer } = this._options;
+        switch (multiplayer) {
+            case "AltV": {
+                return new AltVManagersFactory_1.AltVManagersFactory();
+            }
+            case "RageMP": {
+                return new RageManagersFactory_1.RageManagersFactory();
+            }
+        }
+    }
+}
+exports.RockMod = RockMod;

package/dist/server/common/utils/math/Vectors.d.ts

@@ -0,0 +1,18 @@
+export declare class Vector2D {
+    private readonly _x;
+    private readonly _y;
+    get x(): number;
+    get y(): number;
+    constructor(x: number, y: number);
+    distanceTo(position: Vector2D): number;
+    squaredDistanceTo(position: Vector2D): number;
+    isInRange(position: Vector2D, range: number): boolean;
+}
+export declare class Vector3D extends Vector2D {
+    private readonly _z;
+    get z(): number;
+    constructor(x: number, y: number, z: number);
+    distanceTo(position: Vector3D): number;
+    squaredDistanceTo(position: Vector3D): number;
+    isInRange(position: Vector3D, range: number): boolean;
+}

package/dist/server/common/utils/math/Vectors.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector3D = exports.Vector2D = void 0;
+class Vector2D {
+    _x;
+    _y;
+    get x() {
+        return this._x;
+    }
+    get y() {
+        return this._y;
+    }
+    constructor(x, y) {
+        this._x = x;
+        this._y = y;
+    }
+    distanceTo(position) {
+        return Math.sqrt(this.squaredDistanceTo(position));
+    }
+    squaredDistanceTo(position) {
+        const { x, y } = position;
+        return (this.x - x) * (this.x - x) + (this.y - y) * (this.y - y);
+    }
+    isInRange(position, range) {
+        const squaredDistance = this.squaredDistanceTo(position);
+        return squaredDistance <= range * range;
+    }
+}
+exports.Vector2D = Vector2D;
+class Vector3D extends Vector2D {
+    _z;
+    get z() {
+        return this._z;
+    }
+    constructor(x, y, z) {
+        super(x, y);
+        this._z = z;
+    }
+    distanceTo(position) {
+        return Math.sqrt(this.squaredDistanceTo(position));
+    }
+    squaredDistanceTo(position) {
+        const { x, y, z } = position;
+        return (this.x - x) * (this.x - x) + (this.y - y) * (this.y - y) + (this.z - z) * (this.z - z);
+    }
+    isInRange(position, range) {
+        const squaredDistance = this.squaredDistanceTo(position);
+        return squaredDistance <= range * range;
+    }
+}
+exports.Vector3D = Vector3D;

package/dist/server/entities/altv/AltVManagersFactory.d.ts

@@ -0,0 +1,7 @@
+import { IManagersFactory } from "../common/IManagersFactory";
+import { AltVPlayersManager } from "./player/AltVPlayersManager";
+import { AltVVehiclesManager } from "./vehicle/AltVVehiclesManager";
+export declare class AltVManagersFactory implements IManagersFactory {
+    createPlayersManager(): AltVPlayersManager;
+    createVehiclesManager(): AltVVehiclesManager;
+}

package/dist/server/entities/altv/AltVManagersFactory.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVManagersFactory = void 0;
+const AltVPlayersManager_1 = require("./player/AltVPlayersManager");
+const AltVVehiclesManager_1 = require("./vehicle/AltVVehiclesManager");
+class AltVManagersFactory {
+    createPlayersManager() {
+        return new AltVPlayersManager_1.AltVPlayersManager();
+    }
+    createVehiclesManager() {
+        return new AltVVehiclesManager_1.AltVVehiclesManager();
+    }
+}
+exports.AltVManagersFactory = AltVManagersFactory;

package/dist/server/entities/altv/baseObject/AltVBaseObject.d.ts

@@ -0,0 +1,9 @@
+import { BaseObjectType, IBaseObject, IBaseObjectOptions } from "../../common/baseObject/IBaseObject";
+export declare abstract class AltVBaseObject implements IBaseObject {
+    private readonly _id;
+    private readonly _type;
+    get id(): number;
+    get type(): BaseObjectType;
+    protected constructor(options: IBaseObjectOptions);
+    destroy(): void;
+}

package/dist/server/entities/altv/baseObject/AltVBaseObject.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVBaseObject = void 0;
+class AltVBaseObject {
+    _id;
+    _type;
+    get id() {
+        return this._id;
+    }
+    get type() {
+        return this._type;
+    }
+    constructor(options) {
+        this._id = options.id;
+        this._type = options.type;
+    }
+    destroy() {
+        console.log("destroy");
+    }
+}
+exports.AltVBaseObject = AltVBaseObject;

package/dist/server/entities/altv/baseObject/AltVBaseObjectsIterator.d.ts

@@ -0,0 +1,7 @@
+import { AltVBaseObject } from "./AltVBaseObject";
+import { IBaseObjectsIterator } from "../../common/baseObject/IBaseObjectsIterator";
+export declare class AltVBaseObjectsIterator<T extends AltVBaseObject> implements IBaseObjectsIterator<T> {
+    private readonly _baseObjects;
+    constructor(baseObjects: ReadonlyMap<number, T>);
+    all(): IterableIterator<T>;
+}

package/dist/server/entities/altv/baseObject/AltVBaseObjectsIterator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVBaseObjectsIterator = void 0;
+class AltVBaseObjectsIterator {
+    _baseObjects;
+    constructor(baseObjects) {
+        this._baseObjects = baseObjects;
+    }
+    all() {
+        return this._baseObjects.values();
+    }
+}
+exports.AltVBaseObjectsIterator = AltVBaseObjectsIterator;

package/dist/server/entities/altv/baseObject/AltVBaseObjectsManager.d.ts

@@ -0,0 +1,13 @@
+import { IBaseObjectsManager, IBaseObjectsManagerOptions } from "../../common/baseObject/IBaseObjectsManager";
+import { AltVBaseObject } from "./AltVBaseObject";
+import { AltVBaseObjectsIterator } from "./AltVBaseObjectsIterator";
+export declare abstract class AltVBaseObjectsManager<T extends AltVBaseObject> implements IBaseObjectsManager<T> {
+    private readonly _baseObjects;
+    private readonly _baseObjectsType;
+    protected readonly _iterator: AltVBaseObjectsIterator<T>;
+    protected get baseObjects(): ReadonlyMap<number, T>;
+    get iterator(): AltVBaseObjectsIterator<T>;
+    protected constructor(options: IBaseObjectsManagerOptions);
+    getByID(id: number): T;
+    findByID(id: number): T | null;
+}

package/dist/server/entities/altv/baseObject/AltVBaseObjectsManager.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVBaseObjectsManager = void 0;
+const AltVBaseObjectsIterator_1 = require("./AltVBaseObjectsIterator");
+class AltVBaseObjectsManager {
+    _baseObjects;
+    _baseObjectsType;
+    _iterator;
+    get baseObjects() {
+        return this._baseObjects;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    constructor(options) {
+        this._baseObjects = new Map();
+        this._baseObjectsType = options.baseObjectsType;
+        this._iterator = new AltVBaseObjectsIterator_1.AltVBaseObjectsIterator(this._baseObjects);
+    }
+    getByID(id) {
+        const baseObject = this.findByID(id);
+        if (!baseObject) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${id} not found`);
+        }
+        return baseObject;
+    }
+    findByID(id) {
+        const baseObject = this._baseObjects.get(id);
+        return baseObject ?? null;
+    }
+}
+exports.AltVBaseObjectsManager = AltVBaseObjectsManager;

package/dist/server/entities/altv/entity/AltVEntitiesManager.d.ts

@@ -0,0 +1,5 @@
+import { IEntitiesManager } from "../../common/entity/IEntitiesManager";
+import { AltVEntity } from "./AltVEntity";
+import { AltVWorldObjectsManager } from "../worldObject/AltVWorldObjectsManager";
+export declare abstract class AltVEntitiesManager<T extends AltVEntity> extends AltVWorldObjectsManager<T> implements IEntitiesManager<T> {
+}

package/dist/server/entities/altv/entity/AltVEntitiesManager.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVEntitiesManager = void 0;
+const AltVWorldObjectsManager_1 = require("../worldObject/AltVWorldObjectsManager");
+class AltVEntitiesManager extends AltVWorldObjectsManager_1.AltVWorldObjectsManager {
+}
+exports.AltVEntitiesManager = AltVEntitiesManager;

package/dist/server/entities/altv/entity/AltVEntity.d.ts

@@ -0,0 +1,8 @@
+import { IEntity, IEntityOptions } from "../../common/entity/IEntity";
+import { AltVWorldObject } from "../worldObject/AltVWorldObject";
+export declare abstract class AltVEntity extends AltVWorldObject implements IEntity {
+    private _model;
+    get model(): string;
+    protected constructor(options: IEntityOptions);
+    setModel(value: string): void;
+}

package/dist/server/entities/altv/entity/AltVEntity.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVEntity = void 0;
+const AltVWorldObject_1 = require("../worldObject/AltVWorldObject");
+class AltVEntity extends AltVWorldObject_1.AltVWorldObject {
+    _model;
+    get model() {
+        return this._model;
+    }
+    constructor(options) {
+        super(options);
+        this._model = options.model;
+    }
+    setModel(value) {
+        this._model = value;
+    }
+}
+exports.AltVEntity = AltVEntity;

package/dist/server/entities/altv/player/AltVPlayer.d.ts

@@ -0,0 +1,13 @@
+import { AltVEntity } from "../entity/AltVEntity";
+import { IPlayer, IPlayerOptions } from "../../common/player/IPlayer";
+export declare class AltVPlayer extends AltVEntity implements IPlayer {
+    private _name;
+    private readonly _socialClub;
+    private _health;
+    get name(): string;
+    get socialClub(): string;
+    get health(): number;
+    constructor(options: IPlayerOptions);
+    setName(value: string): void;
+    setHealth(value: number): void;
+}

package/dist/server/entities/altv/player/AltVPlayer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVPlayer = void 0;
+const AltVEntity_1 = require("../entity/AltVEntity");
+class AltVPlayer extends AltVEntity_1.AltVEntity {
+    _name;
+    _socialClub;
+    _health;
+    get name() {
+        return this._name;
+    }
+    get socialClub() {
+        return this._socialClub;
+    }
+    get health() {
+        return this._health;
+    }
+    constructor(options) {
+        super(options);
+        this._name = options.name;
+        this._socialClub = options.socialClub;
+        this._health = 100;
+    }
+    setName(value) {
+        this._name = value;
+    }
+    setHealth(value) {
+        this._health = value;
+    }
+}
+exports.AltVPlayer = AltVPlayer;

package/dist/server/entities/altv/player/AltVPlayersManager.d.ts

@@ -0,0 +1,10 @@
+import { AltVEntitiesManager } from "../entity/AltVEntitiesManager";
+import { AltVPlayer } from "./AltVPlayer";
+import { IPlayersManager } from "../../common/player/IPlayersManager";
+export declare class AltVPlayersManager extends AltVEntitiesManager<AltVPlayer> implements IPlayersManager {
+    constructor();
+    getByName(name: string): AltVPlayer;
+    findByName(name: string): AltVPlayer | null;
+    getBySocialClub(socialClub: string): AltVPlayer;
+    findBySocialClub(socialClub: string): AltVPlayer | null;
+}

package/dist/server/entities/altv/player/AltVPlayersManager.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVPlayersManager = void 0;
+const AltVEntitiesManager_1 = require("../entity/AltVEntitiesManager");
+class AltVPlayersManager extends AltVEntitiesManager_1.AltVEntitiesManager {
+    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.findByName(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.AltVPlayersManager = AltVPlayersManager;

package/dist/server/entities/altv/vehicle/AltVVehicle.d.ts

@@ -0,0 +1,8 @@
+import { AltVEntity } from "../entity/AltVEntity";
+import { IVehicle, IVehicleOptions } from "../../common/vehicle/IVehicle";
+export declare class AltVVehicle extends AltVEntity implements IVehicle {
+    private _bodyHealth;
+    get bodyHealth(): number;
+    constructor(options: IVehicleOptions);
+    setBodyHealth(value: number): void;
+}

package/dist/server/entities/altv/vehicle/AltVVehicle.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVVehicle = void 0;
+const AltVEntity_1 = require("../entity/AltVEntity");
+class AltVVehicle extends AltVEntity_1.AltVEntity {
+    _bodyHealth;
+    get bodyHealth() {
+        return this._bodyHealth;
+    }
+    constructor(options) {
+        super(options);
+        this._bodyHealth = 100;
+    }
+    setBodyHealth(value) {
+        this._bodyHealth = value;
+    }
+}
+exports.AltVVehicle = AltVVehicle;

package/dist/server/entities/altv/vehicle/AltVVehiclesManager.d.ts

@@ -0,0 +1,6 @@
+import { AltVEntitiesManager } from "../entity/AltVEntitiesManager";
+import { AltVVehicle } from "./AltVVehicle";
+import { IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+export declare class AltVVehiclesManager extends AltVEntitiesManager<AltVVehicle> implements IVehiclesManager {
+    constructor();
+}

package/dist/server/entities/altv/vehicle/AltVVehiclesManager.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVVehiclesManager = void 0;
+const AltVEntitiesManager_1 = require("../entity/AltVEntitiesManager");
+class AltVVehiclesManager extends AltVEntitiesManager_1.AltVEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "vehicle",
+        });
+    }
+}
+exports.AltVVehiclesManager = AltVVehiclesManager;

package/dist/server/entities/altv/worldObject/AltVWorldObject.d.ts

@@ -0,0 +1,10 @@
+import { IWorldObject, IWorldObjectOptions } from "../../common/worldObject/IWorldObject";
+import { Vector3D } from "../../../common/utils/math/Vectors";
+import { AltVBaseObject } from "../baseObject/AltVBaseObject";
+export declare abstract class AltVWorldObject extends AltVBaseObject implements IWorldObject {
+    private readonly _position;
+    private readonly _dimension;
+    get position(): Vector3D;
+    get dimension(): number;
+    protected constructor(options: IWorldObjectOptions);
+}

package/dist/server/entities/altv/worldObject/AltVWorldObject.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVWorldObject = void 0;
+const AltVBaseObject_1 = require("../baseObject/AltVBaseObject");
+class AltVWorldObject extends AltVBaseObject_1.AltVBaseObject {
+    _position;
+    _dimension;
+    get position() {
+        return this._position;
+    }
+    get dimension() {
+        return this._dimension;
+    }
+    constructor(options) {
+        super(options);
+        this._position = options.position;
+        this._dimension = options.dimension;
+    }
+}
+exports.AltVWorldObject = AltVWorldObject;

package/dist/server/entities/altv/worldObject/AltVWorldObjectsIterator.d.ts

@@ -0,0 +1,10 @@
+import { IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { AltVWorldObject } from "./AltVWorldObject";
+import { AltVBaseObjectsIterator } from "../baseObject/AltVBaseObjectsIterator";
+import { Vector2D, Vector3D } from "../../../common/utils/math/Vectors";
+export declare class AltVWorldObjectsIterator<T extends AltVWorldObject> extends AltVBaseObjectsIterator<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/altv/worldObject/AltVWorldObjectsIterator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltVWorldObjectsIterator = void 0;
+const AltVBaseObjectsIterator_1 = require("../baseObject/AltVBaseObjectsIterator");
+class AltVWorldObjectsIterator extends AltVBaseObjectsIterator_1.AltVBaseObjectsIterator {
+    constructor(baseObjects) {
+        super(baseObjects);
+    }
+    *dimension(value) {
+        for (const worldObject of this.all()) {
+            if (worldObject.dimension === value) {
+                yield worldObject;
+            }
+        }
+    }
+    *range2D(center, range) {
+        for (const worldObject of this.all()) {
+            const { position } = worldObject;
+            const isInRange = center.isInRange(position, range);
+            if (isInRange) {
+                yield worldObject;
+            }
+        }
+    }
+    *range3D(center, range) {
+        for (const worldObject of this.all()) {
+            const { position } = worldObject;
+            const isInRange = center.isInRange(position, range);
+            if (isInRange) {
+                yield worldObject;
+            }
+        }
+    }
+}
+exports.AltVWorldObjectsIterator = AltVWorldObjectsIterator;

package/dist/server/entities/altv/worldObject/AltVWorldObjectsManager.d.ts

@@ -0,0 +1,9 @@
+import { IWorldObjectsManager, IWorldObjectsManagerOptions } from "../../common/worldObject/IWorldObjectsManager";
+import { AltVWorldObject } from "./AltVWorldObject";
+import { AltVBaseObjectsManager } from "../baseObject/AltVBaseObjectsManager";
+import { AltVWorldObjectsIterator } from "./AltVWorldObjectsIterator";
+export declare abstract class AltVWorldObjectsManager<T extends AltVWorldObject> extends AltVBaseObjectsManager<T> implements IWorldObjectsManager<T> {
+    protected readonly _iterator: AltVWorldObjectsIterator<T>;
+    get iterator(): AltVWorldObjectsIterator<T>;
+    protected constructor(options: IWorldObjectsManagerOptions);
+}

package/dist/server/entities/altv/worldObject/AltVWorldObjectsManager.js

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

package/dist/server/entities/common/IManagersFactory.d.ts

@@ -0,0 +1,6 @@
+import { IPlayersManager } from "./player/IPlayersManager";
+import { IVehiclesManager } from "./vehicle/IVehiclesManager";
+export interface IManagersFactory {
+    createPlayersManager(): IPlayersManager;
+    createVehiclesManager(): IVehiclesManager;
+}

package/dist/server/entities/common/IManagersFactory.js

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

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

@@ -0,0 +1,13 @@
+export declare enum BaseObjectType {
+    Player = "player",
+    Vehicle = "vehicle"
+}
+export interface IBaseObjectOptions {
+    id: number;
+    type: BaseObjectType;
+}
+export interface IBaseObject {
+    id: number;
+    type: BaseObjectType;
+    destroy(): void;
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseObjectType = void 0;
+var BaseObjectType;
+(function (BaseObjectType) {
+    BaseObjectType["Player"] = "player";
+    BaseObjectType["Vehicle"] = "vehicle";
+})(BaseObjectType || (exports.BaseObjectType = BaseObjectType = {}));

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

@@ -0,0 +1,4 @@
+import { IBaseObject } from "./IBaseObject";
+export interface IBaseObjectsIterator<T extends IBaseObject> {
+    all(): IterableIterator<T>;
+}

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

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

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

@@ -0,0 +1,10 @@
+import { BaseObjectType, IBaseObject } from "./IBaseObject";
+import { IBaseObjectsIterator } from "./IBaseObjectsIterator";
+export interface IBaseObjectsManagerOptions {
+    baseObjectsType: `${BaseObjectType}`;
+}
+export interface IBaseObjectsManager<T extends IBaseObject> {
+    get iterator(): IBaseObjectsIterator<T>;
+    getByID(id: number): T;
+    findByID(id: number): T | null;
+}