A!leys Galerie

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
}