A*算法的C#实现（纯代码）

最新推荐文章于 2025-05-02 14:08:41 发布
最新推荐文章于 2025-05-02 14:08:41 发布
阅读量1.2k 收藏 1
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chenyuan_noc/article/details/21698041
本文展示了如何在Unity中使用C#实现A*寻路算法。代码包括了初始化网格、获取网格ID、计算代价、寻找邻居、判断障碍物等功能，用于找到从起点到终点的最优路径。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

#region

using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;

using UnityEngine;

using Debug = UnityEngine.Debug;

#endregion

public class VAStar : MonoBehaviour
{
    #region Fields

    public int GridHeight;

    public int GridWidth;

    private List<VGrid> closedList;

    private Dictionary<int, VGrid> gridDictionary;

    private List<GameObject> obstacleList;

    private List<VGrid> openList;

    private System.Diagnostics.Stopwatch watch;

    public delegate void OnPathComplete ( List<Vector3> posList );

    public OnPathComplete onPathComplete;

    #endregion

    // Use this for initialization

    #region Public Methods and Operators

    public void StartFindPath ( Vector3 startPos, Vector3 endPos, OnPathComplete delegateComplete )
    {
        watch.Start();
        this.onPathComplete = delegateComplete;
        int startGridId = this.GetGridIdByPos(startPos);
        int endGridId = this.GetGridIdByPos(endPos);
        if (startGridId == -1 || endGridId == -1)
        {
            return;
        }
        this.openList.Add(this.gridDictionary[startGridId]);
        this.Test(startGridId, endGridId);
    }

    #endregion

    #region Methods

    private int GetColumnCount ()
    {
        return Screen.width / this.GridWidth;
    }

    private Vector3 GetGridCenterById ( int gridId )
    {
        //Like This:
        //8 9 10 11
        //4 5 6 7
        //0 1 2 3
        return new Vector3(
            gridId % this.GetColumnCount() * this.GridWidth + (this.GridWidth / 2),
            gridId / this.GetColumnCount() * this.GridHeight + (this.GridHeight / 2),
            0);
    }

    private int GetGridIdByPos ( Vector3 pos )
    {
        if (this.gridDictionary != null && this.gridDictionary.Values.Count != 0)
        {
            foreach (KeyValuePair<int, VGrid> kv in this.gridDictionary)
            {
                Rect gridRect = new Rect(
                    kv.Value.Center.x - this.GridWidth / 2,
                    kv.Value.Center.y - this.GridHeight / 2,
                    this.GridWidth,
                    this.GridHeight);
                if (gridRect.Contains(pos))
                {
                    return kv.Key;
                }
            }
        }
        return -1;
    }

    private int GetGridIdByRowAndColumn ( int rowId, int columnId )
    {
        if (rowId < 0 || rowId >= this.GetRowCount() || columnId < 0 || columnId >= this.GetColumnCount())
        {
            return -1;
        }
        return rowId * this.GetColumnCount() + columnId;
    }

    private int GetHValue ( int fromGridId, int targetGridId )
    {
        int fromGridRowId;
        int fromGridColumnId = this.GetRowAndColumnById(fromGridId, out fromGridRowId);
        int targetGridRowId;
        int targetGridColumnId = this.GetRowAndColumnById(targetGridId, out targetGridRowId);
        return Mathf.Abs(fromGridRowId - targetGridRowId) * 10 + Mathf.Abs(fromGridColumnId - targetGridColumnId) * 10;
    }

    private bool GetIsAvailableById ( int gridId )
    {
        Vector3 gridCenter = this.GetGridCenterById(gridId);
        Rect gridRect = new Rect(
            gridCenter.x - this.GridWidth / 2,
            gridCenter.y - this.GridHeight / 2,
            this.GridWidth,
            this.GridHeight);
        foreach (GameObject obstacle in this.obstacleList)
        {
            BoxCollider collider = obstacle.GetComponent<BoxCollider>();
            if (collider != null)
            {
                Rect colliderRect = new Rect(
                    obstacle.transform.position.x - collider.size.x / 2,
                    obstacle.transform.position.y - collider.size.y / 2,
                    collider.size.x,
                    collider.size.y);
                if (this.RectIntersect(gridRect, colliderRect))
                {
                    return false;
                }
            }
        }
        return true;
    }

    private List<int> GetNeighborsById ( int gridId )
    {
        List<int> neighbors = new List<int>();
        int rowId;
        int columnId = this.GetRowAndColumnById(gridId, out rowId);
        int tempId = this.GetGridIdByRowAndColumn(rowId - 1, columnId);
        if (tempId != -1)
        {
            neighbors.Add(tempId);
        }
        tempId = this.GetGridIdByRowAndColumn(rowId + 1, columnId);
        if (tempId != -1)
        {
            neighbors.Add(tempId);
        }
        tempId = this.GetGridIdByRowAndColumn(rowId, columnId - 1);
        if (tempId != -1)
        {
            neighbors.Add(tempId);
        }
        tempId = this.GetGridIdByRowAndColumn(rowId, columnId + 1);
        if (tempId != -1)
        {
            neighbors.Add(tempId);
        }
        tempId = this.GetGridIdByRowAndColumn(rowId - 1, columnId - 1);
        if (tempId != -1)
        {
            neighbors.Add(tempId);
        }
        tempId = this.GetGridIdByRowAndColumn(rowId - 1, columnId + 1);
        if (tempId != -1)
        {
            neighbors.Add(tempId);
        }
        tempId = this.GetGridIdByRowAndColumn(rowId + 1, columnId - 1);
        if (tempId != -1)
        {
            neighbors.Add(tempId);
        }
        tempId = this.GetGridIdByRowAndColumn(rowId + 1, columnId + 1);
        if (tempId != -1)
        {
            neighbors.Add(tempId);
        }
        return neighbors;
    }

    private int GetRowAndColumnById ( int gridId, out int row )
    {
        row = gridId / this.GetColumnCount();
        return gridId % this.GetColumnCount();
    }

    private int GetRowCount ()
    {
        return Screen.height / this.GridHeight;
    }

    private void Init ()
    {
        this.GridHeight = 20;
        this.GridWidth = 20;
        //Get Colliders
        this.obstacleList = new List<GameObject>(GameObject.FindGameObjectsWithTag("Obstacle"));
        //Init Grids
        this.gridDictionary = new Dictionary<int, VGrid>();
        int rowCount = this.GetRowCount();
        int columnCount = this.GetColumnCount();
        int totalGridCount = rowCount * columnCount;
        for (int i = 0; i < totalGridCount; i++)
        {
            VGrid grid = new VGrid();
            grid.GridId = i;
            grid.Center = this.GetGridCenterById(i);
            grid.FValue = 0;
            grid.GValue = 0;
            grid.HValue = 0;
            grid.ParentGridId = -1;
            grid.IsAvailable = this.GetIsAvailableById(i);
            grid.NeighborsId = this.GetNeighborsById(i);
            this.gridDictionary.Add(i, grid);
        }
        this.openList = new List<VGrid>();
        this.closedList = new List<VGrid>();
    }

    private bool RectIntersect ( Rect rect1, Rect rect2 )
    {
        if (rect1.xMax < rect2.xMin)
        {
            return false;
        }
        if (rect1.xMin > rect2.xMax)
        {
            return false;
        }
        if (rect1.yMax < rect2.yMin)
        {
            return false;
        }
        if (rect1.yMin > rect2.yMax)
        {
            return false;
        }
        return true;
    }

    private void Awake ()
    {
        this.Init();
        watch = new Stopwatch();
    }

    private void Test ( int startGridId, int endGridId )
    {
        int count = 0;
        while (true)
        {
            count++;
            if (this.openList.Count == 0)
            {
                Debug.Log("OpenList is Null");
                break;
            }
            this.openList.Sort(( grid1, grid2 ) => grid1.FValue.CompareTo(grid2.FValue));
            VGrid selectedGrid = this.openList[0];

            this.openList.Remove(selectedGrid);
            this.closedList.Add(selectedGrid);
            if (this.closedList.Contains(this.gridDictionary[endGridId]))
            {
                Debug.Log("closedList contains end");
                watch.Stop();
                Debug.Log("Cost Time " + watch.ElapsedMilliseconds);
                if (this.onPathComplete != null)
                {
                    this.onPathComplete(this.GetPath(endGridId));
                }
                break;
            }
            int selectGridRowId;
            int selectGridColumnId = this.GetRowAndColumnById(selectedGrid.GridId, out selectGridRowId);
            selectedGrid.NeighborsId.ForEach(
                neighborId =>
                {
                    VGrid neighborGrid = this.gridDictionary[neighborId];
                    if (neighborGrid.IsAvailable && !this.closedList.Contains(neighborGrid))
                    {
                        int neighborRowId;
                        int neighborColumnId = this.GetRowAndColumnById(neighborId, out neighborRowId);
                        int incrementG = 10;
                        if (Mathf.Abs(neighborRowId - selectGridRowId) == 1
                                && Mathf.Abs(neighborColumnId - selectGridColumnId) == 1)
                        {
                            incrementG = 14;
                        }
                        if (!this.openList.Contains(neighborGrid))
                        {
                            neighborGrid.ParentGridId = selectedGrid.GridId;
                            neighborGrid.GValue = selectedGrid.GValue + incrementG + incrementG;
                            neighborGrid.HValue = this.GetHValue(neighborId, endGridId);
                            this.openList.Add(neighborGrid);
                        }
                        else
                        {
                            if (neighborGrid.GValue > selectedGrid.GValue + incrementG)
                            {
                                neighborGrid.ParentGridId = selectedGrid.GridId;
                                neighborGrid.GValue = selectedGrid.GValue + incrementG;
                            }
                        }
                        neighborGrid.CalculateF();
                    }
                });
        }
        //for (int i = this.closedList.Count - 1; i >= 0; i --)
        //{
        //    VGrid grid = this.closedList[i];
        //    GameObject wayPoint = (GameObject)Instantiate(Resources.Load("WayPoint"));
        //    wayPoint.transform.localPosition = grid.Center;
        //    wayPoint.transform.localScale = new Vector3(100, 100, 1);
        //}
        this.DrawPoints(endGridId);
    }

    private void DrawPoints ( int gridId )
    {
        VGrid grid = this.gridDictionary[gridId];
        GameObject wayPoint = (GameObject)Instantiate(Resources.Load("WayPoint"));
        wayPoint.transform.localPosition = grid.Center;
        wayPoint.transform.localScale = new Vector3(100, 100, 1);
        if (grid.ParentGridId != -1)
        {
            this.DrawPoints(grid.ParentGridId);
        }
        else
        {
            return;
        }
    }

    private List<Vector3> GetPath ( int endGridId )
    {
        List<Vector3> posList = new List<Vector3>();
        int tempGridId = endGridId;
        while (true)
        {
            VGrid grid = this.gridDictionary[tempGridId];
            posList.Add(grid.Center);
            if (grid.ParentGridId != -1)
            {
                tempGridId = grid.ParentGridId;
            }
            else
            {
                break;
            }
        }
        posList.Reverse();
        return posList;
    }

    public class VGrid
    {
        #region Public Properties

        public int FValue { get; set; }

        public int GValue { get; set; }

        public int GridId { get; set; }

        public int HValue { get; set; }

        public int ParentGridId { get; set; }

        public bool IsAvailable { get; set; }

        public List<int> NeighborsId { get; set; }

        public Vector3 Center { get; set; }

        #endregion

        #region Public Methods and Operators

        public void CalculateF ()
        {
            this.FValue = this.GValue + this.HValue;
        }

        #endregion
    }
    #endregion
}

chenyuan_noc
关注
A* 算法（示例程序+源码）（C#版）
05-30
这是一再游戏中很著名的寻路算法，是基于曼哈顿的算法的A*算法！
A*算法的C#实现
weixin_34240520的博客
10-22 251
     在游戏开发中，AI的最基本问题之一就是寻路算法或称路径规划算法，在三年前，我曾实现过基于“图算法”的最短路径规划算法，然而在游戏中，我们通常将地图抽象为有单元格构成的矩形，如：           （本图源于这里）      这个微型地图由3*3的单元格构成，当然，实际游戏中的地图通常比它大很多，这里只是给出一个示例。      由于游戏地图通常由单元格构成，所以，基于“图算法”的...
深入理解基于C#的A*路径规划算法实例
最新发布
weixin_35671843的博客
05-02 1043
A算法是一种广泛应用于计算机科学和信息技术领域的路径搜索算法。它特别适合解决从起点到终点的最短路径问题。A算法的优势在于能够智能地考虑当前已知信息，并预计所需代价，以达到最优搜索效率。估价函数通常定义为，其中n是当前节点。g(n)是从起点到当前节点的实际代价，而h(n)是当前节点到目标节点的估计代价。这个函数的重要之处在于它为搜索树的构建提供了指导，确保了算法的快速收敛。C4框架是一个现代的、模块化的、用于构建基于Web的复杂系统的框架。
A*算法 C#源代码
12-23
此为用C#写的A*算法源代码 using System; using System.Collections.Generic; using System.Text; using System.Drawing; namespace EtSoft.AStarLib { public class AStar { private StarNodeCollection openList = new StarNodeCollection(); private StarNodeCollection closeList = new StarNodeCollection(); public StarNode currentNode = null; #region 构造函数 /// <summary> /// 使用指定的地图对象、起点和终点初始化A星算法 /// </summary> /// <param name="map">地图对象</param> public AStar(Map map) { this.map = map; } /// <summary> /// /// </summary> /// <param name="map">地图对象</param> /// <param name="start">起点坐标</param> /// <param name="end">终点坐标</param> public AStar(Map map, Point start, Point end) : this(map) { this.start = new StarNode(start); this.end = new StarNode(end); openList.Add(new StarNode(start)); //AddStartNodeToOpenList(this.start); } /// <summary> /// /// </summary> /// <param name="map">地图对象</param> /// <param name="startX">起点X坐标</param> /// <param name="startY">起点Y坐标</param> /// <param name="endX">终点X坐标</param> /// <param name="endY">终点Y坐标</param> public AStar(Map map, int startX, int startY, int endX, int endY) : this(map, new Point(startX, startY), new Point(endX, endY)) { } #endregion #region 属性 protected Map map; /// <summary> /// 地图数据 /// </summary> public Map Map { get { return map; } set { map = value; } } private StarNode start = null; /// <summary> /// 起点坐标，如果没有设置起点，返回null /// </summary> public StarNode Start { get { return start; } set { start = value; openList.Clear(); openList.Add(start); //AddNodeToOpenList(start); } } private StarNode end = null; /// <summary> /// 终点坐标，如果没有设置终点，返回null /// </summary> public StarNode End { get { return end; } set { end = value; } } private StarNodeCollection path; /// <summary> /// 返回路径节点集合，没有路径则返回null /// </summary> public StarNodeCollection Path { get { return path; } } private bool allDirection = false; /// <summary> /// true，允许八方向寻路 /// </summary> public bool AllDirection { get { return allDirection; } set { allDirection = value; } } #endregion /// <summary> /// 开始寻路 /// </summary> public void StartSearchPath() { if (start == null) throw new InvalidNodeException(InvalidNodeTypes.NoStart); if (end == null) throw new InvalidNodeException(InvalidNodeTypes.NoEnd); path = null; openList.Clear(); closeList.Clear(); currentNode = start; SearchPath(currentNode); } //寻路递归，受保护的虚方法，允许在子类重写寻路算法 protected virtual void SearchPath(StarNode starNode) { //currentNode = starNode; openList.Remove(starNode); closeList.Add(starNode); AddNodeToOpenList(); if (closeList.Contains(end)) { //如果终点在关闭列表中，找到路径 StarNode node=starNode.Parent; path = new StarNodeCollection(); do { path.Add(node); node = node.Parent; } while (node != null && !node.Equals(start)); path.Reverse(); return; } else if (openList.Count == 0) { //终点不在关闭列表，开放列表已空，没有可通行的路径 return; } currentNode = GetNextNode(); //迭代过程 SearchPath(currentNode); } /// <summary> /// 获得当前节点的下一个最佳节点 /// </summary> /// <returns></returns> public StarNode GetNextNode() { openList.SortByF(); return openList[0]; } /// <summary> /// 把当前点周围可通过的点加入到开放列表中 /// </summary>
C# A*算法实现8数或者15数问题
aome1470的博客
03-24 146
－、问题描述 8数或15数问题是同一个问题，其就是一个随机排列的8个或15个数在一个方正格子中移动到达规定的一个目标状态。由于只有一个空格子，故只有在空格附近的棋子可以移动。 二、算法描述 F 算法选择 此问题需要对所有可能的路径进行穷举，但是由于随着树的高度的加大，其子结点的增加宿舍剧增，所以对所有的子结点进行穷举是不大现实的。而根据当前的状态和目标状态进行对比可以用一个评估函数来评估...
A*算法C#实现
07-27
A*算法，A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近，最终搜索速度越快。代码使用c#语言实现，欢迎下载
C#实现Unity寻路A*算法教程
4. C#实现： - 类和结构：资源可能包含多个类和结构体来组织代码，例如表示节点、网格、路径等。 - 高效编码：C#语言的特性如委托、lambda表达式、LINQ等在实现A*算法时能够提高代码的效率和可读性。 - Unity API...
A星算法简单实现（附源码）
03-22
A星算法简单的实现，分别使用C#、Python、JavaScript三种语言实现，通过界面10x10方格展示算法过程 思路参考于：https://blog.youkuaiyun.com/zhanghow/article/details/53585286
C#中 城市线路图的纯算法以及附带求极权值
09-05
本文主要讨论的是如何在C#中实现城市线路图的纯算法，并附带求解极权值的问题，即找到具有最大或最小权值的路径。 首先，我们需要理解城市线路图的基本概念。在图论中，一个图是由顶点（城市）和边（线路）组成，边...
C#非遍历树实现ID3算法教程
C#实现ID3算法时，若要采用非遍历树的方式来构建决策树，意味着我们将不会使用递归的方式来构建树结构。通常情况下，递归方式构建决策树非常直观，但递归深度过大时容易导致栈溢出。而非遍历方式，即使用循环结构来...
纯C语言实现的改进暗通道图像去雾算法测试程序，内含大量测试图片，速度可以达到10几帧
08-11
标题中的“纯C语言实现的改进暗通道图像去雾算法测试程序”涉及到的是计算机视觉领域的一个重要技术——图像去雾，以及它在C语言环境下的实现。图像去雾，也称为图像雾化去除或大气散射校正，是用于提高低能见度环境...
C#写的A*算法
07-04
C#写的A*算法，支持4发现和八方向，可以选择性绕过斜角。内有详细注释！
C#实现的A*算法代码
04-18
C#实现的A*算法，C#项目，VS2005编译通过
A*算法的迷宫演示（C#实现）
03-03
A*算法的迷宫演示（C#实现），含有详尽代码以及注释
A*算法c#.net
11-11
1. 把起点加入 open list (优先级队列)。 2. 重复如下过程： a. 遍历 open list ，查找 F 值最小的节点，把它作为当前要处理的节点。 b. 把这个节点移到 close list 。 c. 对当前方格的 8 个相邻方格的每一个方格？ ◆ 如果它是不可抵达的或者它在 close list 中，忽略它。否则，做如下操作。 ◆ 如果它不在 open list 中，把它加入 open list ，并且把当前方格设置为它的父亲，记录该方格的 F ， G 和 H 值。
C# A*算法
無限進步的全棧遊戲開發的博客
04-24 2389
A*算法是一种广泛使用的路径搜索算法，通常用于寻找在给定地图或图形中，起点到目标点之间的最短路径。它是一种基于贪心策略的启发式搜索算法，可以在大多数情况下找到最短路径。
A*算法--C#版
Less Is More
03-25 1834
C#版本A*算法实现过程中的一些注意事项。
C#实现A*算法
热门推荐
believe_s的博客
03-26 1万+
理解A*寻路算法具体过程 这两天研究了下 A* 寻路算法, 主要学习了这篇文章, 但这篇翻译得不是很好, 我花了很久才看明白文章中的各种指代. 特写此篇博客用来总结, 并写了寻路算法的代码, 觉得有用的同学可以看看. 另外因为图片制作起来比较麻烦, 所以我用的是原文里的图片. 当然寻路算法不止 A* 这一种, 还有递归, 非递归, 广度优先, 深度优先, 使用堆栈等等, 有兴趣的可以研究研究...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值