[Super detailed teaching] Python tutorial on making maze games

---

foreword

I will provide you with the Python code of a simple maze game, and explain the function of each part, so that you can touch the little fish dignifiedly after work.

Use tools:

Python、Pygame、PyCharm

Click to receive Python tools & aid materials

1. First determine the size of the maze

In this maze game, we need to determine the size of the maze first. We can represent the size of the maze by defining a constant, for example:

MAZE_SIZE = 10

Here we set the size of the maze to 10x10.

2. Defining the walls and passages of the maze

In a maze, we need to define walls and passages. Walls represent obstacles in the maze, and passages represent paths that can be passed. We can use two constants to represent walls and passages:

WALL = "#"
PASSAGE = " "

3. Define the start and end of the maze

In a maze, we need to define a starting point and an ending point. The starting point is the entrance of the maze, and the end point is the exit of the maze. We can use two constants to represent the start and end points:

START = "S"
END = "E"

The data requested by the url network used here.

---

4. Define the direction of the maze

In a maze, we need to define directions. Direction indicates the direction in which you can move, such as up, down, left, right. We can use a list to represent directions:

DIRECTIONS = ["N", "S", "E", "W"]

5. Generate an empty maze

In the maze game, we need to first generate an empty maze. We can use a two-dimensional list to represent the maze:

def create_maze():
    maze = [[WALL for x in range(MAZE_SIZE)] for y in range(MAZE_SIZE)]
    return maze

Here we use a nested list comprehension to generate a 2D list where each element is a wall.

6. Randomly choose a start and end point in the maze

In a maze, we need to randomly choose a start and end point. We can use Python's random module to generate random numbers:

import random

def choose_start_and_end(maze):
    start_x = random.randint(0, MAZE_SIZE - 1)
    start_y = random.randint(0, MAZE_SIZE - 1)
    end_x = random.randint(0, MAZE_SIZE - 1)
    end_y = random.randint(0, MAZE_SIZE - 1)
    maze[start_x][start_y] = START
    maze[end_x][end_y] = END
    return (start_x, start_y), (end_x, end_y)

Here we use the random.randint() function to generate random starting and ending coordinates, and mark the starting and ending points in the maze.

7. Randomly choose a direction in the maze

In a maze, we need to choose a direction at random. We can use Python's random module to generate random numbers, and use the DIRECTIONS list to indicate directions:

def choose_direction():
    return random.choice(DIRECTIONS)

Here we use the random.choice() function to randomly choose a direction from the DIRECTIONS list.

8. Check if a location is inside the maze

In the maze, we need to check if a location is inside the maze. We can use the size of the maze to determine if a location is inside the maze:

def is_valid_position(x, y):
    return x >= 0 and x < MAZE_SIZE and y >= 0 and y < MAZE_SIZE

Here we use the logical operator and and the comparison operators >= and < to determine whether a location is inside the maze.

9. Check if a position is a wall

In a maze, we need to check if a position is a wall. We can use the elements in the maze to determine whether a location is a wall:

def is_wall(maze, x, y):
    return maze[x][y] == WALL

Here we use the index of the list to get the elements in the maze, and use the comparison operator == to determine whether a position is a wall.

10. Check if a location is a channel

In a maze, we need to check if a location is a passage. We can use the elements in the maze to determine whether a position is a passage:

def is_passage(maze, x, y):
    return maze[x][y] == PASSAGE

Here we use the index of the list to get the element in the maze, and use the comparison operator == to determine whether a position is a channel.

11. Check if a location is the start or end point

In a maze, we need to check if a location is a start or end point. We can use the elements in the maze to determine whether a position is a start or end point:

def is_start_or_end(maze, x, y):
    return maze[x][y] == START or maze[x][y] == END

Here we use the logical operator or and the comparison operator == to determine whether a location is a starting point or an ending point.

12. Check if a location has already been visited

In a maze, we need to check if a location has already been visited. We can use a two-dimensional list to record whether each location has been visited:

def is_visited(visited, x, y):
    return visited[x][y]

Here we use the index of the list to get the element in the two-dimensional list, and use the boolean value to indicate whether a position has been visited.

13. Mark a location as visited

In a maze, we need to mark a location as visited. We can use a two-dimensional list to record whether each location has been visited:

def mark_visited(visited, x, y):
    visited[x][y] = True

14. Generate a random path in the maze

In a maze, we need to generate a random path. We can use a recursive function to generate paths:

def generate_path(maze, visited, x, y):
    # 标记当前位置为已访问
    mark_visited(visited, x, y)
    # 随机选择一个方向
    direction = choose_direction()
    # 根据选择的方向移动到下一个位置
    if direction == "N":
        next_x, next_y = x - 1, y
    elif direction == "S":
        next_x, next_y = x + 1, y
    elif direction == "E":
        next_x, next_y = x, y + 1
    else:
        next_x, next_y = x, y - 1
    # 如果下一个位置在迷宫内且未被访问过
    if is_valid_position(next_x, next_y) and not is_visited(visited, next_x, next_y):
        # 标记当前位置和下一个位置之间的墙壁为通道
        if direction == "N":
            maze[x][y] = PASSAGE
        elif direction == "S":
            maze[x + 1][y] = PASSAGE
        elif direction == "E":
            maze[x][y + 1] = PASSAGE
        else:
            maze[x][y - 1] = PASSAGE
        # 递归生成下一个位置的路径
        generate_path(maze, visited, next_x, next_y)
    else:
        # 如果下一个位置已经被访问过或不在迷宫内，则重新选择一个方向
        generate_path(maze, visited, x, y)

Here we usechoose_direction()function to randomly choose a direction and move to the next position according to the chosen direction. If the next location is within the maze and has not been visited, mark the wall between the current location and the next location as a passage, and recursively generate a path to the next location. If the next location has already been visited or is not in the maze, then choose a direction again.

15. Generating a Maze

In a maze game, we need to generate a maze. we can usecreate_maze()The function generates an empty maze, usingchoose_start_and_end()The function chooses a start and end point at random, usinggenerate_path()The function generates a random path:

def generate_maze():
    maze = create_maze()
    visited = [[False for x in range(MAZE_SIZE)] for y in range(MAZE_SIZE)]
    start, end = choose_start_and_end(maze)
    generate_path(maze, visited, start[0], start[1])
    return maze

Here we use a two-dimensional listvisitedto record whether each location has already been visited, and pass the start and end points togenerate_path()function to generate a random path.

16. Print Maze

In the maze game, we need to print the maze. we can useprint()The function prints the maze:

def print_maze(maze):
    for row in maze:
        print("".join(row))

17. Run the maze game

In the maze game, we need to run the maze game. we can usegenerate_maze()function to generate a maze, usingprint_maze()The function prints the maze:

def run_game():
    maze = generate_maze()
    print_maze(maze)

run_game()

Here we use the generate_maze() function to generate the maze, and use the print_maze() function to print the maze.

↓ ↓ ↓ Add the business card below to find me, directly get the source code and cases ↓ ↓ ↓