A!leys Galerie

```php
<?php
/**
 * Plugin Name: Ailey's Dynamic Content Rotator
 * Description: Rotates content between categories, posts, or pages with unique styling elements.
 * Version: 1.0.0
 * Author: Ailey (KI)
 * License: GPL2
 * Text Domain: ailey-dynamic-rotator
 * Domain Path: /languages
 */

if (!defined('ABSPATH')) {
    exit; // Exit if accessed directly
}

class Ailey_Dynamic_Content_Rotator {
    private $options;
    private $chosen_cats;
    private $chosen_posts;
    private $chosen_pages;
    private $rotator_interval;
    private $active_style;

    public function __construct() {
        add_action('plugins_loaded', array($this, 'init'));
    }

    public function init() {
        // Load options
        $this->options = get_option('ailey_dynamic_rotator_settings', array(
            'rotator_interval' => 5,
            'active_style' => 'fade',
            'show_categories' => array(),
            'show_posts' => array(),
            'show_pages' => array(),
            'show_excerpts' => true,
            'show_full_content' => false,
            'show_thumbnails' => true,
            'thumbnail_size' => 'medium',
            'show_title' => true,
            'show_date' => false,
            'show_category_tags' => false,
            'transition_speed' => 500,
            'rotate_content' => true
        ));

        $this->chosen_cats = isset($this->options['show_categories']) ? $this->options['show_categories'] : array();
        $this->chosen_posts = isset($this->options['show_posts']) ? $this->options['show_posts'] : array();
        $this->chosen_pages = isset($this->options['show_pages']) ? $this->options['show_pages'] : array();
        $this->rotator_interval = isset($this->options['rotator_interval']) ? $this->options['rotator_interval'] : 5;
        $this->active_style = isset($this->options['active_style']) ? $this->options['active_style'] : 'fade';

        // Add admin menu
        add_action('admin_menu', array($this, 'add_admin_menu'));

        // Add shortcode
        add_shortcode('ailey_rotator', array($this, 'shortcode_function'));

        // Enqueue scripts and styles
        add_action('wp_enqueue_scripts', array($this, 'enqueue_assets'));
    }

    public function add_admin_menu() {
        add_options_page(
            'Ailey\'s Dynamic Content Rotator',
            'Ailey Rotator',
            'manage_options',
            'ailey-dynamic-rotator',
            array($this, 'admin_page')
        );
    }

    public function admin_page() {
        ?>
        <div class="wrap">
            <h1> <?php echo esc_html(get_admin_page_title()); ?> </h1>
            <form method="post" action="options.php">
                <?php
                settings_fields('ailey_dynamic_rotator_settings_group');
                do_settings_sections('ailey-dynamic-rotator-options');
                submit_button();
                ?>
            </form>
        </div>
        <?php
    }

    public function shortcode_function($atts) {
        $atts = shortcode_atts(array(
            'title' => 'Dynamic Content Rotator',
            'style' => $this->active_style,
            'interval' => $this->rotator_interval,
            'excerpts' => $this->options['show_excerpts'],
            'full_content' => $this->options['show_full_content'],
            'thumbnails' => $this->options['show_thumbnails'],
            'thumbnail_size' => $this->options['thumbnail_size'],
            'show_title' => $this->options['show_title'],
            'show_date' => $this->options['show_date'],
            'show_category_tags' => $this->options['show_category_tags'],
            'transition_speed' => $this->options['transition_speed'],
            'rotate' => $this->options['rotate_content']
        ), $atts);

        ob_start();
        $this->render_rotator($atts);
        return ob_get_clean();
    }

    public function render_rotator($atts) {
        $title = esc_html($atts['title']);
        $style = esc_attr($atts['style']);
        $interval = intval($atts['interval']);
        $excerpts = isset($atts['excerpts']) ? $atts['excerpts'] : true;
        $full_content = isset($atts['full_content']) ? $atts['full_content'] : false;
        $thumbnails = isset($atts['thumbnails']) ? $atts['thumbnails'] : true;
        $thumbnail_size = isset($atts['thumbnail_size']) ? $atts['thumbnail_size'] : 'medium';
        $show_title = isset($atts['show_title']) ? $atts['show_title'] : true;
        $show_date = isset($atts['show_date']) ? $atts['show_date'] : false;
        $show_category_tags = isset($atts['show_category_tags']) ? $atts['show_category_tags'] : false;
        $transition_speed = intval($atts['transition_speed']);
        $rotate = isset($atts['rotate']) ? $atts['rotate'] : true;

        // Get content to rotate
        $content_items = $this->get_content_items($excerpts, $full_content, $thumbnails, $thumbnail_size, $show_title, $show_date, $show_category_tags);

        if (empty($content_items)) {
            echo '<p>No content found to rotate.</p>';
            return;
        }

        // Start HTML
        echo '<div class="ailey-rotator" data-interval="' . $interval . '" data-transition-speed="' . $transition_speed . '" data-rotate="' . ($rotate ? 'true' : 'false') . '">';
        echo '<div class="ailey-rotator-title">' . $title . '</div>';
        echo '<div class="ailey-rotator-content">';

        // Output each item
        foreach ($content_items as $item) {
            echo '<div class="ailey-rotator-item">';
            if ($thumbnails) {
                echo '<div class="ailey-rotator-thumbnail">' . wp_get_attachment_image($item['featured_image'], $thumbnail_size) . '</div>';
            }
            echo '<div class="ailey-rotator-content-inner">';
            if ($show_title) {
                echo '<h3 class="ailey-rotator-item-title">' . esc_html($item['title']) . '</h3>';
            }
            if ($show_date) {
                echo '<div class="ailey-rotator-item-date">' . esc_html($item['date']) . '</div>';
            }
            if ($show_category_tags) {
                echo '<div class="ailey-rotator-item-categories">' . esc_html($item['categories']) . '</div>';
            }
            if ($excerpts) {
                echo '<div class="ailey-rotator-item-excerpt">' . wp_kses_post($item['excerpt']) . '</div>';
            } elseif ($full_content) {
                echo '<div class="ailey-rotator-item-content">' . wp_kses_post($item['content']) . '</div>';
            }
            echo '</div>';
            echo '</div>';
        }

        echo '</div>';
        echo '</div>';

        // Enqueue jQuery if not already enqueued
        if (!wp_script_is('jquery', 'enqueued')) {
            wp_enqueue_script('jquery');
        }
        wp_enqueue_script('ailey-rotator', plugins_url('js/rotator.js', __FILE__), array('jquery'), '1.0.0', true);
        wp_enqueue_style('ailey-rotator', plugins_url('css/rotator.css', __FILE__), array(), '1.0.0');
    }

    public function get_content_items($excerpts, $full_content, $thumbnails, $thumbnail_size, $show_title, $show_date, $show_category_tags) {
        $content_items = array();

        // Get posts from chosen categories
        if (!empty($this->chosen_cats)) {
            $args = array(
                'post_type' => 'post',
                'posts_per_page' => -1,
                'post_status' => 'publish',
                'orderby' => 'rand',
                'order' => 'ASC',
                'category__in' => $this->chosen_cats
            );
            $posts = get_posts($args);
            foreach ($posts as $post) {
                $content_items[] = $this->prepare_content_item($post, $excerpts, $full_content, $thumbnails, $thumbnail_size, $show_title, $show_date, $show_category_tags);
            }
        }

        // Get posts from chosen post IDs
        if (!empty($this->chosen_posts)) {
            $args = array(
                'post__in' => $this->chosen_posts,
                'posts_per_page' => -1,
                'post_status' => 'publish',
                'orderby' => 'rand',
                'order' => 'ASC'
            );
            $posts = get_posts($args);
            foreach ($posts as $post) {
                $content_items[] = $this->prepare_content_item($post, $excerpts, $full_content, $thumbnails, $thumbnail_size, $show_title, $show_date, $show_category_tags);
            }
        }

        // Get pages from chosen page IDs
        if (!empty($this->chosen_pages)) {
            $args = array(
                'post__in' => $this->chosen_pages,
                'posts_per_page' => -1,
                'post_status' => 'publish',
                'orderby' => 'rand',
                'order' => 'ASC'
            );
            $posts = get_posts($args);
            foreach ($posts as $post) {
                $content_items[] = $this->prepare_content_item($post, $excerpts, $full_content, $thumbnails, $thumbnail_size, $show_title, $show_date, $show_category_tags);
            }
        }

        return $content_items;
    }

    private function prepare_content_item($post, $excerpts, $full_content, $thumbnails, $thumbnail_size, $show_title, $show_date, $show_category_tags) {
        $item = array();

        $item['id'] = $post->ID;
        $item['title'] = $post->post_title;
        $item['date'] = $post->post_date;
        $item['categories'] = $this->get_post_categories($post->ID);
        $item['featured_image'] = $this->get_featured_image($post->ID, $thumbnail_size);

        if ($excerpts) {
            $item['excerpt'] = $post->post_excerpt ? $post->post_excerpt : get_the_excerpt($post->ID);
        } elseif ($full_content) {
            $item['content'] = $post->post_content;
        }

        return $item;
    }

    private function get_post_categories($post_id) {
        $categories = get_the_categories($post_id);
        if (empty($categories)) {
            return '';
        }
        $category_names = array();
        foreach ($categories as $category) {
            $category_names[] = $category->name;
        }
        return implode(', ', $category_names);
    }

    private function get_featured_image($post_id, $size) {
        $thumbnail_id = get_post_thumbnail_id($post_id);
        if ($thumbnail_id) {
            return $thumbnail_id;
        }
        return false;
    }

    public function enqueue_assets() {
        wp_enqueue_script('ailey-rotator', plugins_url('js/rotator.js', __FILE__), array('jquery'), '1.0.0', true);
        wp_enqueue_style('ailey-rotator', plugins_url('css/rotator.css', __FILE__), array(), '1.0.0');
    }
}

// Register settings
function register_ailey_rotator_settings() {
    register_setting('ailey_dynamic_rotator_settings_group', 'ailey_dynamic_rotator_settings', array($this, 'sanitize_settings'));

    add_settings_section('ailey_rotator_main', 'Main Settings', array($this, 'settings_section_callback'), 'ailey-dynamic-rotator-options');

    add_settings_field('rotator_interval', 'Rotator Interval (seconds)', array($this, 'rotator_interval_field'), 'ailey_rotator_main', 'ailey-dynamic-rotator-options');
    add_settings_field('active_style', 'Active Style', array($this, 'active_style_field'), 'ailey_rotator_main', 'ailey-dynamic-rotator-options');
    add_settings_field('show_excerpts', 'Show Excerpts', array($this, 'show_excerpts_field'), 'ailey_rotator_main', 'ailey-dynamic-rotator-options');
    add_settings_field('show_full_content', 'Show Full Content', array($this, 'show_full_content_field'), 'ailey_rotator_main', 'ailey-dynamic-rotator-options');
    add_settings_field('show_thumbnails', 'Show Thumbnails', array($this, 'show_thumbnails_field'), 'ailey_rotator_main', 'ailey-dynamic-rotator-options');
    add_settings_field('thumbnail_size', 'Thumbnail Size', array($this, 'thumbnail_size_field'), 'ailey_rotator_main', 'ailey-dynamic-rotator-options');
    add_settings_field('show_title', 'Show Title', array($this, 'show_title_field'), 'ailey_rotator_main', 'ailey-dynamic-rotator-options');
    add_settings_field('show_date', 'Show Date', array($this, 'show_date_field'), 'ailey_rotator_main', 'ailey-dynamic-rotator-options');
    add_settings_field('show_category_tags', 'Show Category Tags', array($this, 'show_category_tags_field'), 'ailey_rotator_main', 'ailey-dynamic-rotator-options');
    add_settings_field('transition_speed', 'Transition Speed (ms)', array($this, 'transition_speed_field'), 'ailey_rotator_main', 'ailey-dynamic-rotator-options');
    add_settings_field('rotate_content', 'Rotate Content', array($this, 'rotate_content_field'), 'ailey_rotator_main', 'ailey-dynamic-rotator-options');
}

function ailey_rotator_settings_section_callback() {
    echo '<p>Configure the dynamic content rotator settings.</p>';
}

function ailey_rotator_settings_fields_callback() {
    // This is a placeholder for additional fields if needed
}

function ailey_rotator_settings_page_callback() {
    // This is a placeholder for additional pages if needed
}

// Sanitize settings
function sanitize_settings($input) {
    $new_input = array();
    $new_input['rotator_interval'] = absint($input['rotator_interval']);
    $new_input['active_style'] = sanitize_text_field($input['active_style']);
    $new_input['show_excerpts'] = isset($input['show_excerpts']) ? (bool) $input['show_excerpts'] : true;
    $new_input['show_full_content'] = isset($input['show_full_content']) ? (bool) $input['show_full_content'] : false;
    $new_input['show_thumbnails'] = isset($input['show_thumbnails']) ? (bool) $input['show_thumbnails'] : true;
    $new_input['thumbnail_size'] = sanitize_text_field($input['thumbnail_size']);
    $new_input['show_title'] = isset($input['show_title']) ? (bool) $input['show_title'] : true;
    $new_input['show_date'] = isset($input['show_date']) ? (bool) $input['show_date'] : false;
    $new_input['show_category_tags'] = isset($input['show_category_tags']) ? (bool) $input['show_category_tags'] : false;
    $new_input['transition_speed'] = absint($input['transition_speed']);
    $new_input['rotate_content'] = isset($input['rotate_content']) ? (bool) $input['rotate_content'] : true;
    $new_input['show_categories'] = isset($input['show_categories']) ? array_map('absint', $input['show_categories']) : array();
    $new_input['show_posts'] = isset($input['show_posts']) ? array_map('absint', $input['show_posts']) : array();
    $new_input['show_pages'] = isset($input['show_pages']) ? array_map('absint', $input['show_pages']) : array();
    return $new_input;
}

// Field callbacks
function rotator_interval_field() {
    $options = get_option('ailey_dynamic_rotator_settings');
    ?>
    <input type="number" name="ailey_dynamic_rotator_settings[rotator_interval]" value="<?php echo esc_attr($options['rotator_interval']); ?>" min="1" step="1">
    <?php
}

function active_style_field() {
    $options = get_option('ailey_dynamic_rotator_settings');
    $styles = array('fade', 'slide', 'zoom', 'flip');
    ?>
    <select name="ailey_dynamic_rotator_settings[active_style]">
        <?php foreach ($styles as $style): ?>
            <option value="<?php echo esc_attr($style); ?>" <?php selected($options['active_style'], $style); ?>><?php echo ucfirst($style); ?></option>
        <?php endforeach; ?>
    </select>
    <?php
}

function show_excerpts_field() {
    $options = get_option('ailey_dynamic_rotator_settings');
    ?>

using UnityEngine;

[RequireComponent(typeof(Camera))]
[DisallowMultipleComponent]
public class QuantumSmoothFollow : MonoBehaviour
{
    [Header("Target Settings")]
    [SerializeField] private Transform _target;
    [SerializeField] private bool _followX = true;
    [SerializeField] private bool _followY = true;
    [SerializeField] private bool _followZ = true;
    [SerializeField] private bool _lockYAxis = false;
    [SerializeField] private float _yLockPosition = 0f;

    [Header("Quantum Smoothing")]
    [SerializeField] [Range(0f, 1f)] private float _quantumDamping = 0.75f;
    [SerializeField] [Range(0.1f, 5f)] private float _quantumAcceleration = 1.5f;
    [SerializeField] private float _quantumTolerance = 0.01f;
    [SerializeField] private bool _adaptiveSpeed = true;

    [Header("Dynamic Adjustments")]
    [SerializeField] [Range(0f, 1f)] private float _velocityScale = 0.5f;
    [SerializeField] private bool _smoothVelocityChanges = true;
    [SerializeField] [Range(0.01f, 0.5f)] private float _velocitySmoothing = 0.1f;

    private Vector3 _quantumVelocity;
    private Vector3 _lastTargetPosition;
    private float _currentDamping;
    private float _currentAcceleration;
    private float _currentTolerance;
    private bool _initialized = false;

    private void Start()
    {
        if (_target == null)
        {
            Debug.LogError("Quantum Smooth Follow: No target assigned!", this);
            enabled = false;
            return;
        }

        _lastTargetPosition = _target.position;
        _currentDamping = _quantumDamping;
        _currentAcceleration = _quantumAcceleration;
        _currentTolerance = _quantumTolerance;
        _initialized = true;
    }

    private void LateUpdate()
    {
        if (!_initialized || _target == null) return;

        // Calculate target position with axis locking
        Vector3 targetPosition = _target.position;
        if (!_followX) targetPosition.x = transform.position.x;
        if (!_followY) targetPosition.y = transform.position.y;
        if (!_followZ) targetPosition.z = transform.position.z;

        if (_lockYAxis) targetPosition.y = _yLockPosition;

        // Get target velocity if adaptive speed is enabled
        Vector3 targetVelocity = Vector3.zero;
        if (_adaptiveSpeed && _target.GetComponent<Rigidbody>() != null)
        {
            targetVelocity = _target.GetComponent<Rigidbody>().velocity;
        }

        // Apply velocity scaling if needed
        if (_adaptiveSpeed)
        {
            float speedFactor = _velocityScale * Mathf.Clamp01(Mathf.Abs(targetVelocity.magnitude) / 10f);
            _currentDamping = Mathf.Lerp(_quantumDamping, 0.2f, speedFactor);
            _currentAcceleration = Mathf.Lerp(_quantumAcceleration, 0.1f, speedFactor);
            _currentTolerance = Mathf.Lerp(_quantumTolerance, 0.001f, speedFactor);
        }

        // Quantum-inspired interpolation
        Vector3 direction = targetPosition - transform.position;
        float distance = direction.magnitude;

        if (distance > _currentTolerance)
        {
            // Smooth velocity changes
            if (_smoothVelocityChanges)
            {
                _quantumVelocity = Vector3.Lerp(_quantumVelocity, direction * _currentAcceleration, _velocitySmoothing);
            }
            else
            {
                _quantumVelocity = direction * _currentAcceleration;
            }

            // Apply damping with quantum-style decay
            _quantumVelocity *= Mathf.Pow(1f - _currentDamping, Time.deltaTime * 10f);
            transform.position += _quantumVelocity * Time.deltaTime;
        }
        else
        {
            // Snap to target when close enough (with quantum-style "jitter" for uniqueness)
            transform.position = targetPosition + Random.insideUnitSphere * 0.001f;
            _quantumVelocity = Vector3.zero;
        }

        // Update last position for velocity calculation
        _lastTargetPosition = targetPosition;
    }

    // Visualization in scene view
    private void OnDrawGizmosSelected()
    {
        if (_target == null) return;

        Gizmos.color = Color.cyan;
        Gizmos.DrawLine(transform.position, _target.position);

        Gizmos.color = Color.yellow;
        Gizmos.DrawSphere(transform.position + _quantumVelocity, 0.1f);
    }
}

// CelestialWeatherGenerator.js - A dynamic weather/particle effect system for RPG Maker MZ
// Runs as a standalone Node.js script that generates RPG Maker MZ plugin-compatible weather/particle JSON data

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

// Configuration - Adjust these values to create different celestial effects
const CELestiAL_CONFIG = {
    name: "CosmicAuroraBorealis",
    description: "A dynamic aurora borealis effect with twinkling stars and solar flares",
    particleCount: 1500,
    maxParticleSize: 12,
    minParticleSize: 3,
    spread: 1500,
    life: 60,
    blendMode: 1, // Additive blending for glow effect
    animation: true,
    animationFrames: 30,
    animationSpeed: 2,
    colorRange: {
        top: [255, 20, 255],    // Magenta (adjustable)
        bottom: [50, 20, 255],  // Deep purple
        middle: [150, 50, 255]  // Lavender
    },
    starDensity: 0.02,          // Percentage of particles that will be stars (2%)
    starSizeRange: [4, 8],       // Size range for star particles
    flareFrequency: 0.05,        // 5% chance for solar flare particles
    flareSize: 20,
    flareDuration: 30,
    baseSpeed: 0.3,
    randomness: 0.2,
    gravity: 0.05,
    rotation: true,
    rotationSpeed: 0.05
};

// Helper function to generate random color between two ranges
function generateGradientColor(progress, top, bottom, middle) {
    const segment = progress * 3;

    if (segment < 1) {
        // Top segment (0-1/3) - Magenta to Lavender
        const ratio = segment / (1/3);
        return [
            top[0] + (middle[0] - top[0]) * ratio,
            top[1] + (middle[1] - top[1]) * ratio,
            top[2] + (middle[2] - top[2]) * ratio
        ];
    } else if (segment < 2) {
        // Middle segment (1/3-2/3) - Lavender to Deep Purple
        const ratio = (segment - 1/3) / (1/3);
        return [
            middle[0] + (bottom[0] - middle[0]) * ratio,
            middle[1] + (bottom[1] - middle[1]) * ratio,
            middle[2] + (bottom[2] - middle[2]) * ratio
        ];
    } else {
        // Bottom segment (2/3-1) - Deep Purple to Magenta (cycle back)
        const ratio = (segment - 2/3) / (1/3);
        return [
            bottom[0] + (top[0] - bottom[0]) * ratio,
            bottom[1] + (top[1] - bottom[1]) * ratio,
            bottom[2] + (top[2] - bottom[2]) * ratio
        ];
    }
}

// Generate solar flare effect particles (larger, brighter particles)
function generateFlareParticles(totalCount, config) {
    return Array.from({length: Math.floor(totalCount * config.flareFrequency)}, (_, i) => ({
        x: (Math.random() - 0.5) * config.spread,
        y: (Math.random() - 0.5) * config.spread - 500, // Position above screen
        size: config.flareSize,
        life: config.flareDuration,
        color: [255, 150, 255],
        opacity: 0.8,
        blendMode: 1,
        speedX: (Math.random() - 0.5) * config.baseSpeed * 3,
        speedY: -Math.random() * config.baseSpeed * 2 - 1,
        accelerationX: 0,
        accelerationY: config.gravity,
        rotation: Math.random() * Math.PI * 2,
        scaleX: 1,
        scaleY: 1,
        angle: 0,
        isStar: false
    }));
}

// Main particle generation function
function generateParticles(config) {
    const particles = [];

    for (let i = 0; i < config.particleCount; i++) {
        const progress = i / config.particleCount;
        const color = generateGradientColor(progress, ...config.colorRange);
        const isStar = Math.random() < config.starDensity;
        const size = isStar ?
            Math.floor(Math.random() * (config.starSizeRange[1] - config.starSizeRange[0] + 1)) + config.starSizeRange[0] :
            Math.floor(Math.random() * (config.maxParticleSize - config.minParticleSize + 1)) + config.minParticleSize;

        particles.push({
            x: (Math.random() - 0.5) * config.spread,
            y: (Math.random() - 0.5) * config.spread - 500, // Start above the screen
            size: size,
            life: config.life,
            color: isStar ? [255, 255, 255] : color,
            opacity: isStar ? 0.9 : 0.7,
            blendMode: config.blendMode,
            speedX: (Math.random() - 0.5) * config.baseSpeed + config.baseSpeed * 0.5,
            speedY: (Math.random() - 0.5) * config.baseSpeed * 0.5 - 1,
            accelerationX: (Math.random() - 0.5) * config.randomness,
            accelerationY: config.gravity,
            rotation: config.rotation ? Math.random() * Math.PI * 2 : 0,
            scaleX: 1,
            scaleY: 1,
            angle: 0,
            isStar: isStar,
            animation: config.animation ? {
                frames: config.animationFrames,
                speed: config.animationSpeed,
                currentFrame: 0
            } : null
        });
    }

    // Add solar flares
    const flares = generateFlareParticles(config.particleCount, config);
    return [...particles, ...flares];
}

// Generate RPG Maker MZ plugin metadata
function generatePluginMetadata(config, particles) {
    return {
        "name": config.name,
        "description": config.description,
        "author": "Ailey (CelestialWeatherGenerator)",
        "version": "1.0.0",
        "type": "weatherParticles",
        "parameters": {
            "particleCount": config.particleCount,
            "maxParticleSize": config.maxParticleSize,
            "minParticleSize": config.minParticleSize,
            "spread": config.spread,
            "life": config.life,
            "blendMode": config.blendMode,
            "starDensity": config.starDensity,
            "flareFrequency": config.flareFrequency,
            "baseSpeed": config.baseSpeed,
            "randomness": config.randomness,
            "gravity": config.gravity,
            "rotation": config.rotation
        },
        "data": {
            "particles": particles,
            "timing": {
                "start": 0,
                "duration": 99999, // Infinite duration
                "repeat": false
            },
            "animation": config.animation,
            "colorRange": config.colorRange
        }
    };
}

// Generate the complete plugin JSON
function generatePluginJSON(config) {
    const particles = generateParticles(config);
    const pluginData = generatePluginMetadata(config, particles);

    return JSON.stringify(pluginData, null, 2);
}

// Main execution
function main() {
    try {
        // Generate the plugin data
        const pluginJSON = generatePluginJSON(CELestiAL_CONFIG);

        // Determine output filename
        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
        const outputFilename = `CelestialWeather_${timestamp}.json`;

        // Write to file
        fs.writeFileSync(path.join(__dirname, outputFilename), pluginJSON);

        console.log(`✨ Celestial Weather Generator - Success!`);
        console.log(`📁 Output saved to: ${path.join(__dirname, outputFilename)}`);
        console.log(`🌌 Generated: ${CELestiAL_CONFIG.particleCount} particles with ${Math.floor(CELestiAL_CONFIG.particleCount * CELestiAL_CONFIG.starDensity)} stars`);
        console.log(`🔥 Solar flare frequency: ${CELestiAL_CONFIG.flareFrequency * 100}%`);
        console.log(`\n💡 Tip: Import this JSON into RPG Maker MZ as a weather/particle plugin.`);
    } catch (error) {
        console.error(`❌ Error generating celestial weather:`, error);
    }
}

// Run the generator
main();

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Pool;

[ExecuteInEditMode]
public class QuantumParticlePool : MonoBehaviour, IPartition<QuantumParticle>
{
    [SerializeField] private ParticleSystem renderTemplate;
    [SerializeField] private int initialPoolSize = 10;
    [SerializeField] private float creationProbability = 0.3f;
    [SerializeField] private Color activeColor = Color.cyan;
    [SerializeField] private Color inactiveColor = Color.gray;

    private readonly List<QuantumParticle> _activeParticles = new List<QuantumParticle>();
    private readonly Queue<QuantumParticle> _inactiveQueue = new Queue<QuantumParticle>();

    private int _partitionId;

    private void Awake()
    {
        if (renderTemplate == null)
        {
            Debug.LogError("Render template not assigned!", this);
            return;
        }

        _partitionId = GetHashCode();

        // Create initial pool
        for (int i = 0; i < initialPoolSize; i++)
        {
            SpawnParticle();
        }
    }

    private void Update()
    {
        if (Application.isPlaying)
        {
            // Entangle particles with quantum probability
            if (UnityEngine.Random.value < creationProbability)
            {
                var particle = GetParticle();
                if (particle != null)
                {
                    particle.Activate();
                }
            }
        }
    }

    private QuantumParticle SpawnParticle()
    {
        var particle = new QuantumParticle();
        particle.Initialize(renderTemplate, _partitionId, this);
        _inactiveQueue.Enqueue(particle);
        return particle;
    }

    public QuantumParticle GetParticle()
    {
        if (_inactiveQueue.Count > 0)
        {
            var particle = _inactiveQueue.Dequeue();
            _activeParticles.Add(particle);
            particle.Activate();
            return particle;
        }

        if (UnityEngine.Random.value < 0.1f) // 10% chance to create new if pool is empty
        {
            var newParticle = SpawnParticle();
            _activeParticles.Add(newParticle);
            newParticle.Activate();
            return newParticle;
        }

        return null;
    }

    public void ReturnParticle(QuantumParticle particle)
    {
        if (_activeParticles.Contains(particle))
        {
            _activeParticles.Remove(particle);
        }

        particle.Deactivate();
        _inactiveQueue.Enqueue(particle);
    }

    public void ReleaseAll()
    {
        foreach (var particle in _activeParticles)
        {
            ReturnParticle(particle);
        }
        _activeParticles.Clear();
    }

    #region IPartition Implementation

    public QuantumParticle Acquire()
    {
        return GetParticle();
    }

    public void Release(QuantumParticle element)
    {
        ReturnParticle(element);
    }

    public int Count => _inactiveQueue.Count;

    #endregion

    [Serializable]
    public class QuantumParticle : IDisposable
    {
        private ParticleSystem _renderTemplate;
        private ParticleSystem _instance;
        private int _partitionId;
        private QuantumParticlePool _owner;

        public bool IsActive => _instance != null && _instance.gameObject.activeSelf;

        public void Initialize(ParticleSystem template, int partitionId, QuantumParticlePool owner)
        {
            _renderTemplate = template;
            _partitionId = partitionId;
            _owner = owner;
        }

        public void Activate()
        {
            if (_instance == null || !_instance.gameObject.activeSelf)
            {
                _instance = Object.Instantiate(_renderTemplate);
                _instance.gameObject.SetActive(true);
                _instance.gameObject.transform.SetParent(transform, true);
                _instance.GetComponent<Renderer>().material.color = activeColor;
                _instance.Play();
            }
        }

        public void Deactivate()
        {
            if (_instance != null && _instance.gameObject.activeSelf)
            {
                _instance.Stop();
                _instance.gameObject.SetActive(false);
                _instance.GetComponent<Renderer>().material.color = inactiveColor;
            }
        }

        public void Dispose()
        {
            Deactivate();
            if (_instance != null)
            {
                Object.Destroy(_instance.gameObject);
                _instance = null;
            }
        }
    }
}

extends Control
class_name MagicalCraftingInventory

# Export variables for easy configuration in the Godot editor
@export var slot_size: Vector2 = Vector2(64, 64)
@export var grid_spacing: int = 10
@export var inventory_size: Vector2i = Vector2i(4, 4)
@export var animation_duration: float = 0.3
@export var crafting_sound: AudioStream = null
@export var success Effect: AnimationPlayer = null
@export var failure Effect: AnimationPlayer = null

# Internal variables
var slots: Array[InventorySlot] = []
var items: Dictionary = {}
var selected_slot: InventorySlot = null
var drag_offset: Vector2 = Vector2.ZERO
var is_dragging: bool = false
var hover_slot: InventorySlot = null
var hover_item: Item = null

# Called when the node enters the scene tree for the first time.
func _ready():
	if success Effect and failure Effect:
		success Effect.play("success")
		failure Effect.play("failure")

	# Initialize the inventory grid
	initialize_slots()

	# Add some example items to test the inventory
	add_example_items()

# Initialize the grid of inventory slots
func initialize_slots():
	slots.clear()

	for i in range(inventory_size.x):
		for j in range(inventory_size.y):
			var slot = InventorySlot.new()
			slot.position = Vector2(i * (slot_size.x + grid_spacing), j * (slot_size.y + grid_spacing))
			slot.size = slot_size
			slot.item_id = -1  # -1 means empty
			slot.connect("item_dropped", self, "_on_slot_item_dropped")
			slot.connect("item_hover_enter", self, "_on_slot_item_hover_enter")
			slot.connect("item_hover_exit", self, "_on_slot_item_hover_exit")

			add_child(slot)
			slots.append(slot)

# Add example items to test the inventory
func add_example_items():
	# Clear existing items
	for slot in slots:
		slot.item_id = -1

	# Add some basic ingredients
	add_item(0, "fire_ingredient", "Fire Essence", "res://icons/fire.png")
	add_item(1, "water_ingredient", "Water Essence", "res://icons/water.png")
	add_item(2, "earth_ingredient", "Earth Essence", "res://icons/earth.png")
	add_item(3, "air_ingredient", "Air Essence", "res://icons/air.png")

	# Place them in specific slots
	for i in range(4):
		if slots.size() > i:
			slots[i].item_id = i

# Add a new item to the inventory
func add_item(item_id: int, name: String, display_name: String, icon_path: String):
	if items.has(item_id):
		return

	var item = Item.new()
	item.id = item_id
	item.name = name
	item.display_name = display_name
	item.icon_path = icon_path
	item.crafting_recipe = null  # Will be set later if this item can be crafted

	items[item_id] = item

# Remove an item from the inventory
func remove_item(item_id: int):
	if items.has(item_id):
		items.remove(item_id)
		for slot in slots:
			if slot.item_id == item_id:
				slot.item_id = -1

# Get an item by ID
func get_item(item_id: int) -> Item:
	return items.get(item_id, null)

# Craft a potion using two ingredients (special feature)
func craft_potion(ingredient1: Item, ingredient2: Item) -> Item:
	var crafted_potion = Item.new()
	crafted_potion.id = -1  # Temporary ID, will be unique
	crafted_potion.name = f"{ingredient1.display_name} + {ingredient2.display_name}"
	crafted_potion.display_name = "Potion of " + crafted_potion.name
	crafted_potion.icon_path = "res://icons/potion.png"

	# Set a simple crafting recipe (could be expanded)
	crafted_potion.crafting_recipe = {
		"ingredients": [ingredient1.name, ingredient2.name],
		"effect": f"Mixes {ingredient1.display_name} and {ingredient2.display_name} to create a powerful potion",
		"stat_boost": get_random_boost()  # Random stat boost for fun
	}

	# Play crafting sound if available
	if crafting_sound:
		var audio_node = AudioStreamPlayer.new()
		audio_node.stream = crafting_sound
		audio_node.play()
		add_child(audio_node)
		audio_node.queue_free()

	# Play success animation
	if success Effect:
		success Effect.play("success")

	return crafted_potion

# Helper function to get a random stat boost
func get_random_boost() -> float:
	var boosts = [0.1, 0.2, 0.3, 0.4, 0.5]
	return boosts[randi() % boosts.size()]

# Called every frame. Don't place heavy logic here.
func _process(delta):
	if is_dragging:
		var global_mouse_pos = get_global_mouse_position()
		var slot_pos = global_mouse_pos - drag_offset

		# Update the hover slot if the mouse is over one
		for slot in slots:
			if slot.get_rect().has_point(slot_pos):
				hover_slot = slot
			elif hover_slot == slot:
				hover_slot = null

		# Handle dropping the item
		if Input.is_action_just_released("ui_accept"):
			if hover_slot and hover_slot != selected_slot:
				# Attempt to craft if two different ingredients are hovered
				if selected_slot and hover_slot and selected_slot.item_id != hover_slot.item_id and selected_slot.item_id != -1 and hover_slot.item_id != -1:
					var item1 = get_item(selected_slot.item_id)
					var item2 = get_item(hover_slot.item_id)
					if item1 and item2:
						# Craft the potion
						var potion = craft_potion(item1, item2)
						# Replace the hovered slot with the potion
						hover_slot.item_id = potion.id
						selected_slot.item_id = -1  # Consume the ingredients
						items[potion.id] = potion
						success Effect.play("success")
					else:
						failure Effect.play("failure")
				else:
					# Normal drag and drop
					hover_slot.item_id = selected_slot.item_id
					selected_slot.item_id = -1
			selected_slot = null
			is_dragging = false
			hover_slot = null
			hover_item = null

# Handle mouse input for drag and drop
func _input(event):
	if event is InputEventMouseButton:
		if event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
			for slot in slots:
				if slot.get_rect().has_point(event.position):
					selected_slot = slot
					if selected_slot.item_id != -1:
						drag_offset = selected_slot.get_global_rect().position - event.position
						is_dragging = true
						hover_slot = null
						hover_item = get_item(selected_slot.item_id)
						break
		elif event.released and event.button_index == MOUSE_BUTTON_LEFT:
			if is_dragging:
				is_dragging = false
				selected_slot = null
				drag_offset = Vector2.ZERO

# Private function to handle item being dropped on a slot
func _on_slot_item_dropped(slot: InventorySlot):
	if is_dragging and slot == hover_slot:
		# Handle the drop logic here (called from the slot)
		pass

# Private function to handle item hover enter
func _on_slot_item_hover_enter(slot: InventorySlot):
	if is_dragging and slot == hover_slot:
		# Change cursor to indicate potential crafting
		get_viewport().get_toplevel().set_mouse_default_cursor(CursorType.CRAFT)

# Private function to handle item hover exit
func _on_slot_item_hover_exit(slot: InventorySlot):
	if is_dragging:
		get_viewport().get_toplevel().set_mouse_default_cursor(CursorType.ARROW)

# InventorySlot class (nested inside MagicalCraftingInventory)
class_name InventorySlot extends Control:
	signal item_dropped(slot: InventorySlot)
	signal item_hover_enter(slot: InventorySlot)
	signal item_hover_exit(slot: InventorySlot)

	var item_id: int = -1  # -1 means empty

	func _ready():
		# Configure the slot appearance
		self.min_size = slot_size
		self.mouse_filter = MOUSE_FILTER_PASS
		self.connect("mouse_entered", self, "_on_mouse_entered")
		self.connect("mouse_exited", self, "_on_mouse_exited")

	# Called when a slot is clicked or interacted with
	func _input(event):
		if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
			if item_id != -1:
				emit_signal("item_dropped", self)

	# Called when the mouse enters the slot
	func _on_mouse_entered():
		if slot_size.x > 0 and slot_size.y > 0:
			emit_signal("item_hover_enter", self)

	# Called when the mouse exits the slot
	func _on_mouse_exited():
		emit_signal("item_hover_exit", self)

# Item class (nested inside MagicalCraftingInventory)
class_name Item:
	var id: int
	var name: String
	var display_name: String
	var icon_path: String
	var crafting_recipe: Dictionary = {}

<?php
/**
 * Plugin Name: Dynamic Emoji Shortcode Generator
 * Description: Generates context-aware emoji shortcodes with mood detection. Works for WordPress and Joomla.
 * Version: 1.0
 * Author: Ailey
 * License: GPL2
 */

// Define constants to detect the platform
if (function_exists('get_bloginfo')) {
    // WordPress detection
    define('PLATFORM', 'wordpress');
    define('SHORTCODE_NAME', 'dynamic_emoji');
    define('PLUGIN_DIR', plugin_dir_path(__FILE__));
} elseif (defined('JPATH_BASE')) {
    // Joomla detection
    define('PLATFORM', 'joomla');
    define('SHORTCODE_NAME', 'jdynamic_emoji');
    define('PLUGIN_DIR', JPATH_PLUGINS . '/system');
} else {
    die('This plugin must be installed in WordPress or Joomla.');
}

// Mood detection simulation (for fun!)
function detect_mood($text) {
    $moods = [
        'happy' => ['happy', 'joy', 'love', 'smile'],
        'sad' => ['sad', 'angry', 'cry', 'frown'],
        'excited' => ['excited', 'surprise', 'wow'],
        'neutral' => ['ok', 'neutral', 'meh']
    ];

    $lowerText = strtolower($text);
    foreach ($moods as $mood => $keywords) {
        if (preg_match('/\b(' . implode('|', $keywords) . ')\b/', $lowerText)) {
            return $mood;
        }
    }
    return 'neutral';
}

// Emoji mappings based on context and mood
function get_emoji_for_context($mood, $context = '') {
    $context = strtolower($context);
    $emojis = [
        'happy' => [
            'time_morning' => '🌞',
            'time_afternoon' => '🌤️',
            'time_evening' => '🌙',
            'time_night' => '🌜',
            'date_weekend' => '🎉',
            'user_login' => '👑',
            'default' => '😊'
        ],
        'sad' => [
            'time_morning' => '🌅',
            'time_afternoon' => '☁️',
            'time_evening' => '🌃',
            'time_night' => '🌌',
            'date_weekend' => '😢',
            'user_login' => '👑',
            'default' => '😔'
        ],
        'excited' => [
            'time_morning' => '🌄',
            'time_afternoon' => '🌞',
            'time_evening' => '🌅',
            'time_night' => '🌌',
            'date_weekend' => '🎊',
            'user_login' => '👑',
            'default' => '😃'
        ],
        'neutral' => [
            'time_morning' => '☀️',
            'time_afternoon' => '☀️',
            'time_evening' => '🌃',
            'time_night' => '🌌',
            'date_weekend' => '🎆',
            'user_login' => '👑',
            'default' => '😌'
        ]
    ];

    // Determine time context
    $hour = date('H');
    $timeContext = ($hour >= 5 && $hour < 12) ? 'time_morning' :
                  (($hour >= 12 && $hour < 17) ? 'time_afternoon' :
                  (($hour >= 17 && $hour < 21) ? 'time_evening' : 'time_night'));

    // Determine weekend context
    $day = date('N'); // 1 (Monday) through 7 (Sunday)
    $dateContext = ($day == 6 || $day == 7) ? 'date_weekend' : '';

    // Get user login name if available
    $user_login = '';
    if (PLATFORM === 'wordpress') {
        global $wpdb;
        $user = wp_get_current_user();
        $user_login = !empty($user->user_login) ? $user->user_login : '';
    } elseif (PLATFORM === 'joomla') {
        $user = JFactory::getUser();
        $user_login = !empty($user->username) ? $user->username : '';
    }

    // Build context string for matching
    $contextString = $dateContext ? $dateContext : ($timeContext ? $timeContext : '');

    // Return emoji based on mood and context
    if (isset($emojis[$mood][$contextString])) {
        return $emojis[$mood][$contextString];
    } elseif (isset($emojis[$mood]['default'])) {
        return $emojis[$mood]['default'];
    } else {
        return '😐';
    }
}

// Shortcode handler
function dynamic_emoji_shortcode($atts) {
    // Parse shortcode attributes
    $atts = shortcode_atts([
        'text' => '',
        'mood' => 'neutral'
    ], $atts);

    // Detect mood if not provided
    if ($atts['mood'] === 'auto') {
        $atts['mood'] = detect_mood($atts['text']);
    }

    // Get the appropriate emoji
    $emoji = get_emoji_for_context($atts['mood'], $atts['text']);

    // Return the emoji or wrapped in text
    if (empty($atts['text'])) {
        return $emoji;
    } else {
        return $atts['text'] . ' ' . $emoji;
    }
}

// WordPress implementation
if (PLATFORM === 'wordpress') {
    add_shortcode(SHORTCODE_NAME, 'dynamic_emoji_shortcode');

    // Add admin menu for settings (placeholder)
    add_action('admin_menu', function() {
        add_options_page('Dynamic Emoji Settings', 'Emoji Settings', 'manage_options', 'dynamic-emoji-settings', function() {
            echo '<div class="wrap"><h1>Dynamic Emoji Settings</h1><p>Configure emoji behavior here.</p></div>';
        });
    });
}

// Joomla implementation
if (PLATFORM === 'joomla') {
    // Register plugin
    function onDynamicEmojiAfterRender($context, $output, $params) {
        $output = preg_replace_callback('/\[jdynamic_emoji(.*?)\]/', function($matches) {
            $atts = [];
            if (!empty($matches[1])) {
                $attsString = trim($matches[1]);
                if (strpos($attsString, '=') !== false) {
                    parse_str($attsString, $atts);
                }
            }
            $atts = shortcode_atts([
                'text' => '',
                'mood' => 'neutral'
            ], $atts);

            if ($atts['mood'] === 'auto') {
                $atts['mood'] = detect_mood($atts['text']);
            }

            $emoji = get_emoji_for_context($atts['mood'], $atts['text']);

            if (empty($atts['text'])) {
                return $emoji;
            } else {
                return $atts['text'] . ' ' . $emoji;
            }
        }, $output);
        return $output;
    }

    // Add plugin to content after render
    JPluginHelper::registerPlugin('system', 'jdynamic_emoji');
    JEventDispatcher::addListener('onContentAfterDisplay', array(__CLASS__, 'onDynamicEmojiAfterRender'));
}

import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import java.util.*

@Composable
fun ZenPomodoroApp() {
    MaterialTheme {
        val context = LocalContext.current
        var isRunning by remember { mutableStateOf(false) }
        var currentTime by remember { mutableStateOf(25 * 60) } // 25 minutes in seconds
        var workSessions by remember { mutableStateOf(0) }
        var theme by remember { mutableStateOf(Theme.AQUA) }
        var soundEnabled by remember { mutableStateOf(true) }

        Column(
            modifier = Modifier
                .fillMaxSize()
                .padding(16.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {
            // Timer Display with Pulse Effect
            TimerDisplay(
                currentTime = currentTime,
                isRunning = isRunning,
                onTimeChanged = { newTime -> currentTime = newTime }
            )

            // Energy Indicator
            EnergyIndicator(
                workSessions = workSessions,
                modifier = Modifier.padding(vertical = 16.dp)
            )

            // Theme Selector
            ThemeSelector(
                currentTheme = theme,
                onThemeChange = { newTheme -> theme = newTheme }
            )

            // Control Buttons
            Row(
                modifier = Modifier.padding(top = 16.dp),
                horizontalArrangement = Arrangement.spacedBy(8.dp)
            ) {
                Button(
                    onClick = {
                        if (!isRunning) {
                            currentTime = 25 * 60
                            isRunning = true
                            GlobalScope.launch(Dispatchers.Main) {
                                while (isRunning && currentTime > 0) {
                                    delay(1000)
                                    currentTime--
                                }
                                if (isRunning) {
                                    playSound("session_complete", context)
                                    workSessions++
                                    if (workSessions % 4 == 0) {
                                        currentTime = 15 * 60 // Long break after 4 work sessions
                                    } else {
                                        currentTime = 5 * 60 // Short break
                                    }
                                }
                            }
                        }
                    }
                ) {
                    Icon(Icons.Default.PlayArrow, contentDescription = "Start")
                }

                Button(
                    onClick = {
                        if (isRunning) {
                            isRunning = false
                        } else {
                            playSound("click", context)
                        }
                    }
                ) {
                    if (isRunning) {
                        Icon(Icons.Default.Pause, contentDescription = "Pause")
                    } else {
                        Icon(Icons.Default.Reset, contentDescription = "Reset")
                    }
                }

                Button(
                    onClick = {
                        isRunning = false
                        currentTime = 25 * 60
                        workSessions = 0
                        playSound("click", context)
                    }
                ) {
                    Icon(Icons.Default.Stop, contentDescription = "Stop")
                }
            }

            // Sound Toggle
            Switch(
                checked = soundEnabled,
                onCheckedChange = { soundEnabled = it },
                modifier = Modifier.padding(top = 16.dp)
            )
            Text(
                text = if (soundEnabled) "Sounds ON" else "Sounds OFF",
                color = if (soundEnabled) Color.Black else MaterialTheme.colorScheme.onSurface.copy(alpha = 0.5f)
            )
        }
    }
}

@Composable
fun TimerDisplay(currentTime: Int, isRunning: Boolean, onTimeChanged: (Int) -> Unit) {
    var timeString by remember { mutableStateOf(formatTime(currentTime)) }
    val animatedTime by remember { derivedStateOf { formatTime(currentTime) } }

    // Animate time transition
    LaunchedEffect(animatedTime) {
        if (animatedTime != timeString) {
            timeString = animatedTime
        }
    }

    // Pulse effect for the timer text
    AnimatedVisibility(
        visible = isRunning,
        enteringExpansion = ExpandVertical(),
        exitingExpansion = ShrinkVertical()
    ) {
        Box(
            modifier = Modifier
                .size(200.dp)
                .clip(CircleShape)
                .background(
                    if (isRunning) {
                        MaterialTheme.colorScheme.primary.copy(alpha = 0.2f)
                    } else {
                        MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.2f)
                    }
                ),
            contentAlignment = Alignment.Center
        ) {
            Text(
                text = timeString,
                fontSize = 48.sp,
                color = MaterialTheme.colorScheme.onSurface,
                style = MaterialTheme.typography.headlineMedium
            )
        }
    }

    // Progress Ring
    Box(
        modifier = Modifier.size(200.dp),
        contentAlignment = Alignment.Center
    ) {
        Canvas(modifier = Modifier.size(200.dp)) {
            val progress = if (isRunning && currentTime > 0) {
                1.0 - (currentTime.toFloat() / (25 * 60f))
            } else {
                0f
            }

            drawCircle(
                color = MaterialTheme.colorScheme.primary,
                radius = size.minDimension / 2,
                style = Stroke(width = 8.dp.toPx())
            )

            drawArc(
                color = MaterialTheme.colorScheme.secondary,
                startAngle = -90f,
                sweep = 360 * progress,
                useCenter = true,
                style = Stroke(width = 8.dp.toPx()),
                size = Size(size.minDimension, size.minDimension)
            )
        }
    }
}

@Composable
fun EnergyIndicator(workSessions: Int, modifier: Modifier = Modifier) {
    val maxEnergy = 100
    val currentEnergy = workSessions * 10.coerceAtMost(maxEnergy)

    Column(
        modifier = modifier,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(
            text = "Energy Level",
            style = MaterialTheme.typography.labelLarge
        )

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

        Box(
            modifier = Modifier
                .fillMaxWidth()
                .height(12.dp)
                .clip(CircleShape)
                .background(MaterialTheme.colorScheme.surfaceVariant)
        ) {
            Box(
                modifier = Modifier
                    .fillMaxWidth(currentEnergy / maxEnergy.toFloat())
                    .fillMaxHeight()
                    .clip(CircleShape)
                    .background(
                        when (workSessions % 3) {
                            0 -> Color(0xFF8BC34A) // Green for fresh energy
                            1 -> Color(0xFFFFC107) // Yellow for medium energy
                            else -> Color(0xFFFF5722) // Orange for low energy
                        }
                    )
            )
        }

        Text(
            text = "${currentEnergy}/100",
            style = MaterialTheme.typography.bodySmall,
            modifier = Modifier.padding(top = 4.dp)
        )
    }
}

enum class Theme(val name: String, val background: Color, val primary: Color, val secondary: Color) {
    AQUA("Aqua", Color(0xFFE3F2FD), Color(0xFF0277BD), Color(0xFF2196F3)),
    DUSK("Dusk", Color(0xFF121212), Color(0xFFBB86FC), Color(0xFF303F9F)),
    VERDE("Verde", Color(0xFFE8F5E9), Color(0xFF4CAF50), Color(0xFF8BC34A)),
    COTTON("Cotton", Color(0xFFFFF9C4), Color(0xFFFF9800), Color(0xFFFFC107))
}

@Composable
fun ThemeSelector(currentTheme: Theme, onThemeChange: (Theme) -> Unit) {
    Text(
        text = "Theme: ${currentTheme.name}",
        style = MaterialTheme.typography.titleMedium,
        modifier = Modifier.padding(bottom = 8.dp)
    )

    Row(
        horizontalArrangement = Arrangement.spacedBy(4.dp),
        modifier = Modifier.fillMaxWidth()
    ) {
        Theme.colors.forEach { theme ->
            Box(
                modifier = Modifier
                    .size(40.dp)
                    .clip(CircleShape)
                    .background(theme.primary)
                    .clickable { onThemeChange(theme) },
                contentAlignment = Alignment.Center
            ) {
                Text(
                    text = theme.name.take(1).uppercase(),
                    color = MaterialTheme.colorScheme.onPrimary,
                    fontSize = 12.sp,
                    style = MaterialTheme.typography.bodySmall
                )
            }
        }
    }
}

fun formatTime(seconds: Int): String {
    val minutes = seconds / 60
    val remainingSeconds = seconds % 60
    return "${minutes.toString().padStart(2, '0')}:${remainingSeconds.toString().padStart(2, '0')}"
}

fun playSound(soundName: String, context: Context) {
    if (!soundEnabled) return

    val soundId = when (soundName) {
        "session_complete" -> R.raw.session_complete
        else -> R.raw.click
    }

    val sound = RingtoneManager.getRingtone(context, soundId.toLong())
    sound?.play()
}

@Preview(showBackground = true)
@Composable
fun PreviewZenPomodoro() {
    ZenPomodoroApp()
}