@open-core/framework 1.0.1-beta.1

package/dist/client/services/world/blip.service.d.ts

@@ -0,0 +1,112 @@
+import type { Vector3 } from '../../../utils';
+export interface BlipOptions {
+    /** Blip sprite ID (icon) */
+    sprite?: number;
+    /** Blip color ID */
+    color?: number;
+    /** Blip scale */
+    scale?: number;
+    /** Short range blip (only visible nearby) */
+    shortRange?: boolean;
+    /** Blip label/name */
+    label?: string;
+    /** Display category (affects visibility on map) */
+    display?: number;
+    /** Blip category */
+    category?: number;
+    /** Flash the blip */
+    flash?: boolean;
+    /** Blip alpha (0-255) */
+    alpha?: number;
+    /** Route to this blip */
+    route?: boolean;
+    /** Route color */
+    routeColor?: number;
+}
+export interface ManagedBlip {
+    id: string;
+    handle: number;
+    position: Vector3;
+    options: BlipOptions;
+}
+/**
+ * Service for creating and managing map blips.
+ */
+export declare class BlipService {
+    private blips;
+    private idCounter;
+    /**
+     * Create a blip at a world position.
+     *
+     * @param position - World position
+     * @param options - Blip options
+     * @returns The blip ID
+     */
+    create(position: Vector3, options?: BlipOptions): string;
+    /**
+     * Create a blip attached to an entity.
+     *
+     * @param entity - Entity handle
+     * @param options - Blip options
+     * @returns The blip ID
+     */
+    createForEntity(entity: number, options?: BlipOptions): string;
+    /**
+     * Create a blip for a radius/area.
+     *
+     * @param position - Center position
+     * @param radius - Radius of the area
+     * @param options - Blip options
+     * @returns The blip ID
+     */
+    createForRadius(position: Vector3, radius: number, options?: BlipOptions): string;
+    /**
+     * Remove a blip by ID.
+     *
+     * @param id - The blip ID
+     */
+    remove(id: string): boolean;
+    /**
+     * Remove all managed blips.
+     */
+    removeAll(): void;
+    /**
+     * Update blip options.
+     *
+     * @param id - The blip ID
+     * @param options - New options to apply
+     */
+    update(id: string, options: Partial<BlipOptions>): boolean;
+    /**
+     * Set blip position.
+     *
+     * @param id - The blip ID
+     * @param position - New position
+     */
+    setPosition(id: string, position: Vector3): boolean;
+    /**
+     * Set whether a route should be drawn to the blip.
+     *
+     * @param id - The blip ID
+     * @param enabled - Whether to show the route
+     * @param color - Optional route color
+     */
+    setRoute(id: string, enabled: boolean, color?: number): boolean;
+    /**
+     * Get blip by ID.
+     */
+    get(id: string): ManagedBlip | undefined;
+    /**
+     * Get all managed blips.
+     */
+    getAll(): ManagedBlip[];
+    /**
+     * Get the native blip handle by ID.
+     */
+    getHandle(id: string): number | undefined;
+    /**
+     * Check if a blip still exists in the game world.
+     */
+    exists(id: string): boolean;
+    private applyOptions;
+}

package/dist/client/services/world/blip.service.js

@@ -0,0 +1,215 @@
+"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.BlipService = void 0;
+const tsyringe_1 = require("tsyringe");
+const DEFAULT_OPTIONS = {
+    sprite: 1,
+    color: 1,
+    scale: 1.0,
+    shortRange: true,
+    display: 4,
+    category: 0,
+    flash: false,
+    alpha: 255,
+    route: false,
+};
+/**
+ * Service for creating and managing map blips.
+ */
+let BlipService = class BlipService {
+    constructor() {
+        this.blips = new Map();
+        this.idCounter = 0;
+    }
+    /**
+     * Create a blip at a world position.
+     *
+     * @param position - World position
+     * @param options - Blip options
+     * @returns The blip ID
+     */
+    create(position, options = {}) {
+        const id = `blip_${++this.idCounter}`;
+        const opts = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
+        const handle = AddBlipForCoord(position.x, position.y, position.z);
+        this.applyOptions(handle, opts);
+        this.blips.set(id, { id, handle, position, options: opts });
+        return id;
+    }
+    /**
+     * Create a blip attached to an entity.
+     *
+     * @param entity - Entity handle
+     * @param options - Blip options
+     * @returns The blip ID
+     */
+    createForEntity(entity, options = {}) {
+        const id = `blip_${++this.idCounter}`;
+        const opts = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
+        const handle = AddBlipForEntity(entity);
+        this.applyOptions(handle, opts);
+        const [x, y, z] = GetEntityCoords(entity, true);
+        this.blips.set(id, { id, handle, position: { x, y, z }, options: opts });
+        return id;
+    }
+    /**
+     * Create a blip for a radius/area.
+     *
+     * @param position - Center position
+     * @param radius - Radius of the area
+     * @param options - Blip options
+     * @returns The blip ID
+     */
+    createForRadius(position, radius, options = {}) {
+        const id = `blip_${++this.idCounter}`;
+        const opts = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
+        const handle = AddBlipForRadius(position.x, position.y, position.z, radius);
+        this.applyOptions(handle, opts);
+        this.blips.set(id, { id, handle, position, options: opts });
+        return id;
+    }
+    /**
+     * Remove a blip by ID.
+     *
+     * @param id - The blip ID
+     */
+    remove(id) {
+        const blip = this.blips.get(id);
+        if (!blip)
+            return false;
+        if (DoesBlipExist(blip.handle)) {
+            RemoveBlip(blip.handle);
+        }
+        this.blips.delete(id);
+        return true;
+    }
+    /**
+     * Remove all managed blips.
+     */
+    removeAll() {
+        for (const blip of this.blips.values()) {
+            if (DoesBlipExist(blip.handle)) {
+                RemoveBlip(blip.handle);
+            }
+        }
+        this.blips.clear();
+    }
+    /**
+     * Update blip options.
+     *
+     * @param id - The blip ID
+     * @param options - New options to apply
+     */
+    update(id, options) {
+        const blip = this.blips.get(id);
+        if (!blip || !DoesBlipExist(blip.handle))
+            return false;
+        blip.options = Object.assign(Object.assign({}, blip.options), options);
+        this.applyOptions(blip.handle, blip.options);
+        return true;
+    }
+    /**
+     * Set blip position.
+     *
+     * @param id - The blip ID
+     * @param position - New position
+     */
+    setPosition(id, position) {
+        const blip = this.blips.get(id);
+        if (!blip || !DoesBlipExist(blip.handle))
+            return false;
+        SetBlipCoords(blip.handle, position.x, position.y, position.z);
+        blip.position = position;
+        return true;
+    }
+    /**
+     * Set whether a route should be drawn to the blip.
+     *
+     * @param id - The blip ID
+     * @param enabled - Whether to show the route
+     * @param color - Optional route color
+     */
+    setRoute(id, enabled, color) {
+        const blip = this.blips.get(id);
+        if (!blip || !DoesBlipExist(blip.handle))
+            return false;
+        SetBlipRoute(blip.handle, enabled);
+        if (color !== undefined) {
+            SetBlipRouteColour(blip.handle, color);
+        }
+        return true;
+    }
+    /**
+     * Get blip by ID.
+     */
+    get(id) {
+        return this.blips.get(id);
+    }
+    /**
+     * Get all managed blips.
+     */
+    getAll() {
+        return Array.from(this.blips.values());
+    }
+    /**
+     * Get the native blip handle by ID.
+     */
+    getHandle(id) {
+        var _a;
+        return (_a = this.blips.get(id)) === null || _a === void 0 ? void 0 : _a.handle;
+    }
+    /**
+     * Check if a blip still exists in the game world.
+     */
+    exists(id) {
+        const blip = this.blips.get(id);
+        return blip ? DoesBlipExist(blip.handle) : false;
+    }
+    applyOptions(handle, options) {
+        if (options.sprite !== undefined) {
+            SetBlipSprite(handle, options.sprite);
+        }
+        if (options.color !== undefined) {
+            SetBlipColour(handle, options.color);
+        }
+        if (options.scale !== undefined) {
+            SetBlipScale(handle, options.scale);
+        }
+        if (options.shortRange !== undefined) {
+            SetBlipAsShortRange(handle, options.shortRange);
+        }
+        if (options.label) {
+            BeginTextCommandSetBlipName('STRING');
+            AddTextComponentString(options.label);
+            EndTextCommandSetBlipName(handle);
+        }
+        if (options.display !== undefined) {
+            SetBlipDisplay(handle, options.display);
+        }
+        if (options.category !== undefined) {
+            SetBlipCategory(handle, options.category);
+        }
+        if (options.flash !== undefined) {
+            SetBlipFlashes(handle, options.flash);
+        }
+        if (options.alpha !== undefined) {
+            SetBlipAlpha(handle, options.alpha);
+        }
+        if (options.route !== undefined) {
+            SetBlipRoute(handle, options.route);
+            if (options.routeColor !== undefined) {
+                SetBlipRouteColour(handle, options.routeColor);
+            }
+        }
+    }
+};
+exports.BlipService = BlipService;
+exports.BlipService = BlipService = __decorate([
+    (0, tsyringe_1.injectable)()
+], BlipService);

package/dist/client/services/world/index.d.ts

@@ -0,0 +1,4 @@
+export * from './marker.service';
+export * from './blip.service';
+export * from './vehicle.service';
+export * from './ped.service';

package/dist/client/services/world/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./marker.service"), exports);
+__exportStar(require("./blip.service"), exports);
+__exportStar(require("./vehicle.service"), exports);
+__exportStar(require("./ped.service"), exports);

package/dist/client/services/world/marker.service.d.ts

@@ -0,0 +1,94 @@
+import type { Vector3 } from '../../../utils';
+export interface MarkerOptions {
+    /** Marker type (0-43) */
+    type?: number;
+    /** Scale of the marker */
+    scale?: Vector3;
+    /** Rotation of the marker */
+    rotation?: Vector3;
+    /** Color (RGBA) */
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    /** Whether the marker should bob up and down */
+    bobUpAndDown?: boolean;
+    /** Whether the marker should face the camera */
+    faceCamera?: boolean;
+    /** Whether the marker should rotate */
+    rotate?: boolean;
+    /** Draw on entities */
+    drawOnEnts?: boolean;
+}
+export interface ManagedMarker {
+    id: string;
+    position: Vector3;
+    options: Required<MarkerOptions>;
+    visible: boolean;
+}
+/**
+ * Service for managing and rendering markers in the game world.
+ * Handles automatic rendering via tick.
+ */
+export declare class MarkerService {
+    private markers;
+    private tickHandle;
+    private idCounter;
+    /**
+     * Create a new managed marker.
+     *
+     * @param position - World position for the marker
+     * @param options - Marker appearance options
+     * @returns The marker ID
+     */
+    create(position: Vector3, options?: MarkerOptions): string;
+    /**
+     * Remove a marker by ID.
+     *
+     * @param id - The marker ID to remove
+     */
+    remove(id: string): boolean;
+    /**
+     * Remove all markers.
+     */
+    removeAll(): void;
+    /**
+     * Update a marker's position.
+     *
+     * @param id - The marker ID
+     * @param position - New position
+     */
+    setPosition(id: string, position: Vector3): boolean;
+    /**
+     * Update marker options.
+     *
+     * @param id - The marker ID
+     * @param options - Options to update
+     */
+    setOptions(id: string, options: Partial<MarkerOptions>): boolean;
+    /**
+     * Set marker visibility.
+     *
+     * @param id - The marker ID
+     * @param visible - Whether the marker should be visible
+     */
+    setVisible(id: string, visible: boolean): boolean;
+    /**
+     * Get a marker by ID.
+     */
+    get(id: string): ManagedMarker | undefined;
+    /**
+     * Get all managed markers.
+     */
+    getAll(): ManagedMarker[];
+    /**
+     * Draw a marker immediately (one frame only).
+     * For persistent markers, use create() instead.
+     */
+    drawOnce(position: Vector3, options?: MarkerOptions): void;
+    private ensureTickRunning;
+    private stopTick;
+    private checkTickNeeded;
+}

package/dist/client/services/world/marker.service.js

@@ -0,0 +1,153 @@
+"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.MarkerService = void 0;
+const tsyringe_1 = require("tsyringe");
+const DEFAULT_OPTIONS = {
+    type: 1,
+    scale: { x: 1.0, y: 1.0, z: 1.0 },
+    rotation: { x: 0, y: 0, z: 0 },
+    color: { r: 255, g: 0, b: 0, a: 200 },
+    bobUpAndDown: false,
+    faceCamera: false,
+    rotate: false,
+    drawOnEnts: false,
+};
+/**
+ * Service for managing and rendering markers in the game world.
+ * Handles automatic rendering via tick.
+ */
+let MarkerService = class MarkerService {
+    constructor() {
+        this.markers = new Map();
+        this.tickHandle = null;
+        this.idCounter = 0;
+    }
+    /**
+     * Create a new managed marker.
+     *
+     * @param position - World position for the marker
+     * @param options - Marker appearance options
+     * @returns The marker ID
+     */
+    create(position, options = {}) {
+        const id = `marker_${++this.idCounter}`;
+        const marker = {
+            id,
+            position,
+            options: Object.assign(Object.assign({}, DEFAULT_OPTIONS), options),
+            visible: true,
+        };
+        this.markers.set(id, marker);
+        this.ensureTickRunning();
+        return id;
+    }
+    /**
+     * Remove a marker by ID.
+     *
+     * @param id - The marker ID to remove
+     */
+    remove(id) {
+        const deleted = this.markers.delete(id);
+        this.checkTickNeeded();
+        return deleted;
+    }
+    /**
+     * Remove all markers.
+     */
+    removeAll() {
+        this.markers.clear();
+        this.stopTick();
+    }
+    /**
+     * Update a marker's position.
+     *
+     * @param id - The marker ID
+     * @param position - New position
+     */
+    setPosition(id, position) {
+        const marker = this.markers.get(id);
+        if (!marker)
+            return false;
+        marker.position = position;
+        return true;
+    }
+    /**
+     * Update marker options.
+     *
+     * @param id - The marker ID
+     * @param options - Options to update
+     */
+    setOptions(id, options) {
+        const marker = this.markers.get(id);
+        if (!marker)
+            return false;
+        marker.options = Object.assign(Object.assign({}, marker.options), options);
+        return true;
+    }
+    /**
+     * Set marker visibility.
+     *
+     * @param id - The marker ID
+     * @param visible - Whether the marker should be visible
+     */
+    setVisible(id, visible) {
+        const marker = this.markers.get(id);
+        if (!marker)
+            return false;
+        marker.visible = visible;
+        return true;
+    }
+    /**
+     * Get a marker by ID.
+     */
+    get(id) {
+        return this.markers.get(id);
+    }
+    /**
+     * Get all managed markers.
+     */
+    getAll() {
+        return Array.from(this.markers.values());
+    }
+    /**
+     * Draw a marker immediately (one frame only).
+     * For persistent markers, use create() instead.
+     */
+    drawOnce(position, options = {}) {
+        const opts = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
+        DrawMarker(opts.type, position.x, position.y, position.z, 0, 0, 0, opts.rotation.x, opts.rotation.y, opts.rotation.z, opts.scale.x, opts.scale.y, opts.scale.z, opts.color.r, opts.color.g, opts.color.b, opts.color.a, opts.bobUpAndDown, opts.faceCamera, 2, opts.rotate, null, null, opts.drawOnEnts);
+    }
+    ensureTickRunning() {
+        if (this.tickHandle !== null)
+            return;
+        this.tickHandle = setTick(() => {
+            for (const marker of this.markers.values()) {
+                if (!marker.visible)
+                    continue;
+                const { position, options } = marker;
+                DrawMarker(options.type, position.x, position.y, position.z, 0, 0, 0, options.rotation.x, options.rotation.y, options.rotation.z, options.scale.x, options.scale.y, options.scale.z, options.color.r, options.color.g, options.color.b, options.color.a, options.bobUpAndDown, options.faceCamera, 2, options.rotate, null, null, options.drawOnEnts);
+            }
+        });
+    }
+    stopTick() {
+        if (this.tickHandle !== null) {
+            clearTick(this.tickHandle);
+            this.tickHandle = null;
+        }
+    }
+    checkTickNeeded() {
+        if (this.markers.size === 0) {
+            this.stopTick();
+        }
+    }
+};
+exports.MarkerService = MarkerService;
+exports.MarkerService = MarkerService = __decorate([
+    (0, tsyringe_1.injectable)()
+], MarkerService);