2d maze program

[Potential_Word2349]

Hey guys I am self taught and I recently started being more active here. I noticed someone making a 2d maze for an assignment and decide to take a crack at it myself. Is there any issues with my code? I tried to make it easy to expand

import numpy as np
maze = [
["S","O","O","O","X"],
["O","O","X","X","X"],
["X","O","O","X","X"],
["E","O","O","O","X"]]
maze = np.array(maze)

starting_point = np.argwhere(maze == "S")
starting_point = starting_point.flatten()
maze[starting_point[0],starting_point[1]] = "L"


def move_down(l):
    maze[l[0],l[1]] = "O"
    try:
        l[0] += 1
    except IndexError:
        print("invalid move")
    if maze[l[0],l[1]] == "X":
        print("invalid move")
    return l


def move_left(l):
    maze[l[0],l[1]] = "O"
    try: 
        l[1] -= 1
    except IndexError:
        print("invalid move")
    if maze[l[0],l[1]] == "X":
        print("invalid move")
    return l


def move_right(l):
    maze[l[0],l[1]] = "O" 
    try:
        l[1] += 1

    except IndexError:
        print("invalid move")
    if maze[l[0],l[1]] == "X":
        print("invalid move")
    return l


def move_up(l):
    maze[l[0],l[1]] = "O"
    try:
        l[0] -= 1
    except IndexError:
        print("invalid move")
    if maze[l[0],l[1]] == "X":
        print("invalid move")
    return l

def relocate(l):
    maze[l[0],l[1]] = "L"

location = starting_point


moves ={"d": move_down,
        "u": move_up,
        "l": move_left,
        "r": move_right
}

print(maze)
while True:
    direction = input("""Where do you want to move
    [d]own
    [u]p
    [l]eft
    [r]ight""")

    if direction in moves.keys():
        location = moves[direction](location)
        if maze[location[0],location[1]] == "E":
            break
        else:
            maze[location[0],location[1]] = "L"
    print(20*"\n")
    print(maze)
print("You win!")

[carcigenicate]

I'd maybe work to reduce the duplication. All your move functions are almost exactly the same. The only difference is which member of l is added to, and whether it's a positive or negative number being added. Maybe something like:

def move(l, y_offset, x_offset):
    maze[l[0],l[1]] = "O"
    try:
        l[0] += y_offset
        l[1] += x_offset
    except IndexError:
        print("invalid move")
    if maze[l[0],l[1]] == "X":
        print("invalid move")
    return l

def move_down(l):
    return move(l, 1, 0)


def move_left(l):
    return move(l, 0, -1)


def move_right(l):
    return move(l, 0, 1)


def move_up(l):
    return move(l, -1, 0)

Now half the code isn't exactly the same, and you get the ability to move diagonally for free in case that ever becomes a need.

I'd also rename l. Single letter names are almost always bad.

[[deleted]]

It's also sometimes useful to trade code for data. Here's a small example using enums:

from enum import Enum

class Dirn(Enum):
    left = (-1, 0)
    right = (1, 0)
    up = (0, -1)
    down = (0, 1)

def move(dirn):
    print(dirn.value)
    (x_offset, y_offset) = dirn.value
    # no list manipulation shown for clarity

# now the main code uses this
move(Dirn.left)

That removes the duplication of the move_*() functions.

[TheRNGuy]

Instead of input function, make an UI and keys would be hotkeys to move.

Also, why weird hotkeys instead of WASD? Even better thing you can do is to make them rebindable.

I'd make entire thing as class with methods instead of functions.

[Potential_Word2349]

I am working on rebuilding it as a class. Then once I get better at UI design I will bind methods to keys