com.amanotes.magictilescore 0.4.2

package/Editor/RhythmContextEditor.cs

@@ -0,0 +1,587 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Profiling;
+using Amanotes.Core;
+using static Amanotes.Core.RhythmJson;
+namespace Amanotes.MagicTilesCore
+{
+    [CustomEditor(typeof(RhythmContext), true)]
+    public partial class RhythmContextEditor : Editor
+    {
+        private int _selectedTab = 0;
+        private readonly string[] _tabNames = { "Config", "Pool", "Extra", "Debug" };
+        private int _selectedDebugTab = 0;
+        private readonly string[] _debugTabNames = { "Registered Views", "Runtime", "Active Tile" };
+        private static int _selectedNoteIndex = 0;
+        private List<EditorDrawer> _configEditorDrawers;
+        private EditorDrawer _rhythmConfigEditorDrawer;
+        private bool _metaSystemsExpanded = true;
+        private bool _listNoteDataExpanded = true;
+        private ClassInstanceDrawer _matchDataDrawer;
+        private ClassInstanceDrawer _rhythmContextDrawer;
+        private ClassInstanceDrawer _tileContextDrawer;
+        private ClassInstanceDrawer _songNotesDrawer;
+        private ClassInstanceDrawer _listNoteDataDrawer;
+        
+        private static readonly HashSet<string> _matchDataForceHideMembers = new HashSet<string> { "context" };
+        private static readonly HashSet<string> _rhythmContextForceHideMembers = new HashSet<string> { "_config" };
+        private static readonly HashSet<string> _tileContextForceShowMembers = new HashSet<string> { "note" };
+        
+        private List<ConfigGroup> _configGroups = new List<ConfigGroup>();
+        private ScriptableObject _lastConfig = null;
+        private int _selectedConfigTab = 0;
+        
+        private class ConfigGroup
+        {
+            public System.Type groupType;
+            public string title;
+            public bool isExpanded;
+            public List<string> propertyNames;
+            
+            public ConfigGroup(System.Type type, string title)
+            {
+                this.groupType = type;
+                this.title = title;
+                this.isExpanded = true;
+                this.propertyNames = new List<string>();
+            }
+        }
+
+        private void OnEnable()
+        {
+            var context = (RhythmContext)target;
+            _selectedTab = context._editorSelectedTab;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            var context = (RhythmContext)target;
+            var config = (serializedObject.targetObject as RhythmContext)._config;
+            if (config == null)
+            {
+                EditorGUILayout.HelpBox("Config is null - Please assign a RhythmConfig and ListSongNote", MessageType.Warning);
+                
+                // Show object fields for drag & drop when config is null
+                EditorGUILayout.Space();
+                EditorGUILayout.LabelField("Assign Required Assets:", EditorStyles.boldLabel);
+                
+                // Config object field
+                var configProperty = serializedObject.FindProperty("_config");
+                if (configProperty != null)
+                {
+                    EditorGUILayout.PropertyField(configProperty, new GUIContent("Game Config"));
+                }
+                
+                // Song Notes object field
+                var songNotesProperty = serializedObject.FindProperty("_songNotes");
+                if (songNotesProperty != null)
+                {
+                    EditorGUILayout.PropertyField(songNotesProperty, new GUIContent("Song Notes"));
+                }
+                
+                serializedObject.ApplyModifiedProperties();
+                return;
+            }
+
+            var configSO = new SerializedObject(config);
+            configSO.Update();
+            
+            var originalLabelWidth = EditorGUIUtility.labelWidth;
+            
+            DrawGameController(context);
+            GUILayout.Space(16f);
+            
+            int newSelectedTab = GUILayout.Toolbar(_selectedTab, _tabNames, GUILayout.Height(30));
+            if (newSelectedTab != _selectedTab)
+            {
+                _selectedTab = newSelectedTab;
+                // Save tab selection to ScriptableObject (persistent across edit/play mode)
+                context._editorSelectedTab = _selectedTab;
+                EditorUtility.SetDirty(context); // Mark as dirty to save changes
+            }
+            EditorGUILayout.Space();
+            
+            switch (_selectedTab)
+            {
+                case 0: DrawConfigTab(context); break;
+                case 1: DrawPoolTab(configSO); break;
+                case 2: DrawExtraTab(context); break;
+                case 3:
+                {
+                    DrawDebugTab(context, configSO);
+                }
+                break;
+            }
+            
+            if (GUI.changed)
+            {
+                EditorUtility.SetDirty(target);
+                serializedObject.ApplyModifiedProperties();
+            }
+            
+            EditorGUIUtility.labelWidth = originalLabelWidth;
+            if (Application.isPlaying) Repaint();
+        }
+        
+        private void DrawConfigTab(RhythmContext context)
+        {
+            DrawSongNotesWithDetails(context);
+            EditorGUILayout.Space(8f);
+            EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(RhythmContext._config)), false, GUILayout.Height(EditorGUIUtility.singleLineHeight));
+            if (context._config != null)
+            {
+                DrawConfigWithGrouping(context._config);
+            }
+        }
+        
+        private void DrawConfigWithGrouping(ScriptableObject config)
+        {
+            if (config == null) return;
+            
+            GroupConfigPropertiesByInheritance(config);
+            
+            var configSO = new SerializedObject(config);
+            configSO.Update();
+            
+            // Create tab names from inheritance chain
+            var tabNames = _configGroups.Where(g => g.propertyNames.Count > 0).Select(g => g.title).ToArray();
+            
+            if (tabNames.Length > 0)
+            {
+                // Ensure selected tab is within bounds
+                _selectedConfigTab = Mathf.Clamp(_selectedConfigTab, 0, tabNames.Length - 1);
+                
+                // Draw child tab toolbar with default height
+                _selectedConfigTab = GUILayout.Toolbar(_selectedConfigTab, tabNames);
+                
+                // Draw properties for the selected tab with 1 level indentation
+                var selectedGroup = _configGroups.Where(g => g.propertyNames.Count > 0).ElementAtOrDefault(_selectedConfigTab);
+                if (selectedGroup != null)
+                {
+                    EditorGUI.indentLevel++;
+                    foreach (var propertyName in selectedGroup.propertyNames)
+                    {
+                        var property = configSO.FindProperty(propertyName);
+                        if (property != null)
+                        {
+                            EditorGUILayout.PropertyField(property, true);
+                        }
+                    }
+                    EditorGUI.indentLevel--;
+                }
+            }
+            
+            configSO.ApplyModifiedProperties();
+            
+            // Trigger config change callback during play time when config values change
+            if (GUI.changed && Application.isPlaying)
+            {
+                var context = (RhythmContext)target;
+                context.OnGameConfigChange?.Invoke();
+            }
+        }
+        
+        private void GroupConfigPropertiesByInheritance(ScriptableObject config)
+        {
+            if (_configGroups.Count == 0 || _lastConfig != config)
+            {
+                _lastConfig = config;
+                _configGroups.Clear();
+                
+                var configType = config.GetType();
+                var inheritanceChain = GetInheritanceChain(configType);
+                
+                foreach (var type in inheritanceChain)
+                {
+                    var group = new ConfigGroup(type, type.Name);
+                    _configGroups.Add(group);
+                }
+                
+                var serializedObject = new SerializedObject(config);
+                var iterator = serializedObject.GetIterator();
+                
+                if (iterator.NextVisible(true))
+                {
+                    while (iterator.NextVisible(false))
+                    {
+                        if (iterator.depth > 0) continue;
+                        
+                        var fieldInfo = GetDirectFieldInfo(configType, iterator.propertyPath);
+                        if (fieldInfo != null)
+                        {
+                            var declaringType = fieldInfo.DeclaringType;
+                            var group = _configGroups.FirstOrDefault(g => g.groupType == declaringType);
+                            
+                            if (group != null)
+                            {
+                                group.propertyNames.Add(iterator.propertyPath);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+        private List<System.Type> GetInheritanceChain(System.Type type)
+        {
+            var chain = new List<System.Type>();
+            var current = type;
+            
+            while (current != null && current != typeof(ScriptableObject) && current != typeof(UnityEngine.Object))
+            {
+                chain.Add(current);
+                current = current.BaseType;
+            }
+            
+            // Reverse to get base classes first
+            chain.Reverse();
+            return chain;
+        }
+        
+        private FieldInfo GetDirectFieldInfo(System.Type type, string propertyPath)
+        {
+            // For direct fields, just get the field directly
+            return type.GetField(propertyPath, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+        }
+        
+
+        
+        
+        private void DrawPoolTab(SerializedObject configSO)
+        {
+            EditorGUILayout.PropertyField(configSO.FindProperty(nameof(RhythmContext.tilePoolGroup)), true);
+            EditorGUILayout.PropertyField(configSO.FindProperty(nameof(RhythmContext.vfxPoolGroup)), true);
+            EditorGUILayout.PropertyField(configSO.FindProperty(nameof(RhythmContext.excludeFromAutoPlay)), true);
+            
+            // Always apply changes and mark dirty
+            if (GUI.changed)
+            {
+                configSO.ApplyModifiedProperties();
+                EditorUtility.SetDirty(configSO.targetObject);
+                
+                // Trigger config change callback during play time
+                if (Application.isPlaying)
+                {
+                    var context = (RhythmContext)target;
+                    context.OnGameConfigChange?.Invoke();
+                }
+            }
+        }
+        
+        private void DrawExtraTab(RhythmContext context)
+        {
+            EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(RhythmContext._gameConfigs)), true);
+            DrawGameConfigsList(context);
+        }
+        
+        
+        private void DrawGameConfigsList(RhythmContext context)
+        {
+            // Initialize or update editor drawers
+            if (_configEditorDrawers == null)
+            {
+                _configEditorDrawers = new List<EditorDrawer>();
+            }
+            
+            // Clean up drawers for removed configs
+            for (int i = _configEditorDrawers.Count - 1; i >= 0; i--)
+            {
+                var drawer = _configEditorDrawers[i];
+                if (drawer.target == null || !context._gameConfigs.Contains(drawer.target))
+                {
+                    drawer.Dispose();
+                    _configEditorDrawers.RemoveAt(i);
+                }
+            }
+            
+            // Create drawers for new configs
+            foreach (var config in context._gameConfigs)
+            {
+                if (config == null) continue;
+                
+                var existingDrawer = _configEditorDrawers.Find(d => d.target == config);
+                if (existingDrawer == null)
+                {
+                    _configEditorDrawers.Add(new EditorDrawer(config));
+                }
+            }
+            
+            // Draw all editor drawers
+            foreach (var drawer in _configEditorDrawers)
+            {
+                drawer.Draw();
+            }
+        }
+        
+        private void OnDisable()
+        {
+            if (_configEditorDrawers == null) return;
+            foreach (var drawer in _configEditorDrawers)
+            {
+                drawer.Dispose();
+            }
+            _configEditorDrawers = null;
+            
+            _rhythmConfigEditorDrawer?.Dispose();
+            _rhythmConfigEditorDrawer = null;
+        }
+
+        private void DrawDebugTags(SerializedObject configSO)
+        {
+            var debugTagsProp = configSO.FindProperty("debugTags");
+            if (debugTagsProp != null)
+            {
+                EditorGUILayout.PropertyField(debugTagsProp, true);
+                configSO.ApplyModifiedProperties();
+            }
+        }
+
+        private bool _registeredViewsExpanded = true;
+        
+        private void DrawRegisteredViews(RhythmContext context)
+        {
+            var registeredViews = context._registeredViews;
+            int viewCount = registeredViews?.Count ?? 0;
+            
+            _registeredViewsExpanded = EditorGUILayout.Foldout(_registeredViewsExpanded, $"Registered Views ({viewCount})");
+            
+            if (_registeredViewsExpanded)
+            {
+                if (registeredViews == null || registeredViews.Count == 0)
+                {
+                    EditorGUILayout.HelpBox("No registered views", MessageType.Info);
+                    return;
+                }
+                
+                for (int i = 0; i < registeredViews.Count; i++)
+                {
+                    var view = registeredViews[i];
+                    if (view == null)
+                    {
+                        EditorGUILayout.LabelField($"[{i}] <null>");
+                        continue;
+                    }
+                    
+                    string viewName = view.GetType().Name;
+                    string priorityText = view is IRhythmBehaviourPriority priorityInterface ? 
+                        $" (Priority: {priorityInterface.Priority})" : "";
+                    
+                    EditorGUI.BeginDisabledGroup(true);
+                    EditorGUILayout.ObjectField($"[{i}] {viewName}{priorityText}", view as UnityEngine.Object, view.GetType(), true);
+                    EditorGUI.EndDisabledGroup();
+                }
+            }
+        }
+        
+        
+        private void DrawGameController(RhythmContext context)
+        {
+            if (!Application.isPlaying)
+            {
+                EditorGUILayout.BeginHorizontal();
+                context.isAutoPlay = EditorGUILayout.ToggleLeft("Auto", context.isAutoPlay, GUILayout.Width(60));
+                if (GUILayout.Button("▶ Enter Play Mode", GUILayout.Height(30)))
+                {
+                    EditorApplication.isPlaying = true;
+                }
+                EditorGUILayout.EndHorizontal();
+            }
+            else
+            {
+                // Draw time slider FIRST (topmost) - even before audio speed
+                DrawTimeSlider(context);
+                EditorGUILayout.Space(8f);
+                
+                // Audio Speed after time slider
+                context.audioSpeed = EditorGUILayout.Slider("Audio Speed", context.audioSpeed, 0.01f, 10f);
+                
+                // Auto Play + Stop/Pause buttons
+                EditorGUILayout.BeginHorizontal();
+                {
+                    context.isAutoPlay = EditorGUILayout.ToggleLeft("Auto", context.isAutoPlay, GUILayout.Width(60));
+                    
+                    bool canStop = context.gameTime > 0.1f;
+                    EditorGUI.BeginDisabledGroup(!canStop);
+                    if (GUILayout.Button("STOP", GUILayout.Height(30)))
+                    {
+                        context.StopGame();
+                    }
+                    EditorGUI.EndDisabledGroup();
+                
+                    if (GUILayout.Button(context.IsPlaying ? "▐▐" : "▶", GUILayout.Width(40), GUILayout.Height(30)))
+                    {
+                        if (!context.IsPlaying)
+                        {
+                            if (context.GameState != GameEvent.GAME_READY && context.GameState != GameEvent.GAME_STOP)
+                            {
+                                context.ResumeGame();
+                            }
+                            else
+                            {
+                                context.StartGame();
+                            }
+                        }
+                        else
+                        {
+                            context.PauseGame();
+                        }
+                    }
+                }
+                EditorGUILayout.EndHorizontal();
+                
+                // Draw Meta Systems after controls
+                EditorGUILayout.Space(8f);
+                DrawMetaSystems(context);
+            }
+        }
+        
+        private void DrawTimeSlider(RhythmContext ctx)
+        {
+            if (!Application.isPlaying || ctx == null) return;
+            
+            float maxTime = ctx.audioDuration > 0 ? ctx.audioDuration : 60f;
+            float currentTime = ctx.audioTime;
+            
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Time:", GUILayout.Width(40));
+            EditorGUILayout.LabelField($"{currentTime:F2}s", GUILayout.Width(50));
+            
+            // Time slider for seeking
+            float newTime = EditorGUILayout.Slider(currentTime, 0f, maxTime);
+            if (!Mathf.Approximately(newTime, currentTime))
+            {
+                ctx.SeekToAudioTime(newTime);
+            }
+            
+            EditorGUILayout.LabelField($"/ {maxTime:F2}s", GUILayout.Width(60));
+            EditorGUILayout.EndHorizontal();
+        }
+        
+        private void DrawMetaSystems(RhythmContext ctx)
+        {
+            if (!Application.isPlaying) return;
+            
+            // Skip if no meta data exists
+            if (ctx.gameMetas == null || ctx.gameMetas.Count == 0) return;
+            
+            // Let MetaLogicDrawer handle ALL the complexity and caching
+            MetaLogicDrawer.DrawMetaSystemsGroup(ctx, ref _metaSystemsExpanded);
+        }
+        
+        private void DrawMatchData(RhythmContext context)
+        {
+            if (context.matchData == null)
+                return;
+            
+            // Initialize drawer if needed
+            if (_matchDataDrawer == null)
+            {
+                _matchDataDrawer = new ClassInstanceDrawer(context.matchData.GetType(), drawProperties: false, forceHideMembers: _matchDataForceHideMembers);
+            }
+            
+            _matchDataDrawer.Draw(context.matchData, "Match Data");
+        }
+        
+        private void DrawRhythmContext(RhythmContext context)
+        {
+            if (context == null)
+                return;
+            
+            // Initialize drawer if needed
+            if (_rhythmContextDrawer == null)
+            {
+                _rhythmContextDrawer = new ClassInstanceDrawer(typeof(RhythmContext), drawProperties: false, forceHideMembers: _rhythmContextForceHideMembers);
+            }
+            
+            _rhythmContextDrawer.Draw(context, "Rhythm Context");
+        }
+        
+        private void DrawTileContext(RhythmContext context)
+        {
+            // Initialize drawer if needed - create once, reuse always
+            if (_tileContextDrawer == null)
+            {
+                _tileContextDrawer = new ClassInstanceDrawer(drawProperties: false, forceShowMembers: _tileContextForceShowMembers);
+            }
+            
+            // Get first touchable tile
+            var firstActiveTile = context?.GetFirstActiveTileContext();
+            
+            // Always draw the TileContext group, even if instance is null
+            _tileContextDrawer.Draw(firstActiveTile, "First Active Tile Context");
+        }
+        
+        private void DrawSongNotesWithDetails(RhythmContext context)
+        {
+            var songNotesProp = serializedObject.FindProperty(nameof(RhythmContext._songNotes));
+            _listNoteDataExpanded = EditorGUILayout.Foldout(_listNoteDataExpanded, GUIContent.none);
+            var rect = GUILayoutUtility.GetLastRect();
+            EditorGUI.PropertyField(rect, songNotesProp, EditorGUIUtility.TrTempContent("Song Notes"), true);
+            
+            // Draw expandable details if song notes exist and foldout is expanded
+            if (!_listNoteDataExpanded) return;
+            
+            if (context?.songNotes == null) 
+            {
+                EditorGUILayout.HelpBox("No Song Notes available", MessageType.Info);
+                return;
+            }
+            
+            var songNotes = context.songNotes;
+            int noteCount = songNotes.noteCount;
+            
+            if (noteCount == 0)
+            {
+                EditorGUILayout.HelpBox("Song Notes is empty", MessageType.Info);
+                return;
+            }
+            
+            EditorGUI.indentLevel++;
+            {
+                if (_listNoteDataDrawer == null)
+                    _listNoteDataDrawer = new ClassInstanceDrawer(typeof(SongNote), drawProperties: false);
+                var note = songNotes.GetNoteAt(_selectedNoteIndex);
+                if (note != null)
+                {
+                    _selectedNoteIndex = EditorGUILayout.IntSlider("Note Index", _selectedNoteIndex, 0, noteCount - 1);
+                    EditorGUILayout.Space();
+                    _listNoteDataDrawer.Draw(note, "");
+                }
+            }
+            EditorGUI.indentLevel--;
+        }
+        
+        private void DrawDebugTab(RhythmContext context, SerializedObject configSO)
+        {
+            // Draw debug tags above sub-tabs
+            DrawDebugTags(configSO);
+            
+            // Draw debug sub-tabs
+            _selectedDebugTab = GUILayout.Toolbar(_selectedDebugTab, _debugTabNames);
+            EditorGUILayout.Space();
+            
+            // Indent sub-tab content
+            EditorGUI.indentLevel++;
+            switch (_selectedDebugTab)
+            {
+                case 0: // Registered Views
+                    DrawRegisteredViews(context);
+                    break;
+                case 1: // Runtime
+                    DrawMatchData(context);
+                    DrawRhythmContext(context);
+                    break;
+                case 2: // Active Tile
+                    DrawTileContext(context);
+                    break;
+            }
+            EditorGUI.indentLevel--;
+        }
+
+    }
+}

package/Editor/RhythmContextEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 63cefbf9f02646438cd892fa62cabd94
+timeCreated: 1760433935

package/Editor/RhythmGameEditor.cs

@@ -0,0 +1,45 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Amanotes.MagicTilesCore
+{
+    [CustomEditor(typeof(RhythmGame), true)]
+    public class RhythmGameEditor : Editor
+    {
+        private RhythmContextEditor.EditorDrawer _contextEditorDrawer;
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            var rhythmGame = (RhythmGame)target;
+            DrawDefaultInspector();
+
+            if (rhythmGame.context == null)
+            {
+                EditorGUILayout.HelpBox("No Game Context assigned", MessageType.Warning);
+            }
+            else
+            {
+                if (_contextEditorDrawer == null || _contextEditorDrawer.target != rhythmGame.context)
+                {
+                    _contextEditorDrawer?.Dispose();
+                    _contextEditorDrawer = new RhythmContextEditor.EditorDrawer(rhythmGame.context);
+                }
+                
+                _contextEditorDrawer.Draw();
+            }
+            
+            if (GUI.changed)
+            {
+                EditorUtility.SetDirty(target);
+                serializedObject.ApplyModifiedProperties();
+            }
+        }
+        
+        private void OnDisable()
+        {
+            _contextEditorDrawer?.Dispose();
+        }
+    }
+}

package/Editor/RhythmGameEditor.cs.meta

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