rock-mod 0.20.0 → 0.22.0

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

@@ -0,0 +1,27 @@
+import { type CCMPEventsManager } from "../../../net/ccmp/events/CCMPEventsManager";
+import { type IPedCreateOptions, type IPedsManager } from "../../common/ped/IPedsManager";
+import { type IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { CCMPPed } from "./CCMPPed";
+export declare class CCMPPedsManager implements IPedsManager {
+    private readonly _events;
+    private readonly _peds;
+    private readonly _pedsByRemoteId;
+    private readonly _iterator;
+    constructor(_events: CCMPEventsManager);
+    create(options: IPedCreateOptions): CCMPPed;
+    syncWithMpPool(): void;
+    registerById(id: number): CCMPPed;
+    unregisterById(id: number): CCMPPed;
+    findByID(id: number): CCMPPed | null;
+    getByID(id: number): CCMPPed;
+    findByRemoteID(remoteId: number): CCMPPed | null;
+    getByRemoteID(remoteId: number): CCMPPed;
+    deleteById(id: number): CCMPPed;
+    get iterator(): IWorldObjectsIterator<CCMPPed>;
+    private _filter;
+    private _register;
+    private _unregister;
+    private _findRegistered;
+    private _registerStreamEvents;
+    private _pruneDestroyed;
+}

package/dist/client/entities/ccmp/ped/CCMPPedsManager.js

@@ -0,0 +1,177 @@
+import { ClientInternalEventName } from "../../../net/common/events/types";
+import { CCMPPed } from "./CCMPPed";
+export class CCMPPedsManager {
+    constructor(_events) {
+        this._events = _events;
+        this._peds = new Map();
+        this._pedsByRemoteId = new Map();
+        this._iterator = {
+            all: () => this._filter(() => true),
+            dimension: (value) => this._filter((ped) => ped.dimension === value),
+            range2D: (center, range) => this._filter((ped) => {
+                const position = ped.position;
+                const squaredDistance = (position.x - center.x) ** 2 + (position.y - center.y) ** 2;
+                return squaredDistance <= range * range;
+            }),
+            range3D: (center, range) => this._filter((ped) => ped.position.isInRange(center, range)),
+        };
+        this._registerStreamEvents();
+        this.syncWithMpPool();
+    }
+    create(options) {
+        const { model, position, rotation, dimension } = options;
+        const ccmpPed = ccmp.peds.create(model, position, rotation.z, { dimension });
+        if (!ccmpPed) {
+            throw new Error(`CCMPPedsManager.create: ccmp.peds.create failed for model "${model}"`);
+        }
+        return this._register(ccmpPed);
+    }
+    syncWithMpPool() {
+        this._pruneDestroyed();
+        for (const ccmpPed of ccmp.peds.all) {
+            this._register(ccmpPed);
+        }
+    }
+    registerById(id) {
+        const existingPed = this.findByID(id);
+        if (existingPed) {
+            return existingPed;
+        }
+        const ccmpPed = ccmp.peds.getById(id);
+        if (!ccmpPed) {
+            throw new Error(`CCMPPedsManager.registerById(${id}): ped not found.`);
+        }
+        return this._register(ccmpPed);
+    }
+    unregisterById(id) {
+        return this.deleteById(id);
+    }
+    findByID(id) {
+        var _a;
+        const ped = (_a = this._peds.get(id)) !== null && _a !== void 0 ? _a : null;
+        if (ped && !ped.isExists) {
+            this._unregister(ped);
+        }
+        else if (ped) {
+            return ped;
+        }
+        const ccmpPed = ccmp.peds.getById(id);
+        if (!ccmpPed) {
+            return null;
+        }
+        return this._register(ccmpPed);
+    }
+    getByID(id) {
+        const ped = this.findByID(id);
+        if (!ped) {
+            throw new Error(`CCMPPedsManager.getByID(${id}): ped not found.`);
+        }
+        return ped;
+    }
+    findByRemoteID(remoteId) {
+        var _a;
+        const ped = (_a = this._pedsByRemoteId.get(remoteId)) !== null && _a !== void 0 ? _a : null;
+        if (ped && !ped.isExists) {
+            this._unregister(ped);
+        }
+        else if (ped) {
+            return ped;
+        }
+        const ccmpPed = ccmp.peds.getByRemoteId(remoteId);
+        if (!ccmpPed) {
+            return null;
+        }
+        return this._register(ccmpPed);
+    }
+    getByRemoteID(remoteId) {
+        const ped = this.findByRemoteID(remoteId);
+        if (!ped) {
+            throw new Error(`CCMPPedsManager.getByRemoteID(${remoteId}): ped not found.`);
+        }
+        return ped;
+    }
+    deleteById(id) {
+        const ped = this.getByID(id);
+        ped.destroy();
+        return ped;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    *_filter(predicate) {
+        for (const ped of this._peds.values()) {
+            if (!ped.isExists) {
+                this._unregister(ped);
+                continue;
+            }
+            if (predicate(ped)) {
+                yield ped;
+            }
+        }
+    }
+    _register(ccmpPed) {
+        const existingPed = this._findRegistered(ccmpPed);
+        if (existingPed && existingPed.isExists) {
+            return existingPed;
+        }
+        if (existingPed) {
+            this._unregister(existingPed);
+        }
+        const ped = new CCMPPed(ccmpPed, (destroyedPed) => {
+            this._unregister(destroyedPed);
+        });
+        this._peds.set(ped.id, ped);
+        if (ped.remoteId !== null) {
+            this._pedsByRemoteId.set(ped.remoteId, ped);
+        }
+        return ped;
+    }
+    _unregister(ped) {
+        this._peds.delete(ped.id);
+        if (ped.remoteId !== null) {
+            this._pedsByRemoteId.delete(ped.remoteId);
+        }
+    }
+    _findRegistered(ccmpPed) {
+        var _a, _b, _c;
+        return ((_c = (_b = (ccmpPed.remoteId === null ? null : ((_a = this._pedsByRemoteId.get(ccmpPed.remoteId)) !== null && _a !== void 0 ? _a : null))) !== null && _b !== void 0 ? _b : this._peds.get(ccmpPed.id)) !== null && _c !== void 0 ? _c : null);
+    }
+    _registerStreamEvents() {
+        ccmp.on("pedCreated", (ccmpPed) => {
+            if (ccmpPed) {
+                const ped = this._register(ccmpPed);
+                this._events.emitInternal(ClientInternalEventName.EntityCreated, ped);
+            }
+        });
+        ccmp.on("pedDestroyed", (ccmpPed) => {
+            var _a;
+            if (ccmpPed) {
+                const ped = (_a = this._findRegistered(ccmpPed)) !== null && _a !== void 0 ? _a : this._register(ccmpPed);
+                this._events.emitInternal(ClientInternalEventName.EntityDestroyed, ped);
+                this._unregister(ped);
+            }
+        });
+        ccmp.on("pedStreamIn", (ccmpPed) => {
+            if (ccmpPed) {
+                const ped = this._register(ccmpPed);
+                this._events.emitInternal(ClientInternalEventName.EntityStreamIn, ped);
+            }
+        });
+        ccmp.on("pedStreamOut", (ccmpPed) => {
+            var _a;
+            if (ccmpPed) {
+                const ped = (_a = this._findRegistered(ccmpPed)) !== null && _a !== void 0 ? _a : this._register(ccmpPed);
+                if (ped) {
+                    this._events.emitInternal(ClientInternalEventName.EntityStreamOut, ped);
+                }
+            }
+        });
+    }
+    _pruneDestroyed() {
+        for (const ped of this._peds.values()) {
+            if (!ped.isExists) {
+                this._unregister(ped);
+            }
+        }
+    }
+}

package/dist/client/entities/ccmp/player/CCMPPlayer.d.ts

@@ -0,0 +1,112 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { type IBaseObject } from "../../common/baseObject/IBaseObject";
+import { type IPlayer } from "../../common/player/IPlayer";
+import { type IVehicle } from "../../common/vehicle/IVehicle";
+import { type IVector3D } from "../../../../shared/common/utils";
+export interface ICCMPPlayerOptions {
+    /** Network id of the player (same as remoteId — CCMP exposes only one id). */
+    readonly id: number;
+    /** Human-readable name from the handshake. May be empty if not yet known. */
+    readonly name: string;
+    /** `true` if this Player represents the local user, `false` for remotes. */
+    readonly isLocal: boolean;
+}
+/**
+ * CCMP implementation of the Rock-Mod player facade.
+ *
+ * Identity and synced meta are tracked by id. Runtime entity operations are
+ * delegated to `ccmp.players.getById(id)`, whose `handle` is live for the
+ * local player and for streamed remote players. Missing remote handles degrade
+ * to safe defaults/no-ops, matching RageMP-style best-effort client behavior.
+ */
+export declare class CCMPPlayer implements IPlayer {
+    /** Глобальный set для one-time warnings, чтобы не флудить лог. */
+    private static readonly _warnedMethods;
+    private readonly _id;
+    private _name;
+    private readonly _isLocal;
+    private _isExists;
+    constructor(options: ICCMPPlayerOptions);
+    /** Помечает игрока как удалённого — вызывается из `CCMPPlayersManager`. */
+    markRemoved(): void;
+    /** Обновляет name (полезно если name приехал позже первого создания). */
+    setNameInternal(name: string): void;
+    get id(): number;
+    get remoteId(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get handle(): number;
+    destroy(): void;
+    get position(): IVector3D;
+    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(): IVector3D;
+    setRotation(value: IVector3D): void;
+    get forwardVector(): IVector3D;
+    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;
+    get name(): string;
+    get health(): number;
+    get armour(): number;
+    get isDead(): boolean;
+    get vehicle(): IVehicle | 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;
+    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;
+    private _getNativePlayer;
+    private _withHandle;
+    private _withHandleVoid;
+    private _warnOnce;
+}

package/dist/client/entities/ccmp/player/CCMPPlayer.js

@@ -0,0 +1,338 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { Vector3D } from "../../../../shared/common/utils";
+const ZERO_VECTOR = new Vector3D(0, 0, 0);
+/**
+ * CCMP implementation of the Rock-Mod player facade.
+ *
+ * Identity and synced meta are tracked by id. Runtime entity operations are
+ * delegated to `ccmp.players.getById(id)`, whose `handle` is live for the
+ * local player and for streamed remote players. Missing remote handles degrade
+ * to safe defaults/no-ops, matching RageMP-style best-effort client behavior.
+ */
+export class CCMPPlayer {
+    constructor(options) {
+        this._id = options.id;
+        this._name = options.name;
+        this._isLocal = options.isLocal;
+        this._isExists = true;
+    }
+    /** Помечает игрока как удалённого — вызывается из `CCMPPlayersManager`. */
+    markRemoved() {
+        this._isExists = false;
+    }
+    /** Обновляет name (полезно если name приехал позже первого создания). */
+    setNameInternal(name) {
+        if (name) {
+            this._name = name;
+        }
+    }
+    // -- IBaseObject ----------------------------------------------------------
+    get id() {
+        return this._id;
+    }
+    get remoteId() {
+        return this._id;
+    }
+    get type() {
+        return BaseObjectType.Player;
+    }
+    get isExists() {
+        return this._isExists;
+    }
+    get handle() {
+        var _a, _b;
+        return (_b = (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.handle) !== null && _b !== void 0 ? _b : 0;
+    }
+    destroy() {
+        this._warnOnce("destroy");
+    }
+    // -- IWorldObject ---------------------------------------------------------
+    get position() {
+        var _a;
+        const position = (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.position;
+        return position ? new Vector3D(position.x, position.y, position.z) : ZERO_VECTOR;
+    }
+    get dimension() {
+        return 0;
+    }
+    setPosition(value) {
+        var _a;
+        (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.setPosition(value);
+    }
+    setDimension(_value) {
+        this._warnOnce("setDimension");
+    }
+    setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea) {
+        var _a;
+        (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea);
+    }
+    // -- IEntity --------------------------------------------------------------
+    get model() {
+        return this._withHandle(0, (handle) => ccmp.natives.entity.getEntityModel(handle));
+    }
+    get heading() {
+        var _a, _b;
+        return (_b = (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.heading) !== null && _b !== void 0 ? _b : 0;
+    }
+    setHeading(heading) {
+        var _a;
+        (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.setHeading(heading);
+    }
+    setModel(_value) {
+        this._warnOnce("setModel");
+    }
+    get rotation() {
+        return this._withHandle(ZERO_VECTOR, (handle) => {
+            const rotation = ccmp.natives.entity.getEntityRotation(handle, 2);
+            return new Vector3D(rotation.x, rotation.y, rotation.z);
+        });
+    }
+    setRotation(value) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.setEntityRotation(handle, value.x, value.y, value.z, 2, true);
+        });
+    }
+    get forwardVector() {
+        return this._withHandle(ZERO_VECTOR, (handle) => {
+            const vector = ccmp.natives.entity.getEntityForwardVector(handle);
+            return new Vector3D(vector.x, vector.y, vector.z);
+        });
+    }
+    freezePosition(freeze) {
+        var _a;
+        (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.freezePosition(freeze);
+    }
+    setCollision(collision, keepPhysics) {
+        var _a;
+        (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.setCollision(collision, keepPhysics);
+    }
+    setInvincible(invincible) {
+        var _a;
+        (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.setInvincible(invincible);
+    }
+    setVisible(visible) {
+        var _a;
+        (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.setVisible(visible);
+    }
+    setAlpha(alpha) {
+        var _a;
+        (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.setAlpha(alpha);
+    }
+    get alpha() {
+        var _a, _b;
+        return (_b = (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.alpha) !== null && _b !== void 0 ? _b : 255;
+    }
+    resetAlpha() {
+        var _a;
+        (_a = this._getNativePlayer()) === null || _a === void 0 ? void 0 : _a.resetAlpha();
+    }
+    getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ) {
+        return this._withHandle(ZERO_VECTOR, (handle) => {
+            const position = ccmp.natives.entity.getOffsetFromEntityInWorldCoords(handle, offsetX, offsetY, offsetZ);
+            return new Vector3D(position.x, position.y, position.z);
+        });
+    }
+    getBoneIndexByName(boneName) {
+        return this._withHandle(-1, (handle) => ccmp.natives.entity.getEntityBoneIndexByName(handle, boneName));
+    }
+    getWorldPositionOfBone(boneIndex) {
+        return this._withHandle(ZERO_VECTOR, (handle) => {
+            const position = ccmp.natives.entity.getWorldPositionOfEntityBone(handle, boneIndex);
+            return new Vector3D(position.x, position.y, position.z);
+        });
+    }
+    getVariable(name) {
+        const value = ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Player, this._id, name);
+        return value === undefined ? null : value;
+    }
+    getSyncedMeta(key) {
+        return ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Player, this._id, key);
+    }
+    hasSyncedMeta(key) {
+        return ccmp.entities.hasStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Player, this._id, key);
+    }
+    getSyncedMetaKeys() {
+        return ccmp.entities.getStreamSyncedMetaKeys(ccmp.entities.ENTITY_TYPE.Player, this._id);
+    }
+    attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.attachEntityToEntity(handle, target.handle, 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));
+    }
+    // -- IPlayer --------------------------------------------------------------
+    get name() {
+        return this._name;
+    }
+    get health() {
+        return 100;
+    }
+    get armour() {
+        return 0;
+    }
+    get isDead() {
+        return false;
+    }
+    get vehicle() {
+        return null;
+    }
+    get isVoice3DEnabled() {
+        return false;
+    }
+    get voiceVolume() {
+        return 0;
+    }
+    get isVoiceActive() {
+        return false;
+    }
+    setVoice3D(_enable) {
+        this._warnOnce("setVoice3D");
+    }
+    setVoiceVolume(_volume) {
+        this._warnOnce("setVoiceVolume");
+    }
+    get isReloading() {
+        return false;
+    }
+    get weapon() {
+        return 0;
+    }
+    getAmmoInClip(_weapon) {
+        return 0;
+    }
+    getWeaponAmmo(_weapon) {
+        return 0;
+    }
+    getBoneIndex(boneId) {
+        return this._withHandle(-1, (handle) => ccmp.natives.ped.getPedBoneIndex(handle, boneId));
+    }
+    setDecoration(_collection, _overlay) {
+        this._warnOnce("setDecoration");
+    }
+    removeDecoration(_collection, _overlay) {
+        this._warnOnce("removeDecoration");
+    }
+    clearDecorations() {
+        this._warnOnce("clearDecorations");
+    }
+    setHeadBlendData(_shapeFirstId, _shapeSecondId, _shapeThirdId, _skinFirstId, _skinSecondId, _skinThirdId, _shapeMix, _skinMix, _thirdMix, _isParent) {
+        this._warnOnce("setHeadBlendData");
+    }
+    setFaceFeature(_index, _value) {
+        this._warnOnce("setFaceFeature");
+    }
+    setHeadOverlay(_overlayId, _index, _opacity, _firstColor, _secondColor) {
+        this._warnOnce("setHeadOverlay");
+    }
+    setHeadOverlayColor(_overlayId, _colorTypeId, _firstColor, _secondColor) {
+        this._warnOnce("setHeadOverlayColor");
+    }
+    setEyeColor(_eyeColor) {
+        this._warnOnce("setEyeColor");
+    }
+    setHairColor(_colorId, _highlightColorId) {
+        this._warnOnce("setHairColor");
+    }
+    setComponentVariation(_componentId, _drawableId, _textureId, _paletteId) {
+        this._warnOnce("setComponentVariation");
+    }
+    setPropertyVariation(_componentId, _drawableId, _textureId, _attach) {
+        this._warnOnce("setPropertyVariation");
+    }
+    clearProp(_componentId) {
+        this._warnOnce("clearProp");
+    }
+    get isLocalPlayer() {
+        return this._isLocal;
+    }
+    taskSwapWeapon() {
+        this._warnOnce("taskSwapWeapon");
+    }
+    taskEnterVehicle(vehicleHandle, timeout, seat, speed, flag, _p6) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.task.taskEnterVehicle(handle, vehicleHandle, timeout, seat, speed, flag, "");
+        });
+    }
+    clearTasks() {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.task.clearPedTasks(handle);
+        });
+    }
+    clearTasksImmediately() {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.task.clearPedTasksImmediately(handle);
+        });
+    }
+    taskPlayAnim(_dictionary, _name, _blendInSpeed, _blendOutSpeed, _duration, _flag, _playbackRate, _lockX, _lockY, _lockZ) {
+        this._warnOnce("taskPlayAnim");
+    }
+    stopAnim(_dictionary, _name, _blendOutSpeed) {
+        this._warnOnce("stopAnim");
+    }
+    setMovementClipset(_clipset, _speed) {
+        this._warnOnce("setMovementClipset");
+    }
+    resetMovementClipset(_blendDuration) {
+        this._warnOnce("resetMovementClipset");
+    }
+    getBoneCoords(boneId, offsetX, offsetY, offsetZ) {
+        return this._withHandle(ZERO_VECTOR, (handle) => {
+            const position = ccmp.natives.ped.getPedBoneCoords(handle, boneId, offsetX, offsetY, offsetZ);
+            return new Vector3D(position.x, position.y, position.z);
+        });
+    }
+    setNoCollision(otherHandle, thisFrameOnly) {
+        this._withHandleVoid((handle) => {
+            if (otherHandle !== 0) {
+                ccmp.natives.entity.setEntityNoCollisionEntity(handle, otherHandle, thisFrameOnly);
+            }
+        });
+    }
+    _getNativePlayer() {
+        try {
+            const player = ccmp.players.getById(this._id);
+            if (player) {
+                return player;
+            }
+            const localPlayer = ccmp.players.local;
+            return (localPlayer === null || localPlayer === void 0 ? void 0 : localPlayer.id) === this._id ? localPlayer : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    _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);
+    }
+    _warnOnce(method) {
+        if (CCMPPlayer._warnedMethods.has(method)) {
+            return;
+        }
+        CCMPPlayer._warnedMethods.add(method);
+        console.warn(`[CCMPPlayer] ${method}() пока не реализован для CCMP — вызов проигнорирован ` +
+            `(следующие вызовы этого метода будут проигнорированы молча).`);
+    }
+}
+/** Глобальный set для one-time warnings, чтобы не флудить лог. */
+CCMPPlayer._warnedMethods = new Set();