rock-mod 0.17.0 → 0.19.0

package/dist/client/entities/ragemp/baseObject/RageBaseObject.js

@@ -2,12 +2,21 @@ export class RageBaseObject {
     get id() {
         return this._mpEntity.id;
     }
+    get remoteId() {
+        return this.mpEntity.remoteId;
+    }
+    get handle() {
+        return this.mpEntity.handle;
+    }
     get type() {
         return this._mpEntity.type;
     }
     get isExists() {
         return this._mpEntity.isExists();
     }
+    destroy() {
+        this.mpEntity.destroy();
+    }
     get mpEntity() {
         return this._mpEntity;
     }

package/dist/client/entities/ragemp/baseObject/RageBaseObjectsManager.d.ts

@@ -12,6 +12,9 @@ export declare abstract class RageBaseObjectsManager<T extends RageBaseObject<En
     protected constructor(options: IRageBaseObjectsManagerOptions);
     getByID(id: number): T;
     findByID(id: number): T | null;
+    getByRemoteID(remoteId: number): T;
+    findByRemoteID(remoteId: number): T | null;
+    deleteById(id: number): T;
     protected registerBaseObject(baseObject: T): void;
     protected unregisterBaseObject(baseObject: T): void;
 }

package/dist/client/entities/ragemp/baseObject/RageBaseObjectsManager.js

@@ -1,6 +1,6 @@
 import { RageBaseObjectsIterator } from "./RageBaseObjectsIterator";
 import { RockMod } from "../../../RockMod";
-import { ClientInternalEventName } from "@RockMod/client/net/common/events/types";
+import { ClientInternalEventName } from "../../../net/common/events/types";
 export class RageBaseObjectsManager {
     get baseObjects() {
         return this._baseObjects;
@@ -14,7 +14,10 @@ export class RageBaseObjectsManager {
         this._iterator = new RageBaseObjectsIterator(this._baseObjects);
         mp.events.add("entityDestroyed", (mpEntity) => {
             if (mpEntity.type === this._baseObjectsType) {
-                const baseObject = this.getByID(mpEntity.id);
+                const baseObject = this.findByID(mpEntity.id);
+                if (!baseObject) {
+                    return;
+                }
                 this.unregisterBaseObject(baseObject);
             }
         });
@@ -30,6 +33,23 @@ export class RageBaseObjectsManager {
         const baseObject = this._baseObjects.get(id);
         return baseObject !== null && baseObject !== void 0 ? baseObject : null;
     }
+    getByRemoteID(remoteId) {
+        const baseObject = this.findByRemoteID(remoteId);
+        if (!baseObject) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${remoteId} not found`);
+        }
+        return baseObject;
+    }
+    findByRemoteID(remoteId) {
+        const baseObject = Array.from(this._baseObjects.values()).find((obj) => obj.remoteId === remoteId);
+        return baseObject !== null && baseObject !== void 0 ? baseObject : null;
+    }
+    deleteById(id) {
+        const object = this.getByID(id);
+        object.destroy();
+        this.unregisterBaseObject(object);
+        return object;
+    }
     registerBaseObject(baseObject) {
         if (this._baseObjects.has(baseObject.id)) {
             throw new Error(`BaseObject [${this._baseObjectsType}] with id ${baseObject.id} already exists`);

package/dist/client/entities/ragemp/blip/RageBlip.d.ts

@@ -1,9 +1,10 @@
 import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
 import { type IBlip } from "../../common/blip/IBlip";
-import { type IBlipColor, type IBlipSprite } from "@shared/entities";
+import { type IBlipColor, type IBlipSprite } from "../../../../shared/entities";
 export interface IRageBlipOptions extends IRageWorldObjectOptions<EntityMp> {
 }
 export declare class RageBlip extends RageWorldObject<EntityMp> implements IBlip {
+    private get _blipEntity();
     get sprite(): IBlipSprite;
     get color(): IBlipColor;
     get alpha(): number;
@@ -12,4 +13,6 @@ export declare class RageBlip extends RageWorldObject<EntityMp> implements IBlip
     setSprite(value: IBlipSprite): void;
     setColor(value: IBlipColor): void;
     setAlpha(value: number): void;
+    setShowHeadingIndicator(value: boolean): void;
+    setRotation(value: number): void;
 }

package/dist/client/entities/ragemp/blip/RageBlip.js

@@ -1,27 +1,36 @@
 import { RageWorldObject } from "../worldObject/RageWorldObject";
 export class RageBlip extends RageWorldObject {
+    get _blipEntity() {
+        return this.mpEntity;
+    }
     get sprite() {
-        return this.mpEntity.getSprite();
+        return this._blipEntity.getSprite();
     }
     get color() {
-        return this.mpEntity.getColour();
+        return this._blipEntity.getColour();
     }
     get alpha() {
         return this.mpEntity.alpha;
     }
     get shortRange() {
-        return this.mpEntity.isShortRange();
+        return this._blipEntity.isShortRange();
     }
     constructor(options) {
         super(options);
     }
     setSprite(value) {
-        this.mpEntity.setSprite(value);
+        this._blipEntity.setSprite(value);
     }
     setColor(value) {
-        this.mpEntity.setColour(value);
+        this._blipEntity.setColour(value);
     }
     setAlpha(value) {
         this.mpEntity.alpha = value;
     }
+    setShowHeadingIndicator(value) {
+        this._blipEntity.setShowHeadingIndicator(value);
+    }
+    setRotation(value) {
+        this._blipEntity.setRotation(value);
+    }
 }

package/dist/client/entities/ragemp/camera/RageCamera.d.ts

@@ -0,0 +1,19 @@
+import type { ICamera } from "../../../entities";
+import { type IVector3D, Vector3D } from "../../../../shared/index";
+import { type IRageBaseObjectOptions, RageBaseObject } from "../../../entities/ragemp/baseObject/RageBaseObject";
+export interface IRageCameraOptions extends IRageBaseObjectOptions<EntityMp> {
+}
+export declare class RageCamera extends RageBaseObject implements ICamera {
+    constructor(options: IRageCameraOptions);
+    private get _cameraEntity();
+    get isActive(): boolean;
+    setIsActive(value: boolean): void;
+    get direction(): IVector3D;
+    get fov(): number;
+    setFov(value: number): void;
+    pointAtCoord(value: IVector3D): void;
+    setPosition(value: Vector3D): void;
+    get position(): Vector3D;
+    get rotation(): IVector3D;
+    setRotation(value: IVector3D): void;
+}

package/dist/client/entities/ragemp/camera/RageCamera.js

@@ -0,0 +1,43 @@
+import { Vector3D } from "../../../../shared/index";
+import { RageBaseObject } from "../../../entities/ragemp/baseObject/RageBaseObject";
+export class RageCamera extends RageBaseObject {
+    constructor(options) {
+        super(options);
+    }
+    get _cameraEntity() {
+        return this.mpEntity;
+    }
+    get isActive() {
+        return this._cameraEntity.isActive();
+    }
+    setIsActive(value) {
+        this._cameraEntity.setActive(value);
+    }
+    get direction() {
+        const { x, y, z } = this._cameraEntity.getDirection();
+        return new Vector3D(x, y, z);
+    }
+    get fov() {
+        return this._cameraEntity.getFov();
+    }
+    setFov(value) {
+        this._cameraEntity.setFov(value);
+    }
+    pointAtCoord(value) {
+        this._cameraEntity.pointAtCoord(value.x, value.y, value.z);
+    }
+    setPosition(value) {
+        this._cameraEntity.setCoord(value.x, value.y, value.z);
+    }
+    get position() {
+        const { x, y, z } = this._cameraEntity.getCoord();
+        return new Vector3D(x, y, z);
+    }
+    get rotation() {
+        const { x, y, z } = this._cameraEntity.getRot(2);
+        return new Vector3D(x, y, z);
+    }
+    setRotation(value) {
+        this._cameraEntity.setRot(value.x, value.y, value.z, 2);
+    }
+}

package/dist/client/entities/ragemp/camera/RageCameraManager.d.ts

@@ -0,0 +1,9 @@
+import { RageCamera } from "../../../entities/ragemp/camera/RageCamera";
+import { type ICameraCreateOptions, type ICameraManager } from "../../../entities";
+import { RageBaseObjectsManager } from "../../../entities/ragemp/baseObject/RageBaseObjectsManager";
+export declare class RageCameraManager extends RageBaseObjectsManager<RageCamera> implements ICameraManager {
+    constructor();
+    create(options: ICameraCreateOptions): RageCamera;
+    renderScriptCams(render: boolean, ease: boolean, easeTime: number, freezePreviousCamera: boolean): void;
+    getGameplayCamera(): RageCamera;
+}

package/dist/client/entities/ragemp/camera/RageCameraManager.js

@@ -0,0 +1,26 @@
+import { RageCamera } from "../../../entities/ragemp/camera/RageCamera";
+import { RageBaseObjectsManager } from "../../../entities/ragemp/baseObject/RageBaseObjectsManager";
+export class RageCameraManager extends RageBaseObjectsManager {
+    constructor() {
+        super({
+            baseObjectsType: "camera",
+        });
+    }
+    create(options) {
+        const mpEntity = mp.cameras.new(options.name, new mp.Vector3(options.position), new mp.Vector3(options.rotation), options.fov);
+        const camera = new RageCamera({
+            mpEntity: mpEntity,
+        });
+        this.registerBaseObject(camera);
+        return camera;
+    }
+    renderScriptCams(render, ease, easeTime, freezePreviousCamera) {
+        mp.game.cam.renderScriptCams(render, ease, easeTime, freezePreviousCamera, false, 0);
+    }
+    getGameplayCamera() {
+        const mpCamera = mp.cameras.gameplay;
+        return new RageCamera({
+            mpEntity: mpCamera,
+        });
+    }
+}

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

@@ -5,4 +5,7 @@ export interface IRageEntitiesManagerOptions extends IRageWorldObjectsManagerOpt
 }
 export declare abstract class RageEntitiesManager<T extends RageEntity<EntityMp>> extends RageWorldObjectsManager<T> implements IEntitiesManager<T> {
     protected constructor(options: IRageEntitiesManagerOptions);
+    abstract syncWithMpPool(): void;
+    abstract registerById(id: number): T;
+    unregisterById(id: number): T;
 }

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

@@ -3,4 +3,9 @@ export class RageEntitiesManager extends RageWorldObjectsManager {
     constructor(options) {
         super(options);
     }
+    unregisterById(id) {
+        const existingObject = this.getByID(id);
+        this.unregisterBaseObject(existingObject);
+        return existingObject;
+    }
 }

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

@@ -1,12 +1,31 @@
+import { type IBaseObject } from "../../common/baseObject";
 import { type IEntity } from "../../common/entity/IEntity";
 import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
-import { Vector3D } from "../../../../shared/common/utils";
+import { type IVector3D, Vector3D } from "../../../../shared/common/utils";
 export interface IRageEntityOptions<T extends EntityMp> extends IRageWorldObjectOptions<T> {
 }
 export declare abstract class RageEntity<T extends EntityMp> extends RageWorldObject<T> implements IEntity {
     get model(): number;
     get rotation(): Vector3D;
     protected constructor(options: IRageEntityOptions<T>);
+    get heading(): number;
+    setHeading(heading: number): void;
     setModel(value: string): void;
     setRotation(value: Vector3D): void;
+    get forwardVector(): Vector3D;
+    freezePosition(freeze: boolean): void;
+    setCollision(collision: boolean, keepPhysics: boolean): void;
+    setInvincible(invincible: boolean): void;
+    setVisible(visible: boolean): void;
+    setAlpha(alpha: number): void;
+    get alpha(): number;
+    getOffsetFromInWorldCoords(offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    resetAlpha(): void;
+    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

@@ -11,10 +11,67 @@ export class RageEntity extends RageWorldObject {
     constructor(options) {
         super(options);
     }
+    get heading() {
+        return this.mpEntity.getHeading();
+    }
+    setHeading(heading) {
+        this.mpEntity.setHeading(heading);
+    }
     setModel(value) {
         this.mpEntity.model = mp.game.joaat(value);
     }
     setRotation(value) {
         this.mpEntity.rotation = new mp.Vector3(value);
     }
+    get forwardVector() {
+        const vector = this.mpEntity.getForwardVector();
+        return new Vector3D(vector.x, vector.y, vector.z);
+    }
+    freezePosition(freeze) {
+        this.mpEntity.freezePosition(freeze);
+    }
+    setCollision(collision, keepPhysics) {
+        this.mpEntity.setCollision(collision, keepPhysics);
+    }
+    setInvincible(invincible) {
+        this.mpEntity.setInvincible(invincible);
+    }
+    setVisible(visible) {
+        this.mpEntity.setVisible(visible, false);
+    }
+    setAlpha(alpha) {
+        this.mpEntity.setAlpha(alpha);
+    }
+    get alpha() {
+        return this.mpEntity.alpha;
+    }
+    getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ) {
+        const { x, y, z } = this.mpEntity.getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ);
+        return new Vector3D(x, y, z);
+    }
+    resetAlpha() {
+        this.mpEntity.resetAlpha();
+    }
+    getBoneIndexByName(boneName) {
+        return this.mpEntity.getBoneIndexByName(boneName);
+    }
+    getWorldPositionOfBone(boneIndex) {
+        const { x, y, z } = this.mpEntity.getWorldPositionOfBone(boneIndex);
+        return new Vector3D(x, y, z);
+    }
+    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/marker/RageMarker.d.ts

@@ -1,7 +1,7 @@
 import { type IMarker } from "../../common";
 import { type IRageWorldObjectOptions, RageWorldObject } from "../worldObject/RageWorldObject";
-import { type IVector3D } from "../../../../shared/common/utils";
-import { type IMarkerType } from "@shared/entities";
+import { type IRGBA, type IVector3D } from "../../../../shared/common/utils";
+import { type IMarkerType } from "../../../../shared/entities";
 export interface IRageMarkerOptions extends IRageWorldObjectOptions<MarkerMp> {
 }
 export declare class RageMarker extends RageWorldObject<MarkerMp> implements IMarker {
@@ -11,4 +11,8 @@ export declare class RageMarker extends RageWorldObject<MarkerMp> implements IMa
     constructor(options: IRageMarkerOptions);
     setVisible(value: boolean): void;
     setRotation(value: IVector3D): void;
+    get scale(): number;
+    setScale(value: number): void;
+    get color(): IRGBA;
+    setColor(value: IRGBA): void;
 }

package/dist/client/entities/ragemp/marker/RageMarker.js

@@ -1,5 +1,5 @@
 import { RageWorldObject } from "../worldObject/RageWorldObject";
-import { Vector3D } from "../../../../shared/common/utils";
+import { RGBA, Vector3D } from "../../../../shared/common/utils";
 export class RageMarker extends RageWorldObject {
     get markerType() {
         return this.mpEntity.model;
@@ -20,4 +20,19 @@ export class RageMarker extends RageWorldObject {
     setRotation(value) {
         this.mpEntity.rotation = new mp.Vector3(value);
     }
+    get scale() {
+        return this.mpEntity.scale;
+    }
+    setScale(value) {
+        this.mpEntity.scale = value;
+    }
+    get color() {
+        var _a, _b, _c;
+        const color = this.mpEntity.color;
+        return new RGBA((_a = color[0]) !== null && _a !== void 0 ? _a : 0, (_b = color[1]) !== null && _b !== void 0 ? _b : 0, (_c = color[2]) !== null && _c !== void 0 ? _c : 0, color[3]);
+    }
+    setColor(value) {
+        var _a;
+        this.mpEntity.color = [value.r, value.g, value.b, (_a = value.a) !== null && _a !== void 0 ? _a : 255];
+    }
 }

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

@@ -1,9 +1,9 @@
 import { type IRageEntityOptions, RageEntity } from "../entity/RageEntity";
-import { type IObject } from "../../common/object/IObject";
+import { type IObject } from "../../../entities";
 export interface IRageObjectOptions extends IRageEntityOptions<ObjectMp> {
 }
 export declare class RageObject extends RageEntity<ObjectMp> implements IObject {
-    get alpha(): number;
     constructor(options: IRageObjectOptions);
-    setAlpha(value: number): void;
+    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;
 }

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

@@ -1,12 +1,12 @@
 import { RageEntity } from "../entity/RageEntity";
 export class RageObject extends RageEntity {
-    get alpha() {
-        return this.mpEntity.alpha;
-    }
     constructor(options) {
         super(options);
     }
-    setAlpha(value) {
-        this.mpEntity.alpha = value;
+    attachTo(entity, boneIndex, xPos, yPos, zPos, xRot, yRot, zRot, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
+        this.mpEntity.attachTo(entity, boneIndex, xPos, yPos, zPos, xRot, yRot, zRot, false, useSoftPinning, collision, isPed, vertexIndex, fixedRot);
+    }
+    isAttachedTo(entity) {
+        return this.mpEntity.isAttachedTo(entity);
     }
 }

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

@@ -6,4 +6,6 @@ export interface IRageObjectCreateOptions extends IObjectCreateOptions {
 export declare class RageObjectsManager extends RageEntitiesManager<RageObject> implements IObjectsManager {
     constructor();
     create(options: IRageObjectCreateOptions): RageObject;
+    syncWithMpPool(): void;
+    registerById(id: number): RageObject;
 }

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

@@ -18,4 +18,22 @@ export class RageObjectsManager extends RageEntitiesManager {
         this.registerBaseObject(object);
         return object;
     }
+    syncWithMpPool() {
+        for (const mpObject of mp.objects.toArray()) {
+            this.registerById(mpObject.id);
+        }
+    }
+    registerById(id) {
+        const existingObject = this.findByID(id);
+        if (existingObject) {
+            return existingObject;
+        }
+        const mpObject = mp.objects.at(id);
+        mpObject.isExists = () => mp.objects.exists(mpObject);
+        const object = new RageObject({
+            mpEntity: mpObject,
+        });
+        this.registerBaseObject(object);
+        return object;
+    }
 }

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

@@ -1,7 +1,21 @@
 import { type IRageEntityOptions, RageEntity } from "../entity/RageEntity";
 import { type IPed } from "../../common";
+import { type IVector3D } from "../../../../shared/common/utils";
 export interface IRagePedOptions extends IRageEntityOptions<PedMp> {
 }
 export declare class RagePed extends RageEntity<PedMp> implements IPed {
     constructor(options: IRagePedOptions);
+    setDecoration(collection: string, overlay: string): void;
+    removeDecoration(collection: string, overlay: string): void;
+    clearDecorations(): void;
+    setHeadBlendData(shapeFirstId: number, shapeSecondId: number, shapeThirdId: number, skinFirstId: number, skinSecondId: number, skinThirdId: number, shapeMix: number, skinMix: number, thirdMix: number, isParent: boolean): void;
+    setFaceFeature(index: number, value: number): void;
+    setHeadOverlay(overlayId: number, index: number, opacity: number): void;
+    setHeadOverlayColor(overlayId: number, colorTypeId: number, firstColor: number, secondColor: number): void;
+    setEyeColor(eyeColor: number): void;
+    setHairColor(colorId: number, highlightColorId: number): void;
+    setComponentVariation(componentId: number, drawableId: number, textureId: number, paletteId: number): void;
+    setPropertyVariation(componentId: number, drawableId: number, textureId: number, attach: boolean): void;
+    clearProp(componentId: number): void;
+    getBoneCoords(boneId: number, offsetX: number, offsetY: number, offsetZ: number): IVector3D;
 }

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

@@ -1,6 +1,52 @@
 import { RageEntity } from "../entity/RageEntity";
+import { Vector3D } from "../../../../shared/common/utils";
 export class RagePed extends RageEntity {
     constructor(options) {
         super(options);
     }
+    setDecoration(collection, overlay) {
+        const collectionHash = mp.game.joaat(collection);
+        const overlayHash = mp.game.joaat(overlay);
+        this.mpEntity.setDecoration(collectionHash, overlayHash);
+    }
+    removeDecoration(collection, overlay) {
+        const collectionHash = mp.game.joaat(collection);
+        const overlayHash = mp.game.joaat(overlay);
+        // @ts-expect-error TODO test if this works
+        this.mpEntity.removeDecoration(collectionHash, overlayHash);
+    }
+    clearDecorations() {
+        this.mpEntity.clearDecorations();
+    }
+    setHeadBlendData(shapeFirstId, shapeSecondId, shapeThirdId, skinFirstId, skinSecondId, skinThirdId, shapeMix, skinMix, thirdMix, isParent) {
+        this.mpEntity.setHeadBlendData(shapeFirstId, shapeSecondId, shapeThirdId, skinFirstId, skinSecondId, skinThirdId, shapeMix, skinMix, thirdMix, isParent);
+    }
+    setFaceFeature(index, value) {
+        this.mpEntity.setFaceFeature(index, value);
+    }
+    setHeadOverlay(overlayId, index, opacity) {
+        this.mpEntity.setHeadOverlay(overlayId, index, opacity);
+    }
+    setHeadOverlayColor(overlayId, colorTypeId, firstColor, secondColor) {
+        this.mpEntity.setHeadOverlayColor(overlayId, colorTypeId, firstColor, secondColor);
+    }
+    setEyeColor(eyeColor) {
+        this.mpEntity.setEyeColor(eyeColor);
+    }
+    setHairColor(colorId, highlightColorId) {
+        this.mpEntity.setHairColor(colorId, highlightColorId);
+    }
+    setComponentVariation(componentId, drawableId, textureId, paletteId) {
+        this.mpEntity.setComponentVariation(componentId, drawableId, textureId, paletteId);
+    }
+    setPropertyVariation(componentId, drawableId, textureId, attach) {
+        this.mpEntity.setPropIndex(componentId, drawableId, textureId, attach);
+    }
+    clearProp(componentId) {
+        this.mpEntity.clearProp(componentId);
+    }
+    getBoneCoords(boneId, offsetX, offsetY, offsetZ) {
+        const { x, y, z } = this.mpEntity.getBoneCoords(boneId, offsetX, offsetY, offsetZ);
+        return new Vector3D(x, y, z);
+    }
 }

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

@@ -6,4 +6,6 @@ export interface IRagePedCreateOptions extends IPedCreateOptions {
 export declare class RagePedsManager extends RageEntitiesManager<RagePed> implements IPedsManager {
     constructor();
     create(options: IRagePedCreateOptions): RagePed;
+    syncWithMpPool(): void;
+    registerById(id: number): RagePed;
 }

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

@@ -14,4 +14,22 @@ export class RagePedsManager extends RageEntitiesManager {
         this.registerBaseObject(ped);
         return ped;
     }
+    syncWithMpPool() {
+        for (const mpPed of mp.peds.toArray()) {
+            this.registerById(mpPed.id);
+        }
+    }
+    registerById(id) {
+        const existingPed = this.findByID(id);
+        if (existingPed) {
+            return existingPed;
+        }
+        const mpPed = mp.peds.at(id);
+        mpPed.isExists = () => mp.peds.exists(mpPed);
+        const ped = new RagePed({
+            mpEntity: mpPed,
+        });
+        this.registerBaseObject(ped);
+        return ped;
+    }
 }

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

@@ -1,13 +1,47 @@
 import { type IRageEntityOptions, RageEntity } from "../entity/RageEntity";
-import { type IPlayer } from "../../common/player/IPlayer";
+import { type IPlayer } from "../../../entities";
+import { type RageVehicle } from "../../../entities/ragemp/vehicle/RageVehicle";
+import { type IVector3D } from "../../../../shared/common/utils";
 interface IRagePlayerOptions extends IRageEntityOptions<PlayerMp> {
 }
 export declare class RagePlayer extends RageEntity<PlayerMp> implements IPlayer {
     get name(): string;
-    get heading(): number;
     get health(): number;
     get armour(): number;
     get isDead(): boolean;
     constructor(options: IRagePlayerOptions);
+    get vehicle(): RageVehicle | null;
+    get isVoice3DEnabled(): boolean;
+    get voiceVolume(): number;
+    get isVoiceActive(): boolean;
+    setVoice3D(enable: boolean): void;
+    setVoiceVolume(volume: number): void;
+    get isReloading(): boolean;
+    get weapon(): number;
+    getAmmoInClip(weapon: number): number;
+    getWeaponAmmo(weapon: number): number;
+    getBoneIndex(boneId: number): number;
+    setDecoration(collection: string, overlay: string): void;
+    removeDecoration(collection: string, overlay: string): void;
+    clearDecorations(): void;
+    setHeadBlendData(shapeFirstId: number, shapeSecondId: number, shapeThirdId: number, skinFirstId: number, skinSecondId: number, skinThirdId: number, shapeMix: number, skinMix: number, thirdMix: number, isParent: boolean): void;
+    setFaceFeature(index: number, value: number): void;
+    setHeadOverlay(overlayId: number, index: number, opacity: number, firstColor: number, secondColor: number): void;
+    setHeadOverlayColor(overlayId: number, colorTypeId: number, firstColor: number, secondColor: number): void;
+    setEyeColor(eyeColor: number): void;
+    setHairColor(colorId: number, highlightColorId: number): void;
+    setComponentVariation(componentId: number, drawableId: number, textureId: number, paletteId: number): void;
+    setPropertyVariation(componentId: number, drawableId: number, textureId: number, attach: boolean): void;
+    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;
 }
 export {};