Алгоритм генерации подземелий генерирует нежелательные результаты

Question

Я написал алгоритм генерации подземелий в Swift для iOS с использованием SpriteKit.Код работает, как и ожидалось, генерируя правильные многоугольники с четырьмя сторонами.Но когда я переключаюсь на группу смежности с 8 путями, генератор начинает портиться.

Вот код, который генерирует подземелье с некоторыми скриншотами одной плитки, используемой для представления комнат и прихожих.

import Foundation
import SpriteKit

private let mapWidth = 100
private let mapHeight = 100


class Room {
    // these values hold grid coordinates for each corner of the room
    var x1:Int
    var x2:Int
    var y1:Int
    var y2:Int

    var width:Int
    var height:Int

    // center point of the room
    var center:CGPoint

    init (x:Int, y:Int, w:Int, h:Int) {

        x1 = x
        x2 = x + w
        y1 = y
        y2 = y + h
        width = w
        height = h
        center = CGPoint(x: (x1 + x2) / 2,
                         y: (y1 + y2) / 2)
    }
    func intersects(room:Room) -> Bool {
        if y2 >= mapHeight - 1 || x2 >= mapWidth - 1 {
            return true
        }
        if x1 <= room.x2 + 2 && x2 >= room.x1 - 2 && y1 <= room.y2 + 2 && y2 >= room.y1 - 2 {
            return true
        }
        return false
    }
}

//******* 1 *******//
//******* 1 *******//
//******* 1 *******//

class TileEngine: SKNode {

    var rooms = [Room]()

    init (tileSize: CGSize) {
        super.init()

        let tile1 = SKTexture(imageNamed: "black")
        let tile2 = SKTexture(imageNamed: "red")

        let black = SKTileGroup(tileDefinition: SKTileDefinition(texture: tile1, size: CGSize(width: 32, height: 32)))
        let red = SKTileGroup(tileDefinition: SKTileDefinition(texture: tile2, size: CGSize(width: 32, height: 32)))

        let tileSet = SKTileSet(tileGroups: [black,red])

        let tileMap = SKTileMapNode(tileSet: tileSet, columns: mapWidth, rows: mapHeight, tileSize: tileSize)

        func createRooms() {

            for c in 0..<tileMap.numberOfColumns {
                for r in 0..<tileMap.numberOfRows  {
                    for i in 0..<rooms.count {
                       if rooms[i].x1 <= c && rooms[i].x2 >= c && rooms[i].y1 <= r && rooms[i].y2 >= r {
                            tileMap.setTileGroup(red, forColumn: c, row: r)
                        } else if tileMap.tileGroup(atColumn: c, row: r) != red && tileMap.tileGroup(atColumn: c, row: r) != red {
                        tileMap.setTileGroup(black, forColumn: c, row: r)
                        }
                    }
                }
            }
            self.addChild(tileMap)
            tileMap.setScale(0.3)
        }

        //******* 2 *******//
        //******* 2 *******//
        //******* 2 *******//

        func placeRooms() {

            let numberOfRooms = Int(arc4random_uniform(25) + 15)

            for i in 0..<numberOfRooms {
                let w = Int(arc4random_uniform(8) + 4);
                let h =  Int(arc4random_uniform(8) + 4);
                let x = Int(arc4random_uniform(UInt32(mapWidth)));
                let y = Int(arc4random_uniform(UInt32(mapHeight)));

                // create room with randomized values
                let newRoom = Room(x:x, y:y, w:w, h:h);

                var failed = false
                for otherRoom in rooms {
                    if newRoom.intersects(room: otherRoom) {
                        failed = true
                    }
                }
                if failed != true {
                    let newCenter = newRoom.center

                    if rooms.isEmpty != true {
                        let prevCenter = rooms[rooms.count - 1].center

                        let rand = Int(arc4random_uniform(2) + 1)

                        if rand == 1 {
                            hCorridor(x1: Int(prevCenter.x), x2: Int(newCenter.x), y: Int(prevCenter.y))
                            vCorridor(y1: Int(prevCenter.y), y2: Int(newCenter.y), x: Int(newCenter.x))
                        } else {
                            vCorridor(y1: Int(prevCenter.y), y2: Int(newCenter.y), x: Int(prevCenter.x))
                            hCorridor(x1: Int(prevCenter.x), x2: Int(newCenter.x), y: Int(newCenter.y))
                        }
                    }
                }
                if failed != true {
                    rooms.append(newRoom)
                }
            }
            createRooms()
        }

        //******* 3 *******//
        //******* 3 *******//
        //******* 3 *******//

        func hCorridor(x1: Int, x2:Int, y: Int) {
            for x in min(x1,x2)..<max(x1,x2) {
                tileMap.setTileGroup(red, forColumn: x, row: y)
            }
        }
        func vCorridor(y1: Int, y2:Int, x: Int) {
            for y in Int(min(y1,y2))..<Int(max(y1,y2) + 1) {
                tileMap.setTileGroup(red, forColumn: x, row: y)
            }
        }

        placeRooms()
    }
    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}

Этот код создает базовые, чистые на вид подземелья, подобные этим:

Я создал несколько плиток в Aseprite, потому что я хочу создавать текстурированные карты.Я поместил их в группу смежности с 8 путями, чтобы я мог загрузить их в карту.Когда я строю и запускаю, код больше не генерирует правильные четырехсторонние многоугольники.Я начинаю получать нежелательные результаты:

Как прихожие, которые почти соединяются друг с другом, но отключаются:

И нерегулярнофасонные комнаты:

Они генерируются каждый раз, когда я запускаю код.Кажется, это происходит только тогда, когда я использую группу смежности с 8 путями вместо одной плитки.

В самом коде, похоже, нет никаких проблем.Просто, когда я добавляю группу плиток, она портится.Мой желаемый результат - прямоугольные комнаты с коридорами, которые соединяются друг с другом.Почему группа плиток испортила это?И как я могу это исправить?

Здесь - статья, которая объясняет, что делает алгоритм и как он это делает.