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

最新推荐文章于 2024-01-15 10:37:25 发布
最新推荐文章于 2024-01-15 10:37:25 发布
阅读量445 收藏 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

努力总会有收获
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Unity Enum位掩码（BitMask）的运用
SlowFeather's blog
01-04 624
在Unity游戏开发中，我们经常会面临需要对一组相关的状态进行管理的情况。Enum位掩码是一种有效的方法，可以帮助我们简洁而灵活地处理这类状态。本文将介绍在Unity中如何使用Enum位掩码，并通过一个实际项目的案例来进行详细讲解。首先，我们需要定义一个Enum，其中包含所有可能的技能。[Flags]None = 0,注意到我们在Enum的声明上使用了[Flags]特性，这是Enum位掩码的关键。通过使用Enum位掩码，我们能够以一种简洁而高效的方式管理复杂的状态。
Unity 算法 之 A星（A Star/A*）寻路算法实现和封装，并带动态演示Demo
仙魁XAN
03-08 1万+
Unity 算法 之 A星（A Star/A*）寻路的算法法实现和封装，并带动态演示Demo 目录 Unity 算法 之 A星（A Star/A*）寻路的算法法实现和封装，并带动态演示Demo 一、简单介绍 二、 A星（A Star/A*）寻路算法相关知识 1、什么是A星（A Star/A*）寻路算法 2、寻路：寻找最短路径并避开障碍物 3、几个重要的概念 4、寻路结束的条件...
基于Unity的A星寻路算法（绝对简单完整版本）
xinzhilinger的博客
08-12 6469
前言 在上一篇文章，介绍了网格地图的实现方式，基于该文章，我们来实现一个A星寻路的算法,最终实现的效果为： 项目源码已上传Github：AStarNavigate 在阅读本篇文章，如果你对于里面提到的一些关于网格地图的创建方式的一些地图不了解的话，可以先阅读了解一下下面的这篇文章： 文章链接： Unity 制作一个网格地图生成组件 1、简单做一些背景介绍 在介绍A星寻路算法前，先介绍另外一种算法：Dijkstra寻路算法，简单的来说是一种A星寻路的基础版。Dijkstra作为一种无启发的寻路算法，
【Unity】A星寻路算法 + Demo示例
qq_42404497的博客
07-16 707
A寻路算法的估量代价* 在A算法中核心的寻路依据就是估量代价，在A中通常用 F 表示。 F = G + H 其中G表示当前点到起始点的估量代价 ，H表示当前点到终点的代价。 G的计算方式： 最开始，以起点为中心开始计算周边的八个格子，然后在以这算出来的八个格子为中心，继续计算他们周围的八个格子的G值。 以此类推，直到找到终端，或遍历完所有的格子。 G值的计算结果为：中心点的G值+距离值【10 or 14】 A*算法步骤 1.设置开放列表OpenList和关闭列表CloseList 2.将起点放置到OpenL
Unity之A星算法
m0_61490399的博客
08-22 2879
本文到这里就结束了,大佬们的支持是我们更新的最大动力，希望这篇文章能帮到大家💪个人专栏连接🔗下篇文章再见ヾ(￣▽￣)ByeByeHomePage社区链接🔗专栏连接🔗点击直接阅读文章Unirt~UI简单框架。
Unity-A星算法
09-02
A星算法的核心，地形网格的构建以及评估函数的算法，其它都是可以复用的。其实代码是次要的东西，要理解A星算法，建议先去看数学证明，否则看代码一点意义没有，因为看懂了证明，代码会变得非常简单。证明里有个核心...
unity3d寻路A星算法
03-07
在Unity3D中，案例可能使用C#编写A*算法，并结合Unity的内置组件如Transform和Rigidbody来实现角色的动态移动。同时，可能会利用Unity的图形化编程工具如Scriptable Objects或者Unity的Inspector窗口来配置和调整...
unity简单的A星算法
02-24
Unity中的A*（A-star）...总之，A*算法在Unity中的应用涉及地图网格化、路径计算、启发式函数设计等多个方面，是游戏开发中不可或缺的路径规划工具。通过理解和实现A*算法，开发者能够创建出更加智能和流畅的游戏体验。
A*算法在unity中的实现
11-12
在Unity中，可以利用C#编写算法逻辑，并结合Unity的图形界面和脚本系统进行可视化调试和交互。例如，可以使用Unity的OnDrawGizmos()方法绘制路径和节点，以帮助开发者更好地理解算法的工作过程。 A*算法的高效性和...
unity简单实现AStar A*算法
09-18
Unity简单实现A*算法 一、功能概述 1.地图节点类 坐标值； 定义节点类型； 记录父节点； 计算F,G,H； 2.AStart类 寻路； 寻找路径点； openList； closeList； 建立链表关系； 按照F值排序；
unity下A*算法实现包含word和package包
09-22
在unity5.4.0下实现了一个2DA*算法,其中压缩包含一个word有详细的步骤和一个unityPackage包导入可以查看效果
Unity A星（A Star/A*）寻路算法
九本才的博客
11-08 8516
演示： 我们知道Unity中的Navigation只能实现3D场景的寻路，不能实现2D的寻路，常见的寻路算法有很多种，其中A星是项目中最常用的寻路方法。在项目中用到了A星，就简单总结一下吧。 原理： 最通俗的原理就是寻找周围的点。选出一个到终点最近的点，再从选出的点为起点寻找下一个点，直到到达目标点。 实现： 如何选出最近的点呢，我们就会利用曼哈顿街区算法公式寻找下一个点。 如下图：我们以黄色为起点，黄色的点周围有八个可以移动的点，移动的距离对角移动为1.4，直线移动为1。 ..
【Unity 实用工具篇】✨| A* Pathfinding Project - A*寻路插件 的使用教程
热门推荐
努力前行，总会成为自己心中的那道光
07-28 1万+
寻路系统 在很多游戏中都会用到，该功能会经常用来自动寻路时使用。 A星(A Start)寻路算法常用的路径搜索算法，用于在图形或网格中找到最短路径。 本文就来讲一下以 A*寻路算法 基础上延伸的插件A* Pathfinding Project的使用方法。
Unity寻路A星算法
最新发布
qqrrjj2011的博客
01-15 2225
在A*寻路中，从一个节点到另一个相邻节点的移动成本通常不是简单的单位距离，而是可以根据地形、障碍物、角色能力等因素来定制。总之，在A*寻路算法中，移动成本是一个灵活的概念，需要根据具体的游戏环境或实际问题需求来设计和实施。否则，将其相邻的未探索过的节点加入到优先级队列中。对于新加入优先级队列的相邻节点，计算其G值（从起点到达该节点的实际代价）、H值（启发式估计值，即到目标节点的预计代价），然后根据公式。在实现过程中，当计算相邻节点的F值（总成本）时，G值会包括前一节点到当前节点的实际移动成本，即。
Unity 中 A*寻路（AStar，A星）的优化，二叉堆，双向队列，哈希表
XueZhiXia_的博客
12-07 2333
对A星寻路的进一步优化，二叉堆，哈希表，双向队列
Unity学习笔记--易学易会的unity中A星寻路插件:A*Pathfind Project的使用
qq_42434073的博客
02-07 7102
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
【推荐100个unity插件之1】2d使用A*Pathfinding插件实现敌人AI，并自动躲避障碍物
向宇
05-07 2159
最终效果可以前往官网下载和查看开发文档导入AI插件新建空物体，添加PathFinder组件，用在地图导航渲染导航路径，绘制出来的蓝色部分则为可行走区域，非蓝色区域是我配置的碰撞器区域，可自行修改，如果不满意可以修改Diameter的值，控制碰撞器区域多大的范围不可行走给敌人添加碰撞器，碰撞区域自行调整给敌人添加AIPath组件，我们这里的2d项目，，如果你不想敌人旋转，可以去掉勾选Enable Rotation。
[Unity] A-Star(A星)寻路算法
weixin_34150503的博客
04-29 911
在游戏中，有一个很常见地需求，就是要让一个角色从A点走向B点，我们期望是让角色走最少的路。嗯，大家可能会说，直线就是最短的。没错，但大多数时候，A到B中间都会出现一些角色无法穿越的东西，比如墙、坑等障碍物。这个时候怎么办呢？ 是的，我们需要有一个算法来解决这个问题，算法的目标就是计算出两点之间的最短路径，而且要能避开障碍物。 百度百科： A*搜寻算法俗称A星算法。这是一种在图形平面上...
unity3d A星算法
07-20
在Unity3D中，你可以使用A*算法来实现角色的自动寻路。 在Unity3D中，有一些现成的A*算法的实现库，例如： 1. **A* Pathfinding Project**: 这是一个非常流行的A*算法实现库，提供了强大的路径搜索功能和多种寻路...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值