MCH2022 badge?
go to mch2022.badge.team

Content ### Author: Leiden Tech ### Description: Leiden Tech ### Category: Games ### License: MIT ### Appname: Maze3D ### Built-in: no #TODO - this crashes for no apparent reason after playing for a while, or just letting it sit, I don't see the problem import badge import ugfx import machine import math import random import appglue fgcolor = ugfx.BLACK bgcolor = ugfx.WHITE font = "Roboto_Black22" grid = [] #size of maze - TODO can't be bigger than 4x5 otherwise fails with: # maximum recursion depth exceeded # have to figure a non-recursive way to generate the maze - sigh w = 3 h = 4 #size of screen screenX = 296 screenY = 128 #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 = 10 pixelH = 10 #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 badge.init() badge.eink_init() ugfx.init() ugfx.input_init() ugfx.input_attach(ugfx.JOY_UP, lambda pressed: btn_up(pressed)) ugfx.input_attach(ugfx.JOY_DOWN, lambda pressed: btn_down(pressed)) ugfx.input_attach(ugfx.JOY_LEFT, lambda pressed: btn_left(pressed)) ugfx.input_attach(ugfx.JOY_RIGHT, lambda pressed: btn_right(pressed)) ugfx.input_attach(ugfx.BTN_SELECT, lambda pressed: btn_select(pressed)) ugfx.input_attach(ugfx.BTN_START, lambda pressed: btn_start(pressed)) ugfx.input_attach(ugfx.BTN_A, lambda pressed: btn_a(pressed)) ugfx.input_attach(ugfx.BTN_B, lambda pressed: btn_b(pressed)) #Default random seed doesn't seem to work - does it work for anyone? [year, month, mday, wday, hour, minute, second, microseconds] = machine.RTC().datetime() random.seed(int(microseconds)) clearScreen() makeMaze() clearStatus() posX = random.randrange(1, w * 2 - 1, 2) posY = random.randrange(1, h * 2 - 1, 2) grid[posX][posY][1] = 1 ugfx.flush() display() """ 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 #area is MUCH quicker than clear... hmm ugfx.area(0, 0, screenX, screenY, bgcolor) #compass - has to be set before drawView because that relies on this value compass = dirOffset[direction][2] ugfx.string(screenX - (pixelW * (w * 2 + 1)), 100, compass, font, fgcolor) #There is room for status messages here #ugfx.string(screenX - (pixelW * (w * 2 + 1)) + 20, 100, str(posX), font, fgcolor) #ugfx.string(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 ugfx.area(startX + (pixelW * x), startY + (pixelH * y), pixelW, pixelH, fgcolor) if matrix[x][y][1] == 1: #char pos triangle pointing in direction polyArray = resizePoly(dirOffset[fixed][3], charSize) ugfx.fill_polygon(startX + (pixelW * x) + math.floor(pixelH/2), startY + ( pixelH * y ) + math.floor(pixelH/2)-1, polyArray, 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 #box around view ugfx.box(0, 0, viewX, viewY, 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 ugfx.line(endLTX, endLTY, endLBX, endLBY, fgcolor) else: #left is wall #draw left vertical line ugfx.line(endLTX, endLTY, endLBX, endLBY, fgcolor) #draw two lines for that position ugfx.line(startLTX, startLTY, endLTX, endLTY, fgcolor) ugfx.line(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 ugfx.line(endRTX, endRTY, endRBX, endRBY, fgcolor) else: #draw right vertical line ugfx.line(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 ugfx.line(endRTX, endRTY, endLTX, endLTY, fgcolor) ugfx.line(endRBX, endRBY, endLBX, endLBY, fgcolor) done = True #draw right lines ugfx.line(startRTX, startRTY, endRTX, endRTY, fgcolor) ugfx.line(startRBX, startRBY, endRBX, endRBY, fgcolor) if done: break row = row + 1 return def display(): drawCompass() drawMaze(grid, screenX - (pixelW * (w * 2 + 1)), 0) draw3dView() ugfx.flush() def quit(): ugfx.clear(ugfx.WHITE) ugfx.flush() ugfx.string(50, 50, "Quitting", font, fgcolor) ugfx.flush() appglue.start_app("launcher", False) def clearfg(): ugfx.clear(fgcolor) ugfx.flush() def clearbg(): ugfx.clear(bgcolor) ugfx.flush() def clearScreen(): clearfg() clearbg() def btn_a(pressed): if pressed: ugfx.clear(ugfx.WHITE) ugfx.flush() display() def btn_b(pressed): if pressed: display() def 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 display() def btn_down(pressed): global direction if pressed: for i in range(2): direction = direction + 1 if direction >= len(dirOffset): direction = 0 display() def btn_left(pressed): global direction if pressed: direction = direction - 1 if direction < 0: direction = len(dirOffset) - 1 display() def btn_right(pressed): global direction if pressed: direction = direction+1 if direction >= len(dirOffset): direction = 0 display() def btn_start(pressed): if pressed: quit() def btn_select(pressed): if pressed: Maze3D() Maze3D()