Code News

Facebook's Latest Fix for Fake News: Ask Users What They Trust

We Put The Entire Internet On The Blockchain—and You Can Too

Why This Quantum-Encrypted Video Hangout Is a Big Deal

Newark's Amazon HQ2 Bid Reveals What's at Stake For Every Finalist City

The Magnetohydrodynamic Drive Is Real—and You Can Build One

This Year's Sundance Lineup Might Be Its Most Crucial Yet

Building Games With Python 3 and Pygame: Part 5

  • Overview

    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, caption, width, height, back_image_filename, frame_rate): ... self.game_over = False ... def run(self): while not self.game_over: self.surface.blit(self.background_image, (0, 0)) self.handle_events() self.update() self.draw() pygame.display.update() self.clock.tick(self.frame_rate)

    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 self.ball.top > 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 return def update(self): ... if not self.bricks: self.show_message('YOU WIN!!!', centralized=True) self.is_game_running = False self.game_over = True return 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, text, color=colors.WHITE, font_name='Arial', font_size=20, centralized=False): message = TextObject(c.screen_width // 2, c.screen_height // 2, lambda: text, color, font_name, font_size) self.draw() message.draw(self.surface, centralized) pygame.display.update() time.sleep(c.message_duration)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/ 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 config.py sounds_effects = dict( brick_hit='sound_effects/brick_hit.wav', effect_done='sound_effects/effect_done.wav', paddle_hit='sound_effects/paddle_hit.wav', level_complete='sound_effects/level_complete.wav', ) # In breakout.py 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: continue self.sound_effects['brick_hit'].play()

    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 = pygame.mixer.music.load('background_music.mp3') pygame.mixer.music.play(-1, 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 breakout.py 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( long_paddle=( colors.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)), slow_ball=( colors.AQUAMARINE2, lambda g: g.change_ball_speed(-1), lambda g: g.change_ball_speed(1)), tripple_points=( colors.DARKSEAGREEN4, lambda g: g.set_points_per_brick(3), lambda g: g.set_points_per_brick(1)), extra_life=( colors.GOLD1, 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), w, h, brick_color, effect) bricks.append(brick) self.objects.append(brick) 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: self.reset_effect(self) # Trigger special effect self.effect_start_time = datetime.now() brick.special_effect[0](self) # 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 = datetime.now() - self.effect_start_time if elapsed >= timedelta(seconds=c.effect_duration): self.reset_effect(self) 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:

    long_paddle=( colors.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.

    slow_ball=(colors.AQUAMARINE2, 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.

    tripple_points=(colors.DARKSEAGREEN4, 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.

    extra_life=(colors.GOLD1, 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.

    Conclusion

    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.


    3 days 21 hours ago

Lil Uzi Vert and the Rest of Soundcloud Rap Will Continue to Dominate Music in 2018

Gadget Lab Podcast: Navigating Facebook's News-Free Future

Pages