寫在前面：之前看過一點，然后看不懂，也沒用過，
最近正好重構專案看到尋路這塊，想起來就去查查資料，總算稍微理解一點了，下面記錄一下自己的成果（哈哈哈 :> ）
下面分享幾篇我覺得挺不錯的文章
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 = https://www.cnblogs.com/lovewaits/p/_G + _H; 183 GValue =https://www.cnblogs.com/lovewaits/p/ _G; 184 HValue =https://www.cnblogs.com/lovewaits/p/ _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
==============================================================================================================================
暫時先這樣，后面補充
（今天你加班嗎 :> 我不加）
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/49716.html
標籤：其他
上一篇：演算法初探 - 鏈式前向星