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

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

@@ -0,0 +1,298 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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.
+ */
+let PedService = class PedService {
+    peds = new Map();
+    idCounter = 0;
+    /**
+     * Spawn a ped at a position.
+     *
+     * @param options - Spawn options
+     * @returns The ped ID and handle
+     */
+    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)) {
+            throw new Error(`Invalid ped model: ${model}`);
+        }
+        RequestModel(modelHash);
+        while (!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) {
+            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
+        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);
+        }
+        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);
+        }
+        // Remove from our map if tracked
+        for (const [id, ped] of this.peds) {
+            if (ped.handle === handle) {
+                this.peds.delete(id);
+                break;
+            }
+        }
+    }
+    /**
+     * Delete all managed peds.
+     */
+    deleteAll() {
+        for (const ped of this.peds.values()) {
+            if (DoesEntityExist(ped.handle)) {
+                SetEntityAsMissionEntity(ped.handle, true, true);
+                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))
+            return;
+        // Load anim dict
+        RequestAnimDict(dict);
+        while (!HasAnimDictLoaded(dict)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        TaskPlayAnim(handle, dict, anim, blendInSpeed, blendOutSpeed, duration, flags, playbackRate, false, false, false);
+    }
+    /**
+     * Stop all animations on a ped.
+     *
+     * @param handle - Ped handle
+     */
+    stopAnimation(handle) {
+        if (!DoesEntityExist(handle))
+            return;
+        ClearPedTasks(handle);
+    }
+    /**
+     * Stop animation immediately on a ped.
+     *
+     * @param handle - Ped handle
+     */
+    stopAnimationImmediately(handle) {
+        if (!DoesEntityExist(handle))
+            return;
+        ClearPedTasksImmediately(handle);
+    }
+    /**
+     * Freeze a ped in place.
+     *
+     * @param handle - Ped handle
+     * @param freeze - Whether to freeze
+     */
+    freeze(handle, freeze) {
+        if (!DoesEntityExist(handle))
+            return;
+        FreezeEntityPosition(handle, freeze);
+    }
+    /**
+     * Set ped invincibility.
+     *
+     * @param handle - Ped handle
+     * @param invincible - Whether invincible
+     */
+    setInvincible(handle, invincible) {
+        if (!DoesEntityExist(handle))
+            return;
+        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))
+            return;
+        const weaponHash = GetHashKey(weapon);
+        GiveWeaponToPed(handle, weaponHash, ammo, hidden, forceInHand);
+    }
+    /**
+     * Remove all weapons from a ped.
+     *
+     * @param handle - Ped handle
+     */
+    removeAllWeapons(handle) {
+        if (!DoesEntityExist(handle))
+            return;
+        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)
+            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;
+    }
+    /**
+     * 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))
+            return;
+        TaskLookAtEntity(handle, entity, duration, 2048, 3);
+    }
+    /**
+     * 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))
+            return;
+        TaskLookAtCoord(handle, position.x, position.y, position.z, duration, 2048, 3);
+    }
+    /**
+     * 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))
+            return;
+        TaskGoStraightToCoord(handle, position.x, position.y, position.z, speed, -1, 0.0, 0.0);
+    }
+    /**
+     * 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))
+            return;
+        SetPedCombatAttributes(handle, 46, canFight); // Can fight
+        SetPedCombatAttributes(handle, 0, canUseCover); // Can use cover
+    }
+    /**
+     * 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;
+    }
+};
+PedService = __decorate([
+    injectable()
+], PedService);
+export { PedService };

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

@@ -0,0 +1,199 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 displaying progress bars/indicators.
+ */
+let ProgressService = class ProgressService {
+    state = null;
+    tickHandle = null;
+    callback = null;
+    propHandle = null;
+    /**
+     * Start a progress action.
+     *
+     * @param options - Progress options
+     * @returns Promise that resolves with true if completed, false if cancelled
+     */
+    async start(options) {
+        if (this.state?.active) {
+            return false;
+        }
+        return new Promise((resolve) => {
+            this.state = {
+                active: true,
+                progress: 0,
+                label: options.label,
+                startTime: GetGameTimer(),
+                duration: options.duration,
+                options,
+            };
+            this.callback = resolve;
+            this.startProgress();
+        });
+    }
+    /**
+     * Cancel the current progress.
+     */
+    cancel() {
+        if (!this.state?.active)
+            return;
+        this.cleanup(false);
+    }
+    /**
+     * Check if a progress is currently active.
+     */
+    isActive() {
+        return this.state?.active ?? false;
+    }
+    /**
+     * Get current progress percentage (0-100).
+     */
+    getProgress() {
+        return this.state?.progress ?? 0;
+    }
+    /**
+     * Get current progress state.
+     */
+    getState() {
+        return this.state;
+    }
+    async startProgress() {
+        if (!this.state)
+            return;
+        const { options } = this.state;
+        const ped = PlayerPedId();
+        // Load and play animation if specified
+        if (options.animation) {
+            await this.loadAnimDict(options.animation.dict);
+            TaskPlayAnim(ped, options.animation.dict, options.animation.anim, 8.0, -8.0, options.duration, options.animation.flags ?? 1, 0.0, false, false, false);
+        }
+        // Attach prop if specified
+        if (options.prop) {
+            await this.loadModel(options.prop.model);
+            const propHash = GetHashKey(options.prop.model);
+            const coords = GetEntityCoords(ped, true);
+            this.propHandle = CreateObject(propHash, coords[0], coords[1], coords[2], true, true, true);
+            AttachEntityToEntity(this.propHandle, ped, GetPedBoneIndex(ped, options.prop.bone), options.prop.offset.x, options.prop.offset.y, options.prop.offset.z, options.prop.rotation.x, options.prop.rotation.y, options.prop.rotation.z, true, true, false, true, 1, true);
+        }
+        // Start the tick
+        this.tickHandle = setTick(() => {
+            if (!this.state)
+                return;
+            const elapsed = GetGameTimer() - this.state.startTime;
+            this.state.progress = Math.min((elapsed / this.state.duration) * 100, 100);
+            // Handle controls
+            if (options.disableControls) {
+                DisableAllControlActions(0);
+            }
+            else {
+                if (options.disableMovement) {
+                    DisableControlAction(0, 30, true); // Move LR
+                    DisableControlAction(0, 31, true); // Move UD
+                    DisableControlAction(0, 21, true); // Sprint
+                    DisableControlAction(0, 22, true); // Jump
+                }
+                if (options.disableCombat) {
+                    DisableControlAction(0, 24, true); // Attack
+                    DisableControlAction(0, 25, true); // Aim
+                    DisableControlAction(0, 47, true); // Weapon
+                    DisableControlAction(0, 58, true); // Weapon
+                    DisableControlAction(0, 263, true); // Melee
+                    DisableControlAction(0, 264, true); // Melee
+                }
+            }
+            // Check for cancel
+            if (options.canCancel && IsControlJustPressed(0, 200)) {
+                // ESC key
+                this.cancel();
+                return;
+            }
+            // Draw progress bar (native style)
+            this.drawProgressBar();
+            // Check completion
+            if (elapsed >= this.state.duration) {
+                this.cleanup(true);
+            }
+        });
+    }
+    drawProgressBar() {
+        if (!this.state)
+            return;
+        const { label, progress, options } = this.state;
+        if (options.useCircular) {
+            // Circular progress indicator
+            BeginTextCommandBusyspinnerOn('STRING');
+            AddTextComponentString(label);
+            EndTextCommandBusyspinnerOn(4);
+        }
+        else {
+            // Bar style progress
+            const barWidth = 0.15;
+            const barHeight = 0.015;
+            const x = 0.5 - barWidth / 2;
+            const y = 0.88;
+            // Background
+            DrawRect(0.5, y + barHeight / 2, barWidth, barHeight, 0, 0, 0, 180);
+            // Progress fill
+            const fillWidth = (barWidth * progress) / 100;
+            DrawRect(x + fillWidth / 2, y + barHeight / 2, fillWidth, barHeight, 255, 255, 255, 255);
+            // Label
+            SetTextFont(4);
+            SetTextScale(0.35, 0.35);
+            SetTextColour(255, 255, 255, 255);
+            SetTextCentre(true);
+            BeginTextCommandDisplayText('STRING');
+            AddTextComponentString(`${label} (${Math.floor(progress)}%)`);
+            EndTextCommandDisplayText(0.5, y - 0.03);
+        }
+    }
+    cleanup(completed) {
+        const ped = PlayerPedId();
+        // Stop animation
+        if (this.state?.options.animation) {
+            StopAnimTask(ped, this.state.options.animation.dict, this.state.options.animation.anim, 1.0);
+        }
+        // Remove prop
+        if (this.propHandle) {
+            DeleteEntity(this.propHandle);
+            this.propHandle = null;
+        }
+        // Clear tick
+        if (this.tickHandle !== null) {
+            clearTick(this.tickHandle);
+            this.tickHandle = null;
+        }
+        // Clear busy spinner
+        if (this.state?.options.useCircular) {
+            BusyspinnerOff();
+        }
+        // Reset state
+        this.state = null;
+        // Invoke callback
+        if (this.callback) {
+            this.callback(completed);
+            this.callback = null;
+        }
+    }
+    async loadAnimDict(dict) {
+        RequestAnimDict(dict);
+        while (!HasAnimDictLoaded(dict)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+    }
+    async loadModel(model) {
+        const hash = GetHashKey(model);
+        RequestModel(hash);
+        while (!HasModelLoaded(hash)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+    }
+};
+ProgressService = __decorate([
+    injectable()
+], ProgressService);
+export { ProgressService };

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

@@ -0,0 +1,73 @@
+import { PlayerAppearance } from '../../../kernel';
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { AppearanceService } from './appearance.service';
+interface SpawnOptions {
+    /** Optional: Apply complete character appearance (RP clothing, face, props, tattoos...) */
+    appearance?: PlayerAppearance;
+}
+/**
+ * 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.
+ */
+export declare class SpawnService {
+    private appearanceService;
+    private spawned;
+    private spawning;
+    constructor(appearanceService: AppearanceService);
+    init(): Promise<void>;
+    /**
+     * 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.
+     */
+    spawn(position: Vector3, model: string, heading?: number, options?: SpawnOptions): Promise<void>;
+    /**
+     * Teleports the player instantly to a new position.
+     * Does not change the model or resurrect the player.
+     * Safe for gameplay use.
+     */
+    teleportTo(position: Vector3, heading?: number): Promise<void>;
+    /**
+     * 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.
+     */
+    respawn(position: Vector3, heading?: number): Promise<void>;
+    /**
+     * Returns whether the player has completed their first spawn.
+     */
+    isSpawned(): boolean;
+    /**
+     * Allows other systems to wait until the player is fully spawned.
+     */
+    waitUntilSpawned(): Promise<void>;
+    private ensureNetworkReady;
+    private closeLoadingScreens;
+    private setPlayerModel;
+    private ensurePed;
+    private ensureCollisionAt;
+    private setupPedForGameplay;
+    private placePed;
+    private applyAppearanceIfNeeded;
+}
+export {};