rock-mod 0.18.0 → 0.19.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/player/IPlayer.d.ts

@@ -35,7 +35,9 @@ 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;

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,10 @@ 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;
 }

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

@@ -62,4 +62,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/player/RagePlayer.d.ts

@@ -35,6 +35,8 @@ 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;

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

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,10 @@ 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;
 }

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

@@ -111,4 +111,22 @@ 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);
+    }
 }

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

@@ -1,7 +1,12 @@
+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;
     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.d.ts

@@ -1,8 +1,13 @@
 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;
     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,6 +5,9 @@ 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);
@@ -15,4 +18,13 @@ export class RageStreamingManager {
     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.19.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",