@directivegames/genesys.js 3.1.24

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

@@ -0,0 +1,407 @@
+import { BaseUIComponent } from './BaseUIComponent.js';
+export class InventoryGrid extends BaseUIComponent {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "items", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "slotElements", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "draggedItem", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "draggedFromIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: -1
+        });
+        Object.defineProperty(this, "dragImageCanvas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    getAssetPaths() {
+        return {
+            templatePath: '@engine/assets/ui/templates/inventory-grid.html',
+            stylesPath: '@engine/assets/ui/styles/inventory-grid.css'
+        };
+    }
+    getDefaultOptions() {
+        return {
+            position: 'center',
+            visible: false,
+            customClasses: [],
+            customStyles: {},
+            columns: 10,
+            rows: 6,
+            slotSize: 50,
+            slotGap: 4,
+            itemRenderer: this.defaultItemRenderer.bind(this),
+            slotClearer: this.defaultSlotClearer.bind(this),
+            filledClass: 'filled',
+            emptyClass: 'empty',
+            dragHoverClass: 'drag-hover',
+            itemContentSelector: '.item-content',
+            enableDragDrop: true,
+            onClose: () => { }
+        };
+    }
+    getInitialData() {
+        const totalSlots = this.options.columns * this.options.rows;
+        const slots = Array.from({ length: totalSlots }, (_, index) => ({
+            index,
+            row: Math.floor(index / this.options.columns),
+            col: index % this.options.columns,
+            isEmpty: true
+        }));
+        // Generate slots HTML
+        const slotsHTML = slots.map(slot => `
+      <div class="inventory-slot empty" data-slot="${slot.index}" data-row="${slot.row}" data-col="${slot.col}" style="width: ${this.options.slotSize}px; height: ${this.options.slotSize}px;">
+        <div class="item-content"></div>
+        <div class="slot-border"></div>
+      </div>
+    `).join('');
+        // Calculate grid dimensions with reasonable constraints
+        const gridWidth = Math.min((this.options.slotSize + this.options.slotGap) * this.options.columns - this.options.slotGap, window.innerWidth - 100 // Leave 100px margin
+        );
+        const gridHeight = Math.min((this.options.slotSize + this.options.slotGap) * this.options.rows - this.options.slotGap + 80, // +80 for header
+        window.innerHeight - 100 // Leave 100px margin
+        );
+        return {
+            slots,
+            columns: this.options.columns,
+            rows: this.options.rows,
+            slotSize: this.options.slotSize,
+            slotGap: this.options.slotGap,
+            gridWidth,
+            gridHeight,
+            slotsHTML
+        };
+    }
+    cacheElements() {
+        const totalSlots = this.options.columns * this.options.rows;
+        for (let i = 0; i < totalSlots; i++) {
+            const slotElement = this.layout?.querySelector(`.inventory-slot[data-slot="${i}"]`);
+            if (slotElement) {
+                const wrappedElement = this.createElementWrapper(slotElement);
+                this.elements.set(`slot-${i}`, wrappedElement);
+                this.slotElements.push(wrappedElement);
+            }
+        }
+        // Initialize items array with nulls
+        this.items = new Array(totalSlots).fill(null);
+    }
+    async onInitialize() {
+        await super.onInitialize();
+        if (this.options.enableDragDrop) {
+            this.setupDragAndDrop();
+        }
+        // Setup close button event handler
+        this.setupCloseButton();
+    }
+    /**
+     * Default item renderer - displays item as text
+     */
+    defaultItemRenderer(item, slotElement) {
+        const contentElement = slotElement.querySelector(this.options.itemContentSelector);
+        if (contentElement) {
+            contentElement.textContent = item.id;
+            contentElement.style.display = 'block';
+            contentElement.title = `Item: ${item.id}`;
+        }
+    }
+    /**
+     * Default slot clearer - hides content
+     */
+    defaultSlotClearer(slotElement) {
+        const contentElement = slotElement.querySelector(this.options.itemContentSelector);
+        if (contentElement) {
+            contentElement.style.display = 'none';
+            contentElement.textContent = '';
+            contentElement.title = '';
+        }
+    }
+    /**
+     * Setup drag and drop functionality
+     */
+    setupDragAndDrop() {
+        this.slotElements.forEach((slotElement, index) => {
+            const element = slotElement.element;
+            // Make slots droppable
+            element.addEventListener('dragover', (e) => this.handleDragOver(e, index));
+            element.addEventListener('dragenter', (e) => this.handleDragEnter(e, index));
+            element.addEventListener('dragleave', (e) => this.handleDragLeave(e, index));
+            element.addEventListener('drop', (e) => this.handleDrop(e, index));
+            // Make item content draggable
+            const contentElement = element.querySelector(this.options.itemContentSelector);
+            if (contentElement) {
+                contentElement.addEventListener('dragstart', (e) => this.handleDragStart(e, index));
+                contentElement.addEventListener('dragend', (e) => this.handleDragEnd(e, index));
+            }
+        });
+    }
+    handleDragStart(e, index) {
+        const item = this.items[index];
+        if (!item)
+            return;
+        this.draggedItem = item;
+        this.draggedFromIndex = index;
+        // Create custom drag image from the item content
+        const contentElement = e.target;
+        this.createDragImage(contentElement);
+        if (e.dataTransfer) {
+            e.dataTransfer.effectAllowed = 'move';
+            e.dataTransfer.setData('text/plain', item.id);
+            // Set custom drag image if available
+            if (this.dragImageCanvas) {
+                e.dataTransfer.setDragImage(this.dragImageCanvas, 25, 25);
+            }
+        }
+        // Add dragging class to original slot
+        this.slotElements[index].addClass('dragging');
+    }
+    handleDragEnd(e, index) {
+        // Clean up drag state
+        this.slotElements.forEach(slot => {
+            slot.removeClass('dragging');
+            slot.removeClass(this.options.dragHoverClass);
+        });
+        this.draggedItem = null;
+        this.draggedFromIndex = -1;
+        if (this.dragImageCanvas) {
+            this.dragImageCanvas = null;
+        }
+    }
+    handleDragOver(e, index) {
+        if (!this.draggedItem)
+            return;
+        e.preventDefault();
+        if (e.dataTransfer) {
+            e.dataTransfer.dropEffect = 'move';
+        }
+    }
+    handleDragEnter(e, index) {
+        if (!this.draggedItem || index === this.draggedFromIndex)
+            return;
+        e.preventDefault();
+        this.slotElements[index].addClass(this.options.dragHoverClass);
+    }
+    handleDragLeave(e, index) {
+        if (!this.draggedItem)
+            return;
+        // Only remove hover class if we're actually leaving the slot
+        const rect = this.slotElements[index].element.getBoundingClientRect();
+        const x = e.clientX;
+        const y = e.clientY;
+        if (x < rect.left || x > rect.right || y < rect.top || y > rect.bottom) {
+            this.slotElements[index].removeClass(this.options.dragHoverClass);
+        }
+    }
+    handleDrop(e, toIndex) {
+        if (!this.draggedItem || this.draggedFromIndex === -1)
+            return;
+        e.preventDefault();
+        this.slotElements[toIndex].removeClass(this.options.dragHoverClass);
+        // Don't allow dropping on the same slot
+        if (toIndex === this.draggedFromIndex)
+            return;
+        // Move the item
+        this.moveItem(this.draggedFromIndex, toIndex);
+    }
+    createDragImage(contentElement) {
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            return;
+        const rect = contentElement.getBoundingClientRect();
+        canvas.width = rect.width;
+        canvas.height = rect.height;
+        // Copy the visual appearance of the item
+        const computedStyle = window.getComputedStyle(contentElement);
+        ctx.fillStyle = computedStyle.backgroundColor || 'transparent';
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+        // Add text if any
+        if (contentElement.textContent) {
+            ctx.fillStyle = computedStyle.color || 'white';
+            ctx.font = computedStyle.font || '12px Arial';
+            ctx.textAlign = 'center';
+            ctx.fillText(contentElement.textContent, canvas.width / 2, canvas.height / 2);
+        }
+        this.dragImageCanvas = canvas;
+    }
+    /**
+     * Move an item from one slot to another
+     */
+    moveItem(fromIndex, toIndex) {
+        if (fromIndex < 0 || fromIndex >= this.items.length ||
+            toIndex < 0 || toIndex >= this.items.length ||
+            fromIndex === toIndex) {
+            return false;
+        }
+        const fromItem = this.items[fromIndex];
+        const toItem = this.items[toIndex];
+        if (!fromItem)
+            return false;
+        // Swap items (or place in empty slot)
+        this.items[fromIndex] = toItem;
+        this.items[toIndex] = fromItem;
+        this.updateDisplay();
+        return true;
+    }
+    /**
+     * Set items in the grid, filling from top-left
+     */
+    setItems(items) {
+        const totalSlots = this.options.columns * this.options.rows;
+        this.items = new Array(totalSlots).fill(null);
+        // Fill slots with items up to capacity
+        for (let i = 0; i < Math.min(items.length, totalSlots); i++) {
+            this.items[i] = items[i];
+        }
+        this.updateDisplay();
+    }
+    /**
+     * Add an item to the first available slot
+     */
+    addItem(item) {
+        const emptyIndex = this.items.findIndex(slot => slot === null);
+        if (emptyIndex === -1) {
+            return false; // Grid is full
+        }
+        this.items[emptyIndex] = item;
+        this.updateDisplay();
+        return true;
+    }
+    /**
+     * Remove an item from a specific slot
+     */
+    removeItem(index) {
+        if (index < 0 || index >= this.items.length || !this.items[index]) {
+            return false;
+        }
+        this.items[index] = null;
+        this.updateDisplay();
+        return true;
+    }
+    /**
+     * Remove an item by ID
+     */
+    removeItemById(id) {
+        const index = this.items.findIndex(item => item?.id === id);
+        if (index >= 0) {
+            return this.removeItem(index);
+        }
+        return false;
+    }
+    /**
+     * Get all items in the grid (excluding null slots)
+     */
+    getItems() {
+        return this.items.filter((item) => item !== null);
+    }
+    /**
+     * Get all items including their positions
+     */
+    getItemsWithPositions() {
+        return this.items.map((item, index) => ({
+            item,
+            index,
+            row: Math.floor(index / this.options.columns),
+            col: index % this.options.columns
+        }));
+    }
+    /**
+     * Check if the grid is full
+     */
+    isFull() {
+        return !this.items.includes(null);
+    }
+    /**
+     * Get number of items in the grid
+     */
+    getItemCount() {
+        return this.items.filter(item => item !== null).length;
+    }
+    /**
+     * Clear all items from the grid
+     */
+    clearItems() {
+        this.items.fill(null);
+        this.updateDisplay();
+    }
+    /**
+     * Find an item by ID
+     */
+    findItem(id) {
+        return this.items.find(item => item?.id === id) ?? undefined;
+    }
+    /**
+     * Check if the grid contains an item with the given ID
+     */
+    hasItem(id) {
+        return this.items.some(item => item?.id === id);
+    }
+    /**
+     * Toggle visibility of the inventory grid
+     */
+    toggle() {
+        if (this.getIsVisible()) {
+            this.hide();
+        }
+        else {
+            this.show();
+        }
+    }
+    updateDisplay() {
+        this.slotElements.forEach((slotElement, index) => {
+            const item = this.items[index];
+            const contentElement = slotElement.element.querySelector(this.options.itemContentSelector);
+            if (item) {
+                // Show item using custom renderer
+                slotElement.removeClass(this.options.emptyClass);
+                slotElement.addClass(this.options.filledClass);
+                this.options.itemRenderer(item, slotElement.element);
+                // Make draggable if drag and drop is enabled
+                if (this.options.enableDragDrop && contentElement) {
+                    contentElement.draggable = true;
+                }
+            }
+            else {
+                // Empty slot using custom clearer
+                slotElement.removeClass(this.options.filledClass);
+                slotElement.addClass(this.options.emptyClass);
+                this.options.slotClearer(slotElement.element);
+                // Remove draggable attribute
+                if (contentElement) {
+                    contentElement.draggable = false;
+                }
+            }
+        });
+    }
+    /**
+     * Setup close button event handler
+     */
+    setupCloseButton() {
+        const closeButton = this.layout?.querySelector('.close-button');
+        if (closeButton) {
+            closeButton.addEventListener('click', () => {
+                this.hide();
+                this.options.onClose();
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"InventoryGrid.js","sourceRoot":"","sources":["../../../../src/ui/components/InventoryGrid.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,39 @@
+import * as THREE from 'three';
+import { BaseUIComponent } from './BaseUIComponent.js';
+import type { BaseUIComponentOptions } from './BaseUIComponent.js';
+export interface MinimapOptions extends BaseUIComponentOptions {
+    size?: number;
+    worldRadius?: number;
+    playerColor?: string;
+    targetColor?: string;
+    backgroundColor?: string;
+    borderColor?: string;
+}
+export interface MinimapTarget {
+    position: THREE.Vector3;
+    color?: string;
+    size?: number;
+}
+export declare class Minimap extends BaseUIComponent<MinimapOptions> {
+    private canvas;
+    private ctx;
+    private playerPosition;
+    private targets;
+    protected getAssetPaths(): {
+        templatePath: string;
+        stylesPath: string;
+    };
+    protected getDefaultOptions(): Required<MinimapOptions>;
+    protected getInitialData(): Record<string, any>;
+    protected onInitialize(): Promise<void>;
+    setPlayerPosition(position: THREE.Vector3): void;
+    setTargets(targets: MinimapTarget[]): void;
+    addTarget(target: MinimapTarget): void;
+    removeTarget(index: number): void;
+    clearTargets(): void;
+    render(): void;
+    private drawCardinalDirections;
+    setSize(size: number): void;
+    setWorldRadius(radius: number): void;
+    protected onDestroy(): void;
+}

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

@@ -0,0 +1,156 @@
+import * as THREE from 'three';
+import { BaseUIComponent } from './BaseUIComponent.js';
+export class Minimap extends BaseUIComponent {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "canvas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "playerPosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new THREE.Vector3()
+        });
+        Object.defineProperty(this, "targets", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    getAssetPaths() {
+        return {
+            templatePath: '@engine/assets/ui/templates/minimap.html',
+            stylesPath: '@engine/assets/ui/styles/minimap.css'
+        };
+    }
+    getDefaultOptions() {
+        return {
+            position: 'top-right',
+            visible: true,
+            customClasses: [],
+            customStyles: {},
+            size: 150,
+            worldRadius: 40,
+            playerColor: '#00ff00',
+            targetColor: '#ff0000',
+            backgroundColor: 'rgba(0, 0, 0, 0.7)',
+            borderColor: 'rgba(255, 255, 255, 0.3)'
+        };
+    }
+    getInitialData() {
+        return {
+            size: this.options.size,
+            position: this.options.position
+        };
+    }
+    async onInitialize() {
+        // Get canvas reference
+        this.canvas = this.layout?.querySelector('.minimap');
+        if (this.canvas) {
+            this.ctx = this.canvas.getContext('2d');
+            this.canvas.width = this.options.size;
+            this.canvas.height = this.options.size;
+        }
+    }
+    // Public API methods
+    setPlayerPosition(position) {
+        this.playerPosition.copy(position);
+    }
+    setTargets(targets) {
+        this.targets = [...targets];
+    }
+    addTarget(target) {
+        this.targets.push(target);
+    }
+    removeTarget(index) {
+        if (index >= 0 && index < this.targets.length) {
+            this.targets.splice(index, 1);
+        }
+    }
+    clearTargets() {
+        this.targets = [];
+    }
+    render() {
+        if (!this.canvas || !this.ctx)
+            return;
+        const ctx = this.ctx;
+        const size = this.options.size;
+        // Clear canvas
+        ctx.fillStyle = this.options.backgroundColor;
+        ctx.fillRect(0, 0, size, size);
+        const center = size / 2;
+        // Draw cardinal direction labels
+        this.drawCardinalDirections(ctx, size);
+        // Draw player as dot in center
+        ctx.fillStyle = this.options.playerColor;
+        ctx.beginPath();
+        ctx.arc(center, center, 4, 0, 2 * Math.PI);
+        ctx.fill();
+        // Draw targets
+        this.targets.forEach(target => {
+            // Calculate relative position to player
+            const relativeX = target.position.x - this.playerPosition.x;
+            const relativeZ = target.position.z - this.playerPosition.z;
+            // Convert to minimap coordinates (Note: Z maps to Y axis, with negative Z pointing North/up)
+            const mapX = center + (relativeX / this.options.worldRadius) * (size / 2);
+            const mapZ = center + (-relativeZ / this.options.worldRadius) * (size / 2); // Negative Z for North-up orientation
+            // Only draw if within minimap bounds
+            if (mapX >= 0 && mapX <= size && mapZ >= 0 && mapZ <= size) {
+                ctx.fillStyle = target.color ?? this.options.targetColor;
+                ctx.beginPath();
+                ctx.arc(mapX, mapZ, target.size ?? 3, 0, 2 * Math.PI);
+                ctx.fill();
+            }
+        });
+        // Draw border
+        ctx.strokeStyle = this.options.borderColor;
+        ctx.lineWidth = 2;
+        ctx.strokeRect(0, 0, size, size);
+    }
+    drawCardinalDirections(ctx, size) {
+        ctx.fillStyle = 'rgba(255, 255, 255, 0.8)';
+        ctx.font = 'bold 14px Arial, sans-serif';
+        ctx.textAlign = 'center';
+        ctx.textBaseline = 'middle';
+        const padding = 12;
+        const center = size / 2;
+        // North (top)
+        ctx.fillText('N', center, padding);
+        // South (bottom)
+        ctx.fillText('S', center, size - padding);
+        // East (right)
+        ctx.fillText('E', size - padding, center);
+        // West (left)
+        ctx.fillText('W', padding, center);
+    }
+    setSize(size) {
+        this.options.size = size;
+        if (this.canvas) {
+            this.canvas.width = size;
+            this.canvas.height = size;
+            this.canvas.style.width = `${size}px`;
+            this.canvas.style.height = `${size}px`;
+        }
+    }
+    setWorldRadius(radius) {
+        this.options.worldRadius = radius;
+    }
+    onDestroy() {
+        // Clean up canvas references
+        this.canvas = null;
+        this.ctx = null;
+        this.targets = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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