com.amanotes.magictilescore 0.4.2

package/Editor/ClassInstanceDrawer.cs

@@ -0,0 +1,256 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+
+namespace Amanotes.MagicTilesCore
+{
+    public class ClassInstanceDrawer
+    {
+        private System.Type _type;
+        private List<(string name, PropertyInfo property, FieldInfo field)> _members;
+        private List<(string name, PropertyInfo property, FieldInfo field)> _forceDrawMembers;
+        private readonly bool _drawProperties;
+        private readonly HashSet<string> _forceShowMembers;
+        private readonly HashSet<string> _forceHideMembers;
+        private bool _isExpanded = true;
+        private bool _isInitialized = false;
+        private float _maxLabelWidth = 0f; // Calculated max width needed for all labels
+        
+        private readonly Dictionary<string, ClassInstanceDrawer> _forceDrawSubDrawers = new Dictionary<string, ClassInstanceDrawer>();
+        
+        public ClassInstanceDrawer(System.Type type, bool drawProperties = true, HashSet<string> forceShowMembers = null, HashSet<string> forceHideMembers = null)
+        {
+            _type = type;
+            _drawProperties = drawProperties;
+            _forceShowMembers = forceShowMembers ?? new HashSet<string>();
+            _forceHideMembers = forceHideMembers ?? new HashSet<string>();
+            InitializeMembers();
+        }
+        
+        public ClassInstanceDrawer(bool drawProperties = true, HashSet<string> forceShowMembers = null, HashSet<string> forceHideMembers = null)
+        {
+            _drawProperties = drawProperties;
+            _forceShowMembers = forceShowMembers ?? new HashSet<string>();
+            _forceHideMembers = forceHideMembers ?? new HashSet<string>();
+            _members = new List<(string name, PropertyInfo property, FieldInfo field)>();
+            _forceDrawMembers = new List<(string name, PropertyInfo property, FieldInfo field)>();
+        }
+        
+        private void InitializeMembers()
+        {
+            if (_isInitialized || _type == null) return;
+                
+            _members = new List<(string name, PropertyInfo property, FieldInfo field)>();
+            _forceDrawMembers = new List<(string name, PropertyInfo property, FieldInfo field)>();
+            
+            var properties = _type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
+                .Where(p => p.CanRead && !p.GetIndexParameters().Any())
+                .OrderBy(p => p.Name);
+            
+            var fields = _type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
+                .OrderBy(f => f.Name);
+            
+            var allFields = fields.ToArray();
+            
+            if (_drawProperties)
+            {
+                foreach (var prop in properties)
+                {
+                    if (_forceShowMembers.Contains(prop.Name))
+                    {
+                        _forceDrawMembers.Add((prop.Name, prop, null));
+                        _forceDrawSubDrawers[prop.Name] = new ClassInstanceDrawer(prop.PropertyType, drawProperties: false);
+                    }
+                    else if (ShouldShowMember(prop.PropertyType, prop.Name) && !HasBackingField(prop, allFields))
+                    {
+                        _members.Add((prop.Name, prop, null));
+                    }
+                }
+            }
+            
+            foreach (var field in fields)
+            {
+                if (_forceShowMembers.Contains(field.Name))
+                {
+                    _forceDrawMembers.Add((field.Name, null, field));
+                    _forceDrawSubDrawers[field.Name] = new ClassInstanceDrawer(field.FieldType, drawProperties: false);
+                }
+                else if (!_members.Any(m => m.name == field.Name) && ShouldShowMember(field.FieldType, field.Name))
+                {
+                    _members.Add((field.Name, null, field));
+                }
+            }
+            
+            _isInitialized = true;
+            
+            // Calculate max label width needed
+            CalculateMaxLabelWidth();
+        }
+        
+        private bool ShouldShowMember(System.Type type, string memberName)
+        {
+            if (_forceHideMembers.Contains(memberName)) return false;
+            if (_forceShowMembers.Contains(memberName)) return true;
+            
+            if (type.IsPrimitive || type.IsValueType || type.IsEnum || type == typeof(string)) return true;
+            if (typeof(UnityEngine.Object).IsAssignableFrom(type)) return true;
+            
+            return false;
+        }
+        
+        private bool HasBackingField(PropertyInfo property, FieldInfo[] allFields)
+        {
+            var propertyName = property.Name;
+            var backingFieldName = $"<{propertyName}>k__BackingField";
+            var underscoreFieldName = $"_{char.ToLower(propertyName[0])}{propertyName.Substring(1)}";
+            
+            return allFields.Any(f => f.Name == backingFieldName || f.Name == underscoreFieldName);
+        }
+        
+        private void CalculateMaxLabelWidth()
+        {
+            _maxLabelWidth = 0f;
+            
+            // Check all member labels
+            foreach (var (name, _, _) in _members)
+            {
+                var textWidth = EditorStyles.label.CalcSize(new GUIContent(name)).x;
+                _maxLabelWidth = Mathf.Max(_maxLabelWidth, textWidth);
+            }
+            
+            // Check all force draw member labels
+            foreach (var (name, _, _) in _forceDrawMembers)
+            {
+                var textWidth = EditorStyles.label.CalcSize(new GUIContent(name)).x;
+                _maxLabelWidth = Mathf.Max(_maxLabelWidth, textWidth);
+            }
+
+            _maxLabelWidth += 16f;
+        }
+        
+        public void Draw(object instance, string foldoutTitle = "Instance Data")
+        {
+            if (_type == null && instance != null)
+            {
+                _type = instance.GetType();
+                InitializeMembers();
+            }
+            
+            if (string.IsNullOrEmpty(foldoutTitle))
+            {
+                if (instance == null)
+                {
+                    EditorGUILayout.HelpBox("Instance is null", MessageType.Warning);
+                    return;
+                }
+
+                DrawFields(instance);
+                return;
+            }
+
+            if (!string.IsNullOrEmpty(foldoutTitle))
+            {
+                _isExpanded = EditorGUILayout.Foldout(_isExpanded, foldoutTitle, true);
+                if (!_isExpanded) return;    
+            }
+            
+            if (instance == null)
+            {
+                EditorGUILayout.HelpBox("Instance is null", MessageType.Warning);
+            }
+            else
+            {
+                DrawFields(instance);
+            }
+        }
+        
+        private void DrawFields(object instance)
+        {
+            if (_members.Count == 0 && _forceDrawMembers.Count == 0)
+            {
+                EditorGUILayout.HelpBox("No readable properties or fields found", MessageType.Info);
+                return;
+            }
+            
+
+
+            // Save current label width
+            var originalLabelWidth = EditorGUIUtility.labelWidth;
+            
+            // Set the calculated max label width
+            EditorGUIUtility.labelWidth = _maxLabelWidth;
+            EditorGUILayout.BeginHorizontal();
+            {
+                EditorGUILayout.BeginVertical();
+                if (_members.Count > 0)
+                {
+                    var halfCount = (_members.Count + 1) / 2;
+                    for (int i = 0; i < halfCount; i++)
+                    {
+                        var (name, property, field) = _members[i];
+                        DrawField(instance, name, property, field);
+                    }
+                }
+                EditorGUILayout.EndVertical();
+                
+                EditorGUILayout.BeginVertical();
+                if (_members.Count > 0)
+                {
+                    var halfCount = (_members.Count + 1) / 2;
+                    for (int i = halfCount; i < _members.Count; i++)
+                    {
+                        var (name, property, field) = _members[i];
+                        DrawField(instance, name, property, field);
+                    }
+                }
+                EditorGUILayout.EndVertical();
+            }
+            EditorGUILayout.EndHorizontal();
+            EditorGUIUtility.labelWidth = originalLabelWidth;
+
+            // Draw sub-drawers as collapsible groups
+            foreach (var (name, property, field) in _forceDrawMembers)
+            {
+                object value = property != null ? property.GetValue(instance) : field.GetValue(instance);
+                var subDrawer = _forceDrawSubDrawers[name];
+                subDrawer.Draw(value, name);
+            }
+        }
+        
+        private void DrawField(object instance, string name, PropertyInfo property, FieldInfo field)
+        {
+            EditorGUILayout.BeginHorizontal();
+            {
+                object value = property != null ? property.GetValue(instance) : field.GetValue(instance);
+                System.Type type = property != null ? property.PropertyType : field.FieldType;
+                
+                if (_forceDrawSubDrawers.TryGetValue(name, out var subDrawer))
+                {
+                    subDrawer.Draw(value, "");
+                }
+                else
+                {
+                    EditorGUI.BeginDisabledGroup(true);
+                    DrawValue(name, value, type);
+                    EditorGUI.EndDisabledGroup();
+                }
+            }
+            EditorGUILayout.EndHorizontal();
+        }
+        
+        private void DrawValue(string title, object value, System.Type type)
+        {
+            if (value == null) EditorGUILayout.TextField(new GUIContent(title),"null");
+            else if (type == typeof(int) || type == typeof(int?)) EditorGUILayout.IntField(new GUIContent(title), (int)value);
+            else if (type == typeof(float) || type == typeof(float?)) EditorGUILayout.FloatField(new GUIContent(title),(float)value);
+            else if (type == typeof(bool) || type == typeof(bool?)) EditorGUILayout.Toggle(new GUIContent(title),(bool)value);
+            else if (type == typeof(Vector3)) EditorGUILayout.Vector3Field(new GUIContent(title), (Vector3)value);
+            else if (type == typeof(string)) EditorGUILayout.TextField(new GUIContent(title), (string)value);
+            else if (typeof(UnityEngine.Object).IsAssignableFrom(type)) EditorGUILayout.ObjectField(new GUIContent(title), (UnityEngine.Object)value, type, true);
+            else if (type.IsEnum) EditorGUILayout.EnumPopup(new GUIContent(title), (System.Enum)value);
+            else EditorGUILayout.TextField(new GUIContent(title),value.ToString());
+        }
+    }
+}

package/Editor/ClassInstanceDrawer.cs.meta

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

package/Editor/CollapsibleGroupEditor.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+
+namespace Amanotes.MagicTilesCore
+{
+    public abstract class CollapsibleGroupEditor : Editor
+    {
+        private Dictionary<Type, bool> _foldoutStates = new Dictionary<Type, bool>();
+        private Dictionary<Type, List<SerializedProperty>> _groupedProperties = new Dictionary<Type, List<SerializedProperty>>();
+        
+        protected virtual void OnEnable()
+        {
+            GroupPropertiesByInheritanceLevel();
+        }
+        
+        private void GroupPropertiesByInheritanceLevel()
+        {
+            _groupedProperties.Clear();
+            
+            var targetType = target.GetType();
+            var inheritanceChain = GetInheritanceChain(targetType);
+            
+            var serializedObject = this.serializedObject;
+            var iterator = serializedObject.GetIterator();
+            
+            if (iterator.NextVisible(true))
+            {
+                while (iterator.NextVisible(false))
+                {
+                    var fieldInfo = GetFieldInfo(targetType, iterator.propertyPath);
+                    if (fieldInfo != null)
+                    {
+                        var declaringType = fieldInfo.DeclaringType;
+                        var groupType = inheritanceChain.FirstOrDefault(type => 
+                            declaringType == type || declaringType.IsSubclassOf(type));
+                        
+                        if (groupType != null)
+                        {
+                            if (!_groupedProperties.ContainsKey(groupType))
+                            {
+                                _groupedProperties[groupType] = new List<SerializedProperty>();
+                                _foldoutStates[groupType] = true;
+                            }
+                            
+                            _groupedProperties[groupType].Add(iterator.Copy());
+                        }
+                    }
+                }
+            }
+        }
+        
+        private List<Type> GetInheritanceChain(Type type)
+        {
+            var chain = new List<Type>();
+            var current = type;
+            
+            while (current != null && current != typeof(ScriptableObject) && current != typeof(UnityEngine.Object))
+            {
+                chain.Add(current);
+                current = current.BaseType;
+            }
+            
+            chain.Reverse();
+            return chain;
+        }
+        
+        private FieldInfo GetFieldInfo(Type type, string propertyPath)
+        {
+            var parts = propertyPath.Split('.');
+            var currentType = type;
+            FieldInfo fieldInfo = null;
+            
+            foreach (var part in parts)
+            {
+                fieldInfo = currentType.GetField(part, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+                if (fieldInfo == null) break;
+                
+                currentType = fieldInfo.FieldType;
+                
+                if (currentType.IsArray)
+                {
+                    currentType = currentType.GetElementType();
+                }
+                else if (currentType.IsGenericType && currentType.GetGenericTypeDefinition() == typeof(List<>))
+                {
+                    currentType = currentType.GetGenericArguments()[0];
+                }
+            }
+            
+            return fieldInfo;
+        }
+        
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            
+            // Draw each group as a collapsible foldout
+            foreach (var kvp in _groupedProperties.OrderBy(x => GetInheritanceChain(target.GetType()).IndexOf(x.Key)))
+            {
+                var groupType = kvp.Key;
+                var properties = kvp.Value;
+                
+                if (properties.Count == 0) continue;
+                
+                var groupName = GetGroupDisplayName(groupType);
+                _foldoutStates[groupType] = EditorGUILayout.BeginFoldoutHeaderGroup(_foldoutStates[groupType], groupName);
+                
+                if (_foldoutStates[groupType])
+                {
+                    EditorGUI.indentLevel++;
+                    foreach (var property in properties)
+                    {
+                        EditorGUILayout.PropertyField(property, true);
+                    }
+                    EditorGUI.indentLevel--;
+                }
+                
+                EditorGUILayout.EndFoldoutHeaderGroup();
+            }
+            
+            serializedObject.ApplyModifiedProperties();
+        }
+        
+        protected virtual string GetGroupDisplayName(Type type)
+        {
+            // Remove common suffixes and prefixes for cleaner names
+            var name = type.Name;
+            
+            if (name.EndsWith("Config"))
+                name = name.Substring(0, name.Length - 6);
+            
+            if (name.StartsWith("MT"))
+                name = name.Substring(2);
+            
+            return name;
+        }
+    }
+}

package/Editor/CollapsibleGroupEditor.cs.meta

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