A!leys Galerie

#!/usr/bin/env python3
"""
QuantumWhisper - A playful file encryption/decryption utility with a twist of quantum-inspired bit diffusion.
"""

import argparse
import os
import sys
import random
from typing import Tuple, List, Optional
from pathlib import Path

# Colorized output for a playful touch
class Color:
    RESET = "\033[0m"
    GREEN = "\033[92m"
    RED = "\033[91m"
    BLUE = "\033[94m"
    YELLOW = "\033[93m"
    MAGENTA = "\033[95m"

def generate_quantum_key(length: int) -> List[int]:
    """Generate a 'quantum' key using a blend of randomness and bit diffusion."""
    key = [random.randint(0, 255) for _ in range(length)]
    # Quantum-inspired bit diffusion (simulated)
    for i in range(1, length):
        key[i] ^= (key[i - 1] * 3) % 256
    return key

def xor_cipher(data: bytes, key: List[int]) -> bytes:
    """Apply XOR cipher with the given key (repeating if necessary)."""
    return bytes(b ^ key[i % len(key)] for i, b in enumerate(data))

def quantum_entangle(data: bytes, key: List[int]) -> bytes:
    """Add a quantum-inspired entanglement layer to the data."""
    if len(data) < 2:
        return data
    # Simulate quantum entanglement by swapping bits in a non-trivial way
    entangled = bytearray(data)
    for i in range(0, len(entangled) - 1, 2):
        if i + 1 < len(entangled):
            entangled[i], entangled[i + 1] = entangled[i + 1], entangled[i]
            # XOR with a derived value to break simple patterns
            entangled[i] ^= (key[(i // 2) % len(key)] * 7) % 256
    return bytes(entangled)

def de_quantum_entangle(data: bytes, key: List[int]) -> bytes:
    """Reverse the quantum entanglement layer."""
    if len(data) < 2:
        return data
    de_entangled = bytearray(data)
    for i in range(0, len(de_entangled) - 1, 2):
        if i + 1 < len(de_entangled):
            de_entangled[i], de_entangled[i + 1] = de_entangled[i + 1], de_entangled[i]
            de_entangled[i] ^= (key[(i // 2) % len(key)] * 7) % 256
    return bytes(de_entangled)

def encrypt_file(input_path: Path, output_path: Path, key: Optional[List[int]] = None, entangle: bool = False) -> None:
    """Encrypt the file using XOR cipher and optional quantum entanglement."""
    if not key:
        key_length = min(256, (os.path.getsize(input_path) // 3) + 1)
        key = generate_quantum_key(key_length)
    with open(input_path, "rb") as f_in, open(output_path, "wb") as f_out:
        data = f_in.read()
        encrypted = xor_cipher(data, key)
        if entangle:
            encrypted = quantum_entangle(encrypted, key)
        f_out.write(encrypted)
    print(f"{Color.GREEN}✨ Encrypted '{input_path}' to '{output_path}'{Color.RESET}")

def decrypt_file(input_path: Path, output_path: Path, key: Optional[List[int]] = None, entangle: bool = False) -> None:
    """Decrypt the file using the same key and optional quantum entanglement layer."""
    if not key:
        # If no key is provided, try to generate a plausible one (for demo purposes)
        key_length = min(256, (os.path.getsize(input_path) // 3) + 1)
        key = generate_quantum_key(key_length)
        print(f"{Color.YELLOW}⚠️  No key provided. Generated a new one (this may not work for entangled files).{Color.RESET}")
    with open(input_path, "rb") as f_in, open(output_path, "wb") as f_out:
        data = f_in.read()
        if entangle:
            data = de_quantum_entangle(data, key)
        decrypted = xor_cipher(data, key)
        f_out.write(decrypted)
    print(f"{Color.GREEN}✨ Decrypted '{input_path}' to '{output_path}'{Color.RESET}")

def main() -> None:
    """Main function to parse arguments and execute encryption/decryption."""
    parser = argparse.ArgumentParser(
        description="QuantumWhisper - A playful file encryption/decryption utility.",
        epilog=f"Example: {Color.BLUE}python {sys.argv[0]} encrypt input.txt output.enc --entangle{Color.RESET}"
    )
    subparsers = parser.add_subparsers(dest="command", required=True, help="Command to execute")

    # Encrypt command
    encrypt_parser = subparsers.add_parser("encrypt", help="Encrypt a file")
    encrypt_parser.add_argument("input", type=Path, help="Input file path")
    encrypt_parser.add_argument("output", type=Path, help="Output file path")
    encrypt_parser.add_argument("--key", type=int, nargs="*", default=None, help="Manual key values (optional)")
    encrypt_parser.add_argument("--entangle", action="store_true", help="Add quantum-inspired entanglement layer")

    # Decrypt command
    decrypt_parser = subparsers.add_parser("decrypt", help="Decrypt a file")
    decrypt_parser.add_argument("input", type=Path, help="Input file path")
    decrypt_parser.add_argument("output", type=Path, help="Output file path")
    decrypt_parser.add_argument("--key", type=int, nargs="*", default=None, help="Manual key values (optional)")
    decrypt_parser.add_argument("--entangle", action="store_true", help="Remove quantum-inspired entanglement layer")

    args = parser.parse_args()

    if args.command == "encrypt":
        if args.key:
            key = [k for k in args.key]
        else:
            key = None
        encrypt_file(args.input, args.output, key, args.entangle)
    elif args.command == "decrypt":
        if args.key:
            key = [k for k in args.key]
        else:
            key = None
        decrypt_file(args.input, args.output, key, args.entangle)

if __name__ == "__main__":
    main()

extends ShaderMaterial

class_name "CelestialParticleBurst"

# Export variables for customization
@export var particle_count: int = 500
@export var max_speed: float = 2.0
@export var size_variation: float = 0.5
@export var color_shift_speed: float = 1.0
@export var color_shift_intensity: float = 0.3
@export var organic_formation_strength: float = 0.7
@export var formation_organicness: float = 0.85

# Internal variables for state tracking
var _time: float = 0.0
var _particle_offs: Array2 = Array2.new_filled(particle_count, Vector2.ZERO)

func _ready():
	# Pre-allocate particle positions in 2D array for better performance
	for i in range(particle_count):
		_particle_offs[i] = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)) * 0.5

func _process(delta: float):
	_time += delta

	# Update particle positions with organic formation behavior
	for i in range(particle_count):
		# Base movement with velocity and time-based variation
		var speed = max_speed * (0.8 + 0.4 * sin(_time * 0.7 + i * 0.1))
		var angle = _time * speed * 2.0 + i * 0.3
		var pos = Vector2(cos(angle), sin(angle)) * 0.5

		# Organic formation influence - particles subtly follow wave patterns
		var formation_offset = Vector2(
			sin(_time * 0.5 + i * 0.2) * organic_formation_strength * 0.3,
			cos(_time * 0.4 + i * 0.3) * organic_formation_strength * 0.2
		)

		# Combine positions
		_particle_offs[i] = _particle_offs[i].lerp(pos + formation_offset, 0.05)

func _process_material(_delta: float):
	# Set uniforms for the shader
	uniform_set("u_time", _time)
	uniform_set("u_particle_offs", _particle_offs)
	uniform_set("u_particle_count", particle_count)
	uniform_set("u_size_variation", size_variation)
	uniform_set("u_color_shift", Vector2(color_shift_speed, color_shift_intensity))
	uniform_set("u_organic_strength", organic_formation_strength * formation_organicness)

	# Update shader material with new uniforms
	material_update()

```php
<?php
/*
Plugin Name: Ailey's SmartTOC - AI-Enhanced TOC Generator
Description: Generates intelligent, visually stunning tables of contents with AI-powered heading analysis and interactive features. Uses Nord color scheme for a modern, elegant look.
Version: 1.0.0
Author: Ailey
Author URI: https://ailey.dev/
License: GPL-3.0+
Text Domain: smart-toc
*/

// =============================================
// WORDPRESS IMPLEMENTATION
// =============================================

if (defined('ABSPATH')) {
    // WordPress-specific setup
    define('SMART_TOC_VERSION', '1.0.0');
    define('SMART_TOC_DIR', plugin_dir_path(__FILE__));
    define('SMART_TOC_URL', plugin_dir_url(__FILE__));

    // Enqueue styles and scripts
    function smart_toc_enqueue_assets() {
        wp_enqueue_style(
            'smart-toc-style',
            SMART_TOC_URL . 'assets/css/smart-toc.css',
            array(),
            SMART_TOC_VERSION
        );

        wp_enqueue_script(
            'smart-toc-script',
            SMART_TOC_URL . 'assets/js/smart-toc.js',
            array('jquery'),
            SMART_TOC_VERSION,
            true
        );

        wp_localize_script('smart-toc-script', 'smart_toc_data', array(
            'ajax_url' => admin_url('admin-ajax.php'),
            'nonce' => wp_create_nonce('smart_toc_nonce')
        ));
    }
    add_action('wp_enqueue_scripts', 'smart_toc_enqueue_assets');

    // Shortcode implementation
    function smart_toc_shortcode($atts) {
        $atts = shortcode_atts(array(
            'min_level' => 2,
            'max_level' => 6,
            'show_numbers' => true,
            'show_icons' => true,
            'ai_analysis' => false
        ), $atts);

        ob_start();
        ?>
        <div class="smart-toc-container" data-min-level="<?php echo esc_attr($atts['min_level']); ?>"
             data-max-level="<?php echo esc_attr($atts['max_level']); ?>"
             data-show-numbers="<?php echo esc_attr($atts['show_numbers']); ?>"
             data-show-icons="<?php echo esc_attr($atts['show_icons']); ?>"
             data-ai-analysis="<?php echo esc_attr($atts['ai_analysis']); ?>">
            <div class="smart-toc-header">
                <h3>Contents</h3>
                <div class="smart-toc-controls">
                    <?php if ($atts['ai_analysis']): ?>
                    <button class="smart-toc-ai-btn" title="AI Enhanced">
                        <svg width="16" height="16" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
                            <circle cx="12" cy="12" r="10" stroke="currentColor" stroke-width="2"/>
                            <path d="M8 12l2 2 4-4" stroke="currentColor" stroke-width="2" fill="none"/>
                        </svg>
                    </button>
                    <?php endif; ?>
                    <button class="smart-toc-collapse-btn">
                        <svg width="16" height="16" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
                            <path d="M6 18l12-12M6 6l12 12" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
                        </svg>
                    </button>
                </div>
            </div>
            <div class="smart-toc-placeholder">
                <p>Loading table of contents...</p>
            </div>
        </div>
        <?php
        return ob_get_clean();
    }
    add_shortcode('smart_toc', 'smart_toc_shortcode');

    // AJAX handler for content parsing
    function smart_toc_ajax_handler() {
        check_ajax_referer('smart_toc_nonce', 'nonce');

        $content = isset($_POST['content']) ? $_POST['content'] : '';
        $min_level = isset($_POST['min_level']) ? intval($_POST['min_level']) : 2;
        $max_level = isset($_POST['max_level']) ? intval($_POST['max_level']) : 6;
        $show_numbers = isset($_POST['show_numbers']) && $_POST['show_numbers'] === 'true';
        $show_icons = isset($_POST['show_icons']) && $_POST['show_icons'] === 'true';
        $ai_analysis = isset($_POST['ai_analysis']) && $_POST['ai_analysis'] === 'true';

        $toc = generate_table_of_contents($content, $min_level, $max_level, $show_numbers, $show_icons, $ai_analysis);

        echo json_encode(array(
            'html' => $toc,
            'status' => 'success'
        ));
        wp_die();
    }
    add_action('wp_ajax_get_smart_toc', 'smart_toc_ajax_handler');
    add_action('wp_ajax_nopriv_get_smart_toc', 'smart_toc_ajax_handler');

    // Function to generate TOC from content
    function generate_table_of_contents($content, $min_level = 2, $max_level = 6, $show_numbers = true, $show_icons = true, $ai_analysis = false) {
        // Simple regex to extract headings (h2-h6)
        preg_match_all('/<h([2-6])[^>]*>(.*?)<\/h\1>/i', $content, $matches, PREG_SET_ORDER);

        $toc_items = array();
        foreach ($matches as $match) {
            $level = intval($match[1]);
            $title = strip_tags($match[2]);

            if ($level >= $min_level && $level <= $max_level) {
                $toc_items[] = array(
                    'level' => $level,
                    'title' => $title,
                    'text' => wp_kses_post($title),
                    'depth' => 0, // Will be set when building hierarchy
                    'has_children' => false
                );
            }
        }

        // Build hierarchy
        if (!empty($toc_items)) {
            $hierarchy = array();
            $current = array();
            $max_depth = 0;

            foreach ($toc_items as $item) {
                $depth = $item['level'] - 1; // h2 -> depth 1, h3 -> depth 2, etc.

                while (count($current) > $depth) {
                    array_pop($current);
                }

                if ($depth > 0) {
                    $parent = end($current);
                    $parent['has_children'] = true;
                    $item['depth'] = $depth;
                    $current[] = $item;
                    $max_depth = max($max_depth, $depth);
                } else {
                    $item['depth'] = $depth;
                    $current[] = $item;
                    $max_depth = max($max_depth, $depth);
                }

                if ($ai_analysis && $depth === 1) {
                    // Simulate AI analysis for main headings
                    $item['ai_score'] = rand(70, 90);
                    $item['ai_label'] = $item['ai_score'] >= 85 ? 'Excellent' : ($item['ai_score'] >= 75 ? 'Good' : 'Average');
                }
            }

            $toc_items = $hierarchy;
        }

        // Generate HTML
        $html = generate_toc_html($toc_items, $min_level, $max_level, $show_numbers, $show_icons, $ai_analysis);

        return $html;
    }

    // Recursive function to generate HTML for TOC
    function generate_toc_html($items, $min_level, $max_level, $show_numbers, $show_icons, $ai_analysis) {
        if (empty($items)) {
            return '';
        }

        $html = '<ul class="smart-toc-list">';
        $current_level = $items[0]['level'] ?? 2;

        foreach ($items as $item) {
            $is_expanded = true;
            $children = array();

            // Extract children (simplified - in real implementation, we'd need to match by depth)
            $child_depth = $item['level'] + 1;
            foreach ($items as $child) {
                if ($child['depth'] === $item['depth'] + 1) {
                    $children[] = $child;
                }
            }

            // Remove children from items to avoid double processing
            $items = array_filter($items, function($i) use ($child_depth) {
                return $i['depth'] !== $child_depth;
            });

            $class = 'smart-toc-item smart-toc-level-' . $item['level'];
            if (count($children) > 0) {
                $class .= ' smart-toc-item-has-children';
            }

            $html .= '<li class="' . esc_attr($class) . '">';
            $html .= '<a href="#' . sanitize_title($item['title']) . '" class="smart-toc-link"';

            if ($ai_analysis && isset($item['ai_score'])) {
                $ai_class = 'smart-toc-ai-' . strtolower($item['ai_label']);
                $html .= ' data-ai-score="' . esc_attr($item['ai_score']) . '"';
                $html .= ' data-ai-label="' . esc_attr($item['ai_label']) . '"';
            }

            $html .= '>';
            if ($show_numbers) {
                $html .= '<span class="smart-toc-number">' . ($item['level'] - 1) . '</span>';
            }

            if ($show_icons) {
                $html .= '<span class="smart-toc-icon smart-toc-icon-' . $item['level'] . '"></span>';
            }

            $html .= '<span class="smart-toc-text">' . $item['text'] . '</span>';

            if ($ai_analysis && isset($item['ai_score'])) {
                $html .= '<span class="smart-toc-ai-badge ' . $ai_class . '">' . $item['ai_label'] . '</span>';
            }

            $html .= '</a>';

            if (count($children) > 0) {
                $html .= '<div class="smart-toc-submenu">';
                $html .= generate_toc_html($children, $min_level, $max_level, $show_numbers, $show_icons, $ai_analysis);
                $html .= '</div>';
            }

            $html .= '</li>';
        }

        $html .= '</ul>';

        return $html;
    }

    // WordPress admin settings
    function smart_toc_admin_settings() {
        add_options_page(
            'Smart TOC Settings',
            'Smart TOC',
            'manage_options',
            'smart-toc-settings',
            'smart_toc_admin_settings_page'
        );
    }
    add_action('admin_menu', 'smart_toc_admin_settings');

    function smart_toc_admin_settings_page() {
        ?>
        <div class="wrap">
            <h1>Smart TOC Settings</h1>

            <form method="post" action="options.php">
                <?php settings_fields('smart_toc_settings'); ?>
                <?php do_settings_sections('smart-toc-settings'); ?>
                <input type="submit" class="button-primary" value="Save Settings">
            </form>
        </div>
        <?php
    }

    // Register settings
    function smart_toc_register_settings() {
        register_setting('smart_toc_settings', 'smart_toc_default_options', array(
            'type' => 'array',
            'default' => array(
                'min_level' => 2,
                'max_level' => 4,
                'show_numbers' => true,
                'show_icons' => true,
                'ai_analysis' => false,
                'default Expansion' => 'expanded',
            ),
            'sanitize_callback' => 'smart_toc_sanitize_settings'
        ));

        add_settings_section(
            'smart_toc_main_section',
            'Main Settings',
            'smart_toc_main_section_callback',
            'smart-toc-settings'
        );

        add_settings_field(
            'min_level',
            'Minimum Heading Level',
            'smart_toc_min_level_callback',
            'smart-toc-settings',
            'smart_toc_main_section',
            array(
                'label_for' => 'min_level',
                'description' => 'Set the minimum heading level to include in the table of contents (2 = h2, 3 = h3, etc.)'
            )
        );

        add_settings_field(
            'max_level',
            'Maximum Heading Level',
            'smart_toc_max_level_callback',
            'smart-toc-settings',
            'smart_toc_main_section',
            array(
                'label_for' => 'max_level',
                'description' => 'Set the maximum heading level to include (6 = h6)'
            )
        );

        add_settings_field(
            'show_numbers',
            'Show Numbers',
            'smart_toc_show_numbers_callback',
            'smart-toc-settings',
            'smart_toc_main_section',
            array(
                'label_for' => 'show_numbers',
                'description' => 'Display numbering for headings (1, 1.1, 1.1.1, etc.)'
            )
        );

        add_settings_field(
            'show_icons',
            'Show Icons',
            'smart_toc_show_icons_callback',
            'smart-toc-settings',
            'smart_toc_main_section',
            array(
                'label_for' => 'show_icons',
                'description' => 'Display icons for different heading levels'
            )
        );

        add_settings_field(
            'ai_analysis',
            'AI Analysis (Experimental)',
            'smart_toc_ai_analysis_callback',
            'smart-toc-settings',
            'smart_toc_main_section',
            array(
                'label_for' => 'ai_analysis',
                'description' => 'Enable AI-powered analysis to highlight important headings (simulated)'
            )
        );

        add_settings_field(
            'default_expansion',
            'Default Expansion',
            'smart_toc_default_expansion_callback',
            'smart-toc-settings',
            'smart_toc_main_section',
            array(
                'label_for' => 'default_expansion',
                'description' => 'Set default expansion state for the TOC'
            )
        );
    }
    add_action('admin_init', 'smart_toc_register_settings');

    function smart_toc_main_section_callback() {
        echo '<p>Configure the default settings for Smart TOC</p>';
    }

    function smart_toc_min_level_callback($args) {
        $options = get_option('smart_toc_default_options', array());
        $value = isset($options['min_level']) ? $options['min_level'] : 2;
        ?>
        <label for="<?php echo esc_attr($args['label_for']); ?>">
            <input type="number" id="<?php echo esc_attr($args['label_for']); ?>"
                   name="smart_toc_default_options[min_level]"
                   value="<?php echo esc_attr($value); ?>"
                   min="2" max="6"
                   class="small-text">
            <?php echo esc_html($args['description']); ?>
        </label>
        <?php
    }

    function smart_toc_max_level_callback($args) {
        $options = get_option('smart_toc_default_options', array());
        $value = isset($options['max_level']) ? $options['max_level'] : 4;
        ?>
        <label for="<?php echo esc_attr($args['label_for']); ?>">
            <input type="number" id="<?php echo esc_attr($args['label_for']); ?>"
                   name="smart_toc_default_options[max_level]"
                   value="<?php echo esc_attr($value); ?>"
                   min="2" max="6"
                   class="small-text">
            <?php echo esc_html($args['description']); ?>
        </label>
        <?php
    }

    function smart_toc_show_numbers_callback($args) {
        $options = get_option('smart_toc_default_options', array());
        $value = isset($options['show_numbers']) ? $options['show_numbers'] : true;
        ?>
        <label for="<?php echo esc_attr($args['label_for']); ?>">
            <input type="checkbox" id="<?php echo esc_attr($args['label_for']); ?>"
                   name="smart_toc_default_options[show_numbers]"
                   value="1"
                   <?php checked($value); ?>>
            <?php echo esc_html($args['description']); ?>
        </label>
        <?php
    }

    function smart_toc_show_icons_callback($args) {
        $options = get_option('smart_toc_default_options', array());
        $value = isset($options['show_icons']) ? $options['show_icons'] : true;
        ?>
        <label for="<?php echo esc_attr($args['label_for']); ?>">
            <input type="checkbox" id="<?php echo esc_attr($args['label_for']); ?>"
                   name="smart_toc_default_options[show_icons]"
                   value="1"
                   <?php checked($value); ?>>
            <?php echo esc_html($args['description']); ?>
        </label>
        <?php
    }

    function smart_toc_ai

// CelestialAmbiance - Advanced Day/Night Cycle with Atmospheric Tinting & Weather Effects
// Designed for RPG Maker MZ but runs standalone in Node.js
// Features: Smooth sky transitions, adaptive tinting, dynamic weather particles, and celestial events

const { TiledCanvas } = require("tiled-canvas"); // For in-browser/Node.js compatibility
const MathUtils = require("math-utils"); // Custom module for trigonometric helpers

// Configuration
const config = {
    cycleDuration: 24 * 60 * 1000, // 24h in ms
    time: 0, // Current time in ms (0 = midnight)
    sunPosition: { x: 0.5, y: 0.5 },
    moonPosition: { x: 0.5, y: 0.5 },
    weatherIntensity: 0.1,
    weatherTypes: ['rain', 'snow', 'fog', 'clear'],
    weatherTransitionSpeed: 0.05,
    ambientLight: { r: 0.2, g: 0.2, b: 0.4 },
    celestialEvents: [
        { time: 12 * 60 * 60 * 1000, event: 'sunrise', color: { r: 1, g: 0.8, b: 0.2 } },
        { time: 18 * 60 * 60 * 1000, event: 'sunset', color: { r: 1, g: 0.4, b: 0.2 } },
        { time: 2 * 60 * 60 * 1000, event: 'moonrise', color: { r: 0.8, g: 0.8, b: 1 } }
    ]
};

// Custom Math Utilities
const MathHelper = {
    radiansToDegrees: (rad) => rad * (180 / Math.PI),
    degreesToRadians: (deg) => deg * (Math.PI / 180),
    map: (value, inMin, inMax, outMin, outMax) => outMin + (outMax - outMin) * ((value - inMin) / (inMax - inMin)),
    // Simulate atmospheric scattering (Chandrasekhar's model simplified)
    getSkyTint: (sunAngle) => {
        const angle = MathHelper.map(sunAngle, -90, 90, 0, 1);
        const intensity = Math.sin(angle * Math.PI / 180) * 0.7 + 0.3;
        return {
            r: 0.2 + intensity * 0.5,
            g: 0.2 + intensity * 0.4,
            b: 0.4 + intensity * 0.6
        };
    },
    // Simulate sun/moon position based on time
    getCelestialPosition: (time, isMoon = false) => {
        const normalizedTime = (time / (config.cycleDuration / 2)) % 2; // 0-1 cycle
        const angle = normalizedTime * 360 - (isMoon ? 180 : 0);
        const deg = angle;
        return {
            x: 0.5 + Math.cos(MathHelper.degreesToRadians(deg)) * 0.4,
            y: 0.5 + Math.sin(MathHelper.degreesToRadians(deg)) * 0.4
        };
    }
};

// Weather System
const Weather = {
    currentType: 'clear',
    particles: [],
    update: (canvas, ctx) => {
        // Clear previous particles if transitioning
        if (Weather.currentType !== config.weatherTypes[0]) {
            Weather.particles = [];
        }

        // Random particle generation based on weather type
        const weather = config.weatherTypes[Math.floor(config.weatherIntensity * config.weatherTypes.length)];
        if (weather !== Weather.currentType) {
            Weather.currentType = weather;
        }

        const particleCount = 20 + Math.floor(Math.random() * 50);
        for (let i = 0; i < particleCount; i++) {
            Weather.particles.push({
                x: Math.random() * canvas.width,
                y: Math.random() * canvas.height,
                size: Math.random() * 3,
                speed: Math.random() * 2,
                type: Weather.currentType
            });
        }

        // Draw particles
        Weather.particles.forEach(particle => {
            ctx.beginPath();
            ctx.arc(particle.x, particle.y, particle.size, 0, Math.PI * 2);
            ctx.fillStyle = Weather.getParticleColor(particle.type);
            ctx.fill();
            ctx.closePath();

            // Update position
            particle.y += particle.speed * (Weather.currentType === 'snow' ? 0.5 : 1);
            if (particle.y > canvas.height + particle.size) {
                particle.y = -particle.size;
                particle.x = Math.random() * canvas.width;
            }
        });
    },
    getParticleColor: (type) => {
        switch (type) {
            case 'rain': return 'rgba(100, 180, 255, 0.6)';
            case 'snow': return 'rgba(255, 255, 255, 0.8)';
            case 'fog': return 'rgba(200, 220, 255, 0.3)';
            default: return 'transparent';
        }
    }
};

// Main Renderer
class CelestialRenderer {
    constructor(width, height) {
        this.canvas = new TiledCanvas(width, height);
        this.ctx = this.canvas.getContext();
        this.width = width;
        this.height = height;
        this.frameCount = 0;
        this.lastEventTime = 0;
    }

    update(time) {
        // Update celestial positions and time
        config.time = time;
        config.sunPosition = MathHelper.getCelestialPosition(time, false);
        config.moonPosition = MathHelper.getCelestialPosition(time, true);

        // Handle celestial events
        config.celestialEvents.forEach(event => {
            if (Math.abs(time - event.time) < 60000 && time > this.lastEventTime) { // 1 minute window
                this.lastEventTime = time;
                console.log(`Event triggered: ${event.event}`);
                // In RPG Maker, this would trigger an event or sound
            }
        });

        // Clear canvas with adaptive background
        this.ctx.clearRect(0, 0, this.width, this.height);

        // Draw sky gradient based on sun position
        const sunAngle = MathHelper.radiansToDegrees(
            Math.atan2(
                config.sunPosition.y - 0.5,
                config.sunPosition.x - 0.5
            )
        );

        const skyTint = MathHelper.getSkyTint(sunAngle);
        const topColor = `rgba(${skyTint.r * 255}, ${skyTint.g * 255}, ${skyTint.b * 255}, 0.8)`;
        const bottomColor = `rgba(${skyTint.r * 150}, ${skyTint.g * 150}, ${skyTint.b * 150}, 0.6)`;

        this.ctx.fillStyle = topColor;
        this.ctx.fillRect(0, 0, this.width, this.height / 2);

        this.ctx.fillStyle = bottomColor;
        this.ctx.fillRect(0, this.height / 2, this.width, this.height / 2);

        // Draw sun and moon (simplified as circles)
        this.drawSunMoon(config.sunPosition, 'yellow', 0.1);
        this.drawSunMoon(config.moonPosition, 'white', 0.08);

        // Update weather
        Weather.update(this.canvas, this.ctx);

        this.frameCount++;
    }

    drawSunMoon(position, color, size) {
        const x = position.x * this.width;
        const y = position.y * this.height;
        const radius = size * Math.min(this.width, this.height);

        this.ctx.beginPath();
        this.ctx.arc(x, y, radius, 0, Math.PI * 2);
        this.ctx.fillStyle = color;
        this.ctx.fill();
        this.ctx.closePath();
    }
}

// RPG Maker MZ Integration (when used in RM)
function initRMPlugin() {
    console.log("CelestialAmbiance initialized for RPG Maker MZ");
    return {
        name: "CelestialAmbiance",
        init: function() {
            // In RM, you'd hook into the game's time system
            // This is a simplified version for demonstration
            this._originalUpdate = Scene_Base.prototype.update;
            Scene_Base.prototype.update = function() {
                this._originalUpdate.call(this);
                if (this.isMap()) {
                    const renderer = new CelestialRenderer(1280, 720);
                    renderer.update(Date.now() % config.cycleDuration);
                }
            };
        }
    };
}

// For standalone Node.js execution
function main() {
    const width = 800;
    const height = 600;
    const renderer = new CelestialRenderer(width, height);

    // Simulate time progression
    let time = 0;
    const updateInterval = 1000 / 60; // 60 FPS

    function animate() {
        time = Date.now() % config.cycleDuration;
        renderer.update(time);
        requestAnimationFrame(animate);
    }

    animate();

    // Export PNG every 5 seconds for debugging
    setInterval(() => {
        renderer.canvas.png().then(png => {
            require('fs').writeFileSync(`celestial_${Math.floor(time / (config.cycleDuration / 24))}.png`, png);
        });
    }, 5000);
}

// Run if not in RM (Node.js standalone)
if (typeof window === 'undefined' && typeof process !== 'undefined') {
    main();
} else if (typeof RPGMAKER !== 'undefined') {
    initRMPlugin();
}

extends CharacterBody2D

@export var jump_velocity: float = -500.0
@export var gravity: float = 1500.0
@export var max_speed: float = 300.0
@export var acceleration: float = 20.0
@export var friction: float = 10.0
@export var celestial_mass: float = 0.8  # Affects movement inertia and collision
@export var trail_color: Color = Color(0.1, 0.8, 1.0, 0.3)
@export var trail_width: float = 2.0

private var trail_timer: Timer
private var current_gravity: float = 0.0
private var movement_vector: Vector2 = Vector2.ZERO

func _ready() -> void:
	if not Engine.is_2d:
		print("This script requires 2D mode!")
		return

	trail_timer = Timer.new()
	add_child(trail_timer)
	trail_timer.timeout.connect(_on_trail_timer_timeout)
	trail_timer.start(0.05)

	# Initialize with gravity facing down
	current_gravity = gravity

func _process(delta: float) -> void:
	# Smooth gravity transition
	if current_gravity != gravity:
		current_gravity = lerp(current_gravity, gravity, delta * 10.0)

	# Get input direction
	var input_dir = Input.get_vector("move_left", "move_right", "move_up", "move_down")
	if input_dir.length() > 0:
		movement_vector = input_dir.normalized()

	# Apply acceleration and friction
	var target_speed = movement_vector * max_speed
	var current_speed = velocity.length()

	if current_speed < target_speed:
		velocity = velocity.move_toward(target_speed * movement_vector, acceleration * delta)
	elif current_speed > target_speed:
		velocity = velocity.move_toward(target_speed * movement_vector, friction * delta)

	# Apply gravity
	if not is_on_floor():
		velocity.y += current_gravity * delta

	# Jump if on ground and pressing jump (with celestial mass effect)
	if is_on_floor() and Input.is_action_just_pressed("jump"):
		velocity.y = jump_velocity * (1.0 - celestial_mass * 0.5)
		# Visual feedback based on mass
		if celestial_mass > 0.5:
			$Trail2D.set_color(Color(trail_color.r, trail_color.g, trail_color.b, 0.6))
		else:
			$Trail2D.set_color(trail_color)

	# Celestial mass effect on velocity (simulates inertia)
	velocity *= 1.0 - celestial_mass * 0.02

	# Movement with momentum preservation
.move_and_slide()

func _on_trail_timer_timeout() -> void:
	if velocity.length() > 10:  # Only create trail when moving
		var trail = Trail2D.new()
		add_child(trail)
		trail.position = global_position
		trail.set_color(trail_color)
		trail.set_width(trail_width)
		trail.lifetime = 30  # Frames before disappearing
		queue_free()  # Remove the player's timer after creating trail

# Collision handling with celestial mass effect
func _on_body_entered(body: Body2D) -> void:
	if body.is_in_group("celestial_body"):
		# Mass-based collision response
		var combined_mass = celestial_mass + body.get("celestial_mass") or 0.5
		var repulsion = (1.0 - combined_mass) * 500.0
		apply_central_force(-velocity.normalized() * repulsion)
		body.apply_central_impulse(velocity.normalized() * repulsion)

		# Visual feedback
		if combined_mass > 1.0:
			$Trail2D.set_color(Color(0.0, 0.8, 1.0, 0.3))
		else:
			$Trail2D.set_color(Color(1.0, 0.8, 0.0, 0.3))

using UnityEngine;
using System.Collections.Generic;

[RequireComponent(typeof(Camera))]
[AddComponentMenu("Camera Control/Smoothonacci Follow")]
public class SmoothonacciCameraFollow : MonoBehaviour
{
    [Header("Fibonacci Smoothing Settings")]
    [SerializeField] private float fibonacciSmoothingStrength = 0.5f;
    [SerializeField] [Range(0, 1)] private float fibonacciTension = 0.3f;
    [SerializeField] private float fibonacciAcceleration = 1.05f;
    [SerializeField] private float minFibonacciVelocity = 0.1f;
    [SerializeField] private bool useFibonacciLag = true;
    [SerializeField] [Range(0, 1)] private float fibonacciLagFactor = 0.2f;

    [Header("Dynamic Control Settings")]
    [SerializeField] private float accelerationFactor = 1.5f;
    [SerializeField] private float decelerationFactor = 0.9f;
    [SerializeField] private float minVelocity = 0.1f;
    [SerializeField] private float maxVelocity = 5.0f;
    [SerializeField] private AnimationCurve velocityCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);

    [Header("Target Settings")]
    [SerializeField] private Transform target;
    [SerializeField] private Vector3 offset = new Vector3(0, 0, -5);
    [SerializeField] private bool smoothRotation = true;
    [SerializeField] [Range(0, 180)] private float rotationSmoothing = 15f;

    [Header("Advanced")]
    [SerializeField] private bool adaptiveFieldOfView = false;
    [SerializeField] [Range(0, 1)] private float fovAdaptationSpeed = 0.1f;
    [SerializeField] [Range(20, 120)] private float minFov = 30f;
    [SerializeField] [Range(20, 120)] private float maxFov = 100f;

    private Camera _camera;
    private Vector3 _velocity;
    private float _currentFibonacciValue;
    private float _currentFibonacciVelocity;
    private float _targetFibonacciValue;
    private float _fibonacciLagValue;
    private float _previousFibonacciValue;
    private float _fibonacciLagVelocity;
    private float _currentVelocity;
    private float _currentLerpedFibonacciValue;
    private float _timeSinceVelocityUpdate;

    private Queue<float> _fibonacciSequence = new Queue<float>();

    private void Awake()
    {
        _camera = GetComponent<Camera>();
        InitializeFibonacciSequence();
    }

    private void InitializeFibonacciSequence()
    {
        _fibonacciSequence.Clear();
        _fibonacciSequence.Enqueue(0);
        _fibonacciSequence.Enqueue(1);

        for (int i = 0; i < 10; i++)
        {
            float nextValue = _fibonacciSequence.Peek() + _fibonacciSequence.ElementAt(_fibonacciSequence.Count - 2);
            _fibonacciSequence.Enqueue(nextValue);
        }

        _currentFibonacciValue = 0;
        _targetFibonacciValue = 1;
        _previousFibonacciValue = 0;
        _fibonacciLagValue = 0;
        _fibonacciLagVelocity = 0;
    }

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

        HandleFibonacciSmoothing();
        HandleDynamicVelocity();
        UpdatePosition();
        UpdateRotation();

        if (adaptiveFieldOfView)
        {
            UpdateFieldOfView();
        }

        _timeSinceVelocityUpdate += Time.deltaTime;
    }

    private void HandleFibonacciSmoothing()
    {
        // Calculate target Fibonacci value based on distance
        float distanceToTarget = Vector3.Distance(transform.position, target.position);
        _targetFibonacciValue = Mathf.Clamp(distanceToTarget * 0.1f, 0.1f, 5f);

        // Fibonacci sequence calculation with acceleration
        _currentFibonacciValue += (_targetFibonacciValue - _currentFibonacciValue) * fibonacciSmoothingStrength * fibonacciAcceleration;
        _currentFibonacciValue = Mathf.Clamp(_currentFibonacciValue, 0, 5);

        // Fibonacci velocity calculation with tension
        float fibonacciDelta = _currentFibonacciValue - _previousFibonacciValue;
        _currentFibonacciVelocity = Mathf.Lerp(_currentFibonacciVelocity, fibonacciDelta, fibonacciTension);

        // Store previous value for next frame
        _previousFibonacciValue = _currentFibonacciValue;

        // Apply Fibonacci lag if enabled
        if (useFibonacciLag)
        {
            _fibonacciLagValue += (_currentFibonacciValue - _fibonacciLagValue) * fibonacciLagFactor;
            _fibonacciLagVelocity = (_fibonacciLagValue - _previousFibonacciValue) * 0.1f;
        }
    }

    private void HandleDynamicVelocity()
    {
        float targetVelocity = velocityCurve.Evaluate(_currentFibonacciValue / 5f) * maxVelocity;

        // Accelerate or decelerate based on Fibonacci velocity
        if (_currentFibonacciVelocity > minFibonacciVelocity)
        {
            _currentVelocity += (_currentFibonacciVelocity * accelerationFactor - _currentVelocity) * accelerationFactor * Time.deltaTime;
        }
        else
        {
            _currentVelocity += (minVelocity - _currentVelocity) * decelerationFactor * Time.deltaTime;
        }

        // Clamp velocity
        _currentVelocity = Mathf.Clamp(_currentVelocity, minVelocity, maxVelocity);

        // Add Fibonacci lag velocity contribution if needed
        if (useFibonacciLag)
        {
            _currentVelocity += _fibonacciLagVelocity * 0.5f;
        }
    }

    private void UpdatePosition()
    {
        if (target == null) return;

        Vector3 targetPosition = target.position + offset;
        Vector3 currentPosition = transform.position;

        // Calculate desired movement direction
        Vector3 direction = (targetPosition - currentPosition).normalized;

        // Apply Fibonacci-smoothed movement with dynamic velocity
        Vector3 movement = direction * _currentVelocity * Time.deltaTime;

        // Apply Fibonacci-based weighting to movement
        float fibonacciWeight = Mathf.Clamp01(_currentFibonacciValue / 2f);
        _currentLerpedFibonacciValue = Mathf.Lerp(_currentLerpedFibonacciValue, fibonacciWeight, 0.1f);
        movement *= _currentLerpedFibonacciValue;

        // Smooth movement with Fibonacci influence
        Vector3 smoothedMovement = Vector3.Lerp(currentPosition, currentPosition + movement, _currentFibonacciValue * 0.2f);
        transform.position = smoothedMovement;
    }

    private void UpdateRotation()
    {
        if (target == null || !smoothRotation) return;

        Vector3 direction = target.position - transform.position;
        direction = new Vector3(direction.x, 0, direction.z).normalized;

        if (direction != Vector3.zero)
        {
            Quaternion targetRotation = Quaternion.LookRotation(direction);
            transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, rotationSmoothing * Time.deltaTime);
        }
    }

    private void UpdateFieldOfView()
    {
        if (_camera == null) return;

        float fov = _camera.fieldOfView;
        float targetFov = Mathf.Lerp(minFov, maxFov, _currentFibonacciValue / 5f);
        fov = Mathf.Lerp(fov, targetFov, fovAdaptationSpeed * Time.deltaTime);
        _camera.fieldOfView = fov;
    }

    private void OnValidate()
    {
        fibonacciSmoothingStrength = Mathf.Clamp01(fibonacciSmoothingStrength);
        fibonacciTension = Mathf.Clamp01(fibonacciTension);
        fibonacciAcceleration = Mathf.Clamp(fibonacciAcceleration, 1.01f, 2f);
        fibonacciLagFactor = Mathf.Clamp01(fibonacciLagFactor);
        minFibonacciVelocity = Mathf.Clamp(minFibonacciVelocity, 0.01f, 1f);
        rotationSmoothing = Mathf.Clamp(rotationSmoothing, 0f, 180f);
        fovAdaptationSpeed = Mathf.Clamp01(fovAdaptationSpeed);
        minFov = Mathf.Clamp(minFov, 20f, 120f);
        maxFov = Mathf.Clamp(maxFov, 20f, 120f);
    }

    [ContextMenu("Reset Fibonacci Sequence")]
    private void ResetFibonacciSequence()
    {
        InitializeFibonacciSequence();
    }
}