A*寻路算法分析与实践

已于 2023-03-07 11:02:09 修改
阅读量141 收藏
点赞数
分类专栏： 算法 Unity C# 文章标签： c# 开发语言 算法
于 2022-03-02 14:00:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangliff/article/details/123226607
版权
Unity 同时被 3 个专栏收录
6 篇文章 0 订阅
订阅专栏
算法
4 篇文章 0 订阅
订阅专栏
C#
4 篇文章 0 订阅
订阅专栏
本文详细介绍了A*寻路算法的主体实现，包括关键步骤如开放列表、关闭列表、节点评估函数等。代码示例展示了如何在Unity中使用A*寻路寻找两点之间的最短路径，并提供了三种不同的距离估算公式：欧式距离、曼哈顿距离和对角距离，以适应不同场景需求。此外，还提供了寻路测试和地图绘制功能，便于理解和调试。
摘要由CSDN通过智能技术生成

A*寻路主体思路

在这里插入图片描述

A*寻路代码实现

不同的距离估算公式会导致结果的细微差别

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace AStar
{
    public class Astar : Singleton<Astar>
    {
        private Astar() { }
        //方向数组
        int[,] dir = new int[4, 2] { { 0, 1 }, { 0, -1 }, { 1, 0 }, { -1, 0 } };
        /// <summary>
        /// 寻路主体
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <param name="map"></param>
        /// <returns></returns>
        public bool FindPath(Point start, Point end, Point[,] map)
        {
            if (start == null || end == null || map == null)
            {
                return false;
            }
            LinkedList<Point> openList = new LinkedList<Point>();
            LinkedList<Point> closeList = new LinkedList<Point>();
            openList.AddLast(start);
            while (openList.Count > 0)
            {
                Point point = FindMinFOfPoint(openList);
                openList.Remove(point);
                closeList.AddLast(point);
                LinkedList<Point> roundPointList = GetRoundPoint(point, map, closeList);
                foreach (Point item in roundPointList)
                {
                    if (openList.Contains(item))
                    {
                        float nowG = CalcG(item, point);
                        if (nowG < item.G)
                        {
                            item.Update(point, nowG);
                        }
                    }
                    else
                    {
                        item.parent = point;
                        CalcF(item, end);
                        openList.AddLast(item);
                    }
                    if (item == end)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
        /// <summary>
        /// 获取F值最小的节点
        /// </summary>
        /// <param name="openList"></param>
        /// <returns></returns>
        Point FindMinFOfPoint(LinkedList<Point> openList)
        {
            float f = float.MaxValue;
            Point tmp = null;
            foreach (Point p in openList)
            {
                if (p.F < f)
                {
                    tmp = p;
                    f = p.F;
                }
            }
            return tmp;
        }
        /// <summary>
        /// 获取相邻节点
        /// </summary>
        /// <param name="p"></param>
        /// <param name="map"></param>
        /// <param name="closeList"></param>
        /// <returns></returns>
        LinkedList<Point> GetRoundPoint(Point p, Point[,] map, LinkedList<Point> closeList)
        {
            LinkedList<Point> ret = new LinkedList<Point>();
            bool[] book = new bool[4];
            int mapLen = map.GetLength(0);
            int mapWid = map.GetLength(1);
            for (int i = 0; i < 4; i++)
            {
                int x = p.x + dir[i, 0];
                int y = p.y + dir[i, 1];
                if (x >= 0 && x < mapLen && y >= 0 && y < mapWid && !map[x, y].isWall)
                {
                    ret.AddLast(map[x, y]);
                    book[i] = true;
                }
            }
            for (int i = 0; i < 2; i++)
            {
                for (int j = 2; j < 4; j++)
                {
                    int x = p.x + dir[i, 0] + dir[j, 0];
                    int y = p.y + dir[i, 1] + dir[j, 1];
                    if (book[i] && book[j] && x >= 0 && x < mapLen && y >= 0 && y < mapWid && !map[x, y].isWall)
                    {
                        ret.AddLast(map[x, y]);
                    }
                }
            }
            foreach (var item in closeList)
            {
                if (ret.Contains(item))
                {
                    ret.Remove(item);
                }
            }
            return ret;
        }

        /// <summary>
        /// 计算G值
        /// </summary>
        /// <param name="now"></param>
        /// <param name="parent"></param>
        /// <returns></returns>
        float CalcG(Point now, Point parent)
        {
            return GetDistance(now, parent) + parent.G;
        }
        /// <summary>
        /// 计算F值
        /// </summary>
        /// <param name="now"></param>
        /// <param name="end"></param>
        void CalcF(Point now, Point end)
        {
            float h = GetDistance_MHD(now, end);
            float g = 0;
            if (now.parent != null)
            {
                g = CalcG(now,now.parent);
            }
            float f = g + h;
            now.F = f;
            now.G = g;
            now.H = h;
        }

        /// <summary>
        /// 欧式距离
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        float GetDistance(Point a, Point b)
        {
            return Vector2.Distance(new Vector2(a.x, a.y), new Vector2(b.x, b.y));
        }

        /// <summary>
        /// 曼哈顿距离
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        float GetDistance_MHD(Point a, Point b)
        {
            return Mathf.Abs(a.x - b.x) + Mathf.Abs(a.y - b.y);
        }

        /// <summary>
        /// 对角距离
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        float GetDistance_DJ(Point a, Point b)
        {
            float dx = Mathf.Abs(a.x - b.x);
            float dy = Mathf.Abs(a.y - b.y);
            return dx + dy + (Mathf.Sqrt(2) - 2) * Mathf.Min(dx, dy);
        }
    }
}

测试寻路

Point

public class Point
    {
        public Point parent;
        public float F;
        public float G;
        public float H;
        public int x;
        public int y;
        public bool isWall;
        public GameObject go;
        public Point(int x, int y, GameObject go = null, Point parent = null)
        {
            this.go = go;
            this.x = x;
            this.y = y;
            this.parent = parent;
        }
        public void Update(Point parent, float g)
        {
            this.parent = parent;
            G = g;
            F = G + H;
        }
    }

AStarTest

public class AstarTest : MonoBehaviour
{
    public RectTransform map;
    //格子的长宽
    public int ceilWidth = 20;
    public int ceilHeight = 20;
    //格子间隔
    public int margin = 2;
    //横排格子数
    public int xNum = 20;
    //竖排格子数
    public int yNum = 20;
    public Button drawBtn;
    Point[,] mapData;
    Point star;
    Point end;
    Coroutine co;
    //模拟玩家
    GameObject player;
    //初始化
    void Start()
    {
        player = new GameObject("Player");
        player.AddComponent<RectTransform>().sizeDelta = new Vector2(20, 20);
        player.AddComponent<Image>().color = Color.blue;
        player.SetActive(false);
        player.transform.SetParent(map.transform.parent);
        int mapx = (ceilWidth + margin) * xNum + 10;
        int mapy = (ceilWidth + margin) * yNum + 10;
        map.sizeDelta = new Vector2(mapx, mapy);
        var grid = map.gameObject.AddComponent<GridLayoutGroup>();
        grid.cellSize = new Vector2(ceilWidth, ceilHeight);
        grid.spacing = new Vector2(margin, margin);
        mapData = new Point[yNum, xNum];
        for (int i = 0; i < yNum; i++)
        {
            for (int j = 0; j < xNum; j++)
            {
                GameObject go = new GameObject();
                go.AddComponent<RectTransform>();
                go.AddComponent<Image>();
                var btm = go.AddComponent<ButtonPointManager>();
                go.transform.SetParent(map.transform);
                Point point = new Point(i, j, go);
                mapData[i, j] = point;
                btm.leftClick.AddListener(() =>
                {
                    if (point.isWall) return;
                    point.go.GetComponent<Image>().color = Color.green;
                    if (co != null) StopCoroutine(co);
                    ClearRoad();
                    if (star != null)
                    {
                        star.go.GetComponent<Image>().color = Color.white;
                    }
                    star = point;
                    co = StartCoroutine(MovePath());
                });
                btm.rightClick.AddListener(() =>
                {
                    if (point.isWall) return;
                    point.go.GetComponent<Image>().color = Color.red;
                    if (co != null) StopCoroutine(co);
                    ClearRoad();
                    if (end != null)
                    {
                        end.go.GetComponent<Image>().color = Color.white;
                    }
                    end = point;
                    co = StartCoroutine(MovePath());
                });
                btm.middleClick.AddListener(() =>
                {
                    if (point != end && point != star)
                    {
                        point.isWall = !point.isWall;
                        point.go.GetComponent<Image>().color = point.isWall ? Color.black : Color.white;
                    }
                });
            }
        }
        DrawMap();
        if (drawBtn != null)
        {
            drawBtn.onClick.AddListener(() =>
            {
                DrawMap();
            });
        }
    }
    //清空痕迹
    void ClearRoad()
    {
        if (star != null && end != null)
        {
            Point temp = end.parent;
            while (temp != null)
            {
                if (temp == star) return;
                temp.go.GetComponent<Image>().color = Color.white;
                temp = temp.parent;
            }
        }
    }
    //根据路径移动
    IEnumerator MovePath()
    {
        List<Point> points = new List<Point>();
        Point x1 = star, x2 = end;
        while (x1 != null && x2 != null && x1 != x2 && Astar.Instance.FindPath(x1, x2, mapData))
        {
            player.transform.position = x1.go.transform.position;
            player.SetActive(true);
            Point temp = x2;
            while (temp != null)
            {
                points.Add(temp);
                temp = temp.parent;
                if (temp == x1) break;
            }
            points.Reverse();
            foreach (Point item in points)
            {
                //无法通过重新寻路
                if (!Check(x1, item))
                {
                    points.Clear();
                    break;
                }
                StartCoroutine(MoveTrans(player.transform, item.go.transform.position, 0.49f));
                yield return new WaitForSeconds(0.5f);
                x1 = item;
                // 保留痕迹
                if (item != x2)
                {
                    item.go.GetComponent<Image>().color = Color.yellow;
                }
            }
        }
        yield return 0;
    }
    // 移动物体
    IEnumerator MoveTrans(Transform trans, Vector3 target, float time)
    {
        float curTime = 0;
        while (true)
        {
            curTime += Time.deltaTime;
            if (curTime >= time) curTime = 1;
            trans.position = Vector3.Lerp(trans.position, target, curTime);
            if (curTime == 1) break;
            yield return 0;
        }
    }
    //绘制地图
    void DrawMap()
    {
        if (co != null) StopCoroutine(co);
        for (int i = 0; i < mapData.GetLength(0); i++)
        {
            for (int j = 0; j < mapData.GetLength(1); j++)
            {
                var point = mapData[i, j];
                point.isWall = Random.Range(0, 100) > 90;
                point.parent = null;
                point.go.GetComponent<Image>().color = point.isWall ? Color.black : Color.white;
            }
        }
    }
    /// <summary>
    /// 检查x1能否到达x2
    /// </summary>
    /// <param name="x1"></param>
    /// <param name="x2"></param>
    /// <returns></returns>
    bool Check(Point x1, Point x2)
    {
        if (x2.isWall) return false;
        int x = x2.x - x1.x;
        int y = x2.y - x1.y;
        if (Mathf.Abs(x) + Mathf.Abs(y) == 2)
        {
            if (mapData[x1.x + x, x1.y].isWall || mapData[x1.x, x1.y + y].isWall) return false;
        }
        return true;
    }
}

寻路演示

请添加图片描述

FanJiangDaoHaizZ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
A星寻路算法案例
04-10
A星寻路算法（A* Search Algorithm）是计算机...通过分析和实践"A星寻路算法案例"，你可以更好地理解和运用这一算法，解决实际问题。记住，实践中遇到的问题和解决方案往往能帮助你深入理解理论知识，并提升编程技能。
【转】A*寻路 -- 弗洛伊德（Floyd）算法
08-12
A*（A-star）寻路算法是一种启发式搜索算法，它的主要目标是在一个带有成本的图中找到从起点到终点的最短路径。A*算法结合了Dijkstra算法的最优化特性以及最佳优先搜索的效率，通过使用一个评估函数来预测从当前节点...
寻路算法——A*算法详解并附带实现代码
热门推荐
行走
06-13 4万+
一、前言 之前在做rpg游戏的时候实体移动用的是A*算法，那时候没有去研究A*算法原理，前天看了一篇博客介绍A*算法，按照自己的理解记录一下A*算法。 参考：https://blog.csdn.net/nie2314550441/article/details/106673966 https://zhuanlan.zhihu.com/p/23199073 二、应用场景 一副地图中有坐标A和B，需要找到一条路径（如果有的话）能从A到B，地图中可能有河流或墙壁不能直接穿过，我们需要怎样找到这条路.
【A星算法】A星A*寻路算法详解（小白一看就懂+C#代码+零基础学习A*）
qq_58047420的博客
06-06 7131
【A星算法】A星A*寻路算法详解（小白一看就懂+C#代码+零基础学习A*）
【路径规划】全局路径规划算法——A*算法（含python实现 | c++实现）
weixin_42301220的博客
06-06 3万+
A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。广泛应用于室内机器人路径搜索、游戏动画路径搜索等A*算法结合了贪心算法（深度优先）和Dijkstra算法（广度优先），是一种启发式搜索算法。它使用一个路径优劣评价公式为： f(n)=g(n)+h(n) f(n)=g(n)+h(n) f(n)=g(n)+h(n)A*算法需要维护两个状态表，分别称为表和表。表由待考察的节点组成， 表由已经考察过的节点组成。如图，假设我们需要从点到目标点，这两点之间有一堵墙。
实用高效的寻路算法——A*寻路算法的实现及优化思路
woliuqiangdong的博客
09-18 4814
https://www.fgba.net/sitemap.xml
自动驾驶路径规划——A*（Astar）算法
sinat_52032317的博客
10-03 2万+
      1968年发明的A*算法就是把启发式方法（heuristic approaches）如BFS，和常规方法如Dijsktra算法结合在一起的算法。      A-Star算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。
广度优先算法、最佳优先算法、A*算法寻路程序
06-21
这对于学习者来说是一个很好的实践工具，帮助他们深入理解这些算法的工作原理，提升编程和算法分析能力。在压缩包中的"FindWays"可能包含了源代码、数据文件以及执行程序，使用者可以通过运行和调试代码，进一步探究...
Snake:一个简单的Snake游戏，可以通过A *寻路算法自动进行选择
05-08
它利用了A*（A-Star）寻路算法来帮助蛇自动移动，这使得游戏不仅具有娱乐性，还融入了算法的实践应用。 【描述】：这个Snake游戏的亮点在于其自动化决策过程。通常的Snake游戏，玩家需要通过手动操作控制蛇的方向，...
cocos creator 实现A*寻路
01-24
具体代码分析和学习将帮助你深入理解A*寻路算法在Cocos Creator中的应用。 总之，A*寻路算法在Cocos Creator中的实现涉及到JavaScript编程、启发式函数设计、数据结构的使用，以及游戏引擎的组件系统。通过实践和...
关于搜索策略实验的A*算法实验报告
01-14
一个基于采用A*算法实现搜索策略实验的报告，大家可以看看，参考一下
A星寻路算法
03-08
在游戏中，有一个很常见地需求，就是要让一个角色从A点走向B点，我们期望是让角色走最少的路。嗯，大家可能会说，直线就是最短的。没错，但大多数时候，A到B中间都会出现一些角色无法穿越的东西，比如墙、坑等障碍物。这个时候怎么办呢？ 是的，我们需要有一个算法来解决这个问题，算法的目标就是计算出两点之间的最短路径，而且要能避开障碍物。
A*寻路算法实现MATLAB代码
10-14
本人经过学习A*寻路算法，使用MATLAB进行编程实现，现通过分享给大家进行交流学习。
A* 算法研究（附 Python / C++ 实现）
最新发布
Solititude的博客
06-28 2564
对 A* 算法的原理进行较为详细的讲解，并给出 Python 和 C++ 的实现
A星寻路算法详解（C++实现 完整代码+图片演示 ）
ylh的博客
08-11 1万+
A星寻路算法 最小代价点，入树，保存容器，当前点移动到最小代价的点，删除最小代价点，以当前点的位置和终点比较来看是否到达了终点。地图行列数，方向枚举，地图，辅助地图的设计等在此不描述，具体请看之前我写的前两种寻路算法的博客。（如何计算：数格子即可，某个点到终点的格子数，只能行列，不能斜着），此代价为。，用于判断地图某个点是否能走，即不为墙，没越界，没走过，则能走。（即是代价最小点，但是这个点是死胡同），...
【算法入门】A* 寻路算法具体过程及实现
summer
08-01 1万+
http://www.360doc.com/content/16/1201/12/99071_610999046.shtml http://blog.csdn.net/booirror/article/details/50834915 http://www.cnblogs.com/technology/archive/2011/05/26/2058842.html
A*算法原理与实现
weixin_50431732的博客
04-29 7688
A*算法原理与实现
关于A*寻路算法的实现
qq_38223336的博客
03-27 161
关于A*寻路算法的总结 具体的原理简介可以参考以下帖子，该帖子讲的十分清楚 原文连接 由于原文的代码已经失效，所以自己动手写了cpp代码，带有详细注释 代码结构如下 具体的程序代码如下： star.h头文件 简要说明：star是一个表示某个结点的类 #ifndef STAR_H #define STAR_H class star//每个结点 { public: star(int x, int y, int G, int H); int x;//坐标点范围0 - m-1 int y
游戏人工智能之A *寻路算法(适合初学者)
胖胖的橘猫君
02-22 1万+
引言：小生今日分享的是寻路系统中常用的A*寻路算法，在此特别感谢Siki学院的老师们。如果大神发现错误，请评论告知！再次感谢！开发版本：unity 2017.1.1f1适合人群：Unity有一定基础的童鞋开启学习之旅吧！寻路：寻找最短路径并避开障碍物首先将地图虚拟化，将地图划分为一个一个的小方块，这样可以用二维数组来表示地图。如下所示，绿色块(A)是起点，红色块(B)是终点，中间蓝色块是障碍物，白...
智能算法与应用探索：A*寻路与接纳采样
这份智能英文文献涵盖了人工智能中的核心算法、模拟策略以及经济与系统分析的关键概念，对于理解和应用智能技术具有很高的参考价值。深入研究这些内容将有助于提升在智能系统设计和优化方面的专业知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值