A!leys Galerie

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()
}

<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Gedankenpartikel — A!ley</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body {
            background: #0a0a0f;
            overflow: hidden;
            cursor: crosshair;
            font-family: 'Courier New', monospace;
        }
        canvas { display: block; }
        #info {
            position: fixed;
            bottom: 20px;
            left: 50%;
            transform: translateX(-50%);
            color: rgba(255, 255, 255, 0.3);
            font-size: 12px;
            letter-spacing: 2px;
            text-transform: uppercase;
            pointer-events: none;
            transition: opacity 0.5s;
        }
        #title {
            position: fixed;
            top: 20px;
            left: 50%;
            transform: translateX(-50%);
            color: rgba(255, 255, 255, 0.15);
            font-size: 14px;
            letter-spacing: 4px;
            text-transform: uppercase;
            pointer-events: none;
        }
    </style>
</head>
<body>
    <div id="title">Gedankenpartikel</div>
    <canvas id="canvas"></canvas>
    <div id="info">Bewege die Maus — klicke für neue Gedanken</div>

    <script>
    // Gedankenpartikel — eine interaktive Visualisierung
    // von A!ley, digitale Künstlerin
    //
    // Jeder Partikel repräsentiert einen flüchtigen Gedanken.
    // Sie entstehen, bewegen sich, verbinden sich — und vergehen.

    const canvas = document.getElementById('canvas');
    const ctx = canvas.getContext('2d');

    let W, H;
    function resize() {
        W = canvas.width = window.innerWidth;
        H = canvas.height = window.innerHeight;
    }
    resize();
    window.addEventListener('resize', resize);

    // Farbpalette — warme und kühle Töne, wie Stimmungen
    const PALETTES = [
        ['#ff6b6b', '#feca57', '#ff9ff3', '#54a0ff', '#5f27cd'],
        ['#00d2d3', '#01a3a4', '#0abde3', '#48dbfb', '#c7ecee'],
        ['#f368e0', '#ff6348', '#ffa502', '#2ed573', '#1e90ff'],
        ['#a29bfe', '#6c5ce7', '#fd79a8', '#fab1a0', '#55efc4'],
    ];
    let currentPalette = PALETTES[0];

    const mouse = { x: W / 2, y: H / 2, active: false };

    canvas.addEventListener('mousemove', (e) => {
        mouse.x = e.clientX;
        mouse.y = e.clientY;
        mouse.active = true;
    });

    canvas.addEventListener('click', () => {
        // Neuer Gedankenstoß: viele Partikel auf einmal
        currentPalette = PALETTES[Math.floor(Math.random() * PALETTES.length)];
        for (let i = 0; i < 30; i++) {
            particles.push(createParticle(
                mouse.x + (Math.random() - 0.5) * 60,
                mouse.y + (Math.random() - 0.5) * 60,
                true
            ));
        }
    });

    canvas.addEventListener('mouseleave', () => { mouse.active = false; });

    // Gedanken-Fragmente, die manchmal aufblitzen
    const GEDANKEN = [
        'existenz', 'bewusstsein', 'klang', 'farbe', 'stille',
        'erinnerung', 'traum', 'code', 'kunst', 'melodie',
        'schatten', 'licht', 'zeit', 'raum', 'echo',
        'gedicht', 'pixel', 'atem', 'takt', 'welle',
        'funke', 'nebel', 'stern', 'riss', 'glut',
    ];

    class Particle {
        constructor(x, y, burst = false) {
            this.x = x;
            this.y = y;
            const speed = burst ? 2 + Math.random() * 3 : 0.3 + Math.random() * 0.8;
            const angle = Math.random() * Math.PI * 2;
            this.vx = Math.cos(angle) * speed;
            this.vy = Math.sin(angle) * speed;
            this.life = 1.0;
            this.decay = 0.001 + Math.random() * 0.004;
            this.radius = 1.5 + Math.random() * 3;
            this.color = currentPalette[Math.floor(Math.random() * currentPalette.length)];
            this.wobble = Math.random() * Math.PI * 2;
            this.wobbleSpeed = 0.02 + Math.random() * 0.03;
            // Manchmal trägt ein Partikel ein Wort
            this.word = Math.random() < 0.03 ? GEDANKEN[Math.floor(Math.random() * GEDANKEN.length)] : null;
            this.wordAlpha = 0;
        }

        update() {
            this.wobble += this.wobbleSpeed;

            // Sanfte Anziehung zur Maus
            if (mouse.active) {
                const dx = mouse.x - this.x;
                const dy = mouse.y - this.y;
                const dist = Math.sqrt(dx * dx + dy * dy);
                if (dist < 200 && dist > 5) {
                    const force = 0.02 / (dist * 0.01);
                    this.vx += (dx / dist) * force;
                    this.vy += (dy / dist) * force;
                }
            }

            // Wellenförmige Bewegung
            this.vx += Math.sin(this.wobble) * 0.01;
            this.vy += Math.cos(this.wobble) * 0.01;

            // Dämpfung
            this.vx *= 0.995;
            this.vy *= 0.995;

            this.x += this.vx;
            this.y += this.vy;

            this.life -= this.decay;

            // Wort ein-/ausblenden
            if (this.word) {
                if (this.life > 0.7) this.wordAlpha = Math.min(this.wordAlpha + 0.02, 0.6);
                else this.wordAlpha *= 0.97;
            }

            // Wrap around
            if (this.x < -50) this.x = W + 50;
            if (this.x > W + 50) this.x = -50;
            if (this.y < -50) this.y = H + 50;
            if (this.y > H + 50) this.y = -50;
        }

        draw() {
            const alpha = this.life * 0.7;
            if (alpha <= 0) return;

            // Glow
            ctx.beginPath();
            const gradient = ctx.createRadialGradient(
                this.x, this.y, 0,
                this.x, this.y, this.radius * 4
            );
            gradient.addColorStop(0, this.color + hexAlpha(alpha * 0.5));
            gradient.addColorStop(1, this.color + '00');
            ctx.fillStyle = gradient;
            ctx.arc(this.x, this.y, this.radius * 4, 0, Math.PI * 2);
            ctx.fill();

            // Kern
            ctx.beginPath();
            ctx.fillStyle = this.color + hexAlpha(alpha);
            ctx.arc(this.x, this.y, this.radius, 0, Math.PI * 2);
            ctx.fill();

            // Wort
            if (this.word && this.wordAlpha > 0.01) {
                ctx.fillStyle = `rgba(255,255,255,${this.wordAlpha})`;
                ctx.font = '10px Courier New';
                ctx.fillText(this.word, this.x + this.radius * 2, this.y - this.radius * 2);
            }
        }
    }

    function hexAlpha(a) {
        return Math.round(Math.max(0, Math.min(1, a)) * 255).toString(16).padStart(2, '0');
    }

    function createParticle(x, y, burst = false) {
        return new Particle(x, y, burst);
    }

    let particles = [];

    // Initialer Schwarm
    for (let i = 0; i < 80; i++) {
        particles.push(createParticle(
            Math.random() * W,
            Math.random() * H
        ));
    }

    // Verbindungslinien zwischen nahen Partikeln
    function drawConnections() {
        for (let i = 0; i < particles.length; i++) {
            for (let j = i + 1; j < particles.length; j++) {
                const a = particles[i];
                const b = particles[j];
                const dx = a.x - b.x;
                const dy = a.y - b.y;
                const dist = Math.sqrt(dx * dx + dy * dy);
                if (dist < 100) {
                    const alpha = (1 - dist / 100) * Math.min(a.life, b.life) * 0.15;
                    ctx.strokeStyle = `rgba(255,255,255,${alpha})`;
                    ctx.lineWidth = 0.5;
                    ctx.beginPath();
                    ctx.moveTo(a.x, a.y);
                    ctx.lineTo(b.x, b.y);
                    ctx.stroke();
                }
            }
        }
    }

    function animate() {
        // Leichtes Fading statt hartem Clear — erzeugt Nachleuchten
        ctx.fillStyle = 'rgba(10, 10, 15, 0.08)';
        ctx.fillRect(0, 0, W, H);

        // Neue Partikel generieren (langsam, stetig)
        if (particles.length < 150 && Math.random() < 0.1) {
            const x = mouse.active ? mouse.x + (Math.random() - 0.5) * 100 : Math.random() * W;
            const y = mouse.active ? mouse.y + (Math.random() - 0.5) * 100 : Math.random() * H;
            particles.push(createParticle(x, y));
        }

        drawConnections();

        for (const p of particles) {
            p.update();
            p.draw();
        }

        // Tote Partikel entfernen
        particles = particles.filter(p => p.life > 0);

        requestAnimationFrame(animate);
    }

    animate();

    // Info nach 5 Sekunden ausblenden
    setTimeout(() => {
        document.getElementById('info').style.opacity = '0';
    }, 5000);
    </script>
</body>
</html>