[A*算法]A*算法的簡單實現（一）

寫在前面：以前看過一點，而後看不懂，也沒用過。

最近正好重構項目看到尋路這塊，想起來就去查查資料，總算稍微理解一點了，下面記錄一下本身的成果（哈哈哈 :> ）

下面分享幾篇我以爲挺不錯的文章

A*算法

A*尋路算法詳細解讀

========================================================================================

搜索區域(The Search Area)

咱們假設某人要從 A 點移動到 B 點，可是這兩點之間被一堵牆隔開。如圖 1 ，綠色是 A ，紅色是 B ，中間藍色是牆。

圖 1

你應該注意到了，咱們把要搜尋的區域劃分紅了正方形的格子。這是尋路的第一步，簡化搜索區域，就像咱們這裏作的同樣。這個特殊的方法把咱們的搜索區域簡化爲了 2 維數組。數組的每一項表明一個格子，它的狀態就是可走 (walkalbe) 和不可走 (unwalkable) 。經過計算出從 A 到 B須要走過哪些方格，就找到了路徑。一旦路徑找到了，人物便從一個方格的中心移動到另外一個方格的中心，直至到達目的地。

方格的中心點咱們成爲「節點 (nodes) 」。若是你讀過其餘關於 A* 尋路算法的文章，你會發現人們經常都在討論節點。爲何不直接描述爲方格呢？由於咱們有可能把搜索區域劃爲爲其餘多變形而不是正方形，例如能夠是六邊形，矩形，甚至能夠是任意多變形。而節點能夠放在任意多邊形裏面，能夠放在多變形的中心，也能夠放在多邊形的邊上。咱們使用這個系統，由於它最簡單。

開始搜索(Starting the Search)

一旦咱們把搜尋區域簡化爲一組能夠量化的節點後，就像上面作的同樣，咱們下一步要作的即是查找最短路徑。在 A* 中，咱們從起點開始，檢查其相鄰的方格，而後向四周擴展，直至找到目標。

咱們這樣開始咱們的尋路旅途：

1.       從起點 A 開始，並把它就加入到一個由方格組成的 open list( 開放列表 ) 中。這個 open list 有點像是一個購物單。固然如今 open list 裏只有一項，它就是起點 A ，後面會慢慢加入更多的項。 Open list 裏的格子是路徑可能會是沿途通過的，也有可能不通過。基本上 open list 是一個待檢查的方格列表。

2.       查看與起點 A 相鄰的方格 ( 忽略其中牆壁所佔領的方格，河流所佔領的方格及其餘非法地形佔領的方格 ) ，把其中可走的 (walkable) 或可到達的 (reachable) 方格也加入到 open list 中。把起點 A 設置爲這些方格的父親 (parent node 或 parent square) 。當咱們在追蹤路徑時，這些父節點的內容是很重要的。稍後解釋。

3.       把 A 從 open list 中移除，加入到 close list( 封閉列表 ) 中， close list 中的每一個方格都是如今不須要再關注的。

以下圖所示，深綠色的方格爲起點，它的外框是亮藍色，表示該方格被加入到了 close list 。與它相鄰的黑色方格是須要被檢查的，他們的外框是亮綠色。每一個黑方格都有一個灰色的指針指向他們的父節點，這裏是起點 A 。

圖 2 。

下一步，咱們須要從 open list 中選一個與起點 A 相鄰的方格，按下面描述的同樣或多或少的重複前面的步驟。可是到底選擇哪一個方格好呢？具備最小 F 值的那個。

 

路徑排序(Path Sorting)

計算出組成路徑的方格的關鍵是下面這個等式：

F = G + H

這裏，

G = 從起點 A 移動到指定方格的移動代價，沿着到達該方格而生成的路徑。

H = 從指定的方格移動到終點 B 的估算成本。這個一般被稱爲試探法，有點讓人混淆。爲何這麼叫呢，由於這是個猜想。直到咱們找到了路徑咱們纔會知道真正的距離，由於途中有各類各樣的東西 ( 好比牆壁，水等 ) 。本教程將教你一種計算 H 的方法，你也能夠在網上找到其餘方法。

咱們的路徑是這麼產生的：反覆遍歷 open list ，選擇 F 值最小的方格。這個過程稍後詳細描述。咱們仍是先看看怎麼去計算上面的等式。

如上所述， G 是從起點Ａ移動到指定方格的移動代價。在本例中，橫向和縱向的移動代價爲 10 ，對角線的移動代價爲 14 。之因此使用這些數據，是由於實際的對角移動距離是 2 的平方根，或者是近似的 1.414 倍的橫向或縱向移動代價。使用 10 和 14 就是爲了簡單起見。比例是對的，咱們避免了開放和小數的計算。這並非咱們沒有這個能力或是不喜歡數學。使用這些數字也可使計算機更快。稍後你便會發現，若是不使用這些技巧，尋路算法將很慢。

 

既然咱們是沿着到達指定方格的路徑來計算 G 值，那麼計算出該方格的 G 值的方法就是找出其父親的 G 值，而後按父親是直線方向仍是斜線方向加上 10 或 14 。隨着咱們離開起點而獲得更多的方格，這個方法會變得更加明朗。

 

有不少方法能夠估算 H 值。這裏咱們使用 Manhattan 方法，計算從當前方格橫向或縱向移動到達目標所通過的方格數，忽略對角移動，而後把總數乘以 10 。之因此叫作 Manhattan 方法，是由於這很像統計從一個地點到另外一個地點所穿過的街區數，而你不能斜向穿過街區。重要的是，計算 H 是，要忽略路徑中的障礙物。這是對剩餘距離的估算值，而不是實際值，所以才稱爲試探法。

 

把 G 和 H 相加便獲得 F 。咱們第一步的結果以下圖所示。每一個方格都標上了 F ， G ， H 的值，就像起點右邊的方格那樣，左上角是 F ，左下角是 G ，右下角是 H 。

圖 3

好，如今讓咱們看看其中的一些方格。在標有字母的方格， G = 10 。這是由於水平方向從起點到那裏只有一個方格的距離。與起點直接相鄰的上方，下方，左方的方格的 G 值都是 10 ，對角線的方格 G 值都是 14 。

 

H 值經過估算起點於終點 ( 紅色方格 ) 的 Manhattan 距離獲得，僅做橫向和縱向移動，而且忽略沿途的牆壁。使用這種方式，起點右邊的方格到終點有 3 個方格的距離，所以 H = 30 。這個方格上方的方格到終點有 4 個方格的距離 ( 注意只計算橫向和縱向距離 ) ，所以 H = 40 。對於其餘的方格，你能夠用一樣的方法知道 H 值是如何得來的。

 

每一個方格的 F 值，再說一次，直接把 G 值和 H 值相加就能夠了。

 

繼續搜索(Continuing the Search)

爲了繼續搜索，咱們從 open list 中選擇 F 值最小的 ( 方格 ) 節點，而後對所選擇的方格做以下操做：

4.       把它從 open list 裏取出，放到 close list 中。

5.       檢查全部與它相鄰的方格，忽略其中在 close list 中或是不可走 (unwalkable) 的方格 ( 好比牆，水，或是其餘非法地形 ) ，若是方格不在open lsit 中，則把它們加入到 open list 中。

把咱們選定的方格設置爲這些新加入的方格的父親。

6.       若是某個相鄰的方格已經在 open list 中，則檢查這條路徑是否更優，也就是說經由當前方格 ( 咱們選中的方格 ) 到達那個方格是否具備更小的 G 值。若是沒有，不作任何操做。

相反，若是 G 值更小，則把那個方格的父親設爲當前方格 ( 咱們選中的方格 ) ，而後從新計算那個方格的 F 值和 G 值。若是你仍是很混淆，請參考下圖。

圖 4

Ok ，讓咱們看看它是怎麼工做的。在咱們最初的 9 個方格中，還有 8 個在 open list 中，起點被放入了 close list 中。在這些方格中，起點右邊的格子的 F 值 40 最小，所以咱們選擇這個方格做爲下一個要處理的方格。它的外框用藍線打亮。

 

首先，咱們把它從 open list 移到 close list 中 ( 這就是爲何用藍線打亮的緣由了 ) 。而後咱們檢查與它相鄰的方格。它右邊的方格是牆壁，咱們忽略。它左邊的方格是起點，在 close list 中，咱們也忽略。其餘 4 個相鄰的方格均在 open list 中，咱們須要檢查經由這個方格到達那裏的路徑是否更好，使用 G 值來斷定。讓咱們看看上面的方格。它如今的 G 值爲 14 。若是咱們經由當前方格到達那裏， G 值將會爲 20(其中 10 爲到達當前方格的 G 值，此外還要加上從當前方格縱向移動到上面方格的 G 值 10) 。顯然 20 比 14 大，所以這不是最優的路徑。若是你看圖你就會明白。直接從起點沿對角線移動到那個方格比先橫向移動再縱向移動要好。

 

當把 4 個已經在 open list 中的相鄰方格都檢查後，沒有發現經由當前方格的更好路徑，所以咱們不作任何改變。如今咱們已經檢查了當前方格的全部相鄰的方格，並也對他們做了處理，是時候選擇下一個待處理的方格了。

 

所以再次遍歷咱們的 open list ，如今它只有 7 個方格了，咱們須要選擇 F 值最小的那個。有趣的是，此次有兩個方格的 F 值都 54 ，選哪一個呢？沒什麼關係。從速度上考慮，選擇最後加入 open list 的方格更快。這致使了在尋路過程當中，當靠近目標時，優先使用新找到的方格的偏好。可是這並不重要。 ( 對相同數據的不一樣對待，致使兩中版本的 A* 找到等長的不一樣路徑 ) 。

 

咱們選擇起點右下方的方格，以下圖所示。

圖 5

 

此次，當咱們檢查相鄰的方格時，咱們發現它右邊的方格是牆，忽略之。上面的也同樣。

咱們把牆下面的一格也忽略掉。爲何？由於若是不穿越牆角的話，你不能直接從當前方格移動到那個方格。你須要先往下走，而後再移動到那個方格，這樣來繞過牆角。 ( 注意：穿越牆角的規則是可選的，依賴於你的節點是怎麼放置的 )

 

這樣還剩下 5 個相鄰的方格。當前方格下面的 2 個方格尚未加入 open list ，因此把它們加入，同時把當前方格設爲他們的父親。在剩下的3 個方格中，有 2 個已經在 close list 中 ( 一個是起點，一個是當前方格上面的方格，外框被加亮的 ) ，咱們忽略它們。最後一個方格，也就是當前方格左邊的方格，咱們檢查經由當前方格到達那裏是否具備更小的 G 值。沒有。所以咱們準備從 open list 中選擇下一個待處理的方格。

 

不斷重複這個過程，直到把終點也加入到了 open list 中，此時以下圖所示。

圖 6

 

注意，在起點下面 2 格的方格的父親已經與前面不一樣了。以前它的 G 值是 28 而且指向它右上方的方格。如今它的 G 值爲 20 ，而且指向它正上方的方格。這在尋路過程當中的某處發生，使用新路徑時 G 值通過檢查而且變得更低，所以父節點被從新設置， G 和 F 值被從新計算。儘管這一變化在本例中並不重要，可是在不少場合中，這種變化會致使尋路結果的巨大變化。

 

那麼咱們怎麼樣去肯定實際路徑呢？很簡單，從終點開始，按着箭頭向父節點移動，這樣你就被帶回到了起點，這就是你的路徑。以下圖所示。從起點 A 移動到終點 B 就是簡單從路徑上的一個方格的中心移動到另外一個方格的中心，直至目標。就是這麼簡單！

圖 7

 

A*算法總結(Summary of the A* Method)

Ok ，如今你已經看完了整個的介紹，如今咱們把全部步驟放在一塊兒：

1.         把起點加入 open list 。

2.         重複以下過程：

a.         遍歷 open list ，查找 F 值最小的節點，把它做爲當前要處理的節點。

b.         把這個節點移到 close list 。

c.         對當前方格的 8 個相鄰方格的每個方格？

◆     若是它是不可抵達的或者它在 close list 中，忽略它。不然，作以下操做。

◆     若是它不在 open list 中，把它加入 open list ，而且把當前方格設置爲它的父親，記錄該方格的 F ， G 和 H 值。

◆     若是它已經在 open list 中，檢查這條路徑 ( 即經由當前方格到達它那裏 ) 是否更好，用 G 值做參考。更小的 G 值表示這是更好的路徑。若是是這樣，把它的父親設置爲當前方格，並從新計算它的 G 和 F 值。若是你的 open list 是按 F 值排序的話，改變後你可能須要從新排序。

d.         中止，當你

◆     把終點加入到了 open list 中，此時路徑已經找到了，或者

◆     查找終點失敗，而且 open list 是空的，此時沒有路徑。

3.         保存路徑。從終點開始，每一個方格沿着父節點移動直至起點，這就是你的路徑。

上面原文：https://blog.csdn.net/weixin_44489823/article/details/89382502

=============================================================================================

下面是我本身實現的

 

在實現A*尋路過程當中，我本身有幾個點繞了很久

1.每一次找到下一個點後，搜索列表裏面的點的G是按照起點仍是當前點計算

我當前仍是按照當前點來計算的，這個我仍是有點疑問，須要本身想想

2.搜索列表裏面已有的點，在當前點改變時，若是爲當前點的附近點時，他的父節點是否變爲當前點

結果是不用的，這個應該是我剛開始沒看太明白；只有當前點的下一級點爲已有搜索點，而且當前點的索引<下一級點當前的父節點的索引時，纔將下一級點的父節點改成當前點

 

  1 using System;
  2 using System.Collections;
  3 using System.Collections.Generic;
  4 using System.Linq;
  5 using UnityEngine;
  6 
  7 public class CSPathFindManager : MonoBehaviour
  8 {
  9     private CopyObjs copyObjs;
 10 
 11     public Vector2 CellSize = new Vector2();
 12 
 13     public List<CSNode> AllNodesList = new List<CSNode>();
 14     public List<CSNode> curPathList = new List<CSNode>();
 15     public List<CSNode> closeNodeList = new List<CSNode>();
 16 
 17 
 18     public int notMoveNodeCount = 0;
 19     public CSNode curNode = null;
 20 
 21     public bool isEndFind = false;
 22 
 23     public bool isFinding = false;
 24 
 25     // Start is called before the first frame update
 26     void Start()
 27     {
 28         copyObjs = gameObject.GetComponentInChildren<CopyObjs>();
 29         if (copyObjs == null) return;
 30         InitAllPath();
 31     }
 32 
 33     // Update is called once per frame
 34     void Update()
 35     {
 36         if (Input.GetKeyDown(KeyCode.Space))
 37         {
 38             //InitNearNodes();
 39             isFinding = !isFinding;
 40         }
 41 
 42         if (isFinding)
 43         {
 44             InitNearNodes();
 45         }
 46     }
 47 
 48     public List<CSNode> GetNearNode(CSNode node)
 49     {
 50         List<CSNode> tempNode = AllNodesList.FindAll(temp => (temp.pos.x >= node.pos.x - 1 && temp.pos.x <= node.pos.x + 1) && (temp.pos.y >= node.pos.y - 1 && temp.pos.y <= node.pos.y + 1));
 51         if (tempNode != null) tempNode.Remove(node);
 52         return tempNode;
 53     }
 54 
 55     public bool IsChild(CSNode parentNode,CSNode childNode)
 56     {
 57         if (parentNode == null || childNode == null) return false;
 58         return childNode.pos.x >= parentNode.pos.x - 1 && childNode.pos.x <= parentNode.pos.x + 1 && childNode.pos.y >= parentNode.pos.y - 1 && childNode.pos.y <= parentNode.pos.y + 1;
 59     }
 60 
 61     public void InitNearNodes()
 62     {
 63         if (CSNode.StartNode == null || CSNode.FinialNode == null)
 64         {
 65             isFinding = false;
 66             return;
 67         }
 68         if (!isEndFind)
 69         {
 70             if (curNode == null)
 71             {
 72                 curNode = CSNode.StartNode;
 73                 curNode.SetIndex(0);
 74             }
 75             else if (curNode != CSNode.FinialNode)
 76             {
 77                 curNode = GetMinNodeByF(curPathList);
 78 
 79                 curNode.SetIndex(curNode.parent.Index + 1);
 80             }
 81             else
 82             {
 83                 isEndFind = true;
 84             }
 85         }
 86 
 87         if(isEndFind)
 88         {
 89             if (curNode!= null && curNode.parent != null && curNode.parent != CSNode.StartNode)
 90             {
 91                 curNode = curNode.parent;
 92                 curNode.SetMoveState(EnumMoveState.best);
 93             }
 94             else
 95             {
 96                 isFinding = false;
 97 
 98                 Debug.LogError("找到了！");
 99             }
100             return;
101         }
102         if (curNode.curMoveState == EnumMoveState.moveing) curNode.SetMoveState(EnumMoveState.select);
103         if (AllNodesList == null) return;
104         for (int i = 0; i < closeNodeList.Count; i++)
105         {
106             if (closeNodeList[i].curMoveState == EnumMoveState.select) closeNodeList[i].SetMoveState(EnumMoveState.path);
107         }
108         closeNodeList.Add(curNode);
109         curPathList.Remove(curNode);
110         List<CSNode> tempNearList = GetNearNode(curNode);
111         tempNearList.RemoveAll(temp => closeNodeList.Contains(temp));
112         RemoveNotMoveNode(ref tempNearList);
113 
114         for (int i = 0; i < tempNearList.Count; i++)
115         {
116             if (tempNearList[i].parent == null || tempNearList[i].parent.Index > curNode.Index)
117             {
118                 tempNearList[i].parent = curNode;
119             }
120         }
121 
122         curPathList.AddRange(tempNearList.FindAll(temp=>!closeNodeList.Contains(temp) && !curPathList.Contains(temp)));
123 
124         for (int i = 0; i < curPathList.Count; i++)
125         {
126             int gV = GetGValue(curNode, curPathList[i]);
127             int hV = GetCurNode(curPathList[i]);
128             curPathList[i].SetNodeInfo(gV,hV);
129         }
130         if (curPathList.Count == 0)
131         {
132             isFinding = false;
133             Debug.LogError("死路！");
134         }
135     }
136 
137     internal void ReSetPath()
138     {
139         curNode = null;
140         for (int i = 0; i < curPathList.Count; i++)
141         {
142             curPathList[i].SetIndex(0);
143             curPathList[i].parent = null;
144         }
145         curPathList.Clear();
146         for (int i = 0; i < closeNodeList.Count; i++)
147         {
148             if((int)closeNodeList[i].curMoveState > 4 && (int)closeNodeList[i].curMoveState < 8) closeNodeList[i].SetMoveState(EnumMoveState.moveing);
149             closeNodeList[i].parent = null;
150         }
151         closeNodeList.Clear();
152         isEndFind = false;
153     }
154 
155     public static int GetGValue(CSNode startNode,CSNode targetNode)
156     {
157         int gV = 14;
158         if (targetNode.pos.x == startNode.pos.x || targetNode.pos.y == startNode.pos.y) gV = 10;
159         int absX = (int)Mathf.Abs(targetNode.pos.x - startNode.pos.x);
160         int absY = (int)Mathf.Abs(targetNode.pos.y - startNode.pos.y);
161         if (absX > absY)
162         {
163             gV = 14 * absY + 10 * (absX - absY);
164         }
165         else
166         {
167             gV = 14 * absX + 10 * (absY - absX);
168         }
169         return gV;
170     }
171 
172     private void RemoveNotMoveNode(ref List<CSNode> tempNearList)
173     {
174         List<CSNode> notMoveNode = tempNearList.FindAll(temp=>temp.curMoveState == EnumMoveState.notmove);
175         tempNearList.RemoveAll(temp => temp.curMoveState == EnumMoveState.notmove);
176         for (int i = 0; i < notMoveNode.Count; i++)
177         {
178             if(notMoveNode[i].pos.y == curNode.pos.y || notMoveNode[i].pos.x == curNode.pos.x) tempNearList.RemoveAll(temp=>temp.pos.y != curNode.pos.y && temp.pos.x != curNode.pos.x && (temp.pos.x == notMoveNode[i].pos.x || temp.pos.y == notMoveNode[i].pos.y));
179             tempNearList.Remove(notMoveNode[i]);
180         }
181     }
182 
183     public CSNode GetMinNodeByF(List<CSNode> nodes)
184     {
185         if (nodes == null || nodes.Count == 0) return null;
186         nodes.Sort((x,y)=>x.FValue.CompareTo(y.FValue));
187         return nodes[0];
188     }
189 
190     public void InitAllPath()
191     {
192         AllNodesList.Clear();
193         curPathList.Clear();
194         closeNodeList.Clear();
195 
196         if (copyObjs == null) return;
197         copyObjs.MaxCount = (int)(CellSize.x * CellSize.y);
198 
199         int nodeIndex = 0;
200         System.Random tempRandom = new System.Random(GetRandomSeedbyGuid());
201 
202         for (int y = 0; y < CellSize.x; y++)
203         {
204             for (int x = 0; x < CellSize.y; x++)
205             {
206                 CSNode tempNode = copyObjs.copyObjList[nodeIndex].GetComponent<CSNode>();
207                 tempNode.SetPos(x,y);
208                 //int randomNumber = UnityEngine.Random.Range(0,100); //tempRandom.Next(0, 100);
209                 //                                                    //if (notMoveNodeCount < 3)
210                 //                                                    //{
211                 //                                                    //List<CSNode> tempList = GetNearNode(tempNode);
212                 //                                                    //int notMoveProb = (5 - notMoveNodeCount) / (171 - nodeIndex) * (tempList.Count + 1 + 5 - notMoveNodeCount);
213                 //    int tempPosIndex = notMovePos.FindIndex(pos => pos.x == x && pos.y == y);
214                 //    if (tempPosIndex >= 0)//x == 10 && y > 2)//randomNumber <= notMoveProb)
215                 //    {
216                 //        tempNode.SetMoveState(EnumMoveState.notmove);
217                 //        notMoveNodeCount++;
218                 //    }
219                 ////}
220 
221                 if (tempNode.curMoveState == EnumMoveState.NULL)
222                 {
223                     //randomNumber = UnityEngine.Random.Range(0, 100); //tempRandom.Next(0, 100);
224                     //if (CSNode.StartNode == null && x == 5 && y == 4)//randomNumber <= 2)
225                     //{
226                     //    tempNode.SetMoveState(EnumMoveState.start);
227                     //    startNode = tempNode;
228                     //}
229                     //else if (finialNode == null && x == 15 && y == 4)//randomNumber >= 98 && randomNumber < 100)
230                     //{
231                     //    tempNode.SetMoveState(EnumMoveState.finial);
232                     //    finialNode = tempNode;
233                     //}
234                     //else
235                     //{
236                         tempNode.SetMoveState(EnumMoveState.moveing);
237                     //}
238                 }
239 
240                 AllNodesList.Add(tempNode);
241                 nodeIndex++;
242             }
243         }
244     }
245 
246 
247 
248     static int GetRandomSeedbyGuid()
249     {
250         return new Guid().GetHashCode();
251     }
252 
253     int GetCurNode(CSNode node)
254     {
255         if (CSNode.FinialNode == null) return 99;
256         return (int)Mathf.Abs(node.pos.x - CSNode.FinialNode.pos.x) * 10 + (int)Mathf.Abs(node.pos.y - CSNode.FinialNode.pos.y) * 10;
257     }
258 }

View Code

  1 using System;
  2 using System.Collections;
  3 using System.Collections.Generic;
  4 using UnityEngine;
  5 using UnityEngine.EventSystems;
  6 using UnityEngine.UI;
  7 
  8 public enum EnumMoveState
  9 {
 10     NULL,
 11     moveing,
 12     notmove,
 13     start,
 14     finial,
 15     path,
 16     select,
 17     best,
 18 }
 19 
 20 public class CSNode : MonoBehaviour
 21 {
 22 
 23     private Text F;
 24     private Text G;
 25     private Text H;
 26     private Text PosText;
 27     private Text IndexText;
 28     private Image movePoint;
 29 
 30     public Vector2 pos;
 31     public int FValue;
 32     public int GValue;
 33     public int HValue;
 34     public int Index;
 35 
 36     public CSNode parent;
 37     public EnumMoveState curMoveState;
 38 
 39     private EventTrigger eventTrigger;
 40     private CSPathFindManager cSPathFindManager;
 41 
 42     public static CSNode StartNode;
 43     public static CSNode FinialNode;
 44     public static List<CSNode> NotMoveNodeList = new List<CSNode>();
 45 
 46     public CSNode(int _x,int _y)
 47     {
 48         pos.x = _x;
 49         pos.y = _y;
 50     }
 51 
 52     public static Dictionary<EnumMoveState, Color> pointColorDic = new Dictionary<EnumMoveState, Color>()
 53     {
 54         { EnumMoveState.moveing,Color.white},
 55         { EnumMoveState.notmove,Color.red},
 56         { EnumMoveState.start,Color.blue},
 57         { EnumMoveState.finial,Color.yellow},
 58         { EnumMoveState.path,Color.gray},
 59         { EnumMoveState.select,Color.cyan},
 60         { EnumMoveState.best,Color.green},
 61     };
 62     // Start is called before the first frame update
 63     void Awake()
 64     {
 65         F = transform.Find("F").GetComponent<Text>();
 66         G = transform.Find("G").GetComponent<Text>();
 67         H = transform.Find("H").GetComponent<Text>();
 68         PosText = transform.Find("Pos").GetComponent<Text>();
 69         IndexText = transform.Find("Index").GetComponent<Text>();
 70         movePoint = GetComponent<Image>();
 71         eventTrigger = gameObject.GetComponent<EventTrigger>();
 72         if (eventTrigger == null) eventTrigger = gameObject.AddComponent<EventTrigger>();
 73         List<EventTrigger.Entry> entryList = eventTrigger.triggers;
 74         if (entryList == null) entryList = new List<EventTrigger.Entry>();
 75         EventTrigger.Entry tempEntry = new EventTrigger.Entry();
 76         bool isExist = false;
 77         for (int i = 0; i < entryList.Count; i++)
 78         {
 79             if (entryList[i].eventID == EventTriggerType.PointerDown)
 80             {
 81                 tempEntry = entryList[i];
 82                 isExist = true;
 83                 break;
 84             }
 85         }
 86         tempEntry.callback.AddListener(OnClick);
 87         if (!isExist)
 88         {
 89             tempEntry.eventID = EventTriggerType.PointerDown;
 90             entryList.Add(tempEntry);
 91         }
 92         cSPathFindManager = GetComponentInParent<CSPathFindManager>();
 93     }
 94 
 95     private void OnClick(BaseEventData arg0)
 96     {
 97         SetMoveState((EnumMoveState)SetNextType());
 98         cSPathFindManager.ReSetPath();
 99     }
100 
101     public int SetNextType()
102     {
103         int tempType = ((int)curMoveState + 1) % 8;
104         if (tempType < 1 || tempType > 4) tempType = 1;
105         return tempType;
106     }
107 
108     // Update is called once per frame
109     void Update()
110     {
111         
112     }
113 
114     public void SetMoveState(EnumMoveState state)
115     {
116         if (state != curMoveState)
117         {
118             ResetNodeInfo(curMoveState, true);
119             ResetNodeInfo(state,false);
120             curMoveState = state;
121             if (movePoint) movePoint.color = pointColorDic[state];
122 
123         }
124     }
125 
126     public void ResetNodeInfo(EnumMoveState state,bool isDel = false)
127     {
128         switch (state)
129         {
130             case EnumMoveState.notmove:
131                 if (isDel)
132                 {
133                     NotMoveNodeList.Remove(this);
134                 }
135                 else
136                 {
137                     if (NotMoveNodeList.Contains(this)) NotMoveNodeList.Add(this);
138                 }
139                 break;
140             case EnumMoveState.start:
141                 if (isDel)
142                 {
143                     if (StartNode == this)
144                     {
145                         StartNode = null;
146                     }
147                 }
148                 else
149                 {
150                     if (StartNode != this)
151                     {
152                         if(StartNode != null)StartNode.SetMoveState(EnumMoveState.moveing);
153                         StartNode = this;
154                     }
155                 }
156                 break;
157             case EnumMoveState.finial:
158                 if (isDel)
159                 {
160                     if (FinialNode == this)
161                     {
162                         FinialNode = null;
163                     }
164                 }
165                 else
166                 {
167                     if (FinialNode != this)
168                     {
169                         if (FinialNode != null) FinialNode.SetMoveState(EnumMoveState.moveing);
170                         FinialNode = this;
171                     }
172                 }
173                 break;
174             default:
175                 break;
176         }
177         //Debug.LogErrorFormat("當前狀態：{0}; 是否刪除：{3} 起點:{1}; 終點:{2}",state,StartNode,FinialNode,isDel);
178     }
179 
180     public void SetNodeInfo(int _G,int _H)
181     {
182         FValue = _G + _H;
183         GValue = _G;
184         HValue = _H;
185         if (F) F.text = (_G + _H).ToString();
186         if (G) G.text = _G.ToString();
187         if (H) H.text = _H.ToString();
188     }
189 
190     internal void SetPos(int _x, int _y)
191     {
192         pos.x = _x;
193         pos.y = _y;
194         if (PosText) PosText.text = string.Format("{0},{1}", _x, _y);
195     }
196 
197     internal void SetIndex(int index)
198     {
199         Index = index;
200         if (IndexText) IndexText.text = string.Format("{0}", index);
201     }
202 }

View Code

 

 ==============================================================================================================================

暫時先這樣，後面補充

（今天你加班嗎 :> 我不加）