A星算法设计（在unity中编写）

最新推荐文章于 2022-08-22 23:29:11 发布
最新推荐文章于 2022-08-22 23:29:11 发布
阅读量836 收藏 3
点赞数
分类专栏： 算法 文章标签： 游戏开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32354205/article/details/117323606
版权

这里写目录标题

前述

地图：

在这里插入图片描述

寻路步骤：

在这里插入图片描述

公式：

在这里插入图片描述

实现代码：

实现代码：

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

public class AStar : MonoBehaviour
{
    const int mapWidth = 8;
    const int mapHeight = 6;
    private Point[,] map = new Point[mapWidth, mapHeight];
    void Start()
    {
        InitMap();
        Point start = map[2, 3];
        Point end = map[6, 3];
        FindPath(start, end);
        ShowPath(start, end);
        GetArroundPoints(map[3, 3]);
    }

    private void ShowPath(Point start, Point end)
    {
        Point tempPoint = end;
        while(true)
        {
            Debug.Log("temp.X:" + tempPoint.X + "temp.Y:" + tempPoint.Y);
            tempPoint = tempPoint.parent;
            if(tempPoint == null)
            {
                return;
            }
        }
    }

    private void InitMap()
    {
        for(int x=0;x< mapWidth;x++)
        {
            for(int y=0;y<mapHeight;y++)
            {
                map[x, y] = new Point(x, y);
            }
        }

        map[4, 2].IsWall = true;
        map[4, 3].IsWall = true;
        map[4, 4].IsWall = true;
    }

    private void FindPath(Point start,Point end)
    {
        List<Point> openList = new List<Point>();
        List<Point> closeList = new List<Point>();
        openList.Add(start);
        while(openList.Count> 0 )
        {
            Point p = FindMinFofPoint(openList);
            openList.Remove(p);
            closeList.Add(p);
            List<Point> arroundPoints = GetArroundPoints(p);
            PointsFilter(arroundPoints, closeList);
            foreach (Point arroundPoint in arroundPoints)
            {
                if(openList.IndexOf(arroundPoint)> -1)
                {
                    float nowG = CalcG(arroundPoint, p);
                    if (nowG < arroundPoint.G)
                    {
                        arroundPoint.UpdateParent(p, nowG);
                    }
                }
                else //不在开启列表中
                {
                    arroundPoint.parent = p;
                    CalcF(arroundPoint, end);
                    openList.Add(arroundPoint);
                }
            }

            //判断终止
            if(openList.IndexOf(end)> -1)
            {
                return;
            }
        }
    }
    private void PointsFilter(List<Point> src,List<Point> closeList)
    {
        foreach(Point p in closeList)
        {
            if(src.IndexOf(p) > -1)
            {
                src.Remove(p);
            }
        }
    }
    private Point FindMinFofPoint(List<Point> openList)
    {
        float f = float.MaxValue;
        Point tempP = null;
        foreach(Point p in openList)
        {
            if(p.F < f)
            {
                tempP = p;
                f = p.F;
            }
        }
        return tempP;
    }

    private List<Point> GetArroundPoints(Point point)
    {
        Point up = null, down = null, left = null, right = null;
        Point lu = null, ru = null, ld = null, rd = null;
        if (point.Y < mapHeight - 1)
        {
            up = map[point.X, point.Y + 1];
        }
        if (point.Y > 0)
        {
            down = map[point.X, point.Y - 1];
        }
        if (point.X > 0)
        {
            left = map[point.X - 1, point.Y];
        }
        if (point.X < mapWidth - 1)
        {
            right = map[point.X + 1, point.Y];
        }
        if (up != null && left != null)
        {
            lu = map[point.X - 1, point.Y + 1];
        }
        if (up != null && right != null)
        {
            ru = map[point.X + 1, point.Y + 1];
        }
        if (down != null && left != null)
        {
            ld = map[point.X - 1, point.Y - 1];
        }
        if (down != null && right != null)
        {
            rd = map[point.X + 1, point.Y - 1];
        }
        List<Point> list = new List<Point>();
        if (down != null && down.IsWall == false)
        {
            list.Add(down);
        }
        if (up != null && up.IsWall == false)
        {
            list.Add(up);
        }
        if (left != null && left.IsWall == false)
        {
            list.Add(left);
        }
        if (right != null && right.IsWall == false)
        {
            list.Add(right);
        }
        if (lu != null && lu.IsWall == false && left.IsWall == false && up.IsWall == false)
        {
            list.Add(lu);
        }
        if (ld != null && ld.IsWall == false && left.IsWall == false && down.IsWall == false)
        {
            list.Add(ld);
        }
        if (ru != null && ru.IsWall == false && right.IsWall == false && up.IsWall == false)
        {
            list.Add(ru);
        }
        if (rd != null && rd.IsWall == false && right.IsWall == false && down.IsWall == false)
        {
            list.Add(rd);
        }
        return list;
    }

    private float CalcG(Point now, Point parent)
    {
       return Vector2.Distance(new Vector2(now.X, now.Y), new Vector2(parent.X, parent.Y)) + parent.G;
    }

    private void CalcF(Point now, Point end)
    {
        //F = G + H
        float h = Mathf.Abs(now.X - end.X) + Mathf.Abs(now.Y - end.Y);
        float g = 0;
        if(now.parent == null)
        {
            g = 0;
        }
        else
        {
            g = Vector2.Distance(new Vector2(now.X, now.Y), new Vector2(now.parent.X, now.parent.Y)) + now.parent.G;
        }
        float f = g + h;
        now.F = f;
        now.G = g;
        now.H = h;
    }

}

顶点定义脚本：

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

public class Point
{
    public Point parent { get; set; }
    public float F { get; set; }
    public float G { get; set; }
    public float H { get; set; }

    public int X { get; set; }
    public int Y { get; set; }

    public bool IsWall { get; set; }

    public Point(int x, int y, Point parent = null)
    {
        this.X = x;
        this.Y = y;
        this.parent = parent;
        IsWall = false;
    }

    public void UpdateParent(Point parent,float g)
    {
        this.parent = parent;
        this.G = g;
        F = G + H;
    }

}

代码详解：

AStar

1.把地图小方块转换成Point方式便于计算
 const int mapWidth = 8;
    const int mapHeight = 6;
    private Point[,] map = new Point[mapWidth, mapHeight];
2.初始化地图 InitMap()
private void InitMap()
    {
        for(int x=0;x< mapWidth;x++)
        {
            for(int y=0;y<mapHeight;y++)
            {
                map[x, y] = new Point(x, y);
            }
        }

        map[4, 2].IsWall = true;
        map[4, 3].IsWall = true;
        map[4, 4].IsWall = true;
    }

把那些是墙的地方赋值上去

3.查找寻路路径 FindPath(start, end)
思路：

分两个列表 开启列表和关闭列表，如前面步骤所述就不再描述了，

  1. 先从开启列表中找一个F最小的点，也就是最近的点，通过方法FindMinFofPoint 找到p
  2. 把p从开启列表中移出去，添加到关闭列表中
  3. 查找p周围可达到点 通过方法GetArroundPoints
  4. 判断周围可达到点 是否在关闭列表中 如果在的话，就排除掉，因为关闭列表的不需要检查
  5. 遍历这些周围可达到点，如果在开启列表中，就看看他需不需要换个爸爸，即到达该点有没有更短的路径
    如果他不在开启列表中(当然也不在关闭列表)，这时要考虑把他加进开启列表,就要计算他的 F,G,H
    每个点的H基本是不变的，就是到end点的横坐标距离加上纵坐标距离的和 因为只能上下左右的移动
  6. 如果关闭点也在开启列表中了，那么就说明我们都计算完了，因为如果在开启列表中了，我们就知道他爸爸是谁了
代码：
private void FindPath(Point start,Point end)
    {
        List<Point> openList = new List<Point>();
        List<Point> closeList = new List<Point>();
        openList.Add(start);
        while(openList.Count> 0 )
        {
            Point p = FindMinFofPoint(openList);
            openList.Remove(p);
            closeList.Add(p);
            List<Point> arroundPoints = GetArroundPoints(p);
            PointsFilter(arroundPoints, closeList);
            foreach (Point arroundPoint in arroundPoints)
            {
                if(openList.IndexOf(arroundPoint)> -1)
                {
                    float nowG = CalcG(arroundPoint, p);
                    if (nowG < arroundPoint.G)
                    {
                        arroundPoint.UpdateParent(p, nowG);
                    }
                }
                else //不在开启列表中
                {
                    arroundPoint.parent = p;
                    CalcF(arroundPoint, end);
                    openList.Add(arroundPoint);
                }
            }

            //判断终止
            if(openList.IndexOf(end)> -1)
            {
                return;
            }
        }
    }
从开启列表中找一个最近的点 FindMinFofPoint

即F最小的点

private Point FindMinFofPoint(List<Point> openList)
    {
        float f = float.MaxValue;
        Point tempP = null;
        foreach(Point p in openList)
        {
            if(p.F < f)
            {
                tempP = p;
                f = p.F;
            }
        }
        return tempP;
    }
寻找P周围的点 GetArroundPoints
private List<Point> GetArroundPoints(Point point)
    {
        Point up = null, down = null, left = null, right = null;
        //左上，右上，左下，右下
        Point lu = null, ru = null, ld = null, rd = null;
        //检查p的上方是否有可达点
        if (point.Y < mapHeight - 1)
        {
            up = map[point.X, point.Y + 1];
        }
        //检查p的下方是否有可达点
        if (point.Y > 0)
        {
            down = map[point.X, point.Y - 1];
        }
        //检查p的左方是否有可达点
        if (point.X > 0)
        {
            left = map[point.X - 1, point.Y];
        }
        //检查p的右方是否有可达点
        if (point.X < mapWidth - 1)
        {
            right = map[point.X + 1, point.Y];
        }
        //检查p的左上方是否有可达点
        if (up != null && left != null)
        {
            lu = map[point.X - 1, point.Y + 1];
        }
        //检查p的右上方是否有可达点
        if (up != null && right != null)
        {
            ru = map[point.X + 1, point.Y + 1];
        }
        //检查p的左上方是否有可达点
        if (down != null && left != null)
        {
            ld = map[point.X - 1, point.Y - 1];
        }
        //检查p的右下方是否有可达点
        if (down != null && right != null)
        {
            rd = map[point.X + 1, point.Y - 1];
        }
        List<Point> list = new List<Point>();
        if (down != null && down.IsWall == false)
        {
            list.Add(down);
        }
        if (up != null && up.IsWall == false)
        {
            list.Add(up);
        }
        if (left != null && left.IsWall == false)
        {
            list.Add(left);
        }
        if (right != null && right.IsWall == false)
        {
            list.Add(right);
        }
        //因为左上方是先左边在上边移动过去的，所以左和上都不能说墙
        if (lu != null && lu.IsWall == false && left.IsWall == false && up.IsWall == false)
        {
            list.Add(lu);
        }
        if (ld != null && ld.IsWall == false && left.IsWall == false && down.IsWall == false)
        {
            list.Add(ld);
        }
        if (ru != null && ru.IsWall == false && right.IsWall == false && up.IsWall == false)
        {
            list.Add(ru);
        }
        if (rd != null && rd.IsWall == false && right.IsWall == false && down.IsWall == false)
        {
            list.Add(rd);
        }
        return list;
    }
关闭列表的点不需要再检查 PointsFilter

所以周围的点如果在关闭列表中 就把这个点移除出去

private void PointsFilter(List<Point> src,List<Point> closeList)
    {
        foreach(Point p in closeList)
        {
            if(src.IndexOf(p) > -1)
            {
                src.Remove(p);
            }
        }
    }
计算当前点的G点 CalcG

因为可以斜着 所以

 private float CalcG(Point now, Point parent)
    {
       return Vector2.Distance(new Vector2(now.X, now.Y), new Vector2(parent.X, parent.Y)) + parent.G;
    }

即从当前点到父亲点距离，然后加上父亲点的G

努力总会有收获
关注
专栏目录
基于Unity的A星寻路算法（绝对简单完整版本）
xinzhilinger的博客
08-12 6650
前言 在上一篇文章，介绍了网格地图的实现方式，基于该文章，我们来实现一个A星寻路的算法,最终实现的效果为： 项目源码已上传Github：AStarNavigate 在阅读本篇文章，如果你对于里面提到的一些关于网格地图的创建方式的一些地图不了解的话，可以先阅读了解一下下面的这篇文章： 文章链接： Unity 制作一个网格地图生成组件 1、简单做一些背景介绍 在介绍A星寻路算法前，先介绍另外一种算法：Dijkstra寻路算法，简单的来说是一种A星寻路的基础版。Dijkstra作为一种无启发的寻路算法，
A星算法unity实现
qq_39756476的博客
12-21 316
using System.Collections; using System.Collections.Generic; using UnityEngine; using System; public class A_Star : MonoBehaviour { private readonly GameObject[,] Map=new GameObject[13,13]; private Mouse mouse ; private Point Player; priv..
Unity 算法 之 A星（A Star/A*）寻路算法实现和封装，并带动态演示Demo
03-08
Unity 算法 之 A星（A Star/A*）寻路算法实现和封装，并带动态演示Demo Demo 使用操作说明 1、按空格可以刷线地图，更新地图的障碍物位置（动态随机设置） 2、鼠标左键设置开始点位置 3、鼠标右键设置目标点位置 4、开始点和目标点都不为空，即会动态绘制路径 寻路原理 1）首先有一张一定宽高的地图 （定义好 Point 点的地图，其中 Point 中有 IsWall 属性） 2）设定开始点，和目标点 3）传入 FindPath 开始寻找较短路径，找到返回true，否则 false 4）为 true 就可以通过 目标点的父亲点的父亲点的父亲点，直到父亲点为开始点，这些点集合即是路径 5）FindPath 寻找原理 （1）开列表，关列表初始化 （2）添加开始点到开列表，然后获得周围点集合，接着又把开始点从开列表中移除，并添加到关列表 （3）判断这些周围点集合是否已经在开列表中，不在则更新这些点的F 和 父亲点，并添加到开列表；再则重新计算G值，G较小则更新GF 和父亲点 （4）从周围点集合中找到 F 最小的点，然后获得周围点集合，接着又把找到 F 最小的点从开列表中移除，并添加到关列表 （5）接着执行第 3） 步骤 （6）直到目标点被添加到开列表中，则路径找到 （7）否则，直到开列表中没有了数据，则说明没有合适路径
[Unity] A-Star(A星)寻路算法
weixin_34150503的博客
04-29 936
在游戏中，有一个很常见地需求，就是要让一个角色从A点走向B点，我们期望是让角色走最少的路。嗯，大家可能会说，直线就是最短的。没错，但大多数时候，A到B中间都会出现一些角色无法穿越的东西，比如墙、坑等障碍物。这个时候怎么办呢？ 是的，我们需要有一个算法来解决这个问题，算法的目标就是计算出两点之间的最短路径，而且要能避开障碍物。 百度百科： A*搜寻算法俗称A星算法。这是一种在图形平面上...
Unity学习笔记--易学易会的unity中A星寻路插件:A*Pathfind Project的使用
qq_42434073的博客
02-07 7622
A寻路看似简单，但实际项目中的各种应用是有一定难度的，需要较强的算法功底，不过，幸运的是，Unity Asset Store中已经有了现成的A寻路插件"A* Pathfinding Project"（作者：Aron Granberg），它有免费版和收费两个版本，不过一般免费版足以让我们使用。 下载链接1：http://arongranberg.com/astar/download 下载链接2：https://download.csdn.net/download/qq_42434073/15116553
[Unity]_A星寻路
—巨人绿
08-27 375
对地图点进行评分的寻路算法，选择评分最优作为下一个行走路径点（一直评一直走走到终点）F总分= G当前节点到开始节点的评分（确定值）+H曼哈顿距离（横格子+竖格子） A星算法并不去遍历整个地图，而是只遍历了最短路径上的点和其周围的点，所以得到的是一种近似最优解。 让玩家控制的角色自动寻路到目标地点，或是让AI角色移动到目标位置，实际的情况可能很复杂，比如地图上有无法通过的障碍或者需要付出代价（时间或其他资源）才能通过的河流、沼泽等，想要让角色找到一条付出最小代价到达目标的路径，就需要使用一些特殊的算法
unity简单的A星算法
02-24
unity简单的A星算法；unity简单的A星算法；unity简单的A星算法
unity3d寻路A星算法
03-07
在Unity3D中，案例可能使用C#编写A*算法，并结合Unity的内置组件如Transform和Rigidbody来实现角色的动态移动。同时，可能会利用Unity的图形化编程工具如Scriptable Objects或者Unity的Inspector窗口来配置和调整...
Unity-A星算法
09-02
A星算法的核心，地形网格的构建以及评估函数的算法，其它都是可以复用的。其实代码是次要的东西，要理解A星算法，建议先去看数学证明，否则看代码一点意义没有，因为看懂了证明，代码会变得非常简单。证明里有个核心点就是，评估函数值<=实际值，可以确保找到最短路径的证明，理解了这个证明，也就理解了A星算法。
遵循路径走，A星寻路算法
10-12
A星算法以其高效性和优化的搜索性能而闻名，可以找到两点之间最短的路径，同时避免障碍物。 A星算法的核心思想是结合了Dijkstra算法的全局最优性和最佳优先搜索的效率。它使用一个评估函数（F-score）来判断节点的...
用Unity实现A星寻路算法
Had的博客
08-08 359
用Unity实现A星寻路算法
利用unity3D实现A星算法（一）
xhugleixin123的博客
11-01 707
A星算法 算法分析 Node的属性 gCost 利用currentNode来来计算 从起点到currentNode再到neighbourNode的距离=gCost hCost 网格到targetNode的距离 fCost fCost = gCost + hCost parent neighbourNode的parent就是使其gCost最短的Node...
Unity之A星算法
m0_61490399的博客
08-22 2976
本文到这里就结束了,大佬们的支持是我们更新的最大动力，希望这篇文章能帮到大家💪个人专栏连接🔗下篇文章再见ヾ(￣▽￣)ByeByeHomePage社区链接🔗专栏连接🔗点击直接阅读文章Unirt~UI简单框架。
A星算法练习——Unity实现
学无止境
05-17 490
GitHub地址
Unity新手适用A星寻路demo，C#实现广度优先
资源摘要信息:"本资源为Unity游戏开发中的A星寻路demo，该demo由作者亲自用C#编写，实现了广度优先搜索和A星算法两种寻路方法。该demo对于新手来说非常友好，易于理解。作者建议读者结合相关文章一起阅读，以便更快...
【Unity】A星寻路算法 + Demo示例
qq_42404497的博客
07-16 827
A寻路算法的估量代价* 在A算法中核心的寻路依据就是估量代价，在A中通常用 F 表示。 F = G + H 其中G表示当前点到起始点的估量代价 ，H表示当前点到终点的代价。 G的计算方式： 最开始，以起点为中心开始计算周边的八个格子，然后在以这算出来的八个格子为中心，继续计算他们周围的八个格子的G值。 以此类推，直到找到终端，或遍历完所有的格子。 G值的计算结果为：中心点的G值+距离值【10 or 14】 A*算法步骤 1.设置开放列表OpenList和关闭列表CloseList 2.将起点放置到OpenL
unity3d中A星寻路
09-08
A星寻路在游戏中是一个很好的工具，此文档说明A星寻路的原理以及用法
Unity A*插件
05-05
Unity A*插件
Unity A星（A Star/A*）寻路算法
九本才的博客
11-08 8766
演示： 我们知道Unity中的Navigation只能实现3D场景的寻路，不能实现2D的寻路，常见的寻路算法有很多种，其中A星是项目中最常用的寻路方法。在项目中用到了A星，就简单总结一下吧。 原理： 最通俗的原理就是寻找周围的点。选出一个到终点最近的点，再从选出的点为起点寻找下一个点，直到到达目标点。 实现： 如何选出最近的点呢，我们就会利用曼哈顿街区算法公式寻找下一个点。 如下图：我们以黄色为起点，黄色的点周围有八个可以移动的点，移动的距离对角移动为1.4，直线移动为1。 ..
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值