rock-mod 0.22.0 → 0.23.0

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

@@ -1,23 +1,9 @@
+import { type Vehicle as CcmpVehicle } from "@classic-mp/types/client";
 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 type ICCMPNativeVehicle = CcmpVehicle;
 export declare class CCMPVehicle implements IVehicle {
     private readonly _ccmpVehicle;
     private readonly _onDestroy;
@@ -31,20 +17,20 @@ export declare class CCMPVehicle implements IVehicle {
     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;
+    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;
+    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;
+    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;
@@ -55,28 +41,28 @@ export declare class CCMPVehicle implements IVehicle {
     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;
+    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;
+    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;
+    setBodyHealth(value: number): void;
+    setEngineHealth(value: number): void;
+    setNumberPlate(value: string): void;
     explode(): void;
     getPedInSeat(seat: number): number;
-    setUndriveable(_toggle: boolean): void;
+    setUndriveable(toggle: boolean): void;
     get maxNumberOfPassengers(): number;
     get gear(): number;
     get speed(): number;
     get isEngineRunning(): boolean;
-    setEngineOn(_toggle: boolean, _instantly: boolean, _otherwise: boolean): void;
+    setEngineOn(toggle: boolean, instantly: boolean, otherwise: boolean): void;
     get lightsState(): ILightState;
     get isLocked(): boolean;
-    setIsLocked(_value: boolean): void;
+    setIsLocked(value: boolean): void;
     setCustomPrimaryColour(color: IRGB): void;
     setCustomSecondaryColour(color: IRGB): void;
     get customPrimaryColour(): IRGB;
@@ -90,20 +76,20 @@ export declare class CCMPVehicle implements IVehicle {
     get windowTint(): number;
     setWheelType(wheelType: number): void;
     get wheelType(): number;
-    setNumberPlateTextIndex(_index: number): void;
+    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;
+    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;
+    setExtraColours(pearlescentColor: number, wheelColor: number): void;
     setHeadlightColor(colorIndex: number): void;
     setDashboardColor(colorIndex: number): void;
     setInteriorColor(colorIndex: number): void;
@@ -111,9 +97,6 @@ export declare class CCMPVehicle implements IVehicle {
     getAcceleration(): number;
     getMaxTraction(): number;
     getModelMaxSpeed(): number;
-    private _withHandle;
-    private _withHandleVoid;
-    private _setModKit;
+    private _normalizeHandle;
     private _getRemoteVehicleExists;
-    private _getOffsetFromCachedTransform;
 }

package/dist/client/entities/ccmp/vehicle/CCMPVehicle.js

@@ -1,9 +1,5 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import { BaseObjectType } from "../../../../shared/entities";
 import { Vector3D } from "../../../../shared/common/utils";
-const notImplemented = (memberName) => {
-    throw new Error(`CCMPVehicle.${memberName}: not implemented`);
-};
 export class CCMPVehicle {
     constructor(_ccmpVehicle, _onDestroy = () => { }) {
         this._ccmpVehicle = _ccmpVehicle;
@@ -20,17 +16,14 @@ export class CCMPVehicle {
         return BaseObjectType.Vehicle;
     }
     get isExists() {
-        var _a;
         if (this._destroyed)
             return false;
-        if (this._ccmpVehicle.isRemote) {
+        if (this._ccmpVehicle.isRemote)
             return this._getRemoteVehicleExists();
-        }
-        return !this._destroyed && ((_a = this._ccmpVehicle.isExists) !== null && _a !== void 0 ? _a : this._ccmpVehicle.isAlive);
+        return this._ccmpVehicle.isExists;
     }
     get handle() {
-        const handle = Number(this._ccmpVehicle.handle);
-        return Number.isFinite(handle) && handle > 0 ? Math.trunc(handle) : 0;
+        return this._normalizeHandle(this._ccmpVehicle.handle);
     }
     destroy() {
         if (this._destroyed)
@@ -46,14 +39,14 @@ export class CCMPVehicle {
     get dimension() {
         return this._ccmpVehicle.dimension;
     }
-    setPosition(_value) {
-        notImplemented("setPosition");
+    setPosition(value) {
+        this._ccmpVehicle.setPosition(value);
     }
-    setDimension(_value) {
-        notImplemented("setDimension");
+    setDimension(value) {
+        this._ccmpVehicle.setDimension(value);
     }
-    setCoords(_xPos, _yPos, _zPos, _xAxis, _yAxis, _zAxis, _clearArea) {
-        notImplemented("setCoords");
+    setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea) {
+        this._ccmpVehicle.setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea);
     }
     get model() {
         return this._ccmpVehicle.model;
@@ -61,332 +54,258 @@ export class CCMPVehicle {
     get heading() {
         return this._ccmpVehicle.heading;
     }
-    setHeading(_heading) {
-        notImplemented("setHeading");
+    setHeading(heading) {
+        this._ccmpVehicle.setHeading(heading);
     }
-    setModel(_value) {
-        notImplemented("setModel");
+    setModel(value) {
+        this._ccmpVehicle.setModel(value);
     }
     get rotation() {
         const { x, y, z } = this._ccmpVehicle.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);
+        const { x, y, z } = this._ccmpVehicle.forwardVector;
+        return new Vector3D(x, y, z);
     }
-    setRotation(_value) {
-        notImplemented("setRotation");
+    setRotation(value) {
+        this._ccmpVehicle.setRotation(value);
     }
-    freezePosition(_freeze) {
-        notImplemented("freezePosition");
+    freezePosition(freeze) {
+        this._ccmpVehicle.freezePosition(freeze);
     }
-    setCollision(_collision, _keepPhysics) {
-        notImplemented("setCollision");
+    setCollision(collision, keepPhysics) {
+        this._ccmpVehicle.setCollision(collision, keepPhysics);
     }
-    setInvincible(_invincible) {
-        notImplemented("setInvincible");
+    setInvincible(invincible) {
+        this._ccmpVehicle.setInvincible(invincible);
     }
-    setVisible(_visible) {
-        notImplemented("setVisible");
+    setVisible(visible) {
+        this._ccmpVehicle.setVisible(visible);
     }
     setAlpha(alpha) {
-        this._withHandleVoid((handle) => {
-            ccmp.natives.entity.setEntityAlpha(handle, alpha, false);
-        });
+        this._ccmpVehicle.setAlpha(alpha);
     }
     get alpha() {
-        return this._withHandle(255, (handle) => ccmp.natives.entity.getEntityAlpha(handle));
+        return this._ccmpVehicle.alpha;
     }
     resetAlpha() {
-        this._withHandleVoid((handle) => {
-            ccmp.natives.entity.resetEntityAlpha(handle);
-        });
+        this._ccmpVehicle.resetAlpha();
     }
     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);
-        });
+        const { x, y, z } = this._ccmpVehicle.getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ);
+        return new Vector3D(x, y, z);
     }
     getBoneIndexByName(boneName) {
-        return this._withHandle(-1, (handle) => ccmp.natives.entity.getEntityBoneIndexByName(handle, boneName));
+        return this._ccmpVehicle.getBoneIndexByName(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);
-        });
+        const { x, y, z } = this._ccmpVehicle.getWorldPositionOfBone(boneIndex);
+        return new Vector3D(x, y, z);
     }
     getVariable(name) {
         const remoteId = this.remoteId;
-        if (remoteId === null) {
+        if (remoteId === null)
             return null;
-        }
         const value = ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId, name);
         return value === undefined ? null : value;
     }
     getSyncedMeta(key) {
         const remoteId = this.remoteId;
-        if (remoteId === null) {
+        if (remoteId === null)
             return undefined;
-        }
         return ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId, key);
     }
     hasSyncedMeta(key) {
         const remoteId = this.remoteId;
-        if (remoteId === null) {
+        if (remoteId === null)
             return false;
-        }
         return ccmp.entities.hasStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId, key);
     }
     getSyncedMetaKeys() {
         const remoteId = this.remoteId;
-        if (remoteId === null) {
+        if (remoteId === null)
             return [];
-        }
         return ccmp.entities.getStreamSyncedMetaKeys(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId);
     }
-    attachToEntity(_target, _boneIndex, _offset, _rotation, _p9, _useSoftPinning, _collision, _isPed, _vertexIndex, _fixedRot) {
-        notImplemented("attachToEntity");
+    attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
+        this._ccmpVehicle.attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot);
     }
-    detach(_useDetachVelocity, _collision) {
-        notImplemented("detach");
+    detach(useDetachVelocity, collision) {
+        this._ccmpVehicle.detach(useDetachVelocity, collision);
     }
     getSpeed() {
-        return notImplemented("getSpeed");
+        return this._ccmpVehicle.getSpeed();
     }
-    isPlayingAnim(_dictionary, _name, _taskFlag) {
-        return notImplemented("isPlayingAnim");
+    isPlayingAnim(dictionary, name, taskFlag) {
+        return this._ccmpVehicle.isPlayingAnim(dictionary, name, taskFlag);
     }
     get bodyHealth() {
-        return notImplemented("bodyHealth");
+        return this._ccmpVehicle.bodyHealth;
     }
     get engineHealth() {
-        return notImplemented("engineHealth");
+        return this._ccmpVehicle.engineHealth;
     }
     get numberPlate() {
-        var _a;
-        return (_a = this._ccmpVehicle.numberPlate) !== null && _a !== void 0 ? _a : this._ccmpVehicle.numberPlateText;
+        return this._ccmpVehicle.numberPlate;
     }
     get isDead() {
-        return !this.isExists;
+        return this._ccmpVehicle.isDead;
     }
-    setBodyHealth(_value) {
-        notImplemented("setBodyHealth");
+    setBodyHealth(value) {
+        this._ccmpVehicle.setBodyHealth(value);
     }
-    setEngineHealth(_value) {
-        notImplemented("setEngineHealth");
+    setEngineHealth(value) {
+        this._ccmpVehicle.setEngineHealth(value);
     }
-    setNumberPlate(_value) {
-        notImplemented("setNumberPlate");
+    setNumberPlate(value) {
+        this._ccmpVehicle.setNumberPlate(value);
     }
     explode() {
-        notImplemented("explode");
+        this._ccmpVehicle.explode();
     }
     getPedInSeat(seat) {
-        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getPedInVehicleSeat(handle, seat, false));
+        return this._ccmpVehicle.getPedInSeat(seat);
     }
-    setUndriveable(_toggle) {
-        notImplemented("setUndriveable");
+    setUndriveable(toggle) {
+        this._ccmpVehicle.setUndriveable(toggle);
     }
     get maxNumberOfPassengers() {
-        return notImplemented("maxNumberOfPassengers");
+        return this._ccmpVehicle.maxNumberOfPassengers;
     }
     get gear() {
-        return notImplemented("gear");
+        return this._ccmpVehicle.gear;
     }
     get speed() {
-        return notImplemented("speed");
+        return this._ccmpVehicle.speed;
     }
     get isEngineRunning() {
-        return notImplemented("isEngineRunning");
+        return this._ccmpVehicle.isEngineRunning;
     }
-    setEngineOn(_toggle, _instantly, _otherwise) {
-        notImplemented("setEngineOn");
+    setEngineOn(toggle, instantly, otherwise) {
+        this._ccmpVehicle.setEngineOn(toggle, instantly, otherwise);
     }
     get lightsState() {
-        return notImplemented("lightsState");
+        return this._ccmpVehicle.lightsState;
     }
     get isLocked() {
-        return notImplemented("isLocked");
+        return this._ccmpVehicle.isLocked;
     }
-    setIsLocked(_value) {
-        notImplemented("setIsLocked");
+    setIsLocked(value) {
+        this._ccmpVehicle.setIsLocked(value);
     }
     setCustomPrimaryColour(color) {
-        this._withHandleVoid((handle) => {
-            ccmp.natives.vehicle.setVehicleCustomPrimaryColour(handle, color.r, color.g, color.b);
-        });
+        this._ccmpVehicle.setCustomPrimaryColour(color);
     }
     setCustomSecondaryColour(color) {
-        this._withHandleVoid((handle) => {
-            ccmp.natives.vehicle.setVehicleCustomSecondaryColour(handle, color.r, color.g, color.b);
-        });
+        this._ccmpVehicle.setCustomSecondaryColour(color);
     }
     get customPrimaryColour() {
-        return this._withHandle({ r: 0, g: 0, b: 0 }, (handle) => ccmp.natives.vehicle.getVehicleCustomPrimaryColour(handle));
+        return this._ccmpVehicle.customPrimaryColour;
     }
     get customSecondaryColour() {
-        return this._withHandle({ r: 0, g: 0, b: 0 }, (handle) => ccmp.natives.vehicle.getVehicleCustomSecondaryColour(handle));
+        return this._ccmpVehicle.customSecondaryColour;
     }
     setMod(modType, modIndex) {
-        this._withHandleVoid((handle) => {
-            this._setModKit(handle);
-            ccmp.natives.vehicle.setVehicleMod(handle, modType, modIndex, false);
-        });
+        this._ccmpVehicle.setMod(modType, modIndex);
     }
     getMod(modType) {
-        return this._withHandle(-1, (handle) => ccmp.natives.vehicle.getVehicleMod(handle, modType));
+        return this._ccmpVehicle.getMod(modType);
     }
     getNumMods(modType) {
-        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getNumVehicleMods(handle, modType));
+        return this._ccmpVehicle.getNumMods(modType);
     }
     setNeonLightEnabled(index, toggle) {
-        this._withHandleVoid((handle) => {
-            ccmp.natives.vehicle.setVehicleNeonEnabled(handle, index, toggle);
-        });
+        this._ccmpVehicle.setNeonLightEnabled(index, toggle);
     }
     setNeonLightsColour(color) {
-        this._withHandleVoid((handle) => {
-            ccmp.natives.vehicle.setVehicleNeonColour(handle, color.r, color.g, color.b);
-        });
+        this._ccmpVehicle.setNeonLightsColour(color);
     }
     setWindowTint(tintType) {
-        this._withHandleVoid((handle) => {
-            ccmp.natives.vehicle.setVehicleWindowTint(handle, tintType);
-        });
+        this._ccmpVehicle.setWindowTint(tintType);
     }
     get windowTint() {
-        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getVehicleWindowTint(handle));
+        return this._ccmpVehicle.windowTint;
     }
     setWheelType(wheelType) {
-        this._withHandleVoid((handle) => {
-            ccmp.natives.vehicle.setVehicleWheelType(handle, wheelType);
-        });
+        this._ccmpVehicle.setWheelType(wheelType);
     }
     get wheelType() {
-        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getVehicleWheelType(handle));
+        return this._ccmpVehicle.wheelType;
     }
-    setNumberPlateTextIndex(_index) {
-        notImplemented("setNumberPlateTextIndex");
+    setNumberPlateTextIndex(index) {
+        this._ccmpVehicle.setNumberPlateTextIndex(index);
     }
     get numberPlateTextIndex() {
-        return notImplemented("numberPlateTextIndex");
+        return this._ccmpVehicle.numberPlateTextIndex;
     }
-    setDoorOpen(_doorIndex, _loose, _openInstantly) {
-        notImplemented("setDoorOpen");
+    setDoorOpen(doorIndex, loose, openInstantly) {
+        this._ccmpVehicle.setDoorOpen(doorIndex, loose, openInstantly);
     }
-    setDoorShut(_doorIndex, _instantly) {
-        notImplemented("setDoorShut");
+    setDoorShut(doorIndex, instantly) {
+        this._ccmpVehicle.setDoorShut(doorIndex, instantly);
     }
-    setHandling(_field, _value) {
-        notImplemented("setHandling");
+    setHandling(field, value) {
+        this._ccmpVehicle.setHandling(field, value);
     }
-    getHandling(_field) {
-        return notImplemented("getHandling");
+    getHandling(field) {
+        return this._ccmpVehicle.getHandling(field);
     }
-    setEnginePowerMultiplier(_value) {
-        notImplemented("setEnginePowerMultiplier");
+    setEnginePowerMultiplier(value) {
+        this._ccmpVehicle.setEnginePowerMultiplier(value);
     }
-    setEngineTorqueMultiplier(_value) {
-        notImplemented("setEngineTorqueMultiplier");
+    setEngineTorqueMultiplier(value) {
+        this._ccmpVehicle.setEngineTorqueMultiplier(value);
     }
-    modifyTopSpeed(_value) {
-        notImplemented("modifyTopSpeed");
+    modifyTopSpeed(value) {
+        this._ccmpVehicle.modifyTopSpeed(value);
     }
-    setCheatPowerIncrease(_value) {
-        notImplemented("setCheatPowerIncrease");
+    setCheatPowerIncrease(value) {
+        this._ccmpVehicle.setCheatPowerIncrease(value);
     }
     toggleMod(modType, toggle) {
-        this._withHandleVoid((handle) => {
-            this._setModKit(handle);
-            ccmp.natives.vehicle.toggleVehicleMod(handle, modType, toggle);
-        });
+        this._ccmpVehicle.toggleMod(modType, toggle);
     }
     setTyreSmokeColor(r, g, b) {
-        this._withHandleVoid((handle) => {
-            ccmp.natives.vehicle.setVehicleTyreSmokeColor(handle, r, g, b);
-        });
+        this._ccmpVehicle.setTyreSmokeColor(r, g, b);
     }
     setModColor1(paintType, color, p3) {
-        this._withHandleVoid((handle) => {
-            ccmp.natives.vehicle.setVehicleModColor1(handle, paintType, color, p3);
-        });
+        this._ccmpVehicle.setModColor1(paintType, color, p3);
     }
-    setExtraColours(_pearlescentColor, _wheelColor) {
-        notImplemented("setExtraColours");
+    setExtraColours(pearlescentColor, wheelColor) {
+        this._ccmpVehicle.setExtraColours(pearlescentColor, wheelColor);
     }
     setHeadlightColor(colorIndex) {
-        this._withHandleVoid((handle) => {
-            ccmp.natives.vehicle.setVehicleXenonLightColorIndex(handle, colorIndex);
-        });
+        this._ccmpVehicle.setHeadlightColor(colorIndex);
     }
     setDashboardColor(colorIndex) {
-        this._withHandleVoid((handle) => {
-            var _a;
-            const vehicleNatives = ccmp.natives.vehicle;
-            const setDashboardColor = (_a = vehicleNatives.setVehicleDashboardColor) !== null && _a !== void 0 ? _a : vehicleNatives.setVehicleDashboardColour;
-            if (!setDashboardColor)
-                return;
-            setDashboardColor(handle, colorIndex);
-        });
+        this._ccmpVehicle.setDashboardColor(colorIndex);
     }
     setInteriorColor(colorIndex) {
-        this._withHandleVoid((handle) => {
-            var _a;
-            const vehicleNatives = ccmp.natives.vehicle;
-            const setInteriorColor = (_a = vehicleNatives.setVehicleInteriorColor) !== null && _a !== void 0 ? _a : vehicleNatives.setVehicleInteriorColour;
-            if (!setInteriorColor)
-                return;
-            setInteriorColor(handle, colorIndex);
-        });
+        this._ccmpVehicle.setInteriorColor(colorIndex);
     }
     getMaxBraking() {
-        return notImplemented("getMaxBraking");
+        return this._ccmpVehicle.getMaxBraking();
     }
     getAcceleration() {
-        return notImplemented("getAcceleration");
+        return this._ccmpVehicle.getAcceleration();
     }
     getMaxTraction() {
-        return notImplemented("getMaxTraction");
+        return this._ccmpVehicle.getMaxTraction();
     }
     getModelMaxSpeed() {
-        return notImplemented("getModelMaxSpeed");
-    }
-    _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);
+        return this._ccmpVehicle.getModelMaxSpeed();
     }
-    _setModKit(handle) {
-        ccmp.natives.vehicle.setVehicleModKit(handle, 0);
+    _normalizeHandle(value) {
+        const handle = Number(value);
+        return Number.isFinite(handle) && handle > 0 ? Math.trunc(handle) : 0;
     }
     _getRemoteVehicleExists() {
-        var _a;
         try {
-            return (_a = this._ccmpVehicle.isExists) !== null && _a !== void 0 ? _a : true;
+            return this._ccmpVehicle.isExists;
         }
-        catch (_b) {
+        catch (_a) {
             return true;
         }
     }
-    _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/vehicle/CCMPVehiclesManager.js

@@ -32,7 +32,8 @@ export class CCMPVehiclesManager {
         return this._register(ccmpVehicle);
     }
     getDisplayNameFromVehicleModel(modelHash) {
-        return ccmp.natives.vehicle.getDisplayNameFromVehicleModel(modelHash);
+        var _a, _b;
+        return (_b = (_a = this._getNativeVehiclesApi()) === null || _a === void 0 ? void 0 : _a.getDisplayNameFromModel(modelHash)) !== null && _b !== void 0 ? _b : "";
     }
     syncWithMpPool() {
         this._pruneDestroyed();