zzdxxz/Gen_Hack-and-Slash-Roguelite-zzdxxz
1
0
Fork 0
forked from Roguelite-Game-Developing-Team/Gen_Hack-and-Slash-Roguelite
Code Pull Requests Activity

(client) feat:实现行为树条件节点的实际功能

Browse Source
This commit is contained in:
m0_75251201
2025-08-24 17:15:52 +08:00
parent da93368f02
commit 797cf69f75
17 changed files with 937 additions and 752 deletions
Download Patch File Download Diff File Expand all files Collapse all files

350
Client/Assets/Scripts/Data/DefinePack.cs
View File

@ -11,17 +11,31 @@ using Object = System.Object;
namespace Data
{
/// <summary>
/// 表示模组包的基本信息
/// </summary>
public class PackAbout
{
public string name;
public string description;
public string author;
public string version;
public string packID;
public string Name { get; private set; }
public string Description { get; private set; }
public string Author { get; private set; }
public string Version { get; private set; }
public string PackID { get; private set; }
public string[] necessary;
public string[] after;
public string[] before;
public string[] Necessary { get; private set; }
public string[] After { get; private set; }
public string[] Before { get; private set; }
private const string RootElementName = "About";
private const string ElementName_Name = "name";
private const string ElementName_Description = "description";
private const string ElementName_Author = "author";
private const string ElementName_Version = "version";
private const string ElementName_PackID = "packID";
private const string ElementName_Sort = "sort";
private const string ElementName_Before = "before";
private const string ElementName_After = "after";
private const string ElementName_Necessary = "necessary";
/// <summary>
/// 使用静态方法从 XML 文档创建 PackAbout 实例。
@ -30,28 +44,28 @@ namespace Data
/// <returns>初始化的 PackAbout 实例。</returns>
public static PackAbout FromXDocument(XDocument doc)
{
var aboutElement = doc.Element("About");
if (aboutElement == null) throw new ArgumentException("XML 文档无效，根节点为空或不是 'About'。");
var aboutElement = doc.Element(RootElementName);
if (aboutElement == null) throw new ArgumentException($"XML 文档无效，根节点为空或不是 '{RootElementName}'。");
PackAbout result = new();
result.name = aboutElement.Element("name")?.Value ?? "Unknown";
result.description = aboutElement.Element("description")?.Value ?? "Unknown";
result.author = aboutElement.Element("author")?.Value ?? "Unknown";
result.version = aboutElement.Element("version")?.Value ?? "Unknown";
result.packID = aboutElement.Element("packID")?.Value ?? "Unknown";
result.Name = aboutElement.Element(ElementName_Name)?.Value ?? "Unknown";
result.Description = aboutElement.Element(ElementName_Description)?.Value ?? "Unknown";
result.Author = aboutElement.Element(ElementName_Author)?.Value ?? "Unknown";
result.Version = aboutElement.Element(ElementName_Version)?.Value ?? "Unknown";
result.PackID = aboutElement.Element(ElementName_PackID)?.Value ?? "Unknown";
var sortElement = aboutElement.Element("sort");
var sortElement = aboutElement.Element(ElementName_Sort);
if (sortElement != null)
{
result.before = GetElementValues(sortElement.Element("before"));
result.after = GetElementValues(sortElement.Element("after"));
result.necessary = GetElementValues(sortElement.Element("necessary"));
result.Before = GetElementValues(sortElement.Element(ElementName_Before));
result.After = GetElementValues(sortElement.Element(ElementName_After));
result.Necessary = GetElementValues(sortElement.Element(ElementName_Necessary));
}
else
{
result.before = Array.Empty<string>();
result.after = Array.Empty<string>();
result.necessary = Array.Empty<string>();
result.Before = Array.Empty<string>();
result.After = Array.Empty<string>();
result.Necessary = Array.Empty<string>();
}
return result;
@ -81,30 +95,56 @@ namespace Data
var sb = new StringBuilder();
// 基础字段（单行）
sb.AppendLine($"{"Name:",labelWidth}{name,valueWidth}");
sb.AppendLine($"{"Description:",labelWidth}{description,valueWidth}");
sb.AppendLine($"{"Author:",labelWidth}{author,valueWidth}");
sb.AppendLine($"{"Version:",labelWidth}{version,valueWidth}");
sb.AppendLine($"{"PackID:",labelWidth}{packID,valueWidth}");
sb.AppendLine($"{"Name:",labelWidth}{Name,valueWidth}");
sb.AppendLine($"{"Description:",labelWidth}{Description,valueWidth}");
sb.AppendLine($"{"Author:",labelWidth}{Author,valueWidth}");
sb.AppendLine($"{"Version:",labelWidth}{Version,valueWidth}");
sb.AppendLine($"{"PackID:",labelWidth}{PackID,valueWidth}");
// 数组字段（多行，每项缩进）
sb.AppendLine(
$"{"Necessary:",labelWidth}{string.Join(", ", necessary ?? Array.Empty<string>()),valueWidth}");
sb.AppendLine($"{"After:",labelWidth}{string.Join(", ", after ?? Array.Empty<string>()),valueWidth}");
sb.AppendLine($"{"Before:",labelWidth}{string.Join(", ", before ?? Array.Empty<string>()),valueWidth}");
$"{"Necessary:",labelWidth}{string.Join(", ", Necessary ?? Array.Empty<string>()),valueWidth}");
sb.AppendLine($"{"After:",labelWidth}{string.Join(", ", After ?? Array.Empty<string>()),valueWidth}");
sb.AppendLine($"{"Before:",labelWidth}{string.Join(", ", Before ?? Array.Empty<string>()),valueWidth}");
return sb.ToString();
}
}
/// <summary>
/// 表示一个模组包的定义集合
/// </summary>
public class DefinePack
{
private const string CoreNamespace = "Data.";
// 优化点7：将魔法字符串转换为常量
private const string RootElementName_About = "About";
private const string RootElementName_Define = "Define";
// 优化点1和2：反射缓存和改进的类型查找
private static readonly Dictionary<string, Type> _typeCache = new();
private static readonly Dictionary<Type, ConstructorInfo> _constructorCache = new();
private static readonly Dictionary<Type, FieldInfo[]> _fieldCache = new();
private static readonly List<Assembly> _assembliesToSearch = new(); // 缓存要搜索的程序集
static DefinePack()
{
// 优化点2：一次性初始化要搜索的程序集。
// 为简单起见，我们将扫描所有当前加载的程序集。
// 在实际游戏中，您可能希望显式添加特定的程序集
// 如 Assembly.Load("YourGameLogicAssembly") 或按名称过滤。
_assembliesToSearch.AddRange(AppDomain.CurrentDomain.GetAssemblies());
// 可选：过滤或添加特定程序集：
// _assembliesToSearch.Add(Assembly.GetExecutingAssembly()); // 添加当前程序集
// _assembliesToSearch.Add(Assembly.Load("AnotherAssemblyContainingDefines"));
}
/// <summary>
/// define类别及其定义
/// </summary>
public Dictionary<string, List<Define>> defines=new();
public Dictionary<string, List<Define>> defines = new();
public PackAbout packAbout;
public string packID;
@ -114,15 +154,17 @@ namespace Data
{
get
{
return packAbout.name;
// 优化点5：Name属性的空值安全性
return packAbout?.Name ?? "Unnamed Pack"; // 使用 PackAbout.Name 属性
}
}
public bool LoadPack(string packPath)
{
packRootPath=System.IO.Path.GetFullPath(packPath);;
packRootPath = System.IO.Path.GetFullPath(packPath);
var packDatas = ConfigProcessor.LoadXmlFromPath(packPath);
var aboutXmls = FindDocumentsWithRootName(packDatas, "About");
// 优化点7：使用常量
var aboutXmls = FindDocumentsWithRootName(packDatas, RootElementName_About);
if (aboutXmls == null || aboutXmls.Count < 1)
{
Debug.LogError("包缺少配置文件，加载跳过");
@ -131,10 +173,13 @@ namespace Data
var aboutXml = aboutXmls[0];
packAbout = PackAbout.FromXDocument(aboutXml);
packID = packAbout.packID;
if (aboutXmls.Count > 1) Debug.LogWarning($"{packAbout.name}包拥有多个配置文件，系统选择了加载序的第一个，请避免这种情况");
// 优化点3：使用 PackAbout.PackID 属性
packID = packAbout.PackID;
// 优化点3：使用 PackAbout.Name 属性
if (aboutXmls.Count > 1) Debug.LogWarning($"{packAbout.Name}包拥有多个配置文件，系统选择了加载序的第一个，请避免这种情况");
var defineXmls = FindDocumentsWithRootName(packDatas, "Define");
// 优化点7：使用常量
var defineXmls = FindDocumentsWithRootName(packDatas, RootElementName_Define);
// Debug.Log($"Define文件数量{defineXmls.Count}");
foreach (var defineXml in defineXmls) LoadDefines(defineXml);
return true;
@ -143,7 +188,8 @@ namespace Data
private void LoadDefines(XDocument defineDoc)
{
var rootElement = defineDoc.Root;
if (rootElement == null || rootElement.Name != "Define")
// 优化点7：使用常量
if (rootElement == null || rootElement.Name != RootElementName_Define)
return;
foreach (var element in rootElement.Elements())
@ -151,7 +197,7 @@ namespace Data
var className = element.Name.ToString();
if (string.IsNullOrEmpty(className))
continue;
var def = LoadDefineClass(element,element.Name.ToString());
var def = LoadDefineClass(element, className);
if (def == null)
continue;
def.packID = packID;
@ -160,6 +206,7 @@ namespace Data
defines[className].Add(def);
}
}
/// <summary>
/// 根据指定的 XML 元素 (<paramref name="defineDoc"/>) 和类名 (<paramref name="className"/>),
/// 动态加载并初始化一个继承自 <see cref="Define"/> 的类实例。
@ -178,44 +225,47 @@ namespace Data
/// 如果类存在且满足条件，则尝试调用其 <see cref="Define.Init(XElement)"/> 方法进行初始化。
/// 如果初始化失败，则使用默认初始化方法 (<see cref="DefaultInitDefine(Define, XElement, Type)"/>)。
/// </remarks>
public static Define LoadDefineClass(XElement defineDoc,string className)
public static Define LoadDefineClass(XElement defineDoc, string className)
{
var assembly = Assembly.GetExecutingAssembly();
Type type;
if (!className.Contains('.'))
// 优化点1和2：反射缓存和改进的类型查找
if (!_typeCache.TryGetValue(className, out Type type))
{
// 尝试拼接默认命名空间
// 首先尝试使用 CoreNamespace
var fullClassName = CoreNamespace + className;
type = assembly.GetType(fullClassName);
type = _assembliesToSearch.Select(a => a.GetType(fullClassName)).FirstOrDefault(t => t != null);
// 如果拼接命名空间后仍找不到，尝试直接查找（可能是全局命名空间下的类）
if (type == null) type = assembly.GetType(className);
}
else
{
// 直接查找
type = assembly.GetType(className);
// 如果未找到，尝试不使用 CoreNamespace（可能在全局命名空间中或已经是完全限定名）
if (type == null)
{
type = _assembliesToSearch.Select(a => a.GetType(className)).FirstOrDefault(t => t != null);
}
if (type == null)
{
Debug.LogError($"未定义的类型: {className}");
return null;
}
_typeCache[className] = type;
}
if (type == null)
// 优化点1：构造函数缓存
if (!_constructorCache.TryGetValue(type, out ConstructorInfo constructor))
{
Debug.LogError($"未定义的类型: {className}");
return null;
constructor = type.GetConstructor(Type.EmptyTypes);
if (constructor == null)
{
Debug.LogError($"{className} 必须包含无参构造函数");
return null;
}
_constructorCache[type] = constructor;
}
var constructor = type.GetConstructor(Type.EmptyTypes);
if (constructor == null)
{
Debug.LogError($"{className} 必须包含无参构造函数");
return null;
}
// 3. 创建实例
object instance;
try
{
instance = Activator.CreateInstance(type);
instance = constructor.Invoke(null); // 使用缓存的构造函数
}
catch (Exception ex)
{
@ -231,10 +281,11 @@ namespace Data
}
if (define.Init(defineDoc)) return define;
DefaultInitDefine(define,defineDoc, type);
DefaultInitDefine(define, defineDoc, type);
return define;
}
/// <summary>
/// 初始化指定的 <paramref name="define"/> 对象，根据 <paramref name="defineDoc"/> 中的 XML 元素内容，
/// 将对应的字段值赋给 <paramref name="define"/> 对象。
@ -251,9 +302,14 @@ namespace Data
/// 如果找到匹配的子元素，则将其值转换为字段的类型并赋值给字段。
/// 如果字段类型继承自 <see cref="Define"/>，则递归调用 <see cref="LoadDefineClass(XElement, string)"/> 方法进行加载。
/// </remarks>
public static void DefaultInitDefine(Define define,XElement defineDoc,Type defineType)
public static void DefaultInitDefine(Define define, XElement defineDoc, Type defineType)
{
var fields = defineType.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic);
// 优化点1：FieldInfo 缓存
if (!_fieldCache.TryGetValue(defineType, out FieldInfo[] fields))
{
fields = defineType.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic);
_fieldCache[defineType] = fields;
}
// 遍历字段并尝试从 XElement 中赋值
foreach (var field in fields)
@ -263,115 +319,98 @@ namespace Data
if (element != null)
try
{
Object value;
if (IsFieldTypeInheritedFrom(field, typeof(Define)))
{
if (element.HasElements)
{
value = LoadDefineClass(element, field.FieldType.Name);
}
else
{
var reference = (Define)Activator.CreateInstance(field.FieldType);
reference.isReferene = true;
reference.description=field.FieldType.Name;
reference.label = field.Name;
reference.defName = element.Value;
value = reference;
}
}
else if(field.FieldType.IsArray||typeof(IList).IsAssignableFrom(field.FieldType))
{
value = ProcessArrayField(field, element);
}
else if (field.FieldType.IsEnum)
{
value = Enum.Parse(field.FieldType, element.Value);
}
else
{
value = Convert.ChangeType(element.Value, field.FieldType);
}
// 优化点4：重构 ProcessArrayField 并引入通用转换辅助方法
object value = ConvertXElementValueToType(element, field.FieldType);
field.SetValue(define, value);
}
catch (Exception ex)
{
Debug.LogWarning($"Error setting field ,field name:{field.Name}; value: {element.Value}; error: {ex.Message}");
Debug.LogWarning($"设置字段时出错，字段名:{field.Name}; 值: {element.Value}; 错误: {ex.Message}");
}
}
}
private static object ProcessArrayField(FieldInfo field, XElement element)
// 优化点4：新的辅助方法，用于将 XElement 值转换为特定类型
private static object ConvertXElementValueToType(XElement element, Type targetType)
{
// 获取集合元素的类型
Type elementType = field.FieldType.IsArray
? field.FieldType.GetElementType()
: field.FieldType.GetGenericArguments()[0];
if (elementType == null) return null;
var arrayElements = new List<object>();
// 遍历 XML 元素中的子元素
foreach (var liElement in element.Elements())
if (IsTypeInheritedFrom(targetType, typeof(Define)))
{
if (elementType.IsSubclassOf(typeof(Define)))
if (element.HasElements)
{
// 如果是 Define 类型或其子类
var nestedDefine = (Define)Activator.CreateInstance(elementType);
DefaultInitDefine(nestedDefine, liElement, elementType);
arrayElements.Add(nestedDefine);
}
else if (elementType.IsArray || typeof(IList).IsAssignableFrom(elementType))
{
// 嵌套数组处理（递归调用）
var pseudoField = new { FieldType = elementType };
var nestedArray = ProcessArrayField(
pseudoField.GetType().GetField("FieldType"),
liElement
);
arrayElements.Add(nestedArray);
}
else if (elementType.IsEnum)
{
// 枚举类型处理
arrayElements.Add(Enum.Parse(elementType, liElement.Value));
return LoadDefineClass(element, targetType.Name);
}
else
{
// 基本类型处理
arrayElements.Add(Convert.ChangeType(liElement.Value, elementType));
// 引用另一个 Define
var reference = (Define)Activator.CreateInstance(targetType);
reference.isReferene = true;
reference.description = targetType.Name;
reference.label = element.Name.LocalName; // 使用元素的名称作为标签
reference.defName = element.Value;
return reference;
}
}
// 根据目标字段的类型构建结果
if (field.FieldType.IsArray)
else if (targetType.IsArray || typeof(IList).IsAssignableFrom(targetType))
{
return ProcessArrayField(targetType, element);
}
else if (targetType.IsEnum)
{
return Enum.Parse(targetType, element.Value);
}
else
{
return Convert.ChangeType(element.Value, targetType);
}
}
// 优化点4：修改 ProcessArrayField 以直接接受 Type
private static object ProcessArrayField(Type fieldType, XElement element)
{
// 获取集合的元素类型
Type elementType = fieldType.IsArray
? fieldType.GetElementType()
: fieldType.GetGenericArguments().FirstOrDefault(); // 使用 FirstOrDefault 以确保安全
if (elementType == null)
{
Debug.LogWarning($"无法确定类型为 {fieldType.Name} 的集合字段的元素类型");
return null;
}
var arrayElements = new List<object>();
// 遍历 XML 子元素
foreach (var liElement in element.Elements())
{
// 对每个项目使用新的辅助方法
arrayElements.Add(ConvertXElementValueToType(liElement, elementType));
}
// 根据目标字段的类型构造结果
if (fieldType.IsArray)
{
// 如果目标字段是数组类型
var resultArray = Array.CreateInstance(elementType, arrayElements.Count);
for (var i = 0; i < arrayElements.Count; i++)
{
resultArray.SetValue(arrayElements[i], i);
}
return resultArray;
}
else if (typeof(IList).IsAssignableFrom(field.FieldType))
else if (typeof(IList).IsAssignableFrom(fieldType))
{
// 如果目标字段是泛型集合类型（如 List<T>）
var listType = typeof(List<>).MakeGenericType(elementType);
var resultList = (IList)Activator.CreateInstance(listType);
foreach (var item in arrayElements)
{
resultList.Add(item);
}
return resultList;
}
return null;
}
/// <summary>
/// 从 List<c>XDocument</c> 中查找指定根元素名称的文档。
@ -381,7 +420,7 @@ namespace Data
/// <returns>符合条件的 XML 文档列表。</returns>
public static List<XDocument> FindDocumentsWithRootName(List<XDocument> xmlDocuments, string rootName)
{
// Using LINQ to Objects for a more concise solution
// 使用 LINQ to Objects 实现更简洁的解决方案
var result = xmlDocuments
.Where(doc => doc.Root != null && doc.Root.Name.LocalName == rootName)
.ToList();
@ -403,7 +442,8 @@ namespace Data
// PackAbout 对象
sb.AppendLine("=== PackAbout ===");
sb.AppendLine(packAbout?.ToString() ?? "N/A"); // 调用 PackAbout 的 ToString()
// 优化点3：使用 PackAbout.ToString()
sb.AppendLine(packAbout?.ToString() ?? "N/A");
sb.AppendLine();
// 字典字段（defines）
@ -417,28 +457,38 @@ namespace Data
sb.AppendLine(); // 每个类别后空一行
}
else
sb.AppendLine("No defines found.");
sb.AppendLine("未找到定义。");
return sb.ToString();
}
/// <summary>
/// 检查字段的类型是否继承自指定的类
/// 检查字段的类型是否继承自指定的类 (严格派生，不包括基类本身)
/// </summary>
/// <param name="field">字段信息</param>
/// <param name="baseType">要检查的基类类型</param>
/// <returns>如果字段的类型是基类或其派生类，则返回 true</returns>
/// <returns>如果字段的类型是基类的严格派生类，则返回 true</returns>
// 优化点6：为 IsFieldTypeInheritedFrom 进行语义澄清
public static bool IsFieldTypeInheritedFrom(FieldInfo field, Type baseType)
{
// 获取字段的类型
var fieldType = field.FieldType;
// 如果字段的类型为 null 或不是基类的派生类，则返回 false
if (!baseType.IsAssignableFrom(fieldType))
return false;
// 如果字段的类型直接是基类或其派生类，则返回 true
return fieldType != baseType && baseType.IsAssignableFrom(fieldType);
// 严格派生：不包括基类本身
return fieldType != null && fieldType != baseType && baseType.IsAssignableFrom(fieldType);
}
/// <summary>
/// 检查一个类型是否继承自指定的基类 (严格派生，不包括基类本身)
/// </summary>
/// <param name="type">要检查的类型</param>
/// <param name="baseType">要检查的基类类型</param>
/// <returns>如果类型是基类的严格派生类，则返回 true</returns>
// 在 ConvertXElementValueToType 中使用的新类型检查辅助方法
public static bool IsTypeInheritedFrom(Type type, Type baseType)
{
return type != null && type != baseType && baseType.IsAssignableFrom(type);
}
}
}