rock-mod 0.20.0 → 0.22.0

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

@@ -0,0 +1,85 @@
+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>`. For CCMP players only, `id` and `remoteId` still
+ * mean the same server/network id. Non-player CCMP wrappers have a separate
+ * client-local `id` and nullable server `remoteId`.
+ * `findByID`/`findByRemoteID`/`findByRemoteId` map to one lookup for players.
+ *
+ * ### Жизненный цикл 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;
+}

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

@@ -0,0 +1,331 @@
+import { ClientInternalEventName } from "../../../net/common/events/types";
+import { CCMPPlayer } from "./CCMPPlayer";
+/**
+ * Реализация `IPlayersManager` под CCMP — single source of truth для
+ * `IPlayer`-инстансов и `rm::playerReady`/`rm::playerConnected`-эмиссий
+ * с настоящими `CCMPPlayer`-инстансами.
+ *
+ * ### Хранилище
+ *
+ * `Map<id, CCMPPlayer>`. For CCMP players only, `id` and `remoteId` still
+ * mean the same server/network id. Non-player CCMP wrappers have a separate
+ * client-local `id` and nullable server `remoteId`.
+ * `findByID`/`findByRemoteID`/`findByRemoteId` map to one lookup for players.
+ *
+ * ### Жизненный цикл 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 class CCMPPlayersManager {
+    constructor(events) {
+        var _a;
+        this._players = new Map();
+        this._localPlayer = null;
+        // Iterator реализован inline — у CCMP нет per-dimension/per-range
+        // фильтрации игроков на JS-уровне.
+        this._iterator = {
+            all: () => this._players.values(),
+            dimension: (value) => this._iterateDimension(value),
+            range2D: (center, range) => this._iterateRange2D(center, range),
+            range3D: (center, range) => this._iterateRange3D(center, range),
+        };
+        this._events = events;
+        // 1) Subscribe ПЕРВЫМ — чтобы между подпиской и prepopulation'ом не
+        // пропустить параллельный `rm::playerConnected`.
+        this._events.onInternal({
+            [ClientInternalEventName.PlayerReady]: (player) => {
+                // Если кто-то ещё эмитнул rm::playerReady (например, cooperation
+                // fallback в будущем) — синхронизируем своё состояние.
+                const remoteId = player.remoteId;
+                if (remoteId === null) {
+                    return;
+                }
+                this._ensurePlayer(remoteId, player.name, /* isLocal */ true);
+            },
+            [ClientInternalEventName.PlayerConnected]: (player) => {
+                const remoteId = player.remoteId;
+                if (remoteId === null) {
+                    return;
+                }
+                this._ensurePlayer(remoteId, player.name, /* isLocal */ false);
+            },
+            [ClientInternalEventName.PlayerDisconnected]: (player) => {
+                const remoteId = player.remoteId;
+                if (remoteId === null) {
+                    return;
+                }
+                const existing = this._players.get(remoteId);
+                if (existing) {
+                    existing.markRemoved();
+                    this._players.delete(remoteId);
+                }
+            },
+        });
+        this._registerNativePlayerEvents();
+        // 2) Prepopulate уже-существующих remote-игроков из CCMP-runtime'а.
+        // `ccmp.players.all` исключает local (см. js_runtime.rs::setup_globals).
+        try {
+            for (const ccmpPlayer of ccmp.players.all) {
+                this._ensurePlayer(ccmpPlayer.id, (_a = ccmpPlayer.name) !== null && _a !== void 0 ? _a : "", /* isLocal */ false);
+            }
+        }
+        catch (error) {
+            console.warn("[CCMPPlayersManager] failed to prepopulate from ccmp.players.all:", error);
+        }
+        // 3) Fast-path: попытка эмитнуть rm::playerReady сразу. Если local не
+        // готов (handshake ещё не отработал) — пропускаем, дальше connectionStateChanged
+        // подберёт.
+        this._tryEmitLocalPlayerReady();
+        // 4) Retry-on-reconnect + reset-on-disconnect. Listener регистрируем
+        // через `ccmp.on` напрямую (не через bridge), чтобы наша логика была
+        // независимой от состояния других менеджеров.
+        ccmp.on("connectionStateChanged", (state) => {
+            if (state === null || state === void 0 ? void 0 : state.connected) {
+                this._tryEmitLocalPlayerReady();
+            }
+            else {
+                this._handleDisconnect();
+            }
+        });
+    }
+    // -- IPlayersManager ------------------------------------------------------
+    findLocalPlayer() {
+        // Кэшированный _localPlayer проставлен из rm::playerReady-эмиссии
+        // (либо нашей собственной из конструктора, либо чьей-то ещё).
+        // Если кэш пуст, lazy-retry: возможно local op теперь валиден.
+        if (this._localPlayer) {
+            return this._localPlayer;
+        }
+        this._tryEmitLocalPlayerReady();
+        return this._localPlayer;
+    }
+    getLocalPlayer() {
+        const player = this.findLocalPlayer();
+        if (!player) {
+            throw new Error("CCMPPlayersManager.getLocalPlayer: local player ещё не известен — handshake не завершён");
+        }
+        return player;
+    }
+    findByRemoteId(remoteId) {
+        var _a;
+        return (_a = this._players.get(remoteId)) !== null && _a !== void 0 ? _a : null;
+    }
+    getByRemoteId(remoteId) {
+        const player = this.findByRemoteId(remoteId);
+        if (!player) {
+            throw new Error(`CCMPPlayersManager.getByRemoteId: player remoteId=${remoteId} не найден`);
+        }
+        return player;
+    }
+    findByName(name) {
+        for (const player of this._players.values()) {
+            if (player.name === name) {
+                return player;
+            }
+        }
+        return null;
+    }
+    getByName(name) {
+        const player = this.findByName(name);
+        if (!player) {
+            throw new Error(`CCMPPlayersManager.getByName: player name="${name}" не найден`);
+        }
+        return player;
+    }
+    // -- IEntitiesManager -----------------------------------------------------
+    syncWithMpPool() {
+        // RageMP-pool API не существует под CCMP. Игроки управляются событиями
+        // `rm::playerConnected`/`rm::playerDisconnected`, prepopulation идёт
+        // из `ccmp.players.all` в конструкторе. No-op для соответствия интерфейсу.
+    }
+    registerById(id) {
+        // Под CCMP мы не можем "достать" игрока по id из глобального пула без
+        // дополнительных данных (name, isLocal). Возвращаем существующего или
+        // создаём минимальный stub. Корректный путь регистрации — через события.
+        return this._ensurePlayer(id, /* name */ "", /* isLocal */ false);
+    }
+    unregisterById(id) {
+        return this.deleteById(id);
+    }
+    // -- IBaseObjectsManager / IWorldObjectsManager ---------------------------
+    findByID(id) {
+        return this.findByRemoteId(id);
+    }
+    getByID(id) {
+        return this.getByRemoteId(id);
+    }
+    findByRemoteID(remoteId) {
+        return this.findByRemoteId(remoteId);
+    }
+    getByRemoteID(remoteId) {
+        return this.getByRemoteId(remoteId);
+    }
+    deleteById(id) {
+        const player = this.getByRemoteId(id);
+        player.markRemoved();
+        this._players.delete(id);
+        if (this._localPlayer === player) {
+            this._localPlayer = null;
+            this._events.clearInternalSticky(ClientInternalEventName.PlayerReady);
+        }
+        return player;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    // -- Внутреннее -----------------------------------------------------------
+    _registerNativePlayerEvents() {
+        ccmp.on("playerConnected", (ccmpPlayer) => {
+            var _a;
+            const player = this._ensurePlayer(ccmpPlayer.id, (_a = ccmpPlayer.name) !== null && _a !== void 0 ? _a : "", /* isLocal */ false);
+            this._events.emitInternal(ClientInternalEventName.PlayerConnected, player);
+        });
+        ccmp.on("playerDisconnected", (ccmpPlayer) => {
+            var _a, _b;
+            const player = (_a = this._players.get(ccmpPlayer.id)) !== null && _a !== void 0 ? _a : this._ensurePlayer(ccmpPlayer.id, (_b = ccmpPlayer.name) !== null && _b !== void 0 ? _b : "", /* isLocal */ false);
+            player.markRemoved();
+            this._players.delete(ccmpPlayer.id);
+            if (this._localPlayer === player) {
+                this._localPlayer = null;
+                this._events.clearInternalSticky(ClientInternalEventName.PlayerReady);
+            }
+            this._events.emitInternal(ClientInternalEventName.PlayerDisconnected, player);
+        });
+        ccmp.on("playerStreamIn", (ccmpPlayer) => {
+            var _a;
+            const player = this._ensurePlayer(ccmpPlayer.id, (_a = ccmpPlayer.name) !== null && _a !== void 0 ? _a : "", /* isLocal */ false);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamIn, player);
+        });
+        ccmp.on("playerStreamOut", (ccmpPlayer) => {
+            var _a, _b;
+            const player = (_a = this._players.get(ccmpPlayer.id)) !== null && _a !== void 0 ? _a : this._ensurePlayer(ccmpPlayer.id, (_b = ccmpPlayer.name) !== null && _b !== void 0 ? _b : "", /* isLocal */ false);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamOut, player);
+        });
+    }
+    /**
+     * Идемпотентная точка создания/обновления CCMPPlayer. Все источники
+     * (events, prepopulation, fast-path) проходят сюда.
+     */
+    _ensurePlayer(id, name, isLocal) {
+        const existing = this._players.get(id);
+        if (existing) {
+            if (name) {
+                existing.setNameInternal(name);
+            }
+            if (isLocal && !this._localPlayer) {
+                this._localPlayer = existing;
+            }
+            return existing;
+        }
+        const player = new CCMPPlayer({
+            id,
+            name,
+            isLocal,
+        });
+        this._players.set(id, player);
+        if (isLocal) {
+            this._localPlayer = player;
+        }
+        return player;
+    }
+    /**
+     * Пытается синхронно достать local player из CCMP, создать CCMPPlayer
+     * и эмитнуть rm::playerReady как sticky-event. Идемпотентна: повторный
+     * вызов после успешной эмиссии — no-op (`_localPlayer !== null`).
+     */
+    _tryEmitLocalPlayerReady() {
+        var _a;
+        if (this._localPlayer) {
+            return;
+        }
+        let nativeLocal;
+        try {
+            nativeLocal = ccmp.players.local;
+        }
+        catch (error) {
+            console.warn("[CCMPPlayersManager] ccmp.players.local read failed:", error);
+            return;
+        }
+        if (!nativeLocal) {
+            return;
+        }
+        const localPlayer = this._ensurePlayer(nativeLocal.id, (_a = nativeLocal.name) !== null && _a !== void 0 ? _a : "", /* isLocal */ true);
+        // Sticky: поздние подписчики из async DI-bootstrap'а геймода
+        // (например `RockModMultiplayerEventsAdapter` из NetworkModule.init)
+        // получат событие сразу при подписке.
+        this._events.emitInternalSticky(ClientInternalEventName.PlayerReady, localPlayer);
+    }
+    _handleDisconnect() {
+        if (this._localPlayer) {
+            this._localPlayer.markRemoved();
+            this._players.delete(this._localPlayer.id);
+            this._localPlayer = null;
+        }
+        // Чистим sticky-кэш — иначе новые подписчики после reconnect'а получат
+        // устаревший local-player stub с прошлым remoteId.
+        this._events.clearInternalSticky(ClientInternalEventName.PlayerReady);
+    }
+    *_iterateDimension(value) {
+        for (const player of this._players.values()) {
+            if (player.dimension === value) {
+                yield player;
+            }
+        }
+    }
+    *_iterateRange2D(center, range) {
+        const squaredRange = range * range;
+        for (const player of this._players.values()) {
+            if (!player.isExists || player.handle === 0) {
+                continue;
+            }
+            const position = player.position;
+            const dx = position.x - center.x;
+            const dy = position.y - center.y;
+            if (dx * dx + dy * dy <= squaredRange) {
+                yield player;
+            }
+        }
+    }
+    *_iterateRange3D(center, range) {
+        const squaredRange = range * range;
+        for (const player of this._players.values()) {
+            if (!player.isExists || player.handle === 0) {
+                continue;
+            }
+            const position = player.position;
+            const dx = position.x - center.x;
+            const dy = position.y - center.y;
+            const dz = position.z - center.z;
+            if (dx * dx + dy * dy + dz * dz <= squaredRange) {
+                yield player;
+            }
+        }
+    }
+}

package/dist/client/entities/ccmp/vehicle/CCMPVehicle.d.ts

@@ -0,0 +1,119 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { type IRGB, type IVector3D, Vector3D } from "../../../../shared/common/utils";
+import { type IBaseObject } from "../../common/baseObject/IBaseObject";
+import { type ILightState, type IVehicle } from "../../common/vehicle/IVehicle";
+export interface ICCMPNativeVehicle {
+    readonly id: number;
+    readonly remoteId: number | null;
+    readonly isRemote: boolean;
+    readonly handle: number;
+    readonly model: number;
+    readonly dimension: number;
+    readonly isAlive: boolean;
+    readonly isExists?: boolean;
+    readonly position: IVector3D;
+    readonly rotation: IVector3D;
+    readonly heading: number;
+    readonly numberPlateText: string;
+    readonly numberPlate: string;
+    destroy(): boolean;
+}
+export declare class CCMPVehicle implements IVehicle {
+    private readonly _ccmpVehicle;
+    private readonly _onDestroy;
+    private _destroyed;
+    constructor(_ccmpVehicle: ICCMPNativeVehicle, _onDestroy?: (vehicle: CCMPVehicle) => 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;
+    get forwardVector(): Vector3D;
+    setRotation(_value: IVector3D): void;
+    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 bodyHealth(): number;
+    get engineHealth(): number;
+    get numberPlate(): string;
+    get isDead(): boolean;
+    setBodyHealth(_value: number): void;
+    setEngineHealth(_value: number): void;
+    setNumberPlate(_value: string): void;
+    explode(): void;
+    getPedInSeat(seat: number): number;
+    setUndriveable(_toggle: boolean): void;
+    get maxNumberOfPassengers(): number;
+    get gear(): number;
+    get speed(): number;
+    get isEngineRunning(): boolean;
+    setEngineOn(_toggle: boolean, _instantly: boolean, _otherwise: boolean): void;
+    get lightsState(): ILightState;
+    get isLocked(): boolean;
+    setIsLocked(_value: boolean): void;
+    setCustomPrimaryColour(color: IRGB): void;
+    setCustomSecondaryColour(color: IRGB): void;
+    get customPrimaryColour(): IRGB;
+    get customSecondaryColour(): IRGB;
+    setMod(modType: number, modIndex: number): void;
+    getMod(modType: number): number;
+    getNumMods(modType: number): number;
+    setNeonLightEnabled(index: number, toggle: boolean): void;
+    setNeonLightsColour(color: IRGB): void;
+    setWindowTint(tintType: number): void;
+    get windowTint(): number;
+    setWheelType(wheelType: number): void;
+    get wheelType(): number;
+    setNumberPlateTextIndex(_index: number): void;
+    get numberPlateTextIndex(): number;
+    setDoorOpen(_doorIndex: number, _loose: boolean, _openInstantly: boolean): void;
+    setDoorShut(_doorIndex: number, _instantly: boolean): void;
+    setHandling(_field: string, _value: number): void;
+    getHandling(_field: string): number;
+    setEnginePowerMultiplier(_value: number): void;
+    setEngineTorqueMultiplier(_value: number): void;
+    modifyTopSpeed(_value: number): void;
+    setCheatPowerIncrease(_value: number): void;
+    toggleMod(modType: number, toggle: boolean): void;
+    setTyreSmokeColor(r: number, g: number, b: number): void;
+    setModColor1(paintType: number, color: number, p3: number): void;
+    setExtraColours(_pearlescentColor: number, _wheelColor: number): void;
+    setHeadlightColor(colorIndex: number): void;
+    setDashboardColor(colorIndex: number): void;
+    setInteriorColor(colorIndex: number): void;
+    getMaxBraking(): number;
+    getAcceleration(): number;
+    getMaxTraction(): number;
+    getModelMaxSpeed(): number;
+    private _withHandle;
+    private _withHandleVoid;
+    private _setModKit;
+    private _getRemoteVehicleExists;
+    private _getOffsetFromCachedTransform;
+}