rock-mod 0.19.0 → 0.21.0

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

@@ -0,0 +1,332 @@
+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._warnOnce("taskEnterVehicle");
+    }
+    clearTasks() {
+        this._warnOnce("clearTasks");
+    }
+    clearTasksImmediately() {
+        this._warnOnce("clearTasksImmediately");
+    }
+    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();

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

@@ -0,0 +1,84 @@
+import { type CCMPEventsManager } from "../../../net/ccmp/events/CCMPEventsManager";
+import { type IPlayersManager } from "../../common/player/IPlayersManager";
+import { type IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { CCMPPlayer } from "./CCMPPlayer";
+/**
+ * Реализация `IPlayersManager` под CCMP — single source of truth для
+ * `IPlayer`-инстансов и `rm::playerReady`/`rm::playerConnected`-эмиссий
+ * с настоящими `CCMPPlayer`-инстансами.
+ *
+ * ### Хранилище
+ *
+ * `Map<id, CCMPPlayer>`. У CCMP нет отдельных `id`/`remoteId` как в RageMP:
+ * один числовой `id` приходит от сервера, и он же используется везде.
+ * `findByID`/`findByRemoteID`/`findByRemoteId` маппятся на один lookup.
+ *
+ * ### Жизненный цикл local player'а
+ *
+ * `ccmp.players.local` (backed by `op_get_local_player_id`) валиден сразу
+ * после handshake'а — `PlayerManager::set_local_player_id` срабатывает до
+ * того, как scripts загружаются. Мы используем его, чтобы синхронно
+ * выпустить `rm::playerReady` как sticky-event (см. ниже):
+ *
+ *  1. **На конструкторе** — fast-path. Если local op возвращает игрока,
+ *     эмитим `rm::playerReady` через `emitInternalSticky` с реальным
+ *     `CCMPPlayer`-инстансом. Sticky-кэш гарантирует, что поздние
+ *     подписчики из async DI-bootstrap'а геймода тоже получат сигнал
+ *     при подписке.
+ *  2. **На `connectionStateChanged`** — fallback / handler реконнекта.
+ *     Если на конструкторе local ещё не был валиден (handshake race),
+ *     `connected = true` запустит retry fast-path. На `connected = false`
+ *     чистим _localPlayer и sticky-кэш, чтобы при следующем connect'е
+ *     эмитнуть с актуальным remoteId.
+ *
+ * `CCMPPlayer`-инстанс важен (а не структурный stub) потому что
+ * `RockModStateAdapter` в геймоде хранит `rockModPlayer`-ссылку и через
+ * неё вызывает методы (`setNoCollision`, etc). На структурном stub'е
+ * без методов это падало бы с `TypeError`.
+ *
+ * ### Remote-игроки
+ *
+ * Источники:
+ *  - `ccmp.players.all` — prepopulation для уже-существующих на момент
+ *    подключения (заполнен Rust'ом в `ClientScriptingService::init`).
+ *  - `rm::playerConnected`/`rm::playerDisconnected` internal events
+ *    (эмитит `CCMPEventsBridge` из нативных `ccmp.on('playerConnected'/...)`).
+ */
+export declare class CCMPPlayersManager implements IPlayersManager {
+    private readonly _players;
+    private readonly _events;
+    private _localPlayer;
+    constructor(events: CCMPEventsManager);
+    findLocalPlayer(): CCMPPlayer | null;
+    getLocalPlayer(): CCMPPlayer;
+    findByRemoteId(remoteId: number): CCMPPlayer | null;
+    getByRemoteId(remoteId: number): CCMPPlayer;
+    findByName(name: string): CCMPPlayer | null;
+    getByName(name: string): CCMPPlayer;
+    syncWithMpPool(): void;
+    registerById(id: number): CCMPPlayer;
+    unregisterById(id: number): CCMPPlayer;
+    findByID(id: number): CCMPPlayer | null;
+    getByID(id: number): CCMPPlayer;
+    findByRemoteID(remoteId: number): CCMPPlayer | null;
+    getByRemoteID(remoteId: number): CCMPPlayer;
+    deleteById(id: number): CCMPPlayer;
+    get iterator(): IWorldObjectsIterator<CCMPPlayer>;
+    private _registerNativePlayerEvents;
+    /**
+     * Идемпотентная точка создания/обновления CCMPPlayer. Все источники
+     * (events, prepopulation, fast-path) проходят сюда.
+     */
+    private _ensurePlayer;
+    /**
+     * Пытается синхронно достать local player из CCMP, создать CCMPPlayer
+     * и эмитнуть rm::playerReady как sticky-event. Идемпотентна: повторный
+     * вызов после успешной эмиссии — no-op (`_localPlayer !== null`).
+     */
+    private _tryEmitLocalPlayerReady;
+    private _handleDisconnect;
+    private readonly _iterator;
+    private _iterateDimension;
+    private _iterateRange2D;
+    private _iterateRange3D;
+}