Building Games With Python 3 and Pygame: Part 5


This is part five of a five-part series of tutorials about making games with Python 3 and PyGame. In part four we detected collisions, responded to the ball hitting various game objects, and created a game menu with custom buttons. 

In this last part, we’ll cover diverse topics such as the end game, managing lives and score, sound effects, music, and even a flexible special effects system. For dessert, we’ll discuss potential improvements and future directions.

The End Game

Eventually, the game has to end. In this version of Breakout, the game ends in one of two ways: either the player loses all their lives or they hit all the bricks. There is no next level (although it would be easy to add).

Game Over!

The game_over field of the Game class is set to False in the __init__() method of the Game class. The main loop goes round and round until the game_over variable is set to True:

class Game:
    def __init__(self, 
        self.game_over = False
def run(self):
	while not self.game_over:
		self.surface.blit(self.background_image, (0, 0))



That all happens in the Breakout class in the following cases:

  • The player clicked the QUIT button from the menu.
  • The player loses their last life.
  • The player cleared all the bricks.
def on_quit(button):
    self.game_over = True
	self.is_game_running = False

def handle_ball_collisions(self):
	# Hit floor
	if > c.screen_height:
		self.lives -= 1
		if self.lives == 0:
			self.game_over = True

        if not self.bricks:
            self.show_message('YOU WIN!!!', centralized=True)
            self.is_game_running = False
            self.game_over = True

def update(self):
	if not self.bricks:
		self.show_message('YOU WIN!!!', centralized=True)
		self.is_game_running = False
		self.game_over = True

Display the End Game Message

Usually, when the game ends, we don’t want the game window to just disappear into thin air. The exception is if you clicked the QUIT button in the menu. When the player loses their last life, Breakout displays the traditional ‘GAME OVER!’ message, and when the player wins, it displays ‘YOU WIN!’

The show_message() function is used in both cases. It displays the text on top of the current screen (the game will be paused) and waits for a few seconds before returning. In the next iteration of the game loop, the check for the game_over field will determine it is True, and the program will exit. 

Here is the show_message() function:

def show_message(self, 
    message = TextObject(c.screen_width // 2, 
                         c.screen_height // 2, 
                         lambda: text, 
    message.draw(self.surface, centralized)

Keeping the High Score Between Games

In this version, I don’t keep the high score because there is just one level, and everybody’s score will be the same if they clear all the bricks. In general, it can be done locally by storing the high score in a file and then displaying another message if the player broke the high score.

Adding Sound Effects and Music

Games are an audio-visual experience. Most games have sound effects that are short sound bytes that are played when the player kills a monster, finds some treasure, or explodes horribly. Some games have background music too, which contributes to the atmosphere. Breakout has only sound effects, but I’ll show you how to play background music in your games.

Sound Effects

You need sound files (similar to image files) to play as sound effects. These files can be in .wav, .mp3, or .ogg formats. Breakout keeps its sound effects in the sound_effects folder:

~/git/pygame-breakout > tree sound_effects/
├── brick_hit.wav
├── effect_done.wav
├── level_complete.wav
└── paddle_hit.wav

Let’s see how these sound effects are loaded and played at the right time. First, to play sound effects (or background music) you need to initialize the sound system of Pygame. That happens in the Game class: pygame.mixer.pre_init(44100, 16, 2, 4096)

Then, in the Breakout class, all the sound effects are loaded from the config into the pygame.mixer.Sound object and are stored in a dictionary:

# In
sounds_effects = dict(

# In
class Breakout(Game):
    def __init__(self):
        self.sound_effects = {
            name: pygame.mixer.Sound(sound)
            for name, sound in c.sounds_effects.items()}

Now, we can play the sound effects when something interesting happens. For example, when the ball hits a brick:

# Hit brick
for brick in self.bricks:
    edge = intersect(brick, self.ball)
    if not edge:


The sound effect plays asynchronously, which means the game doesn’t freeze while the sound is playing. Multiple sound effects can be played simultaneously.

Record Your Own Sound Effects and Messages

Recording your sound effects is both easy and rewarding. Unlike visual asset design, it doesn’t take much talent. Anybody can say “Kaboom!” or “Boing” or shout “You’re dead. Better luck next time!”

I often ask my kids to record sound effects as well as voice messages that accompany text messages like ‘YOU WIN!’ or ‘GAME OVER!’ Your imagination is the only limitation.

Playing Background Music

Background music should play constantly. In theory, you can have a very loooooooong sound effect, but a more common approach is simply to play the background music in a loop. Music files can be .wav, .mp3, or .midi format. Here is how it’s done:

music ='background_music.mp3'), 0.0)

You can have only one piece of background music playing at a time. But multiple sound effects can play over the background music. That’s what mixing is all about.

Adding Advanced Features

Let’s get fancy. Breaking bricks with a ball is cool, but it gets old pretty fast. How about a generic special effects system? We’ll develop an extensible system of special effects that are associated with certain bricks and activate when the ball hits the brick. 

Here is the plan. Effects have a lifetime. The effect starts when the brick breaks and ends when the duration of the effect elapses. What happens if the ball hits another special effect brick? In theory, you could have compounding effects, but to simplify things for the initial implementation, the active effect will stop, and the new effect will take its place.

Special Effects System

A special effect can be defined in the most generic way as two functions. The first function activates the effect, and the second function resets it. We want to attach effects to bricks and make it clear to the player which bricks are special, so they can try to hit or avoid them at certain points. 

The following dict from the module defines our special effects. Each effect has a name (e.g. long_paddle) and a value, which consists of the color its brick will have as well as the two functions. The functions are defined as lambda functions that take a Game instance, which includes everything a special effect in Breakout may want to change.

special_effects = dict(
        lambda g: g.paddle.bounds.inflate_ip(
                    c.paddle_width // 2, 0),
        lambda g: g.paddle.bounds.inflate_ip(
                    -c.paddle_width // 2, 0)),
        lambda g: g.change_ball_speed(-1),
        lambda g: g.change_ball_speed(1)),
        lambda g: g.set_points_per_brick(3),
        lambda g: g.set_points_per_brick(1)),
        lambda g: g.add_life(),
        lambda g: None))

When the bricks are created, they have a change to be assigned one of the special effects. Here is the code:

def create_bricks(self):
    w = c.brick_width
    h = c.brick_height
    brick_count = c.screen_width // (w + 1)
    offset_x = (c.screen_width - brick_count * (w + 1)) // 2

    bricks = []
    for row in range(c.row_count):
        for col in range(brick_count):
            effect = None
            brick_color = c.brick_color
            index = random.randint(0, 10)
            if index < len(special_effects):
                x = list(special_effects.values())[index]
                brick_color = x[0]
                effect = x[1:]

            brick = Brick(offset_x + col * (w + 1),
                          c.offset_y + row * (h + 1),
    self.bricks = bricks

The Brick class has an effect field that is usually None, but can get (30% chance) one of the special effects defined above. Note that this code is unaware of what effects are available. It simply gets the effect and the brick color and assigns them if needed. 

In this version of Breakout, I trigger effects only when a brick is hit, but you can imagine other scenarios that could trigger events. The previous effect is reset (if there was one), and then the new effect is launched. The reset function and the effect start time are stored for later.

if brick.special_effect is not None:
    # Reset previous effect if any
    if self.reset_effect is not None:

    # Trigger special effect
    self.effect_start_time =
    # Set current reset effect function
    self.reset_effect = brick.special_effect[1]

If no new effect was triggered, we still need to reset the current event when it expires. That happens in the update() method. In each frame, the reset function of the current effect was assigned to the reset_effect field. If the time since the current effect started exceeded the effect duration then the reset_effect() function is called and the reset_effect field is set to None (meaning there is no active effect right now).

# Reset special effect if needed
if self.reset_effect:
    elapsed = - self.effect_start_time 
    if elapsed >= timedelta(seconds=c.effect_duration):
        self.reset_effect = None

Enlarging the Paddle

The long paddle effect works by inflating the paddle by 50%. Its reset function just resizes it back to normal. The brick color is Orange:

    lambda g: g.paddle.bounds.inflate_ip(
                c.paddle_width // 2, 0),
    lambda g: g.paddle.bounds.inflate_ip(
               -c.paddle_width // 2, 0)),

Slowing the Ball

Another effect that helps with chasing the ball is the slow ball effect, which simply slows the ball speed by one unit. The brick color is Aquamarine.

           lambda g: g.change_ball_speed(-1),
           lambda g: g.change_ball_speed(1)),

More Points

If you want big numbers, you’ll like the triple points effect that gives you three points for each brick you hit instead of the standard one point. The brick color is dark green.

                lambda g: g.set_points_per_brick(3),
                lambda g: g.set_points_per_brick(1)),

Extra Lives

Finally, a very helpful effect is the extra lives effect. It just gives you an extra life. No reset is needed really. The brick color is gold.

            lambda g: g.add_life(),
            lambda g: None))

Future Features

There are several natural directions to extend Breakout. If you’re interested in trying your hand at adding more capabilities and features, here are some ideas.

Take It to the Next Level

To make Breakout a serious game, it needs levels. Playing just one screen is not enough. At the beginning of each level, you will reset the screen, but keep the score and lives as is. To make the game harder, you can slightly increase the ball speed on each level or add another layer of bricks.

Second Ball

Adding a second ball as a temporary effect is bound to create a lot of chaos. The tricky part here is to treat both balls as equal, regardless of which one was the original. When one ball is gone, the game continues with the single ball that was left. No life is lost.

Persistent High Score

When you have levels with increasing difficulty, the high score becomes a coveted prize. You can keep the high score in a file to persist between games. When a player breaks the high score, you can add a little pizazz or let them write their name (traditionally just three characters).

Bombs and Power-Ups

In the current implementation, all special effects are tied to bricks, but you can add effects (good and bad) that drop from the sky and the player has to collect them or avoid them.


Developing Breakout using Python 3 and Pygame was a super rewarding experience. It’s a very powerful combination for 2D games (and 3D games too). If you like Python and want to make your own games, you can’t go wrong with Pygame. 

I definitely plan to make more games with Python and Pygame.

Finally, remember we have plenty of Python content available for sale and for study in the Envato Market.

Leave a Reply

Your email address will not be published. Required fields are marked *