@open-core/framework 1.0.1-beta.1

package/dist/client/services/world/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/world/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/world/vehicle.service.d.ts

@@ -0,0 +1,168 @@
+import type { Vector3 } from '../../../utils';
+export interface VehicleSpawnOptions {
+    /** Model name or hash */
+    model: string;
+    /** Spawn position */
+    position: Vector3;
+    /** Heading/rotation */
+    heading?: number;
+    /** Whether to place on ground */
+    placeOnGround?: boolean;
+    /** Whether to warp the player into the vehicle */
+    warpIntoVehicle?: boolean;
+    /** Seat index to warp into (-1 = driver) */
+    seatIndex?: number;
+    /** Primary color */
+    primaryColor?: number;
+    /** Secondary color */
+    secondaryColor?: number;
+    /** License plate text */
+    plate?: string;
+    /** Network the vehicle */
+    networked?: boolean;
+}
+export interface VehicleMods {
+    spoiler?: number;
+    frontBumper?: number;
+    rearBumper?: number;
+    sideSkirt?: number;
+    exhaust?: number;
+    frame?: number;
+    grille?: number;
+    hood?: number;
+    fender?: number;
+    rightFender?: number;
+    roof?: number;
+    engine?: number;
+    brakes?: number;
+    transmission?: number;
+    horns?: number;
+    suspension?: number;
+    armor?: number;
+    turbo?: boolean;
+    xenon?: boolean;
+    wheelType?: number;
+    wheels?: number;
+    windowTint?: number;
+    livery?: number;
+    plateStyle?: number;
+}
+/**
+ * Service for vehicle operations and management.
+ */
+export declare class VehicleService {
+    /**
+     * Spawn a vehicle at a position.
+     *
+     * @param options - Spawn options
+     * @returns The vehicle handle
+     */
+    spawn(options: VehicleSpawnOptions): Promise<number>;
+    /**
+     * Delete a vehicle.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    delete(vehicle: number): void;
+    /**
+     * Delete the vehicle the player is currently in.
+     */
+    deleteCurrentVehicle(): void;
+    /**
+     * Repair a vehicle completely.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    repair(vehicle: number): void;
+    /**
+     * Set vehicle fuel level.
+     *
+     * @param vehicle - Vehicle handle
+     * @param level - Fuel level (0.0-1.0)
+     */
+    setFuel(vehicle: number, level: number): void;
+    /**
+     * Get vehicle fuel level.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Fuel level (0.0-1.0)
+     */
+    getFuel(vehicle: number): number;
+    /**
+     * Get the closest vehicle to the player.
+     *
+     * @param radius - Search radius
+     * @returns Vehicle handle or null
+     */
+    getClosest(radius?: number): number | null;
+    /**
+     * Check if the player is in a vehicle.
+     */
+    isPlayerInVehicle(): boolean;
+    /**
+     * Get the vehicle the player is currently in.
+     *
+     * @returns Vehicle handle or null
+     */
+    getCurrentVehicle(): number | null;
+    /**
+     * Get the last vehicle the player was in.
+     *
+     * @returns Vehicle handle or null
+     */
+    getLastVehicle(): number | null;
+    /**
+     * Check if player is the driver of their current vehicle.
+     */
+    isPlayerDriver(): boolean;
+    /**
+     * Apply modifications to a vehicle.
+     *
+     * @param vehicle - Vehicle handle
+     * @param mods - Modifications to apply
+     */
+    setMods(vehicle: number, mods: VehicleMods): void;
+    /**
+     * Set vehicle doors locked state.
+     *
+     * @param vehicle - Vehicle handle
+     * @param locked - Whether doors should be locked
+     */
+    setDoorsLocked(vehicle: number, locked: boolean): void;
+    /**
+     * Set vehicle engine state.
+     *
+     * @param vehicle - Vehicle handle
+     * @param running - Whether engine should be running
+     * @param instant - Whether to start instantly
+     */
+    setEngineRunning(vehicle: number, running: boolean, instant?: boolean): void;
+    /**
+     * Set vehicle invincibility.
+     *
+     * @param vehicle - Vehicle handle
+     * @param invincible - Whether vehicle should be invincible
+     */
+    setInvincible(vehicle: number, invincible: boolean): void;
+    /**
+     * Get vehicle speed in km/h.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    getSpeed(vehicle: number): number;
+    /**
+     * Set vehicle heading/rotation.
+     *
+     * @param vehicle - Vehicle handle
+     * @param heading - Heading in degrees
+     */
+    setHeading(vehicle: number, heading: number): void;
+    /**
+     * Teleport a vehicle to a position.
+     *
+     * @param vehicle - Vehicle handle
+     * @param position - Target position
+     * @param heading - Optional heading
+     */
+    teleport(vehicle: number, position: Vector3, heading?: number): void;
+}