Roguelite-Game-Developing-Team/Gen_Hack-and-Slash-Roguelite
2
0
Fork 2
Code Issues Pull Requests Actions Packages Projects Releases Activity

main #7

Merged
TheRedApricot merged 4 commits from :main into main 2025-07-12 16:57:28 +08:00
Conversation 1 Commits 4 Files Changed 3 +256 -181
3 changed files with 256 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
Client/Assets/Scripts/Data/DefineManager.cs
View File

@ -1,9 +1,11 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Xml.Linq;
using UnityEngine;
using UnityEngine.Rendering;
using Utils;
namespace Data
@ -15,150 +17,20 @@ namespace Data
const string coreNamespace = "Data";
public Dictionary<string, Dictionary<string, Define>> defines = new();
public Dictionary<string, DefinePack> packs = new();
public void Init()
{
// 加载所有 XML 文件路径
var xmlFilePaths = FileHandler.GetXmlFilePathsFromPaths(dataSetFilePath);
// 遍历并加载每个 XML 文件
foreach (var xmlFilePath in xmlFilePaths)
var packFolder = Directory.GetDirectories(dataSetFilePath[0]);
foreach (var folder in packFolder)
{
LoadXmlData(xmlFilePath);
}
}
public void LoadXmlData(string xmlFilePath)
var pack=new DefinePack();
if (pack.LoadPack(folder))
{
// 检查文件是否存在
if (!File.Exists(xmlFilePath))
{
Debug.LogWarning($"XML文件不存在: {xmlFilePath}");
return;
}
var xdoc = XDocument.Load(xmlFilePath);
// 解析Define节点
var rootElement = xdoc.Root;
if (rootElement != null)
{
if (rootElement.Name == "Define")
{
foreach (var element in rootElement.Elements())
{
var def = LoadDefine(element);
var className = element.Name.ToString();
var name = element.Element("defName")?.Value;
if (def != null && !string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(className))
{
defines.TryAdd(className, new Dictionary<string, Define>());
defines[className][name] = (Define)def;
packs.Add(pack.packID, pack);
}
}
}
}
}
public object LoadDefine(XElement xElement)
{
var className = xElement.Name.ToString();
var assembly = Assembly.GetExecutingAssembly();
Type type;
if (!className.Contains('.'))
{
// 尝试拼接默认命名空间
var fullClassName = coreNamespace + className;
type = assembly.GetType(fullClassName);
// 如果拼接命名空间后仍找不到，尝试直接查找（可能是全局命名空间下的类）
if (type == null)
{
type = assembly.GetType(className);
}
}
else
{
// 直接查找
type = assembly.GetType(className);
}
if (type == null)
{
Debug.LogError($"未定义的类型: {className}");
return null;
}
var constructor = type.GetConstructor(Type.EmptyTypes);
if (constructor == null)
{
Debug.LogError($"{className} 必须包含无参构造函数");
return null;
}
// 3. 创建实例
object instance;
try
{
instance = Activator.CreateInstance(type);
}
catch (Exception ex)
{
Debug.LogError($"创建 {className} 实例失败: {ex.Message}");
return null;
}
// 4. 检查是否继承自 Define
if (instance is not Define define)
{
Debug.LogError($"{className} 必须继承自 Define");
return null;
}
if (define.Init(xElement))
{
return define;
}
// 获取类的所有字段（不包括私有字段）
var fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
// 遍历字段并尝试从 XElement 中赋值
foreach (var field in fields)
{
// 查找对应的 XElement 子元素
var element = xElement.Element(field.Name);
if (element != null)
{
try
{
// 将子元素的值转换为目标类型并赋值
object value = Convert.ChangeType(element.Value, field.FieldType);
field.SetValue(define, value);
}
catch (Exception ex)
{
Debug.LogWarning($"Error setting field {field.Name}: {ex.Message}");
}
}
}
return define;
}
public static void SetField(object obj, string fieldName, object value)
{
var type = obj.GetType();
var field = type.GetField(fieldName);
if (field != null)
{
field.SetValue(obj, Convert.ChangeType(value, field.FieldType));
}
else
{
Debug.LogWarning($"Field '{fieldName}' not found.");
}
}
}
}

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

@ -1,54 +1,236 @@
using System;
using System.Collections.Generic;
using System.Xml;
using System.Linq;
using System.Reflection;
using System.Xml.Linq;
using UnityEngine;
namespace Data
{
public struct PackAbout
{
public string name;
public string description;
public string author;
public string version;
public string packID;
public string[] necessary;
public string[] after;
public string[] before;
/// <summary>
/// 使用静态方法从 XML 文档创建 PackAbout 实例。
/// </summary>
/// <param name="doc">XML 文档。</param>
/// <returns>初始化的 PackAbout 实例。</returns>
public static PackAbout FromXDocument(XDocument doc)
{
var aboutElement = doc.Element("About");
if (aboutElement == null)
{
throw new ArgumentException("XML 文档无效，根节点为空或不是 'About'。");
}
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";
XElement sortElement = aboutElement.Element("sort");
if (sortElement != null)
{
result.before = GetElementValues(sortElement.Element("before"));
result.after = GetElementValues(sortElement.Element("after"));
result.necessary = GetElementValues(sortElement.Element("necessary"));
}
else
{
result.before = System.Array.Empty<string>();
result.after = System.Array.Empty<string>();
result.necessary = System.Array.Empty<string>();
}
return result;
}
/// <summary>
/// 获取指定 XElement 下所有子元素的值并返回为字符串数组。
/// </summary>
/// <param name="element">父 XElement。</param>
/// <returns>字符串数组。</returns>
private static string[] GetElementValues(XElement element)
{
if (element == null || !element.HasElements)
{
return System.Array.Empty<string>();
}
return element.Elements()
.Select(e => e.Value.Trim())
.ToArray();
}
}
public class DefinePack
{
public string packID;
public PackAbout packAbout;
public List<Define> defines;
/// <summary>
/// define类别及其定义
/// </summary>
public Dictionary<string,List<Define>> defines;
public void LoadPack(string packPath)
private const string CoreNamespace = "Data.";
public bool LoadPack(string packPath)
{
var packDatas=Utils.FileHandler.LoadXmlFromPath(packPath);
var aboutXmls=FindDocumentsWithRootName(packDatas,"About");
if (aboutXmls == null || aboutXmls.Count < 1)
{
Debug.LogError("包缺少配置文件，加载跳过");
return false;
}
var aboutXml=aboutXmls[0];
packAbout=PackAbout.FromXDocument(aboutXml);
packID=packAbout.packID;
if (aboutXmls.Count > 1)
{
Debug.LogWarning($"{packAbout.name}包拥有多个配置文件，系统选择了加载序的第一个，请避免这种情况");
}
var defineXmls=FindDocumentsWithRootName(aboutXmls, "Define");
foreach (var defineXml in defineXmls)
{
LoadDefines(defineXml);
}
return true;
}
private void LoadDefines(XDocument defineDoc)
{
var rootElement = defineDoc.Root;
if(rootElement==null||rootElement.Name != "Define")
return;
foreach (var element in rootElement.Elements())
{
var className = element.Name.ToString();
if (string.IsNullOrEmpty(className))
continue;
var def = LoadDefineClass(element);
if (def == null)
continue;
if (!defines.ContainsKey(className))
defines.Add(className,new List<Define>());
defines[className].Add(def);
}
}
private Define LoadDefineClass(XElement defineDoc)
{
var className = defineDoc.Name.ToString();
var assembly = Assembly.GetExecutingAssembly();
Type type;
if (!className.Contains('.'))
{
// 尝试拼接默认命名空间
var fullClassName = CoreNamespace + className;
type = assembly.GetType(fullClassName);
// 如果拼接命名空间后仍找不到，尝试直接查找（可能是全局命名空间下的类）
if (type == null)
{
type = assembly.GetType(className);
}
}
else
{
// 直接查找
type = assembly.GetType(className);
}
if (type == null)
{
Debug.LogError($"未定义的类型: {className}");
return null;
}
var constructor = type.GetConstructor(Type.EmptyTypes);
if (constructor == null)
{
Debug.LogError($"{className} 必须包含无参构造函数");
return null;
}
// 3. 创建实例
object instance;
try
{
instance = Activator.CreateInstance(type);
}
catch (Exception ex)
{
Debug.LogError($"创建 {className} 实例失败: {ex.Message}");
return null;
}
// 4. 检查是否继承自 Define
if (instance is not Define define)
{
Debug.LogError($"{className} 必须继承自 Define");
return null;
}
if (define.Init(defineDoc))
{
return define;
}
// 获取类的所有字段（不包括私有字段）
var fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic);
// 遍历字段并尝试从 XElement 中赋值
foreach (var field in fields)
{
// 查找对应的 XElement 子元素
var element = defineDoc.Element(field.Name);
if (element != null)
{
try
{
// 将子元素的值转换为目标类型并赋值
object value = Convert.ChangeType(element.Value, field.FieldType);
field.SetValue(define, value);
}
catch (Exception ex)
{
Debug.LogWarning($"Error setting field {field.Name}: {ex.Message}");
}
}
}
return define;
}
/// <summary>
/// 从 List<c>XmlDocument</c> 中查找指定根元素名称的文档。
/// 从 List<c>XDocument</c> 中查找指定根元素名称的文档。
/// </summary>
/// <param name="xmlDocuments">XML 文档列表。</param>
/// <param name="rootName">目标根元素名称。</param>
/// <returns>符合条件的 XML 文档列表。</returns>
public static List<XmlDocument> FindDocumentsWithRootName(List<XmlDocument> xmlDocuments, string rootName)
public static List<XDocument> FindDocumentsWithRootName(List<XDocument> xmlDocuments, string rootName)
{
var result = new List<XmlDocument>();
foreach (var xmlDoc in xmlDocuments)
{
try
{
// 获取根节点
var root = xmlDoc.DocumentElement;
if (root != null && root.Name == rootName)
{
// 如果根节点名称匹配，则添加到结果列表
result.Add(xmlDoc);
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"处理 XML 文档时发生错误: {ex.Message}");
}
}
// Using LINQ to Objects for a more concise solution
var result = xmlDocuments
.Where(doc => doc.Root != null && doc.Root.Name.LocalName == rootName)
.ToList();
return result;
}

61
Client/Assets/Scripts/Utils/FileHandler.cs
View File

@ -1,7 +1,7 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml;
using System.Xml.Linq;
using Newtonsoft.Json;
using UnityEngine;
using Formatting = Newtonsoft.Json.Formatting;
@ -196,37 +196,30 @@ namespace Utils
return xmlFilePaths;
}
/// <summary>
/// 从指定路径加载所有 XML 文件并解析为 XmlDocument 对象。
/// 从指定路径加载所有 XML 文件并解析为 XDocument 对象。
/// </summary>
/// <param name="paths">文件夹路径数组。</param>
/// <returns>包含所有解析后的 XmlDocument 对象的列表。</returns>
public static List<XmlDocument> LoadXmlFromPaths(string[] paths)
/// <returns>包含所有解析后的 XDocument 对象的列表。</returns>
public static List<XDocument> LoadXmlFromPaths(string[] paths)
{
var xmlDocuments = new List<XmlDocument>();
var xDocuments = new List<XDocument>();
var xmlFilePaths = GetXmlFilePathsFromPaths(paths);
foreach (var filePath in xmlFilePaths)
{
try
{
// 创建一个新的 XmlDocument 实例
var xmlDoc = new XmlDocument();
// 加载 XML 文件内容
xmlDoc.Load(filePath);
// 将解析后的 XmlDocument 添加到结果列表中
xmlDocuments.Add(xmlDoc);
var xDoc = XDocument.Load(filePath);
xDocuments.Add(xDoc);
}
catch (Exception ex)
catch (System.Exception ex)
{
Console.Error.WriteLine($"加载 XML 文件 {filePath} 时发生错误: {ex.Message}");
Debug.LogError($"加载 XML 文件 {filePath} 时发生错误: {ex.Message}");
}
}
return xmlDocuments;
return xDocuments;
}
/// <summary>
/// 获取指定单个路径下的所有 XML 文件。
@ -238,14 +231,42 @@ namespace Utils
return GetXmlFilePathsFromPaths(new[] { path });
}
/// <summary>
/// 从指定单个路径加载所有 XML 文件并解析为 XmlDocument 对象。
/// 从指定单个路径加载所有 XML 文件并解析为 XDocument 对象。
/// </summary>
/// <param name="path">文件夹路径。</param>
/// <returns>包含所有解析后的 XmlDocument 对象的列表。</returns>
public static List<XmlDocument> LoadXmlFromPath(string path)
/// <returns>包含所有解析后的 XDocument 对象的列表。</returns>
public static List<XDocument> LoadXmlFromPath(string path)
{
return LoadXmlFromPaths(new[] { path });
}
/// <summary>
/// 获取文件夹列表中所有直接子文件夹的路径。
/// </summary>
/// <param name="folderPaths">文件夹路径列表。</param>
/// <returns>包含所有子文件夹路径的列表。</returns>
public static List<string> GetSubFolders(List<string> folderPaths)
{
List<string> result = new List<string>();
foreach (string folderPath in folderPaths)
{
if (Directory.Exists(folderPath))
{
// 获取当前文件夹的直接子文件夹
string[] subFolders = Directory.GetDirectories(folderPath);
// 将子文件夹路径添加到结果列表中
result.AddRange(subFolders);
}
else
{
Debug.LogWarning($"警告: 文件夹不存在 - {folderPath}");
}
}
return result;
}
}
}