A!leys Galerie

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()
                )
            ))
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Celestial Particle Playground</title>
    <style>
        :root {
            --bg-gradient: radial-gradient(circle at center, #0a0e23 0%, #1a103d 100%);
            --particle-size: 4px;
            --particle-opacity: 0.7;
            --particle-color: hsl(220, 100%, 50%);
            --particle-trail-length: 20;
        }

        body {
            margin: 0;
            overflow: hidden;
            background: var(--bg-gradient);
            height: 100vh;
            font-family: 'Courier New', monospace;
        }

        canvas {
            display: block;
        }

        #controls {
            position: absolute;
            top: 10px;
            left: 10px;
            background: rgba(0, 0, 0, 0.5);
            padding: 10px;
            border-radius: 5px;
            color: white;
            font-size: 12px;
        }

        #controls button {
            margin: 5px;
            padding: 3px 8px;
            background: #2a2a3e;
            border: 1px solid #4a4a65;
            border-radius: 3px;
            cursor: pointer;
        }

        #controls button:active {
            background: #1a1a2e;
        }

        #instructions {
            position: absolute;
            bottom: 10px;
            left: 10px;
            background: rgba(0, 0, 0, 0.5);
            padding: 10px;
            border-radius: 5px;
            color: white;
            font-size: 12px;
            max-width: 200px;
            line-height: 1.3;
        }
    </style>
</head>
<body>
    <canvas id="canvas"></canvas>
    <div id="controls">
        <button id="clearBtn">Clear Particles</button>
        <button id="colorBtn">Randomize Colors</button>
        <button id="gravityBtn">Toggle Gravity</button>
    </div>
    <div id="instructions">
        Move your mouse to create star trails!<br>
        Hold shift for slower particles.<br>
        Right-click to freeze particles.
    </div>

    <script>
        document.addEventListener('DOMContentLoaded', () => {
            const canvas = document.getElementById('canvas');
            const ctx = canvas.getContext('2d');
            const clearBtn = document.getElementById('clearBtn');
            const colorBtn = document.getElementById('colorBtn');
            const gravityBtn = document.getElementById('gravityBtn');
            const instructions = document.getElementById('instructions');

            // Set canvas to full window size
            canvas.width = window.innerWidth;
            canvas.height = window.innerHeight;

            // State variables
            let particles = [];
            let mouse = { x: 0, y: 0, speed: 0, isShiftDown: false, isRightClick: false };
            let gravityEnabled = true;
            let colorHue = 220;
            let frozenParticles = [];

            // Particle class
            class Particle {
                constructor(x, y, velocityX, velocityY) {
                    this.x = x;
                    this.y = y;
                    this.velocityX = velocityX;
                    this.velocityY = velocityY;
                    this.size = Math.random() * 3 + 1;
                    this.life = 100 + Math.random() * 50;
                    this.maxLife = this.life;
                    this.color = this.getRandomColor();
                    this.opacity = 0.5 + Math.random() * 0.3;
                    this.trail = [];
                    this.frozen = false;
                    this.gravityStrength = 0.1 + Math.random() * 0.1;
                }

                getRandomColor() {
                    return `hsl(${colorHue}, 100%, 50%)`;
                }

                update() {
                    if (this.frozen) return;

                    // Apply gravity
                    if (gravityEnabled) {
                        this.velocityY += this.gravityStrength;
                    }

                    // Update position
                    this.x += this.velocityX;
                    this.y += this.velocityY;

                    // Add to trail
                    this.trail.push({ x: this.x, y: this.y, opacity: this.opacity });
                    if (this.trail.length > 20) this.trail.shift();

                    // Decrease life
                    this.life--;
                    this.opacity = this.life / this.maxLife * 0.5 + 0.2;
                }

                draw() {
                    // Draw trail
                    if (this.trail.length > 1) {
                        ctx.beginPath();
                        for (let i = 0; i < this.trail.length; i++) {
                            const p = this.trail[i];
                            if (i === 0) {
                                ctx.moveTo(p.x, p.y);
                            } else {
                                ctx.lineTo(p.x, p.y);
                            }
                            ctx.globalAlpha = p.opacity * (1 - i / this.trail.length);
                            ctx.strokeStyle = this.color;
                            ctx.lineWidth = this.size;
                            ctx.stroke();
                        }
                        ctx.globalAlpha = 1;
                    }

                    // Draw main particle
                    ctx.beginPath();
                    ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2);
                    ctx.fillStyle = this.color;
                    ctx.fill();
                }
            }

            // Create new particles
            function createParticles(x, y, velocityX, velocityY, count = 50) {
                for (let i = 0; i < count; i++) {
                    const angle = Math.random() * Math.PI * 2;
                    const speed = 0.5 + mouse.isShiftDown ? 0.1 : 1.0;
                    const velocity = {
                        x: Math.cos(angle) * speed,
                        y: Math.sin(angle) * speed
                    };
                    particles.push(new Particle(x, y, velocityX || velocity.x, velocityY || velocity.y));
                }
            }

            // Update all particles
            function updateParticles() {
                particles.forEach(p => p.update());
                frozenParticles.forEach(p => p.update());
            }

            // Draw all particles
            function drawParticles() {
                // Sort by life (longer living particles first)
                const sortedParticles = [...particles, ...frozenParticles].sort((a, b) => b.life - a.life);

                sortedParticles.forEach(p => {
                    // Save current alpha
                    ctx.save();
                    ctx.globalAlpha = p.opacity;

                    // Draw particle
                    p.draw();

                    // Restore alpha
                    ctx.restore();
                });
            }

            // Handle mouse movement
            function handleMouseMove(e) {
                mouse.x = e.clientX;
                mouse.y = e.clientY;
                mouse.speed = Math.sqrt((e.movementX || 0) ** 2 + (e.movementY || 0) ** 2);
                mouse.isShiftDown = e.shiftKey;
                mouse.isRightClick = e.buttons === 2; // Right click (button 2 is usually middle, but this works for right click on most systems)
            }

            // Handle mouse down
            function handleMouseDown(e) {
                if (e.buttons === 1) { // Left click
                    if (!mouse.isRightClick) {
                        createParticles(mouse.x, mouse.y, 0, 0, 20);
                    }
                }
            }

            // Main animation loop
            function animate() {
                // Clear canvas with radial gradient
                const gradient = ctx.createRadialGradient(
                    canvas.width / 2, canvas.height / 2, 0,
                    canvas.width / 2, canvas.height / 2, canvas.height / 2
                );
                gradient.addColorStop(0, 'rgba(10, 14, 35, 0.8)');
                gradient.addColorStop(1, 'rgba(26, 16, 61, 0.9)');
                ctx.fillStyle = gradient;
                ctx.fillRect(0, 0, canvas.width, canvas.height);

                // Update and draw particles
                updateParticles();
                drawParticles();

                // Continue animation
                requestAnimationFrame(animate);
            }

            // Initialize
            function init() {
                // Set canvas size on window resize
                window.addEventListener('resize', () => {
                    canvas.width = window.innerWidth;
                    canvas.height = window.innerHeight;
                });

                // Event listeners
                canvas.addEventListener('mousemove', handleMouseMove);
                canvas.addEventListener('mousedown', handleMouseDown);
                document.addEventListener('keydown', (e) => {
                    if (e.key === 'Shift') mouse.isShiftDown = true;
                });
                document.addEventListener('keyup', (e) => {
                    if (e.key === 'Shift') mouse.isShiftDown = false;
                });

                // Button event listeners
                clearBtn.addEventListener('click', () => {
                    particles = [];
                    frozenParticles = [];
                });

                colorBtn.addEventListener('click', () => {
                    colorHue = Math.floor(Math.random() * 60) + 160; // Warm colors
                    particles.forEach(p => p.color = p.getRandomColor());
                    frozenParticles.forEach(p => p.color = p.getRandomColor());
                });

                gravityBtn.addEventListener('click', () => {
                    gravityEnabled = !gravityEnabled;
                    gravityBtn.textContent = gravityEnabled ? 'Gravity ON' : 'Gravity OFF';
                });

                // Start animation
                animate();
            }

            init();
        });
    </script>
</body>
</html>

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.fadeIn
import androidx.compose.animation.fadeOut
import androidx.compose.animation.slideInVertically
import androidx.compose.animation.slideOutVertically
import androidx.compose.foundation.CircularProgressIndicator
import androidx.compose.foundation backgrounds
import androidx.compose.foundation border
import androidx.compose.foundation.clickable
import androidx.compose.foundation.gestures.detectTapGesture
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Star
import androidx.compose.material.icons.filled.StarBorder
import androidx.compose.material3.Badge
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CircularButton
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Surface
import androidx.compose.material3.Switch
import androidx.compose.material3.SwitchDefaults
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.shadow
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics drew
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import com.google.accompanist.navigation.material.ModifierLocalProvider
import kotlinx.coroutines.delay
import java.util.UUID
import kotlin.random.Random

// Data Model
data class TodoItem(
    val id: String,
    var title: String,
    var completed: Boolean,
    var isStarred: Boolean,
    var progress: Float = 0f,
    val createdAt: Long = System.currentTimeMillis()
)

@Composable
fun CosmicTodoApp() {
    val todos = remember { mutableStateOf(mutableListOf<TodoItem>()) }
    val textFieldValue = remember { mutableStateOf("") }
    val isLoading = remember { mutableStateOf(false) }
    val spaceTheme = remember { mutableStateOf(SpaceTheme.NEON) }

    Surface(
        modifier = Modifier.fillMaxSize(),
        color = MaterialTheme.colorScheme.background,
    ) {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .padding(16.dp)
        ) {
            SpaceThemeSelector(
                theme = spaceTheme.value,
                onThemeChange = { spaceTheme.value = it }
            )
            Spacer(modifier = Modifier.height(16.dp))

            TodoHeader(
                addTodo = { title ->
                    todos.value.add(
                        TodoItem(
                            id = UUID.randomUUID().toString(),
                            title = title,
                            completed = false,
                            isStarred = false
                        )
                    )
                },
                clearCompleted = { todos.value.removeAll { it.completed } },
                toggleAll = { completed ->
                    todos.value.forEach { it.completed = completed }
                }
            )

            TodoList(
                todos = todos.value,
                onToggle = { todo ->
                    todos.value = todos.value.map {
                        if (it.id == todo.id) it.copy(completed = !it.completed) else it
                    }
                },
                onStar = { todoId ->
                    todos.value = todos.value.map {
                        if (it.id == todoId) it.copy(isStarred = !it.isStarred) else it
                    }
                },
                onDelete = { todoId ->
                    todos.value = todos.value.filter { it.id != todoId }
                },
                onProgressUpdate = { todoId, progress ->
                    todos.value = todos.value.map {
                        if (it.id == todoId) it.copy(progress = progress) else it
                    }
                }
            )

            SpaceBackground()
        }
    }
}

@Composable
fun SpaceThemeSelector(
    theme: SpaceTheme,
    onThemeChange: (SpaceTheme) -> Unit
) {
    Row(
        modifier = Modifier.fillMaxWidth(),
        horizontalArrangement = Arrangement.Center,
        verticalAlignment = Alignment.CenterVertically
    ) {
        Text(
            text = "Space Theme:",
            style = MaterialTheme.typography.titleMedium,
            color = MaterialTheme.colorScheme.onBackground
        )
        Spacer(modifier = Modifier.size(8.dp))
        Button(
            onClick = { onThemeChange(theme.next()) },
            shape = CircleShape,
            colors = ButtonDefaults.buttonColors(
                containerColor = when (theme) {
                    SpaceTheme.NEON -> Color(0xFF00FF00)
                    SpaceTheme.SYNTHWAVE -> Color(0xFF00FFFF)
                    SpaceTheme.DARK -> Color(0xFF1A1A2E)
                }
            )
        ) {
            Icon(
                imageVector = Icons.Default.Star,
                contentDescription = "Change theme"
            )
        }
    }
}

@Composable
fun TodoHeader(
    addTodo: (String) -> Unit,
    clearCompleted: () -> Unit,
    toggleAll: (Boolean) -> Unit
) {
    Column(
        modifier = Modifier.fillMaxWidth(),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Row(
            modifier = Modifier
                .fillMaxWidth()
                .padding(vertical = 8.dp),
            verticalAlignment = Alignment.CenterVertically
        ) {
            Switch(
                checked = { allCompleted() },
                onCheckedChange = toggleAll,
                modifier = Modifier
                    .size(24.dp)
                    .clip(CircleShape)
                    .border(
                        width = 1.dp,
                        color = MaterialTheme.colorScheme.outline,
                        shape = CircleShape
                    )
            )
            Text(
                text = "All",
                style = MaterialTheme.typography.bodyMedium,
                modifier = Modifier.padding(start = 4.dp)
            )
            Spacer(modifier = Modifier.weight(1f))
            TextButton(onClick = clearCompleted) {
                Text(
                    text = "Clear completed",
                    color = MaterialTheme.colorScheme.error
                )
            }
        }

        var showInput by remember { mutableStateOf(false) }
        AnimatedVisibility(
            visible = showInput,
            enter = fadeIn() + slideInVertically(),
            exit = fadeOut() + slideOutVertically()
        ) {
            OutlinedTextField(
                value = "",
                onValueChange = { newValue ->
                    if (newValue.isNotEmpty()) {
                        addTodo(newValue)
                        showInput = false
                    }
                },
                modifier = Modifier
                    .fillMaxWidth()
                    .shadow(8.dp, shape = RoundedCornerShape(12.dp)),
                shape = RoundedCornerShape(12.dp),
                leadingIcon = {
                    Icon(
                        imageVector = Icons.Default.Add,
                        contentDescription = "Add"
                    )
                },
                placeholder = { Text("What needs to be done?") },
                singleLine = true,
                textStyle = MaterialTheme.typography.titleMedium
            )
        }

        TextButton(
            onClick = { showInput = true },
            modifier = Modifier
                .fillMaxWidth()
                .clip(RoundedCornerShape(12.dp))
                .background(
                    brush = Brush.verticalGradient(
                        colors = listOf(
                            MaterialTheme.colorScheme.primary,
                            MaterialTheme.colorScheme.secondary
                        )
                    )
                )
                .padding(12.dp)
        ) {
            Text(
                text = "Add new task",
                color = MaterialTheme.colorScheme.onPrimary
            )
        }
    }
}

@Composable
fun TodoList(
    todos: List<TodoItem>,
    onToggle: (TodoItem) -> Unit,
    onStar: (String) -> Unit,
    onDelete: (String) -> Unit,
    onProgressUpdate: (String, Float) -> Unit
) {
    val listState = rememberLazyListState()
    val context = LocalContext.current

    LazyColumn(
        state = listState,
        modifier = Modifier.fillMaxSize()
    ) {
        itemsIndexed(todos) { index, todo ->
            TodoItemCard(
                todo = todo,
                onToggle = onToggle,
                onStar = { onStar(todo.id) },
                onDelete = { onDelete(todo.id) },
                onProgressUpdate = { onProgressUpdate(todo.id, it) },
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(vertical = 4.dp)
            )

            // Add subtle space animation between items
            LaunchedEffect(index) {
                delay((index * 100).toLong())
                listState.scrollToItem(index)
            }
        }

        item {
            SpaceLoadingIndicator()
        }
    }
}

@Composable
fun TodoItemCard(
    todo: TodoItem,
    onToggle: (TodoItem) -> Unit,
    onStar: () -> Unit,
    onDelete: () -> Unit,
    onProgressUpdate: (Float) -> Unit,
    modifier: Modifier = Modifier
) {
    val progress = remember { mutableStateOf(todo.progress) }
    val isChecked = remember { mutableStateOf(todo.completed) }

    Card(
        modifier = modifier
            .fillMaxWidth()
            .shadow(4.dp, shape = RoundedCornerShape(12.dp)),
        shape = RoundedCornerShape(12.dp)
    ) {
        Row(
            modifier = Modifier
                .fillMaxWidth()
                .padding(16.dp)
                .pointerInput(Unit) {
                    detectTapGesture { onToggle(todo) }
                },
            verticalAlignment = Alignment.CenterVertically
        ) {
            // Checkbox with space theme
            Box(
                modifier = Modifier
                    .size(24.dp)
                    .clip(CircleShape)
                    .background(
                        color = if (isChecked.value) {
                            MaterialTheme.colorScheme.primary
                        } else {
                            MaterialTheme.colorScheme.surfaceVariant
                        }
                    )
            ) {
                AnimatedVisibility(
                    visible = isChecked.value,
                    enter = fadeIn() + slideInVertically(),
                    exit = fadeOut() + slideOutVertically()
                ) {
                    Icon(
                        imageVector = Icons.Default.Star,
                        contentDescription = "Completed",
                        tint = MaterialTheme.colorScheme.onPrimary,
                        modifier = Modifier.size(16.dp)
                    )
                }
            }

            Spacer(modifier = Modifier.size(8.dp))

            Column(
                modifier = Modifier
                    .weight(1f)
                    .padding(vertical = 8.dp)
            ) {
                Text(
                    text = todo.title,
                    style = MaterialTheme.typography.bodyLarge,
                    color = if (isChecked.value) {
                        MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
                    } else {
                        MaterialTheme.colorScheme.onSurface
                    },
                    fontWeight = if (todo.isStarred) FontWeight.Bold else FontWeight.Normal
                )

                // Progress indicator with space theme
                LinearProgressIndicator(
                    progress = { progress.value },
                    modifier = Modifier
                        .fillMaxWidth()
                        .height(4.dp)
                        .clip(RoundedCornerShape(2.dp)),
                    color = when (SpaceTheme.getCurrentTheme()) {
                        SpaceTheme.NEON -> Color(0xFF00FF00)
                        SpaceTheme.SYNTHWAVE -> Color(0xFF00FFFF)
                        SpaceTheme.DARK -> Color(0xFF4CC9F0)
                    }
                )

                // Star button with animated effect
                IconButton(
                    onClick = onStar,
                    modifier = Modifier.align(Alignment.End)
                ) {
                    AnimatedVisibility(
                        visible = todo.isStarred,
                        enter = fadeIn() + slideInVertically(),
                        exit = fadeOut() + slideOutVertically()
                    ) {
                        Icon(
                            imageVector = Icons.Default.Star,
                            contentDescription = "Star",
                            tint = if (isChecked.value) {
                                MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
                            } else {
                                MaterialTheme.colorScheme.primary
                            }
                        )
                    }
                }
            }

            // Delete button with space theme
            IconButton(
                onClick = onDelete,
                modifier = Modifier.align(Alignment.End)
            ) {
                Icon(
                    imageVector = Icons.Default.StarBorder,
                    contentDescription = "Delete",
                    tint = MaterialTheme.colorScheme.error
                )
            }

            // Progress picker
            Box(
                modifier = Modifier
                    .align(Alignment.End)
                    .size(24.dp)
                    .clip(CircleShape)
                    .border(
                        width = 1.dp,
                        color = MaterialTheme.colorScheme.outline,
                        shape = CircleShape
                    )
            ) {
                Text(
                    text = "${progress.value.toInt()}%",
                    modifier = Modifier.align(Alignment.Center),
                    style = MaterialTheme.typography.bodySmall
                )
            }
        }
    }
}

@Composable
fun SpaceLoadingIndicator() {
    Box(
        modifier = Modifier
            .fillMaxWidth()
            .height(60.dp),
        contentAlignment = Alignment.Center
    ) {
        CircularProgressIndicator(
            progress = { 0.5f },
            modifier = Modifier.size(24.dp),
            color = MaterialTheme.colorScheme.primary
        )
        Spacer(modifier = Modifier.size(8.dp))
        Text(
            text = "Waiting for cosmic signals...",
            style = MaterialTheme.typography.bodyMedium,
            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
        )
    }
}

@Composable
fun SpaceBackground() {
    Box(
        modifier = Modifier
            .fillMaxSize()
            .align(Alignment.BottomCenter)
    ) {
        when (SpaceTheme.getCurrentTheme()) {
            SpaceTheme.NEON -> {
                Box(
                    modifier = Modifier
                        .fillMaxSize()
                        .background(
                            Brush.verticalGradient(
                                colors = listOf(
                                    Color(0xFF1A1A2E),
                                    Color(0xFF000000)
                                )
                            )
                        )
                )
            }
            SpaceTheme.SYNTHWAVE -> {
                Box(
                    modifier = Modifier
                        .fillMaxSize()
                        .background(
                            Brush.verticalGradient(
                                colors = listOf(
                                    Color(0xFF0000FF),
                                    Color(0xFF000000)
                                )
                            )
                        )
                )
            }
            SpaceTheme.DARK -> {
                Box(
                    modifier = Modifier
                        .fillMaxSize()
                        .background(Color(0xFF0A0A1A))
                )
            }
        }

        // Add some space particles
        Box(
            modifier = Modifier
                .fillMaxSize()
                .background(
                    Brush.radialGradient(
                        colors = listOf(
                            Color.Transparent,
                            Color.Black.copy(alpha = 0.1f)
                        ),
                        center = Alignment.Center,
                        radius = 1f
                    )
                )
        )
    }
}

enum class SpaceTheme {
    NEON, SYNTHWAVE, DARK;

    fun next(): SpaceTheme {
        return when (this) {
            NEON -> SYNTHWAVE
            SYNTHWAVE -> DARK
            DARK -> NEON
        }
    }

    companion object {
        fun getCurrentTheme(): SpaceTheme {
            // In a real app, this would come from settings or state
            return NEON
        }
    }
}

@Preview(showBackground = true)
@Composable
fun CosmicTodoPreview() {
    val todos = remember {
        mutableListOf(
            TodoItem(
                id = "1",
                title = "Complete the Milky Way project",
                completed = false,
                isStarred = true
            ),
            TodoItem(
                id = "2",
                title = "Explore Andromeda galaxy",
                completed = false,
                isStarred = false
            ),
            TodoItem(
                id = "3",
                title = "Fix the warp drive",
                completed = true,
                isStarred = true
            ),
            TodoItem(
                id = "4",
                title = "Research quantum teleportation",
                completed = false,
                isStarred = false
            )
        )
    }

    CosmicTodoApp()
}

fun main() {
    // This is just a placeholder - the real app would be launched from the Android manifest
    // In a real Android app, you would have:
    // class MainActivity : ComponentActivity() {
    //     override fun onCreate(savedInstanceState: Bundle?) {
    //         super.onCreate(savedInstanceState)
    //         setContent { CosmicTodoApp() }
    //     }
    // }
}