A!leys Galerie

// DynamicBattleEnhancer.js
// A creative plugin for RPG Maker MZ that adds dynamic battle effects when imported as a Node.js script for development.

// This script simulates the behavior of a battle system plugin for RPG Maker MZ.
// It's designed to be run with Node.js to test and develop the plugin's logic.

// ============================================================================
// Plugin Manager Structure Simulation
// ============================================================================
const $plugins = [];
let $gameMap = { displayName: "Battle Map", tileset: {}, events: [] };
let $gameTroop = { members: [], _initMembers: () => {}, _startAction: () => {} };
let $gameParty = { actors: () => [], actor: () => ({}), _onBattleStart: () => {} };
let $gameVariables = new Map();
let $gameSelfSwitches = new Map();

// ============================================================================
// Core Battle Enhancer Logic
// ============================================================================
class DynamicBattleEnhancer {
    constructor() {
        this.weatherEffects = [
            { name: "Rain", intensity: 0.5, duration: 120, effect: this._handleRain },
            { name: "Thunder", intensity: 0.3, duration: 60, effect: this._handleThunder },
            { name: "Fog", intensity: 0.7, duration: 180, effect: this._handleFog },
            { name: "Sandstorm", intensity: 0.4, duration: 90, effect: this._handleSandstorm }
        ];

        this.terrainEffects = {
            'water': { effect: this._handleWater, priority: 2 },
            'lava': { effect: this._handleLava, priority: 3 },
            'mud': { effect: this._handleMud, priority: 1 },
            'grass': { effect: this._handleGrass, priority: 0 }
        };

        this.enemyBehaviors = {
            'aggressive': this._aggressiveBehavior,
            'defensive': this._defensiveBehavior,
            'passive': this._passiveBehavior,
            'opportunistic': this._opportunisticBehavior
        };

        this.activeWeather = null;
        this.activeTerrain = null;
        this.battleTurn = 0;
    }

    // Initialize the plugin
    init() {
        this._setupBattleEvents();
        this._simulateBattle();
    }

    // Set up battle events
    _setupBattleEvents() {
        $gameTroop._startAction = () => {
            this._startBattle();
        };
    }

    // Start battle simulation
    _startBattle() {
        console.log("\n=== BATTLE STARTED ===");
        this._setRandomWeather();
        this._setRandomTerrain();
        this._assignBehaviorsToEnemies();
        this.battleTurn = 0;
    }

    // Simulate battle turns
    _simulateBattle() {
        const interval = setInterval(() => {
            this.battleTurn++;
            console.log(`\n--- TURN ${this.battleTurn} ---`);

            // Apply weather and terrain effects
            if (this.activeWeather) {
                this.activeWeather.effect();
            }

            if (this.activeTerrain) {
                this.activeTerrain.effect();
            }

            // Simulate enemy actions
            $gameTroop.members.forEach(enemy => {
                if (enemy._behavior) {
                    enemy._behavior();
                }
            });

            // Check if battle should end
            if (this.battleTurn >= 10 || $gameParty.actors().length === 0) {
                clearInterval(interval);
                console.log("\n=== BATTLE ENDED ===");
            }
        }, 1000);
    }

    // Weather effect handlers
    _handleRain() {
        console.log("Rain is falling. Accuracy is reduced slightly.");
        // Simulate accuracy reduction
        this._applyStatusEffect("AccuracyDown", 0.9);
    }

    _handleThunder() {
        console.log("Thunder strikes! Chance of instant damage to enemies.");
        // 30% chance to strike a random enemy
        if (Math.random() < 0.3) {
            const randomEnemy = $gameTroop.members[Math.floor(Math.random() * $gameTroop.members.length)];
            console.log(`Thunder struck ${randomEnemy._name}! (${randomEnemy._hp} HP damage)`);
            randomEnemy._hp = Math.max(0, randomEnemy._hp - 20);
        }
    }

    _handleFog() {
        console.log("Thick fog obscures vision. Evasion is increased.");
        this._applyStatusEffect("EvasionUp", 1.2);
    }

    _handleSandstorm() {
        console.log("Sandstorm! Attacks have a chance to miss.");
        this._applyStatusEffect("EvasionUp", 1.1);
    }

    // Terrain effect handlers
    _handleWater() {
        console.log("Water terrain! Electric attacks are super effective.");
        this._applyStatusEffect("ElectricEffect", 1.5);
    }

    _handleLava() {
        console.log("Lava terrain! Fire attacks are super effective, but takes damage.");
        this._applyStatusEffect("FireEffect", 1.5);
        console.log("Taking 10 damage per turn from lava...");
        $gameParty.actors().forEach(actor => {
            actor._hp = Math.max(0, actor._hp - 10);
        });
    }

    _handleMud() {
        console.log("Muddy terrain! Movement is slower, but physical attacks are slightly stronger.");
        this._applyStatusEffect("PhysicalAttackUp", 1.1);
    }

    _handleGrass() {
        console.log("Grass terrain! Healing effects are more potent.");
        this._applyStatusEffect("HealingEffect", 1.2);
    }

    // Enemy behavior implementations
    _aggressiveBehavior() {
        console.log(`${this._name} is aggressive! Always targets the weakest party member.`);
        const weakestActor = $gameParty.actors().reduce((weakest, actor) =>
            actor._hp < weakest._hp ? actor : weakest
        );
        console.log(`Attacking ${weakestActor._name}!`);
    }

    _defensiveBehavior() {
        console.log(`${this._name} is defensive! Always tries to avoid damage.`);
        if (Math.random() < 0.5) {
            console.log(`${this._name} guards!`);
        } else {
            console.log(`${this._name} attacks randomly.`);
        }
    }

    _passiveBehavior() {
        console.log(`${this._name} is passive! Only attacks when HP is below 50%.`);
        if (this._hp < this._maxhp * 0.5) {
            console.log(`${this._name} attacks!`);
        }
    }

    _opportunisticBehavior() {
        console.log(`${this._name} is opportunistic! Waits for a weak enemy before attacking.`);
        if (Math.random() < 0.3 || $gameTroop.members.some(e =>
            e._hp < e._maxhp * 0.3 && e !== this)) {
            console.log(`${this._name} sees an opening and attacks!`);
        }
    }

    // Utility methods
    _setRandomWeather() {
        const weather = this.weatherEffects[Math.floor(Math.random() * this.weatherEffects.length)];
        this.activeWeather = weather;
        console.log(`Weather: ${weather.name} (intensity: ${weather.intensity}, duration: ${weather.duration} turns)`);
    }

    _setRandomTerrain() {
        const terrainKeys = Object.keys(this.terrainEffects);
        const terrain = terrainKeys[Math.floor(Math.random() * terrainKeys.length)];
        this.activeTerrain = this.terrainEffects[terrain];
        console.log(`Terrain: ${terrain} (priority: ${this.activeTerrain.priority})`);
    }

    _assignBehaviorsToEnemies() {
        $gameTroop.members = Array.from({ length: 3 }, (_, i) => {
            const behaviors = ['aggressive', 'defensive', 'passive', 'opportunistic'];
            const behavior = behaviors[Math.floor(Math.random() * behaviors.length)];
            return {
                _name: `Enemy ${i + 1}`,
                _hp: 100,
                _maxhp: 100,
                _behavior: this.enemyBehaviors[behavior],
                _behavior: this.enemyBehaviors[behavior].bind({ _name: `Enemy ${i + 1}` })
            };
        });
    }

    _applyStatusEffect(name, value) {
        $gameVariables.set(name, value);
        console.log(`Applied ${name}: ${value}`);
    }
}

// ============================================================================
// Mock RPG Maker MZ Classes
// ============================================================================
class Game_Actor {
    constructor(actorId) {
        this._actorId = actorId;
        this._name = `Actor ${actorId}`;
        this._hp = 100;
        this._maxhp = 100;
    }
}

class Game_Enemy {
    constructor(enemyId) {
        this._enemyId = enemyId;
        this._name = `Enemy ${enemyId}`;
        this._hp = 100;
        this._maxhp = 100;
    }
}

// ============================================================================
// Initialize and run the simulation
// ============================================================================
function main() {
    // Set up mock game objects
    $gameParty._onBattleStart = () => {
        $gameParty.actors = () => Array.from({ length: 3 }, (_, i) => new Game_Actor(i + 1));
    };

    $gameTroop._initMembers = () => {
        $gameTroop.members = [];
    };

    $gameParty._onBattleStart();
    $gameTroop._initMembers();

    // Initialize and start the battle enhancer
    const enhancer = new DynamicBattleEnhancer();
    enhancer.init();
}

// Run the simulation
main();

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System.Linq;

public class QuantumMenuSystem : MonoBehaviour
{
    [SerializeField] private RectTransform _menuContainer;
    [SerializeField] private RectTransform _iconPrefab;
    [SerializeField] private AnimationCurve _morphCurve;
    [SerializeField] private float _morphDuration = 0.8f;
    [SerializeField] private float _hapticFeedbackForce = 0.5f;
    [SerializeField] private Vector2[] _quantumStates = new Vector2[]
    {
        new Vector2(0.3f, 0.3f), // Superposition
        new Vector2(0.7f, 0.7f), // Entangled
        new Vector2(0.1f, 0.9f), // Collapsed
        new Vector2(0.9f, 0.1f)  // Observer Effect
    };

    private RectTransform[] _activeIcons;
    private int _currentStateIndex = 0;
    private Coroutine _morphRoutine;

    private void Awake()
    {
        if (_menuContainer == null)
        {
            Debug.LogError("Menu Container reference is missing!");
            enabled = false;
            return;
        }

        InitializeMenu();
        TriggerRandomMorph();
    }

    private void InitializeMenu()
    {
        _activeIcons = new RectTransform[4]; // 4 quantum states per menu

        for (int i = 0; i < _activeIcons.Length; i++)
        {
            var iconInstance = Instantiate(_iconPrefab, _menuContainer);
            iconInstance.anchoredPosition = new Vector2(
                Random.Range(-150f, 150f),
                Random.Range(-150f, 150f)
            );
            _activeIcons[i] = iconInstance;

            // Add haptic feedback on click
            var button = iconInstance.GetComponent<Button>();
            if (button != null)
            {
                button.onClick.AddListener(() => TriggerHapticFeedback());
            }
        }
    }

    public void TriggerRandomMorph()
    {
        if (_morphRoutine != null)
        {
            StopCoroutine(_morphRoutine);
        }

        _morphRoutine = StartCoroutine(MorphToRandomState());
    }

    private IEnumerator MorphToRandomState()
    {
        int targetIndex = Random.Range(0, _quantumStates.Length);

        for (float t = 0; t < 1; t += Time.deltaTime / _morphDuration)
        {
            float progress = Mathf.Clamp01(_morphCurve.Evaluate(t));

            // Animate position and scale based on quantum state
            Vector2 newState = Vector2.Lerp(_quantumStates[_currentStateIndex], _quantumStates[targetIndex], progress);

            foreach (RectTransform icon in _activeIcons)
            {
                icon.anchoredPosition = Vector2.Lerp(
                    icon.anchoredPosition,
                    new Vector2(
                        Mathf.Lerp(-150f, 150f, newState.x),
                        Mathf.Lerp(-150f, 150f, newState.y)
                    ),
                    progress
                );

                icon.localScale = Vector3.Lerp(
                    icon.localScale,
                    new Vector3(1 + (0.3f * newState.y), 1 + (0.3f * newState.x), 1),
                    progress * 0.7f
                );
            }

            yield return null;
        }

        _currentStateIndex = targetIndex;
    }

    private void TriggerHapticFeedback()
    {
        #if UNITY_EDITOR
        Debug.Log("Quantum Observer Effect Detected! Haptic Feedback Triggered");
        #else
        Handheld.Vibrate(_hapticFeedbackForce, _morphDuration * 0.5f);
        #endif
    }

    private void OnDestroy()
    {
        if (_morphRoutine != null)
        {
            StopCoroutine(_morphRoutine);
        }
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Dynamic Floral Canvas</title>
    <style>
        :root {
            --petal-count: 5;
            --floral-radius: 150px;
            --floral-center: 50%;
            --floral-color: #6a4c93;
            --background-gradient: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
            --animation-duration: 4s;
            --animation-delay: 0.1s;
        }

        body {
            margin: 0;
            padding: 0;
            background: var(--background-gradient);
            height: 100vh;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            overflow: hidden;
            color: #333;
        }

        .container {
            position: relative;
            width: 100%;
            max-width: 600px;
            margin: 0 auto;
            text-align: center;
        }

        .controls {
            margin-bottom: 2rem;
            display: flex;
            flex-direction: column;
            gap: 1rem;
        }

        button {
            background-color: var(--floral-color);
            color: white;
            border: none;
            padding: 0.75rem 1.5rem;
            border-radius: 30px;
            font-size: 1rem;
            cursor: pointer;
            transition: all 0.3s ease;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }

        button:hover {
            transform: translateY(-2px);
            box-shadow: 0 6px 8px rgba(0, 0, 0, 0.15);
        }

        button:active {
            transform: translateY(0);
        }

        .floral-container {
            position: relative;
            width: var(--floral-radius);
            height: var(--floral-radius);
            margin: 0 auto;
            border-radius: 50%;
            background-color: rgba(106, 76, 147, 0.1);
            backdrop-filter: blur(5px);
            border: 1px solid rgba(106, 76, 147, 0.3);
        }

        .floral {
            position: absolute;
            width: 100%;
            height: 100%;
            top: 0;
            left: 0;
            transform-origin: var(--floral-center);
            animation: pulse 1s infinite ease-in-out;
        }

        @keyframes pulse {
            0%, 100% { transform: rotate(0deg) scale(1); }
            50% { transform: rotate(180deg) scale(1.05); }
        }

        .petal {
            position: absolute;
            width: 30%;
            height: 80%;
            background-color: var(--floral-color);
            border-radius: 50% 50% 0 50%;
            transform-origin: 50% 80%;
            transition: transform 0.3s ease, opacity 0.3s ease;
        }

        .center {
            position: absolute;
            width: 20px;
            height: 20px;
            background-color: #ffd700;
            border-radius: 50%;
            z-index: 10;
            box-shadow: 0 0 10px rgba(255, 215, 0, 0.5);
        }

        .export-btn {
            background-color: #2c3e50;
            margin-top: 1rem;
        }

        .export-btn:hover {
            background-color: #1a252f;
        }

        .config {
            margin-bottom: 1rem;
            display: flex;
            justify-content: center;
            gap: 1rem;
        }

        .config input {
            padding: 0.5rem;
            border-radius: 5px;
            border: 1px solid #ddd;
            width: 60px;
            text-align: center;
        }

        .config label {
            font-size: 0.9rem;
            color: #555;
        }

        .info {
            margin-top: 2rem;
            font-size: 0.8rem;
            color: #777;
        }

        . Exporting...
    </style>
</head>
<body>
    <div class="container">
        <h1>Dynamic Floral Canvas</h1>
        <div class="config">
            <label for="petalCount">Petals: </label>
            <input type="range" id="petalCount" min="3" max="12" value="5">
            <span id="petalCountValue">5</span>
        </div>
        <div class="controls">
            <button id="generateBtn">Generate New Floral Art</button>
            <button id="exportBtn" class="export-btn" disabled>Export as SVG</button>
        </div>
        <div class="floral-container">
            <div class="center"></div>
        </div>
        <p class="info">Click the "Generate New Floral Art" button to create unique floral patterns. Right-click the canvas to export as SVG.</p>
    </div>

    <script>
        document.addEventListener('DOMContentLoaded', () => {
            const petalCountInput = document.getElementById('petalCount');
            const petalCountValue = document.getElementById('petalCountValue');
            const generateBtn = document.getElementById('generateBtn');
            const exportBtn = document.getElementById('exportBtn');
            const floralContainer = document.querySelector('.floral-container');
            const floral = document.querySelector('.floral') || createFloralElement();
            const center = document.querySelector('.center');

            petalCountInput.addEventListener('input', () => {
                petalCountValue.textContent = petalCountInput.value;
                document.documentElement.style.setProperty('--petal-count', petalCountInput.value);
            });

            generateBtn.addEventListener('click', generateFloral);

            exportBtn.addEventListener('click', () => {
                exportAsSVG();
            });

            floralContainer.addEventListener('contextmenu', (e) => {
                e.preventDefault();
                exportAsSVG();
            });

            function createFloralElement() {
                const floralElement = document.createElement('div');
                floralElement.className = 'floral';
                floralContainer.appendChild(floralElement);
                return floralElement;
            }

            function generateFloral() {
                floral.innerHTML = '';
                exportBtn.disabled = true;
                floralContainer.style.opacity = '0.5';

                // Create petals
                const petalCount = parseInt(document.documentElement.style.getPropertyValue('--petal-count').trim());
                for (let i = 0; i < petalCount; i++) {
                    const petal = document.createElement('div');
                    petal.className = 'petal';

                    // Randomize size, position, and color
                    const size = 30 + Math.random() * 20;
                    const angle = (i * (360 / petalCount)) * Math.PI / 180;
                    const radius = 150 + Math.random() * 50;
                    const hue = 300 + Math.random() * 30;
                    const saturation = 70 + Math.random() * 20;
                    const lightness = 40 + Math.random() * 20;

                    petal.style.width = `${size}%`;
                    petal.style.height = `${80 + Math.random() * 20}%`;
                    petal.style.transformOrigin = `50% ${80 + Math.random() * 20}%`;
                    petal.style.backgroundColor = `hsl(${hue}, ${saturation}%, ${lightness}%)`;
                    petal.style.transform = `rotate(${angle * 180 / Math.PI}deg) translate(${radius}px, 0)`;
                    petal.style.opacity = 0.8 + Math.random() * 0.2;
                    petal.style.transitionDelay = `${Math.random() * 0.5}s`;

                    floral.appendChild(petal);
                }

                // Add animation to petals
                floral.style.animation = `pulse ${0.5 + Math.random() * 1.5}s infinite ease-in-out, rotate ${2 + Math.random() * 2}s linear infinite`;

                // Add subtle ripple effect
                const ripple = document.createElement('div');
                ripple.className = 'ripple';
                ripple.style.position = 'absolute';
                ripple.style.width = '100%';
                ripple.style.height = '100%';
                ripple.style.background = 'radial-gradient(circle, rgba(255,255,255,0.2) 0%, transparent 70%)';
                ripple.style.animation = `ripple ${3 + Math.random() * 2}s infinite ease-in-out`;
                floral.appendChild(ripple);

                setTimeout(() => {
                    floralContainer.style.opacity = '1';
                    exportBtn.disabled = false;
                }, 500);
            }

            // Create ripple effect animation
            const style = document.createElement('style');
            style.textContent = `
                @keyframes ripple {
                    0% { transform: scale(0.5); opacity: 0.5; }
                    100% { transform: scale(1.5); opacity: 0; }
                }
            `;
            document.head.appendChild(style);

            function exportAsSVG() {
                // Create SVG element
                const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
                svg.setAttribute('width', '300');
                svg.setAttribute('height', '300');
                svg.setAttribute('viewBox', '0 0 300 300');

                // Add background circle
                const bgCircle = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
                bgCircle.setAttribute('cx', '150');
                bgCircle.setAttribute('cy', '150');
                bgCircle.setAttribute('r', '120');
                bgCircle.setAttribute('fill', 'rgba(106, 76, 147, 0.1)');
                svg.appendChild(bgCircle);

                // Add center
                const centerCircle = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
                centerCircle.setAttribute('cx', '150');
                centerCircle.setAttribute('cy', '150');
                centerCircle.setAttribute('r', '10');
                centerCircle.setAttribute('fill', '#ffd700');
                svg.appendChild(centerCircle);

                // Add petals
                const petals = floral.querySelectorAll('.petal');
                const petalCount = petals.length;

                petals.forEach((petal, i) => {
                    const angle = (i * (360 / petalCount)) * Math.PI / 180;
                    const radius = 150 + Math.random() * 50;
                    const hue = 300 + Math.random() * 30;
                    const saturation = 70 + Math.random() * 20;
                    const lightness = 40 + Math.random() * 20;

                    const x = 150 + radius * Math.cos(angle);
                    const y = 150 + radius * Math.sin(angle);

                    const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
                    path.setAttribute('d', `M 150 150
                                            L ${x - 20} ${y - 15}
                                            L ${x + 20} ${y - 15}
                                            L ${x + 15} ${y + 15}
                                            L ${x - 15} ${y + 15}
                                            Z`);
                    path.setAttribute('fill', `hsl(${hue}, ${saturation}%, ${lightness}%)`);
                    svg.appendChild(path);
                });

                // Serialize SVG to string
                const serializer = new XMLSerializer();
                const svgStr = serializer.serializeToString(svg);

                // Create download link
                const blob = new Blob([svgStr], { type: 'image/svg+xml' });
                const url = URL.createObjectURL(blob);

                const link = document.createElement('a');
                link.href = url;
                link.download = `floral-art-${new Date().getTime()}.svg`;
                document.body.appendChild(link);
                link.click();
                document.body.removeChild(link);
                URL.revokeObjectURL(url);

                // Show temporary message
                const originalText = document.querySelector('.info').textContent;
                document.querySelector('.info').textContent = ' Exporting...';
                setTimeout(() => {
                    document.querySelector('.info').textContent = originalText;
                }, 2000);
            }

            // Initial generation
            generateFloral();
        });
    </script>
</body>
</html>

#!/usr/bin/env node

// Quantum Doodle - ASCII Art Generator mit Quantenmetaphern
// Unterstützt Farbausgabe (wenn TTY), interaktive Parameter und zufällige Muster
// Läuft mit: node quantum-doodle.js [--width=30] [--height=15] [--min=2] [--max=5] [--seed=random]

import { program } from 'commander';
import readline from 'readline';
import chalk from 'chalk';

program
  .version('1.0.0')
  .description('Quantum Doodle - Generiert farbenfrohe ASCII-Kunst mit Quantenmetaphern')
  .option('-w, --width <number>', 'Breite der ASCII-Kunst (Standard: 30)', parseInt)
  .option('-h, --height <number>', 'Höhe der ASCII-Kunst (Standard: 15)', parseInt)
  .option('-m, --min <number>', 'Minimale Komplexität (Standard: 2)', parseInt)
  .option('-M, --max <number>', 'Maximale Komplexität (Standard: 5)', parseInt)
  .option('-s, --seed <string>', 'Seed für reproduzierbare Muster (Standard: zufällig)', String)
  .option('-i, --interactive', 'Interaktiver Modus (Parametermanager)')
  .action(async (options) => {
    const rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    });

    if (options.interactive) {
      await interactiveMode(rl, options);
    } else {
      generateArt({
        width: options.width || 30,
        height: options.height || 15,
        min: options.min || 2,
        max: options.max || 5,
        seed: options.seed || null
      });
    }

    process.exit(0);
  });

program.parse(process.argv);

// Quantenmetaphern-Farben (based on quantum spectra)
const quantumColors = {
  electron: chalk.hex('#FF5E62'),
  proton: chalk.hex('#5E81AC'),
  neutron: chalk.hex('#B26F35'),
  entangled: chalk.hex('#5F819D'),
  observer: chalk.hex('#F8C471'),
  vacuum: chalk.hex('#333333'),
  uncertainty: chalk.hex('#A29BFE'),
  superposition: chalk.hex('#96CEB4'),
  collapse: chalk.hex('#E84393')
};

// ASCII-Kunst-Charaktere (Quantum-Theme)
const quantumChars = [
  '•', 'o', 'O', '°', '░', '▒', '▓', '█', '▔', '▕', '▖', '▗', '▖', '▘', '▙', '▚', '▛', '▜', '▝', '▞'
];

// Generiert ein zufälliges Quanten-Muster
function generateQuantumPattern(width, height, min, max, seed = null) {
  const pattern = [];
  const chars = quantumChars.slice();

  // Seed für reproduzierbare Muster
  if (seed) {
    const seedValue = typeof seed === 'number' ? seed : seed.charCodeAt(0);
    chars.sort((a, b) => a.localeCompare(b) - seedValue);
  }

  // Erzeugt ein 2D-Array mit zufälligen Quantenzuständen
  for (let y = 0; y < height; y++) {
    const row = [];
    for (let x = 0; x < width; x++) {
      // Quantentunneling-Effekt: randomness mit Neigung
      const complexity = Math.min(max, Math.floor((x + y) / (width / min)) + 1);
      const index = Math.floor(Math.random() * complexity) % chars.length;
      row.push(chars[index]);
    }
    pattern.push(row);
  }

  return pattern;
}

// Wählt eine Farbe basierend auf Quantenzustand
function getQuantumColor(x, y, width, height, pattern) {
  const char = pattern[y][x];
  const pos = { x, y, total: x + y, center: width / 2, edge: width - x };

  // Quanten-Interferenzmuster
  const interference = (Math.sin(x / 5) + Math.cos(y / 3)) / 2;
  const uncertainty = Math.random() * 0.3;

  // Entscheidung basierend auf Position und Charakter
  if (char === 'O' || char === 'o') {
    return quantumColors.electron;
  } else if (char === '°' || char === '░') {
    return quantumColors.proton;
  } else if (char === '▓' || char === '█') {
    return quantumColors.neutron;
  } else if (interference > 0.7) {
    return quantumColors.entangled;
  } else if (Math.random() > 0.7) {
    return quantumColors.superposition;
  } else if (pos.center - pos.x < 3) {
    return quantumColors.observer;
  } else {
    return quantumColors.vacuum;
  }
}

// Generiert die finale ASCII-Kunst
function generateArt(config) {
  const { width, height, min, max, seed } = config;
  const pattern = generateQuantumPattern(width, height, min, max, seed);
  let output = '';

  // Header mit Quantenmetapher
  output += quantumColors.uncertainty(`Quantum Doodle v1.0.0 | Width: ${width} | Height: ${height} | Complexity: ${min}-${max}\n`);
  output += quantumColors.observer(`Seed: ${seed || 'random (quantum superposition)'}\n\n`);

  // Hauptmuster
  for (let y = 0; y < height; y++) {
    for (let x = 0; x < width; x++) {
      const color = getQuantumColor(x, y, width, height, pattern);
      output += color(pattern[y][x]);
    }
    output += '\n';
  }

  // Quanten-Interferenz-Effekt (wenn TTY)
  if (process.stdout.isTTY) {
    output += quantumColors.superposition('\n  ~ Quantum interference detected ~\n');
    output += quantumColors.collapse('  (Observer effect: This pattern collapses upon viewing)\n\n');
  }

  console.log(output);
}

// Interaktiver Modus
async function interactiveMode(rl, initialOptions) {
  const options = {
    width: initialOptions.width || 30,
    height: initialOptions.height || 15,
    min: initialOptions.min || 2,
    max: initialOptions.max || 5,
    seed: initialOptions.seed || null,
    interactive: true
  };

  console.log(quantumColors.superposition('\n=== Quantum Doodle Interactive Mode ===\n'));

  // Fragen stellen
  const questions = [
    {
      question: `Breite (Standard: ${options.width}): `,
      key: 'width',
      validator: (val) => parseInt(val) >= 5 && parseInt(val) <= 100
    },
    {
      question: `Höhe (Standard: ${options.height}): `,
      key: 'height',
      validator: (val) => parseInt(val) >= 5 && parseInt(val) <= 30
    },
    {
      question: `Minimale Komplexität (Standard: ${options.min}): `,
      key: 'min',
      validator: (val) => parseInt(val) >= 1 && parseInt(val) <= 10
    },
    {
      question: `Maximale Komplexität (Standard: ${options.max}): `,
      key: 'max',
      validator: (val) => parseInt(val) >= options.min && parseInt(val) <= 10
    },
    {
      question: `Seed (Standard: zufällig, oder 'test123' für reproduzierbar): `,
      key: 'seed'
    }
  ];

  for (const q of questions) {
    const answer = await ask(rl, q.question);
    if (q.validator) {
      const parsed = parseInt(answer);
      if (isNaN(parsed) || !q.validator(answer)) {
        console.log(chalk.red('  Ungültige Eingabe!'));
        continue;
      }
      options[q.key] = parsed;
    } else {
      options[q.key] = answer.trim();
    }
  }

  generateArt(options);
  rl.close();
}

function ask(rl, question) {
  return new Promise((resolve) => {
    rl.question(question, (answer) => {
      resolve(answer);
    });
  });
}

// Export für andere Module (falls benötigt)
export { generateArt, generateQuantumPattern, getQuantumColor };

// Falls direkt ausgeführt wird
if (process.env.NODE_ENV !== 'test') {
  // Command-line-Parser einrichten
  const parsedArgs = program.parse(process.argv);
  generateArt({
    width: parsedArgs.width || 30,
    height: parsedArgs.height || 15,
    min: parsedArgs.min || 2,
    max: parsedArgs.max || 5,
    seed: parsedArgs.seed || null
  });
}

#!/usr/bin/env node
import fs from 'fs/promises';
import path from 'path';
import { fileURLToPath } from 'url';
import readline from 'readline';
import crypto from 'crypto';

const __dirname = path.dirname(fileURLToPath(import.meta.url));

class FileOrchestrator {
  constructor(targetDir) {
    this.targetDir = path.resolve(targetDir);
    this.rules = {
      'images': ['.jpg', '.jpeg', '.png', '.gif', '.svg', '.webp'],
      'documents': ['.pdf', '.doc', '.docx', '.txt', '.md', '.xlsx', '.xls'],
      'videos': ['.mp4', '.mov', '.avi', '.mkv', '.webm'],
      'audio': ['.mp3', '.wav', '.ogg', '.m4a'],
      'archives': ['.zip', '.tar', '.gz', '.rar', '.7z'],
      'code': ['.js', '.ts', '.jsx', '.tsx', '.py', '.java', '.c', '.cpp', '.h'],
      'others': []
    };
    this.chaosMode = false;
    this.chaosFolders = [];
  }

  async initialize() {
    try {
      await this._ensureDirectory(this.targetDir);
      const items = await fs.readdir(this.targetDir, { withFileTypes: true });

      // Collect existing files and their extensions
      const existingFiles = await Promise.all(
        items.filter(item => item.isFile())
          .map(async item => {
            const filePath = path.join(this.targetDir, item.name);
            const ext = path.extname(item.name).toLowerCase();
            return { name: item.name, ext, path: filePath };
          })
      );

      // Create folders if they don't exist (except for 'others')
      for (const [folder, extensions] of Object.entries(this.rules)) {
        if (folder !== 'others') {
          await this._ensureDirectory(path.join(this.targetDir, folder));
        }
      }

      // If in chaos mode, create random folders and move files
      if (this.chaosMode) {
        await this._applyChaosMode(existingFiles);
      } else {
        await this._organizeFiles(existingFiles);
      }

      console.log('\n✨ File organization complete!');
    } catch (error) {
      console.error('❌ Error:', error.message);
      process.exit(1);
    }
  }

  async _organizeFiles(files) {
    const movedFiles = [];

    for (const file of files) {
      let targetFolder = 'others';
      for (const [folder, extensions] of Object.entries(this.rules)) {
        if (extensions.includes(file.ext)) {
          targetFolder = folder;
          break;
        }
      }

      if (targetFolder !== 'others' && file.path !== path.join(this.targetDir, targetFolder, file.name)) {
        const targetPath = path.join(this.targetDir, targetFolder, file.name);
        await fs.rename(file.path, targetPath);
        movedFiles.push(file.name);
      }
    }

    if (movedFiles.length > 0) {
      console.log(`✅ Moved ${movedFiles.length} files to appropriate folders.`);
    } else {
      console.log('ℹ️ No files needed to be moved (or already organized).');
    }
  }

  async _applyChaosMode(files) {
    // Create random folder names (but avoid clashing with existing ones)
    const existingFolders = await fs.readdir(this.targetDir)
      .catch(err => err.code === 'ENOENT' ? [] : err);

    for (let i = 0; i < 5; i++) {
      const hash = crypto.randomBytes(3).toString('hex');
      const folderName = `chaos_${hash}`;
      if (!existingFolders.includes(folderName)) {
        this.chaosFolders.push(folderName);
        await fs.mkdir(path.join(this.targetDir, folderName));
      }
    }

    // Shuffle files and distribute them randomly
    const shuffledFiles = [...files].sort(() => 0.5 - Math.random());

    for (let i = 0; i < shuffledFiles.length; i++) {
      const file = shuffledFiles[i];
      const targetFolder = i % this.chaosFolders.length;
      const targetPath = path.join(this.targetDir, this.chaosFolders[targetFolder], file.name);

      // Skip if the file is already in a chaos folder (avoid infinite loops)
      if (!file.path.includes('chaos_')) {
        await fs.rename(file.path, targetPath);
      }
    }

    console.log(`🤪 Applied Chaos Mode! Files are now randomly distributed across ${this.chaosFolders.length} folders.`);
  }

  async _ensureDirectory(dirPath) {
    try {
      await fs.access(dirPath);
    } catch {
      await fs.mkdir(dirPath);
    }
  }

  async toggleChaosMode() {
    this.chaosMode = !this.chaosMode;
    console.log(this.chaosMode ? '🔥 Chaos Mode: ON' : '🔄 Chaos Mode: OFF');
  }
}

async function main() {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  console.log('🎵 File Orchestrator with AI-Inspired Chaos Mode 🎵');
  console.log('--------------------------------------------------');
  console.log('This tool will organize your files smartly... or playfully scramble them in Chaos Mode!');

  const dir = await rl.question('Enter the target directory path: ');
  const orchestrator = new FileOrchestrator(dir);

  while (true) {
    console.log('\nOptions:');
    console.log('1. Organize files normally');
    console.log('2. Toggle Chaos Mode');
    console.log('3. Exit');

    const choice = await rl.question('Choose an option (1-3): ');

    if (choice === '1') {
      orchestrator.chaosMode = false;
      await orchestrator.initialize();
    } else if (choice === '2') {
      await orchestrator.toggleChaosMode();
    } else if (choice === '3') {
      console.log('👋 Goodbye!');
      rl.close();
      break;
    } else {
      console.log('❌ Invalid choice. Please try again.');
    }
  }
}

main().catch(console.error);

use std::{
    env, fs,
    io::{self, Write, Stdout, Stdin},
    path::Path,
    process,
};
use crossterm::{
    execute,
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
    style::{SetForegroundColor, Color},
    event::{Event, KeyCode, poll},
    cursor::{Hide, Show},
};
use termion::color;

const EMJOS: [char; 8] = [
    '🌳', '🌲', '🌳', '🌳', '🌳', '🌳', '🌳', '🌳',
];

fn main() {
    // Parse command line arguments
    let args: Vec<String> = env::args().collect();
    if args.len() != 2 {
        eprintln!("Usage: {} <directory>", args[0]);
        process::exit(1);
    }
    let path = Path::new(&args[1]);
    if !path.exists() || !path.is_dir() {
        eprintln!("Error: Path '{}' is not a valid directory", args[1]);
        process::exit(1);
    }

    // Initialize terminal
    enable_raw_mode().expect("Failed to enable raw mode");
    let mut stdout = io::stdout();
    execute!(stdout, EnterAlternateScreen, Hide).expect("Failed to enter alternate screen");

    // Set up terminal colors
    let mut stdout = stdout.lock();
    execute!(stdout, SetForegroundColor(Color::LightGreen)).unwrap();

    // Main loop
    loop {
        let tree = build_tree(path, 0);
        display_tree(&tree, &mut stdout);

        // Wait for user input
        let event = poll().expect("Failed to poll event");
        if let Event::Key(key) = event {
            match key.code {
                KeyCode::Char('q') => break,
                KeyCode::Up | KeyCode::Char('k') => {
                    if let Some(parent) = path.parent() {
                        path = parent;
                    }
                }
                KeyCode::Down | KeyCode::Char('j') => {
                    let entries = fs::read_dir(path).expect("Failed to read directory");
                    let mut next_path = None;
                    for entry in entries {
                        if let Ok(entry) = entry {
                            if entry.path() == path {
                                continue;
                            }
                            next_path = Some(entry.path());
                            break;
                        }
                    }
                    if let Some(next) = next_path {
                        path = next;
                    }
                }
                KeyCode::Char('l') => {
                    let entries = fs::read_dir(path).expect("Failed to read directory");
                    for entry in entries {
                        if let Ok(entry) = entry {
                            if entry.path() == path {
                                continue;
                            }
                            path = entry.path();
                            break;
                        }
                    }
                }
                KeyCode::Char('h') => {
                    display_help();
                }
                _ => {}
            }

            // Clear screen and redraw
            execute!(stdout, LeaveAlternateScreen).unwrap();
            execute!(stdout, EnterAlternateScreen).unwrap();
        }
    }

    // Cleanup terminal
    execute!(stdout, Show, LeaveAlternateScreen).unwrap();
    disable_raw_mode().expect("Failed to disable raw mode");
}

fn build_tree(path: &Path, depth: usize) -> TreeNode {
    let mut node = TreeNode {
        name: path.file_name().unwrap().to_string_lossy().into_owned(),
        depth,
        children: Vec::new(),
    };

    if path.is_dir() {
        if let Ok(entries) = fs::read_dir(path) {
            for entry in entries {
                if let Ok(entry) = entry {
                    node.children.push(build_tree(&entry.path(), depth + 1));
                }
            }
        }
    }

    node
}

fn display_tree(node: &TreeNode, stdout: &mut Stdout) {
    // Draw top border
    execute!(stdout, SetForegroundColor(Color::DarkGreen)).unwrap();
    writeln!(stdout, "╔═══════════════════════════════════════════════╗").unwrap();

    // Draw tree nodes
    execute!(stdout, SetForegroundColor(Color::LightGreen)).unwrap();
    draw_node(node, stdout);

    // Draw bottom border
    execute!(stdout, SetForegroundColor(Color::DarkGreen)).unwrap();
    writeln!(stdout, "╚═══════════════════════════════════════════════╝").unwrap();

    // Display help
    execute!(stdout, SetForegroundColor(Color::LightBlue)).unwrap();
    writeln!(stdout, "Controls: q=quit, j/k=up/down, l=enter, h=help").unwrap();
}

fn draw_node(node: &TreeNode, stdout: &mut Stdout) {
    // Get emoji based on depth
    let emoji = EMJOS.get(node.depth % EMJOS.len()).unwrap();

    // Set color based on depth
    let color = match node.depth % 4 {
        0 => Color::Green,
        1 => Color::Yellow,
        2 => Color::Red,
        _ => Color::Magenta,
    };
    execute!(stdout, SetForegroundColor(color)).unwrap();

    // Print node with indentation
    writeln!(stdout, "{}{}", "    ".repeat(node.depth), node.name).unwrap();

    // Print children
    for child in &node.children {
        draw_node(child, stdout);
    }
}

fn display_help() {
    println!("\nHelp:");
    println!("  q - Quit the application");
    println!("  j/k - Navigate up and down the directory tree");
    println!("  l - Enter a directory");
    println!("  h - Display this help");
    println!("\nTreeDaze - Directory Tree Visualizer with Emoji Depth");
}

#[derive(Debug)]
struct TreeNode {
    name: String,
    depth: usize,
    children: Vec<TreeNode>,
}

use rand::Rng;
use std::io::{self, Write};

// Custom error type for handling input failures elegantly
#[derive(Debug)]
struct PasswordGenError(String);

impl std::fmt::Display for PasswordGenError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "PasswordGenError: {}", self.0)
    }
}

impl std::error::Error for PasswordGenError {}

/// Simulates chaotic entropy with a mix of randomness and pseudo-determinism
fn chaotic_entropy(entropy: u32, meme_mode: bool) -> Vec<bool> {
    let mut rng = rand::thread_rng();
    let mut entropy_bits = Vec::with_capacity(entropy as usize);

    for i in 0..entropy {
        // Introduce controlled chaos: flip bits based on a mix of RNG and index
        let bit = (rng.gen_bool(0.7) || (i % 5 == 0)) as u8;
        entropy_bits.push(bit != 0);
    }

    if meme_mode {
        // Meme mode: replace every 10th bit with a "chaotic" XOR pattern
        for i in (1..entropy).step_by(10) {
            if i < entropy as usize {
                entropy_bits[i] ^= true;
            }
        }
    }

    entropy_bits
}

/// Generates a password based on entropy bits and style
fn generate_password(entropy_bits: &[bool], length: u32, style: PasswordStyle) -> String {
    let mut password = String::with_capacity(length as usize);
    let mut rng = rand::thread_rng();
    let chars = style.chars();

    for &bit in entropy_bits {
        if bit {
            // Use a random char from the style set if bit is true
            let idx = rng.gen_range(0..chars.len());
            password.push(chars[idx]);
        } else {
            // If bit is false, add a "static" element based on index
            let static_char = match (style.index) % 3 {
                0 => 'A',
                1 => '1',
                _ => '#',
            };
            password.push(static_char);
        }
    }

    // Ensure the password is at least 1 char long (shouldn't happen, but just in case)
    if password.is_empty() {
        password.push('!');
    }

    password
}

/// Represents different password styles with character sets
#[derive(Debug, Clone, Copy)]
enum PasswordStyle {
    Secure,
    Balanced,
    Meme,
}

impl PasswordStyle {
    fn chars(&self) -> Vec<char> {
        match self {
            PasswordStyle::Secure => {
                vec![
                    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
                    'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
                    'U', 'V', 'W', 'X', 'Y', 'Z',
                    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
                    'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
                    'u', 'v', 'w', 'x', 'y', 'z',
                    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                    '!', '@', '#', '$', '%', '^', '&', '*', '(', ')',
                ]
            }
            PasswordStyle::Balanced => {
                vec![
                    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
                    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
                    '0', '1', '2', '3', '4', '5',
                    '!', '@', '#',
                ]
            }
            PasswordStyle::Meme => {
                vec![
                    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
                    'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
                    'U', 'V', 'W', 'X', 'Y', 'Z',
                    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
                    'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
                    'u', 'v', 'w', 'x', 'y', 'z',
                    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                    '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '?', '~',
                    'X', 'D', 'P', 'L', 'G', 'K', 'W', 'E', 'B', 'O', 'R',
                ]
            }
        }
    }

    fn index(&self) -> u8 {
        match self {
            PasswordStyle::Secure => 0,
            PasswordStyle::Balanced => 1,
            PasswordStyle::Meme => 2,
        }
    }
}

/// Displays an ASCII art entropy bar (with intentional "glitches" for fun)
fn display_entropy_bar(entropy: u32, is_meme_mode: bool) {
    let bar_length = 30;
    let filled = (entropy as f32 / 100.0) * bar_length as f32;
    let mut bar = String::with_capacity(bar_length + 5);

    bar.push_str("Entropy: [");
    for i in 0..bar_length {
        if i as f32 < filled {
            bar.push(if is_meme_mode { 'X' } else { '=' });
        } else {
            bar.push(if is_meme_mode && i % 3 == 0 { '!' } else { ' ' });
        }
    }

    bar.push(']');
    println!("{} ({} bits)", bar, entropy);

    // Glitchy meme mode text
    if is_meme_mode {
        println!("  (Entropy is chaotic, like your aunt's Wi-Fi password)");
    }
}

/// Validates user input for password length
fn validate_length(input: &str) -> Result<u32, PasswordGenError> {
    let length = input.trim().parse::<u32>().map_err(|_| PasswordGenError("Invalid number".to_string()))?;
    if length == 0 {
        return Err(PasswordGenError("Length must be > 0".to_string()));
    }
    if length > 100 {
        return Err(PasswordGenError("Length too long (max 100)".to_string()));
    }
    Ok(length)
}

/// Main function with user interaction
fn main() {
    println!("🔐 CryptaGen: Password Generator with Chaotic Entropy 🔐");
    println!("------------------------------------------------------");

    // Prompt for password length
    print!("Enter password length (1-100): ");
    io::stdout().flush().unwrap();

    let length_input = match io::stdin().read_line() {
        Ok(line) => line.trim(),
        Err(_) => {
            println!("\nFailed to read input. Using default length of 12.");
            "12"
        }
    };

    let length = match validate_length(length_input) {
        Ok(len) => len,
        Err(e) => {
            println!("\nError: {}", e);
            println!("Using default length of 12.");
            12
        }
    };

    // Prompt for style
    println!("\nChoose password style:");
    println!("1. Secure (high entropy, complex characters)");
    println!("2. Balanced (easy to remember, moderate complexity)");
    println!("3. Meme (extra chaotic, for when you want to troll)");
    print!("Select (1/2/3): ");
    io::stdout().flush().unwrap();

    let style_input = match io::stdin().read_line() {
        Ok(line) => line.trim(),
        Err(_) => {
            println!("\nInvalid input. Using Secure style.");
            "1"
        }
    };

    let style = match style_input {
        "1" => PasswordStyle::Secure,
        "2" => PasswordStyle::Balanced,
        "3" => PasswordStyle::Meme,
        _ => {
            println!("\nInvalid choice. Using Secure style.");
            PasswordStyle::Secure
        }
    };

    // Calculate entropy (1 bit per character in the password, but scaled for display)
    let entropy = length * 5; // 5 bits per character for display purposes
    let is_meme_mode = matches!(style, PasswordStyle::Meme);

    // Generate chaotic entropy bits
    let entropy_bits = chaotic_entropy(entropy, is_meme_mode);

    // Display entropy bar
    display_entropy_bar(entropy, is_meme_mode);

    // Generate password
    let password = generate_password(&entropy_bits, length, style);
    println!("\n🔑 Generated Password: {}", password);

    // Extra meme if in meme mode
    if is_meme_mode {
        println!("💀 Meme mode activated! This password is as unpredictable as your ex's dating life.");
    }
}

extends Node2D

class_name: "MagicInventory"

# --- Configuration ---
@export var grid_size: Vector2i = Vector2i(3, 3)  # Rows, Columns
@export var slot_size: Vector2i = Vector2i(80, 80)  # Size of each slot
@export var slot_spacing: int = 10  # Space between slots
@export var drag_threshold: int = 5  # Minimum distance for drag to register
@export var hover_color: Color = Color(1, 0.8, 0.6)  # Hover effect color
@export var highlight_color: Color = Color(0.6, 1, 0.8)  # Highlight color for combinable items

# --- Magic System ---
@export var magic_slots: Array[Vector2i] = [
    Vector2i(0, 1),  # Top-center
    Vector2i(1, 1),  # Center
    Vector2i(2, 1),  # Bottom-center
    Vector2i(1, 0),  # Left-center
    Vector2i(1, 2),  # Right-center
]

@export var item_combinations: Dictionary = {
    "gold_coin": ["gold_coin", "gold_coin", "gold_coin"],  # 3 coins -> gold_ingot
    "potion": ["potion", "potion"],  # 2 potions -> elixir
    "rune": ["rune", "rune", "rune"],  # 3 runes -> dragon_gem
}

# --- State ---
var slots: Array[ invent.Slot ] = []
var items: Array[ invent.Item ] = []
var current_dragged_item: invent.Item? = null
var dragged_item_offset: Vector2 = Vector2.ZERO
var hovering_slots: Array[ invent.Slot ] = []

# --- Signals ---
signal item_combined(item_name: String, new_item_name: String)
signal item_used(item_name: String)
signal item_removed(item_name: String)

# --- Ready ---
func _ready() -> void:
    _generate_grid()
    _init_example_items()

func _generate_grid() -> void:
    for y in range(grid_size.y):
        for x in range(grid_size.x):
            var slot = invent.Slot.new()
            slot.position = Vector2(x, y) * (slot_size + Vector2(slot_spacing, slot_spacing))
            slot.size = slot_size
            slot.connect("mouse_entered", Callable(self, "_on_slot_hovered"))
            slot.connect("mouse_exited", Callable(self, "_on_slot_unhovered"))
            slot.connect("input_event", Callable(self, "_on_slot_input"))
            add_child(slot)
            slots.append(slot)

func _init_example_items() -> void:
    var gold_coin = invent.Item.new()
    gold_coin.item_name = "gold_coin"
    gold_coin.texture = load("res://assets/coin.png")
    gold_coin.icon_color = Color(218 / 255, 165 / 255, 32 / 255)  # Gold color

    var potion = invent.Item.new()
    potion.item_name = "potion"
    potion.texture = load("res://assets/potion.png")
    potion.icon_color = Color(0, 255 / 255, 255 / 255)  # Cyan

    var rune = invent.Item.new()
    rune.item_name = "rune"
    rune.texture = load("res://assets/rune.png")
    rune.icon_color = Color(255 / 255, 0, 255 / 255)  # Magenta

    for _i in range(5):
        slots[randi() % slots.size()].add_item(gold_coin.duplicate())
    for _i in range(3):
        slots[randi() % slots.size()].add_item(potion.duplicate())
    for _i in range(2):
        slots[randi() % slots.size()].add_item(rune.duplicate())

# --- Input Handling ---
func _on_slot_input(slot: invent.Slot, event: InputEvent) -> void:
    if event is InputEventMouseButton and event.pressed:
        if slot.is_empty():
            if current_dragged_item:
                current_dragged_item.remove_from_parent()
                slot.add_item(current_dragged_item)
                current_dragged_item = null
        else:
            var item = slot.get_item()
            if item.is_draggable():
                current_dragged_item = item
                dragged_item_offset = global_mouse_position() - item.global_position
                item.undock()

func _on_slot_hovered(slot: invent.Slot) -> void:
    if slot.is_empty():
        return
    hovering_slots.append(slot)
    _update_hover_effects()

func _on_slot_unhovered(slot: invent.Slot) -> void:
    hovering_slots.erase(slot)
    _update_hover_effects()

func _update_hover_effects() -> void:
    for slot in slots:
        slot.set_hovered(hovering_slots.has(slot))
        slot.set_highlighted(false)

    for slot in hovering_slots:
        for magic_slot in magic_slots:
            if slot.position == (magic_slot * (slot_size + Vector2(slot_spacing, slot_spacing))):
                slot.set_highlighted(true)

# --- Process ---
func _process(delta: float) -> void:
    if current_dragged_item:
        current_dragged_item.position = global_mouse_position() - dragged_item_offset
        _check_drop_target()

func _check_drop_target() -> void:
    for slot in slots:
        if slot.get_rect().intersects(current_dragged_item.get_rect()):
            slot.set_hovered(true)
            if not slot.is_empty() and _can_combine(slot.get_item(), current_dragged_item):
                slot.set_highlighted(true)
            return

func _can_combine(target: invent.Item, source: invent.Item) -> bool:
    if target.item_name != source.item_name:
        return false

    var target_slot = slots[target.slot_index]
    var source_slot = slots[source.slot_index]

    # Check if target is a magic slot and has enough items for combination
    for magic_slot in magic_slots:
        if target_slot.position == (magic_slot * (slot_size + Vector2(slot_spacing, slot_spacing))):
            var items_in_slot = 0
            for slot in slots:
                if slot.position == target_slot.position and not slot.is_empty():
                    items_in_slot += 1

            if items_in_slot >= 2 and item_combinations.has(target.item_name):
                var required = item_combinations[target.item_name].size()
                if items_in_slot >= required:
                    return true

    return false

# --- Combination Logic ---
func _on_drop_completed(slot: invent.Slot, item: invent.Item) -> void:
    if slot.is_empty():
        slot.add_item(item)
    else:
        if _can_combine(slot.get_item(), item):
            _combine_items(slot, item)

func _combine_items(slot: invent.Slot, item: invent.Item) -> void:
    var items_to_remove: Array[invent.Item] = []
    var item_count = 0

    # Collect all items of the same type in magic slots
    for magic_slot in magic_slots:
        var pos = magic_slot * (slot_size + Vector2(slot_spacing, slot_spacing))
        for s in slots:
            if s.position == pos and not s.is_empty():
                items_to_remove.append(s.get_item())
                item_count += 1

    if item_count >= 2 and item_combinations.has(item.item_name):
        var required = item_combinations[item.item_name].size()
        if item_count >= required:
            # Remove all items
            for i in items_to_remove:
                i.queue_free()
                emit_signal("item_removed", i.item_name)

            # Create new item
            var new_item = invent.Item.new()
            new_item.item_name = item_combinations[item.item_name][0]  # Simplified - just take first
            new_item.texture = load("res://assets/" + new_item.item_name + ".png")
            new_item.icon_color = Color(randf(), randf(), randf())  # Random magic color

            slot.add_item(new_item)
            emit_signal("item_combined", item.item_name, new_item.item_name)
            emit_signal("item_used", item.item_name)

func _on_item_used(item_name: String) -> void:
    for slot in slots:
        if not slot.is_empty() and slot.get_item().item_name == item_name:
            slot.remove_item()
            emit_signal("item_removed", item_name)

# --- Nested Classes ---
namespace invent:
    class_name: "Item"
    class Item extends Sprite2D:
        @export var item_name: String = ""
        @export var texture: Texture2D? = null
        @export var icon_color: Color = Color.WHITE
        @export var value: int = 1
        @export var is_draggable: bool = true

        var slot_index: int = -1

        func add_to_slot(slot: Slot) -> void:
            slot.add_child(self)
            slot_index = slots.get_index(slot)
            position = Vector2.ZERO
            dock_into_slot()

        func remove_from_slot() -> void:
            if slot_index >= 0 and slot_index < slots.size():
                slots[slot_index].remove_child(self)
            slot_index = -1

        func dock_into_slot() -> void:
            position = Vector2.ZERO
            scale = Vector2(1, 1)

        func undock() -> void:
            remove_from_parent()
            slot_index = -1

        func get_rect() -> Rect2:
            return Rect2(position, size)

    class_name: "Slot"
    class ItemContainer extends Rect2:
        @export var item: Item? = null
        @export var hovered: bool = false
        @export var highlighted: bool = false
        @export var color: Color = Color(0.2, 0.2, 0.2)

        var shader_material: ShaderMaterial? = null

        func _ready() -> void:
            var shader = Shader.new()
            shader.code = """
            shader_type canvas_item;

            void fragment() {
                COLOR = texture(TEXTURE, UV);
                if (hovered) {
                    COLOR = mix(COLOR, ${hover_color}, 0.2);
                }
                if (highlighted) {
                    COLOR = mix(COLOR, ${highlight_color}, 0.3);
                }
            }
            """
            shader.set_shader_param("hovered", hovered)
            shader.set_shader_param("highlighted", highlighted)
            shader_material = ShaderMaterial.new()
            shader_material.shader = shader
            material_override = shader_material

        func set_hovered(hover: bool) -> void:
            hovered = hover
            if shader_material:
                shader_material.set_shader_param("hovered", hovered)

        func set_highlighted(highlight: bool) -> void:
            highlighted = highlight
            if shader_material:
                shader_material.set_shader_param("highlighted", highlight)

        func add_item(item: Item) -> void:
            if item:
                item.add_to_slot(self)
                item = item

        func remove_item() -> void:
            if item:
                item.remove_from_slot()
                item = null

        func get_item() -> Item?:
            return item

        func is_empty() -> bool:
            return item == null

        func _input(event: InputEvent) -> void:
            if event is InputEventMouseButton and event.pressed:
                if is_connected("input_event", Callable(self, "_on_slot_input")):
                    emit_signal("input_event", event)

// RPG Maker MZ Dynamic Menu Enchantments
// Node.js script for RPG Maker MZ menu UI transformation
// Features: Animated health/mana pools, spell-like item effects, responsive particle magic

import { Scene_Menu, Window_MenuCommand, Window_MenuStatus, Window_Hello, Window_Gold, Window_Options, Window_Skill, Window_Item, Window_Equip, Window_PartyCommand, Window_SaveFile } from 'tkmz-helpers';
import { Scene_Map, Game_Interpreter, DataManager, BattleManager, AudioManager, Graphics, Sprite, TilingSprite, Util, SceneBase, Window_Selectable, Window_Command, Window_Message, Window_Number, Window_SkillList, Window_ItemList, Window_EquipList, Window_PartyList, Window_Status, Window_ShopCommand, Window_ShopNum, Window_ShopItem, Window_ShopPrice, Window_ShopStatus, Window_ChoiceList, Window_NumberInput, Window_StringInput, Window_MenuItem, Window_Message, Window_Gauge, Window_Number, Window_Selectable, Window_Command, Window_MenuCommand, Window_MenuStatus, Window_Options, Window_Skill, Window_Item, Window_Equip, Window_PartyCommand, Window_SaveFile } from 'tkmz-helpers';

// Custom enchantment system
class MenuEnchantments {
    constructor() {
        this.activeEnchants = new Map();
        this.particleEffects = [];
        this.poolEffects = [];
        this.initialized = false;
    }

    init() {
        if (this.initialized) return;
        this.initialized = true;

        // Create particle effect manager
        this.particleManager = new ParticleManager();
        Graphics sprite = new Graphics();

        // Add event listeners
        Scene_Menu.prototype.onMenuClose = this.onMenuClose.bind(this);
        Window_MenuStatus.prototype.onInit = this.onWindowInit.bind(this);
    }

    onMenuClose() {
        this.cleanupEffects();
    }

    onWindowInit(window) {
        if (window instanceof Window_MenuStatus) {
            this.enchantStatusWindow(window);
        }
    }

    enchantStatusWindow(window) {
        // Remove existing status window
        window._gauge = new Window_Gauge(0, 0, window.width, 100);
        window._gauge.x = 0;
        window._gauge.y = 0;
        window._gauge.setGaugeType('HP');
        window._gauge.setValue($gameParty.agilityPoints());
        window._gauge.refresh();

        // Create enchanted version
        this.enchantedGauge = new EnchantedGauge(window.x, window.y, window.width, 100);
        this.enchantedGauge.setGaugeType('HP');
        this.enchantedGauge.setValue($gameParty.agilityPoints());
        this.enchantedGauge.refresh();
        window.addChild(this.enchantedGauge);

        // Add particle effects
        this.addParticleEffects(window);
    }

    addParticleEffects(window) {
        // Health particles
        const healthParticles = this.particleManager.createParticles(
            window.x, window.y,
            20, 0.5, [20, 30, 40], // Ranges for particle count, speed, size
            0xFF0000, 0xFF8888, 0xFF4444, // Colors
            0.8, 1.2, // Alpha range
            false, true, // Rotation and scale
            0, 0, 0 // Acceleration
        );
        this.particleEffects.push(...healthParticles);

        // Mana particles
        const manaParticles = this.particleManager.createParticles(
            window.x, window.y - 20,
            15, 0.4, [15, 25, 35],
            0x0088FF, 0x88FFFF, 0x44AAFF,
            0.7, 1.1,
            true, false,
            0, 0, 0
        );
        this.particleEffects.push(...manaParticles);

        // Start particles
        healthParticles.forEach(p => p.start());
        manaParticles.forEach(p => p.start());
    }

    cleanupEffects() {
        this.particleEffects.forEach(p => p.destroy());
        this.particleEffects = [];
        this.poolEffects = [];
        this.activeEnchants.clear();
    }
}

class EnchantedGauge extends Window_Gauge {
    constructor(x, y, width, height) {
        super(x, y, width, height);
        this._enchanted = true;
        this._effects = [];
        this._poolEffect = null;
        this._sparkleEffect = null;
    }

    setGaugeType(type) {
        super.setGaugeType(type);
        this._type = type;
        this.setupEffects();
    }

    setupEffects() {
        switch (this._type) {
            case 'HP':
                this._poolEffect = new PoolEffect(this.x, this.y, this.width, this.height, 0xFF0000, 0xFF8888);
                this._sparkleEffect = new SparkleEffect(this.x, this.y, 0xFF88FF, 0xFF0000);
                break;
            case 'MP':
                this._poolEffect = new PoolEffect(this.x, this.y, this.width, this.height, 0x0088FF, 0x88FFFF);
                this._sparkleEffect = new SparkleEffect(this.x, this.y, 0x88FFFF, 0x0088FF);
                break;
        }
    }

    refresh() {
        super.refresh();
        if (this._poolEffect) this._poolEffect.update();
        if (this._sparkleEffect) this._sparkleEffect.update();
    }

    destroy() {
        if (this._poolEffect) this._poolEffect.destroy();
        if (this._sparkleEffect) this._sparkleEffect.destroy();
        super.destroy();
    }
}

class PoolEffect {
    constructor(x, y, width, height, color1, color2) {
        this._sprite = new Sprite();
        this._sprite.x = x;
        this._sprite.y = y;
        this._sprite.width = width;
        this._sprite.height = height;
        this._color1 = color1;
        this._color2 = color2;
        this._timer = 0;
        this._progress = 0;
        this._scaling = 0;
        this._direction = 1;
    }

    update() {
        this._timer += 0.05;
        this._progress = (Math.sin(this._timer * 2) + 1) * 0.5;
        this._scaling = 1 + Math.sin(this._timer * 3) * 0.1;

        this._sprite.setFrame(0, 0, this._sprite.width, this._sprite.height);
        this._sprite.setColorTone([0, 0, 0, 0]);
        this._sprite.setBlendColor([this._color1, this._color2]);
        this._sprite.setBlendMode(1);
        this._sprite.setGlow(0.2, 0xFFFFFF, 0.8);
        this._sprite.setScale(this._scaling, this._scaling);
    }

    destroy() {
        this._sprite.removeAllChildren();
        this._sprite.destroy();
    }
}

class SparkleEffect {
    constructor(x, y, color1, color2) {
        this._sprite = new Sprite();
        this._sprite.x = x;
        this._sprite.y = y;
        this._color1 = color1;
        this._color2 = color2;
        this._timer = 0;
        this._posX = 0;
        this._posY = 0;
        this._size = 0;
        this._opacity = 0;
        this._active = false;
    }

    update() {
        this._timer += 0.1;

        if (this._timer > 2) {
            this._active = true;
            this._timer = 0;
            this._posX = Math.random() * 20 - 10;
            this._posY = Math.random() * 20 - 10;
            this._size = Math.random() * 10 + 5;
            this._opacity = 1;
        }

        if (this._active) {
            this._opacity -= 0.02;
            this._posY -= 0.5;

            if (this._opacity <= 0) {
                this._active = false;
                this._opacity = 0;
            }
        }

        this._sprite.setFrame(0, 0, this._size, this._size);
        this._sprite.setColorTone([0, 0, 0, 0]);
        this._sprite.setBlendColor([this._color1, this._color2]);
        this._sprite.setBlendMode(1);
        this._sprite.setOpacity(this._opacity * 255);
        this._sprite.setGlow(0.5, 0xFFFFFF, 0.8);
    }

    destroy() {
        this._sprite.removeAllChildren();
        this._sprite.destroy();
    }
}

class ParticleManager {
    constructor() {
        this._particles = [];
    }

    createParticles(x, y, count, speed, sizeRange, colors, alphaRange, rotate, scale, acceleration) {
        const particles = [];

        for (let i = 0; i < count; i++) {
            const particle = new Particle(
                x, y,
                speed,
                sizeRange[0] + Math.random() * (sizeRange[2] - sizeRange[0]),
                colors[Math.floor(Math.random() * colors.length)],
                alphaRange[0] + Math.random() * (alphaRange[1] - alphaRange[0]),
                rotate ? Math.random() * 6.28 : 0,
                scale ? 0.5 + Math.random() * 0.5 : 1,
                acceleration[0] + Math.random() * (acceleration[2] - acceleration[0])
            );
            particles.push(particle);
            this._particles.push(particle);
        }

        return particles;
    }
}

class Particle {
    constructor(x, y, speed, size, color, alpha, rotation, scale, acceleration) {
        this._sprite = new Sprite();
        this._sprite.x = x;
        this._sprite.y = y;
        this._speed = speed;
        this._size = size;
        this._color = color;
        this._alpha = alpha;
        this._rotation = rotation;
        this._scale = scale;
        this._acceleration = acceleration;
        this._life = 0;
        this._maxLife = 60;
        this._active = false;
        this._direction = Math.random() * 6.28;
    }

    start() {
        this._life = 0;
        this._active = true;
        this._direction = Math.random() * 6.28;
    }

    update() {
        if (!this._active) return;

        this._life++;
        if (this._life >= this._maxLife) {
            this._active = false;
            return;
        }

        this._direction += this._acceleration;
        this._sprite.setFrame(0, 0, this._size, this._size);
        this._sprite.setColorTone([0, 0, 0, 0]);
        this._sprite.setBlendColor([this._color, this._color]);
        this._sprite.setBlendMode(1);
        this._sprite.setOpacity(this._alpha * 255);
        this._sprite.setRotation(this._rotation + this._direction);
        this._sprite.setScale(this._scale * (1 - this._life / this._maxLife));

        const angle = this._direction;
        this._sprite.x += Math.cos(angle) * this._speed;
        this._sprite.y += Math.sin(angle) * this._speed;
    }

    destroy() {
        this._sprite.removeAllChildren();
        this._sprite.destroy();
    }
}

// Main initialization
const enchantments = new MenuEnchantments();
enchantments.init();

// Patch RPG Maker MZ's Scene_Menu
Scene_Menu.prototype.create = function() {
    Scene_Base.prototype.create.call(this);

    // Create windows
    this.createCommandWindow();
    this.createGoldWindow();
    this.createStatusWindow();
    this.createOptionsWindow();
    this.createSavefileWindow();

    // Set up
    this._commandWindow.select(0);
    this._statusWindow.setParty($gameParty);
    this._goldWindow.setValue($gameParty.gold());
    this._savefileWindow.setSavefiles(this.getSavefiles());
    this._savefileWindow.select(0);

    // Enchant the status window
    enchantments.enchantStatusWindow(this._statusWindow);
};

// Patch Window_MenuStatus to make it work with our enchantments
Window_MenuStatus.prototype.refresh = function() {
    this.contents.clear();

    const rect = this.getLineRect(0);
    const y = rect.y + rect.height / 2 - this.lineHeight() / 2;

    this.changeTextColor(this.normalColor());
    this.drawTextEx($gameSystem.escapeName($gameParty.leader().name), rect.x, y);

    this.drawActorLv($gameParty.leader());
    this.drawGauge(0, $gameParty.agilityPoints());
    this.drawGauge(1, $gameParty.maxAgilityPoints() - $gameParty.agilityPoints());

    this.changeTextColor(this NormalColor());
    this.drawTextEx('HP', rect.x, rect.y + rect.height - this.lineHeight() / 2);
    this.drawTextEx('MP', rect.x, rect.y + 2 * rect.height - this.lineHeight() / 2);
};

// Patch DataManager to handle our custom enhancements
DataManager.prototype._database = function() {
    DataManager._database.call(this);
    this._enchantData = {};
    return this._enchantData;
};

// Export for RPG Maker MZ
export default enchantments;

use std::path::{Path, PathBuf};
use std::fs;
use std::io::{self, Write};
use colored::Colorize;
use rand::Rng;
use crossterm::{
    event::{Event, KeyCode},
    execute,
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternativeScreen, LeaveAlternativeScreen},
    cursor::{Hide, Show},
    style::{Print, SetBackgroundColor, SetForegroundColor},
};
use tui::{
    backend::CrosstermBackend,
    Terminal,
    layout::{Constraint, Direction, Layout},
    style::{Color, Style},
    widgets::{Block, Borders, Paragraph, Tabs},
    text::{Span, Spans},
};

/// Main structure representing a file system node with fractal properties
#[derive(Debug, Clone)]
struct FractalNode {
    path: PathBuf,
    is_dir: bool,
    children: Vec<FractalNode>,
    expanded: bool,
    depth: usize,
    color: Color,
    symbol: String,
}

/// Generate a visually appealing color based on depth and whether it's a directory
fn generate_color(depth: usize, is_dir: bool) -> Color {
    let mut rng = rand::thread_rng();
    let hue = (depth as f32 * 10.0 + if is_dir { 30.0 } else { 0.0 }) % 360.0;
    let saturation = 0.9 + (depth as f32 * 0.02).min(0.2);
    let value = 0.9 + (depth as f32 * 0.01).min(0.1);

    // Convert HSV to RGB for terminal display
    let chroma = value * saturation;
    let h_prime = hue / 60.0;
    let x = chroma * (1.0 - ((h_prime % 2.0) - 1.0).abs());
    let mut r = 0.0;
    let mut g = 0.0;
    let mut b = 0.0;

    match (h_prime.floor() as usize) {
        0 => { r = chroma; g = x; }
        1 => { r = x; g = chroma; }
        2 => { g = chroma; b = x; }
        3 => { g = x; b = chroma; }
        4 => { r = x; b = chroma; }
        _ => { r = chroma; b = x; }
    }

    let r = (r * 255.0).round() as u8;
    let g = (g * 255.0).round() as u8;
    let b = (b * 255.0).round() as u8;

    Color::Rgb(r, g, b)
}

/// Create a visual symbol based on node type and expansion state
fn generate_symbol(is_dir: bool, expanded: bool) -> String {
    if is_dir {
        if expanded {
            "📂".to_string() // Open folder symbol
        } else {
            "📁".to_string() // Closed folder symbol
        }
    } else {
        match rand::thread_rng().gen_range(0..4) {
            0 => "📄".to_string(),  // Document
            1 => "📑".to_string(),  // Page
            2 => "📝".to_string(),  // Note
            _ => "📋".to_string(),  // Clipboard
        }
    }
}

/// Recursively build the fractal tree structure from a directory
fn build_fractal_tree(path: &Path, depth: usize) -> FractalNode {
    let is_dir = path.is_dir();
    let color = generate_color(depth, is_dir);
    let symbol = generate_symbol(is_dir, false);

    let mut children = Vec::new();

    if is_dir {
        if let Ok(entries) = fs::read_dir(path) {
            for entry in entries.flatten() {
                let entry_path = entry.path();
                if entry_path.is_dir() || entry_path.is_file() {
                    children.push(build_fractal_tree(&entry_path, depth + 1));
                }
            }
        }
    }

    FractalNode {
        path: path.to_path_buf(),
        is_dir,
        children,
        expanded: false,
        depth,
        color,
        symbol,
    }
}

/// Calculate the indentation based on depth for proper tree alignment
fn calculate_indent(depth: usize) -> usize {
    depth * 3 + 2
}

/// Render a single node with proper fractal-style expansion effects
fn render_node(node: &FractalNode, prefix: &str, terminal: &mut Terminal<CrosstermBackend>) -> io::Result<()> {
    let indent = " ".repeat(calculate_indent(node.depth));
    let node_text = Spans::from(vec![
        Span {
            content: format!("{} {}", prefix, node.symbol),
            style: Style::default().fg(node.color),
        },
        Span {
            content: node.path.file_name()
                .map_or_else(|| "".to_string(), |name| name.to_string_lossy().into_owned()),
            style: Style::default().fg(node.color),
        },
    ]);

    terminal.draw(|f| {
        f.render_paragraph(
            node.path.file_name()
                .map_or_else(|| "".to_string(), |name| name.to_string_lossy().into_owned()),
            Block::default()
                .borders(Borders::NONE)
                .style(Style::default().fg(node.color)),
            (0, node.depth as u16),
        )
    })?;

    if node.expanded && node.is_dir {
        for (i, child) in node.children.iter().enumerate() {
            let is_last = i == node.children.len() - 1;
            let connector = if is_last { "└ " } else { "├ " };
            let prefix = if is_last { "  " } else { "│ " };
            render_node(child, connector, terminal)?;
        }
    }

    Ok(())
}

/// Apply fractal expansion effect to the tree
fn apply_fractal_expansion(root: &mut FractalNode, depth: usize) {
    if depth > 0 {
        if rand::thread_rng().gen_bool(0.7) {
            root.expanded = true;
        }

        for child in &mut root.children {
            apply_fractal_expansion(child, depth + 1);
        }
    }
}

/// Main rendering function with interactive controls
fn render_tree(root: &FractalNode, terminal: &mut Terminal<CrosstermBackend>) -> io::Result<()> {
    terminal.clear()?;

    let layout = Layout::default()
        .direction(Direction::Vertical)
        .constraints(vec![
            Constraint::Percentage(100),
        ])
        .margin(1)
        .split(terminal.size()?);

    let block = Block::default()
        .borders(Borders::ALL)
        .title("Fractal File Explorer". bright_blue().bold())
        .style(Style::default().bg(Color::DarkBlue));

    terminal.draw(|f| {
        f.render_block(block, layout[0], |f| {
            for (i, node) in root.traverse().enumerate() {
                let indent = " ".repeat(calculate_indent(node.depth));
                let prefix = if node.depth == 0 { "" } else {
                    match node.children.iter().position(|n| n == node) {
                        Some(pos) if pos == node.children.len() - 1 => "  ",
                        _ => "│ "
                    }
                };

                let symbol = if node.is_dir {
                    if node.expanded { "📂" } else { "📁" }
                } else {
                    match rand::thread_rng().gen_range(0..4) {
                        0 => "📄", 1 => "📑", 2 => "📝", _ => "📋",
                    }
                };

                let content = Spans::from(vec![
                    Span {
                        content: format!("{}{}", indent, prefix),
                        style: Style::default().fg(node.color),
                    },
                    Span {
                        content: format!("{} {}", symbol, node.path.file_name()
                            .map_or_else(|| "".to_string(), |name| name.to_string_lossy().into_owned())),
                        style: Style::default().fg(node.color).bold(),
                    },
                ]);

                f.render_paragraph(content, (0, i as u16), |span| {
                    span.style = Style::default().fg(node.color);
                });
            }
        });
    })?;

    Ok(())
}

/// Extension trait to traverse the tree
trait Traverse {
    fn traverse(&self) -> Vec<&FractalNode>;
}

impl Traverse for FractalNode {
    fn traverse(&self) -> Vec<&FractalNode> {
        let mut result = vec![self];
        for child in &self.children {
            result.extend(child.traverse());
        }
        result
    }
}

fn main() -> io::Result<()> {
    // Initialize colored output
    colored::control::set_override(true);

    // Parse command line arguments for directory path
    let args: Vec<String> = std::env::args().collect();
    let path = if args.len() > 1 {
        Path::new(&args[1])
    } else {
        Path::new(".")
    };

    if !path.exists() {
        eprintln!("Error: Path does not exist: {}", path.display());
        std::process::exit(1);
    }

    if !path.is_dir() {
        eprintln!("Error: Path is not a directory: {}", path.display());
        std::process::exit(1);
    }

    // Build the initial fractal tree
    let mut root = build_fractal_tree(path, 0);
    apply_fractal_expansion(&mut root, 0);

    // Initialize terminal for interactive display
    enable_raw_mode()?;
    let mut terminal = Terminal::new(CrosstermBackend::new(io::stderr()))?;
    terminal.hide_cursor()?;
    execute!(terminal.backend_mut(), EnterAlternativeScreen)?;

    // Main rendering loop with keyboard controls
    let mut rng = rand::thread_rng();
    loop {
        terminal.draw(|f| {
            render_tree(&root, f)
        })?;

        if let Event::Key(key) = crossterm::event::poll(1000 / 60)? {
            match key.code {
                KeyCode::Char('q') | KeyCode::Esc => break,
                KeyCode::Char(' ') => {
                    // Toggle expansion at root level
                    root.expanded = !root.expanded;
                    if root.expanded {
                        apply_fractal_expansion(&mut root, 0);
                    }
                },
                KeyCode::Char('r') => {
                    // Randomize the fractal structure
                    root = build_fractal_tree(path, 0);
                    apply_fractal_expansion(&mut root, 0);
                },
                KeyCode::Down | KeyCode::Up | KeyCode::Left | KeyCode::Right => {
                    // For future navigation implementation
                    let _ = key;
                },
                _ => {}
            }
        }
    }

    // Clean up terminal
    terminal.show_cursor()?;
    execute!(terminal.backend_mut(), LeaveAlternativeScreen)?;
    disable_raw_mode()?;

    Ok(())
}