Circle Maze

# Circular maze generator
# @eigenbom

from random import randint, sample
from operator import xor
import math
import pygame

TITLE = 'MAZE'

WIDTH = 540
HEIGHT = 540

NUM_RINGS = 8
ROOMS_PER_RING = 64

ROOM, WALL, CORRIDOR = 0, 1, 2

valid_rooms = set()
maze = None # list of room pairs indicating a path
generator = None
timer = 0

def setup_rooms():
    global valid_rooms
    for i in range(ROOMS_PER_RING):
        for j in range(NUM_RINGS):
            valid_rooms.add((i,j))

def adjacent_walls(room):
    walls = set()
    for dir in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
        if ((room[0]+dir[0])%ROOMS_PER_RING, room[1]+dir[1]) in valid_rooms:
            walls.add((dir[0], dir[1], room))
    return walls

def create_maze():
    global maze
    open_walls = set()
    start = sample(valid_rooms, 1)[0]
    path = set({start})
    walls = adjacent_walls(start)
    while len(walls)>0:
        wall = sample(walls, 1)[0]
        dx, dy, room = wall
        r1 = room[0], room[1]
        r2 = (room[0] + dx) % ROOMS_PER_RING, (room[1] + dy) % NUM_RINGS
        suitable = xor(r1 in path, r2 in path)
        if suitable:
            r = r2 if r1 in path else r1
            if r is r1:
                open_walls.add((dx, dy, r))
            else:
                open_walls.add((-dx, -dy, r))
            path.add(r)
            maze.append((r1, r2, 0))
            walls.update(adjacent_walls(r))
        walls.remove(wall)

        for i in range(len(maze)):
            maze[i] = maze[i][0], maze[i][1], maze[i][2] + 1
        yield

def generate(instantly = False):
    global maze, generator
    maze = list()
    setup_rooms()
    generator = create_maze()
    if instantly:
        while generator:
            try:
                next(generator)
            except StopIteration:
                generator = None

generate(True)

def update(dt):
    global timer, generator
    timer += dt
    if timer > 0.0001 and generator:
        timer = 0
        try:
            next(generator)
        except StopIteration:
            generator = None

def lerp(a, b, t):
    return a*(1-t) + b*t

def room_position(i1, j1):
    center = WIDTH/2, HEIGHT/2
    inner_radius = WIDTH/4
    outer_radius = WIDTH/2.5
    rad1, th1 = inner_radius + (outer_radius - inner_radius)* j1 / (NUM_RINGS-1), math.fmod(1 + (i1 / ROOMS_PER_RING), 1) * (2 * math.pi)
    x1, y1 = center[0] + rad1 * math.cos(th1), center[1] + rad1 * math.sin(th1)
    return x1, y1

def draw():
    screen.fill((0, 0, 0))
    if maze is None:
        return

    # render..
    for (r1, r2, v) in maze:
        # draw line between these rooms
        if v > 0 and v < 40:
            colour = 255, 255, 255
        else:
            colour = 128, 128, 128
        p1 = room_position(*r1)
        p2 = room_position(*r2)
        screen.draw.line(p1, p2, colour)
        sz1 = int(lerp(2, 4, r1[1] / (NUM_RINGS-1)))
        sz2 = int(lerp(2, 4, r2[1] / (NUM_RINGS-1)))
        screen.draw.filled_circle(p1, sz1, colour)
        screen.draw.filled_circle(p2, sz2, colour)
    new_s = pygame.transform.laplacian(screen.surface)
    new_s.set_alpha(128)
    screen.blit(new_s, (0,0))

def on_key_down():
    generate()