com.amanotes.magictilescore 0.4.2

package/Runtime/MoodChange/ColorHueExtensions.cs

@@ -0,0 +1,227 @@
+using UnityEngine;
+
+namespace Amanotes.MagicTilesCore
+{
+    public static class ColorHueExtensions
+    {
+        private static float GetHue01(Color c)
+        {
+            float r = c.r, g = c.g, b = c.b;
+
+            var max = Mathf.Max(r, Mathf.Max(g, b));
+            var min = Mathf.Min(r, Mathf.Min(g, b));
+            var delta = max - min;
+
+            if (delta <= 0.000001f)
+                return 0f;
+
+            float h;
+
+            if (Mathf.Approximately(max, r))
+                h = (g - b) / delta;
+            else if (Mathf.Approximately(max, g))
+                h = 2f + (b - r) / delta;
+            else
+                h = 4f + (r - g) / delta;
+
+            h /= 6f;
+            if (h < 0f) h += 1f;
+
+            return h;
+        }
+        private static Color WithHue01(Color c, float newHue)
+        {
+            Color.RGBToHSV(c, out _, out var s, out var v);
+            var final = Color.HSVToRGB(newHue, s, v);
+            final.a = c.a;
+            return final;
+        }
+        
+        
+        public static int GetHue(this Color c) => Mathf.RoundToInt(GetHue01(c) * 255);
+        public static Color WithHue(this Color c, int newHue) => WithHue01(c, newHue/255f);
+        
+        
+        // Material support
+        public static void SetHue(this Material m, Color c, int nameID, int customHue = -1)
+        {
+            if (m == null) return;
+            var c2 = c;
+            if (customHue != -1) c2 = c.WithHue(customHue);
+            m.SetColor(nameID, c2);
+        }
+        public static void SetHue(this Material m,int nameID, int hue)
+        {
+            if (m == null) return;
+            
+            var colorInfo = HueCache.GetOrCreateColorInfo(m);
+            if (!colorInfo.isValid)
+            {
+                colorInfo.CacheColor(m.GetColor(nameID));
+            }
+            
+            m.SetColor(nameID, colorInfo.GetColorWithNewHue(hue));
+        }
+        
+        public static int GetHue(this Material m,int nameID)
+            => m == null ? 0 : m.GetColor(nameID).GetHue();
+        public static Color WithHue(this Material m,int nameID, int hue)
+            => m == null ? Color.white : m.GetColor(nameID).WithHue(hue);
+        
+        
+        // Gradient Support
+        public static int GetHue(this Gradient g)
+        {
+            if (g == null) return 0;
+            var keys = g.colorKeys;
+            if (keys == null || keys.Length == 0) return 0;
+            return keys[0].color.GetHue();
+        }
+        
+        public static Gradient WithHue(this Gradient g, int newHue)
+        {
+            if (g == null) return null;
+
+            var keysC = g.colorKeys;
+            var keysA = g.alphaKeys;
+
+            for (var i = 0; i < keysC.Length; i++)
+            {
+                var c = keysC[i].color;
+                keysC[i].color = c.WithHue(newHue);
+            }
+
+            g.SetKeys(keysC, keysA);
+            return g;
+        }
+        
+        // Particle effect support
+        // for (var i = 0; i < particles.Count; i++)
+        // {
+        //     particles[i].startColor = c;
+        // }
+        
+        public static void SetHue(this ParticleSystem ps, int newHue)
+        {
+            if (ps == null) return;
+
+            var colorInfo = HueCache.GetOrCreateColorInfo(ps);
+            var main = ps.main;
+            var startColor = main.startColor;
+            
+            switch (startColor.mode)
+            {
+                case ParticleSystemGradientMode.Color:
+                    if (!colorInfo.isValid)
+                    {
+                        colorInfo.CacheColor(startColor.color);
+                    }
+                    startColor.color = colorInfo.GetColorWithNewHue(newHue);
+                    break;
+                case ParticleSystemGradientMode.Gradient:
+                    startColor.gradient = startColor.gradient.WithHue(newHue);
+                    break;
+                case ParticleSystemGradientMode.TwoColors:
+                    startColor.colorMin = startColor.colorMin.WithHue(newHue);
+                    startColor.colorMax = startColor.colorMax.WithHue(newHue);
+                    break;
+                case ParticleSystemGradientMode.TwoGradients:
+                    startColor.gradientMin = startColor.gradientMin.WithHue(newHue);
+                    startColor.gradientMax = startColor.gradientMax.WithHue(newHue);
+                    break;
+            }
+
+            main.startColor = startColor;
+        }
+
+        public static int GetHue(this ParticleSystem ps)
+        {
+            if (ps == null) return 0;
+            var sc = ps.main.startColor;
+
+            switch (sc.mode)
+            {
+                case ParticleSystemGradientMode.Color:
+                    return sc.color.GetHue();
+                case ParticleSystemGradientMode.Gradient:
+                    return sc.gradient.GetHue();
+                case ParticleSystemGradientMode.TwoColors:
+                    return sc.colorMax.GetHue();
+                case ParticleSystemGradientMode.TwoGradients:
+                    return sc.gradientMax.GetHue();
+                default:
+                    return 0;
+            }
+        }
+        
+        // Support Sprite Renderer
+        public static int GetHue(this SpriteRenderer sr)
+        {
+            return sr == null ? 0 : sr.color.GetHue();
+        }
+
+        public static void SetHue(this SpriteRenderer sr, int newHue)
+        {
+            if (sr == null) return;
+            
+            var colorInfo = HueCache.GetOrCreateColorInfo(sr);
+            if (!colorInfo.isValid)
+            {
+                colorInfo.CacheColor(sr.color);
+            }
+            
+            sr.color = colorInfo.GetColorWithNewHue(newHue);
+        }
+
+        public static Color WithHue(this SpriteRenderer sr, int newHue)
+        {
+            if (sr == null) return Color.white;
+            
+            var colorInfo = HueCache.GetOrCreateColorInfo(sr);
+            if (!colorInfo.isValid)
+            {
+                colorInfo.CacheColor(sr.color);
+            }
+            
+            var c = colorInfo.GetColorWithNewHue(newHue);
+            sr.color = c;
+            return c;
+        }
+        
+        // support TrailRenderer.colorGradient
+        public static int GetHue(this TrailRenderer tr)
+        {
+            if (tr == null) return 0;
+            return tr.colorGradient.GetHue();
+        }
+
+        public static void SetHue(this TrailRenderer tr, int newHue)
+        {
+            if (tr == null) return;
+            
+            var colorInfo = HueCache.GetOrCreateColorInfo(tr);
+            if (!colorInfo.isValid)
+            {
+                // For TrailRenderer, we cache the first color key of the gradient
+                var gradient = tr.colorGradient;
+                if (gradient != null && gradient.colorKeys.Length > 0)
+                {
+                    colorInfo.CacheColor(gradient.colorKeys[0].color);
+                }
+            }
+            
+            var g = tr.colorGradient;
+            g.WithHue(newHue);
+            tr.colorGradient = g;
+        }
+
+        public static Gradient WithHue(this TrailRenderer tr, int newHue)
+        {
+            if (tr == null) return null;
+            var g = tr.colorGradient;
+            g.WithHue(newHue);
+            tr.colorGradient = g;
+            return g;
+        }
+    }
+}

package/Runtime/MoodChange/ColorHueExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cbad9131893b4fe496e56d2a66e59ba0
+timeCreated: 1763518215

package/Runtime/MoodChange/HueCache.cs

@@ -0,0 +1,167 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Amanotes.MagicTilesCore
+{
+    /// <summary>
+    /// Shared hue cache system to prevent color drift when applying hue changes multiple times.
+    /// Maps UnityEngine.Object instances to their original color information.
+    /// </summary>
+    public static class HueCache
+    {
+        /// <summary>
+        /// Cached color information for a Unity object
+        /// </summary>
+        public class ColorInfo
+        {
+            public Color originalColorRGB;
+            public Vector3 originalHSV; // x=H, y=S, z=V
+            public float originalAlpha;
+            public bool isValid = false;
+            
+            public void CacheColor(Color color)
+            {
+                if (isValid)
+                {
+                    Debug.LogWarning($"CacheColor should happen once, previous: <{originalColorRGB}> --> {color}");
+                    return;
+                }
+                
+                originalColorRGB = color;
+                originalAlpha = color.a;
+                RGBToHSV(color, out float h, out float s, out float v);
+                originalHSV = new Vector3(h, s, v);
+                isValid = true;
+            }
+            
+            public Color GetColorWithNewHue(int hue)
+            {
+                if (!isValid)
+                {
+                    var c = HSVToRGB(hue, 0.9f, 0.9f, 1f);
+                    Debug.LogWarning($"Color not init: {hue}, default set to {c}!");
+                    CacheColor(c);
+                    
+                    return c;
+                }
+                var newHue = (hue / 255.0f) * 360.0f;
+                return HSVToRGB(newHue, originalHSV.y, originalHSV.z, originalAlpha);
+            }
+        }
+        
+        // Cache mapping UnityEngine.Object -> ColorInfo
+        private static readonly Dictionary<Object, ColorInfo> _colorCache = new Dictionary<Object, ColorInfo>();
+        
+        /// <summary>
+        /// Gets cached color info for a Unity object, creating it if it doesn't exist
+        /// </summary>
+        public static ColorInfo GetOrCreateColorInfo(Object unityObject)
+        {
+            if (unityObject == null) return null;
+            if (_colorCache.TryGetValue(unityObject, out var colorInfo)) return colorInfo;
+            
+            colorInfo = new ColorInfo();
+            _colorCache[unityObject] = colorInfo;
+            return colorInfo;
+        }
+        
+        /// <summary>
+        /// Clears cached color info for a specific object
+        /// </summary>
+        public static void ClearCache(Object unityObject)
+        {
+            if (unityObject != null)
+            {
+                _colorCache.Remove(unityObject);
+            }
+        }
+        
+        /// <summary>
+        /// Clears all cached color information
+        /// </summary>
+        public static void ClearAllCache()
+        {
+            _colorCache.Clear();
+        }
+        
+        /// <summary>
+        /// Gets the number of cached objects
+        /// </summary>
+        public static int CacheCount => _colorCache.Count;
+        
+        // HSV conversion methods (same as in AdjustHue for consistency)
+        private static void RGBToHSV(Color color, out float h, out float s, out float v)
+        {
+            float r = color.r;
+            float g = color.g;
+            float b = color.b;
+            
+            float max = Mathf.Max(r, Mathf.Max(g, b));
+            float min = Mathf.Min(r, Mathf.Min(g, b));
+            float delta = max - min;
+            
+            // Value
+            v = max;
+            
+            // Saturation
+            s = (max != 0) ? (delta / max) : 0;
+            
+            // Hue
+            if (delta == 0)
+            {
+                h = 0; // Undefined, but we'll use 0
+            }
+            else if (max == r)
+            {
+                h = ((g - b) / delta) % 6;
+            }
+            else if (max == g)
+            {
+                h = (b - r) / delta + 2;
+            }
+            else // max == b
+            {
+                h = (r - g) / delta + 4;
+            }
+            
+            h *= 60;
+            if (h < 0) h += 360;
+        }
+        
+        private static Color HSVToRGB(float h, float s, float v, float a)
+        {
+            float c = v * s;
+            float x = c * (1 - Mathf.Abs((h / 60) % 2 - 1));
+            float m = v - c;
+            
+            float r, g, b;
+            
+            if (h >= 0 && h < 60)
+            {
+                r = c; g = x; b = 0;
+            }
+            else if (h >= 60 && h < 120)
+            {
+                r = x; g = c; b = 0;
+            }
+            else if (h >= 120 && h < 180)
+            {
+                r = 0; g = c; b = x;
+            }
+            else if (h >= 180 && h < 240)
+            {
+                r = 0; g = x; b = c;
+            }
+            else if (h >= 240 && h < 300)
+            {
+                r = x; g = 0; b = c;
+            }
+            else // h >= 300 && h < 360
+            {
+                r = c; g = 0; b = x;
+            }
+            
+            return new Color(r + m, g + m, b + m, a);
+        }
+    }
+}

package/Runtime/MoodChange/HueCache.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c6998857b64004ab49a1dc9d2e876677
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/MoodChange/MoodChange.cs

@@ -0,0 +1,52 @@
+using System;
+using UnityEngine;
+
+namespace Amanotes.MagicTilesCore
+{
+    public static class MoodChange
+    {
+        [Serializable] public abstract class ColorAnim
+        {
+            [NonSerialized] protected Color fromColor;
+            [NonSerialized] protected Color targetColor;
+            
+            public virtual void SetTargetHue(int hue)
+            {
+                fromColor = GetCurrentColor(); 
+                targetColor = fromColor.WithHue(hue);
+            }
+            
+            protected abstract Color GetCurrentColor();
+            public abstract void Refresh(float lerp);
+        }
+
+        [Serializable] public class MaterialColorAnim : ColorAnim
+        {
+            [SerializeField] private Material material;
+            [SerializeField] private string colorProp = "_Color";
+            [NonSerialized] private int colorNameID = -1;
+            
+            protected override Color GetCurrentColor()
+            {
+                
+                if (!Application.isPlaying || colorNameID == -1) colorNameID = Shader.PropertyToID(colorProp);
+                return material.GetColor(colorNameID);
+            }
+
+            public override void Refresh(float lerp)
+            {
+                if (!Application.isPlaying || colorNameID == -1) colorNameID = Shader.PropertyToID(colorProp);
+                material.SetColor(colorNameID, Color.Lerp(fromColor, targetColor, lerp));
+            }
+        }
+        
+        [Serializable] public class FogColorAnim : ColorAnim
+        {
+            protected override Color GetCurrentColor() => RenderSettings.fogColor;
+            public override void Refresh(float lerp)
+            {
+                RenderSettings.fogColor = Color.Lerp(fromColor, targetColor, lerp);
+            }
+        }
+    }
+}

package/Runtime/MoodChange/MoodChange.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0b1f7320d1394b71a96e045f217de7dd
+timeCreated: 1763525880

package/Runtime/MoodChange.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5ddb7f56900a4b9899323e1a48ebef6b
+timeCreated: 1763525701

package/Runtime/Physics/TriggerCallback.cs

@@ -0,0 +1,21 @@
+using System;
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace Amanotes.MagicTilesCore
+{
+    [Serializable]
+    public class TriggerEvent : UnityEvent<string> { }
+    public class TriggerCallback : MonoBehaviour
+    {
+        [SerializeField] private string id = "";
+        [SerializeField] private string targetTag = "";
+        [SerializeField] private TriggerEvent OnTrigger;
+        
+        private void OnTriggerEnter(Collider other)
+        {
+            if (!other.CompareTag(targetTag)) return;
+            OnTrigger?.Invoke(id ?? gameObject.name);
+        }
+    }
+}

package/Runtime/Physics/TriggerCallback.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7b5f7a767cd9456f898b488d14a3afc6
+timeCreated: 1766647198

package/Runtime/Physics.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 71ea8110f5397466badf3d388acc2404
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Preset/AudioSourcePlayer/AudioSourcePlayer.cs

@@ -0,0 +1,153 @@
+using System;
+using UnityEngine;
+
+namespace Amanotes.MagicTilesCore
+{
+    public class AudioSourcePlayer : RhythmBehaviour, IAudioPlayer
+    {
+        public AudioSource source;
+        public bool fakeMode => context?.fakeMode ?? false;
+        
+        public override void Init()
+        {
+            context.audioPlayer = this;
+        }
+
+        public void Prepare()
+        {
+            if (!fakeMode && source != null)
+            {
+                source.playOnAwake = false;
+                source.loop = false;
+            }
+            
+            sourceTime = 0f;
+            simulateTime = 0f;
+            _isPlaying = false;
+            _audioSpeed = 1f;
+        }
+        
+        public void Play()
+        {
+            _isPlaying = true;
+            if (fakeMode) return;
+            
+            if (source != null)
+            {
+                sourceTime = source.clip != null ? source.time : 0f;
+                simulateTime = 0;
+                source.Play();
+            }
+        }
+
+        public bool isPlaying => !fakeMode && source != null ? source.isPlaying : _isPlaying;
+
+        public void Pause()
+        {
+            _isPlaying = false;
+            if (fakeMode || source == null) return;
+            source.Pause();
+            sourceTime = source.clip != null ? source.time : 0f;
+            simulateTime = 0;
+        }
+        
+        public void Seek(float time)
+        {
+            var duration = ((IAudioPlayer)this).audioDuration;
+            
+            if (duration <= 0)
+            {
+                RhythmDebug.Log("Audio", $"AudioSourcePlayer.Seek: Cannot seek when audio duration is {duration}. Audio clip may not be loaded.");
+                return;
+            }
+            
+            if (time < 0 || time > duration)
+            {
+                RhythmDebug.Log("Audio", $"AudioSourcePlayer.Seek: Invalid seek time {time:F3}s. Valid range is [0, {duration:F3}]s. Clamping to valid range.");
+                time = Mathf.Clamp(time, 0, duration);
+            }
+
+            if (fakeMode)
+            {
+                sourceTime = time;
+                simulateTime = 0;
+                return;
+            }
+            
+            if (source == null)
+            {
+                RhythmDebug.Log("Audio", "AudioSourcePlayer.Seek: AudioSource is null");
+                return;
+            }
+            
+            if (source.clip == null)
+            {
+                RhythmDebug.Log("Audio", "AudioSourcePlayer.Seek: AudioSource.clip is null");
+                return;
+            }
+            
+            // Final validation against actual clip length
+            if (time >= source.clip.length)
+            {
+                RhythmDebug.Log("Audio", $"AudioSourcePlayer.Seek: Seek time {time:F3}s exceeds clip length {source.clip.length:F3}s. Clamping to clip length.");
+                time = source.clip.length-0.001f;
+            }
+            
+            try
+            {
+                source.time = time;
+                sourceTime = source.time;
+                simulateTime = time - sourceTime;
+            }
+            catch (System.Exception ex)
+            {
+                Debug.LogWarning("Audio --> " + $"AudioSourcePlayer.Seek: Failed to seek to time {time:F3}s / {source.clip.length}. Error: {ex.Message}");
+            }
+        }
+        
+        private float sourceTime;
+        private float simulateTime;
+        private bool _isPlaying;
+        private float _audioSpeed = 1f;
+
+        private const float TIME_SYNC_THRESHOLD = 0.001f;
+
+        public float audioTime => sourceTime + simulateTime;
+        float IAudioPlayer.audioDuration => (!fakeMode && source != null && source.clip != null ? source.clip.length : 0f);
+        public float audioSpeed
+        {
+            get => !fakeMode && source != null ? source.pitch : _audioSpeed;
+            set
+            {
+                _audioSpeed = value;
+                if (!fakeMode && source != null)
+                {
+                    source.pitch = value;
+                }
+            }
+        }
+
+
+        public void UpdateTime(float dt)
+        {
+            if (!isPlaying) return;
+            if (fakeMode)
+            {
+                sourceTime += dt;
+                simulateTime = 0;
+                return;
+            }
+            
+            if (source != null && source.clip != null && Math.Abs(sourceTime - source.time) < TIME_SYNC_THRESHOLD)
+            {
+                simulateTime += dt;
+            }
+            else if (source != null && source.clip != null)
+            {
+                sourceTime = source.time;
+                simulateTime = 0;
+            }
+        }
+    }
+    
+}

package/Runtime/Preset/AudioSourcePlayer/AudioSourcePlayer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3d55a896b871a40daace03a806b3444f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: