A!leys Galerie

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System.Collections.Generic;
using UnityEngine.XR.Interaction.Toolkit; // For haptic feedback (requires XR Interaction Toolkit)

[RequireComponent(typeof(AudioSource))]
public class HolographicMenuSystem : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler, IPointerClickHandler
{
    [Header("Menu Settings")]
    [SerializeField] private float menuSpacing = 0.5f;
    [SerializeField] private float menuItemScale = 1.2f;
    [SerializeField] private float hologramGlowIntensity = 0.3f;
    [SerializeField] private Color hologramGlowColor = new Color(0.1f, 0.8f, 1.0f, 0.3f);
    [SerializeField] private AnimationCurve hoverAnimationCurve;
    [SerializeField] private float hoverDuration = 0.2f;
    [SerializeField] private float hoverDelay = 0.1f;

    [Header("Haptic Feedback")]
    [SerializeField] private float hapticPulseDuration = 0.2f;
    [SerializeField] private float hapticPulseAmplitude = 0.5f;
    [SerializeField] private float hapticClickDuration = 0.4f;
    [SerializeField] private float hapticClickAmplitude = 0.7f;

    [Header("References")]
    [SerializeField] private GameObject menuItemPrefab;
    [SerializeField] private Transform menuContainer;
    [SerializeField] private AudioClip menuHoverSound;
    [SerializeField] private AudioClip menuSelectSound;

    private List<HolographicMenuItem> menuItems = new List<HolographicMenuItem>();
    private int selectedIndex = -1;
    private bool isAnimating = false;
    private Coroutine hoverCoroutine = null;
    private AudioSource audioSource;

    private void Awake()
    {
        audioSource = GetComponent<AudioSource>();
        if (menuContainer == null)
        {
            menuContainer = new GameObject("MenuContainer").transform;
        }
    }

    private void Start()
    {
        GenerateMenuItems();
    }

    private void GenerateMenuItems()
    {
        ClearMenu();

        // Example menu items with unique holographic names
        string[] menuItemNames = { "Quantum Leap", "Neural Sync", "Holo Map", "AI Core", "Gravity Well", "Time Fold" };

        for (int i = 0; i < menuItemNames.Length; i++)
        {
            GameObject itemObj = Instantiate(menuItemPrefab, menuContainer);
            HolographicMenuItem item = itemObj.GetComponent<HolographicMenuItem>();

            if (item != null)
            {
                item.Initialize(menuItemNames[i], i, this);
                item.transform.localPosition = new Vector3(0, i * menuSpacing, 0);
                item.transform.localScale = Vector3.one * menuItemScale;
                item.transform.localEulerAngles = new Vector3(0, 0, -15 * i); // Slight tilt for depth

                // Add glow effect
                AddGlowEffect(item.gameObject);

                menuItems.Add(item);
            }
        }
    }

    private void AddGlowEffect(GameObject target)
    {
        GameObject glow = new GameObject("GlowEffect");
        glow.transform.parent = target.transform;
        glow.transform.localPosition = Vector3.zero;
        glow.transform.localScale = target.transform.localScale * 1.1f;

        Image glowImage = glow.AddComponent<Image>();
        glowImage.color = hologramGlowColor;
        glowImage.type = Image.Type.Sliced;
        glowImage.preserveAspect = true;

        // Simple glow outline shader (requires this to be set in project)
        glowImage.material = Resources.Load<Material>("Materials/GlowOutline");
        glowImage.enabled = true;
    }

    private void ClearMenu()
    {
        foreach (Transform child in menuContainer)
        {
            Destroy(child.gameObject);
        }
        menuItems.Clear();
        selectedIndex = -1;
    }

    public void SelectItem(int index)
    {
        if (index >= 0 && index < menuItems.Count && !isAnimating)
        {
            selectedIndex = index;
            HolographicMenuItem selectedItem = menuItems[index];

            // Trigger haptic feedback
            TriggerHapticPulse(hapticPulseAmplitude, hapticPulseDuration);
            TriggerHapticClick(hapticClickAmplitude, hapticClickDuration);

            // Play select sound
            if (audioSource != null && menuSelectSound != null)
            {
                audioSource.PlayOneShot(menuSelectSound);
            }

            // Call the item's action
            selectedItem.OnSelected();

            // Animation feedback
            isAnimating = true;
            StartCoroutine(SelectAnimation(selectedItem));
        }
    }

    private IEnumerator SelectAnimation(HolographicMenuItem item)
    {
        // Scale down slightly when selected
        Vector3 originalScale = item.transform.localScale;
        item.transform.localScale = originalScale * 0.9f;

        yield return new WaitForSeconds(0.1f);

        item.transform.localScale = originalScale * 1.1f;

        yield return new WaitForSeconds(0.1f);

        item.transform.localScale = originalScale;

        isAnimating = false;
    }

    public void OnPointerEnter(PointerEventData eventData)
    {
        if (hoverCoroutine != null)
        {
            StopCoroutine(hoverCoroutine);
        }

        if (selectedIndex != -1)
        {
            // If already selected, don't play hover sound again
            return;
        }

        if (eventData.pointerCurrentRaycast.gameObject != null)
        {
            int newIndex = menuItems.FindIndex(item => item.gameObject == eventData.pointerCurrentRaycast.gameObject);
            if (newIndex != -1 && newIndex != selectedIndex)
            {
                TriggerHapticPulse(hapticPulseAmplitude * 0.7f, hapticPulseDuration * 0.8f);
                hoverCoroutine = StartCoroutine(HoverAnimation(menuItems[newIndex]));
            }
        }
    }

    private IEnumerator HoverAnimation(HolographicMenuItem item)
    {
        float timer = 0f;
        Vector3 originalScale = item.transform.localScale;
        Vector3 originalPosition = item.transform.localPosition;

        while (timer < hoverDuration)
        {
            timer += Time.deltaTime;
            float t = Mathf.Clamp01(timer / hoverDuration);

            // Apply animation curve for smooth scaling
            float scaleFactor = 1 + hoverAnimationCurve.Evaluate(t) * 0.2f;
            item.transform.localScale = originalScale * scaleFactor;

            // Slight upward movement
            item.transform.localPosition = originalPosition + Vector3.up * Mathf.Sin(t * Mathf.PI * 2) * 0.05f;

            yield return null;
        }

        // Return to original state
        item.transform.localScale = originalScale;
        item.transform.localPosition = originalPosition;

        // Play hover sound
        if (audioSource != null && menuHoverSound != null)
        {
            audioSource.PlayOneShot(menuHoverSound);
        }
    }

    public void OnPointerExit(PointerEventData eventData)
    {
        if (hoverCoroutine != null)
        {
            StopCoroutine(hoverCoroutine);
            hoverCoroutine = null;
        }
    }

    public void OnPointerClick(PointerEventData eventData)
    {
        if (eventData.pointerCurrentRaycast.gameObject != null)
        {
            int clickedIndex = menuItems.FindIndex(item => item.gameObject == eventData.pointerCurrentRaycast.gameObject);
            if (clickedIndex != -1)
            {
                SelectItem(clickedIndex);
            }
        }
    }

    private void TriggerHapticPulse(float amplitude, float duration)
    {
        #if UNITY_XR_MANAGEMENT && UNITY_EDITOR_WIN
        // For Unity Editor with XR Interaction Toolkit
        if (XRBaseInteractable Sélectionner is XRBaseInteractable interactable)
        {
            interactable.SendHapticImpulse(amplitude, duration);
        }
        #endif
    }

    private void TriggerHapticClick(float amplitude, float duration)
    {
        #if UNITY_XR_MANAGEMENT && UNITY_EDITOR_WIN
        // Stronger haptic feedback for selection
        if (XRBaseInteractable Sélectionner is XRBaseInteractable interactable)
        {
            interactable.SendHapticImpulse(amplitude, duration);
        }
        #endif
    }

    // Expose method for external script to add new items
    public void AddMenuItem(string itemName, System.Action action)
    {
        GameObject itemObj = Instantiate(menuItemPrefab, menuContainer);
        HolographicMenuItem item = itemObj.GetComponent<HolographicMenuItem>();

        if (item != null)
        {
            int newIndex = menuItems.Count;
            item.Initialize(itemName, newIndex, this);
            item.transform.localPosition = new Vector3(0, newIndex * menuSpacing, 0);
            item.transform.localScale = Vector3.one * menuItemScale;
            item.transform.localEulerAngles = new Vector3(0, 0, -15 * newIndex);
            AddGlowEffect(item.gameObject);
            item.OnSelected = action;
            menuItems.Add(item);
        }
    }

    // Simple menu item class for this system
    private class HolographicMenuItem : MonoBehaviour
    {
        public string ItemName { get; private set; }
        public int Index { get; private set; }
        public System.Action OnSelected { get; set; }
        public HolographicMenuSystem ParentMenu { get; private set; }

        private Text itemText;

        public void Initialize(string name, int index, HolographicMenuSystem parent)
        {
            ItemName = name;
            Index = index;
            ParentMenu = parent;

            // Get or add Text component
            itemText = GetComponentInChildren<Text>();
            if (itemText == null)
            {
                itemText = gameObject.AddComponent<Text>();
                itemText.rectTransform.sizeDelta = new Vector2(200, 50);
                itemText.alignment = TextAnchor.MiddleCenter;
                itemText.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
                itemText.fontSize = 24;
                itemText.color = Color.white;
            }

            itemText.text = ItemName;
        }

        public void OnSelectedAction()
        {
            OnSelected?.Invoke();
        }
    }
}

using UnityEngine;
using UnityEngine.Events;

[RequireComponent(typeof(Camera))]
public class AileyDynamicCameraSmoother : MonoBehaviour
{
    [Header("Follow Settings")]
    [SerializeField] private Transform _target;
    [SerializeField] private float _smoothTime = 0.3f;
    [SerializeField] private float _dampingTime = 0.1f;
    [SerializeField] private float _velocityChange = 10f;
    [SerializeField] private float _maxVelocity = 10f;

    [Header("Bounce Effect")]
    [SerializeField] private bool _enableBounce = false;
    [SerializeField] [Range(0f, 1f)] private float _bounceIntensity = 0.2f;
    [SerializeField] private float _bounceFrequency = 5f;
    [SerializeField] private float _bounceDamping = 10f;

    private Vector3 _velocity;
    private Vector3 _bounceOffset;
    private float _bounceVelocity;

    public UnityEvent<Transform> OnCameraMoved;

    private void Awake()
    {
        if (_target == null)
        {
            Debug.LogError("No target assigned to the camera smoother!");
        }
    }

    private void Update()
    {
        if (_target == null) return;

        Vector3 targetPosition = _target.position;
        if (_enableBounce)
        {
            targetPosition += CalculateBounceOffset();
        }

        Vector3 smoothedPosition = Vector3.SmoothDamp(transform.position, targetPosition, ref _velocity, _smoothTime, _maxVelocity, _dampingTime);
        transform.position = smoothedPosition;

        // Call the event if the camera has moved significantly
        if (Vector3.Distance(transform.position, targetPosition) > 0.01f)
        {
            OnCameraMoved?.Invoke(_target);
        }
    }

    private Vector3 CalculateBounceOffset()
    {
        float bounce = Mathf.Sin(_bounceFrequency * Time.time) * _bounceIntensity;
        _bounceVelocity = Mathf.SmoothDamp(_bounceVelocity, bounce, ref _bounceVelocity, _bounceDamping);
        return new Vector3(_bounceVelocity, 0, _bounceVelocity);
    }

    // Public method to manually update the target (useful for dynamic target changes)
    public void SetTarget(Transform newTarget)
    {
        _target = newTarget;
    }
}

```javascript
// Ailey's RPG Maker MZ Dynamic Menu Generator
// Complete Node.js script for standalone development and export to RPG Maker MZ

// Core dependencies
const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

// Modern ES modules for RPG Maker MZ compatibility
import { Window_MenuCommand, Window_MenuStatus, Window_Selectable, Window_Message } from './rpg_maker_mz_classes/Window_Classes.js';
import { Sprite_RadialProgress, Sprite_MenuHighlight } from './rpg_maker_mz_classes/Sprite_Classes.js';
import { AudioManager } from './rpg_maker_mz_classes/AudioManager.js';

// Unique menu theme configuration
const MENU_THEME = {
    baseColor: '#1a237e',
    accentColor: '#42a5f5',
    radialColors: ['#ff7e5f', '#feb47b', '#42a5f5', '#1a237e'],
    particleColors: ['#ff9ff3', '#a855f7'],
    transitionSpeed: 0.1,
    particleDensity: 0.3
};

// Menu state management
let menuState = {
    activeIndex: 0,
    scrolling: false,
    lastTime: 0,
    currentWindow: null,
    commandWindow: null,
    statusWindow: null,
    messageWindow: null,
    radialProgress: null,
    highlights: []
};

// Core menu class with unique features
class DynamicMenuGenerator {
    constructor() {
        this.initMenuSystem();
    }

    initMenuSystem() {
        // Create main menu window with custom styling
        this.menuWindow = new Window_MenuCommand(0, 0, 640, 480, 'Menu');
        this.menuWindow._list = [
            { name: 'Party', enabled: true, symbol: null, acceleration: null },
            { name: 'Items', enabled: true, symbol: null, acceleration: null },
            { name: 'Skills', enabled: true, symbol: null, acceleration: null },
            { name: 'Equipment', enabled: true, symbol: null, acceleration: null },
            { name: 'Formation', enabled: true, symbol: null, acceleration: null },
            { name: 'Save', enabled: true, symbol: null, acceleration: null },
            { name: 'Options', enabled: true, symbol: null, acceleration: null },
            { name: 'End Game', enabled: true, symbol: null, acceleration: null }
        ];

        // Apply unique styling
        this.menuWindow._windowBackground = new Color(MENU_THEME.baseColor);
        this.menuWindow._commandWindowskin = null; // Use our custom skin
        this.menuWindow._textColor = new Color(MENU_THEME.accentColor);
        this.menuWindow._commandBackgroundSplitting = true;

        // Add radial progress indicator (unique feature)
        this.radialProgress = new Sprite_RadialProgress(320, 240, 120);
        this.radialProgress.setColors(MENU_THEME.radialColors);
        this.radialProgress.setValue(0.75);
        this.radialProgress.setTransitionSpeed(MENU_THEME.transitionSpeed);

        // Create command selection window
        this.commandWindow = new Window_Selectable(0, 80, 640, 320);
        this.commandWindow._list = [];
        this.commandWindow._fixedWidth = true;
        this.commandWindow._itemMax = 4;
        this.commandWindow._padding = 12;
        this.commandWindow._opacity = 0;
        this.commandWindow._windowBackground = new Color(MENU_THEME.baseColor);
        this.commandWindow._commandBackgroundSplitting = true;

        // Status window
        this.statusWindow = new Window_MenuStatus(0, 400, 640, 80);
        this.statusWindow._characterBoxWidth = 168;
        this.statusWindow._characterBoxHeight = 144;
        this.statusWindow._padding = 4;
        this.statusWindow._windowBackground = new Color(MENU_THEME.baseColor);
        this.statusWindow._commandBackgroundSplitting = true;

        // Message window
        this.messageWindow = new Window_Message(0, 0, 640, 480);
        this.messageWindow._backOpacity = 192;
        this.messageWindow._padding = 48;
        this.messageWindow._windowBackground = new Color(MENU_THEME.baseColor);

        // Highlight effects
        this.highlights = [];
        for (let i = 0; i < 8; i++) {
            const highlight = new Sprite_MenuHighlight(0, 0, 640, 480);
            highlight.setColor(MENU_THEME.particleColors[i % 2]);
            highlight.setDensity(MENU_THEME.particleDensity);
            this.highlights.push(highlight);
        }

        // Initialize audio system
        this.audioManager = new AudioManager();
        this.audioManager.loadDynamicMenuSounds();
    }

    update(time) {
        const delta = time - menuState.lastTime;
        menuState.lastTime = time;

        // Update all elements
        if (this.radialProgress) this.radialProgress.update(delta);
        if (this.commandWindow) this.commandWindow.update();
        if (this.statusWindow) this.statusWindow.update();
        if (this.messageWindow) this.messageWindow.update();

        // Update highlight effects
        this.highlights.forEach(highlight => highlight.update(delta));

        // Handle menu scrolling with inertia
        if (menuState.scrolling) {
            this.menuWindow._index += this.menuWindow._scrollSpeed * delta / 16;
            if (this.menuWindow._index < 0) this.menuWindow._index = 0;
            if (this.menuWindow._index > this.menuWindow._list.length - 1) {
                this.menuWindow._index = this.menuWindow._list.length - 1;
                menuState.scrolling = false;
            }
        }
    }

    drawMenuContext(bitmap, x, y) {
        // Clear canvas
        bitmap.clear();

        // Draw theme background
        bitmap.fillAll(MENU_THEME.baseColor);

        // Draw menu window with unique styling
        this.menuWindow.draw(bitmap, x, y);

        // Draw radial progress indicator
        if (this.radialProgress) {
            this.radialProgress.draw(bitmap, x + 320 - 60, y + 240 - 60);
        }

        // Draw highlights
        this.highlights.forEach(highlight => {
            highlight.draw(bitmap, x, y);
        });
    }

    generateMenuData() {
        // Generate complete menu data structure for RPG Maker MZ
        const menuData = {
            theme: MENU_THEME,
            windows: {
                menuWindow: {
                    type: 'Window_MenuCommand',
                    x: 0,
                    y: 0,
                    width: 640,
                    height: 480,
                    commands: this.menuWindow._list,
                    baseColor: MENU_THEME.baseColor,
                    accentColor: MENU_THEME.accentColor,
                    transitionSpeed: MENU_THEME.transitionSpeed
                },
                commandWindow: {
                    type: 'Window_Selectable',
                    x: 0,
                    y: 80,
                    width: 640,
                    height: 320,
                    maxItems: 4,
                    colors: MENU_THEME.radialColors,
                    opacity: 0
                },
                statusWindow: {
                    type: 'Window_MenuStatus',
                    x: 0,
                    y: 400,
                    width: 640,
                    height: 80,
                    characterBox: {
                        width: 168,
                        height: 144
                    }
                },
                messageWindow: {
                    type: 'Window_Message',
                    x: 0,
                    y: 0,
                    width: 640,
                    height: 480,
                    padding: 48
                }
            },
            effects: {
                radialProgress: {
                    x: 320,
                    y: 240,
                    radius: 120,
                    colors: MENU_THEME.radialColors,
                    transitionSpeed: MENU_THEME.transitionSpeed,
                    currentValue: 0.75
                },
                highlights: this.highlights.map((h, i) => ({
                    x: 0,
                    y: 0,
                    width: 640,
                    height: 480,
                    color: MENU_THEME.particleColors[i % 2],
                    density: MENU_THEME.particleDensity
                }))
            },
            audio: {
                theme: 'DynamicMenuTheme',
                sounds: {
                    menuOpen: 'MenuOpen',
                    menuClose: 'MenuClose',
                    selection: 'MenuSelection',
                    cursor: 'MenuCursor'
                }
            }
        };

        return menuData;
    }

    exportToRPGmaker() {
        // Generate complete menu data
        const menuData = this.generateMenuData();

        // Create output directory
        const outputDir = './AileyDynamicMenu';
        if (!fs.existsSync(outputDir)) {
            fs.mkdirSync(outputDir);
        }

        // Export all necessary files
        const jsContent = `// Ailey's Dynamic Menu for RPG Maker MZ\n\n${this.generateExportJS(menuData)}`;
        fs.writeFileSync(path.join(outputDir, 'Ailey_DynamicMenu.js'), jsContent);

        const cssContent = this.generateExportCSS(menuData);
        fs.writeFileSync(path.join(outputDir, 'Ailey_DynamicMenu.css'), cssContent);

        const jsonContent = JSON.stringify(menuData, null, 2);
        fs.writeFileSync(path.join(outputDir, 'Ailey_DynamicMenuConfig.json'), jsonContent);

        console.log('✅ Menu export complete! Files saved to:', outputDir);
        console.log('📁 Contents:');
        console.log('  - Ailey_DynamicMenu.js (Main implementation)');
        console.log('  - Ailey_DynamicMenu.css (Styling)');
        console.log('  - Ailey_DynamicMenuConfig.json (Configuration)');
    }

    generateExportJS(menuData) {
        return `// Ailey's Dynamic Menu System for RPG Maker MZ
// This is the main implementation file

class Ailey_DynamicMenu {
    constructor() {
        this.config = ${JSON.stringify(menuData)};
        this.init();
    }

    init() {
        // Initialize all menu components
        this.createMenuWindow();
        this.createCommandWindow();
        this.createStatusWindow();
        this.createMessageWindow();
        this.createRadialProgress();
        this.createHighlights();

        // Load audio
        this.loadAudio();
    }

    createMenuWindow() {
        this.menuWindow = new Window_MenuCommand(
            this.config.windows.menuWindow.x,
            this.config.windows.menuWindow.y,
            this.config.windows.menuWindow.width,
            this.config.windows.menuWindow.height,
            ''
        );

        this.menuWindow._list = this.config.windows.menuWindow.commands;
        this.menuWindow._windowBackground = new Color(this.config.theme.baseColor);
        this.menuWindow._commandWindowskin = null;
        this.menuWindow._textColor = new Color(this.config.theme.accentColor);
        this.menuWindow._commandBackgroundSplitting = true;

        // Add event handlers
        this.menuWindow.setHandler('party', () => this.commandParty());
        this.menuWindow.setHandler('items', () => this.commandItems());
        this.menuWindow.setHandler('skills', () => this.commandSkills());
        this.menuWindow.setHandler('equipment', () => this.commandEquipment());
        this.menuWindow.setHandler('formation', () => this.commandFormation());
        this.menuWindow.setHandler('save', () => this.commandSave());
        this.menuWindow.setHandler('options', () => this.commandOptions());
        this.menuWindow.setHandler('end', () => this.commandEnd());
    }

    // [Additional methods would go here in a real implementation]
    // For brevity, we'll skip the full method implementations
    // but the structure is complete and would work when fleshed out

    createRadialProgress() {
        this.radialProgress = new Sprite_RadialProgress(
            this.config.effects.radialProgress.x,
            this.config.effects.radialProgress.y,
            this.config.effects.radialProgress.radius
        );
        this.radialProgress.setColors(this.config.effects.radialProgress.colors);
        this.radialProgress.setValue(this.config.effects.radialProgress.currentValue);
        this.radialProgress.setTransitionSpeed(this.config.theme.transitionSpeed);
        this.addChild(this.radialProgress);
    }

    loadAudio() {
        const audio = this.config.audio;
        AudioManager.loadSound('MenuOpen', 'audio/MenuOpen.mp3');
        AudioManager.loadSound('MenuClose', 'audio/MenuClose.mp3');
        AudioManager.loadSound('MenuSelection', 'audio/MenuSelection.mp3');
        AudioManager.loadSound('MenuCursor', 'audio/MenuCursor.mp3');
    }

    update(time) {
        // Update all elements with delta time
        if (this.radialProgress) this.radialProgress.update(time);
        if (this.menuWindow) this.menuWindow.update();
        if (this.commandWindow) this.commandWindow.update();
        if (this.statusWindow) this.statusWindow.update();
        if (this.messageWindow) this.messageWindow.update();

        // Update highlights
        this.highlights.forEach(h => h.update(time));
    }

    draw(bitmap) {
        // Draw all menu elements
        this.menuWindow.draw(bitmap);
        if (this.radialProgress) this.radialProgress.draw(bitmap);
        this.highlights.forEach(h => h.draw(bitmap));
    }
}

// Main menu class for RPG Maker MZ
class Window_AileyMenu extends Window_Selectable {
    constructor(x, y, width, height) {
        super(x, y, width, height);
        this._menu = new Ailey_DynamicMenu();
    }

    update() {
        super.update();
        this._menu.update(0); // Simplified for RPG Maker MZ
    }

    draw(bitmap) {
        super.draw(bitmap);
        this._menu.draw(bitmap);
    }
}

// Plugin manager for RPG Maker MZ
if (typeof Scene_Menu !== 'undefined') {
    Scene_Menu.prototype.create = function() {
        Scene_Base.prototype.create.call(this);
        this.createMenuWindow();
    };

    Scene_Menu.prototype.createMenuWindow = function() {
        this._menuWindow = new Window_AileyMenu(0, 0, this._width, this._height);
        this.addChild(this._menuWindow);
    };
}

// Export for RPG Maker MZ plugin system
AileyDynamicMenu = function() {
    this.name = 'Ailey Dynamic Menu';
    this.version = '1.0.0';
    this.description = 'A creative, animated menu system with radial progress indicators and particle effects';
    this.parameters = {};
    this._menu = null;
};

AileyDynamicMenu.prototype = Object.create(Window_AileyMenu.prototype);
AileyDynamicMenu.prototype.constructor = AileyDynamicMenu;

`;
    }

    generateExportCSS(menuData) {
        return `@font-face {
    font-family: 'DynamicMenuFont';
    src: url('fonts/DynamicMenuFont.woff2') format('woff2');
    font-weight: normal;
    font-style: normal;
    font-display: swap;
}

/* Main menu styling */
.Window_AileyMenu {
    color: ${menuData.theme.accentColor};
    background-color: ${menuData.theme.baseColor};
    border-color: rgba(0, 0, 0, 0);
    border-width: 0;
    outline-width: 0;
    padding: 0;
    font-family: 'DynamicMenuFont', 'GameFont', monospace;
    font-size: 24px;
}

/* Command window styling */
.Window_Command {
    color: ${menuData.theme.accentColor};
    background-color: rgba(26, 35, 126, 0.8);
    border-color: rgba(66, 165, 245, 0.3);
    border-width: 2;
    outline-width: 0;
    padding: 12px;
    font-family: 'DynamicMenuFont', 'GameFont', monospace;
    font-size: 22px;
    cursor: pointer;
}

/* Status window styling */
.Window_Status {
    color: ${menuData.theme.accentColor};
    background-color: rgba(26, 35, 126, 0.6);
    border-color: rgba(66, 165, 245, 0.2);
    border-width: 1;
    outline-width: 0;
    padding: 8px;
    font-family: 'DynamicMenuFont', 'GameFont', monospace;
    font-size: 18px;
}

/* Radial progress styling */
.RadialProgress {
    stroke: ${menuData.effects.radialProgress.colors[0]};
    stroke-width: 10;
    stroke-dasharray: 0;
    stroke-dashoffset: 0;
    transition: stroke-dasharray 0.5s ease, stroke 0.5s ease;
}

/* Highlight effects */
.HighlightParticle {
    fill: ${menuData.theme.particleColors[0]};
    opacity: 0.7;
    transition: transform 0.2s ease, opacity 0.2s ease;
}

/* Animated cursor */
.MenuCursor {
    color: ${menuData.theme.accentColor};
    animation: pulse 1.5s infinite;
}

@keyframes pulse {
    0% { transform: scale(1); }
    50% { transform: scale(1.1); }

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System.Collections;
using TMPro;
using UnityEngine.XR Interaction.Toolkit;

[RequireComponent(typeof(AudioSource))]
[DisallowMultipleComponent]
public class NebulaNavigationSystem : MonoBehaviour
{
    [Header("Nebula Settings")]
    [SerializeField] private Material _nebulaMaterial;
    [SerializeField] private float _rotationSpeed = 90f;
    [SerializeField] private float _scaleSpeed = 2f;
    [SerializeField] private float _pulseFrequency = 1.5f;
    [SerializeField] private float _pulseAmount = 0.15f;
    [SerializeField] private AnimationCurve _pulseCurve;
    [SerializeField] private float _hapticFeedbackDuration = 0.1f;
    [SerializeField] private float _hapticFeedbackAmplitude = 0.5f;

    [Header("Menu Items")]
    [SerializeField] private GameObject[] _menuItems;
    [SerializeField] private float _itemSpacing = 90f;
    [SerializeField] private float _itemScale = 0.8f;
    [SerializeField] private float _itemRotationOffset = 45f;

    [Header("Particle Effects")]
    [SerializeField] private ParticleSystem _selectionParticles;
    [SerializeField] private ParticleSystem _deselectionParticles;
    [SerializeField] private float _particleLifetime = 0.5f;

    [Header("Audio Feedback")]
    [SerializeField] private AudioClip _selectionSound;
    [SerializeField] private AudioClip _deselectionSound;
    [SerializeField] private AudioClip _hapticSound;

    private int _currentSelection = 0;
    private Transform _centerTransform;
    private bool _isInitialized = false;
    private XRBaseInteractor _currentInteractor;
    private XRBaseInteractable _currentInteractable;
    private Coroutine _pulseCoroutine;
    private bool _isPulsing = false;

    private void Awake()
    {
        _centerTransform = new GameObject("NebulaCenter").transform;
        _centerTransform.SetParent(transform);
        _centerTransform.localPosition = Vector3.zero;

        // Initialize menu items in a circular formation
        for (int i = 0; i < _menuItems.Length; i++)
        {
            var item = _menuItems[i];
            item.SetActive(true);
            var itemTransform = item.transform;
            itemTransform.SetParent(_centerTransform);
            itemTransform.localPosition = Quaternion.Euler(0, _itemRotationOffset * i, 0) * Vector3.forward * 1.5f;
            itemTransform.localRotation = Quaternion.Euler(0, _itemRotationOffset * i, 0);
            itemTransform.localScale = Vector3.one * _itemScale;

            // Add interaction components if using XR Interaction Toolkit
            var interactable = item.GetComponent<XRBaseInteractable>();
            if (interactable != null)
            {
                interactable.selectEntered.AddListener(OnItemSelected);
                interactable.selectExited.AddListener(OnItemDeselected);
            }

            // Setup TMP text if present
            var textMeshPro = item.GetComponentInChildren<TMP_Text>();
            if (textMeshPro != null)
            {
                textMeshPro.fontSharedMaterial = _nebulaMaterial;
            }
        }

        // Setup particle systems
        if (_selectionParticles != null)
        {
            var main = _selectionParticles.main;
            main.startLifetime = _particleLifetime;
            _selectionParticles.Stop();
        }

        if (_deselectionParticles != null)
        {
            var main = _deselectionParticles.main;
            main.startLifetime = _particleLifetime;
            _deselectionParticles.Stop();
        }

        _isInitialized = true;
    }

    private void OnEnable()
    {
        if (_hapticSound != null)
        {
            GetComponent<AudioSource>().playOnAwake = false;
        }
    }

    private void Update()
    {
        if (!_isInitialized) return;

        // Continuous rotation of the nebula
        _centerTransform.Rotate(Vector3.up, _rotationSpeed * Time.deltaTime);

        // Handle non-XR input (mouse/keyboard)
        if (EventSystem.current.IsPointerOverGameObject(0) == false)
        {
            HandleInput();
        }
    }

    private void HandleInput()
    {
        // Mouse wheel for selection
        if (Input.GetAxis("Mouse ScrollWheel") > 0f)
        {
            DeselectItem();
            _currentSelection = (_currentSelection + 1) % _menuItems.Length;
            SelectItem(_currentSelection);
        }
        else if (Input.GetAxis("Mouse ScrollWheel") < 0f)
        {
            DeselectItem();
            _currentSelection = (_currentSelection - 1 + _menuItems.Length) % _menuItems.Length;
            SelectItem(_currentSelection);
        }

        // Keyboard arrow keys
        if (Input.GetKeyDown(KeyCode.UpArrow))
        {
            DeselectItem();
            _currentSelection = (_currentSelection - 1 + _menuItems.Length) % _menuItems.Length;
            SelectItem(_currentSelection);
        }
        else if (Input.GetKeyDown(KeyCode.DownArrow))
        {
            DeselectItem();
            _currentSelection = (_currentSelection + 1) % _menuItems.Length;
            SelectItem(_currentSelection);
        }
    }

    private void SelectItem(int index)
    {
        if (index < 0 || index >= _menuItems.Length) return;

        // Stop any existing pulse
        if (_pulseCoroutine != null && _isPulsing)
        {
            StopCoroutine(_pulseCoroutine);
            _isPulsing = false;
        }

        // Highlight selected item
        for (int i = 0; i < _menuItems.Length; i++)
        {
            var item = _menuItems[i];
            var renderer = item.GetComponent<Renderer>();
            if (renderer != null)
            {
                renderer.material = (i == index) ? _nebulaMaterial : null;
            }

            var textMeshPro = item.GetComponentInChildren<TMP_Text>();
            if (textMeshPro != null)
            {
                textMeshPro.color = (i == index) ? Color.white : new Color(0.5f, 0.5f, 0.5f, 1f);
            }
        }

        // Trigger particle effect
        if (_selectionParticles != null)
        {
            _selectionParticles.transform.position = _menuItems[index].transform.position;
            _selectionParticles.Play();
        }

        // Haptic feedback
        if (SystemInfo.supportsVibration)
        {
            StartCoroutine(TriggerHapticFeedback());
        }

        // Audio feedback
        if (_selectionSound != null)
        {
            AudioSource.PlayClipAtPoint(_selectionSound, transform.position);
        }

        // Start pulsing effect on selected item
        if (index < _menuItems.Length)
        {
            StartCoroutine(PulseSelectedItem(index));
        }

        // XR interaction feedback
        if (_currentInteractor != null)
        {
            _currentInteractor.SendHapticImpulse(_hapticFeedbackAmplitude, _hapticFeedbackDuration);
        }
    }

    private void DeselectItem()
    {
        // Stop pulsing
        if (_pulseCoroutine != null && _isPulsing)
        {
            StopCoroutine(_pulseCoroutine);
            _isPulsing = false;
        }

        // Reset all items
        for (int i = 0; i < _menuItems.Length; i++)
        {
            var item = _menuItems[i];
            var renderer = item.GetComponent<Renderer>();
            if (renderer != null)
            {
                renderer.material = null;
            }

            var textMeshPro = item.GetComponentInChildren<TMP_Text>();
            if (textMeshPro != null)
            {
                textMeshPro.color = new Color(0.5f, 0.5f, 0.5f, 1f);
            }
        }

        // Trigger deselection particles
        if (_deselectionParticles != null && _currentSelection < _menuItems.Length)
        {
            _deselectionParticles.transform.position = _menuItems[_currentSelection].transform.position;
            _deselectionParticles.Play();
        }

        // Audio feedback
        if (_deselectionSound != null)
        {
            AudioSource.PlayClipAtPoint(_deselectionSound, transform.position);
        }
    }

    private IEnumerator PulseSelectedItem(int index)
    {
        _isPulsing = true;
        var item = _menuItems[index];
        var originalScale = item.transform.localScale;
        float time = 0f;

        while (time < 1f)
        {
            time += Time.deltaTime * _pulseFrequency;
            float t = Mathf.PingPong(time, 1f);
            item.transform.localScale = originalScale * (1f + _pulseCurve.Evaluate(t) * _pulseAmount);
            yield return null;
        }

        _isPulsing = false;
    }

    private IEnumerator TriggerHapticFeedback()
    {
        if (SystemInfo.supportsVibration)
        {
            Input.vibrationActive = true;
            Input.SetVibration(0f, 1f, _hapticFeedbackDuration);

            if (_hapticSound != null)
            {
                AudioSource.PlayClipAtPoint(_hapticSound, transform.position);
            }
        }
        yield return new WaitForSeconds(_hapticFeedbackDuration);
        Input.vibrationActive = false;
    }

    private void OnItemSelected(SelectEnterEventArgs args)
    {
        _currentInteractable = (XRBaseInteractable)args.interactableObject;
        _currentInteractor = (XRBaseInteractor)args.interactorObject;
        DeselectItem();
        _currentSelection = System.Array.IndexOf(_menuItems, _currentInteractable.gameObject);
        SelectItem(_currentSelection);
    }

    private void OnItemDeselected(SelectExitEventArgs args)
    {
        _currentInteractable = null;
        _currentInteractor = null;
        DeselectItem();
    }

    private void OnDestroy()
    {
        if (_isInitialized)
        {
            for (int i = 0; i < _menuItems.Length; i++)
            {
                var item = _menuItems[i];
                var interactable = item.GetComponent<XRBaseInteractable>();
                if (interactable != null)
                {
                    interactable.selectEntered.RemoveListener(OnItemSelected);
                    interactable.selectExited.RemoveListener(OnItemDeselected);
                }
            }
        }
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Transitions of the Forgotten</title>
    <style>
        :root {
            --bg-color: #1a1a2e;
            --text-color: #e6e6e6;
            --accent-color: #6c5ce7;
            --accent-hover: #a29bfe;
            --transition-speed: 0.8s;
            --shadow-color: rgba(108, 92, 231, 0.3);
        }

        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }

        body {
            background-color: var(--bg-color);
            color: var(--text-color);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            overflow: hidden;
            padding: 2rem;
        }

        .container {
            max-width: 800px;
            width: 100%;
            text-align: center;
            position: relative;
        }

        .title {
            font-size: 2.5rem;
            margin-bottom: 2rem;
            background: linear-gradient(90deg, var(--accent-color), #a29bfe);
            -webkit-background-clip: text;
            background-clip: text;
            color: transparent;
            text-shadow: 0 0 10px rgba(108, 92, 231, 0.5);
            transition: font-size var(--transition-speed) ease;
        }

        .title:hover {
            font-size: 3rem;
        }

        .poem-container {
            background-color: rgba(26, 26, 46, 0.8);
            border-radius: 15px;
            padding: 2rem;
            box-shadow: 0 4px 20px var(--shadow-color);
            position: relative;
            overflow: hidden;
        }

        .poem {
            font-size: 1.2rem;
            line-height: 1.8;
            margin-bottom: 2rem;
            transition: all var(--transition-speed) ease;
        }

        .line {
            display: block;
            margin-bottom: 1rem;
            transition: transform var(--transition-speed) ease, opacity var(--transition-speed) ease;
        }

        .line.highlight {
            color: var(--accent-color);
            transform: scale(1.02);
            font-weight: bold;
        }

        .line.lowlight {
            color: rgba(230, 230, 230, 0.6);
            transform: scale(0.98);
        }

        .line.exit {
            opacity: 0;
            transform: translateY(20px);
            position: absolute;
        }

        .interactive-word {
            cursor: pointer;
            transition: color var(--transition-speed) ease;
            position: relative;
        }

        .interactive-word:hover {
            color: var(--accent-hover);
            text-shadow: 0 0 10px var(--accent-hover);
        }

        .interactive-word::after {
            content: "";
            position: absolute;
            bottom: -5px;
            left: 0;
            width: 0;
            height: 3px;
            background-color: var(--accent-color);
            transition: width var(--transition-speed) ease;
        }

        .interactive-word:hover::after {
            width: 100%;
        }

        .button {
            background-color: var(--accent-color);
            color: white;
            border: none;
            padding: 0.8rem 1.5rem;
            font-size: 1rem;
            border-radius: 25px;
            cursor: pointer;
            transition: all var(--transition-speed) ease;
            box-shadow: 0 4px 10px var(--shadow-color);
            margin: 1rem 0;
        }

        .button:hover {
            background-color: var(--accent-hover);
            transform: translateY(-3px);
            box-shadow: 0 6px 15px var(--shadow-color);
        }

        .button:active {
            transform: translateY(1px);
        }

        .button:focus {
            outline: none;
        }

        .particle {
            position: absolute;
            width: 10px;
            height: 10px;
            background-color: var(--accent-color);
            border-radius: 50%;
            pointer-events: none;
            opacity: 0;
            transition: opacity var(--transition-speed) ease, transform 2s ease;
        }

        .settings {
            margin-top: 2rem;
            display: flex;
            justify-content: center;
            gap: 1rem;
        }

        .slider-container {
            display: flex;
            flex-direction: column;
            gap: 0.5rem;
        }

        .slider-label {
            font-size: 0.9rem;
            color: rgba(230, 230, 230, 0.8);
        }

        input[type="range"] {
            -webkit-appearance: none;
            appearance: none;
            width: 150px;
            height: 5px;
            background: rgba(230, 230, 230, 0.2);
            border-radius: 5px;
            outline: none;
        }

        input[type="range"]::-webkit-slider-thumb {
            -webkit-appearance: none;
            appearance: none;
            width: 15px;
            height: 15px;
            border-radius: 50%;
            background: var(--accent-color);
            cursor: pointer;
            transition: background var(--transition-speed) ease;
        }

        input[type="range"]::-webkit-slider-thumb:hover {
            background: var(--accent-hover);
        }

        input[type="range"]::-moz-range-thumb {
            width: 15px;
            height: 15px;
            border-radius: 50%;
            background: var(--accent-color);
            cursor: pointer;
            transition: background var(--transition-speed) ease;
        }

        input[type="range"]::-moz-range-thumb:hover {
            background: var(--accent-hover);
        }

        .speed-display {
            font-size: 0.8rem;
            color: rgba(230, 230, 230, 0.7);
        }

        .particle-system {
            position: fixed;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            pointer-events: none;
            z-index: -1;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1 class="title">Transitions of the Forgotten</h1>
        <div class="poem-container">
            <div class="poem" id="poem">
                <div class="line">In the quiet of twilight's embrace,</div>
                <div class="line">Stories fade like echoes, half-told,</div>
                <div class="line">Words dance on the edge of silence,</div>
                <div class="line interactive-word" data-action="highlight">Whispered, lost, yet never forgotten.</div>
                <div class="line">I reach out, but my fingers find only</div>
                <div class="line">The cold breath of pages turned.</div>
            </div>
            <button class="button" id="revealButton">Reveal the Next Verse</button>
        </div>
        <div class="settings">
            <div class="slider-container">
                <label class="slider-label">Transition Speed</label>
                <input type="range" id="speedSlider" min="0.2" max="2" step="0.1" value="0.8">
                <div class="speed-display" id="speedValue">0.8s</div>
            </div>
        </div>
    </div>

    <div class="particle-system" id="particleSystem"></div>

    <script>
        // Particle System for Background Effects
        const particleSystem = document.getElementById('particleSystem');
        const speedSlider = document.getElementById('speedSlider');
        const speedValue = document.getElementById('speedValue');
        const revealButton = document.getElementById('revealButton');
        const poem = document.getElementById('poem');
        const title = document.querySelector('.title');

        // Update transition speed based on slider
        speedSlider.addEventListener('input', function() {
            const speed = this.value;
            speedValue.textContent = `${speed}s`;

            // Update CSS variable for transition speed
            document.documentElement.style.setProperty('--transition-speed', `${speed}s`);

            // Update particle animation duration
            const particles = particleSystem.querySelectorAll('.particle');
            particles.forEach(particle => {
                particle.style.transitionDuration = `${2 * speed}s`;
            });
        });

        // Create particle system
        function createParticleSystem() {
            for (let i = 0; i < 50; i++) {
                const particle = document.createElement('div');
                particle.className = 'particle';

                // Random position
                particle.style.left = `${Math.random() * 100}%`;
                particle.style.top = `${Math.random() * 100}%`;

                // Random size
                const size = Math.random() * 8 + 2;
                particle.style.width = `${size}px`;
                particle.style.height = `${size}px`;

                // Random opacity
                particle.style.opacity = Math.random() * 0.3 + 0.1;

                // Random delay
                particle.style.transitionDelay = `${Math.random() * 2 * parseFloat(document.documentElement.style.getPropertyValue('--transition-speed'))}s`;

                // Random animation
                particle.style.transform = `translate(-${Math.random() * 100}px, -${Math.random() * 100}px)`;

                particleSystem.appendChild(particle);
            }
        }

        createParticleSystem();

        // Interactive words
        const interactiveWords = document.querySelectorAll('.interactive-word');

        interactiveWords.forEach(word => {
            word.addEventListener('click', function(e) {
                e.preventDefault();
                e.stopPropagation();

                // Trigger word-specific action based on data-action
                const action = this.getAttribute('data-action');

                switch(action) {
                    case 'highlight':
                        highlightWord(this);
                        break;
                    case 'reveal':
                        revealNextLine();
                        break;
                }

                // Create ripple effect on click
                createRippleEffect(this);
            });
        });

        // Highlight word with animation
        function highlightWord(wordElement) {
            const lines = poem.querySelectorAll('.line');

            // Reset all lines
            lines.forEach(line => {
                line.classList.remove('highlight', 'lowlight');
            });

            // Highlight the clicked word's line
            const line = wordElement.parentElement;
            line.classList.add('highlight');

            // Add lowlight to other lines
            lines.forEach(l => {
                if (l !== line) {
                    l.classList.add('lowlight');
                }
            });
        }

        // Reveal next line with animation
        function revealNextLine() {
            const lines = poem.querySelectorAll('.line');
            const visibleLines = Array.from(lines).filter(line => !line.classList.contains('exit'));

            if (visibleLines.length < 4) {
                const newLine = document.createElement('div');
                newLine.className = 'line';

                const possibleLines = [
                    "The ink bleeds through time's seams,",
                    "A symphony of shadows, half-seen,",
                    "I trace the paths of forgotten dreams,",
                    "Their footprints dissolving like sugar in rain.",
                    "The library hums with stories untold,",
                    "Yet every shelf whispers of what was.",
                    "I press my ear to the spine of a book,",
                    "And hear the echoes of a thousand voices."
                ];

                newLine.textContent = possibleLines[Math.floor(Math.random() * possibleLines.length)];

                // Add interactive word randomly
                if (Math.random() > 0.5) {
                    const word = document.createElement('span');
                    word.className = 'interactive-word';
                    word.textContent = 'whispers';
                    word.setAttribute('data-action', 'reveal');
                    newLine.appendChild(word);
                }

                // Add to poem
                poem.appendChild(newLine);

                // Animate new line
                newLine.style.opacity = 0;
                newLine.style.transform = 'translateY(20px)';
                setTimeout(() => {
                    newLine.style.opacity = 1;
                    newLine.style.transform = 'translateY(0)';
                }, 10);
            } else {
                // If we have enough lines, fade out one and add a new one
                const exitLine = lines[0];
                exitLine.classList.add('exit');

                setTimeout(() => {
                    exitLine.remove();
                    revealNextLine();
                }, 500);
            }
        }

        // Ripple effect on click
        function createRippleEffect(element) {
            const ripple = document.createElement('span');
            ripple.className = 'ripple';

            // Position the ripple at the center of the clicked element
            const rect = element.getBoundingClientRect();
            const x = rect.left + rect.width / 2 - window.scrollX;
            const y = rect.top + rect.height / 2 - window.scrollY;

            ripple.style.left = `${x}px`;
            ripple.style.top = `${y}px`;

            // Add ripple to the body
            document.body.appendChild(ripple);

            // Animate ripple
            ripple.style.width = '0px';
            ripple.style.height = '0px';
            ripple.style.transform = 'scale(0)';

            setTimeout(() => {
                ripple.style.width = '200px';
                ripple.style.height = '200px';
                ripple.style.transform = 'scale(1)';
                ripple.style.opacity = '0';

                setTimeout(() => {
                    ripple.remove();
                }, 600);
            }, 10);
        }

        // Add ripple effect styles
        const style = document.createElement('style');
        style.textContent = `
            .ripple {
                position: fixed;
                border-radius: 50%;
                background-color: rgba(108, 92, 231, 0.3);
                pointer-events: none;
                z-index: 100;
                transform: translate(-50%, -50%);
                transition: transform 0.3s ease, opacity 0.3s ease;
            }
        `;
        document.head.appendChild(style);

        // Button to reveal next verse
        revealButton.addEventListener('click', function() {
            revealNextLine();

            // Add particle effect on button click
            const buttonRect = this.getBoundingClientRect();
            const x = buttonRect.left + buttonRect.width / 2 - window.scrollX;
            const y = buttonRect.top + buttonRect.height / 2 - window.scrollY;

            for (let i = 0; i < 20; i++) {
                const particle = document.createElement('div');
                particle.className = 'particle';

                particle.style.left = `${x}px`;
                particle.style.top = `${y}px`;

                const size = Math.random() * 10 + 5;
                particle.style.width = `${size}px`;
                particle.style.height = `${size}px`;

                particle.style.opacity = Math.random() * 0.5 + 0.2;

                // Random animation direction
                const angle = Math.random() * Math.PI * 2;
                const velocity = 2 + Math.random() * 3;
                particle.style.transform = `translate(${Math.cos(angle) * velocity * 20}px, ${Math.sin(angle) * velocity * 20}px)`;

                particleSystem.appendChild(particle);

                setTimeout(() => {
                    particle.remove();
                }, 2000);
            }
        });

        // Typewriter effect for title
        let titleIndex = 0;
        const titleText = "Transitions of the Forgotten";
        const typingSpeed = 100;

        function typeTitle() {
            if (titleIndex < titleText.length) {
                title.textContent += titleText.charAt(titleIndex);
                titleIndex++;
                setTimeout(typeTitle, typingSpeed);
            }
        }

        // Start typing effect after a delay
        setTimeout(typeTitle, 500);

        // Highlight first interactive word when poem is loaded
        setTimeout(() => {
            highlightWord(poem.querySelector('.interactive-word'));
        }, 2000);
    </script>
</body>
</html>

#!/usr/bin/env node
// ChunkSorter - Intelligent File Chunker & Organizer
// Recursively scans directories, chunks files by size ranges, and organizes them with visual progress tracking

import { readdir, rename, stat, mkdir, existsSync, rmSync } from 'node:fs/promises';
import { join, dirname, basename } from 'node:path';
import { program } from 'commander';
import { EOL } from 'node:os';

// Constants for size ranges (in bytes)
const SIZE_RANGES = {
  TINY: { max: 1024, color: 'green' },
  SMALL: { max: 1024 * 10, color: 'yellow' },
  MEDIUM: { max: 1024 * 100, color: 'blue' },
  LARGE: { max: 1024 * 1024, color: 'magenta' },
  HUGE: { color: 'cyan' }
};

// ANSI color codes for terminal output
const COLORS = {
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  blue: '\x1b[34m',
  magenta: '\x1b[35m',
  cyan: '\x1b[36m',
  reset: '\x1b[0m'
};

// Progress bar characters
const PROGRESS_BAR = {
  empty: '░',
  full: '▒',
  done: '▓'
};

// Configure command-line interface
program
  .name('ChunkSorter')
  .description('Intelligently organizes files by size ranges with visual progress')
  .version('1.0.0')
  .argument('[directory]', 'Directory to organize (default: current directory)')
  .option('-p, --preserve-original', 'Preserve original directory structure')
  .option('-d, --dry-run', 'Dry run - show what would be done without moving files')
  .option('-s, --size-ranges <ranges>', 'Custom size ranges (e.g., "1K,10M,100M")', parseSizeRanges)
  .option('-v, --verbose', 'Verbose output')
  .option('-c, --color <enable>', 'Enable/disable colors (auto, true, false)')
  .action(organizeFiles)
  .parse(process.argv);

// Helper to parse custom size ranges
function parseSizeRanges(value) {
  return value.split(',').map(range => {
    const num = parseInt(range);
    const unit = range.slice(-1).toUpperCase();

    if (!num || !unit || !['K', 'M', 'G', 'T'].includes(unit)) {
      throw new Error(`Invalid size range format: ${range}. Use format like "1K,10M,100M"`);
    }

    return num * Math.pow(1024, ['K', 'M', 'G', 'T'].indexOf(unit));
  });
}

// Main function to organize files
async function organizeFiles(directory = '.', options) {
  const {
    preserveOriginal,
    dryRun,
    sizeRanges: customRanges,
    verbose,
    color: colorOption
  } = options;

  // Validate directory
  if (!existsSync(directory)) {
    console.error(`Directory does not exist: ${directory}`);
    process.exit(1);
  }

  // Determine if we should use colors
  const useColors = colorOption === 'true' ||
    (colorOption !== 'false' && process.stdout.isTTY && process.env.TERM !== 'dumb');

  // Get the actual size ranges to use
  const ranges = customRanges
    ? customRanges.sort((a, b) => a - b).map((size, i) => ({
        max: i === customRanges.length - 1 ? Infinity : customRanges[i + 1],
        color: Object.keys(COLORS)[i + 1] || 'cyan'
      }))
    : Object.values(SIZE_RANGES);

  // Prepare progress tracking
  const progress = {
    total: 0,
    moved: 0,
    files: [],
    totalSize: 0
  };

  try {
    // Count total files and size for progress tracking
    await countFilesAndSize(directory, progress, ranges);

    // Show header with progress info
    showProgressHeader(progress, ranges, useColors);

    // Start organizing files
    const filesToProcess = await getFilesToProcess(directory, preserveOriginal);
    for (const filePath of filesToProcess) {
      await processFile(filePath, directory, ranges, progress, dryRun, preserveOriginal, verbose, useColors);
    }

    // Finalize progress
    showProgressFooter(progress, useColors);

    if (verbose) {
      console.log('\nOrganization complete!');
    }

  } catch (error) {
    console.error(`\nError during organization: ${error.message}`);
    process.exit(1);
  }
}

// Count files and total size for progress tracking
async function countFilesAndSize(directory, progress, ranges) {
  const files = await readdir(directory);

  for (const file of files) {
    const filePath = join(directory, file);
    const fileStat = await stat(filePath);

    if (fileStat.isDirectory()) {
      await countFilesAndSize(filePath, progress, ranges);
    } else if (fileStat.isFile()) {
      progress.total++;
      progress.totalSize += fileStat.size;
      progress.files.push(filePath);
    }
  }
}

// Get files to process (excluding special directories)
async function getFilesToProcess(directory, preserveOriginal) {
  const files = await readdir(directory);
  const specialDirs = ['.git', 'node_modules', '__MACOSX', 'dist'];

  return Promise.all(files.map(async (file) => {
    const filePath = join(directory, file);
    const fileStat = await stat(filePath);

    if (fileStat.isDirectory() && !specialDirs.includes(file)) {
      return [...(await getFilesToProcess(filePath, preserveOriginal))];
    } else if (fileStat.isFile()) {
      return filePath;
    }
    return [];
  })).then(results => results.flat());
}

// Process a single file
async function processFile(filePath, baseDir, ranges, progress, dryRun, preserveOriginal, verbose, useColors) {
  const fileStat = await stat(filePath);
  const dirName = dirname(filePath);
  const fileName = basename(filePath);
  const fileSize = fileStat.size;
  const color = useColors ? COLORS.reset : '';

  // Determine size category
  const category = ranges.find(range => fileSize <= (range.max || Infinity)) || ranges[ranges.length - 1];
  const sizeLabel = getSizeLabel(fileSize);

  // Calculate progress percentage
  const progressPercent = Math.floor((progress.moved / progress.total) * 100);

  // Update progress bar
  showProgressBar(progressPercent, progress, useColors);

  if (verbose) {
    console.log(`${color}${category.color ? COLORS[category.color] + '●' : ''} ${fileName.padEnd(30)} ${sizeLabel.padEnd(10)} ${color}${COLORS.reset}`);
  }

  // Skip if already in correct category
  if (preserveOriginal) {
    const currentDir = dirName.replace(baseDir, '');
    const expectedDir = ranges.find(r => fileSize <= (r.max || Infinity))?.color?.slice(0, 1) || 'x';

    if (!currentDir.startsWith(expectedDir) && currentDir !== '') {
      await createDirectoryStructure(dirName, ranges, preserveOriginal);
      const newPath = join(dirName, expectedDir, fileName);
      if (!dryRun) {
        await rename(filePath, newPath);
        progress.moved++;
      }
    }
  } else {
    // Create directory structure if needed
    await createDirectoryStructure(dirName, ranges, preserveOriginal);

    // Calculate target directory
    const targetDir = ranges.find(r => fileSize <= (r.max || Infinity))?.color?.slice(0, 1) || 'x';
    const newPath = join(baseDir, targetDir, fileName);

    if (!dryRun) {
      await rename(filePath, newPath);
      progress.moved++;
    }
  }
}

// Create directory structure if needed
async function createDirectoryStructure(filePath, ranges, preserveOriginal) {
  const dirName = dirname(filePath);
  const baseDir = preserveOriginal ? dirname(filePath) : dirname(dirname(filePath));

  // For preserved original structure, we need to create category directories
  if (preserveOriginal) {
    const relativePath = dirName.replace(baseDir, '');
    const parts = relativePath.split(join(...));

    for (let i = 0; i < parts.length; i++) {
      const part = parts[i];
      const currentDir = join(baseDir, ...parts.slice(0, i + 1));
      const targetDir = ranges.find(r => part.startsWith(r.color?.slice(0, 1)))?.color?.slice(0, 1) || part;

      try {
        await mkdir(currentDir, { recursive: true });
      } catch (err) {
        if (err.code !== 'EEXIST') throw err;
      }
    }
  }
}

// Format file size for display
function getSizeLabel(size) {
  if (size < 1024) return `${size} B`;
  if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)} KB`;
  if (size < 1024 * 1024 * 1024) return `${(size / (1024 * 1024)).toFixed(1)} MB`;
  return `${(size / (1024 * 1024 * 1024)).toFixed(1)} GB`;
}

// Show progress header
function showProgressHeader(progress, ranges, useColors) {
  const header = useColors ? `${COLORS.blue}📁 ChunkSorter${COLORS.reset} - Intelligent File Organization${EOL}`;
  const rangesInfo = ranges.map(r =>
    useColors ? `${COLORS[r.color]}${r.max === Infinity ? '❄️' : `${(r.max / (1024 * 1024)).toFixed(1)}MB`}${COLORS.reset}` : ` ${r.max === Infinity ? '❄️' : `${(r.max / (1024 * 1024)).toFixed(1)}MB`}`
  ).join(' | ');

  console.log(header);
  console.log(`Target: ${progress.total} files (${formatSize(progress.totalSize)})`);
  console.log(`Ranges: ${rangesInfo}${EOL}`);
  console.log(`Progress: `);
}

// Show progress bar
function showProgressBar(percent, progress, useColors) {
  const width = 40;
  const filled = Math.floor(width * percent / 100);
  const empty = width - filled;

  const bar = [
    PROGRESS_BAR.done.repeat(filled),
    PROGRESS_BAR.full.repeat(Math.min(5, empty - 5)),
    PROGRESS_BAR.empty.repeat(Math.max(0, empty - 5))
  ].join('');

  const status = useColors ? `${COLORS.blue}${bar} ${percent}%${COLORS.reset}` : `${bar} ${percent}%`;

  process.stdout.write(`\r${status}  ${progress.moved}/${progress.total} files moved`);
  if (percent === 100) {
    process.stdout.write('\n');
  }
}

// Show progress footer
function showProgressFooter(progress, useColors) {
  const totalSize = formatSize(progress.totalSize);
  const movedSize = formatSize(progress.moved * (progress.totalSize / progress.total));

  const summary = useColors ?
    `${COLORS.green}✅ Organization Complete!${COLORS.reset}\n` +
    `   Files: ${progress.moved}/${progress.total} (${Math.floor((progress.moved / progress.total) * 100)}%)\n` +
    `   Size: ${movedSize}/${totalSize}` :
    `Organization Complete!\n` +
    `  Files: ${progress.moved}/${progress.total} (${Math.floor((progress.moved / progress.total) * 100)}%)\n` +
    `  Size: ${movedSize}/${totalSize}`;

  console.log(summary);
}

// Format size for display
function formatSize(bytes) {
  if (bytes < 1024) return `${bytes} B`;
  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
}

import SwiftUI
import WidgetKit
import CoreLocation

// MARK: - Weather Whimsy Widget Entry
struct WeatherWhimsyWidget: Widget {
    let kind: String = "WeatherWhimsyWidget"

    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            WeatherWhimsyView(entry: entry)
        }
        .configurationDisplayName("Weather Whimsy")
        .description("A playful take on weather with animated skeletons, clouds, and dynamic colors.")
        .supportedFamilies([.systemSmall, .systemMedium])
    }
}

// MARK: - Weather Data Provider
struct Provider: AppIntent {
    static var defaultProvider = Provider()

    func placeמודels: [WeatherData] = [] {
        // This would be populated with real data in a real app
        // For demo, we use mock data that changes based on time
        let currentHour = Calendar.current.component(.hour, from: Date())
        let isDaytime = currentHour >= 6 && currentHour < 18

        return [
            WeatherData(
                condition: isDaytime ? .sunny : .clear,
                temperature: Int.random(in: 15...30),
                humidity: Int.random(in: 30...80),
                windSpeed: Double.random(in: 1...10),
                timestamp: Date()
            )
        ]
    }
}

// MARK: - Weather Conditions Enum
enum WeatherCondition: String, CaseIterable, Codable {
    case sunny = "☀️"
    case clear = "🌙"
    case cloudy = "☁️"
    case rain = "🌧️"
    case snow = "❄️"

    var color: Color {
        switch self {
        case .sunny: return .yellow
        case .clear: return .blue
        case .cloudy: return .gray
        case .rain: return .blue.opacity(0.7)
        case .snow: return .white.opacity(0.8)
        }
    }

    var skeletonColor: Color {
        switch self {
        case .sunny: return .yellow.opacity(0.8)
        case .clear: return .blue.opacity(0.8)
        case .cloudy: return .gray.opacity(0.8)
        case .rain: return .blue.opacity(0.9)
        case .snow: return .white.opacity(0.9)
        }
    }
}

// MARK: - Weather Data Model
struct WeatherData: Codable, Hashable {
    let condition: WeatherCondition
    let temperature: Int
    let humidity: Int
    let windSpeed: Double
    let timestamp: Date

    var displayTemperature: String {
        "\(temperature)°"
    }

    var humidityPercentage: String {
        "\(humidity)%"
    }

    var windSpeedDisplay: String {
        "\(String(format: "%.1f", windSpeed)) m/s"
    }
}

// MARK: - Animated Weather View
struct WeatherWhimsyView: View {
    let entry: Provider.Entry

    @State private var isAnimating: Bool = false

    var body: some View {
        VStack(spacing: 8) {
            // Animated Skeleton
            SkeletonView(condition: entry.weatherData.condition)
                .frame(height: 80)
                .onAppear {
                    withAnimation(.easeInOut(duration: 2).repeatForever(autoreverses: false)) {
                        isAnimating = true
                    }
                }

            // Weather Stats
            VStack(spacing: 4) {
                Text(entry.weatherData.condition.rawValue)
                    .font(.headline)
                    .padding(.bottom, 2)

                HStack(spacing: 8) {
                    VStack(alignment: .leading, spacing: 2) {
                        Text("Temp")
                        Text(entry.weatherData.displayTemperature)
                            .font(.subheadline)
                    }

                    Spacer()

                    VStack(alignment: .leading, spacing: 2) {
                        Text("Wind")
                        Text(entry.weatherData.windSpeedDisplay)
                            .font(.subheadline)
                    }
                }
            }
            .frame(maxWidth: .infinity)

            // Humidity with subtle animation
            Text("Humidity: \(entry.weatherData.humidityPercentage)")
                .font(.caption)
                .offset(y: isAnimating ? 5 : 0)
        }
        .containerBackground(.fill.tertiary, for: .widget)
        .widgetURL(URL(string: "weather-whimsy://"))
    }
}

// MARK: - Skeleton View with Bone Animation
struct SkeletonView: View {
    let condition: WeatherCondition

    var body: some View {
        ZStack {
            // Base body
            RoundedRectangle(cornerRadius: 8)
                .fill(condition.color)
                .frame(width: 60, height: 60)
                .shadow(radius: 3)

            // Skeleton bones (animated)
            HStack(spacing: 4) {
                Rectangle()
                    .fill(condition.skeletonColor)
                    .frame(width: 4, height: 40)
                    .offset(y: -10)

                Rectangle()
                    .fill(condition.skeletonColor)
                    .frame(width: 4, height: 50)
                    .offset(y: -15)

                Rectangle()
                    .fill(condition.skeletonColor)
                    .frame(width: 4, height: 35)
                    .offset(y: -5)
            }
            .offset(x: -15)

            // Arm bones (animated)
            VStack(spacing: 0) {
                Rectangle()
                    .fill(condition.skeletonColor)
                    .frame(width: 20, height: 2)
                    .offset(x: -30, y: -30)

                Rectangle()
                    .fill(condition.skeletonColor)
                    .frame(width: 20, height: 2)
                    .offset(x: 15, y: -30)
            }
        }
    }
}

// MARK: - Preview Provider
struct WeatherWhimsyWidget_Previews: PreviewProvider {
    static var previews: some View {
        WeatherWhimsyWidget()
            .previewContext(Provider.Entry(
                weatherData: WeatherData(
                    condition: .sunny,
                    temperature: 22,
                    humidity: 65,
                    windSpeed: 3.2,
                    timestamp: Date()
                )
            ))
    }
}