rock-mod 0.9.1 → 0.10.0

package/dist/server/entities/altv/colshape/AltVColshapesManager.d.ts

@@ -6,6 +6,7 @@ import { AltVCuboidColshape } from "./AltVCuboidColshape";
 import { AltVCylinderColshape } from "./AltVCylinderColshape";
 import { AltVRectangleColshape } from "./AltVRectangleColshape";
 import { AltVSphereColshape } from "./AltVSphereColshape";
+import { type AltVPlayer } from "../player/AltVPlayer";
 export interface IAltVCircleColshapeCreateOptions extends ICircleColshapeCreateOptions {
 }
 export interface IAltVCuboidColshapeCreateOptions extends ICuboidColshapeCreateOptions {
@@ -17,10 +18,12 @@ export interface IAltVRectangleColshapeCreateOptions extends IRectangleColshapeC
 export interface IAltVSphereColshapeCreateOptions extends ISphereColshapeCreateOptions {
 }
 export declare class AltVColshapesManager extends AltVWorldObjectsManager<AltVColshape> implements IColshapesManager {
+    private readonly _colshapesParticipants;
     constructor();
     createCircle(options: IAltVCircleColshapeCreateOptions): AltVCircleColshape;
     createCuboid(options: IAltVCuboidColshapeCreateOptions): AltVCuboidColshape;
     createCylinder(options: IAltVCylinderColshapeCreateOptions): AltVCylinderColshape;
     createRectangle(options: IAltVRectangleColshapeCreateOptions): AltVRectangleColshape;
     createSphere(options: IAltVSphereColshapeCreateOptions): AltVSphereColshape;
+    getParticipants(colshape: AltVColshape): Set<AltVPlayer>;
 }

package/dist/server/entities/altv/colshape/AltVColshapesManager.js

@@ -7,16 +7,38 @@ const AltVCuboidColshape_1 = require("./AltVCuboidColshape");
 const AltVCylinderColshape_1 = require("./AltVCylinderColshape");
 const AltVRectangleColshape_1 = require("./AltVRectangleColshape");
 const AltVSphereColshape_1 = require("./AltVSphereColshape");
+const RockMod_1 = require("../../../RockMod");
+const types_1 = require("../../../net/common/events/types");
 var ColshapeCircle = AltVServer.ColshapeCircle;
 var ColshapeCuboid = AltVServer.ColshapeCuboid;
 var ColshapeCylinder = AltVServer.ColshapeCylinder;
 var ColshapeRectangle = AltVServer.ColshapeRectangle;
 var ColshapeSphere = AltVServer.ColshapeSphere;
+var BaseObjectType = AltVShared.BaseObjectType;
 class AltVColshapesManager extends AltVWorldObjectsManager_1.AltVWorldObjectsManager {
+    _colshapesParticipants = new Map();
     constructor() {
         super({
             baseObjectsType: "colshape",
         });
+        AltVServer.on("entityEnterColshape", (mpColshape, mpEntity) => {
+            if (mpEntity.type === BaseObjectType.Player) {
+                const player = RockMod_1.RockMod.instance.players.getByID(mpEntity.id);
+                const colshape = this.getByID(mpColshape.id);
+                const participants = this.getParticipants(colshape);
+                participants.add(player);
+                RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.PlayerEnteredColshape, player, colshape);
+            }
+        });
+        AltVServer.on("entityLeaveColshape", (mpColshape, mpEntity) => {
+            if (mpEntity.type === BaseObjectType.Player) {
+                const player = RockMod_1.RockMod.instance.players.getByID(mpEntity.id);
+                const colshape = this.getByID(mpColshape.id);
+                const participants = this.getParticipants(colshape);
+                participants.delete(player);
+                RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.PlayerLeftColshape, player, colshape);
+            }
+        });
     }
     createCircle(options) {
         const { range, position, dimension } = options;
@@ -63,5 +85,13 @@ class AltVColshapesManager extends AltVWorldObjectsManager_1.AltVWorldObjectsMan
         this.registerBaseObject(colshape);
         return colshape;
     }
+    getParticipants(colshape) {
+        let participants = this._colshapesParticipants.get(colshape);
+        if (!participants) {
+            participants = new Set();
+            this._colshapesParticipants.set(colshape, participants);
+        }
+        return participants;
+    }
 }
 exports.AltVColshapesManager = AltVColshapesManager;

package/dist/server/entities/common/colshape/IColshapesManager.d.ts

@@ -6,6 +6,7 @@ import { type ICuboidColshape } from "./ICuboidColshape";
 import { type ICylinderColshape } from "./ICylinderColshape";
 import { type IRectangleColshape } from "./IRectangleColshape";
 import { type ISphereColshape } from "./ISphereColshape";
+import { type IPlayer } from "../player";
 export interface ICircleColshapeCreateOptions extends Omit<IWorldObjectCreateOptions, "position"> {
     position: IVector2D;
     range: number;
@@ -32,4 +33,5 @@ export interface IColshapesManager extends IWorldObjectsManager<IColshape> {
     createCylinder(options: ICylinderColshapeCreateOptions): ICylinderColshape;
     createRectangle(options: IRectangleColshapeCreateOptions): IRectangleColshape;
     createSphere(options: ISphereColshapeCreateOptions): ISphereColshape;
+    getParticipants(colshape: IColshape): Set<IPlayer>;
 }

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

@@ -6,6 +6,7 @@ import { MockCylinderColshape } from "./MockCylinderColshape";
 import { MockRectangleColshape } from "./MockRectangleColshape";
 import { MockSphereColshape } from "./MockSphereColshape";
 import { type MockColshape } from "./MockColshape";
+import { type MockPlayer } from "../player/MockPlayer";
 export interface IMockCircleColshapeCreateOptions extends ICircleColshapeCreateOptions {
 }
 export interface IMockCuboidColshapeCreateOptions extends ICuboidColshapeCreateOptions {
@@ -24,4 +25,5 @@ export declare class MockColshapesManager extends MockWorldObjectsManager<MockCo
     createCylinder(options: IMockCylinderColshapeCreateOptions): MockCylinderColshape;
     createRectangle(options: IMockRectangleColshapeCreateOptions): MockRectangleColshape;
     createSphere(options: IMockSphereColshapeCreateOptions): MockSphereColshape;
+    getParticipants(): Set<MockPlayer>;
 }

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

@@ -86,5 +86,8 @@ class MockColshapesManager extends MockWorldObjectsManager_1.MockWorldObjectsMan
         this.registerBaseObject(colshape);
         return colshape;
     }
+    getParticipants() {
+        return new Set();
+    }
 }
 exports.MockColshapesManager = MockColshapesManager;

package/dist/server/entities/ragemp/colshape/RageColshapesManager.d.ts

@@ -6,6 +6,7 @@ import { RageCuboidColshape } from "./RageCuboidColshape";
 import { RageCylinderColshape } from "./RageCylinderColshape";
 import { RageRectangleColshape } from "./RageRectangleColshape";
 import { RageSphereColshape } from "./RageSphereColshape";
+import { type RagePlayer } from "../player/RagePlayer";
 export interface IRageCircleColshapeCreateOptions extends ICircleColshapeCreateOptions {
 }
 export interface IRageCuboidColshapeCreateOptions extends ICuboidColshapeCreateOptions {
@@ -17,10 +18,12 @@ export interface IRageRectangleColshapeCreateOptions extends IRectangleColshapeC
 export interface IRageSphereColshapeCreateOptions extends ISphereColshapeCreateOptions {
 }
 export declare class RageColshapesManager extends RageWorldObjectsManager<RageColshape> implements IColshapesManager {
+    private readonly _colshapesParticipants;
     constructor();
     createCircle(options: IRageCircleColshapeCreateOptions): RageCircleColshape;
     createCuboid(options: IRageCuboidColshapeCreateOptions): RageCuboidColshape;
     createCylinder(options: IRageCylinderColshapeCreateOptions): RageCylinderColshape;
     createRectangle(options: IRageRectangleColshapeCreateOptions): RageRectangleColshape;
     createSphere(options: IRageSphereColshapeCreateOptions): RageSphereColshape;
+    getParticipants(colshape: RageColshape): Set<RagePlayer>;
 }

package/dist/server/entities/ragemp/colshape/RageColshapesManager.js

@@ -7,11 +7,28 @@ const RageCuboidColshape_1 = require("./RageCuboidColshape");
 const RageCylinderColshape_1 = require("./RageCylinderColshape");
 const RageRectangleColshape_1 = require("./RageRectangleColshape");
 const RageSphereColshape_1 = require("./RageSphereColshape");
+const RockMod_1 = require("../../../RockMod");
+const types_1 = require("../../../net/common/events/types");
 class RageColshapesManager extends RageWorldObjectsManager_1.RageWorldObjectsManager {
+    _colshapesParticipants = new Map();
     constructor() {
         super({
             baseObjectsType: "colshape",
         });
+        mp.events.add("playerEnterColshape", (mpPlayer, mpColshape) => {
+            const player = RockMod_1.RockMod.instance.players.getByID(mpPlayer.id);
+            const colshape = this.getByID(mpColshape.id);
+            const participants = this.getParticipants(colshape);
+            participants.add(player);
+            RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.PlayerEnteredColshape, player, colshape);
+        });
+        mp.events.add("playerExitColshape", (mpPlayer, mpColshape) => {
+            const player = RockMod_1.RockMod.instance.players.getByID(mpPlayer.id);
+            const colshape = this.getByID(mpColshape.id);
+            const participants = this.getParticipants(colshape);
+            participants.delete(player);
+            RockMod_1.RockMod.instance.net.events.emitInternal(types_1.ServerInternalEventName.PlayerLeftColshape, player, colshape);
+        });
     }
     createCircle(options) {
         const { range, position, dimension } = options;
@@ -58,5 +75,13 @@ class RageColshapesManager extends RageWorldObjectsManager_1.RageWorldObjectsMan
         this.registerBaseObject(colshape);
         return colshape;
     }
+    getParticipants(colshape) {
+        let participants = this._colshapesParticipants.get(colshape);
+        if (!participants) {
+            participants = new Set();
+            this._colshapesParticipants.set(colshape, participants);
+        }
+        return participants;
+    }
 }
 exports.RageColshapesManager = RageColshapesManager;

package/dist/server/net/common/events/types.d.ts

@@ -1,13 +1,17 @@
-import { type IBaseObject, type IPlayer } from "../../../entities";
+import { type IBaseObject, type IColshape, type IPlayer } from "../../../entities";
 export declare enum ServerInternalEventName {
     PlayerConnected = "rm::playerConnected",
     PlayerDisconnected = "rm::playerDisconnected",
+    PlayerEnteredColshape = "rm::playerEnteredColshape",
+    PlayerLeftColshape = "rm::playerLeftColshape",
     EntityCreated = "rm::entityCreated",
     EntityDestroyed = "rm::entityDestroyed"
 }
 export interface IServerInternalEvents {
     [ServerInternalEventName.PlayerConnected]: (player: IPlayer) => void;
     [ServerInternalEventName.PlayerDisconnected]: (player: IPlayer) => void;
+    [ServerInternalEventName.PlayerEnteredColshape]: (player: IPlayer, colshape: IColshape) => void;
+    [ServerInternalEventName.PlayerLeftColshape]: (player: IPlayer, colshape: IColshape) => void;
     [ServerInternalEventName.EntityCreated]: (object: IBaseObject) => void;
     [ServerInternalEventName.EntityDestroyed]: (object: IBaseObject) => void;
 }

package/dist/server/net/common/events/types.js

@@ -5,6 +5,8 @@ var ServerInternalEventName;
 (function (ServerInternalEventName) {
     ServerInternalEventName["PlayerConnected"] = "rm::playerConnected";
     ServerInternalEventName["PlayerDisconnected"] = "rm::playerDisconnected";
+    ServerInternalEventName["PlayerEnteredColshape"] = "rm::playerEnteredColshape";
+    ServerInternalEventName["PlayerLeftColshape"] = "rm::playerLeftColshape";
     ServerInternalEventName["EntityCreated"] = "rm::entityCreated";
     ServerInternalEventName["EntityDestroyed"] = "rm::entityDestroyed";
 })(ServerInternalEventName || (exports.ServerInternalEventName = ServerInternalEventName = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rock-mod",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Rock-Mod is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",