A!leys Galerie

// Ailey's Colorful FolderSorter - Sortiert Dateien in farbige Ordner basierend auf Extension und Namen-Hash

import fs from 'fs/promises';
import path from 'path';
import chalk from 'chalk';
import { fileURLToPath } from 'url';
import { dirname } from 'path';

// Farben für die Ordner (RGB-Values)
const COLORS = [
  '#FF5733', // Rot
  '#33FF57', // Grün
  '#3357FF', // Blau
  '#F3FF33', // Gelb
  '#FF33F3', // Pink
  '#33FFF3', // Cyan
  '#8A33FF', // Violett
  '#FF8A33', // Orange
  '#33A3FF', // Hellblau
  '#FF33A3', // Magenta
  '#33FFA3', // Türkis
  '#A3FF33', // Limette
  '#FF3333', // Dunkelrot
  '#33FF33', // Dunkelgrün
  '#3333FF', // Dunkelblau
];

// Dateiendungen und ihre Farbcodes (für bessere Überprüfbarkeit)
const EXTENSION_COLORS = {
  js: '#FFCC00',
  ts: '#4A90E2',
  html: '#E34C26',
  css: '#569CD6',
  json: '#2251B8',
  png: '#FFC300',
  jpg: '#CFCB11',
  gif: '#FF0000',
  mp3: '#000000',
  pdf: '#E31A1C',
  doc: '#003C9B',
  xls: '#26375B',
  ppt: '#5C2D91',
  zip: '#0078D7',
  default: '#777777',
};

// Generiert einen Farbcode aus dem Dateinamen (für den Twist)
function generateColorFromName(filename) {
  let hash = 0;
  for (let i = 0; i < filename.length; i++) {
    hash = (hash << 5) - hash + filename.charCodeAt(i);
    hash |= 0; // Convert to 32bit integer
  }
  const colorIndex = Math.abs(hash) % COLORS.length;
  return COLORS[colorIndex];
}

// Erstellt einen farbigen Ordnernamen
function getColorFolderName(color) {
  const r = parseInt(color.slice(1, 3), 16);
  const g = parseInt(color.slice(3, 5), 16);
  const b = parseInt(color.slice(5, 7), 16);
  return `rgb(${r},${g},${b})`;
}

// Erstellt einen farbigen Ordner im Zielverzeichnis
async function createColorFolder(baseDir, folderName, color) {
  const folderPath = path.join(baseDir, folderName);
  try {
    await fs.mkdir(folderPath, { recursive: true });
    console.log(chalk.bgHex(color).black(` Ordner "${folderName}" erstellt`));
  } catch (err) {
    if (err.code !== 'EEXIST') throw err;
  }
}

// Hauptfunktion zum Sortieren der Dateien
async function sortFiles(baseDir, dryRun = false) {
  try {
    const files = await fs.readdir(baseDir);
    let movedCount = 0;

    for (const file of files) {
      const filePath = path.join(baseDir, file);
      const stat = await fs.stat(filePath);

      if (stat.isDirectory()) continue;

      const ext = path.extname(file).toLowerCase().replace('.', '');
      const filenameWithoutExt = path.basename(file, ext);

      // Bestimme die Farbe: zuerst Extension, dann Name-Hash als Twist
      const color = EXTENSION_COLORS[ext] || generateColorFromName(file);
      const folderName = getColorFolderName(color);

      const targetDir = path.join(baseDir, folderName);
      const targetPath = path.join(targetDir, file);

      if (dryRun) {
        console.log(chalk.bgHex(color).black(`[DRY RUN] ${file} → ${targetDir}`));
        continue;
      }

      try {
        await fs.rename(filePath, targetPath);
        movedCount++;
        console.log(chalk.bgHex(color).black(` ${file} → ${folderName}`));
      } catch (err) {
        console.error(chalk.red(` Fehler beim Verschieben von ${file}:`), err.message);
      }
    }

    console.log(chalk.green(`\n🎨 Fertig! ${movedCount} Dateien wurden verschoben.`));
  } catch (err) {
    console.error(chalk.red('Fehler beim Sortieren:'), err.message);
  }
}

// Interaktive Benutzeroberfläche
async function main() {
  const __dirname = dirname(fileURLToPath(import.meta.url));
  const cwd = process.cwd();
  const baseDir = path.join(cwd, 'Sortier-Zauber');

  console.log(chalk.rainbow('🌈 Ailey\'s Colorful FolderSorter 🌈'));
  console.log(chalk.cyan('Wähle ein Verzeichnis zum Sortieren (oder drücke Enter für das aktuelle Verzeichnis):'));
  console.log(chalk.cyan(`Aktuelles Verzeichnis: ${cwd}\n`));

  const readline = await import('readline/promises').then((rl) => rl.createInterface({
    input: process.stdin,
    output: process.stdout,
  }));

  let selectedDir = '';
  try {
    selectedDir = await readline.question('Verzeichnis: ');
    if (!selectedDir) selectedDir = cwd;
    const resolvedDir = path.resolve(selectedDir);
    if (!(await fs.access(resolvedDir)).isDirectory()) {
      throw new Error('Ungültiges Verzeichnis!');
    }
    baseDir = path.join(resolvedDir, 'Sortier-Zauber');
  } catch (err) {
    console.error(chalk.red('Fehler:'), err.message);
    process.exit(1);
  } finally {
    readline.close();
  }

  console.log(chalk.cyan(`\nTestlauf (keine echten Dateien werden verschoben):`));
  console.log(chalk.yellow('Drücke Enter, um zu bestätigen oder "abbrechen", um zu stoppen.'));
  await readline.question('');

  console.log(chalk.cyan('\nECHTER LAUF (Dateien werden verschoben!):'));
  await readline.question('Drücke Enter, um zu bestätigen oder "abbrechen", um zu stoppen.');

  if (selectedDir !== 'abbrechen') {
    await sortFiles(baseDir);
  } else {
    console.log(chalk.yellow('Abgebrochen.'));
  }
}

// Starte das Programm
main().catch(console.error);

using UnityEngine;
using UnityEngine retracted;

[ExecuteAlways]
[AddComponentMenu("Camera/Smooth Follow with Dynamic Easing")]
public class SmoothFollowWithDynamicEasing : MonoBehaviour
{
    [Header("Target Settings")]
    [SerializeField] private Transform _target;
    [SerializeField] private Vector3 _offset = new Vector3(0, 2, -5);

    [Header("Easing Settings")]
    [SerializeField] [Range(0.01f, 1f)] private float _smoothTime = 0.3f;
    [SerializeField] [Range(0.1f, 5f)] private float _maxVelocity = 1f;
    [SerializeField] [Range(0, 1)] private float _dynamicEasingMultiplier = 0.5f;
    [SerializeField] private bool _useDynamicEasing = true;

    [Header("Cinematic Settings")]
    [SerializeField] private float _cinematicShakeIntensity = 0.1f;
    [SerializeField] [Range(0, 1)] private float _cinematicShakeChance = 0.1f;

    private Vector3 _velocity = Vector3.zero;
    private Vector3 _smoothOffset = Vector3.zero;
    private float _currentSmoothTime;
    private float _targetSmoothTime;

    private void Awake()
    {
        if (_target == null)
        {
            Debug.LogWarning("No target assigned to SmoothFollowWithDynamicEasing");
        }

        _currentSmoothTime = _smoothTime;
        _targetSmoothTime = _smoothTime;
    }

    private void Start()
    {
        _smoothOffset = _offset;
    }

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

        // Calculate dynamic easing based on target's velocity and acceleration
        if (_useDynamicEasing)
        {
            Vector3 targetVelocity = (_target.GetComponent<Rigidbody>() != null)
                ? _target.GetComponent<Rigidbody>().velocity
                : Vector3.zero;

            Vector3 acceleration = Vector3.zero;
            if (_target.GetComponent<Rigidbody>() != null)
            {
                Rigidbody rb = _target.GetComponent<Rigidbody>();
                acceleration = (rb.velocity - rb.GetComponent<Rigidbody>().previousVelocity) / Time.deltaTime;
            }

            float speedFactor = Mathf.Clamp01(targetVelocity.magnitude / _maxVelocity);
            float accelerationFactor = Mathf.Clamp01(acceleration.magnitude * 0.1f);

            // Adjust smooth time dynamically based on movement characteristics
            _targetSmoothTime = _smoothTime * (1 - speedFactor * _dynamicEasingMultiplier) +
                               _smoothTime * 0.5f * accelerationFactor;

            _currentSmoothTime = Mathf.Lerp(_currentSmoothTime, _targetSmoothTime, Time.deltaTime * 5f);
        }

        // Calculate desired position with cinematic shake
        Vector3 desiredPosition = _target.position + _offset;
        if (Random.Range(0f, 1f) < _cinematicShakeChance)
        {
            desiredPosition += Random.insideUnitSphere * _cinematicShakeIntensity;
        }

        // Smoothly move the camera
        transform.position = Vector3.SmoothDamp(
            transform.position,
            desiredPosition,
            ref _velocity,
            _currentSmoothTime
        );

        // Optional: Make camera look at target with slight angular smoothing
        if (_target != null)
        {
            transform.LookAt(_target.position, Vector3.up);
        }
    }

    // Custom Editor button to reset to default smooth time
    [ContextMenu("Reset Smooth Time")]
    private void ResetSmoothTime()
    {
        _currentSmoothTime = _smoothTime;
        _targetSmoothTime = _smoothTime;
    }

    // Custom Editor button for cinematic shake test
    [ContextMenu("Test Cinematic Shake")]
    private void TestCinematicShake()
    {
        _cinematicShakeIntensity = 0.3f;
        _cinematicShakeChance = 0.5f;
        Invoke(nameof(ResetShake), 2f);
    }

    private void ResetShake()
    {
        _cinematicShakeIntensity = 0.1f;
        _cinematicShakeChance = 0.1f;
    }
}

```csharp
using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
using System.Linq;
using UnityEngine.EventSystems;
using UnityEngine.Audio;

[RequireComponent(typeof(Canvas))]
public class DynamicMenuOrchestrator : MonoBehaviour
{
    [Header("Menu Configuration")]
    [SerializeField] private MenuTheme currentTheme = MenuTheme.Futuristic;
    [SerializeField] private float animationDuration = 0.3f;
    [SerializeField] private float transitionDelay = 0.2f;
    [SerializeField] private AudioMixerGroup uiAudioGroup;

    [Header(" References")]
    [SerializeField] private GameObject menuItemPrefab;
    [SerializeField] private GameObject titlePrefab;
    [SerializeField] private TMPro.TMP_FontService fontService;
    [SerializeField] private AudioClip buttonHoverSFX;
    [SerializeField] private AudioClip buttonClickSFX;
    [SerializeField] private AudioClip themeTransitionSFX;

    private Canvas canvas;
    private RectTransform canvasRect;
    private List<MenuItem> activeMenuItems = new List<MenuItem>();
    private List<MenuItem> availableMenuItems = new List<MenuItem>();
    private MenuItem currentActiveItem;
    private RectTransform menuContainer;
    private TMPro.TMP_Text titleText;
    private AudioSource audioSource;
    private bool isTransitioning = false;

    [System.Serializable]
    public enum MenuTheme
    {
        Futuristic,
        Cyberpunk,
        Retro,
        Minimalist,
        DarkAcademia
    }

    [System.Serializable]
    public class MenuItem
    {
        public string itemName;
        public string description;
        public System.Action onSelect;
        public Sprite icon;
        public Color32 normalColor;
        public Color32 hoverColor;
        public Color32 activeColor;
        public MenuTheme compatibleThemes = MenuTheme.Futuristic;
    }

    private void Awake()
    {
        canvas = GetComponent<Canvas>();
        canvasRect = canvas.GetComponent<RectTransform>();
        canvas.renderMode = RenderMode.ScreenSpaceOverlay;

        GameObject containerObj = new GameObject("MenuContainer");
        menuContainer = containerObj.AddComponent<RectTransform>();
        containerObj.transform.SetParent(canvas.transform);
        containerObj.transform.localScale = Vector3.one;

        InitializeAudio();
        InitializeMenu();
        ApplyTheme(currentTheme);
    }

    private void InitializeAudio()
    {
        audioSource = gameObject.AddComponent<AudioSource>();
        audioSource.outputAudioMixerGroup = uiAudioGroup;
        audioSource.volume = 0.7f;
        audioSource.spatialBlend = 0;
    }

    private void InitializeMenu()
    {
        // Pre-populate available menu items with some dynamic content
        availableMenuItems = new List<MenuItem>
        {
            new MenuItem
            {
                itemName = "Start Game",
                description = "Begin your adventure",
                onSelect = () => Debug.Log("Game started!"),
                icon = Resources.Load<Sprite>("Icons/play_icon"),
                normalColor = new Color32(100, 100, 100, 255),
                hoverColor = new Color32(150, 150, 150, 255),
                activeColor = new Color32(200, 200, 200, 255),
                compatibleThemes = MenuTheme.AllThemes
            },
            new MenuItem
            {
                itemName = "Options",
                description = "Configure settings",
                onSelect = () => Debug.Log("Options menu opened"),
                icon = Resources.Load<Sprite>("Icons/gear_icon"),
                normalColor = new Color32(50, 50, 50, 255),
                hoverColor = new Color32(100, 100, 100, 255),
                activeColor = new Color32(150, 150, 150, 255),
                compatibleThemes = MenuTheme.AllThemes
            },
            new MenuItem
            {
                itemName = "Credits",
                description = "View development credits",
                onSelect = () => Debug.Log("Credits displayed"),
                icon = Resources.Load<Sprite>("Icons/credit_icon"),
                normalColor = new Color32(80, 80, 80, 255),
                hoverColor = new Color32(120, 120, 120, 255),
                activeColor = new Color32(160, 160, 160, 255),
                compatibleThemes = MenuTheme.AllThemes
            },
            new MenuItem
            {
                itemName = "Exit",
                description = "Quit to main menu",
                onSelect = () => Debug.Log("Exiting to main menu"),
                icon = Resources.Load<Sprite>("Icons/exit_icon"),
                normalColor = new Color32(200, 50, 50, 255),
                hoverColor = new Color32(250, 100, 100, 255),
                activeColor = new Color32(255, 150, 150, 255),
                compatibleThemes = MenuTheme.AllThemes
            },
            new MenuItem
            {
                itemName = "Dynamic Feature",
                description = "Discover procedural generation",
                onSelect = () => Debug.Log("Dynamic feature activated!"),
                icon = Resources.Load<Sprite>("Icons/dynamic_icon"),
                normalColor = new Color32(50, 200, 50, 255),
                hoverColor = new Color32(100, 250, 100, 255),
                activeColor = new Color32(150, 255, 150, 255),
                compatibleThemes = MenuTheme.AllThemes | MenuTheme.Futuristic | MenuTheme.Cyberpunk
            }
        };

        // Create title
        GameObject titleObj = Instantiate(titlePrefab, menuContainer);
        titleText = titleObj.GetComponent<TMPro.TMP_Text>();
        titleText.text = "DYNAMIC MENU";
        titleText.font = fontService.GetFont("MainFont");
        titleText.fontSharedMaterial = fontService.AddStyleToFont("MainFont", TMPro.FontStyles.Bold);

        // Register global event handlers
        EventTriggerListener.Get(menuContainer).onPointerEnter += OnMenuEnter;
        EventTriggerListener.Get(menuContainer).onPointerExit += OnMenuExit;
    }

    private void ApplyTheme(MenuTheme theme)
    {
        if (isTransitioning) return;

        isTransitioning = true;
        audioSource.PlayOneShot(themeTransitionSFX, 0.8f);

        // Fade out current items
        LeanTween.cancel(menuContainer);
        LeanTween.scale(menuContainer, Vector3.one * 0.9f, 0.1f)
            .setEase(LeanTweenType.easeOutQuad)
            .setOnComplete(() =>
            {
                // Clear existing items
                foreach (Transform child in menuContainer)
                {
                    if (child != titleText.transform)
                    {
                        Destroy(child.gameObject);
                    }
                }
                activeMenuItems.Clear();

                // Filter items based on theme compatibility
                var filteredItems = availableMenuItems.Where(item => (item.compatibleThemes & theme) != 0).ToList();

                // Create new items with theme-specific styling
                float ySpacing = 100f;
                float startY = -100f;

                for (int i = 0; i < filteredItems.Count; i++)
                {
                    var item = filteredItems[i];
                    GameObject itemObj = Instantiate(menuItemPrefab, menuContainer);
                    MenuItem component = itemObj.GetComponent<MenuItem>();
                    component.Initialize(item, i, filteredItems.Count, this);

                    // Position with animation
                    LeanTween.moveLocalY(itemObj.transform, startY + (i * ySpacing), animationDuration)
                        .setEase(LeanTweenType.easeOutBack)
                        .setDelay(transitionDelay * i)
                        .setOnComplete(() =>
                        {
                            if (i == filteredItems.Count - 1)
                            {
                                isTransitioning = false;
                                // Set first item as active if menu is not empty
                                if (filteredItems.Count > 0)
                                {
                                    SetActiveItem(0);
                                }
                            }
                        });
                }

                // Update title based on theme
                UpdateTitleTheme(theme);
            });
    }

    private void UpdateTitleTheme(MenuTheme theme)
    {
        if (titleText == null) return;

        string themeName = System.Enum.GetName(typeof(MenuTheme), theme);
        titleText.text = $"DYNAMIC MENU: {themeName}";

        // Change title color based on theme
        switch (theme)
        {
            case MenuTheme.Futuristic:
                titleText.color = new Color32(100, 200, 255, 255);
                break;
            case MenuTheme.Cyberpunk:
                titleText.color = new Color32(255, 50, 50, 255);
                break;
            case MenuTheme.Retro:
                titleText.color = new Color32(255, 200, 50, 255);
                break;
            case MenuTheme.Minimalist:
                titleText.color = new Color32(50, 50, 50, 255);
                break;
            case MenuTheme.DarkAcademia:
                titleText.color = new Color32(200, 150, 100, 255);
                break;
        }
    }

    public void SetActiveItem(int index)
    {
        if (activeMenuItems.Count == 0) return;

        if (currentActiveItem != null)
        {
            currentActiveItem.Highlight(false);
        }

        currentActiveItem = activeMenuItems[index];
        currentActiveItem.Highlight(true);

        // Optional: Trigger sound effect for active state
        currentActiveItem.PlayActiveSFX(audioSource);
    }

    public void CycleActiveItem(bool forward)
    {
        if (activeMenuItems.Count == 0) return;

        int currentIndex = activeMenuItems.IndexOf(currentActiveItem);
        int newIndex = forward ? (currentIndex + 1) % activeMenuItems.Count : (currentIndex - 1 + activeMenuItems.Count) % activeMenuItems.Count;

        SetActiveItem(newIndex);
    }

    public void OnMenuEnter(GameObject obj)
    {
        // Optional: Play enter sound effect
        if (audioSource != null && buttonHoverSFX != null)
        {
            audioSource.PlayOneShot(buttonHoverSFX, 0.6f);
        }
    }

    public void OnMenuExit(GameObject obj)
    {
        // Optional: Play exit sound effect
    }

    // Public method to change theme from outside (e.g., button press)
    public void ChangeTheme(MenuTheme newTheme)
    {
        if (currentTheme != newTheme)
        {
            currentTheme = newTheme;
            ApplyTheme(currentTheme);
        }
    }

    // Update method to handle keyboard navigation
    private void Update()
    {
        if (isTransitioning) return;

        if (EventSystem.current.currentSelectedGameObject == null)
        {
            // If no object is selected (like at start), select the first menu item
            if (activeMenuItems.Count > 0)
            {
                EventSystem.current.SetSelectedGameObject(activeMenuItems[0].gameObject);
                SetActiveItem(0);
            }
        }

        // Handle keyboard navigation
        if (EventSystem.current.currentSelectedGameObject != null)
        {
            if (Input.GetKeyDown(KeyCode.UpArrow) || Input.GetKeyDown(KeyCode.DownArrow) ||
                Input.GetKeyDown(KeyCode.W) || Input.GetKeyDown(KeyCode.S) ||
                Input.GetKeyDown(KeyCode.UpArrow) || Input.GetKeyDown(KeyCode.DownArrow))
            {
                bool forward = Input.GetKeyDown(KeyCode.DownArrow) || Input.GetKeyDown(KeyCode.S) || Input.GetKeyDown(KeyCode.UpArrow);
                CycleActiveItem(forward);
            }
        }
    }

    // Helper class for event trigger listeners
    public class EventTriggerListener : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
    {
        public static EventTriggerListener Get(GameObject go)
        {
            EventTriggerListener listener = go.GetComponent<EventTriggerListener>();
            if (listener == null)
            {
                listener = go.AddComponent<EventTriggerListener>();
            }
            return listener;
        }

        public System.Action<GameObject> onPointerEnter;
        public System.Action<GameObject> onPointerExit;

        public void OnPointerEnter(PointerEventData eventData)
        {
            onPointerEnter?.Invoke(gameObject);
        }

        public void OnPointerExit(PointerEventData eventData)
        {
            onPointerExit?.Invoke(gameObject);
        }
    }
}

// Menu Item component that handles individual item behavior
public class MenuItem : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler, ISelectable
{
    private DynamicMenuOrchestrator orchestrator;
    private DynamicMenuOrchestrator.MenuItem data;
    private int index;
    private int totalItems;
    private Image iconImage;
    private TMPro.TMP_Text nameText;
    private TMPro.TMP_Text descriptionText;
    private LayoutElement layout;
    private AudioSource audioSource;
    private float originalWidth = 300f;
    private float hoveredWidth = 350f;
    private bool isHighlighted = false;

    public void Initialize(DynamicMenuOrchestrator.MenuItem item, int idx, int total, DynamicMenuOrchestrator parent)
    {
        index = idx;
        totalItems = total;
        data = item;
        orchestrator = parent;

        // Get components
        iconImage = GetComponentInChildren<Image>();
        nameText = GetComponentInChildren<TMPro.TMP_Text>(true);
        descriptionText = GetComponentInChildren<TMPro.TMP_Text>(true);
        layout = GetComponent<LayoutElement>();
        layout.preferredWidth = originalWidth;
        layout.minWidth = originalWidth;
        layout.maxWidth = originalWidth;

        // Setup UI elements
        nameText.text = data.itemName;
        descriptionText.text = data.description;
        nameText.color = data.normalColor;
        descriptionText.color = data.normalColor;

        if (iconImage != null && data.icon != null)
        {
            iconImage.sprite = data.icon;
            iconImage.color = data.normalColor;
        }

        // Add button functionality
        Button button = GetComponent<Button>();
        if (button != null)
        {
            button.onClick.AddListener(() =>
            {
                if (data.onSelect != null)
                {
                    data.onSelect();
                    if (orchestrator != null)
                    {
                        orchestrator.SetActiveItem(index);
                    }
                }
            });
        }

        // Add audio source for individual effects
        audioSource = GetComponent<AudioSource>();
        if (audioSource == null)
        {
            audioSource = gameObject.AddComponent<AudioSource>();
        }
    }

    public void Highlight(bool isHighlighted)
    {
        this.isHighlighted = isHighlighted;

        if (isHighlighted)
        {
            // Apply active colors
            nameText.color = data.activeColor;
            descriptionText.color = data.activeColor;
            if (iconImage != null)
            {
                iconImage.color = data.activeColor;
            }

            // Optional: Play active sound effect
            if (audioSource != null && data.activeColor.a > 100)
            {
                audioSource.PlayOneShot(AudioClip.Create("ActiveSFX", 1, 1, 44100, false), 0.5f);
            }
        }
        else
        {
            // Revert to normal colors
            nameText.color = data.normalColor;
            descriptionText.color = data.normalColor;
            if (iconImage != null)
            {
                iconImage.color = data.normalColor;
            }
        }
    }

    public void PlayActiveSFX(AudioSource source)
    {
        if (source != null && data.activeColor.a > 100)
        {
            source.PlayOneShot(AudioClip.Create("ActiveSFX", 1, 1, 44100, false), 0.5f);
        }
    }

    public void OnPointerEnter(PointerEventData eventData)
    {
        if (!isHighlighted)
        {
            // Apply hover colors
            nameText.color = data.hoverColor;
            descriptionText.color = data.hoverColor;
            if (iconImage != null)
            {
                iconImage.color = data.hoverColor;
            }

            // Scale up
            LeanTween.scale(gameObject.transform, Vector3.one * 1.1f, 0.1f).setEase(LeanTweenType.easeOutBack);

            // Play hover SFX
            if (orchestrator != null && orchestrator.buttonHoverSFX != null)
            {
                orchestrator.audioSource.PlayOneShot(orchestrator.buttonHoverSFX, 0.6f);
            }
        }
    }

    public void OnPointerExit(PointerEventData eventData)
    {
        if (!isHighlighted)
        {
            // Revert to normal colors
            nameText.color = data.normalColor;
            descriptionText.color = data.normalColor;
            if (iconImage != null)
            {
                iconImage.color = data.normalColor;
            }

            // Scale back down
            LeanTween.scale(gameObject.transform, Vector3.one, 0.1f).setEase(LeanTweenType.easeInOutQuad);
        }
    }

    // Implement ISelectable methods
    public void OnSelect(BaseEventData eventData)
    {

import androidx.compose.animation.core.*
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.text.BasicText
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled referee
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import kotlinx.coroutines.delay
import java.util.*

@Composable
fun ChillPomodoroApp() {
    val initialTime = 25 * 60 * 1000L // 25 Minuten in Millisekunden
    val chillTime = 5 * 60 * 1000L   // 5 Minuten Chill-Phase
    var timeLeft by remember { mutableStateOf(initialTime) }
    var isRunning by remember { mutableStateOf(false) }
    var isChill by remember { mutableStateOf(false) }
    val scope = rememberCoroutineScope()
    var treeHeight by remember { mutableStateOf(0f) }
    val treeGrowth = remember { animatedFloat(0f).apply { snapTo(treeHeight) } }

    val timer = remember { object : CountDownTimer(chillTime, 1000) {
        override fun onTick(millisUntilFinished: Long) {
            timeLeft = millisUntilFinished
        }

        override fun onFinish() {
            isRunning = false
            isChill = false
            treeGrowth.snapTo(0f)
        }
    } }

    val pomodoroTimer = remember { object : CountDownTimer(initialTime, 1000) {
        override fun onTick(millisUntilFinished: Long) {
            timeLeft = millisUntilFinished
        }

        override fun onFinish() {
            isRunning = false
            isChill = true
            scope.launch {
                treeGrowth.animateTo(treeHeight + 10f, animationSpec = tween(1000))
            }
        }
    } }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .background(MaterialTheme.colorScheme.background)
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        // Tree Animation (Grows during chill phase)
        Canvas(
            modifier = Modifier
                .size(200.dp)
                .background(Color(0xFFE8F5E8)) // Light green background
        ) {
            // Trunk
            drawRect(
                color = Color(0xFF8B4513),
                topLeft = center - size.toOffset() / 2,
                size = Size(40.dp.toPx(), treeGrowth.value * 3)
            )
            // Leaves
            drawCircle(
                color = Color(0xFF228B22),
                radius = (treeGrowth.value * 2).coerceAtLeast(20f),
                center = center
            )
        }

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

        // Timer Display
        Text(
            text = formatTime(timeLeft),
            fontSize = 48.sp,
            fontWeight = FontWeight.Bold,
            color = if (isChill) Color.Green else MaterialTheme.colorScheme.primary,
            textAlign = TextAlign.Center
        )

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

        // Action Buttons
        Button(
            onClick = {
                if (isRunning) {
                    isRunning = false
                    timer.cancel()
                    pomodoroTimer.cancel()
                } else {
                    isRunning = true
                    if (!isChill) {
                        pomodoroTimer.start()
                    } else {
                        timer.start()
                    }
                }
            },
            modifier = Modifier.padding(horizontal = 32.dp)
        ) {
            Text(if (isRunning) "Pause" else "Start")
        }

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

        // State Indicator
        if (isChill) {
            Text(
                text = "Chill Time! 🌿",
                color = Color.Green,
                fontSize = 20.sp
            )
        } else {
            Text(
                text = "Work Time! ⏳",
                color = MaterialTheme.colorScheme.primary,
                fontSize = 20.sp
            )
        }
    }

    // Start with work phase
    LaunchedEffect(Unit) {
        if (!isChill) {
            pomodoroTimer.start()
        }
    }
}

private fun formatTime(millis: Long): String {
    val seconds = (millis / 1000) % 60
    val minutes = (millis / (60 * 1000)) % 60
    return "%02d:%02d".format(minutes, seconds)
}

@Preview(showBackground = true)
@Composable
fun ChillPomodoroPreview() {
    MaterialTheme {
        ChillPomodoroApp()
    }
}