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

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

@@ -4,77 +4,60 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { injectable } from 'tsyringe';
-/**
- * Service for ped (NPC) operations and management.
- */
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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';
 let PedService = class PedService {
+    platform;
     peds = new Map();
     idCounter = 0;
-    /**
-     * Spawn a ped at a position.
-     *
-     * @param options - Spawn options
-     * @returns The ped ID and handle
-     */
+    constructor(platform) {
+        this.platform = platform;
+    }
     async spawn(options) {
         const { model, position, heading = 0, networked = false, missionEntity = true, blockEvents = true, } = options;
-        const modelHash = GetHashKey(model);
-        // Load the model
-        if (!IsModelInCdimage(modelHash) || !IsModelValid(modelHash)) {
+        const modelHash = this.platform.getHashKey(model);
+        if (!this.platform.isModelInCdimage(modelHash) || !this.platform.isModelValid(modelHash)) {
             throw new Error(`Invalid ped model: ${model}`);
         }
-        RequestModel(modelHash);
-        while (!HasModelLoaded(modelHash)) {
+        this.platform.requestModel(modelHash);
+        while (!this.platform.hasModelLoaded(modelHash)) {
             await new Promise((r) => setTimeout(r, 0));
         }
-        // Create the ped
-        const ped = CreatePed(4, modelHash, position.x, position.y, position.z, heading, networked, true);
-        SetModelAsNoLongerNeeded(modelHash);
-        if (!ped || ped === 0) {
+        const ped = this.platform.createPed(4, modelHash, position, heading, networked, true);
+        this.platform.setModelAsNoLongerNeeded(modelHash);
+        if (!ped || ped === 0)
             throw new Error('Failed to create ped');
-        }
-        // Configure the ped
-        if (missionEntity) {
-            SetEntityAsMissionEntity(ped, true, true);
-        }
-        if (blockEvents) {
-            SetBlockingOfNonTemporaryEvents(ped, true);
-        }
-        // Set default relationship (neutral)
-        SetPedRelationshipGroupHash(ped, GetHashKey('CIVMALE'));
-        // Register in our map
+        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 });
         return { id, handle: ped };
     }
-    /**
-     * Delete a ped by ID.
-     *
-     * @param id - The ped ID
-     */
     delete(id) {
         const ped = this.peds.get(id);
         if (!ped)
             return false;
-        if (DoesEntityExist(ped.handle)) {
-            SetEntityAsMissionEntity(ped.handle, true, true);
-            DeletePed(ped.handle);
+        if (this.platform.doesEntityExist(ped.handle)) {
+            this.platform.setEntityAsMissionEntity(ped.handle, true, true);
+            this.platform.deletePed(ped.handle);
         }
         this.peds.delete(id);
         return true;
     }
-    /**
-     * Delete a ped by handle.
-     *
-     * @param handle - The ped handle
-     */
     deleteByHandle(handle) {
-        if (DoesEntityExist(handle)) {
-            SetEntityAsMissionEntity(handle, true, true);
-            DeletePed(handle);
+        if (this.platform.doesEntityExist(handle)) {
+            this.platform.setEntityAsMissionEntity(handle, true, true);
+            this.platform.deletePed(handle);
         }
-        // Remove from our map if tracked
         for (const [id, ped] of this.peds) {
             if (ped.handle === handle) {
                 this.peds.delete(id);
@@ -82,217 +65,102 @@ let PedService = class PedService {
             }
         }
     }
-    /**
-     * Delete all managed peds.
-     */
     deleteAll() {
         for (const ped of this.peds.values()) {
-            if (DoesEntityExist(ped.handle)) {
-                SetEntityAsMissionEntity(ped.handle, true, true);
-                DeletePed(ped.handle);
+            if (this.platform.doesEntityExist(ped.handle)) {
+                this.platform.setEntityAsMissionEntity(ped.handle, true, true);
+                this.platform.deletePed(ped.handle);
             }
         }
         this.peds.clear();
     }
-    /**
-     * Play an animation on a ped.
-     *
-     * @param handle - Ped handle
-     * @param options - Animation options
-     */
     async playAnimation(handle, options) {
         const { dict, anim, blendInSpeed = 8.0, blendOutSpeed = -8.0, duration = -1, flags = 1, playbackRate = 0.0, } = options;
-        if (!DoesEntityExist(handle))
+        if (!this.platform.doesEntityExist(handle))
             return;
-        // Load anim dict
-        RequestAnimDict(dict);
-        while (!HasAnimDictLoaded(dict)) {
+        this.platform.requestAnimDict(dict);
+        while (!this.platform.hasAnimDictLoaded(dict)) {
             await new Promise((r) => setTimeout(r, 0));
         }
-        TaskPlayAnim(handle, dict, anim, blendInSpeed, blendOutSpeed, duration, flags, playbackRate, false, false, false);
+        this.platform.taskPlayAnim(handle, dict, anim, blendInSpeed, blendOutSpeed, duration, flags, playbackRate);
     }
-    /**
-     * Stop all animations on a ped.
-     *
-     * @param handle - Ped handle
-     */
     stopAnimation(handle) {
-        if (!DoesEntityExist(handle))
+        if (!this.platform.doesEntityExist(handle))
             return;
-        ClearPedTasks(handle);
+        this.platform.clearPedTasks(handle);
     }
-    /**
-     * Stop animation immediately on a ped.
-     *
-     * @param handle - Ped handle
-     */
     stopAnimationImmediately(handle) {
-        if (!DoesEntityExist(handle))
+        if (!this.platform.doesEntityExist(handle))
             return;
-        ClearPedTasksImmediately(handle);
+        this.platform.clearPedTasksImmediately(handle);
     }
-    /**
-     * Freeze a ped in place.
-     *
-     * @param handle - Ped handle
-     * @param freeze - Whether to freeze
-     */
     freeze(handle, freeze) {
-        if (!DoesEntityExist(handle))
+        if (!this.platform.doesEntityExist(handle))
             return;
-        FreezeEntityPosition(handle, freeze);
+        this.platform.freezeEntityPosition(handle, freeze);
     }
-    /**
-     * Set ped invincibility.
-     *
-     * @param handle - Ped handle
-     * @param invincible - Whether invincible
-     */
     setInvincible(handle, invincible) {
-        if (!DoesEntityExist(handle))
+        if (!this.platform.doesEntityExist(handle))
             return;
-        SetEntityInvincible(handle, invincible);
+        this.platform.setEntityInvincible(handle, invincible);
     }
-    /**
-     * Give a weapon to a ped.
-     *
-     * @param handle - Ped handle
-     * @param weapon - Weapon name/hash
-     * @param ammo - Ammo count
-     * @param hidden - Whether to hide the weapon
-     * @param forceInHand - Whether to force weapon in hand
-     */
     giveWeapon(handle, weapon, ammo = 100, hidden = false, forceInHand = true) {
-        if (!DoesEntityExist(handle))
+        if (!this.platform.doesEntityExist(handle))
             return;
-        const weaponHash = GetHashKey(weapon);
-        GiveWeaponToPed(handle, weaponHash, ammo, hidden, forceInHand);
+        this.platform.giveWeaponToPed(handle, this.platform.getHashKey(weapon), ammo, hidden, forceInHand);
     }
-    /**
-     * Remove all weapons from a ped.
-     *
-     * @param handle - Ped handle
-     */
     removeAllWeapons(handle) {
-        if (!DoesEntityExist(handle))
+        if (!this.platform.doesEntityExist(handle))
             return;
-        RemoveAllPedWeapons(handle, true);
+        this.platform.removeAllPedWeapons(handle, true);
     }
-    /**
-     * Get the closest ped to the player.
-     *
-     * @param radius - Search radius
-     * @param excludePlayer - Exclude the player ped
-     * @returns Ped handle or null
-     */
     getClosest(radius = 10.0, excludePlayer = true) {
-        const playerPed = PlayerPedId();
-        const [px, py, pz] = GetEntityCoords(playerPed, true);
-        const [found, handle] = GetClosestPed(px, py, pz, radius, true, true, true, false, -1);
-        if (!found || handle === 0)
+        const playerPed = this.platform.getLocalPlayerPed();
+        const handle = this.platform.getClosestPed(this.platform.getEntityCoords(playerPed), radius);
+        if (!handle)
             return null;
         if (excludePlayer && handle === playerPed)
             return null;
         return handle;
     }
-    /**
-     * Get all peds in a radius.
-     *
-     * @param position - Center position
-     * @param radius - Search radius
-     * @param excludePlayer - Exclude the player ped
-     * @returns Array of ped handles
-     */
     getNearby(position, radius, excludePlayer = true) {
-        const peds = [];
-        const playerPed = PlayerPedId();
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const [handle, _] = FindFirstPed(0);
-        const ped = handle;
-        do {
-            if (!DoesEntityExist(ped))
-                continue;
-            if (excludePlayer && ped === playerPed)
-                continue;
-            const [ex, ey, ez] = GetEntityCoords(ped, true);
-            const dist = Math.sqrt((ex - position.x) ** 2 + (ey - position.y) ** 2 + (ez - position.z) ** 2);
-            if (dist <= radius) {
-                peds.push(ped);
-            }
-        } while (FindNextPed(handle, ped));
-        EndFindPed(handle);
-        return peds;
+        return this.platform.getNearbyPeds(position, radius, excludePlayer ? this.platform.getLocalPlayerPed() : undefined);
     }
-    /**
-     * Make ped look at entity.
-     *
-     * @param handle - Ped handle
-     * @param entity - Entity to look at
-     * @param duration - Duration in ms (-1 for infinite)
-     */
     lookAtEntity(handle, entity, duration = -1) {
-        if (!DoesEntityExist(handle))
+        if (!this.platform.doesEntityExist(handle))
             return;
-        TaskLookAtEntity(handle, entity, duration, 2048, 3);
+        this.platform.taskLookAtEntity(handle, entity, duration);
     }
-    /**
-     * Make ped look at position.
-     *
-     * @param handle - Ped handle
-     * @param position - Position to look at
-     * @param duration - Duration in ms (-1 for infinite)
-     */
     lookAtCoords(handle, position, duration = -1) {
-        if (!DoesEntityExist(handle))
+        if (!this.platform.doesEntityExist(handle))
             return;
-        TaskLookAtCoord(handle, position.x, position.y, position.z, duration, 2048, 3);
+        this.platform.taskLookAtCoord(handle, position, duration);
     }
-    /**
-     * Make ped walk to position.
-     *
-     * @param handle - Ped handle
-     * @param position - Target position
-     * @param speed - Walking speed (1.0 = walk, 2.0 = run)
-     */
     walkTo(handle, position, speed = 1.0) {
-        if (!DoesEntityExist(handle))
+        if (!this.platform.doesEntityExist(handle))
             return;
-        TaskGoStraightToCoord(handle, position.x, position.y, position.z, speed, -1, 0.0, 0.0);
+        this.platform.taskGoStraightToCoord(handle, position, speed);
     }
-    /**
-     * Set ped combat attributes.
-     *
-     * @param handle - Ped handle
-     * @param canFight - Whether the ped can fight
-     * @param canUseCover - Whether the ped can use cover
-     */
     setCombatAttributes(handle, canFight, canUseCover = true) {
-        if (!DoesEntityExist(handle))
+        if (!this.platform.doesEntityExist(handle))
             return;
-        SetPedCombatAttributes(handle, 46, canFight); // Can fight
-        SetPedCombatAttributes(handle, 0, canUseCover); // Can use cover
+        this.platform.setPedCombatAttributes(handle, 46, canFight);
+        this.platform.setPedCombatAttributes(handle, 0, canUseCover);
     }
-    /**
-     * Get a managed ped by ID.
-     */
     get(id) {
         return this.peds.get(id);
     }
-    /**
-     * Get all managed peds.
-     */
     getAll() {
         return Array.from(this.peds.values());
     }
-    /**
-     * Check if a managed ped still exists.
-     */
     exists(id) {
         const ped = this.peds.get(id);
-        return ped ? DoesEntityExist(ped.handle) : false;
+        return ped ? this.platform.doesEntityExist(ped.handle) : false;
     }
 };
 PedService = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientPlatformBridge)),
+    __metadata("design:paramtypes", [IClientPlatformBridge])
 ], PedService);
 export { PedService };

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

@@ -1,25 +1,18 @@
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
 export interface ProgressOptions {
-    /** Progress label/title */
     label: string;
-    /** Duration in milliseconds */
     duration: number;
-    /** Whether to use a circular indicator */
     useCircular?: boolean;
-    /** Whether the player can cancel (usually with a key) */
     canCancel?: boolean;
-    /** Disable player controls during progress */
     disableControls?: boolean;
-    /** Disable player movement */
     disableMovement?: boolean;
-    /** Disable combat actions */
     disableCombat?: boolean;
-    /** Animation to play during progress */
     animation?: {
         dict: string;
         anim: string;
         flags?: number;
     };
-    /** Prop to attach during progress */
     prop?: {
         model: string;
         bone: number;
@@ -43,36 +36,18 @@ export interface ProgressState {
     duration: number;
     options: ProgressOptions;
 }
-/**
- * Service for displaying progress bars/indicators.
- */
 export declare class ProgressService {
+    private readonly platform;
+    private readonly runtime;
     private state;
     private tickHandle;
     private callback;
     private propHandle;
-    /**
-     * Start a progress action.
-     *
-     * @param options - Progress options
-     * @returns Promise that resolves with true if completed, false if cancelled
-     */
+    constructor(platform: IClientPlatformBridge, runtime: IClientRuntimeBridge);
     start(options: ProgressOptions): Promise<boolean>;
-    /**
-     * Cancel the current progress.
-     */
     cancel(): void;
-    /**
-     * Check if a progress is currently active.
-     */
     isActive(): boolean;
-    /**
-     * Get current progress percentage (0-100).
-     */
     getProgress(): number;
-    /**
-     * Get current progress state.
-     */
     getState(): ProgressState | null;
     private startProgress;
     private drawProgressBar;