Skip to content
CodeMDD.io | Coding Tutorials

Easily Create Python Games

[

PyGame: A Primer on Game Programming in Python

Are you interested in learning how to write computer games using Python? Look no further! In this article, we will explore PyGame, a Python library that allows you to create games and other graphical programs. By the end of this tutorial, you will be able to draw items on your screen, play sound effects and music, handle user input, and implement event loops. Let’s get started!

Background and Setup

PyGame is a Python wrapper for the Simple DirectMedia Layer (SDL) library, which provides cross-platform access to multimedia hardware components such as sound, video, mouse, keyboard, and joystick. Before we begin, make sure you have PyGame installed on your system. You can install it using the pip command:

$ pip install pygame

To verify your installation, you can run one of the examples that come with the library. Open your terminal and enter the following command:

$ python3 -m pygame.examples.aliens

If a game window appears, then PyGame is installed properly!

Basic PyGame Program

Let’s start by writing a basic PyGame program. First, import the pygame module:

import pygame

Next, initialize PyGame using the pygame.init() function:

pygame.init()

To create a window, you can use the pygame.display.set_mode() function. The following code creates a window with a width of 800 pixels and a height of 600 pixels:

window_width = 800
window_height = 600
window = pygame.display.set_mode((window_width, window_height))

To keep the window open, you need to set up a game loop. The game loop repeatedly checks for events and updates the game state. In this simple example, we will create a basic game loop that runs until the user closes the window:

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

To update the display, use the pygame.display.flip() function:

pygame.display.flip()

Finally, don’t forget to call pygame.quit() to properly shut down PyGame:

pygame.quit()

That’s it! You have written a basic PyGame program that creates a window and maintains a game loop. Run the program and you should see a blank window that closes when you click the close button.

PyGame Concepts

Now that you know how to create a basic PyGame program, let’s dive into some of the important PyGame concepts.

Initialization and Modules

To begin using PyGame, you need to initialize it using the pygame.init() function. This function initializes all the PyGame modules and prepares them for use. You only need to call this function once at the beginning of your program.

pygame.init()

PyGame has various modules that provide different functionalities. Some of the commonly used modules include:

  • pygame.display: This module handles the display functionality, such as creating windows and updating the screen.
  • pygame.event: This module handles user events, such as mouse or keyboard input.
  • pygame.image: This module allows you to load and manipulate images.
  • pygame.mixer: This module provides audio support, allowing you to play sound effects and music.

Make sure to import the modules you need before using them in your program. For example, to use the display module, you can import it as follows:

import pygame.display

Displays and Surfaces

In PyGame, a display represents a physical or virtual screen on which you can draw graphics. The pygame.display.set_mode() function creates a new display window. It takes a tuple containing the width and height of the window as arguments. Here’s an example:

window_width = 800
window_height = 600
window = pygame.display.set_mode((window_width, window_height))

A surface in PyGame is an object that represents an image. You can think of it as a canvas where you can draw your game elements. The window created by pygame.display.set_mode() is also a surface. To draw on the window surface, you can use various functions provided by PyGame, such as pygame.draw.circle() or pygame.draw.rect().

pygame.draw.circle(window, (255, 0, 0), (400, 300), 50)

Images and Rects

PyGame allows you to load and manipulate images using the pygame.image module. To load an image, you can use the pygame.image.load() function. This function takes the path to the image file as an argument and returns a surface object representing the loaded image.

image = pygame.image.load("image.png")

A rect in PyGame represents a rectangle. It is often used to store the position and size of a game object. The pygame.Rect class provides various methods and attributes for working with rects. You can create a rect using the pygame.Rect() constructor.

rect = pygame.Rect(x, y, width, height)

Rects are commonly used for collision detection and positioning game objects on the screen.

Basic Game Design

Now that you have familiarized yourself with some of the PyGame concepts, let’s move on to basic game design. In this section, we will cover the essential components of a game, such as importing and initializing PyGame, setting up the display, setting up the game loop, processing events, drawing on the screen, and using .blit() and .flip().

Importing and Initializing PyGame

To use PyGame, you need to import the pygame module and initialize it using the pygame.init() function.

import pygame
pygame.init()

Setting Up the Display

To create a window for your game, use the pygame.display.set_mode() function. This function takes a tuple containing the width and height of the window as arguments.

window_width = 800
window_height = 600
window = pygame.display.set_mode((window_width, window_height))

Setting Up the Game Loop

A game loop is a way of structuring the code that runs a game. It typically consists of three main parts: handling user input, updating the game state, and drawing the game on the screen. The game loop repeatedly performs these steps until the game is over.

running = True
while running:
    # Handle user input
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False


    # Update game state


    # Draw on the screen


    # Update the display
    pygame.display.flip()

Processing Events

PyGame provides an event system that allows your game to respond to various user actions, such as mouse clicks or keyboard presses. To process events, you can use the pygame.event.get() function, which returns a list of all the events that have occurred since the last time the function was called.

for event in pygame.event.get():
    if event.type == pygame.MOUSEBUTTONDOWN:
        # Handle mouse click event
    elif event.type == pygame.KEYDOWN:
        # Handle key press event

Drawing on the Screen

To draw game elements on the screen, you can use various functions provided by PyGame, such as pygame.draw.circle() or pygame.draw.rect(). These functions take the target surface and the desired parameters (e.g., position, size, color) as arguments.

pygame.draw.circle(window, (255, 0, 0), (400, 300), 50)

Using .blit() and .flip()

To update the display, use the pygame.display.flip() function. This function updates the contents of the window surface and shows the changes on the screen. You can also use the pygame.Surface.blit() function to copy the contents of one surface to another.

# Copy the contents of the image surface to the window surface
window.blit(image, (x, y))


# Update the display
pygame.display.flip()

Sprites

Sprites are a fundamental concept in game programming. They represent game objects that have a position, an image, and other properties. PyGame provides a Sprite class that you can use to create and manage sprites in your game.

Players

In a game, the player is often represented by a sprite. To define a player sprite, you can create a subclass of the pygame.sprite.Sprite class and add the necessary attributes and methods.

class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.image.load("player.png")
        self.rect = self.image.get_rect()
        self.rect.center = (window_width / 2, window_height / 2)


    def update(self):
        # Update player position based on user input
        pressed_keys = pygame.key.get_pressed()
        if pressed_keys[pygame.K_LEFT]:
            self.rect.x -= 5
        if pressed_keys[pygame.K_RIGHT]:
            self.rect.x += 5
        if pressed_keys[pygame.K_UP]:
            self.rect.y -= 5
        if pressed_keys[pygame.K_DOWN]:
            self.rect.y += 5

User Input

To handle user input, you can check for keyboard events in the game loop. PyGame provides functions such as pygame.key.get_pressed() to get the current state of all keyboard keys. You can then update the player’s position based on the user input.

pressed_keys = pygame.key.get_pressed()
if pressed_keys[pygame.K_LEFT]:
    self.rect.x -= 5
if pressed_keys[pygame.K_RIGHT]:
    self.rect.x += 5
if pressed_keys[pygame.K_UP]:
    self.rect.y -= 5
if pressed_keys[pygame.K_DOWN]:
    self.rect.y += 5

Enemies

In addition to the player sprite, you can create enemy sprites that the player needs to avoid or defeat. Enemy sprites are typically created using the same approach as player sprites, with their own attributes and methods.

class Enemy(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.image.load("enemy.png")
        self.rect = self.image.get_rect()
        # Set initial position off-screen
        self.rect.x = -100
        self.rect.y = -100


    def update(self):
        # Update enemy position and behavior
        self.rect.x += 2
        if self.rect.left > window_width:
            self.rect.right = 0
            self.rect.y = random.randint(0, window_height)

Sprite Groups

Sprite groups are a convenient way of managing multiple sprites in a game. You can create a sprite group using the pygame.sprite.Group() class.

enemies = pygame.sprite.Group()
player = Player()
all_sprites = pygame.sprite.Group()
all_sprites.add(player)

To update and draw all the sprites in a group, you can use the update() and draw() methods.

all_sprites.update()
all_sprites.draw(window)

Custom Events

PyGame allows you to create and handle custom events in your game. Custom events are useful when you need to trigger specific actions at specific times. To create a custom event, you can use the pygame.event.Event() class.

custom_event = pygame.event.Event(pygame.USEREVENT, attr1=value1, attr2=value2)
pygame.event.post(custom_event)

To handle a custom event, you can check for it in the game loop using the event.type attribute.

for event in pygame.event.get():
    if event.type == pygame.USEREVENT:
        # Handle the custom event

Collision Detection

Collision detection is an important part of game programming. PyGame provides various functions and methods for detecting collisions between sprites, such as pygame.sprite.collide_rect() or pygame.sprite.collide_mask().

if pygame.sprite.collide_rect(player, enemy):
    # Handle the collision between the player and the enemy

You can also use collision detection to check for collisions between groups of sprites.

collisions = pygame.sprite.groupcollide(player_group, enemy_group, True, False)

Sprite Images

You can manipulate sprite images in PyGame to create more dynamic and visually appealing games. Here are a few techniques you can use:

Altering the Object Constructors

You can modify the constructor of a sprite subclass to change its image dynamically during runtime. For example, you can change the image of an enemy sprite to represent different enemy types.

class Enemy(pygame.sprite.Sprite):
    def __init__(self, image_path):
        super().__init__()
        self.image = pygame.image.load(image_path)
        self.rect = self.image.get_rect()
        # ...

Adding Background Images

You can set a background image for your game window by using the pygame.Surface.blit() function to copy the image to the window surface.

background = pygame.image.load("background.png")
window.blit(background, (0, 0))

Game Speed

Controlling the speed of your game is important to ensure smooth gameplay. You can use the pygame.time.Clock() class to create a clock object that will help you control the speed of your game.

clock = pygame.time.Clock()
while running:
    # ...
    clock.tick(60)  # Limit the frame rate to 60 frames per second

Sound Effects

Sound effects and music can greatly enhance the gaming experience. PyGame provides the pygame.mixer module for working with audio. You can load and play sound effects using the pygame.mixer.Sound() class.

sound_effect = pygame.mixer.Sound("explosion.wav")
sound_effect.play()

You can also play music using the pygame.mixer.music module.

pygame.mixer.music.load("background_music.mp3")
pygame.mixer.music.play(-1)  # Loop the music indefinitely

A Note on Sources

When developing games or other graphical programs, it’s common to use images, sounds, and other media assets created by someone else. Make sure to respect the copyrights and licenses of these assets. PyGame provides pygames.image.load() and pygame.mixer.Sound() functions for loading image and sound assets, respectively.

Conclusion

In this tutorial, we covered the basics of game programming using PyGame. We explored important concepts such as initializing PyGame, setting up the display and game loop, handling user input, drawing on the screen, and using sprites, collision detection, and sound effects. With the knowledge gained from this tutorial, you should be well-equipped to start creating your own games using Python and PyGame. Keep practicing and experimenting to further enhance your skills in game programming!

Remember, the key to becoming a proficient game programmer is practice and persistence. Happy coding!