kruskal and sidewinder maze generation sketches

mazes/MazeGenSidewinder/MazeGenSidewinder.pyde

@@ -0,0 +1,159 @@
+import random
+
+class Cell:
+    def __init__(self, x, y):
+        self.x, self.y = x, y
+        self.right, self.bottom, self.visited, self.live = True, True, False, False
+    
+    # Identify the neighbors of the cell
+    def neighbors(self):
+        global offsets
+        neighbors = []
+        for offset in offsets:
+            neighbor = (self.x + offset[0], self.y + offset[1])
+            if not valid(neighbor):
+                continue
+            if grid[neighbor[0]][neighbor[1]].visited:
+                continue
+            neighbors.append(neighbor)
+        return neighbors
+    
+    # Render the single cell
+    def render(self):
+        global divX, divY
+        translate(self.x * divX, self.y * divY)
+        # Drawing Cell Background
+        # Visited, Unvisited, Highlighted
+        
+        if self.live:
+            fill(244, 117, 117)
+        elif self.visited:
+            fill(255)
+        else:
+            fill(204)
+        noStroke()
+        rect(0, 0, divX, divY)
+        
+        # Drawing Cell Lines
+        stroke(0)
+        fill(255)
+        strokeWeight(2.5)
+        if self.bottom:
+            line(0, divY, divX, divY)
+        if self.right:
+            line(divX, 0, divX, divY)
+        resetMatrix()
+
+# Open walls between two cells on the grid
+def openWalls(x1, y1, x2, y2):
+    global offsets
+    # Bottom, Right, Left, Top
+    offset = (x2 - x1, y2 - y1)
+    if offset == offsets[0]:
+        grid[x1][y1].bottom = False
+    if offset == offsets[1]:
+        grid[x1][y1].right = False
+    if offset == offsets[2]:
+        grid[x2][y2].right = False
+    if offset == offsets[3]:
+        grid[x2][y2].bottom = False
+
+# Validates whether a coordinate is valid with the curret columns and rows set
+def valid(coordinate):
+    global columns, rows
+    return not (coordinate[0] < 0 or coordinate[0] >= columns or coordinate[1] < 0 or coordinate[1] >= rows)
+
+# Generates a new grid and cellList (with start) for the maze generation.
+# Serves mostly to ease the process of regenerating a maze without restarting the Sketch
+def generate(xx=None, yy=None):
+    global columns, rows, offsets
+    # Bottom, Right, Left, Top
+    offsets = [(0, 1), (1, 0), (-1, 0), (0, -1)]
+    columns, rows = 25, 25
+    
+    global grid, divX, divY
+    divX, divY = width / float(columns), height / float(rows)
+    grid = [[Cell(x, y) for y in range(rows)] for x in range(columns)]
+    
+    global current, runSet, runSetActive
+    current = 0, 0
+    runSet = []
+    runSetActive = False
+    
+def pixelToCoordinates(x, y): 
+    return int(x / float
+           (divX)), int(y / float(divY))
+
+def setup():
+    size(750, 750)
+    generate()
+    
+# Runs the cell.render() action on every cell    
+def render():
+    background(0)
+    for row in grid:
+        for cell in row:
+            cell.render()
+            
+def tick():
+    global current, runSet, runSetActive
+    if runSetActive:
+        if len(runSet) > 0:
+            print('a')
+            get = runSet[0]
+            if get == []:
+                return
+            print('b')
+            print(runSet, get)
+            choice = random.choice(get)
+            print('c')
+            openWalls(choice[0], choice[1], choice[0], choice[1] - 1)
+            print('d')
+            del runSet[0]
+            return
+        else:
+            runSet = [[]]
+            runSetActive = False
+            
+    # Are we done with the maze?
+    if current[0] == columns and current[1] == rows - 1:
+        if len(runSet) > 0:
+            runSetActive = True
+            return
+        print('Done')
+        render()
+        noLoop()
+    # Are we on the horozontal edge?
+    elif current[0] == columns:
+        if not runSetActive:
+            if current[1] > 0:
+                for coord in runSet[-1]:
+                    grid[coord[0]][coord[1]].live = False
+            runSetActive = True
+            current = 0, current[1] + 1
+    # Keep carving runSets
+    else:
+        # If you're on the ceiling of the maze, just carve and skip the whole thing.
+        if current[1] == 0:
+            openWalls(current[0], current[1], current[0] + 1, current[1])
+        # Keep carving east
+        elif current[0] == 0 or not random.choice([True, False]):
+            runSet[-1].append((current[0], current[1]))
+            grid[current[0]][current[1]].live = True
+            openWalls(current[0], current[1], current[0] + 1, current[1])
+        # Break out new runSet
+        else:
+            for coord in runSet[-1]:
+                grid[coord[0]][coord[1]].live = False
+            runSet.append([(current[0], current[1])])
+    if not runSetActive:
+        current = current[0] + 1, current[1]
+    
+def draw():
+    for _ in range(columns):
+        tick()
+    render()
+    
+def mouseClicked():
+    loop()
+    generate(mouseX, mouseY)