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

(client) feat:实现实体动态创建，实体右键菜单

Browse Source 
Co-authored-by: m0_75251201 <m0_75251201@noreply.gitcode.com>
Reviewed-on: #41
This commit is contained in:
zzdxxz
2025-07-25 19:16:58 +08:00
parent 28ddcda9a0
commit 82dc89c890
55 changed files with 2964 additions and 747 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
Client/Assets/Scripts/Managers/DefineManager.cs
View File

@ -1,4 +1,5 @@
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
@ -14,9 +15,11 @@ namespace Managers
public class DefineManager : Singleton<DefineManager>
{
private static readonly string[] dataSetFilePath = { "Data", "Mods" };
//类别，定义名，定义
public Dictionary<string, Dictionary<string, Define>> defines = new();
//包id，包
public Dictionary<string, DefinePack> packs = new();
//类别，定义
public Dictionary<string, List<Define>> anonymousDefines = new();
/// <summary>
/// 初始化定义管理器，加载所有定义包并构建定义字典。
@ -44,15 +47,18 @@ namespace Managers
Dictionary<Type, FieldInfo[]> fieldCache = new();
// 需要链接的定义、需要链接的字段、链接信息
List<Tuple<Define, FieldInfo, Define>> defineCache = new();
HashSet<Define> processedDefines = new(); // 用于跟踪已处理的 Define 对象
string currentPackID = string.Empty;
void ProcessDefine(Define def, Define parentDef, FieldInfo parentField)
void ProcessDefine(Define def)
{
if (def == null || def.isReferene || processedDefines.Contains(def))
if (def == null || def.isReferene)
return;
processedDefines.Add(def);
def.packID = currentPackID;
// 如果字段信息已经缓存，则直接使用缓存
if (!fieldCache.TryGetValue(def.GetType(), out var defineFields))
@ -60,57 +66,123 @@ namespace Managers
// 获取所有字段类型为 Define 或其派生类型的字段
defineFields = def.GetType()
.GetFields(BindingFlags.Public | BindingFlags.Instance)
.Where(field => typeof(Define).IsAssignableFrom(field.FieldType))
.ToArray();
.ToArray(); // 不再过滤，先获取所有字段
// 缓存字段信息
fieldCache[def.GetType()] = defineFields;
}
foreach (var defineField in defineFields)
{
var defRef = (Define)defineField.GetValue(def);
if (defRef == null)
continue;
if (defRef.isReferene)
var fieldType = defineField.FieldType;
// 处理单个 Define 类型的字段
if (typeof(Define).IsAssignableFrom(fieldType))
{
defineCache.Add(new Tuple<Define, FieldInfo, Define>(parentDef, parentField, defRef));
}
else
{
if (string.IsNullOrEmpty(defRef.defName))
var defRef = (Define)defineField.GetValue(def);
if (defRef == null)
continue;
if (defRef.isReferene)
{
var typeName = defRef.GetType().Name;
if (!anonymousDefines.ContainsKey(typeName))
anonymousDefines.Add(typeName, new List<Define>());
anonymousDefines[typeName].Add(defRef);
defineCache.Add(new Tuple<Define, FieldInfo, Define>(def, defineField, 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);
}
}
// 处理集合类型字段
else if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(List<>))
{
var elementType = fieldType.GenericTypeArguments[0];
if (typeof(Define).IsAssignableFrom(elementType))
{
var list = (IList)defineField.GetValue(def);
if (list != null)
{
foreach (var item in list)
{
if (item is Define defItem && !defItem.isReferene)
{
ProcessDefine(defItem);
}
}
}
}
}
// 处理数组类型字段
else if (fieldType.IsArray)
{
var elementType = fieldType.GetElementType();
if (typeof(Define).IsAssignableFrom(elementType))
{
var array = (Array)defineField.GetValue(def);
if (array != null)
{
foreach (var item in array)
{
if (item is Define defItem && !defItem.isReferene)
{
ProcessDefine(defItem);
}
}
}
}
ProcessDefine(defRef, def, defineField);
}
}
}
foreach (var pack in packs)
{
foreach (var define in pack.Value.defines)
currentPackID = pack.Value.packID;
foreach (var (typeName, defList) in pack.Value.defines)
{
var typeName = define.Key;
var defList = define.Value;
if (!defines.ContainsKey(typeName))
defines[typeName] = new Dictionary<string, Define>();
foreach (var def in defList)
{
defines[typeName][def.defName] = def;
// 处理顶层 Define
ProcessDefine(def, null, null);
ProcessDefine(def);
}
}
}
foreach (var defRef in defineCache)
{
defRef.Item2.SetValue(defRef.Item1, FindDefine(defRef.Item3.description, defRef.Item3.defName));
if (defRef.Item1 == null)
{
Debug.LogError("defRef.Item1 为 null！");
continue;
}
if (defRef.Item2 == null)
{
Debug.LogError("defRef.Item2 为 null！");
continue;
}
var value = FindDefine(defRef.Item3.description, defRef.Item3.defName);
if (value == null)
{
Debug.LogError($"FindDefine 返回 null: description={defRef.Item3.description}, defName={defRef.Item3.defName}");
continue;
}
try
{
defRef.Item2.SetValue(defRef.Item1, value);
}
catch (Exception ex)
{
Debug.LogError($"SetValue 出错: {ex.Message}");
}
}
}
@ -138,7 +210,23 @@ namespace Managers
}
return null;
}
/// <summary>
/// 使用模板查找并返回指定类型的 Define 对象。
/// </summary>
/// <typeparam name="T">目标类型</typeparam>
/// <param name="defineName">定义名</param>
/// <returns>如果找到，返回转换为目标类型的 Define 对象；否则返回 null。</returns>
public T FindDefine<T>(string defineName) where T : Define
{
foreach (var typeDict in defines.Values)
{
if (typeDict.TryGetValue(defineName, out var define) && define is T result)
{
return result;
}
}
return null;
}
public DefinePack GetDefinePackage(Define define)
{
if (define == null || define.packID == null)
@ -340,4 +428,5 @@ namespace Managers
return result.ToString();
}
}
}
}