蜂巢型六边形A星寻路算法unity完整流程

作者：云影 Unity官方平台 2020-07-27
一、需求

我们需要一个这样的函数：给定六边形网格的一个起点和一个终点，函数能够返回从起点到终点的通路经过哪些六边形。

适应场景：战棋类游戏，常常因为六边形网格更好的美术表现及游戏性选择蜂巢型的网格作为游戏内寻路的基础，而一些moba类游戏也常常因为NaviMesh网格型寻路消耗过大、服务端客户端网格算法不同（例如unity内置的网格寻路功能，服务端就没办法使用）等原因，最终选择A星寻路算法来制作功能（节点需要足够小，且寻路结果需要平滑优化）。

二、算法讲解

1. 搜索区域

节点：就是单个六边形，整个搜索区域需要被节点铺满。

首先需要明确的一点是，正方形网格和六边形的网格没有本质上的区别，只不过正方形可以行走的方向是4个，六边形是6个，这个在程序上的区别主要体现在一个节点的相邻节点集上，正方形的相邻节点在4个以内，六边形的相邻节点在6个以内，不过对于算法理解没有影响。

2. 开始搜索

开启列表：需要考虑的节点都会被放到开启列表中，刚开始的时候开启列表只有起点一个节点，然后根据节点的相邻节点集，会逐渐把附近的节点都加到开启列表中。

关闭列表：所有不在考虑的节点的集合。

六边形网格，红色为不可通过点

我们以节点11为起点，节点8为终点。

先把节点11加入开启列表，再通过节点11找到他的相邻节点，也就是节点1、3、12、14、15、10，把他们放入开启列表，并为他们设置父节点为节点11。将节点11放入关闭列表。

3. 估值

上面讲的是如何扩大搜索范围，而如果想要获得一条最优路径，那么必然是有一个估值方式，在A星算法中，我们为每个节点都做估值，估算值F = G + H:

G：从起点，沿着产生的路径，移动到网格上指定方格的移动耗费。在这里，我们认为相邻的六边形，移动消耗是1，例如，从节点11移动到3，移动消耗就是1.

H：从网格上那个方格移动到终点B的预估移动耗费。这经常被称为启发式的，可因为它只是个猜测。这个H值的估算方式有很多种，我们暂时使用两个节点的直线距离，对应unity的实现就是Vector3.Distance(curHex.transform.position, tarHex.transform.position)。

F = G + H估值

很容易得到，节点3的估值是最低，估值最低则代表最优先。

4. 继续搜索

找到F值最低的节点3作为当前结点，我们把节点3从开启列表中删除，然后添加到关闭列表中。

找到节点3的所有相邻节点，跳过那些已经在关闭列表中、不可通过的点（节点2、4）。

如果该节点已经在开启列表中，则计算从当前节点到这个节点的G估算值为多少，例如节点12已经在开启列表中了，从当前节点（也就是节点3）到节点12的G估算值等于节点3当前G估值 + 1（从3走到12），也就是2。如果这个G估值比原先的G估值大，则什么都不做；如果比原来的G估值小，则把该节点的父节点改为当前节点，并将该节点的G估值设为更小的那个值。

再从开启列表中选取F值最低的那个，设为当前节点，重复以上过程。

在图中示例的六边形网格中，节点3的相邻网格有1、12、16，节点1和12已经在开启列表中了，节点3的G估值1+从3走到12的移动消耗1 = 2，2>节点12的当前G估值，所以什么都不做（节点1类似）。现在开启列表中有1、10、15、14、12、16，计算F估值，节点16最小，所以再以节点16为当前节点，重复以上过程。最终得到路径11、3、16、13、8。

三、在unity内的具体实现

1. 使用6个cube（每个cube旋转角差距60度）拼成一个六边形，用这些六边形拼出来一块网格，为方便调试，以数字依次命名。

2. 复制以下代码，命名为Hexagon，附加到每个六边形上：


  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using UnityEngine;

  6. public class Hexagon : MonoBehaviour
  7. {
  8.     Hexagon father = null;
  9.     public Hexagon[] neighbors = new Hexagon[6];
  10.     public bool passFlag = true;
  11.     float gValue = 999f;
  12.     float hValue = 999f;

  14.     public Material redMat;
  15.     public Material greenMat;

  17.     void Start()
  18.     {
  19.     }

  21.     public void reset()
  22.     {

  24.     }

  26.     public Hexagon[] getNeighborList()
  27.     {
  28.         return neighbors;
  29.     }

  31.     public void setFatherHexagon(Hexagon f)
  32.     {
  33.         father = f;
  34.     }

  36.     public Hexagon getFatherHexagon()
  37.     {
  38.         return father;
  39.     }

  41.     public void setCanPass(bool f)
  42.     {
  43.         passFlag = f;


  46.     }

  48.     public bool canPass()
  49.     {
  50.         return passFlag;
  51.     }

  53.     public float computeGValue(Hexagon hex)
  54.     {
  55.         return 1f;
  56.     }

  58.     public void setgValue(float v)
  59.     {
  60.         gValue = v;
  61.     }

  63.     public float getgValue()
  64.     {
  65.         return gValue;
  66.     }

  68.     public void sethValue(float v)
  69.     {
  70.         hValue = v;
  71.     }

  73.     public float gethValue()
  74.     {
  75.         return hValue;
  76.     }

  78.     public float computeHValue(Hexagon hex)
  79.     {
  80.         return Vector3.Distance(transform.position, hex.transform.position);
  81.     }
  82. }
复制代码


3. 为所有六边形添加一个空的父gameobject，命名为HexManager，为HexManager添加以下代码：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using System;

  6. public class HexManager : MonoBehaviour {
  7.     Dictionary name2Hex = new Dictionary();

  9.     static List openList = new List();
  10.     static List closeList = new List();

  12.     void Start()
  13.     {
  14.         foreach (Transform child in transform)
  15.         {
  16.             name2Hex.Add(child.name, child.GetComponent());
  17.         }
  18.     }

  20.     public Hexagon GetHexByName(string i)
  21.     {
  22.         Hexagon v = new Hexagon();
  23.         name2Hex.TryGetValue(i, out v);
  24.         return v;
  25.     }
  26.     public Dictionary GetAllHex()
  27.     {
  28.         return name2Hex;
  29.     }


  32.     public static List searchRoute(Hexagon thisHexagon, Hexagon targetHexagon)
  33.     {
  34.         Hexagon nowHexagon = thisHexagon;
  35.         nowHexagon.reset();

  37.         openList.Add(nowHexagon);
  38.         bool finded = false;
  39.         while (!finded)
  40.         {
  41.             openList.Remove(nowHexagon);//将当前节点从openList中移除  
  42.             closeList.Add(nowHexagon);//将当前节点添加到关闭列表中  
  43.             Hexagon[] neighbors = nowHexagon.getNeighborList();//获取当前六边形的相邻六边形  
  44.             //print("当前相邻节点数----" + neighbors.size());  
  45.             foreach (Hexagon neighbor in neighbors)
  46.             {
  47.                 if (neighbor == null) continue;

  49.                 if (neighbor == targetHexagon)
  50.                 {//找到目标节点  
  51.                     //System.out.println("找到目标点");  
  52.                     finded = true;
  53.                     neighbor.setFatherHexagon(nowHexagon);
  54.                 }
  55.                 if (closeList.Contains(neighbor) || !neighbor.canPass())
  56.                 {//在关闭列表里  
  57.                     //print("无法通过或者已在关闭列表");  
  58.                     continue;
  59.                 }

  61.                 if (openList.Contains(neighbor))
  62.                 {//该节点已经在开启列表里  
  63.                     //print("已在开启列表，判断是否更改父节点");  
  64.                     float assueGValue = neighbor.computeGValue(nowHexagon) + nowHexagon.getgValue();//计算假设从当前节点进入，该节点的g估值  
  65.                     if (assueGValue < neighbor.getgValue())
  66.                     {//假设的g估值小于于原来的g估值  
  67.                         openList.Remove(neighbor);//重新排序该节点在openList的位置  
  68.                         neighbor.setgValue(assueGValue);//从新设置g估值  
  69.                         openList.Add(neighbor);//从新排序openList。
  70.                     }
  71.                 }
  72.                 else
  73.                 {//没有在开启列表里  
  74.                     //print("不在开启列表，添加");  
  75.                     neighbor.sethValue(neighbor.computeHValue(targetHexagon));//计算好他的h估值  
  76.                     neighbor.setgValue(neighbor.computeGValue(nowHexagon) + nowHexagon.getgValue());//计算该节点的g估值（到当前节点的g估值加上当前节点的g估值）  
  77.                     openList.Add(neighbor);//添加到开启列表里  
  78.                     neighbor.setFatherHexagon(nowHexagon);//将当前节点设置为该节点的父节点  
  79.                 }
  80.             }

  82.             if (openList.Count <= 0)
  83.             {
  84.                 //print("无法到达该目标");  
  85.                 break;
  86.             }
  87.             else
  88.             {
  89.                 nowHexagon = openList[0];//得到f估值最低的节点设置为当前节点  
  90.             }
  91.         }
  92.         openList.Clear();
  93.         closeList.Clear();

  95.         List route = new List();
  96.         if (finded)
  97.         {//找到后将路线存入路线集合  
  98.             Hexagon hex = targetHexagon;
  99.             while (hex != thisHexagon)
  100.             {
  101.                 route.Add(hex);//将节点添加到路径列表里

  103.                 Hexagon fatherHex = hex.getFatherHexagon();//从目标节点开始搜寻父节点就是所要的路线  
  104.                 hex = fatherHex;
  105.             }
  106.             route.Add(hex);


  109.         }
  110.         route.Reverse();
  111.         return route;
  112.         //      resetMap();  
  113.     }

  115.     //通过无阻挡寻路确定两个六边形的距离
  116.     public static  int GetRouteDis(Hexagon thisHexagon, Hexagon targetHexagon)
  117.     {
  118.         Hexagon nowHexagon = thisHexagon;
  119.         nowHexagon.reset();

  121.         openList.Add(nowHexagon);
  122.         bool finded = false;
  123.         while (!finded)
  124.         {
  125.             openList.Remove(nowHexagon);//将当前节点从openList中移除  
  126.             closeList.Add(nowHexagon);//将当前节点添加到关闭列表中  
  127.             Hexagon[] neighbors = nowHexagon.getNeighborList();//获取当前六边形的相邻六边形  
  128.             //print("当前相邻节点数----" + neighbors.size());  
  129.             foreach (Hexagon neighbor in neighbors)
  130.             {
  131.                 if (neighbor == null) continue;

  133.                 if (neighbor == targetHexagon)
  134.                 {//找到目标节点  
  135.                     //System.out.println("找到目标点");  
  136.                     finded = true;
  137.                     neighbor.setFatherHexagon(nowHexagon);
  138.                 }
  139.                 if (closeList.Contains(neighbor))
  140.                 {//在关闭列表里  
  141.                     //System.out.println("无法通过或者已在关闭列表");  
  142.                     continue;
  143.                 }

  145.                 if (openList.Contains(neighbor))
  146.                 {//该节点已经在开启列表里  
  147.                     //System.out.println("已在开启列表，判断是否更改父节点");  
  148.                     float assueGValue = neighbor.computeGValue(nowHexagon) + nowHexagon.getgValue();//计算假设从当前节点进入，该节点的g估值  
  149.                     if (assueGValue < neighbor.getgValue())
  150.                     {//假设的g估值小于于原来的g估值  
  151.                         openList.Remove(neighbor);//重新排序该节点在openList的位置  
  152.                         neighbor.setgValue(assueGValue);//从新设置g估值  
  153.                         openList.Add(neighbor);//从新排序openList。
  154.                     }
  155.                 }
  156.                 else
  157.                 {//没有在开启列表里  
  158.                     //System.out.println("不在开启列表，添加");  
  159.                     neighbor.sethValue(neighbor.computeHValue(targetHexagon));//计算好他的h估值  
  160.                     neighbor.setgValue(neighbor.computeGValue(nowHexagon) + nowHexagon.getgValue());//计算该节点的g估值（到当前节点的g估值加上当前节点的g估值）  
  161.                     openList.Add(neighbor);//添加到开启列表里  
  162.                     neighbor.setFatherHexagon(nowHexagon);//将当前节点设置为该节点的父节点  
  163.                 }
  164.             }

  166.             if (openList.Count <= 0)
  167.             {
  168.                 //System.out.println("无法到达该目标");  
  169.                 break;
  170.             }
  171.             else
  172.             {
  173.                 nowHexagon = openList[0];//得到f估值最低的节点设置为当前节点  
  174.             }
  175.         }
  176.         openList.Clear();
  177.         closeList.Clear();

  179.         List route = new List();
  180.         if (finded)
  181.         {//找到后将路线存入路线集合  
  182.             Hexagon hex = targetHexagon;
  183.             while (hex != thisHexagon)
  184.             {
  185.                 route.Add(hex);//将节点添加到路径列表里

  187.                 Hexagon fatherHex = hex.getFatherHexagon();//从目标节点开始搜寻父节点就是所要的路线  
  188.                 hex = fatherHex;
  189.             }
  190.             route.Add(hex);


  193.         }
  194.         return route.Count - 1;
  195.     }
  196. }
复制代码


4. 在其他地方调用searchRoute接口，检查调试。

作者：云影
来源： Unity官方平台
原地址：https://mp.weixin.qq.com/s/NWuD9G3ArekC0wyLnqXFJQ

最新评论
暂无评论
参与评论