1. 项目概述与核心价值如果你正在开发一款类似《原神》这样拥有广阔开放世界和动态环境的游戏那么游戏内NPC或敌人的智能移动尤其是面对动态变化的障碍物比如突然出现的宝箱、被玩家技能改变的地形、可破坏的箱子或者移动的平台时如何规划出一条高效、平滑且“聪明”的路径绝对是一个绕不开的核心挑战。传统的静态寻路算法在这里会显得力不从心而动态寻路算法又往往伴随着高昂的计算开销。今天我想和你深入聊聊如何将经典的A算法与高效的增量式动态寻路算法DLite结合起来在Unity中用C#打造一套既能应对复杂静态地形又能优雅处理动态障碍物的寻路系统。这不仅仅是实现一个功能更是对游戏AI“智商”的一次关键升级直接关系到玩家的沉浸感和游戏体验的流畅度。简单来说这个项目的目标是为你的游戏角色赋予一双“动态的眼睛”。当世界静止时它能像A一样快速找到最优路径当世界发生变化比如一堵墙突然立起或一座桥被炸毁时它不需要从头开始重新计算整个路径而是能像DLite一样只重新计算受影响的部分智能地绕开新障碍或者重新规划路线。这对于需要大量AI单位、且环境交互丰富的开放世界或RTS游戏来说性能提升是巨大的。接下来我会拆解整个实现思路从最基础的网格表示到A的静态寻路再到DLite如何增量式地处理动态变化并附上可直接集成到Unity项目中的C#代码示例和避坑指南。2. 寻路基础与核心算法选型在深入代码之前我们必须先理清两个核心算法的角色定位以及为什么是它们俩的组合而不是单独使用某一个。2.1 A* 算法静态世界寻路的黄金标准A*A-Star算法几乎是游戏寻路领域的代名词。它之所以如此流行是因为它在“完备性”只要路径存在就一定能找到和“最优性”能找到最短路径之间取得了完美平衡同时通过启发式函数大幅提升了搜索效率。它的核心思想并不复杂算法维护两个列表一个“开放列表”存放待考察的节点一个“关闭列表”存放已考察过的节点。每个节点都有三个关键值G值从起点移动到该节点的实际代价。H值启发值从该节点到终点的预估代价常用曼哈顿距离或欧几里得距离。F值F G H是选择下一个扩展节点的总代价估计。算法从起点开始不断从开放列表中取出F值最小的节点进行扩展计算其邻居节点的代价直到终点被加入到关闭列表。回溯父节点就能得到路径。在Unity中实现A*我们通常将游戏世界离散化为一个网格Grid。每个网格单元Node记录着自己的坐标、是否可通过Walkable、以及上面的G、H、F值。这个网格就是我们的“静态地图”。在《原神》这样的游戏中大部分的山体、建筑、固定地形在单次寻路过程中都可以视为静态的A*能完美处理这部分。注意启发函数H的选择至关重要。对于允许对角移动的网格使用对角线距离切比雪夫距离或欧几里得距离通常比曼哈顿距离更准确。但切记H值必须永远小于或等于从该节点到终点的真实代价即可采纳性否则A*可能找不到最优解。2.2 D*Lite 算法应对动态变化的智能增量寻路当游戏世界动起来问题就来了。假设你的角色正走向一个宝箱宝箱突然被怪物击飞原地留下一个不可通过的碰撞体。如果用A*你需要检测到环境变化。完全废弃当前计算到一半或已执行的路径。以角色当前位置为新的起点终点不变重新运行一次完整的A*。如果这种变化很频繁或者地图很大频繁的全局重算将成为性能杀手。这时就需要D*Lite。DLite是D算法家族的高效成员它是一种增量式的搜索算法。其核心智慧在于“反向搜索”和“重用信息”。与A从起点向终点搜索不同DLite的第一次搜索是从终点向起点进行的可以理解为预先计算了终点到地图所有点的代价。这样每个节点都保存了一个从该节点到终点的代价估计值称为rhs值。当环境发生变化时比如某个节点从可通过变为不可通过D*Lite不会重算整个地图。它只会更新受影响节点及其邻居的rhs值。将这些受影响节点放入一个优先队列中。高效地局部传播这个代价变化更新受影响的路径段。对于我们的角色来说它只需要沿着当前每个节点存储的“指向终点的方向”移动即可。当走到一个发现前方路况有变的节点时算法能快速局部调整给出新的方向而不必全局重算。为什么选择A D*Lite的组合*初始化与静态寻路游戏启动时或当角色需要一条全新的、长距离的路径时我们可以先用A进行一次高效的全局寻路。这次寻路的结果每个节点的G值可以作为DLite非常高质量的初始启发式信息极大加速D*Lite的首次计算。动态避障在角色移动过程中由DLite负责监控和处理环境的动态变化。它将基于A计算好的基础路径进行增量式的、低开销的调整。职责清晰A负责“战略规划”规划出一条从A到B的宏观最优路径DLite负责“战术调整”处理行进途中遇到的突发路况。3. 核心数据结构与Unity工程搭建理论清晰后我们开始在Unity中搭建框架。一个清晰的数据结构是成功的一半。3.1 节点Node与网格Grid的C#实现首先定义寻路的基本单元PathNode。using System.Collections.Generic; using UnityEngine; public class PathNode { public Vector2Int GridPosition { get; private set; } // 在网格中的坐标 public bool IsWalkable { get; set; } true; // 是否可通过这是动态变化的关键属性 public Vector3 WorldPosition { get; set; } // 对应的世界坐标用于移动 // A* 相关属性 public int GCost; // 从起点到本节点的代价 public int HCost; // 从本节点到终点的启发代价 public int FCost GCost HCost; // 总代价 public PathNode ParentAStar; // 用于A*回溯路径 // D*Lite 相关属性 (Key, rhs, g 是D*Lite的核心) public float Key1 { get; set; } // 优先队列排序主键 public float Key2 { get; set; } // 优先队列排序次键 public float Rhs { get; set; } // 从本节点到终点的最小代价估计满足一致性条件 public float G { get; set; } // 从本节点到终点的实际代价估计 public PathNode ParentDStarLite { get; set; } // 用于D*Lite回溯路径 // 邻居节点引用在Grid初始化时填充 public ListPathNode Neighbors { get; set; } public PathNode(Vector2Int gridPos, Vector3 worldPos) { GridPosition gridPos; WorldPosition worldPos; Neighbors new ListPathNode(8); // 预设8个方向邻居 } // 计算到另一个节点的移动代价可扩展为不同地形代价 public int GetMovementCostTo(PathNode targetNode) { // 简单实现如果是对角线邻居代价约为14√2*10否则为10 int dx Mathf.Abs(GridPosition.x - targetNode.GridPosition.x); int dz Mathf.Abs(GridPosition.y - targetNode.GridPosition.y); return dx dz 2 ? 14 : 10; } }接着创建管理所有节点的PathfindingGrid。这个网格需要能够在游戏运行时动态更新节点的IsWalkable状态。public class PathfindingGrid : MonoBehaviour { public int Width 50; public int Height 50; public float NodeSize 1.0f; public LayerMask UnwalkableMask; // 用于检测障碍物的Layer private PathNode[,] _grid; private Vector3 _gridWorldBottomLeft; void Start() { CreateGrid(); } void CreateGrid() { _grid new PathNode[Width, Height]; _gridWorldBottomLeft transform.position - Vector3.right * Width * NodeSize / 2 - Vector3.forward * Height * NodeSize / 2; for (int x 0; x Width; x) { for (int y 0; y Height; y) { Vector3 worldPoint _gridWorldBottomLeft Vector3.right * (x * NodeSize NodeSize / 2) Vector3.forward * (y * NodeSize NodeSize / 2); // 检测该点是否可通行 bool walkable !Physics.CheckSphere(worldPoint, NodeSize / 2, UnwalkableMask); Vector2Int gridPos new Vector2Int(x, y); _grid[x, y] new PathNode(gridPos, worldPoint) { IsWalkable walkable }; } } // 初始化所有节点的邻居关系8方向 InitializeNeighbors(); } void InitializeNeighbors() { for (int x 0; x Width; x) { for (int y 0; y Height; y) { PathNode node _grid[x, y]; node.Neighbors.Clear(); for (int i -1; i 1; i) { for (int j -1; j 1; j) { if (i 0 j 0) continue; // 跳过自己 int checkX x i; int checkY y j; if (checkX 0 checkX Width checkY 0 checkY Height) { node.Neighbors.Add(_grid[checkX, checkY]); } } } } } } // 根据世界坐标获取节点 public PathNode GetNodeFromWorldPoint(Vector3 worldPosition) { float percentX (worldPosition.x - _gridWorldBottomLeft.x) / (Width * NodeSize); float percentY (worldPosition.z - _gridWorldBottomLeft.z) / (Height * NodeSize); // 注意Z轴 percentX Mathf.Clamp01(percentX); percentY Mathf.Clamp01(percentY); int x Mathf.RoundToInt((Width - 1) * percentX); int y Mathf.RoundToInt((Height - 1) * percentY); return _grid[x, y]; } // **关键方法动态更新节点状态** public void UpdateNodeWalkable(Vector3 worldPosition, bool isWalkable) { PathNode node GetNodeFromWorldPoint(worldPosition); if (node ! null node.IsWalkable ! isWalkable) { node.IsWalkable isWalkable; // 这里需要通知D*Lite管理器该节点的代价发生了变化 // 例如FindObjectOfTypeDStarLitePathfinder()?.OnNodeChanged(node); // 我们会在后续D*Lite管理器部分实现这个回调 } } // 在Scene视图中绘制网格Gizmos便于调试 void OnDrawGizmos() { Gizmos.DrawWireCube(transform.position, new Vector3(Width * NodeSize, 1, Height * NodeSize)); if (_grid ! null) { foreach (PathNode n in _grid) { Gizmos.color n.IsWalkable ? Color.white : Color.red; Gizmos.DrawCube(n.WorldPosition, Vector3.one * (NodeSize - 0.1f)); } } } }这个网格系统是整个寻路的基础。UpdateNodeWalkable方法是实现动态避障的触发器当游戏中的动态事件如物体被破坏、创建发生时调用此方法来更新网格状态并通知D*Lite算法。3.2 A* 寻路器的完整C#实现有了网格我们先实现静态的A*寻路器。这是一个独立的、无状态的静态类。using System.Collections.Generic; using UnityEngine; public static class AStarPathfinder { public static ListVector3 FindPath(Vector3 startWorldPos, Vector3 targetWorldPos, PathfindingGrid grid) { PathNode startNode grid.GetNodeFromWorldPoint(startWorldPos); PathNode targetNode grid.GetNodeFromWorldPoint(targetWorldPos); if (startNode null || targetNode null || !targetNode.IsWalkable) { Debug.LogWarning(A*: 起点或终点无效); return null; } // 开放集合和关闭集合 ListPathNode openSet new ListPathNode(); HashSetPathNode closedSet new HashSetPathNode(); openSet.Add(startNode); // 初始化所有节点重置A*相关属性 for (int x 0; x grid.Width; x) { for (int y 0; y grid.Height; y) { PathNode node grid.Grid[x, y]; // 假设Grid属性是公开的或者通过方法获取 node.GCost int.MaxValue; node.HCost CalculateHeuristic(node, targetNode); node.ParentAStar null; } } startNode.GCost 0; startNode.HCost CalculateHeuristic(startNode, targetNode); while (openSet.Count 0) { // 找到开放集中F值最小的节点 PathNode currentNode openSet[0]; for (int i 1; i openSet.Count; i) { if (openSet[i].FCost currentNode.FCost || (openSet[i].FCost currentNode.FCost openSet[i].HCost currentNode.HCost)) { currentNode openSet[i]; } } openSet.Remove(currentNode); closedSet.Add(currentNode); // 如果到达目标回溯路径 if (currentNode targetNode) { return RetracePath(startNode, targetNode); } // 遍历邻居 foreach (PathNode neighbor in currentNode.Neighbors) { if (!neighbor.IsWalkable || closedSet.Contains(neighbor)) { continue; } int newMovementCostToNeighbor currentNode.GCost currentNode.GetMovementCostTo(neighbor); if (newMovementCostToNeighbor neighbor.GCost || !openSet.Contains(neighbor)) { neighbor.GCost newMovementCostToNeighbor; neighbor.HCost CalculateHeuristic(neighbor, targetNode); neighbor.ParentAStar currentNode; if (!openSet.Contains(neighbor)) { openSet.Add(neighbor); } } } } // 开放集为空未找到路径 return null; } // 启发函数使用对角线距离切比雪夫距离适合8方向移动 private static int CalculateHeuristic(PathNode a, PathNode b) { int dx Mathf.Abs(a.GridPosition.x - b.GridPosition.x); int dy Mathf.Abs(a.GridPosition.y - b.GridPosition.y); // D10, D214 对应直线和对角线代价 return 10 * (dx dy) (14 - 2 * 10) * Mathf.Min(dx, dy); } private static ListVector3 RetracePath(PathNode startNode, PathNode endNode) { ListVector3 path new ListVector3(); PathNode currentNode endNode; while (currentNode ! startNode) { path.Add(currentNode.WorldPosition); currentNode currentNode.ParentAStar; } path.Reverse(); // 反转从起点到终点 // 可以在这里进行路径平滑如漏斗算法以得到更自然的移动路径 return path; } }这个A实现是标准的但请注意在寻路开始前我们重置了所有节点的A属性。在实际游戏中如果频繁调用A*这种全局重置可能成为性能瓶颈。一个优化点是使用一个递增的“时间戳”或“搜索ID”来标记本次搜索访问过的节点避免每次重置所有节点。4. D*Lite 算法的核心实现与Unity集成这是项目的核心难点。D*Lite的算法描述有些抽象我们将它拆解为几个关键部分并用C#在Unity中实现。4.1 D*Lite 算法核心类设计我们创建一个DStarLitePathfinder类它将被附加到需要动态寻路的AI角色上或者作为一个全局管理器。using System.Collections.Generic; using UnityEngine; public class DStarLitePathfinder : MonoBehaviour { public PathfindingGrid Grid; public Transform Target; // 动态目标可以是玩家或其他移动物体 private PathNode _startNode; private PathNode _goalNode; private PathNode _lastNode; // 角色当前所在的节点 // D*Lite 核心数据结构 private PriorityQueuePathNode _openQueue; private float _km; // 用于Key值计算的偏移量 // 最终路径 private ListVector3 _currentPath new ListVector3(); private int _pathIndex 0; void Start() { if (Grid null) Grid FindObjectOfTypePathfindingGrid(); if (Target null) { Debug.LogError(D*Lite: 未指定目标); enabled false; return; } _openQueue new PriorityQueuePathNode(CompareKeys); _goalNode Grid.GetNodeFromWorldPoint(Target.position); _startNode Grid.GetNodeFromWorldPoint(transform.position); _lastNode _startNode; // 初始化计算所有节点的rhs和g值 Initialize(); // 首次计算最短路径 ComputeShortestPath(); // 生成初始路径 UpdatePath(); } void Update() { // 1. 检查目标是否移动 PathNode newGoal Grid.GetNodeFromWorldPoint(Target.position); if (newGoal ! _goalNode) { _km CalculateHeuristic(_lastNode, _goalNode); // 更新km _goalNode newGoal; // 更新目标节点的rhs (goal.rhs 0) _goalNode.Rhs 0; _goalNode.Key1 CalculateKey(_goalNode, 0); _openQueue.Enqueue(_goalNode); } // 2. 检查角色周围地形是否变化简化每帧检查角色所在节点 // 在实际项目中应由事件驱动如Grid.UpdateNodeWalkable时调用OnNodeChanged CheckForEdgeCostChanges(); // 3. 如果开放队列不为空说明有代价需要传播重新计算路径 if (_openQueue.Count 0 (_openQueue.Peek().Key1 CalculateKey(_startNode, 0) || _startNode.Rhs _startNode.G)) { ComputeShortestPath(); UpdatePath(); } // 4. 沿路径移动 FollowPath(); } // **核心初始化所有节点** private void Initialize() { _openQueue.Clear(); _km 0; // 将所有节点的rhs和g设为无穷大 for (int x 0; x Grid.Width; x) { for (int y 0; y Grid.Height; y) { PathNode node Grid.Grid[x, y]; node.Rhs float.PositiveInfinity; node.G float.PositiveInfinity; } } // 目标节点的rhs为0 _goalNode.Rhs 0; _goalNode.Key1 CalculateKey(_goalNode, 0); _openQueue.Enqueue(_goalNode); } // **核心计算Key用于优先队列排序** private float CalculateKey(PathNode node, float kModifier) { float minGrhs Mathf.Min(node.G, node.Rhs); float heuristic CalculateHeuristic(_startNode, node); // 注意这里启发值是到当前起点 return new Vector2(minGrhs heuristic _km, minGrhs); // 实际实现中Key是一个二维值 (k1, k2)。我们这里用float表示k1排序时需比较k1和k2。 // 为简化我们使用一个自定义的Key结构体和比较器。下面会给出PriorityQueue的实现。 } // **核心更新节点** private void UpdateVertex(PathNode node) { if (node.G ! node.Rhs _openQueue.Contains(node)) { // 节点不一致且在开放集中更新其Key node.Key1 CalculateKey(node, 0); _openQueue.UpdateItem(node); } else if (node.G ! node.Rhs !_openQueue.Contains(node)) { // 节点不一致且不在开放集中加入 node.Key1 CalculateKey(node, 0); _openQueue.Enqueue(node); } else if (node.G node.Rhs _openQueue.Contains(node)) { // 节点一致且在开放集中移除 _openQueue.Remove(node); } } // **核心计算最短路径主循环** private void ComputeShortestPath() { while (_openQueue.Count 0 (_openQueue.Peek().Key1 CalculateKey(_startNode, 0) || _startNode.Rhs _startNode.G)) { PathNode node _openQueue.Dequeue(); float kOld node.Key1; float kNew CalculateKey(node, 0); if (kOld kNew) { // Key值过时重新插入 node.Key1 kNew; _openQueue.Enqueue(node); } else if (node.G node.Rhs) { // 节点过一致overconsistent需要传播更低的代价 node.G node.Rhs; foreach (PathNode neighbor in node.Neighbors) { if (neighbor ! _goalNode) { // 更新邻居的rhs值rhs(s) min_{s in Succ(s)}(c(s, s) g(s)) float newRhs float.PositiveInfinity; foreach (PathNode succ in neighbor.Neighbors) // 注意这里是前驱节点 { if (succ.IsWalkable) { float cost succ.GetMovementCostTo(neighbor); // 移动代价 newRhs Mathf.Min(newRhs, cost succ.G); } } if (neighbor.Rhs ! newRhs) { neighbor.Rhs newRhs; UpdateVertex(neighbor); } } } } else { // 节点欠一致underconsistent需要传播更高的代价 float gOld node.G; node.G float.PositiveInfinity; // 更新自己及受自己影响的邻居 UpdateVertex(node); foreach (PathNode neighbor in node.Neighbors) { if (neighbor.Rhs gOld node.GetMovementCostTo(neighbor)) // 如果邻居的rhs依赖于这个节点 { if (neighbor ! _goalNode) { // 重新计算邻居的rhs float newRhs float.PositiveInfinity; foreach (PathNode succ in neighbor.Neighbors) { if (succ.IsWalkable) { float cost succ.GetMovementCostTo(neighbor); newRhs Mathf.Min(newRhs, cost succ.G); } } neighbor.Rhs newRhs; } UpdateVertex(neighbor); } } } } } // 从当前起点回溯路径 private void UpdatePath() { _currentPath.Clear(); PathNode currentNode _startNode; // 沿着最小g值的邻居走直到终点 while (currentNode ! _goalNode currentNode ! null) { _currentPath.Add(currentNode.WorldPosition); PathNode nextNode null; float minCost float.PositiveInfinity; foreach (PathNode neighbor in currentNode.Neighbors) { if (neighbor.IsWalkable) { // 选择使 c(current, neighbor) g(neighbor) 最小的邻居 float cost currentNode.GetMovementCostTo(neighbor) neighbor.G; if (cost minCost) { minCost cost; nextNode neighbor; } } } if (nextNode null) break; // 无路可走 currentNode nextNode; } if (currentNode _goalNode) { _currentPath.Add(_goalNode.WorldPosition); } _pathIndex 0; } // 沿路径移动示例 private void FollowPath() { if (_currentPath null || _pathIndex _currentPath.Count) return; Vector3 targetPos _currentPath[_pathIndex]; transform.position Vector3.MoveTowards(transform.position, targetPos, 5f * Time.deltaTime); if (Vector3.Distance(transform.position, targetPos) 0.1f) { _pathIndex; // 更新当前起点节点 _lastNode _startNode; _startNode Grid.GetNodeFromWorldPoint(transform.position); } } // 当网格节点状态改变时由Grid调用 public void OnNodeChanged(PathNode changedNode) { // 重新计算该节点所有出边的代价影响 // 简化处理将该节点及其所有邻居的rhs设为无穷大并加入开放集重新计算 changedNode.Rhs float.PositiveInfinity; UpdateVertex(changedNode); foreach (PathNode neighbor in changedNode.Neighbors) { if (neighbor ! _goalNode) { // 重新计算邻居的rhs float newRhs float.PositiveInfinity; foreach (PathNode succ in neighbor.Neighbors) { if (succ.IsWalkable) { float cost succ.GetMovementCostTo(neighbor); newRhs Mathf.Min(newRhs, cost succ.G); } } neighbor.Rhs newRhs; UpdateVertex(neighbor); } } // 不需要立即调用ComputeShortestPathUpdate()中的循环会处理 } // 检查角色周围边的代价变化示例性实现实际应由事件触发 private void CheckForEdgeCostChanges() { // 这里可以检查_startNode周围邻居的可通过性是否发生变化 // 如果变化调用OnNodeChanged } // 启发函数与A*保持一致 private float CalculateHeuristic(PathNode a, PathNode b) { int dx Mathf.Abs(a.GridPosition.x - b.GridPosition.x); int dy Mathf.Abs(a.GridPosition.y - b.GridPosition.y); return 10 * (dx dy) (14 - 20) * Mathf.Min(dx, dy); } // 优先队列比较器 private int CompareKeys(PathNode a, PathNode b) { int compare a.Key1.CompareTo(b.Key1); if (compare 0) { compare a.Key2.CompareTo(b.Key2); } return compare; } } // 一个简单的基于二叉堆的优先队列实现需补充完整 public class PriorityQueueT { private ListT _data; private System.FuncT, T, int _comparer; public PriorityQueue(System.FuncT, T, int comparer) { _data new ListT(); _comparer comparer; } public int Count _data.Count; public void Enqueue(T item) { /* 实现堆插入 */ } public T Dequeue() { /* 实现堆删除并返回最小值 */ } public T Peek() { /* 返回最小值 */ } public bool Contains(T item) { /* ... */ } public void UpdateItem(T item) { /* 更新项后重新排序 */ } public void Remove(T item) { /* ... */ } public void Clear() { _data.Clear(); } }这段代码是DLite的核心框架但请注意这是一个高度简化的教学版本。一个生产级别的DLite实现需要处理更多边界条件优化数据结构特别是优先队列的UpdateItem和Remove操作并仔细处理浮点数精度问题。4.2 动态地形事件的响应机制在《原神》式的游戏中动态地形事件是异步、离散发生的。我们需要一个事件系统来高效地通知寻路系统。创建事件管理器可以是一个简单的静态类或使用C#的event关键字。public static class PathfindingEventManager { public static event System.ActionPathNode OnNodeWalkabilityChanged; public static void TriggerNodeChanged(PathNode node) { OnNodeWalkabilityChanged?.Invoke(node); } }修改Grid的更新方法public void UpdateNodeWalkable(Vector3 worldPosition, bool isWalkable) { PathNode node GetNodeFromWorldPoint(worldPosition); if (node ! null node.IsWalkable ! isWalkable) { node.IsWalkable isWalkable; PathfindingEventManager.TriggerNodeChanged(node); } }在D*LitePathfinder中订阅事件void OnEnable() { PathfindingEventManager.OnNodeWalkabilityChanged HandleNodeChanged; } void OnDisable() { PathfindingEventManager.OnNodeWalkabilityChanged - HandleNodeChanged; } private void HandleNodeChanged(PathNode changedNode) { OnNodeChanged(changedNode); // 调用之前实现的方法 }在游戏逻辑中触发事件例如当一个可破坏的木箱被摧毁时。public class DestructibleCrate : MonoBehaviour { public PathfindingGrid grid; void OnDestroy() { grid.UpdateNodeWalkable(transform.position, true); // 箱子被摧毁后该点变为可通行 } }这样任何游戏逻辑都能通过修改网格和触发事件来影响AI的寻路实现了真正的动态避障。5. 性能优化与高级技巧将A和DLite结合起来后在大型地图上性能依然可能成为问题。以下是一些关键的优化方向5.1 分层寻路HPA*对于超大型开放世界不要在整个世界网格上运行寻路。可以采用分层路径规划高层将地图划分为大的“区块”Chunk区块之间的连接点作为高层节点。先用A*在高层找到需要经过的区块序列。底层在角色当前所在区块和下一个目标区块内使用D*Lite进行精细的、动态的局部寻路。优势极大减少了单次搜索的节点数量。D*Lite只活跃在角色当前所在的局部网格上计算量可控。5.2 路径平滑与移动A和DLite返回的是网格中心点路径直接让角色按此移动会产生“锯齿感”。需要使用路径平滑技术漏斗算法在网格路径的基础上生成一个通过多边形通道由障碍物边缘定义的最短平滑路径。贝塞尔曲线/样条曲线对路径点进行插值得到平滑的曲线路径。与Unity NavMesh 结合可以将网格路径的第一个可达点作为临时目标让Unity的NavMeshAgent去执行实际的移动和避障针对其他动态单位实现高层决策与底层执行的解耦。5.3 多单位管理与冲突避免当大量AI同时使用D*Lite时可能会相互阻塞。需要考虑局部避障每个单位除了遵循全局路径还应使用简单的局部避障算法如RVO互惠速度障碍或简单的力导向法来处理与其他移动单位的瞬间碰撞。路径预留对于重要的、确定性的移动如队伍行军可以尝试简单的“时空”路径预留避免交叉。5.4 调试与可视化在Unity编辑器中建立强大的调试视图至关重要绘制网格如之前代码中的OnDrawGizmos用颜色区分可通过/不可通过节点。绘制当前路径用Gizmos.DrawLine或Handles.DrawPolyLine实时绘制_currentPath。绘制开放集/关闭集在D*Lite计算时高亮显示正在被计算的节点便于理解算法行为。打印关键信息在屏幕上显示当前目标、路径长度、开放队列大小等。6. 常见问题与实战避坑指南在实际集成这套系统时你几乎一定会遇到下面这些问题。这里是我的实战记录问题1D*Lite的“原地抖动”或“频繁重新规划”现象角色在接近动态障碍物时路径频繁闪烁变化导致移动抖动。原因OnNodeChanged被触发得太频繁例如每帧检测到障碍物或者D*Lite的Key计算或优先队列实现有误导致节点在开放集中被反复无效地插入弹出。解决事件去抖为地形变化事件添加一个小的延迟或合并间隔避免单帧内多次触发。例如记录所有变化的节点在FixedUpdate中统一处理一次。检查一致性仔细调试UpdateVertex和ComputeShortestPath逻辑确保节点状态g, rhs和队列状态同步。使用断言检查g rhs是否始终成立对于一致节点。优化启发式确保启发式函数CalculateHeuristic是可采纳且一致的单调的。不一致的启发式会导致D*Lite行为异常。问题2移动代价不对称导致的路径怪异现象AI有时会选择看似绕远的路径。原因GetMovementCostTo函数实现的代价不对称。例如从A到B的代价是10但从B到A的代价计算错误变成了12。DLite和A都假设移动代价是对称的。解决确保移动代价计算函数是对称的。通常使用固定的每格代价或基于节点自身属性如地形类型的代价保证Cost(A, B) Cost(B, A)。问题3帧率下降特别是在大量AI或大地图上现象游戏运行时卡顿Profiler显示CPU时间消耗在寻路线程或主线程的ComputeShortestPath上。解决分帧计算将D*Lite的ComputeShortestPath主循环拆开每次Update只执行有限次数的迭代例如100次。虽然这会延迟路径计算完成但保证了帧率稳定。对于非即时战略游戏AI的反应延迟几百毫秒是可以接受的。降低更新频率不是每帧都检查目标移动或重新计算路径。可以每0.1-0.3秒执行一次Update中的路径逻辑。使用Job System/Burst Compiler将网格表示和代价计算转换为原生的结构体利用Unity的C# Job System进行并行化的代价传播计算可以大幅提升性能。问题4AI卡在角落或薄墙处现象路径显示可通过但AI的碰撞体无法通过。原因网格分辨率NodeSize大于AI角色的碰撞体半径。寻路网格认为可通过但实际物理碰撞通不过。解决使用更小的网格但这会增加节点数量降低性能。在寻路时考虑角色半径这是更专业的做法。在检测节点是否可通行IsWalkable时不要只检测一个点而是检测一个以节点为中心、半径为角色碰撞体大小的圆形或胶囊体区域。这被称为“膨胀”Inflation或“代理半径”Agent Radius。Unity的NavMesh生成就有这个参数。路径后处理生成路径后用角色的碰撞体沿着路径做一次“射线扫描”或“OverlapSphere”检测如果发现碰撞则将该点标记为临时障碍触发重新寻路。问题5动态目标如玩家移动过快AI永远追不上原因AI每帧沿当前路径移动一段固定距离而路径是基于上一帧的目标位置计算的。当目标移动速度超过AI时路径会不断向后延伸形成“你追我跑”的无限循环。解决预测拦截不要直接寻路到目标的当前位置而是预测其未来几帧的位置根据其速度和方向寻路到那个预测点。这需要一些简单的向量运算。周期性重规划即使目标节点没变也定期比如每秒用A重新计算一次全局路径以纠正DLite在长期追逐中可能积累的局部最优而非全局最优的问题。实现A与DLite的混合动态寻路系统是一个从理论到实践的深度工程。它没有银弹需要你根据自己游戏的具体特点地图大小、AI数量、动态元素频率进行细致的调优和裁剪。从一个小型原型开始逐步增加复杂度并辅以强大的调试工具是最终成功上线的唯一路径。这套系统一旦调通你的游戏世界将真正“活”起来AI不再是被预设路径束缚的木偶而是能够对环境变化做出实时反应的智能存在。