@directivegames/genesys.js 3.1.24

package/dist/games/ui-demo.js

@@ -0,0 +1,1054 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+var GemType;
+(function (GemType) {
+    GemType["Ruby"] = "ruby";
+    GemType["Emerald"] = "emerald";
+    GemType["Sapphire"] = "sapphire";
+    GemType["Diamond"] = "diamond";
+    GemType["Amethyst"] = "amethyst";
+})(GemType || (GemType = {}));
+export class UIDemo extends ENGINE.BaseGameLoop {
+    constructor() {
+        super(...arguments);
+        // New HUD Components
+        Object.defineProperty(this, "ammoCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pointsCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "crosshair", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reloadIndicator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "minimap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "compass", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inventoryBar", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inventoryGrid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Progress bars for demonstration
+        Object.defineProperty(this, "healthBar", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "manaBar", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "experienceBar", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Menu and other UI
+        Object.defineProperty(this, "menuLayout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "controlsLayout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "controlsPanel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isMenuVisible", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "isInventoryGridVisible", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        // Game objects
+        Object.defineProperty(this, "pawn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "controller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "weaponComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "cubeTargets", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "collectables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        // Game state
+        Object.defineProperty(this, "currentAmmo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 3
+        }); // Start with low ammo for testing
+        Object.defineProperty(this, "maxAmmo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 30
+        });
+        Object.defineProperty(this, "isReloading", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "points", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "inventory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "maxInventorySlots", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 9
+        });
+        // Progress bar demo values
+        Object.defineProperty(this, "currentHealth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 85
+        });
+        Object.defineProperty(this, "maxHealth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 100
+        });
+        Object.defineProperty(this, "currentMana", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 60
+        });
+        Object.defineProperty(this, "maxMana", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 120
+        });
+        Object.defineProperty(this, "currentExperience", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 75
+        });
+        Object.defineProperty(this, "maxExperience", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 100
+        });
+        // Gem configuration
+        Object.defineProperty(this, "gemConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map([
+                [GemType.Ruby, { color: 0xff0000, name: 'Ruby' }],
+                [GemType.Emerald, { color: 0x00ff00, name: 'Emerald' }],
+                [GemType.Sapphire, { color: 0x0066ff, name: 'Sapphire' }],
+                [GemType.Diamond, { color: 0xffffff, name: 'Diamond' }],
+                [GemType.Amethyst, { color: 0x9966ff, name: 'Amethyst' }]
+            ])
+        });
+    }
+    async preStart() {
+        // Don't call super.preStart() to avoid creating default player controller
+        // Prevent scroll bars from appearing during rapid camera movement
+        this.container.style.overflow = 'hidden';
+        // Add lighting
+        ENGINE.GameBuilder.createDefaultLighting(this.world);
+        // Add ground
+        ENGINE.GameBuilder.createDefaultGround(this.world);
+        // Create player
+        this.createPlayer();
+        // Create cube targets
+        this.createCubeTargets();
+        // Create collectables
+        this.createCollectables();
+        // Setup UI
+        await this.setupUI();
+        this.setupGameLogic();
+    }
+    destroy() {
+        this.cleanupUI();
+        super.destroy();
+    }
+    cleanupUI() {
+        // Clean up new HUD components
+        this.ammoCounter?.destroy();
+        this.pointsCounter?.destroy();
+        this.crosshair?.destroy();
+        this.reloadIndicator?.destroy();
+        this.minimap?.destroy();
+        this.compass?.destroy();
+        this.inventoryBar?.destroy();
+        this.inventoryGrid?.destroy();
+        // Clean up progress bars
+        this.healthBar?.destroy();
+        this.manaBar?.destroy();
+        this.experienceBar?.destroy();
+        // Clean up controls panel
+        this.controlsPanel?.destroy();
+        // Remove menu layout
+        if (this.menuLayout) {
+            this.menuLayout.remove();
+        }
+        // Remove controls layout
+        if (this.controlsLayout) {
+            this.controlsLayout.remove();
+        }
+        // Clean up health bars
+        this.cubeTargets.forEach(cube => {
+            if (cube.healthBarContainer) {
+                cube.healthBarContainer.remove();
+            }
+        });
+        // Clean up collectables
+        this.collectables.forEach(collectable => {
+            this.world.removeActors(collectable.actor);
+        });
+        // Clear arrays
+        this.cubeTargets = [];
+        this.collectables = [];
+        this.inventory = [];
+    }
+    createPlayer() {
+        this.pawn = new ENGINE.Pawn({
+            movementComponent: new ENGINE.CharacterMovementComponent({
+                ...ENGINE.CharacterMovementComponent.DEFAULT_OPTIONS,
+                movementType: ENGINE.CharacterMovementType.FirstPerson,
+            }),
+            position: new THREE.Vector3(0, 10, 0),
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.CapsuleGeometry(1, 4),
+                material: new THREE.MeshStandardMaterial({
+                    color: 0x00ff00,
+                    visible: false,
+                    transparent: true,
+                    opacity: 0
+                }),
+                physicsOptions: {
+                    enabled: true,
+                    motionType: ENGINE.PhysicsMotionType.KinematicVelocityBased,
+                }
+            }),
+            camera: new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, 0.1, 1000)
+        });
+        // Add weapon component
+        this.weaponComponent = new ENGINE.ProjectileWeaponComponent({
+            position: new THREE.Vector3(0, 0, -2),
+            fireInterval: 0.1,
+            isSingleFire: true,
+            projectileOptions: {
+                velocity: 100,
+                range: 200,
+                damageDealt: 25,
+                useOverlapCheck: false, // Use collision detection instead of overlap
+                destroyOnHit: true,
+                geometry: new THREE.SphereGeometry(0.2),
+                material: new THREE.MeshStandardMaterial({ color: 0xffff00 })
+            }
+        });
+        this.pawn.rootComponent.add(this.weaponComponent);
+        this.controller = new ENGINE.PlayerController();
+        this.controller.possess(this.pawn);
+        this.world.addActors(this.pawn, this.controller);
+        // Position camera for first person
+        const camera = this.pawn.getComponent(THREE.Camera);
+        camera.position.set(0, 1, 0);
+    }
+    createCubeTargets() {
+        const numCubes = 8;
+        const spawnRadius = 20;
+        for (let i = 0; i < numCubes; i++) {
+            // Random position around the player
+            const angle = (i / numCubes) * Math.PI * 2 + (Math.random() - 0.5) * 0.5;
+            const distance = spawnRadius + Math.random() * 10;
+            const x = Math.cos(angle) * distance;
+            const z = Math.sin(angle) * distance;
+            const y = Math.random() * 5 + 1;
+            const cubeActor = new ENGINE.Actor({
+                rootComponent: new ENGINE.MeshComponent({
+                    position: new THREE.Vector3(x, y, z),
+                    geometry: new THREE.BoxGeometry(2, 2, 2),
+                    material: new THREE.MeshStandardMaterial({
+                        color: new THREE.Color().setHSL(Math.random(), 0.7, 0.5)
+                    }),
+                    physicsOptions: {
+                        enabled: true,
+                        motionType: ENGINE.PhysicsMotionType.Static,
+                    }
+                })
+            });
+            // Add CharacterStatsComponent so the cube can receive damage from projectiles
+            const statsComponent = new ENGINE.CharacterStatsComponent({
+                maxHealth: 100,
+                healthRegen: 0, // No health regeneration
+                attackCooldown: 0,
+                attackRange: 0,
+                attackDamage: 0,
+                speed: 0
+            });
+            cubeActor.rootComponent.add(statsComponent);
+            this.world.addActors(cubeActor);
+            // Create HP bar for this cube
+            const { healthBarContainer, healthBarElement } = this.createHealthBarForCube(cubeActor);
+            const cubeTarget = {
+                actor: cubeActor,
+                health: 100,
+                maxHealth: 100,
+                healthBarElement,
+                healthBarContainer
+            };
+            // Listen for health changes and update the health bar
+            statsComponent.onHealthChanged.add((currentHealth, maxHealth) => {
+                cubeTarget.health = currentHealth;
+                cubeTarget.maxHealth = maxHealth;
+                this.updateCubeHealthBar(cubeTarget);
+            });
+            // Listen for death and destroy the cube
+            statsComponent.onDeath.add(() => {
+                this.addPoints(50); // Add 50 points for destroying a cube
+                // Demo: Gain significant experience for destroying cubes
+                this.currentExperience = Math.min(this.maxExperience, this.currentExperience + 15);
+                this.experienceBar.setValue(this.currentExperience);
+                this.destroyCube(cubeTarget);
+            });
+            this.cubeTargets.push(cubeTarget);
+        }
+    }
+    createHealthBarForCube(cubeActor) {
+        const ui = this.world.uiManager;
+        // Create a single health bar element with CSS-based fill using background gradient
+        const healthBarContainer = ui.createElement(`health-container-${cubeActor.uuid}`, {
+            style: {
+                position: 'absolute',
+                width: '60px',
+                height: '8px',
+                backgroundColor: 'rgba(0, 0, 0, 0.7)',
+                borderRadius: '4px',
+                border: '1px solid rgba(255, 255, 255, 0.3)',
+                pointerEvents: 'none',
+                display: 'none',
+                left: '-1000px',
+                top: '-1000px',
+                zIndex: '1500',
+                boxSizing: 'border-box',
+                // Use background gradient to create the fill effect
+                backgroundImage: 'linear-gradient(to right, #4CAF50 100%, transparent 100%)',
+                backgroundClip: 'padding-box',
+                transition: 'background-image 0.3s ease'
+            }
+        });
+        // Return the same element for both container and fill for compatibility
+        return { healthBarContainer, healthBarElement: healthBarContainer };
+    }
+    async setupUI() {
+        const ui = this.world.uiManager;
+        // Initialize new HUD components
+        await this.setupHUDComponents(ui);
+        await this.createMenu(ui);
+        await this.createControls(ui);
+    }
+    async setupHUDComponents(ui) {
+        // Initialize all HUD components
+        this.ammoCounter = new ENGINE.AmmoCounter(ui, {
+            lowAmmoThreshold: 5,
+            showLowAmmoWarning: true
+        });
+        await this.ammoCounter.initialize();
+        this.ammoCounter.setPosition({
+            position: 'absolute',
+            bottom: '30px',
+            right: '30px'
+        }, '.ammo-counter-container');
+        this.ammoCounter.setAmmo(this.currentAmmo, this.maxAmmo);
+        this.pointsCounter = new ENGINE.NumberDisplay(ui, {
+            prefix: 'Points: ',
+            initialValue: this.points,
+            animate: true,
+            animationDuration: 200
+        });
+        await this.pointsCounter.initialize();
+        this.pointsCounter.setPosition({
+            position: 'absolute',
+            top: '180px', // Position below minimap
+            right: '30px'
+        }, '.number-display-container');
+        this.crosshair = new ENGINE.Crosshair(ui, {
+            size: 4,
+            color: 'white',
+            style: 'dot'
+        });
+        await this.crosshair.initialize();
+        this.reloadIndicator = new ENGINE.ReloadIndicator(ui, {
+            reloadDuration: 2000,
+            text: 'RELOADING',
+            color: '#4CAF50'
+        });
+        await this.reloadIndicator.initialize();
+        this.minimap = new ENGINE.Minimap(ui, {
+            size: 150,
+            worldRadius: 40,
+            playerColor: '#00ff00',
+            targetColor: '#ff0000'
+        });
+        await this.minimap.initialize();
+        this.minimap.setPosition({
+            position: 'absolute',
+            top: '30px',
+            right: '30px'
+        }, '.minimap-container');
+        this.compass = new ENGINE.Compass(ui, {
+            width: 300,
+            pixelsPerDegree: 2.5
+        });
+        await this.compass.initialize();
+        this.compass.setPosition({
+            position: 'absolute',
+            top: '20px',
+            left: '50%',
+            transform: 'translateX(-50%)'
+        }, '.compass-container');
+        this.inventoryBar = new ENGINE.InventoryBar(ui, {
+            slotCount: 9,
+            itemRenderer: this.renderGemItem.bind(this),
+            slotClearer: this.clearGemSlot.bind(this)
+        });
+        await this.inventoryBar.initialize();
+        this.inventoryBar.setPosition({
+            position: 'absolute',
+            bottom: '20px',
+            left: '50%',
+            transform: 'translateX(-50%)'
+        }, '.inventory-bar');
+        this.inventoryGrid = new ENGINE.InventoryGrid(ui, {
+            columns: 9,
+            rows: 6,
+            itemRenderer: this.renderGemItem.bind(this),
+            slotClearer: this.clearGemSlot.bind(this),
+            onClose: () => {
+                // Handle close button click - restore pointer lock and update state
+                this.isInventoryGridVisible = false;
+                this.world.inputManager.requestPointerLock({});
+            }
+        });
+        await this.inventoryGrid.initialize();
+        this.inventoryGrid.setPosition({
+            position: 'fixed',
+            top: '50%',
+            left: '50%',
+            transform: 'translate(-50%, -50%)'
+        }, '.inventory-grid');
+        // Initialize progress bars for demonstration
+        this.healthBar = new ENGINE.ProgressBar(ui, {
+            currentValue: this.currentHealth,
+            maxValue: this.maxHealth,
+            theme: 'health',
+            width: 200,
+            height: 20,
+            label: 'Health',
+            textDisplay: 'both',
+            style: 'gradient',
+            animate: true
+        });
+        await this.healthBar.initialize();
+        this.healthBar.setPosition({
+            position: 'absolute',
+            top: '20px',
+            left: '20px'
+        }, '.progress-bar-container');
+        this.manaBar = new ENGINE.ProgressBar(ui, {
+            currentValue: this.currentMana,
+            maxValue: this.maxMana,
+            theme: 'mana',
+            width: 200,
+            height: 18,
+            label: 'Mana',
+            textDisplay: 'both',
+            style: 'glow',
+            animate: true
+        });
+        await this.manaBar.initialize();
+        this.manaBar.setPosition({
+            position: 'absolute',
+            top: '70px', // Position below health bar
+            left: '20px'
+        }, '.progress-bar-container');
+        this.experienceBar = new ENGINE.ProgressBar(ui, {
+            currentValue: this.currentExperience,
+            maxValue: this.maxExperience,
+            theme: 'experience',
+            width: 300,
+            height: 12,
+            label: 'Experience',
+            textDisplay: 'percentage',
+            style: 'rounded',
+            animate: true
+        });
+        await this.experienceBar.initialize();
+        this.experienceBar.setPosition({
+            position: 'absolute',
+            bottom: '120px', // Increased from 80px to give more clearance above inventory bar
+            left: '50%',
+            transform: 'translateX(-50%)'
+        }, '.progress-bar-container');
+        // Initialize the new controls panel using the convenience method
+        this.controlsPanel = new ENGINE.ControlsPanel(ui, {
+            visible: true
+        });
+        await this.controlsPanel.initialize();
+        // Use the convenience method to position it at bottom-left
+        this.controlsPanel.setCustomPosition({
+            position: 'absolute',
+            bottom: '20px',
+            left: '20px',
+            top: 'auto',
+            right: 'auto'
+        });
+        // Start HUD update loop
+        this.startHUDUpdates();
+    }
+    async createMenu(ui) {
+        // Load menu assets from external files
+        const { template, styles } = await ENGINE.UIAssetLoader.loadUIAsset(ENGINE.AssetPath.fromString('@engine/assets/ui/templates/main-menu.html'), ENGINE.AssetPath.fromString('@engine/assets/ui/styles/main-menu.css'));
+        this.menuLayout = ui.createLayout('main-menu', {
+            template,
+            styles,
+            data: {
+                title: 'FPS Demo'
+            },
+            eventHandlers: {
+                resume: {
+                    selector: '#resume-btn',
+                    event: 'click',
+                    handler: () => this.toggleMenu()
+                },
+                restart: {
+                    selector: '#restart-btn',
+                    event: 'click',
+                    handler: () => this.restartGame()
+                },
+                quit: {
+                    selector: '#quit-btn',
+                    event: 'click',
+                    handler: () => this.quitGame()
+                }
+            }
+        });
+        // Hide menu initially
+        this.menuLayout.getElement().hide();
+    }
+    async createControls(ui) {
+        // For now, continue with the direct approach until we create a proper ControlsPanel component
+        // Load controls help assets from external files
+        const { template, styles } = await ENGINE.UIAssetLoader.loadUIAsset(ENGINE.AssetPath.fromString('@engine/assets/ui/templates/controls-help.html'), ENGINE.AssetPath.fromString('@engine/assets/ui/styles/controls-help.css'));
+        // Create a layout for the controls help to apply external styles
+        this.controlsLayout = ui.createLayout('controls-help', {
+            template,
+            styles,
+            data: {}
+        });
+        // Position the controls panel at bottom-left using direct styling
+        const controlsElement = this.controlsLayout.getElement();
+        if (controlsElement) {
+            // Target the controls-container element for precise positioning
+            const controlsContainer = this.controlsLayout.querySelector('.controls-container');
+            if (controlsContainer) {
+                controlsContainer.style.position = 'absolute';
+                controlsContainer.style.bottom = '20px';
+                controlsContainer.style.left = '20px';
+                controlsContainer.style.top = 'auto';
+                controlsContainer.style.right = 'auto';
+            }
+            else {
+                // Fallback to root element if container not found
+                controlsElement.setStyle('position', 'absolute');
+                controlsElement.setStyle('bottom', '20px');
+                controlsElement.setStyle('left', '20px');
+                controlsElement.setStyle('top', 'auto');
+                controlsElement.setStyle('right', 'auto');
+            }
+        }
+    }
+    setupGameLogic() {
+        // Add input handlers for demo
+        const inputHandler = new ENGINE.BaseInputHandler();
+        inputHandler.handleKeyDown = (e) => {
+            switch (e.code) {
+                case 'KeyP':
+                    this.toggleMenu();
+                    return true;
+                case 'KeyR':
+                    this.reloadWeapon();
+                    return true;
+                case 'KeyI':
+                    this.toggleInventoryGrid();
+                    return true;
+            }
+            return false;
+        };
+        this.world.inputManager.addInputHandler(inputHandler);
+        // Hook into the PlayerController's mouse events using delegates
+        if (this.controller) {
+            this.controller.onMouseDown.add((button, e) => {
+                if (button === ENGINE.MouseButton.Left && !this.isMenuVisible) {
+                    this.shoot();
+                    return true;
+                }
+                return false;
+            });
+        }
+        // Update health bars every frame
+        this.startHealthBarUpdates();
+        // Start collectable spinning animation
+        this.startCollectableUpdates();
+    }
+    shoot() {
+        if (this.currentAmmo <= 0 || this.isReloading || !this.weaponComponent) {
+            return;
+        }
+        // Fire the weapon
+        this.weaponComponent.beginFire();
+        this.weaponComponent.endFire();
+        this.currentAmmo--;
+        this.updateAmmoDisplay();
+        // Demo: Decrease mana when shooting (costs 2 mana per shot)
+        this.currentMana = Math.max(0, this.currentMana - 2);
+        this.manaBar.setValue(this.currentMana);
+    }
+    async reloadWeapon() {
+        if (this.isReloading || this.currentAmmo === this.maxAmmo) {
+            return;
+        }
+        this.isReloading = true;
+        // Start reload animation using the new component
+        await this.reloadIndicator.startReload();
+        // Reload complete
+        this.currentAmmo = this.maxAmmo;
+        this.isReloading = false;
+        this.ammoCounter.setAmmo(this.currentAmmo, this.maxAmmo);
+    }
+    updateAmmoDisplay() {
+        // Update using the new ammo counter component
+        this.ammoCounter.setAmmo(this.currentAmmo, this.maxAmmo);
+    }
+    addPoints(amount) {
+        this.points += amount;
+        this.pointsCounter.add(amount);
+    }
+    startHUDUpdates() {
+        const updateHUD = () => {
+            if (!this.pawn)
+                return;
+            const camera = this.pawn.getComponent(THREE.Camera);
+            if (!camera)
+                return;
+            // Update compass
+            this.compass.updateRotation(camera);
+            // Update minimap
+            const playerPosition = new THREE.Vector3();
+            this.pawn.rootComponent.getWorldPosition(playerPosition);
+            this.minimap.setPlayerPosition(playerPosition);
+            // Update minimap targets
+            const minimapTargets = this.cubeTargets.map(cube => {
+                const position = new THREE.Vector3();
+                cube.actor.rootComponent.getWorldPosition(position);
+                return { position };
+            });
+            this.minimap.setTargets(minimapTargets);
+            this.minimap.render();
+            requestAnimationFrame(updateHUD);
+        };
+        updateHUD();
+    }
+    updateCubeHealthBar(cube) {
+        if (!cube.healthBarElement)
+            return; // Skip if disabled for debugging
+        const percentage = Math.max(0, cube.health / cube.maxHealth);
+        // Determine color based on health
+        let color = '#4CAF50'; // Green
+        if (cube.health <= 30) {
+            color = '#F44336'; // Red
+        }
+        else if (cube.health <= 60) {
+            color = '#FF9800'; // Orange
+        }
+        // Update the background gradient to show the health percentage
+        const fillPercentage = Math.round(percentage * 100);
+        cube.healthBarElement.setStyle('backgroundImage', `linear-gradient(to right, ${color} ${fillPercentage}%, transparent ${fillPercentage}%)`);
+    }
+    destroyCube(cube) {
+        // Check if cube is already removed from array to prevent double removal
+        const index = this.cubeTargets.indexOf(cube);
+        if (index === -1) {
+            return; // Already removed
+        }
+        // Note: Don't call world.removeActors() here because CharacterStatsComponent
+        // already removes the actor from the world when health reaches 0
+        // Remove health bar
+        if (cube.healthBarContainer) {
+            cube.healthBarContainer.remove();
+        }
+        // Remove from array
+        this.cubeTargets.splice(index, 1);
+        // Spawn a new cube if all are destroyed
+        if (this.cubeTargets.length === 0) {
+            setTimeout(() => {
+                this.createCubeTargets();
+            }, 1000);
+        }
+    }
+    startHealthBarUpdates() {
+        // Update health bar positions every frame
+        const updateUI = () => {
+            if (!this.pawn)
+                return;
+            const camera = this.pawn.getComponent(THREE.Camera);
+            if (!camera)
+                return;
+            this.cubeTargets.forEach(cube => {
+                // Skip if health bar is disabled for debugging
+                if (!cube.healthBarContainer)
+                    return;
+                const cubePosition = new THREE.Vector3();
+                cube.actor.rootComponent.getWorldPosition(cubePosition);
+                // Position health bar above the cube
+                cubePosition.y += 2;
+                // Project 3D position to screen coordinates
+                const screenPosition = cubePosition.clone().project(camera);
+                // Convert to screen pixels using container size (not window size)
+                const containerSize = this.renderer.getWindowSize();
+                const x = (screenPosition.x * 0.5 + 0.5) * containerSize.width;
+                const y = (screenPosition.y * -0.5 + 0.5) * containerSize.height;
+                // Health bar dimensions
+                const healthBarWidth = 60;
+                const healthBarHeight = 8;
+                const healthBarX = x - healthBarWidth / 2;
+                const healthBarY = y - 10;
+                // Hide health bar if cube is behind camera or outside container bounds
+                // Add margin to prevent positioning near edges that could cause scroll bars
+                const margin = 10;
+                if (screenPosition.z > 1 || screenPosition.z < 0 ||
+                    healthBarX < margin || healthBarX + healthBarWidth > containerSize.width - margin ||
+                    healthBarY < margin || healthBarY + healthBarHeight > containerSize.height - margin) {
+                    cube.healthBarContainer.hide();
+                }
+                else {
+                    // Update health bar position (clamp to safe bounds)
+                    const clampedX = Math.max(margin, Math.min(healthBarX, containerSize.width - healthBarWidth - margin));
+                    const clampedY = Math.max(margin, Math.min(healthBarY, containerSize.height - healthBarHeight - margin));
+                    cube.healthBarContainer.setStyle('left', `${clampedX}px`);
+                    cube.healthBarContainer.setStyle('top', `${clampedY}px`);
+                    cube.healthBarContainer.setStyle('display', 'block');
+                    cube.healthBarContainer.show();
+                }
+            });
+            requestAnimationFrame(updateUI);
+        };
+        updateUI();
+    }
+    toggleMenu() {
+        this.isMenuVisible = !this.isMenuVisible;
+        if (this.isMenuVisible) {
+            // Show menu and release pointer lock
+            this.menuLayout.getElement().show();
+            this.world.inputManager.exitPointerLock();
+        }
+        else {
+            // Hide menu and re-enable pointer lock
+            this.menuLayout.getElement().hide();
+            this.world.inputManager.requestPointerLock({});
+        }
+    }
+    toggleInventoryGrid() {
+        this.isInventoryGridVisible = !this.isInventoryGridVisible;
+        if (this.isInventoryGridVisible) {
+            // Sync inventory grid with inventory bar when opening
+            this.syncInventoryGrid();
+            this.inventoryGrid.show();
+            // Release pointer lock so mouse can interact with UI
+            this.world.inputManager.exitPointerLock();
+        }
+        else {
+            this.inventoryGrid.hide();
+            // Re-enable pointer lock when closing inventory
+            this.world.inputManager.requestPointerLock({});
+        }
+    }
+    /**
+     * Synchronize the inventory grid with the inventory bar
+     */
+    syncInventoryGrid() {
+        const barItems = this.inventoryBar.getItems();
+        this.inventoryGrid.setItems(barItems);
+    }
+    restartGame() {
+        // Reset ammo
+        this.currentAmmo = this.maxAmmo;
+        this.isReloading = false;
+        this.ammoCounter.setAmmo(this.currentAmmo, this.maxAmmo);
+        // Reset points
+        this.points = 0;
+        this.pointsCounter.setValue(this.points);
+        // Reset progress bars
+        this.currentHealth = this.maxHealth;
+        this.currentMana = this.maxMana;
+        this.currentExperience = 0;
+        this.healthBar.setValue(this.currentHealth);
+        this.manaBar.setValue(this.currentMana);
+        this.experienceBar.setValue(this.currentExperience);
+        // Clear inventory
+        this.inventoryBar.clearItems();
+        this.inventoryGrid.clearItems();
+        // Hide inventory grid if visible
+        if (this.isInventoryGridVisible) {
+            this.toggleInventoryGrid();
+        }
+        // Destroy all cubes and recreate them
+        this.cubeTargets.forEach(cube => {
+            this.world.removeActors(cube.actor);
+            if (cube.healthBarContainer) {
+                cube.healthBarContainer.remove();
+            }
+        });
+        this.cubeTargets = [];
+        // Destroy all collectables and recreate them
+        this.collectables.forEach(collectable => {
+            this.world.removeActors(collectable.actor);
+        });
+        this.collectables = [];
+        // Recreate game objects
+        this.createCubeTargets();
+        this.createCollectables();
+        this.toggleMenu();
+    }
+    quitGame() {
+        if (confirm('Are you sure you want to quit?')) {
+            window.location.reload();
+        }
+    }
+    createCollectables() {
+        const numCollectables = 15;
+        const spawnRadius = 30;
+        const gemTypes = Array.from(this.gemConfig.keys());
+        for (let i = 0; i < numCollectables; i++) {
+            // Random position around the world
+            const angle = Math.random() * Math.PI * 2;
+            const distance = Math.random() * spawnRadius + 10;
+            const x = Math.cos(angle) * distance;
+            const z = Math.sin(angle) * distance;
+            const y = Math.random() * 3 + 2; // Float above ground
+            // Random gem type
+            const gemType = gemTypes[Math.floor(Math.random() * gemTypes.length)];
+            const gemInfo = this.gemConfig.get(gemType);
+            // Create smaller spinning pyramid
+            const pyramidGeometry = new THREE.ConeGeometry(0.4, 0.8, 4); // Made smaller: was 0.8, 1.5
+            const pyramidMaterial = new THREE.MeshStandardMaterial({
+                color: gemInfo.color,
+                metalness: 0.3,
+                roughness: 0.2,
+                emissive: new THREE.Color(gemInfo.color).multiplyScalar(0.1)
+            });
+            const collectableActor = new ENGINE.Actor({
+                rootComponent: new ENGINE.MeshComponent({
+                    position: new THREE.Vector3(x, y, z),
+                    geometry: pyramidGeometry,
+                    material: pyramidMaterial,
+                    physicsOptions: {
+                        enabled: true,
+                        motionType: ENGINE.PhysicsMotionType.Static,
+                        collisionProfile: ENGINE.DefaultCollisionProfile.OverlapAll, // Trigger overlap, not collision
+                        generateCollisionEvents: true
+                    }
+                })
+            });
+            this.world.addActors(collectableActor);
+            const collectable = {
+                actor: collectableActor,
+                gemType,
+                rotationSpeed: (Math.random() * 2 + 1) * Math.PI // 1-3 rad/s
+            };
+            this.collectables.push(collectable);
+        }
+    }
+    startCollectableUpdates() {
+        console.log('Starting collectable updates...', this.collectables.length, 'collectables');
+        const updateCollectables = () => {
+            this.collectables.forEach((collectable, index) => {
+                const meshComponent = collectable.actor.rootComponent;
+                // Rotate the component directly
+                meshComponent.rotation.y += collectable.rotationSpeed * 0.016; // 60fps delta
+                // Check distance to player for collection (backup to physics)
+                if (this.pawn) {
+                    const playerPos = new THREE.Vector3();
+                    const collectablePos = new THREE.Vector3();
+                    this.pawn.rootComponent.getWorldPosition(playerPos);
+                    meshComponent.getWorldPosition(collectablePos);
+                    const distance = playerPos.distanceTo(collectablePos);
+                    // Collection distance threshold
+                    if (distance < 2.0) { // 2 units
+                        console.log(`Player close to gem! Distance: ${distance.toFixed(2)}`);
+                        this.collectGem(collectable);
+                    }
+                }
+            });
+            if (this.collectables.length > 0) {
+                requestAnimationFrame(updateCollectables);
+            }
+        };
+        updateCollectables();
+    }
+    collectGem(collectable) {
+        // Check if collectable is still in the array (prevent double collection)
+        const index = this.collectables.indexOf(collectable);
+        if (index === -1) {
+            console.log('Gem already collected!');
+            return;
+        }
+        // Check if inventory is full using the inventory bar component
+        if (this.inventoryBar.isFull()) {
+            console.log('Inventory full! Cannot collect gem.');
+            return; // Refuse pickup
+        }
+        // Add to inventory using the inventory bar component
+        const gemInfo = this.gemConfig.get(collectable.gemType);
+        const gemItem = {
+            id: `${collectable.gemType}-${Date.now()}`, // Add required id field
+            gemType: collectable.gemType,
+            color: `#${gemInfo.color.toString(16).padStart(6, '0')}`,
+            name: gemInfo.name
+        };
+        const success = this.inventoryBar.addItem(gemItem);
+        if (!success) {
+            console.log('Failed to add item to inventory');
+            return;
+        }
+        // Also add to inventory grid to keep them synchronized
+        this.inventoryGrid.addItem(gemItem);
+        // Remove from collectables array first to prevent double collection
+        this.collectables.splice(index, 1);
+        // Remove from world
+        this.world.removeActors(collectable.actor);
+        // Add points for collecting
+        this.addPoints(10);
+        // Demo: Gain experience when collecting gems
+        this.currentExperience = Math.min(this.maxExperience, this.currentExperience + 5);
+        this.experienceBar.setValue(this.currentExperience);
+        // Demo: Heal a bit when collecting gems
+        this.currentHealth = Math.min(this.maxHealth, this.currentHealth + 2);
+        this.healthBar.setValue(this.currentHealth);
+        console.log(`Collected ${gemInfo.name}! Inventory: ${this.inventoryBar.getItemCount()}/${this.maxInventorySlots}`);
+    }
+    /**
+     * Custom gem renderer for the inventory
+     */
+    renderGemItem(item, slotElement) {
+        const contentElement = slotElement.querySelector('.item-content');
+        if (contentElement) {
+            contentElement.style.backgroundColor = item.color;
+            contentElement.style.borderRadius = '50%'; // Make it circular like a gem
+            contentElement.style.display = 'block';
+            contentElement.style.boxShadow = `
+        0 0 8px rgba(255, 255, 255, 0.3),
+        inset 0 2px 4px rgba(255, 255, 255, 0.2),
+        inset 0 -2px 4px rgba(0, 0, 0, 0.3)
+      `;
+            contentElement.title = item.name;
+            // Add gem shine effect
+            contentElement.innerHTML = '<div style="position: absolute; top: 3px; left: 6px; width: 6px; height: 6px; background: rgba(255, 255, 255, 0.4); border-radius: 50%; filter: blur(1px);"></div>';
+        }
+    }
+    /**
+     * Custom gem slot clearer
+     */
+    clearGemSlot(slotElement) {
+        const contentElement = slotElement.querySelector('.item-content');
+        if (contentElement) {
+            contentElement.style.display = 'none';
+            contentElement.style.backgroundColor = '';
+            contentElement.style.boxShadow = '';
+            contentElement.innerHTML = '';
+            contentElement.title = '';
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui-demo.js","sourceRoot":"","sources":["../../games/ui-demo.ts"],"names":[],"mappings":"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"}