mirror of
https://github.com/Xevion/processing-projects.git
synced 2025-12-06 17:16:04 -06:00
145 lines
4.1 KiB
Python
145 lines
4.1 KiB
Python
import random, time
|
|
|
|
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 = 50, 50
|
|
|
|
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 switch
|
|
switch = True
|
|
global cellList
|
|
cellList = []
|
|
if xx != None and yy != None:
|
|
start = pixelToCoordinates(xx, yy)
|
|
else:
|
|
start = (random.randint(0, columns-1), random.randint(0, rows-1))
|
|
cellList.append(start)
|
|
|
|
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():
|
|
for _ in range(columns + rows):
|
|
if len(cellList) > 0:
|
|
global switch
|
|
if switch:
|
|
# most recent
|
|
# index = len(cellList) - 1
|
|
# select = cellList[index]
|
|
|
|
# oldest
|
|
index = 0
|
|
select = cellList[0]
|
|
else:
|
|
# most random
|
|
index = random.randint(0, len(cellList)-1)
|
|
select = cellList[index]
|
|
|
|
|
|
|
|
neighbors = grid[select[0]][select[1]].neighbors()
|
|
if len(neighbors) < 1:
|
|
grid[select[0]][select[1]].live = False
|
|
cellList.pop(index)
|
|
else:
|
|
new = random.choice(neighbors)
|
|
openWalls(select[0], select[1], new[0], new[1])
|
|
grid[new[0]][new[1]].visited = True
|
|
grid[new[0]][new[1]].live = True
|
|
cellList.append(new)
|
|
else:
|
|
# time.sleep(2)
|
|
return
|
|
|
|
def draw():
|
|
global switch
|
|
switch = not switch
|
|
render()
|
|
# if len(cellList) == 0:
|
|
# generate()
|
|
tick()
|
|
|
|
def mouseClicked():
|
|
generate(mouseX, mouseY)
|