Question

首先让我为尺寸道歉，我会尽量保持尽可能小的

在尝试构建prim的算法后，确切地说它在维基百科上的说法我发现它不会像我构建的迷宫那样工作。所以我试图做同样的想法以适应我的迷宫，但我看到一个奇怪的错误，

当我的游戏开始时，它只是没有正确构建我的迷宫，我无法弄清楚原因偶尔会发生这种情况

Maze Error picture

其他时候它完美无缺，所以我有一个public Dictionary<int, Dictionary<int, MazeCellState>> maze这个迷宫开始迷宫的时候就是所有的对冲我然后继续建造这样的路径

private static void buildPath()
       {
           List<KeyValuePair<Misc.Cord, Misc.Cord>> ends = new List<KeyValuePair<Misc.Cord, Misc.Cord>>();
           ends.Add(new KeyValuePair<Misc.Cord, Misc.Cord>(new Misc.Cord() { X = 0, Y = 0 }, new Misc.Cord() { X = 0, Y = 0 }));
           Misc.Cord currentPos = null;

           while (ends.Count > 0)
           {
               int posKey = rand.Next(0, ends.Count);
               Misc.Cord lastPos = ends[posKey].Key;
               currentPos = ends[posKey].Value;
               maze[currentPos.X][currentPos.Y] = MazeCellState.Path;
               int currentCount = 0;

               MovingState moveTo1 = (MovingState)rand.Next(0, 4);
               MovingState moveTo2 = (MovingState)rand.Next(0, 4);
               while (moveTo1.Equals(moveTo2))
               {
                   moveTo1 = (MovingState)rand.Next(0, 4);
                   moveTo2 = (MovingState)rand.Next(0, 4);
               }

               // check left
               if (currentPos.X - 2 > 0 && maze[currentPos.X - 2][currentPos.Y] != MazeCellState.Path && currentCount < 2 && (moveTo1 == MovingState.Left || moveTo2 == MovingState.Left))
               {
                   if(!lastPos.Equals(new Misc.Cord() { X = currentPos.X - 2, Y = currentPos.Y }))
                   {
                       ends.Add(new KeyValuePair<Misc.Cord, Misc.Cord>(currentPos, new Misc.Cord() { X = currentPos.X - 2, Y = currentPos.Y }));
                       maze[currentPos.X - 1][currentPos.Y] = MazeCellState.Path;
                       currentCount++;
                   }
               }

               // check right
               if (currentPos.X + 2 < maze.Count && maze[currentPos.X + 2][currentPos.Y] != MazeCellState.Path && currentCount < 2 && (moveTo1 == MovingState.Right || moveTo2 == MovingState.Right))
               {
                   if (!lastPos.Equals(new Misc.Cord() { X = currentPos.X + 2, Y = currentPos.Y }))
                   {
                       ends.Add(new KeyValuePair<Misc.Cord, Misc.Cord>(currentPos, new Misc.Cord() { X = currentPos.X + 2, Y = currentPos.Y }));
                       maze[currentPos.X + 1][currentPos.Y] = MazeCellState.Path;
                       currentCount++;
                   }
               }

               // check Up
               if (currentPos.Y - 2 > 0 && maze[currentPos.X][currentPos.Y - 2] != MazeCellState.Path && currentCount < 2 && (moveTo1 == MovingState.Up || moveTo2 == MovingState.Up))
               {
                   if(!lastPos.Equals(new Misc.Cord() { X = currentPos.X, Y = currentPos.Y - 2}))
                   {
                       ends.Add(new KeyValuePair<Misc.Cord, Misc.Cord>(currentPos, new Misc.Cord() { X = currentPos.X, Y = currentPos.Y - 2 }));
                       maze[currentPos.X][currentPos.Y - 1] = MazeCellState.Path;
                       currentCount++;
                   }
               }

               // check Down
               if (currentPos.Y + 2 < maze[0].Count && maze[currentPos.X][currentPos.Y + 2] != MazeCellState.Path && currentCount < 2 && (moveTo1 == MovingState.Down || moveTo2 == MovingState.Down))
               {
                   if(!lastPos.Equals(new Misc.Cord() { X = currentPos.X, Y = currentPos.Y + 2}))
                   {
                       ends.Add(new KeyValuePair<Misc.Cord, Misc.Cord>(currentPos, new Misc.Cord() { X = currentPos.X, Y = currentPos.Y + 2 }));
                       maze[currentPos.X][currentPos.Y + 1] = MazeCellState.Path;
                       currentCount++;
                   }
               }
                ends.RemoveAt(posKey);
                ends = reorderList(ends);
           }

           maze[0][1] = MazeCellState.Path;
       }

我不确定为什么偶尔我会得到上面的图片，我的理论是它最终会重新开始自己的工作

一些快速说明，MazeCellState此时只能是2个选项之一，路径或对冲和reorderList将重新索引任何类型迷宫大小的列表从屏幕分辨率计算，每个单元格为64x64 PX，

            GraphicsDevice.Viewport.Width * 5 / 64,
            GraphicsDevice.Viewport.Height * 5 / 64

Answer 1

当您的字段是网格时，这实现算法真的很难。 Prim的网格算法可以更容易表达。而不是研究你的代码做错了什么，我会告诉你简单的方法。

创建网格，并将所有单元格从零开始连续编号。每个单元都有两个可以破坏的边界墙;向上和向左，向下或向右，或其他一些组合，只要你选择（左/右）和（上/下）之一就没关系。

现在选择任何一个单元格，然后选择其中一个墙壁。如果该墙另一侧的单元具有不同的数字（一个更高，一个更低），则打破该墙，然后在整个迷宫中，将所有出现的较高数字重新编号为较低的数字。如果您选择另一侧已经具有相同数字的单元格和墙壁，请不要尝试另一面墙，而是按顺序移动到下一个单元格，重复每行和向下（可能几乎一直骑自行车））直到你找到一个可以打破墙壁的牢房。

如果你有N个细胞，你必须完全重复这次破壁练习N-1次，直到最后一次所有细胞编号为零（因为每次你破坏时，你从田地中删除更高的数字），并且你有一个完整的迷宫。

如果你想要一个迷路，其路径通常是左上方而不是上下方，那么就可以随意选择哪条墙在那个方向上打破。这也适用于3D迷宫，你可能不需要很多梯子;只是不要选择打破这么多的天花板/地板。

在我描述了这个算法之后，我的14yo儿子用Turbo-Pascal在3D中实现了它，所以我知道算法和这个描述实际上是有效的。这实际上是Prim算法的一个版本，除非所有弧都具有相同的成本（或者所有左右的弧都有，所有上下的弧都有，等等）。关于它的巧妙之处在于编号的工作方式，以确定哪些单元格已经可以从哪些单元格到达。

C＃Maze Generation我自己实现了Prim的算法Bug

1 个答案: