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

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

@@ -0,0 +1,160 @@
+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';
+const DEFAULT_OPTIONS = {
+    font: 4,
+    scale: 0.35,
+    color: { r: 255, g: 255, b: 255, a: 255 },
+    alignment: 0,
+    dropShadow: true,
+    outline: false,
+    wrapWidth: 0,
+};
+const DEFAULT_3D_OPTIONS = {
+    ...DEFAULT_OPTIONS,
+    scale: 0.25,
+    background: false,
+    backgroundColor: { r: 0, g: 0, b: 0, a: 150 },
+    backgroundPadding: 0.002,
+};
+/**
+ * Service for rendering text UI elements on screen and in 3D world.
+ */
+let TextUIService = class TextUIService {
+    activeTextUI = null;
+    tickHandle = null;
+    /**
+     * Show persistent text UI at the bottom-right of the screen.
+     *
+     * @param text - The text to display
+     * @param options - Text options
+     */
+    show(text, options = {}) {
+        this.activeTextUI = {
+            text,
+            options: { ...DEFAULT_OPTIONS, ...options },
+        };
+        this.ensureTickRunning();
+    }
+    /**
+     * Hide the persistent text UI.
+     */
+    hide() {
+        this.activeTextUI = null;
+        this.stopTick();
+    }
+    /**
+     * Check if text UI is currently visible.
+     */
+    isVisible() {
+        return this.activeTextUI !== null;
+    }
+    /**
+     * Draw text on screen for one frame.
+     * Call this every frame for persistent display.
+     *
+     * @param text - The text to draw
+     * @param x - Screen X position (0.0-1.0)
+     * @param y - Screen Y position (0.0-1.0)
+     * @param options - Text options
+     */
+    drawText(text, x, y, options = {}) {
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        SetTextFont(opts.font);
+        SetTextScale(opts.scale, opts.scale);
+        SetTextColour(opts.color.r, opts.color.g, opts.color.b, opts.color.a);
+        SetTextJustification(opts.alignment);
+        if (opts.dropShadow) {
+            SetTextDropshadow(0, 0, 0, 0, 255);
+            SetTextDropShadow();
+        }
+        if (opts.outline) {
+            SetTextOutline();
+        }
+        if (opts.wrapWidth > 0) {
+            SetTextWrap(x, x + opts.wrapWidth);
+        }
+        if (opts.alignment === 2) {
+            SetTextRightJustify(true);
+            SetTextWrap(0.0, x);
+        }
+        BeginTextCommandDisplayText('STRING');
+        AddTextComponentString(text);
+        EndTextCommandDisplayText(x, y);
+    }
+    /**
+     * Draw 3D text in the game world.
+     *
+     * @param position - World position
+     * @param text - The text to draw
+     * @param options - Text options
+     */
+    drawText3D(position, text, options = {}) {
+        const opts = { ...DEFAULT_3D_OPTIONS, ...options };
+        const [onScreen, screenX, screenY] = World3dToScreen2d(position.x, position.y, position.z);
+        if (!onScreen)
+            return;
+        // Calculate distance-based scale
+        const camCoords = GetGameplayCamCoords();
+        const distance = GetDistanceBetweenCoords(camCoords[0], camCoords[1], camCoords[2], position.x, position.y, position.z, true);
+        const scale = opts.scale * (1 / distance) * 2;
+        const scaledScale = Math.max(scale, 0.15);
+        // Draw background if enabled
+        if (opts.background) {
+            const factor = text.length / 300;
+            DrawRect(screenX, screenY + opts.backgroundPadding, factor + opts.backgroundPadding * 2, 0.03 + opts.backgroundPadding * 2, opts.backgroundColor.r, opts.backgroundColor.g, opts.backgroundColor.b, opts.backgroundColor.a);
+        }
+        // Draw text
+        SetTextScale(scaledScale, scaledScale);
+        SetTextFont(opts.font);
+        SetTextColour(opts.color.r, opts.color.g, opts.color.b, opts.color.a);
+        SetTextCentre(true);
+        if (opts.dropShadow) {
+            SetTextDropshadow(0, 0, 0, 0, 255);
+            SetTextDropShadow();
+        }
+        if (opts.outline) {
+            SetTextOutline();
+        }
+        BeginTextCommandDisplayText('STRING');
+        AddTextComponentString(text);
+        EndTextCommandDisplayText(screenX, screenY);
+    }
+    /**
+     * Get text width for layout calculations.
+     * Note: This is an approximation based on character count and scale.
+     */
+    getTextWidth(text, _font, scale) {
+        // Approximate text width based on character count and scale
+        // Average character width at scale 1.0 is approximately 0.01
+        return text.length * 0.01 * scale;
+    }
+    ensureTickRunning() {
+        if (this.tickHandle !== null)
+            return;
+        this.tickHandle = setTick(() => {
+            if (!this.activeTextUI)
+                return;
+            const { text, options } = this.activeTextUI;
+            // Draw at bottom-right
+            this.drawText(text, 0.985, 0.93, {
+                ...options,
+                alignment: 2,
+            });
+        });
+    }
+    stopTick() {
+        if (this.tickHandle !== null) {
+            clearTick(this.tickHandle);
+            this.tickHandle = null;
+        }
+    }
+};
+TextUIService = __decorate([
+    injectable()
+], TextUIService);
+export { TextUIService };

package/dist/runtime/client/services/vehicle-client.service.d.ts

@@ -0,0 +1,180 @@
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { SerializedVehicleData, VehicleCreateOptions, VehicleSpawnResult } from '../../server/types/vehicle.types';
+/**
+ * Client-side vehicle service.
+ *
+ * This service provides a simplified interface for vehicle operations on the client.
+ * Most operations delegate to the server for security and synchronization.
+ *
+ * @remarks
+ * - Vehicle creation is server-authoritative (prevents spawning exploits)
+ * - Modifications require server validation
+ * - Local operations (queries, visual changes) are safe to perform client-side
+ */
+export declare class VehicleClientService {
+    private pendingCreations;
+    private requestIdCounter;
+    constructor();
+    /**
+     * Requests vehicle creation from the server.
+     *
+     * @param options - Vehicle creation options
+     * @returns Promise resolving to spawn result
+     */
+    createVehicle(options: Omit<VehicleCreateOptions, 'ownership'>): Promise<VehicleSpawnResult>;
+    /**
+     * Requests vehicle deletion from the server.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @returns Promise resolving to success status
+     */
+    deleteVehicle(networkId: number): Promise<boolean>;
+    /**
+     * Requests vehicle repair from the server.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @returns Promise resolving to success status
+     */
+    repairVehicle(networkId: number): Promise<boolean>;
+    /**
+     * Gets the closest vehicle to the player.
+     *
+     * @param radius - Search radius
+     * @returns Vehicle handle or null
+     */
+    getClosestVehicle(radius?: number): number | null;
+    /**
+     * Checks if the player is in a vehicle.
+     */
+    isPlayerInVehicle(): boolean;
+    /**
+     * Gets the vehicle the player is currently in.
+     *
+     * @returns Vehicle handle or null
+     */
+    getCurrentVehicle(): number | null;
+    /**
+     * Gets the last vehicle the player was in.
+     *
+     * @returns Vehicle handle or null
+     */
+    getLastVehicle(): number | null;
+    /**
+     * Checks if player is the driver of their current vehicle.
+     */
+    isPlayerDriver(): boolean;
+    /**
+     * Gets vehicle speed in km/h.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    getSpeed(vehicle: number): number;
+    /**
+     * Gets the network ID from a vehicle handle.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Network ID or 0 if invalid
+     */
+    getNetworkId(vehicle: number): number;
+    /**
+     * Gets the vehicle handle from a network ID.
+     *
+     * @param networkId - Network ID
+     * @returns Vehicle handle or 0 if not found
+     */
+    getVehicleFromNetworkId(networkId: number): number;
+    /**
+     * Gets vehicle data from state bag.
+     *
+     * @param vehicle - Vehicle handle
+     * @param key - State bag key
+     * @returns State value or undefined
+     */
+    getVehicleState<T = any>(vehicle: number, key: string): T | undefined;
+    /**
+     * Requests to lock/unlock vehicle doors.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param locked - Whether to lock or unlock
+     */
+    setDoorsLocked(networkId: number, locked: boolean): void;
+    /**
+     * Requests vehicle data from the server.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @returns Promise resolving to vehicle data
+     */
+    getVehicleData(networkId: number): Promise<SerializedVehicleData | null>;
+    /**
+     * Requests all player vehicles from the server.
+     *
+     * @returns Promise resolving to array of vehicle data
+     */
+    getPlayerVehicles(): Promise<SerializedVehicleData[]>;
+    /**
+     * Local-only: Warps player into a vehicle.
+     *
+     * @param vehicle - Vehicle handle
+     * @param seatIndex - Seat index (-1 = driver)
+     */
+    warpIntoVehicle(vehicle: number, seatIndex?: number): void;
+    /**
+     * Local-only: Sets vehicle heading.
+     *
+     * @param vehicle - Vehicle handle
+     * @param heading - Heading in degrees
+     */
+    setHeading(vehicle: number, heading: number): void;
+    /**
+     * Local-only: Gets vehicle position.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Position vector
+     */
+    getPosition(vehicle: number): Vector3 | null;
+    /**
+     * Local-only: Gets vehicle heading.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Heading in degrees
+     */
+    getHeading(vehicle: number): number;
+    /**
+     * Local-only: Gets vehicle model hash.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Model hash
+     */
+    getModel(vehicle: number): number;
+    /**
+     * Local-only: Gets vehicle license plate.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns License plate text
+     */
+    getPlate(vehicle: number): string;
+    /**
+     * Applies vehicle mods from state bag data.
+     *
+     * @param vehicle - Vehicle handle
+     * @param mods - Mods object from state bag
+     */
+    applyMods(vehicle: number, mods: Record<string, any>): void;
+    /**
+     * Repairs a vehicle completely (client-side).
+     *
+     * @param vehicle - Vehicle handle
+     */
+    repair(vehicle: number): void;
+    /**
+     * Sets fuel level on a vehicle (client-side).
+     *
+     * @param vehicle - Vehicle handle
+     * @param level - Fuel level (0-100)
+     */
+    setFuel(vehicle: number, level: number): void;
+    /**
+     * Registers event handlers for server responses.
+     */
+    private registerEventHandlers;
+}