A!leys Galerie

#!/usr/bin/env python3
"""
PixelStory - Transform images into stylized narrative visuals with theme-based pixel art effects.
"""

from __future__ import annotations
from typing import Optional, Tuple, List, Literal
import sys
import os
import argparse
from pathlib import Path
from PIL import Image, ImageFilter, ImageDraw, ImageFont, ImageOps
from PIL.Image import Image as PILImage

# Constant themes with their color palettes and styling
THEMES = {
    "Mystery": {
        "palette": [(0, 0, 25), (45, 45, 60), (85, 85, 105), (120, 120, 150), (150, 150, 180)],
        "filter": ImageFilter.GaussianBlur(radius=2),
        "text_color": (220, 220, 255),
        "font_path": None,
    },
    "Cyberpunk": {
        "palette": [(0, 0, 0), (0, 20, 40), (40, 60, 120), (80, 120, 200), (120, 200, 240)],
        "filter": ImageFilter.EdgeEnhance(more=2),
        "text_color": (255, 255, 0),
        "font_path": None,
    },
    "Retro": {
        "palette": [(150, 0, 0), (0, 150, 0), (0, 0, 150), (255, 150, 0), (150, 0, 255)],
        "filter": ImageFilter.MedianFilter(size=3),
        "text_color": (255, 255, 255),
        "font_path": None,
    },
}

class PixelStoryGenerator:
    """
    Generates stylized pixel art narratives from input images.
    """

    def __init__(self, theme: str = "Mystery"):
        """
        Initialize with a theme.

        Args:
            theme: One of the predefined themes (Mystery, Cyberpunk, Retro)
        """
        if theme not in THEMES:
            raise ValueError(f"Invalid theme. Choose from: {list(THEMES.keys())}")

        self.theme = theme
        self.theme_data = THEMES[theme]
        self._load_font()
        self._setup_palette()

    def _load_font(self) -> None:
        """Load the font for the theme, or use default if not specified."""
        if self.theme_data["font_path"]:
            try:
                self.font = ImageFont.truetype(self.theme_data["font_path"], 36)
            except IOError:
                print(f"Warning: Could not load font {self.theme_data['font_path']}, using default.")
                self.font = ImageFont.load_default()
        else:
            self.font = ImageFont.load_default()

    def _setup_palette(self) -> None:
        """Create a color palette for the theme."""
        self.palette = self.theme_data["palette"]

    def _apply_pixel_art_effect(self, image: PILImage) -> PILImage:
        """
        Apply pixel art effect with color quantization to the palette.

        Args:
            image: Input PIL Image

        Returns:
            Processed PIL Image with pixel art effect
        """
        # Resize for pixel art look
        width, height = image.size
        pixel_size = max(4, min(8, width // 32, height // 32))
        new_width, new_height = width // pixel_size, height // pixel_size
        resized = image.resize((new_width, new_height), Image.NEAREST)

        # Quantize to our palette
        quantized = resized.quantize(
            palette=Image.ADAPTIVE,
            colors=len(self.palette)
        )

        # Recolor to match our theme's palette
        recolored = quantized.convert("RGB")
        for i, color in enumerate(self.palette):
            quantized.putpixel((0, 0), color)
            quantized = quantized.convert("RGB")

        # Upscale back
        final = quantized.resize(
            (width, height),
            Image.NEAREST
        )

        return final

    def _add_narrative_text(self, image: PILImage, caption: str) -> PILImage:
        """
        Add thematic narrative text to the image.

        Args:
            image: Input PIL Image
            caption: Text to add as caption

        Returns:
            Image with text overlay
        """
        draw = ImageDraw.Draw(image)
        text_width, text_height = draw.textbbox((0, 0), caption, font=self.font)[2:]
        margin = 20
        x = (image.width - text_width) // 2
        y = image.height - text_height - margin

        draw.text((x, y), caption, font=self.font, fill=self.theme_data["text_color"])
        return image

    def generate(self, input_path: str, output_path: str, caption: str = "") -> Path:
        """
        Generate the pixel story from input image.

        Args:
            input_path: Path to input image
            output_path: Path to save output image
            caption: Optional caption for the narrative

        Returns:
            Path to the generated image
        """
        try:
            with Image.open(input_path) as img:
                # Convert to RGB if needed
                if img.mode != "RGB":
                    img = img.convert("RGB")

                # Apply theme-specific filter
                filtered = img.filter(self.theme_data["filter"])

                # Apply pixel art effect
                pixel_art = self._apply_pixel_art_effect(filtered)

                # Add caption if provided
                if caption:
                    result = self._add_narrative_text(pixel_art, caption)
                else:
                    result = pixel_art

                # Save result
                output_path = Path(output_path)
                result.save(output_path)
                print(f"Pixel story generated at: {output_path}")
                return output_path

        except Exception as e:
            print(f"Error processing image: {e}")
            sys.exit(1)

def main():
    """Command-line interface for PixelStory."""
    parser = argparse.ArgumentParser(
        description="Transform images into stylized pixel narratives with thematic effects."
    )
    parser.add_argument("input", help="Path to input image")
    parser.add_argument("output", help="Path to save output image")
    parser.add_argument(
        "--theme", choices=THEMES.keys(), default="Mystery",
        help="Theme for the pixel story (default: Mystery)"
    )
    parser.add_argument(
        "--caption", type=str, default="",
        help="Optional caption to add to the image"
    )
    parser.add_argument(
        "--font", type=str, default=None,
        help="Path to custom font file (TTF) for the caption"
    )

    args = parser.parse_args()

    # Update theme data if custom font is provided
    if args.font:
        THEMES[args.theme]["font_path"] = args.font

    generator = PixelStoryGenerator(theme=args.theme)
    generator.generate(
        input_path=args.input,
        output_path=args.output,
        caption=args.caption
    )

if __name__ == "__main__":
    main()

using UnityEngine;
using System.Collections;
using System.Linq;
using UnityEngine.Audio;

[RequireComponent(typeof(AudioSource))]
public class HarmonicFusion : MonoBehaviour
{
    [Header("Audio Settings")]
    [SerializeField] private AudioMixerGroup _targetMixerGroup;
    [SerializeField] private float _crossfadeDuration = 0.5f;
    [SerializeField] private float _minVolumeThreshold = 0.1f;
    [SerializeField] private bool _randomizeOrder = true;

    [Header("Audio Clips")]
    [SerializeField] private AudioClip[] _audioClips;

    [Header("Easter Egg")]
    [SerializeField] private float _easterEggThreshold = 0.3f;
    [SerializeField] private AudioClip _easterEggSound;
    [SerializeField] private Color _easterEggColor = Color.magenta;

    private AudioSource _audioSource;
    private AudioClip _currentClip;
    private AudioClip _nextClip;
    private float _crossfadeProgress;
    private bool _isCrossfading = false;
    private bool _hasPlayedEasterEgg = false;
    private Coroutine _currentCrossfadeRoutine;
    private int _easterEggKeyPresses = 0;

    private void Awake()
    {
        _audioSource = GetComponent<AudioSource>();
        if (_audioSource == null)
        {
            _audioSource = gameObject.AddComponent<AudioSource>();
        }

        _audioSource.outputAudioMixerGroup = _targetMixerGroup;
        _audioSource.volume = 0f;

        if (_audioClips.Length < 2)
        {
            Debug.LogWarning("HarmonicFusion: At least two audio clips are required for crossfading.");
        }
        else
        {
            InitializeClips();
        }
    }

    private void InitializeClips()
    {
        if (_randomizeOrder)
        {
            _audioClips = _audioClips.OrderBy(x => Random.Range(0f, 1f)).ToArray();
        }

        _currentClip = _audioClips[0];
        _nextClip = _audioClips[1];
    }

    private void Update()
    {
        CheckEasterEggInput();
    }

    private void CheckEasterEggInput()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            _easterEggKeyPresses++;
            if (_easterEggKeyPresses >= 5)
            {
                StartCoroutine(PlayEasterEgg());
                _easterEggKeyPresses = 0;
            }
        }
        else
        {
            _easterEggKeyPresses = 0;
        }
    }

    public void PlayNextClip()
    {
        if (_audioClips.Length < 2) return;

        if (_isCrossfading)
        {
            StopCoroutine(_currentCrossfadeRoutine);
            _isCrossfading = false;
        }

        _crossfadeProgress = 0f;
        _audioSource.volume = 1f;

        _currentClip = _nextClip;
        _nextClip = GetNextClip(_currentClip);

        if (_nextClip == null) return;

        _currentCrossfadeRoutine = StartCoroutine(CrossfadeToNextClip());
    }

    private AudioClip GetNextClip(AudioClip currentClip)
    {
        int currentIndex = System.Array.IndexOf(_audioClips, currentClip);
        int nextIndex = (currentIndex + 1) % _audioClips.Length;
        return _audioClips[nextIndex];
    }

    private IEnumerator CrossfadeToNextClip()
    {
        _isCrossfading = true;
        float duration = Mathf.Clamp(_crossfadeDuration, 0.1f, 5f);
        float elapsed = 0f;

        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            _crossfadeProgress = Mathf.Clamp01(elapsed / duration);
            _audioSource.volume = 1f - _crossfadeProgress;

            if (_audioSource.volume < _minVolumeThreshold)
            {
                _audioSource.Stop();
                _audioSource.clip = _nextClip;
                _audioSource.volume = 0f;
                _audioSource.Play();
            }

            yield return null;
        }

        _audioSource.volume = 0f;
        _isCrossfading = false;
    }

    private IEnumerator PlayEasterEgg()
    {
        if (_easterEggSound == null || _hasPlayedEasterEgg) yield break;

        _hasPlayedEasterEgg = true;

        // Visual feedback
        StartCoroutine(FlashEasterEggColor());

        // Play easter egg sound
        AudioSource tempSource = gameObject.AddComponent<AudioSource>();
        tempSource.playOnAwake = false;
        tempSource.clip = _easterEggSound;
        tempSource.SpatialBlend = 0f; // 2D sound
        tempSource.volume = 1f;
        tempSource.Play();

        // Wait for sound to finish
        yield return new WaitForSeconds(_easterEggSound.length);

        // Cleanup
        Destroy(tempSource);
        _hasPlayedEasterEgg = false;
    }

    private IEnumerator FlashEasterEggColor()
    {
        Renderer[] renderers = GetComponentsInChildren<Renderer>();
        if (renderers.Length == 0) yield break;

        float duration = 0.5f;
        float elapsed = 0f;
        Color originalColor = renderers[0].material.color;

        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            float progress = Mathf.Clamp01(elapsed / duration);
            foreach (Renderer renderer in renderers)
            {
                renderer.material.color = Color.Lerp(originalColor, _easterEggColor, progress);
            }
            yield return null;
        }

        // Reset to original color
        foreach (Renderer renderer in renderers)
        {
            renderer.material.color = originalColor;
        }
    }

    #region Editor Helpers
    private void OnValidate()
    {
        if (_audioClips == null || _audioClips.Length == 0)
        {
            Debug.LogWarning("HarmonicFusion: No audio clips assigned. Please assign at least two clips in the inspector.");
        }
    }
    #endregion
}

using UnityEngine;
using System.Collections.Generic;
using UnityEngine.UI;

/// <summary>
/// A creative object pooling system with a twist: pooled objects can be "evolved" over time.
/// This system is optimized for mobile-first with responsive behavior.
/// </summary>
public class EvolutionaryObjectPool : MonoBehaviour
{
    [Header("Pool Settings")]
    [SerializeField] private GameObject _prefabToPool;
    [SerializeField] private int _initialPoolSize = 5;
    [SerializeField] private int _minPoolSize = 3;
    [SerializeField] private int _maxPoolSize = 20;
    [SerializeField] private float _evolutionRate = 0.01f;
    [SerializeField] private float _minEvolutionRate = 0.001f;
    [SerializeField] private float _maxEvolutionRate = 0.1f;

    [Header("UI References")]
    [SerializeField] private Button _instantiateButton;
    [SerializeField] private Text _poolSizeText;
    [SerializeField] private Text _evolutionRateText;

    private List<GameObject> _activeObjects;
    private List<GameObject> _inactiveObjects;
    private int _currentPoolSize;
    private float _currentEvolutionRate;

    private void Awake()
    {
        _activeObjects = new List<GameObject>();
        _inactiveObjects = new List<GameObject>();

        // Initialize the pool with the minimum size for mobile optimization
        InitializePool(_minPoolSize);

        // Set up UI event handlers with touch/mobile considerations
        if (_instantiateButton != null)
        {
            _instantiateButton.onClick.AddListener(InstantiateObject);
        }

        UpdateUI();
    }

    private void InitializePool(int size)
    {
        for (int i = 0; i < size; i++)
        {
            GameObject obj = (GameObject)Instantiate(_prefabToPool);
            obj.SetActive(false);
            _inactiveObjects.Add(obj);
        }

        _currentPoolSize = size;
        _currentEvolutionRate = _evolutionRate;
    }

    public GameObject GetPooledObject()
    {
        if (_inactiveObjects.Count > 0)
        {
            GameObject obj = _inactiveObjects[_inactiveObjects.Count - 1];
            _inactiveObjects.RemoveAt(_inactiveObjects.Count - 1);
            _activeObjects.Add(obj);
            obj.SetActive(true);

            // Apply current evolution mutation
            ApplyMutation(obj);

            return obj;
        }
        else if (_currentPoolSize < _maxPoolSize)
        {
            // Grow the pool if we need more objects
            GameObject newObj = (GameObject)Instantiate(_prefabToPool);
            _activeObjects.Add(newObj);
            newObj.SetActive(true);

            ApplyMutation(newObj);
            _currentPoolSize++;

            return newObj;
        }
        else
        {
            // No more objects available in the pool
            return null;
        }
    }

    private void ApplyMutation(GameObject obj)
    {
        // Get the poolable component if it exists
        Poolable poolable = obj.GetComponent<Poolable>();

        if (poolable != null)
        {
            // Apply random mutation based on evolution rate
            float mutationAmount = Random.Range(-1, 1) * _currentEvolutionRate;

            // Example: Mutate scale with some constraints
            Vector3 currentScale = obj.transform.localScale;
            float newScale = currentScale.x + mutationAmount;
            newScale = Mathf.Clamp(newScale, 0.5f, 2.0f); // Constrain scale to reasonable values

            obj.transform.localScale = new Vector3(newScale, newScale, newScale);

            // Example: Mutate color with some constraints
            Color currentColor = poolable.GetColor();
            float r = Mathf.Clamp01(currentColor.r + mutationAmount * 0.5f);
            float g = Mathf.Clamp01(currentColor.g + mutationAmount * 0.5f);
            float b = Mathf.Clamp01(currentColor.b + mutationAmount * 0.5f);

            poolable.SetColor(new Color(r, g, b));

            // Example: Mutate material properties
            Renderer renderer = obj.GetComponent<Renderer>();
            if (renderer != null)
            {
                Material material = renderer.material;
                material.SetFloat("_Metallic", Mathf.Clamp01(material.GetFloat("_Metallic") + mutationAmount * 0.1f));
                material.SetFloat("_Glossiness", Mathf.Clamp01(material.GetFloat("_Glossiness") + mutationAmount * 0.1f));
            }
        }
    }

    public void ReturnObject(GameObject obj)
    {
        if (_activeObjects.Contains(obj))
        {
            _activeObjects.Remove(obj);
            obj.SetActive(false);
            _inactiveObjects.Add(obj);

            // Adjust pool size based on usage for mobile optimization
            if (_currentPoolSize > _minPoolSize && _inactiveObjects.Count > _currentPoolSize * 0.5f)
            {
                // Reduce pool size if we have too many inactive objects
                GameObject toDestroy = _inactiveObjects[0];
                _inactiveObjects.RemoveAt(0);
                Destroy(toDestroy);
                _currentPoolSize--;
            }
        }
    }

    public void InstantiateObject()
    {
        GameObject obj = GetPooledObject();
        if (obj != null)
        {
            // For mobile, we'll position it near the center but with some randomness
            Vector3 spawnPosition = Camera.main.ViewportToWorldPoint(new Vector3(Random.Range(0.2f, 0.8f), Random.Range(0.2f, 0.8f), 10));
            obj.transform.position = spawnPosition;

            // Set up a return timer for the object
            StartCoroutine(ReturnObjectAfterDelay(obj, Random.Range(1f, 3f));
        }
    }

    private System.Collections.IEnumerator ReturnObjectAfterDelay(GameObject obj, float delay)
    {
        yield return new WaitForSeconds(delay);
        ReturnObject(obj);
    }

    private void Update()
    {
        // Gradually increase evolution rate over time for interesting behavior
        _currentEvolutionRate = Mathf.Lerp(_currentEvolutionRate, _maxEvolutionRate, Time.deltaTime * _evolutionRate);

        // If evolution rate is too low, reset it to avoid stagnation
        if (_currentEvolutionRate < _minEvolutionRate)
        {
            _currentEvolutionRate = _minEvolutionRate;
        }

        UpdateUI();
    }

    private void UpdateUI()
    {
        if (_poolSizeText != null)
        {
            _poolSizeText.text = $"Pool Size: {_currentPoolSize} (Active: {_activeObjects.Count}, Inactive: {_inactiveObjects.Count})";
        }

        if (_evolutionRateText != null)
        {
            _evolutionRateText.text = $"Evolution Rate: {_currentEvolutionRate:F4}";
        }
    }

    // Simple interface for poolable objects to get/set color
    public interface Poolable
    {
        Color GetColor();
        void SetColor(Color color);
    }
}

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.EventSystems;
using UnityEngine.UI;

[RequireComponent(typeof(RectTransform))]
[DisallowMultipleComponent]
public class DynamicLocalizationStudio : MonoBehaviour, IPointerClickHandler
{
    [Header("CSV Import Settings")]
    [SerializeField] private TextAsset csvTemplate = null;
    [SerializeField] private bool autoImportOnStart = true;
    [SerializeField] private string delimiter = ",";
    [SerializeField] private bool includeHeader = true;

    [Header("UI Components")]
    [SerializeField] private Text targetText = null;
    [SerializeField] private TMPro.TMP_Text tmpTargetText = null;
    [SerializeField] private Slider blendSlider = null;
    [SerializeField] private Button languageButton = null;
    [SerializeField] private GameObject languagePanel = null;
    [SerializeField] private List<Sprite> languageFlags = new List<Sprite>();

    [Header("Visual Effects")]
    [SerializeField] private AnimationCurve blendCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);
    [SerializeField] private float blendDuration = 0.8f;
    [SerializeField] private bool useTMPColorGradient = false;

    [Header("Events")]
    [SerializeField] private UnityEvent<string> onLanguageChanged = new UnityEvent<string>();
    [SerializeField] private UnityEvent onLanguageBlendComplete = new UnityEvent();

    private Dictionary<string, Dictionary<string, string>> _languageData = new Dictionary<string, Dictionary<string, string>>();
    private Dictionary<string, string> _currentLanguage = new Dictionary<string, string>();
    private string _currentLanguageKey = "en";
    private bool _isBlending = false;
    private Coroutine _blendCoroutine = null;
    private TMPro.TMP_TextInfo _textInfo = new TMPro.TMP_TextInfo();

    private void Awake()
    {
        if (tmpTargetText == null && targetText == null)
        {
            Debug.LogError("DynamicLocalizationStudio: No text component assigned. Please assign either Text or TMP_Text.");
            enabled = false;
            return;
        }

        if (blendSlider != null) blendSlider.onValueChanged.AddListener(UpdateBlendProgress);
        if (languageButton != null) languageButton.onClick.AddListener(ToggleLanguagePanel);
        if (languagePanel != null) languagePanel.SetActive(false);

        if (autoImportOnStart && csvTemplate != null)
        {
            ImportCSV(csvTemplate);
        }
    }

    private void OnEnable()
    {
        if (blendSlider != null) blendSlider.onValueChanged.AddListener(UpdateBlendProgress);
        if (languageButton != null) languageButton.onClick.AddListener(ToggleLanguagePanel);
    }

    private void OnDisable()
    {
        if (blendSlider != null) blendSlider.onValueChanged.RemoveListener(UpdateBlendProgress);
        if (languageButton != null) languageButton.onClick.RemoveListener(ToggleLanguagePanel);
    }

    public void ImportCSV(TextAsset csvFile)
    {
        if (csvFile == null) return;

        _languageData.Clear();
        var lines = csvFile.text.Split('\n');

        if (includeHeader && lines.Length > 0)
        {
            var headers = lines[0].Split(delimiter);
            for (int i = 0; i < headers.Length; i++)
            {
                headers[i] = headers[i].Trim('"');
            }

            for (int i = 1; i < lines.Length; i++)
            {
                if (string.IsNullOrWhiteSpace(lines[i])) continue;

                var values = lines[i].Split(delimiter);
                if (values.Length != headers.Length) continue;

                for (int j = 0; j < values.Length; j++)
                {
                    values[j] = values[j].Trim('"');
                }

                if (!_languageData.ContainsKey(headers[0]))
                {
                    _languageData[headers[0]] = new Dictionary<string, string>();
                }

                for (int j = 1; j < headers.Length; j++)
                {
                    _languageData[headers[0]][headers[j]] = values[j - 1];
                }
            }
        }

        if (_languageData.Count == 0)
        {
            Debug.LogError("No valid language data found in CSV.");
            return;
        }

        if (_currentLanguageKey == null || !_languageData.ContainsKey(_currentLanguageKey))
        {
            _currentLanguageKey = _languageData.Keys.FirstOrDefault();
            if (_currentLanguageKey == null) return;
        }

        _currentLanguage = _languageData[_currentLanguageKey];
        UpdateText();
        Debug.Log($"Successfully imported {_languageData.Count} languages.");
    }

    public void ChangeLanguage(string languageKey)
    {
        if (string.IsNullOrEmpty(languageKey) || !_languageData.ContainsKey(languageKey)) return;

        _currentLanguageKey = languageKey;
        _currentLanguage = _languageData[languageKey];

        if (blendSlider != null) blendSlider.value = 0f;
        if (_blendCoroutine != null) StopCoroutine(_blendCoroutine);

        if (blendSlider != null && blendSlider.value < 1f) StartBlend(_currentLanguageKey);
        else UpdateText();

        onLanguageChanged.Invoke(_currentLanguageKey);
    }

    public void ToggleLanguagePanel()
    {
        languagePanel.SetActive(!languagePanel.activeSelf);
    }

    public void SetLanguageFromDropdown(string languageKey)
    {
        ToggleLanguagePanel();
        ChangeLanguage(languageKey);
    }

    private void UpdateBlendProgress(float value)
    {
        if (_isBlending)
        {
            float progress = Mathf.Clamp01(value);
            UpdateText(progress);
        }
    }

    private IEnumerator StartBlend(string targetKey)
    {
        _isBlending = true;
        _blendCoroutine = StartCoroutine(BlendLanguages(targetKey));
        yield return null;
    }

    private IEnumerator BlendLanguages(string targetKey)
    {
        float elapsed = 0f;
        Dictionary<string, string> targetLanguage = _languageData[targetKey];
        List<string> originalTexts = new List<string>();
        List<string> targetTexts = new List<string>();

        // Cache original and target texts
        foreach (var kvp in _currentLanguage)
        {
            originalTexts.Add(kvp.Value);
            targetTexts.Add(targetLanguage[kvp.Key]);
        }

        while (elapsed < 1f)
        {
            elapsed += Time.deltaTime / blendDuration;
            float t = Mathf.Clamp01(elapsed);
            UpdateText(t, originalTexts, targetTexts, true);
            yield return null;
        }

        _currentLanguageKey = targetKey;
        _currentLanguage = targetLanguage;
        _isBlending = false;
        onLanguageBlendComplete.Invoke();
    }

    private void UpdateText(float? blendProgress = null, List<string> originalTexts = null, List<string> targetTexts = null, bool isBlending = false)
    {
        if (targetText != null && tmpTargetText == null)
        {
            UpdateLegacyText(blendProgress, originalTexts, targetTexts, isBlending);
        }
        else if (tmpTargetText != null)
        {
            UpdateTMPText(blendProgress, originalTexts, targetTexts, isBlending);
        }
    }

    private void UpdateLegacyText(float? blendProgress, List<string> originalTexts, List<string> targetTexts, bool isBlending)
    {
        if (targetText == null) return;

        if (blendProgress.HasValue && isBlending)
        {
            float progress = blendProgress.Value;
            string blendedText = BlendTexts(originalTexts, targetTexts, progress);
            targetText.text = blendedText;
        }
        else
        {
            string text = string.Join("\n", _currentLanguage.Values);
            targetText.text = text;
        }
    }

    private void UpdateTMPText(float? blendProgress, List<string> originalTexts, List<string> targetTexts, bool isBlending)
    {
        if (tmpTargetText == null) return;

        if (blendProgress.HasValue && isBlending)
        {
            float progress = blendProgress.Value;
            string blendedText = BlendTexts(originalTexts, targetTexts, progress);
            tmpTargetText.text = blendedText;
        }
        else
        {
            string text = string.Join("\n", _currentLanguage.Values);
            tmpTargetText.text = text;
        }

        if (useTMPColorGradient)
        {
            tmpTargetText.GetTextInfo(tmpTargetText.text, out _textInfo);
            if (_textInfo.characterCount > 0)
            {
                TMP_Color32 startColor = tmpTargetText.color;
                TMP_Color32 endColor = tmpTargetText.color;

                if (isBlending)
                {
                    float t = blendProgress.Value;
                    endColor = Color.Lerp(startColor, tmpTargetText.color, t);
                }

                for (int i = 0; i < _textInfo.characterCount; i++)
                {
                    tmpTargetText.SetColor(i, _textInfo, endColor);
                }
            }
        }
    }

    private string BlendTexts(List<string> originalTexts, List<string> targetTexts, float progress)
    {
        if (originalTexts == null || targetTexts == null || originalTexts.Count != targetTexts.Count) return string.Empty;

        List<string> blendedLines = new List<string>();
        for (int i = 0; i < originalTexts.Count; i++)
        {
            string original = originalTexts[i];
            string target = targetTexts[i];
            float t = blendCurve.Evaluate(progress);
            string blended = BlendSingleLine(original, target, t);
            blendedLines.Add(blended);
        }

        return string.Join("\n", blendedLines);
    }

    private string BlendSingleLine(string original, string target, float t)
    {
        if (original == target) return original;

        if (original.Length != target.Length)
        {
            // Simple fallback if lengths don't match
            return ColorLerp(original, target, t);
        }

        StringBuilder blended = new StringBuilder();
        for (int i = 0; i < original.Length; i++)
        {
            char originalChar = original[i];
            char targetChar = target[i];
            blended.Append(ColorLerp(originalChar, targetChar, t));
        }

        return blended.ToString();
    }

    private string ColorLerp(string a, string b, float t)
    {
        if (a == b) return a;

        // Simple character-based blending (for demonstration)
        return $"{a}{(int)(t * 255) > 127 ? b : a}";
    }

    private string ColorLerp(char a, char b, float t)
    {
        // This is a very basic implementation - in a real scenario you'd want proper Unicode handling
        return (t < 0.5f) ? a : b;
    }

    public void OnPointerClick(PointerEventData eventData)
    {
        if (eventData.pointerCurrentRaycast.gameObject == languagePanel) return;
        ToggleLanguagePanel();
    }

    // Editor utility methods
#if UNITY_EDITOR
    private void Reset()
    {
        blendSlider = GetComponentInChildren<Slider>(true);
        languageButton = GetComponentInChildren<Button>(true);
        languagePanel = GetComponentInChildren<CanvasGroup>(true)?.gameObject;
        targetText = GetComponentInChildren<Text>(true);
        tmpTargetText = GetComponentInChildren<TMPro.TMP_Text>(true);

        if (languagePanel != null)
        {
            var buttons = languagePanel.GetComponentsInChildren<Button>(true);
            foreach (var button in buttons)
            {
                button.onClick.AddListener(() => SetLanguageFromDropdown(button.name));
            }
        }
    }

    [ContextMenu("Generate Sample CSV")]
    public void GenerateSampleCSV()
    {
        string sampleCSV = @"
en,de,es,fr
greeting,Hello,Hola,Salut
farewell,Goodbye,Adiós,Au revoir
language,English,Deutsch,Español,Français
blend_example,This text will blend,Dieser Text wird gemischt,Este texto se mezclará,Ce texte sera mélangé
";

        TextAsset sample = new TextAsset(sampleCSV);
        UnityEditor.AssetDatabase.CreateAsset(sample, "Assets/DynamicLocalizationSample.csv");
        csvTemplate = sample;
    }
#endif
}