rock-mod 0.18.0 → 0.20.0

package/dist/client/entities/common/entity/IEntity.d.ts

@@ -1,3 +1,4 @@
+import { type IBaseObject } from "../baseObject";
 import { type IWorldObject, type IWorldObjectOptions } from "../worldObject/IWorldObject";
 import { type IVector3D } from "../../../../shared/common/utils";
 export interface IEntityOptions extends IWorldObjectOptions {
@@ -21,4 +22,8 @@ export interface IEntity extends IWorldObject {
     getBoneIndexByName(boneName: string): number;
     getWorldPositionOfBone(boneIndex: number): IVector3D;
     getVariable(name: string): unknown | null;
+    attachToEntity(target: IBaseObject, boneIndex: number, offset: IVector3D, rotation: IVector3D, p9: boolean, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean): void;
+    detach(useDetachVelocity: boolean, collision: boolean): void;
+    getSpeed(): number;
+    isPlayingAnim(dictionary: string, name: string, taskFlag: number): boolean;
 }

package/dist/client/entities/common/object/IObject.d.ts

@@ -4,5 +4,4 @@ export interface IObjectOptions extends IEntityOptions {
 export interface IObject extends IEntity {
     attachTo(entity: Handle, boneIndex: number, xPos: number, yPos: number, zPos: number, xRot: number, yRot: number, zRot: number, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean): void;
     isAttachedTo(entity: number): boolean;
-    detach(applyVelocy: boolean, collision: boolean): void;
 }

package/dist/client/entities/common/ped/IPed.d.ts

@@ -16,4 +16,9 @@ export interface IPed extends IEntity {
     setPropertyVariation(componentId: number, drawableId: number, textureId: number, attach: boolean): void;
     clearProp(componentId: number): void;
     getBoneCoords(boneId: number, offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    clearTasks(): void;
+    taskPlayAnim(dictionary: string, name: string, blendInSpeed: number, blendOutSpeed: number, duration: number, flag: number, playbackRate: number): void;
+    taskGoToCoordAnyMeans(x: number, y: number, z: number, speed: number, walkingStyle?: number, drivingFlags?: number): void;
+    stopAnim(dictionary: string, name: string, blendOutSpeed: number): void;
+    setBlockingOfNonTemporaryEvents(blocking: boolean): void;
 }

package/dist/client/entities/common/player/IPlayer.d.ts

@@ -35,8 +35,11 @@ export interface IPlayer extends IEntity {
     taskSwapWeapon(): void;
     taskEnterVehicle(vehicleHandle: number, timeout: number, seat: number, speed: number, flag: number, p6: number): void;
     clearTasks(): void;
+    clearTasksImmediately(): void;
     taskPlayAnim(dictionary: string, name: string, blendInSpeed: number, blendOutSpeed: number, duration: number, flag: number, playbackRate: number, lockX: boolean, lockY: boolean, lockZ: boolean): void;
+    stopAnim(dictionary: string, name: string, blendOutSpeed: number): void;
     setMovementClipset(clipset: string, speed: number): void;
     resetMovementClipset(blendDuration: number): void;
     getBoneCoords(boneId: number, offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    setNoCollision(otherHandle: number, thisFrameOnly: boolean): void;
 }

package/dist/client/entities/common/player/IPlayersManager.d.ts

@@ -3,6 +3,8 @@ import { type IPlayer } from "./IPlayer";
 export interface IPlayersManager extends IEntitiesManager<IPlayer> {
     getByName(name: string): IPlayer;
     findByName(name: string): IPlayer | null;
+    findByRemoteId(remoteId: number): IPlayer | null;
+    getByRemoteId(remoteId: number): IPlayer;
     findLocalPlayer(): IPlayer | null;
     getLocalPlayer(): IPlayer;
 }

package/dist/client/entities/common/vehicle/IVehicle.d.ts

@@ -42,4 +42,21 @@ export interface IVehicle extends IEntity {
     get numberPlateTextIndex(): number;
     setDoorOpen(doorIndex: number, loose: boolean, openInstantly: boolean): void;
     setDoorShut(doorIndex: number, instantly: boolean): void;
+    setHandling(field: string, value: number): void;
+    getHandling(field: string): number;
+    setEnginePowerMultiplier(value: number): void;
+    setEngineTorqueMultiplier(value: number): void;
+    modifyTopSpeed(value: number): void;
+    setCheatPowerIncrease(value: number): void;
+    toggleMod(modType: number, toggle: boolean): void;
+    setTyreSmokeColor(r: number, g: number, b: number): void;
+    setModColor1(paintType: number, color: number, p3: number): void;
+    setExtraColours(pearlescentColor: number, wheelColor: number): void;
+    setHeadlightColor(colorIndex: number): void;
+    setDashboardColor(colorIndex: number): void;
+    setInteriorColor(colorIndex: number): void;
+    getMaxBraking(): number;
+    getAcceleration(): number;
+    getMaxTraction(): number;
+    getModelMaxSpeed(): number;
 }

package/dist/client/entities/ragemp/entity/RageEntity.d.ts

@@ -1,3 +1,4 @@
+import { type IBaseObject } from "../../common/baseObject";
 import { type IEntity } from "../../common/entity/IEntity";
 import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
 import { type IVector3D, Vector3D } from "../../../../shared/common/utils";
@@ -23,4 +24,8 @@ export declare abstract class RageEntity<T extends EntityMp> extends RageWorldOb
     getBoneIndexByName(boneName: string): number;
     getWorldPositionOfBone(boneIndex: number): IVector3D;
     getVariable(name: string): unknown | null;
+    attachToEntity(target: IBaseObject, boneIndex: number, offset: IVector3D, rotation: IVector3D, p9: boolean, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean): void;
+    detach(useDetachVelocity: boolean, collision: boolean): void;
+    getSpeed(): number;
+    isPlayingAnim(dictionary: string, name: string, taskFlag: number): boolean;
 }

package/dist/client/entities/ragemp/entity/RageEntity.js

@@ -28,10 +28,13 @@ export class RageEntity extends RageWorldObject {
         return new Vector3D(vector.x, vector.y, vector.z);
     }
     freezePosition(freeze) {
-        this.mpEntity.freezePosition(freeze);
+        // FREEZE_ENTITY_POSITION via raw native: the RAGEMP wrapper does not consistently
+        // toggle the engine-level freeze for client-spawned entities, leaving them frozen.
+        mp.game.invoke("0x428CA6DBD1094446", this.handle, freeze);
     }
     setCollision(collision, keepPhysics) {
-        this.mpEntity.setCollision(collision, keepPhysics);
+        // SET_ENTITY_COLLISION via raw native for the same reason as freezePosition above.
+        mp.game.invoke("0x1A9205C1B9EE827F", this.handle, collision, keepPhysics);
     }
     setInvincible(invincible) {
         this.mpEntity.setInvincible(invincible);
@@ -62,4 +65,16 @@ export class RageEntity extends RageWorldObject {
     getVariable(name) {
         return this.mpEntity.getVariable(name);
     }
+    attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
+        mp.game.entity.attachToEntity(this.handle, target.handle, boneIndex, offset.x, offset.y, offset.z, rotation.x, rotation.y, rotation.z, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot);
+    }
+    detach(useDetachVelocity, collision) {
+        mp.game.entity.detach(this.handle, useDetachVelocity, collision);
+    }
+    getSpeed() {
+        return mp.game.entity.getSpeed(this.handle);
+    }
+    isPlayingAnim(dictionary, name, taskFlag) {
+        return mp.game.entity.isPlayingAnim(this.handle, dictionary, name, taskFlag);
+    }
 }

package/dist/client/entities/ragemp/object/RageObject.d.ts

@@ -6,5 +6,4 @@ export declare class RageObject extends RageEntity<ObjectMp> implements IObject
     constructor(options: IRageObjectOptions);
     attachTo(entity: Handle, boneIndex: number, xPos: number, yPos: number, zPos: number, xRot: number, yRot: number, zRot: number, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean): void;
     isAttachedTo(entity: number): boolean;
-    detach(applyVelocy: boolean, collision: boolean): void;
 }

package/dist/client/entities/ragemp/object/RageObject.js

@@ -9,7 +9,4 @@ export class RageObject extends RageEntity {
     isAttachedTo(entity) {
         return this.mpEntity.isAttachedTo(entity);
     }
-    detach(applyVelocy, collision) {
-        this.mpEntity.detach(applyVelocy, collision);
-    }
 }

package/dist/client/entities/ragemp/ped/RagePed.d.ts

@@ -18,4 +18,9 @@ export declare class RagePed extends RageEntity<PedMp> implements IPed {
     setPropertyVariation(componentId: number, drawableId: number, textureId: number, attach: boolean): void;
     clearProp(componentId: number): void;
     getBoneCoords(boneId: number, offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    clearTasks(): void;
+    taskPlayAnim(dictionary: string, name: string, blendInSpeed: number, blendOutSpeed: number, duration: number, flag: number, playbackRate: number): void;
+    stopAnim(dictionary: string, name: string, blendOutSpeed: number): void;
+    taskGoToCoordAnyMeans(x: number, y: number, z: number, speed: number, walkingStyle?: number, drivingFlags?: number): void;
+    setBlockingOfNonTemporaryEvents(blocking: boolean): void;
 }

package/dist/client/entities/ragemp/ped/RagePed.js

@@ -49,4 +49,20 @@ export class RagePed extends RageEntity {
         const { x, y, z } = this.mpEntity.getBoneCoords(boneId, offsetX, offsetY, offsetZ);
         return new Vector3D(x, y, z);
     }
+    clearTasks() {
+        this.mpEntity.clearTasks();
+    }
+    taskPlayAnim(dictionary, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate) {
+        this.mpEntity.taskPlayAnim(dictionary, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate, false, false, false);
+    }
+    stopAnim(dictionary, name, blendOutSpeed) {
+        mp.game.task.stopAnimTask(this.handle, dictionary, name, blendOutSpeed);
+    }
+    taskGoToCoordAnyMeans(x, y, z, speed, walkingStyle = 786603, drivingFlags = 0xbf800000) {
+        mp.game.task.goToCoordAnyMeans(this.handle, x, y, z, speed, 0, false, walkingStyle, drivingFlags);
+    }
+    setBlockingOfNonTemporaryEvents(blocking) {
+        // BLOCKING_OF_NON_TEMPORARY_EVENTS — no RAGEMP wrapper, invoke native by hash
+        mp.game.invoke("0x9F8AA94D6D97DBF4", this.handle, blocking);
+    }
 }

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

@@ -35,11 +35,14 @@ export declare class RagePlayer extends RageEntity<PlayerMp> implements IPlayer
     clearProp(componentId: number): void;
     get isLocalPlayer(): boolean;
     clearTasks(): void;
+    clearTasksImmediately(): void;
+    stopAnim(dictionary: string, name: string, blendOutSpeed: number): void;
     resetMovementClipset(blendDuration: number): void;
     setMovementClipset(clipset: string, speed: number): void;
     taskEnterVehicle(vehicleHandle: number, timeout: number, seat: number, speed: number, flag: number, p6: number): void;
     taskPlayAnim(dictionary: string, name: string, blendInSpeed: number, blendOutSpeed: number, duration: number, flag: number, playbackRate: number, lockX: boolean, lockY: boolean, lockZ: boolean): void;
     taskSwapWeapon(): void;
     getBoneCoords(boneId: number, offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    setNoCollision(otherHandle: number, thisFrameOnly: boolean): void;
 }
 export {};

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

@@ -101,6 +101,12 @@ export class RagePlayer extends RageEntity {
     clearTasks() {
         this.mpEntity.clearTasks();
     }
+    clearTasksImmediately() {
+        mp.game.task.clearPedTasksImmediately(this.handle);
+    }
+    stopAnim(dictionary, name, blendOutSpeed) {
+        mp.game.task.stopAnimTask(this.handle, dictionary, name, blendOutSpeed);
+    }
     resetMovementClipset(blendDuration) {
         this.mpEntity.resetMovementClipset(blendDuration);
     }
@@ -120,4 +126,7 @@ export class RagePlayer extends RageEntity {
         const { x, y, z } = this.mpEntity.getBoneCoords(boneId, offsetX, offsetY, offsetZ);
         return new Vector3D(x, y, z);
     }
+    setNoCollision(otherHandle, thisFrameOnly) {
+        this.mpEntity.setNoCollision(otherHandle, thisFrameOnly);
+    }
 }

package/dist/client/entities/ragemp/player/RagePlayersManager.d.ts

@@ -5,6 +5,8 @@ export declare class RagePlayersManager extends RageEntitiesManager<RagePlayer>
     constructor();
     getByName(name: string): RagePlayer;
     findByName(name: string): RagePlayer | null;
+    findByRemoteId(remoteId: number): RagePlayer | null;
+    getByRemoteId(remoteId: number): RagePlayer;
     findLocalPlayer(): RagePlayer | null;
     getLocalPlayer(): IPlayer;
     syncWithMpPool(): void;

package/dist/client/entities/ragemp/player/RagePlayersManager.js

@@ -21,6 +21,20 @@ export class RagePlayersManager extends RageEntitiesManager {
         }
         return null;
     }
+    findByRemoteId(remoteId) {
+        const mpPlayer = mp.players.atRemoteId(remoteId);
+        if (!mpPlayer) {
+            return null;
+        }
+        return this.findByID(mpPlayer.id);
+    }
+    getByRemoteId(remoteId) {
+        const player = this.findByRemoteId(remoteId);
+        if (!player) {
+            throw new Error(`Player with remoteId ${remoteId} not found`);
+        }
+        return player;
+    }
     findLocalPlayer() {
         return this.findByID(mp.players.local.id);
     }

package/dist/client/entities/ragemp/vehicle/RageVehicle.d.ts

@@ -40,4 +40,21 @@ export declare class RageVehicle extends RageEntity<VehicleMp> implements IVehic
     get numberPlateTextIndex(): number;
     setDoorOpen(doorIndex: number, loose: boolean, openInstantly: boolean): void;
     setDoorShut(doorIndex: number, instantly: boolean): void;
+    setHandling(field: string, value: number): void;
+    getHandling(field: string): number;
+    setEnginePowerMultiplier(value: number): void;
+    setEngineTorqueMultiplier(value: number): void;
+    modifyTopSpeed(value: number): void;
+    setCheatPowerIncrease(value: number): void;
+    toggleMod(modType: number, toggle: boolean): void;
+    setTyreSmokeColor(r: number, g: number, b: number): void;
+    setModColor1(paintType: number, color: number, p3: number): void;
+    setExtraColours(pearlescentColor: number, wheelColor: number): void;
+    setHeadlightColor(colorIndex: number): void;
+    setDashboardColor(colorIndex: number): void;
+    setInteriorColor(colorIndex: number): void;
+    getMaxBraking(): number;
+    getAcceleration(): number;
+    getMaxTraction(): number;
+    getModelMaxSpeed(): number;
 }

package/dist/client/entities/ragemp/vehicle/RageVehicle.js

@@ -111,4 +111,58 @@ export class RageVehicle extends RageEntity {
     setDoorShut(doorIndex, instantly) {
         this.mpEntity.setDoorShut(doorIndex, instantly);
     }
+    setHandling(field, value) {
+        this.mpEntity.setHandling(field, value);
+    }
+    getHandling(field) {
+        return this.mpEntity.getHandling(field);
+    }
+    setEnginePowerMultiplier(value) {
+        this.mpEntity.setEnginePowerMultiplier(value);
+    }
+    setEngineTorqueMultiplier(value) {
+        this.mpEntity.setEngineTorqueMultiplier(value);
+    }
+    modifyTopSpeed(value) {
+        mp.game.vehicle.modifyTopSpeed(this.handle, value);
+    }
+    setCheatPowerIncrease(value) {
+        mp.game.vehicle.setCheatPowerIncrease(this.handle, value);
+    }
+    toggleMod(modType, toggle) {
+        this.mpEntity.toggleMod(modType, toggle);
+    }
+    setTyreSmokeColor(r, g, b) {
+        this.mpEntity.setTyreSmokeColor(r, g, b);
+    }
+    setModColor1(paintType, color, p3) {
+        this.mpEntity.setModColor1(paintType, color, p3);
+    }
+    setExtraColours(pearlescentColor, wheelColor) {
+        this.mpEntity.setExtraColours(pearlescentColor, wheelColor);
+    }
+    setHeadlightColor(colorIndex) {
+        // _SET_VEHICLE_HEADLIGHT_COLOUR — no RAGEMP wrapper, invoke native by hash
+        mp.game.invoke("0xE41033B25D003A07", this.handle, colorIndex);
+    }
+    setDashboardColor(colorIndex) {
+        // SET_VEHICLE_DASHBOARD_COLOUR — no RAGEMP wrapper, invoke native by hash
+        mp.game.invoke("0x6089CDF6A57F326C", this.handle, colorIndex);
+    }
+    setInteriorColor(colorIndex) {
+        // SET_VEHICLE_INTERIOR_COLOUR — no RAGEMP wrapper, invoke native by hash
+        mp.game.invoke("0xF40DD601A65F7F19", this.handle, colorIndex);
+    }
+    getMaxBraking() {
+        return this.mpEntity.getMaxBraking();
+    }
+    getAcceleration() {
+        return this.mpEntity.getAcceleration();
+    }
+    getMaxTraction() {
+        return this.mpEntity.getMaxTraction();
+    }
+    getModelMaxSpeed() {
+        return mp.game.vehicle.getVehicleModelMaxSpeed(this.mpEntity.model);
+    }
 }

package/dist/client/game/common/graphics/IGraphicsManager.d.ts

@@ -11,4 +11,6 @@ export interface IGraphicsManager {
     world3dToScreen2d(position: IVector3D): IVector2D | null;
     startScreenEffect(effectName: string, duration: number, looped: boolean): void;
     stopScreenEffect(effectName: string): void;
+    getSafeZoneSize(): number;
+    getActiveScreenResolution(): IVector2D;
 }

package/dist/client/game/common/streaming/IStreamingManager.d.ts

@@ -1,7 +1,14 @@
+import { type IVector3D } from "../../../../shared/common/utils";
 export interface IStreamingManager {
     requestAnimationDictionary(dictionary: string): void;
     hasAnimationDictionaryLoaded(dictionary: string): boolean;
+    removeAnimationDictionary(dictionary: string): void;
     isModelInCdimage(model: string): boolean;
+    requestModel(modelHash: number): void;
+    hasModelLoaded(modelHash: number): boolean;
     requestIpl(iplName: string): void;
     removeIpl(iplName: string): void;
+    setFocusArea(position: IVector3D, offset: IVector3D): void;
+    clearFocus(): void;
+    setFocusEntity(entityHandle: number): void;
 }

package/dist/client/game/ragemp/graphics/RageGraphicsManager.d.ts

@@ -5,4 +5,6 @@ export declare class RageGraphicsManager implements IGraphicsManager {
     world3dToScreen2d(position: IVector3D): IVector2D | null;
     startScreenEffect(effectName: string, duration: number, looped: boolean): void;
     stopScreenEffect(effectName: string): void;
+    getSafeZoneSize(): number;
+    getActiveScreenResolution(): IVector2D;
 }

package/dist/client/game/ragemp/graphics/RageGraphicsManager.js

@@ -27,4 +27,11 @@ export class RageGraphicsManager {
     stopScreenEffect(effectName) {
         mp.game.graphics.stopScreenEffect(effectName);
     }
+    getSafeZoneSize() {
+        return mp.game.graphics.getSafeZoneSize();
+    }
+    getActiveScreenResolution() {
+        const result = mp.game.graphics.getActiveScreenResolution();
+        return new Vector2D(result.x, result.y);
+    }
 }

package/dist/client/game/ragemp/streaming/RageStreamingManager.d.ts

@@ -1,8 +1,15 @@
 import { type IStreamingManager } from "../../../game";
+import { type IVector3D } from "../../../../shared/common/utils";
 export declare class RageStreamingManager implements IStreamingManager {
     requestAnimationDictionary(dictionary: string): void;
     hasAnimationDictionaryLoaded(dictionary: string): boolean;
+    removeAnimationDictionary(dictionary: string): void;
     isModelInCdimage(model: string): boolean;
+    requestModel(modelHash: number): void;
+    hasModelLoaded(modelHash: number): boolean;
     requestIpl(iplName: string): void;
     removeIpl(iplName: string): void;
+    setFocusArea(position: IVector3D, offset: IVector3D): void;
+    clearFocus(): void;
+    setFocusEntity(entityHandle: number): void;
 }

package/dist/client/game/ragemp/streaming/RageStreamingManager.js

@@ -5,14 +5,32 @@ export class RageStreamingManager {
     hasAnimationDictionaryLoaded(dictionary) {
         return mp.game.streaming.hasAnimDictLoaded(dictionary);
     }
+    removeAnimationDictionary(dictionary) {
+        mp.game.streaming.removeAnimDict(dictionary);
+    }
     isModelInCdimage(model) {
         const modelHash = mp.game.joaat(model);
         return mp.game.streaming.isModelInCdimage(modelHash);
     }
+    requestModel(modelHash) {
+        mp.game.streaming.requestModel(modelHash);
+    }
+    hasModelLoaded(modelHash) {
+        return mp.game.streaming.hasModelLoaded(modelHash);
+    }
     requestIpl(iplName) {
         mp.game.streaming.requestIpl(iplName);
     }
     removeIpl(iplName) {
         mp.game.streaming.removeIpl(iplName);
     }
+    setFocusArea(position, offset) {
+        mp.game.streaming.setFocusArea(position.x, position.y, position.z, offset.x, offset.y, offset.z);
+    }
+    clearFocus() {
+        mp.game.streaming.clearFocus();
+    }
+    setFocusEntity(entityHandle) {
+        mp.game.streaming.setFocusEntity(entityHandle);
+    }
 }

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

@@ -4,6 +4,7 @@ exports.RagePlayersManager = void 0;
 const RageEntitiesManager_1 = require("../entity/RageEntitiesManager");
 const RagePlayer_1 = require("./RagePlayer");
 const types_1 = require("../../../net/common/events/types");
+const RockMod_1 = require("../../../RockMod");
 class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
     constructor(net) {
         super({
@@ -51,11 +52,37 @@ class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
                 this.registerBaseObject(player);
                 net.events.emitInternal(types_1.ServerInternalEventName.PlayerConnected, player);
             },
-            playerQuit: (mpPlayer) => {
+            playerQuit: (mpPlayer, exitType, reason) => {
                 const player = this.getByID(mpPlayer.id);
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerQuit, player, exitType, reason);
                 this.unregisterBaseObject(player);
                 net.events.emitInternal(types_1.ServerInternalEventName.PlayerDisconnected, player);
             },
+            playerDeath: (mpPlayer, reason, killer) => {
+                const player = this.getByID(mpPlayer.id);
+                const killerPlayer = killer ? (RockMod_1.RockMod.instance.players.findByID(killer.id) ?? null) : null;
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerDeath, player, reason, killerPlayer);
+            },
+            playerDamage: (mpPlayer, healthLoss, armourLoss) => {
+                const player = this.getByID(mpPlayer.id);
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerDamage, player, healthLoss, armourLoss);
+            },
+            playerEnterVehicle: (mpPlayer, mpVehicle, seat) => {
+                const player = this.getByID(mpPlayer.id);
+                const vehicle = RockMod_1.RockMod.instance.vehicles.findByID(mpVehicle.id);
+                if (!vehicle) {
+                    return;
+                }
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerEnterVehicle, player, vehicle, seat);
+            },
+            playerExitVehicle: (mpPlayer, mpVehicle) => {
+                const player = this.getByID(mpPlayer.id);
+                const vehicle = RockMod_1.RockMod.instance.vehicles.findByID(mpVehicle.id);
+                if (!vehicle) {
+                    return;
+                }
+                net.events.emitInternal(types_1.ServerInternalEventName.PlayerExitVehicle, player, vehicle);
+            },
         });
     }
 }

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

@@ -1,7 +1,12 @@
-import { type IBaseObject, type IColshape, type IPlayer } from "../../../entities";
+import { type IBaseObject, type IColshape, type IPlayer, type IVehicle } from "../../../entities";
 export declare enum ServerInternalEventName {
     PlayerConnected = "rm::playerConnected",
     PlayerDisconnected = "rm::playerDisconnected",
+    PlayerQuit = "rm::playerQuit",
+    PlayerDeath = "rm::playerDeath",
+    PlayerDamage = "rm::playerDamage",
+    PlayerEnterVehicle = "rm::playerEnterVehicle",
+    PlayerExitVehicle = "rm::playerExitVehicle",
     PlayerEnteredColshape = "rm::playerEnteredColshape",
     PlayerLeftColshape = "rm::playerLeftColshape",
     EntityCreated = "rm::entityCreated",
@@ -10,6 +15,11 @@ export declare enum ServerInternalEventName {
 export interface IServerInternalEvents {
     [ServerInternalEventName.PlayerConnected]: (player: IPlayer) => void;
     [ServerInternalEventName.PlayerDisconnected]: (player: IPlayer) => void;
+    [ServerInternalEventName.PlayerQuit]: (player: IPlayer, exitType: string, reason: string) => void;
+    [ServerInternalEventName.PlayerDeath]: (player: IPlayer, reason: number, killer: IPlayer | null) => void;
+    [ServerInternalEventName.PlayerDamage]: (player: IPlayer, healthLoss: number, armourLoss: number) => void;
+    [ServerInternalEventName.PlayerEnterVehicle]: (player: IPlayer, vehicle: IVehicle, seat: number) => void;
+    [ServerInternalEventName.PlayerExitVehicle]: (player: IPlayer, vehicle: IVehicle) => void;
     [ServerInternalEventName.PlayerEnteredColshape]: (player: IPlayer, colshape: IColshape) => void;
     [ServerInternalEventName.PlayerLeftColshape]: (player: IPlayer, colshape: IColshape) => void;
     [ServerInternalEventName.EntityCreated]: (object: IBaseObject) => void;

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

@@ -5,6 +5,11 @@ var ServerInternalEventName;
 (function (ServerInternalEventName) {
     ServerInternalEventName["PlayerConnected"] = "rm::playerConnected";
     ServerInternalEventName["PlayerDisconnected"] = "rm::playerDisconnected";
+    ServerInternalEventName["PlayerQuit"] = "rm::playerQuit";
+    ServerInternalEventName["PlayerDeath"] = "rm::playerDeath";
+    ServerInternalEventName["PlayerDamage"] = "rm::playerDamage";
+    ServerInternalEventName["PlayerEnterVehicle"] = "rm::playerEnterVehicle";
+    ServerInternalEventName["PlayerExitVehicle"] = "rm::playerExitVehicle";
     ServerInternalEventName["PlayerEnteredColshape"] = "rm::playerEnteredColshape";
     ServerInternalEventName["PlayerLeftColshape"] = "rm::playerLeftColshape";
     ServerInternalEventName["EntityCreated"] = "rm::entityCreated";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rock-mod",
-  "version": "0.18.0",
+  "version": "0.20.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",
@@ -82,6 +82,9 @@
   ],
   "author": "xvetal",
   "license": "MIT",
+  "dependencies": {
+    "@swc/helpers": "^0.5.15"
+  },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-node-resolve": "^15.2.3",