rock-mod 0.20.0 → 0.22.0

package/dist/client/entities/ccmp/object/CCMPObject.js

@@ -0,0 +1,218 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { BaseObjectType } from "../../../../shared/entities";
+import { Vector3D } from "../../../../shared/common/utils";
+const notImplemented = (memberName) => {
+    throw new Error(`CCMPObject.${memberName}: not implemented`);
+};
+export class CCMPObject {
+    constructor(_ccmpObject, _onDestroy = () => { }) {
+        this._ccmpObject = _ccmpObject;
+        this._onDestroy = _onDestroy;
+        this._destroyed = false;
+    }
+    get id() {
+        return this._ccmpObject.id;
+    }
+    get remoteId() {
+        return this._ccmpObject.remoteId;
+    }
+    get type() {
+        return BaseObjectType.Object;
+    }
+    get isExists() {
+        return !this._destroyed && this._ccmpObject.isExists;
+    }
+    get handle() {
+        const handle = Number(this._ccmpObject.handle);
+        return Number.isFinite(handle) && handle > 0 ? Math.trunc(handle) : 0;
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._ccmpObject.destroy();
+        this._onDestroy(this);
+    }
+    get position() {
+        const { x, y, z } = this._ccmpObject.position;
+        return new Vector3D(x, y, z);
+    }
+    get dimension() {
+        return this._ccmpObject.dimension;
+    }
+    setPosition(value) {
+        this.setCoords(value.x, value.y, value.z, false, false, false, false);
+    }
+    setDimension(_value) {
+        notImplemented("setDimension");
+    }
+    setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.setEntityCoords(handle, xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea);
+        });
+    }
+    get model() {
+        return this._ccmpObject.model;
+    }
+    get heading() {
+        return this._ccmpObject.heading;
+    }
+    setHeading(heading) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.setEntityHeading(handle, heading);
+        });
+    }
+    setModel(_value) {
+        notImplemented("setModel");
+    }
+    get rotation() {
+        const { x, y, z } = this._ccmpObject.rotation;
+        return new Vector3D(x, y, z);
+    }
+    get forwardVector() {
+        const headingRad = (this.heading * Math.PI) / 180;
+        return new Vector3D(-Math.sin(headingRad), Math.cos(headingRad), 0);
+    }
+    setRotation(value) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.setEntityRotation(handle, value.x, value.y, value.z, 2, true);
+        });
+    }
+    freezePosition(freeze) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.freezeEntityPosition(handle, freeze);
+        });
+    }
+    setCollision(collision, keepPhysics) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.setEntityCollision(handle, collision, keepPhysics);
+        });
+    }
+    setInvincible(invincible) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.setEntityInvincible(handle, invincible, true);
+        });
+    }
+    setVisible(visible) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.setEntityVisible(handle, visible, false);
+        });
+    }
+    setAlpha(alpha) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.setEntityAlpha(handle, alpha, false);
+        });
+    }
+    get alpha() {
+        return this._withHandle(this._ccmpObject.alpha, (handle) => ccmp.natives.entity.getEntityAlpha(handle));
+    }
+    resetAlpha() {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.resetEntityAlpha(handle);
+        });
+    }
+    getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ) {
+        return this._withHandle(this._getOffsetFromCachedTransform(offsetX, offsetY, offsetZ), (handle) => {
+            const { x, y, z } = ccmp.natives.entity.getOffsetFromEntityInWorldCoords(handle, offsetX, offsetY, offsetZ);
+            return new Vector3D(x, y, z);
+        });
+    }
+    getBoneIndexByName(boneName) {
+        return this._withHandle(-1, (handle) => ccmp.natives.entity.getEntityBoneIndexByName(handle, boneName));
+    }
+    getWorldPositionOfBone(boneIndex) {
+        return this._withHandle(this.position, (handle) => {
+            const { x, y, z } = ccmp.natives.entity.getWorldPositionOfEntityBone(handle, boneIndex);
+            return new Vector3D(x, y, z);
+        });
+    }
+    getVariable(name) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return null;
+        }
+        const value = ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Object, remoteId, name);
+        return value === undefined ? null : value;
+    }
+    getSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return undefined;
+        }
+        return ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Object, remoteId, key);
+    }
+    hasSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return false;
+        }
+        return ccmp.entities.hasStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Object, remoteId, key);
+    }
+    getSyncedMetaKeys() {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return [];
+        }
+        return ccmp.entities.getStreamSyncedMetaKeys(ccmp.entities.ENTITY_TYPE.Object, remoteId);
+    }
+    attachTo(entity, boneIndex, xPos, yPos, zPos, xRot, yRot, zRot, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
+        const targetHandle = this._normalizeHandle(entity);
+        if (!targetHandle)
+            return;
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.attachEntityToEntity(handle, targetHandle, boneIndex, xPos, yPos, zPos, xRot, yRot, zRot, false, useSoftPinning, collision, isPed, vertexIndex, fixedRot, 0);
+        });
+    }
+    isAttachedTo(entity) {
+        const targetHandle = this._normalizeHandle(entity);
+        if (!targetHandle)
+            return false;
+        return this._withHandle(false, (handle) => ccmp.natives.entity.isEntityAttachedToEntity(handle, targetHandle));
+    }
+    attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
+        const targetHandle = this._normalizeHandle(target.handle);
+        if (!targetHandle)
+            return;
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.attachEntityToEntity(handle, targetHandle, boneIndex, offset.x, offset.y, offset.z, rotation.x, rotation.y, rotation.z, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot, 0);
+        });
+    }
+    detach(useDetachVelocity, collision) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.detachEntity(handle, useDetachVelocity, collision);
+        });
+    }
+    getSpeed() {
+        return this._withHandle(0, (handle) => ccmp.natives.entity.getEntitySpeed(handle));
+    }
+    isPlayingAnim(dictionary, name, taskFlag) {
+        return this._withHandle(false, (handle) => ccmp.natives.entity.isEntityPlayingAnim(handle, dictionary, name, taskFlag));
+    }
+    _withHandle(fallback, callback) {
+        const handle = this.handle;
+        if (!handle) {
+            return fallback;
+        }
+        return callback(handle);
+    }
+    _withHandleVoid(callback) {
+        const handle = this.handle;
+        if (!handle) {
+            return;
+        }
+        callback(handle);
+    }
+    _normalizeHandle(value) {
+        const handle = Number(value);
+        return Number.isFinite(handle) && handle > 0 ? Math.trunc(handle) : 0;
+    }
+    _getOffsetFromCachedTransform(offsetX, offsetY, offsetZ) {
+        const position = this.position;
+        const headingRad = (this.heading * Math.PI) / 180;
+        const rightX = Math.cos(headingRad);
+        const rightY = Math.sin(headingRad);
+        const forwardX = -Math.sin(headingRad);
+        const forwardY = Math.cos(headingRad);
+        return new Vector3D(position.x + rightX * offsetX + forwardX * offsetY, position.y + rightY * offsetX + forwardY * offsetY, position.z + offsetZ);
+    }
+}

package/dist/client/entities/ccmp/object/CCMPObjectsManager.d.ts

@@ -0,0 +1,27 @@
+import { type CCMPEventsManager } from "../../../net/ccmp/events/CCMPEventsManager";
+import { type IObjectCreateOptions, type IObjectsManager } from "../../common/object/IObjectsManager";
+import { type IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { CCMPObject } from "./CCMPObject";
+export declare class CCMPObjectsManager implements IObjectsManager {
+    private readonly _events;
+    private readonly _objects;
+    private readonly _objectsByRemoteId;
+    private readonly _iterator;
+    constructor(_events: CCMPEventsManager);
+    create(options: IObjectCreateOptions): CCMPObject;
+    syncWithMpPool(): void;
+    registerById(id: number): CCMPObject;
+    unregisterById(id: number): CCMPObject;
+    findByID(id: number): CCMPObject | null;
+    getByID(id: number): CCMPObject;
+    findByRemoteID(remoteId: number): CCMPObject | null;
+    getByRemoteID(remoteId: number): CCMPObject;
+    deleteById(id: number): CCMPObject;
+    get iterator(): IWorldObjectsIterator<CCMPObject>;
+    private _register;
+    private _unregister;
+    private _findRegistered;
+    private _registerLifecycleEvents;
+    private _filter;
+    private _pruneDestroyed;
+}

package/dist/client/entities/ccmp/object/CCMPObjectsManager.js

@@ -0,0 +1,177 @@
+import { ClientInternalEventName } from "../../../net/common/events/types";
+import { CCMPObject } from "./CCMPObject";
+export class CCMPObjectsManager {
+    constructor(_events) {
+        this._events = _events;
+        this._objects = new Map();
+        this._objectsByRemoteId = new Map();
+        this._iterator = {
+            all: () => this._filter(() => true),
+            dimension: (value) => this._filter((object) => object.dimension === value),
+            range2D: (center, range) => this._filter((object) => {
+                const position = object.position;
+                const squaredDistance = (position.x - center.x) ** 2 + (position.y - center.y) ** 2;
+                return squaredDistance <= range * range;
+            }),
+            range3D: (center, range) => this._filter((object) => object.position.isInRange(center, range)),
+        };
+        this._registerLifecycleEvents();
+        this.syncWithMpPool();
+    }
+    create(options) {
+        const ccmpObject = ccmp.objects.create(options.model, options.position, options.rotation, {
+            dimension: options.dimension,
+            alpha: options.alpha,
+        });
+        if (!ccmpObject) {
+            throw new Error(`CCMPObjectsManager.create: ccmp.objects.create failed for model "${options.model}"`);
+        }
+        return this._register(ccmpObject);
+    }
+    syncWithMpPool() {
+        this._pruneDestroyed();
+        for (const ccmpObject of ccmp.objects.all) {
+            this._register(ccmpObject);
+        }
+    }
+    registerById(id) {
+        const existingObject = this.findByID(id);
+        if (existingObject) {
+            return existingObject;
+        }
+        const ccmpObject = ccmp.objects.getById(id);
+        if (!ccmpObject) {
+            throw new Error(`CCMPObjectsManager.registerById(${id}): object not found.`);
+        }
+        return this._register(ccmpObject);
+    }
+    unregisterById(id) {
+        return this.deleteById(id);
+    }
+    findByID(id) {
+        var _a;
+        const object = (_a = this._objects.get(id)) !== null && _a !== void 0 ? _a : null;
+        if (object && !object.isExists) {
+            this._unregister(object);
+        }
+        else if (object) {
+            return object;
+        }
+        const ccmpObject = ccmp.objects.getById(id);
+        if (!ccmpObject) {
+            return null;
+        }
+        return this._register(ccmpObject);
+    }
+    getByID(id) {
+        const object = this.findByID(id);
+        if (!object) {
+            throw new Error(`CCMPObjectsManager.getByID(${id}): object not found.`);
+        }
+        return object;
+    }
+    findByRemoteID(remoteId) {
+        var _a;
+        const object = (_a = this._objectsByRemoteId.get(remoteId)) !== null && _a !== void 0 ? _a : null;
+        if (object && !object.isExists) {
+            this._unregister(object);
+        }
+        else if (object) {
+            return object;
+        }
+        const ccmpObject = ccmp.objects.getByRemoteId(remoteId);
+        if (!ccmpObject) {
+            return null;
+        }
+        return this._register(ccmpObject);
+    }
+    getByRemoteID(remoteId) {
+        const object = this.findByRemoteID(remoteId);
+        if (!object) {
+            throw new Error(`CCMPObjectsManager.getByRemoteID(${remoteId}): object not found.`);
+        }
+        return object;
+    }
+    deleteById(id) {
+        const object = this.getByID(id);
+        object.destroy();
+        return object;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    _register(ccmpObject) {
+        const existingObject = this._findRegistered(ccmpObject);
+        if (existingObject && existingObject.isExists) {
+            return existingObject;
+        }
+        if (existingObject) {
+            this._unregister(existingObject);
+        }
+        const object = new CCMPObject(ccmpObject, (destroyedObject) => {
+            this._unregister(destroyedObject);
+        });
+        this._objects.set(object.id, object);
+        if (object.remoteId !== null) {
+            this._objectsByRemoteId.set(object.remoteId, object);
+        }
+        return object;
+    }
+    _unregister(object) {
+        this._objects.delete(object.id);
+        if (object.remoteId !== null) {
+            this._objectsByRemoteId.delete(object.remoteId);
+        }
+    }
+    _findRegistered(ccmpObject) {
+        var _a, _b, _c;
+        return ((_c = (_b = (ccmpObject.remoteId === null ? null : ((_a = this._objectsByRemoteId.get(ccmpObject.remoteId)) !== null && _a !== void 0 ? _a : null))) !== null && _b !== void 0 ? _b : this._objects.get(ccmpObject.id)) !== null && _c !== void 0 ? _c : null);
+    }
+    _registerLifecycleEvents() {
+        ccmp.on("objectCreated", (ccmpObject) => {
+            if (!ccmpObject)
+                return;
+            const object = this._register(ccmpObject);
+            this._events.emitInternal(ClientInternalEventName.EntityCreated, object);
+        });
+        ccmp.on("objectDestroyed", (ccmpObject) => {
+            var _a;
+            if (!ccmpObject)
+                return;
+            const object = (_a = this._findRegistered(ccmpObject)) !== null && _a !== void 0 ? _a : this._register(ccmpObject);
+            this._events.emitInternal(ClientInternalEventName.EntityDestroyed, object);
+            this._unregister(object);
+        });
+        ccmp.on("objectStreamIn", (ccmpObject) => {
+            if (!ccmpObject)
+                return;
+            const object = this._register(ccmpObject);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamIn, object);
+        });
+        ccmp.on("objectStreamOut", (ccmpObject) => {
+            var _a;
+            if (!ccmpObject)
+                return;
+            const object = (_a = this._findRegistered(ccmpObject)) !== null && _a !== void 0 ? _a : this._register(ccmpObject);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamOut, object);
+        });
+    }
+    *_filter(predicate) {
+        for (const object of this._objects.values()) {
+            if (!object.isExists) {
+                this._unregister(object);
+                continue;
+            }
+            if (predicate(object)) {
+                yield object;
+            }
+        }
+    }
+    _pruneDestroyed() {
+        for (const object of this._objects.values()) {
+            if (!object.isExists) {
+                this._unregister(object);
+            }
+        }
+    }
+}

package/dist/client/entities/ccmp/ped/CCMPPed.d.ts

@@ -0,0 +1,65 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { type IVector3D, Vector3D } from "../../../../shared/common/utils";
+import { type Ped as CcmpPed } from "@classic-mp/types/client";
+import { type IBaseObject } from "../../common/baseObject/IBaseObject";
+import { type IPed } from "../../common/ped/IPed";
+export declare class CCMPPed implements IPed {
+    private readonly _ccmpPed;
+    private readonly _onDestroy;
+    private _destroyed;
+    constructor(_ccmpPed: CcmpPed, _onDestroy?: (ped: CCMPPed) => void);
+    get id(): number;
+    get remoteId(): number | null;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get handle(): number;
+    destroy(): void;
+    get position(): Vector3D;
+    get dimension(): number;
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+    setCoords(xPos: number, yPos: number, zPos: number, xAxis: boolean, yAxis: boolean, zAxis: boolean, clearArea: boolean): void;
+    get model(): number;
+    get heading(): number;
+    setHeading(heading: number): void;
+    setModel(value: string): void;
+    get rotation(): Vector3D;
+    setRotation(value: IVector3D): 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;
+    resetAlpha(): void;
+    getOffsetFromInWorldCoords(offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    getBoneIndexByName(boneName: string): number;
+    getWorldPositionOfBone(boneIndex: number): IVector3D;
+    getVariable(name: string): unknown | null;
+    getSyncedMeta(key: string): unknown | undefined;
+    hasSyncedMeta(key: string): boolean;
+    getSyncedMetaKeys(): readonly string[];
+    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;
+    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;
+    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/ccmp/ped/CCMPPed.js

@@ -0,0 +1,199 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { Vector3D } from "../../../../shared/common/utils";
+export class CCMPPed {
+    constructor(_ccmpPed, _onDestroy = () => { }) {
+        this._ccmpPed = _ccmpPed;
+        this._onDestroy = _onDestroy;
+        this._destroyed = false;
+    }
+    get id() {
+        return this._ccmpPed.id;
+    }
+    get remoteId() {
+        return this._ccmpPed.remoteId;
+    }
+    get type() {
+        return BaseObjectType.Ped;
+    }
+    get isExists() {
+        return !this._destroyed && this._ccmpPed.isAlive;
+    }
+    get handle() {
+        return this._ccmpPed.handle;
+    }
+    destroy() {
+        if (this._destroyed) {
+            return;
+        }
+        this._destroyed = true;
+        this._ccmpPed.destroy();
+        this._onDestroy(this);
+    }
+    get position() {
+        const { x, y, z } = this._ccmpPed.position;
+        return new Vector3D(x, y, z);
+    }
+    get dimension() {
+        return this._ccmpPed.dimension;
+    }
+    setPosition(value) {
+        this._ccmpPed.setPosition(value);
+    }
+    setDimension(value) {
+        this._ccmpPed.setDimension(value);
+    }
+    setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea) {
+        this._ccmpPed.setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea);
+    }
+    get model() {
+        return this._ccmpPed.model;
+    }
+    get heading() {
+        return this._ccmpPed.heading;
+    }
+    setHeading(heading) {
+        this._ccmpPed.setHeading(heading);
+    }
+    setModel(value) {
+        this._ccmpPed.setModel(value);
+    }
+    get rotation() {
+        const { x, y, z } = this._ccmpPed.rotation;
+        return new Vector3D(x, y, z);
+    }
+    setRotation(value) {
+        this._ccmpPed.setRotation(value);
+    }
+    get forwardVector() {
+        const { x, y, z } = this._ccmpPed.forwardVector;
+        return new Vector3D(x, y, z);
+    }
+    freezePosition(freeze) {
+        this._ccmpPed.freezePosition(freeze);
+    }
+    setCollision(collision, keepPhysics) {
+        this._ccmpPed.setCollision(collision, keepPhysics);
+    }
+    setInvincible(invincible) {
+        this._ccmpPed.setInvincible(invincible);
+    }
+    setVisible(visible) {
+        this._ccmpPed.setVisible(visible);
+    }
+    setAlpha(alpha) {
+        this._ccmpPed.setAlpha(alpha);
+    }
+    get alpha() {
+        return this._ccmpPed.alpha;
+    }
+    resetAlpha() {
+        this._ccmpPed.resetAlpha();
+    }
+    getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ) {
+        const { x, y, z } = this._ccmpPed.getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ);
+        return new Vector3D(x, y, z);
+    }
+    getBoneIndexByName(boneName) {
+        return this._ccmpPed.getBoneIndexByName(boneName);
+    }
+    getWorldPositionOfBone(boneIndex) {
+        const { x, y, z } = this._ccmpPed.getWorldPositionOfBone(boneIndex);
+        return new Vector3D(x, y, z);
+    }
+    getVariable(name) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return null;
+        }
+        const value = ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Ped, remoteId, name);
+        return value === undefined ? null : value;
+    }
+    getSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return undefined;
+        }
+        return ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Ped, remoteId, key);
+    }
+    hasSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return false;
+        }
+        return ccmp.entities.hasStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Ped, remoteId, key);
+    }
+    getSyncedMetaKeys() {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return [];
+        }
+        return ccmp.entities.getStreamSyncedMetaKeys(ccmp.entities.ENTITY_TYPE.Ped, remoteId);
+    }
+    attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
+        this._ccmpPed.attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot);
+    }
+    detach(useDetachVelocity, collision) {
+        this._ccmpPed.detach(useDetachVelocity, collision);
+    }
+    getSpeed() {
+        return this._ccmpPed.getSpeed();
+    }
+    isPlayingAnim(dictionary, name, taskFlag) {
+        return this._ccmpPed.isPlayingAnim(dictionary, name, taskFlag);
+    }
+    setDecoration(collection, overlay) {
+        this._ccmpPed.setDecoration(collection, overlay);
+    }
+    removeDecoration(collection, overlay) {
+        this._ccmpPed.removeDecoration(collection, overlay);
+    }
+    clearDecorations() {
+        this._ccmpPed.clearDecorations();
+    }
+    setHeadBlendData(shapeFirstId, shapeSecondId, shapeThirdId, skinFirstId, skinSecondId, skinThirdId, shapeMix, skinMix, thirdMix, isParent) {
+        this._ccmpPed.setHeadBlendData(shapeFirstId, shapeSecondId, shapeThirdId, skinFirstId, skinSecondId, skinThirdId, shapeMix, skinMix, thirdMix, isParent);
+    }
+    setFaceFeature(index, value) {
+        this._ccmpPed.setFaceFeature(index, value);
+    }
+    setHeadOverlay(overlayId, index, opacity) {
+        this._ccmpPed.setHeadOverlay(overlayId, index, opacity);
+    }
+    setHeadOverlayColor(overlayId, colorTypeId, firstColor, secondColor) {
+        this._ccmpPed.setHeadOverlayColor(overlayId, colorTypeId, firstColor, secondColor);
+    }
+    setEyeColor(eyeColor) {
+        this._ccmpPed.setEyeColor(eyeColor);
+    }
+    setHairColor(colorId, highlightColorId) {
+        this._ccmpPed.setHairColor(colorId, highlightColorId);
+    }
+    setComponentVariation(componentId, drawableId, textureId, paletteId) {
+        this._ccmpPed.setComponentVariation(componentId, drawableId, textureId, paletteId);
+    }
+    setPropertyVariation(componentId, drawableId, textureId, attach) {
+        this._ccmpPed.setPropertyVariation(componentId, drawableId, textureId, attach);
+    }
+    clearProp(componentId) {
+        this._ccmpPed.clearProp(componentId);
+    }
+    getBoneCoords(boneId, offsetX, offsetY, offsetZ) {
+        const { x, y, z } = this._ccmpPed.getBoneCoords(boneId, offsetX, offsetY, offsetZ);
+        return new Vector3D(x, y, z);
+    }
+    clearTasks() {
+        this._ccmpPed.clearTasks();
+    }
+    taskPlayAnim(dictionary, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate) {
+        this._ccmpPed.taskPlayAnim(dictionary, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate);
+    }
+    taskGoToCoordAnyMeans(x, y, z, speed, walkingStyle, drivingFlags) {
+        this._ccmpPed.taskGoToCoordAnyMeans(x, y, z, speed, walkingStyle, drivingFlags);
+    }
+    stopAnim(dictionary, name, blendOutSpeed) {
+        this._ccmpPed.stopAnim(dictionary, name, blendOutSpeed);
+    }
+    setBlockingOfNonTemporaryEvents(blocking) {
+        this._ccmpPed.setBlockingOfNonTemporaryEvents(blocking);
+    }
+}