Master Python by making 5 games [the new ultimate introduction to pygame]

Summary

The video teaches Python game development by building five games with Pygame: a space shooter, a Vampire Survivors-style top-down game, Pong, a platformer, and a Pokémon-inspired battle game. The presenter expects viewers to know basic Python functions and data types and to have created at least one class.

The presenter recommends Pygame Community Edition (Pygame CE) over the original Pygame, describing it as the actively maintained, more modern version. Pygame provides relatively low-level tools for drawing, sound, input, and object positions. Unlike a full game engine, it does not provide systems such as physics or networking. Building those systems yourself offers practice with problem-solving and Python.

Core Pygame Concepts

• Game loop and events: Games repeatedly read input, update timers and objects, calculate positions, and draw frames. An event loop handles actions such as closing the window and can capture input events.
• Surfaces and drawing: Surfaces represent images, text, or blank canvases. The display surface is the game window; other surfaces are drawn onto it. Draw order matters because later-drawn elements appear on top.
• Rectangles: Rects position surfaces and support overlap checks. The presenter recommends floating-point rects for movement to avoid losing fractional position changes.
• Vectors and delta time: Pygame vectors make it convenient to represent and update two-dimensional movement. Multiplying movement by delta time makes game speed independent of frame rate. Normalizing the input direction prevents diagonal movement from being faster than horizontal or vertical movement.
• Sprites and groups: Pygame sprites bundle an image and rectangle. Groups can update or draw many sprites together, helping organize larger projects.
• Timers, collisions, and transforms: The tutorial demonstrates reusable timers, rectangle and sprite overlap checks, pixel-mask collisions, surface transformations, and simple frame-based animations.
• Project organization: The games introduce separate Python files, reusable classes, inheritance, multiple inheritance, decorators, and other Python features.

The Five Game Projects

1. Space shooter — Pygame fundamentals The first game introduces window setup, surfaces, rectangles, movement, input, sprite groups, timers, and collisions. It grows to include meteor and laser sprites, a score display, drawing shapes, sound, rotating meteors, pixel-mask collisions, and animated explosions. A key lesson is to remove sprites once they are no longer needed so they do not accumulate.

2. Vampire Survivors-style game — levels, camera, and animation The player moves through a tile-based level, aims a gun with the mouse, and shoots bullets at enemies. The tutorial uses Tiled to create a level and imports its tile and object layers into Pygame. It adds collision resolution against static obstacles, a camera that follows the player, and Y-sorting so characters can appear in front of or behind objects. Enemies use animated sprites and timers; bullets and enemies are handled with sprite collisions, while masks can improve collision accuracy.

3. Pong — moving-object collisions and saving data Pong introduces collisions between two moving objects by comparing both current and previous rectangle positions. The player and opponent share paddle behavior through inheritance, while their direction controls differ. The game tracks the score and saves it to a JSON-formatted file so it persists across runs, with a fallback for the first run when no save file exists. The tutorial also adds a delayed ball reset and shadows.

4. Platformer — gravity, jumping, and reusable systems The platformer imports a level from Tiled and adds horizontal movement, gravity, jumping, and collision checks. It uses a small rectangle beneath the player to determine whether the player is standing on a surface, which gates jumping. The project also develops more centralized asset imports, animated characters, bullets, and a reusable timer system for cooldowns, temporary effects, and recurring enemy spawns. Enemy types use shared behavior through inheritance.

5. Pokémon-inspired battle game — menus and combat logic The final game centers on a menu-driven battle system. It builds menus from text surfaces and rectangles, supports selecting attacks and switching monsters, and connects UI selections to the game logic. Attack damage depends on base damage and elemental effectiveness. Health bars visualize the monsters’ current health, and property getters and setters keep health within its allowed range. The project also includes attack animations, healing, monster switching and defeat, and sound effects.

Guides, Exercises, and Related Tutorials

The video includes coding exercises throughout, such as importing and positioning graphics, implementing movement and collisions, building menus, and adding enemies.

The presenter also points viewers to separate tutorials or introductions for:

• Python fundamentals and classes
• Godot 4
• Pygame masks
• Tiled map creation
• A more complete platformer
• A more elaborate RPG-style game

Main Speaker and Sources

• Main speaker: The video’s instructor and narrator, from the Clear Code channel.
• Sponsor segment: Brilliant, promoted for interactive courses in areas including Python and software development.