(client) chore:Clean code

2025-08-28 16:20:24 +08:00
parent 909e995e15
commit c3bff1cf88
76 changed files with 5689 additions and 445 deletions
--- a/Client/Assets/Scripts/Parsing/ConditionDelegateFactory.cs
+++ b/Client/Assets/Scripts/Parsing/ConditionDelegateFactory.cs
@ -0,0 +1,309 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace Parsing
+{
+    public static class ConditionDelegateFactory
+    {
+        // 正则表达式用于解析函数名和参数
+        private static readonly Regex _methodCallRegex = new Regex(
+            @"^(?<methodName>[a-zA-Z_][a-zA-Z0-9_]*)(?:\((?<args>.*)\))?$",
+            RegexOptions.Compiled
+        );
+
+        /// <summary>
+        /// 解析条件字符串并创建 Func<Entity.Entity, bool> 委托。
+        /// </summary>
+        /// <param name="conditionString">条件字符串，如 "EntityHealth(20)" 或 "IsTargetAlive"。</param>
+        /// <param name="entityType">实体类型，通常是 typeof(Entity.Entity)。</param>
+        /// <param name="conditionClassType">包含条件静态方法的类类型，如 typeof(ConditionFunctions)。</param>
+        /// <returns>一个 Func<Entity.Entity, bool> 委托。</returns>
+        /// <exception cref="ArgumentException">当条件字符串格式不正确时抛出。</exception>
+        /// <exception cref="MissingMethodException">当找不到匹配的条件方法时抛出。</exception>
+        public static Func<Entity.Entity, bool> CreateConditionDelegate(
+            string conditionString,
+            Type entityType,
+            Type conditionClassType)
+        {
+            if (string.IsNullOrWhiteSpace(conditionString))
+                throw new ArgumentException("条件字符串不能为空。", nameof(conditionString));
+            if (entityType == null)
+                throw new ArgumentNullException(nameof(entityType));
+            if (conditionClassType == null)
+                throw new ArgumentNullException(nameof(conditionClassType));
+
+            var match = _methodCallRegex.Match(conditionString);
+            if (!match.Success)
+            {
+                throw new ArgumentException(
+                    $"条件字符串 '{conditionString}' 格式不正确。期望格式: MethodName 或 MethodName(arg1, arg2)。");
+            }
+
+            var methodName = match.Groups["methodName"].Value;
+            var argsString = match.Groups["args"].Success ? match.Groups["args"].Value : null;
+
+            // 逻辑修改：支持多参数解析
+            var parsedArgValues = new List<object>(); // 存储解析后的参数值
+            var parsedArgTypes = new List<Type>(); // 存储解析后的参数类型
+
+            // 第一个参数始终是实体类型
+            parsedArgTypes.Add(entityType);
+
+            if (!string.IsNullOrEmpty(argsString))
+            {
+                // 使用辅助方法拆分参数字符串
+                var argStrings = SplitArguments(argsString); // <-- 新增辅助方法调用
+                foreach (var argStr in argStrings)
+                {
+                    var arg = ParseLiteral(argStr.Trim());
+                    parsedArgValues.Add(arg.value);
+                    parsedArgTypes.Add(arg.type);
+                }
+            }
+
+            // 逻辑修改：更健壮的方法查找和参数类型匹配
+            MethodInfo bestMatchMethod = null;
+            object[] finalInvokeArgs = null; // 存储最终用于 Invoke 的参数值（已转换类型）
+
+            // 获取所有静态、公共或非公共的同名方法，并过滤返回类型为 bool 的
+            var methods = conditionClassType
+                .GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
+                .Where(m => m.Name == methodName && m.ReturnType == typeof(bool))
+                .ToList();
+
+            foreach (var method in methods)
+            {
+                var parameters = method.GetParameters();
+
+                // 检查参数数量是否匹配
+                if (parameters.Length != parsedArgTypes.Count)
+                    continue;
+
+                var paramsMatch = true;
+                var currentInvokeArgs = new object[parameters.Length]; // 临时存储当前方法的参数值
+
+                // 检查第一个参数（实体类型）
+                if (!parameters[0].ParameterType.IsAssignableFrom(entityType))
+                {
+                    paramsMatch = false;
+                    continue;
+                }
+                // 注意：currentInvokeArgs[0] 在这里不赋值，它将在委托执行时由传入的 entity 填充。
+
+                // 检查后续参数（解析出的额外参数）
+                for (var i = 1; i < parameters.Length; i++)
+                {
+                    var methodParamType = parameters[i].ParameterType;
+                    var parsedValueType = parsedArgTypes[i];
+                    var parsedValue = parsedArgValues[i - 1]; // parsedArgValues 从索引0开始对应第一个额外参数
+
+                    // 尝试直接赋值
+                    if (methodParamType.IsInstanceOfType(parsedValue))
+                    {
+                        currentInvokeArgs[i] = parsedValue;
+                    }
+                    // 尝试类型转换（例如 int 到 long，float 到 double）
+                    else if (CanConvert(parsedValue, methodParamType)) // <-- 新增辅助方法调用
+                    {
+                        try
+                        {
+                            currentInvokeArgs[i] = Convert.ChangeType(parsedValue, methodParamType);
+                        }
+                        catch (Exception) // 捕获所有转换异常
+                        {
+                            paramsMatch = false;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        paramsMatch = false;
+                        break;
+                    }
+                }
+
+                if (paramsMatch)
+                {
+                    bestMatchMethod = method;
+                    finalInvokeArgs = currentInvokeArgs; // 存储已转换的参数值
+                    break; // 找到第一个匹配项即停止，如果需要更复杂的匹配规则（如最具体匹配），则需要进一步处理
+                }
+            }
+
+            if (bestMatchMethod == null)
+            {
+                // 如果没有找到匹配的方法，抛出异常
+                var expectedSignature = $"{methodName}({string.Join(", ", parsedArgTypes.Select(t => t.Name))})";
+                throw new MissingMethodException(
+                    $"在类 '{conditionClassType.FullName}' 中未找到名为 '{methodName}' 的静态方法，" +
+                    $"其签名与期望的 '{expectedSignature}' 且返回类型为 'bool' 不兼容。"
+                );
+            }
+
+            // 如果没有额外参数，直接创建委托以获得最佳性能
+            if (parsedArgValues.Count == 0)
+            {
+                return (Func<Entity.Entity, bool>)Delegate.CreateDelegate(typeof(Func<Entity.Entity, bool>),
+                    bestMatchMethod);
+            }
+            else
+            {
+                // 创建一个闭包来绑定解析后的参数
+                // 闭包捕获 finalInvokeArgs，并在运行时填充第一个参数 (entity)
+                return (entity) =>
+                {
+                    // 复制一份 finalInvokeArgs，因为 Invoke 会修改数组内容（如果参数是 ref/out）
+                    // 并且需要将 entity 放入第一个位置
+                    var invokeArgs = new object[finalInvokeArgs.Length];
+                    invokeArgs[0] = entity;
+                    for (var i = 1; i < finalInvokeArgs.Length; i++)
+                    {
+                        invokeArgs[i] = finalInvokeArgs[i];
+                    }
+
+                    return (bool)bestMatchMethod.Invoke(null, invokeArgs);
+                };
+            }
+        }
+
+        /// <summary>
+        /// 辅助方法：拆分参数字符串。
+        /// 这是一个更健壮的实现，能够正确处理包含逗号的带引号字符串和嵌套括号。
+        /// </summary>
+        /// <param name="argsString">待拆分的参数字符串。</param>
+        /// <returns>拆分后的参数列表。</returns>
+        private static IEnumerable<string> SplitArguments(string argsString)
+        {
+            if (string.IsNullOrEmpty(argsString))
+            {
+                return Enumerable.Empty<string>();
+            }
+
+            var arguments = new List<string>();
+            var currentArgument = new StringBuilder();
+            var inQuote = false; // 跟踪是否在双引号内部
+            var parenLevel = 0;   // 跟踪括号的嵌套层级
+
+            for (var i = 0; i < argsString.Length; i++)
+            {
+                var c = argsString[i];
+
+                if (c == '"')
+                {
+                    inQuote = !inQuote; // 切换引号状态
+                    currentArgument.Append(c); // 将引号字符保留在参数中
+                }
+                else if (c == '(')
+                {
+                    parenLevel++; // 增加括号层级
+                    currentArgument.Append(c);
+                }
+                else if (c == ')')
+                {
+                    parenLevel--; // 减少括号层级
+                    currentArgument.Append(c);
+                }
+                else if (c == ',' && !inQuote && parenLevel == 0)
+                {
+                    // 发现一个顶级的逗号分隔符：不在引号内，也不在任何括号内
+                    var arg = currentArgument.ToString().Trim();
+                    if (!string.IsNullOrEmpty(arg))
+                    {
+                        arguments.Add(arg);
+                    }
+                    currentArgument.Clear(); // 重置，开始收集下一个参数
+                }
+                else
+                {
+                    // 其他字符，直接添加到当前参数
+                    currentArgument.Append(c);
+                }
+            }
+
+            // 循环结束后，添加最后一个参数（如果有的话）
+            var lastArg = currentArgument.ToString().Trim();
+            if (!string.IsNullOrEmpty(lastArg))
+            {
+                arguments.Add(lastArg);
+            }
+
+            return arguments;
+        }
+
+        /// <summary>
+        /// 辅助方法：检查一个值是否可以转换为目标类型。
+        /// </summary>
+        private static bool CanConvert(object value, Type targetType)
+        {
+            // 逻辑修改：新增辅助方法，用于检查类型转换可行性
+            if (value == null) return !targetType.IsValueType || (Nullable.GetUnderlyingType(targetType) != null);
+            if (targetType.IsInstanceOfType(value)) return true;
+
+            try
+            {
+                // 尝试转换，如果成功则表示可转换
+                Convert.ChangeType(value, targetType);
+                return true;
+            }
+            catch (Exception) // 捕获所有可能的转换异常
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 解析字符串字面量为对应的对象和类型。
+        /// 支持 int, long, float, double, bool, string。
+        /// </summary>
+        /// <param name="literalString">要解析的字面量字符串。</param>
+        /// <returns>包含解析后的值和类型的元组。</returns>
+        private static (object value, Type type) ParseLiteral(string literalString)
+        {
+            // 逻辑修改：增强 ParseLiteral，增加对 long 和 double 的支持
+            // 顺序很重要：先尝试更窄的类型，再尝试更宽的类型，以避免不必要的类型提升。
+
+            // 尝试解析为 int
+            if (int.TryParse(literalString, out var intValue))
+            {
+                return (intValue, typeof(int));
+            }
+
+            // 尝试解析为 long
+            if (long.TryParse(literalString, out var longValue))
+            {
+                return (longValue, typeof(long));
+            }
+
+            // 尝试解析为 float
+            if (float.TryParse(literalString, out var floatValue))
+            {
+                return (floatValue, typeof(float));
+            }
+
+            // 尝试解析为 double
+            if (double.TryParse(literalString, out var doubleValue))
+            {
+                return (doubleValue, typeof(double));
+            }
+
+            // 尝试解析为 bool
+            if (bool.TryParse(literalString, out var boolValue))
+            {
+                return (boolValue, typeof(bool));
+            }
+
+            // 尝试解析为 string (如果被双引号包围)
+            if (literalString.StartsWith("\"") && literalString.EndsWith("\"") && literalString.Length > 1)
+            {
+                return (literalString.Substring(1, literalString.Length - 2), typeof(string));
+            }
+
+            // 默认作为字符串处理
+            return (literalString, typeof(string));
+        }
+    }
+}
--- a/Client/Assets/Scripts/Parsing/ConditionDelegateFactory.cs.meta
+++ b/Client/Assets/Scripts/Parsing/ConditionDelegateFactory.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 57f4a853e270411f89c13a3b385ab47d
+timeCreated: 1756024020
--- a/Client/Assets/Scripts/Parsing/ConditionFunctions.cs
+++ b/Client/Assets/Scripts/Parsing/ConditionFunctions.cs
@ -0,0 +1,15 @@
+namespace Parsing
+{
+    public static class ConditionFunctions
+    {
+        public static bool EntityHealth(Entity.Entity entity, int minHealth)
+        {
+            return entity.attributes.health >= minHealth;
+        }
+
+        public static bool HasEnemyInSight(Entity.Entity entity)
+        {
+            return Managers.EntityManage.Instance.ExistsHostile(entity.currentDimensionId, entity.entityPrefab);
+        }
+    }
+}
--- a/Client/Assets/Scripts/Parsing/ConditionFunctions.cs.meta
+++ b/Client/Assets/Scripts/Parsing/ConditionFunctions.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c81bab8c57104b6ba1fddfee22bc6c7c
+timeCreated: 1756023349
--- a/Client/Assets/Scripts/Parsing/Resolver.cs
+++ b/Client/Assets/Scripts/Parsing/Resolver.cs
@ -0,0 +1,131 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace Parsing
+{
+    public static class Resolver
+    {
+        /// <summary>
+        /// 将字符串表达式解析为一个谓词函数，该函数可以用于筛选实体对象。
+        /// </summary>
+        /// <param name="expression">表示条件的字符串表达式。格式示例："entity.Id &gt; 10" 或 "entity.Name == 'John'"。</param>
+        /// <returns>返回一个 Func&lt;Entity.Entity, bool&gt; 类型的委托，表示解析后的谓词函数。</returns>
+        /// <exception cref="FormatException">当输入表达式的格式不正确时抛出此异常。</exception>
+        /// <exception cref="NotSupportedException">当表达式中包含不支持的操作符或数据类型时抛出此异常。</exception>
+        /// <remarks>
+        /// 表达式的格式必须符合以下规则：
+        /// - 表达式由三部分组成：属性路径、操作符和值，用空格分隔。
+        /// - 属性路径格式为 "entity.PropertyName"，其中 PropertyName 是实体类中的一个公共属性或字段。
+        /// - 操作符可以是以下之一："&gt;", "&lt;", "&gt;=", "&lt;=", "==", "!="。
+        /// - 值的类型必须与属性的类型匹配，并且支持以下类型：string, int, long, float, double, decimal, bool, DateTime, Guid 和枚举类型。
+        /// 
+        /// 注意事项：
+        /// - 字符串值需要用单引号或双引号括起来，例如 'John' 或 "John"。
+        /// - 对于可为空类型（Nullable），会自动处理其底层类型的转换。
+        /// - 字符串比较默认使用不区分大小写的 Equals 方法。
+        /// </remarks>
+        public static Func<Entity.Entity, bool> ParsePredicate(string expression)
+        {
+            // 格式示例："entity.Id > 10" 或 "entity.Name == 'John'"
+            var parts = expression.Split(new[] { ' ' }, 3, StringSplitOptions.RemoveEmptyEntries);
+            if (parts.Length != 3)
+                throw new FormatException(
+                    "Invalid expression format. Expected format: 'entity.Property Operator Value'");
+
+            // 解析属性和操作符
+            var propPath = parts[0].Split('.')[1]; // "Id" 或 "Name"
+            var op = parts[1]; // ">", "==" 等
+
+            // 创建表达式参数
+            var param = Expression.Parameter(typeof(Entity.Entity), "entity");
+
+            // 获取属性访问表达式
+            var propAccess = propPath.Split('.')
+                .Aggregate<string, Expression>(param, Expression.PropertyOrField);
+
+            // 获取属性类型
+            var propType = propAccess.Type;
+
+            // 解析值并转换为适当类型
+            object value;
+            var valueStr = parts[2].Trim();
+
+            try
+            {
+                if (propType == typeof(string))
+                    // 处理字符串值（去除引号）
+                    value = valueStr.Trim('\'', '"');
+                else if (propType == typeof(int))
+                    value = int.Parse(valueStr);
+                else if (propType == typeof(long))
+                    value = long.Parse(valueStr);
+                else if (propType == typeof(float))
+                    value = float.Parse(valueStr);
+                else if (propType == typeof(double))
+                    value = double.Parse(valueStr);
+                else if (propType == typeof(decimal))
+                    value = decimal.Parse(valueStr);
+                else if (propType == typeof(bool))
+                    value = bool.Parse(valueStr);
+                else if (propType == typeof(DateTime))
+                    value = DateTime.Parse(valueStr);
+                else if (propType == typeof(Guid))
+                    value = Guid.Parse(valueStr);
+                else if (propType.IsEnum)
+                    value = Enum.Parse(propType, valueStr);
+                else
+                    throw new NotSupportedException($"Type {propType.Name} is not supported");
+            }
+            catch (Exception ex)
+            {
+                throw new FormatException($"Failed to parse value '{valueStr}' for type {propType.Name}", ex);
+            }
+
+            // 创建常量表达式（确保类型匹配）
+            var constant = Expression.Constant(value, propType);
+
+            // 处理可为空类型的情况
+            if (propType.IsGenericType && propType.GetGenericTypeDefinition() == typeof(Nullable<>))
+            {
+                var underlyingType = Nullable.GetUnderlyingType(propType);
+                propAccess = Expression.Property(propAccess, "Value");
+                constant = Expression.Constant(Convert.ChangeType(value, underlyingType), underlyingType);
+            }
+
+            // 创建比较表达式
+            Expression comparison;
+            if (propType == typeof(string) && (op == "==" || op == "!="))
+            {
+                // 字符串特殊处理：使用Equals方法进行不区分大小写的比较
+                var equalsMethod =
+                    typeof(string).GetMethod("Equals", new[] { typeof(string), typeof(StringComparison) });
+                var methodCall = Expression.Call(
+                    propAccess,
+                    equalsMethod,
+                    constant,
+                    Expression.Constant(StringComparison.OrdinalIgnoreCase));
+
+                comparison = op == "==" ? methodCall : Expression.Not(methodCall);
+            }
+            else
+            {
+                // 其他类型使用标准二元运算符
+                comparison = op switch
+                {
+                    ">" => Expression.GreaterThan(propAccess, constant),
+                    "<" => Expression.LessThan(propAccess, constant),
+                    ">=" => Expression.GreaterThanOrEqual(propAccess, constant),
+                    "<=" => Expression.LessThanOrEqual(propAccess, constant),
+                    "==" => Expression.Equal(propAccess, constant),
+                    "!=" => Expression.NotEqual(propAccess, constant),
+                    _ => throw new NotSupportedException($"Operator {op} not supported")
+                };
+            }
+
+            // 编译为委托
+            var lambda = Expression.Lambda<Func<Entity.Entity, bool>>(comparison, param);
+            return lambda.Compile();
+        }
+    }
+}
--- a/Client/Assets/Scripts/Parsing/Resolver.cs.meta
+++ b/Client/Assets/Scripts/Parsing/Resolver.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: acd36958b991488f92c4b9a8b903c0be
+timeCreated: 1753012536