Retarded Dungeon Generator

import turtle, random

MAX_CORRIDOR_LENGTH = 7

def get_map_size(tile_map):
    return (len(tile_map), len(tile_map[0]))

def get_neighbor_count(tile_map, coord):
    count = 0
    h, w = get_map_size(tile_map)
    if (coord[0] > 0 and tile_map[coord[0]-1][coord[1]] > 0):
        count += 1
    if (coord[0] < h-1 and tile_map[coord[0]+1][coord[1]] > 0):
        count += 1
    if (coord[1] > 0 and tile_map[coord[0]][coord[1]-1] > 0):
        count += 1
    if (coord[1] < w-1 and tile_map[coord[0]][coord[1]+1] > 0):
        count += 1
    return count

def get_corridor_length(tile_map, coord, direction):
    offsets = ((-1, 0), (0, 1), (1, 0), (0, -1))
    h, w = get_map_size(tile_map)
    new_coord = coord
    length = 0
    while (new_coord[0] in range(h) and new_coord[1] in range(w)) and tile_map[new_coord[0]][new_coord[1]] > 0:
        length += 1
        new_coord = tuple(map(sum, zip(new_coord, offsets[direction])))
    return length

def gen_path_tree(w, h):
    offsets = ((-1, 0), (0, 1), (1, 0), (0, -1))

    tile_map = [[0 for x in range(w)] for y in range(h)]
    start = (random.randint(0, h-1), random.randint(0, w-1), 1)
    tile_map[start[0]][start[1]] = start[2]
    stack = [start]
    while len(stack) > 0:
        if (len(stack) >= 2 and random.randint(0, 1) == 1):
            k, l = stack.pop(), stack.pop()
            stack.append(k)
            stack.append(l)
        coord = stack.pop()
        for o in offsets:
            next_coord = tuple(map(sum, zip(coord, o)))+(coord[2]+1,)
            if next_coord[0] in range(0, h) and next_coord[1] in range(0, w):
                if get_neighbor_count(tile_map, next_coord) == 1:
                    stack.append(next_coord)
                    tile_map[next_coord[0]][next_coord[1]] = next_coord[2]
    return tile_map

def isolate_path(tile_map):
    offsets = ((-1, 0), (0, 1), (1, 0), (0, -1))
    h, w = get_map_size(tile_map)
    max_coord = (0, 0)
    for y in range(h):
        for x in range(y):
            if tile_map[y][x] > tile_map[max_coord[0]][max_coord[1]]:
                max_coord = (y, x)
    stack = [max_coord]
    new_map = [[0 for x in range(w)] for y in range(h)]
    while len(stack) > 0:
        coord = stack.pop()
        new_map[coord[0]][coord[1]] = tile_map[coord[0]][coord[1]]
        for o in offsets:
            new_coord = tuple(map(sum, zip(coord, o)))
            if new_coord[0] in range(h) and new_coord[1] in range(w):
                if tile_map[new_coord[0]][new_coord[1]] < tile_map[coord[0]][coord[1]]:
                    stack.append(new_coord)
    return new_map

# this is just here to prevent rooms from being cut off
def add_padding(tile_map, width):
    h, w = get_map_size(tile_map)
    new_map = [[0 for x in range(w+(width*2))] for y in range(h+(width*2))]
    for y in range(h):
        for x in range(w):
            new_map[y+width][x+width] = tile_map[y][x]
    return new_map

def plot_rooms(tile_map):
    h, w = get_map_size(tile_map)
    room_map = [[0 for x in range(w)] for y in range(h)]
    max_coord = (-1, -1, 0)
    for y in range(h):
        for x in range(w):
            if tile_map[y][x] > max_coord[2]:
                max_coord = (y, x, tile_map[y][x])
    room_map[max_coord[0]][max_coord[1]] = 1
    for y in range(h):
        for x in range(w):
            if tile_map[y][x]%10 == 1:
                room_map[y][x] = 1
    return room_map

def apply_pattern(old_map, pattern, replacement):
    tile_map = [x[:] for x in old_map]
    ht, wt = get_map_size(tile_map)
    hp, wp = get_map_size(pattern)
    blacklist = []
    for y in range(ht-(hp-1)):
        for x in range(wt-(wp-1)):
            works = True
            for y2 in range(hp):
                for x2 in range(wp):
                    if (pattern[y2][x2] > -1 and tile_map[y+y2][x+x2] != pattern[y2][x2]) or \
                        ((y+y2, x+x2) in blacklist and pattern[y2][x2] > 0 and tile_map[y+y2][x+x2] > 0):
                        works = False
                if not works:
                    break
            if works:
                for y2 in range(hp):
                    for x2 in range(wp):
                        if replacement[y2][x2] > 0:
                            tile_map[y+y2][x+x2] = replacement[y2][x2]
                            blacklist.append((y+y2, x+x2))
    return tile_map

def enlarge_rooms(room_map):
    patterns = (
        (
            ( 0, 0, 0, 0, 0),
            ( 0, 0, 0, 0, 0),
            (-1,-1, 0,-1,-1),
            (-1,-1, 1,-1,-1)),
        (
            (-1,-1, 1,-1,-1),
            (-1,-1, 0,-1,-1),
            ( 0, 0, 0, 0, 0),
            ( 0, 0, 0, 0, 0)),
        (
            (-1,-1, 0, 0),
            (-1,-1, 0, 0),
            ( 1, 0, 0, 0),
            (-1,-1, 0, 0),
            (-1,-1, 0, 0)),
        (
            ( 0, 0,-1,-1),
            ( 0, 0,-1,-1),
            ( 0, 0, 0, 1),
            ( 0, 0,-1,-1),
            ( 0, 0,-1,-1))
    )

    replacements = (
        (
            (0, 0, 0, 0, 0),
            (0, 0, 0, 0, 0),
            (0, 0, 1, 0, 0),
            (0, 0, 1, 0, 0)),
        (
            (0, 0, 1, 0, 0),
            (0, 0, 1, 0, 0),
            (0, 0, 0, 0, 0),
            (0, 0, 0, 0, 0)),
        (
            (0, 0, 0, 0),
            (0, 0, 0, 0),
            (1, 1, 0, 0),
            (0, 0, 0, 0),
            (0, 0, 0, 0)),
        (
            (0, 0, 0, 0),
            (0, 0, 0, 0),
            (0, 0, 1, 1),
            (0, 0, 0, 0),
            (0, 0, 0, 0))
    )
    new_rooms = [x[:] for x in room_map]
    for i in range(2):
        for j in range(4):
            new_rooms = apply_pattern(new_rooms, patterns[j], replacements[j])
    return new_rooms

def combine(map_1, map_2):
    h1, w1 = get_map_size(map_1)
    h2, w2 = get_map_size(map_2)
    h = max(h1, h2)
    w = max(w1, w2)
    new_map = [[0 for x in range(w)] for y in range(h)]
    for y in range(h):
        for x in range(w):
            if y < h1 and x < w1:
                new_map[y][x] = map_1[y][x]
            if y < h2 and x < w2 and map_2[y][x] > new_map[y][x]:
                new_map[y][x] = map_2[y][x]
    return new_map

def turtle_print(tile_map):
    h, w = get_map_size(tile_map)
    turtle.setup(w*4, h*4)
    turtle.setworldcoordinates(0,h,w,0)
    turtle.up()
    turtle.speed(0)
    turtle.tracer(100)
    for y in range(h):
        for x in range(w):
            if tile_map[y][x] > 0:
                turtle.goto(x, y)
                turtle.dot(4)
    turtle.exitonclick()

tree = gen_path_tree(45,45)
tree = isolate_path(tree)
tree = add_padding(tree, 5)
rooms = plot_rooms(tree)
rooms = enlarge_rooms(rooms)
final = combine(tree, rooms)
turtle_print(final)