Алгоритм создания сегмента лабиринта - PullRequest
9 голосов
/ 15 апреля 2010

Я хочу создать лабиринт, который выглядит следующим образом: alt text

То есть он состоит из путей в одном направлении, которые затем соединяются. Я искал алгоритм для создания лабиринтов, как это без успеха.

В частности, я не хочу такой лабиринт:

Maze

потому что он не «бежит» только в одном направлении.

Кроме того, было бы неплохо, если бы решение этого лабиринта потребовало от игрока «отступить» - то есть не просто постоянно двигаться вверх.

Ответы [ 6 ]

4 голосов
/ 15 апреля 2010

Ну, это было весело! В комплекте с выходом ASCII art я представляю ...

█    ██████    █████████████████████    █
█    █                             █    █
█    █                             █    █
█    █    ██████████████████████████    █
█                                       █
█                                       █
██████    ██████    ███████████    ██████
█    █    █              █         █    █
█    █    █              █         █    █
███████████████████████████████    ██████
█                                       █
█                                       █
██████    █████████████████████    ██████
█                             █         █
█                             █         █
██████    ███████████    ███████████    █
█              █                   █    █
█              █                   █    █
█████████████████████    ██████    ██████
█         █              █              █
█         █              █              █
███████████████████████████████    ██████
█                                       █
█                                       █



    private struct Cell
    {
        public bool visited;
        public bool right;
        public bool top;
    }

    static void Main(string[] args)
    {
        Random Rand = new Random();

        int size = 8;

        var maze = new Cell[size,size];

        for (int x = 0; x < size; x++)
            for (int y = 0; y < size; y++)
            {
                maze[x, y] = new Cell() { right = true, top = true, visited = false };
            }

        int count = size * size;

        int positionX = Rand.Next(size);

        // mark space below (outside matrix)

        for (int y = 0; y < size; y++)
        {
            maze[positionX, y].top = false; maze[positionX, y].visited = true;
            count--;

            // move left or right n spaces
            int n = Rand.Next(size);                    // random left or right by an amount n
            int direction = (Rand.Next(2) == 0) ? 1 : -1; 
            while (positionX + direction > 0 && positionX + direction < size -1 && n-- > 0)
            {
                // moving sideways
                if (direction == -1)
                {
                    positionX += direction;
                    maze[positionX, y].right = false;
                    maze[positionX, y].visited = true;
                    count--;
                }
                else
                {
                    maze[positionX, y].right=false;
                    positionX += direction;
                    maze[positionX, y].visited = true;
                    count--;
                }
            }
        }


        // Now pick a random place we have visited and extend into new territory
        while (count > 0)
        {
            int x = Rand.Next(size);
            int y = Rand.Next(size);
            if (!maze[x, y].visited) continue;      // not visited yet

            // We are on a visited node, where can we go from here?

            // Pick a direction to break down a wall - favor left right
            if (Rand.Next(4) > 0)
            {
                if (Rand.Next(2) == 1 && x < size-1 && !maze[x+1,y].visited )
                    { maze[x,y].right = false; maze[x+1,y].visited = true; count--;}
                else if (x > 0 && !maze[x-1,y].visited)
                    {maze[x-1,y].right = false; maze[x-1,y].visited = true; count--;}
            }
            else
            {
                if (Rand.Next(2) == 1 && y < size - 1 && !maze[x, y + 1].visited)
                    { maze[x, y].top = false; maze[x, y+1].visited = true; count--; }
                else if (y > 0 && !maze[x, y-1].visited)
                    { maze[x, y-1].top = false; maze[x,y-1].visited = true; count--; }
            }
        }

        // Dump the maze
        for (int y = 0; y < size; y++)
        {
            Console.Write("█");
            for (int x = 0; x < size; x++)
                Console.Write((maze[x, y].top) ? "█████" : "    █");
            Console.WriteLine();

            for (int repeat = 0; repeat < 2; repeat++)
            {
                Console.Write("█");
                for (int x = 0; x < size; x++)
                {
                    Console.Write(maze[x, y].right ? "    █" : "     ");
                }
                Console.WriteLine();
            }
        }
4 голосов
/ 15 апреля 2010
  1. создать случайный путь между точкой A и B
  2. случайным образом добавляйте стены, пока они не лежат на пути, пока вы не будете удовлетворены
0 голосов
/ 26 апреля 2012

Используйте алгоритм Эллера и введите смещение в горизонтальном направлении.

0 голосов
/ 15 апреля 2010

Если я вас правильно понимаю, вы хотите, чтобы ваше решение никогда не падало (когда вход снизу, а выход сверху).

Я думаю, что простой способ - это сначала создать простую горизонтальную карту, выбрав одну случайную дыру в каждом слое, например:

+--------------- +
+                +
+--- ------------+
+                +
+-------------- -+
+                +
+-------- -------+
+                +
+ ---------------+

Вы уже определили, куда идет путь решения. Теперь просто сделайте некоторую путаницу: удалите где-нибудь случайный горизонтальный край, затем добавьте вертикальный край, который предотвращает его использование, в строке выше или ниже нового отверстия, случайным образом выбранной между отверстием и тем, куда идет реальное решение. (Вам необходимо убедиться, что вы не удалили горизонтальный край между двумя участками пути решения.)

Я думаю, это будет работать очень хорошо. Впрочем, он может не слишком легко генерировать большие (многорядные) ложные пути.

0 голосов
/ 15 апреля 2010

Вот еще один:

  1. Добавьте стены к границам комнаты.
  2. Выберите несколько случайных точек на границах и в середине комнаты. За каждое место:
  3. Если из этого места есть направления туда, где еще нет стены, выберите случайное свободное направление и «вырастите» там стену. В противном случае удалите это место из списка.
  4. Дайте ему 20% шанс прорасти зародышем, и если это да, то добавьте это место в список.
  5. Если в списке больше мест, выберите следующий и перейдите к # 2. В противном случае получил # 5.
  6. Если есть свободные места, добавьте их в список. За каждое свободное место:
  7. «Постройте» стену по направлению к ближайшей стене, чтобы они встретились.
0 голосов
/ 15 апреля 2010

Просто используйте A * Search, чтобы убедиться, что вы всегда сможете найти путь до конца, а затем для каждого ряда добавьте двадцать случайно расположенных стен. Если A * не может дойти до конца после того, как вы поместили новый ряд вниз, используйте обратный ход, чтобы восстановить новый набор стен, пока он не заработает. Возможно, не самый эффективный метод, но я думаю, что он будет работать достаточно хорошо большую часть времени.

...