[A*算法]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

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

暂时先这样，后面补充

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