@open-core/framework 1.0.5-beta.2 → 1.0.6

package/dist/runtime/client/services/spawn.service.d.ts

@@ -1,18 +1,16 @@
 import { PlayerAppearance } from '../../../kernel';
 import { Vector3 } from '../../../kernel/utils/vector3';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
 import { AppearanceService } from './appearance.service';
-import { IClientSpawnBridge } from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
+import { IClientSpawnPort } from '../../../adapters/contracts/client/spawn/IClientSpawnPort';
 interface SpawnOptions {
     appearance?: PlayerAppearance;
 }
 export declare class SpawnService {
     private readonly appearanceService;
-    private readonly spawnBridge;
-    private readonly platform;
+    private readonly spawnPort;
     private spawned;
     private spawning;
-    constructor(appearanceService: AppearanceService, spawnBridge: IClientSpawnBridge, platform: IClientPlatformBridge);
+    constructor(appearanceService: AppearanceService, spawnPort: IClientSpawnPort);
     init(): Promise<void>;
     spawn(position: Vector3, model: string, heading?: number, options?: SpawnOptions): Promise<void>;
     teleportTo(position: Vector3, heading?: number): Promise<void>;

package/dist/runtime/client/services/spawn.service.js

@@ -12,19 +12,16 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { inject, injectable } from 'tsyringe';
 import { loggers } from '../../../kernel';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
 import { AppearanceService } from './appearance.service';
-import { IClientSpawnBridge } from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
+import { IClientSpawnPort } from '../../../adapters/contracts/client/spawn/IClientSpawnPort';
 let SpawnService = class SpawnService {
     appearanceService;
-    spawnBridge;
-    platform;
+    spawnPort;
     spawned = false;
     spawning = false;
-    constructor(appearanceService, spawnBridge, platform) {
+    constructor(appearanceService, spawnPort) {
         this.appearanceService = appearanceService;
-        this.spawnBridge = spawnBridge;
-        this.platform = platform;
+        this.spawnPort = spawnPort;
     }
     async init() {
         loggers.spawn.debug('SpawnService initialized');
@@ -37,10 +34,10 @@ let SpawnService = class SpawnService {
         this.spawning = true;
         try {
             loggers.spawn.debug('Waiting for spawn bridge readiness');
-            await this.spawnBridge.waitUntilReady();
+            await this.spawnPort.waitUntilReady();
             loggers.spawn.debug('Spawn bridge ready, executing spawn', { position, model, heading });
-            await this.spawnBridge.spawn({ position, model, heading });
-            const ped = this.platform.getLocalPlayerPed();
+            const outcome = await this.spawnPort.spawn({ position, model, heading });
+            const ped = outcome.localPlayerHandle ?? 0;
             if (ped !== 0) {
                 if (options?.appearance) {
                     loggers.spawn.debug('Applying post-spawn appearance', { ped });
@@ -67,11 +64,11 @@ let SpawnService = class SpawnService {
         }
     }
     async teleportTo(position, heading) {
-        await this.spawnBridge.teleport({ position, heading });
+        await this.spawnPort.teleport({ position, heading });
     }
     async respawn(position, heading = 0.0) {
-        await this.spawnBridge.waitUntilReady();
-        await this.spawnBridge.respawn({ position, heading });
+        await this.spawnPort.waitUntilReady();
+        await this.spawnPort.respawn({ position, heading });
         this.spawned = true;
         loggers.spawn.info('Player respawned', {
             position: { x: position.x, y: position.y, z: position.z },
@@ -89,10 +86,8 @@ let SpawnService = class SpawnService {
 };
 SpawnService = __decorate([
     injectable(),
-    __param(1, inject(IClientSpawnBridge)),
-    __param(2, inject(IClientPlatformBridge)),
+    __param(1, inject(IClientSpawnPort)),
     __metadata("design:paramtypes", [AppearanceService,
-        IClientSpawnBridge,
-        IClientPlatformBridge])
+        IClientSpawnPort])
 ], SpawnService);
 export { SpawnService };

package/dist/runtime/client/services/vehicle-client.service.d.ts

@@ -1,11 +1,11 @@
+import { IClientVehiclePort } from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
 import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { Vector3 } from '../../../kernel/utils/vector3';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
 import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
 import { SerializedVehicleData, VehicleCreateOptions, VehicleSpawnResult } from '../../server/types/vehicle.types';
 export declare class VehicleClientService {
     private readonly events;
-    private readonly platform;
+    private readonly vehicles;
     private readonly runtime;
     private pendingCreations;
     private pendingDeletes;
@@ -13,7 +13,7 @@ export declare class VehicleClientService {
     private pendingData;
     private pendingPlayerVehicles;
     private requestIdCounter;
-    constructor(events: EventsAPI<'client'>, platform: IClientPlatformBridge, runtime: IClientRuntimeBridge);
+    constructor(events: EventsAPI<'client'>, vehicles: IClientVehiclePort, runtime: IClientRuntimeBridge);
     createVehicle(options: Omit<VehicleCreateOptions, 'ownership'>): Promise<VehicleSpawnResult>;
     deleteVehicle(networkId: number): Promise<boolean>;
     repairVehicle(networkId: number): Promise<boolean>;

package/dist/runtime/client/services/vehicle-client.service.js

@@ -11,12 +11,13 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'tsyringe';
+import { IClientVehiclePort } from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
 import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
 import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
 let VehicleClientService = class VehicleClientService {
     events;
-    platform;
+    vehicles;
     runtime;
     pendingCreations = new Map();
     pendingDeletes = new Map();
@@ -24,9 +25,9 @@ let VehicleClientService = class VehicleClientService {
     pendingData = new Map();
     pendingPlayerVehicles = null;
     requestIdCounter = 0;
-    constructor(events, platform, runtime) {
+    constructor(events, vehicles, runtime) {
         this.events = events;
-        this.platform = platform;
+        this.vehicles = vehicles;
         this.runtime = runtime;
         this.registerEventHandlers();
     }
@@ -34,7 +35,7 @@ let VehicleClientService = class VehicleClientService {
         return new Promise((resolve) => {
             const requestId = this.requestIdCounter++;
             this.pendingCreations.set(requestId, resolve);
-            this.events.emit('opencore:vehicle:create', { ...options, _requestId: requestId });
+            this.events.emit(SYSTEM_EVENTS.vehicle.create, { ...options, _requestId: requestId });
             setTimeout(() => {
                 if (!this.pendingCreations.has(requestId))
                     return;
@@ -46,7 +47,7 @@ let VehicleClientService = class VehicleClientService {
     async deleteVehicle(networkId) {
         return new Promise((resolve) => {
             this.pendingDeletes.set(networkId, resolve);
-            this.events.emit('opencore:vehicle:delete', networkId);
+            this.events.emit(SYSTEM_EVENTS.vehicle.delete, networkId);
             setTimeout(() => {
                 if (!this.pendingDeletes.has(networkId))
                     return;
@@ -58,7 +59,7 @@ let VehicleClientService = class VehicleClientService {
     async repairVehicle(networkId) {
         return new Promise((resolve) => {
             this.pendingRepairs.set(networkId, resolve);
-            this.events.emit('opencore:vehicle:repair', networkId);
+            this.events.emit(SYSTEM_EVENTS.vehicle.repair, networkId);
             setTimeout(() => {
                 if (!this.pendingRepairs.has(networkId))
                     return;
@@ -68,54 +69,42 @@ let VehicleClientService = class VehicleClientService {
         });
     }
     getClosestVehicle(radius = 10.0) {
-        const playerPed = this.platform.getLocalPlayerPed();
-        return this.platform.getClosestVehicle(this.platform.getEntityCoords(playerPed), radius);
+        return this.vehicles.getClosest(radius);
     }
     isPlayerInVehicle() {
-        return this.platform.isPedInAnyVehicle(this.platform.getLocalPlayerPed());
+        return this.vehicles.isLocalPlayerInVehicle();
     }
     getCurrentVehicle() {
-        const ped = this.platform.getLocalPlayerPed();
-        if (!this.platform.isPedInAnyVehicle(ped))
-            return null;
-        return this.platform.getVehiclePedIsIn(ped, false);
+        return this.vehicles.getCurrentForLocalPlayer();
     }
     getLastVehicle() {
-        return this.platform.getVehiclePedIsIn(this.platform.getLocalPlayerPed(), true);
+        return this.vehicles.getLastForLocalPlayer();
     }
     isPlayerDriver() {
         const vehicle = this.getCurrentVehicle();
         if (!vehicle)
             return false;
-        return this.platform.getPedInVehicleSeat(vehicle, -1) === this.platform.getLocalPlayerPed();
+        return this.vehicles.isLocalPlayerDriver(vehicle);
     }
     getSpeed(vehicle) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return 0;
-        return this.platform.getEntitySpeed(vehicle) * 3.6;
+        return this.vehicles.getSpeed(vehicle) * 3.6;
     }
     getNetworkId(vehicle) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return 0;
-        return this.platform.networkGetNetworkIdFromEntity(vehicle);
+        return this.vehicles.getNetworkId(vehicle);
     }
     getVehicleFromNetworkId(networkId) {
-        if (!this.platform.networkDoesEntityExistWithNetworkId(networkId))
-            return 0;
-        return this.platform.networkGetEntityFromNetworkId(networkId);
+        return this.vehicles.getFromNetworkId(networkId);
     }
     getVehicleState(vehicle, key) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return undefined;
-        return this.platform.getEntityState(vehicle, key);
+        return this.vehicles.getState(vehicle, key);
     }
     setDoorsLocked(networkId, locked) {
-        this.events.emit('opencore:vehicle:setLocked', networkId, locked);
+        this.events.emit(SYSTEM_EVENTS.vehicle.setLocked, networkId, locked);
     }
     async getVehicleData(networkId) {
         return new Promise((resolve) => {
             this.pendingData.set(networkId, resolve);
-            this.events.emit('opencore:vehicle:getData', networkId);
+            this.events.emit(SYSTEM_EVENTS.vehicle.getData, networkId);
             setTimeout(() => {
                 if (!this.pendingData.has(networkId))
                     return;
@@ -127,7 +116,7 @@ let VehicleClientService = class VehicleClientService {
     async getPlayerVehicles() {
         return new Promise((resolve) => {
             this.pendingPlayerVehicles = resolve;
-            this.events.emit('opencore:vehicle:getPlayerVehicles');
+            this.events.emit(SYSTEM_EVENTS.vehicle.getPlayerVehicles);
             setTimeout(() => {
                 if (!this.pendingPlayerVehicles)
                     return;
@@ -137,123 +126,34 @@ let VehicleClientService = class VehicleClientService {
         });
     }
     warpIntoVehicle(vehicle, seatIndex = -1) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return;
-        this.platform.taskWarpPedIntoVehicle(this.platform.getLocalPlayerPed(), vehicle, seatIndex);
+        this.vehicles.warpLocalPlayerInto(vehicle, seatIndex);
     }
     setHeading(vehicle, heading) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return;
-        this.platform.setEntityHeading(vehicle, heading);
+        this.vehicles.setHeading(vehicle, heading);
     }
     getPosition(vehicle) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return null;
-        return this.platform.getEntityCoords(vehicle);
+        return this.vehicles.getPosition(vehicle);
     }
     getHeading(vehicle) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return 0;
-        return this.platform.getEntityHeading(vehicle);
+        return this.vehicles.getHeading(vehicle);
     }
     getModel(vehicle) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return 0;
-        return this.platform.getEntityModel(vehicle);
+        return this.vehicles.getModel(vehicle);
     }
     getPlate(vehicle) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return '';
-        return this.platform.getVehicleNumberPlateText(vehicle);
+        return this.vehicles.getPlate(vehicle);
     }
     applyMods(vehicle, mods) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return;
-        this.platform.setVehicleModKit(vehicle, 0);
-        if (mods.spoiler !== undefined)
-            this.platform.setVehicleMod(vehicle, 0, mods.spoiler, false);
-        if (mods.frontBumper !== undefined)
-            this.platform.setVehicleMod(vehicle, 1, mods.frontBumper, false);
-        if (mods.rearBumper !== undefined)
-            this.platform.setVehicleMod(vehicle, 2, mods.rearBumper, false);
-        if (mods.sideSkirt !== undefined)
-            this.platform.setVehicleMod(vehicle, 3, mods.sideSkirt, false);
-        if (mods.exhaust !== undefined)
-            this.platform.setVehicleMod(vehicle, 4, mods.exhaust, false);
-        if (mods.frame !== undefined)
-            this.platform.setVehicleMod(vehicle, 5, mods.frame, false);
-        if (mods.grille !== undefined)
-            this.platform.setVehicleMod(vehicle, 6, mods.grille, false);
-        if (mods.hood !== undefined)
-            this.platform.setVehicleMod(vehicle, 7, mods.hood, false);
-        if (mods.fender !== undefined)
-            this.platform.setVehicleMod(vehicle, 8, mods.fender, false);
-        if (mods.rightFender !== undefined)
-            this.platform.setVehicleMod(vehicle, 9, mods.rightFender, false);
-        if (mods.roof !== undefined)
-            this.platform.setVehicleMod(vehicle, 10, mods.roof, false);
-        if (mods.engine !== undefined)
-            this.platform.setVehicleMod(vehicle, 11, mods.engine, false);
-        if (mods.brakes !== undefined)
-            this.platform.setVehicleMod(vehicle, 12, mods.brakes, false);
-        if (mods.transmission !== undefined)
-            this.platform.setVehicleMod(vehicle, 13, mods.transmission, false);
-        if (mods.horns !== undefined)
-            this.platform.setVehicleMod(vehicle, 14, mods.horns, false);
-        if (mods.suspension !== undefined)
-            this.platform.setVehicleMod(vehicle, 15, mods.suspension, false);
-        if (mods.armor !== undefined)
-            this.platform.setVehicleMod(vehicle, 16, mods.armor, false);
-        if (mods.turbo !== undefined)
-            this.platform.toggleVehicleMod(vehicle, 18, mods.turbo);
-        if (mods.xenon !== undefined)
-            this.platform.toggleVehicleMod(vehicle, 22, mods.xenon);
-        if (mods.wheelType !== undefined)
-            this.platform.setVehicleWheelType(vehicle, mods.wheelType);
-        if (mods.wheels !== undefined)
-            this.platform.setVehicleMod(vehicle, 23, mods.wheels, false);
-        if (mods.windowTint !== undefined)
-            this.platform.setVehicleWindowTint(vehicle, mods.windowTint);
-        if (mods.livery !== undefined)
-            this.platform.setVehicleLivery(vehicle, mods.livery);
-        if (mods.plateStyle !== undefined)
-            this.platform.setVehicleNumberPlateTextIndex(vehicle, mods.plateStyle);
-        if (mods.neonEnabled !== undefined) {
-            this.platform.setVehicleNeonLightEnabled(vehicle, 0, mods.neonEnabled[0]);
-            this.platform.setVehicleNeonLightEnabled(vehicle, 1, mods.neonEnabled[1]);
-            this.platform.setVehicleNeonLightEnabled(vehicle, 2, mods.neonEnabled[2]);
-            this.platform.setVehicleNeonLightEnabled(vehicle, 3, mods.neonEnabled[3]);
-        }
-        if (mods.neonColor !== undefined) {
-            this.platform.setVehicleNeonLightsColour(vehicle, mods.neonColor[0], mods.neonColor[1], mods.neonColor[2]);
-        }
-        if (mods.extras) {
-            for (const [extraId, enabled] of Object.entries(mods.extras)) {
-                this.platform.setVehicleExtra(vehicle, Number(extraId), !enabled);
-            }
-        }
-        if (mods.pearlescentColor !== undefined || mods.wheelColor !== undefined) {
-            const [currentPearl, currentWheel] = this.platform.getVehicleExtraColours(vehicle);
-            this.platform.setVehicleExtraColours(vehicle, mods.pearlescentColor ?? currentPearl, mods.wheelColor ?? currentWheel);
-        }
+        this.vehicles.applyMods(vehicle, mods);
     }
     repair(vehicle) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return;
-        this.platform.setVehicleFixed(vehicle);
-        this.platform.setVehicleDeformationFixed(vehicle);
-        this.platform.setVehicleUndriveable(vehicle, false);
-        this.platform.setVehicleEngineOn(vehicle, true, true, false);
-        this.platform.setVehicleEngineHealth(vehicle, 1000.0);
-        this.platform.setVehiclePetrolTankHealth(vehicle, 1000.0);
+        this.vehicles.repair(vehicle);
     }
     setFuel(vehicle, level) {
-        if (!this.platform.doesEntityExist(vehicle))
-            return;
-        this.platform.setVehicleFuelLevel(vehicle, Math.max(0, Math.min(100, level)));
+        this.vehicles.setFuel(vehicle, level);
     }
     registerEventHandlers() {
-        this.events.on('opencore:vehicle:createResult', (_ctx, result) => {
+        this.events.on(SYSTEM_EVENTS.vehicle.createResult, (_ctx, result) => {
             if (result._requestId === undefined)
                 return;
             const callback = this.pendingCreations.get(result._requestId);
@@ -262,21 +162,21 @@ let VehicleClientService = class VehicleClientService {
             callback(result);
             this.pendingCreations.delete(result._requestId);
         });
-        this.events.on('opencore:vehicle:deleteResult', (_ctx, result) => {
+        this.events.on(SYSTEM_EVENTS.vehicle.deleteResult, (_ctx, result) => {
             const callback = this.pendingDeletes.get(result.networkId);
             if (!callback)
                 return;
             callback(result.success);
             this.pendingDeletes.delete(result.networkId);
         });
-        this.events.on('opencore:vehicle:repairResult', (_ctx, result) => {
+        this.events.on(SYSTEM_EVENTS.vehicle.repairResult, (_ctx, result) => {
             const callback = this.pendingRepairs.get(result.networkId);
             if (!callback)
                 return;
             callback(result.success);
             this.pendingRepairs.delete(result.networkId);
         });
-        this.events.on('opencore:vehicle:dataResult', (_ctx, data) => {
+        this.events.on(SYSTEM_EVENTS.vehicle.dataResult, (_ctx, data) => {
             if (!data)
                 return;
             const callback = this.pendingData.get(data.networkId);
@@ -285,11 +185,11 @@ let VehicleClientService = class VehicleClientService {
             callback(data);
             this.pendingData.delete(data.networkId);
         });
-        this.events.on('opencore:vehicle:playerVehiclesResult', (_ctx, vehicles) => {
+        this.events.on(SYSTEM_EVENTS.vehicle.playerVehiclesResult, (_ctx, vehicles) => {
             this.pendingPlayerVehicles?.(vehicles);
             this.pendingPlayerVehicles = null;
         });
-        this.events.on('opencore:vehicle:created', async (_ctx, data) => {
+        this.events.on(SYSTEM_EVENTS.vehicle.created, async (_ctx, data) => {
             const veh = await this.waitForVehicle(data.networkId);
             if (!veh)
                 return;
@@ -298,17 +198,17 @@ let VehicleClientService = class VehicleClientService {
             if (data.metadata?.fuel !== undefined)
                 this.setFuel(veh, data.metadata.fuel);
         });
-        this.events.on('opencore:vehicle:modified', (_ctx, data) => {
+        this.events.on(SYSTEM_EVENTS.vehicle.modified, (_ctx, data) => {
             const veh = this.getVehicleFromNetworkId(data.networkId);
-            if (veh && this.platform.doesEntityExist(veh))
+            if (veh && this.vehicles.exists(veh))
                 this.applyMods(veh, data.mods);
         });
-        this.events.on('opencore:vehicle:repaired', (_ctx, networkId) => {
+        this.events.on(SYSTEM_EVENTS.vehicle.repaired, (_ctx, networkId) => {
             const veh = this.getVehicleFromNetworkId(networkId);
-            if (veh && this.platform.doesEntityExist(veh))
+            if (veh && this.vehicles.exists(veh))
                 this.repair(veh);
         });
-        this.events.on('opencore:vehicle:warpInto', async (_ctx, networkId, seatIndex = -1) => {
+        this.events.on(SYSTEM_EVENTS.vehicle.warpInto, async (_ctx, networkId, seatIndex = -1) => {
             const veh = await this.waitForVehicle(networkId);
             if (veh)
                 this.warpIntoVehicle(veh, seatIndex);
@@ -318,7 +218,7 @@ let VehicleClientService = class VehicleClientService {
         const started = this.runtime.getGameTimer();
         while (this.runtime.getGameTimer() - started < 5000) {
             const veh = this.getVehicleFromNetworkId(networkId);
-            if (veh && this.platform.doesEntityExist(veh))
+            if (veh && this.vehicles.exists(veh))
                 return veh;
             await new Promise((r) => setTimeout(r, 0));
         }
@@ -328,10 +228,10 @@ let VehicleClientService = class VehicleClientService {
 VehicleClientService = __decorate([
     injectable(),
     __param(0, inject(EventsAPI)),
-    __param(1, inject(IClientPlatformBridge)),
+    __param(1, inject(IClientVehiclePort)),
     __param(2, inject(IClientRuntimeBridge)),
     __metadata("design:paramtypes", [EventsAPI,
-        IClientPlatformBridge,
+        IClientVehiclePort,
         IClientRuntimeBridge])
 ], VehicleClientService);
 export { VehicleClientService };

package/dist/runtime/client/services/vehicle.service.d.ts

@@ -1,46 +1,9 @@
 import { Vector3 } from '../../../kernel/utils/vector3';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
-export interface VehicleSpawnOptions {
-    model: string;
-    position: Vector3;
-    heading?: number;
-    placeOnGround?: boolean;
-    warpIntoVehicle?: boolean;
-    seatIndex?: number;
-    primaryColor?: number;
-    secondaryColor?: number;
-    plate?: string;
-    networked?: boolean;
-}
-export interface VehicleMods {
-    spoiler?: number;
-    frontBumper?: number;
-    rearBumper?: number;
-    sideSkirt?: number;
-    exhaust?: number;
-    frame?: number;
-    grille?: number;
-    hood?: number;
-    fender?: number;
-    rightFender?: number;
-    roof?: number;
-    engine?: number;
-    brakes?: number;
-    transmission?: number;
-    horns?: number;
-    suspension?: number;
-    armor?: number;
-    turbo?: boolean;
-    xenon?: boolean;
-    wheelType?: number;
-    wheels?: number;
-    windowTint?: number;
-    livery?: number;
-    plateStyle?: number;
-}
+import { type ClientVehicleMods as VehicleMods, type ClientVehicleSpawnOptions as VehicleSpawnOptions, IClientVehiclePort } from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
+export type { VehicleSpawnOptions, VehicleMods };
 export declare class VehicleService {
-    private readonly platform;
-    constructor(platform: IClientPlatformBridge);
+    private readonly vehicles;
+    constructor(vehicles: IClientVehiclePort);
     spawn(options: VehicleSpawnOptions): Promise<number>;
     delete(vehicle: number): void;
     deleteCurrentVehicle(): void;