@directivegames/genesys.js 3.1.24

package/dist/src/ui/components/BaseUIComponent.js

@@ -0,0 +1,342 @@
+import * as ENGINE from '../../index.js';
+import { AssetPath } from '../../storage/storageProvider.js';
+import { shortUUID } from '../../utils/Utils.js';
+/**
+ * Abstract base class for all UI components
+ * Provides common functionality and enforces consistent interface
+ */
+export class BaseUIComponent {
+    constructor(ui, options) {
+        Object.defineProperty(this, "ui", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "layout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "elements", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "isInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "isVisible", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.ui = ui;
+        this.options = this.mergeWithDefaults(options);
+    }
+    /**
+     * Initialize the component - loads assets and creates layout
+     * Must be called before using the component
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            console.warn(`Component ${this.constructor.name} is already initialized`);
+            return;
+        }
+        try {
+            // Load component assets
+            const { template, styles } = await this.loadAssets();
+            // Create layout with initial data
+            this.layout = this.ui.createLayout(this.getComponentId(), {
+                template,
+                styles,
+                data: this.getInitialData()
+            });
+            // Apply positioning and styling
+            this.applyPositioning();
+            this.applyCustomStyling();
+            // Cache element references
+            this.cacheElements();
+            // Perform component-specific initialization
+            await this.onInitialize();
+            // Set initial visibility
+            if (!this.options.visible) {
+                this.hide();
+            }
+            this.isInitialized = true;
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize ${this.constructor.name}: ${error}`);
+        }
+    }
+    /**
+     * Show the component
+     */
+    show() {
+        if (!this.isInitialized) {
+            console.warn(`Cannot show ${this.constructor.name} - not initialized`);
+            return;
+        }
+        this.layout?.getElement().show();
+        this.isVisible = true;
+        this.onShow();
+    }
+    /**
+     * Hide the component
+     */
+    hide() {
+        if (!this.isInitialized) {
+            console.warn(`Cannot hide ${this.constructor.name} - not initialized`);
+            return;
+        }
+        this.layout?.getElement().hide();
+        this.isVisible = false;
+        this.onHide();
+    }
+    /**
+     * Toggle component visibility
+     */
+    toggle() {
+        if (this.isVisible) {
+            this.hide();
+        }
+        else {
+            this.show();
+        }
+    }
+    /**
+     * Check if component is visible
+     */
+    getIsVisible() {
+        return this.isVisible;
+    }
+    /**
+     * Check if component is initialized
+     */
+    getIsInitialized() {
+        return this.isInitialized;
+    }
+    /**
+     * Get the root layout element
+     */
+    getElement() {
+        return this.layout?.getElement() ?? null;
+    }
+    /**
+     * Get a cached element by key
+     */
+    getElementByKey(key) {
+        return this.elements.get(key);
+    }
+    /**
+     * Update component data and re-render
+     * Note: This triggers onDataUpdate for component-specific handling
+     */
+    updateData(data) {
+        if (!this.isInitialized || !this.layout) {
+            console.warn(`Cannot update data for ${this.constructor.name} - not initialized`);
+            return;
+        }
+        // Note: UILayout doesn't have updateData method, so we handle updates in onDataUpdate
+        this.onDataUpdate(data);
+    }
+    /**
+     * Set the position of the component using CSS properties
+     * @param styles - CSS positioning properties (e.g. { top: '20px', left: '20px' })
+     * @param selector - Optional CSS selector to target a specific child element
+     */
+    setPosition(styles, selector) {
+        if (!this.isInitialized || !this.layout) {
+            console.warn(`Cannot set position for ${this.constructor.name} - not initialized`);
+            return;
+        }
+        let targetElement = null;
+        if (selector) {
+            // Target a specific child element
+            targetElement = this.layout.querySelector(selector);
+            if (!targetElement) {
+                console.warn(`Cannot find element with selector "${selector}" in ${this.constructor.name}`);
+                return;
+            }
+        }
+        else {
+            // Target the root element of the layout
+            const rootElement = this.layout.getElement();
+            targetElement = rootElement?.element;
+        }
+        if (targetElement) {
+            // Apply positioning styles
+            Object.entries(styles).forEach(([property, value]) => {
+                targetElement.style.setProperty(property, value);
+            });
+        }
+    }
+    /**
+     * Destroy the component and clean up resources
+     */
+    destroy() {
+        if (!this.isInitialized) {
+            return;
+        }
+        this.onDestroy();
+        this.layout?.remove();
+        this.layout = null;
+        this.elements.clear();
+        this.isInitialized = false;
+        this.isVisible = false;
+    }
+    // Virtual methods that subclasses can override
+    /**
+     * Get the unique ID for this component instance
+     * Default implementation uses kebab-case class name + UUID
+     * Override if you need custom ID generation logic
+     */
+    getComponentId() {
+        // Convert class name from PascalCase to kebab-case
+        const className = this.constructor.name;
+        const kebabCase = className
+            .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+            .toLowerCase();
+        return `${kebabCase}-${shortUUID()}`;
+    }
+    /**
+     * Cache frequently accessed elements after layout creation
+     */
+    cacheElements() {
+        // Override in subclasses to cache specific elements
+    }
+    /**
+     * Called after successful initialization
+     */
+    async onInitialize() {
+        // Override in subclasses for custom initialization
+    }
+    /**
+     * Called when component is shown
+     */
+    onShow() {
+        // Override in subclasses for show logic
+    }
+    /**
+     * Called when component is hidden
+     */
+    onHide() {
+        // Override in subclasses for hide logic
+    }
+    /**
+     * Called when data is updated
+     */
+    onDataUpdate(data) {
+        // Override in subclasses for data update logic
+    }
+    /**
+     * Called before component destruction
+     */
+    onDestroy() {
+        // Override in subclasses for cleanup logic
+    }
+    // Private helper methods
+    async loadAssets() {
+        const { templatePath, stylesPath } = this.getAssetPaths();
+        return await ENGINE.UIAssetLoader.loadUIAsset(AssetPath.fromString(templatePath), AssetPath.fromString(stylesPath));
+    }
+    mergeWithDefaults(options) {
+        const defaults = this.getDefaultOptions();
+        return { ...defaults, ...options };
+    }
+    applyPositioning() {
+        if (!this.layout || !this.options.position)
+            return;
+        const layoutElement = this.layout.getElement();
+        // Find the actual template root (skip Vite injected scripts and other non-template elements)
+        let templateRoot = null;
+        for (let i = 0; i < layoutElement.element.children.length; i++) {
+            const child = layoutElement.element.children[i];
+            // Skip script tags (Vite development scripts)
+            if (child.tagName.toLowerCase() === 'script') {
+                continue;
+            }
+            // Skip elements with Vite-specific attributes
+            if (child.hasAttribute('src') && child.getAttribute('src')?.includes('vite')) {
+                continue;
+            }
+            // This should be our template root
+            templateRoot = child;
+            break;
+        }
+        if (templateRoot) {
+            templateRoot.classList.add(this.options.position);
+        }
+    }
+    applyCustomStyling() {
+        if (!this.layout)
+            return;
+        const element = this.layout.getElement();
+        // Apply custom classes
+        if (this.options.customClasses) {
+            this.options.customClasses.forEach(className => {
+                element.addClass(className);
+            });
+        }
+        // Apply custom styles using direct style property access
+        if (this.options.customStyles) {
+            Object.entries(this.options.customStyles).forEach(([property, value]) => {
+                // Get the underlying HTML element and set style directly
+                const htmlElement = element.element;
+                if (htmlElement && htmlElement.style) {
+                    htmlElement.style.setProperty(property, value);
+                }
+            });
+        }
+    }
+    /**
+     * Utility method to create element wrappers for HTML elements
+     */
+    createElementWrapper(htmlElement) {
+        if (!htmlElement) {
+            throw new Error(`HTML element not found in ${this.constructor.name} layout`);
+        }
+        // Create a wrapper that delegates to the HTML element
+        const wrapper = {
+            element: htmlElement,
+            setText: (text) => {
+                htmlElement.textContent = text;
+                return wrapper;
+            },
+            addClass: (className) => {
+                htmlElement.classList.add(className);
+                return wrapper;
+            },
+            removeClass: (className) => {
+                htmlElement.classList.remove(className);
+                return wrapper;
+            },
+            show: () => {
+                htmlElement.style.display = 'block';
+                return wrapper;
+            },
+            hide: () => {
+                htmlElement.style.display = 'none';
+                return wrapper;
+            },
+            setStyle: (property, value) => {
+                htmlElement.style.setProperty(property, value);
+                return wrapper;
+            }
+        };
+        return wrapper;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BaseUIComponent.js","sourceRoot":"","sources":["../../../../src/ui/components/BaseUIComponent.ts"],"names":[],"mappings":"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"}

package/dist/src/ui/components/Compass.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from 'three';
+import { BaseUIComponent } from './BaseUIComponent.js';
+import type { BaseUIComponentOptions } from './BaseUIComponent.js';
+export interface CompassOptions extends BaseUIComponentOptions {
+    width?: number;
+    height?: number;
+    pixelsPerDegree?: number;
+}
+export interface CompassDirection {
+    name: string;
+    angle: number;
+    cardinal: boolean;
+}
+export declare class Compass extends BaseUIComponent<CompassOptions> {
+    private compassMarkers;
+    private directions;
+    protected getAssetPaths(): {
+        templatePath: string;
+        stylesPath: string;
+    };
+    protected getDefaultOptions(): Required<CompassOptions>;
+    protected getInitialData(): Record<string, any>;
+    protected onInitialize(): Promise<void>;
+    updateRotation(camera: THREE.Camera): void;
+    private initializeMarkers;
+    private updateCenterLineHeight;
+    protected onDestroy(): void;
+}

package/dist/src/ui/components/Compass.js

@@ -0,0 +1,125 @@
+import * as THREE from 'three';
+import { BaseUIComponent } from './BaseUIComponent.js';
+export class Compass extends BaseUIComponent {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "compassMarkers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "directions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                { name: 'N', angle: 0, cardinal: true },
+                { name: 'NE', angle: 45, cardinal: false },
+                { name: 'E', angle: 90, cardinal: true },
+                { name: 'SE', angle: 135, cardinal: false },
+                { name: 'S', angle: 180, cardinal: true },
+                { name: 'SW', angle: 225, cardinal: false },
+                { name: 'W', angle: 270, cardinal: true },
+                { name: 'NW', angle: 315, cardinal: false }
+            ]
+        });
+    }
+    getAssetPaths() {
+        return {
+            templatePath: '@engine/assets/ui/templates/compass.html',
+            stylesPath: '@engine/assets/ui/styles/compass.css'
+        };
+    }
+    getDefaultOptions() {
+        return {
+            position: 'bottom-center',
+            visible: true,
+            customClasses: [],
+            customStyles: {},
+            width: 300,
+            height: 20,
+            pixelsPerDegree: 2.5
+        };
+    }
+    getInitialData() {
+        return {
+            position: this.options.position,
+            width: this.options.width,
+            height: this.options.height
+        };
+    }
+    async onInitialize() {
+        // Initialize compass markers
+        this.initializeMarkers();
+        // Update center line height based on compass height
+        this.updateCenterLineHeight();
+    }
+    // Public API methods
+    updateRotation(camera) {
+        if (!camera || this.compassMarkers.length === 0)
+            return;
+        // Get the camera's world direction
+        const direction = new THREE.Vector3();
+        camera.getWorldDirection(direction);
+        // Calculate angle in radians (0 = North, positive = clockwise)
+        const angle = Math.atan2(direction.x, direction.z);
+        // Convert to degrees and normalize to 0-360
+        let playerAngle = (angle * 180 / Math.PI + 360) % 360;
+        // Update each marker position
+        const compassCenter = this.options.width / 2;
+        this.compassMarkers.forEach(marker => {
+            const markerAngle = parseFloat(marker.getAttribute('data-angle') ?? '0');
+            // Calculate the relative angle difference
+            let angleDiff = markerAngle - playerAngle;
+            // Normalize angle difference to -180 to 180
+            while (angleDiff > 180)
+                angleDiff -= 360;
+            while (angleDiff < -180)
+                angleDiff += 360;
+            // Convert angle to pixel position
+            const xPosition = compassCenter + (angleDiff * this.options.pixelsPerDegree);
+            // Only show markers that are within the visible area (with some padding)
+            if (xPosition >= -50 && xPosition <= this.options.width + 50) {
+                marker.style.left = `${xPosition}px`;
+                marker.style.display = 'block';
+                // Fade out markers near the edges for a smooth effect
+                const distanceFromCenter = Math.abs(xPosition - compassCenter);
+                const maxDistance = this.options.width / 2;
+                const opacity = Math.max(0.3, 1 - (distanceFromCenter / maxDistance));
+                marker.style.opacity = opacity.toString();
+            }
+            else {
+                marker.style.display = 'none';
+            }
+        });
+    }
+    // Private methods
+    initializeMarkers() {
+        const compassContainer = this.layout?.querySelector('.compass-markers');
+        if (!compassContainer)
+            return;
+        // Create marker elements
+        this.directions.forEach(dir => {
+            const marker = document.createElement('div');
+            marker.className = `compass-marker${dir.cardinal ? ' cardinal' : ''}`;
+            marker.textContent = dir.name;
+            marker.setAttribute('data-angle', dir.angle.toString());
+            compassContainer.appendChild(marker);
+            this.compassMarkers.push(marker);
+        });
+    }
+    updateCenterLineHeight() {
+        const centerLine = this.layout?.querySelector('.compass-center-line');
+        if (centerLine && this.options.height) {
+            // Scale center line height to be about 20% of compass height, but at least 20px
+            const lineHeight = Math.max(20, this.options.height * 0.2);
+            centerLine.style.height = `${lineHeight}px`;
+        }
+    }
+    onDestroy() {
+        // Clean up marker references
+        this.compassMarkers = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/ui/components/ControlsPanel.d.ts

@@ -0,0 +1,37 @@
+import { BaseUIComponent } from './BaseUIComponent.js';
+import type { BaseUIComponentOptions } from './BaseUIComponent.js';
+export interface ControlsPanelOptions extends BaseUIComponentOptions {
+    /** Controls to display */
+    controls?: {
+        key: string;
+        description: string;
+    }[];
+    /** Panel title */
+    title?: string;
+}
+export declare class ControlsPanel extends BaseUIComponent<ControlsPanelOptions> {
+    protected getAssetPaths(): {
+        templatePath: string;
+        stylesPath: string;
+    };
+    protected getDefaultOptions(): Required<ControlsPanelOptions>;
+    protected getInitialData(): {
+        title: string;
+        controls: {
+            key: string;
+            description: string;
+        }[];
+    };
+    /**
+     * Set custom position for the controls panel
+     * @param styles - CSS positioning properties
+     */
+    setCustomPosition(styles: Record<string, string>): void;
+    /**
+     * Update the controls list
+     */
+    updateControls(controls: {
+        key: string;
+        description: string;
+    }[]): void;
+}

package/dist/src/ui/components/ControlsPanel.js

@@ -0,0 +1,47 @@
+import { BaseUIComponent } from './BaseUIComponent.js';
+export class ControlsPanel extends BaseUIComponent {
+    getAssetPaths() {
+        return {
+            templatePath: '@engine/assets/ui/templates/controls-help.html',
+            stylesPath: '@engine/assets/ui/styles/controls-help.css'
+        };
+    }
+    getDefaultOptions() {
+        return {
+            position: 'bottom-left',
+            visible: true,
+            customClasses: [],
+            customStyles: {},
+            controls: [
+                { key: 'WASD', description: 'Move' },
+                { key: 'Mouse', description: 'Look' },
+                { key: 'Left Click', description: 'Shoot' },
+                { key: 'R', description: 'Reload' },
+                { key: 'I', description: 'Inventory' },
+                { key: 'P', description: 'Menu' }
+            ],
+            title: 'Controls:'
+        };
+    }
+    getInitialData() {
+        return {
+            title: this.options.title,
+            controls: this.options.controls
+        };
+    }
+    /**
+     * Set custom position for the controls panel
+     * @param styles - CSS positioning properties
+     */
+    setCustomPosition(styles) {
+        this.setPosition(styles, '.controls-container');
+    }
+    /**
+     * Update the controls list
+     */
+    updateControls(controls) {
+        this.options.controls = controls;
+        // Re-render would go here if we had dynamic content updates
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29udHJvbHNQYW5lbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91aS9jb21wb25lbnRzL0NvbnRyb2xzUGFuZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBWXZELE1BQU0sT0FBTyxhQUFjLFNBQVEsZUFBcUM7SUFFbkQsYUFBYTtRQUM5QixPQUFPO1lBQ0wsWUFBWSxFQUFFLGdEQUFnRDtZQUM5RCxVQUFVLEVBQUUsNENBQTRDO1NBQ3pELENBQUM7SUFDSixDQUFDO0lBRWtCLGlCQUFpQjtRQUNsQyxPQUFPO1lBQ0wsUUFBUSxFQUFFLGFBQWE7WUFDdkIsT0FBTyxFQUFFLElBQUk7WUFDYixhQUFhLEVBQUUsRUFBRTtZQUNqQixZQUFZLEVBQUUsRUFBRTtZQUNoQixRQUFRLEVBQUU7Z0JBQ1IsRUFBRSxHQUFHLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUU7Z0JBQ3BDLEVBQUUsR0FBRyxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxFQUFFO2dCQUNyQyxFQUFFLEdBQUcsRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUFFLE9BQU8sRUFBRTtnQkFDM0MsRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLFdBQVcsRUFBRSxRQUFRLEVBQUU7Z0JBQ25DLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxXQUFXLEVBQUUsV0FBVyxFQUFFO2dCQUN0QyxFQUFFLEdBQUcsRUFBRSxHQUFHLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRTthQUNsQztZQUNELEtBQUssRUFBRSxXQUFXO1NBQ25CLENBQUM7SUFDSixDQUFDO0lBRWtCLGNBQWM7UUFDL0IsT0FBTztZQUNMLEtBQUssRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUs7WUFDekIsUUFBUSxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUTtTQUNoQyxDQUFDO0lBQ0osQ0FBQztJQUVEOzs7T0FHRztJQUNJLGlCQUFpQixDQUFDLE1BQThCO1FBQ3JELElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxFQUFFLHFCQUFxQixDQUFDLENBQUM7SUFDbEQsQ0FBQztJQUVEOztPQUVHO0lBQ0ksY0FBYyxDQUFDLFFBQWdEO1FBQ3BFLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztRQUNqQyw0REFBNEQ7SUFDOUQsQ0FBQztDQUNGIn0=

package/dist/src/ui/components/Crosshair.d.ts

@@ -0,0 +1,20 @@
+import { BaseUIComponent } from './BaseUIComponent.js';
+import type { BaseUIComponentOptions } from './BaseUIComponent.js';
+export interface CrosshairOptions extends BaseUIComponentOptions {
+    size?: number;
+    color?: string;
+    style?: 'dot' | 'cross' | 'circle';
+}
+export declare class Crosshair extends BaseUIComponent<CrosshairOptions> {
+    private crosshairElement;
+    protected getAssetPaths(): {
+        templatePath: string;
+        stylesPath: string;
+    };
+    protected getDefaultOptions(): Required<CrosshairOptions>;
+    protected getInitialData(): Record<string, any>;
+    protected cacheElements(): void;
+    setColor(color: string): void;
+    setSize(size: number): void;
+    protected onDestroy(): void;
+}