@open-core/framework 0.1.0-alpha.1

package/dist/client/services/notification.service.js

@@ -0,0 +1,111 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationService = void 0;
+const tsyringe_1 = require("tsyringe");
+/**
+ * Service for displaying native GTA V notifications.
+ */
+let NotificationService = class NotificationService {
+    /**
+     * Show a simple notification on screen.
+     *
+     * @param message - The message to display
+     * @param blink - Whether the notification should blink
+     */
+    show(message, blink = false) {
+        SetNotificationTextEntry('STRING');
+        AddTextComponentString(message);
+        DrawNotification(blink, true);
+    }
+    /**
+     * Show a notification with a type indicator using throbber icons.
+     *
+     * @param message - The message to display
+     * @param type - The notification type
+     */
+    showWithType(message, type = 'info') {
+        const iconMap = {
+            info: 1,
+            success: 2,
+            warning: 3,
+            error: 4,
+        };
+        BeginTextCommandThefeedPost('STRING');
+        AddTextComponentString(message);
+        EndTextCommandThefeedPostMessagetext('CHAR_SOCIAL_CLUB', 'CHAR_SOCIAL_CLUB', true, iconMap[type], '', message);
+    }
+    /**
+     * Show an advanced notification with picture/icon.
+     *
+     * @param options - Advanced notification options
+     */
+    showAdvanced(options) {
+        const { title, subtitle = '', message, textureDict = 'CHAR_HUMANDEFAULT', textureName = 'CHAR_HUMANDEFAULT', iconType = 1, flash = false, saveToBrief = true, backgroundColor, } = options;
+        SetNotificationTextEntry('STRING');
+        AddTextComponentString(message);
+        if (backgroundColor !== undefined) {
+            SetNotificationBackgroundColor(backgroundColor);
+        }
+        SetNotificationMessage(textureDict, textureName, flash, iconType, title, subtitle);
+        DrawNotification(flash, saveToBrief);
+    }
+    /**
+     * Show a help notification (appears at top-left).
+     *
+     * @param message - The help message
+     * @param duration - How long to show in milliseconds (-1 for indefinite)
+     * @param beep - Play a beep sound
+     * @param looped - Keep showing until cleared
+     */
+    showHelp(message, duration = 5000, beep = true, looped = false) {
+        BeginTextCommandDisplayHelp('STRING');
+        AddTextComponentSubstringPlayerName(message);
+        EndTextCommandDisplayHelp(0, looped, beep, duration);
+    }
+    /**
+     * Clear all help messages.
+     */
+    clearHelp() {
+        ClearAllHelpMessages();
+    }
+    /**
+     * Show a subtitle (centered at bottom of screen).
+     *
+     * @param message - The subtitle text
+     * @param duration - Duration in milliseconds
+     */
+    showSubtitle(message, duration = 2500) {
+        BeginTextCommandPrint('STRING');
+        AddTextComponentSubstringPlayerName(message);
+        EndTextCommandPrint(duration, true);
+    }
+    /**
+     * Clear the current subtitle.
+     */
+    clearSubtitle() {
+        ClearPrints();
+    }
+    /**
+     * Show a floating help text above the player's head.
+     *
+     * @param message - The message to display
+     */
+    showFloatingHelp(message) {
+        const [x, y, z] = GetEntityCoords(PlayerPedId(), true);
+        SetFloatingHelpTextWorldPosition(1, x, y, z);
+        SetFloatingHelpTextStyle(1, 1, 2, -1, 3, 0);
+        BeginTextCommandDisplayHelp('STRING');
+        AddTextComponentSubstringPlayerName(message);
+        EndTextCommandDisplayHelp(2, false, false, -1);
+    }
+};
+exports.NotificationService = NotificationService;
+exports.NotificationService = NotificationService = __decorate([
+    (0, tsyringe_1.injectable)()
+], NotificationService);

package/dist/client/services/ped.service.d.ts

@@ -0,0 +1,182 @@
+import type { Vector3 } from '../../utils';
+export interface PedSpawnOptions {
+    /** Model name or hash */
+    model: string;
+    /** Spawn position */
+    position: Vector3;
+    /** Heading/rotation */
+    heading?: number;
+    /** Network the ped */
+    networked?: boolean;
+    /** Make the ped a mission entity */
+    missionEntity?: boolean;
+    /** Relationship group */
+    relationshipGroup?: string;
+    /** Whether to block non-temporary events */
+    blockEvents?: boolean;
+}
+export interface PedAnimationOptions {
+    /** Animation dictionary */
+    dict: string;
+    /** Animation name */
+    anim: string;
+    /** Blend in speed */
+    blendInSpeed?: number;
+    /** Blend out speed */
+    blendOutSpeed?: number;
+    /** Duration (-1 for looped) */
+    duration?: number;
+    /** Animation flags */
+    flags?: number;
+    /** Playback rate */
+    playbackRate?: number;
+}
+export interface ManagedPed {
+    id: string;
+    handle: number;
+    model: string;
+    position: Vector3;
+}
+/**
+ * Service for ped (NPC) operations and management.
+ */
+export declare class PedService {
+    private peds;
+    private idCounter;
+    /**
+     * Spawn a ped at a position.
+     *
+     * @param options - Spawn options
+     * @returns The ped ID and handle
+     */
+    spawn(options: PedSpawnOptions): Promise<{
+        id: string;
+        handle: number;
+    }>;
+    /**
+     * Delete a ped by ID.
+     *
+     * @param id - The ped ID
+     */
+    delete(id: string): boolean;
+    /**
+     * Delete a ped by handle.
+     *
+     * @param handle - The ped handle
+     */
+    deleteByHandle(handle: number): void;
+    /**
+     * Delete all managed peds.
+     */
+    deleteAll(): void;
+    /**
+     * Play an animation on a ped.
+     *
+     * @param handle - Ped handle
+     * @param options - Animation options
+     */
+    playAnimation(handle: number, options: PedAnimationOptions): Promise<void>;
+    /**
+     * Stop all animations on a ped.
+     *
+     * @param handle - Ped handle
+     */
+    stopAnimation(handle: number): void;
+    /**
+     * Stop animation immediately on a ped.
+     *
+     * @param handle - Ped handle
+     */
+    stopAnimationImmediately(handle: number): void;
+    /**
+     * Freeze a ped in place.
+     *
+     * @param handle - Ped handle
+     * @param freeze - Whether to freeze
+     */
+    freeze(handle: number, freeze: boolean): void;
+    /**
+     * Set ped invincibility.
+     *
+     * @param handle - Ped handle
+     * @param invincible - Whether invincible
+     */
+    setInvincible(handle: number, invincible: boolean): void;
+    /**
+     * 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: number, weapon: string, ammo?: number, hidden?: boolean, forceInHand?: boolean): void;
+    /**
+     * Remove all weapons from a ped.
+     *
+     * @param handle - Ped handle
+     */
+    removeAllWeapons(handle: number): void;
+    /**
+     * Get the closest ped to the player.
+     *
+     * @param radius - Search radius
+     * @param excludePlayer - Exclude the player ped
+     * @returns Ped handle or null
+     */
+    getClosest(radius?: number, excludePlayer?: boolean): number | null;
+    /**
+     * 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: Vector3, radius: number, excludePlayer?: boolean): number[];
+    /**
+     * 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: number, entity: number, duration?: number): void;
+    /**
+     * 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: number, position: Vector3, duration?: number): void;
+    /**
+     * 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: number, position: Vector3, speed?: number): void;
+    /**
+     * 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: number, canFight: boolean, canUseCover?: boolean): void;
+    /**
+     * Get a managed ped by ID.
+     */
+    get(id: string): ManagedPed | undefined;
+    /**
+     * Get all managed peds.
+     */
+    getAll(): ManagedPed[];
+    /**
+     * Check if a managed ped still exists.
+     */
+    exists(id: string): boolean;
+}

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

@@ -0,0 +1,302 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PedService = void 0;
+const tsyringe_1 = require("tsyringe");
+/**
+ * Service for ped (NPC) operations and management.
+ */
+let PedService = class PedService {
+    constructor() {
+        this.peds = new Map();
+        this.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();
+        const [handle, _] = FindFirstPed(0);
+        let ped = handle;
+        do {
+            if (!DoesEntityExist(ped))
+                continue;
+            if (excludePlayer && ped === playerPed)
+                continue;
+            const [ex, ey, ez] = GetEntityCoords(ped, true);
+            const dist = Math.sqrt(Math.pow(ex - position.x, 2) + Math.pow(ey - position.y, 2) + Math.pow(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;
+    }
+};
+exports.PedService = PedService;
+exports.PedService = PedService = __decorate([
+    (0, tsyringe_1.injectable)()
+], PedService);

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

@@ -0,0 +1,82 @@
+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;
+        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;
+}
+/**
+ * Service for displaying progress bars/indicators.
+ */
+export declare class ProgressService {
+    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
+     */
+    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;
+    private cleanup;
+    private loadAnimDict;
+    private loadModel;
+}