com.amanotes.magictilescore 0.4.2

package/Runtime/Rhythm/Game/RhythmContext.cs

@@ -0,0 +1,312 @@
+using System;
+using System.Collections.Generic;
+using Amanotes.Core;
+using UnityEngine;
+using static Amanotes.Core.RhythmJson;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Amanotes.MagicTilesCore
+{
+    public struct KnotData
+    {
+        public VisualKnot prevKnot;
+        public VisualKnot nextKnot;
+        public float progress;
+        public int activeNoteIndex;
+        public Vector3 warpedPosition;
+        public Quaternion warpedRotation;
+        public bool knotChanged;
+    }
+    
+    [CreateAssetMenu(menuName = "Rhythm/Context")]
+    public partial class RhythmContext : ScriptableObject
+    {
+        [SerializeField] internal RhythmConfig _config;
+        [SerializeField] internal ListSongNote _songNotes;
+        [SerializeField] internal List<ScriptableObject> _gameConfigs = new List<ScriptableObject>();
+        [SerializeField] public bool isAutoPlay;
+        
+        // Editor state - persistent across edit/play mode
+        [SerializeField] internal int _editorSelectedTab = 0;
+        
+        [NonSerialized] internal bool _isReady;
+        [NonSerialized] internal bool _constantSpeed = true;
+        [NonSerialized] internal bool _hasInitialized = false;
+        [NonSerialized] internal bool _hasSongLoaded = false;
+        
+        [NonSerialized] private VisualSpeedMeta visualSpeedMeta;
+        [NonSerialized] public readonly VisualKnotLogic visualKnotLogic = new VisualKnotLogic();
+        [NonSerialized] private readonly List<VisualKnot> _tempKnots = new List<VisualKnot>();
+        
+        public RhythmConfig config => _config;
+        public ListSongNote songNotes => _songNotes;
+        
+        // Config property getters
+        public float touchLatency => _config.touchLatency;
+        public float deviceAudioLatency => _config.deviceAudioLatency;
+        public float noteGenerate_bufferTime => _config.noteGenerate_bufferTime;
+        public float noteDispose_delayTime => _config.noteDispose_delayTime;
+        public float loopPrepareTime => _config.loopPrepareTime;
+        public float rewindingDuration => _config.rewindingDuration;
+        public float gameDepartTime => _config.gameDepartTime;
+        public float endingBufferTime => _config.endingBufferTime;
+        public float mp3Offset => _config.mp3Offset;
+        public float audioSpeed;
+        public int nLanes => _config.nLanes;
+        public bool isAutoRewind => _config.isAutoRewind;
+        
+        public List<string> excludeFromAutoPlay => _config.excludeFromAutoPlay;
+        public PoolGroup tilePoolGroup => _config.tilePoolGroup;
+        public PoolGroup vfxPoolGroup => _config.vfxPoolGroup;
+        public List<RhythmDebug.TagConfig> debugTags => _config.debugTags;
+        
+        public float visualSpeed
+        {
+            get
+            {
+                if (_constantSpeed) return config.visualSpeed;
+                return ((VisualSpeedMeta.Info)visualSpeedMeta.currentMeta)?.speed ?? 1f;
+            }
+        } 
+        
+        [NonSerialized] public readonly RhythmStateMachine stateMachine = new RhythmStateMachine();
+        [NonSerialized] public RhythmGame game;
+        [NonSerialized] public IPrefabPool prefabPool;
+        [NonSerialized] public IAudioPlayer audioPlayer;
+        [NonSerialized] public RhythmMatch matchData;
+        [NonSerialized] public Dictionary<string, MetaLogic> gameMetas = new Dictionary<string, MetaLogic>();
+        [NonSerialized] public List<(string key, string value)> forceCreationMetas = new List<(string key, string value)>();
+        [NonSerialized] public bool fakeMode;
+        [NonSerialized] public int _forceMissNote = 0;
+        [NonSerialized] public int _forceWrongNote = 0;
+        
+        [NonSerialized] public float audioDuration;
+        [NonSerialized] public IVisualWarp visualWarp;
+        
+        public Transform tileParent => game?.tileParent ?? game?.transform;
+        
+        public Action OnGameInit, OnLoadingSong, OnSongLoaded;
+        public Action OnGamePrepare, OnGameReady, OnGameStart, OnGameStop;
+        public Action OnGamePause, OnGamePlay, OnGameDie, OnGameRevive;
+        public Action OnGameEnd, OnGameEndRound, OnGameReset, OnGameRewind, OnGameShutdown;
+        public Action OnGameNotReady, OnViewSizeChange, OnTileSpawn;
+        public Action<TileContext> OnTileMissed, OnWrongLaneTap, OnTileStatusChange;
+        public Action<string> OnGameStateChange;
+        public Action<float> OnGameProgress, OnVisualSpeedChange;
+#if SNAPBEAT
+        public Action<GameMode> OnGameModeChange;
+#endif
+        public Action<int> OnGameScoreChange;
+        public Action OnGameConfigChange;
+        public Action<string, string> OnMetaChanged;
+        public Action OnPrepareData, OnInit;
+        public Action<float> OnBeforeSeek, OnAfterSeek;
+        public Action OnInitDone;
+        public Action<VisualKnot, VisualKnot> OnKnotChanged;
+        public Action<int> OnActiveNoteChanged;
+        
+        [NonSerialized] private KnotData _knotData;
+        
+        public KnotData knotData => _knotData;
+        
+        public (SongNote, TileContext) GetNoteDetail(int noteIdx)
+        {
+            var songNote = songNotes.GetNoteAt(noteIdx);
+            if (songNote == null)
+            {
+                Debug.LogWarning("Invalid touch: SongNote not found <" + noteIdx + ">");
+                return (null, null);
+            }
+            
+            var tile = GetTileContext(noteIdx);
+            if (tile == null)
+            {
+                Debug.LogWarning("Invalid touch: TileContext not found <" + noteIdx + ">");
+                return (songNote, null);
+            }
+            
+            return (songNote, tile);
+        }
+        
+        public float GetTimeDistanceToNote(int noteIndex)
+        {
+            var note = songNotes.GetNoteAt(noteIndex);
+            if (note == null) return 0f;
+            return GetTimeDistanceToTimeAppear(note.time);
+        }
+        
+        public float GetTimeDistanceToNote(SongNote note)
+        {
+            return GetTimeDistanceToTimeAppear(note.time);
+        }
+        
+        public float GetTimeDistanceToTimeAppear(float timeAppear)
+        {
+            return timeAppear - (gameTime - gameDepartTime);
+        }
+
+        public float GetPositionDistanceToNote(int index)
+            => GetPositionDistanceToNote(songNotes.GetNoteAt(index));
+        
+        public float GetPositionDistanceToNote(SongNote note)
+        {
+            var currentPos = GetDistanceAtTime(gameTime - gameDepartTime);
+            return note.position - currentPos;
+        }
+
+        public void ResetListeners()
+        {
+            OnGameProgress = null;
+            OnGameStateChange = null;
+            OnViewSizeChange = null;
+            OnTileStatusChange = null;
+#if SNAPBEAT
+            OnGameModeChange = null;
+#endif
+            OnGameConfigChange = null;
+        }
+        
+        /// <summary>
+        /// INTERNAL: Initializes core game systems (matchData, prefabPool) during engine setup.
+        /// Called once during initialization by InitializeCoroutine().
+        /// External code should NOT call this - use InitGame() + SetupSong() instead.
+        /// For gameplay reset, use StopGame() which returns to PREPARE state.
+        /// </summary>
+        internal void InitializeCoreSystems()
+        {
+            if (game == null)
+            {
+                Debug.LogWarning("InitializeCoreSystems called but game is null");
+                return;
+            }
+            
+            matchData = game.CreateMatchData();
+            matchData.Init(this);
+            
+            if (prefabPool != null)
+            {
+                prefabPool.RegisterGroup(tilePoolGroup, tileParent);
+                prefabPool.RegisterGroup(vfxPoolGroup, tileParent);
+                game.StartCoroutine(prefabPool.Initialize());
+            }
+            
+            OnGameReset?.Invoke();
+        }
+        
+        [Obsolete("Use InitializeCoreSystems() for clarity")]
+        public void ResetGame() => InitializeCoreSystems();
+
+        public (VisualKnot prevKnot, VisualKnot nextKnot, float percent) GetKnotInfo(float time)
+            => visualKnotLogic.InterpolateKnot(time);
+
+        public void ClearAllData()
+        {
+            stateMachine.Clear();
+            
+            OnGameInit = null;
+            OnLoadingSong = null;
+            OnSongLoaded = null;
+            OnGamePrepare = null;
+            OnGameReady = null;
+            OnGameNotReady = null;
+            OnGameStart = null;
+            OnGameStop = null;
+            OnGamePlay = null;
+            OnGamePause = null;
+            OnGameDie = null;
+            OnGameRewind = null;
+            OnGameRevive = null;
+            OnGameEnd = null;
+            OnGameEndRound = null;
+            OnGameReset = null;
+            OnGameShutdown = null;  // Added missing event
+            
+            // Progress and state events
+            OnGameProgress = null;  // Added missing event
+            OnGameStateChange = null;  // Added missing event
+            OnViewSizeChange = null;
+            OnGameRewind = null;
+            OnGameShutdown = null;
+#if SNAPBEAT
+            OnGameModeChange = null;
+#endif
+            OnGameScoreChange = null;
+            OnGameConfigChange = null;
+            OnVisualSpeedChange = null;
+            OnMetaChanged = null;
+            
+            // Tile events
+            OnTileSpawn = null;
+            OnTileStatusChange = null;
+            OnTileMissed = null;
+            OnWrongLaneTap = null;
+            
+            // Knot tracking events
+            OnKnotChanged = null;  // Added missing event
+            OnActiveNoteChanged = null;  // Added missing event
+            
+            // Init events
+            OnPrepareData = null;
+            OnInit = null;
+            OnInitDone = null;
+            OnBeforeSeek = null;
+            OnAfterSeek = null;
+            
+            if (tm != null)
+            {
+                tm.ResetAndClear();
+            }
+            
+            DetachAll();
+            gameMetas.Clear();
+            
+            if (audioPlayer != null)
+            {
+                audioPlayer.Pause();
+                audioPlayer.Seek(0);
+            }
+            
+            game = null;
+            prefabPool = null;
+            audioPlayer = null;
+            matchData = null;
+            visualSpeedMeta = null;
+            visualKnotLogic.Clear();
+            
+            // Temp
+            _firstActive = null;
+            _isPlaying = false;
+            _isRewinding = false;
+            _rewindTimeElapse = 0f;
+            _rewindStartTime = 0f;
+            _rewindEndTime = 0f;
+            _rewindToNoteIndex = -1;
+
+            _wasAutoPlay = false;
+            _constantSpeed = true;
+            _isReady = false;
+            _hasInitialized = false;
+            _hasSongLoaded = false;
+#if SNAPBEAT
+            _gameMode = GameMode.Play;
+#endif
+            _isInitialized = false;
+
+            config.context = null;
+        }
+
+#if UNITY_EDITOR
+        private void OnValidate()
+        {
+            if (PrefabUtility.IsPartOfPrefabAsset(this)) return;
+            if (!UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode && UnityEditor.EditorApplication.isPlaying)
+            {
+                ClearAllData();
+            }
+        }
+#endif
+    }
+}

package/Runtime/Rhythm/Game/RhythmContext.cs.meta

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

package/Runtime/Rhythm/Game/RhythmContextExtensions.cs

@@ -0,0 +1,91 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+using static Amanotes.Core.RhythmJson;
+namespace Amanotes.MagicTilesCore
+{
+    public static class RhythmContextExtensions
+    {
+        internal static void SafeSeek(this IAudioPlayer audioPlayer, float time, bool autoPlayPause = true)
+        {
+            if (audioPlayer == null) 
+            {
+                Debug.LogWarning("SafeSeek: AudioPlayer is null");
+                return;
+            }
+            
+            float duration = audioPlayer.audioDuration;
+            if (duration <= 0)
+            {
+                Debug.LogWarning($"SafeSeek: Cannot seek when audio duration is {duration}. Audio may not be loaded.");
+                return;
+            }
+            
+            float clampedTime = Mathf.Clamp(time, 0, duration);
+            RhythmContext.LogAudio($"SafeSeek: Seeking to time {time:F3}s (clamped to {clampedTime:F3}s, duration: {duration:F3}s)");
+            
+            try
+            {
+                audioPlayer.Seek(clampedTime);
+            }
+            catch (System.Exception ex)
+            {
+                Debug.LogError($"SafeSeek: Failed to seek to time {clampedTime:F3}s. Error: {ex.Message}");
+                return;
+            }
+            
+            if (autoPlayPause == false) return;
+            
+            if (time <= 0 || time >= duration)
+            {
+                RhythmContext.LogAudio($"SafeSeek: Pausing audio (time {time:F3}s out of bounds [0, {duration:F3}])");
+                audioPlayer.Pause();
+            }
+            else
+            {
+                if (!audioPlayer.isPlaying)
+                {
+                    RhythmContext.LogAudio($"SafeSeek: Starting audio playback");
+                    audioPlayer.Play();
+                }
+            }
+        }
+        
+        internal static void TransitionToPlayMode(this RhythmContext context)
+        {
+#if SNAPBEAT
+            if (context.IsEditMode)
+            {
+                context.CurrentGameMode = GameMode.Play;
+                if (context.audioPlayer != null) context.audioPlayer.Seek(Mathf.Max(0, context.audioSeekTime));
+            }
+#endif
+            
+            context._firstActive = null;
+            context.UpdateAllTileStatus();
+        }
+
+        private static readonly List<(SongNote note,TileContext tile)> updateList = new List<(SongNote,TileContext)>();
+        internal static void UpdateAllTileStatus(this RhythmContext context)
+        {
+            updateList.Clear();
+            
+            // Optimized: Direct iteration instead of LINQ for better performance
+            foreach (var kvp in context.tileMap)
+            {
+                var note = context.songNotes.GetNoteAt(kvp.Key);
+                if (note != null)
+                {
+                    updateList.Add((note, kvp.Value));
+                }
+            }
+
+            for (var i = 0; i < updateList.Count; i++)
+            {
+                var item = updateList[i];
+                context.UpdateNoteStatusFromTime(item.tile, item.note);
+            }
+        }
+    }
+}

package/Runtime/Rhythm/Game/RhythmContextExtensions.cs.meta

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

package/Runtime/Rhythm/Game/Tile/ITileProgress.cs

@@ -0,0 +1,7 @@
+namespace Amanotes.MagicTilesCore
+{
+    public interface ITileProgress
+    {
+        void RefreshTileProgress();
+    }
+}

package/Runtime/Rhythm/Game/Tile/ITileProgress.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aa518514f9a64e3aafab02386af27319
+timeCreated: 1757249668

package/Runtime/Rhythm/Game/Tile/TileContext.cs

@@ -0,0 +1,194 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+using static Amanotes.Core.RhythmJson;
+namespace Amanotes.MagicTilesCore
+{
+    public enum TileStatus
+    {
+        None,
+        Touching,
+        End,
+        Missed,
+    }
+
+
+    public sealed class TileContext
+    {
+        public readonly int index;
+        public readonly SongNote note;
+        public readonly RhythmContext context;
+        public readonly float slideLength;
+        public readonly List<VisualKnot> knots = new List<VisualKnot>();
+        
+        public TileContext(int index, SongNote note, RhythmContext context)
+        {
+            this.index = index;
+            this.note = note;
+            this.context = context;
+            slideLength = context.config.GetSlideLength(note);
+            
+            context.visualKnotLogic.ExtractKnotsByNoteIdx(knots, index);
+        }
+
+        public float GetKnotProgressAtTime(float time)
+        {
+            if (knots.Count == 0) return 0f;
+            if (knots.Count == 1) return 0f;
+            
+            // If time is before first knot, return 0
+            if (time <= knots[0].time) return 0f;
+            
+            // If time is after last knot, return last knot index
+            if (time >= knots[knots.Count - 1].time) return knots.Count - 1;
+            
+            // Linear search for the knot segment
+            for (int i = 0; i < knots.Count - 1; i++)
+            {
+                var currentKnot = knots[i];
+                var nextKnot = knots[i + 1];
+                
+                if (time >= currentKnot.time && time <= nextKnot.time)
+                {
+                    // Calculate progress within this segment
+                    float segmentDuration = nextKnot.time - currentKnot.time;
+                    if (segmentDuration <= 0f) return i;
+                    
+                    float segmentProgress = (time - currentKnot.time) / segmentDuration;
+                    return i + segmentProgress;
+                }
+            }
+            
+            return knots.Count - 1;
+        }
+        
+        public float? perfectLinePos;
+        public float progress = 0f; // For long notes progress tracking
+        public float accuracy = -1;
+        public float stTouchDiff = -1;
+        public float edTouchDiff = -1;
+
+        public RhythmTile view { get; private set; }
+
+        public TileContext AttachView()
+        {
+            if (view != null) return this;
+            Status = TileStatus.None;
+            RhythmContext.LogTileLifecycle($"AttachView: Getting prefab for tile {index} type '{note.type}'");
+            view = context.game.CreateRhythmTile(note);
+            if (view == null)
+            {
+                RhythmContext.LogTileLifecycle($"Failed to get prefab for tile {index} type '{note.type}'");
+                Debug.LogWarning($"Unsupported type (no prefab): <{note.type}> | {note.index}");
+            }
+
+            if (view == null) return this;
+            view.OnAttach(this);
+            view.RefreshTileStatus(); // force refresh tile status
+            RhythmContext.LogTileLifecycle($"AttachView: Successfully attached tile {index} type '{note.type}'");
+            context.OnTileSpawn?.Invoke();
+            return this;
+        }
+
+        public void RemoveView()
+        {
+            if (view == null) return;
+
+            RhythmContext.LogTileLifecycle($"RemoveView: Detaching tile {index} type '{note.type}'");
+            context.Unregister((MonoBehaviour)view);
+            view.OnDetach();
+            view.tileContext = null;
+            context.config.tilePoolGroup.Return(view.gameObject);
+            RhythmContext.LogTileLifecycle($"RemoveView: Returned tile {index} to pool");
+            view = null;
+        }
+        
+        public NoteControl endControl
+        {
+            get
+            {
+                if (note?.controls == null || note.controls.Count == 0) return null;
+                return note.controls[note.controls.Count - 1];
+            }
+        }
+
+        public bool hasView => view != null;
+
+        private TileStatus _status;
+        public TileStatus Status
+        {
+            get => _status;
+            set
+            {
+                if (_status == value) return;
+                var oldStatus = _status;
+                _status = value;
+                RhythmContext.LogTileStatus($"Tile {index}: Status changed from {oldStatus} to {value}");
+
+                if (_status == TileStatus.None)
+                {
+                    accuracy = -1;
+                    progress = 0f;
+                    stTouchDiff = -1;
+                    edTouchDiff = -1;
+                }
+
+                context.OnTileStatusChange?.Invoke(this);
+                if (_status == TileStatus.Touching || (_status == TileStatus.End && note.duration > 0))
+                {
+                    context.matchData.CalculateScore(this);
+                }
+                
+                view.RefreshTileStatus();
+            }
+        }
+
+        public void CalculateAutoProgress()
+        {
+            var note = context.songNotes.GetNoteAt(index);
+            float noteStartTime = note.time + context.config.gameDepartTime;
+            float noteEndTime = noteStartTime + note.duration;
+            float currentTime = context.gameTime;
+
+            // Calculate progress (0 to 1) based on current game time
+            if (currentTime >= noteStartTime && currentTime <= noteEndTime)
+            {
+                progress = Mathf.Clamp01(FillingProgress);
+            }
+            else if (currentTime < noteStartTime)
+            {
+                progress = 0f;
+            }
+            else if (currentTime > noteEndTime)
+            {
+                progress = 1f;
+            }
+        }
+
+        public float FillingProgress
+        {
+            get
+            {
+                var note = context.songNotes.GetNoteAt(index);
+                if (note.duration <= 0f) return 0f;
+
+                float noteStartTime = note.time;
+                float noteEndTime = noteStartTime + note.duration;
+                float currentAudioTime = context.audioTime;
+
+                // Use VisualSpeedMeta position differences instead of simple time
+                float noteStartPos = context.GetDistanceAtTime(noteStartTime);
+                float noteEndPos = context.GetDistanceAtTime(noteEndTime);
+                float currentPos = context.GetDistanceAtTime(currentAudioTime);
+
+                float totalDistance = noteEndPos - noteStartPos;
+                if (totalDistance <= 0f) return 0f;
+
+                float currentDistance = currentPos - noteStartPos;
+                return currentDistance / totalDistance;
+            }
+        }
+    }
+}
+

package/Runtime/Rhythm/Game/Tile/TileContext.cs.meta

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

package/Runtime/Rhythm/Game/Tile.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6d7ad9c807a84102b9b36835e727659f
+timeCreated: 1757248867

package/Runtime/Rhythm/Game.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b9c8a8d6eca54b978d625642f82bc8cd
+timeCreated: 1757248903

package/Runtime/Rhythm/Math/Parabol.cs

@@ -0,0 +1,35 @@
+using System;
+using UnityEngine;
+
+[Serializable]
+public class Parabol
+{
+    public float g;
+    public float v0;
+    public float y0;
+
+    public float GetY(float t)
+    {
+        return y0 + v0 * t + g * t * t / 2f;
+    }
+
+	public float GetVY(float t)
+	{
+		return v0 + g*t;
+	}
+
+    public static Parabol Calculate(float hA, float hB, float hJump)
+    {
+        var result = new Parabol();
+        var hMax = Mathf.Max(hA, hB) + hJump;
+
+        var h1 = hMax - hA;
+        var h2 = hB - hA;
+
+        result.y0 = hA;
+        result.v0 = 2 * h1 + 2 * Mathf.Sqrt(h1 * (h1 - h2));
+        result.g = 2 * (h2 - result.v0);
+
+        return result;
+    }
+}