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

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

@@ -11,53 +11,35 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'tsyringe';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientPedPort, } from '../../../adapters/contracts/client/ped/IClientPedPort';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 let PedService = class PedService {
-    platform;
+    pedsPort;
+    localPlayer;
     peds = new Map();
     idCounter = 0;
-    constructor(platform) {
-        this.platform = platform;
+    constructor(pedsPort, localPlayer) {
+        this.pedsPort = pedsPort;
+        this.localPlayer = localPlayer;
     }
     async spawn(options) {
-        const { model, position, heading = 0, networked = false, missionEntity = true, blockEvents = true, } = options;
-        const modelHash = this.platform.getHashKey(model);
-        if (!this.platform.isModelInCdimage(modelHash) || !this.platform.isModelValid(modelHash)) {
-            throw new Error(`Invalid ped model: ${model}`);
-        }
-        this.platform.requestModel(modelHash);
-        while (!this.platform.hasModelLoaded(modelHash)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
-        const ped = this.platform.createPed(4, modelHash, position, heading, networked, true);
-        this.platform.setModelAsNoLongerNeeded(modelHash);
+        const ped = await this.pedsPort.spawn(options);
         if (!ped || ped === 0)
             throw new Error('Failed to create ped');
-        if (missionEntity)
-            this.platform.setEntityAsMissionEntity(ped, true, true);
-        if (blockEvents)
-            this.platform.setBlockingOfNonTemporaryEvents(ped, true);
-        this.platform.setPedRelationshipGroupHash(ped, this.platform.getHashKey('CIVMALE'));
         const id = `ped_${++this.idCounter}`;
-        this.peds.set(id, { id, handle: ped, model, position });
+        this.peds.set(id, { id, handle: ped, model: options.model, position: options.position });
         return { id, handle: ped };
     }
     delete(id) {
         const ped = this.peds.get(id);
         if (!ped)
             return false;
-        if (this.platform.doesEntityExist(ped.handle)) {
-            this.platform.setEntityAsMissionEntity(ped.handle, true, true);
-            this.platform.deletePed(ped.handle);
-        }
+        this.pedsPort.delete(ped.handle);
         this.peds.delete(id);
         return true;
     }
     deleteByHandle(handle) {
-        if (this.platform.doesEntityExist(handle)) {
-            this.platform.setEntityAsMissionEntity(handle, true, true);
-            this.platform.deletePed(handle);
-        }
+        this.pedsPort.delete(handle);
         for (const [id, ped] of this.peds) {
             if (ped.handle === handle) {
                 this.peds.delete(id);
@@ -67,56 +49,34 @@ let PedService = class PedService {
     }
     deleteAll() {
         for (const ped of this.peds.values()) {
-            if (this.platform.doesEntityExist(ped.handle)) {
-                this.platform.setEntityAsMissionEntity(ped.handle, true, true);
-                this.platform.deletePed(ped.handle);
-            }
+            this.pedsPort.delete(ped.handle);
         }
         this.peds.clear();
     }
     async playAnimation(handle, options) {
-        const { dict, anim, blendInSpeed = 8.0, blendOutSpeed = -8.0, duration = -1, flags = 1, playbackRate = 0.0, } = options;
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.requestAnimDict(dict);
-        while (!this.platform.hasAnimDictLoaded(dict)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
-        this.platform.taskPlayAnim(handle, dict, anim, blendInSpeed, blendOutSpeed, duration, flags, playbackRate);
+        await this.pedsPort.playAnimation(handle, options);
     }
     stopAnimation(handle) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.clearPedTasks(handle);
+        this.pedsPort.stopAnimation(handle);
     }
     stopAnimationImmediately(handle) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.clearPedTasksImmediately(handle);
+        this.pedsPort.stopAnimationImmediately(handle);
     }
     freeze(handle, freeze) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.freezeEntityPosition(handle, freeze);
+        this.pedsPort.freeze(handle, freeze);
     }
     setInvincible(handle, invincible) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.setEntityInvincible(handle, invincible);
+        this.pedsPort.setInvincible(handle, invincible);
     }
     giveWeapon(handle, weapon, ammo = 100, hidden = false, forceInHand = true) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.giveWeaponToPed(handle, this.platform.getHashKey(weapon), ammo, hidden, forceInHand);
+        this.pedsPort.giveWeapon(handle, weapon, ammo, hidden, forceInHand);
     }
     removeAllWeapons(handle) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.removeAllPedWeapons(handle, true);
+        this.pedsPort.removeAllWeapons(handle);
     }
     getClosest(radius = 10.0, excludePlayer = true) {
-        const playerPed = this.platform.getLocalPlayerPed();
-        const handle = this.platform.getClosestPed(this.platform.getEntityCoords(playerPed), radius);
+        const playerPed = this.localPlayer.getHandle();
+        const handle = this.pedsPort.getClosest(radius, excludePlayer);
         if (!handle)
             return null;
         if (excludePlayer && handle === playerPed)
@@ -124,28 +84,19 @@ let PedService = class PedService {
         return handle;
     }
     getNearby(position, radius, excludePlayer = true) {
-        return this.platform.getNearbyPeds(position, radius, excludePlayer ? this.platform.getLocalPlayerPed() : undefined);
+        return this.pedsPort.getNearby(position, radius, excludePlayer ? this.localPlayer.getHandle() : undefined);
     }
     lookAtEntity(handle, entity, duration = -1) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.taskLookAtEntity(handle, entity, duration);
+        this.pedsPort.lookAtEntity(handle, entity, duration);
     }
     lookAtCoords(handle, position, duration = -1) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.taskLookAtCoord(handle, position, duration);
+        this.pedsPort.lookAtCoords(handle, position, duration);
     }
     walkTo(handle, position, speed = 1.0) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.taskGoStraightToCoord(handle, position, speed);
+        this.pedsPort.walkTo(handle, position, speed);
     }
     setCombatAttributes(handle, canFight, canUseCover = true) {
-        if (!this.platform.doesEntityExist(handle))
-            return;
-        this.platform.setPedCombatAttributes(handle, 46, canFight);
-        this.platform.setPedCombatAttributes(handle, 0, canUseCover);
+        this.pedsPort.setCombatAttributes(handle, canFight, canUseCover);
     }
     get(id) {
         return this.peds.get(id);
@@ -155,12 +106,14 @@ let PedService = class PedService {
     }
     exists(id) {
         const ped = this.peds.get(id);
-        return ped ? this.platform.doesEntityExist(ped.handle) : false;
+        return ped ? this.pedsPort.exists(ped.handle) : false;
     }
 };
 PedService = __decorate([
     injectable(),
-    __param(0, inject(IClientPlatformBridge)),
-    __metadata("design:paramtypes", [IClientPlatformBridge])
+    __param(0, inject(IClientPedPort)),
+    __param(1, inject(IClientLocalPlayerBridge)),
+    __metadata("design:paramtypes", [IClientPedPort,
+        IClientLocalPlayerBridge])
 ], PedService);
 export { PedService };

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

@@ -1,57 +1,11 @@
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
-import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
-export interface ProgressOptions {
-    label: string;
-    duration: number;
-    useCircular?: boolean;
-    canCancel?: boolean;
-    disableControls?: boolean;
-    disableMovement?: boolean;
-    disableCombat?: boolean;
-    animation?: {
-        dict: string;
-        anim: string;
-        flags?: number;
-    };
-    prop?: {
-        model: string;
-        bone: number;
-        offset: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        rotation: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    };
-}
-export interface ProgressState {
-    active: boolean;
-    progress: number;
-    label: string;
-    startTime: number;
-    duration: number;
-    options: ProgressOptions;
-}
+import { type ClientProgressOptions as ProgressOptions, type ClientProgressState as ProgressState, IClientProgressPort } from '../../../adapters/contracts/client/progress/IClientProgressPort';
+export type { ProgressOptions, ProgressState };
 export declare class ProgressService {
-    private readonly platform;
-    private readonly runtime;
-    private state;
-    private tickHandle;
-    private callback;
-    private propHandle;
-    constructor(platform: IClientPlatformBridge, runtime: IClientRuntimeBridge);
+    private readonly progressPort;
+    constructor(progressPort: IClientProgressPort);
     start(options: ProgressOptions): Promise<boolean>;
     cancel(): void;
     isActive(): boolean;
     getProgress(): number;
     getState(): ProgressState | null;
-    private startProgress;
-    private drawProgressBar;
-    private cleanup;
-    private loadAnimDict;
-    private loadModel;
 }

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

@@ -11,163 +11,31 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'tsyringe';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
-import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+import { IClientProgressPort, } from '../../../adapters/contracts/client/progress/IClientProgressPort';
 let ProgressService = class ProgressService {
-    platform;
-    runtime;
-    state = null;
-    tickHandle = null;
-    callback = null;
-    propHandle = null;
-    constructor(platform, runtime) {
-        this.platform = platform;
-        this.runtime = runtime;
+    progressPort;
+    constructor(progressPort) {
+        this.progressPort = progressPort;
     }
     async start(options) {
-        if (this.state?.active)
-            return false;
-        return new Promise((resolve) => {
-            this.state = {
-                active: true,
-                progress: 0,
-                label: options.label,
-                startTime: this.runtime.getGameTimer(),
-                duration: options.duration,
-                options,
-            };
-            this.callback = resolve;
-            void this.startProgress();
-        });
+        return this.progressPort.start(options);
     }
     cancel() {
-        if (!this.state?.active)
-            return;
-        this.cleanup(false);
+        this.progressPort.cancel();
     }
     isActive() {
-        return this.state?.active ?? false;
+        return this.progressPort.isActive();
     }
     getProgress() {
-        return this.state?.progress ?? 0;
+        return this.progressPort.getProgress();
     }
     getState() {
-        return this.state;
-    }
-    async startProgress() {
-        if (!this.state)
-            return;
-        const { options } = this.state;
-        const ped = this.platform.getLocalPlayerPed();
-        if (options.animation) {
-            await this.loadAnimDict(options.animation.dict);
-            this.platform.taskPlayAnim(ped, options.animation.dict, options.animation.anim, 8.0, -8.0, options.duration, options.animation.flags ?? 1, 0.0);
-        }
-        if (options.prop) {
-            await this.loadModel(options.prop.model);
-            const propHash = this.platform.getHashKey(options.prop.model);
-            const coords = this.platform.getEntityCoords(ped);
-            this.propHandle = this.platform.createObject(propHash, coords, true, true, true);
-            this.platform.attachEntityToEntity(this.propHandle, ped, this.platform.getPedBoneIndex(ped, options.prop.bone), options.prop.offset, options.prop.rotation);
-        }
-        this.tickHandle = this.runtime.setTick(() => {
-            if (!this.state)
-                return;
-            const elapsed = this.runtime.getGameTimer() - this.state.startTime;
-            this.state.progress = Math.min((elapsed / this.state.duration) * 100, 100);
-            if (options.disableControls) {
-                this.platform.disableAllControlActions(0);
-            }
-            else {
-                if (options.disableMovement) {
-                    this.platform.disableControlAction(0, 30, true);
-                    this.platform.disableControlAction(0, 31, true);
-                    this.platform.disableControlAction(0, 21, true);
-                    this.platform.disableControlAction(0, 22, true);
-                }
-                if (options.disableCombat) {
-                    this.platform.disableControlAction(0, 24, true);
-                    this.platform.disableControlAction(0, 25, true);
-                    this.platform.disableControlAction(0, 47, true);
-                    this.platform.disableControlAction(0, 58, true);
-                    this.platform.disableControlAction(0, 263, true);
-                    this.platform.disableControlAction(0, 264, true);
-                }
-            }
-            if (options.canCancel && this.platform.isControlJustPressed(0, 200)) {
-                this.cancel();
-                return;
-            }
-            this.drawProgressBar();
-            if (elapsed >= this.state.duration)
-                this.cleanup(true);
-        });
-    }
-    drawProgressBar() {
-        if (!this.state)
-            return;
-        const { label, progress, options } = this.state;
-        if (options.useCircular) {
-            this.platform.beginTextCommandBusyspinnerOn('STRING');
-            this.platform.addTextComponentString(label);
-            this.platform.endTextCommandBusyspinnerOn(4);
-            return;
-        }
-        const barWidth = 0.15;
-        const barHeight = 0.015;
-        const x = 0.5 - barWidth / 2;
-        const y = 0.88;
-        this.platform.drawRect(0.5, y + barHeight / 2, barWidth, barHeight, 0, 0, 0, 180);
-        const fillWidth = (barWidth * progress) / 100;
-        this.platform.drawRect(x + fillWidth / 2, y + barHeight / 2, fillWidth, barHeight, 255, 255, 255, 255);
-        this.platform.setTextFont(4);
-        this.platform.setTextScale(0.35);
-        this.platform.setTextColour({ r: 255, g: 255, b: 255, a: 255 });
-        this.platform.setTextCentre(true);
-        this.platform.beginTextCommandDisplayText('STRING');
-        this.platform.addTextComponentString(`${label} (${Math.floor(progress)}%)`);
-        this.platform.endTextCommandDisplayText(0.5, y - 0.03);
-    }
-    cleanup(completed) {
-        const ped = this.platform.getLocalPlayerPed();
-        if (this.state?.options.animation) {
-            this.platform.stopAnimTask(ped, this.state.options.animation.dict, this.state.options.animation.anim, 1.0);
-        }
-        if (this.propHandle) {
-            this.platform.deleteEntity(this.propHandle);
-            this.propHandle = null;
-        }
-        if (this.tickHandle !== null) {
-            this.runtime.clearTick(this.tickHandle);
-            this.tickHandle = null;
-        }
-        if (this.state?.options.useCircular)
-            this.platform.busyspinnerOff();
-        this.state = null;
-        if (this.callback) {
-            this.callback(completed);
-            this.callback = null;
-        }
-    }
-    async loadAnimDict(dict) {
-        this.platform.requestAnimDict(dict);
-        while (!this.platform.hasAnimDictLoaded(dict)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
-    }
-    async loadModel(model) {
-        const hash = this.platform.getHashKey(model);
-        this.platform.requestModel(hash);
-        while (!this.platform.hasModelLoaded(hash)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
+        return this.progressPort.getState();
     }
 };
 ProgressService = __decorate([
     injectable(),
-    __param(0, inject(IClientPlatformBridge)),
-    __param(1, inject(IClientRuntimeBridge)),
-    __metadata("design:paramtypes", [IClientPlatformBridge,
-        IClientRuntimeBridge])
+    __param(0, inject(IClientProgressPort)),
+    __metadata("design:paramtypes", [IClientProgressPort])
 ], ProgressService);
 export { ProgressService };

package/dist/runtime/client/services/session-bridge.service.js

@@ -14,6 +14,7 @@ import { inject, injectable } from 'tsyringe';
 import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
 import { coreLogger, LogDomain } from '../../../kernel/logger';
 import { Vec3 } from '../../../kernel/utils/vector3';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
 import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
 const clientSession = coreLogger.child('Session', LogDomain.CLIENT);
@@ -37,11 +38,11 @@ let ClientSessionBridgeService = class ClientSessionBridgeService {
                 return;
             clientSession.debug('Client session bridge initialized');
         });
-        this.events.on('core:playerSessionInit', (_ctx, data) => {
+        this.events.on(SYSTEM_EVENTS.session.playerInit, (_ctx, data) => {
             this.playerId = data.playerId;
             clientSession.info('Player session initialized', { playerId: data.playerId });
         });
-        this.events.on('core:teleportTo', (_ctx, x, y, z, heading) => {
+        this.events.on(SYSTEM_EVENTS.session.teleportTo, (_ctx, x, y, z, heading) => {
             this.localPlayer.setPosition(Vec3.create(x, y, z), heading);
         });
     }

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>;