using System.Collections.Generic;
|
using System.Linq;
|
using System.Reflection;
|
using UnityEditor;
|
using UnityEngine;
|
|
/// <summary>
|
/// 战斗网络包查看器
|
/// 用于查看和搜索 DTCB430_tagSCTurnFightReport 解析的战斗包
|
/// 快捷键：Alt+8
|
/// </summary>
|
public class BattleReportChecker : EditorWindow
|
{
|
#region 静态数据存储
|
|
// 存储所有战斗包数据，按 guid 组织
|
private static Dictionary<string, List<PackageInfo>> allBattlePackages = new Dictionary<string, List<PackageInfo>>();
|
|
// 跟踪已执行的包UID（按 guid 组织）
|
private static Dictionary<string, HashSet<ulong>> executedPackUIDs = new Dictionary<string, HashSet<ulong>>();
|
|
// 跟踪当前正在执行的包UID（按 guid 组织）
|
private static Dictionary<string, ulong> currentExecutingPackUID = new Dictionary<string, ulong>();
|
|
// 包信息类
|
public class PackageInfo
|
{
|
public GameNetPackBasic package;
|
public string displayName;
|
public ulong packUID;
|
public string typeName;
|
public bool isExpanded;
|
public Dictionary<string, string> fields = new Dictionary<string, string>();
|
public Dictionary<string, FieldDetail> fieldDetails = new Dictionary<string, FieldDetail>();
|
|
public PackageInfo(GameNetPackBasic pack)
|
{
|
package = pack;
|
packUID = pack.packUID;
|
typeName = pack.GetType().Name;
|
displayName = $"[{packUID}] {typeName}";
|
isExpanded = false;
|
ExtractFields();
|
}
|
|
private void ExtractFields()
|
{
|
if (package == null) return;
|
|
var type = package.GetType();
|
var fieldInfos = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
|
|
foreach (var field in fieldInfos)
|
{
|
try
|
{
|
var value = field.GetValue(package);
|
string valueStr = value != null ? value.ToString() : "null";
|
|
var detail = new FieldDetail { value = value };
|
|
// 特殊处理数组（注意：先判断Array，因为Array不是IList的子类）
|
if (value != null && value.GetType().IsArray)
|
{
|
System.Array array = value as System.Array;
|
valueStr = $"Array[{array.Length}]";
|
detail.isArray = true;
|
detail.arrayValue = array;
|
}
|
// 特殊处理列表（IList包括List<T>和其他列表类型）
|
else if (value is System.Collections.IList list && !(value is string))
|
{
|
valueStr = $"List[{list.Count}]";
|
detail.isList = true;
|
detail.listValue = list;
|
}
|
|
fields[field.Name] = valueStr;
|
fieldDetails[field.Name] = detail;
|
}
|
catch (System.Exception ex)
|
{
|
fields[field.Name] = "读取失败: " + ex.Message;
|
fieldDetails[field.Name] = new FieldDetail { value = null };
|
}
|
}
|
}
|
}
|
|
// 字段详细信息类
|
public class FieldDetail
|
{
|
public object value;
|
public bool isArray;
|
public bool isList;
|
public bool isExpanded;
|
public System.Array arrayValue;
|
public System.Collections.IList listValue;
|
|
// 嵌套的子字段详情（用于复杂类型）
|
public Dictionary<string, FieldDetail> subFieldDetails = new Dictionary<string, FieldDetail>();
|
|
// 数组/列表元素的展开状态
|
public Dictionary<int, ElementDetail> elementDetails = new Dictionary<int, ElementDetail>();
|
}
|
|
// 数组/列表元素详细信息类
|
public class ElementDetail
|
{
|
public bool isExpanded;
|
public Dictionary<string, FieldDetail> fieldDetails = new Dictionary<string, FieldDetail>();
|
}
|
|
/// <summary>
|
/// 供外部调用，添加解析后的包
|
/// </summary>
|
public static void AddBattlePackages(string guid, List<GameNetPackBasic> packages)
|
{
|
if (packages == null || packages.Count == 0) return;
|
|
var packInfoList = packages.Select(p => new PackageInfo(p)).ToList();
|
|
if (allBattlePackages.ContainsKey(guid))
|
{
|
allBattlePackages[guid].AddRange(packInfoList);
|
}
|
else
|
{
|
allBattlePackages[guid] = packInfoList;
|
}
|
|
Debug.Log($"[BattleReportChecker] 已记录 {packages.Count} 个包，GUID: {guid}");
|
}
|
|
/// <summary>
|
/// 清空所有记录
|
/// </summary>
|
public static void ClearAllPackages()
|
{
|
allBattlePackages.Clear();
|
executedPackUIDs.Clear();
|
currentExecutingPackUID.Clear();
|
Debug.Log("[BattleReportChecker] 已清空所有包记录");
|
}
|
|
/// <summary>
|
/// 标记包开始执行
|
/// </summary>
|
public static void MarkPackageExecuting(string guid, ulong packUID)
|
{
|
if (!currentExecutingPackUID.ContainsKey(guid))
|
{
|
currentExecutingPackUID[guid] = packUID;
|
}
|
else
|
{
|
currentExecutingPackUID[guid] = packUID;
|
}
|
}
|
|
/// <summary>
|
/// 标记包执行完成
|
/// </summary>
|
public static void MarkPackageExecuted(string guid, ulong packUID)
|
{
|
if (!executedPackUIDs.ContainsKey(guid))
|
{
|
executedPackUIDs[guid] = new HashSet<ulong>();
|
}
|
executedPackUIDs[guid].Add(packUID);
|
|
// 清除当前执行标记
|
if (currentExecutingPackUID.ContainsKey(guid) && currentExecutingPackUID[guid] == packUID)
|
{
|
currentExecutingPackUID.Remove(guid);
|
}
|
}
|
|
#endregion
|
|
#region 窗口管理
|
|
[MenuItem("程序/战斗网络包查看器 &8")] // Alt+8
|
public static void ShowWindow()
|
{
|
var window = GetWindow<BattleReportChecker>("战斗包查看器");
|
window.minSize = new Vector2(600, 400);
|
window.Show();
|
}
|
|
#endregion
|
|
#region UI 状态
|
|
private Vector2 scrollPosition;
|
private Vector2 detailScrollPosition;
|
private string searchText = "";
|
private string detailSearchText = ""; // 详情搜索文本
|
private string lastDetailSearchText = ""; // 上次的详情搜索文本，用于检测变化
|
private string selectedGuid = "";
|
private List<string> guidList = new List<string>();
|
private int selectedGuidIndex = 0;
|
private List<PackageInfo> filteredPackages = new List<PackageInfo>();
|
private PackageInfo selectedPackage = null;
|
private PackageInfo lastSelectedPackage = null; // 上次选中的包，用于检测包切换
|
|
// 高亮相关
|
private PackageInfo highlightedPackage = null;
|
private double highlightStartTime = 0;
|
private const double highlightDuration = 5.0; // 高亮持续5秒
|
private int selectedPackageIndex = -1; // 记录选中包在列表中的索引，用于滚动
|
|
// 搜索缓存
|
private HashSet<string> matchedFieldNames = new HashSet<string>(); // 缓存匹配的字段名
|
private Dictionary<string, bool> fieldHasMatchedChild = new Dictionary<string, bool>(); // 缓存字段是否有匹配的子元素
|
|
#endregion
|
|
#region Unity 生命周期
|
|
private void OnEnable()
|
{
|
RefreshGuidList();
|
// 启用编辑器更新，让颜色实时刷新
|
EditorApplication.update += OnEditorUpdate;
|
}
|
|
private void OnDisable()
|
{
|
// 移除更新回调
|
EditorApplication.update -= OnEditorUpdate;
|
}
|
|
private void OnEditorUpdate()
|
{
|
// 定期刷新UI以更新包的执行状态颜色
|
Repaint();
|
}
|
|
private void OnGUI()
|
{
|
EditorGUILayout.BeginVertical();
|
|
DrawToolbar();
|
DrawGuidSelector();
|
DrawSearchBar();
|
|
EditorGUILayout.BeginHorizontal();
|
DrawPackageList();
|
DrawPackageDetails();
|
EditorGUILayout.EndHorizontal();
|
|
EditorGUILayout.EndVertical();
|
}
|
|
#endregion
|
|
#region UI 绘制
|
|
private void DrawToolbar()
|
{
|
EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
|
|
if (GUILayout.Button("刷新", EditorStyles.toolbarButton, GUILayout.Width(60)))
|
{
|
// 刷新前清空搜索缓存，避免卡死
|
matchedFieldNames.Clear();
|
fieldHasMatchedChild.Clear();
|
lastSelectedPackage = null;
|
lastDetailSearchText = "";
|
|
RefreshGuidList();
|
FilterPackages();
|
}
|
|
if (GUILayout.Button("清空所有", EditorStyles.toolbarButton, GUILayout.Width(80)))
|
{
|
if (EditorUtility.DisplayDialog("确认", "确定要清空所有包记录吗？", "确定", "取消"))
|
{
|
ClearAllPackages();
|
RefreshGuidList();
|
FilterPackages();
|
}
|
}
|
|
GUILayout.FlexibleSpace();
|
|
GUILayout.Label($"总包数: {filteredPackages.Count}", EditorStyles.toolbarButton);
|
|
EditorGUILayout.EndHorizontal();
|
}
|
|
private void DrawGuidSelector()
|
{
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Label("战场GUID:", GUILayout.Width(80));
|
|
if (guidList.Count == 0)
|
{
|
GUILayout.Label("暂无数据", EditorStyles.helpBox);
|
}
|
else
|
{
|
int newIndex = EditorGUILayout.Popup(selectedGuidIndex, guidList.ToArray());
|
if (newIndex != selectedGuidIndex)
|
{
|
selectedGuidIndex = newIndex;
|
selectedGuid = guidList[selectedGuidIndex];
|
FilterPackages();
|
}
|
}
|
|
EditorGUILayout.EndHorizontal();
|
EditorGUILayout.Space(5);
|
}
|
|
private void DrawSearchBar()
|
{
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Label("搜索:", GUILayout.Width(80));
|
|
string newSearchText = EditorGUILayout.TextField(searchText);
|
if (newSearchText != searchText)
|
{
|
searchText = newSearchText;
|
FilterPackages();
|
|
// 搜索后自动选中第一个结果并高亮
|
if (filteredPackages.Count > 0)
|
{
|
selectedPackage = filteredPackages[0];
|
selectedPackageIndex = 0;
|
StartHighlight(selectedPackage);
|
ScrollToSelectedPackage();
|
}
|
}
|
|
if (GUILayout.Button("清空", GUILayout.Width(60)))
|
{
|
searchText = "";
|
FilterPackages();
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
GUILayout.Label("支持搜索：包类型名、UID、字段值", EditorStyles.miniLabel);
|
EditorGUILayout.Space(5);
|
}
|
|
private void DrawPackageList()
|
{
|
EditorGUILayout.BeginVertical(GUILayout.Width(position.width * 0.5f));
|
|
GUILayout.Label("包列表", EditorStyles.boldLabel);
|
|
scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition, GUI.skin.box);
|
|
if (filteredPackages.Count == 0)
|
{
|
GUILayout.Label("没有找到匹配的包", EditorStyles.helpBox);
|
}
|
else
|
{
|
foreach (var packInfo in filteredPackages)
|
{
|
DrawPackageItem(packInfo);
|
}
|
}
|
|
EditorGUILayout.EndScrollView();
|
EditorGUILayout.EndVertical();
|
}
|
|
private void DrawPackageItem(PackageInfo packInfo)
|
{
|
// 判断包的执行状态
|
bool isExecuting = currentExecutingPackUID.ContainsKey(selectedGuid) &&
|
currentExecutingPackUID[selectedGuid] == packInfo.packUID;
|
bool isExecuted = executedPackUIDs.ContainsKey(selectedGuid) &&
|
executedPackUIDs[selectedGuid].Contains(packInfo.packUID);
|
|
// 判断是否是高亮状态
|
bool isHighlighted = IsPackageHighlighted(packInfo);
|
|
// 设置背景颜色
|
Color originalBgColor = GUI.backgroundColor;
|
if (isHighlighted)
|
{
|
// 高亮状态 - 使用绿色闪烁效果
|
float pulse = Mathf.PingPong((float)EditorApplication.timeSinceStartup * 2f, 1f);
|
GUI.backgroundColor = Color.Lerp(new Color(0.3f, 0.8f, 0.3f), new Color(0.5f, 1f, 0.5f), pulse);
|
}
|
else if (isExecuting)
|
{
|
GUI.backgroundColor = new Color(0.3f, 0.3f, 0.3f); // 深黑色（正在执行）
|
}
|
else if (isExecuted)
|
{
|
GUI.backgroundColor = new Color(0.6f, 0.6f, 0.6f); // 灰色（已执行）
|
}
|
else
|
{
|
GUI.backgroundColor = new Color(0.8f, 0.8f, 0.8f); // 浅灰色（未执行）
|
}
|
|
EditorGUILayout.BeginVertical(GUI.skin.box);
|
|
GUI.backgroundColor = originalBgColor; // 恢复原始颜色
|
|
EditorGUILayout.BeginHorizontal();
|
|
// 展开/折叠按钮
|
string foldoutLabel = packInfo.isExpanded ? "▼" : "▶";
|
if (GUILayout.Button(foldoutLabel, EditorStyles.label, GUILayout.Width(20)))
|
{
|
packInfo.isExpanded = !packInfo.isExpanded;
|
}
|
|
// 包名称（可点击选中）
|
bool isSelected = selectedPackage == packInfo;
|
|
// 根据状态设置文本颜色
|
GUIStyle style;
|
if (isSelected)
|
{
|
style = new GUIStyle(EditorStyles.boldLabel) { normal = { textColor = Color.cyan } };
|
}
|
else if (isExecuting)
|
{
|
style = new GUIStyle(EditorStyles.label) { normal = { textColor = Color.yellow } }; // 黄色高亮
|
}
|
else if (isExecuted)
|
{
|
style = new GUIStyle(EditorStyles.label) { normal = { textColor = Color.gray } };
|
}
|
else
|
{
|
style = EditorStyles.label;
|
}
|
|
if (GUILayout.Button(packInfo.displayName, style))
|
{
|
selectedPackage = packInfo;
|
selectedPackageIndex = filteredPackages.IndexOf(packInfo);
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
// 展开显示简要信息
|
if (packInfo.isExpanded)
|
{
|
EditorGUI.indentLevel++;
|
|
// 显示前5个字段
|
int count = 0;
|
foreach (var field in packInfo.fields)
|
{
|
if (count >= 5) break;
|
|
EditorGUILayout.BeginHorizontal();
|
GUILayout.Label(field.Key + ":", GUILayout.Width(120));
|
GUILayout.Label(field.Value, EditorStyles.wordWrappedLabel);
|
EditorGUILayout.EndHorizontal();
|
|
count++;
|
}
|
|
if (packInfo.fields.Count > 5)
|
{
|
GUILayout.Label($"... 更多字段请在右侧查看", EditorStyles.miniLabel);
|
}
|
|
EditorGUI.indentLevel--;
|
}
|
|
EditorGUILayout.EndVertical();
|
}
|
|
private void DrawPackageDetails()
|
{
|
EditorGUILayout.BeginVertical(GUILayout.Width(position.width * 0.5f - 10));
|
|
GUILayout.Label("包详情", EditorStyles.boldLabel);
|
|
if (selectedPackage == null)
|
{
|
GUILayout.Label("请从左侧列表选择一个包查看详情", EditorStyles.helpBox);
|
}
|
else
|
{
|
// 详情搜索栏
|
EditorGUILayout.BeginHorizontal();
|
GUILayout.Label("搜索字段:", GUILayout.Width(70));
|
detailSearchText = EditorGUILayout.TextField(detailSearchText);
|
if (GUILayout.Button("清空", GUILayout.Width(50)))
|
{
|
detailSearchText = "";
|
}
|
EditorGUILayout.EndHorizontal();
|
|
// 检测选中包或搜索文本变化，更新缓存
|
bool packageChanged = selectedPackage != lastSelectedPackage;
|
bool searchTextChanged = detailSearchText != lastDetailSearchText;
|
|
if (packageChanged || searchTextChanged)
|
{
|
lastDetailSearchText = detailSearchText;
|
lastSelectedPackage = selectedPackage;
|
UpdateDetailSearchCache();
|
}
|
|
if (string.IsNullOrEmpty(detailSearchText))
|
{
|
GUILayout.Label("在此包的字段中搜索（字段名或值）", EditorStyles.miniLabel);
|
}
|
else
|
{
|
GUILayout.Label($"找到 {matchedFieldNames.Count} 个匹配的字段（已自动展开并高亮）", EditorStyles.miniLabel);
|
}
|
EditorGUILayout.Space(5);
|
|
detailScrollPosition = EditorGUILayout.BeginScrollView(detailScrollPosition, GUI.skin.box);
|
|
// 标题
|
GUILayout.Label(selectedPackage.displayName, EditorStyles.boldLabel);
|
EditorGUILayout.Space(5);
|
|
// 基本信息 - 支持搜索高亮
|
string searchLower = detailSearchText.ToLower();
|
bool typeMatched = !string.IsNullOrEmpty(detailSearchText) && selectedPackage.typeName.ToLower().Contains(searchLower);
|
bool uidMatched = !string.IsNullOrEmpty(detailSearchText) && selectedPackage.packUID.ToString().Contains(searchLower);
|
bool cmdMatched = !string.IsNullOrEmpty(detailSearchText) && selectedPackage.package.cmd.ToString().Contains(searchLower);
|
|
DrawDetailFieldWithHighlight("包类型", selectedPackage.typeName, typeMatched);
|
DrawDetailFieldWithHighlight("UID", selectedPackage.packUID.ToString(), uidMatched);
|
DrawDetailFieldWithHighlight("Cmd", selectedPackage.package.cmd.ToString(), cmdMatched);
|
EditorGUILayout.Space(10);
|
|
// 所有字段
|
GUILayout.Label("字段列表:", EditorStyles.boldLabel);
|
|
// 根据搜索文本过滤字段
|
foreach (var field in selectedPackage.fields)
|
{
|
if (ShouldShowDetailField(field.Key, field.Value, selectedPackage))
|
{
|
DrawDetailFieldWithExpand(field.Key, field.Value, selectedPackage);
|
}
|
}
|
|
EditorGUILayout.EndScrollView();
|
}
|
|
EditorGUILayout.EndVertical();
|
}
|
|
private void DrawDetailField(string fieldName, string value)
|
{
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Label(fieldName + ":", GUILayout.Width(150));
|
|
EditorGUILayout.SelectableLabel(value, EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
|
|
EditorGUILayout.EndHorizontal();
|
}
|
|
private void DrawDetailFieldWithHighlight(string fieldName, string value, bool isMatched)
|
{
|
if (isMatched)
|
{
|
Color originalBgColor = GUI.backgroundColor;
|
GUI.backgroundColor = new Color(1f, 1f, 0.5f); // 淡黄色背景
|
EditorGUILayout.BeginHorizontal(GUI.skin.box);
|
GUI.backgroundColor = originalBgColor;
|
|
GUIStyle labelStyle = new GUIStyle(GUI.skin.label) { fontStyle = FontStyle.Bold };
|
GUILayout.Label(fieldName + ":", labelStyle, GUILayout.Width(150));
|
EditorGUILayout.SelectableLabel(value, EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
|
|
EditorGUILayout.EndHorizontal();
|
}
|
else
|
{
|
DrawDetailField(fieldName, value);
|
}
|
}
|
|
private void DrawDetailFieldWithExpand(string fieldName, string value, PackageInfo packInfo)
|
{
|
if (!packInfo.fieldDetails.ContainsKey(fieldName))
|
{
|
DrawDetailField(fieldName, value);
|
return;
|
}
|
|
var detail = packInfo.fieldDetails[fieldName];
|
|
// 使用缓存检查是否匹配
|
bool isMatched = matchedFieldNames.Contains(fieldName);
|
|
// 使用缓存检查子元素是否匹配
|
bool hasMatchedChild = false;
|
if (!string.IsNullOrEmpty(detailSearchText))
|
{
|
fieldHasMatchedChild.TryGetValue(fieldName, out hasMatchedChild);
|
}
|
|
// 如果自身匹配或子元素匹配，自动展开
|
if ((isMatched || hasMatchedChild) && !string.IsNullOrEmpty(detailSearchText))
|
{
|
detail.isExpanded = true;
|
}
|
|
// 判断是否是复杂对象（非基本类型、非字符串、非枚举）
|
bool isComplexObject = detail.value != null &&
|
!detail.value.GetType().IsPrimitive &&
|
detail.value.GetType() != typeof(string) &&
|
!detail.value.GetType().IsEnum &&
|
!detail.isArray &&
|
!detail.isList;
|
|
// 如果是数组、列表或复杂对象，显示展开按钮
|
if (detail.isArray || detail.isList || isComplexObject)
|
{
|
// 如果匹配或有匹配的子元素，添加背景颜色
|
Color originalBgColor = GUI.backgroundColor;
|
if (isMatched || hasMatchedChild)
|
{
|
GUI.backgroundColor = new Color(1f, 1f, 0.5f); // 淡黄色背景
|
}
|
|
EditorGUILayout.BeginHorizontal((isMatched || hasMatchedChild) ? GUI.skin.box : GUIStyle.none);
|
GUI.backgroundColor = originalBgColor;
|
|
// 展开按钮
|
string foldoutLabel = detail.isExpanded ? "▼" : "▶";
|
if (GUILayout.Button(foldoutLabel, EditorStyles.label, GUILayout.Width(20)))
|
{
|
detail.isExpanded = !detail.isExpanded;
|
}
|
|
// 字段名样式
|
GUIStyle labelStyle = (isMatched || hasMatchedChild) ? new GUIStyle(GUI.skin.label) { fontStyle = FontStyle.Bold } : GUI.skin.label;
|
GUILayout.Label(fieldName + ":", labelStyle, GUILayout.Width(130));
|
EditorGUILayout.SelectableLabel(value, EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
|
|
EditorGUILayout.EndHorizontal();
|
|
// 如果展开，显示内容
|
if (detail.isExpanded)
|
{
|
EditorGUI.indentLevel++;
|
|
if (detail.isArray && detail.arrayValue != null)
|
{
|
DrawArrayElements(detail.arrayValue, detail);
|
}
|
else if (detail.isList && detail.listValue != null)
|
{
|
DrawListElements(detail.listValue, detail);
|
}
|
else if (isComplexObject)
|
{
|
// 展开复杂对象的字段
|
DrawObjectFields(detail.value, detail.subFieldDetails);
|
}
|
|
EditorGUI.indentLevel--;
|
}
|
}
|
else
|
{
|
// 简单字段也添加高亮
|
if (isMatched)
|
{
|
Color originalBgColor = GUI.backgroundColor;
|
GUI.backgroundColor = new Color(1f, 1f, 0.5f);
|
EditorGUILayout.BeginHorizontal(GUI.skin.box);
|
GUI.backgroundColor = originalBgColor;
|
|
GUIStyle labelStyle = new GUIStyle(GUI.skin.label) { fontStyle = FontStyle.Bold };
|
GUILayout.Label(fieldName + ":", labelStyle, GUILayout.Width(150));
|
EditorGUILayout.SelectableLabel(value, EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
|
|
EditorGUILayout.EndHorizontal();
|
}
|
else
|
{
|
DrawDetailField(fieldName, value);
|
}
|
}
|
}
|
|
private void DrawArrayElements(System.Array array, FieldDetail parentDetail)
|
{
|
if (array == null)
|
{
|
EditorGUILayout.LabelField("Array is null");
|
return;
|
}
|
|
// 显示数组元素数量
|
EditorGUILayout.LabelField($"总共 {array.Length} 个元素:", EditorStyles.miniLabel);
|
|
for (int i = 0; i < array.Length; i++)
|
{
|
var element = array.GetValue(i);
|
DrawArrayElement(i, element, parentDetail);
|
}
|
}
|
|
private void DrawListElements(System.Collections.IList list, FieldDetail parentDetail)
|
{
|
if (list == null)
|
{
|
EditorGUILayout.LabelField("List is null");
|
return;
|
}
|
|
// 显示列表元素数量
|
EditorGUILayout.LabelField($"总共 {list.Count} 个元素:", EditorStyles.miniLabel);
|
|
for (int i = 0; i < list.Count; i++)
|
{
|
var element = list[i];
|
DrawArrayElement(i, element, parentDetail);
|
}
|
}
|
|
private void DrawArrayElement(int index, object element, FieldDetail parentDetail)
|
{
|
if (element == null)
|
{
|
EditorGUILayout.LabelField($"[{index}]", "null");
|
return;
|
}
|
|
var type = element.GetType();
|
|
// 检查元素是否匹配搜索
|
bool isElementMatched = false;
|
if (!string.IsNullOrEmpty(detailSearchText))
|
{
|
HashSet<object> visited = new HashSet<object>();
|
isElementMatched = RecursiveSearchInObject(element, detailSearchText.ToLower(), visited);
|
}
|
|
// 检查是否是 GameNetPackBasic 类型，并判断是否处于执行状态
|
bool isPackageElement = element is GameNetPackBasic;
|
bool isHighlightedPackage = false;
|
bool isExecutingPackage = false;
|
bool isExecutedPackage = false;
|
|
if (isPackageElement)
|
{
|
GameNetPackBasic pack = element as GameNetPackBasic;
|
ulong packUID = pack.packUID;
|
|
// 检查高亮状态
|
if (highlightedPackage != null && highlightedPackage.packUID == packUID)
|
{
|
double elapsed = EditorApplication.timeSinceStartup - highlightStartTime;
|
isHighlightedPackage = elapsed < highlightDuration;
|
}
|
|
// 检查执行状态
|
isExecutingPackage = currentExecutingPackUID.ContainsKey(selectedGuid) &&
|
currentExecutingPackUID[selectedGuid] == packUID;
|
isExecutedPackage = executedPackUIDs.ContainsKey(selectedGuid) &&
|
executedPackUIDs[selectedGuid].Contains(packUID);
|
}
|
|
// 如果是基本类型，直接显示
|
if (type.IsPrimitive || type == typeof(string) || type.IsEnum)
|
{
|
// 如果匹配，添加高亮
|
if (isElementMatched)
|
{
|
Color originalBgColor = GUI.backgroundColor;
|
GUI.backgroundColor = new Color(1f, 1f, 0.5f);
|
EditorGUILayout.BeginHorizontal(GUI.skin.box);
|
GUI.backgroundColor = originalBgColor;
|
|
GUIStyle labelStyle = new GUIStyle(EditorStyles.label) { fontStyle = FontStyle.Bold };
|
EditorGUILayout.PrefixLabel($"[{index}]", labelStyle, labelStyle);
|
EditorGUILayout.SelectableLabel(element.ToString(), EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
|
|
EditorGUILayout.EndHorizontal();
|
}
|
else
|
{
|
EditorGUILayout.BeginHorizontal();
|
EditorGUILayout.PrefixLabel($"[{index}]");
|
EditorGUILayout.SelectableLabel(element.ToString(), EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
|
EditorGUILayout.EndHorizontal();
|
}
|
}
|
else
|
{
|
// 复杂类型，需要展开
|
// 确保有ElementDetail
|
if (parentDetail != null && !parentDetail.elementDetails.ContainsKey(index))
|
{
|
parentDetail.elementDetails[index] = new ElementDetail();
|
}
|
|
var elemDetail = parentDetail?.elementDetails[index];
|
|
// 如果元素匹配搜索，自动展开
|
if (isElementMatched && elemDetail != null)
|
{
|
elemDetail.isExpanded = true;
|
}
|
|
// 为包元素设置背景颜色
|
Color originalBgColor = GUI.backgroundColor;
|
if (isPackageElement)
|
{
|
if (isHighlightedPackage)
|
{
|
// 高亮状态 - 使用绿色闪烁效果
|
float pulse = Mathf.PingPong((float)EditorApplication.timeSinceStartup * 2f, 1f);
|
GUI.backgroundColor = Color.Lerp(new Color(0.3f, 0.8f, 0.3f), new Color(0.5f, 1f, 0.5f), pulse);
|
}
|
else if (isExecutingPackage)
|
{
|
GUI.backgroundColor = new Color(0.3f, 0.3f, 0.3f); // 深黑色（正在执行）
|
}
|
else if (isExecutedPackage)
|
{
|
GUI.backgroundColor = new Color(0.6f, 0.6f, 0.6f); // 灰色（已执行）
|
}
|
else if (isElementMatched)
|
{
|
GUI.backgroundColor = new Color(1f, 1f, 0.5f); // 黄色（搜索匹配）
|
}
|
}
|
else if (isElementMatched)
|
{
|
GUI.backgroundColor = new Color(1f, 1f, 0.5f); // 黄色（搜索匹配）
|
}
|
|
EditorGUILayout.BeginVertical(isPackageElement || isElementMatched ? GUI.skin.box : GUIStyle.none);
|
GUI.backgroundColor = originalBgColor;
|
|
// 展开按钮 + 类型名
|
GUIStyle labelStyle = EditorStyles.foldout;
|
if (isPackageElement)
|
{
|
if (isHighlightedPackage)
|
{
|
labelStyle = new GUIStyle(EditorStyles.foldout) { normal = { textColor = Color.green }, fontStyle = FontStyle.Bold };
|
}
|
else if (isExecutingPackage)
|
{
|
labelStyle = new GUIStyle(EditorStyles.foldout) { normal = { textColor = Color.yellow }, fontStyle = FontStyle.Bold };
|
}
|
else if (isExecutedPackage)
|
{
|
labelStyle = new GUIStyle(EditorStyles.foldout) { normal = { textColor = Color.gray } };
|
}
|
else if (isElementMatched)
|
{
|
labelStyle = new GUIStyle(EditorStyles.foldout) { fontStyle = FontStyle.Bold };
|
}
|
}
|
else if (isElementMatched)
|
{
|
labelStyle = new GUIStyle(EditorStyles.foldout) { fontStyle = FontStyle.Bold };
|
}
|
|
if (elemDetail != null)
|
{
|
GameNetPackBasic pack = element as GameNetPackBasic;
|
string displayText = isPackageElement ? $"[{index}] [{pack.packUID}] {type.Name}" : $"[{index}] {type.Name}";
|
|
// 特殊处理：HB427 技能包显示释放者和技能名
|
if (element is HB427_tagSCUseSkill skillPack)
|
{
|
string casterName = GetObjectName(skillPack.ObjID);
|
string skillName = GetSkillName(skillPack.SkillID);
|
displayText += $" - {casterName} 使用 {skillName}";
|
}
|
// 特殊处理：CustomHB426CombinePack 显示是否需要等待
|
else if (element is CustomHB426CombinePack combinePack)
|
{
|
bool needWaiting = combinePack.NeedWaiting();
|
displayText += needWaiting ? " [需要等待]" : " [无需等待]";
|
}
|
|
elemDetail.isExpanded = EditorGUILayout.Foldout(elemDetail.isExpanded, displayText, true, labelStyle);
|
}
|
else
|
{
|
EditorGUILayout.LabelField($"[{index}] {type.Name}");
|
}
|
|
// 如果展开，显示字段
|
if (elemDetail != null && elemDetail.isExpanded)
|
{
|
EditorGUI.indentLevel++;
|
DrawObjectFields(element, elemDetail.fieldDetails);
|
EditorGUI.indentLevel--;
|
}
|
|
if (isPackageElement || isElementMatched)
|
{
|
EditorGUILayout.EndVertical();
|
}
|
}
|
}
|
|
// 绘制对象的字段（支持递归展开）
|
private void DrawObjectFields(object obj, Dictionary<string, FieldDetail> fieldDetailsDict)
|
{
|
if (obj == null) return;
|
|
var type = obj.GetType();
|
var fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
|
|
foreach (var field in fields)
|
{
|
try
|
{
|
var value = field.GetValue(obj);
|
|
// 确保有FieldDetail
|
if (!fieldDetailsDict.ContainsKey(field.Name))
|
{
|
var detail = new FieldDetail { value = value };
|
|
if (value != null && value.GetType().IsArray)
|
{
|
detail.isArray = true;
|
detail.arrayValue = value as System.Array;
|
}
|
else if (value is System.Collections.IList list && !(value is string))
|
{
|
detail.isList = true;
|
detail.listValue = list;
|
}
|
|
fieldDetailsDict[field.Name] = detail;
|
}
|
|
var fieldDetail = fieldDetailsDict[field.Name];
|
|
// 绘制字段
|
DrawFieldWithRecursiveExpand(field.Name, value, fieldDetail);
|
}
|
catch
|
{
|
EditorGUILayout.LabelField(field.Name, "读取失败");
|
}
|
}
|
}
|
|
// 递归地绘制字段（支持多层展开）
|
private void DrawFieldWithRecursiveExpand(string fieldName, object value, FieldDetail fieldDetail)
|
{
|
if (value == null)
|
{
|
EditorGUILayout.LabelField(fieldName + ":", "null");
|
return;
|
}
|
|
var type = value.GetType();
|
|
// 检查字段值是否匹配搜索
|
bool isValueMatched = false;
|
if (!string.IsNullOrEmpty(detailSearchText))
|
{
|
string searchLower = detailSearchText.ToLower();
|
// 字段名匹配
|
if (fieldName.ToLower().Contains(searchLower))
|
isValueMatched = true;
|
// 字段值匹配
|
else if (value.ToString().Contains(searchLower))
|
isValueMatched = true;
|
}
|
|
// 基本类型直接显示
|
if (type.IsPrimitive || type == typeof(string) || type.IsEnum)
|
{
|
// 获取显示值，如果是ObjID则追加对象名称
|
string displayValue = value.ToString();
|
if (fieldName == "ObjID" && uint.TryParse(displayValue, out uint objID))
|
{
|
string objName = GetObjectName(objID);
|
displayValue = $"{displayValue} ({objName})";
|
}
|
|
if (isValueMatched)
|
{
|
// 高亮显示匹配的字段
|
Color originalBgColor = GUI.backgroundColor;
|
GUI.backgroundColor = new Color(1f, 1f, 0.5f); // 淡黄色背景
|
EditorGUILayout.BeginHorizontal(GUI.skin.box);
|
GUI.backgroundColor = originalBgColor;
|
|
GUIStyle labelStyle = new GUIStyle(GUI.skin.label) { fontStyle = FontStyle.Bold };
|
GUILayout.Space(EditorGUI.indentLevel * 15); // 手动缩进
|
GUILayout.Label(fieldName + ":", labelStyle, GUILayout.Width(120));
|
EditorGUILayout.SelectableLabel(displayValue, EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
|
|
EditorGUILayout.EndHorizontal();
|
}
|
else
|
{
|
EditorGUILayout.BeginHorizontal();
|
GUILayout.Space(EditorGUI.indentLevel * 15); // 手动缩进
|
GUILayout.Label(fieldName + ":", GUILayout.Width(120));
|
EditorGUILayout.SelectableLabel(displayValue, EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
|
EditorGUILayout.EndHorizontal();
|
}
|
}
|
// 数组类型
|
else if (type.IsArray && fieldDetail.arrayValue != null)
|
{
|
fieldDetail.isExpanded = EditorGUILayout.Foldout(fieldDetail.isExpanded, $"{fieldName}: Array[{fieldDetail.arrayValue.Length}]", true);
|
|
if (fieldDetail.isExpanded)
|
{
|
EditorGUI.indentLevel++;
|
for (int i = 0; i < fieldDetail.arrayValue.Length; i++)
|
{
|
var element = fieldDetail.arrayValue.GetValue(i);
|
DrawArrayElement(i, element, fieldDetail);
|
}
|
EditorGUI.indentLevel--;
|
}
|
}
|
// 列表类型
|
else if (fieldDetail.isList && fieldDetail.listValue != null)
|
{
|
fieldDetail.isExpanded = EditorGUILayout.Foldout(fieldDetail.isExpanded, $"{fieldName}: List[{fieldDetail.listValue.Count}]", true);
|
|
if (fieldDetail.isExpanded)
|
{
|
EditorGUI.indentLevel++;
|
for (int i = 0; i < fieldDetail.listValue.Count; i++)
|
{
|
var element = fieldDetail.listValue[i];
|
DrawArrayElement(i, element, fieldDetail);
|
}
|
EditorGUI.indentLevel--;
|
}
|
}
|
// 其他复杂类型
|
else
|
{
|
EditorGUILayout.BeginHorizontal();
|
EditorGUILayout.PrefixLabel(fieldName);
|
EditorGUILayout.SelectableLabel(value.ToString(), EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
|
EditorGUILayout.EndHorizontal();
|
}
|
}
|
|
#endregion
|
|
#region 详情搜索
|
|
/// <summary>
|
/// 更新详情搜索缓存（仅在搜索文本改变时调用）
|
/// </summary>
|
private void UpdateDetailSearchCache()
|
{
|
matchedFieldNames.Clear();
|
fieldHasMatchedChild.Clear();
|
|
if (selectedPackage == null || string.IsNullOrEmpty(detailSearchText))
|
return;
|
|
string searchLower = detailSearchText.ToLower();
|
|
// 检查基本信息是否匹配（包类型、UID、Cmd）
|
bool basicInfoMatched = selectedPackage.typeName.ToLower().Contains(searchLower) ||
|
selectedPackage.packUID.ToString().Contains(searchLower) ||
|
selectedPackage.package.cmd.ToString().Contains(searchLower);
|
|
foreach (var field in selectedPackage.fields)
|
{
|
string fieldName = field.Key;
|
string fieldValue = field.Value;
|
|
// 检查字段名或字段值是否匹配
|
bool fieldMatched = fieldName.ToLower().Contains(searchLower) ||
|
fieldValue.ToLower().Contains(searchLower);
|
|
if (fieldMatched)
|
{
|
matchedFieldNames.Add(fieldName);
|
}
|
|
// 检查数组/列表的子元素是否匹配
|
if (selectedPackage.fieldDetails.ContainsKey(fieldName))
|
{
|
var detail = selectedPackage.fieldDetails[fieldName];
|
if (detail.isArray || detail.isList)
|
{
|
bool hasMatch = CheckChildElementsMatch(detail, searchLower);
|
if (hasMatch)
|
{
|
fieldHasMatchedChild[fieldName] = true;
|
if (!fieldMatched)
|
{
|
matchedFieldNames.Add(fieldName); // 也算作匹配字段
|
}
|
}
|
}
|
}
|
}
|
|
// 如果基本信息匹配但没有字段匹配，至少显示一个字段让用户知道有匹配
|
if (basicInfoMatched && matchedFieldNames.Count == 0 && selectedPackage.fields.Count > 0)
|
{
|
// 添加第一个字段，这样至少会显示一些内容
|
var firstField = selectedPackage.fields.First();
|
matchedFieldNames.Add(firstField.Key);
|
}
|
}
|
|
/// <summary>
|
/// 检查字段是否匹配搜索（用于高亮显示）
|
/// </summary>
|
private bool IsFieldMatched(string fieldName, string fieldValue, FieldDetail detail)
|
{
|
if (string.IsNullOrEmpty(detailSearchText))
|
return false;
|
|
string searchLower = detailSearchText.ToLower();
|
|
// 字段名匹配
|
if (fieldName.ToLower().Contains(searchLower))
|
return true;
|
|
// 字段值匹配
|
if (fieldValue.ToLower().Contains(searchLower))
|
return true;
|
|
return false;
|
}
|
|
/// <summary>
|
/// 检查数组/列表中是否有匹配的子元素（用于缓存计算）
|
/// </summary>
|
private bool CheckChildElementsMatch(FieldDetail detail, string searchLower)
|
{
|
HashSet<object> visited = new HashSet<object>();
|
|
// 检查数组
|
if (detail.isArray && detail.arrayValue != null)
|
{
|
foreach (var element in detail.arrayValue)
|
{
|
if (element != null)
|
{
|
// 特殊处理：如果是 GameNetPackBasic，优先检查 packUID
|
if (element is GameNetPackBasic pack && pack.packUID.ToString().Contains(searchLower))
|
return true;
|
|
if (RecursiveSearchInObject(element, searchLower, visited))
|
return true;
|
}
|
}
|
}
|
|
// 检查列表
|
if (detail.isList && detail.listValue != null)
|
{
|
foreach (var element in detail.listValue)
|
{
|
if (element != null)
|
{
|
// 特殊处理：如果是 GameNetPackBasic，优先检查 packUID
|
if (element is GameNetPackBasic pack && pack.packUID.ToString().Contains(searchLower))
|
return true;
|
|
if (RecursiveSearchInObject(element, searchLower, visited))
|
return true;
|
}
|
}
|
}
|
|
return false;
|
}
|
|
/// <summary>
|
/// 判断字段是否应该显示（根据详情搜索文本）
|
/// </summary>
|
private bool ShouldShowDetailField(string fieldName, string fieldValue, PackageInfo packInfo)
|
{
|
if (string.IsNullOrEmpty(detailSearchText))
|
return true;
|
|
string searchLower = detailSearchText.ToLower();
|
|
// 搜索字段名
|
if (fieldName.ToLower().Contains(searchLower))
|
return true;
|
|
// 搜索字段值
|
if (fieldValue.ToLower().Contains(searchLower))
|
return true;
|
|
// 如果有详细信息，递归搜索
|
if (packInfo.fieldDetails.ContainsKey(fieldName))
|
{
|
var detail = packInfo.fieldDetails[fieldName];
|
HashSet<object> visited = new HashSet<object>();
|
if (RecursiveSearchInFieldDetail(detail, searchLower, visited))
|
return true;
|
}
|
|
return false;
|
}
|
|
/// <summary>
|
/// 递归搜索字段详情
|
/// </summary>
|
private bool RecursiveSearchInFieldDetail(FieldDetail detail, string searchLower, HashSet<object> visited)
|
{
|
if (detail.value != null)
|
{
|
// 防止循环引用
|
if (!detail.value.GetType().IsPrimitive &&
|
detail.value.GetType() != typeof(string) &&
|
!detail.value.GetType().IsEnum)
|
{
|
if (visited.Contains(detail.value))
|
return false;
|
visited.Add(detail.value);
|
}
|
|
// 搜索值本身
|
if (detail.value.ToString().ToLower().Contains(searchLower))
|
return true;
|
|
// 如果是数组
|
if (detail.isArray && detail.arrayValue != null)
|
{
|
foreach (var element in detail.arrayValue)
|
{
|
if (element != null && RecursiveSearchInObject(element, searchLower, visited))
|
return true;
|
}
|
}
|
|
// 如果是列表
|
if (detail.isList && detail.listValue != null)
|
{
|
foreach (var element in detail.listValue)
|
{
|
if (element != null && RecursiveSearchInObject(element, searchLower, visited))
|
return true;
|
}
|
}
|
|
// 搜索子字段
|
foreach (var subField in detail.subFieldDetails.Values)
|
{
|
if (RecursiveSearchInFieldDetail(subField, searchLower, visited))
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
/// <summary>
|
/// 递归搜索对象内容
|
/// </summary>
|
private bool RecursiveSearchInObject(object obj, string searchLower, HashSet<object> visited)
|
{
|
if (obj == null) return false;
|
|
var type = obj.GetType();
|
|
// 特殊处理：如果是 GameNetPackBasic，优先检查 packUID
|
if (obj is GameNetPackBasic pack)
|
{
|
if (pack.packUID.ToString().Contains(searchLower))
|
return true;
|
// 还要检查类型名
|
if (pack.GetType().Name.ToLower().Contains(searchLower))
|
return true;
|
}
|
|
// 基本类型直接比较（包括所有数字类型）
|
if (type.IsPrimitive || type == typeof(string) || type.IsEnum)
|
{
|
string valueStr = obj.ToString();
|
// 对于数字，直接比较字符串（不转小写，因为数字没有大小写）
|
if (type.IsPrimitive && !type.IsEnum)
|
{
|
return valueStr.Contains(searchLower);
|
}
|
// 对于字符串和枚举，转小写比较
|
return valueStr.ToLower().Contains(searchLower);
|
}
|
|
// 防止循环引用
|
if (visited.Contains(obj))
|
return false;
|
visited.Add(obj);
|
|
// 限制递归深度，防止过深的嵌套
|
if (visited.Count > 1000)
|
return false;
|
|
// 特殊处理数组
|
if (type.IsArray)
|
{
|
var array = obj as System.Array;
|
if (array != null)
|
{
|
foreach (var element in array)
|
{
|
if (element != null && RecursiveSearchInObject(element, searchLower, visited))
|
return true;
|
}
|
}
|
return false;
|
}
|
|
// 特殊处理列表
|
if (obj is System.Collections.IList list && !(obj is string))
|
{
|
foreach (var element in list)
|
{
|
if (element != null && RecursiveSearchInObject(element, searchLower, visited))
|
return true;
|
}
|
return false;
|
}
|
|
// 复杂对象，搜索所有字段
|
var fields = type.GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
|
foreach (var field in fields)
|
{
|
try
|
{
|
// 搜索字段名
|
if (field.Name.ToLower().Contains(searchLower))
|
return true;
|
|
var value = field.GetValue(obj);
|
if (value != null && RecursiveSearchInObject(value, searchLower, visited))
|
return true;
|
}
|
catch { }
|
}
|
|
return false;
|
}
|
|
#endregion
|
|
#region 辅助方法
|
|
/// <summary>
|
/// 根据对象ID获取对象名称
|
/// </summary>
|
private string GetObjectName(uint objID)
|
{
|
try
|
{
|
var battleField = BattleManager.Instance?.GetBattleField(selectedGuid);
|
if (battleField != null && battleField.battleObjMgr != null)
|
{
|
var battleObj = battleField.battleObjMgr.GetBattleObject((int)objID);
|
if (battleObj is HeroBattleObject heroBattleObject && heroBattleObject.teamHero != null)
|
{
|
return heroBattleObject.teamHero.name;
|
}
|
}
|
}
|
catch { }
|
|
return $"对象{objID}";
|
}
|
|
/// <summary>
|
/// 根据技能ID获取技能名称
|
/// </summary>
|
private string GetSkillName(uint skillID)
|
{
|
try
|
{
|
var skillConfig = SkillConfig.Get((int)skillID);
|
if (skillConfig != null && !string.IsNullOrEmpty(skillConfig.SkillName))
|
{
|
return skillConfig.SkillName;
|
}
|
}
|
catch { }
|
|
return $"技能{skillID}";
|
}
|
|
#endregion
|
|
#region 高亮和滚动
|
|
/// <summary>
|
/// 开始高亮一个包
|
/// </summary>
|
private void StartHighlight(PackageInfo package)
|
{
|
highlightedPackage = package;
|
highlightStartTime = EditorApplication.timeSinceStartup;
|
}
|
|
/// <summary>
|
/// 判断包是否处于高亮状态
|
/// </summary>
|
private bool IsPackageHighlighted(PackageInfo package)
|
{
|
if (highlightedPackage == null || highlightedPackage != package)
|
return false;
|
|
double elapsed = EditorApplication.timeSinceStartup - highlightStartTime;
|
return elapsed < highlightDuration;
|
}
|
|
/// <summary>
|
/// 滚动到选中的包位置
|
/// </summary>
|
private void ScrollToSelectedPackage()
|
{
|
if (selectedPackageIndex < 0 || filteredPackages.Count == 0)
|
return;
|
|
// 计算目标滚动位置
|
// 每个包条目的大概高度（可根据实际情况调整）
|
float itemHeight = 60f;
|
float targetY = selectedPackageIndex * itemHeight;
|
|
// 滚动到目标位置
|
scrollPosition.y = targetY;
|
|
Repaint();
|
}
|
|
#endregion
|
|
#region 数据处理
|
|
private void RefreshGuidList()
|
{
|
guidList = allBattlePackages.Keys.ToList();
|
|
if (guidList.Count > 0)
|
{
|
if (string.IsNullOrEmpty(selectedGuid) || !guidList.Contains(selectedGuid))
|
{
|
selectedGuidIndex = 0;
|
selectedGuid = guidList[0];
|
}
|
else
|
{
|
selectedGuidIndex = guidList.IndexOf(selectedGuid);
|
}
|
|
FilterPackages();
|
}
|
else
|
{
|
selectedGuid = "";
|
selectedGuidIndex = 0;
|
filteredPackages.Clear();
|
}
|
}
|
|
private void FilterPackages()
|
{
|
if (string.IsNullOrEmpty(selectedGuid) || !allBattlePackages.ContainsKey(selectedGuid))
|
{
|
filteredPackages.Clear();
|
return;
|
}
|
|
var allPackages = allBattlePackages[selectedGuid];
|
|
if (string.IsNullOrEmpty(searchText))
|
{
|
filteredPackages = new List<PackageInfo>(allPackages);
|
}
|
else
|
{
|
string searchLower = searchText.ToLower();
|
|
filteredPackages = allPackages.Where(p =>
|
{
|
// 搜索包类型名
|
if (p.typeName.ToLower().Contains(searchLower))
|
return true;
|
|
// 搜索 UID
|
if (p.packUID.ToString().Contains(searchLower))
|
return true;
|
|
// 递归搜索所有字段（包括嵌套内容）
|
if (RecursiveSearchInPackage(p.package, searchLower))
|
return true;
|
|
return false;
|
}).ToList();
|
}
|
|
// 按照 packUID 从小到大排序
|
filteredPackages.Sort((a, b) => a.packUID.CompareTo(b.packUID));
|
|
Repaint();
|
}
|
|
/// <summary>
|
/// 递归搜索对象的所有字段（包括嵌套数组、列表等）
|
/// </summary>
|
private bool RecursiveSearchInPackage(object obj, string searchLower)
|
{
|
if (obj == null) return false;
|
|
var type = obj.GetType();
|
|
// 基本类型直接比较
|
if (type.IsPrimitive || type == typeof(string) || type.IsEnum)
|
{
|
return obj.ToString().ToLower().Contains(searchLower);
|
}
|
|
// 数组类型
|
if (obj is System.Array array)
|
{
|
foreach (var element in array)
|
{
|
if (RecursiveSearchInPackage(element, searchLower))
|
return true;
|
}
|
return false;
|
}
|
|
// 列表类型
|
if (obj is System.Collections.IList list)
|
{
|
foreach (var element in list)
|
{
|
if (RecursiveSearchInPackage(element, searchLower))
|
return true;
|
}
|
return false;
|
}
|
|
// 复杂对象，递归搜索所有字段
|
var fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
|
foreach (var field in fields)
|
{
|
try
|
{
|
// 搜索字段名
|
if (field.Name.ToLower().Contains(searchLower))
|
return true;
|
|
var value = field.GetValue(obj);
|
if (value == null) continue;
|
|
// 递归搜索字段值
|
if (RecursiveSearchInPackage(value, searchLower))
|
return true;
|
}
|
catch
|
{
|
// 忽略读取失败的字段
|
}
|
}
|
|
return false;
|
}
|
|
#endregion
|
}
|
