通过俄罗斯方块浅谈游戏中的AI(六)变化的A*算法

开场：

A*这个经典的最短路径搜索算法--很多人都用过它快速计算迷宫出路，也有人用来进行2d游戏的路径搜索。总之在搜索路径时大都第首先想到它。

---

简述A*最短路径算法的方法：

 

目标：从当前位置A到目标位置B找到一条最短的行走路径。

方法：从A点开始，遍历所有的可走路径，记录到一个结构中，记录内容为（位置点，最小步数）

       当任何第二次走到一个点的时候，判断最小步骤是否小于记录的内容，如果是，则更新掉原最小步数，

一直到所有的路径点都不能继续都了为止，最终那个点被标注的最小步数既是最短路径，而反向找跟它相连的步数相继少一个值的点连起来就形成了最短路径，当多个点相同，则任意取一条即可。

总结：A*算法实际是个穷举算法，也与课本上教的最短路径算法类似。课本上教的是两头往中间走，也是所有路径都走一次，每一个点标注最短值。

---

进入正题：A*在俄罗斯方块游戏中的应用。

 

最早的版本中，我已经在Tetris游戏中加入了A*算法，它不计算方块变形操作的，是传统A*算法的一个简单变形。差别仅在于：原算法通常是仅占一个坐标点，现在是占几个坐标点。所有的思路和算法都是相同的。同时，我应用这个路径算法的目的是判断是否有有效路径，所以并没有存储步数也并没有求最短路径。

本文主要讨论的并非这个版本的A*变化，而是包含方块变化的A*路径搜索算法。

 

 

大家都知道，俄罗斯方块在移动过程中，经常需要变化一下形势才能移动到更好的位置，如果我们找到了一个最好位置，就必须找到一条可以达到这个位置的路径去实现它，如果路径找不到，目标位置再好也不可以。

 

本算法的思路归纳如下：

 

 

1、数据结构：

  存储结构1(所有路径点的富存储):步骤目标点(x,y)，目标样式hash值，移动次数;

  存储结构2(快速查找是否重复的贫存储):前三个值再次做一次hash，但这个hash是绝对不能重复的那种运算，然后借助C#本身的数据结构Dictionary<hash,times>存储所有找到点。

  描述：用结构2的目的是减少查找匹配速度，而由于hash本身可能是不可逆的，我在写思路的时候，必须标明使用两个结构存储

 实际过程中我会将x，y，hash值用位操作同时存储于一个int中，实际仅用存储结构2。

2、算法搜索路径规则：

 起始位置：如果刚开始游戏的时候，要下降10多行才需要变形即可，可以完全不需要计算前10多行的情况，也就是可以做一个开始路径优化，但A*算法的优势就是路径最短，起始位置并不用做这个优化，也不会带来太多次的计算。

 可选位移：A*s算法默认可选方向通常是上下左右,根据需要可能加入斜着4个方向;

  然而我们的位移必须加上变形位移.由于方块不能向上移动,所以初步分析只允许{左移,右移,下落一格,变形}几个操作.

 高级分析,实际游戏中通常下降我们会使用快速下降和瞬间下降两个操作,而这两个操作会大大减少路径搜寻时间,如果在A*中加入这个步骤可能会降低总步骤,而且会让路径看起来更舒服.

分析后一种高级方案的弊端:由于瞬间下落的可行度与一步位移的可行度计算复杂度完全不一样,可能造成算法复杂度的膨胀.路径结构需要修改,路径点的回溯寻找算法也会出现变化,必须用一个图记住所有路径.综合考虑,不适用高级分析所提出的思路解决问题.

3、找到目标后路径确定(让搜索出来的路径更和谐)：

除了路径最短以外，还应该注意下面两点

尽量少的拐点（别让观众以为电脑是个疯子）；

横向位移尽量短（避免在高速下落的状态下，横向位移达不到目标就停止）；

为达到上面两个额外目标，我们必须在所有可选路径中按照一定的规则进行查找。

我总结的规则是：尽量先横移到目标，然后再下降，同一层的横移尽量少于3个单位。

 

public struct AStarRoot { public int X; public int Y; public int ThisHash; public int StepCount; public SetOfTetris TheSet; public List<AStarRoot> allComeRoot; //所有可以到达这步的点 public AStarRoot(int x,int y,SetOfTetris theSet,int stepCount ) { X = x; Y = y; // 由于X可能小于0 ，给它加上4再位移就ok了 ThisHash = (X + 4) << 16 | Y << 8 | theSet.GetHashCode(); TheSet = theSet; StepCount = stepCount; allComeRoot = new List<AStarRoot>(); } }

2.A*算法：主体,主体分两个步骤，前面都说过了

  /// <summary> /// 变形的A*算法 /// </summary> /// <param name="nowSituation">当前局势</param> /// <param name="AimPosition">目标位置</param> /// <param name="theAimTetris">目标块的样子</param> /// <param name="theDroppingPosition">起始位置</param> /// <param name="theDroppingTetris">当前下落的块</param> /// <param name="theRoad">解</param> /// <returns>是否有解</returns> private bool AStartMethod(List<int> nowSituation, XYPair AimPosition, SetOfTetris theAimTetris, XYPair theDroppingPosition, SetOfTetris theDroppingTetris, out List<WayPoint> theRoad) { theRoad = new List<WayPoint>(); //参数判断，不判断目标位置是否能放得住，判断是否能移动过去 //当目标型不一样的情况下，或者目标位置的Y坐标小于当前起始坐标Y，直接返回失败 if (theAimTetris.TheType != theDroppingTetris.TheType || AimPosition.Y < theDroppingPosition.Y) return false; //A*算法本身没有必要使用递归，要建立一个类似堆的存储空间，专门存储走过路点的信息； #region 第一步，遍历所有路径 ... #region 第二步：找到所有路径后，回退找合适的最短路径 ... return false; }

 

3.A*算法内部第一步片段：遍历所有路径

//A*算法本身没有必要使用递归，要建立一个类似堆的存储空间，专门存储走过路点的信息； #region 第一步，遍历所有路径 //第一个int是AStarRoot.ThisHash，第二个AStarRoot 是Root；这里不记录最小步数,最小步数记录在AStarRoot中 Dictionary<int, AStarRoot> allRoat = new Dictionary<int, AStarRoot>(); //下一步需要计算的所有点 List<AStarRoot> allNeedToCalculate = new List<AStarRoot>(); //第0步的初始化 AStarRoot theFirstRoot = new AStarRoot(theDroppingPosition.X, theDroppingPosition.Y, theDroppingTetris,0); allRoat.Add(theFirstRoot.ThisHash, theFirstRoot); allNeedToCalculate.Add(theFirstRoot); //目标的初始化 AStarRoot theEndRoot = new AStarRoot(AimPosition.X, AimPosition.Y, theAimTetris,0); int theEndHash = theEndRoot.ThisHash; int step = 0; //是否可以结束 bool finish = false; while (!finish) { step++; List<AStarRoot> temps = new List<AStarRoot>(); //得到所有应该计算的点的下一步可能值 for (int i = 0; i < allNeedToCalculate.Count; i++) { #region 得到所有可能的方向，下降，左，右，变形左，变形右 //注意顺序是下降，横移，变形，因为后面反向查找的时候，先看下降、再看横移、再看变形 //为什么查找路径的时候先查看下降的是因为，最后下降的走法最安全，担心最后横移或变形的会因为速度太快而操作失败。 //下落 if (insideAStartInit(ref nowSituation, ref allRoat, ref temps, allNeedToCalculate[i], allNeedToCalculate[i].X, allNeedToCalculate[i].Y + 1, allNeedToCalculate[i].TheSet, step) == theEndHash || //左 //AStarRoot leftOneTemp = new AStarRoot(allNeedToCalculate[i].X - 1, allNeedToCalculate[i].Y, allNeedToCalculate[i].TheSet, step); insideAStartInit(ref nowSituation, ref allRoat, ref temps, allNeedToCalculate[i], allNeedToCalculate[i].X - 1, allNeedToCalculate[i].Y, allNeedToCalculate[i].TheSet, step) == theEndHash || //右 insideAStartInit(ref nowSituation, ref allRoat, ref temps, allNeedToCalculate[i], allNeedToCalculate[i].X + 1, allNeedToCalculate[i].Y, allNeedToCalculate[i].TheSet, step) == theEndHash || //变形左 insideAStartInit(ref nowSituation, ref allRoat, ref temps, allNeedToCalculate[i], allNeedToCalculate[i].X, allNeedToCalculate[i].Y, allNeedToCalculate[i].TheSet.LeftNext, step) == theEndHash || //变形右 insideAStartInit(ref nowSituation, ref allRoat, ref temps, allNeedToCalculate[i], allNeedToCalculate[i].X, allNeedToCalculate[i].Y, allNeedToCalculate[i].TheSet.RightNext, step) == theEndHash) { finish = true; break; } #endregion } //找不到了 if (temps.Count == 0) { return false; } //还需要继续找 allNeedToCalculate.Clear(); allNeedToCalculate.AddRange(temps); } #endregion

 

4.A*算法中调用的内部函数，用了一堆的ref，为了降低代码量才这么干的

private int insideAStartInit(ref List<int> nowSituation,ref Dictionary<int, AStarRoot> allRoat,ref List<AStarRoot> temps,AStarRoot theLastRoot, int x,int y,SetOfTetris theSet,int step) { AStarRoot tempOne = new AStarRoot(x,y,theSet, step); tempOne.allComeRoot.Add(theLastRoot); //先计算是否存在，这个算法的计算量稍低！ //存在了则不用计算了，根本不需要判断步数是否比原来的少，因为不可能找到更少的步骤。 if (!allRoat.ContainsKey(tempOne.ThisHash)) { //再计算位置是否可以，如果可以，则添加到字典中 if (insidePositionIsPermit(nowSituation, new XYPair(x, y), theSet)) { temps.Add(tempOne); allRoat.Add(tempOne.ThisHash, tempOne); tempOne.allComeRoot.Add(theLastRoot); } } //当找到了以后，如果发现步数一样，则也算一种解。 else if (allRoat[tempOne.ThisHash].StepCount == step) { if (!allRoat[tempOne.ThisHash].allComeRoot.Contains(allRoat[theLastRoot.ThisHash])) allRoat[tempOne.ThisHash].allComeRoot.Add(allRoat[theLastRoot.ThisHash]); } return tempOne.ThisHash; }

 

5.A*算法中的第二步片段：

#region 找到所有路径后，回退找合适的最短路径 //回退找的前提是，前面是正常finish的，而且已经在路径中加入了最终结点的，通常正常finish的肯定有结点，这个为了双保险 if (finish && allRoat.ContainsKey(theEndHash)) { //内部储存当前路径回退到的位置，第一步复制最后一个结点，一点点往回找 int theHashNow = theEndHash; //当前查找的进度， //0 下降的；1 横移的；2变形的；3找不到，重新回来找。 //%%%%%%%%通常先变形，后横移，最后下降，所以倒着找Road按照正好相反的路走。%%%%%%%%% //当重新回来找的情况下，必须插入一个路点，说明这是个拐点。除了拐点，都不需要插入路点，成型会自动走：比如连续下降10行，不用一行一行加路点，加一个就可以了 int findStep = 3; #region while Begin step--; //当前的step应该是路径长度，第一个路径就是终点，已经加入了，所以要－－； while (true) { //当需要加入一个路点的情况下，要生成一个路点，并加入到路径中的第一位，因为是倒叙找，每次都加最前面。 //注意，当所有的查找进度完成的情况下，就要加入路点，加入路点后，重新搜索这个点的所有路径，所以不能step--； if (findStep == 3) { //这里不执行 step-- 为了避免出现死循环，必须加入一个必要判断，路点数量不能超过40！已经足够大了通常不会超过5. if (theRoad.Count > 40) return false; WayPoint oneTempWay = new WayPoint(new XYPair(allRoat[theHashNow].X, allRoat[theHashNow].Y), allRoat[theHashNow].TheSet); theRoad.Insert(0, oneTempWay); findStep = 0; } else step--; //当走到头了，就成功退出 if (step == 0) return true; //当没有走到头，目标位置的所有来的路线已经为0了，就使失败了，实际这是不可能的，但是确实出现了这个情况，是个bug if (allRoat[theHashNow].allComeRoot.Count == 0) return false; //在当前搜寻步骤下，是否找到了目标，比如竖向搜寻的时候，是否找到了竖向的路径 bool find = false; //存储路径中所有的方向备选值，在当前搜索方案未果的情况下继续找下一个可能的步骤//竖向的是最先查找的，不需要存储。 int theHorizentalHash = 0; int theChangeHash = 0; //便利所有的可选解，下降的，横移的，变形的 foreach (AStarRoot tempRoot in allRoat[theHashNow].allComeRoot) { //必须是最短路径的可选集合 if (tempRoot.StepCount > step) continue; if (tempRoot.Y == allRoat[theHashNow].Y - 1) { if (findStep == 0) { find = true; //找到了,继续 theHashNow = tempRoot.ThisHash; break; } } else if (tempRoot.X != allRoat[theHashNow].X) { if (findStep == 1) { find = true; //找到了，继续 theHashNow = tempRoot.ThisHash; break; } else //当前不是找横向的情况下，记录到临时变量中，一旦竖向的没有找到，切换到找横向的情况下，可以直接给它值，而不需要下次遍历。 { theHorizentalHash = tempRoot.ThisHash; } } else { if (findStep == 2) { find = true; //找到了 由于旋转比较危险，有可能卡住，所以一旦旋转，则必须一步一个路点。 theHashNow = tempRoot.ThisHash; findStep = 3; step--; break; } else //同上描述 { theChangeHash = tempRoot.ThisHash; } } } //没有找到预订目标的情况下的做法 if (!find) { //当查找竖向的，却没有找到值，则自动切换到横向 if (findStep == 0) { findStep = 1; //判断横向预存的值是否有效，有效则标明找到了 if (theHorizentalHash != 0) { theHashNow = theHorizentalHash; continue; } } //当查找横向的没有找到，则自动切换到变形 if (findStep == 1) { findStep = 2; if (theChangeHash != 0) { theHashNow = theChangeHash; findStep = 3; step--; continue; } } //所有的都没有找到，则切换到 状态3 找不到 这时，等待添加路点，重新找。 findStep = 3; } } #endregion } #endregion

 

源代码思想上就是这样，但是实际代码可能会根据版本不同有一定调整，希望看到最新代码就下载下面的连接。

或者返回开场那个连接，那里总是最新的通过俄罗斯方块浅谈游戏中的AI(序)

 

---

 

 源代码下载