(client) feat:添加角色定义，为匿名定义建立索引，修复一些数据定义中的错误 (#39)

Co-authored-by: zzdxxz <2079238449@qq.com>
Co-committed-by: zzdxxz <2079238449@qq.com>

Client/Assets/Scripts/Managers/DefineManager.cs

@@ -1,8 +1,10 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Threading.Tasks;
 using Data;
 using UnityEngine;
 using Utils;
@@ -11,10 +13,11 @@ namespace Managers
 {
     public class DefineManager : Singleton<DefineManager>
     {
-        private static readonly string[] dataSetFilePath = { "Data", "Mod" };
+        private static readonly string[] dataSetFilePath = { "Data", "Mods" };
 
         public Dictionary<string, Dictionary<string, Define>> defines = new();
         public Dictionary<string, DefinePack> packs = new();
+        public Dictionary<string, List<Define>> anonymousDefines = new();
         /// <summary>
         /// 初始化定义管理器，加载所有定义包并构建定义字典。
         /// </summary>
@@ -26,17 +29,66 @@ namespace Managers
         /// </remarks>
         public void Init()
         {
+            if (packs.Count > 0)
+                return;
+            // 单线程
             var packFolder = Configs.ConfigProcessor.GetSubFolders(new(dataSetFilePath));
             foreach (var folder in packFolder)
             {
                 var pack = new DefinePack();
-                if (pack.LoadPack(folder)) packs.Add(pack.packID, pack);
+                if (pack.LoadPack(folder))
+                {
+                    packs.Add(pack.packID, pack);
+                }
             }
-            
+
+
             Dictionary<Type, FieldInfo[]> fieldCache = new();
-            //不优化到循环里面是因为要先建立索引再链接
             List<Tuple<Define, FieldInfo, Define>> defineCache = new();
-            
+            HashSet<Define> processedDefines = new(); // 用于跟踪已处理的 Define 对象
+
+            void ProcessDefine(Define def, Define parentDef, FieldInfo parentField)
+            {
+                if (def == null || def.isReferene || processedDefines.Contains(def))
+                    return;
+
+                processedDefines.Add(def);
+
+                // 如果字段信息已经缓存，则直接使用缓存
+                if (!fieldCache.TryGetValue(def.GetType(), out var defineFields))
+                {
+                    // 获取所有字段类型为 Define 或其派生类型的字段
+                    defineFields = def.GetType()
+                        .GetFields(BindingFlags.Public | BindingFlags.Instance)
+                        .Where(field => typeof(Define).IsAssignableFrom(field.FieldType))
+                        .ToArray();
+                    // 缓存字段信息
+                    fieldCache[def.GetType()] = defineFields;
+                }
+
+                foreach (var defineField in defineFields)
+                {
+                    var defRef = (Define)defineField.GetValue(def);
+                    if (defRef == null)
+                        continue;
+                    if (defRef.isReferene)
+                    {
+                        defineCache.Add(new Tuple<Define, FieldInfo, Define>(parentDef, parentField, defRef));
+                    }
+                    else
+                    {
+                        if (string.IsNullOrEmpty(defRef.defName))
+                        {
+                            var typeName = defRef.GetType().Name;
+                            if (!anonymousDefines.ContainsKey(typeName))
+                                anonymousDefines.Add(typeName, new List<Define>());
+                            anonymousDefines[typeName].Add(defRef);
+                        }
+                        ProcessDefine(defRef, def, defineField);
+                    }
+                }
+            }
+
             foreach (var pack in packs)
             {
                 foreach (var define in pack.Value.defines)
@@ -51,34 +103,23 @@ namespace Managers
                     {
                         defines[typeName][def.defName] = def;
 
-                        // 如果字段信息已经缓存，则直接使用缓存
-                        if (!fieldCache.TryGetValue(def.GetType(), out var defineFields))
-                        {
-                            // 获取所有字段类型为 Define 或其派生类型的字段
-                            defineFields = def.GetType()
-                                .GetFields(BindingFlags.Public | BindingFlags.Instance)
-                                .Where(field => typeof(Define).IsAssignableFrom(field.FieldType))
-                                .ToArray();
-                            // 缓存字段信息
-                            fieldCache[def.GetType()] = defineFields;
-                        }
-                        
-                        foreach (var defineField in defineFields)
-                        {
-                            var defRef=(Define)defineField.GetValue(def);
-                            if (defRef==null || !defRef.isReferene)
-                                continue;
-                            defineCache.Add(new(def, defineField, defRef));
-                        }
+                        // 处理顶层 Define
+                        ProcessDefine(def, null, null);
                     }
                 }
             }
-
             foreach (var defRef in defineCache)
             {
                 defRef.Item2.SetValue(defRef.Item1, FindDefine(defRef.Item3.description, defRef.Item3.defName));
             }
-            
+        }
+
+        public void Reload()
+        {
+            defines.Clear();
+            packs.Clear();
+            anonymousDefines.Clear();
+            Init();
         }
         /// <summary>
         /// 查找指定定义类型的定义名对应的 Define 对象。
@@ -126,41 +167,16 @@ namespace Managers
             {
                 defineList.AddRange(define.Values);
             }
+
+            foreach (var anonymousDefine in anonymousDefines)
+            {
+                defineList.AddRange(anonymousDefine.Value);
+            }
             return defineList.ToArray();
         }
         
         /// <summary>
-        /// 查询 Define 对象。
-        /// </summary>
-        /// <param name="defineType">定义类型（外层字典的键）。</param>
-        /// <param name="defineName">定义名（内层字典的键）。</param>
-        /// <returns>如果找到，则返回 Define 对象；否则返回 null。</returns>
-        public Define QueryDefine(string defineType, string defineName)
-        {
-            if (string.IsNullOrEmpty(defineType))
-            {
-                Debug.LogError("查询失败：定义类型参数不能为空！");
-                return null;
-            }
-            if (string.IsNullOrEmpty(defineName))
-            {
-                Debug.LogError("查询失败：定义名参数不能为空！");
-                return null;
-            }
-            if (!defines.TryGetValue(defineType, out var typeDefinitions))
-            {
-                Debug.LogWarning($"查询失败：未找到定义类型 '{defineType}'");
-                return null;
-            }
-            if (!typeDefinitions.TryGetValue(defineName, out var targetDefine))
-            {
-                Debug.LogWarning($"查询失败：定义类型 '{defineType}' 中未找到定义名 '{defineName}'");
-                return null;
-            }
-            return targetDefine;
-        }
-        /// <summary>
-        /// 查询指定类型下的所有 Define 对象。
+        /// 查询指定类型下的所有 Define 对象。(包括匿名定义)
         /// </summary>
         /// <param name="defineType">定义类型（外层字典的键）。</param>
         /// <returns>该类型下的 Define 数组，如果未找到则返回 null。</returns>
@@ -172,39 +188,49 @@ namespace Managers
                 return null;
             }
 
-            if (!defines.TryGetValue(defineType, out var typeDefinitions))
+            List<Define> result = new List<Define>();
+
+            // 从命名定义中查询
+            if (defines.TryGetValue(defineType, out var namedDefinitions))
+            {
+                result.AddRange(namedDefinitions.Values);
+            }
+
+            // 从匿名定义中查询
+            if (anonymousDefines.TryGetValue(defineType, out var anonymousDefinitionList))
+            {
+                result.AddRange(anonymousDefinitionList);
+            }
+
+            // 如果结果为空，则返回 null
+            if (result.Count == 0)
             {
                 Debug.LogWarning($"查询失败：未找到定义类型 '{defineType}'");
                 return null;
             }
 
-            return typeDefinitions.Values.ToArray();
+            return result.ToArray();
         }
         /// <summary>
-        /// 查询指定类型下的所有 Define 对象，并尝试转换为目标类型。
+        /// 查询指定类型下的所有 Define 对象，并尝试转换为目标类型。(包括匿名定义)
         /// </summary>
         /// <typeparam name="T">目标类型。</typeparam>
         /// <returns>转换后的目标类型数组，如果未找到或转换失败则返回 null。</returns>
         public T[] QueryDefinesByType<T>()
         {
             var defineType = typeof(T).Name;
-            if (string.IsNullOrEmpty(defineType))
-            {
-                Debug.LogError("查询失败：定义类型参数不能为空！");
-                return null;
-            }
 
-            if (!defines.TryGetValue(defineType, out var typeDefinitions))
+            List<Define> allDefines = QueryDefinesByType(defineType)?.ToList();
+            if (allDefines == null || allDefines.Count == 0)
             {
-                Debug.LogWarning($"查询失败：未找到定义类型 '{defineType}'");
                 return null;
             }
 
             try
             {
-                // 获取所有值并尝试转换为目标类型
+                // 尝试将所有 Define 对象转换为目标类型 T
                 var result = new List<T>();
-                foreach (var item in typeDefinitions.Values)
+                foreach (var item in allDefines)
                 {
                     if (item is T converted)
                     {
@@ -216,6 +242,79 @@ namespace Managers
                         return null;
                     }
                 }
+
+                return result.ToArray();
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"类型转换失败：从 Define 转换为 {typeof(T).Name} 时出错。错误信息：{ex.Message}");
+                return null;
+            }
+        }
+        
+        /// <summary>
+        /// 查询指定类型下的所有 Define 对象（仅包含命名定义，不包括匿名定义）。
+        /// </summary>
+        /// <param name="defineType">定义类型（外层字典的键）。</param>
+        /// <returns>该类型下的 Define 数组，如果未找到则返回 null。</returns>
+        public Define[] QueryNamedDefinesByType(string defineType)
+        {
+            if (string.IsNullOrEmpty(defineType))
+            {
+                Debug.LogError("查询失败：定义类型参数不能为空！");
+                return null;
+            }
+
+            List<Define> result = new List<Define>();
+
+            // 仅从命名定义中查询
+            if (defines.TryGetValue(defineType, out var namedDefinitions))
+            {
+                result.AddRange(namedDefinitions.Values);
+            }
+
+            // 如果结果为空，则返回 null
+            if (result.Count == 0)
+            {
+                Debug.LogWarning($"查询失败：未找到定义类型 '{defineType}' 的命名定义");
+                return null;
+            }
+
+            return result.ToArray();
+        }
+
+        /// <summary>
+        /// 查询指定类型下的所有 Define 对象，并尝试转换为目标类型（仅包含命名定义，不包括匿名定义）。
+        /// </summary>
+        /// <typeparam name="T">目标类型。</typeparam>
+        /// <returns>转换后的目标类型数组，如果未找到或转换失败则返回 null。</returns>
+        public T[] QueryNamedDefinesByType<T>()
+        {
+            var defineType = typeof(T).Name;
+
+            List<Define> allDefines = QueryNamedDefinesByType(defineType)?.ToList();
+            if (allDefines == null || allDefines.Count == 0)
+            {
+                return null;
+            }
+
+            try
+            {
+                // 尝试将所有 Define 对象转换为目标类型 T
+                var result = new List<T>();
+                foreach (var item in allDefines)
+                {
+                    if (item is T converted)
+                    {
+                        result.Add(converted);
+                    }
+                    else
+                    {
+                        Debug.LogError($"类型转换失败：无法将 {item.GetType().Name} 转换为 {typeof(T).Name}");
+                        return null;
+                    }
+                }
+
                 return result.ToArray();
             }
             catch (Exception ex)

Client/Assets/Scripts/Managers/PackagesImageManager.cs

@@ -61,7 +61,7 @@ namespace Managers
                     // 创建Sprite
                     var sprite = Sprite.Create(texture, (Rect)spriteRect, new Vector2(0.5f, 0.5f), pixelsPerUnit);
 
-                    var index = row * cols + col;
+                    var index = (rows - row - 1) * cols + col;
                     sprites[name + $"_{index}"] = sprite;
                 }
             }