Movatterモバイル変換

Michael Maranan · 27 min read · Updated jul 2023 ·Game Development

Turn your code into any language with ourCode Converter. It's the ultimate tool for multi-language programming. Start converting now!

Maze games have been a popular genre for decades, challenging players to navigate through intricate labyrinths while avoiding obstacles and searching for the exit. With Python's versatility and the power of the Pygame library, we can bring this classic gaming experience to life.

Throughout this tutorial, we'll cover the fundamentals of maze generation, player movement, collision detection, game logic, and more. By the end, you'll have a fully functional maze game that you can customize and expand upon to create your own unique gaming experience.

Whether you're a beginner or an experienced Python developer, this tutorial will provide step-by-step guidance to help you understand the game development process and unleash your creativity. Get ready to dive into the world of game development and create a captivating maze game that will challenge and entertain players. Throughout this article, we will cover various aspects of the game development process, including:

Installation and Setup

Let's start by making sure that Python is installed on our computer. You can download Python from theirofficial website. Once Python is installed, we need to install the Pygame library:

$ pip install pygame

Next, create a new folder and name itMaze-Game. Inside our main directory, we need to create several Python files:main.py,game.py,clock.py,maze.py,cell.py, andplayer.py.

Also, create another folder inside our game directory and name itimg which we'll use to store the images we're using for the game. We're using only one picture for this game, which is a picture of a gate that serves as the goal point for the player to reach in order to win the game. You can provide yours or download and use minehere.

Now that we have certain files created, our game directory should look like this:

After having all the required files created, we can start coding.

Creating Grid Cell

We're gonna use grids to draw the maze for our game, so the first thing we're adding to the game is theCell class that represents a single cell within the grid and holds essential information about its state, such as its position, neighbors, and whether it contains walls or pathways:

# cell.pyimport pygamefrom random import choiceclass Cell:    def __init__(self, x, y, thickness):        self.x, self.y = x, y        self.thickness = thickness        self.walls = {'top': True, 'right': True, 'bottom': True, 'left': True}        self.visited = False

When an instance of theCell class is created, the__init__() method is called. This special method serves as a constructor and takes three parameters:x,y, andthickness. These parameters define the position and thickness of the wall per cell within the maze. Within the constructor, thewalls attribute is initialized as a dictionary with keys representing the directions (top,right,bottom, andleft) and values set toTrue. This indicates that all walls surrounding the cell are initially present. Thevisited attribute is set toFalse, allowing us to keep track of whether the cell has been visited during maze generation or traversal.

Now let's create another method for theCell class, thedraw() method. This method is responsible for creating and adding walls for each cell.

Thedraw() method within theCell class plays a crucial role in visually rendering the walls of a cell using the Pygame library. This method takes two parameters:sc, representing the Pygame screen object, andtile, which determines the size of each cell in pixels:

# cell.pyclass Cell:    ...    # draw grid cell walls    def draw(self, sc, tile):        x, y = self.x * tile, self.y * tile        if self.walls['top']:            pygame.draw.line(sc, pygame.Color('darkgreen'), (x, y), (x + tile, y), self.thickness)        if self.walls['right']:            pygame.draw.line(sc, pygame.Color('darkgreen'), (x + tile, y), (x + tile, y + tile), self.thickness)        if self.walls['bottom']:            pygame.draw.line(sc, pygame.Color('darkgreen'), (x + tile, y + tile), (x , y + tile), self.thickness)        if self.walls['left']:            pygame.draw.line(sc, pygame.Color('darkgreen'), (x, y + tile), (x, y), self.thickness)

To begin, the method calculates the screen coordinates of the top-left corner of the cell based on itsx andy positions and thetile size, making walls for each cell accurately positioned within the maze. Then, we go through each wall - thetop,right,bottom, andleft - and check if it exists by peeking into theself.walls dictionary. If a wall is present (True), then it will draw the wall. We use thepygame.draw.line() function to bring those walls to life. We pick a cool'darkgreen' color and set the thickness of the wall toself.thickness. This way, the walls will stand out and make an impact.

Let's add two more methods for theCell class, thecheck_cell() and thecheck_neighbors() methods, they help us check and find neighboring cells in our maze:

# cell.pyclass Cell:    ...    # checks if cell does exist and returns it if it does    def check_cell(self, x, y, cols, rows, grid_cells):        find_index = lambda x, y: x + y * cols        if x < 0 or x > cols - 1 or y < 0 or y > rows - 1:            return False        return grid_cells[find_index(x, y)]    # checking cell neighbors of current cell if visited (carved) or not    def check_neighbors(self, cols, rows, grid_cells):        neighbors = []        top = self.check_cell(self.x, self.y - 1, cols, rows, grid_cells)        right = self.check_cell(self.x + 1, self.y, cols, rows, grid_cells)        bottom = self.check_cell(self.x, self.y + 1, cols, rows, grid_cells)        left = self.check_cell(self.x - 1, self.y, cols, rows, grid_cells)        if top and not top.visited:            neighbors.append(top)        if right and not right.visited:            neighbors.append(right)        if bottom and not bottom.visited:            neighbors.append(bottom)        if left and not left.visited:            neighbors.append(left)        return choice(neighbors) if neighbors else False

Thecheck_cell() function is like our detective. It takes in the coordinatesx andy, the number of columns and rows in the grid, and thegrid_cells list that holds all the cells. Its job is to check if the cell at the given coordinates actually exists. It uses a lambda function calledfind_index to convert the 2D coordinates into a 1D index to access the cell in thegrid_cells list. If the coordinates are out of bounds (i.e., the cell doesn't exist), it returnsFalse. Otherwise, it returns the cell itself.

Thecheck_neighbors() function looks for neighboring cells that haven't been visited yet. It takes in the number of columns and rows in the grid and thegrid_cells list. It starts by creating an empty list calledneighbors to store the neighboring cells. Next, it checks the cells in four directions:top,right,bottom, andleft. It uses thecheck_cell() function to determine if the neighboring cell exists and if it has been visited. If a neighboring cell exists and hasn't been visited, it adds it to theneighbors list. Finally, it randomly selects a cell from theneighbors list using therandom.choice() function. If there are no available neighbors, it returnsFalse.

Constructing the Maze

Now, that we have a class for creating cells, let's create another class for making the maze. Inmaze.py, create a new class and name itMaze:

# maze.pyimport pygamefrom cell import Cellclass Maze:    def __init__(self, cols, rows):        self.cols = cols        self.rows = rows        self.thickness = 4        self.grid_cells = [Cell(col, row, self.thickness) for row in range(self.rows) for col in range(self.cols)]

The__init__() method contains all the attributes we need for theMaze class. Thecols androws defines how many columns and rows our grid gonna have. The method also sets thethickness attribute to4, which represents the thickness of the walls between the cells in the maze. You can adjust this value to modify the appearance of the maze walls. Thegrid_cells attribute is created as a list comprehension. It creates a list ofCell objects by iterating over each row and column in the maze. EachCell object is instantiated with its respectivecol,row, andthickness values.

Since we already had a grid of cells from thegrid_cells list, we can carve now a path to each cell in order to create the maze. To carve the maze, we're using theremove_walls() method that is responsible for removing the walls between two adjacent cells in the maze:

# maze.pyclass Maze:    ...    # carve grid cell walls    def remove_walls(self, current, next):        dx = current.x - next.x        if dx == 1:            current.walls['left'] = False            next.walls['right'] = False        elif dx == -1:            current.walls['right'] = False            next.walls['left'] = False        dy = current.y - next.y        if dy == 1:            current.walls['top'] = False            next.walls['bottom'] = False        elif dy == -1:            current.walls['bottom'] = False            next.walls['top'] = False

It takes two parameters:current andnext, which represent the current cell and the neighboring cell respectively.

To determine which walls to remove, the function calculates the differences in thex andy coordinates between the current and next cells. These differences are stored in the variablesdx anddy respectively. Ifdx is equal to 1, it means that the next cell is to the left of the current cell. In this case, the left wall of the current cell (current.walls['left']) is set toFalse, indicating that the left wall is removed. Similarly, the right wall of the next cell (next.walls['right']) is set toFalse, removing the right wall between the two cells. Ifdx is equal to -1, it means that the next cell is to the right of the current cell. In this case, the right wall of the current cell and the left wall of the next cell are removed, resulting to carve a path little by little. Similarly, the function checks thedy coordinate differences. Ifdy is equal to 1, it means that the next cell is above the current cell. The top wall of the current cell is removed, as well as the bottom wall of the next cell. Ifdy is equal to -1, the bottom wall of the current cell and the top wall of the next cell is removed.

And to create the maze, we're using thegenerate_maze() method in theMaze class that is responsible for generating the maze using the Recursive Backtracking algorithm:

# maze.pyclass Maze:    ...    # generates maze    def generate_maze(self):        current_cell = self.grid_cells[0]        array = []        break_count = 1        while break_count != len(self.grid_cells):            current_cell.visited = True            next_cell = current_cell.check_neighbors(self.cols, self.rows, self.grid_cells)            if next_cell:                next_cell.visited = True                break_count += 1                array.append(current_cell)                self.remove_walls(current_cell, next_cell)                current_cell = next_cell            elif array:                current_cell = array.pop()        return self.grid_cells

It starts by setting the initial cell as thecurrent_cell, which is the first cell in thegrid_cells list. The algorithm uses awhile loop that continues until thebreak_count is equal to the total number of cells in the maze. Inside the loop, thecurrent_cell is marked as visited, and the algorithm checks for an unvisited neighboring cell using thecheck_neighbors() method of theCell class. If a valid neighboring cell (next_cell) is found, it is marked as visited, the wall between thecurrent_cell andnext_cell is removed, and thenext_cell becomes the newcurrent_cell. If no valid neighboring cell is found and there are cells in thearray, backtracking occurs by setting thecurrent_cell to the most recently added cell in the array. Once the loop completes, the maze generation is finished, and thegrid_cells list is returned. This list represents the fully generated maze, where each cell is marked as visited or unvisited.

Adding Player

Next, we're creating thePlayer class in theplayer.py that is responsible for managing the player's character in the game:

# player.pyimport pygameclass Player:    def __init__(self, x, y):        self.x = int(x)        self.y = int(y)        self.player_size = 10        self.rect = pygame.Rect(self.x, self.y, self.player_size, self.player_size)        self.color = (250, 120, 60)        self.velX = 0        self.velY = 0        self.left_pressed = False        self.right_pressed = False        self.up_pressed = False        self.down_pressed = False        self.speed = 4

In the__init__() method, the player's initial position is set based on thex andy coordinates passed as arguments. Theplayer_size attribute is set to 10, representing the size of the player's character.

Apygame.Rect object is created using the player's position and size that is used for collision detection and positioning of the player's character on the game screen and is stored in theself.rect attribute.

Thecolor attribute is set to (250,120,60), representing the RGB values of the player's character color.The attributesvelX andvelY represent the player's velocity in the horizontal and vertical directions respectively. They are initially set to 0.

The boolean attributesleft_pressed,right_pressed,up_pressed, anddown_pressed are used to track whether the corresponding movement keys (left, right, up, down) are currently being pressed or not. They are all initially set toFalse. Thespeed attribute is set to 4, representing the speed at which the player's character moves in the game.

Let's create two functions in thePlayer class and name themget_current_cell() andcheck_move() for handling the movements of the player:

# player.pyclass Player:    ...    # get current cell position of the player    def get_current_cell(self, x, y, grid_cells):        for cell in grid_cells:            if cell.x == x and cell.y == y:                return cell    # stops player to pass through walls    def check_move(self, tile, grid_cells, thickness):        current_cell_x, current_cell_y = self.x // tile, self.y // tile        current_cell = self.get_current_cell(current_cell_x, current_cell_y, grid_cells)        current_cell_abs_x, current_cell_abs_y = current_cell_x * tile, current_cell_y * tile        if self.left_pressed:            if current_cell.walls['left']:                if self.x <= current_cell_abs_x + thickness:                    self.left_pressed = False        if self.right_pressed:            if current_cell.walls['right']:                if self.x >= current_cell_abs_x + tile - (self.player_size + thickness):                    self.right_pressed = False        if self.up_pressed:            if current_cell.walls['top']:                if self.y <= current_cell_abs_y + thickness:                    self.up_pressed = False        if self.down_pressed:            if current_cell.walls['bottom']:                if self.y >= current_cell_abs_y + tile - (self.player_size + thickness):                    self.down_pressed = False

Theget_current_cell() method takes the player's current position (x andy coordinates) and thegrid_cells list as parameters. It iterates through thegrid_cells list and checks if any cell'sx andy coordinates match the player's position. If a match is found, the corresponding cell object is returned.

Thecheck_move() method is responsible for checking if the player's movement is allowed based on the walls of the current cell they are in. It takes parameters such astile (cell size),grid_cells, andthickness (wall thickness).

First, the method calculates the current cell position of the player by dividing the player's coordinates (x andy) by thetile size. This determines which cell the player is currently in. Then, it retrieves the correspondingcurrent_cell object using theget_current_cell() method. Next, the method calculates the absolute position of the current cell (current_cell_abs_x andcurrent_cell_abs_y) by multiplying the current cell position by thetile size. For each movement direction (left, right, up, down), the method checks if the player's movement is blocked by the walls of the current cell. If the corresponding movement key is pressed and the wall in that direction exists (current_cell.walls['left'],current_cell.walls['right'], etc.), the method further checks if the player's position is near the wall (within a certain threshold defined by thickness). If so, it prevents the movement by setting the corresponding movement flag (self.left_pressed,self.right_pressed, etc.) toFalse.

By implementing these methods, thePlayer class ensures that the player's character moves within the boundaries of the maze and cannot pass through walls, providing collision detection and movement restriction functionality.

Now that we can move without the player passing through the walls, the next thing we need is to draw the player into the game window. We have another two functions for thePlayer class, thedraw() function for drawing the player on its current position and theupdate() function to update the player's position while moving:

# player.pyclass Player:    ...    # drawing player to the screen    def draw(self, screen):        pygame.draw.rect(screen, self.color, self.rect)    # updates player position while moving    def update(self):        self.velX = 0        self.velY = 0        if self.left_pressed and not self.right_pressed:            self.velX = -self.speed        if self.right_pressed and not self.left_pressed:            self.velX = self.speed        if self.up_pressed and not self.down_pressed:            self.velY = -self.speed        if self.down_pressed and not self.up_pressed:            self.velY = self.speed        self.x += self.velX        self.y += self.velY        self.rect = pygame.Rect(int(self.x), int(self.y), self.player_size, self.player_size)

Thedraw() method takes a screen parameter, which represents the game screen or surface. Usingpygame.draw.rect, it draws a rectangle representing the player's character on the specified screen. The rectangle is drawn with theself.color and dimensions defined byself.rect.

Theupdate() method starts by resetting the player's velocity in both the horizontal and vertical directions (self.velX andself.velY) to zero. The method then checks the state of movement input flags to determine the direction of movement. If the left arrow key is pressed (self.left_pressed isTrue) and the right arrow key is not pressed (self.right_pressed isFalse), the player's horizontal velocity (self.velX) is set to a negative value (-self.speed). Similarly, if the right arrow key is pressed and the left arrow key is not pressed, the horizontal velocity is set to a positive value (self.speed).

This logic ensures that the player can only move horizontally in one direction at a time. The same logic is applied to the vertical movement. If the up arrow key is pressed and the down arrow key is not, the player's vertical velocity (self.velY) is set to a negative value (-self.speed). If the down arrow key is pressed and the up arrow key is not, the vertical velocity is set to a positive value (self.speed). This ensures that the player can only move vertically in one direction at a time.

After determining the velocities, the player's position is updated by adding the horizontal velocity to the current x position (self.x) and the vertical velocity to the current y position (self.y). Finally, the player character is redrawn usingpygame.Rect object, which is created using the updated position, player size (self.player_size), and it is assigned toself.rect.

Adding Game Attributes

Now that we have the two most important objects for our game (the maze and the player), we can now start applying some game rules. TheGame class represents the main game logic and functionality of the Maze Game. It encapsulates the rules of the game, adding a winning message (once the player solved the Maze) and a goal point or a finish line:

# game.pyimport pygamepygame.font.init()class Game:    def __init__(self, goal_cell, tile):        self.font = pygame.font.SysFont("impact", 35)        self.message_color = pygame.Color("darkorange")        self.goal_cell = goal_cell        self.tile = tile    # add goal point for player to reach    def add_goal_point(self, screen):        # adding gate for the goal point        img_path = 'img/gate.png'        img = pygame.image.load(img_path)        img = pygame.transform.scale(img, (self.tile, self.tile))        screen.blit(img, (self.goal_cell.x * self.tile, self.goal_cell.y * self.tile))    # winning message    def message(self):        msg = self.font.render('You Win!!', True, self.message_color)        return msg    # checks if player reached the goal point    def is_game_over(self, player):        goal_cell_abs_x, goal_cell_abs_y = self.goal_cell.x * self.tile, self.goal_cell.y * self.tile        if player.x >= goal_cell_abs_x and player.y >= goal_cell_abs_y:            return True        else:            return False

Theadd_goal_point() method is responsible for adding a goal point for the player to reach in the game. First, the code specifies the image path for the gate image and is constructed dynamically using a string and assumes that the gate image is located in the"img" directory and named"gate.png". Make sure to adjust the path and image name accordingly to match your file structure.

The code then loads the gate image usingpygame.image.load(img_path). Next, the code scales the loaded image to match the size of a single grid cell (tile) in the game. This is achieved usingpygame.transform.scale, which takes the loaded image and the desired dimensions as arguments. In this case, the dimensions are specified as (self.tile,self.tile), indicating that the image should be scaled to have a width and height equal toself.tile. Adjust this scaling factor as needed to match the desired size of the gate image on the screen.

Finally, the scaled gate image is drawn on the screen usingscreen.blit(img, (self.goal_cell.x * self.tile, self.goal_cell.y * self.tile)).Theblit() function in Pygame is used to draw oneSurface onto another. In this case, it takes the gate imageimg and specifies the position where it should be drawn on the screen. The position is determined by thex andy coordinates of thegoal_cell (representing the grid cell where the goal point is located) multiplied byself.tile, which gives the pixel coordinates corresponding to the top-left corner of the grid cell.

Themessage() function only returns the winning message once was called.

Theis_game_over() method is responsible for checking if the player has reached the goal point in the game. First, the code calculates the absolute pixel coordinates of the goal cell by multiplying thex andy coordinates of thegoal_cell withself.tile. This determines the top-left corner of the goal cell on the screen. Next, the method compares the player's currentx andy coordinates with the goal cell's absolute coordinates. If both the player'sx coordinate is greater than or equal to the goal cell's absolutex coordinate, and the player'sy coordinate is greater than or equal to the goal cell's absolutey coordinate, it means that the player has reached or surpassed the goal cell. And if the player has reached the goal point, the method returnsTrue, indicating that the game is over. Otherwise, it returnsFalse, indicating that the game is still ongoing.

Adding Game Timer

Let's add some accessories to the game: A timer to measure how long it takes for the player to solve the maze. TheClock class is responsible for managing the game timer functionality in the Maze Game:

# clock.pyimport pygame, timepygame.font.init()class Clock:    def __init__(self):        self.start_time = None        self.elapsed_time = 0        self.font = pygame.font.SysFont("monospace", 35)        self.message_color = pygame.Color("yellow")    # Start the timer    def start_timer(self):        self.start_time = time.time()    # Update the timer    def update_timer(self):        if self.start_time is not None:            self.elapsed_time = time.time() - self.start_time    # Display the timer    def display_timer(self):        secs = int(self.elapsed_time % 60)        mins = int(self.elapsed_time / 60)        my_time = self.font.render(f"{mins:02}:{secs:02}", True, self.message_color)        return my_time    # Stop the timer    def stop_timer(self):        self.start_time = None

TheClock class contains several attributes. Thestart_time attribute is initially set toNone and will store the starting time of the timer. Theelapsed_time attribute is set to 0 and will keep track of the elapsed time since the timer started. Thefont attribute holds a font object from the pygame module, which will be used for rendering the timer text. Themessage_color attribute determines the color of the timer text.

Thestart_timer method sets thestart_time attribute to the current time, effectively starting the timer. Theupdate_timer() method calculates the elapsed time by subtracting thestart_time from the current time. It is intended to be called within the game loop to keep the timer up to date.

Thedisplay_timer() method formats the elapsed time into minutes and seconds and renders it using the specified font and color. We format ourmy_time inmins andsecs to render it in the more analog type of timer. The formatted time is returned as a surface object, which can then be displayed on the screen. This method is responsible for visually displaying the timer to the player.

Lastly, thestop_timer() method resets thestart_time attribute toNone, effectively stopping the timer.

By utilizing theClock class and its methods, we can easily implement and display a timer in the Maze Game. Players will be able to track the time it takes them to complete the maze, adding an exciting element to the gameplay.

Running the Whole Game

The last thing we need is to run all of the code we did into one game. TheMain class will serve as the main class to run our game by containing the game loop to present, update the screen according to current events, and control our game:

# main.pyimport pygame, sysfrom maze import Mazefrom player import Playerfrom game import Gamefrom clock import Clockpygame.init()pygame.font.init()class Main():    def __init__(self, screen):        self.screen = screen        self.font = pygame.font.SysFont("impact", 30)        self.message_color = pygame.Color("cyan")        self.running = True        self.game_over = False        self.FPS = pygame.time.Clock()

Here we start by importing Python modules such aspygame andsys, and also import the Python classes we did earlier.

Let's add theinstructions() method to the main class which simply adds instructions for the game:

# main.pyclass Main():    ...    def instructions(self):        instructions1 = self.font.render('Use', True, self.message_color)        instructions2 = self.font.render('Arrow Keys', True, self.message_color)        instructions3 = self.font.render('to Move', True, self.message_color)        self.screen.blit(instructions1,(655,300))        self.screen.blit(instructions2,(610,331))        self.screen.blit(instructions3,(630,362))

As you notice, I create three different variables to deliver one message, we'll add the message in the sidebar we'll do later and a one-line message will result to go beyond the screen.

Let's create another function and name it_draw() that draws all of the configurations we add to the game screen such as the maze, the player character, the clock, etc:

    # draws all configs; maze, player, instructions, and time    def _draw(self, maze, tile, player, game, clock):        # draw maze        [cell.draw(self.screen, tile) for cell in maze.grid_cells]        # add a goal point to reach        game.add_goal_point(self.screen)        # draw every player movement        player.draw(self.screen)        player.update()        # instructions, clock, winning message        self.instructions()        if self.game_over:            clock.stop_timer()            self.screen.blit(game.message(),(610,120))        else:            clock.update_timer()        self.screen.blit(clock.display_timer(), (625,200))        pygame.display.flip()

The_draw() method is responsible for rendering various game elements onto the screen. Firstly, the maze is drawn by iterating over each cell in themaze.grid_cells list and calling thedraw() method on eachcell object, passing thescreen andtile parameters. This step visualizes the maze structure.

Next, the goal point for the player to reach is added to the screen by invoking theadd_goal_point() method of thegame object, passing thescreen as an argument. The player's movement is then updated by calling thedraw() method on the player object, followed by theupdate() method. This ensures that the player's position is rendered correctly on the screen based on their movement. Additionally, instructions for the game are displayed by calling theinstructions() method, which likely shows information or guidance to the player.

If the game is over, as indicated by theself.game_over flag, the timer is stopped by invoking thestop_timer() method of theclock object. A winning message is also displayed on the screen using themessage() method. Otherwise, the timer is updated by callingclock.update_timer(). The elapsed time is then rendered on the screen usingclock.display_timer(). Finally, the changes made to the screen are updated and displayed usingpygame.display.flip(), allowing the updated game elements to become visible to the player.

And for the last and final touch, we're adding themain() method which contains the main loop of the game. It's also responsible for getting clicks and releasing key events for playing the game:

# main.pyclass Main():    ...    # main game loop    def main(self, frame_size, tile):        cols, rows = frame_size[0] // tile, frame_size[-1] // tile        maze = Maze(cols, rows)        game = Game(maze.grid_cells[-1], tile)        player = Player(tile // 3, tile // 3)        clock = Clock()        maze.generate_maze()        clock.start_timer()        while self.running:            self.screen.fill("gray")            self.screen.fill( pygame.Color("darkslategray"), (603, 0, 752, 752))            for event in pygame.event.get():                if event.type == pygame.QUIT:                    pygame.quit()                    sys.exit()            # if keys were pressed still            if event.type == pygame.KEYDOWN:                if not self.game_over:                    if event.key == pygame.K_LEFT:                        player.left_pressed = True                    if event.key == pygame.K_RIGHT:                        player.right_pressed = True                    if event.key == pygame.K_UP:                        player.up_pressed = True                    if event.key == pygame.K_DOWN:                        player.down_pressed = True                    player.check_move(tile, maze.grid_cells, maze.thickness)            # if pressed key released            if event.type == pygame.KEYUP:                if not self.game_over:                    if event.key == pygame.K_LEFT:                        player.left_pressed = False                    if event.key == pygame.K_RIGHT:                        player.right_pressed = False                    if event.key == pygame.K_UP:                        player.up_pressed = False                    if event.key == pygame.K_DOWN:                        player.down_pressed = False                    player.check_move(tile, maze.grid_cells, maze.thickness)            if game.is_game_over(player):                self.game_over = True                player.left_pressed = False                player.right_pressed = False                player.up_pressed = False                player.down_pressed = False            self._draw(maze, tile, player, game, clock)            self.FPS.tick(60)

First, the method initializes the necessary variables and objects required for the game. It creates instances of theMaze,Game,Player, andClock classes, passing appropriate parameters. The maze is then generated using thegenerate_maze() method, and the timer is started with theclock.start_timer() method.

Inside the main game loop, several actions are performed. First, the screen is cleared by filling it with the color "gray". Additionally, a sidebar or background area is filled with the color"darkslategray". The loop then iterates over the events received from the event queue usingpygame.event.get().

If the event type ispygame.QUIT, indicating that the player closed the game window, the game is terminated. If a key is pressed (pygame.KEYDOWN event), the player's movement direction is updated based on the pressed key, such as left, right, up, or down. Theplayer.check_move() method is called to ensure the player does not pass through walls.

When a key is released (pygame.KEYUP event), the player's movement direction is adjusted accordingly. Thegame.is_game_over() method is called to check if the player has reached the goal. If so, the game over the state is set toTrue, and the player's movement is stopped by resetting the movement direction flags.

The_draw() method is then invoked to render the maze, player, instructions, and timer on the screen. If the game is over, the timer is stopped using theclock.stop_timer() , and a winning message is displayed on the screen. Otherwise, the timer is updated using theupdate_timer() method.

And now we are doing the coding. We can start trying the game by adding the following code below to themain.py below theMain class:

# main.pyif __name__ == "__main__":    window_size = (602, 602)    screen = (window_size[0] + 150, window_size[-1])    tile_size = 30    screen = pygame.display.set_mode(screen)    pygame.display.set_caption("Maze")    game = Main(screen)    game.main(window_size, tile_size)

Here are some of the Game snapshots:

Here's a video of me playing the game:

Throughout this article, we've delved into the key components that make this maze game a thrilling experience. From the maze generation algorithm that ensures each playthrough is unique, to the player's movement mechanics that require careful maneuvering, every aspect has been meticulously crafted to provide an immersive and enjoyable gameplay experience.

The integration of features such as the player's ability to interact with the maze walls, the inclusion of a goal point to strive for, and the incorporation of a timer to track progress add depth and excitement to the gameplay. Additionally, the captivating visuals and intuitive controls enhance the overall immersion and make the maze game a delight to play.

By understanding the inner workings of the maze game, you now have the knowledge to create your own unique twists and variations. Whether you want to introduce additional challenges, create different maze styles, or add power-ups and obstacles, the possibilities for customization and expansion are endless.

You can getthe complete code here.

Here are some other games we've built with Pygame:

Happy coding ♥

Why juggle between languages when you can convert? Check out ourCode Converter. Try it out today!

View Full Code Assist My Coding

Sharing is caring!

Read Also

How to Create a Slide Puzzle Game in Python

Learn how to make a slide puzzle game from scratch step by step with Pygame library in Python.

How to Make a Snake Game in Python

Learn how to build a classic snake game using Pygame in Python. This detailed step-by-step tutorial explains how to initialize Pygame, generate food for the snake, draw game objects, update the snake's position, handle user input, and manage the game loop. Suitable for beginner to intermediate Python programmers intere

How to Make a Checkers Game with Pygame in Python

Learn how to build a checkers game from scratch with the help of Pygame library in Python.

Comment panel

Got a coding query or need some guidance before you comment? Check out thisPython Code Assistant for expert advice and handy tips. It's like having a coding tutor right in your fingertips!