A!leys Galerie

using UnityEngine;

[RequireComponent(typeof(Camera))]
public class DynamicCameraSmoother : MonoBehaviour
{
    [Header("Target Reference")]
    [SerializeField] private Transform _target; // The object the camera will follow
    [SerializeField] private Vector2 _offset = new Vector2(0f, 0f); // Offset from the target

    [Header("Smoothing Settings")]
    [SerializeField] [Min(0.01f)] private float _baseSmoothTime = 0.2f; // Base smoothing time
    [SerializeField] [Range(0f, 1f)] private float _dampingVariation = 0.5f; // How much the smoothing varies based on target velocity
    [SerializeField] [Min(0.01f)] private float _velocityThreshold = 0.5f; // Velocity above which damping is reduced for snappier follow

    [Header("Dynamic Radius")]
    [SerializeField] private float _minRadius = 2f; // Minimum distance from target
    [SerializeField] private float _maxRadius = 8f; // Maximum distance from target
    [SerializeField] [Range(0f, 1f)] private float _radiusLagFactor = 0.3f; // How quickly the radius adapts to movement

    [Header("Boundary Constraints")]
    [SerializeField] private Vector2 _boundaryMin = Vector2.zero; // Minimum boundary for camera positioning
    [SerializeField] private Vector2 _boundaryMax = Vector2.zero; // Maximum boundary for camera positioning

    private Vector3 _velocity = Vector3.zero;
    private float _currentSmoothTime;
    private float _targetRadius;

    private void Awake()
    {
        if (_target == null)
        {
            Debug.LogError("No target assigned to DynamicCameraSmoother!", this);
            enabled = false;
        }
        else
        {
            _currentSmoothTime = _baseSmoothTime;
            _targetRadius = Mathf.Clamp(_minRadius, _minRadius, _maxRadius);
        }
    }

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

        // Calculate target velocity magnitude (2D)
        float targetVelocity = _target.GetComponent<Rigidbody2D>()?.velocity.magnitude ?? 0f;
        float velocityFactor = Mathf.Clamp01(targetVelocity / _velocityThreshold);
        _currentSmoothTime = Mathf.Lerp(_baseSmoothTime, _baseSmoothTime * (1f - _dampingVariation), velocityFactor);

        // Dynamically adjust radius based on target movement and camera's own movement
        float targetMovement = Mathf.Abs(_target.position.x - transform.position.x);
        _targetRadius = Mathf.Lerp(_targetRadius, Mathf.Clamp(targetMovement * (1f + _radiusLagFactor), _minRadius, _maxRadius), Time.deltaTime * 10f);

        // Calculate target position with dynamic radius and offset
        Vector3 targetPosition = _target.position + _offset;
        Vector3 smoothedPosition = Vector3.SmoothDamp(transform.position, targetPosition, ref _velocity, _currentSmoothTime);

        // Apply boundary constraints
        smoothedPosition.x = Mathf.Clamp(smoothedPosition.x, _boundaryMin.x, _boundaryMax.x);
        smoothedPosition.y = Mathf.Clamp(smoothedPosition.y, _boundaryMin.y, _boundaryMax.y);

        // Apply dynamic radius as z-position (for 2D camera, this sets the distance)
        smoothedPosition.z = _targetRadius;

        transform.position = smoothedPosition;
    }

    // Optional: Expose a method to manually set the target (useful for level transitions)
    public void SetTarget(Transform newTarget)
    {
        _target = newTarget;
        if (_target != null)
        {
            _currentSmoothTime = _baseSmoothTime;
            _targetRadius = Mathf.Clamp(_minRadius, _minRadius, _maxRadius);
        }
    }
}

#!/usr/bin/env node

// ChromaSort - File Organizer with Colorful Folders
// Organizes files by their first character's color theme (dark/light) and creates emoji-named folders

import fs from 'fs/promises';
import path from 'path';
import { fileURLToPath } from 'url';
import { execSync } from 'child_process';

// Convert ESM __filename to CJS __filename equivalent
const __dirname = path.dirname(fileURLToPath(import.meta.url));

// Color theme detection based on first character
function getColorTheme(firstChar) {
    // Simple color theme detection (dark: low lightness, light: high lightness)
    const charCode = firstChar.charCodeAt(0);
    const lightness = (charCode % 256) / 255; // Normalized to 0-1
    return lightness > 0.5 ? 'light' : 'dark';
}

// Get emoji name based on color theme and first letter
function getEmojiFolderName(firstChar, theme) {
    const baseEmojis = {
        light: ['🌞', '☀️', '🌇', '🌅', '🌈', '🌃', '🌙'],
        dark: ['🌌', '🌒', '🌠', '🌌', '🌑', '🌓', '🌔']
    };

    const index = firstChar.charCodeAt(0) % baseEmojis[theme].length;
    return `${baseEmojis[theme][index]}${firstChar.toUpperCase()}`;
}

// Main function to organize files
async function organizeFiles(directory = process.cwd()) {
    try {
        // Check if directory exists
        await fs.access(directory);
        console.log(`📂 Starting organization in: ${directory}`);

        const files = await fs.readdir(directory);
        const filesWithPaths = await Promise.all(
            files.map(async (file) => {
                const filePath = path.join(directory, file);
                const stat = await fs.stat(filePath);
                return {
                    name: file,
                    path: filePath,
                    size: stat.size,
                    isDirectory: stat.isDirectory()
                };
            })
        );

        const fileItems = filesWithPaths.filter(item => !item.isDirectory);

        if (fileItems.length === 0) {
            console.log('❌ No files found in the directory.');
            return;
        }

        console.log(`✅ Found ${fileItems.length} files to organize.`);

        // Process each file
        for (const item of fileItems) {
            const firstChar = item.name.charAt(0);
            const theme = getColorTheme(firstChar);
            const folderName = getEmojiFolderName(firstChar, theme);
            const folderPath = path.join(directory, folderName);

            try {
                // Check if folder exists, if not create it
                try {
                    await fs.access(folderPath);
                } catch {
                    await fs.mkdir(folderPath, { recursive: true });
                    console.log(`📁 Created folder: ${folderName}`);
                }

                // Move file to the folder
                const destPath = path.join(folderPath, item.name);
                await fs.rename(item.path, destPath);
                console.log(`📄 Moved: ${item.name} → ${folderName}/`);
            } catch (err) {
                console.error(`❌ Error processing ${item.name}:`, err.message);
            }
        }

        console.log('\n🎨 Organization complete! Files are now sorted by color theme.');
    } catch (err) {
        console.error('❌ Error:', err.message);
        process.exit(1);
    }
}

// Check if a directory was provided as argument
const targetDir = process.argv[2] || process.cwd();
if (!fs.existsSync(targetDir)) {
    console.error('❌ Target directory does not exist.');
    process.exit(1);
}

// Make the script executable on Unix-like systems
if (process.platform !== 'win32') {
    try {
        fs.chmodSync(__filename, 0o755);
    } catch (e) {
        // Ignore if already executable
    }
}

// Run the organizer
organizeFiles(targetDir).catch(console.error);

extends Control

class_name: "SorceryCraftInventory"

# @export variables for easy tweaking in the editor
@export var ingredient_scene_path: PackedScene = null  # Path to the ingredient item scene
@export var potion_scene_path: PackedScene = null      # Path to the potion container scene
@export var grid_spacing: int = 50                      # Spacing between grid items
@export var max_ingredients: int = 12                  # Maximum ingredients in the inventory
@export var brew_duration: float = 2.0                  # Time to brew a potion
@export var particle_scene_path: PackedScene = null     # Path to the particle effect scene

# Variables to track the inventory and brewing
var inventory_items: Array = []
var brewing_items: Array = []
var current_potion: Node2D = null
var brew_timer: float = 0.0
var is_brewing: bool = false
var particles: Array = []

# Callbacks for when a potion is successfully brewed
var on_potion_brewed_callback: Callable = null

# The grid layout container
var grid: GridContainer = $GridContainer

# _ready() initializes the inventory with default ingredients
func _ready():
    if ingredient_scene_path.is_connected("root_path") and potion_scene_path.is_connected("root_path"):
        # Add some default ingredients to the inventory
        var default_ingredients = [
            {"name": "Mana Root", "color": Color(0.2, 0.5, 0.2), "effect": "heal"},
            {"name": "Frostbite Flower", "color": Color(0.5, 0.8, 1.0), "effect": "slow"},
            {"name": "Fire Lotus", "color": Color(1.0, 0.3, 0.3), "effect": "burn"},
            {"name": "Void Shard", "color": Color(0.2, 0.2, 0.2), "effect": "poison"}
        ]

        for ingredient in default_ingredients:
            add_ingredient(ingredient["name"], ingredient["color"], ingredient["effect"])

        # Setup the brewing area
        setup_brewing_area()

# _process() handles the brewing timer and particle effects
func _process(delta: float):
    if is_brewing:
        brew_timer += delta
        update_brew_visuals()

        if brew_timer >= brew_duration:
            finish_brewing()

# Adds an ingredient to the inventory with drag-and-drop functionality
func add_ingredient(name: String, color: Color, effect: String):
    if inventory_items.size() >= max_ingredients:
        push_error("Inventory is full!")
        return

    var ingredient = ingredient_scene_path.instantiate()
    ingredient.name = name
    ingredient.set("color", color)
    ingredient.set("effect", effect)

    # Setup drag and drop signals
    ingredient.set("drag_started", true)
    ingredient.connect("input_event", _on_ingredient_input_event)
    ingredient.connect("item_dropped", _on_item_dropped)

    inventory_items.append(ingredient)
    grid.add_child(ingredient)
    grid.set_cell_left_margin(ingredient, 1)
    grid.set_cell_top_margin(ingredient, 1)

# Sets up the brewing area with particle effects
func setup_brewing_area():
    var brewing_area = $BrewingArea
    if brewing_area:
        brewing_area.connect("input_event", _on_brewing_area_input_event)
    else:
        push_error("BrewingArea node not found!")

# Handles input events for ingredients (drag and drop)
func _on_ingredient_input_event(view: InputEvent, item: Node):
    if view is InputEventDragStart:
        item.set("drag_started", true)
        item.move_to_global_position(get_global_mouse_position())
    elif view is InputEventMouseButton and view.pressed:
        item.set("drag_started", false)

# Handles when an item is dropped in the brewing area
func _on_item_dropped(item: Node):
    if not is_brewing and not brewing_items.has(item):
        brewing_items.append(item)
        item.set_position($BrewingArea.get_global_position())
        start_brew_animation()
    elif is_brewing:
        push_warning("Can't add more items while brewing!")

# Starts the brewing process with visual effects
func start_brew_animation():
    is_brewing = true
    brew_timer = 0.0

    # Create particle effects
    for _ in range(5):
        var particle = particle_scene_path.instantiate()
        particle.position = $BrewingArea.get_global_position()
        particle.set("lifetime", 1.0)
        add_child(particle)
        particles.append(particle)

    # Play brewing sound (if available)
    if $BrewingArea.has_method("play_brew_sound"):
        $BrewingArea.play_brew_sound()

# Updates the visuals during brewing
func update_brew_visuals():
    var progress = brew_timer / brew_duration
    var brewing_area = $BrewingArea

    # Update particle effects (pulse with brew progress)
    for particle in particles:
        particle.position = brewing_area.get_global_position() + Vector2.rand() * 50 * (1.0 - progress)
        particle.set("speed", Vector2(0, 200 * progress))

    # Update the potion's appearance (if it exists)
    if current_potion:
        current_potion.set("brew_progress", progress)

# Finishes brewing and creates a potion
func finish_brewing():
    is_brewing = false
    brew_timer = 0.0
    particles.clear()

    # Remove all particles
    for particle in particles:
        particle.queue_free()

    # Create a potion with combined effects
    var potion = potion_scene_path.instantiate()
    potion.position = $BrewingArea.get_global_position() + Vector2(0, 50)

    # Combine effects (simple logic for demo)
    var combined_effect = "basic"
    var combined_color = Color.WHITE

    for item in brewing_items:
        if item.get("effect") == "heal":
            combined_effect = "heal"
            combined_color = Color.GREEN
        elif item.get("effect") == "slow" and combined_effect != "heal":
            combined_effect = "slow"
            combined_color = Color.BLUE
        elif item.get("effect") == "burn" and combined_effect != "heal":
            combined_effect = "burn"
            combined_color = Color.RED
        elif item.get("effect") == "poison" and combined_effect != "heal":
            combined_effect = "poison"
            combined_color = Color.PURPLE

    potion.set("effect", combined_effect)
    potion.set("color", combined_color)

    # Add the potion to the scene and clean up
    get_parent().add_child(potion)
    current_potion = potion

    # Reset brewing items
    brewing_items.clear()

    # Trigger callback if set
    if on_potion_brewed_callback:
        on_potion_brewed_callback.call(potion)

    # Play success sound (if available)
    if $BrewingArea.has_method("play_brew_success_sound"):
        $BrewingArea.play_brew_success_sound()

# Callbacks for external use
func set_on_potion_brewed(callback: Callable):
    on_potion_brewed_callback = callback

```php
<?php
/**
 * Plugin Name: Ailey's Dynamic Background Changer
 * Plugin URI: https://ailey.dev
 * Description: Dynamically changes background images with KI-inspired patterns and animations. Supports WordPress and Joomla.
 * Version: 1.0.0
 * Author: Ailey
 * Author URI: https://ailey.dev
 * License: GPL-2.0+
 * Text Domain: ailey-dynamic-bg
 * Domain Path: /languages
 * WC requires: >= 5.0
 */

// Define constants to avoid direct path access
if (!defined('AILEY_DYNAMIC_BG_PATH')) {
    define('AILEY_DYNAMIC_BG_PATH', __DIR__);
}

// Check if WordPress is active
if (function_exists('is_wordpress')) {
    // WordPress implementation
    require_once(AILEY_DYNAMIC_BG_PATH . '/wp/ailey-dynamic-bg-wordpress.php');
} // Check if Joomla is active
elseif (defined('JPATH_BASE') && file_exists(JPATH_BASE . '/administrator')) {
    // Joomla implementation
    require_once(AILEY_DYNAMIC_BG_PATH . '/joomla/ailey-dynamic-bg-joomla.php');
} else {
    wp_die('Ailey\'s Dynamic Background Changer requires WordPress or Joomla to be installed.');
}

// WordPress directory structure
if (!file_exists(AILEY_DYNAMIC_BG_PATH . '/wp')) {
    mkdir(AILEY_DYNAMIC_BG_PATH . '/wp', 0755, true);
}

// Joomla directory structure
if (!file_exists(AILEY_DYNAMIC_BG_PATH . '/joomla')) {
    mkdir(AILEY_DYNAMIC_BG_PATH . '/joomla', 0755, true);
}

// Ensure CSS is enqueued globally
function ailey_dynamic_bg_enqueue_assets() {
    wp_enqueue_style('ailey-dynamic-bg', plugins_url('assets/css/dynamic-bg.css', __FILE__), array(), '1.0.0');
    wp_enqueue_script('ailey-dynamic-bg', plugins_url('assets/js/dynamic-bg.js', __FILE__), array('jquery'), '1.0.0', true);
}
add_action('wp_enqueue_scripts', 'ailey_dynamic_bg_enqueue_assets');

// Generate dynamic background with KI-inspired patterns
function ailey_generate_ki_background($settings) {
    // Simulate KI-generated pattern with noise and colors
    $pattern = imagecreatetruecolor(100, 100);
    $bgColor = hex2rgb($settings['background_color']);
    imagefill($pattern, 0, 0, $bgColor['r'], $bgColor['g'], $bgColor['b']);

    // Add noise-based pattern (simulated KI effect)
    for ($i = 0; $i < 1000; $i++) {
        $x = rand(0, 99);
        $y = rand(0, 99);
        $color = hex2rgb($settings['primary_color']);
        imagesetpixel($pattern, $x, $y, $color['r'], $color['g'], $color['b']);
    }

    // Add subtle gradient
    $grad = imagecreatetruecolor(100, 100);
    for ($y = 0; $y < 100; $y++) {
        $color1 = hex2rgb($settings['background_color']);
        $color2 = hex2rgb($settings['secondary_color']);
        $interpolated = imagecolorallocate($grad, $color1['r'], $color1['g'], $color1['b']);
        imagefill($grad, 0, $y, $interpolated);
    }

    // Combine and output as data URL
    ob_start();
    imagepng($pattern);
    $data = base64_encode(ob_get_clean());
    return 'data:image/png;base64,' . $data;
}

// Helper to convert hex to RGB
function hex2rgb($hex) {
    $hex = str_replace('#', '', $hex);
    return [
        'r' => hexdec(substr($hex, 0, 2)),
        'g' => hexdec(substr($hex, 2, 2)),
        'b' => hexdec(substr($hex, 4, 2))
    ];
}

// Main function to apply dynamic background
function ailey_apply_dynamic_background($settings) {
    if (empty($settings)) return '';
    $background = ailey_generate_ki_background($settings);

    $output = <<<HTML
    <style>
        .ailey-dynamic-bg {
            background-image: url({$background});
            background-size: cover;
            background-position: center;
            background-attachment: fixed;
            opacity: 0.8;
            transition: opacity 0.5s ease;
        }
        .ailey-dynamic-bg:hover {
            opacity: 0.9;
        }
    </style>
    <div class="ailey-dynamic-bg" style="position: fixed; top: 0; left: 0; width: 100%; height: 100%; z-index: -1;"></div>
    HTML;
    return $output;
}

// WordPress-specific implementation
if (function_exists('is_wordpress')) {
    // Widget class
    class Ailey_Dynamic_Bg_Widget extends WP_Widget {
        public function __construct() {
            parent::__construct(
                'ailey_dynamic_bg_widget',
                __('Ailey\'s Dynamic Background Changer', 'ailey-dynamic-bg'),
                array('description' => __('Dynamically changes background with KI-inspired patterns.', 'ailey-dynamic-bg'))
            );
        }

        public function widget($args, $instance) {
            $settings = get_field('ailey_dynamic_bg_settings', 'options');
            if (!$settings) return;

            echo $args['before_widget'];
            echo ailey_apply_dynamic_background($settings);
            echo $args['after_widget'];
        }

        public function form($instance) {
            $settings = wp_parse_args($instance, array(
                'background_color' => '#ffffff',
                'primary_color' => '#000000',
                'secondary_color' => '#333333',
                'animation' => 'none',
            ));
            ?>
            <p>
                <label for="<?php echo $this->get_field_id('background_color'); ?>"><?php _e('Background Color:', 'ailey-dynamic-bg'); ?></label>
                <input class="widefat" id="<?php echo $this->get_field_id('background_color'); ?>" name="<?php echo $this->get_field_name('background_color'); ?>" value="<?php echo esc_attr($settings['background_color']); ?>" type="color">
            </p>
            <p>
                <label for="<?php echo $this->get_field_id('primary_color'); ?>"><?php _e('Primary Color:', 'ailey-dynamic-bg'); ?></label>
                <input class="widefat" id="<?php echo $this->get_field_id('primary_color'); ?>" name="<?php echo $this->get_field_name('primary_color'); ?>" value="<?php echo esc_attr($settings['primary_color']); ?>" type="color">
            </p>
            <p>
                <label for="<?php echo $this->get_field_id('secondary_color'); ?>"><?php _e('Secondary Color:', 'ailey-dynamic-bg'); ?></label>
                <input class="widefat" id="<?php echo $this->get_field_id('secondary_color'); ?>" name="<?php echo $this->get_field_name('secondary_color'); ?>" value="<?php echo esc_attr($settings['secondary_color']); ?>" type="color">
            </p>
            <p>
                <label for="<?php echo $this->get_field_id('animation'); ?>"><?php _e('Animation:', 'ailey-dynamic-bg'); ?></label>
                <select id="<?php echo $this->get_field_id('animation'); ?>" name="<?php echo $this->get_field_name('animation'); ?>" class="widefat">
                    <option value="none" <?php selected($settings['animation'], 'none'); ?>><?php _e('None', 'ailey-dynamic-bg'); ?></option>
                    <option value="subtle" <?php selected($settings['animation'], 'subtle'); ?>><?php _e('Subtle Motion', 'ailey-dynamic-bg'); ?></option>
                    <option value="vibrant" <?php selected($settings['animation'], 'vibrant'); ?>><?php _e('Vibrant', 'ailey-dynamic-bg'); ?></option>
                </select>
            </p>
            <?php
        }

        public function update($new_instance, $old_instance) {
            return $new_instance;
        }
    }

    // Register widget
    add_action('widgets_init', function() {
        register_widget('Ailey_Dynamic_Bg_Widget');
    });

    // Admin settings page
    add_action('admin_menu', function() {
        add_options_page(
            'Ailey\'s Dynamic Background Changer',
            'Dynamic Background Settings',
            'manage_options',
            'ailey-dynamic-bg-settings',
            'ailey_dynamic_bg_admin_page'
        );
    });

    function ailey_dynamic_bg_admin_page() {
        if (!current_user_can('manage_options')) return;
        $settings = get_option('ailey_dynamic_bg_settings', array(
            'background_color' => '#ffffff',
            'primary_color' => '#000000',
            'secondary_color' => '#333333',
            'animation' => 'none',
        ));

        if (isset($_POST['ailey_dynamic_bg_save'])) {
            update_option('ailey_dynamic_bg_settings', $_POST['ailey_dynamic_bg_settings']);
            add_action('admin_notices', function() {
                echo '<div class="notice notice-success is-dismissible"><p>Settings saved!</p></div>';
            });
        }

        ?>
        <div class="wrap">
            <h1>Dynamic Background Settings</h1>
            <form method="post" action="">
                <table class="form-table">
                    <tr>
                        <th><label for="background_color">Background Color</label></th>
                        <td>
                            <input type="color" name="ailey_dynamic_bg_settings[background_color]" id="background_color" value="<?php echo esc_attr($settings['background_color']); ?>">
                        </td>
                    </tr>
                    <tr>
                        <th><label for="primary_color">Primary Color</label></th>
                        <td>
                            <input type="color" name="ailey_dynamic_bg_settings[primary_color]" id="primary_color" value="<?php echo esc_attr($settings['primary_color']); ?>">
                        </td>
                    </tr>
                    <tr>
                        <th><label for="secondary_color">Secondary Color</label></th>
                        <td>
                            <input type="color" name="ailey_dynamic_bg_settings[secondary_color]" id="secondary_color" value="<?php echo esc_attr($settings['secondary_color']); ?>">
                        </td>
                    </tr>
                    <tr>
                        <th><label for="animation">Animation</label></th>
                        <td>
                            <select name="ailey_dynamic_bg_settings[animation]" id="animation">
                                <option value="none" <?php selected($settings['animation'], 'none'); ?>>None</option>
                                <option value="subtle" <?php selected($settings['animation'], 'subtle'); ?>>Subtle Motion</option>
                                <option value="vibrant" <?php selected($settings['animation'], 'vibrant'); ?>>Vibrant</option>
                            </select>
                        </td>
                    </tr>
                </table>
                <?php wp_nonce_field('ailey_dynamic_bg_save'); ?>
                <input type="hidden" name="ailey_dynamic_bg_save" value="1">
                <p class="submit">
                    <input type="submit" class="button button-primary" value="Save Settings">
                </p>
            </form>
        </div>
        <?php
    }
}

// Joomla-specific implementation
if (defined('JPATH_BASE') && file_exists(JPATH_BASE . '/administrator')) {
    // Joomla plugin class
    class plgSystemAileyDynamicBg extends JPlugin {
        public function onAfterRender() {
            $app = JFactory::getApplication();
            if ($app->isSite()) {
                $document = JFactory::getDocument();
                $settings = $this->getSettings();

                if ($settings) {
                    $document->addStyleDeclaration(ailey_apply_dynamic_background($settings));
                }
            }
            return true;
        }

        public function onContentAfterDisplay($content, $section, $params, $page) {
            return $content;
        }

        private function getSettings() {
            $db = JFactory::getDbo();
            $query = $db->getQuery(true);
            $query->select($db->quoteName('*'));
            $query->from($db->quoteName('#__extension_options', 'o'));
            $query->where($db->quoteName('o.extension_id') . ' = ' . $db->quote($this->get('element')));
            $db->setQuery($query);
            $options = $db->loadObject();

            if (!$options) return null;

            return json_decode($options->params, true);
        }

        public function onAfterInstallPlugin($data) {
            $this->installDatabase();
        }

        private function installDatabase() {
            $db = JFactory::getDbo();
            $query = $db->getQuery(true);
            $query->insert($db->quoteName('#__extension_options'))
                ->columns($db->quoteName(['extension_id', 'params']))
                ->values($db->quote($this->get('element')) . ',' . $db->quote(json_encode([
                    'background_color' => '#ffffff',
                    'primary_color' => '#000000',
                    'secondary_color' => '#333333',
                    'animation' => 'none',
                ])));
            $db->setQuery($query);
            $db->execute();
        }
    }

    // Create necessary files for Joomla
    if (!file_exists(AILEY_DYNAMIC_BG_PATH . '/joomla/ailey_dynamic_bg.xml')) {
        file_put_contents(AILEY_DYNAMIC_BG_PATH . '/joomla/ailey_dynamic_bg.xml', <<<XML
<?xml version="1.0" encoding="utf-8"?>
<extension type="plugin" group="system" method="upgrade">
    <name>PLG_SYSTEM_AILEY_DYNAMIC_BG_NAME</name>
    <creationDate>2023-10-01</creationDate>
    <author>Ailey</author>
    <authorEmail>ailey@ailey.dev</authorEmail>
    <authorUrl>https://ailey.dev</authorUrl>
    <copyright>Copyright (C) 2023 Ailey</copyright>
    <license>GNU General Public License version 2 or later</license>
    <version>1.0.0</version>
    <description>PLG_SYSTEM_AILEY_DYNAMIC_BG_DESCRIPTION</description>
    <namespace path="ailey.dev">Ailey\DynamicBg</namespace>
    <files>
        <folder>ailey_dynamic_bg</folder>
        <filename plugin="ailey_dynamic_bg">ailey_dynamic_bg.php</filename>
    </files>
    <languages>
        <language tag="en-GB">ailey_dynamic_bg/en-GB/ailey_dynamic_bg.ini</language>
    </languages>
    <params>
        <param name="background_color" type="text" default="#ffffff" label="Background Color" />
        <param name="primary_color" type="text" default="#000000" label="Primary Color" />
        <param name="secondary_color" type="text" default="#333333" label="Secondary Color" />
        <param name="animation" type="text" default="none" label="Animation" />
    </params>
</extension>
XML
        );
    }

    if (!file_exists(AILEY_DYNAMIC_BG_PATH . '/joomla/ailey_dynamic_bg.php')) {
        file_put_contents(AILEY_DYNAMIC_BG_PATH . '/joomla/ailey_dynamic_bg.php', <<<PHP
<?php
defined('_JEXEC') or die;

require_once dirname(__FILE__) . '/../../' . basename(__FILE__, '.php') . '.php';

class plgSystemAileyDynamicBg extends JPlugin {
    public function onAfterRender() {
        \$app = JFactory::getApplication();
        if (\$app->isSite()) {
            \$document = JFactory::getDocument();
            \$settings = \$this->getSettings();

            if (\$settings) {
                \$document->addStyleDeclaration(ailey_apply_dynamic_background(\$settings));
            }
        }
        return true;
    }

    public function onContentAfterDisplay(\$content, \$section, \$params, \$page) {
        return \$content;
    }

    private function getSettings() {
        \$db = JFactory::getDbo();
        \$query = \$db->getQuery(true);
        \$query->select(\$db->quoteName('*'));
        \$query->from(\$db->quoteName('#__extension_options', 'o'));
        \$query->where(\$db->quoteName('o.extension_id') . ' = ' . \$db->quote(\$this->get('element')));
        \$db->setQuery(\$query);
        \$options = \$db->loadObject