蜂巢型六邊形A星尋路演算法unity完整流程

雲影發表於2020-07-27
演算法Unity
一、需求

我們需要一個這樣的函式：給定六邊形網格的一個起點和一個終點，函式能夠返回從起點到終點的通路經過哪些六邊形。

適應場景：戰棋類遊戲，常常因為六邊形網格更好的美術表現及遊戲性選擇蜂巢型的網格作為遊戲內尋路的基礎，而一些moba類遊戲也常常因為NaviMesh網格型尋路消耗過大、服務端客戶端網格演算法不同（例如unity內建的網格尋路功能，服務端就沒辦法使用）等原因，最終選擇A星尋路演算法來製作功能（節點需要足夠小，且尋路結果需要平滑優化）。

二、演算法講解

1. 搜尋區域

節點：就是單個六邊形，整個搜尋區域需要被節點鋪滿。

首先需要明確的一點是，正方形網格和六邊形的網格沒有本質上的區別，只不過正方形可以行走的方向是4個，六邊形是6個，這個在程式上的區別主要體現在一個節點的相鄰節點集上，正方形的相鄰節點在4個以內，六邊形的相鄰節點在6個以內，不過對於演算法理解沒有影響。

2. 開始搜尋

開啟列表：需要考慮的節點都會被放到開啟列表中，剛開始的時候開啟列表只有起點一個節點，然後根據節點的相鄰節點集，會逐漸把附近的節點都加到開啟列表中。

關閉列表：所有不在考慮的節點的集合。

蜂巢型六邊形A星尋路演算法unity完整流程
六邊形網格，紅色為不可通過點

我們以節點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)。

蜂巢型六邊形A星尋路演算法unity完整流程
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

相關文章