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

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

@@ -7,52 +7,28 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { injectable } from 'tsyringe';
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
 import { loggers } from '../../../kernel';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
 import { AppearanceService } from './appearance.service';
-const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const NETWORK_TIMEOUT_MS = 15_000;
-const PED_TIMEOUT_MS = 10_000;
-const COLLISION_TIMEOUT_MS = 7_000;
-/**
- * Handles all player spawning logic on the client.
- *
- * This service manages the complete lifecycle of a player spawn:
- * - Waiting for the network session
- * - Loading and applying the player model
- * - Ensuring collision and world data is ready
- * - Resurrecting the player cleanly
- * - Applying default ped components for freemode models
- * - Fading the screen in/out during transitions
- *
- * The service is designed to be robust, predictable, and safe for any gamemode.
- */
+import { IClientSpawnBridge } from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
 let SpawnService = class SpawnService {
     appearanceService;
+    spawnBridge;
+    platform;
     spawned = false;
     spawning = false;
-    constructor(appearanceService) {
+    constructor(appearanceService, spawnBridge, platform) {
         this.appearanceService = appearanceService;
+        this.spawnBridge = spawnBridge;
+        this.platform = platform;
     }
     async init() {
         loggers.spawn.debug('SpawnService initialized');
     }
-    /**
-     * Performs the first spawn of the player.
-     *
-     * This method handles:
-     * - Fade out
-     * - Closing loading screens
-     * - Setting the player model
-     * - Ensuring the ped exists
-     * - Ensuring collision is loaded
-     * - Resurrecting the player
-     * - Preparing the ped for gameplay
-     * - Placing the player at the desired position
-     * - Fade in
-     *
-     * It should only be called once when the player joins.
-     */
     async spawn(position, model, heading = 0.0, options) {
         if (this.spawning) {
             loggers.spawn.warn('Spawn requested while a spawn is already in progress');
@@ -60,27 +36,22 @@ let SpawnService = class SpawnService {
         }
         this.spawning = true;
         try {
-            await this.ensureNetworkReady();
-            if (!IsScreenFadedOut() && !IsScreenFadingOut()) {
-                DoScreenFadeOut(500);
-                while (!IsScreenFadedOut()) {
-                    await delay(0);
+            loggers.spawn.debug('Waiting for spawn bridge readiness');
+            await this.spawnBridge.waitUntilReady();
+            loggers.spawn.debug('Spawn bridge ready, executing spawn', { position, model, heading });
+            await this.spawnBridge.spawn({ position, model, heading });
+            const ped = this.platform.getLocalPlayerPed();
+            if (ped !== 0) {
+                if (options?.appearance) {
+                    loggers.spawn.debug('Applying post-spawn appearance', { ped });
+                    await this.appearanceService.applyAppearance(ped, options.appearance);
+                }
+                else {
+                    this.appearanceService.setDefaultAppearance(ped);
                 }
             }
-            this.closeLoadingScreens();
-            await this.setPlayerModel(model);
-            const ped = await this.ensurePed();
-            await this.applyAppearanceIfNeeded(ped, options?.appearance);
-            await this.ensureCollisionAt(position, ped);
-            NetworkResurrectLocalPlayer(position.x, position.y, position.z, heading, 0, false);
-            const finalPed = await this.ensurePed();
-            await this.setupPedForGameplay(finalPed);
-            await this.placePed(finalPed, position, heading);
             this.spawned = true;
-            if (!IsScreenFadedIn() && !IsScreenFadingIn()) {
-                DoScreenFadeIn(500);
-            }
-            loggers.spawn.info('Player spawned successfully (first spawn)', {
+            loggers.spawn.info('Player spawned successfully', {
                 position: { x: position.x, y: position.y, z: position.z },
                 model,
             });
@@ -95,161 +66,33 @@ let SpawnService = class SpawnService {
             this.spawning = false;
         }
     }
-    /**
-     * Teleports the player instantly to a new position.
-     * Does not change the model or resurrect the player.
-     * Safe for gameplay use.
-     */
     async teleportTo(position, heading) {
-        const ped = await this.ensurePed();
-        await this.ensureCollisionAt(position, ped);
-        FreezeEntityPosition(ped, true);
-        SetEntityCoordsNoOffset(ped, position.x, position.y, position.z, false, false, false);
-        if (heading !== undefined) {
-            SetEntityHeading(ped, heading);
-        }
-        FreezeEntityPosition(ped, false);
+        await this.spawnBridge.teleport({ position, heading });
     }
-    /**
-     * Respawns the player after death or a gameplay event.
-     * Restores health, resurrects the player, loads collision,
-     * prepares the ped and teleports them to the desired location.
-     */
     async respawn(position, heading = 0.0) {
-        const ped = await this.ensurePed();
-        await this.ensureCollisionAt(position, ped);
-        ClearPedTasksImmediately(ped);
-        SetEntityHealth(ped, GetEntityMaxHealth(ped));
-        NetworkResurrectLocalPlayer(position.x, position.y, position.z, heading, 0, false);
-        const finalPed = await this.ensurePed();
-        await this.setupPedForGameplay(finalPed);
-        await this.teleportTo(position, heading);
+        await this.spawnBridge.waitUntilReady();
+        await this.spawnBridge.respawn({ position, heading });
+        this.spawned = true;
         loggers.spawn.info('Player respawned', {
             position: { x: position.x, y: position.y, z: position.z },
             heading,
         });
     }
-    /**
-     * Returns whether the player has completed their first spawn.
-     */
     isSpawned() {
         return this.spawned;
     }
-    /**
-     * Allows other systems to wait until the player is fully spawned.
-     */
     async waitUntilSpawned() {
         while (!this.spawned) {
-            await delay(0);
-        }
-    }
-    async ensureNetworkReady() {
-        const start = GetGameTimer();
-        while (!NetworkIsSessionStarted()) {
-            if (GetGameTimer() - start > NETWORK_TIMEOUT_MS) {
-                loggers.spawn.error('Network session did not start in time');
-                throw new Error('NETWORK_TIMEOUT');
-            }
-            await delay(0);
-        }
-    }
-    closeLoadingScreens() {
-        try {
-            ShutdownLoadingScreen();
-        }
-        catch { }
-        try {
-            ShutdownLoadingScreenNui();
-        }
-        catch { }
-    }
-    async setPlayerModel(model) {
-        const modelHash = GetHashKey(model);
-        if (!IsModelInCdimage(modelHash) || !IsModelValid(modelHash)) {
-            loggers.spawn.error('Invalid model requested', { model });
-            throw new Error('MODEL_INVALID');
-        }
-        RequestModel(modelHash);
-        while (!HasModelLoaded(modelHash)) {
-            await delay(0);
-        }
-        SetPlayerModel(PlayerId(), modelHash);
-        SetModelAsNoLongerNeeded(modelHash);
-        const ped = PlayerPedId();
-        if (ped !== 0) {
-            SetPedDefaultComponentVariation(ped);
-        }
-    }
-    async ensurePed() {
-        const start = GetGameTimer();
-        let ped = PlayerPedId();
-        while (ped === 0) {
-            if (GetGameTimer() - start > PED_TIMEOUT_MS) {
-                loggers.spawn.error('PlayerPedId() did not become valid in time');
-                throw new Error('PED_TIMEOUT');
-            }
-            await delay(0);
-            ped = PlayerPedId();
-        }
-        return ped;
-    }
-    async ensureCollisionAt(position, ped) {
-        RequestCollisionAtCoord(position.x, position.y, position.z);
-        const start = GetGameTimer();
-        while (!HasCollisionLoadedAroundEntity(ped)) {
-            if (GetGameTimer() - start > COLLISION_TIMEOUT_MS) {
-                loggers.spawn.warn('Collision did not fully load around entity in time', {
-                    x: position.x,
-                    y: position.y,
-                    z: position.z,
-                });
-                break;
-            }
-            await delay(0);
-        }
-    }
-    async setupPedForGameplay(ped) {
-        SetEntityAsMissionEntity(ped, true, true);
-        ClearPedTasksImmediately(ped);
-        RemoveAllPedWeapons(ped, true);
-        ResetEntityAlpha(ped);
-        await delay(0);
-        SetEntityAlpha(ped, 255, false);
-        SetEntityVisible(ped, true, false);
-        SetEntityCollision(ped, true, true);
-        SetEntityInvincible(ped, false);
-    }
-    async placePed(ped, position, heading) {
-        FreezeEntityPosition(ped, true);
-        SetEntityCoordsNoOffset(ped, position.x, position.y, position.z, false, false, false);
-        SetEntityHeading(ped, heading);
-        await delay(0);
-        FreezeEntityPosition(ped, false);
-    }
-    async applyAppearanceIfNeeded(ped, appearance) {
-        if (!appearance) {
-            SetPedDefaultComponentVariation(ped);
-            return;
-        }
-        const validation = this.appearanceService.validateAppearance(appearance);
-        if (!validation.valid) {
-            loggers.spawn.warn('Invalid appearance data', { errors: validation.errors });
-            SetPedDefaultComponentVariation(ped);
-            return;
-        }
-        try {
-            await this.appearanceService.applyAppearance(ped, appearance);
-        }
-        catch (error) {
-            loggers.spawn.error('Failed to apply appearance, using default variation', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            SetPedDefaultComponentVariation(ped);
+            await new Promise((resolve) => setTimeout(resolve, 0));
         }
     }
 };
 SpawnService = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [AppearanceService])
+    __param(1, inject(IClientSpawnBridge)),
+    __param(2, inject(IClientPlatformBridge)),
+    __metadata("design:paramtypes", [AppearanceService,
+        IClientSpawnBridge,
+        IClientPlatformBridge])
 ], SpawnService);
 export { SpawnService };

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

@@ -1,103 +1,28 @@
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
 export interface StreamingRequest {
     type: 'model' | 'animDict' | 'ptfx' | 'texture' | 'audio';
     asset: string;
     loaded: boolean;
     hash?: number;
 }
-/**
- * Service for managing asset streaming (models, animations, particles, etc.).
- */
 export declare class StreamingService {
+    private readonly platform;
+    private readonly runtime;
     private loadedAssets;
-    /**
-     * Request and load a model.
-     *
-     * @param model - Model name or hash
-     * @param timeout - Maximum wait time in ms
-     * @returns Whether the model was loaded successfully
-     */
+    constructor(platform: IClientPlatformBridge, runtime: IClientRuntimeBridge);
     requestModel(model: string | number, timeout?: number): Promise<boolean>;
-    /**
-     * Check if a model is loaded.
-     *
-     * @param model - Model name or hash
-     */
     isModelLoaded(model: string | number): boolean;
-    /**
-     * Release a loaded model.
-     *
-     * @param model - Model name or hash
-     */
     releaseModel(model: string | number): void;
-    /**
-     * Check if a model is valid and exists in the game files.
-     *
-     * @param model - Model name or hash
-     */
     isModelValid(model: string | number): boolean;
-    /**
-     * Check if a model is a vehicle.
-     *
-     * @param model - Model name or hash
-     */
     isModelVehicle(model: string | number): boolean;
-    /**
-     * Check if a model is a ped.
-     *
-     * @param model - Model name or hash
-     */
     isModelPed(model: string | number): boolean;
-    /**
-     * Request and load an animation dictionary.
-     *
-     * @param dict - Animation dictionary name
-     * @param timeout - Maximum wait time in ms
-     * @returns Whether the dictionary was loaded successfully
-     */
     requestAnimDict(dict: string, timeout?: number): Promise<boolean>;
-    /**
-     * Check if an animation dictionary is loaded.
-     *
-     * @param dict - Animation dictionary name
-     */
     isAnimDictLoaded(dict: string): boolean;
-    /**
-     * Release a loaded animation dictionary.
-     *
-     * @param dict - Animation dictionary name
-     */
     releaseAnimDict(dict: string): void;
-    /**
-     * Request and load a particle effect asset.
-     *
-     * @param asset - PTFX asset name
-     * @param timeout - Maximum wait time in ms
-     * @returns Whether the asset was loaded successfully
-     */
     requestPtfxAsset(asset: string, timeout?: number): Promise<boolean>;
-    /**
-     * Check if a PTFX asset is loaded.
-     *
-     * @param asset - PTFX asset name
-     */
     isPtfxAssetLoaded(asset: string): boolean;
-    /**
-     * Release a loaded PTFX asset.
-     *
-     * @param asset - PTFX asset name
-     */
     releasePtfxAsset(asset: string): void;
-    /**
-     * Start a particle effect at a position.
-     *
-     * @param asset - PTFX asset name
-     * @param effectName - Effect name within the asset
-     * @param position - World position
-     * @param rotation - Rotation
-     * @param scale - Scale
-     * @param looped - Whether to loop
-     * @returns The particle effect handle
-     */
     startParticleEffect(asset: string, effectName: string, position: {
         x: number;
         y: number;
@@ -107,59 +32,13 @@ export declare class StreamingService {
         y: number;
         z: number;
     }, scale?: number, looped?: boolean): Promise<number>;
-    /**
-     * Stop a looped particle effect.
-     *
-     * @param handle - Particle effect handle
-     */
     stopParticleEffect(handle: number): void;
-    /**
-     * Request and load a texture dictionary.
-     *
-     * @param dict - Texture dictionary name
-     * @param timeout - Maximum wait time in ms
-     * @returns Whether the dictionary was loaded successfully
-     */
     requestTextureDict(dict: string, timeout?: number): Promise<boolean>;
-    /**
-     * Check if a texture dictionary is loaded.
-     *
-     * @param dict - Texture dictionary name
-     */
     isTextureDictLoaded(dict: string): boolean;
-    /**
-     * Release a loaded texture dictionary.
-     *
-     * @param dict - Texture dictionary name
-     */
     releaseTextureDict(dict: string): void;
-    /**
-     * Request and load a script audio bank.
-     *
-     * @param audioBank - Audio bank name
-     * @param networked - Whether the audio should be networked
-     * @param timeout - Maximum wait time in ms
-     * @returns Whether the audio bank was loaded successfully
-     */
     requestAudioBank(audioBank: string, networked?: boolean, _timeout?: number): Promise<boolean>;
-    /**
-     * Release a loaded audio bank.
-     *
-     * @param audioBank - Audio bank name
-     */
     releaseAudioBank(audioBank: string): void;
-    /**
-     * Get all currently loaded assets.
-     */
     getLoadedAssets(): StreamingRequest[];
-    /**
-     * Release all loaded assets.
-     */
     releaseAll(): void;
-    /**
-     * Get hash key for a string.
-     *
-     * @param str - String to hash
-     */
     getHash(str: string): number;
 }