# Laby

Laby project on Wokwi for ESP32.
Written by Paul Jaros Ⓒ 2024. Released under the MIT License.

Generates a random labyrinth and allows you to walk in it with
the push-buttons, which are also mapped WASD-keys.

The LEDs show the walls around you. A lit LED means a wall blocks
the passage.

The player starts at the top left position in the labyrinth. The
exit is at the bottom-right.

Reaching the exit will advance you to the next level. Which is
is a bigger labyrinth. You will again be set to the top-left
position and need to find the exit on the bottom-right.

README.md

diagram.json

# Labyrinth walk for ESP32, (C) 2024 Paul Jaros
# Released under the MIT License.

# Pinout ESP32: https://lastminuteengineers.com/esp32-pinout-reference/

# Game supports WASD to walk around

from machine import Pin
from utime import sleep
import laby

# Initialize variables
btn_n = Pin(32, Pin.IN, Pin.PULL_UP)
btn_w = Pin(33, Pin.IN, Pin.PULL_UP)
btn_e = Pin(25, Pin.IN, Pin.PULL_UP)
btn_s = Pin(26, Pin.IN, Pin.PULL_UP)

led_n = Pin(19, Pin.OUT)
led_w = Pin(21, Pin.OUT)
led_e = Pin(22, Pin.OUT)
led_s = Pin(23, Pin.OUT)

hw = laby.hw(btn_n, btn_w, btn_e, btn_s,
             led_n, led_w, led_e, led_s)

sizeX, sizeY = (9, 7) # Size must have odd numbers
level = 1
game = laby.create_random_game(sizeY, sizeX)
# game = laby.create_game() # Static labyrinth
print("Level %d. Generating a labyrinth: %d x %d" %(level, game.sizeX, game.sizeY))
laby.line_print(game)

laby.blink(hw)
was_pressed = None

# Game loop
while True:
    b = laby.buttons(hw)
    w = laby.walls(game)
    laby.show_walls(hw, w)

    if (b.any_btn_pressed()):
        was_pressed = b
    elif was_pressed != None:
        # Test if released button is a allowed move
        if   (was_pressed.btn_n and w.wall_n == 0): game.posY -= 2
        elif (was_pressed.btn_w and w.wall_w == 0): game.posX -= 2
        elif (was_pressed.btn_e and w.wall_e == 0): game.posX += 2
        elif (was_pressed.btn_s and w.wall_s == 0): game.posY += 2
        elif (was_pressed.btn_n and w.wall_n == 1): laby.blink(hw); laby.show_walls(hw, w);
        elif (was_pressed.btn_w and w.wall_w == 1): laby.blink(hw); laby.show_walls(hw, w);
        elif (was_pressed.btn_e and w.wall_e == 1): laby.blink(hw); laby.show_walls(hw, w);
        elif (was_pressed.btn_s and w.wall_s == 1): laby.blink(hw); laby.show_walls(hw, w);
        else: print("?!")

        was_pressed = None
        # Test if outer border was reached -> player has found the exit!
        if (   game.posX == 0              or game.posY == 0
            or game.posX == game.sizeX + 1 or game.posY == game.sizeY + 1):
            laby.blink(hw)
            laby.blink(hw)
            if (level == 1):
                print("Exit found!")
            else:
                print("Exit found! This was the labyrinth: ")
                laby.line_print(game)
            level += 1    
            sizeY, sizeX = sizeY + 2, sizeX + 2
            print("Level %d. Generating a labyrinth: %d x %d" %(level, game.sizeX, game.sizeY))
            game = laby.create_random_game(sizeY, sizeX)

    sleep(0.1)

main.py

from utime import sleep
from random import choice

"""Hardware. Pins and LEDs"""
class hw:
    def __init__(self, 
                 btn_n, btn_w, btn_e, btn_s,
                 led_n, led_w, led_e, led_s):
        self.btn_n = btn_n
        self.btn_w = btn_w
        self.btn_e = btn_e
        self.btn_s = btn_s
        self.led_n = led_n
        self.led_w = led_w
        self.led_e = led_e
        self.led_s = led_s

"""Game State. Player position and labyrinth"""
class game:
    def __init__(self, posY, posX, li):
        self.posY  = posY
        self.posX  = posX
        self.li    = li
        self.sizeY = len(li)    - 2
        self.sizeX = len(li[0]) - 2

"""Walls seen from the player position"""
class walls:
    def __init__(self, game):
        self.wall_n = 0 if game.li[game.posY - 1][game.posX    ] == ' ' else 1
        self.wall_w = 0 if game.li[game.posY    ][game.posX - 1] == ' ' else 1
        self.wall_e = 0 if game.li[game.posY    ][game.posX + 1] == ' ' else 1
        self.wall_s = 0 if game.li[game.posY + 1][game.posX    ] == ' ' else 1

"""Buttons. Save the current button values"""
class buttons:
    def __init__(self, hw):
        self.btn_n = 1 - hw.btn_n.value()
        self.btn_w = 1 - hw.btn_w.value()
        self.btn_e = 1 - hw.btn_e.value()
        self.btn_s = 1 - hw.btn_s.value()

    def any_btn_pressed(self):
        return (self.btn_n == 1 
             or self.btn_w == 1 
             or self.btn_e == 1 
             or self.btn_s == 1)

"""Return labyrinth"""
def create_game():
    li = \
    ['         '
    ,' ####### '
    ,' #   # # '
    ,' # ### # '
    ,' #     # '
    ,' # # ### '
    ,' # #   # '
    ,' ##### # '
    ,'         ']
    return game(2, 2, li)

"""Generate random labyrinth"""
def create_random_game(sizeY, sizeX):
    # Initialize labyrinth
    dirs = ((1,0), (0,1), (-1,0), (0,-1))
    li = [[' ']+['#']*sizeX+[' '] for i in range(sizeY)]
    li.append(  [' ']*(sizeX+2))
    li.insert(0,[' ']*(sizeX+2))
    jumpPos = []
    posY, posX = (2, 2)
    li[posY][posX] = ' '

    # Dig labyrinth
    while True:
        while True:
            avaiDir = [d
                    for d in dirs
                    if li[posY+d[1]*2][posX+d[0]*2] != ' ']                   
            if not avaiDir: break

            dir = choice(avaiDir)
            jumpPos.append((posY, posX))
            
            for i in (0, 1):
                posX, posY = posX + dir[0], posY + dir[1]
                li[posY][posX] = ' '
                
        if not jumpPos: break
        else:           posY, posX = jumpPos.pop()

    li[sizeY][sizeX-1] = ' '
    return game(2, 2, li)

"""Set all LEDs to value"""
def led_all(hw, value):
    hw.led_n.value(value)
    hw.led_w.value(value)
    hw.led_e.value(value)
    hw.led_s.value(value)

"""Blink with LEDs"""
def blink(hw):
    for _ in range(2):
        for v in (1, 0):
            led_all(hw, v)
            sleep(0.1)

"""Set LEDs to show walls"""
def show_walls(hw, w):
    hw.led_n.value(w.wall_n)
    hw.led_w.value(w.wall_w)
    hw.led_e.value(w.wall_e)
    hw.led_s.value(w.wall_s)

"""Print labyrinth with spaces and hashes"""
def hash_print(game):
    print("\n".join(["".join(elem) for elem in game.li]))

"""Print labyrinth with line blocks"""
def line_print(game):
    for y in range(1, game.sizeY+1, 2):
        row = ""
        for x in range(1, game.sizeX+1, 2):
            n = game.li[y - 1][x    ] == '#'
            w = game.li[y    ][x - 1] == '#'
            e = game.li[y    ][x + 1] == '#'
            s = game.li[y + 1][x    ] == '#'
            if   (n, w, e, s) == (0, 0, 0, 0): c = ' '
            elif (n, w, e, s) == (0, 0, 0, 1): c = '╷'
            elif (n, w, e, s) == (0, 0, 1, 0): c = '╶'
            elif (n, w, e, s) == (0, 0, 1, 1): c = '┌'
            elif (n, w, e, s) == (0, 1, 0, 0): c = '╴'
            elif (n, w, e, s) == (0, 1, 0, 1): c = '┐'
            elif (n, w, e, s) == (0, 1, 1, 0): c = '─'
            elif (n, w, e, s) == (0, 1, 1, 1): c = '┬'
            elif (n, w, e, s) == (1, 0, 0, 0): c = '╵'
            elif (n, w, e, s) == (1, 0, 0, 1): c = '│'
            elif (n, w, e, s) == (1, 0, 1, 0): c = '└'
            elif (n, w, e, s) == (1, 0, 1, 1): c = '├'
            elif (n, w, e, s) == (1, 1, 0, 0): c = '┘'
            elif (n, w, e, s) == (1, 1, 0, 1): c = '┤'
            elif (n, w, e, s) == (1, 1, 1, 0): c = '┴'
            elif (n, w, e, s) == (1, 1, 1, 1): c = '┼'
            row += c
        print(row)
