Dungeon generation algorithm is generating undesired results

Question

I wrote an algorithm to generate dungeons in Swift for iOS using SpriteKit. The code functions as expected generating regular polygons with four sides. But when I switch to an 8-way adjacency group, the generator starts messing up.

Here is the code that generates the dungeon with some screenshots of a single tile used to represent the rooms and hallways.

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")
    }
}

This code generates basic, clean-looking dungeons like these:

I drew up some tiles in Aseprite because I want to generate textured maps. I put them into an 8-way adjacency group so I could load them into the map. When I build and run, the code no longer generates regular four-sided polygons. I start getting undesirable results:

Like hallways that almost connect to one-another hallway but get cut off:

And irregularly shaped rooms:

These generate every time I run the code. It seems to only occur when I use an 8-way adjacency group instead of a single tile.

There doesn't seem to be any problems in the code itself. Just when I add the tile group it messes up. My desired result is rectangular rooms with hallways that connect to each other. Why does the tile group mess this up? And how can I fix it?

Here is an article that explains what the algorithm is doing and how it is doing it.