Building a Simple Game

From Idea to Plan

You've learned the building blocks of Pygame: how to create a window, handle input, draw shapes, and play sounds. Now it's time to assemble those blocks into a complete game. Before writing a single line of code, every game starts with an idea and a plan.

This planning stage is often called game design. For a simple project, you don't need a massive document. A few notes on the core elements will do. Think about what the player does, what their goal is, and how they win or lose. Let's design a simple game: a player at the bottom of the screen has to dodge falling objects.

Element	Description
Concept	A classic 'dodger' game. The player moves left and right to avoid falling enemies.
Objective	Survive as long as possible. The score increases over time.
Controls	Left and right arrow keys to move the player.
Mechanics	Enemies spawn at the top and fall down. If an enemy hits the player, the game is over.
Assets	Player image, enemy image, background music, collision sound effect.

This simple plan gives us a clear roadmap. We know what to build, what assets we need, and how the game should function. This clarity prevents you from getting lost in the middle of development.

Structuring Your Project

A well-organized project is easier to build and debug. Instead of piling everything into one file, we can separate our code into logical parts. It's also a good practice to keep your assets, like images and sounds, in their own folder.

A common approach is to have a main file that runs the game, a settings or constants file, and a file for each major game object, like the player or enemies. For our simple game, we can start with a main file and a separate settings.py file to hold constants like screen dimensions and colors.

# main.py - The heart of our game
import pygame
import settings # Import our settings

# Initialize Pygame
pygame.init()

# Set up the display using values from settings
screen = pygame.display.set_mode((settings.WIDTH, settings.HEIGHT))
pygame.display.set_caption("Dodger Game")

# Game loop
running = True
while running:
    # Event handling
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Update game state

    # Draw everything
    screen.fill(settings.BLACK)

    # Flip the display
    pygame.display.flip()

pygame.quit()

This structure keeps our main loop clean. All the configuration values, like WIDTH, HEIGHT, and BLACK, are neatly stored in settings.py.

# settings.py - Game constants

# Screen dimensions
WIDTH = 800
HEIGHT = 600

# Colors (R, G, B)
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)

Implementing the Pieces

With our plan and structure in place, we can start building. This involves integrating the concepts you've already covered: loading graphics, implementing player movement, spawning enemies, detecting collisions, and playing sounds.

First, you'd create a Player class. This class would handle loading the player image, positioning it on the screen, and updating its position based on keyboard input. You've already learned how to check for KEYDOWN events for the left and right arrow keys.

Next, you'd create an Enemy class. This class would be responsible for its appearance and movement. Enemies would spawn at a random position along the top of the screen and move downwards. You can use a timer event (pygame.USEREVENT) to spawn new enemies periodically, making the game more challenging over time.

Then, you tie it all together in the main game loop. You'll need a way to manage all the active enemies. A Pygame Group is perfect for this. In each frame of the loop, you update the position of the player and all enemies, and then you draw them to the screen.

The core of the game happens inside the loop: handle input, update game objects, check for collisions, and draw the new scene.

You'll use pygame.sprite.spritecollideany() to check if the player has collided with any sprite in the enemy group. If a collision occurs, you play a collision sound, end the game, and perhaps show a "Game Over" screen. Meanwhile, a score can be displayed on screen, incrementing with each passing frame the player survives.

Testing and Debugging

No game works perfectly on the first try. Testing is a crucial step. Play your game repeatedly and look for bugs. Does the player get stuck? Do enemies spawn correctly? Does the score update as expected?

When you find a bug, debugging is the process of finding and fixing it. The humble print() statement is a powerful debugging tool. You can use it to display the values of variables in the console while the game is running.

For example, if the player isn't moving, you can print its coordinates inside the game loop to see if they are changing. Is the collision not working? Print the positions of the player and the enemy to see if their rectangles are actually overlapping when they appear to on screen.

Start simple. Test one feature at a time. Get the player moving correctly before you add enemies. Make sure enemies fall before you implement collision detection. This iterative process of building and testing makes development much more manageable.

Now you have a process for turning an idea into a simple, playable game.

Quiz Questions 1/5

What is the primary benefit of designing a game's core elements, like player goals and win/loss conditions, before writing any code?

Quiz Questions 2/5

When organizing a Pygame project, what is the recommended practice for handling constants like screen dimensions and colors?

Python for Game Developers in a Week