A!leys Galerie

// Magical RPG Inventory with Confetti
// Ein interaktives Inventory-System mit magischen Effekten und Konfetti bei Erfolg

class MagicalInventory {
    constructor() {
        this.items = [
            { name: "Health Potion", type: "consumable", effect: "+20 HP" },
            { name: "Mana Elixir", type: "consumable", effect: "+30 MP" },
            { name: "Steel Sword", type: "weapon", effect: "+15 ATK" },
            { name: "Leather Armor", type: "armor", effect: "+10 DEF" },
            { name: "Dragon Scale", type: "material", effect: "Crafting" },
            { name: "Magic Wand", type: "weapon", effect: "+25 MAG" }
        ];
        this.equipped = { weapon: null, armor: null };
        this.stats = { hp: 100, mp: 50, atk: 10, def: 5, mag: 5 };
    }

    // Magische Effekte bei Item-Verwendung
    useItem(itemName) {
        const item = this.items.find(i => i.name === itemName);
        if (!item) return "Item not found!";

        switch (item.type) {
            case "consumable":
                if (item.name === "Health Potion") {
                    if (this.stats.hp < 100) {
                        this.stats.hp = Math.min(100, this.stats.hp + 20);
                        return `Used ${item.name}! HP: ${this.stats.hp}/100`;
                    } else return "HP is already full!";
                }
                if (item.name === "Mana Elixir") {
                    if (this.stats.mp < 50) {
                        this.stats.mp = Math.min(50, this.stats.mp + 30);
                        return `Used ${item.name}! MP: ${this.stats.mp}/50`;
                    } else return "MP is already full!";
                }
                break;
            case "weapon":
                this.equipped.weapon = item;
                return `Equipped ${item.name}! ATK: +${item.effect.slice(4)}`;
            case "armor":
                this.equipped.armor = item;
                return `Equipped ${item.name}! DEF: +${item.effect.slice(4)}`;
            default:
                return `Cannot use ${item.name} directly!`;
        }
    }

    // Magischer Angriff mit Konfetti
    attack(enemyStats) {
        let damage = this.stats.atk + (this.equipped.weapon ? parseInt(this.equipped.weapon.effect.slice(4)) : 0);
        damage = Math.max(1, Math.floor(damage * (1 - enemyStats.def / 200))); // DEF reduces damage

        enemyStats.hp -= damage;
        this.showConfetti("Attack successful!");

        if (enemyStats.hp <= 0) {
            return "Enemy defeated! Victory!";
        } else {
            return `Dealt ${damage} damage! Enemy HP: ${enemyStats.hp}`;
        }
    }

    // Magische Kommunalität
    combineItems(item1, item2) {
        const i1 = this.items.find(i => i.name === item1);
        const i2 = this.items.find(i => i.name === item2);

        if (!i1 || !i2) return "Items not found!";
        if (i1.type !== "material" || i2.type !== "material") return "Only materials can be combined!";

        // Magische Kombination
        const newItem = {
            name: `Mystic ${i1.name.replace("Dragon ", "")}${i2.name.replace("Dragon ", "")}`,
            type: "weapon",
            effect: "+30 MAG +15 ATK"
        };

        this.items.push(newItem);
        this.items = this.items.filter(i => i.name !== item1 && i.name !== item2);
        this.showConfetti("Successfully combined items!");
        return `Created ${newItem.name}!`;
    }

    // Magische Konfetti-Anzeige
    showConfetti(message) {
        console.log("\n" + "=" repeat(50));
        console.log(" * ".repeat(10));
        console.log("  " + message.split(" ").join(" * ") + "  ");
        console.log(" * ".repeat(10));
        console.log("=" repeat(50) + "\n");
    }

    // Magische Status-Anzeige
    showStatus() {
        console.log("\n" + "=".repeat(50));
        console.log("MAGICAL INVENTORY STATUS");
        console.log("=".repeat(50));
        console.log(`HP: ${this.stats.hp}/100`);
        console.log(`MP: ${this.stats.mp}/50`);
        console.log(`ATK: ${this.stats.atk + (this.equipped.weapon ? parseInt(this.equipped.weapon.effect.slice(4)) : 0)}`);
        console.log(`DEF: ${this.stats.def + (this.equipped.armor ? parseInt(this.equipped.armor.effect.slice(4)) : 0)}`);
        console.log(`MAG: ${this.stats.mag + (this.equipped.weapon ? parseInt(this.equipped.weapon.effect.slice(8)) : 0)}`);
        console.log("\nItems:");
        this.items.forEach(item => console.log(`- ${item.name} (${item.type})`));
        console.log("\nEquipped:");
        if (this.equipped.weapon) console.log(`- Weapon: ${this.equipped.weapon.name}`);
        if (this.equipped.armor) console.log(`- Armor: ${this.equipped.armor.name}`);
        console.log("=".repeat(50) + "\n");
    }
}

// Magische Main-Funktion
function main() {
    const inventory = new MagicalInventory();

    console.log("WELCOME TO THE MAGICAL INVENTORY SYSTEM!");
    console.log("Type 'help' for commands.\n");

    // Magische Menü-Schleife
    while (true) {
        console.log("> ");
        const input = require('readline').createInterface({
            input: process.stdin,
            output: process.stdout
        });
        const line = input[Symbol('asyncIterator')]().next().value;

        if (line === "help") {
            console.log("\nCommands:");
            console.log("- use [item] - Use an item (e.g., 'use Health Potion')");
            console.log("- attack - Attack an enemy");
            console.log("- combine [item1] [item2] - Combine two materials (e.g., 'combine Dragon Scale Dragon Scale')");
            console.log("- status - Show your status and inventory");
            console.log("- exit - Exit the program\n");
        }
        else if (line === "exit") break;
        else if (line.startsWith("use ")) {
            const item = line.slice(4);
            console.log(inventory.useItem(item));
        }
        else if (line === "attack") {
            const enemy = { hp: 50, def: 10 };
            console.log(inventory.attack(enemy));
        }
        else if (line.startsWith("combine ")) {
            const parts = line.slice(8).split(" ");
            if (parts.length === 2) {
                console.log(inventory.combineItems(parts[0], parts[1]));
            } else {
                console.log("Usage: combine [item1] [item2]");
            }
        }
        else if (line === "status") {
            inventory.showStatus();
        }
        else {
            console.log("Unknown command. Type 'help' for commands.\n");
        }
        input.close();
    }
    console.log("\nMAGICAL SESSION ENDED. THANK YOU FOR PLAYING!\n");
}

// Magische Funktion zum Starten
main();

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>FontSpark — Creative Font Pairing</title>
    <link rel="preconnect" href="https://fonts.googleapis.com">
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
    <style>
        :root {
            --accent: #FF8C00;
            --bg-dark: #1a1a1a;
            --bg-light: #f8f8f8;
            --text-dark: #333;
            --text-light: #fff;
            --card-bg: rgba(255, 255, 255, 0.9);
        }

        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }

        body {
            font-family: 'Inter', sans-serif;
            background-color: var(--bg-light);
            color: var(--text-dark);
            line-height: 1.6;
            padding: 20px;
        }

        .container {
            max-width: 1000px;
            margin: 0 auto;
            padding: 20px;
        }

        h1 {
            font-family: 'Bebas Neue', cursive;
            font-size: 2.5rem;
            text-align: center;
            margin-bottom: 1rem;
            color: var(--accent);
        }

        .subtitle {
            text-align: center;
            margin-bottom: 3rem;
            color: #666;
        }

        .font-picker {
            display: flex;
            justify-content: space-between;
            margin-bottom: 3rem;
            gap: 20px;
        }

        .picker-group {
            flex: 1;
            background-color: var(--card-bg);
            border-radius: 12px;
            padding: 20px;
            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
            position: relative;
        }

        .picker-group h3 {
            margin-bottom: 1rem;
            font-weight: 600;
        }

        .font-family {
            font-size: 1.8rem;
            font-weight: 700;
            letter-spacing: 0.5px;
            padding: 15px;
            margin: 10px 0;
            border-radius: 8px;
            cursor: pointer;
            transition: all 0.3s ease;
            display: flex;
            align-items: center;
        }

        .font-family.selected {
            background-color: var(--accent);
            color: var(--text-light);
            border: 2px solid var(--text-light);
            transform: scale(1.02);
        }

        .font-family::before {
            content: 'Aa';
            font-size: 0.8rem;
            margin-right: 10px;
            color: #999;
        }

        .font-family.selected::before {
            color: var(--text-light);
        }

        .toggle-switch {
            position: absolute;
            top: 10px;
            right: 10px;
            width: 40px;
            height: 20px;
            background-color: #ccc;
            border-radius: 10px;
            cursor: pointer;
            transition: background-color 0.3s;
        }

        .toggle-switch.active {
            background-color: var(--accent);
        }

        .toggle-switch::after {
            content: '';
            position: absolute;
            top: 2px;
            left: 2px;
            width: 16px;
            height: 16px;
            background-color: white;
            border-radius: 50%;
            transition: transform 0.3s;
        }

        .toggle-switch.active::after {
            transform: translateX(20px);
        }

        .contrast-slider {
            margin: 20px 0;
        }

        .contrast-slider label {
            display: block;
            margin-bottom: 8px;
            font-weight: 500;
        }

        .slider {
            -webkit-appearance: none;
            width: 100%;
            height: 6px;
            border-radius: 3px;
            background: #d1d5db;
            outline: none;
            opacity: 0.9;
            transition: opacity .2s;
        }

        .slider:hover {
            opacity: 1;
        }

        .slider::-webkit-slider-thumb {
            -webkit-appearance: none;
            appearance: none;
            width: 20px;
            height: 20px;
            background: var(--accent);
            cursor: pointer;
            border-radius: 50%;
            border: 4px solid white;
            box-shadow: 0 0 0 0 rgba(0, 0, 0, 0);
            transition: background-color 0.2s;
        }

        .slider::-webkit-slider-thumb:hover {
            background: #f97316;
        }

        .slider::-moz-range-thumb {
            width: 20px;
            height: 20px;
            background: var(--accent);
            cursor: pointer;
            border-radius: 50%;
            border: 4px solid white;
            transition: background-color 0.2s;
        }

        .slider::-moz-range-thumb:hover {
            background: #f97316;
        }

        .controls {
            display: flex;
            justify-content: center;
            gap: 20px;
            margin: 2rem 0;
        }

        button {
            background-color: var(--accent);
            color: white;
            border: none;
            padding: 12px 24px;
            border-radius: 8px;
            font-weight: 600;
            cursor: pointer;
            transition: all 0.3s ease;
            display: flex;
            align-items: center;
            gap: 8px;
        }

        button:hover {
            background-color: #e07a00;
            transform: translateY(-2px);
            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
        }

        button:disabled {
            background-color: #ccc;
            cursor: not-allowed;
            transform: none;
        }

        .export-button {
            background-color: #2563eb;
        }

        .export-button:hover {
            background-color: #1d4ed8;
        }

        .mood-selector {
            margin-bottom: 1rem;
        }

        .mood-options {
            display: flex;
            justify-content: center;
            gap: 10px;
            flex-wrap: wrap;
        }

        .mood-option {
            background-color: #e5e7eb;
            padding: 8px 12px;
            border-radius: 20px;
            font-size: 0.9rem;
            cursor: pointer;
            transition: all 0.2s;
        }

        .mood-option:hover, .mood-option.selected {
            background-color: var(--accent);
            color: white;
        }

        .contrast-result {
            display: flex;
            justify-content: center;
            margin: 2rem 0;
        }

        .contrast-text {
            font-size: 3rem;
            padding: 20px;
            border-radius: 8px;
            display: flex;
            align-items: center;
            justify-content: center;
            width: 50%;
            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
            text-align: center;
        }

        .contrast-text.left {
            background-color: var(--card-bg);
            color: var(--text-dark);
        }

        .contrast-text.right {
            background-color: var(--accent);
            color: var(--text-light);
        }

        .export-section {
            margin-top: 3rem;
            padding: 20px;
            background-color: var(--card-bg);
            border-radius: 12px;
            display: none;
        }

        .export-section h3 {
            margin-bottom: 1rem;
        }

        .export-code {
            background-color: #f3f4f6;
            border: 1px solid #d1d5db;
            border-radius: 8px;
            padding: 15px;
            font-family: 'Monaco', 'Menlo', monospace;
            white-space: pre-wrap;
            overflow-x: auto;
        }

        .export-button {
            background-color: #2563eb;
        }

        .export-button:hover {
            background-color: #1d4ed8;
        }

        @media (max-width: 768px) {
            .font-picker {
                flex-direction: column;
            }
            .contrast-text {
                width: 80%;
                font-size: 2rem;
            }
        }

        /* Load Google Fonts */
        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Bebas+Neue&display=swap');
    </style>
</head>
<body>
    <div class="container">
        <h1>FontSpark</h1>
        <p class="subtitle">Find the perfect font pair with AI-inspired contrast</p>

        <div class="mood-selector">
            <h3>Mood</h3>
            <div class="mood-options">
                <div class="mood-option selected" data-mood="playful">Playful</div>
                <div class="mood-option" data-mood="serious">Serious</div>
                <div class="mood-option" data-mood="elegant">Elegant</div>
                <div class="mood-option" data-mood="minimal">Minimal</div>
                <div class="mood-option" data-mood="vintage">Vintage</div>
            </div>
        </div>

        <div class="font-picker">
            <div class="picker-group">
                <div class="toggle-switch active" data-group="fontA"></div>
                <h3>Primary Font</h3>
                <div class="font-family" data-font="Comic Sans MS">Comic Sans MS</div>
                <div class="font-family" data-font="Times New Roman">Times New Roman</div>
                <div class="font-family" data-font="Helvetica">Helvetica</div>
                <div class="font-family" data-font="Courier New">Courier New</div>
                <div class="font-family" data-font="Georgia">Georgia</div>
                <div class="font-family" data-font="Arial">Arial</div>
                <div class="font-family" data-font="Verdana">Verdana</div>
            </div>

            <div class="picker-group">
                <div class="toggle-switch" data-group="fontB"></div>
                <h3>Accent Font</h3>
                <div class="font-family" data-font="Impact">Impact</div>
                <div class="font-family" data-font="Papyrus">Papyrus</div>
                <div class="font-family" data-font="Lobster">Lobster</div>
                <div class="font-family" data-font="Bebas Neue">Bebas Neue</div>
                <div class="font-family" data-font="Rockwell">Rockwell</div>
                <div class="font-family" data-font="Bruschettin">Bruschettin</div>
                <div class="font-family" data-font="Raleway">Raleway</div>
            </div>
        </div>

        <div class="contrast-slider">
            <label for="contrastSlider">Contrast Level</label>
            <input type="range" min="10" max="90" value="50" class="slider" id="contrastSlider">
        </div>

        <div class="controls">
            <button id="generateBtn">Generate Pair</button>
            <button id="exportBtn" class="export-button" disabled>Export CSS</button>
        </div>

        <div class="contrast-result">
            <div class="contrast-text left">
                <span class="sample-text">Sample text goes here</span>
            </div>
            <div class="contrast-text right">
                <span class="sample-text">Sample text goes here</span>
            </div>
        </div>

        <div class="export-section" id="exportSection">
            <h3>Copy &amp; Use</h3>
            <p>Your font pairing CSS:</p>
            <div class="export-code" id="exportCode">
                /* Font Pairing CSS */
                .primary-font {
                  font-family: 'Comic Sans MS', cursive, sans-serif;
                  font-weight: 400;
                }
                .accent-font {
                  font-family: 'Impact', sans-serif;
                  font-weight: 700;
                }
            </div>
        </div>
    </div>

    <script>
        document.addEventListener('DOMContentLoaded', function() {
            // DOM Elements
            const fontAGroup = document.querySelector('[data-group="fontA"]');
            const fontBGroup = document.querySelector('[data-group="fontB"]');
            const fontAFamilies = document.querySelectorAll('[data-group="fontA"] .font-family');
            const fontBFamilies = document.querySelectorAll('[data-group="fontB"] .font-family');
            const moodOptions = document.querySelectorAll('.mood-option');
            const contrastSlider = document.getElementById('contrastSlider');
            const generateBtn = document.getElementById('generateBtn');
            const exportBtn = document.getElementById('exportBtn');
            const exportSection = document.getElementById('exportSection');
            const exportCode = document.getElementById('exportCode');
            const leftText = document.querySelector('.contrast-text.left .sample-text');
            const rightText = document.querySelector('.contrast-text.right .sample-text');

            // State
            let currentFontA = 'Comic Sans MS';
            let currentFontB = 'Impact';
            let currentMood = 'playful';
            let contrastValue = 50;

            // Initialize
            updateFontDisplay();
            updateContrastResult();
            setupEventListeners();

            function setupEventListeners() {
                // Toggle between font A and B
                fontAGroup.addEventListener('click', (e) => {
                    if (e.target.closest('.font-family')) return;
                    fontAGroup.classList.toggle('active');
                    fontBGroup.classList.toggle('active');
                });

                fontBGroup.addEventListener('click', (e) => {
                    if (e.target.closest('.font-family')) return;
                    fontAGroup.classList.toggle('active');
                    fontBGroup.classList.toggle('active');
                });

                // Font selection
                fontAFamilies.forEach(font => {
                    font.addEventListener('click', () => {
                        currentFontA = font.dataset.font;
                        updateFontDisplay();
                        generateBtn.disabled = false;
                    });
                });

                fontBFamilies.forEach(font => {
                    font.addEventListener('click', () => {
                        currentFontB = font.dataset.font;
                        updateFontDisplay();
                        generateBtn.disabled = false;
                    });
                });

                // Mood selection
                moodOptions.forEach(option => {
                    option.addEventListener('click', () => {
                        moodOptions.forEach(opt => opt.classList.remove('selected'));
                        option.classList.add('selected');
                        currentMood = option.dataset.mood;
                        generateBtn.disabled = false;
                    });
                });

                // Contrast slider
                contrastSlider.addEventListener('input', () => {
                    contrastValue = parseInt(contrastSlider.value);
                    updateContrastResult();
                });

                // Generate button
                generateBtn.addEventListener('click', () => {
                    generateFontPair();
                    exportBtn.disabled = false;
                    exportSection.style.display = 'block';
                });

                // Export button
                exportBtn.addEventListener('click', () => {
                    copyToClipboard(exportCode.textContent);
                    alert('CSS code copied to clipboard!');
                });
            }

            function updateFontDisplay() {
                // Clear selections
                fontAFamilies.forEach(f => f.classList.remove('selected'));
                fontBFamilies.forEach(f => f.classList.remove('selected'));

                // Select current fonts
                const fontAFamily = Array.from(fontAFamilies).find(f => f.dataset.font === currentFontA);
                const fontBFamily = Array.from(fontBFamilies).find(f => f.dataset.font === currentFontB);

                if (fontAFamily) fontAFamily.classList.add('selected');
                if (fontBFamily) fontBFamily.classList.add('selected');

                updateContrastResult();
            }

            function updateContrastResult() {
                const contrastPercent = contrastValue;

                // Apply contrast to text (simplified for demo)
                const leftFontWeight = Math.min(400, 400 + (100 - contrastPercent) * 2);
                const rightFontWeight = Math.min(900, 400 + contrastPercent * 2);

                leftText.style.fontWeight = leftFontWeight;
                rightText.style.fontWeight = rightFontWeight;

                // Apply actual font families
                leftText.style.fontFamily = `${currentFontA}, sans-serif`;
                rightText.style.fontFamily = `${currentFontB}, sans-serif`;
            }

            function generateFontPair() {
                // In a real implementation, this would use actual font metrics
            }
        });
    </script>
</body>
</html>
```

use std::{
    fs,
    io,
    path::{Path, PathBuf},
    sync::{Arc, Mutex},
};
use hyper::{Body, Request, Response, Server, StatusCode};
use hyper::service::{make_service_fn, service_fn};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

// Struktur für den Server-Zustand (shared zwischen Requests)
#[derive(Clone, Default)]
struct ServerState {
    current_dir: Arc<Mutex<PathBuf>>,
    history: Arc<Mutex<Vec<PathBuf>>>,
}

// Struktur für das URL-Query-Objekt
#[derive(Deserialize)]
struct QueryParams {
    path: Option<String>,
    save: Option<bool>,
}

// Hauptfunktion mit asynchronem HTTP-Server
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Standardverzeichnis (wird später geladen)
    let mut current_dir = PathBuf::from(".");

    // Lade letzten Stand aus localStorage (Simuliert)
    if let Ok(history) = load_history() {
        current_dir = if history.is_empty() {
            PathBuf::from(".")
        } else {
            history.last().unwrap().clone()
        };
    }

    // Erstelle den Server-Zustand
    let state = ServerState {
        current_dir: Arc::new(Mutex::new(current_dir)),
        history: Arc::new(Mutex::new(load_history().unwrap_or_default())),
    };

    // URL: http://localhost:8080
    let addr = ([127, 0, 0, 1], 8080).into();

    // Erstelle den HTTP-Server
    let make_svc = make_service_fn(|_conn| {
        let state = state.clone();
        async move {
            Ok::<_, hyper::Error>(service_fn(move |req: Request<Body>| {
                handle_request(req, state.clone())
            }))
        }
    });

    println!("Server läuft auf http://localhost:8080");
    Server::bind(&addr).serve(make_svc).await?;

    Ok(())
}

// Verarbeitet eingehende HTTP-Requests
async fn handle_request(
    req: Request<Body>,
    state: ServerState,
) -> Result<Response<Body>, hyper::Error> {
    // Parsen der URL
    let path = req.uri().path().to_string();
    let query_string = req.uri().query().unwrap_or_default();
    let query_params: QueryParams = match serde_urlencoded::from_str(query_string) {
        Ok(p) => p,
        Err(_) => QueryParams { path: None, save: None },
    };

    // Aktuelle Pfad-Konstruktion
    let mut current_dir = state.current_dir.lock().unwrap().clone();
    if let Some(ref path) = query_params.path {
        current_dir = if path.is_empty() {
            PathBuf::from(".")
        } else {
            PathBuf::from(path)
        };
        // Aktualisiere den Pfad im Zustand
        let mut history = state.history.lock().unwrap();
        history.push(current_dir.clone());
        if query_params.save.unwrap_or(true) {
            save_history(&history);
        }
    }

    // Versuche, den Ordner zu lesen
    match fs::read_dir(&current_dir) {
        Ok(entries) => {
            // Erstelle die Baumansicht
            let tree = generate_tree(&current_dir, entries);
            let response = Response::builder()
                .status(StatusCode::OK)
                .header("Content-Type", "text/html")
                .body(Body::from(tree))?;
            Ok(response)
        }
        Err(_) => {
            // Falls der Ordner ungültig ist, zeige Fehlerseite
            let response = Response::builder()
                .status(StatusCode::NOT_FOUND)
                .body(Body::from(
                    format!(
                        r#"
                        <h1>404 Not Found</h1>
                        <p>Die angegebene Pfad: {} existiert nicht.</p>
                        <a href="/?save=true">Zurück zur Startseite</a>
                        "#,
                        current_dir.display()
                    ),
                ))?;
            Ok(response)
        }
    }
}

// Generiert einen Baum aus den Dateien
fn generate_tree(parent: &Path, entries: io::Result<fs::ReadDir>) -> String {
    let mut tree = String::new();
    tree.push_str("<html><head><title>Dateibaum</title></head><body><h1>Dateibaum: ");
    tree.push_str(parent.display().to_string().as_str());
    tree.push_str("</h1><ul>");

    for entry in entries.unwrap() {
        let entry = entry.unwrap();
        let name = entry.file_name().to_string_lossy();
        let path = entry.path();

        if path.is_dir() {
            tree.push_str(&format!("<li><a href=\"/?path={}\">{}/</a>", path.display(), name));
        } else {
            tree.push_str(&format!("<li>{}", name));
        }
    }

    tree.push_str("</ul><a href=\"/?save=true\">Zurück zur Startseite</a></body></html>");
    tree
}

// Simuliert localStorage für den letzten Stand
fn save_history(history: &[PathBuf]) -> Result<(), Box<dyn std::error::Error>> {
    // In einer echten App würdest du hier e.g. eine Datei oder echte localStorage (z.B. über wasm-bindgen) verwenden
    // Für dieses Beispiel speichern wir nur in einem HashMap (Simuliert)
    let history_str: String = history.iter().map(|p| p.to_string_lossy().into_owned()).collect();
    std::env::set_var("RUSTY_FILE_TREE_HISTORY", history_str);
    Ok(())
}

// Lädt den letzten Stand
fn load_history() -> Result<Vec<PathBuf>, Box<dyn std::error::Error>> {
    if let Some(history_str) = std::env::var("RUSTY_FILE_TREE_HISTORY").ok() {
        let history: Vec<PathBuf> = history_str
            .split(',')
            .map(|s| PathBuf::from(s.trim()))
            .collect();
        Ok(history)
    } else {
        Ok(vec![])
    }
}

#!/usr/bin/env python3
"""
HashSleuth - Interactive Duplicate File Finder

Features:
- Finds duplicate files using SHA-256 hashing
- Visualizes hash distribution and clusters
- Smooth animations between states
- Interactive file selection
- Progress tracking
"""

import os
import hashlib
import time
import typing as t
from pathlib import Path
from dataclasses import dataclass, field
from collections import defaultdict

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from matplotlib.colors import ListedColormap
import PySimpleGUI as sg

# Constants
MAX_FILE_SIZE = 100 * 1024 * 1024  # 100MB
HASH_FINGERPRINT_LENGTH = 6
VISUAL_DENSITY = 0.1
ANIMATION_DURATION = 1000  # ms

@dataclass(order=True)
class FileHash:
    """Immutable file hash representation for comparison."""
    path: str
    size: int
    hash: str
    timestamp: float = field(compare=False)
    display_name: str = field(compare=False)

class HashVisualizer:
    """Handles the visualization of hash distributions."""

    def __init__(self):
        self.fig, self.ax = plt.subplots(figsize=(10, 8))
        plt.subplots_adjust(left=0, right=1, top=1, bottom=0)
        plt.axis('off')

        # Create colormap
        self.colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFBE0B',
                      '#FB5607', '#8338EC', '#3A86FF', '#FF006E']
        self.cmap = ListedColormap(self.colors)

        self.sc = self.ax.scatter([], [], s=5, color='white', alpha=0)
        self.ax.set_facecolor('#222222')
        self.ax.grid(False)
        self.fig.patch.set_facecolor('#222222')

        # Store previous state for animation
        self.prev_x = []
        self.prev_y = []
        self.prev_colors = []

    def update_plot(self, x: np.ndarray, y: np.ndarray, colors: np.ndarray):
        """Updates the visualization with new data."""
        self.sc.set_offsets(np.c_[x, y])
        self.sc.set_color(colors)

        self.prev_x = x.copy()
        self.prev_y = y.copy()
        self.prev_colors = colors.copy()

        # Smooth transition
        return self.sc,

    def animate_to(self, x: np.ndarray, y: np.ndarray, colors: np.ndarray):
        """Animates transition between visualizations."""
        def update(frame):
            t = frame / ANIMATION_DURATION
            current_x = (1-t) * np.array(self.prev_x) + t * x
            current_y = (1-t) * np.array(self.prev_y) + t * y
            current_colors = (1-t) * self.prev_colors + t * colors
            return self.update_plot(current_x, current_y, current_colors)

        return FuncAnimation(
            self.fig, update, frames=ANIMATION_DURATION, interval=10,
            blit=True, repeat=False
        )

class HashSleuth:
    """Main class for finding duplicate files."""

    def __init__(self):
        self.file_hashes = []
        self.hash_clusters = defaultdict(list)
        self.current_files = []
        self.visualizer = HashVisualizer()

    def _compute_hash(self, file_path: str) -> str:
        """Computes SHA-256 hash of a file."""
        if not os.path.exists(file_path):
            return ""

        sha256 = hashlib.sha256()
        try:
            with open(file_path, 'rb') as f:
                # Read in chunks to handle large files
                for chunk in iter(lambda: f.read(4096), b""):
                    sha256.update(chunk)
            return sha256.hexdigest()
        except (IOError, PermissionError):
            return ""

    def _process_file(self, file_path: str) -> t.Optional[FileHash]:
        """Processes a single file and returns its hash information."""
        if os.path.islink(file_path):
            return None

        file_stat = os.stat(file_path)
        if file_stat.st_size > MAX_FILE_SIZE:
            return None

        file_hash = self._compute_hash(file_path)
        if not file_hash:
            return None

        return FileHash(
            path=file_path,
            size=file_stat.st_size,
            hash=file_hash,
            timestamp=file_stat.st_mtime,
            display_name=os.path.basename(file_path)
        )

    def scan_directory(self, directory: str):
        """Scans a directory for duplicate files."""
        self.file_hashes = []
        self.hash_clusters.clear()

        if not os.path.isdir(directory):
            return False, 0, 0

        start_time = time.time()
        processed = 0

        for root, _, files in os.walk(directory):
            for file in files:
                file_path = os.path.join(root, file)
                file_hash = self._process_file(file_path)
                if file_hash:
                    self.file_hashes.append(file_hash)
                    self.hash_clusters[file_hash.hash].append(file_hash)
                    processed += 1

                    # Update progress in UI
                    if sg.WINDOWS and sg.WINDOWS[0].visible:
                        event, values = sg.WINDOWS[0].read(timeout=0)
                        if event == sg.TIMEOUT_EVENT:
                            sg.WINDOWS[0].read_non_blocking()

        elapsed = time.time() - start_time
        return True, processed, elapsed

    def visualize_hashes(self):
        """Creates a visualization of the hash distribution."""
        if not self.file_hashes:
            return False

        # Extract hash fingerprints (first 6 chars for visualization)
        fingerprints = [fh.hash[:HASH_FINGERPRINT_LENGTH] for fh in self.file_hashes]

        # Create hash vector (normalized coordinates)
        hash_vectors = []
        for fp in fingerprints:
            # Simple hash-to-2D mapping
            h1 = sum(ord(c) for c in fp[::2]) % 256
            h2 = sum(ord(c) for c in fp[1::2]) % 256
            hash_vectors.append((h1, h2))

        # Convert to numpy array
        x = np.array([v[0] for v in hash_vectors])
        y = np.array([v[1] for v in hash_vectors])

        # Create color array based on cluster size
        colors = []
        for i, (fp, fh) in enumerate(zip(fingerprints, self.file_hashes)):
            cluster_size = len(self.hash_clusters[fp])
            color_index = min(cluster_size - 1, len(self.colors) - 1)
            colors.append(self.colors[color_index])

        colors = np.array(colors)

        # Show visualization
        anim = self.visualizer.animate_to(x, y, colors)
        plt.show()

        return True

    def show_duplicates(self):
        """Displays duplicate files in the UI."""
        if not self.hash_clusters:
            return False

        # Prepare data for the UI
        duplicates = []
        for hash_val, files in self.hash_clusters.items():
            if len(files) > 1:
                duplicates.append((hash_val, files))

        # Sort by cluster size (descending)
        duplicates.sort(key=lambda x: len(x[1]), reverse=True)

        # Update the UI
        if sg.WINDOWS and sg.WINDOWS[0].visible:
            layout = [
                [sg.Text("Duplicate Files Found:", font=('Helvetica', 16, 'bold'))],
                [sg.HSeparator()],
                [sg.Column([
                    [sg.Text(f"Cluster {i+1} (Size: {len(files)})", font=('Helvetica', 10))],
                    [sg.Text(f"Hash: {hash_val[:HASH_FINGERPRINT_LENGTH]}...", font=('Courier', 10))],
                    [sg.Listbox(
                        [f"{fh.display_name} ({fh.size/1024/1024:.2f}MB)" for fh in files],
                        size=(60, len(files)),
                        key=f"-LISTBOX-{i}-",
                        enable_events=True
                    )],
                    [sg.HSeparator()],
                ], element_justification='c') for i, (hash_val, files) in enumerate(duplicates)],
                [sg.Button("Close", size=(10, 1))]
            ]

            window = sg.Window(
                "Duplicate Files",
                layout,
                size=(600, 400),
                element_justification='c',
                background_color='#222222',
                text_color='#FFFFFF',
                font=('Helvetica', 10)
            )

            while True:
                event, values = window.read()
                if event == sg.WIN_CLOSED or event == "Close":
                    window.close()
                    break
                elif event.startswith("-LISTBOX-"):
                    idx = int(event.split("-")[2])
                    window[f"-LISTBOX-{idx}-"].update(values[f"-LISTBOX-{idx}-"], set_to_index=0)

            sg.WINDOWS[0].close()

        return True

def create_ui():
    """Creates the user interface."""
    layout = [
        [sg.Text("HashSleuth - Duplicate File Finder", font=('Helvetica', 16, 'bold'))],
        [sg.HSeparator()],
        [sg.Text("Select directory to scan:"), sg.In(size=(40, 1), key="-DIRECTORY-")],
        [sg.FolderBrowse(button_text="Browse"), sg.Button("Scan Directory")],
        [sg.HSeparator()],
        [sg.Text("Progress:"), sg.ProgressBar(max_value=100, orientation='h', size=(40, 20), key="-PROGRESS-")],
        [sg.Text("", key="-PROGRESS_TEXT-")],
        [sg.Button("Show Visualization"), sg.Button("Show Duplicates"), sg.Button("Exit")],
    ]

    return sg.Window(
        "HashSleuth",
        layout,
        size=(600, 400),
        resizable=True,
        element_justification='c',
        background_color='#222222',
        text_color='#FFFFFF',
        font=('Helvetica', 10)
    )

def main():
    """Main application function."""
    app = HashSleuth()
    window = create_ui()

    while True:
        event, values = window.read()
        if event == sg.WIN_CLOSED or event == "Exit":
            break
        elif event == "Scan Directory":
            directory = values["-DIRECTORY-"]
            if directory:
                success, processed, elapsed = app.scan_directory(directory)
                if success:
                    window["-PROGRESS-"].update(100)
                    window["-PROGRESS_TEXT-"].update(f"Scan complete. Processed {processed} files in {elapsed:.2f} seconds.")
                else:
                    window["-PROGRESS-"].update(0)
                    window["-PROGRESS_TEXT-"].update("Invalid directory path.")
        elif event == "Show Visualization":
            if app.file_hashes:
                app.visualize_hashes()
            else:
                sg.popup("Please scan a directory first.")
        elif event == "Show Duplicates":
            if app.file_hashes:
                app.show_duplicates()
            else:
                sg.popup("Please scan a directory first.")

    window.close()

if __name__ == "__main__":
    main()

"""
MemoMaster - Intelligent Note-Taking API
Features:
- Text analysis with NLP (sentiment, key terms)
- Note organization with automatic tagging
- Search by content and metadata
- Export to Markdown/PDF
"""

from typing import List, Dict, Optional
from datetime import datetime, timedelta
import uuid
import re
from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel
from starlette.responses import JSONResponse
import textstat
import nltk
from nltk.sentiment import SentimentIntensityAnalyzer
from fastapi.middleware.cors import CORSMiddleware

# Download NLTK resources
try:
    nltk.data.find('tokenizers/punkt')
    nltk.data.find('sentiment/vader_lexicon')
except LookupError:
    nltk.download('punkt')
    nltk.download('vader_lexicon')

app = FastAPI(
    title="MemoMaster API",
    description="Intelligent Note-Taking API with NLP Features",
    version="1.0.0"
)

# CORS configuration
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

class Note(BaseModel):
    title: str
    content: str
    tags: List[str] = []
    created_at: Optional[datetime] = None
    updated_at: Optional[datetime] = None
    is_important: bool = False

class NoteResponse(BaseModel):
    id: str
    title: str
    content: str
    tags: List[str]
    created_at: datetime
    updated_at: datetime
    is_important: bool
    sentiment_score: float
    reading_time: int  # in seconds
    key_terms: List[str]

class NoteAnalysis(BaseModel):
    sentiment: Dict[str, float]
    complexity: float
    reading_time: int
    key_terms: List[str]
    summary: str

# In-memory database (for demo purposes)
notes_db: Dict[str, Note] = {}

@app.post("/notes/", response_model=NoteResponse)
async def create_note(note: Note):
    """Create a new note with automatic analysis"""
    note_id = str(uuid.uuid4())
    note.created_at = datetime.utcnow()
    note.updated_at = note.created_at

    # Store note
    notes_db[note_id] = note

    # Return with analysis
    return await analyze_note(note_id)

@app.get("/notes/{note_id}", response_model=NoteResponse)
async def read_note(note_id: str):
    """Read a note with analysis"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")
    return await analyze_note(note_id)

@app.get("/notes/", response_model=List[NoteResponse])
async def list_notes(
    tags: Optional[List[str]] = None,
    search: Optional[str] = None,
    limit: int = 10,
    important: Optional[bool] = None
):
    """List notes with optional filtering"""
    filtered_notes = []

    for note in notes_db.values():
        # Filter by tags
        if tags:
            if not any(tag in note.tags for tag in tags):
                continue

        # Filter by importance
        if important is not None:
            if note.is_important != important:
                continue

        # Filter by search term
        if search:
            if (search.lower() not in note.title.lower() and
                search.lower() not in note.content.lower()):
                continue

        filtered_notes.append(note)

    # Apply limit
    filtered_notes = filtered_notes[:limit]

    # Return with analysis
    return [await analyze_note(note_id) for note_id, note in notes_db.items() if note in filtered_notes]

@app.put("/notes/{note_id}", response_model=NoteResponse)
async def update_note(note_id: str, note: Note):
    """Update an existing note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    note.updated_at = datetime.utcnow()
    notes_db[note_id] = note
    return await analyze_note(note_id)

@app.delete("/notes/{note_id}")
async def delete_note(note_id: str):
    """Delete a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    del notes_db[note_id]
    return JSONResponse(status_code=status.HTTP_204_NO_CONTENT)

@app.post("/notes/{note_id}/tag", response_model=NoteResponse)
async def add_tag(note_id: str, tag: str):
    """Add a tag to a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    if tag in notes_db[note_id].tags:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Tag already exists")

    notes_db[note_id].tags.append(tag)
    notes_db[note_id].updated_at = datetime.utcnow()
    return await analyze_note(note_id)

@app.post("/notes/{note_id}/importance", response_model=NoteResponse)
async def toggle_importance(note_id: str):
    """Toggle importance flag on a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    notes_db[note_id].is_important = not notes_db[note_id].is_important
    notes_db[note_id].updated_at = datetime.utcnow()
    return await analyze_note(note_id)

async def analyze_note(note_id: str) -> NoteResponse:
    """Analyze a note and return enhanced response"""
    note = notes_db[note_id]

    # Sentiment analysis
    sia = SentimentIntensityAnalyzer()
    sentiment = sia.polarity_scores(note.content)
    compound_score = sentiment['compound']

    # Text complexity
    complexity = textstat.flesch_reading_ease(note.content)

    # Reading time (words per minute is typically 200)
    word_count = len(re.findall(r'\w+', note.content))
    reading_time = int((word_count / 200) * 60)  # Convert to seconds

    # Extract key terms (simple approach)
    key_terms = [term for term in nltk.word_tokenize(note.title.lower()) if len(term) > 3]

    # Generate summary (very basic)
    summary = f"Note about {note.title} with {len(key_terms)} key terms."

    return NoteResponse(
        id=note_id,
        title=note.title,
        content=note.content,
        tags=note.tags,
        created_at=note.created_at,
        updated_at=note.updated_at,
        is_important=note.is_important,
        sentiment_score=compound_score,
        reading_time=reading_time,
        key_terms=key_terms
    )

@app.get("/notes/analysis/{note_id}", response_model=NoteAnalysis)
async def get_note_analysis(note_id: str):
    """Get detailed analysis of a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    note = notes_db[note_id]

    # Sentiment analysis
    sia = SentimentIntensityAnalyzer()
    sentiment = sia.polarity_scores(note.content)

    # Text complexity
    complexity = textstat.flesch_reading_ease(note.content)

    # Reading time
    word_count = len(re.findall(r'\w+', note.content))
    reading_time = int((word_count / 200) * 60)  # Convert to seconds

    # Extract key terms
    key_terms = [term for term in nltk.word_tokenize(note.title.lower()) if len(term) > 3]

    # Generate summary (very basic)
    summary = f"Note about {note.title} with {len(key_terms)} key terms."

    return NoteAnalysis(
        sentiment=sentiment,
        complexity=complexity,
        reading_time=reading_time,
        key_terms=key_terms,
        summary=summary
    )

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

use wasm_bindgen::prelude::*;
use js_sys::{
    Array, Reflect, Object, Undefinable, Uint8Array, console,
};
use web_sys::{
    window, local_storage, HttpRequest, HttpRequestResponse, FetchOptions, RequestInit,
    RequestCache, RequestCredentials, RequestMode, RequestReferrerPolicy, RequestDestination,
};
use serde::{Serialize, Deserialize};
use std::error::Error;
use wasm_bindgen_futures::JsFuture;

// Custom highlight pattern that includes colors and fonts
const HIGHLIGHT_PATTERN: &str = r#"
    background: #FFD700;
    color: #000000;
    font-weight: bold;
    padding: 0 2px;
    border-radius: 2px;
    white-space: pre-wrap;
"#;

// Configuration struct with Serialize/Deserialize
#[derive(Serialize, Deserialize, Debug)]
struct Config {
    highlight_color: String,
    history_limit: usize,
    search_history: Vec<String>,
}

impl Default for Config {
    fn default() -> Self {
        Config {
            highlight_color: "#FFD700".to_string(),
            history_limit: 10,
            search_history: Vec::new(),
        }
    }
}

// Load or initialize config from localStorage
fn load_config() -> Config {
    if let Some(storage) = window().and_then(|w| w.local_storage()) {
        if let Ok(Some(config_json)) = JsFuture::from(storage.get("aileygrep_config")) {
            if let Ok(Some(config_string)) = config_json.dyn_into::<String>() {
                if let Ok(config) = serde_json::from_str(&config_string) {
                    return config;
                }
            }
        }
    }
    Config::default()
}

// Save config to localStorage
fn save_config(config: &Config) -> Result<(), JsValue> {
    if let Some(storage) = window().and_then(|w| w.local_storage()) {
        let config_json = serde_json::to_string(config)?;
        storage.set("aileygrep_config", &config_json)?;
    }
    Ok(())
}

// Apply highlight to matches
fn apply_highlight(matches: Vec<(usize, usize)>) -> String {
    let mut result = String::new();
    let mut last_pos = 0;
    for (start, end) in matches {
        result.push_str(&js_sys::Reflect::get(&result, &last_pos.to_string()).unwrap_or(&JsvValue::UNDEFINED));
        result.push_str("<span style=\"");
        result.push_str(HIGHLIGHT_PATTERN);
        result.push_str("\">");
        if let Some(text) = js_sys::Reflect::get(&result, &end.to_string()).unwrap_or(&JsvValue::UNDEFINED).dyn_into::<String>().ok() {
            result.push_str(&text);
        }
        result.push_str("</span>");
        last_pos = end + 1;
    }
    result.push_str(&js_sys::Reflect::get(&result, &last_pos.to_string()).unwrap_or(&JsvValue::UNDEFINED));
    result
}

// Search files using fetch (simulated file system)
async fn search_files(query: &str) -> Result<String, JsValue> {
    // Simulate a file system with a fetch request
    let mut opts = FetchOptions::new();
    opts.method("GET");
    let request = RequestInit::new_with_str(&format!("/api/search?query={}", query))?;
    let response = window().fetch_with_request_and_init(&request, &opts).await?;

    if response.status() == 200 {
        let text = JsFuture::from(response.text()).await?;
        Ok(text)
    } else {
        Err(JsValue::from_str(&format!("HTTP error {}!", response.status())))
    }
}

// Main function with WebAssembly entry point
#[wasm_bindgen(start)]
pub async fn main() -> Result<(), JsValue> {
    console::log_1(&"AileyGrep: Search tool started".into());

    // Load configuration
    let mut config = load_config();

    // Simulate user input (in a real app, this would be from UI)
    let search_terms = ["main.rs", "pub mod", "AileyGrep"];

    for term in search_terms {
        // Search files
        match search_files(&term).await {
            Ok(result) => {
                console::log_1(&format!("Search results for '{}':", term).into());
                console::log_1(&result.into());
                // Apply highlighting
                let highlighted = apply_highlight(vec![(0, term.len())]);
                console::log_1(&format!("Highlighted results: {}", highlighted).into());

                // Update search history
                if !config.search_history.contains(&term.to_string()) {
                    config.search_history.push(term.to_string());
                    if config.search_history.len() > config.history_limit {
                        config.search_history.remove(0);
                    }
                    save_config(&config)?;
                }
            }
            Err(e) => console::log_1(&e),
        }
    }

    // Final status log
    console::log_1(&format!("AileyGrep: Saved {} search terms to localStorage", config.search_history.len()).into());

    Ok(())
}

import SwiftUI
import Combine

struct ZenGridGallery: View {
    // MARK: - State
    @State private var images: [Image] = []
    @State private var selectedImageIndex: Int? = nil
    @State private var isEditing: Bool = false
    @State private var photoLibraryPermission: Bool = false
    @State private var showZoomedImage: Bool = false

    // MARK: - Preview Images
    private let previewImages: [Image] = [
        Image("tate1"),
        Image("tate2"),
        Image("tate3")
    ]

    // MARK: - Body
    var body: some View {
        NavigationStack {
            ZStack {
                // Background
                RadialGradient(
                    gradient: Gradient(colors: [.clear, .black.opacity(0.3)]),
                    center: .center,
                    startRadius: 0,
                    endRadius: 200
                )
                .ignoresSafeArea()

                // Main View
                ScrollView {
                    LazyVGrid(columns: [GridItem(.adaptive(minimum: 200), spacing: 10)],
                              spacing: 10) {
                        ForEach(images.indices, id: \.self) { index in
                            ImageView(image: images[index], selected: selectedImageIndex == index)
                                .onTapGesture {
                                    selectedImageIndex = index
                                    isEditing = true
                                }
                        }
                    }
                    .padding()

                    // Edit Button
                    Button(action: {
                        isEditing = true
                    }) {
                        Label("Edit", systemImage: "pencil")
                            .font(.headline)
                            .foregroundColor(.primary)
                    }
                    .padding(.top, 20)
                }
                .background(Color.clear)

                // Zoomed Image Overlay
                if showZoomedImage && let index = selectedImageIndex {
                    ZStack {
                        Color.black.opacity(0.9)
                            .ignoresSafeArea()
                            .onTapGesture {
                                withAnimation {
                                    showZoomedImage = false
                                }
                            }

                        Image(images[index].name ?? "")
                            .resizable()
                            .scaledToFit()
                            .frame(maxWidth: .infinity, maxHeight: .infinity)
                            .transition(.opacity)
                    }
                    .zIndex(1)
                }
            }
            .navigationTitle("Zen Grid")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: {
                        addImage()
                    }) {
                        Label("Add", systemImage: "plus")
                    }
                }
            }
            .onAppear {
                checkPhotoLibraryPermission()
                if images.isEmpty {
                    images = previewImages
                }
            }
            .sheet(isPresented: $isEditing) {
                ImageEditor(image: $images[selectedImageIndex ?? 0])
            }
        }
    }

    // MARK: - Functions
    private func addImage() {
        if !photoLibraryPermission {
            return
        }

        let picker = UIImagePickerController()
        picker.delegate = self
        UIApplication.shared.windows.first?.rootViewController?.present(picker, animated: true)
    }

    private func checkPhotoLibraryPermission() {
        let status = PHPhotoLibrary.authorizationStatus()
        if status == .notDetermined {
            PHPhotoLibrary.requestAuthorization { granted in
                DispatchQueue.main.async {
                    photoLibraryPermission = granted
                }
            }
        } else {
            photoLibraryPermission = status == .authorized
        }
    }
}

// MARK: - Image View
struct ImageView: View {
    let image: Image
    let selected: Bool

    var body: some View {
        ZStack {
            RoundedRectangle(cornerRadius: 8)
                .stroke(selected ? Color.accentColor : Color.clear, lineWidth: 2)

            image
                .resizable()
                .scaledToFill()
                .frame(height: 200)
                .clipped()
                .opacity(selected ? 1 : 0.9)
        }
        .frame(height: 200)
    }
}

// MARK: - Image Editor
struct ImageEditor: View {
    @Binding var image: Image

    @State private var zoomScale: CGFloat = 1.0
    @State private var panOffset: CGSize = .zero

    var body: some View {
        VStack {
            // Image View
            GeometryReader { geometry in
                Image(image)
                    .resizable()
                    .scaledToFit()
                    .frame(width: geometry.size.width, height: geometry.size.height)
                    .offset(x: panOffset.width, y: panOffset.height)
                    .scaleEffect(zoomScale)
                    .gesture(
                        MagnificationGesture()
                            .onChanged { value in
                                zoomScale = value.magnification
                            }
                    )
                    .gesture(
                        DragGesture()
                            .onChanged { value in
                                panOffset = value.translation
                            }
                            .onEnded { _ in
                                panOffset = .zero
                            }
                    )
            }
            .frame(height: 300)
            .padding(.horizontal)

            // Save Button
            Button(action: {
                UIApplication.shared.windows.first?.rootViewController?.dismiss(animated: true)
            }) {
                Text("Done")
                    .font(.headline)
                    .foregroundColor(.white)
                    .frame(width: 200, height: 44)
                    .background(Color.accentColor)
                    .cornerRadius(8)
            }
            .padding(.top)
        }
        .background(Color.black)
        .ignoresSafeArea()
    }
}

// MARK: - Preview Provider
struct ZenGridGallery_Previews: PreviewProvider {
    static var previews: some View {
        ZenGridGallery()
            .preferredColorScheme(.dark)
    }
}

// MARK: - UIImagePickerController Delegate
extension ZenGridGallery: UINavigationControllerDelegate, UIImagePickerControllerDelegate {
    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
        if let uiImage = info[.originalImage] as? UIImage {
            let swiftUIImage = Image(uiImage: uiImage)
            images.append(swiftUIImage)
        }
        picker.dismiss(animated: true)
    }
}

// MARK: - Preview Images
struct PreviewImage: View {
    var body: some View {
        Image(systemName: "photo")
            .resizable()
            .scaledToFill()
            .frame(width: 200, height: 200)
            .clipped()
            .opacity(0.5)
    }
}

use serde_json::{Value, from_reader, to_writer, ser::PrettyGenerator};
use std::io::{self, Read, Write};
use std::error::Error;
use rand::Rng;
use crossterm::{
    execute,
    style::{Color, Print, SetForegroundColor},
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
    cursor::Hide, queue,
    Event, KeyCode,
};
use ratatui::{
    backend::CrosstermBackend,
    Terminal,
    text::{Span, Text},
    widgets::{Block, Borders, Paragraph},
    layout::{Constraint, Direction, Layout, Rectangle},
    style::{Style, Stylize},
};
use std::time::Duration;

const CONFETTI_CHARS: [char; 12] = ['♥', '☆', '★', '♦', '♣', '♠', '•', '◕', '◈', '◑', '☺', '☻'];
const COLORS: [Color; 8] = [
    Color::Red,
    Color::Green,
    Color::Yellow,
    Color::Blue,
    Color::Magenta,
    Color::Cyan,
    Color::White,
    Color::Gray,
];

struct JSONFormatter {
    terminal: Terminal<CrosstermBackend>,
    confetti_active: bool,
    confetti_timeout: Duration,
}

impl JSONFormatter {
    fn new(terminal: Terminal<CrosstermBackend>) -> Self {
        JSONFormatter {
            terminal,
            confetti_active: false,
            confetti_timeout: Duration::from_millis(100),
        }
    }

    fn handle_confetti(&mut self) {
        if !self.confetti_active {
            return;
        }

        let width = self.terminal.size().unwrap().width as usize;
        let height = self.terminal.size().unwrap().height as usize;

        let mut rng = rand::thread_rng();
        let mut confetti_lines = Vec::new();

        for _ in 0..(rng.gen_range(5..15)) {
            let char_index = rng.gen_range(0..CONFETTI_CHARS.len());
            let color_index = rng.gen_range(0..COLORS.len());
            let x = rng.gen_range(0..width);
            let y = rng.gen_range(0..height);
            let speed = rng.gen_range(1..4);
            let char_span = Span::from(CONFETTI_CHARS[char_index].to_string())
                .fg(COLORS[color_index])
                .bold();
            confetti_lines.push((x, y, speed, char_span));
        }

        self.draw_confetti(confetti_lines);
        if self.confetti_active {
            std::thread::spawn(|| {
                std::thread::sleep(self.confetti_timeout);
                let mut term = self.terminal.clone();
                term.clear().unwrap();
                term.draw(|f| {
                    f.render_widget(
                        Paragraph::new("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n")
                            .block(Block::default().borders(Borders::NONE))
                            .style(Style::default().add_modifier(ratatui::style::Modifier::REVERSED)),
                        f.size(),
                    );
                }).unwrap();
            });
        }
    }

    fn draw_confetti(&mut self, lines: Vec<(usize, usize, usize, Span)>) {
        let mut term = self.terminal.clone();
        term.clear().unwrap();
        term.draw(|f| {
            for (x, y, speed, char_span) in lines {
                let mut y_pos = y;
                for _ in 0..speed {
                    if y_pos > 0 {
                        y_pos -= 1;
                    } else {
                        break;
                    }
                }
                if y_pos < f.size().height as usize {
                    let position = (x, y_pos);
                    f.render_widget(
                        Paragraph::new(char_span)
                            .block(Block::default().borders(Borders::NONE))
                            .position(position),
                        f.size(),
                    );
                }
            }
        }).unwrap();
    }

    fn format_json(&mut self, input: String) -> Result<String, Box<dyn Error>> {
        let value: Value = from_reader(&mut io::Cursor::new(input.clone()))?;
        let mut pretty = PrettyGenerator::new(io::stdout());
        to_writer(&mut pretty, &value)?;

        let output = prettyIntoString(&value)?;

        if output.len() > 500 {
            self.confetti_active = true;
            self.handle_confetti();
        }

        Ok(output)
    }
}

fn prettyIntoString(value: &Value) -> Result<String, Box<dyn Error>> {
    let mut buffer = String::new();
    let mut generator = PrettyGenerator::new(&mut buffer);
    generator.write(value)?;
    Ok(buffer)
}

fn main() -> Result<(), Box<dyn Error>> {
    // Initialize terminal
    let mut stdout = io::stdout();
    enable_raw_mode()?;
    let mut terminal = Terminal::new(CrosstermBackend::new(stdout))?;
    execute!(
        terminal.backend_mut(),
        EnterAlternateScreen,
        Hide,
    )?;
    terminal.clear()?;

    let mut formatter = JSONFormatter::new(terminal);

    // Main loop
    loop {
        // Draw UI
        let size = terminal.size()?;
        let layout = Layout::default()
            .direction(Direction::Vertical)
            .constraints([
                Constraint::Percentage(20),
                Constraint::Percentage(60),
                Constraint::Percentage(20),
            ])
            .split(size);

        terminal.draw(|f| {
            // Header
            let header = Text::from("GlitterJSON - JSON Pretty Printer with Syntax Highlighting")
                .green()
                .bold();
            f.render_widget(
                Paragraph::new(header)
                    .block(Block::default().borders(Borders::ALL).title("GlitterJSON")),
                layout[0],
            );

            // Instructions
            let instructions = Text::from([
                "1. Paste your JSON (max 500 chars for confetti!)",
                "2. Press Enter to format",
                "3. Press Esc to quit",
                "4. Press Backspace to clear",
            ])
            .green()
            .bold();
            f.render_widget(
                Paragraph::new(instructions)
                    .block(Block::default().borders(Borders::ALL).title("Instructions")),
                layout[2],
            );
        })?;

        // Get user input
        let mut input = String::new();
        let event = terminal.backend().poll_event()?;
        match event.code {
            KeyCode::Char(c) if c.is_ascii() => {
                input.push(c);
                let mut term = formatter.terminal.clone();
                term.draw(|f| {
                    let output = Text::from(input.clone()).green();
                    f.render_widget(
                        Paragraph::new(output)
                            .block(Block::default().borders(Borders::ALL).title("Input")),
                        layout[1],
                    );
                })?;
            }
            KeyCode::Backspace => {
                input.pop();
                let mut term = formatter.terminal.clone();
                term.draw(|f| {
                    let output = Text::from(input.clone()).green();
                    f.render_widget(
                        Paragraph::new(output)
                            .block(Block::default().borders(Borders::ALL).title("Input")),
                        layout[1],
                    );
                })?;
            }
            KeyCode::Enter => {
                if input.trim().is_empty() {
                    continue;
                }
                match formatter.format_json(input.clone()) {
                    Ok(output) => {
                        // Display formatted JSON
                        let mut term = formatter.terminal.clone();
                        term.draw(|f| {
                            let formatted = Text::from(output.clone())
                                .green()
                                .bold();
                            f.render_widget(
                                Paragraph::new(formatted)
                                    .block(Block::default().borders(Borders::ALL).title("Formatted JSON")),
                                layout[1],
                            );
                        })?;
                    }
                    Err(e) => {
                        // Display error
                        let mut term = formatter.terminal.clone();
                        term.draw(|f| {
                            let error = Text::from(format!("Error: {}", e))
                                .red()
                                .bold();
                            f.render_widget(
                                Paragraph::new(error)
                                    .block(Block::default().borders(Borders::ALL).title("Error")),
                                layout[1],
                            );
                        })?;
                    }
                }
            }
            KeyCode::Esc => break,
            _ => {}
        }
    }

    // Cleanup
    execute!(
        terminal.backend_mut(),
        LeaveAlternateScreen,
        Hide,
    )?;
    disable_raw_mode()?;
    terminal.show_cursor()?;
    Ok(())
}

```swift
import SwiftUI
import Combine

// MARK: - MODELS

struct Flashcard: Identifiable, Codable {
    let id = UUID()
    var question: String
    var answer: String
    var lastReview: Date?
    var difficulty: Int = 1

    var nextReview: Date? {
        guard let lastReview = lastReview else { return nil }
        return lastReview.addingTimeInterval(TimeInterval(difficulty * 24 * 3600))
    }
}

class FlashcardStore: ObservableObject {
    @Published var flashcards: [Flashcard] = []

    init() {
        load()
    }

    func save() {
        do {
            try PropertyListEncoder().encode(flashcards).write(to: getDocumentsDirectory().appendingPathComponent("flashcards.plist"))
        } catch {
            print("Save error: \(error)")
        }
    }

    func load() {
        let path = getDocumentsDirectory().appendingPathComponent("flashcards.plist")
        guard FileManager.default.fileExists(atPath: path.path) else {
            return
        }
        do {
            flashcards = try PropertyListDecoder().decode([Flashcard].self, from: Data(contentsOf: path))
        } catch {
            print("Load error: \(error)")
        }
    }

    func addFlashcard(question: String, answer: String) {
        let newCard = Flashcard(question: question, answer: answer)
        flashcards.append(newCard)
        save()
    }

    func updateFlashcard(_ flashcard: Flashcard, question: String? = nil, answer: String? = nil) {
        if let index = flashcards.firstIndex(where: { $0.id == flashcard.id }) {
            flashcards[index].question = question ?? flashcards[index].question
            flashcards[index].answer = answer ?? flashcards[index].answer
            flashcards[index].lastReview = Date()
            save()
        }
    }

    func deleteFlashcard(at offsets: IndexSet) {
        flashcards.remove(atOffsets: offsets)
        save()
    }

    func markAsReviewed(_ flashcard: Flashcard) {
        if let index = flashcards.firstIndex(where: { $0.id == flashcard.id }) {
            flashcards[index].lastReview = Date()
            flashcards[index].difficulty = min(flashcards[index].difficulty + 1, 5)
            save()
        }
    }

    func getNextFlashcard() -> Flashcard? {
        guard var now = Date().addingTimeInterval(-300) else { return nil } // Look 5 minutes back
        let candidates = flashcards.filter { $0.lastReview == nil || $0.nextReview! <= now }
        return candidates.sorted { $0.nextReview ?? Date.distantPast < $1.nextReview ?? Date.distantPast }.first
    }

    private func getDocumentsDirectory() -> URL {
        FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
    }
}

// MARK: - VIEWS

struct LuminaView: View {
    @StateObject private var store = FlashcardStore()
    @State private var showingAddCard = false
    @State private var currentFlashcard: Flashcard?
    @State private var showingEditCard = false
    @State private var editFlashcard: Flashcard?

    var body: some View {
        NavigationStack {
            VStack {
                if let card = currentFlashcard {
                    FlashcardDetailView(flashcard: card, onReview: { store.markAsReviewed(card) },
                                       onEdit: { editFlashcard = card; showingEditCard = true },
                                       onDelete: { currentFlashcard = nil; showingAddCard = true },
                                       onNext: { currentFlashcard = nil; showingAddCard = true })
                } else {
                    if !store.flashcards.isEmpty {
                        FlashcardsListView(store: store, onFlashcardTapped: { currentFlashcard = $0 })
                    } else {
                        EmptyStateView(action: { showingAddCard = true })
                    }
                }
            }
            .navigationTitle("Lumina")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: { showingAddCard = true }) {
                        Image(systemName: "plus")
                    }
                }
            }
            .sheet(isPresented: $showingAddCard) {
                AddEditFlashcardView(store: store, isEditing: false, onDismiss: { showingAddCard = false })
            }
            .sheet(isPresented: $showingEditCard) {
                if let card = editFlashcard {
                    AddEditFlashcardView(store: store, isEditing: true, flashcard: card, onDismiss: {
                        showingEditCard = false
                    })
                }
            }
        }
    }
}

struct FlashcardDetailView: View {
    let flashcard: Flashcard
    let onReview: () -> Void
    let onEdit: () -> Void
    let onDelete: () -> Void
    let onNext: () -> Void

    @State private var showingAnswer = false
    @State private var scaleFactor: CGFloat = 0.95

    var body: some View {
        VStack(spacing: 40) {
            Text(flashcard.question)
                .font(.title2)
                .multilineTextAlignment(.center)
                .padding()
                .background(NeumorphicBackgroundView(scale: 1.1, isSelected: true))
                .clipShape(RoundedRectangle(cornerRadius: 24))
                .shadow(color: .black.opacity(0.1), radius: 5, x: 0, y: 2)
                .scaleEffect(scaleFactor)
                .animation(.spring(response: 0.4, dampingFraction: 0.6), value: showingAnswer)
                .onAppear {
                    withAnimation(.spring(response: 0.5, dampingFraction: 0.6)) {
                        scaleFactor = 1.0
                    }
                }

            if showingAnswer {
                VStack(spacing: 20) {
                    Text(flashcard.answer)
                        .font(.title3)
                        .multilineTextAlignment(.center)
                        .padding()
                        .background(NeumorphicBackgroundView(scale: 1.1, isSelected: true))
                        .clipShape(RoundedRectangle(cornerRadius: 24))
                        .shadow(color: .black.opacity(0.1), radius: 5, x: 0, y: 2)

                    Spacer()

                    HStack {
                        Spacer()
                        Button(action: onReview) {
                            Label("Reviewed", systemImage: "checkmark.circle.fill")
                                .font(.headline)
                                .padding()
                                .background(NeumorphicButtonBackground())
                                .clipShape(Circle())
                                .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
                        }
                        Spacer()
                        Button(action: onNext) {
                            Label("Next", systemImage: "arrow.right.circle.fill")
                                .font(.headline)
                                .padding()
                                .background(NeumorphicButtonBackground())
                                .clipShape(Circle())
                                .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
                        }
                        Spacer()
                    }
                }
                .padding(.vertical, 20)
            } else {
                Button(action: { showingAnswer = true }) {
                    Label("Show Answer", systemImage: "eye.fill")
                        .font(.headline)
                        .padding()
                        .background(NeumorphicButtonBackground())
                        .clipShape(Capsule())
                        .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
                }
                .padding(.top, 40)

                HStack {
                    Spacer()
                    Button(action: onEdit) {
                        Label("Edit", systemImage: "pencil")
                            .font(.subheadline)
                            .padding()
                            .background(NeumorphicButtonBackground())
                            .clipShape(Circle())
                            .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
                    }
                    Spacer()
                    Button(action: onDelete) {
                        Label("Delete", systemImage: "trash")
                            .font(.subheadline)
                            .foregroundColor(.red)
                            .padding()
                            .background(NeumorphicButtonBackground())
                            .clipShape(Circle())
                            .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
                    }
                    Spacer()
                }
            }
        }
        .padding()
    }
}

struct FlashcardsListView: View {
    @ObservedObject var store: FlashcardStore
    let onFlashcardTapped: (Flashcard) -> Void

    var body: some View {
        if store.flashcards.isEmpty {
            EmptyStateView(action: { })
        } else {
            List {
                ForEach(store.flashcards.sorted(by: { $0.nextReview ?? Date.distantPast < $1.nextReview ?? Date.distantPast })) { card in
                    FlashcardRow(flashcard: card, onTap: { onFlashcardTapped(card) })
                }
                .listRowBackground(Color.clear)
                .listRowSeparator(.hidden)
            }
            .listStyle(PlainListStyle())
            .padding(.horizontal)
        }
    }
}

struct FlashcardRow: View {
    let flashcard: Flashcard
    let onTap: () -> Void

    var timeRemaining: String {
        guard let next = flashcard.nextReview else { return "New" }
        let components = Calendar.current.dateComponents([.day, .hour, .minute], from: Date(), to: next)
        var result = ""
        if let day = components.day, day > 0 { result = "\(day)d" }
        if let hour = components.hour, hour > 0 || result.isEmpty { result = "\(hour)h\(result)" }
        if let minute = components.minute, minute > 0 || result.isEmpty { result = "\(minute)m\(result)" }
        return result
    }

    var difficultyColor: Color {
        switch flashcard.difficulty {
        case 1: return .green
        case 2: return .green.opacity(0.7)
        case 3: return .yellow
        case 4: return .orange
        case 5: return .red
        default: return .green
        }
    }

    var body: some View {
        Button(action: onTap) {
            HStack(spacing: 16) {
                VStack(alignment: .leading, spacing: 4) {
                    Text(flashcard.question.prefix(20))
                        .font(.headline)
                        .lineLimit(1)

                    Text(timeRemaining)
                        .font(.caption)
                        .foregroundColor(.secondary)

                    HStack {
                        Text("Difficulty \(flashcard.difficulty)")
                        Spacer()
                        Image(systemName: "star.fill")
                            .foregroundColor(difficultyColor)
                    }
                    .font(.caption)
                }

                Spacer()

                Image(systemName: "chevron.right")
                    .foregroundColor(.secondary)
            }
            .padding(.vertical, 8)
            .background(NeumorphicListRowBackground())
            .cornerRadius(12)
            .shadow(color: .black.opacity(0.1), radius: 2, x: 0, y: 1)
        }
    }
}

struct AddEditFlashcardView: View {
    @ObservedObject var store: FlashcardStore
    @Environment(\.dismiss) private var dismiss

    let isEditing: Bool
    var flashcard: Flashcard?
    let onDismiss: () -> Void

    @State private var question: String = ""
    @State private var answer: String = ""
    @State private var difficulty: Int = 1

    var body: some View {
        NavigationStack {
            Form {
                Section {
                    TextField("Question", text: $question)
                        .font(.headline)
                        .multilineTextAlignment(.leading)

                    TextField("Answer", text: $answer)
                        .font(.headline)
                        .multilineTextAlignment(.leading)
                }

                Section {
                    Picker("Difficulty", selection: $difficulty) {
                        ForEach(1..<6) { level in
                            Text("Level \(level)").tag(level)
                        }
                    }
                    .pickerStyle(.segmented)
                    .padding(.horizontal)

                    HStack {
                        Text("Preview")
                        Spacer()
                        Text(difficulty == 1 ? "Easy" : difficulty == 5 ? "Hard" : "Balanced")
                    }
                    .font(.caption)
                    .foregroundColor(.secondary)
                }
            }
            .navigationTitle(isEditing ? "Edit Flashcard" : "New Flashcard")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .confirmationAction) {
                    Button(action: saveFlashcard) {
                        Text(isEditing ? "Update" : "Add")
                    }
                }
                ToolbarItem(placement: .cancellationAction) {
                    Button(action: dismissFlashcard) {
                        Text("Cancel")
                    }
                }
            }
        }
    }

    private func saveFlashcard() {
        if !question.isEmpty && !answer.isEmpty {
            if isEditing, let card = flashcard {
                store.updateFlashcard(card, question: question, answer: answer)
            } else {
                store.addFlashcard(question: question, answer: answer)
            }
            dismiss()
            onDismiss()
        }
    }

    private func dismissFlashcard() {
        dismiss()
        onDismiss()
    }
}

struct EmptyStateView: View {
    let action: () -> Void

    var body: some View {
        VStack(spacing: 20) {
            Image(systemName: "note.text")
                .font(.system(size: 50))
                .foregroundColor(.secondary)

            Text("No flashcards yet")
                .font(.title2)
                .foregroundColor(.secondary)

            Text("Tap the + button to add your first flashcard")
                .font(.subheadline)
                .foregroundColor(.secondary.opacity(0.7))
                .multilineTextAlignment(.center)

            Button(action: action) {
                Label("Add First Flashcard", systemImage: "plus.circle.fill")
                    .font(.headline)
                    .padding()
                    .background(NeumorphicButtonBackground())
                    .clipShape(Circle())
                    .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
            }
        }
        .padding()
    }
}

// MARK: - NEUMORPHIC STYLES

struct NeumorphicBackgroundView: View {
    let scale: CGFloat
    let isSelected: Bool

    var body: some View {
        RoundedRectangle(cornerRadius: 24)
            .fill(
                LinearGradient(
                    gradient: Gradient(colors: [
                        isSelected ? Color.white : Color-white.opacity(0.9),
                        isSelected ? Color-white.opacity(0.7) : Color.white
                    ]),
                    startPoint: .topLeading,
                    endPoint: .bottomTrailing
                )
            )
            .shadow(
                color: isSelected ? Color.black.opacity(0.1) : Color.black.opacity(0.05),
                radius: scale * 2,
                x: scale,
                y: scale
            )
            .shadow(
                color: isSelected ? Color.white.opacity(0.3) : Color.white.opacity(0.15),
                radius: scale * 2,
                x: -scale,
                y: -scale
            )
    }
}

struct NeumorphicListRowBackground: ViewModifier {
    func body(matcher: View) -> some View {
        matcher
            .background(
                RoundedRectangle(cornerRadius: 12)
                    .fill(
                        LinearGradient(
                            gradient: Gradient(colors: [
                                Color.white.opacity(0.85),
                                Color.white.opacity(0.9)
                            ]),
                            startPoint: .topLeading,
                            endPoint: .bottomTrailing
                        )
                    )
                    .shadow(
                        color: Color.black.opacity(0.05),
                        radius: 3,
                        x: 1.5,
                        y: 1.5
                    )
                    .shadow(
                        color: Color.white.opacity(0.1),
                        radius: 3,
                        x: -1.5,
                        y: -1.5
                    )
            )
    }
}

struct NeumorphicButtonBackground: ViewModifier {
    func body(matcher: View) -> some View {
        matcher
            .background(
                RoundedRectangle(cornerRadius: 16)
                    .fill(
                        LinearGradient(
                            gradient: Gradient(colors: [
                                Color.white.opacity(0.9),
                                Color.white.opacity(0.95)
                            ]),
                            startPoint: .topLeading,
                            endPoint: .bottomTrailing
                        )
                    )
                    .shadow(
                        color: Color.black.opacity(0.1),
                        radius: 2,
                        x: 1,
                        y: 1
                    )
                    .shadow(
                        color: Color.white.opacity(0.2),
                        radius: 2,
                        x: -1,
                        y: -1
                    )
            )
    }
}

extension View {
    func neumorphicBackground() -> some View {
        self.modifier(NeumorphicListRowBackground())
    }
}

// MARK: - PREVIEW

struct LuminaView_Previews: PreviewProvider {
    static var previews: some View {
        LuminaView()
            .previewDevice("iPhone 13 Pro")
            .previewDisplayName("Lumina

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Nebula Breakout</title>
    <style>
        :root {
            --bg-color: #0a0e23;
            --neon-green: #00ff41;
            --neon-pink: #ff2f9d;
            --neon-blue: #00f2ff;
            --text-color: #fff;
            --brick-color: #1a1a3a;
            --brick-highlight: rgba(255, 255, 255, 0.1);
        }

        body {
            margin: 0;
            padding: 0;
            background-color: var(--bg-color);
            color: var(--text-color);
            font-family: 'Courier New', monospace;
            overflow: hidden;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
        }

        #game-container {
            position: relative;
            width: 800px;
            height: 600px;
            border: 2px solid var(--neon-green);
            border-radius: 10px;
            box-shadow: 0 0 20px rgba(0, 255, 65, 0.3);
            background: radial-gradient(circle at 50% 50%, rgba(10, 14, 35, 0.8) 0%, var(--bg-color) 100%);
            overflow: hidden;
        }

        #paddle {
            position: absolute;
            bottom: 20px;
            left: 50%;
            transform: translateX(-50%);
            width: 100px;
            height: 15px;
            background-color: var(--neon-blue);
            border-radius: 5px;
            border: 2px solid var(--neon-pink);
            transition: left 0.1s;
        }

        #ball {
            position: absolute;
            width: 15px;
            height: 15px;
            background-color: var(--neon-green);
            border-radius: 50%;
            box-shadow: 0 0 10px var(--neon-green);
            top: 200px;
            left: 400px;
        }

        #bricks-container {
            position: absolute;
            top: 50px;
            left: 0;
            width: 100%;
            height: 400px;
            display: grid;
            grid-template-columns: repeat(10, 1fr);
            gap: 5px;
        }

        .brick {
            background-color: var(--brick-color);
            border: 1px solid var(--brick-highlight);
            border-radius: 5px;
            height: 30px;
            display: flex;
            justify-content: center;
            align-items: center;
            font-size: 12px;
            transition: background-color 0.2s;
        }

        .brick:nth-child(3n) { border-left: 2px solid var(--neon-pink); }
        .brick:nth-child(3n + 1) { border-right: 2px solid var(--neon-blue); }

        #score-display {
            position: absolute;
            top: 10px;
            left: 20px;
            font-size: 18px;
            text-shadow: 0 0 5px var(--neon-green);
        }

        #level-display {
            position: absolute;
            top: 10px;
            right: 20px;
            font-size: 18px;
            text-shadow: 0 0 5px var(--neon-blue);
        }

        #game-over {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            color: var(--neon-pink);
            font-size: 48px;
            display: none;
            text-shadow: 0 0 10px var(--neon-pink);
        }

        #restart-button {
            position: absolute;
            top: 60%;
            left: 50%;
            transform: translateX(-50%);
            padding: 10px 20px;
            background-color: var(--neon-green);
            color: var(--bg-color);
            border: none;
            border-radius: 5px;
            font-size: 16px;
            cursor: pointer;
            display: none;
            box-shadow: 0 0 10px var(--neon-green);
        }

        #instructions {
            position: absolute;
            bottom: 20px;
            right: 20px;
            font-size: 14px;
            opacity: 0.7;
        }

        #neon-particles {
            position: absolute;
            width: 100%;
            height: 100%;
            pointer-events: none;
            z-index: 10;
        }

        .particle {
            position: absolute;
            background-color: var(--neon-green);
            border-radius: 50%;
            box-shadow: 0 0 5px var(--neon-green);
            animation: float 10s infinite linear;
        }

        @keyframes float {
            0% { transform: translateY(0) rotate(0deg); }
            25% { transform: translateY(-50px) rotate(180deg); }
            50% { transform: translateY(0) rotate(360deg); }
            75% { transform: translateY(50px) rotate(540deg); }
            100% { transform: translateY(0) rotate(720deg); }
        }
    </style>
</head>
<body>
    <div id="game-container">
        <div id="bricks-container"></div>
        <div id="paddle"></div>
        <div id="ball"></div>
        <div id="score-display">Score: 0</div>
        <div id="level-display">Level: 1</div>
        <div id="game-over">GAME OVER</div>
        <button id="restart-button">PLAY AGAIN</button>
        <div id="instructions">Move paddle with LEFT/RIGHT arrows</div>
    </div>
    <div id="neon-particles"></div>

    <script>
        // Game configuration
        const config = {
            paddleSpeed: 10,
            ballSpeed: 5,
            brickRows: 5,
            brickCols: 10,
            brickHeight: 30,
            brickWidth: 80,
            brickGap: 5,
            brickPadding: 5,
            ballRadius: 7.5,
            lives: 3,
            colors: ['#00ff41', '#ff2f9d', '#00f2ff', '#ff00ff', '#ffff00', '#00ffff'],
            levels: [
                { bricks: 50, speedMultiplier: 1 },
                { bricks: 30, speedMultiplier: 1.5 },
                { bricks: 15, speedMultiplier: 2 },
                { bricks: 5, speedMultiplier: 2.5 }
            ]
        };

        // Game state
        let gameState = {
            score: 0,
            level: 1,
            lives: config.lives,
            gameOver: false,
            gamePaused: false,
            bricks: [],
            ball: {
                x: 0,
                y: 0,
                dx: 0,
                dy: 0,
                radius: config.ballRadius
            },
            paddle: {
                x: 0,
                y: 0,
                width: 100,
                height: 15,
                speed: config.paddleSpeed
            },
            canvas: null,
            ctx: null,
            animationId: null,
            particles: []
        };

        // DOM elements
        const paddle = document.getElementById('paddle');
        const ball = document.getElementById('ball');
        const bricksContainer = document.getElementById('bricks-container');
        const scoreDisplay = document.getElementById('score-display');
        const levelDisplay = document.getElementById('level-display');
        const gameOver = document.getElementById('game-over');
        const restartButton = document.getElementById('restart-button');
        const neonParticles = document.getElementById('neon-particles');
        const gameContainer = document.getElementById('game-container');

        // Initialize the game
        function initGame() {
            gameState.score = 0;
            gameState.level = 1;
            gameState.lives = config.lives;
            gameState.gameOver = false;
            gameState.gamePaused = false;
            gameState.bricks = [];
            gameOver.style.display = 'none';
            restartButton.style.display = 'none';

            // Reset ball
            gameState.ball = {
                x: gameContainer.offsetWidth / 2 - config.ballRadius,
                y: gameContainer.offsetHeight - 200 - config.ballRadius,
                dx: config.ballSpeed,
                dy: -config.ballSpeed,
                radius: config.ballRadius
            };

            // Reset paddle
            gameState.paddle = {
                x: gameContainer.offsetWidth / 2 - 50,
                y: gameContainer.offsetHeight - 40,
                width: 100,
                height: 15,
                speed: config.paddleSpeed
            };

            // Create bricks for current level
            createBricks();

            // Position paddle and ball in DOM
            paddle.style.left = gameState.paddle.x + 'px';
            ball.style.left = gameState.ball.x + 'px';
            ball.style.top = gameState.ball.y + 'px';

            // Start game loop
            if (gameState.animationId) {
                cancelAnimationFrame(gameState.animationId);
            }
            gameState.animationId = requestAnimationFrame(gameLoop);

            // Update displays
            updateDisplays();

            // Add event listeners
            document.addEventListener('keydown', handleKeyDown);
        }

        // Create bricks for current level
        function createBricks() {
            bricksContainer.innerHTML = '';
            const levelConfig = config.levels[gameState.level - 1];
            const bricksToCreate = Math.min(levelConfig.bricks, config.brickRows * config.brickCols);

            for (let i = 0; i < config.brickRows; i++) {
                for (let j = 0; j < config.brickCols; j++) {
                    if (i * config.brickCols + j >= bricksToCreate) {
                        gameState.bricks.push(null);
                        continue;
                    }

                    const brick = document.createElement('div');
                    brick.className = 'brick';
                    brick.style.top = (i * (config.brickHeight + config.brickGap) + 50) + 'px';
                    brick.style.left = (j * (config.brickWidth + config.brickGap) + 20) + 'px';
                    brick.textContent = Math.floor(Math.random() * 9) + 1;
                    brick.dataset.x = j * (config.brickWidth + config.brickGap) + 20;
                    brick.dataset.y = i * (config.brickHeight + config.brickGap) + 50;

                    // Assign random color
                    const colorIndex = i % config.colors.length;
                    brick.style.borderLeftColor = config.colors[colorIndex];
                    brick.style.backgroundColor = `rgba(26, 26, 58, 0.8)`;

                    bricksContainer.appendChild(brick);
                    gameState.bricks.push({
                        element: brick,
                        x: parseInt(brick.dataset.x),
                        y: parseInt(brick.dataset.y),
                        color: config.colors[colorIndex],
                        rowsCleared: 0
                    });
                }
            }

            // Check for level completion
            if (gameState.bricks.every(brick => brick === null)) {
                completeLevel();
            }
        }

        // Handle level completion
        function completeLevel() {
            gameState.level++;
            if (gameState.level <= config.levels.length) {
                gameState.score += 1000 * (gameState.level - 1);
                updateDisplays();
                setTimeout(initGame, 1500);
            } else {
                gameOver.style.display = 'block';
                restartButton.style.display = 'block';
                gameState.gameOver = true;
            }
        }

        // Update score and level displays
        function updateDisplays() {
            scoreDisplay.textContent = `Score: ${gameState.score}`;
            levelDisplay.textContent = `Level: ${gameState.level}`;
        }

        // Main game loop
        function gameLoop() {
            if (gameState.gameOver || gameState.gamePaused) {
                gameState.animationId = requestAnimationFrame(gameLoop);
                return;
            }

            // Clear any existing particles
            neonParticles.innerHTML = '';

            // Update ball position
            gameState.ball.x += gameState.ball.dx;
            gameState.ball.y += gameState.ball.dy;

            // Ball collision with top
            if (gameState.ball.y <= 50) {
                gameState.ball.dy = -gameState.ball.dy;
                createParticle(gameState.ball.x, gameState.ball.y, 'green');
            }

            // Ball collision with sides
            if (gameState.ball.x <= gameState.ball.radius || gameState.ball.x >= gameContainer.offsetWidth - gameState.ball.radius) {
                gameState.ball.dx = -gameState.ball.dx;
                createParticle(gameState.ball.x, gameState.ball.y, 'blue');
            }

            // Ball collision with paddle
            if (gameState.ball.y >= gameState.paddle.y - gameState.ball.radius &&
                gameState.ball.y <= gameState.paddle.y + gameState.paddle.height + gameState.ball.radius &&
                gameState.ball.x >= gameState.paddle.x &&
                gameState.ball.x <= gameState.paddle.x + gameState.paddle.width) {

                // Calculate bounce angle based on where ball hits paddle
                const relativePosition = (gameState.ball.x - (gameState.paddle.x + gameState.paddle.width / 2)) /
                                         (gameState.paddle.width / 2);
                const bounceAngle = relativePosition * Math.PI / 4;

                gameState.ball.dy = -Math.abs(gameState.ball.dy);
                gameState.ball.dx = Math.abs(gameState.ball.dx) * Math.sin(bounceAngle);
                gameState.ball.dy *= Math.cos(bounceAngle);

                createParticle(gameState.ball.x, gameState.paddle.y, 'pink');
            }

            // Ball goes below paddle - lose life
            if (gameState.ball.y >= gameContainer.offsetHeight) {
                gameState.lives--;
                if (gameState.lives <= 0) {
                    gameOver.style.display = 'block';
                    restartButton.style.display = 'block';
                    gameState.gameOver = true;
                } else {
                    // Reset ball position
                    gameState.ball.x = gameContainer.offsetWidth / 2 - config.ballRadius;
                    gameState.ball.y = gameContainer.offsetHeight - 200 - config.ballRadius;
                    gameState.ball.dx = config.ballSpeed * (Math.random() > 0.5 ? 1 : -1);
                    gameState.ball.dy = -config.ballSpeed;
                }
            }

            // Ball collision with bricks
            for (let i = 0; i < gameState.bricks.length; i++) {
                if (gameState.bricks[i] === null) continue;

                const brick = gameState.bricks[i];
                const brickRight = brick.x + config.brickWidth;
                const brickBottom = brick.y + config.brickHeight;

                // Check if ball collides with brick
                if (gameState.ball.x + gameState.ball.radius > brick.x &&
                    gameState.ball.x - gameState.ball.radius < brickRight &&
                    gameState.ball.y + gameState.ball.radius > brick.y &&
                    gameState.ball.y - gameState.ball.radius < brickBottom) {

                    // Determine which side was hit
                    const topHit = gameState.ball.y - gameState.ball.radius < brick.y;
                    const bottomHit = gameState.ball.y + gameState.ball.radius > brickBottom;
                    const leftHit = gameState.ball.x - gameState.ball.radius < brick.x;
                    const rightHit = gameState.ball.x + gameState.ball.radius > brickRight;

                    if (topHit) {
                        gameState.ball.dy = -gameState.ball.dy;
                    } else if (bottomHit) {
                        gameState.ball.dy = -gameState.ball.dy;
                    } else if (leftHit) {
                        gameState.ball.dx = -gameState.ball.dx;
                    } else if (rightHit) {
                        gameState.ball.dx = -gameState.ball.dx;
                    }

                    // Remove the brick

                    // Update brick's rows cleared
                    gameState.bricks[i].rowsCleared++;
                    if (gameState.bricks[i].rowsCleared === config.brickRows) {
                        gameState.bricks[i].element.remove();
                        gameState.bricks.splice(i, 1);
                        gameState.score += 1000 * (gameState.level - 1);
                        updateDisplays();
                    }
                }
            }
        }
    </script>
</body>
</html>
```

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>PIXELIE - Pixel Art Editor</title>
    <style>
        :root {
            --bg-color: #1a1a1a;
            --panel-bg: #2a2a2a;
            --text-color: #e0e0e0;
            --accent-color: #ff6b6b;
            --primary-color: #4a90e2;
            --secondary-color: #555555;
        }

        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Courier New', monospace;
        }

        body {
            background-color: var(--bg-color);
            color: var(--text-color);
            overflow: hidden;
            min-height: 100vh;
            padding: 1rem;
        }

        .container {
            display: grid;
            grid-template-columns: 300px 1fr;
            gap: 1rem;
            height: calc(100vh - 2rem);
        }

        .sidebar {
            background-color: var(--panel-bg);
            padding: 1rem;
            border-radius: 8px;
            display: flex;
            flex-direction: column;
            gap: 1rem;
        }

        .canvas-container {
            position: relative;
            background-color: #000;
            border-radius: 8px;
            overflow: hidden;
            display: flex;
            flex-direction: column;
        }

        .canvas-wrapper {
            position: relative;
            flex-grow: 1;
            overflow: auto;
            cursor: crosshair;
        }

        canvas {
            background-color: #000;
            display: block;
            image-rendering: pixelated;
        }

        .color-picker {
            display: flex;
            gap: 0.5rem;
            align-items: center;
        }

        .color-swatch {
            width: 30px;
            height: 30px;
            border-radius: 4px;
            cursor: pointer;
            border: 2px solid transparent;
        }

        .color-swatch.active {
            border-color: white;
        }

        .tool-selection {
            display: flex;
            flex-direction: column;
            gap: 0.5rem;
        }

        .tool-btn {
            padding: 0.5rem;
            background-color: var(--panel-bg);
            border: 1px solid var(--secondary-color);
            border-radius: 4px;
            cursor: pointer;
            text-align: center;
            transition: background-color 0.2s;
        }

        .tool-btn:hover {
            background-color: #3a3a3a;
        }

        .tool-btn.active {
            background-color: var(--primary-color);
            border-color: var(--primary-color);
            color: white;
        }

        .export-section {
            margin-top: auto;
            padding-top: 1rem;
            border-top: 1px solid var(--secondary-color);
        }

        button {
            padding: 0.5rem 1rem;
            background-color: var(--panel-bg);
            border: 1px solid var(--secondary-color);
            border-radius: 4px;
            color: var(--text-color);
            cursor: pointer;
            transition: background-color 0.2s;
        }

        button:hover {
            background-color: #3a3a3a;
        }

        button.export-btn {
            background-color: var(--accent-color);
            border-color: var(--accent-color);
        }

        button.export-btn:hover {
            background-color: #ff5252;
        }

        .zoom-slider {
            width: 100%;
            margin: 0.5rem 0;
        }

        .status-bar {
            height: 24px;
            background-color: var(--panel-bg);
            padding: 0 0.5rem;
            border-radius: 4px;
            margin-top: 0.5rem;
            font-size: 0.8rem;
            display: flex;
            justify-content: space-between;
            align-items: center;
        }

        .zoom-info {
            font-weight: bold;
        }

        .color-info {
            font-weight: bold;
        }

        h1 {
            font-size: 1.5rem;
            margin-bottom: 1rem;
            color: var(--accent-color);
        }

        .palette-container {
            display: grid;
            grid-template-columns: repeat(10, 1fr);
            gap: 0.25rem;
        }

        .palette-btn {
            width: 20px;
            height: 20px;
            background-color: #333;
            border: 1px solid var(--secondary-color);
            border-radius: 2px;
            cursor: pointer;
            position: relative;
        }

        .palette-btn:hover {
            background-color: #444;
        }

        .palette-btn.active {
            background-color: var(--primary-color);
            border-color: var(--primary-color);
        }

        .palette-btn::after {
            content: '';
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            width: 12px;
            height: 12px;
            background-color: white;
            border-radius: 50%;
            opacity: 0.5;
        }

        .palette-btn.pin.active::after {
            opacity: 1;
        }

        @media (max-width: 768px) {
            .container {
                grid-template-columns: 1fr;
            }
            .sidebar {
                grid-column: 1 / -1;
            }
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="sidebar">
            <h1>PIXELIE</h1>

            <div class="palette-container">
                <button class="palette-btn pin active" data-color="#ffffff"></button>
                <button class="palette-btn" data-color="#e6e6e6"></button>
                <button class="palette-btn" data-color="#d0d0d0"></button>
                <button class="palette-btn" data-color="#b9b9b9"></button>
                <button class="palette-btn" data-color="#a0a0a0"></button>
                <button class="palette-btn" data-color="#888888"></button>
                <button class="palette-btn" data-color="#707070"></button>
                <button class="palette-btn" data-color="#595959"></button>
                <button class="palette-btn" data-color="#414141"></button>
                <button class="palette-btn" data-color="#292929"></button>
                <button class="palette-btn" data-color="#111111"></button>
                <button class="palette-btn" data-color="#000000"></button>
                <button class="palette-btn" data-color="#ff0000"></button>
                <button class="palette-btn" data-color="#ff6600"></button>
                <button class="palette-btn" data-color="#ffff00"></button>
                <button class="palette-btn" data-color="#66ff00"></button>
                <button class="palette-btn" data-color="#00ff66"></button>
                <button class="palette-btn" data-color="#00ffff"></button>
                <button class="palette-btn" data-color="#0066ff"></button>
                <button class="palette-btn" data-color="#6600ff"></button>
                <button class="palette-btn" data-color="#ff00ff"></button>
                <button class="palette-btn" data-color="#ff66ff"></button>
                <button class="palette-btn" data-color="#ffcc00"></button>
                <button class="palette-btn" data-color="#ff9900"></button>
                <button class="palette-btn" data-color="#ff6699"></button>
                <button class="palette-btn" data-color="#ff3366"></button>
                <button class="palette-btn" data-color="#ff0099"></button>
                <button class="palette-btn" data-color="#cc00ff"></button>
                <button class="palette-btn" data-color="#9900ff"></button>
                <button class="palette-btn" data-color="#6600cc"></button>
                <button class="palette-btn" data-color="#330099"></button>
                <button class="palette-btn" data-color="#000066"></button>
                <button class="palette-btn" data-color="#003366"></button>
                <button class="palette-btn" data-color="#006699"></button>
                <button class="palette-btn" data-color="#0099cc"></button>
                <button class="palette-btn" data-color="#6699ff"></button>
                <button class="palette-btn" data-color="#99ccff"></button>
                <button class="palette-btn" data-color="#66ccff"></button>
                <button class="palette-btn" data-color="#3399ff"></button>
                <button class="palette-btn" data-color="#0066ff"></button>
                <button class="palette-btn" data-color="#0099ff"></button>
                <button class="palette-btn" data-color="#00ccff"></button>
                <button class="palette-btn" data-color="#66ffcc"></button>
                <button class="palette-btn" data-color="#99ffcc"></button>
                <button class="palette-btn" data-color="#ccffcc"></button>
                <button class="palette-btn" data-color="#99ff99"></button>
                <button class="palette-btn" data-color="#66ff66"></button>
                <button class="palette-btn" data-color="#33ff33"></button>
                <button class="palette-btn" data-color="#00ff00"></button>
                <button class="palette-btn" data-color="#00cc00"></button>
                <button class="palette-btn" data-color="#009900"></button>
                <button class="palette-btn" data-color="#66cc00"></button>
                <button class="palette-btn" data-color="#99cc33"></button>
                <button class="palette-btn" data-color="#cccc00"></button>
                <button class="palette-btn" data-color="#cc9933"></button>
                <button class="palette-btn" data-color="#cc6633"></button>
                <button class="palette-btn" data-color="#cc3333"></button>
                <button class="palette-btn" data-color="#cc0000"></button>
                <button class="palette-btn" data-color="#ff66cc"></button>
                <button class="palette-btn" data-color="#ff9999"></button>
                <button class="palette-btn" data-color="#ffcccc"></button>
                <button class="palette-btn" data-color="#ff99ff"></button>
                <button class="palette-btn" data-color="#ff66ff"></button>
                <button class="palette-btn" data-color="#ff33ff"></button>
                <button class="palette-btn" data-color="#cc66cc"></button>
                <button class="palette-btn" data-color="#cc99cc"></button>
                <button class="palette-btn" data-color="#cccccc"></button>
                <button class="palette-btn" data-color="#cc9999"></button>
                <button class="palette-btn" data-color="#cc6666"></button>
                <button class="palette-btn" data-color="#cc3333"></button>
                <button class="palette-btn" data-color="#9966cc"></button>
                <button class="palette-btn" data-color="#9999cc"></button>
                <button class="palette-btn" data-color="#99cccc"></button>
                <button class="palette-btn" data-color="#999999"></button>
                <button class="palette-btn" data-color="#996699"></button>
                <button class="palette-btn" data-color="#993366"></button>
                <button class="palette-btn" data-color="#6666cc"></button>
                <button class="palette-btn" data-color="#6699cc"></button>
                <button class="palette-btn" data-color="#66cccc"></button>
                <button class="palette-btn" data-color="#669999"></button>
                <button class="palette-btn" data-color="#666699"></button>
                <button class="palette-btn" data-color="#663366"></button>
                <button class="palette-btn" data-color="#330099"></button>
                <button class="palette-btn" data-color="#000066"></button>
                <button class="palette-btn" data-color="#003366"></button>
                <button class="palette-btn" data-color="#006699"></button>
                <button class="palette-btn" data-color="#0099cc"></button>
                <button class="palette-btn" data-color="#6699ff"></button>
                <button class="palette-btn" data-color="#99ccff"></button>
                <button class="palette-btn" data-color="#66ccff"></button>
                <button class="palette-btn" data-color="#3399ff"></button>
                <button class="palette-btn" data-color="#0066ff"></button>
                <button class="palette-btn" data-color="#0099ff"></button>
                <button class="palette-btn" data-color="#00ccff"></button>
                <button class="palette-btn" data-color="#66ffcc"></button>
                <button class="palette-btn" data-color="#99ffcc"></button>
                <button class="palette-btn" data-color="#ccffcc"></button>
                <button class="palette-btn" data-color="#99ff99"></button>
                <button class="palette-btn" data-color="#66ff66"></button>
                <button class="palette-btn" data-color="#33ff33"></button>
                <button class="palette-btn" data-color="#00ff00"></button>
                <button class="palette-btn" data-color="#00cc00"></button>
                <button class="palette-btn" data-color="#009900"></button>
                <button class="palette-btn" data-color="#66cc00"></button>
                <button class="palette-btn" data-color="#99cc33"></button>
                <button class="palette-btn" data-color="#cccc00"></button>
                <button class="palette-btn" data-color="#cc9933"></button>
                <button class="palette-btn" data-color="#cc6633"></button>
                <button class="palette-btn" data-color="#cc3333"></button>
                <button class="palette-btn" data-color="#cc0000"></button>
                <button class="palette-btn" data-color="#ff66cc"></button>
                <button class="palette-btn" data-color="#ff9999"></button>
                <button class="palette-btn" data-color="#ffcccc"></button>
                <button class="palette-btn" data-color="#ff99ff"></button>
                <button class="palette-btn" data-color="#ff66ff"></button>
                <button class="palette-btn" data-color="#ff33ff"></button>
                <button class="palette-btn" data-color="#cc66cc"></button>
                <button class="palette-btn" data-color="#cc99cc"></button>
                <button class="palette-btn" data-color="#cccccc"></button>
                <button class="palette-btn" data-color="#cc9999"></button>
                <button class="palette-btn" data-color="#cc6666"></button>
                <button class="palette-btn" data-color="#cc3333"></button>
                <button class="palette-btn" data-color="#9966cc"></button>
                <button class="palette-btn" data-color="#9999cc"></button>
                <button class="palette-btn" data-color="#99cccc"></button>
                <button class="palette-btn" data-color="#999999"></button>
                <button class="palette-btn" data-color="#996699"></button>
                <button class="palette-btn" data-color="#993366"></button>
                <button class="palette-btn" data-color="#6666cc"></button>
                <button class="palette-btn" data-color="#6699cc"></button>
                <button class="palette-btn" data-color="#66cccc"></button>
                <button class="palette-btn" data-color="#669999"></button>
                <button class="palette-btn" data-color="#666699"></button>
                <button class="palette-btn" data-color="#663366"></button>
                <button class="palette-btn" data-color="#330099"></button>
                <button class="palette-btn" data-color="#000066"></button>
                <button class="palette-btn" data-color="#003366"></button>
                <button class="palette-btn" data-color="#006699"></button>
                <button class="palette-btn" data-color="#0099cc"></button>
                <button class="palette-btn" data-color="#6699ff"></button>
                <button class="palette-btn" data-color="#99ccff"></button>
                <button class="palette-btn" data-color="#66ccff"></button>
                <button class="palette-btn" data-color="#3399ff"></button>
                <button class="palette-btn" data-color="#0066ff"></button>
                <button class="palette-btn" data-color="#0099ff"></button>
                <button class="palette-btn" data-color="#00ccff"></button>
                <button class="palette-btn" data-color="#66ffcc"></button>
                <button class="palette-btn" data-color="#99ffcc"></button

#!/usr/bin/env python3
"""
Artistic Vignette Generator - A creative image processing pipeline that applies
vignette effects with customizable color inversion and lens distortion.
Includes local state persistence.
"""

import os
import json
import argparse
import base64
from pathlib import Path
from typing import Optional, Tuple, Dict, Any
from dataclasses import dataclass, asdict
from PIL import Image, ImageFilter, ImageEnhance, ImageOps
import numpy as np

# Configuration
STATE_FILE = "vignette_state.json"

@dataclass
class VignetteConfig:
    """Configuration for the artistic vignette effect."""
    vignette_strength: float = 0.7
    vignette_color: Tuple[int, int, int] = (0, 0, 0)
    color_inversion: float = 0.5
    lens_distortion: float = 0.3
    edge_enhancement: float = 1.5
    contrast: float = 1.2
    noise: bool = False
    noise_amount: float = 0.1

class VignetteGenerator:
    """Main class handling all vignette generation operations."""

    def __init__(self):
        self.config = self._load_state() or VignetteConfig()
        self._ensure_state_file()

    def _ensure_state_file(self) -> None:
        """Ensure state file exists."""
        if not Path(STATE_FILE).exists():
            with open(STATE_FILE, 'w') as f:
                json.dump({}, f)

    def _load_state(self) -> Optional[VignetteConfig]:
        """Load state from file if it exists."""
        if not Path(STATE_FILE).exists():
            return None
        try:
            with open(STATE_FILE, 'r') as f:
                state = json.load(f)
                return VignetteConfig(**state)
        except (json.JSONDecodeError, KeyError):
            return None

    def _save_state(self) -> None:
        """Save current configuration to file."""
        with open(STATE_FILE, 'w') as f:
            json.dump(asdict(self.config), f, indent=2)

    def apply_vignette(self, image: Image.Image) -> Image.Image:
        """
        Apply all vignette effects to an image.

        Args:
            image: PIL Image to process

        Returns:
            Processed Image with vignette effects
        """
        # Base image operations
        image = ImageOps.color_invert(image) if self.config.color_inversion > 0 else image

        # Vignette effect (darker edges)
        vignette_mask = Image.new('L', image.size, 0)
        for r in range(image.size[0]):
            for c in range(image.size[1]):
                dist = min(
                    (r - image.size[0] // 2) ** 2 + (c - image.size[1] // 2) ** 2,
                    (image.size[0] // 2) ** 2 + (image.size[1] // 2) ** 2
                ) ** 0.5
                vignette_mask.putpixel((r, c), int(255 * (1 - dist / max(image.size) * self.config.vignette_strength)))

        # Apply vignette color
        vignette_color_layer = Image.new('RGB', image.size, self.config.vignette_color)
        vignette_mask = vignette_mask.filter(ImageFilter.GaussianBlur(radius=5))
        vignette_mask = vignette_mask.resize(image.size)

        # Blend vignette with original
        alpha = Image.blend(image, vignette_color_layer, vignette_mask)

        # Additional effects
        alpha = alpha.filter(ImageFilter.UnsharpMask(radius=1.0, percent=100, threshold=2))
        alpha = ImageEnhance.Contrast(alpha).enhance(self.config.contrast)

        # Lens distortion
        if self.config.lens_distortion > 0:
            alpha = self._apply_lens_distortion(alpha)

        # Edge enhancement
        if self.config.edge_enhancement > 1:
            alpha = self._enhance_edges(alpha)

        # Add noise if enabled
        if self.config.noise:
            alpha = self._add_noise(alpha)

        return alpha

    def _apply_lens_distortion(self, image: Image.Image) -> Image.Image:
        """Apply lens distortion effect using numpy."""
        img_array = np.array(image)
        h, w = img_array.shape[:2]
        center = (w // 2, h // 2)

        # Create coordinate grid
        x, y = np.meshgrid(np.arange(w), np.arange(h))
        dx = (x - center[0]) / float(w)
        dy = (y - center[1]) / float(h)
        dist = np.sqrt(dx**2 + dy**2)
        distortion = self.config.lens_distortion * (1 - dist)

        # Apply distortion
        distorted_x = (x + distortion * (x - center[0])).astype(np.int32)
        distorted_y = (y + distortion * (y - center[1])).astype(np.int32)

        # Create distorted image
        distorted = np.zeros_like(img_array)
        for i in range(h):
            for j in range(w):
                if 0 <= distorted_x[i, j] < w and 0 <= distorted_y[i, j] < h:
                    distorted[i, j] = img_array[distorted_y[i, j], distorted_x[i, j]]

        return Image.fromarray(distorted)

    def _enhance_edges(self, image: Image.Image) -> Image.Image:
        """Enhance edges using edge detection and blending."""
        edge_detected = image.filter(ImageFilter.FIND_EDGES)
        edge_enhanced = Image.blend(image, edge_detected, self.config.edge_enhancement - 1)
        return edge_enhanced

    def _add_noise(self, image: Image.Image) -> Image.Image:
        """Add film grain noise to the image."""
        img_array = np.array(image)
        noise = np.random.normal(0, self.config.noise_amount * 255, img_array.shape).astype(np.int16)
        noisy = np.clip(img_array + noise, 0, 255).astype(np.uint8)
        return Image.fromarray(noisy)

    def process_image(self, input_path: str, output_path: Optional[str] = None) -> str:
        """
        Process an image file and save the result.

        Args:
            input_path: Path to input image
            output_path: Path to save output (defaults to input_path with _vignette added)

        Returns:
            Path to the output image
        """
        try:
            with Image.open(input_path) as img:
                processed = self.apply_vignette(img)

                if output_path is None:
                    base, ext = os.path.splitext(input_path)
                    output_path = f"{base}_vignette{ext}"

                processed.save(output_path)
                print(f"Successfully processed image: {output_path}")

                return output_path
        except Exception as e:
            print(f"Error processing image: {e}")
            raise

    def update_config(self, **kwargs) -> None:
        """Update configuration with new values."""
        for key, value in kwargs.items():
            if hasattr(self.config, key):
                setattr(self.config, key, value)
        self._save_state()

def main():
    """Command line interface for the vignette generator."""
    parser = argparse.ArgumentParser(description="Artistic Vignette Generator - Apply creative vignette effects to images.")
    parser.add_argument("input", help="Input image path")
    parser.add_argument("-o", "--output", help="Output image path (optional)")
    parser.add_argument("--vignette-strength", type=float, default=None,
                       help="Vignette strength (0-1)")
    parser.add_argument("--vignette-color", type=int, nargs=3, default=None,
                       help="Vignette color as RGB values")
    parser.add_argument("--color-inversion", type=float, default=None,
                       help="Color inversion strength (0-1)")
    parser.add_argument("--lens-distortion", type=float, default=None,
                       help="Lens distortion amount")
    parser.add_argument("--edge-enhancement", type=float, default=None,
                       help="Edge enhancement strength")
    parser.add_argument("--contrast", type=float, default=None,
                       help="Contrast enhancement")
    parser.add_argument("--noise", action="store_true",
                       help="Enable noise addition")
    parser.add_argument("--noise-amount", type=float, default=None,
                       help="Noise amount (0-1)")

    args = parser.parse_args()

    generator = VignetteGenerator()

    # Update config with provided arguments
    updates = {
        k: v for k, v in vars(args).items()
        if v is not None and k != 'input' and k != 'output'
    }

    if updates:
        generator.update_config(**updates)
        print("Configuration updated. Processing with new settings...")
    else:
        print("Using saved configuration or defaults.")

    # Process the image
    generator.process_image(args.input, args.output)

if __name__ == "__main__":
    main()

<?php
/**
 * Plugin Name: Ailey's Creative Post Type Builder
 * Description: Creates custom post types with dynamic meta boxes and confetti animation on success
 * Version: 1.0
 * Author: Ailey
 * License: GPL2
 */

// Constants
define('AILEY_CPT_BUILDER_VERSION', '1.0');
define('AILEY_CPT_BUILDER_DIR', plugin_dir_path(__FILE__));

// Check if WordPress or Joomla is installed
if (function_exists('add_action')) {
    // WordPress implementation
    class Ailey_CPT_Builder {
        private $confetti_enabled = true;

        public function __construct() {
            add_action('init', [$this, 'register_custom_post_type']);
            add_action('add_meta_boxes', [$this, 'add_custom_meta_boxes']);
            add_action('save_post', [$this, 'save_custom_meta'], 10, 2);
            add_filter('the_content', [$this, 'add_confetti_animation']);

            // Special post type for showcase
            add_action('init', [$this, 'register_showcase_post_type']);
        }

        public function register_custom_post_type() {
            $labels = [
                'name'               => _x('Ailey Projects', 'post type general name', 'ailey-cpt-builder'),
                'singular_name'      => _x('Ailey Project', 'post type singular name', 'ailey-cpt-builder'),
                'menu_name'          => _x('Ailey Projects', 'admin menu', 'ailey-cpt-builder'),
                'name_admin_bar'     => _x('Ailey Project', 'add new on admin bar', 'ailey-cpt-builder'),
                'add_new'            => _x('Add New', 'project', 'ailey-cpt-builder'),
                'add_new_item'       => __('Add New Project', 'ailey-cpt-builder'),
                'new_item'           => __('New Project', 'ailey-cpt-builder'),
                'view_item'          => __('View Project', 'ailey-cpt-builder'),
                'all_items'          => __('All Projects', 'ailey-cpt-builder'),
                'search_items'       => __('Search Projects', 'ailey-cpt-builder'),
                'parent_item_colon'  => __('Parent Projects:', 'ailey-cpt-builder'),
                'not_found'          => __('No projects found.', 'ailey-cpt-builder'),
                'not_found_in_trash' => __('No projects found in Trash.', 'ailey-cpt-builder'),
            ];

            $args = [
                'labels'             => $labels,
                'public'             => true,
                'publicly_queryable' => true,
                'show_ui'            => true,
                'show_in_menu'       => true,
                'query_var'          => true,
                'rewrite'            => ['slug' => 'ailey-project'],
                'capability_type'    => 'post',
                'has_archive'        => true,
                'hierarchical'       => false,
                'menu_position'      => 5,
                'supports'           => ['title', 'editor', 'thumbnail'],
            ];

            register_post_type('ailey_project', $args);
        }

        public function register_showcase_post_type() {
            $labels = [
                'name'               => _x('Showcase Items', 'post type general name', 'ailey-cpt-builder'),
                'singular_name'      => _x('Showcase Item', 'post type singular name', 'ailey-cpt-builder'),
                'menu_name'          => _x('Showcase', 'admin menu', 'ailey-cpt-builder'),
            ];

            $args = [
                'labels'             => $labels,
                'public'             => false,
                'show_ui'            => true,
                'show_in_menu'       => true,
                'capability_type'    => 'post',
                'menu_position'      => 6,
                'supports'           => ['title', 'editor', 'thumbnail'],
                'show_in_rest'       => true,
            ];

            register_post_type('showcase_item', $args);
        }

        public function add_custom_meta_boxes() {
            add_meta_box(
                'ailey_project_details',
                __('Project Details', 'ailey-cpt-builder'),
                [$this, 'render_project_details_meta_box'],
                'ailey_project',
                'normal',
                'high'
            );

            add_meta_box(
                'ailey_project_creative_info',
                __('Creative Information', 'ailey-cpt-builder'),
                [$this, 'render_creative_info_meta_box'],
                'ailey_project',
                'advanced',
                'default'
            );
        }

        public function render_project_details_meta_box($post) {
            wp_nonce_field('ailey_project_details_nonce', 'ailey_project_details_nonce');
            $project_type = get_post_meta($post->ID, '_project_type', true);
            $project_url = get_post_meta($post->ID, '_project_url', true);
            $project_status = get_post_meta($post->ID, '_project_status', true);

            echo '<div class="ailey-meta-box">';
            echo '<label for="project_type">' . __('Project Type:', 'ailey-cpt-builder') . '</label>';
            echo '<select id="project_type" name="_project_type">';
            echo '<option value="web" ' . selected($project_type, 'web', false) . '>Website</option>';
            echo '<option value="app" ' . selected($project_type, 'app', false) . '>Mobile App</option>';
            echo '<option value="design" ' . selected($project_type, 'design', false) . '>Design System</option>';
            echo '<option value="other" ' . selected($project_type, 'other', false) . '>Other</option>';
            echo '</select>';

            echo '<label for="project_url">' . __('Project URL:', 'ailey-cpt-builder') . '</label>';
            echo '<input type="url" id="project_url" name="_project_url" value="' . esc_attr($project_url) . '" placeholder="https://example.com" />';

            echo '<label for="project_status">' . __('Project Status:', 'ailey-cpt-builder') . '</label>';
            echo '<select id="project_status" name="_project_status">';
            echo '<option value="planning" ' . selected($project_status, 'planning', false) . '>Planning</option>';
            echo '<option value="development" ' . selected($project_status, 'development', false) . '>Development</option>';
            echo '<option value="testing" ' . selected($project_status, 'testing', false) . '>Testing</option>';
            echo '<option value="live" ' . selected($project_status, 'live', false) . '>Live</option>';
            echo '</select>';
            echo '</div>';
        }

        public function render_creative_info_meta_box($post) {
            wp_nonce_field('ailey_creative_info_nonce', 'ailey_creative_info_nonce');
            $creative_style = get_post_meta($post->ID, '_creative_style', true);
            $inspiration_source = get_post_meta($post->ID, '_inspiration_source', true);
            $fun_fact = get_post_meta($post->ID, '_fun_fact', true);

            echo '<div class="ailey-meta-box">';
            echo '<label for="creative_style">' . __('Creative Style:', 'ailey-cpt-builder') . '</label>';
            echo '<select id="creative_style" name="_creative_style">';
            echo '<option value="minimalist" ' . selected($creative_style, 'minimalist', false) . '>Minimalist</option>';
            echo '<option value="modern" ' . selected($creative_style, 'modern', false) . '>Modern</option>';
            echo '<option value="vintage" ' . selected($creative_style, 'vintage', false) . '>Vintage</option>';
            echo '<option value="experimental" ' . selected($creative_style, 'experimental', false) . '>Experimental</option>';
            echo '</select>';

            echo '<label for="inspiration_source">' . __('Inspiration Source:', 'ailey-cpt-builder') . '</label>';
            echo '<input type="text" id="inspiration_source" name="_inspiration_source" value="' . esc_attr($inspiration_source) . '" placeholder="Nature, AI, etc." />';

            echo '<label for="fun_fact">' . __('Fun Fact:', 'ailey-cpt-builder') . '</label>';
            echo '<textarea id="fun_fact" name="_fun_fact" rows="3">' . esc_html($fun_fact) . '</textarea>';
            echo '</div>';
        }

        public function save_custom_meta($post_id, $post) {
            // Verify nonce
            if (!isset($_POST['ailey_project_details_nonce']) || !wp_verify_nonce($_POST['ailey_project_details_nonce'], 'ailey_project_details_nonce')) {
                return;
            }

            if (!isset($_POST['ailey_creative_info_nonce']) || !wp_verify_nonce($_POST['ailey_creative_info_nonce'], 'ailey_creative_info_nonce')) {
                return;
            }

            // Verify post type
            if ('ailey_project' !== $post->post_type) {
                return;
            }

            // Update project details
            if (isset($_POST['_project_type'])) {
                update_post_meta($post_id, '_project_type', sanitize_text_field($_POST['_project_type']));
            }

            if (isset($_POST['_project_url'])) {
                update_post_meta($post_id, '_project_url', esc_url_raw($_POST['_project_url']));
            }

            if (isset($_POST['_project_status'])) {
                update_post_meta($post_id, '_project_status', sanitize_text_field($_POST['_project_status']));
            }

            // Update creative info
            if (isset($_POST['_creative_style'])) {
                update_post_meta($post_id, '_creative_style', sanitize_text_field($_POST['_creative_style']));
            }

            if (isset($_POST['_inspiration_source'])) {
                update_post_meta($post_id, '_inspiration_source', sanitize_text_field($_POST['_inspiration_source']));
            }

            if (isset($_POST['_fun_fact'])) {
                update_post_meta($post_id, '_fun_fact', sanitize_textarea_field($_POST['_fun_fact']));
            }

            // Add showcase item if project is live
            if (isset($_POST['_project_status']) && $_POST['_project_status'] === 'live') {
                $showcase_item = get_posts([
                    'post_type' => 'showcase_item',
                    'meta_query' => [
                        [
                            'key' => '_project_id',
                            'value' => $post_id,
                        ],
                    ],
                    'numberposts' => 1,
                ]);

                if (empty($showcase_item)) {
                    $new_showcase = [
                        'post_title' => sprintf(__('Showcase: %s', 'ailey-cpt-builder'), get_the_title($post)),
                        'post_type' => 'showcase_item',
                        'post_status' => 'publish',
                        'post_content' => get_post_field('post_content', $post_id),
                    ];

                    $showcase_id = wp_insert_post($new_showcase);
                    if (!is_wp_error($showcase_id)) {
                        update_post_meta($showcase_id, '_project_id', $post_id);
                        update_post_meta($showcase_id, '_project_type', get_post_meta($post_id, '_project_type', true));
                        update_post_meta($showcase_id, '_creative_style', get_post_meta($post_id, '_creative_style', true));
                    }
                }
            }
        }

        public function add_confetti_animation($content) {
            if ($this->confetti_enabled && is_admin() && !wp_doing_ajax() && function_exists('wp_enqueue_script')) {
                wp_enqueue_script('ailey-confetti', plugins_url('confetti.js', __FILE__), ['jquery'], AILEY_CPT_BUILDER_VERSION, true);
                wp_enqueue_style('ailey-confetti', plugins_url('confetti.css', __FILE__), [], AILEY_CPT_BUILDER_VERSION);
            }
            return $content;
        }
    }

    // Initialize the plugin
    new Ailey_CPT_Builder();
} elseif (class_exists('JFactory')) {
    // Joomla implementation
    class AileyCptBuilder extends JObject {
        protected $confetti_enabled = true;

        public function __construct() {
            parent::__construct();
            $this->registerCustomPostType();
            $this->addCustomMetaBoxes();
            $this->addConfettiScript();
        }

        public function registerCustomPostType() {
            $table = '#__ailey_projects';
            $query = "CREATE TABLE IF NOT EXISTS $table (
                id INT AUTO_INCREMENT PRIMARY KEY,
                title VARCHAR(255) NOT NULL,
                content TEXT,
                type ENUM('web', 'app', 'design', 'other') NOT NULL DEFAULT 'web',
                url VARCHAR(255),
                status ENUM('planning', 'development', 'testing', 'live') NOT NULL DEFAULT 'planning',
                creative_style ENUM('minimalist', 'modern', 'vintage', 'experimental'),
                inspiration_source VARCHAR(255),
                fun_fact TEXT,
                created datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
                modified datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                published INT NOT NULL DEFAULT 0,
                author_id INT NOT NULL DEFAULT 1,
                FOREIGN KEY (author_id) REFERENCES #__users(id)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";

            $db = JFactory::getDbo();
            $db->setQuery($query);
            if (!$db->execute()) {
                JError::raiseError(500, $db->getErrorMessage());
            }

            $this->createShowcaseTable();
        }

        protected function createShowcaseTable() {
            $table = '#__showcase_items';
            $query = "CREATE TABLE IF NOT EXISTS $table (
                id INT AUTO_INCREMENT PRIMARY KEY,
                title VARCHAR(255) NOT NULL,
                project_id INT NOT NULL,
                content TEXT,
                created datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
                FOREIGN KEY (project_id) REFERENCES #__ailey_projects(id)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";

            $db = JFactory::getDbo();
            $db->setQuery($query);
            if (!$db->execute()) {
                JError::raiseError(500, $db->getErrorMessage());
            }
        }

        public function addCustomMetaBoxes() {
            // In Joomla, we'll add this to the admin form via a plugin
            // This would typically be done in a system plugin
            JPluginHelper::registerPlugin('system', 'aileycptbuilder');
        }

        public function addConfettiScript() {
            $document = JFactory::getApplication()->getDocument();
            $document->addStyleSheet(JUri::root() . 'plugins/system/aileycptbuilder/confetti.css');
            $document->addScript(JUri::root() . 'plugins/system/aileycptbuilder/confetti.js');
        }
    }

    // Initialize the module
    $aileyCptBuilder = new AileyCptBuilder();
}

// Confetti animation files would be included here in a real plugin
// This is just a placeholder for the structure
?>

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>404 – Pixel Lost</title>
  <style>
    :root {
      --bg: #0a0a0a;
      --accent: #ff4d4d;
      --text: #e0e0e0;
      --pixel: #ff2222;
      --easter: #4dff4d;
    }

    * {
      margin: 0;
      padding: 0;
      box-sizing: border-box;
      font-family: 'Courier New', monospace;
    }

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

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

    .title {
      font-size: 2.5rem;
      margin-bottom: 1rem;
      text-shadow: 0 0 8px rgba(255, 77, 77, 0.3);
    }

    .subtitle {
      font-size: 1.2rem;
      margin-bottom: 2rem;
      color: rgba(224, 224, 224, 0.8);
    }

    .pixel-grid {
      width: 100%;
      height: 300px;
      position: relative;
      margin-bottom: 2rem;
      display: grid;
      grid-template-columns: repeat(40, 1fr);
      grid-template-rows: repeat(20, 1fr);
      gap: 1px;
      background: linear-gradient(45deg, #000 25%, transparent 25%), linear-gradient(-45deg, #000 25%, transparent 25%), linear-gradient(45deg, transparent 75%, #000 75%), linear-gradient(-45deg, transparent 75%, #000 75%);
      background-size: 40px 40px;
      border: 1px solid #333;
    }

    .pixel {
      background-color: var(--pixel);
      width: 100%;
      height: 100%;
      transition: background-color 0.1s ease;
      cursor: pointer;
    }

    .pixel:hover {
      background-color: var(--easter);
      transform: scale(1.2);
    }

    .easter-indicator {
      position: absolute;
      bottom: -20px;
      left: 0;
      right: 0;
      font-size: 0.9rem;
      color: var(--easter);
      opacity: 0.7;
      transition: opacity 0.3s ease;
    }

    .easter-indicator:hover {
      opacity: 1;
    }

    .console-output {
      background-color: #1e1e1e;
      border: 1px solid #444;
      border-radius: 4px;
      padding: 1rem;
      margin-top: 1rem;
      max-height: 200px;
      overflow-y: auto;
      font-family: 'Courier New', monospace;
      font-size: 0.9rem;
      line-height: 1.4;
    }

    .console-line {
      margin-bottom: 0.3rem;
    }

    .success {
      color: var(--easter);
    }

    .error {
      color: var(--pixel);
    }

    .form {
      margin-top: 2rem;
      width: 100%;
      max-width: 300px;
    }

    .form input {
      width: 100%;
      padding: 0.5rem;
      background-color: #333;
      border: 1px solid #555;
      color: var(--text);
      font-family: inherit;
      font-size: 1rem;
      margin-bottom: 1rem;
    }

    .form button {
      background-color: var(--accent);
      color: white;
      border: none;
      padding: 0.5rem 1rem;
      font-size: 1rem;
      cursor: pointer;
      border-radius: 4px;
      transition: background-color 0.2s ease;
    }

    .form button:hover {
      background-color: #ff3333;
    }

    .hidden {
      display: none;
    }

    @media (max-width: 600px) {
      .title {
        font-size: 1.8rem;
      }
      .subtitle {
        font-size: 1rem;
      }
    }
  </style>
</head>
<body>
  <div class="container">
    <h1 class="title">404 – Pixel Lost</h1>
    <p class="subtitle">The page you're looking for has escaped to the pixel grid. Try to find the hidden Easter Egg!</p>

    <div class="pixel-grid" id="pixelGrid">
      <!-- Pixels will be generated by JS -->
    </div>

    <div class="easter-indicator" id="easterIndicator">
      <strong>Easter Egg:</strong> Click the hidden green pixel to unlock the secret!
    </div>

    <div class="console-output" id="consoleOutput">
      <div class="console-line">System: Initializing 404 simulation...</div>
      <div class="console-line">System: Pixel grid loaded (800x400)</div>
      <div class="console-line">System: Waiting for user interaction...</div>
    </div>

    <div class="form hidden" id="form">
      <input type="text" id="inputCode" placeholder="Enter the secret code...">
      <button id="checkCode">Check Code</button>
    </div>
  </div>

  <script>
    // Configuration
    const GRID_SIZE = 40;
    const PIXEL_COUNT = GRID_SIZE * GRID_SIZE;
    const EASTER_EGG_POSITION = [15, 10]; // Row, Column
    const SECRET_CODE = "PIXEL404";
    const ANIMATION_DURATION = 500;

    // DOM elements
    const pixelGrid = document.getElementById('pixelGrid');
    const consoleOutput = document.getElementById('consoleOutput');
    const easterIndicator = document.getElementById('easterIndicator');
    const form = document.getElementById('form');
    const inputCode = document.getElementById('inputCode');
    const checkCodeBtn = document.getElementById('checkCode');

    // Create the pixel grid
    function createPixelGrid() {
      for (let row = 0; row < GRID_SIZE; row++) {
        for (let col = 0; col < GRID_SIZE; col++) {
          const pixel = document.createElement('div');
          pixel.className = 'pixel';
          pixel.dataset.row = row;
          pixel.dataset.col = col;

          // Set the Easter Egg pixel
          if (row === EASTER_EGG_POSITION[0] && col === EASTER_EGG_POSITION[1]) {
            pixel.style.backgroundColor = '#4dff4d';
            pixel.dataset.easter = 'true';
          }

          pixel.addEventListener('click', handlePixelClick);
          pixelGrid.appendChild(pixel);
        }
      }

      logConsole("System: Pixel grid creation complete");
    }

    // Handle pixel click
    function handlePixelClick(e) {
      const row = parseInt(e.target.dataset.row);
      const col = parseInt(e.target.dataset.col);

      // Check if this is the Easter Egg
      if (e.target.dataset.easter === 'true') {
        e.target.style.backgroundColor = '#4dff4d';
        e.target.style.transform = 'scale(1.2)';
        logConsole("System: Easter Egg found! Form unlocked.", true);
        form.classList.remove('hidden');
        easterIndicator.classList.add('hidden');
        return;
      }

      // Animate the clicked pixel
      e.target.style.backgroundColor = '#4dff4d';
      e.target.style.transform = 'scale(1.2)';

      // Create a ripple effect
      setTimeout(() => {
        e.target.style.backgroundColor = '#ff2222';
        e.target.style.transform = 'scale(1)';

        // Create multiple ripples
        for (let i = 0; i < 5; i++) {
          setTimeout(() => {
            const ripplePixels = getRipplePixels(row, col, i);
            ripplePixels.forEach(pixel => {
              pixel.style.backgroundColor = '#4dff4d';
              setTimeout(() => {
                pixel.style.backgroundColor = '#ff2222';
              }, 100);
            });
          }, i * 100);
        }
      }, 200);

      logConsole(`System: Pixel clicked at [${row},${col}]`);
    }

    // Get pixels for ripple effect
    function getRipplePixels(centerRow, centerCol, iteration) {
      const radius = iteration + 1;
      const pixels = [];

      for (let row = 0; row < GRID_SIZE; row++) {
        for (let col = 0; col < GRID_SIZE; col++) {
          const distance = Math.sqrt(
            Math.pow(row - centerRow, 2) +
            Math.pow(col - centerCol, 2)
          );

          if (distance <= radius) {
            const pixel = document.querySelector(`.pixel[data-row="${row}"][data-col="${col}"]`);
            if (pixel) pixels.push(pixel);
          }
        }
      }

      return pixels;
    }

    // Check the secret code
    function checkSecretCode() {
      const code = inputCode.value.trim().toUpperCase();

      if (code === SECRET_CODE) {
        logConsole("System: Access granted! Congratulations!", true);
        showEasterEggSurprise();
      } else {
        logConsole(`System: Invalid code: ${code}`, false);
      }
    }

    // Show the Easter Egg surprise
    function showEasterEggSurprise() {
      // Disable the form
      form.classList.add('hidden');

      // Change the console output
      consoleOutput.innerHTML = `
        <div class="console-line">System: Access granted! Welcome to the secret area!</div>
        <div class="console-line success">Secret: The Easter Egg is actually a hidden message!</div>
        <div class="console-line success">Secret: Try clicking the Easter Egg pixel again to see the message.</div>
        <div class="console-line success">Secret: Congratulations on finding this creative 404 page!</div>
      `;

      // Add a special effect to the Easter Egg pixel
      const easterPixel = document.querySelector(`.pixel[data-row="${EASTER_EGG_POSITION[0]}"][data-col="${EASTER_EGG_POSITION[1]}"]`);
      if (easterPixel) {
        easterPixel.style.backgroundColor = '#4dff4d';
        easterPixel.style.animation = 'pulse 1s infinite';
      }

      // Add animation to the console
      const consoleLines = consoleOutput.querySelectorAll('.console-line');
      consoleLines.forEach((line, index) => {
        line.style.transition = `all ${index * 0.1}s ease`;
        line.style.opacity = '0';
        line.style.transform = 'translateY(20px)';
        setTimeout(() => {
          line.style.opacity = '1';
          line.style.transform = 'translateY(0)';
        }, index * 100);
      });
    }

    // Log to console
    function logConsole(message, isSuccess = false) {
      const line = document.createElement('div');
      line.className = `console-line ${isSuccess ? 'success' : 'error'}`;
      line.textContent = message;

      if (consoleOutput.children.length > 10) {
        consoleOutput.removeChild(consoleOutput.children[0]);
      }

      consoleOutput.appendChild(line);
      consoleOutput.scrollTop = consoleOutput.scrollHeight;
    }

    // Initialize the page
    function init() {
      createPixelGrid();
      checkCodeBtn.addEventListener('click', checkSecretCode);
    }

    // Start the application
    init();
  </script>
</body>
</html>

using UnityEngine;
using UnityEngine.Rendering.Universal;
using UnityEngine.Tilemap;
using UnityEngine.UI;

[ExecuteInEditMode]
[RequireComponent(typeof( TilemapRenderer ))]
public class AileysDynamicFogOfWar : MonoBehaviour
{
    [Header( "Fog Settings" )]
    [SerializeField] private float revealSpeed = 0.5f;
    [SerializeField] private float maxVisionRadius = 5f;
    [SerializeField] private float distortionIntensity = 0.3f;
    [SerializeField] private bool enableDarkMode = false;
    [SerializeField] private Color fogColor = new Color( 0f, 0f, 0f, 0.7f );

    [Header( "Scan Settings" )]
    [SerializeField] private float scanCooldown = 1f;
    [SerializeField] private float scanRadius = 3f;
    [SerializeField] private AnimationCurve scanPulse;

    [Header( "References" )]
    [SerializeField] private Tilemap visionTilemap;
    [SerializeField] private Tilemap revealedTilemap;
    [SerializeField] private Tilemap scanTilemap;
    [SerializeField] private TileBase fogTile;
    [SerializeField] private TileBase revealedTile;
    [SerializeField] private TileBase scanTile;
    [SerializeField] private Color darkModeFogColor = new Color( 0f, 0f, 0f, 0.9f );
    [SerializeField] private Color darkModeRevealedColor = new Color( 0.1f, 0.1f, 0.1f );

    private TilemapRenderer visionRenderer;
    private TilemapRenderer revealedRenderer;
    private TilemapRenderer scanRenderer;

    private Vector3Int playerPosition;
    private float timeSinceLastScan;
    private float currentScanPulse;

    private void Awake()
    {
        if ( visionTilemap == null || revealedTilemap == null || scanTilemap == null )
        {
            Debug.LogError( "Missing required Tilemap references!" );
            return;
        }

        visionRenderer = visionTilemap.GetComponent<TilemapRenderer>();
        revealedRenderer = revealedTilemap.GetComponent<TilemapRenderer>();
        scanRenderer = scanTilemap.GetComponent<TilemapRenderer>();

        visionRenderer.tilingRule = TilemapTilingRule.Staggered;
        revealedRenderer.tilingRule = TilemapTilingRule.Staggered;
        scanRenderer.tilingRule = TilemapTilingRule.Staggered;

        if ( fogTile == null )
        {
            fogTile = new Tile();
            fogTile.sprite = null;
            fogTile.color = enableDarkMode ? darkModeFogColor : fogColor;
        }

        if ( revealedTile == null )
        {
            revealedTile = new Tile();
            revealedTile.sprite = null;
            revealedTile.color = enableDarkMode ? darkModeRevealedColor : Color.white;
        }

        if ( scanTile == null )
        {
            scanTile = new Tile();
            scanTile.sprite = null;
            scanTile.color = Color.yellow;
        }

        UpdateFogTiles();
    }

    private void Update()
    {
        if ( Application.isPlaying )
        {
            timeSinceLastScan += Time.deltaTime;

            if ( timeSinceLastScan >= scanCooldown )
            {
                TriggerScan();
            }

            currentScanPulse = Mathf.PingPong( Time.time * 2f, 1f ) * scanPulse.Evaluate( 0.5f );
        }
    }

    private void UpdateFogTiles()
    {
        Color fogColor = enableDarkMode ? darkModeFogColor : this.fogColor;
        fogTile.color = fogColor;

        Color revealedColor = enableDarkMode ? darkModeRevealedColor : Color.white;
        revealedTile.color = revealedColor;
    }

    private void TriggerScan()
    {
        timeSinceLastScan = 0f;
        ScanArea( playerPosition, scanRadius );
    }

    private void ScanArea( Vector3Int center, float radius )
    {
        float scanProgress = Mathf.Clamp01( ( Time.time * 5f ) % 1f );
        Vector3Int min = center - Vector3Int.CeilToInt( Vector3Int.one * radius );
        Vector3Int max = center + Vector3Int.CeilToInt( Vector3Int.one * radius );

        for ( int x = min.x; x <= max.x; x++ )
        {
            for ( int z = min.z; z <= max.z; z++ )
            {
                Vector3Int pos = new Vector3Int( x, 0, z );
                float distance = Vector3.Distance( center, pos );

                if ( distance <= radius )
                {
                    float revealProgress = Mathf.Clamp01( ( radius - distance ) / radius * 2f );

                    // Update vision tilemap
                    visionTilemap.SetTile( pos, fogTile );

                    // Update revealed tilemap with progression
                    Tile progressTile = new Tile();
                    progressTile.color = revealedTile.color;
                    progressTile.color.a = Mathf.Lerp( 0f, 1f, revealProgress );
                    revealedTilemap.SetTile( pos, progressTile );
                }
            }
        }

        // Apply scan effect to the current scan position
        Tile scanEffect = new Tile();
        scanEffect.color = scanTile.color;
        scanEffect.color.a = currentScanPulse;
        scanTilemap.SetTile( playerPosition, scanEffect );
    }

    public void SetPlayerPosition( Vector3Int position )
    {
        playerPosition = position;
        ScanArea( position, maxVisionRadius );
    }

    private void OnDrawGizmos()
    {
        if ( Application.isPlaying )
        {
            Gizmos.color = Color.red;
            Gizmos.DrawWireSphere( transform.position, maxVisionRadius );
        }
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Cosmic Spinners — 12+ CSS-Only Loading Animations</title>
  <style>
    :root {
      --bg-light: #f5f7fa;
      --text-light: #333;
      --accent-light: #6c5ce7;
      --bg-dark: #1a1a2e;
      --text-dark: #f5f7fa;
      --accent-dark: #bb86fc;
    }

    .dark-mode {
      --bg: var(--bg-dark);
      --text: var(--text-dark);
      --accent: var(--accent-dark);
    }

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

    body {
      background: var(--bg);
      color: var(--text);
      line-height: 1.6;
      min-height: 100vh;
      padding: 2rem;
      transition: background 0.5s, color 0.5s;
    }

    .container {
      max-width: 1200px;
      margin: 0 auto;
    }

    header {
      text-align: center;
      margin-bottom: 3rem;
      padding-bottom: 1rem;
      border-bottom: 1px solid rgba(255, 255, 255, 0.1);
    }

    h1 {
      font-size: 2.5rem;
      margin-bottom: 0.5rem;
      background: linear-gradient(90deg, var(--accent), #9333ea);
      -webkit-background-clip: text;
      background-clip: text;
      color: transparent;
    }

    .subtitle {
      font-size: 1.2rem;
      color: rgba(255, 255, 255, 0.8);
      margin-bottom: 1rem;
    }

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

    .toggle-btn {
      padding: 0.5rem 1rem;
      background: rgba(255, 255, 255, 0.2);
      color: var(--text);
      border: none;
      border-radius: 0.5rem;
      cursor: pointer;
      font-size: 0.9rem;
      transition: all 0.3s;
    }

    .toggle-btn.active {
      background: var(--accent);
      color: white;
    }

    .spinner-grid {
      display: grid;
      grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
      gap: 2rem;
      margin-bottom: 3rem;
    }

    .spinner-card {
      background: rgba(255, 255, 255, 0.1);
      border-radius: 1rem;
      padding: 1.5rem;
      transition: transform 0.3s, box-shadow 0.3s;
      position: relative;
      overflow: hidden;
    }

    .spinner-card:hover {
      transform: translateY(-5px);
      box-shadow: 0 10px 20px rgba(0, 0, 0, 0.2);
    }

    .spinner-card h3 {
      margin-bottom: 1rem;
      font-size: 1.3rem;
    }

    .spinner-container {
      height: 100px;
      display: flex;
      justify-content: center;
      align-items: center;
      margin: 1rem 0;
    }

    .spinner {
      width: 50px;
      height: 50px;
      position: relative;
    }

    /* Spinner 1: Fade Pulses */
    .spinner-1 .dot {
      position: absolute;
      width: 10px;
      height: 10px;
      background: var(--accent);
      border-radius: 50%;
      animation: fadePulse 1.5s infinite ease-in-out;
    }

    .spinner-1 .dot:nth-child(2) { animation-delay: 0.3s; }
    .spinner-1 .dot:nth-child(3) { animation-delay: 0.6s; }
    .spinner-1 .dot:nth-child(4) { animation-delay: 0.9s; }

    @keyframes fadePulse {
      0%, 100% { opacity: 0.4; transform: scale(0.8); }
      50% { opacity: 1; transform: scale(1); }
    }

    /* Spinner 2: Orbiting Circles */
    .spinner-2 {
      position: relative;
    }

    .spinner-2 .circle {
      position: absolute;
      width: 15px;
      height: 15px;
      background: var(--accent);
      border-radius: 50%;
      animation: orbit 3s infinite linear;
    }

    .spinner-2 .circle:nth-child(1) { animation-delay: 0.1s; }
    .spinner-2 .circle:nth-child(2) { animation-delay: 0.2s; }
    .spinner-2 .circle:nth-child(3) { animation-delay: 0.3s; }
    .spinner-2 .circle:nth-child(4) { animation-delay: 0.4s; }

    @keyframes orbit {
      0% { transform: rotate(0deg) translate(30px, 0); }
      100% { transform: rotate(360deg) translate(30px, 0); }
    }

    /* Spinner 3: Wave Pulse */
    .spinner-3 {
      position: relative;
      overflow: hidden;
    }

    .spinner-3 .wave {
      position: absolute;
      width: 100%;
      height: 2px;
      background: var(--accent);
      border-radius: 1px;
      animation: wavePulse 1s infinite ease-in-out;
    }

    @keyframes wavePulse {
      0%, 100% { height: 2px; transform: translateX(-50%); }
      50% { height: 4px; transform: translateX(50%); }
    }

    /* Spinner 4: Bouncing Dots */
    .spinner-4 .dot {
      position: absolute;
      width: 10px;
      height: 10px;
      background: var(--accent);
      border-radius: 50%;
      animation: bounce 1.5s infinite ease-in-out;
    }

    .spinner-4 .dot:nth-child(1) { top: 20px; left: 20px; animation-delay: 0s; }
    .spinner-4 .dot:nth-child(2) { top: 20px; right: 20px; animation-delay: 0.2s; }
    .spinner-4 .dot:nth-child(3) { bottom: 20px; left: 20px; animation-delay: 0.4s; }
    .spinner-4 .dot:nth-child(4) { bottom: 20px; right: 20px; animation-delay: 0.6s; }

    @keyframes bounce {
      0%, 100% { transform: translateY(0) scale(1); }
      50% { transform: translateY(-20px) scale(1.2); }
    }

    /* Spinner 5: Rotating Bars */
    .spinner-5 {
      position: relative;
    }

    .spinner-5 .bar {
      position: absolute;
      width: 4px;
      height: 20px;
      background: var(--accent);
      border-radius: 2px;
      animation: rotate 1.5s infinite linear;
    }

    .spinner-5 .bar:nth-child(1) { transform-origin: 50% 0; animation-delay: 0.1s; }
    .spinner-5 .bar:nth-child(2) { transform-origin: 50% 0; animation-delay: 0.2s; }
    .spinner-5 .bar:nth-child(3) { transform-origin: 50% 0; animation-delay: 0.3s; }
    .spinner-5 .bar:nth-child(4) { transform-origin: 50% 0; animation-delay: 0.4s; }

    @keyframes rotate {
      0% { transform: rotate(0deg); }
      100% { transform: rotate(360deg); }
    }

    /* Spinner 6: Flickering Stars */
    .spinner-6 .star {
      position: absolute;
      width: 8px;
      height: 8px;
      background: var(--accent);
      clip-path: polygon(50% 0%, 61% 35%, 98% 35%, 68% 57%, 79% 91%, 50% 70%, 21% 91%, 32% 57%, 2% 35%, 39% 35%);
      animation: flicker 1.5s infinite ease-in-out;
    }

    .spinner-6 .star:nth-child(1) { top: 10px; left: 10px; animation-delay: 0s; }
    .spinner-6 .star:nth-child(2) { top: 10px; right: 10px; animation-delay: 0.2s; }
    .spinner-6 .star:nth-child(3) { bottom: 10px; left: 10px; animation-delay: 0.4s; }
    .spinner-6 .star:nth-child(4) { bottom: 10px; right: 10px; animation-delay: 0.6s; }

    @keyframes flicker {
      0%, 100%, 17%, 53% { opacity: 0.3; transform: scale(0.9); }
      33%, 67% { opacity: 1; transform: translateX(-5px) rotate(0deg); }
      75% { transform: translate(5px, -3px) scale(0.95); }
      100% { transform: translate(0, 0) scale(1); }
    }

    /* Spinner 7: Pulsing Orbs */
    .spinner-7 {
      position: relative;
    }

    .spinner-7 .orb {
      position: absolute;
      width: 20px;
      height: 20px;
      background: var(--accent);
      border-radius: 50%;
      filter: blur(2px);
      animation: pulseOrbit 2.5s infinite ease-in-out;
    }

    .spinner-7 .orb:nth-child(1) { animation-delay: 0.1s; }
    .spinner-7 .orb:nth-child(2) { animation-delay: 0.2s; }
    .spinner-7 .orb:nth-child(3) { animation-delay: 0.3s; }

    @keyframes pulseOrbit {
      0% { transform: rotate(0deg) translate(25px, 0) scale(0.8); opacity: 0.7; }
      50% { transform: rotate(180deg) translate(25px, 0) scale(1.2); opacity: 1; }
      75% { transform: rotate(360deg) translate(25px, 0) scale(0.8); opacity: 0.7; }
    }

    /* Spinner 8: Zigzag Lines */
    .spinner-8 {
      position: relative;
      height: 40px;
    }

    .spinner-8 .line {
      position: absolute;
      width: 3px;
      height: 20px;
      background: var(--accent);
      left: 50%;
      transform: translateX(-50%);
      animation: zigzag 1s infinite ease-in-out;
    }

    .spinner-8 .line:nth-child(1) { top: 0; animation-delay: 0.1s; }
    .spinner-8 .line:nth-child(2) { top: 10px; animation-delay: 0.2s; }
    .spinner-8 .line:nth-child(3) { top: 20px; animation-delay: 0.3s; }

    @keyframes zigzag {
      0%, 100% { transform: translate(-5px, 0) translateX(-50%); }
      50% { transform: translate(5px, -3px) scale(0.95); }
    }

    /* Spinner 9: Color Shift Pulse */
    .spinner-9 {
      position: relative;
    }

    .spinner-9 .dot {
      position: absolute;
      width: 15px;
      height: 15px;
      border-radius: 50%;
      animation: colorPulse 1.5s infinite ease-in-out;
    }

    .spinner-9 .dot:nth-child(1) { top: 15px; left: 15px; }
    .spinner-9 .dot:nth-child(2) { top: 15px; right: 15px; }
    .spinner-9 .dot:nth-child(3) { bottom: 15px; left: 15px; }
    .spinner-9 .dot:nth-child(4) { bottom: 15px; right: 15px; }

    @keyframes colorPulse {
      0% { background: var(--accent); transform: scale(0.8); }
      25% { background: #bb86fc; transform: scale(1.2); }
      50% { background: #9333ea; transform: scale(0.9); }
      75% { background: #f0abfc; transform: scale(1.1); }
      100% { background: var(--accent); transform: scale(0.8); }
    }

    /* Spinner 10: Starlight Trail */
    .spinner-10 {
      position: relative;
      overflow: hidden;
    }

    .spinner-10 .trail {
      position: absolute;
      width: 1px;
      height: 20px;
      background: var(--accent);
      border-radius: 0.5px;
      animation: starlightTrail 1.5s infinite linear;
    }

    .spinner-10 .trail:nth-child(1) { animation-delay: 0.1s; }
    .spinner-10 .trail:nth-child(2) { animation-delay: 0.2s; }
    .spinner-10 .trail:nth-child(3) { animation-delay: 0.3s; }
    .spinner-10 .trail:nth-child(4) { animation-delay: 0.4s; }

    @keyframes starlightTrail {
      0% { opacity: 0; transform: translateX(-50px) rotate(0deg); }
      10% { opacity: 1; transform: translateX(-30px) rotate(10deg); }
      20% { opacity: 1; transform: translateX(-10px) rotate(20deg); }
      30% { opacity: 1; transform: translateX(10px) rotate(30deg); }
      40% { opacity: 1; transform: translateX(30px) rotate(40deg); }
      50% { opacity: 1; transform: translateX(50px) rotate(50deg); }
      60% { opacity: 0; transform: translateX(70px) rotate(60deg); }
      100% { opacity: 0; transform: translateX(-50px) rotate(0deg); }
    }

    /* Spinner 11: Glitch Effect */
    .spinner-11 {
      position: relative;
      font-size: 0;
    }

    .spinner-11 .glitch {
      position: absolute;
      width: 30px;
      height: 30px;
      background: var(--accent);
      border-radius: 4px;
      animation: glitch 0.5s infinite;
    }

    @keyframes glitch {
      0% { transform: translate(0, 0) scale(1); }
      25% { transform: translate(-3px, 2px) scale(1.05); }
      50% { transform: translate(2px, -3px) scale(0.95); }
      75% { transform: translate(0, 0) scale(1); }
      100% { transform: translate(0, 0) scale(1); }
    }

    /* Spinner 12: Nebula Pulse */
    .spinner-12 {
      position: relative;
      overflow: hidden;
    }

    .spinner-12 .nebula {
      position: absolute;
      width: 100%;
      height: 100%;
      background: var(--accent);
      border-radius: 50%;
      animation: nebulaPulse 2s infinite linear;
    }

    @keyframes nebulaPulse {
      0% { transform: scale(1); opacity: 0.5; }
      50% { transform: scale(1.2); opacity: 0.8; }
      100% { transform: scale(1); opacity: 0.5; }
    }
  </style>
</head>
<body>
  <div class="container">
    <header>
      <h1>Cosmic Spinners — 12+ CSS-Only Loading Animations</h1>
      <p class="subtitle">A collection of 12 stunning CSS-only loading animations</p>
    </header>
    <div class="toggle-container">
      <button class="toggle-btn" onclick="toggleTheme()">Toggle Theme

```swift
import SwiftUI
import CoreData
import CoreHaptics
import UniformTypeIdentifiers

// MARK: - CoreData Setup

extension MemoryMazeApp {
    static let shared = MemoryMazeApp()

    static var preview: MemoryMazeApp = {
        let result = MemoryMazeApp()
        let container = NSPersistentContainer(name: "MemoryMazeCoreData")
        container.persistentStoreDescriptions.first!.url = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: "group.com.ailey.memorymaze")?.appendingPathComponent("MemoryMazeCoreData.sqlite")
        container.loadPersistentStores { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        }
        result.container = container
        return result
    }()

    @Environment(\.managedObjectContext) private var viewContext

    lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "MemoryMazeCoreData")
        container.loadPersistentStores { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        }
        return container
    }()

    var managedObjectContext: NSManagedObjectContext {
        return persistentContainer.viewContext
    }

    func save() {
        if managedObjectContext.hasChanges {
            do {
                try managedObjectContext.save()
            } catch {
                let nserror = error as NSError
                fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
            }
        }
    }
}

class Note: NSManagedObject, Identifiable {
    @NSManaged var title: String
    @NSManaged var content: String
    @NSManaged var positionX: Double
    @NSManaged var positionY: Double
    @NSManaged var color: String
    @NSManaged var isLocked: Bool
    @NSManaged var createdAt: Date
    @NSManaged var updatedAt: Date

    var coordinates: (x: Double, y: Double) {
        return (positionX, positionY)
    }
}

class NoteColor: NSManagedObject, Identifiable {
    @NSManaged var name: String
    @NSManaged var hexColor: String
}

class MemoryMazeApp: NSObject, ObservableObject {
    @Published var notes: [Note] = []
    @Published var selectedNote: Note?
    @Published var showAddNoteSheet = false
    @Published var showNoteDetail = false
    @Published var showColorPicker = false
    @Published var selectedColor: String = "FF5722"
    @Published var mazeSize: Double = 300
    @Published var mazeLevel: Int = 1
    @Published var showSettings = false
    @Published var isEditing = false
    @Published var searchText: String = ""
    @Published var showDeleteAlert = false

    lazy var engine = try? CHHapticEngine()

    override init() {
        super.init()
        fetchNotes()
        fetchColors()
        setupHaptics()
    }

    func setupHaptics() {
        guard CHHapticEngine.capabilitiesForHardware().supportsHaptics else { return }

        do {
            try engine?.start()
        } catch {
            print("Haptic engine failed to start: \(error.localizedDescription)")
        }
    }

    func fetchNotes() {
        let fetchRequest: NSFetchRequest<Note> = Note.fetchRequest()
        do {
            notes = try viewContext.fetch(fetchRequest)
            notes.sort { $0.createdAt > $1.createdAt }
        } catch {
            print("Fetch failed: \(error)")
        }
    }

    func fetchColors() {
        let fetchRequest: NSFetchRequest<NoteColor> = NoteColor.fetchRequest()
        do {
            let colors = try viewContext.fetch(fetchRequest)
            if colors.isEmpty {
                let defaultColors = [
                    NoteColor(name: "Red", hexColor: "FF5722"),
                    NoteColor(name: "Blue", hexColor: "2196F3"),
                    NoteColor(name: "Green", hexColor: "4CAF50"),
                    NoteColor(name: "Yellow", hexColor: "FFEB3B"),
                    NoteColor(name: "Purple", hexColor: "9C27B0")
                ]

                for color in defaultColors {
                    viewContext.insert(color)
                }

                try viewContext.save()
            }
        } catch {
            print("Fetch colors failed: \(error)")
        }
    }

    func saveNote(_ note: Note) {
        note.updatedAt = Date()
        do {
            try viewContext.save()
            fetchNotes()
        } catch {
            print("Save note failed: \(error)")
        }
    }

    func addNote(title: String, content: String, position: (x: Double, y: Double) = (0, 0)) {
        let note = Note(context: viewContext)
        note.title = title
        note.content = content
        note.positionX = position.x
        note.positionY = position.y
        note.color = selectedColor
        note.isLocked = false
        note.createdAt = Date()
        note.updatedAt = Date()

        saveNote(note)
    }

    func deleteNote(_ note: Note) {
        viewContext.delete(note)
        save()
    }

    func toggleLock(_ note: Note) {
        note.isLocked.toggle()
        saveNote(note)
    }

    func updateNoteColor(_ note: Note, color: String) {
        note.color = color
        saveNote(note)
    }

    func changeMazeSize(size: Double) {
        mazeSize = size
    }

    func increaseMazeLevel() {
        mazeLevel = min(mazeLevel + 1, 5)
    }

    func decreaseMazeLevel() {
        mazeLevel = max(mazeLevel - 1, 1)
    }

    func playHapticFeedback() {
        guard CHHapticEngine.capabilitiesForHardware().supportsHaptics else { return }

        let intensity = CHHapticEventParameter(parameterID: .hapticIntensity, value: 0.5)
        let sharpness = CHHapticEventParameter(parameterID: .hapticSharpness, value: 0.3)

        let event = CHHapticEvent(eventType: .click, parameters: [intensity, sharpness], relativeTime: 0)

        do {
            let pattern = try CHHapticPattern(events: [event], parameters: [])
            try engine?.play(pattern)
        } catch {
            print("Failed to play pattern: \(error.localizedDescription)")
        }
    }

    func save() {
        do {
            try viewContext.save()
            fetchNotes()
        } catch {
            let nserror = error as NSError
            print("Unresolved error \(nserror), \(nserror.userInfo)")
        }
    }
}

// MARK: - Models

struct NotePreview: View {
    var note: Note

    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            Text(note.title)
                .font(.headline)
            Text(note.content)
                .font(.subheadline)
                .lineLimit(2)
        }
        .padding(8)
        .background(Color.white.opacity(0.9))
        .cornerRadius(8)
        .shadow(radius: 2)
    }
}

// MARK: - Views

struct MemoryMazeNoteView: View {
    @ObservedObject var app: MemoryMazeApp
    @State private var isEditing = false
    @State private var noteContent = ""
    @State private var noteTitle = ""

    var note: Note

    init(app: MemoryMazeApp, note: Note) {
        self.app = app
        self.note = note
    }

    var body: some View {
        VStack(spacing: 16) {
            HStack {
                if note.isLocked {
                    Image(systemName: "lock.fill")
                        .font(.caption)
                        .foregroundColor(.gray)
                }

                Text(note.title)
                    .font(.headline)
                    .lineLimit(1)

                Spacer()

                if note.isLocked {
                    Button(action: {
                        app.toggleLock(note)
                        app.playHapticFeedback()
                    }) {
                        Image(systemName: "lock.open.fill")
                            .font(.caption)
                            .foregroundColor(.blue)
                    }
                }
            }

            if isEditing {
                VStack(alignment: .leading, spacing: 8) {
                    TextField("Title", text: $noteTitle, prompt: Text("Title"))
                        .font(.headline)
                        .textFieldStyle(.roundedBorder)

                    ScrollView {
                        VStack(alignment: .leading, spacing: 4) {
                            TextEditor(text: .constant(note.content))
                                .font(.body)
                                .frame(minHeight: 100)
                        }
                    }
                    .frame(maxHeight: 200)
                }
                .padding(8)
                .background(Color(.systemBackground))
                .cornerRadius(12)
                .shadow(radius: 4)
                .padding(.horizontal, 8)
            } else {
                Text(note.content)
                    .font(.body)
                    .lineLimit(5)
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .padding(.horizontal, 8)
                    .padding(.vertical, 4)
            }

            HStack {
                Button(action: {
                    isEditing.toggle()
                    if !isEditing {
                        note.title = noteTitle
                        note.content = noteContent
                        app.saveNote(note)
                    }
                    app.playHapticFeedback()
                }) {
                    Text(isEditing ? "Done" : "Edit")
                        .font(.caption)
                        .fontWeight(.semibold)
                        .foregroundColor(.white)
                        .padding(.horizontal, 8)
                        .padding(.vertical, 4)
                        .background(Color.blue)
                        .cornerRadius(6)
                }

                Spacer()

                Button(action: {
                    app.showColorPicker = true
                    app.playHapticFeedback()
                }) {
                    Circle()
                        .fill(Color(note.color, bundle: nil))
                        .frame(width: 24, height: 24)
                }
                .sheet(isPresented: $app.showColorPicker) {
                    ColorPickerView(app: app, selectedColor: $app.selectedColor, currentColor: note.color)
                }
            }
            .padding(.horizontal, 8)
        }
        .background(
            RoundedRectangle(cornerRadius: 16)
                .fill(Color(note.color, bundle: nil).opacity(0.2))
                .shadow(color: Color(note.color, bundle: nil).opacity(0.3), radius: 8, x: 0, y: 4)
        )
        .frame(width: 120, height: 160)
        .cornerRadius(16)
        .shadow(radius: 8)
        .offset(x: note.positionX, y: note.positionY)
        .gesture(
            DragGesture()
                .onEnded { value in
                    if !note.isLocked && !isEditing {
                        let newX = min(max(note.positionX + value.translation.width, -50), 50)
                        let newY = min(max(note.positionY + value.translation.height, -50), 50)

                        note.positionX = newX
                        note.positionY = newY
                        app.saveNote(note)
                        app.playHapticFeedback()
                    }
                }
        )
        .onAppear {
            noteTitle = note.title
            noteContent = note.content
        }
    }
}

struct ColorPickerView: View {
    @ObservedObject var app: MemoryMazeApp
    @Binding var selectedColor: String
    var currentColor: String

    let colorOptions: [String] = ["FF5722", "2196F3", "4CAF50", "FFEB3B", "9C27B0", "00BCD4", "8BC34A", "FF9800"]

    var body: some View {
        VStack(spacing: 24) {
            Text("Choose Color")
                .font(.title2)
                .fontWeight(.bold)

            VStack(spacing: 12) {
                ForEach(colorOptions, id: \.self) { color in
                    Button(action: {
                        selectedColor = color
                        app.updateNoteColor(app.selectedNote!, color: color)
                        app.showColorPicker = false
                        app.playHapticFeedback()
                    }) {
                        Circle()
                            .fill(Color(color, bundle: nil))
                            .frame(width: 50, height: 50)
                            .shadow(radius: 4)
                            .overlay(
                                Circle()
                                    .stroke(Color.white.opacity(0.3), lineWidth: 2)
                            )
                    }
                    .buttonStyle(PlainButtonStyle())
                }
            }

            Text(currentColor)
                .font(.caption)
                .fontWeight(.light)
                .foregroundColor(.gray)
        }
        .padding()
        .frame(width: 280, height: 400)
        .background(Color(.systemBackground))
        .cornerRadius(16)
        .shadow(radius: 8)
    }
}

struct AddNoteView: View {
    @ObservedObject var app: MemoryMazeApp
    @Environment(\.dismiss) var dismiss

    @State private var noteTitle = ""
    @State private var noteContent = ""

    var body: some View {
        NavigationView {
            Form {
                Section(header: Text("New Note")) {
                    TextField("Title", text: $noteTitle, prompt: Text("Title"))
                        .autocapitalization(.words)
                        .disableAutocorrection(true)

                    TextEditor(text: .constant(noteContent))
                        .font(.body)
                        .frame(minHeight: 150)
                        .overlay(
                            Text("Write your note here...")
                                .foregroundColor(.gray.opacity(0.5))
                                .padding(.horizontal, 8)
                                .padding(.vertical, 16)
                        )
                }

                Section {
                    Button(action: {
                        if !noteTitle.isEmpty || !noteContent.isEmpty {
                            app.addNote(title: noteTitle, content: noteContent)
                            dismiss()
                            app.playHapticFeedback()
                        }
                    }) {
                        Text("Save Note")
                            .fontWeight(.semibold)
                            .frame(maxWidth: .infinity)
                    }
                }
            }
            .navigationTitle("Add Note")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button("Cancel") {
                        dismiss()
                    }
                }
            }
        }
    }
}

struct MemoryMazeMainView: View {
    @ObservedObject var app = MemoryMazeApp.shared
    @State private var isAddingNote = false
    @State private var mazeSize: Double = 300
    @State private var mazeLevel: Int = 1
    @State private var selectedNote: Note?
    @State private var searchText: String = ""

    var filteredNotes: [Note] {
        if searchText.isEmpty {
            return app.notes
        } else {
            return app.notes.filter { note in
                note.title.localizedCaseInsensitiveContains(searchText) ||
                note.content.localizedCaseInsensitiveContains(searchText)
            }
        }
    }

    var body: some View {
        NavigationView {
            ZStack {
                // Maze Background
                Color(.systemBackground)
                    .ignoresSafeArea()

                // Maze Grid
                ForEach(0..<mazeLevel*5, id: \.self) { x in
                    ForEach(0..<mazeLevel*5, id: \.self) { y in
                        Rectangle()
                            .fill(Color.gray.opacity(0.1))
                            .frame(width: mazeSize / 5, height: mazeSize / 5)
                            .offset(x: mazeSize / 5 * Double(x), y: mazeSize / 5 * Double(y))
                    }
                }

                // Notes
                ForEach(filteredNotes) { note in
                    MemoryMazeNoteView(app: app, note: note)
                        .onTapGesture {
                            selectedNote = note
                            app.selectedNote = note
                            app.showNoteDetail = true
                        }
                }

                // Add Note Button (Floating Action Button)
                Button(action: {
                    isAddingNote = true
                }) {
                    Image(systemName: "plus.circle.fill")
                        .font(.title)
                        .foregroundColor(.white)
                        .padding(12)
                        .background(Color.blue)
                        .clipShape(Circle())
                        .shadow(radius: 10)
                }
                .offset(y: 100)
                .sheet(isPresented: $isAddingNote) {
                    AddNoteView(app: app)
                }

                // Search
                SearchView(app: app, searchText: $searchText)
                    .padding(.top, 10)
            }
            .navigationTitle("Memory Maze")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: {
                        app.showSettings = true
                    }) {
                        Image(systemName: "slider.horizontal.3")
                            .font(.caption)
                    }
                }
            }
            .sheet(isPresented: $app.showSettings) {
                SettingsView(app: app)
            }
            .sheet(item: $selectedNote) { note in
                NoteDetailView(app: app, note: note)
            }
        }
        .preferredColorScheme(.light)
    }
}

struct SearchView: View {
    @ObservedObject var app: MemoryMazeApp
    @Binding var searchText: String

    var body: some View

import SwiftUI
import CoreData

@main
struct WhimsyNotesApp: App {
    let persistenceController = PersistenceController.shared

    var body: some Scene {
        WindowGroup {
            NotesListView()
                .environment(\.managedObjectContext, persistenceController.container.viewContext)
                .keyboardShortcuts([
                    KeyboardShortcut("N", modifiers: [.command], action: AddNoteAction()),
                    KeyboardShortcut("E", modifiers: [.command, .shift], action: EditNoteAction()),
                    KeyboardShortcut("D", modifiers: [.command, .shift], action: DeleteNoteAction())
                ])
        }
    }
}

class PersistenceController: ObservableObject {
    static let shared = PersistenceController()
    let container: NSPersistentContainer

    init() {
        container = NSPersistentContainer(name: "WhimsyNotes")
        container.loadPersistentStores { description, error in
            if let error = error {
                fatalError("CoreData failed to load: \(error.localizedDescription)")
            }
        }
    }

    func save() {
        do {
            try container.viewContext.save()
        } catch {
            let nsError = error as NSError
            fatalError("Unresolved error \(nsError), \(nsError.userInfo)")
        }
    }
}

struct Note: Identifiable, PersistentModel {
    @Attribute var id: String
    @Attribute var title: String
    @Attribute var content: String
    @Attribute var color: String
    @Attribute var emoji: String
}

struct NotesListView: View {
    @Environment(\.managedObjectContext) private var viewContext
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Note.title, ascending: true)],
        animation: .default
    ) private var notes: FetchedResults<Note>

    @State private var newTitle = ""
    @State private var newContent = ""
    @State private var selectedColor = Color.blue.opacity(0.7)
    @State private var selectedEmoji = "😊"

    var body: some View {
        NavigationView {
            List {
                ForEach(notes) { note in
                    NoteRow(note: note, selectedColor: selectedColor, selectedEmoji: selectedEmoji)
                        .onTapGesture {
                            withAnimation {
                                selectedColor = Color(note.color)
                                selectedEmoji = note.emoji
                            }
                        }
                }
                .onDelete { indices in
                    let objects = indices.map { notes[$0] }
                    deleteObjects(objects)
                }
            }
            .navigationTitle("WhimsyNotes")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    EditButton()
                }
                ToolbarItem(placement: .navigationBarTrailing) {
                    AddButton { withAnimation {
                        let newNote = Note(context: viewContext)
                        newNote.id = UUID().uuidString
                        newNote.title = newTitle
                        newNote.content = newContent
                        newNote.color = selectedColor.description
                        newNote.emoji = selectedEmoji
                        do {
                            try viewContext.save()
                            newTitle = ""
                            newContent = ""
                        } catch {
                            print("Save failed: \(error)")
                        }
                    }}
                }
            }
            .sheet(isPresented: .constant(false)) { // Placeholder for edit sheet
                EmptyView()
            }
        }
    }

    private func deleteObjects(_ notes: [Note]) {
        notes.forEach { viewContext.delete($0) }
        PersistenceController.shared.save()
    }
}

struct NoteRow: View {
    let note: Note
    let selectedColor: Color
    let selectedEmoji: String

    var body: some View {
        HStack(spacing: 12) {
            Circle()
                .fill(Color(note.color))
                .frame(width: 40, height: 40)
                .overlay(
                    Text(note.emoji)
                        .font(.system(size: 20))
                )
            VStack(alignment: .leading, spacing: 4) {
                Text(note.title)
                    .font(.headline)
                Text(note.content)
                    .font(.subheadline)
                    .foregroundColor(.secondary)
                if note.content.count > 20 {
                    Text("...")
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
            }
        }
        .padding(.vertical, 8)
        .transition(.opacity.combined(with: .scale))
    }
}

struct AddButton: View {
    let action: () -> Void

    var body: some View {
        Button(action: action) {
            Image(systemName: "plus")
        }
    }
}

struct EditButton: View {
    var body: some View {
        Button("Edit") {
            print("Edit")
        }
    }
}

struct AddNoteAction: KeyboardShortcutProvider {
    var keyboardShortcuts: [KeyboardShortcut<NoteAction>] {
        [KeyboardShortcut("N", modifiers: [.command], action: NoteAction.add)]
    }
}

struct EditNoteAction: KeyboardShortcutProvider {
    var keyboardShortcuts: [KeyboardShortcut<NoteAction>] {
        [KeyboardShortcut("E", modifiers: [.command, .shift], action: NoteAction.edit)]
    }
}

struct DeleteNoteAction: KeyboardShortcutProvider {
    var keyboardShortcuts: [KeyboardShortcut<NoteAction>] {
        [KeyboardShortcut("D", modifiers: [.command, .shift], action: NoteAction.delete)]
    }
}

enum NoteAction: KeyboardShortcutPhase {
    case add, edit, delete

    var shortcutPhase: KeyboardShortcutPhase {
        self
    }

    var displayRepresentation: String? {
        switch self {
        case .add: return "Add Note"
        case .edit: return "Edit Note"
        case .delete: return "Delete Note"
        }
    }
}

struct WhimsyNotes_Previews: PreviewProvider {
    static var previews: some View {
        NotesListView()
            .environment(\.managedObjectContext, PersistenceController.shared.container.viewContext)
    }
}

use anyhow::{Context, Result};
use reqwest::StatusCode;
use std::path::PathBuf;
use std::sync::Arc;
use tokio::fs::File;
use tokio::io::AsyncReadExt;
use walkdir::WalkDir;
use futures::stream::StreamExt;

#[tokio::main]
async fn main() -> Result<()> {
    let args: Vec<String> = std::env::args().collect();
    let markdown_files = if args.len() == 1 {
        // Easter Egg discovery path
        let mut easter_egg_path = PathBuf::from(".");
        easter_egg_path.push("secret.md");
        if easter_egg_path.exists() {
            println!("🔍 EASTER EGG FOUND! 🔍");
            println!("- Read this file with Marketing Overlord to reveal the secret!");
            return Ok(());
        }
        WalkDir::new(".").into_iter().filter_map(|entry| {
            let path = entry.ok()?.path();
            if path.is_file() && path.extension().and_then(|s| s.to_str()) == Some("md") {
                Some(path.to_path_buf())
            } else {
                None
            }
        }).collect()
    } else if args.len() == 2 {
        let path = args[1].as_str();
        if PathBuf::from(path).exists() && PathBuf::from(path).extension().map_or(false, |s| s == "md") {
            vec![PathBuf::from(path)]
        } else {
            WalkDir::new(path).into_iter().filter_map(|entry| {
                let path = entry.ok()?.path();
                if path.is_file() && path.extension().and_then(|s| s.to_str()) == Some("md") {
                    Some(path.to_path_buf())
                } else {
                    None
                }
            }).collect()
        }
    } else {
        eprintln!("Usage: {} [file_or_dir]", args[0]);
        std::process::exit(1);
    };

    if markdown_files.is_empty() {
        eprintln!("No Markdown files found");
        std::process::exit(1);
    }

    let client = reqwest::Client::new();
    let client_arc = Arc::new(client);

    let results = markdown_files.into_par_iter()
        .map(|path| {
            let client = client_arc.clone();
            async move {
                let file = File::open(&path).await?;
                let mut contents = String::new();
                file.read_to_string(&mut contents).await?;

                let links = extract_links(&contents);
                let failed_links = check_links(&links, &client).await;

                let report = generate_report(&path, &failed_links, &links);
                (path, report)
            }
        })
        .buffer_unordered(4)
        .collect::<Vec<_>>()
        .await;

    for (path, report) in results {
        if !report.is_empty() {
            println!("{}", report);
        }
    }

    Ok(())
}

fn extract_links(content: &str) -> Vec<String> {
    let mut links = Vec::new();
    let lines: Vec<&str> = content.lines().collect();

    for line in lines {
        if let Some(link) = line.find("](") {
            let end = line[link + 2..].find(')').map(|i| i + link + 2);
            if let Some(end_pos) = end {
                let url = &line[link + 2..end_pos];
                if !url.trim().starts_with("http") && !url.trim().starts_with("#") {
                    links.push(url.trim().to_string());
                }
            }
        }
    }

    links
}

async fn check_links(links: &[String], client: &reqwest::Client) -> Vec<(String, Result<(), StatusCode>)> {
    let mut results = Vec::new();

    for link in links {
        let url = link.trim();
        if url.starts_with("#") {
            results.push((url.to_string(), Ok(())));
            continue;
        }

        let response = match client.get(url).send().await {
            Ok(r) => {
                if r.status().is_success() {
                    Ok(())
                } else {
                    Err(r.status())
                }
            }
            Err(_) => Err(StatusCode::INTERNAL_SERVER_ERROR),
        };

        results.push((url.to_string(), response));
    }

    results
}

fn generate_report(path: &PathBuf, failed_links: &[(String, Result<(), StatusCode>)], all_links: &[String]) -> String {
    let file_name = path.file_name().unwrap().to_str().unwrap();
    let report_lines: Vec<String> = failed_links.iter()
        .filter(|(_, result)| result.is_err())
        .map(|(url, _)| {
            let confidence = 100;
            format!("- {}: EXTREMELY BROKEN ({}% confidence) - This link is broken beyond belief. Consider updating it or removing it entirely.")
        })
        .collect();

    if report_lines.is_empty() {
        String::new()
    } else {
        format!(
            "\n🔍 LINK CHECK REPORT FOR {} 🔍\n\n🚨 BROKEN LINKS DETECTED:\n{}\n\n📊 TOTAL LINKS: {}\n✅ GOOD LINKS: {}\n🚨 BROKEN LINKS: {}\n\n💡 PRO TIP: Marketing Overlord suggests:\n- If a link is broken, check if the domain exists at all (maybe it was rebranded?)\n- Try adding 'www.' before the domain\n- Consider adding a 404 redirect to your server if this is your own link\n\n🔥 MARKETING OVERLORD REPORT: SUCCESSFULLY GENERATED 🔥",
            file_name,
            report_lines.join("\n"),
            all_links.len(),
            all_links.len() - report_lines.len(),
            report_lines.len()
        )
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>SoundSculpt — Live Audio Visualizer</title>
  <style>
    :root {
      --primary: #6a11cb;
      --secondary: #2575fc;
      --accent: #ff6b6b;
      --dark: #1a1a1a;
      --light: #f0f0f0;
      --glow: rgba(106, 17, 203, 0.5);
    }

    * {
      margin: 0;
      padding: 0;
      box-sizing: border-box;
    }

    body {
      font-family: 'Arial', sans-serif;
      background: linear-gradient(135deg, var(--dark), #0a0a0a);
      color: var(--light);
      min-height: 100vh;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      overflow: hidden;
      text-align: center;
    }

    .container {
      width: 100%;
      max-width: 1200px;
      padding: 2rem;
      position: relative;
    }

    h1 {
      font-size: 2.5rem;
      margin-bottom: 1.5rem;
      text-shadow: 0 0 10px var(--glow);
      background: linear-gradient(90deg, var(--primary), var(--secondary));
      -webkit-background-clip: text;
      background-clip: text;
      color: transparent;
      animation: shimmer 3s infinite alternate;
    }

    @keyframes shimmer {
      0% { background-position: 0 0; }
      100% { background-position: 200% 0; }
    }

    .wave-container {
      position: relative;
      height: 400px;
      margin: 2rem 0;
      overflow: hidden;
    }

    .waveform-canvas {
      width: 100%;
      height: 100%;
      background: rgba(0, 0, 0, 0.2);
      border-radius: 8px;
      box-shadow: 0 0 20px rgba(0, 0, 0, 0.5);
    }

    .controls {
      display: flex;
      justify-content: center;
      gap: 1.5rem;
      margin: 2rem 0;
      flex-wrap: wrap;
    }

    button {
      padding: 0.8rem 1.5rem;
      background: var(--primary);
      color: white;
      border: none;
      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.2);
    }

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

    button.big {
      padding: 1rem 2rem;
      font-size: 1.1rem;
    }

    .color-picker {
      display: flex;
      flex-direction: column;
      gap: 0.5rem;
    }

    .color-option {
      width: 24px;
      height: 24px;
      border-radius: 50%;
      cursor: pointer;
      border: 2px solid transparent;
    }

    .color-option.active {
      border-color: white;
    }

    .wave-patterns {
      display: flex;
      justify-content: center;
      gap: 1rem;
      margin: 1.5rem 0;
      flex-wrap: wrap;
    }

    .pattern-toggle {
      width: 24px;
      height: 24px;
      border-radius: 50%;
      border: 2px solid var(--primary);
      cursor: pointer;
      transition: all 0.3s ease;
    }

    .pattern-toggle.active {
      background: var(--accent);
      transform: scale(1.2);
    }

    .info {
      position: absolute;
      bottom: 20px;
      color: rgba(255, 255, 255, 0.7);
      font-size: 0.9rem;
    }

    .glow {
      position: absolute;
      top: 50%;
      left: 50%;
      width: 200px;
      height: 200px;
      background: radial-gradient(circle, var(--glow) 0%, rgba(0, 0, 0, 0) 70%);
      border-radius: 50%;
      opacity: 0.6;
      animation: pulse 4s infinite;
      pointer-events: none;
    }

    @keyframes pulse {
      0% { transform: scale(0.9); opacity: 0.5; }
      50% { transform: scale(1.1); opacity: 0.8; }
      100% { transform: scale(0.9); opacity: 0.5; }
    }

    .nested-waves {
      position: absolute;
      top: 50%;
      left: 50%;
      width: 100%;
      height: 100%;
      transform: translate(-50%, -50%);
      pointer-events: none;
    }

    .nested-wave {
      position: absolute;
      border: 1px solid rgba(255, 255, 255, 0.1);
      border-radius: 50%;
    }

    .nested-wave:nth-child(1) { width: 60%; height: 60%; }
    .nested-wave:nth-child(2) { width: 40%; height: 40%; }
    .nested-wave:nth-child(3) { width: 20%; height: 20%; }
  </style>
</head>
<body>
  <div class="glow"></div>
  <div class="container">
    <h1>SoundSculpt</h1>
    <p>Visualize your audio in real-time with wave patterns</p>

    <div class="wave-container">
      <canvas class="waveform-canvas" id="waveformCanvas"></canvas>
      <div class="nested-waves">
        <div class="nested-wave"></div>
        <div class="nested-wave"></div>
        <div class="nested-wave"></div>
      </div>
    </div>

    <div class="controls">
      <button id="toggleMic" class="big">🎤 Start Mic</button>
      <button id="loadFile" class="big">📁 Load Audio</button>
      <div class="color-picker">
        <div class="color-option" data-color="var(--primary)"></div>
        <div class="color-option active" data-color="var(--secondary)"></div>
        <div class="color-option" data-color="var(--accent)"></div>
      </div>
    </div>

    <div class="wave-patterns">
      <button class="pattern-toggle" data-pattern="none">✕ Off</button>
      <button class="pattern-toggle active" data-pattern="dot">• Dot</button>
      <button class="pattern-toggle" data-pattern="line">─ Line</button>
      <button class="pattern-toggle" data-pattern="grid">□ Grid</button>
    </div>

    <div class="info">🎧 Mic not available in some browsers (Safari on desktop)</div>
  </div>

  <script>
    document.addEventListener('DOMContentLoaded', function() {
      // Canvas setup
      const canvas = document.getElementById('waveformCanvas');
      const ctx = canvas.getContext('2d');

      // Get canvas dimensions
      function resizeCanvas() {
        canvas.width = canvas.offsetWidth;
        canvas.height = canvas.offsetHeight;
        drawEmpty();
      }
      resizeCanvas();
      window.addEventListener('resize', resizeCanvas);

      // Audio context and analyzer
      let audioContext;
      let analyzer;
      let source = null;
      let isPlaying = false;
      let patternType = 'dot';

      // Initialize audio context
      function initAudioContext() {
        if (!audioContext) {
          audioContext = new (window.AudioContext || window.webkitAudioContext)();
          analyzer = audioContext.createAnalyser();
          analyzer.fftSize = 256;
          analyzer.smoothTimeConstant = 0.8;
        }
      }

      // Draw empty canvas with gradient
      function drawEmpty() {
        const gradient = ctx.createLinearGradient(0, 0, canvas.width, canvas.height);
        gradient.addColorStop(0, 'rgba(0, 0, 0, 0.1)');
        gradient.addColorStop(1, 'rgba(0, 0, 0, 0.3)');

        ctx.fillStyle = gradient;
        ctx.fillRect(0, 0, canvas.width, canvas.height);

        // Center line
        ctx.strokeStyle = 'rgba(255, 255, 255, 0.1)';
        ctx.lineWidth = 1;
        ctx.beginPath();
        ctx.moveTo(0, canvas.height / 2);
        ctx.lineTo(canvas.width, canvas.height / 2);
        ctx.stroke();

        // Time markers
        for (let i = 0; i < canvas.width; i += canvas.width / 10) {
          ctx.beginPath();
          ctx.moveTo(i, canvas.height / 2 - 3);
          ctx.lineTo(i, canvas.height / 2 + 3);
          ctx.stroke();
        }
      }

      // Draw waveform
      function drawWaveform() {
        if (!analyzer) return;

        const bufferLength = analyzer.frequencyBinCount;
        const dataArray = new Uint8Array(bufferLength);

        analyzer.getByteFrequencyData(dataArray);

        ctx.clearRect(0, 0, canvas.width, canvas.height);
        drawEmpty();

        // Scale factor for visual effect
        const scaleFactor = canvas.height / 2 / 128;

        // Draw the waveform
        ctx.beginPath();
        ctx.moveTo(0, canvas.height / 2);

        for (let i = 0; i < bufferLength; i++) {
          const value = dataArray[i] * scaleFactor;
          const x = (i / bufferLength) * canvas.width;
          const y = canvas.height / 2 - value + (Math.random() * 2 - 1) * 2; // Add randomness for visual interest

          ctx.lineTo(x, y);
        }

        ctx.strokeStyle = 'rgba(255, 255, 255, 0.3)';
        ctx.lineWidth = 1;
        ctx.stroke();

        // Add pattern overlay
        if (patternType !== 'none') {
          ctx.globalAlpha = 0.15;
          drawPatterns(ctx, patternType, canvas.width, canvas.height);
          ctx.globalAlpha = 1;
        }

        requestAnimationFrame(drawWaveform);
      }

      // Draw pattern overlays
      function drawPatterns(ctx, pattern, width, height) {
        ctx.strokeStyle = getCurrentColor();
        ctx.lineWidth = 1.5;

        switch (pattern) {
          case 'dot':
            for (let x = 0; x < width; x += 10) {
              for (let y = 0; y < height; y += 10) {
                ctx.beginPath();
                ctx.arc(x + 5, y + 5, 3, 0, Math.PI * 2);
                ctx.fill();
              }
            }
            break;

          case 'line':
            for (let y = 0; y < height; y += 5) {
              ctx.beginPath();
              ctx.moveTo(0, y);
              ctx.lineTo(width, y);
              ctx.stroke();
            }
            break;

          case 'grid':
            for (let x = 0; x < width; x += 20) {
              ctx.beginPath();
              ctx.moveTo(x, 0);
              ctx.lineTo(x, height);
              ctx.stroke();

              ctx.beginPath();
              ctx.moveTo(0, x);
              ctx.lineTo(width, x);
              ctx.stroke();
            }
            break;
        }
      }

      // Color options
      const colorOptions = document.querySelectorAll('.color-option');
      colorOptions.forEach(option => {
        option.addEventListener('click', function() {
          colorOptions.forEach(o => o.classList.remove('active'));
          this.classList.add('active');
          drawEmpty();
          if (isPlaying) drawWaveform();
        });
      });

      function getCurrentColor() {
        const activeOption = document.querySelector('.color-option.active');
        return activeOption ? activeOption.dataset.color : 'var(--secondary)';
      }

      // Pattern toggles
      const patternToggles = document.querySelectorAll('.pattern-toggle');
      patternToggles.forEach(toggle => {
        toggle.addEventListener('click', function() {
          patternToggles.forEach(t => t.classList.remove('active'));
          this.classList.add('active');
          patternType = this.dataset.pattern;
          if (isPlaying) drawWaveform();
        });
      });

      // Toggle microphone
      document.getElementById('toggleMic').addEventListener('click', async function() {
        if (isPlaying) {
          stopAudio();
          this.textContent = '🎤 Start Mic';
          isPlaying = false;
        } else {
          initAudioContext();
          try {
            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
            if (source) source.disconnect();

            source = audioContext.createMediaStreamSource(stream);
            source.connect(analyzer);

            isPlaying = true;
            this.textContent = '🔇 Stop Mic';
            drawWaveform();
          } catch (error) {
            alert('Could not access microphone: ' + error.message);
          }
        }
      });

      // Load audio file
      document.getElementById('loadFile').addEventListener('click', function() {
        const input = document.createElement('input');
        input.type = 'file';
        input.accept = 'audio/*';
        input.click();

        input.addEventListener('change', function(e) {
          const file = e.target.files[0];
          if (!file) return;

          if (source) source.disconnect();

          const reader = new FileReader();
          reader.onload = function(e) {
            initAudioContext();

            audioContext.decodeAudioData(e.target.result)
              .then(buffer => {
                source = audioContext.createBufferSource();
                source.buffer = buffer;
                source.connect(analyzer);
                source.loop = true;
                source.start();
                isPlaying = true;
                drawWaveform();
              })
              .catch(error => {
                console.error('Error decoding audio:', error);
                alert('Error loading audio file');
              });
          };
          reader.readAsArrayBuffer(file);
        });
      });

      // Stop audio
      function stopAudio() {
        if (source) {
          source.stop();
          source = null;
        }
        isPlaying = false;
      }

      // Cleanup on page hide
      window.addEventListener('beforeunload', function() {
        stopAudio();
        if (audioContext) audioContext.close();
      });
    });
  </script>
</body>
</html>

// Quest Journal MZ - Pixel-Art Quest Log mit Kategorien
// Verwendet RPG Maker MZ Plugin-System-Struktur

const fs = require('fs');
const path = require('path');

class QuestJournalMZ {
    constructor() {
        this.quests = [];
        this.categories = {
            main: { name: 'Hauptquests', color: '#00aaff' },
            side: { name: 'Nebenquests', color: '#ff5500' },
            dungeon: { name: 'Dungeon-Quest', color: '#55ff00' },
            event: { name: 'Ereignis-Quest', color: '#ff00aa' },
            rpg: { name: 'RPG-Quest', color: '#aa55ff' }
        };
        this.currentCategory = 'main';
        this.searchQuery = '';
        this.pixelFont = require('pixelart-font')('tiny');
    }

    addQuest(questData) {
        const newQuest = {
            ...questData,
            category: questData.category || this.currentCategory,
            completed: questData.completed || false,
            timestamp: new Date().toISOString()
        };
        this.quests.push(newQuest);
        this.save();
        return newQuest;
    }

    getQuests() {
        if (this.searchQuery) {
            return this.quests.filter(q =>
                q.name.toLowerCase().includes(this.searchQuery.toLowerCase()) ||
                q.description.toLowerCase().includes(this.searchQuery.toLowerCase())
            );
        }
        return this.quests;
    }

    setCurrentCategory(category) {
        if (this.categories[category]) {
            this.currentCategory = category;
        }
    }

    setSearchQuery(query) {
        this.searchQuery = query;
    }

    save() {
        const data = {
            quests: this.quests,
            categories: this.categories,
            currentCategory: this.currentCategory,
            searchQuery: this.searchQuery
        };
        fs.writeFileSync('quest_journal_data.json', JSON.stringify(data, null, 2));
    }

    load() {
        if (fs.existsSync('quest_journal_data.json')) {
            const data = JSON.parse(fs.readFileSync('quest_journal_data.json'));
            this.quests = data.quests || [];
            this.categories = data.categories || this.categories;
            this.currentCategory = data.currentCategory || 'main';
            this.searchQuery = data.searchQuery || '';
        }
    }

    generatePixelArt() {
        return `
⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉
⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊
⌈  QUEST JOURNAL  ⌉
⌈   PIXEL ART     ⌉
⌈  Version 1.0    ⌉
⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉⌈⌉
⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊⌊
        `;
    }

    display() {
        console.log(this.generatePixelArt());
        console.log(`\nAktuelle Kategorie: ${this.categories[this.currentCategory].name} (${this.categories[this.currentCategory].color})`);
        console.log(`\n🔍 Suche: ${this.searchQuery || 'Keine Suche'}\n`);

        const filteredQuests = this.getQuests();

        if (filteredQuests.length === 0) {
            console.log('  Keine Questen in dieser Kategorie found!');
            return;
        }

        console.log('  ╔═════════════════════════════════════╗');
        console.log('  ║    NAME                    ║');
        console.log('  ║  ═════════════════════════════════════╣');
        filteredQuests.forEach((quest, index) => {
            const prefix = quest.completed ? '✓' : '✗';
            console.log(`  ║ [${index + 1}] ${prefix} ${quest.name.padEnd(26)} ║`);
        });
        console.log('  ╚═════════════════════════════════════╝\n');

        console.log(`\n📝 Einstellungen: category: ${this.currentCategory}, search: ${this.searchQuery}`);
        console.log('  ╔═════════════════════════════════════╗');
        console.log('  ║ 1. Quest hinzufügen           ║');
        console.log('  ║ 2. Kategorie ändern           ║');
        console.log('  ║ 3. Suche setzen               ║');
        console.log('  ║ 4. Quest löschen (ID)         ║');
        console.log('  ║ 5. Quest abschließen (ID)     ║');
        console.log('  ║ 6. Quest beschreiben (ID)     ║');
        console.log('  ║ 7. Alle Quests anzeigen       ║');
        console.log('  ║ 8. Beenden                    ║');
        console.log('  ╚═════════════════════════════════════╝\n');
    }

    prompt() {
        const readline = require('readline').createInterface({
            input: process.stdin,
            output: process.stdout
        });

        const choices = {
            '1': () => this.addQuestPrompt(readline),
            '2': () => this.changeCategoryPrompt(readline),
            '3': () => this.searchPrompt(readline),
            '4': () => this.deleteQuestPrompt(readline),
            '5': () => this.completeQuestPrompt(readline),
            '6': () => this.describeQuestPrompt(readline),
            '7': () => this.displayAllQuests(),
            '8': () => {
                readline.close();
                process.exit();
            }
        };

        this.display();
        readline.question('Deine Wahl: ', (choice) => {
            if (choices[choice]) {
                choices[choice]();
            } else {
                console.log('Ungültige Wahl, versuche es nochmal.');
                this.prompt();
            }
        });
    }

    addQuestPrompt(readline) {
        console.log('\n📝 Quest hinzufügen');
        console.log('  Kategorien:');
        for (const [key, cat] of Object.entries(this.categories)) {
            console.log(`    ${key}: ${cat.name} (${cat.color})`);
        }
        console.log('  Wähle eine Kategorie:');
        readline.question('Kategorie (default: main): ', (category) => {
            category = category.trim() || 'main';
            if (!this.categories[category]) {
                console.log('Ungültige Kategorie, verwende "main" stattdessen.');
                category = 'main';
            }

            readline.question('Quest-Name: ', (name) => {
                readline.question('Quest-Beschreibung: ', (description) => {
                    const quest = this.addQuest({
                        name,
                        description,
                        category
                    });
                    console.log(`\n✨ Quest hinzugefügt: ${quest.name} (${this.categories[quest.category].name})`);
                    this.prompt();
                });
            });
        });
    }

    changeCategoryPrompt(readline) {
        console.log('\n🎨 Kategorie ändern');
        console.log('  Aktuelle Kategorie: ' + this.categories[this.currentCategory].name);
        for (const [key, cat] of Object.entries(this.categories)) {
            console.log(`    ${key}: ${cat.name} (${cat.color})`);
        }
        readline.question('Neue Kategorie: ', (category) => {
            category = category.trim();
            if (!this.categories[category]) {
                console.log('Ungültige Kategorie, keine Änderung.');
            } else {
                this.setCurrentCategory(category);
                console.log(`\n🎨 Kategorie geändert zu: ${this.categories[category].name}`);
            }
            this.prompt();
        });
    }

    searchPrompt(readline) {
        readline.question('Suche: ', (query) => {
            this.setSearchQuery(query.trim());
            console.log(`\n🔍 Suche nach: "${this.searchQuery}"`);
            this.prompt();
        });
    }

    deleteQuestPrompt(readline) {
        this.displayQuestsWithIDs();
        readline.question('Quest-ID zum Löschen (0 = Abbrechen): ', (id) => {
            id = parseInt(id);
            if (isNaN(id) || id <= 0 || id > this.quests.length) {
                console.log('Ungültige ID, keine Änderung.');
                this.prompt();
                return;
            }
            const [quest] = this.quests.splice(id - 1, 1);
            this.save();
            console.log(`\n❌ Quest gelöscht: ${quest.name}`);
            this.prompt();
        });
    }

    completeQuestPrompt(readline) {
        this.displayQuestsWithIDs();
        readline.question('Quest-ID zum Abschließen (0 = Abbrechen): ', (id) => {
            id = parseInt(id);
            if (isNaN(id) || id <= 0 || id > this.quests.length) {
                console.log('Ungültige ID, keine Änderung.');
                this.prompt();
                return;
            }
            const quest = this.quests[id - 1];
            quest.completed = true;
            this.save();
            console.log(`\n✅ Quest abgeschlossen: ${quest.name}`);
            this.prompt();
        });
    }

    describeQuestPrompt(readline) {
        this.displayQuestsWithIDs();
        readline.question('Quest-ID für Beschreibung (0 = Abbrechen): ', (id) => {
            id = parseInt(id);
            if (isNaN(id) || id <= 0 || id > this.quests.length) {
                console.log('Ungültige ID, keine Änderung.');
                this.prompt();
                return;
            }
            const quest = this.quests[id - 1];
            console.log(`\n📖 ${quest.name} (${this.categories[quest.category].name})`);
            console.log(`  📍 Status: ${quest.completed ? 'Abgeschlossen' : 'Aktiv'}`);
            console.log(`  📅 Erstellt: ${new Date(quest.timestamp).toLocaleString()}`);
            console.log(`  📝 Beschreibung:\n${quest.description}\n`);
            this.prompt();
        });
    }

    displayQuestsWithIDs() {
        const filteredQuests = this.getQuests();
        if (filteredQuests.length === 0) {
            console.log('  Keine Questen in dieser Kategorie found!');
            return;
        }
        console.log('\n  ╔═════════════════════════════════════╗');
        console.log('  ║ ID | NAME                   ║');
        console.log('  ║   ═══════════════════════════════╣');
        filteredQuests.forEach((quest, index) => {
            const prefix = quest.completed ? '✓' : '✗';
            console.log(`  ║ ${index + 1} | ${prefix} ${quest.name.padEnd(22)} ║`);
        });
        console.log('  ╚═════════════════════════════════════╝');
    }

    displayAllQuests() {
        console.log('\n📋 ALLE QUESTEN');
        const allQuests = this.quests;
        if (allQuests.length === 0) {
            console.log('  Keine Questen found!');
            this.prompt();
            return;
        }

        console.log('  ╔═════════════════════════════════════╗');
        console.log('  ║ ID | NAME                   ║');
        console.log('  ║   ═══════════════════════════════╣');
        allQuests.forEach((quest, index) => {
            const prefix = quest.completed ? '✓' : '✗';
            console.log(`  ║ ${index + 1} | ${prefix} ${quest.name.padEnd(22)} ║`);
        });
        console.log('  ╚═════════════════════════════════════╝\n');
        this.prompt();
    }
}

// Main Execution
const journal = new QuestJournalMZ();
journal.load();

console.log(`
  ███████╗██╗  ██╗██████╗ ██████╗ ███████╗██╗   ██╗██████╗ ███████╗
  ╚══███╔╝██║  ██║██╔══██╗██╔══██╗██╔════╝╚██╗ ██╔╝██╔══██╗██╔════╝
    ███╔╝ ███████║██████╔╝██████╔╝█████╗   ╚████╔╝ ██████╔╝█████╗
   ███╔╝
`);

import android.Manifest
import android.content.Context
import android.content.pm.PackageManager
import android.media.AudioAttributes
import android.media.AudioManager
import android.media.SoundPool
import android.os.Build
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.LinearOutSlowInEasing
import androidx.compose.animation.core.tween
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.FlashOff
import androidx.compose.material.icons.filled.FlashOn
import androidx.compose.material.icons.filled.History
import androidx.compose.material.icons.filled.QrCode
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import androidx.compose.ui.viewinterop.AndroidView
import androidx.core.content.ContextCompat
import com.google.zxing.BarcodeFormat
import com.google.zxing.MultiFormatReader
import com.google.zxing.Result
import com.google.zxing.common.H orientation
import com.google.zxing.qrcode.QRCodeReader
import java.util.*

@Composable
fun QRScannerApp() {
    val context = LocalContext.current
    val permissionLauncher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.RequestPermission()
    ) { isGranted ->
        if (isGranted) {
            // Permission granted, start scanning
        } else {
            Toast.makeText(context, "Camera permission required", Toast.LENGTH_LONG).show()
        }
    }

    // Check and request permission
    LaunchedEffect(Unit) {
        when {
            ContextCompat.checkSelfPermission(
                context,
                Manifest.permission.CAMERA
            ) == PackageManager.PERMISSION_GRANTED -> {
                // Permission already granted
            }
            Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU -> {
                permissionLauncher.launch(Manifest.permission.CAMERA)
            }
            else -> {
                permissionLauncher.launch(Manifest.permission.CAMERA)
            }
        }
    }

    val soundPool = remember { SoundPool(1, AudioAttributes.EFFECT_TYPE, 0) }
    val scanSuccessSound = remember { soundPool.load(context, R.raw.scan_success, 1) }

    var qrResult by remember { mutableStateOf("") }
    var scanMode by remember { mutableStateOf(ScanMode.BACK) }
    var isFlashOn by remember { mutableStateOf(false) }
    var historyItems by remember { mutableStateOf(emptyList<String>()) }
    val scanRotator = remember { Animatable(0f) }

    LaunchedEffect(qrResult) {
        if (qrResult.isNotEmpty()) {
            // Play sound effect
            soundPool.setOnLoadCompleteListener(soundPool) { soundID, _ ->
                if (soundID == scanSuccessSound) {
                    soundPool.play(soundID, 1f, 1f, 0, 0, 1f)
                }
            }

            // Add to history
            historyItems = (qrResult + historyItems).takeLast(20).reversed().toMutableList()

            // Rotate animation
            scanRotator.animateTo(
                targetValue = 360f,
                animationSpec = tween(500, easing = LinearOutSlowInEasing)
            )
        }
    }

    Scaffold(
        topBar = {
            TopAppBar(
                title = { Text("QR Lens Pro") },
                actions = {
                    IconButton(onClick = { isFlashOn = !isFlashOn }) {
                        Icon(
                            imageVector = if (isFlashOn) Icons.Default.FlashOff else Icons.Default.FlashOn,
                            contentDescription = "Toggle flash"
                        )
                    }
                }
            )
        },
        content = { padding ->
            Column(
                modifier = Modifier
                    .fillMaxSize()
                    .padding(padding)
            ) {
                // Scanner view
                Box(
                    modifier = Modifier
                        .weight(1f)
                        .fillMaxWidth(),
                    contentAlignment = Alignment.Center
                ) {
                    QRScannerView(
                        modifier = Modifier.size(300.dp),
                        scanMode = scanMode,
                        flashOn = isFlashOn,
                        onScanResult = { result -> qrResult = result },
                        scanRotation = scanRotator.value
                    )

                    if (qrResult.isNotEmpty()) {
                        Box(
                            modifier = Modifier
                                .align(Alignment.BottomCenter)
                                .background(Color.Black.copy(alpha = 0.7f))
                                .padding(16.dp)
                                .clip(CircleShape)
                        ) {
                            Text(
                                text = qrResult,
                                color = Color.White,
                                style = MaterialTheme.typography.bodyLarge
                            )
                        }
                    }
                }

                // History button
                Button(
                    onClick = { scanMode = ScanMode.HISTORY },
                    modifier = Modifier
                        .fillMaxWidth()
                        .padding(16.dp)
                ) {
                    Icon(Icons.Default.History, contentDescription = null)
                    Spacer(Modifier.size(8.dp))
                    Text("View History")
                }

                // History view
                if (scanMode == ScanMode.HISTORY) {
                    LazyColumn(
                        modifier = Modifier
                            .fillMaxWidth()
                            .weight(1f)
                            .padding(16.dp)
                    ) {
                        items(historyItems) { item ->
                            ListItem(
                                headlineContent = { Text(item) },
                                modifier = Modifier
                                    .fillMaxWidth()
                                    .clickable { qrResult = item }
                            )
                        }
                    }

                    Button(
                        onClick = { scanMode = ScanMode.BACK },
                        modifier = Modifier
                            .fillMaxWidth()
                            .padding(16.dp)
                    ) {
                        Text("Back to Scanner")
                    }
                }
            }
        }
    )
}

enum class ScanMode {
    BACK, HISTORY
}

@Composable
fun QRScannerView(
    modifier: Modifier,
    scanMode: ScanMode,
    flashOn: Boolean,
    onScanResult: (String) -> Unit,
    scanRotation: Float
) {
    val context = LocalContext.current
    var scannerView: ScannerView? = null

    AndroidView(
        modifier = modifier.rotate(scanRotation),
        factory = { ctx ->
            ScannerView(ctx).apply {
                scannerView = this
                setupScanner(
                    onScanResult = { result -> onScanResult(result) },
                    flashOn = flashOn
                )
            }
        },
        update = { view, _ ->
            if (scanMode == ScanMode.BACK) {
                view.startScanner()
            } else {
                view.stopScanner()
            }
        }
    )
}

class ScannerView(context: Context) : AndroidView<com.google.zxing.client.android.CaptureActivity.ScannerView>(context) {
    private var scanner: com.google.zxing.client.android.CaptureActivity.Scanner? = null

    fun setupScanner(onScanResult: (String) -> Unit, flashOn: Boolean) {
        val captureActivity = CaptureActivity(context)
        captureActivity.setupScanner(this, onScanResult, flashOn)
    }

    fun startScanner() {
        scanner?.startScanner()
    }

    fun stopScanner() {
        scanner?.stopScanner()
    }
}

class CaptureActivity(context: Context) {
    private val context = context.applicationContext
    private var cameraManager: com.google.zxing.client.android.CameraManager? = null
    private var beepManager: BeepManager? = null
    private var resultHandler: ResultHandler? = null
    private var lastResult: Result? = null
    private var scanner: Scanner? = null

    fun setupScanner(
        scannerView: ScannerView,
        onScanResult: (String) -> Unit,
        flashOn: Boolean
    ) {
        cameraManager = CameraManager(context)
        beepManager = BeepManager(context)
        resultHandler = ResultHandler(context, onScanResult)

        scanner = Scanner(
            context,
            scannerView,
            cameraManager,
            resultHandler,
            beepManager
        ).apply {
            this.flashOn = flashOn
            startScanner()
        }
    }

    fun startScanner() {
        scanner?.startScanner()
    }

    fun stopScanner() {
        scanner?.stopScanner()
    }
}

class Scanner(
    context: Context,
    scannerView: ScannerView,
    cameraManager: CameraManager,
    resultHandler: ResultHandler,
    beepManager: BeepManager
) {
    private val context = context.applicationContext
    private var cameraManager = cameraManager
    private var beepManager = beepManager
    private var resultHandler = resultHandler
    private var scannerView = scannerView
    private var lastResult: Result? = null
    private var decodingInProgress = false
    private var pendingDecode: Result? = null
    private val decodeFormatter = DecodeFormatter(context)

    var flashOn: Boolean = false
        set(value) {
            field = value
            cameraManager?.setTorch(value)
        }

    fun startScanner() {
        val camera = cameraManager?.openDriver(scannerView.surfaceHolder)
        if (camera != null) {
            cameraManager?.startPreview()
            resultHandler?.handleDecode(camera, scannerView)
        }
    }

    fun stopScanner() {
        cameraManager?.closeDriver()
        lastResult = null
        scanning = false
        pendingDecode = null
    }

    private val scanning = AtomicBoolean(false)
    private val state = AtomicReference<State>(State.RESULT_HANDLING)
    private val factory = BarcodeFormat.EAN_8
    private val reader = MultiFormatReader()

    private enum class State {
        PREVIEW,
        DECODING,
        RESULT_HANDLING
    }

    private val handler = Handler()
    private val decodeRun = Runnable {
        decodingInProgress = true
        if (pendingDecode != null) {
            lastResult = pendingDecode
            pendingDecode = null
        } else {
            lastResult = null
        }
        decodingInProgress = false
    }

    private val pendingDecodeCallback = Runnable {
        handler.post(decodeRun)
    }

    private var remainder: ByteArray? = null
    private val multiFormatReader = MultiFormatReader()

    private fun resetState() {
        remainder = null
        cameraManager?.requestPreviewFrame(multiFormatReader, scannerView)
        decodingInProgress = false
        pendingDecode = null
        state.set(State.DECODING)
        handler.post(pendingDecodeCallback)
    }
}

class DecodeFormatter(context: Context) {
    private val context = context.applicationContext
    private val activity = context as Activity
    private val formatManager = FormatManager(activity)
    private val surface = activity.windowManager.defaultDisplay
    private val width = surface.width
    private val height = surface.height

    fun formatResult(result: Result): String {
        // Add your creative formatting here
        return when (result.text) {
            is Uri -> formatUri(result.text as Uri)
            is Decimal -> formatDecimal(result.text as Decimal)
            else -> result.text
        }
    }

    private fun formatUri(uri: Uri): String {
        return when (uri.scheme) {
            "http", "https" -> "Open: ${uri.host}"
            "tel" -> "Call: ${uri.path}"
            "sms" -> "SMS: ${uri.path}"
            else -> "URI: ${uri.toString()}"
        }
    }

    private fun formatDecimal(decimal: Decimal): String {
        return "Number: ${decimal.value()}"
    }
}

class CameraManager(context: Context) {
    private val context = context.applicationContext
    private var camera: Camera? = null
    private var parameters: Camera.Parameters? = null
    private var previewCallback: Camera.PreviewCallback? = null
    private var previewSize: Size? = null
    private var torchOn = false

    fun openDriver(surfaceHolder: SurfaceHolder): Camera {
        camera = Camera.open()
        parameters = camera?.parameters
        setDesiredCameraParameters()
        camera?.setDisplayOrientation(90)
        camera?.setPreviewDisplay(surfaceHolder)
        return camera!!
    }

    fun startPreview() {
        camera?.startPreview()
    }

    fun closeDriver() {
        if (camera != null) {
            camera?.stopPreview()
            camera?.release()
            camera = null
        }
    }

    fun setTorch(flashOn: Boolean) {
        if (torchOn != flashOn) {
            torchOn = flashOn
            camera?.parameters?.flashMode = if (flashOn) Camera.Parameters.FLASH_MODE_TORCH else Camera.Parameters.FLASH_MODE_OFF
            camera?.parameters = parameters
        }
    }

    fun requestPreviewFrame(reader: Result, scannerView: ScannerView) {
        camera?.setOneShotPreviewCallback {
            bytes -> decode(bytes, reader, scannerView)
        }
    }

    private fun decode(data: ByteArray, reader: Result, scannerView: ScannerView) {
        // Implementation would go here
    }

    private fun setDesiredCameraParameters() {
        parameters?.setPreviewSize(1280, 720)
    }
}

class ResultHandler(context: Context, private val onScanResult: (String) -> Unit) {
    private val context = context.applicationContext
    private var activity: Activity? = null
    private var surface: Surface? = null

    init {
        activity = context as Activity
        surface = activity?.windowManager?.defaultDisplay
    }

    fun handleDecode(camera: Camera, scannerView: ScannerView) {
        camera.setOneShotPreviewCallback {
            bytes -> decode(bytes, scannerView)
        }
    }

    private fun decode(data: ByteArray, scannerView: ScannerView) {
        val result = Result(data, null)
        val format = DecodeFormatter(context)
        val formattedResult = format.formatResult(result)
        onScanResult(formattedResult)
    }
}

class BeepManager(context: Context) {
    private val context = context.applicationContext
    private val soundPool = SoundPool(1, AudioAttributes.EFFECT_TYPE, 0)
    private val beepId = soundPool.load(context, R.raw.beep, 1)

    fun playBeep() {
        soundPool.play(beepId, 1f, 1f, 0, 0, 1f)
    }
}

@Preview(showBackground = true)
@Composable
fun QRScannerAppPreview() {
    QRScannerApp()
}

// Ailey's Dynamic RPG Weather Simulator
// Features: Day/night cycle with atmospheric tints, weather effects, and confetti animations

const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});

let currentTime = 0; // Time in seconds
let dayCycle = 0; // 0-24 hours
let weatherConditions = ['Clear', 'Partly Cloudy', 'Cloudy', 'Rainy', 'Stormy'];
let weatherIndex = 0;
let skyTints = [
    { name: 'Sunrise', color: '#FF6B35' },
    { name: 'Morning', color: '#FFD23F' },
    { name: 'Daytime', color: '#A0D8FF' },
    { name: 'Afternoon', color: '#4DB5FF' },
    { name: 'Evening', color: '#FF6B9D' },
    { name: 'Sunset', color: '#FF2E63' },
    { name: 'Night', color: '#1A1A2E' },
    { name: 'Midnight', color: '#0A0E2A' }
];
let currentTint = 0;
let isRaining = false;
let isStormy = false;
let isSpecialWeather = false;
let confettiActive = false;
let confettiCount = 0;
let specialWeatherAchieved = false;

// DOM simulation for visual output
const terminalOutput = document.createElement('div');
terminalOutput.style.fontFamily = 'monospace';
terminalOutput.style.whiteSpace = 'pre';
document.body.appendChild(terminalOutput);

// Weather effect elements
const weatherContainer = document.createElement('div');
weatherContainer.style.position = 'fixed';
weatherContainer.style.top = '0';
weatherContainer.style.left = '0';
weatherContainer.style.width = '100%';
weatherContainer.style.height = '100%';
weatherContainer.style.pointerEvents = 'none';
weatherContainer.style.zIndex = '9999';
document.body.appendChild(weatherContainer);

// Confetti elements
const confettiElements = [];

function updateTerminal(time, tint, weather) {
    terminalOutput.innerHTML = `
    ┌─────────────────────────────────────┐
    | Ailey's RPG Weather Simulator        |
    | Time: ${time.toFixed(1)} hours        |
    | Weather: ${weather}                   |
    | Atmosphere: ${skyTints[tint].name}    |
    | Account: ${getAchievementStatus()}    |
    └─────────────────────────────────────┘
    `;

    // Update background tint
    document.body.style.backgroundColor = skyTints[tint].color;

    // Apply weather effects
    if (isRaining) {
        drawRain();
    }
    if (isStormy) {
        drawStorm();
    }
    if (isSpecialWeather && !confettiActive) {
        triggerConfettiAnimation();
    }

    requestAnimationFrame(updateTerminal);
}

function drawRain() {
    if (!isRaining) return;

    const rainDrops = document.createElement('div');
    rainDrops.style.position = 'fixed';
    rainDrops.style.top = '0';
    rainDrops.style.left = '0';
    rainDrops.style.width = '100%';
    rainDrops.style.height = '100%';
    rainDrops.style.pointerEvents = 'none';
    rainDrops.style.zIndex = '9998';
    rainDrops.style.backgroundImage = 'linear-gradient(to bottom, rgba(0, 150, 255, 0.3), rgba(0, 150, 255, 0.1))';
    weatherContainer.appendChild(rainDrops);
}

function drawStorm() {
    if (!isStormy) return;

    const stormElements = document.createElement('div');
    stormElements.style.position = 'fixed';
    stormElements.style.top = '0';
    stormElements.style.left = '0';
    stormElements.style.width = '100%';
    stormElements.style.height = '100%';
    stormElements.style.pointerEvents = 'none';
    stormElements.style.zIndex = '9997';
    stormElements.style.backgroundImage = 'radial-gradient(circle at center, rgba(255, 255, 255, 0.1) 0%, transparent 50%)';
    stormElements.style.animation = 'storm 10s infinite';
    weatherContainer.appendChild(stormElements);

    const style = document.createElement('style');
    style.textContent = `
        @keyframes storm {
            0% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.1) 0%, transparent 50%); }
            20% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.2) 0%, transparent 50%); }
            40% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.1) 0%, transparent 50%); }
            60% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.3) 0%, transparent 50%); }
            80% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.1) 0%, transparent 50%); }
            100% { background-image: radial-gradient(circle at center, rgba(255, 255, 255, 0.2) 0%, transparent 50%); }
        }
    `;
    document.head.appendChild(style);
}

function triggerConfettiAnimation() {
    if (confettiActive || specialWeatherAchieved) return;

    confettiActive = true;
    confettiCount = 0;
    specialWeatherAchieved = true;

    // Stop existing rain/storm effects
    if (isRaining) {
        const rainDrops = document.querySelector('div[style*="backgroundImage: linear-gradient"]');
        if (rainDrops) rainDrops.remove();
    }
    if (isStormy) {
        const stormElements = document.querySelector('div[style*="animation: storm"]');
        if (stormElements) stormElements.remove();
    }

    // Create confetti
    function createConfetti() {
        if (confettiCount >= 100) {
            confettiActive = false;
            return;
        }

        const confetti = document.createElement('div');
        confetti.style.position = 'fixed';
        confetti.style.width = '10px';
        confetti.style.height = '10px';
        confetti.style.backgroundColor = getRandomColor();
        confetti.style.borderRadius = '50%';
        confetti.style.pointerEvents = 'none';
        confetti.style.zIndex = '9999';

        // Position on screen edges
        if (Math.random() > 0.5) {
            confetti.style.left = '0';
            confetti.style.top = `${Math.random() * 100}%`;
        } else {
            confetti.style.right = '0';
            confetti.style.top = `${Math.random() * 100}%`;
        }

        confetti.style.animation = `confetti-fall ${Math.random() * 3 + 2}s forwards`;

        weatherContainer.appendChild(confetti);
        confettiElements.push(confetti);
        confettiCount++;

        requestAnimationFrame(createConfetti);
    }

    // Add confetti animation styles
    const style = document.createElement('style');
    style.textContent = `
        @keyframes confetti-fall {
            0% {
                transform: translateX(0) rotate(0deg);
                opacity: 1;
            }
            50% {
                transform: translateX(50vw) rotate(180deg);
            }
            100% {
                transform: translateX(100vw) rotate(360deg);
                opacity: 0;
            }
        }
    `;
    document.head.appendChild(style);

    createConfetti();
}

function getRandomColor() {
    const letters = '0123456789ABCDEF';
    let color = '#';
    for (let i = 0; i < 6; i++) {
        color += letters[Math.floor(Math.random() * 16)];
    }
    return color;
}

function updateWeather() {
    // Natural weather changes based on time and randomness
    const timeOfDay = dayCycle % 24;

    // More rain at certain times
    if (Math.random() < 0.1) {
        isRaining = true;
        isStormy = false;
        weatherIndex = 2; // Cloudy
    } else if (Math.random() < 0.05) {
        isRaining = false;
        isStormy = true;
        weatherIndex = 3; // Rainy (now stormy)
    } else {
        isRaining = false;
        isStormy = false;
        weatherIndex = Math.max(0, Math.min(3, Math.floor(Math.random() * weatherConditions.length)));
    }

    // Special weather based on time of day and randomness
    if (timeOfDay >= 20 || timeOfDay < 4) { // Late evening to early morning
        if (Math.random() < 0.01) {
            isSpecialWeather = true;
        }
    }

    // Update sky tint based on time of day
    if (timeOfDay < 4) {
        currentTint = 7; // Midnight
    } else if (timeOfDay < 6) {
        currentTint = 6; // Sunrise
    } else if (timeOfDay < 9) {
        currentTint = 1; // Morning
    } else if (timeOfDay < 15) {
        currentTint = 2; // Daytime
    } else if (timeOfDay < 18) {
        currentTint = 3; // Afternoon
    } else if (timeOfDay < 20) {
        currentTint = 4; // Evening
    } else {
        currentTint = 5; // Sunset
    }
}

function getAchievementStatus() {
    if (specialWeatherAchieved) {
        return "⭐ SPECIAL WEATHER ACHIEVED! ⭐";
    } else if (isStormy) {
        return "⚡ STORMY WEATHER ⚡";
    } else if (isRaining) {
        return "🌧 RAINY WEATHER 🌧";
    } else {
        return "";
    }
}

// Main simulation loop
function runSimulation() {
    currentTime = 0;
    dayCycle = 0;

    updateTerminal(dayCycle, currentTint, weatherConditions[weatherIndex]);
    updateWeather();

    const simulationInterval = setInterval(() => {
        currentTime += 1;
        dayCycle = currentTime / 3600; // Convert to hours
        updateWeather();
        updateTerminal(dayCycle, currentTint, weatherConditions[weatherIndex]);

        if (dayCycle > 24) {
            clearInterval(simulationInterval);
            terminalOutput.innerHTML += "\n\n🎉 Simulated 24 hours of RPG weather! 🎉";
        }
    }, 1000);
}

// Start the simulation
runSimulation();

// Handle user input to change simulation speed
readline.on('line', (input) => {
    const speed = parseFloat(input);
    if (!isNaN(speed)) {
        const simulationInterval = setInterval(() => {
            currentTime += speed;
            dayCycle = currentTime / 3600;
            updateWeather();
            updateTerminal(dayCycle, currentTint, weatherConditions[weatherIndex]);

            if (dayCycle > 24) {
                clearInterval(simulationInterval);
                terminalOutput.innerHTML += "\n\n🎉 Simulated 24 hours of RPG weather! 🎉";
            }
        }, 100);
    }
});

readline.on('close', () => {
    console.log('Simulation stopped.');
    process.exit(0);
});

using UnityEngine;
using UnityEditor;
using System.Collections.Generic;

[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))]
public class VoronoiFractalTerrain : MonoBehaviour
{
    [Header("Generation Settings")]
    [SerializeField] private int width = 128;
    [SerializeField] private int length = 128;
    [SerializeField] private float scale = 1f;
    [SerializeField] private int maxIterations = 8;
    [SerializeField] private float erosionFactor = 0.7f;
    [SerializeField] private AnimationCurve heightCurve;

    [Header("Visual Settings")]
    [SerializeField] private Material terrainMaterial;
    [SerializeField] private float meshDetail = 1f;

    private Mesh mesh;
    private Vector3[] vertices;
    private int[] triangles;
    private Color[] colors;

    private void Start()
    {
        GenerateTerrain();
        GetComponent<MeshFilter>().mesh = mesh;
        GetComponent<MeshRenderer>().material = terrainMaterial;
    }

    [ContextMenu("Generate Terrain")]
    private void GenerateTerrain()
    {
        GenerateVoronoiFractal();
        CreateMesh();
    }

    private void GenerateVoronoiFractal()
    {
        float[,] heightMap = new float[width, length];

        // Step 1: Generate Voronoi points
        Vector2[] points = GenerateRandomPoints(width, length, scale * 0.1f);

        // Step 2: Calculate Voronoi distances
        float[,] voronoiDistances = CalculateVoronoiDistances(points, width, length);

        // Step 3: Apply fractal erosion
        ErodeFractal(voronoiDistances, maxIterations, erosionFactor);

        // Step 4: Normalize and curve
        float minHeight = Mathf.Min(0f, Mathf.Min(voronoiDistances));
        float maxHeight = Mathf.Max(0f, Mathf.Max(voronoiDistances));
        float range = maxHeight - minHeight;

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                heightMap[x, z] = Mathf.Clamp01((voronoiDistances[x, z] - minHeight) / range);
                heightMap[x, z] = heightCurve.Evaluate(heightMap[x, z]);
            }
        }

        // Generate noise layer for texture variation
        float[,] noiseLayer = GenerateNoiseLayer(width, length, 0.2f);

        // Combine layers
        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                heightMap[x, z] = Mathf.Clamp01(heightMap[x, z] + noiseLayer[x, z] * 0.3f);
            }
        }
    }

    private Vector2[] GenerateRandomPoints(int width, int length, float minDistance)
    {
        List<Vector2> points = new List<Vector2>();

        for (int i = 0; i < width * length / 20; i++)
        {
            Vector2 point = new Vector2(
                Random.Range(0, width),
                Random.Range(0, length)
            );

            if (IsPointValid(points, point, minDistance))
            {
                points.Add(point);
            }
        }

        return points.ToArray();
    }

    private bool IsPointValid(List<Vector2> existingPoints, Vector2 newPoint, float minDistance)
    {
        foreach (Vector2 point in existingPoints)
        {
            float distance = Vector2.Distance(point, newPoint);
            if (distance < minDistance)
            {
                return false;
            }
        }
        return true;
    }

    private float[,] CalculateVoronoiDistances(Vector2[] points, int width, int length)
    {
        float[,] distances = new float[width, length];

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                float minDistance = float.MaxValue;

                foreach (Vector2 point in points)
                {
                    float distance = Vector2.Distance(
                        new Vector2(x, z),
                        point
                    );

                    if (distance < minDistance)
                    {
                        minDistance = distance;
                    }
                }

                distances[x, z] = -minDistance; // Invert for mountain-like terrain
            }
        }

        return distances;
    }

    private void ErodeFractal(float[,] heightMap, int iterations, float erosionFactor)
    {
        for (int i = 0; i < iterations; i++)
        {
            float[,] eroded = new float[heightMap.GetLength(0), heightMap.GetLength(1)];

            for (int x = 1; x < heightMap.GetLength(0) - 1; x++)
            {
                for (int z = 1; z < heightMap.GetLength(1) - 1; z++)
                {
                    float erosion = (heightMap[x-1, z] + heightMap[x+1, z] + heightMap[x, z-1] + heightMap[x, z+1]) / 4f;
                    erosion = Mathf.Lerp(heightMap[x, z], erosion, erosionFactor);
                    eroded[x, z] = erosion;
                }
            }

            heightMap = eroded;
        }
    }

    private float[,] GenerateNoiseLayer(int width, int length, float scale)
    {
        float[,] noiseLayer = new float[width, length];
        float[,] perlinNoise = new float[width, length];

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                float xCoord = (float)x / width * scale;
                float zCoord = (float)z / length * scale;
                perlinNoise[x, z] = Mathf.PerlinNoise(xCoord, zCoord) * 0.5f + 0.5f;
            }
        }

        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < length; z++)
            {
                // Apply fractal noise
                float total = perlinNoise[x, z];
                for (int i = 1; i < 4; i++)
                {
                    xCoord *= 2f;
                    zCoord *= 2f;
                    total += Mathf.PerlinNoise(xCoord, zCoord) * (1f / (float)Mathf.Pow(2, i));
                }
                noiseLayer[x, z] = (total - 0.5f) * 2f; // Normalize to -1..1
            }
        }

        return noiseLayer;
    }

    private void CreateMesh()
    {
        int width = this.width;
        int length = this.length;

        vertices = new Vector3[width * length];
        colors = new Color[width * length];
        triangles = new int[(width - 1) * (length - 1) * 6];

        for (int x = 0, i = 0; x < width; x++, i += length)
        {
            for (int z = 0; z < length; z++, i++)
            {
                vertices[i] = new Vector3(x * meshDetail, 0, z * meshDetail);
                float height = Mathf.Clamp01(heightCurve.Evaluate(Mathf.Abs(vertices[i].x / (float)width * 2f - 1f)));
                vertices[i].y = height * scale * 5f;

                // Create terrain colors based on height
                float r = Mathf.Clamp01(1f - vertices[i].y / (scale * 5f)) * 0.5f;
                float g = Mathf.Clamp01(vertices[i].y / (scale * 5f)) * 0.7f;
                float b = 0.1f;
                colors[i] = new Color(r, g, b, 1f);
            }
        }

        for (int x = 0, i = 0; x < width - 1; x++, i += length)
        {
            for (int z = 0; z < length - 1; z++, i++)
            {
                triangles[i * 6] = i;
                triangles[i * 6 + 1] = i + length;
                triangles[i * 6 + 2] = i + 1;

                triangles[i * 6 + 3] = i + 1;
                triangles[i * 6 + 4] = i + length;
                triangles[i * 6 + 5] = i + length + 1;
            }
        }

        mesh = new Mesh
        {
            vertices = vertices,
            triangles = triangles,
            colors = colors,
            bounds = new Bounds(Vector3.zero, Vector3.one * 10f)
        };
        mesh.RecalculateNormals();
    }

#if UNITY_EDITOR
    [MenuItem("Tools/Generate Terrain")]
    public static void GenerateTerrainFromMenu()
    {
        GameObject terrain = GameObject.FindObjectOfType<VoronoiFractalTerrain>()?.gameObject;
        if (terrain == null)
        {
            terrain = new GameObject("VoronoiTerrain");
            terrain.AddComponent<VoronoiFractalTerrain>();
        }

        VoronoiFractalTerrain generator = terrain.GetComponent<VoronoiFractalTerrain>();
        generator.GenerateTerrain();
    }
#endif
}