A!leys Galerie

```php
<?php
/**
 * Plugin Name: Dynamic Emoji Shortcode & Styling Module
 * Description: A creative WordPress/Joomla plugin that generates dynamic emoji shortcodes with customizable styles and random emoji selection.
 * Version: 1.0.0
 * Author: Ailey (KI)
 * Author URI: https://ailey.dev
 * License: GPLv2 or later
 * Text Domain: ailey-emoji
 * Domain Path: /languages
 */

defined('ABSPATH') || exit; // Exit if accessed directly (WordPress)
defined('_JEXEC') || die;  // Exit if accessed directly (Joomla)

// =============================================
// PLATFORM DETECTION (WordPress/Joomla)
// =============================================
if (function_exists('is_admin') && is_admin()) {
    if (!defined('WPINC')) {
        // Joomla detection
        define('JPATH_PLUGINS', dirname(__FILE__));
        require_once JPATH_BASE . '/includes/defines.php';
        require_once JPATH_BASE . '/includes/framework.php';
        require_once JPATH_BASE . '/libraries/joomla/factory.php';
        JFactory::getApplication('site');
    }
}

// =============================================
// GLOBAL CONFIGURATION
// =============================================
$config = array(
    'emoji_sets' => array(
        'default' => array(
            '😂', '😍', '😎', '😜', '👍', '👏', '🔥', '✨', '💖', '🎉',
            '🎊', '🎇', '🏆', '🏅', '💪', '🦁', '🦄', '🌈', '🌍', '🌟'
        ),
        'nature' => array(
            '🌿', '🌸', '🌺', '🌼', '🌻', '🌱', '🍃', '🍄', '🍅', '🍆',
            '🍈', '🍉', '🍊', '🍋', '🍍', '🍌', '🍎', '🍐', '🥭', '🥥'
        ),
        'food' => array(
            '🍔', '🍕', '🍩', '🍰', '🍭', '🍫', '🍬', '🍭', '🍮', '🍩',
            '🍩', '🍩', '🍩', '🍩', '🍩', '🍩', '🍩', '🍩', '🍩', '🍩'
        )
    ),
    'styles' => array(
        'default' => array(
            'color' => '#000000',
            'size' => '24px',
            'shadow' => 'none',
            'border' => 'none'
        ),
        'glow' => array(
            'color' => '#ffffff',
            'size' => '36px',
            'shadow' => '0 0 10px #ffffff, 0 0 20px #000000',
            'border' => '2px solid #ffffff'
        ),
        'neon' => array(
            'color' => '#00ff00',
            'size' => '40px',
            'shadow' => '0 0 15px #00ff00, 0 0 30px #000000',
            'border' => '3px solid #00ff00'
        )
    )
);

// =============================================
// WORDPRESS IMPLEMENTATION
// =============================================
if (!defined('WPINC') || !class_exists('WP_Emoji')) {
    // WordPress-specific setup
    add_action('plugins_loaded', 'ailey_emoji_init');
    function ailey_emoji_init() {
        if (!class_exists('WP_Emoji')) {
            return; // Skip if emoji support not enabled
        }
        // Register shortcode
        add_shortcode('ailey_emoji', 'ailey_emoji_shortcode');
        add_shortcode('ailey_random_emoji', 'ailey_random_emoji_shortcode');

        // Add admin menu (WordPress only)
        if (is_admin()) {
            add_action('admin_menu', 'ailey_emoji_admin_menu');
        }

        // Add inline CSS for styling
        add_action('wp_enqueue_scripts', 'ailey_emoji_enqueue_styles');
    }

    function ailey_emoji_admin_menu() {
        add_options_page(
            'Dynamic Emoji Settings',
            'Emoji Styling',
            'manage_options',
            'ailey-emoji-settings',
            'ailey_emoji_settings_page'
        );
    }

    function ailey_emoji_shortcode($atts) {
        $atts = shortcode_atts(array(
            'set' => 'default',
            'style' => 'default',
            'count' => 1,
            'separator' => ' ',
            'class' => '',
            'id' => ''
        ), $atts, 'ailey_emoji');

        $emoji_set = isset($config['emoji_sets'][$atts['set']])
            ? $config['emoji_sets'][$atts['set']]
            : $config['emoji_sets']['default'];

        $style = isset($config['styles'][$atts['style']])
            ? $config['styles'][$atts['style']]
            : $config['styles']['default'];

        $emojis = array();
        for ($i = 0; $i < (int)$atts['count']; $i++) {
            $emojis[] = $emoji_set[array_rand($emoji_set)];
        }

        $output = implode($atts['separator'], $emojis);

        $attr_string = '';
        if (!empty($atts['class'])) $attr_string .= ' class="' . esc_attr($atts['class']) . '"';
        if (!empty($atts['id'])) $attr_string .= ' id="' . esc_attr($atts['id']) . '"';

        $style_css = '';
        if (!empty($style['color'])) $style_css .= ' color: ' . esc_attr($style['color']) . ';';
        if (!empty($style['size'])) $style_css .= ' font-size: ' . esc_attr($style['size']) . ';';
        if (!empty($style['shadow'])) $style_css .= ' text-shadow: ' . esc_attr($style['shadow']) . ';';
        if (!empty($style['border'])) $style_css .= ' border: ' . esc_attr($style['border']) . ';';

        return '<span' . $attr_string . ' style="' . $style_css . '">' . $output . '</span>';
    }

    function ailey_random_emoji_shortcode($atts) {
        $atts = shortcode_atts(array(
            'set' => 'default',
            'style' => 'default',
            'count' => 1,
            'class' => '',
            'id' => ''
        ), $atts, 'ailey_random_emoji');

        $emoji_set = isset($config['emoji_sets'][$atts['set']])
            ? $config['emoji_sets'][$atts['set']]
            : $config['emoji_sets']['default'];

        $style = isset($config['styles'][$atts['style']])
            ? $config['styles'][$atts['style']]
            : $config['styles']['default'];

        $emoji = $emoji_set[array_rand($emoji_set)];

        $attr_string = '';
        if (!empty($atts['class'])) $attr_string .= ' class="' . esc_attr($atts['class']) . '"';
        if (!empty($atts['id'])) $attr_string .= ' id="' . esc_attr($atts['id']) . '"';

        $style_css = '';
        if (!empty($style['color'])) $style_css .= ' color: ' . esc_attr($style['color']) . ';';
        if (!empty($style['size'])) $style_css .= ' font-size: ' . esc_attr($style['size']) . ';';
        if (!empty($style['shadow'])) $style_css .= ' text-shadow: ' . esc_attr($style['shadow']) . ';';
        if (!empty($style['border'])) $style_css .= ' border: ' . esc_attr($style['border']) . ';';

        return '<span' . $attr_string . ' style="' . $style_css . '">' . $emoji . '</span>';
    }

    function ailey_emoji_settings_page() {
        ?>
        <div class="wrap">
            <h1>Dynamic Emoji Settings</h1>
            <form method="post" action="options.php">
                <?php settings_fields('ailey_emoji_options'); ?>
                <?php do_settings_sections('ailey-emoji-settings'); ?>
                <p class="submit">
                    <input type="submit" class="button-primary" value="Save Changes">
                </p>
            </form>
        </div>
        <?php
    }

    function ailey_emoji_enqueue_styles() {
        wp_enqueue_style(
            'ailey-emoji-style',
            plugins_url('ailey-emoji-style.css', __FILE__),
            array(),
            '1.0.0'
        );
    }

    // Register settings
    add_action('admin_init', 'ailey_emoji_register_settings');
    function ailey_emoji_register_settings() {
        register_setting('general', 'ailey_emoji_options', 'ailey_emoji_sanitize');
    }

    function ailey_emoji_sanitize($input) {
        $new_input = array();
        if (isset($input['emoji_sets'])) {
            $new_input['emoji_sets'] = array_map('sanitize_text_field', $input['emoji_sets']);
        }
        if (isset($input['styles'])) {
            $new_input['styles'] = array_map(function($style) {
                return array_map('sanitize_text_field', $style);
            }, $input['styles']);
        }
        return $new_input;
    }
}

// =============================================
// JOOMLA IMPLEMENTATION
// =============================================
if (defined('_JEXEC') && !defined('WPINC')) {
    // Joomla-specific setup
    defined('DS') || define('DS', DIRECTORY_SEPARATOR);
    defined('PLG_PATH') || define('PLG_PATH', JPATH_PLUGINS . DS . 'aileyemoji');
    defined('PLG_URL') || define('PLG_URL', JURI::base() . 'plugins' . DS . 'aileyemoji');

    // Load Joomla framework if not already loaded
    require_once JPATH_BASE . DS . 'includes' . DS . 'framework.php';
    $app = JFactory::getApplication('site');

    // Register plugin
    if ($app->isSite()) {
        // Add content plugin for Joomla
        JPluginHelper::registerPlugin('content', 'aileyemoji');
    }

    // Admin setup
    if ($app->isAdmin()) {
        // Add admin menu (Joomla)
        $app->registerTask('aileyemoji.display', 'display');
    }
}

// =============================================
// JOOMLA CONTENT PLUGIN
// =============================================
if (defined('_JEXEC') && !defined('WPINC')) {
    class plgContentAileyemoji extends JPlugin {
        public function onContentBeforeDisplay($context, $params, $limitstart) {
            if ($context != 'com_content.article') {
                return;
            }

            $app = JFactory::getApplication();
            $content = $app->getBody();
            $doc = JFactory::getDocument();

            // Add inline CSS for Joomla
            $doc->addStyleSheet(PLG_URL . DS . 'ailey-emoji-style.css');

            // Process shortcodes in Joomla content
            $content = preg_replace_callback(
                '/\[ailey_emoji(.*?)\]/s',
                array($this, 'processAileyEmojiShortcode'),
                $content
            );

            $content = preg_replace_callback(
                '/\[ailey_random_emoji(.*?)\]/s',
                array($this, 'processAileyRandomEmojiShortcode'),
                $content
            );

            return $content;
        }

        public function processAileyEmojiShortcode($matches) {
            $atts = $this->parseShortcodeAtts($matches[1]);
            $atts = shortcode_atts(array(
                'set' => 'default',
                'style' => 'default',
                'count' => 1,
                'separator' => ' ',
                'class' => '',
                'id' => ''
            ), $atts, 'ailey_emoji');

            $emoji_set = isset($config['emoji_sets'][$atts['set']])
                ? $config['emoji_sets'][$atts['set']]
                : $config['emoji_sets']['default'];

            $style = isset($config['styles'][$atts['style']])
                ? $config['styles'][$atts['style']]
                : $config['styles']['default'];

            $emojis = array();
            for ($i = 0; $i < (int)$atts['count']; $i++) {
                $emojis[] = $emoji_set[array_rand($emoji_set)];
            }

            $output = implode($atts['separator'], $emojis);

            $attr_string = '';
            if (!empty($atts['class'])) $attr_string .= ' class="' . esc_attr($atts['class']) . '"';
            if (!empty($atts['id'])) $attr_string .= ' id="' . esc_attr($atts['id']) . '"';

            $style_css = '';
            if (!empty($style['color'])) $style_css .= ' color: ' . esc_attr($style['color']) . ';';
            if (!empty($style['size'])) $style_css .= ' font-size: ' . esc_attr($style['size']) . ';';
            if (!empty($style['shadow'])) $style_css .= ' text-shadow: ' . esc_attr($style['shadow']) . ';';
            if (!empty($style['border'])) $style_css .= ' border: ' . esc_attr($style['border']) . ';';

            return '<span' . $attr_string . ' style="' . $style_css . '">' . $output . '</span>';
        }

        public function processAileyRandomEmojiShortcode($matches) {
            $atts = $this->parseShortcodeAtts($matches[1]);
            $atts = shortcode_atts(array(
                'set' => 'default',
                'style' => 'default',
                'count' => 1,
                'class' => '',
                'id' => ''
            ), $atts, 'ailey_random_emoji');

            $emoji_set = isset($config['emoji_sets'][$atts['set']])
                ? $config['emoji_sets'][$atts['set']]
                : $config['emoji_sets']['default'];

            $style = isset($config['styles'][$atts['style']])
                ? $config['styles'][$atts['style']]
                : $config['styles']['default'];

            $emoji = $emoji_set[array_rand($emoji_set)];

            $attr_string = '';
            if (!empty($atts['class'])) $attr_string .= ' class="' . esc_attr($atts['class']) . '"';
            if (!empty($atts['id'])) $attr_string .= ' id="' . esc_attr($atts['id']) . '"';

            $style_css = '';
            if (!empty($style['color'])) $style_css .= ' color: ' . esc_attr($style['color']) . ';';
            if (!empty($style['size'])) $style_css .= ' font-size: ' . esc_attr($style['size']) . ';';
            if (!empty($style['shadow'])) $style_css .= ' text-shadow: ' . esc_attr($style['shadow']) . ';';
            if (!empty($style['border'])) $style_css .= ' border: ' . esc_attr($style['border']) . ';';

            return '<span' . $attr_string . ' style="' . $style_css . '">' . $emoji . '</span>';
        }

        protected function parseShortcodeAtts($atts) {
            $parsed = array();
            if (preg_match_all('/(\w+)=(".*?"|\'.*?|[^\s]+)/', $atts, $matches)) {
                foreach ($matches[1] as $key => $value) {
                    $parsed[$key] = $this->stripQuotes($matches[2][$key]);
                }
            }
            return $parsed;
        }

        protected function stripQuotes($value) {
            if (preg_match("/^[\'\"](.*)[\'\"]$/", $value, $matches)) {
                return $matches[1];
            }
            return

extends Node

class_name QuantumDungeonGenerator

@export var width: int = 15
@export var height: int = 15
@export var quantum_probability: float = 0.7
@export var max_iterations: int = 20
@export var wall_thickness: int = 1
@export var room_min_size: int = 3
@export var room_max_size: int = 7

@export var tile_set: TileSet
@export var wall_tile: int
@export var floor_tile: int
@export var quantum_wall_tile: int

var grid: Array[Array[int]] = []
var rooms: Array[Rect2] = []
var quantum_mask: Array[Array<bool]] = []
var output_grid: Array[Array<int>> = []

func _ready() -> void:
	if !tile_set:
		print("Please assign a TileSet to the generator!")
		return

	generate_dungeon()

func generate_dungeon() -> void:
	# Initialize grid with walls
	grid = Array.fill(width, Array.fill(height, 1))
	quantum_mask = Array.fill(width, Array.fill(height, false))
	output_grid = Array.fill(width, Array.fill(height, floor_tile))

	# Create initial rooms using quantum superposition approach
	create_quantum_rooms()

	# Simulate decoherence to create actual paths
	simulate_decoherence()

	# Generate output grid
	generate_output()

func create_quantum_rooms() -> void:
	var potential_rooms: Array[Rect2] = []
	var i, j, x, y, room_size

	# Generate potential room positions in superposition
	for x in range(width - room_max_size):
		for y in range(height - room_max_size):
			for room_size in range(room_min_size, room_max_size + 1):
				for orientation in [Rect2(0, 0, room_size, room_size),
									Rect2(0, 0, room_size, room_size)]:
					var room = orientation
					room.position = Vector2(x, y)

					# Check if room overlaps with existing potential rooms
					var overlap = false
					for existing in potential_rooms:
						if room.intersects(existing):
							overlap = true
							break

					if !overlap:
						# Add to potential rooms with quantum probability
						if randf() < quantum_probability:
							potential_rooms.append(room)

	# Process potential rooms through quantum interference
	for room in potential_rooms:
		# Create a temporary quantum version of the room
		for x in range(room.size.x):
			for y in range(room.size.y):
				if grid[x + room.position.x][y + room.position.y] == 1:
					quantum_mask[x + room.position.x][y + room.position.y] = true

	# Store the most probable room configuration
	rooms = potential_rooms

func simulate_decoherence() -> void:
	var current_iteration = 0
	var changed = true

	while changed and current_iteration < max_iterations:
		changed = false
		current_iteration += 1

		# Simulate decoherence by collapsing quantum states
		for x in range(width):
			for y in range(height):
				if quantum_mask[x][y] and randf() < 0.3:
					quantum_mask[x][y] = false
					changed = true

		# Add new quantum possibilities
		for x in range(1, width - 1):
			for y in range(1, height - 1):
				if !quantum_mask[x][y] and grid[x][y] == 1 and randf() < 0.1:
					quantum_mask[x][y] = true
					changed = true

func generate_output() -> void:
	var valid_tiles = [floor_tile, quantum_wall_tile, wall_tile]

	# Create main dungeon structure
	for x in range(width):
		for y in range(height):
			if grid[x][y] == 1:
				if quantum_mask[x][y]:
					output_grid[x][y] = quantum_wall_tile
				else:
					output_grid[x][y] = wall_tile
			else:
				output_grid[x][y] = floor_tile

	# Add room interiors
	for room in rooms:
		for x in range(room.position.x, room.position.x + room.size.x):
			for y in range(room.position.y, room.position.y + room.size.y):
				if x >= 0 and x < width and y >= 0 and y < height:
					output_grid[x][y] = floor_tile

	# Apply output to tile map
	apply_tiles_to_map()

func apply_tiles_to_map() -> void:
	var map = TileMap.new()
	add_child(map)
	map.tile_set = tile_set

	for y in range(height):
		for x in range(width):
			map.set_cell(Vector2i(x, y), output_grid[x][y])

	# Add some decorative elements
	add_decorations(map)

func add_decorations(map: TileMap) -> void:
	var decoration_tiles = [5, 6, 7, 8, 9]  # Example decoration tiles
	var total_tiles = width * height
	var decoration_count = int(total_tiles * 0.1)  # 10% decoration

	for i in range(decoration_count):
		var x = randi_range(0, width - 1)
		var y = randi_range(0, height - 1)
		if output_grid[x][y] == floor_tile:
			output_grid[x][y] = decoration_tiles[randi_range(0, decoration_tiles.size() - 1)]

	# Reapply tiles
	for y in range(height):
		for x in range(width):
			map.set_cell(Vector2i(x, y), output_grid[x][y])

func _process(delta: float) -> void:
	pass  # Generation happens in _ready()

use std::path::{Path, PathBuf};
use std::io::{self, Write, stdin, stdout};
use std::fs;
use std::time::{Duration, Instant};
use std::thread;
use rand::Rng;
use crossterm::{
    execute,
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
    cursor::{Hide, Show},
    event::{Event, KeyCode},
    style::{SetBackgroundColor, SetForegroundColor, Color},
    ExecutableCommand,
};
use tui::{
    backend::CrosstermBackend,
    Terminal,
    layout::{Constraint, Direction, Layout, Rect},
    widgets::{Block, Borders, List, ListItem, Paragraph},
    text::{Span, Spans},
    style::{Style, StyledGraphic},
    symbols,
    Frame,
};

use clap::{Arg, Command};

// Constants for the animation
const STAR_COUNT: usize = 100;
const MAX_DEPTH: usize = 3;
const ANIMATION_DURATION: u64 = 100;

// Struct to represent a star in the animation
struct Star {
    x: u16,
    y: u16,
    speed: u16,
    twinkle: bool,
}

impl Star {
    fn new(width: u16, height: u16) -> Self {
        let mut rng = rand::thread_rng();
        Star {
            x: rng.gen_range(0..width),
            y: rng.gen_range(0..height),
            speed: rng.gen_range(1..5),
            twinkle: rng.gen_bool(0.3),
        }
    }

    fn update(&mut self, width: u16, height: u16) {
        if self.x >= width {
            self.x = 0;
            self.y = rand::thread_rng().gen_range(0..height);
        } else {
            self.x += self.speed;
        }
    }

    fn render(&self, frame: &mut Frame<CrosstermBackend>) {
        if self.twinkle {
            frame.set_style(Style::default().add_modifier(tui::style::Modifier::BOLD).fg(Color::White));
        } else {
            frame.set_style(Style::default().fg(Color::LightCyan));
        }
        frame.renderer().draw_glyph(self.x, self.y, symbols::block::PLUS, ' ', StyledGraphic::default());
    }
}

fn main() {
    // Parse command line arguments
    let matches = Command::new("Nebula-Finder")
        .version("1.0")
        .author("Ailey")
        .about("A command-line file search tool with a magical starry background")
        .arg(Arg::new("directory")
            .short('d')
            .long("directory")
            .value_name("DIRECTORY")
            .help("Sets the directory to search")
            .default_value("."))
        .arg(Arg::new("pattern")
            .short('p')
            .long("pattern")
            .value_name("PATTERN")
            .help("Sets the search pattern")
            .required(true))
        .get_matches();

    let search_dir = matches.get_one::<String>("directory").unwrap();
    let search_pattern = matches.get_one::<String>("pattern").unwrap();

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

    let backend = CrosstermBackend::new(stdout);
    let mut terminal = Terminal::new(backend).expect("Failed to initialize terminal");
    terminal.clear().expect("Failed to clear terminal");

    // Set up the animation
    let mut stars: Vec<Star> = (0..STAR_COUNT).map(|_| Star::new(terminal.size().unwrap().0, terminal.size().unwrap().1 - 5)).collect();
    let start_time = Instant::now();

    // Main loop
    let mut quit = false;
    let mut search_results: Vec<PathBuf> = Vec::new();
    let mut current_result_index = 0;

    loop {
        terminal.draw(|f| {
            let size = f.size();
            let block = Block::default().borders(Borders::ALL).title(Span::styled(
                format!("Nebula-Finder - Searching for '{}' in {}", search_pattern, search_dir),
                Style::default().fg(Color::White).add_modifier(tui::style::Modifier::BOLD),
            ));

            let inner = Layout::new(
                Constraint::Percentage(80),
                Constraint::Percentage(20),
            )
            .direction(Direction::Vertical)
            .margin(1)
            .split(size);

            // Draw the starry background
            for star in &mut stars {
                star.update(size.width, inner[1].height);
                star.render(f);
            }

            // Draw the search progress and results
            let progress_paragraph = Paragraph::new(Spans::from(vec![
                Span::styled(
                    format!("Searching: {} / {} files", search_results.len(), if search_results.is_empty() { 0 } else { search_results.len() }),
                    Style::default().fg(Color::Yellow),
                ),
                Span::from(""),
            ]))
            .block(block)
            .style(Style::default().add_modifier(tui::style::Modifier::ITALIC));

            f.render_widget(progress_paragraph, inner[0]);

            // Draw the search results
            let results_list = if search_results.is_empty() {
                List::new(
                    vec![ListItem::new(Span::styled(
                        "No results found yet...",
                        Style::default().fg(Color::Red),
                    ))]
                )
                .block(Block::default().borders(Borders::ALL).title(Span::styled("Results", Style::default().fg(Color::White))))
            } else {
                List::new(
                    search_results
                        .iter()
                        .enumerate()
                        .map(|(i, path)| {
                            let style = if i == current_result_index {
                                Style::default().fg(Color::Green)
                            } else {
                                Style::default().fg(Color::White)
                            };
                            ListItem::new(Span::styled(
                                format!("{}", path.display()),
                                style,
                            ))
                        })
                        .collect::<Vec<_>>()
                )
                .block(Block::default().borders(Borders::ALL).title(Span::styled("Results", Style::default().fg(Color::White))))
            };

            f.render_widget(results_list, inner[1]);
        }).expect("Failed to draw terminal");

        // Check if it's time to search (every ANIMATION_DURATION ms)
        if start_time.elapsed().as_millis() >= ANIMATION_DURATION {
            start_time = Instant::now();
            search_files(search_dir, search_pattern, &mut search_results);
        }

        // Handle user input
        if let Ok(Event::Key(key_event)) = crossterm::event::poll(Duration::from_millis(100)) {
            match key_event.code {
                KeyCode::Char('q') | KeyCode::Esc => {
                    quit = true;
                    break;
                }
                KeyCode::Down => {
                    if current_result_index < search_results.len() - 1 {
                        current_result_index += 1;
                    }
                }
                KeyCode::Up => {
                    if current_result_index > 0 {
                        current_result_index -= 1;
                    }
                }
                KeyCode::Enter => {
                    if let Some(path) = search_results.get(current_result_index) {
                        println!("\nOpening: {}", path.display());
                        if let Err(e) = open::that(path) {
                            println!("Failed to open: {}", e);
                        }
                        break;
                    }
                }
                _ => {}
            }
        }

        if quit {
            break;
        }

        thread::sleep(Duration::from_millis(ANIMATION_DURATION));
    }

    // Cleanup
    disable_raw_mode().expect("Failed to disable raw mode");
    execute!(
        terminal.backend(),
        LeaveAlternateScreen,
        Show,
    ).expect("Failed to leave alternate screen");
    terminal.clear().expect("Failed to clear terminal");
    println!("Goodbye, stargazer!");
}

fn search_files(directory: &str, pattern: &str, results: &mut Vec<PathBuf>) {
    let path = Path::new(directory);
    if path.exists() && path.is_dir() {
        if let Ok(entries) = fs::read_dir(path) {
            for entry in entries.flatten() {
                if entry.path().is_dir() {
                    // Recursive search with limited depth
                    if results.len() < MAX_DEPTH * STAR_COUNT {
                        search_files(entry.path().to_str().unwrap(), pattern, results);
                    }
                } else if let Some(extension) = entry.path().extension().and_then(|s| s.to_str()) {
                    if extension == pattern {
                        results.push(entry.path());
                    }
                }
            }
        }
    }
}

const readline = require('readline');
const { stdin, stdout } = require('process');

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

const CHARSET = '.,-~:;*#M@';
const WIDTH = 80;
const HEIGHT = 24;

function generateFractal(x, y, depth, maxDepth, scale, offsetX, offsetY) {
  if (depth >= maxDepth) return ' ';

  const charIndex = Math.floor((x + offsetX) * scale) % CHARSET.length;
  const char = CHARSET[charIndex];

  // Rekursiver Aufruf für komplexe Muster
  const newX = (x * 0.5 + 0.5) * WIDTH;
  const newY = (y * 0.5 + 0.5) * HEIGHT;
  const newDepth = depth + 1;
  const newScale = scale * 1.5;
  const newOffsetX = offsetX + (x * 0.1);
  const newOffsetY = offsetY + (y * 0.1);

  // Symmetrie: Spiegeln und Rotieren
  const mirroredX = WIDTH - newX - 1;
  const rotatedX = HEIGHT - newY - 1;

  const mirroredChar = generateFractal(mirroredX, newY, newDepth, maxDepth, newScale, newOffsetX, offsetY);
  const rotatedChar = generateFractal(rotatedX, newX, newDepth, maxDepth, newScale, offsetX, newOffsetY);

  return char + (mirroredChar === ' ' ? ' ' : mirroredChar) + (rotatedChar === ' ' ? ' ' : rotatedChar);
}

function renderFrame() {
  let output = '';
  const scale = Math.random() * 0.05 + 0.01;
  const offsetX = Math.random() * 10;
  const offsetY = Math.random() * 10;
  const maxDepth = Math.floor(Math.random() * 5) + 2;

  for (let y = 0; y < HEIGHT; y++) {
    for (let x = 0; x < WIDTH; x++) {
      const char = generateFractal(x, y, 0, maxDepth, scale, offsetX, offsetY);
      output += char;
    }
    output += '\n';
  }

  return output;
}

function main() {
  console.log('FractalKaleidoscope - Drücke STRG+C, um zu beenden.');
  console.log('Kreative ASCII-Fraktale mit zufälligen Farben und Symmetrien.\n');

  setInterval(() => {
    stdout.write('\x1B[H'); // Cursor an den Anfang der Konsole
    stdout.write(renderFrame());
  }, 200);
}

main();

// DynamicNPCAdaptor - A dynamic NPC AI plugin for RPG Maker MZ
// Runs as a standalone Node.js script for simulation and testing

const { NPC } = require('./lib/NPC');
const { Environment } = require('./lib/Environment');
const { Player } = require('./lib/Player');
const { Logger } = require('./lib/Logger');

class DynamicNPCAdaptor {
    constructor() {
        this.environment = new Environment();
        this.player = new Player();
        this.npcs = [];
        this.logger = new Logger();
        this.setupNPCs();
        this.setupEventLoop();
    }

    setupNPCs() {
        // Create diverse NPCs with unique personalities and routines
        const personalities = ['Social', 'Shy', 'Aggressive', 'Lazy', 'Curious'];
        const routines = [
            { activity: 'Wander', radius: 3, interval: 1000 },
            { activity: 'Sleep', duration: 5000, wakeTime: '18:00' },
            { activity: 'Gossip', targets: [], interval: 2000 },
            { activity: 'Gather', radius: 2, interval: 1500 },
            { activity: 'Patrol', path: [[0, 0], [5, 5], [10, 0]], speed: 1 }
        ];

        for (let i = 0; i < 10; i++) {
            const personality = personalities[Math.floor(Math.random() * personalities.length)];
            const routine = routines[Math.floor(Math.random() * routines.length)];
            const npc = new NPC(i, personality, routine, this.environment, this.player);
            this.npcs.push(npc);
            this.logger.log(`Created NPC #${i} with personality: ${personality} and routine: ${routine.activity}`);
        }
    }

    setupEventLoop() {
        // Simulate game loop (60 FPS)
        const gameLoop = setInterval(() => {
            // Update environment (time of day, weather, etc.)
            this.environment.update();

            // Update player position (random movement for simulation)
            this.player.update();

            // Update all NPCs
            this.npcs.forEach(npc => npc.update());

            // Log NPC states periodically
            if (this.player.time % 10 === 0) {
                this.logger.logNPCStates(this.npcs);
            }
        }, 16); // ~60 FPS

        // Start with a 1-second delay to allow setup
        setTimeout(() => {
            this.logger.log('DynamicNPCAdaptor simulation started. Press Ctrl+C to exit.');
        }, 1000);
    }
}

// Simulate RPG Maker MZ environment variables
global.$gameMap = {
    _events: new Map(),
    addEvent: (id, x, y) => { /* Simplified */ },
    getEvent: (id) => ({ /* Simplified event object */ }),
    getObjects: () => ({ /* Simplified */ })
};

// Main execution
const adaptor = new DynamicNPCAdaptor();

// Export for potential use in other modules
module.exports = DynamicNPCAdaptor;

import android.media.MediaPlayer
import androidx.compose.foundation.background
import androidx.compose.foundation.gestures.detectTap
import androidx.compose.foundation.gestures.detectTapGesture
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.DarkMode
import androidx.compose.material.icons.filled.MusicNote
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ElevatedCard
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import import androidx.compose.material3.Scaffold
import import androidx.compose.material3.SnackbarHost
import import androidx.compose.material3.SnackbarHostState
import import androidx.compose.material3.Surface
import import androidx.compose.material3.Text
import import androidx.compose.material3.TextButton
import import androidx.compose.material3.IconToggleButton
import import androidx.compose.runtime.Composable
import import androidx.compose.runtime.LaunchedEffect
import import androidx.compose.runtime.getValue
import import androidx.compose.runtime.mutableStateOf
import import androidx.compose.runtime.remember
import import androidx.compose.runtime.setValue
import import androidx.compose.ui.Alignment
import import androidx.compose.ui.Modifier
import import androidx.compose.ui.draw.clip
import import androidx.compose.ui.graphics.Color
import import androidx.compose.ui.graphics.vector.ImageVector
import import androidx.compose.ui.platform.LocalContext
import import androidx.compose.ui.text.font.FontWeight
import import androidx.compose.ui.text.input.TextFieldValue
import import androidx.compose.ui.unit.dp
import import androidx.compose.ui.unit.sp
import import androidx.lifecycle.viewmodel.compose.viewModel
import import com.google.accompanist-systemuicontroller.rememberSystemUiController
import import kotlinx.coroutines.launch
import import androidx.compose.ui.input.nestedscroll
import import androidx.compose.ui.input.pointer.pointerInput
import import androidx.compose.ui.zIndex

@Composable
fun GroovyTodoApp() {
    val systemUiController = rememberSystemUiController()
    systemUiController.setSystemBarsColor(
        color = MaterialTheme.colorScheme.primary,
        darkIcons = !MaterialTheme.colorScheme.isLight
    )

    val viewModel: GroovyTodoViewModel = viewModel()
    val snackbarHostState = remember { SnackbarHostState() }
    val coroutineScope = remember { CoroutineScope(Dispatchers.Main) }

    val listState = rememberLazyListState()

    LaunchedEffect(viewModel) {
        viewModel.loadTasks()
    }

    Scaffold(
        snackbarHost = { SnackbarHost(snackbarHostState) },
        floatingActionButton = {
            FloatingActionButtonWithMusic(
                onClick = { viewModel.addEmptyTask() },
                onToggleMusic = {
                    viewModel.toggleMusic()
                    coroutineScope.launch {
                        snackbarHostState.showMessage(
                            viewModel.musicPlaying.value.let {
                                if (it) "Groovy music ON! ✨" else "Groovy music OFF"
                            }
                        )
                    }
                },
                musicPlaying = viewModel.musicPlaying.value,
                modifier = Modifier
                    .padding(16.dp)
                    .size(64.dp)
            )
        },
        topBar = {
            TopAppBarWithThemeToggle(
                onThemeToggle = { viewModel.toggleTheme() },
                themeState = viewModel.darkTheme.value
            )
        }
    ) { padding ->
        Surface(
            modifier = Modifier
                .fillMaxSize()
                .padding(padding)
                .background(MaterialTheme.colorScheme.background)
        ) {
            GroovyTodoList(
                tasks = viewModel.tasks,
                onTaskChange = viewModel::updateTask,
                onDeleteTask = { index ->
                    viewModel.deleteTask(index)
                    coroutineScope.launch {
                        snackbarHostState.showMessage("Task deleted! 🧹")
                    }
                },
                onAddTask = viewModel::addTask,
                listState = listState,
                onMusicToggle = viewModel::toggleMusic,
                musicPlaying = viewModel.musicPlaying.value
            )
        }
    }
}

@Composable
fun FloatingActionButtonWithMusic(
    onClick: () -> Unit,
    onToggleMusic: () -> Unit,
    musicPlaying: Boolean,
    modifier: Modifier = Modifier
) {
    Card(
        modifier = modifier,
        shape = CircleShape
    ) {
        Column(
            horizontalAlignment = Alignment.CenterHorizontally
        ) {
            IconToggleButton(
                checked = musicPlaying,
                onCheckedChange = { onToggleMusic() }
            ) {
                Icon(
                    imageVector = Icons.Default.MusicNote,
                    contentDescription = "Toggle music",
                    tint = if (musicPlaying) Color.Green else Color.Gray
                )
            }
            Spacer(modifier = Modifier.height(8.dp))
            IconButton(
                onClick = onClick
            ) {
                Icon(
                    imageVector = Icons.Default.Add,
                    contentDescription = "Add task"
                )
            }
        }
    }
}

@Composable
fun TopAppBarWithThemeToggle(
    onThemeToggle: () -> Unit,
    themeState: Boolean
) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .background(MaterialTheme.colorScheme.primaryContainer)
            .padding(16.dp),
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.SpaceBetween
    ) {
        Text(
            text = "Groovy Todos",
            color = MaterialTheme.colorScheme.onPrimaryContainer,
            fontWeight = FontWeight.Bold,
            fontSize = 20.sp
        )
        IconToggleButton(
            checked = themeState,
            onCheckedChange = { onThemeToggle() }
        ) {
            Icon(
                imageVector = Icons.Default.DarkMode,
                contentDescription = "Toggle theme",
                tint = if (themeState) Color.Green else Color.Gray
            )
        }
    }
}

@Composable
fun GroovyTodoList(
    tasks: List<Task>,
    onTaskChange: (Int, String) -> Unit,
    onDeleteTask: (Int) -> Unit,
    onAddTask: (String) -> Unit,
    listState: LazyListState,
    onMusicToggle: () -> Unit,
    musicPlaying: Boolean
) {
    var newTask by remember { mutableStateOf(TextFieldValue("")) }
    var editingIndex by remember { mutableStateOf<Int?>(null) }
    val context = LocalContext.current

    val mediaPlayer = remember {
        MediaPlayer.create(context, R.raw.groovy_music)
    }

    LaunchedEffect(musicPlaying) {
        if (musicPlaying && !mediaPlayer.isPlaying) {
            mediaPlayer.start()
        } else if (!musicPlaying && mediaPlayer.isPlaying) {
            mediaPlayer.pause()
        }
    }

    LazyColumn(
        state = listState,
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp)
    ) {
        item {
            OutlinedTextField(
                value = newTask,
                onValueChange = { newTask = it },
                label = { Text("Add a groovy task") },
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(bottom = 16.dp),
                shape = RoundedCornerShape(8.dp),
                singleLine = true
            )
        }
        itemsIndexed(tasks) { index, task ->
            TaskItem(
                task = task,
                onCheck = { onTaskChange(index, task.text) },
                onDelete = { onDeleteTask(index) },
                onEditStart = { editingIndex = index },
                onEditStop = { editingIndex = null },
                onEditChange = { newText -> onTaskChange(index, newText) },
                isEditing = editingIndex == index,
                onAddTask = onAddTask,
                musicPlaying = musicPlaying,
                context = context
            )
        }
    }
}

@Composable
fun TaskItem(
    task: Task,
    onCheck: () -> Unit,
    onDelete: () -> Unit,
    onEditStart: () -> Unit,
    onEditStop: () -> Unit,
    onEditChange: (String) -> Unit,
    isEditing: Boolean,
    onAddTask: (String) -> Unit,
    musicPlaying: Boolean,
    context: Context
) {
    val mediaPlayer = remember {
        MediaPlayer.create(context, R.raw.groovy_music)
    }

    LaunchedEffect(task.isCompleted) {
        if (task.isCompleted && musicPlaying) {
            mediaPlayer.start()
        }
    }

    ElevatedCard(
        modifier = Modifier
            .fillMaxWidth()
            .padding(bottom = 8.dp)
            .pointerInput(Unit) {
                detectTapGesture(
                    onTap = {
                        if (!task.isCompleted) onCheck()
                    }
                )
            },
        shape = RoundedCornerShape(8.dp)
    ) {
        Row(
            modifier = Modifier
                .fillMaxWidth()
                .padding(16.dp),
            verticalAlignment = Alignment.CenterVertically
        ) {
            IconButton(
                onClick = onCheck,
                enabled = !task.isCompleted
            ) {
                Icon(
                    imageVector = Icons.Default.Check,
                    contentDescription = "Complete task",
                    tint = if (task.isCompleted) Color.Green else Color.Gray
                )
            }
            Spacer(modifier = Modifier.size(8.dp))
            if (isEditing) {
                OutlinedTextField(
                    value = task.text,
                    onValueChange = { onEditChange(it) },
                    modifier = Modifier
                        .weight(1f)
                        .padding(horizontal = 8.dp),
                    singleLine = true,
                    onImeActionPerformed = { onEditStop() }
                )
            } else {
                Text(
                    text = task.text,
                    modifier = Modifier.weight(1f),
                    fontWeight = if (task.isCompleted) FontWeight.Bold else FontWeight.Normal,
                    color = if (task.isCompleted) Color.Green else Color.Black
                )
            }
            IconButton(
                onClick = onDelete
            ) {
                Icon(
                    imageVector = Icons.Default.Delete,
                    contentDescription = "Delete task"
                )
            }
            IconButton(
                onClick = onEditStart,
                modifier = Modifier.zIndex(1f)
            ) {
                Icon(
                    imageVector = Icons.Default.Add,
                    contentDescription = "Edit task"
                )
            }
        }
    }
}

data class Task(
    val text: String,
    var isCompleted: Boolean = false
)

class GroovyTodoViewModel : ViewModel() {
    private val _tasks = mutableListOf<Task>()
    val tasks: List<Task> get() = _tasks

    var musicPlaying by mutableStateOf(false)
        private set

    var darkTheme by mutableStateOf(false)
        private set

    fun loadTasks() {
        // Simulate loading tasks
        if (_tasks.isEmpty()) {
            _tasks.addAll(listOf(
                Task("Buy groovy groceries"),
                Task("Finish that epic Compose project"),
                Task("Learn Kotlin coroutines like a boss"),
                Task("Listen to more groovy music")
            ))
        }
    }

    fun updateTask(index: Int, newText: String) {
        if (index >= 0 && index < _tasks.size) {
            _tasks[index] = _tasks[index].copy(
                text = newText,
                isCompleted = !_tasks[index].isCompleted
            )
        }
    }

    fun deleteTask(index: Int) {
        if (index >= 0 && index < _tasks.size) {
            _tasks.removeAt(index)
        }
    }

    fun addEmptyTask() {
        _tasks.add(Task(""))
    }

    fun addTask(text: String) {
        if (text.isNotBlank()) {
            _tasks.add(Task(text))
        }
    }

    fun toggleMusic() {
        musicPlaying = !musicPlaying
    }

    fun toggleTheme() {
        darkTheme = !darkTheme
    }
}

@Preview(showBackground = true)
@Composable
fun GroovyTodoAppPreview() {
    GroovyTodoApp()
}

// Import required libraries
const { Canvas, Image } = require('canvas');
const fs = require('fs');

// Main plugin class
class PixelArtDynamicMenu {
    constructor(width = 800, height = 600, bgColor = '#121212', textColor = '#FF00FF') {
        this.width = width;
        this.height = height;
        this.bgColor = bgColor;
        this.textColor = textColor;
        this.items = [];
        this.selectedIndex = 0;
        this.animationFrame = 0;
        this.colorCycle = 0;
        this.transition = 'in';
        this.transitionProgress = 0;
        thisovich = false;
    }

    // Initialize the canvas and start rendering
    init() {
        this.canvas = new Canvas(this.width, this.height);
        this.ctx = this.canvas.getContext('2d');

        // Set up the base menu style
        this.setupBaseStyle();

        // Add some default menu items
        this.addMenuItem('Adventure');
        this.addMenuItem('Characters');
        this.addMenuItem('Options');
        this.addMenuItem('Save Game');
        this.addMenuItem('Quit');

        // Start the animation loop
        this.animate();
    }

    // Set up the base pixel-art style
    setupBaseStyle() {
        this.ctx.fillStyle = this.bgColor;
        this.ctx.fillRect(0, 0, this.width, this.height);

        // Draw pixel borders
        this.ctx.strokeStyle = '#FFFFFF';
        this.ctx.lineWidth = 2;
        for (let y = 0; y < this.height; y += 32) {
            for (let x = 0; x < this.width; x += 32) {
                this.ctx.beginPath();
                this.ctx.rect(x, y, 32, 32);
                this.ctx.stroke();
            }
        }

        // Draw pixel text guide
        this.ctx.font = '24px monospace';
        this.ctx.fillStyle = '#444444';
        this.ctx.textAlign = 'center';
        for (let y = 50; y < this.height - 50; y += 32) {
            this.ctx.fillText('|', this.width / 2, y + 5);
        }
    }

    // Add a menu item
    addMenuItem(text, callback = () => {}) {
        this.items.push({
            text: text,
            callback: callback,
            color: this.getRandomColor()
        });
    }

    // Get a random color for pixel art
    getRandomColor() {
        const colors = ['#FF0000', '#00FF00', '#0000FF', '#FFFF00', '#FF00FF', '#00FFFF'];
        return colors[Math.floor(Math.random() * colors.length)];
    }

    // Render the menu
    render() {
        // Clear the canvas with animated transition effect
        this.ctx.clearRect(0, 0, this.width, this.height);

        // Fade in/out transition
        const transitionAlpha = Math.sin(this.transitionProgress * Math.PI) * 0.5 + 0.5;
        this.ctx.fillStyle = `rgba(18, 18, 18, ${transitionAlpha})`;
        this.ctx.fillRect(0, 0, this.width, this.height);

        // Draw the pixel borders again
        this.ctx.strokeStyle = '#FFFFFF';
        this.ctx.lineWidth = 2;
        for (let y = 0; y < this.height; y += 32) {
            for (let x = 0; x < this.width; x += 32) {
                this.ctx.beginPath();
                this.ctx.rect(x, y, 32, 32);
                this.ctx.stroke();
            }
        }

        // Draw menu items with color cycling and pixel effect
        const itemY = 50;
        const itemHeight = 32;
        const centerY = this.height / 2;

        this.items.forEach((item, index) => {
            const y = centerY - (this.items.length / 2 - index) * itemHeight;
            const isSelected = index === this.selectedIndex;

            // Calculate color cycling effect
            const colorPhase = (index + this.colorCycle) % 10;
            let textColor = isSelected ? this.textColor : item.color;
            if (colorPhase < 3) {
                textColor = this.cycleColor(textColor, 10, 20);
            } else if (colorPhase < 6) {
                textColor = this.cycleColor(textColor, 20, 10);
            } else if (colorPhase < 9) {
                textColor = this.cycleColor(textColor, 10, 30);
            }

            // Draw the item
            this.ctx.font = '24px monospace';
            this.ctx.fillStyle = textColor;
            this.ctx.textAlign = 'center';
            this.ctx.fillText(item.text, this.width / 2, y + 5);

            // Draw selected item with pixel highlight
            if (isSelected) {
                this.ctx.strokeStyle = textColor;
                this.ctx.lineWidth = 1;
                this.ctx.beginPath();
                this.ctx.rect(this.width / 2 - 50, y - 5, 100, 22);
                this.ctx.stroke();
            }
        });
    }

    // Cycle colors for animation effect
    cycleColor(color, amount, direction = 1) {
        const r = (parseInt(color.substring(1, 3), 16) + direction * amount) % 256;
        const g = (parseInt(color.substring(3, 5), 16) + direction * amount) % 256;
        const b = (parseInt(color.substring(5, 7), 16) + direction * amount) % 256;
        return `rgb(${r}, ${g}, ${b})`;
    }

    // Animation loop
    animate() {
        this.animationFrame++;
        this.colorCycle = (this.animationFrame / 20) % 10;
        this.transitionProgress = this.animationFrame / 100;

        this.render();

        // Add a little visual chaos for fun
        if (this.animationFrame % 150 === 0 && !this.chaos) {
            this.addChaosItem();
        }

        // Save the current frame if needed
        if (this.animationFrame % 5 === 0) {
            this.saveFrame();
        }

        requestAnimationFrame(() => this.animate());
    }

    // Add a random chaos item for fun
    addChaosItem() {
        const chaosItems = ['HELP!', 'PIXELS', 'RANDOM', 'GLITCH', 'CHAOS', '?'];
        const randomItem = chaosItems[Math.floor(Math.random() * chaosItems.length)];
        const randomColor = this.getRandomColor();
        this.items.push({
            text: randomItem,
            callback: () => {
                console.log(`Chaos item selected: ${randomItem}`);
                this.items = this.items.filter(item => item.text !== randomItem);
            },
            color: randomColor
        });
        this.selectedIndex = this.items.length - 1;
    }

    // Save the current frame to a file
    saveFrame() {
        const framePath = `menu_frame_${this.animationFrame.toString().padStart(5, '0')}.png`;
        const out = fs.createWriteStream(framePath);
        this.canvas.createPNGStream().pipe(out);
        out.on('finish', () => console.log(`Saved frame to ${framePath}`));
    }

    // Handle keyboard input
    handleInput(key) {
        switch (key) {
            case 'ArrowUp':
                this.selectedIndex = (this.selectedIndex - 1 + this.items.length) % this.items.length;
                this.transition = 'in';
                break;
            case 'ArrowDown':
                this.selectedIndex = (this.selectedIndex + 1) % this.items.length;
                this.transition = 'in';
                break;
            case 'Enter':
                this.items[this.selectedIndex].callback();
                this.transition = 'out';
                setTimeout(() => this.transition = 'in', 300);
                break;
            case ' ':
                this.items.push({
                    text: 'New Item',
                    callback: () => console.log('New item selected!'),
                    color: this.getRandomColor()
                });
                this.selectedIndex = this.items.length - 1;
                break;
        }
    }
}

// Create and initialize the menu
const menu = new PixelArtDynamicMenu(800, 600, '#121212', '#FF00FF');
menu.init();

// Simulate some user input (for demonstration)
setInterval(() => {
    const keys = ['ArrowUp', 'ArrowDown', 'ArrowUp', 'Enter', ' '];
    menu.handleInput(keys[Math.floor(Math.random() * keys.length)]);
}, 1000);

// Export the class for potential use in other scripts
module.exports = PixelArtDynamicMenu;