游戏开发实战：A*算法在Unity寻路中的高效实现（附完整C#代码）
在游戏世界里，无论是开放世界的探索，还是策略游戏的单位调度，让角色或单位智能地找到从A点到B点的路径，是开发者必须解决的核心问题之一。你或许尝试过Unity自带的NavMesh系统，它在处理静态场景时表现出色，但对于动态变化的网格、需要高度自定义寻路逻辑，或是追求极致性能的2D/3D项目，手动实现一个寻路算法往往能带来更大的灵活性和控制力。A*（A-Star）算法，正是这个领域里那颗璀璨的明珠，它巧妙地在计算效率和路径最优性之间找到了平衡，成为游戏开发中应用最广泛的寻路算法。
这篇文章不是一篇枯燥的算法论文，而是一份面向Unity开发者的实战手册。我们将从零开始，一步步构建一个高效、可复用的A*寻路系统。我会分享在实际项目中踩过的坑，比如如何处理不同地形代价、如何优化大网格下的性能瓶颈，以及如何将算法优雅地集成到你的游戏循环中。无论你是正在开发一款Roguelike地牢探险游戏，还是一个需要复杂单位调度的RTS游戏，这里提供的思路和代码都能直接为你所用。让我们暂时抛开复杂的数学证明，聚焦于如何让算法在Unity引擎中“跑起来”，并跑得又快又好。
1. 理解A*：从理论到游戏世界的映射
在深入代码之前，我们需要清晰地理解A算法在游戏上下文中的核心思想。简单来说，A是一种“启发式”的搜索算法。它不像无头苍蝇一样盲目探索所有方向，而是像一个手持地图和指南针的探险家，每走一步都会评估两个关键信息：我已经走了多远（G代价），以及我估计离终点还有多远（H代价）。将两者相加，就得到了当前节点的总评估代价（F代价）。算法总是优先探索F代价最小的节点，从而高效地导向目标。
1.1 核心概念的游戏化解读
让我们把这些抽象概念映射到游戏开发的具体元素上：
- 节点 (Node)： 在2D网格地图中，一个节点就是一个格子（Tile）。在3D导航网格（NavMesh）或无网格系统中，一个节点可能是一个多边形（Polygon）或一个路点（Waypoint）。我们的寻路就是在这些节点构成的图（Graph）中进行的。
- G代价 (G Cost)： 从起点移动到当前节点的实际累积代价。在平地上，移动一格代价可能是1；穿越沼泽地，代价可能是3；翻越墙壁？代价可能是无穷大（不可通行）。
- H代价 (H Cost)： 从当前节点到目标节点的估算代价，这就是“启发式”部分。它引导搜索方向。常用的估算方法有：
- 曼哈顿距离： 适用于只能上下左右移动的网格（如经典2D游戏）。
H = |dx| + |dy|。 - 欧几里得距离： 适用于可以任意方向移动的场景（如大多数3D游戏）。
H = sqrt(dx*dx + dy*dy)。 - 切比雪夫距离： 适用于可以八方向（包括对角线）移动的网格。
H = max(|dx|, |dy|)。
- 曼哈顿距离： 适用于只能上下左右移动的网格（如经典2D游戏）。
- F代价 (F Cost)：
F = G + H。这是决定节点探索优先级的关键。开放列表（Open Set）会根据F代价对节点进行排序。
提示： 选择正确的启发函数（H Cost计算方式）至关重要。曼哈顿距离计算快，但在允许对角线移动时可能会高估距离，导致寻路不是“最直观”的直线。欧几里得距离更准确，但计算平方根开销稍大。在大多数情况下，欧几里得距离的平方（
H = dx*dx + dy*dy）是一个很好的折中方案，因为它保持了大小关系且避免了开方运算。
1.2 A*与Dijkstra、Floyd的实战视角对比
你可能会在资料中看到Dijkstra和Floyd算法。它们在游戏寻路中扮演什么角色？
| 特性 | A* 算法 | Dijkstra 算法 | Floyd 算法 |
|---|---|---|---|
| 核心目标 | 找到两点间最短路径 | 找到单点到所有其他点的最短路径 | 计算所有点对之间的最短路径 |
| 启发式 | 有，使用H(n)引导搜索 | 无，均匀向所有方向扩展 | 无，基于动态规划 |
| 游戏应用场景 | 实时单位寻路（主角移动、AI移动） | 地图全图可达性分析、影响力扩散计算 | 极小规模固定图的预计算（如房间内点位），极少用于实时寻路 |
| 性能特点 | 高效，因目标导向，搜索节点少 | 较慢，需探索大量无关节点 | 极慢（O(N³)），仅适合预处理 |
简单来说，Dijkstra是不知道终点在哪里的A*。如果你需要让一个单位探索整个地图并记录下到每个点的最短距离（比如战略游戏中的“视野”或“控制区域”扩散），Dijkstra更有用。而Floyd算法在游戏实时寻路中基本不用，它的立方级时间复杂度无法承受动态变化的游戏世界。A*因其在单次点对点寻路上的高效性，成为游戏开发中的事实标准。
2. 构建Unity中的A*寻路系统：基础框架
理论足够清晰了，现在让我们动手搭建。我们将创建一个基于2D网格的A*系统，但其核心逻辑可以轻松扩展到3D导航网格。
2.1 定义节点类：存储寻路信息
首先，我们需要一个类来代表网格中的每一个节点。这个类需要存储所有A*算法所需的信息。
using System.Collections.Generic;
using UnityEngine;
public class PathNode
{
// 节点在网格中的坐标
public int x;
public int y;
// A* 核心代价
public int gCost; // 从起点到本节点的实际代价
public int hCost; // 到终点的估算代价
public int fCost { get { return gCost + hCost; } } // 总代价，由G和H计算得出
// 是否为障碍物
public bool isWalkable = true;
// 用于回溯路径：当前节点是由哪个节点走过来的
public PathNode cameFromNode;
// 构造函数
public PathNode(int x, int y)
{
this.x = x;
this.y = y;
}
// 重写ToString，方便调试
public override string ToString()
{
return $"({x},{y}) G:{gCost} H:{hCost} F:{fCost}";
}
}
这个PathNode类是寻路数据的载体。cameFromNode属性是路径回溯的关键，当算法找到终点后，我们可以像链表一样从终点节点一路回溯到起点，从而得到完整的路径。
2.2 创建网格管理系统：世界的抽象
接下来，我们需要一个管理所有节点的网格系统。这个系统负责创建节点、根据世界坐标获取节点、设置障碍等。
public class PathfindingGrid : MonoBehaviour
{
[SerializeField] private int width = 20;
[SerializeField] private int height = 20;
[SerializeField] private float cellSize = 1f;
[SerializeField] private LayerMask obstacleLayer; // 用于检测障碍物的图层
[SerializeField] private bool showGridGizmos = true; // 是否在Scene视图显示网格
private PathNode[,] gridArray;
void Start()
{
CreateGrid();
}
// 初始化网格，创建所有节点并检测障碍
private void CreateGrid()
{
gridArray = new PathNode[width, height];
Vector3 worldBottomLeft = transform.position - Vector3.right * width * cellSize / 2 - Vector3.forward * height * cellSize / 2;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Vector3 worldPoint = worldBottomLeft + Vector3.right * (x * cellSize + cellSize * 0.5f) + Vector3.forward * (y * cellSize + cellSize * 0.5f);
// 检测该世界位置是否有障碍物（使用BoxCast或OverlapSphere等）
bool walkable = !Physics.CheckSphere(worldPoint, cellSize * 0.4f, obstacleLayer);
gridArray[x, y] = new PathNode(x, y) { isWalkable = walkable };
}
}
}
// 根据世界坐标获取对应的节点
public PathNode GetNodeFromWorldPoint(Vector3 worldPosition)
{
Vector3 localPos = worldPosition - transform.position;
float percentX = (localPos.x / (width * cellSize)) + 0.5f;
float percentY = (localPos.z / (height * cellSize)) + 0.5f; // 注意：在Unity中，forward对应世界坐标的Z轴
percentX = Mathf.Clamp01(percentX);
percentY = Mathf.Clamp01(percentY);
int x = Mathf.RoundToInt((width - 1) * percentX);
int y = Mathf.RoundToInt((height - 1) * percentY);
return gridArray[x, y];
}
// 获取一个节点的所有邻居节点（四方向或八方向）
public List<PathNode> GetNeighbourNodes(PathNode currentNode)
{
List<PathNode> neighbours = new List<PathNode>();
// 四方向移动
int[] dx = { 0, 1, 0, -1 };
int[] dy = { 1, 0, -1, 0 };
for (int i = 0; i < 4; i++)
{
int checkX = currentNode.x + dx[i];
int checkY = currentNode.y + dy[i];
if (checkX >= 0 && checkX < width && checkY >= 0 && checkY < height)
{
neighbours.Add(gridArray[checkX, checkY]);
}
}
return neighbours;
}
// 在Scene视图中绘制调试网格
private void OnDrawGizmos()
{
if (!showGridGizmos || gridArray == null) return;
foreach (PathNode node in gridArray)
{
Gizmos.color = (node.isWalkable) ? Color.white : Color.red;
Vector3 worldPos = GetWorldPosition(node.x, node.y) + Vector3.up * 0.1f;
Gizmos.DrawCube(worldPos, Vector3.one * (cellSize * 0.9f));
}
}
private Vector3 GetWorldPosition(int x, int y)
{
Vector3 worldBottomLeft = transform.position - Vector3.right * width * cellSize / 2 - Vector3.forward * height * cellSize / 2;
return worldBottomLeft + Vector3.right * (x * cellSize + cellSize * 0.5f) + Vector3.forward * (y * cellSize + cellSize * 0.5f);
}
}
这个PathfindingGrid脚本挂载在一个空物体上，它定义了寻路发生的“舞台”。GetNeighbourNodes方法目前只返回上下左右四个邻居，你可以轻松扩展它来支持八方向移动（包括对角线），但需要注意对角线移动的代价计算（通常是sqrt(2) ≈ 1.4倍）。
3. 实现A*核心算法：从寻找到路径
有了网格和节点，现在可以实现A*算法的主逻辑了。我们将创建一个静态的Pathfinding类来执行寻路计算。
3.1 算法步骤的代码实现
A*算法的流程可以概括为以下几个步骤，我们将用代码逐一实现：
- 将起点加入开放列表（待检查节点集合）。
- 进入循环，只要开放列表不为空：
a. 从开放列表中取出F代价最小的节点作为当前节点。
b. 将当前节点移入关闭列表（已检查节点集合）。
c. 如果当前节点就是终点，重构路径并返回。
d. 遍历当前节点的所有邻居：
i. 如果邻居不可通行或在关闭列表中，跳过。
ii. 计算从起点经过当前节点到该邻居的新G代价。
iii. 如果新G代价更小，或者邻居不在开放列表中：
- 更新邻居的G、H代价。
- 设置邻居的
cameFromNode为当前节点。 - 如果邻居不在开放列表中，将其加入。 - 如果循环结束仍未找到终点，说明路径不存在。
下面是具体的C#实现：
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
public static class Pathfinding
{
// 主寻路函数
public static List<Vector3> 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("起点或终点无效！");
return null;
}
// 开放集合（待检查节点），使用List并手动排序，对于性能要求高的项目可改用优先队列（Heap）
List<PathNode> openSet = new List<PathNode>();
// 关闭集合（已检查节点），使用HashSet实现快速查找
HashSet<PathNode> closedSet = new HashSet<PathNode>();
openSet.Add(startNode);
while (openSet.Count > 0)
{
// 1. 从开放集中找到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];
}
}
// 2. 将当前节点移入关闭集，从开放集移除
openSet.Remove(currentNode);
closedSet.Add(currentNode);
// 3. 找到目标，重构路径
if (currentNode == targetNode)
{
return RetracePath(startNode, targetNode, grid);
}
// 4. 遍历邻居
foreach (PathNode neighbour in grid.GetNeighbourNodes(currentNode))
{
if (!neighbour.isWalkable || closedSet.Contains(neighbour))
{
continue;
}
// 计算从当前节点到邻居的新G代价（假设移动代价为1）
int newMovementCostToNeighbour = currentNode.gCost + GetDistance(currentNode, neighbour);
if (newMovementCostToNeighbour < neighbour.gCost || !openSet.Contains(neighbour))
{
neighbour.gCost = newMovementCostToNeighbour;
neighbour.hCost = GetDistance(neighbour, targetNode);
neighbour.cameFromNode = currentNode;
if (!openSet.Contains(neighbour))
{
openSet.Add(neighbour);
}
}
}
}
// 开放集为空，未找到路径
return null;
}
// 回溯路径：从终点节点根据cameFromNode反向追溯到起点
private static List<Vector3> RetracePath(PathNode startNode, PathNode endNode, PathfindingGrid grid)
{
List<PathNode> path = new List<PathNode>();
PathNode currentNode = endNode;
while (currentNode != startNode)
{
path.Add(currentNode);
currentNode = currentNode.cameFromNode;
}
path.Add(startNode);
path.Reverse(); // 反转列表，得到从起点到终点的顺序
// 将节点列表转换为世界坐标列表（可在此进行路径平滑优化）
List<Vector3> waypoints = new List<Vector3>();
foreach (PathNode node in path)
{
waypoints.Add(grid.GetWorldPosition(node.x, node.y)); // 需要为PathfindingGrid添加GetWorldPosition方法
}
return waypoints;
}
// 计算两个节点之间的估算距离（启发函数H），此处使用曼哈顿距离
private static int GetDistance(PathNode nodeA, PathNode nodeB)
{
int dstX = Mathf.Abs(nodeA.x - nodeB.x);
int dstY = Mathf.Abs(nodeA.y - nodeB.y);
return 10 * (dstX + dstY); // 乘以10是为了避免使用浮点数，同时为对角线移动（14）留出整数空间
}
}
3.2 关键细节与优化点
上面的代码是A*最直接的实现，但有几个地方值得深入讨论：
- 开放列表的数据结构： 我们使用了
List<PathNode>并通过线性搜索查找最小F代价节点。这在节点数量少时没问题，但当网格很大时（如100x100），这会成为性能瓶颈。生产环境强烈建议使用二叉堆（Binary Heap）实现优先队列，可以将“查找并移除最小值”的操作从O(n)优化到O(log n)。这是A*算法最重要的优化之一。 - 启发函数的选择： 代码中
GetDistance使用了曼哈顿距离并乘以10。如果你要实现八方向移动，需要修改这个函数。例如，对角线移动一格的实际距离是sqrt(2)≈1.414，为了保持整数运算，我们可以设定水平/垂直移动代价为10，对角线移动代价为14（≈10*1.414）。 - 路径平滑：
RetracePath返回的是网格中心点的路径，这会导致角色走“锯齿形”路线。一个常见的优化是进行路径后处理，比如使用漏斗算法（Funnel Algorithm） 或简单的射线投射（Raycasting） 来剔除不必要的拐点，让路径更平滑、更自然。
4. 高级优化与实战技巧
一个基础的A*系统已经搭建完成，但要将其投入真正的游戏项目，我们还需要考虑更多现实问题。
4.1 性能优化策略
当处理大规模地图或大量单位同时寻路时，性能至关重要。
- 使用二叉堆（优先队列）： 如前所述，这是必须的优化。你可以自己实现一个
Heap<T>类，或者使用C#的SortedSet（需注意处理相同F值的情况）。 - 分帧/异步寻路： 不要让寻路计算阻塞主游戏线程。可以将寻路请求放入队列，在
Update或协程中每帧只处理一部分计算。Unity的Job System和Burst Compiler也为高性能多线程寻路提供了可能。 - 网格分区与层次化A*： 对于超大型地图，不要使用一个巨大的网格。可以将地图划分为多个区块（Chunk），先在高层次的区块图上寻路，再在具体的区块内进行精细寻路。这能极大减少需要搜索的节点数量。
- 缓存与重用： 如果很多单位需要前往同一个目标点（比如所有士兵冲向一个据点），可以只计算一次从目标点到全图各点的距离场（这类似于Dijkstra算法），然后每个单位只需根据距离场“下山”即可找到路径。这种技术称为流场寻路（Flow Field），在RTS游戏中非常高效。
4.2 处理复杂地形与动态障碍
游戏世界是动态的。一堵墙可能被炸毁，一扇门可能被打开。
- 动态更新网格： 当游戏中的障碍物状态改变时，需要调用
PathfindingGrid的方法更新对应节点的isWalkable状态。为了避免频繁的全局重计算，可以只标记受影响的区域。 - 代价系统（Weighted A）*： 不是所有可通行区域都一样。草地、道路、沼泽应有不同的移动代价。我们可以在
PathNode中增加一个movementPenalty字段，在计算G代价时加上它。这样寻路就会自动偏好道路，避开沼泽。// 在PathNode类中增加 public int movementPenalty = 0; // 在计算G代价时 int newCostToNeighbour = currentNode.gCost + GetDistance(currentNode, neighbour) + neighbour.movementPenalty; - 单位碰撞与局部避障： A*找到的是宏观路径，但单位之间可能会互相阻挡。常见的做法是结合局部避障算法，如RVO（Reciprocal Velocity Obstacles）或简单的力导向模型，让单位在遵循全局路径的同时，能动态避开移动中的其他单位。
4.3 集成到游戏对象：一个移动示例
最后，让我们创建一个简单的脚本，让一个游戏对象使用我们的A*系统进行移动。
public class UnitMovement : MonoBehaviour
{
public PathfindingGrid grid; // 拖拽赋值
public float speed = 5f;
private List<Vector3> path;
private int targetIndex;
void Update()
{
if (Input.GetMouseButtonDown(0))
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out RaycastHit hit))
{
RequestPath(transform.position, hit.point);
}
}
if (path != null)
{
FollowPath();
}
}
void RequestPath(Vector3 start, Vector3 end)
{
// 在实际项目中，这里应该使用异步或分帧寻路
path = Pathfinding.FindPath(start, end, grid);
targetIndex = 0;
if (path == null || path.Count == 0)
{
Debug.Log("无法到达目标点！");
path = null;
}
}
void FollowPath()
{
if (targetIndex >= path.Count)
{
path = null;
return;
}
Vector3 currentWaypoint = path[targetIndex];
Vector3 direction = (currentWaypoint - transform.position).normalized;
transform.position += direction * speed * Time.deltaTime;
if (Vector3.Distance(transform.position, currentWaypoint) < 0.1f)
{
targetIndex++;
}
}
// 在Scene视图中绘制路径（调试用）
private void OnDrawGizmos()
{
if (path != null)
{
for (int i = targetIndex; i < path.Count; i++)
{
Gizmos.color = Color.black;
Gizmos.DrawCube(path[i], Vector3.one * 0.2f);
if (i == targetIndex)
{
Gizmos.DrawLine(transform.position, path[i]);
}
else
{
Gizmos.DrawLine(path[i - 1], path[i]);
}
}
}
}
}
这个脚本实现了点击移动：点击鼠标左键，单位就会计算路径并朝目标点移动。FollowPath方法只是简单地朝下一个路点直线移动，你可以在这里加入更复杂的移动逻辑，比如旋转朝向、使用CharacterController或NavMeshAgent进行最终移动。
实现一个基础的A寻路系统只是第一步。在我最近参与的一个2D战术项目中，我们最初使用标准的网格A，但在超过100个单位同时寻路时遇到了明显的卡顿。后来我们将网格从精细的32x32替换为更粗糙的128x128分区，并在每个分区内使用A*，同时结合了简单的流场思想来处理集群移动，帧率立刻稳定了。另一个教训是关于路径平滑的，直接使用网格中心点路径会让单位移动显得很“呆”，后来我们加入了一个简单的后处理：在得到原始路径后，从起点开始，尝试用射线检测是否能“看到”后面的路点，如果能就直接跳过中间点。这个小小的改动让单位的移动轨迹立刻变得流畅自然了许多。记住，没有完美的通用方案，最好的优化永远是针对你具体游戏的需求和瓶颈来进行的。
3543
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
