Python Game Development™ : Build 11 Total Games

Learn to start with Python and Pygame to build 2D games, handle events, and move in any direction while exploring mini games like Pacman and dodge the car race game.

Explore the turtle module for 2D game development in Python, mastering core methods like forward, left, go to, circle, pen control, and screen events for interactive mini games.

Learn how Python uses magic methods to enable operator overloading, then apply these ideas to 2D game development with vectors, lines, and squares in turtle graphics.

Learn to create simple animations and mini games using the turtle and total modules, building a movable player with a vector class, setup, draw loop, rotation, and boundaries.

Learn the 2d vector class for python games, using x and y coordinates to represent position and movement, with hashing, getters, setters, and operator overloading.

Create a snake game using turtle by rendering the snake as a list of vector-based squares, placing food at zero, zero, and use on key to move by ten units.

Set up a 420 by 420 turtle screen, hide the cursor, and move the snake head every 100 milliseconds while rendering it as green squares.

Develop the snake game capstone by implementing movement, food spawning, boundary checks, and self-collision using the turtle module, with on-timer updates and keyboard controls.

Build a Pacman game world from a zero-one tile map using turtle graphics in Python. Render blue paths, black tiles, and food dots to prepare Pacman and ghost movement.

Learn how Pac-Man movement is validated against blue paths and black tiles, using key events to update movement and a valid/offset system to map positions to tile indices.

Implement Pacman movement by validating moves on the tile map and updating position with vector x,y. Eat dots by updating tiles on a timer, preparing ghost collision logic.

Render four ghosts in Pacman using predefined positions and movement vectors, implement random direction choices within valid tiles, and handle collisions with Pacman before transitioning to Pygame for advanced gameplay.

Install pygame with pip and verify your Python setup, then import the pygame module in a Visual Studio Code environment to run a basic 2D game demo.

Define a 1400×720 pixel game screen and learn that Pygame's origin is the top-left, with x to the right and y downward, using rect and RGB colors to draw shapes.

Learn to draw shapes with the pygame draw module, focusing on the rect method to render rectangles on a surface using x, y, width, height, color, and the top-left origin.

Draw shapes in Pygame—rectangles, lines, circles, and polygons—on a display surface with color and size, and learn the top-left coordinate system for placement.

learn to pick rgb colors with online color pickers and apply them to draw circles in pygame on a display surface by specifying color, position, radius, and thickness.

Explore the fundamentals of pygame with a Python game skeleton. Walk through imports, the main loop, window setup, event handling, screen updates, and optional mixer audio with black background fill.

Import the rect function from Pygame and draw a purple 50 by 50 rectangle on the game window surface at coordinates x and y, using the top-left origin.

Explore moving a 50 by 50 rectangle in Pygame by listening to keyboard input (a, d, w, s) and updating x and y by 50 units with continuous key presses.

Master smooth movement in pygame by using a frame per second tick to run the game loop at 30 fps, and keep the rectangle within the window boundary.

Learn to constrain a player in Pygame to a boundary by clamping x and y, using a 50-pixel wide rectangle and window dimensions to prevent crossing walls.

Explore three major collision detection techniques—overlapping coordinates, distance checking, and axis aligned bounding box—and learn how to apply them to tiled and round objects, with pygame's collide rect.

Explore three collision detection techniques: overlapping collision, distance collision, and axis-aligned bounding box method, with pygame examples, noting their applicability to grid-based games and various shapes.

Create a base class and a vector class to support 14 game projects, managing x and y coordinates, line drawing, and core operations like add, move, and subtract.

Develop and extend the base vector class for 10 games and animation, implementing addition, subtraction, multiplication, division, copy, rotation with radians, magnitude, and representation.

Launch from the base module to run a simple turtle animation, using the vector class, move, wrap, and random direction. Learn timer updates and goto drawing for basic game elements.

Create a bouncy ball animation with turtle and a vector class. Randomize initial velocity, move the ball, bounce on walls, and redraw every 50 milliseconds.

Create a cannon ball game by importing the base module, drawing a blue balloon target, and shooting it with bubbles. Implement boundary checks, ball speed, movement, and basic scoring ideas.

Build a simple, random maze game in Python by drawing a grid, creating walls, and moving between cells, using random to generate new mazes.

Build a snake game by defining the head and food with square blocks, and handle movement, boundary checks, and growth. Explain importing modules and updating snake body and food position.

Build a python snake game by managing the snake as a list, moving with arrow keys, checking boundaries, and generating random food to grow.

Build a Tron-style game where two players extend lines, collide with boundaries or each other, and rotate with keyboard controls using vector movement, drawing, and head-to-body collision logic.

Build a fidget spinner using python turtle, rotate it with the space key, and vary speed with repeated presses while rendering red, blue, green, and white segments.

Learn to build a Python Pac-Man game with a 20-tile grid, score tracking, Pac-Man and ghosts, and tile-based movement using turtle graphics.

Develop a tic tac toe game in Python using Turtle, drawing the grid with lines, rendering Xs and Os, and implementing two-player turns and win conditions.

Develop a two-player pong game in python using turtle, featuring random ball speed, paddle movement, rectangle drawing, collision handling, and a basic game loop with boundaries.

Build a tiles puzzle game that arranges numbers 1 to 15, scrambles the board, and uses tapping to swap tiles with the empty space, rendering numbered tiles on the board.

Develop a Flappy Bird style game in Python using turtle, with a bird and obstacles and boundary checks; track score with updates every 50 ms.

Install PyCharm Community Edition on your machine, configure the Python interpreter, create a new project, and run a simple hello program to start Python game development.

Explore the pygame module for Python game development, learn to import and verify installation, and leverage its tools to control game logic, graphics, and user input.

Initialize the pygame display and create an 800 by 600 game screen. See how the update call refreshes the screen and why a main loop follows.

Learn the main game loop by building a snake game, handling update cycles and user events from the Bigham module, and introduce the upcoming event handling concept.

Master handling events in pygame with an event loop that reads event.type and processes quit, key up/down, and mouse motion or button events using the documentation.

Learn to draw on screen by filling a canvas with rgb colors, then render shapes (rectangles, lines, circles, polygons) at coordinates and update the game screen.

Learn to draw rectangles on the game canvas using x and y coordinates, width and height, and color; explore how draw functions and tuples or lists control placement and size.

Learn to move a snake-like object using arrow keys by updating x and y positions in 10-pixel steps, laying the groundwork for game fundamentals and responsive controls.

Handle multiple key presses by tracking key down and key up events, implement left and right movement on the x axis, and introduce frame rate with a game clock.

Control frame rate by implementing per-second timing, display a clock, and enforce boundaries to achieve smooth snake movement with 30 fps.

Learn to handle keyboard events for game movement, using left and right keys and stopping on release, and prepare for up, down, and boundary drawing in snake-style play.

Handle diagonal movements in the up and down game by syncing x and y coordinates to enforce strict vertical or horizontal movement through event handling.

define and apply a boundary to constrain the snake's movement within 0 to 800 horizontally and 0 to 600 vertically, and implement an exit condition when boundaries are crossed.

Replace hard coding with variables for display width, height, and block size to simplify maintenance. Define frame per second and other values as variables to enable easy testing and changes.

Add a game over screen that displays a scripted message such as 'you lose' using screen text, fonts, colors, and timing to communicate game state.

Define and implement a game loop as the main loop, manage game over state, and handle input to play again or quit, updating the display accordingly.

Identify how to place an apple at a random position on the game screen using the random module, adjusting for block size and display height in a snake game.

Learn to align the apple to a multiple of 10 using round and division, detect collision when the snake head coordinates match the apple, and increase the snake length.

Develop a green snake that moves on a grid, keeps its body as a list of coordinates, places apples at random positions, and grows on eating while restarting at boundaries.

Implement snake game logic using x and y coordinates and a neck list to represent segments, update growth, and render the head and body on screen.

Build the snake body in a Python game development context by updating a snake list with the head, appending as it grows, and trimming the tail in the game loop.

Extend the snake length when eating apples and place a new apple. Detect self-collision by comparing the head coordinates with the rest of the body to trigger game over.

Learn how to handle object crossover across boundaries when objects differ in size, using boundary calculations and thickness to detect hits and eating events in a snake and apple scenario.

Learn how to align the game over text within a center-aligned rectangle and position it at the screen center for a polished end-of-game screen.

Add a 20 by 20 head sprite to the snake using a paint tool, draw it in green, then remove its background with a background removal tool and export.

Learn to add images in pygame by using sprites, loading a head image, and rendering it on the snake game, with rectangles for body parts and proper positioning.

Rotate enemy sprites to face movement by mapping direction to rotation angles (90, 180, 270 degrees) in the game loop, and update direction via left right up down arrow events.

Design a game menu by managing on-screen masses with displacement and spacing to avoid overlap, implement game over screens, and control play and quit inputs.

Learn to create a more appealing menu screen by styling text with small, medium, and large fonts, selecting fonts like Comic Sans, colors, and on-screen text rendering.

Create a one-time start screen that shows welcome text, space to play, and q to quit, with on-screen messages and colors; plan to handle input events to start or exit.

Continue building the entry screen by handling input events, using space to continue, and quitting with q, while guarding the game loop and controlling the frame timing.

Import a 20 by 20 apple sprite, resize to 20-pixel blocks, and render it in the snake game with transparent background.

Create and test a game icon for your python snake project on a 32 by 32 surface, adjust block and apple sizes, and plan scoring next.

Render the score for a Python snake game. Start from zero and increase as the snake eats apples, with the score displayed as text at the top.

install cxFreeze and convert your Python game built with the Bigham module into a distributable exe by creating a setup file that defines the executable and included files.

Convert the snake game to an executable via the command line, set a description, and generate physical executables for Windows, Linux, or Mac.

Learn to download and install cx freeze, configure the environment, and build and package a Python snake game for Windows, Mac, or Linux, with administrator privileges when required.

Install and configure Open Ziel in a Python project, import from Open Ziel and Bigham, and define x, y, z vertices to render 3D graphics.

Define the cube's vertices and edges using tuples to map coordinates, visualize unit steps, and emphasize vertex order to render a connected 3d cube.

Learn how to draw a cube in OpenGL by defining vertices and lines, setting up the draw loop, and interpreting data to render a 3D object with perspective.

Explore the view setup for a cube in Python game development, defining a perspective with field of view and aspect ratio, enabling double buffering, and setting clipping planes for rendering.

Apply a new perspective, translate the cube in x y z, rotate and tilt it. Render with open gl, clear the screen, and handle quit events in the main loop.

Discover how OpenGL rotates a cube, applies axis-specific orientation and translations, and uses clipping planes for perspective rendering and visibility control.

Discover why the order of vertices matters in game objects, as changing a single vertex disrupts rendering, clipping, and rotation, underscoring the need for correct vertex sequencing.

Zoom in and out of a cube by handling mouse button events, translating with x, y, z values, and rotating in OpenGL, with clear, draw, and render steps.

Learn to recreate a classic flappy bird game using basic programming skills, implementing tap-to-flap controls and scoring as you pass pipes.

Learn to use the Bigham rectangle object to position and size sprites, and perform copy and move transformations; explore frame rate and millisecond timing for Flappy Bird style gameplay.

Load and organize sprite assets for a flappy bird game, configure window size and frame rate, and initialize images for background, bird, wings, and pipes using the provided assets.

Create the board class to manage timing with frames to milliseconds at a default 60 fps, and define the bird as the player-controlled main character with pipe avoidance.

Complete bird class implements smooth vertical climbing using a cosine-based motion driven by frame elapsed; updates position, computes delta time, and renders the bird with a rectangle and image attributes.

Build a pipe obstacle system for a flappy bird style game, with top and bottom pipes, image handling, and new pipes spawning at intervals with randomized gaps.

Define a complete pipe class for a Python game, with top and bottom heights, visibility, and a collision rectangle; implement update to move pipes left and handle player collisions.

Explore event handling and collisions in the Python game development project, implementing a bird, pipes, and score updates within the main loop, with input, movement, and collision logic.

Explore running the game and rendering pipes, using a frame clock to spawn new pipes at set intervals and a deque to manage active pipes, updating the display each frame.

Add and display the score when the bird crosses a pipe, update score logic, and render the score as pipes move in this flappy bird style game.

Learn to build an angry bird style game by following along line by line, from basics like installing the board to implementing game logic, level progression, points, and replay.

Explore core physics used in game development, including gravity, mass, inertia, impulse, collision handling, friction coefficients, and beam-and-column structures for building Angry Birds-style mechanics.

Create a new project named angry bird, install Pymunk for physics, and import sprites. Load assets from resources, set a 650 by 650 display, and initialize background, bird, and sling.

Create the bird as a solid circle body in a 2d physics space with the monk module; define mass, radius, inertia, gravity, impulse, and the pig as the second character.

Add physics to the pig by creating a solid circle body with mass and inertia, then apply friction like the bird.

This lecture teaches building a polygon class to create beam and column for a game, using subsurface images extracted from beam and column sprites and preparing the physics body.

Practice drawing polygons and rendering beam and column sprites by converting polygon vertices to 2d vectors, applying rotations, offsets, and on-screen positioning.

Explore the base of physics in Python game development by building a sprite-based scene, implementing gravity, mouse-drag sling mechanics, and a main loop that manages objects, trajectories, and scoring.

Develop a physics setup with static bodies and lines, define segments and collision types, and calculate unit vectors and distance for stable bird and pig motion.

Learn to implement a sling action in Python game development by modeling rope dynamics, unit vectors, displacement, and impulse angle using arctan, guiding projectile motion.

Build a level in Python game development by creating labeled levels with beams, columns, and polygons, importing character and polygon modules, and scripting bird count and level layout.

Create and manage the main game loop, handling mouse and keyboard input, updating physics, and rendering a sling-based level with labels, birds, beams, gravity, and background.

Render a bird on screen by updating its body position with vector coordinates, drawing its body parts and blue lines, and displaying the pig alongside.

Render beam and column on screen by computing their positions, applying rotation and scaling, converting beam coordinates to screen coordinates, and drawing the transformed image on the game surface.

Blit and render game elements for a flappy bird style test, drawing columns and beams while updating physics with gravity and friction, and preparing for collision and scoring features.

Learn to implement bird and beak collisions using collision types and a post-solve handler, removing hit objects, updating lives, and wiring collision handlers to drive gameplay.

Develop an Angry Birds–style game with a dynamic score panel, level progression from 0 to 5, collisions, and UI controls like play, pause, restart, and next.

Render a score panel, initialize a global score variable to zero, and increment the score on collisions, displaying the updated value in white text at a defined position.

Transition from level one to level two by implementing a level cleared screen, score-based stars, and a next button, while managing global level state and replay options.

Implement a restart function that deletes all current level objects (pigs, birds, beams, columns) and resets scores and level state, enabling clean transitions between levels.

Manage game events for collisions and finishing a level by checking mouse input and button presses to resume, restart, or advance levels, while resetting scores and loading the next level.

Begin the arrest game, aiming to collect all trophies within minutes, while learning to work with ai and observe how it acts as the turn starts.

Initialize a python game project with Bigham, import modules, create a main loop with a clock and sprite groups, and configure a full-screen display with a background surface.

Import media assets, load images with transparency via a loader class, and set color keys to render sprites. Build a tile map from map files and handle rotations.

Create a player class using a sprite, load and set its image, center rotation, and spawn position from the map; configure movement with speed, acceleration, deceleration, and max speed.

Learn the functions of the player class, including initialization, reset, spawn, track emission, grass deceleration, and steering to drive movement and rotation.

Explore implementing a Python game boundary system by defining a camera with x and y coordinates, setting min and max bounds, detecting out-of-bounds positions, and rendering boundary visuals.

Learn to add tracks to your Python game by scripting rotation around the image center, handling surfaces, lifetime, and an update loop that moves sprites with the camera.

Explore how to implement game mode by initializing maps, handling random placement of tiles, and resetting game state with time left, score, and penalties, using an initializer and camera updates.

Learn to handle player events, load and render tile-based maps, generate terrains, and drive a camera through a running game loop that processes keyboard input and renders the scene.

Create a traffic system for a Python game by loading vehicle graphics, initializing car variables, and implementing map-based rotation, movement, and collision logic.

Learn to implement ai-driven traffic in a Python game, including rotating directions, random car placement and speed, and collision groundwork for engaging play.

Detect collisions between the player's car and traffic cars and apply an impact emitter that slows the player on impact.

Implement collision handling between the car and traffic sprites, slowing or stopping movement with an impact emitter when a collision occurs and finishing the gameplay loop.

Explore variables in Python game development, using the box analogy to assign and reference values, and understand dynamic type programming and how to store data for reuse.

Explore Python’s core arithmetic: addition, subtraction, multiplication, and division, and distinguish integers from floats, including floor division and modulo operations that return remainders.

Master the Python math module by importing it and using functions like floor, ceiling, power, sqrt, and pi, as well as cosine, sine, and hyperbolic operations.

Explore Python strings, including literals in double or single quotes, and learn to create, fix, and print strings like hello world, with comments to prevent execution.

Explore core Python string methods, including formatting, counting, case conversion, and immutability, with practical examples using strip, index, and find.

Learn string formatting in Python by taking user input, storing it in variables, and printing formatted strings using the format method with placeholders and indexes.

Learn Python string slicing by slicing strings with the square bracket syntax, mastering zero-based indexing, start and end positions, and exclusive end to extract substrings, reverse strings, and handle negatives.

Extract a user name and domain from an input email using string slicing and indexing, then format and print the results.

Master booleans in Python, including true/false values and case sensitivity, and learn comparison operators such as >, <, >=, <=, ==, and != for conditional logic.

Master Python conditional logic by using if, else, and elif with comparison operators to control program flow and outcomes.

Master not and logical operators in Python to evaluate conditions and control flow with if statements and truth tables.

Master the while loop to repeat actions until a condition becomes false, and see practical examples like printing names and building a list that stops at three items.

Master for loops and range to iterate over data structures like strings, lists, and tuples, using range to generate numbers from start to end, and compare with while loops.

Learn to create and manipulate lists in Python, using zero and negative indexing, slicing, and nested lists with multiple data types, plus common methods like append and pop.

Learn how dictionaries map keys to values, look up by key, and add, update, or delete entries; convert keys and values to lists or tuples, noting not ordered.

Build a Python program that counts character occurrences in a string using a dictionary, looping over input and using get with a default value to print formatted results.

Define your own function using def, specify parameters, and return x plus y. Explore positional and keyword arguments, and local versus global scope for reusable game code.

Learn how to define functions with parameters and use default arguments for flexible calls. The lecture shows that default values must be last and non-defaults cannot follow defaults.

Explore packing and unpacking arguments in Python using *args and **kwargs, with examples on lists, dictionaries, and summing numbers for games.

Explore object oriented programming by defining classes and objects to model game characters with attributes and actions. Learn constructors, self, and inheritance to manage complex game data efficiently.

Learn how inheritance lets a subclass override a parent class method with the same signature, enabling different functionality for the subclass, and when needed, call the parent method.

Master operator overloading to perform vector addition in a two dimensional vector class, and implement data hiding with double underscore attributes to protect internal state.

Explore the Mario project overview by rendering game components, implementing movement, and handling growth when items are eaten, to demonstrate building Mario-style gameplay.

Set up a mario-style game project, configure the interpreter, and load resources to enable event handling. Implement the main loop with state management and keybindings to drive gameplay.

Define the main game loop and event loop, handling events, updating game state, and rendering frames while loading graphics, sounds, and resources from a dedicated assets directory.

Build a collider system by implementing a collider class, level state, and a game checkpoint with an invisible sprite and a door tile.

Load mario sprites from a sprite sheet, set up animation timers and frame indices, and define velocity, gravity, and invincible states to drive the character's movement.

Extract Mario from sprite sheet by slicing sprite frames with rectangles, scaling, and blitting; implement left-right flips and transitions between small and big Mario across walking animations.

Create a single list of left and right frames in small, normal, and big sizes with green, red, and black variants to build composite Mario images.

This lecture explains managing Mario's states—standing, walking, jumping, falling, and dying—using state handlers, actions, keybindings, velocity, and animation frames, including size changes and fireball power-ups.

Implement left and right movement for a Mario-style character using velocity, acceleration, and deceleration, manage facing direction, and apply keybindings to drive walking animation.

Calculate the character's animation speed from velocity to drive walking motion in a Mario-style game. Implement left/right movement, gravity, jumping, and fireball actions with velocity limits and acceleration.

This lecture guides you through implementing state transitions for a game character, including movement with gravity, directional sprites, and size-changing and crouching animations.

Master time-based Mario events by animating transitions from small to middle to big sprites, using a self-timer and time-based triggers to control image state and movement.

Implement time-based state transitions to control Mario's animations between start and end times. Handle enemy collisions to shrink Mario from big to small and trigger the invincible time.

Develop and animate a goomba enemy for a Mario-style game by creating an enemy class, setting up frames and velocity with gravity, and implementing walking, falling, sliding, and jumping behaviors.

Implement an enemy in a Python game by creating a sprite with animated frames, loading images, applying gravity and velocity, and handling brick collisions and scoring.

Define and implement a mushroom power-up in a Python game by creating a dedicated sprite class, loading frames, setting up initial position, and handling movement, sliding, and state logic.

Implement bricks for the game by defining a brick class, handling destruction, gravity, and animations, and integrating power-ups and coin mechanics for level progression.

Implement a score panel by rendering digit sprites from images, updating and drawing floating, disappearing scores, and managing a score list for level 1.

Build and render a game level by setting up the background, ground, bricks, steps, pipes, and enemy groups, then initialize the viewport and level objects for play.

Define and place Mario as the player, set up enemy groups, ground, pipes, and level background, and implement update logic to handle keys and frozen states.

Blit everything covers updating sprites, enemy and power-up groups, and coin boxes, while scrolling the viewport to follow Mario. It explains drawing layers, collisions, and level rendering to drive gameplay.

Create a load screen class that imports setup and content, defines startup and persistence, and manages a next-state. Update the screen to render a loading state and transition.

Build an in-game info panel that displays score, time remaining, lives, and top score, while handling level information and sprite-based visuals.

Implement a handle level function to update overhead info and manage the level state. Update score images and the countdown clock based on the level being frozen or active.

Set up a Python game project by importing screens and modules, configure the level 1 layout, run the game, and observe movement, score, and on-screen elements.

Develop a score update system that refreshes images and labels, converts scores to strings via a reverse loop, and updates the on-screen clock in a Python game development project.

Define and position game levels, draw loading and level screens, and manage blit-based rendering of characters, letters, and level labels to drive gameplay.

Implement and refine Mario movements by checking deaths, collisions, and on-screen boundaries; manage enemies, power-ups (stars and mushrooms), and off-screen object removal to complete the level.

Implement collision detection between enemies and pipes, manage an enemy group, and handle enemy direction changes, displacement, and removal on collision for dynamic gameplay.

Implement and fine-tune enemy collisions on the y axis, handling pipes, bricks, and brick groups, updating states, velocity, and enemy death.

Implement x-axis collision checks in a Python Mario game, handling collisions with bricks, enemies and power-ups, updating score, and enabling invincibility, size changes, and power-up transitions.

Implement power-up conversions between five flowers and mushrooms, update bricks and coin boxes accordingly, and handle collision with pipes by adjusting Mario's velocity and direction.

Learn how to implement collisions between objects in a Python game by defining colliders and sprite groups, handling brick, pipe, coin box, power-up, and enemy collisions with priority rules.

Implement four-way collision detection for Mario with bricks, manage brick content and coin collection, update the score, and adjust Mario's velocity to respond to collisions and brick openings.

Render all game elements and implement collisions between Mario, bricks, and enemies, updating scores and handling enemy deaths, player velocity, and game over conditions in a Mario-style game.