用Unity实现A星寻路算法

最新推荐文章于 2024-01-15 10:37:25 发布
最新推荐文章于 2024-01-15 10:37:25 发布
阅读量319 收藏 1
点赞数 1
分类专栏： Unity 算法 文章标签： unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43994445/article/details/119513104
版权
Unity 同时被 2 个专栏收录
35 篇文章 5 订阅
订阅专栏
算法
13 篇文章 0 订阅
订阅专栏

先上图

兰色格子是起点
黄色格子是终点
绿框格子是将要探索的地方
蓝框格子是已经走过的路
最后出现的绿色格子就是算出的路线
在这里插入图片描述

思路

我是看的他的文章, 写的很棒, 深入浅出:
https://blog.csdn.net/zhulichen/article/details/78786493

下面放代码

花了一个中午时间瞎写的, 代码很乱, 知道思路就行

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

public struct AStarDef
{
    public static Color colorDead = new Color(60 / 255f, 60 / 255f, 60 / 255f, 100 / 255f);
    public static Color colorStart = new Color(60 / 255f, 1, 1, 100 / 255f);
    public static Color colorEnd = new Color(1, 1, 60 / 255f, 100 / 255f);
    public static Color colorPath = new Color(60 / 255f, 1, 60 / 255f, 100 / 255f);

    public static Color colorCur = new Color(60 / 255f, 1, 1);
    public static Color colorCanWalk = new Color(60 / 255f, 1, 60 / 255f);
    public static Color colorNull = new Color(200 / 255f, 200 / 255f, 200 / 255f);
    public static Color colorChecked = new Color(60 / 255f, 60 / 255f, 1);
}

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

public class AStarMgr : MonoBehaviour
{
    public Transform parent;
    public AStarCube prefab;
    float height;
    Vector3 offset;

    AStarCube startCube;
    AStarCube endCube;
    bool isComplete = false;
    bool isAuto = false;
    const int maxX = 10;
    const int maxY = 10;
    const int deadNum = 40;

    //全部方块
    Dictionary<int, AStarCube> allCubes = new Dictionary<int, AStarCube>();
    //每个方块 和它的8个邻居
    Dictionary<AStarCube, List<AStarCube>> allNeighbours = new Dictionary<AStarCube, List<AStarCube>>();
    //每个可走的方块 和它的可走的8个邻居
    Dictionary<AStarCube, List<AStarCube>> availableNeighbours = new Dictionary<AStarCube, List<AStarCube>>();
    //待走的方块
    List<AStarCube> canWalks = new List<AStarCube>();
    //不可走的方块
    List<AStarCube> deads = new List<AStarCube>();

    void Awake()
    {
        height = prefab.GetComponent<RectTransform>().rect.height;
        offset = Vector3.one * height;
        CreateAllCubes();
        Reset();
        StartCoroutine(AutoNext());
    }
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Next();
        }
        if (Input.GetKeyDown(KeyCode.R))
        {
            Reset();
        }
        if (Input.GetKeyDown(KeyCode.A))
        {
            isAuto = !isAuto;
        }
    }

    void Reset()
    {
        foreach (AStarCube item in allCubes.Values)
        {
            item.Reset();
        }
        CreateDiedCubes();
        CalcuAvailableNeighbours();
        SetStartCubeEndCube();
    }

    void SetStartCubeEndCube()
    {
        isComplete = false;
        startCube = null;
        endCube = null;
        while (startCube == null || endCube == null)
        {
            int x = Random.Range(0, maxX);
            int y = Random.Range(0, maxY);
            int id = GetID(x, y);
            if (allCubes.ContainsKey(id))
            {
                if (!deads.Contains(allCubes[id]))
                {
                    if (startCube == null)
                    {
                        startCube = allCubes[id];
                        deads.Add(allCubes[id]);
                    }
                    else if (endCube == null)
                    {
                        endCube = allCubes[id];
                        deads.Add(allCubes[id]);
                    }
                }
            }
        }
        startCube.SetStart();
        endCube.SetEnd();
        canWalks.Clear();
        canWalks.Add(startCube);
    }

    WaitForSeconds wait = new WaitForSeconds(0.2f);
    WaitForSeconds wait1 = new WaitForSeconds(1);
    IEnumerator AutoNext()
    {
        while (true)
        {
            if (isAuto)
            {
                if (!isComplete)
                {
                    Next();
                }
                else
                {
                    yield return wait1;
                    Reset();
                }
            }
            yield return wait;
        }
    }

    void Next()
    {
        if (isComplete)
        {
            print("已完成, 别再按空格了, 按R键重置");
            return;
        }
        if (canWalks.Count == 0)
        {
            isComplete = true;
            print("无路可走");
            return;
        }
        AStarCube me = null;
        for (int i = 0; i < canWalks.Count; i++)
        {
            //这里用>=, 而不是用>, 是为了优先选择最新的
            if (me == null || me.F >= canWalks[i].F)
            {
                me = canWalks[i];
            }
        }
        canWalks.Remove(me);
        List<AStarCube> ns = availableNeighbours[me];
        if (ns.Count == 0)
        {
            Next();
        }
        for (int i = 0; i < ns.Count; i++)
        {
            AStarCube neighbour = ns[i];
            if (neighbour.isDead)
            {
                continue;
            }
            if (neighbour.isChecked)
            {
                continue;
            }
            neighbour.SetCanWalk();
            me.SetChecked();
            if (!canWalks.Contains(neighbour))
            {
                canWalks.Add(neighbour);
            }
            neighbour.G = me.G + GetDistance(me, neighbour);
            neighbour.H = GetDistance(neighbour, endCube);
            neighbour.F = neighbour.G + neighbour.H;
            if (neighbour.myDir == null)
            {
                neighbour.myDir = me;
            }

            if (neighbour == endCube)
            {
                print("找到了!");
                MarkPath(endCube);
                isComplete = true;
            }
        }
    }

    float GetDistance(AStarCube a, AStarCube b)
    {
        int xDis = Mathf.Abs(a.x - b.x);
        int yDis = Mathf.Abs(a.Y - b.Y);
        int max = xDis > yDis ? xDis : yDis;
        int orthogonal = Mathf.Abs(xDis - yDis);
        int diagonal = max - orthogonal;
        return diagonal * 1.4f + orthogonal;
    }

    void MarkPath(AStarCube item)
    {
        if (item.myDir != null)
        {
            item.myDir.SetPathMark();
            MarkPath(item.myDir);
        }
        else
        {
            return;
        }
    }

    //生成白色方块
    void CreateAllCubes()
    {
        for (int x = 0; x < maxX; x++)
        {
            for (int y = 0; y < maxX; y++)
            {
                AStarCube go = Instantiate<AStarCube>(prefab, new Vector3(x, y) * height + offset, Quaternion.identity, parent);
                go.x = x;
                go.Y = y;
                int id = GetID(x, y);
                allCubes.Add(id, go);
            }
        }
        foreach (KeyValuePair<int, AStarCube> item in allCubes)
        {
            int[] nbsArray = GetMyNeighbours(item.Key);
            List<AStarCube> nbs = new List<AStarCube>();
            for (int i = 0; i < nbsArray.Length; i++)
            {
                if (allCubes.ContainsKey(nbsArray[i]))
                {
                    nbs.Add(allCubes[nbsArray[i]]);
                }
            }
            allNeighbours.Add(item.Value, nbs);
        }
    }

    int[] GetMyNeighbours(int me)
    {
        int y = me % 100;
        int x = (me - y) / 100;

        int next0 = GetID(x - 1, y);
        int next1 = GetID(x + 1, y);
        int next2 = GetID(x, y - 1);
        int next3 = GetID(x, y + 1);
        int next4 = GetID(x - 1, y - 1);
        int next5 = GetID(x - 1, y + 1);
        int next6 = GetID(x + 1, y - 1);
        int next7 = GetID(x + 1, y + 1);

        return new int[] { next0, next1, next2, next3, next4, next5, next6, next7 };
    }

    //生成不可走的方块
    void CreateDiedCubes()
    {
        deads.Clear();
        for (int i = 0; i < deadNum; i++)
        {
            int x = Random.Range(0, maxX);
            int y = Random.Range(0, maxY);
            int id = GetID(x, y);
            if (allCubes.ContainsKey(id))
            {
                allCubes[id].SetDead();
                if (!deads.Contains(allCubes[id]))
                {
                    deads.Add(allCubes[id]);
                }
            }
        }
    }
    void CalcuAvailableNeighbours()
    {
        availableNeighbours.Clear();
        foreach (KeyValuePair<AStarCube, List<AStarCube>> item in allNeighbours)
        {
            if (!item.Key.isDead)
            {
                List<AStarCube> n = new List<AStarCube>();
                for (int i = 0; i < item.Value.Count; i++)
                {
                    if (!item.Value[i].isDead)
                    {
                        n.Add(item.Value[i]);
                    }
                }
                availableNeighbours.Add(item.Key, n);
                CalcuNeighbours(item.Key, n);
            }
        }
    }

    void CalcuNeighbours(AStarCube me, List<AStarCube> ns)
    {
        int x = me.x;
        int y = me.Y;
        int up = GetID(x, y + 1);
        int down = GetID(x, y - 1);
        int left = GetID(x - 1, y);
        int right = GetID(x + 1, y);
        int upleft = GetID(x - 1, y + 1);
        int upright = GetID(x + 1, y + 1);
        int downleft = GetID(x - 1, y - 1);
        int downright = GetID(x + 1, y - 1);
        if (allCubes.ContainsKey(up) && allCubes[up].isDead)
        {
            if (allCubes.ContainsKey(upleft))
            {
                ns.Remove(allCubes[upleft]);
            }
            if (allCubes.ContainsKey(upright))
            {
                ns.Remove(allCubes[upright]);
            }
        }
        if (allCubes.ContainsKey(down) && allCubes[down].isDead)
        {
            if (allCubes.ContainsKey(downleft))
            {
                ns.Remove(allCubes[downleft]);
            }
            if (allCubes.ContainsKey(downright))
            {
                ns.Remove(allCubes[downright]);
            }
        }
        if (allCubes.ContainsKey(left) && allCubes[left].isDead)
        {
            if (allCubes.ContainsKey(upleft))
            {
                ns.Remove(allCubes[upleft]);
            }
            if (allCubes.ContainsKey(downleft))
            {
                ns.Remove(allCubes[downleft]);
            }
        }
        if (allCubes.ContainsKey(right) && allCubes[right].isDead)
        {
            if (allCubes.ContainsKey(upright))
            {
                ns.Remove(allCubes[upright]);
            }
            if (allCubes.ContainsKey(downright))
            {
                ns.Remove(allCubes[downright]);
            }
        }
    }

    int GetID(int x, int y)
    {
        return x * 100 + y;
    }
}

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



public class AStarCube : MonoBehaviour
{
    public AStarCube myDir;
    public bool isDead;
    public bool isChecked;

    public Image bg;
    public Text textXY;
    public Text textG;
    public Text textH;
    public Text textF;
    public Image dead;

    public int x;

    private int y;
    public int Y
    {
        get { return y; }
        set
        {
            y = value;
            textXY.text = "(" + x.ToString() + "," + y.ToString() + ")";
        }
    }

    private float g;
    public float G
    {
        get { return g; }
        set
        {
            g = value;
            textG.text = g.ToString("F1");
        }
    }

    private float h;
    public float H
    {
        get { return h; }
        set
        {
            h = value;
            textH.text = h.ToString("F1");
        }
    }

    private float f;
    public float F
    {
        get { return f; }
        set
        {
            f = value;
            textF.text = f.ToString("F1");
        }
    }


    public void SetStart()
    {
        dead.gameObject.SetActive(true);
        dead.color = AStarDef.colorStart;
    }
    public void SetEnd()
    {
        dead.gameObject.SetActive(true);
        dead.color = AStarDef.colorEnd;
    }
    public void SetCanWalk()
    {
        bg.color = AStarDef.colorCanWalk;
    }

    public void SetDead()
    {
        dead.gameObject.SetActive(true);
        dead.color = AStarDef.colorDead;
        isDead = true;
    }

    public void SetChecked()
    {
        bg.color = AStarDef.colorChecked;
        isChecked = true;
    }
    public void SetCur()
    {
        bg.color = AStarDef.colorCur;
    }

    public void SetPathMark()
    {
        dead.gameObject.SetActive(true);
        dead.color = AStarDef.colorPath;
    }
    public void Reset()
    {
        isChecked = false;
        isDead = false;
        dead.gameObject.SetActive(false);
        bg.color = AStarDef.colorNull;
        G = 0;
        H = 0;
        F = 0;
        myDir = null;
    }
}
幻冬
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在Unity中实现Astar寻路算法
Meytones的博客
02-19 2358
在游戏中，从一点到另一点的操作有时需要游戏系统自动完成，在一些带有rpg元素的游戏中，敌人在发现玩家位置后会自动向玩家的位置移动。这些移动的路线是如何自动确定的？本文将介绍寻路算法中的A*算法，并在unity中用C#脚本来实现寻路功能。
AStar 算法 ---在Unity当中实现
Sc2Player的博客
06-11 2989
介绍 AStar算法,是一种在静态路网中求最短路径的一种算法,是一种启发式的算法.其中,算法当中起点与终点的距离,与算法当中的预估距离越接近,则搜索速度越快. 其实,在AStar算法当中,他的搜索路径的特点与迪杰斯特拉那种毫无章法四处搜索的不同,他是在向着离终点比较近的方向发起的搜索,因此,他的效率自然也就一般的寻路算法要高效了. 当然,这也可以说是启发式算法的优点了 实现思路 ASta...
Unity寻路A星算法
最新发布
qqrrjj2011的博客
01-15 2193
在A*寻路中，从一个节点到另一个相邻节点的移动成本通常不是简单的单位距离，而是可以根据地形、障碍物、角色能力等因素来定制。总之，在A*寻路算法中，移动成本是一个灵活的概念，需要根据具体的游戏环境或实际问题需求来设计和实施。否则，将其相邻的未探索过的节点加入到优先级队列中。对于新加入优先级队列的相邻节点，计算其G值（从起点到达该节点的实际代价）、H值（启发式估计值，即到目标节点的预计代价），然后根据公式。在实现过程中，当计算相邻节点的F值（总成本）时，G值会包括前一节点到当前节点的实际移动成本，即。
Stm32 CubeMx安装和配置Cube.ai教程
热门推荐
17岁boy的博客
12-13 1万+
前言 Stm32 Cube MX是Stm32公司推出的一款专门为Stm32平台开发的IDE，通过它能够快速构建集成开发环境，与早期的STM32外设库相比，Cube MX更为简单，Cube MX做了更多层的封装，使的用户可以不用太关心MCU底层的实现，通过调用相关API即可完成工作，新手不建议直接使用它，新手可以先从最基本的GPIO口操作，在到外设库，然后在到Cube MX，否则你在开发过程中对底层硬件会浑然不知。 Stm32 Cube MX可以快速构建Stm32开发板的应用程序，同时它内置了许多模块，其
Unity之A星算法
m0_61490399的博客
08-22 2859
本文到这里就结束了,大佬们的支持是我们更新的最大动力，希望这篇文章能帮到大家💪个人专栏连接🔗下篇文章再见ヾ(￣▽￣)ByeByeHomePage社区链接🔗专栏连接🔗点击直接阅读文章Unirt~UI简单框架。
Unity A星（A Star/A*）寻路算法
九本才的博客
11-08 8480
演示： 我们知道Unity中的Navigation只能实现3D场景的寻路，不能实现2D的寻路，常见的寻路算法有很多种，其中A星是项目中最常用的寻路方法。在项目中用到了A星，就简单总结一下吧。 原理： 最通俗的原理就是寻找周围的点。选出一个到终点最近的点，再从选出的点为起点寻找下一个点，直到到达目标点。 实现： 如何选出最近的点呢，我们就会利用曼哈顿街区算法公式寻找下一个点。 如下图：我们以黄色为起点，黄色的点周围有八个可以移动的点，移动的距离对角移动为1.4，直线移动为1。 ..
[Unity] A-Star(A星)寻路算法
weixin_34150503的博客
04-29 905
在游戏中，有一个很常见地需求，就是要让一个角色从A点走向B点，我们期望是让角色走最少的路。嗯，大家可能会说，直线就是最短的。没错，但大多数时候，A到B中间都会出现一些角色无法穿越的东西，比如墙、坑等障碍物。这个时候怎么办呢？ 是的，我们需要有一个算法来解决这个问题，算法的目标就是计算出两点之间的最短路径，而且要能避开障碍物。 百度百科： A*搜寻算法俗称A星算法。这是一种在图形平面上...
Unity 2D A星寻路算法实现(2D与2.5D)
09-20
这个是我个人自己写的Unity 2D环境中的寻路, 分别有两个文件夹，AIPath 是正面2D 环境，45AIPath 是斜45度角(2.5D)环境，本资源包含了一份PDF繁体中文教学文件，而在最后我也提出了一些问题，望高手解答。此算法也是...
Unity 算法 之 A星（A Star/A*）寻路算法实现和封装，并带动态演示Demo
03-08
Unity 算法 之 A星（A Star/A*）寻路算法实现和封装，并带动态演示Demo Demo 使用操作说明 1、按空格可以刷线地图，更新地图的障碍物位置（动态随机设置） 2、鼠标左键设置开始点位置 3、鼠标右键设置目标点位置...
基于unity实现可视化A寻路算法源码.zip
06-02
基于unity实现可视化A寻路算法源码.zip 基于unity实现可视化A寻路算法源码.zip基于unity实现可视化A寻路算法源码.zip基于unity实现可视化A寻路算法源码.zip基于unity实现可视化A寻路算法源码.zip
unityAStar寻路 A星 A*寻路算法Demo
04-25
基于Unity5.4.4版本，随机障碍物，动态实现寻路，UnityA星寻路完整Demo
Unity-A星算法
09-02
A星算法的核心，地形网格的构建以及评估函数的算法，其它都是可以复用的。其实代码是次要的东西，要理解A星算法，建议先去看数学证明，否则看代码一点意义没有，因为看懂了证明，代码会变得非常简单。证明里有个核心点就是，评估函数值<=实际值，可以确保找到最短路径的证明，理解了这个证明，也就理解了A星算法。
unity简单的A星算法
02-24
unity简单的A星算法；unity简单的A星算法；unity简单的A星算法
unity3d寻路A星算法
03-07
Unity3D是一款强大的跨平台游戏开发...总之，Unity3D中的A*寻路算法是一种高效且灵活的方法，能够帮助游戏角色在复杂环境中智能地规划路径。通过对算法的理解和实践，开发者可以创建出更加逼真和交互性强的游戏世界。
unity A星寻路系统A Pathfinding Project Pro 4.1.16
09-29
unity A星寻路系统A Pathfinding Project Pro 4.1.16
Unity 中 A*寻路（AStar，A星）的优化，二叉堆，双向队列，哈希表
XueZhiXia_的博客
12-07 2286
对A星寻路的进一步优化，二叉堆，哈希表，双向队列
unityA星寻路算法基础原理
ET0783的博客
08-25 1263
unityA星寻路算法基础，学习笔记
A星寻路优化方案
qq_42720695的博客
10-13 527
对于地图信息已知且各障碍位置固定的情况下，可以将常用的位置及其之间的路径信息保存，然后寻路时分别找到离开始点，结束点较近的位置，分别进行寻路，再将路径组合得到最终路径，不过此路径可能较正常寻路出的路径较远但寻路用时较少。
用unity实现a星寻路
04-18
A星寻路算法是一种常用的寻路算法，在Unity中实现A星寻路可以让游戏中的角色等能够智能地寻找最优路径。在制作游戏中，我们可以使用Unity自带的Nav Mesh Agent组件，也可以通过编写代码实现。如果您想要详细了解实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值