写在前面：之前看过一点，然后看不懂，也没用过。
最近正好重构项目看到寻路这块，想起来就去查查资料，总算稍微理解一点了，下面记录一下自己的成果（哈哈哈 :> ）
下面分享几篇我觉得挺不错的文章
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 } 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 }
==============================================================================================================================
暂时先这样，后面补充
（今天你加班吗 :> 我不加）
来源：oschina
链接：https://my.oschina.net/u/4334340/blog/4286879