Content ### Author: Leiden Tech ### Description: Leiden Tech ### Category: Games ### License: MIT ### Appname: Maze3D ### Built-in: no import display import buttons import machine import math import random import mch22 fgcolor = display.BLACK bgcolor = display.WHITE font = "Roboto_Black22" grid = [] #size of maze w = 5 h = 8 #size of screen - should be able to get this from the system screenX = 320 screenY = 240 #TODO size of wall block - should maybe be abs((screenX - viewX) / (w * 2 + 1)) for variable sized mazes but then viewX, viewY has to be hard-coded pixelW = 6 pixelH = 6 #size of view screen viewX = screenX - (pixelW * (w * 2 + 1) ) - 6 #200 viewY = screenY - 3 #125 #defines x,y compass and array of 3 points for the poly char object dirOffset = [[0, 1, "N", [[-1, 1], [0, -1], [1, 1]]], [-1, 0, "E", [[-1, -1], [1, 0], [-1, 1]]], [0, -1, "S", [[-1, -1], [0, 1], [1, -1]]], [1, 0, "W", [[1, -1], [-1, 0], [1, 1]]]] #character direction - posX,posY set after maze is built direction = 0 posX = 0 posY = 0 compass = dirOffset[direction][2] def Maze3D(): global posX, posY random.seed(int(microseconds)) clearbg() makeMaze() clearStatus() posX = random.randrange(1, w * 2 - 1, 2) posY = random.randrange(1, h * 2 - 1, 2) grid[posX][posY][1] = 1 display.flush() drawDisplay() """ Start at a random cell. Mark the current cell as visited, and get a list of its neighbors. starting with a random neighbor and stepping through neighbors until a valid unvisited one is found: remove the wall between the current cell and that neighbor, and then recurse with that neighbor as the start point. when you hit the end of the recursion, start over with the next valid neighbor """ def makeMaze(): global grid """ sets up an array of WxH grid[x][y] = [wall,status] wall is True/False status is numeric 1) position of char 2) position of exit 3) position of monster 4) position of treasure 5) etc? """ #Set all positions in grid to wall grid = [[[True, 0] for i in range(h * 2 + 1)] for j in range(w * 2 + 1)] #Remove every other one to set up grid grid[x][y] = [wall,status] for x in range(1, w * 2 + 1, 2): ######### for y in range(1, h * 2 + 1, 2): # # # # # grid[x][y] = [False, 0] ######### #start at random cell and walk # # # # # startw = random.randrange(1, w * 2 - 1, 2) ######### starth = random.randrange(1, h * 2 - 1, 2) # # # # # walk(startw, starth, w * 2 - 1, h * 2 - 1) ######### def walk(x, y, ww, hh): global grid #mark current cell as visited grid[x][y][1] = 1 #get list of neighbors neighbors = [(x - 2, y), (x, y + 2), (x + 2, y), (x, y - 2)] #For each random neighbor #going to have to implement my own shuffle here, sigh neighbors = shuffle(neighbors) for (xx, yy) in neighbors: #skip if out of range if xx <= 0 or xx > ww or yy <= 0 or yy > hh: continue #Skip if already visited if grid[xx][yy][1] == 1: continue #if not previously visited, remove the connecting wall if xx == x: if grid[xx][yy][1] == 0: grid[xx][max(y, yy) - 1] = [False, 0] if yy == y: if grid[xx][yy][1] == 0: grid[max(x, xx) - 1][yy] = [False, 0] #recurse using neighbor as start point walk(xx, yy, ww, hh) def shuffle(target): #doesn't exist in micropython apparently, gotta roll my own length = len(target) secondary = -1 if length < 2: #what are you going to shuffle then moron? return for i in range(length): #maybe math.ceil(length/2)+1): primary = random.randint(0, length - 1) while secondary == primary: #no point in shuffling to itself secondary = random.randint(0, length - 1) tmp = target[primary] target[primary] = target[secondary] target[secondary] = tmp return target def clearStatus(): global grid for i in range(0, (w * 2 + 1)): for j in range(0, (h * 2 + 1)): grid[i][j][1] = 0 def drawCompass(): global compass display.drawFill(bgcolor) #compass - has to be set before drawView because that relies on this value compass = dirOffset[direction][2] display.drawText(screenX - (pixelW * (w * 2 + 1)), 100, compass, fgcolor, font) #There is room for status messages here #display.drawText(screenX - (pixelW * (w * 2 + 1)) + 20, 100, str(posX), font, fgcolor) #display.drawText(screenX - (pixelW * (w * 2 + 1)) + 40, 100, str(posY), font, fgcolor) def drawMaze(matrix, startX, startY, fixed = None): charSize = 4 if fixed is None: fixed = direction #offset where to start drawing map for y in range(len(matrix[0])): for x in range(len(matrix)): if matrix[x][y][0] is True: #wall display.drawRect(startX + (pixelW * x), startY + (pixelH * y), pixelW, pixelH,True, fgcolor) if matrix[x][y][1] == 1: #char pos triangle pointing in direction polyArray = resizePoly(dirOffset[fixed][3], charSize) display.drawTri( startX + (pixelW * x) + math.floor(pixelH/2) + polyArray[0][0], startY + (pixelH * y) + math.floor(pixelH/2) + polyArray[0][1], startX + (pixelW * x) + math.floor(pixelH/2) + polyArray[1][0], startY + (pixelH * y) + math.floor(pixelH/2) + polyArray[1][1], startX + (pixelW * x) + math.floor(pixelH/2) + polyArray[2][0], startY + (pixelH * y) + math.floor(pixelH/2) + polyArray[2][1], fgcolor) def resizePoly(array, size): #for variable sized char indicator polyArray = [] for point in array: polyArray.append([point[0]*size, point[1]*size]) return polyArray #These set up the array of what we can see def chunkN(): array = [] column = [] for row in grid[posX-1:posX+2]: column.append(row[:posY+1][::-1]) for i in range(len(column[0])): t = [e[i] for e in column] array.append(t) return array def chunkE(): array = [] for row in grid[posX:]: array.append(row[posY-1:posY+2]) return array def chunkS(): array = [] column = [] for row in grid[posX-1:posX+2]: column.append(row[posY:]) for i in range(len(column[0])): t = [e[i] for e in column] array.append(t[::-1]) return array def chunkW(): array = [] for row in grid[:posX+1]: array.append(row[posY-1:posY+2][::-1]) return array[::-1] def draw3dView(): done = False row = 0 maxDepth = max(w*2,h*2) #This could be calculated on the fly but it's probably not worth the effort offsetArray = [[0, 0], [28, 18], [48, 30], [62, 40], [77, 49], [84, 54], [90, 60]] maxDepth = min(len(offsetArray)-1, maxDepth) posGrid = [] #rotate and slice grid for view matrix if ( compass == "N"): posGrid = chunkN() if ( compass == "E"): posGrid = chunkE() if ( compass == "S"): posGrid = chunkS() if ( compass == "W"): posGrid = chunkW() #drawMaze(posGrid, 0, 0, 1) #draws what view is based on - for debugging #box around view display.drawRect(0, 0, viewX, viewY, False, fgcolor) while not done and row < maxDepth: #foreach depth #calculate the default points based on offset array offsetX = offsetArray[row + 1][0] offsetY = offsetArray[row + 1][1] startLTX = offsetArray[row][0] startLTY = offsetArray[row][1] endLTX = offsetX endLTY = offsetY #previous loop end numbers startLBX = offsetArray[row][0] startLBY = viewY - offsetArray[row][1] endLBX = offsetX endLBY = viewY - offsetY startRTX = viewX - offsetArray[row][0] startRTY = offsetArray[row][1] endRTX = viewX - offsetX endRTY = offsetY startRBX = viewX - offsetArray[row][0] startRBY = viewY - offsetArray[row][1] endRBX = viewX - offsetX endRBY = viewY - offsetY #if left is not wall, lower the start position if posGrid[row][0][0] is False: startLTY = offsetY startLBY = viewY - offsetY #if front is a wall move start right if posGrid[row + 1][1][0] is True: endLTX = viewX - offsetX endLBX = viewX - offsetX #if right is a wall move start to right wall and skip right if posGrid[row][2][0] is False: endLTX = viewX - offsetArray[row][0] endLBX = viewX - offsetArray[row][0] done = True else: #draw left vertical line display.drawLine(endLTX, endLTY, endLBX, endLBY, fgcolor) else: #left is wall #draw left vertical line display.drawLine(endLTX, endLTY, endLBX, endLBY, fgcolor) #draw two lines for that position display.drawLine(startLTX, startLTY, endLTX, endLTY, fgcolor) display.drawLine(startLBX, startLBY, endLBX, endLBY, fgcolor) if done: break #starting right side #if right is not a wall, lower the start position if posGrid[row][2][0] is False: startRTY = offsetY startRBY = viewY - offsetY #if front is a wall move end left if posGrid[row + 1][1][0] is True: endRTX = offsetX endRBX = offsetX done = True else: #draw right vertical line display.drawLine(endRTX, endRTY, endRBX, endRBY, fgcolor) else: #draw right vertical line display.drawLine(endRTX, endRTY, endRBX, endRBY, fgcolor) if posGrid[row + 1][1][0] is True: #draw end wall and finish #this is going to be redundant in some cases I think display.drawLine(endRTX, endRTY, endLTX, endLTY, fgcolor) display.drawLine(endRBX, endRBY, endLBX, endLBY, fgcolor) done = True #draw right lines display.drawLine(startRTX, startRTY, endRTX, endRTY, fgcolor) display.drawLine(startRBX, startRBY, endRBX, endRBY, fgcolor) if done: break row = row + 1 return def drawDisplay(): drawCompass() drawMaze(grid, screenX - (pixelW * (w * 2 + 1)), 0) draw3dView() display.flush() def quit(): display.clear(display.WHITE) display.flush() display.drawText(50, 50, "Quitting", fgcolor, font) display.flush() def clearbg(): global bgcolor display.drawFill(bgcolor) display.flush() def on_action_btn_a(pressed): global bgcolor if pressed: display.drawFill(bgcolor) display.flush() drawDisplay() def on_action_btn_b(pressed): if pressed: drawDisplay() def on_action_btn_up(pressed): global posX, posY if pressed: newX = posX - dirOffset[direction][0] newY = posY - dirOffset[direction][1] if grid[newX][newY][0] is False: grid[posX][posY][1] = 0 grid[newX][newY][1] = 1 posX = newX posY = newY drawDisplay() def on_action_btn_down(pressed): global direction if pressed: for i in range(2): direction = direction + 1 if direction >= len(dirOffset): direction = 0 drawDisplay() def on_action_btn_left(pressed): global direction if pressed: direction = direction - 1 if direction < 0: direction = len(dirOffset) - 1 drawDisplay() def on_action_btn_right(pressed): global direction if pressed: direction = direction+1 if direction >= len(dirOffset): direction = 0 drawDisplay() def on_action_btn_start(pressed): if pressed: mch22.exit_python() def on_action_btn_select(pressed): if pressed: Maze3D() ######## # MAIN # ######## buttons.attach(buttons.BTN_UP, on_action_btn_up) buttons.attach(buttons.BTN_DOWN, on_action_btn_down) buttons.attach(buttons.BTN_LEFT, on_action_btn_left) buttons.attach(buttons.BTN_RIGHT, on_action_btn_right) buttons.attach(buttons.BTN_SELECT, on_action_btn_select) buttons.attach(buttons.BTN_START, on_action_btn_start) buttons.attach(buttons.BTN_A, on_action_btn_a) buttons.attach(buttons.BTN_B, on_action_btn_b) #Default random seed doesn't seem to work - does it work for anyone? [year, month, mday, wday, hour, minute, second, microseconds] = machine.RTC().datetime() Maze3D()