Python Game Development™: Build 5 Professional Games

learn how to install Python on Windows from python.org, verify installation with command prompt, and set up an integrated development environment to write and run scripts for game development.

Download and install the PyCharm community edition on Windows, set up a Python interpreter, create a project, and install packages to run Python scripts for game development.

Discover how to download and install Visual Studio Code on Windows, add the Python extension, create and run a Python file, and see hello world output.

Learn to install Python 3 on Linux, update packages, verify via the Python shell, and install external libraries with beep for modules like random, math, and pandas.

Install and configure PyCharm on Linux, choose the community version, unzip, set up a Python project and interpreter, and install third-party libraries like panda for game development.

Learn how to use the Python official documentation to explore modules, the math module, and built-in functions for game development, enabling robust, higher-level code.

Learn how to create and use variables in Python with the assignment operator, initialize integers, floats, strings, and booleans, and follow naming rules for readable, case-sensitive code.

Explore Python data types, including strings, sets, and numbers, and learn dynamic typing, string slicing, set uniqueness, and basic numeric types (int, float, complex) with runtime examples.

Explore Python data types by building and manipulating lists, dictionaries, and tuples, learning how to create, index, slice, and access values with keys and indices.

Master Python operators and operands, including integer and floor division, addition, subtraction, multiplication, and exponentiation, using direct operators and the math and operator modules for game development.

Explore boolean operators in Python, including and, or, and not, the truth table, and learn operator precedence with parentheses, exponentiation, and the order of operations.

Explore single-line and multi-line comments for clearer code, and handle user input with Python's input function. Learn how to typecast strings to integers to enable arithmetic operations.

Explore Python modules, including built-in and user-created ones, via importing and aliasing. See how to use math and random modules, and create your own modules with from … import.

Explore how Python lists act as mutable dynamic arrays holding multiple data types, and master append, extend, insert, remove, pop, slice, index, sort, reverse, copy, and in keyword checks.

Explore Python dictionaries as key–value stores, create them with curly braces or dict(), add and access items by keys, and use keys(), values(), and items() with examples.

Master Python string methods, including upper, lower, capitalize, title, translate, and format, and apply slicing, join, split, strip, and isalpha and isdigit checks for robust text handling.

Delve into string formatting in Python using the format method, placeholders and indexes to insert variables and literals, and learn floating point formatting with decimal precision.

Master Python indentation to define blocks for functions, conditionals, and loops, and understand how whitespace shapes readability and correct execution.

Explore Python conditionals, if, elif, and else, that control program flow through boolean tests, with examples showing indentation, code blocks, and simple weather- and input-based scenarios.

Master the while loop and its condition-driven iterations in Python. Use break and continue to control flow, avoid infinite loops, and terminate the loop when conditions are met.

Master Python for loops by iterating over lists, strings, ranges, and dictionaries; leverage range, enumerate, and break/continue to control flow and nest loops for complex data processing.

Explore defining user defined functions in Python with def, pass parameters, call and return results, and use *args and **kwargs to accept arbitrary arguments for reusable, modular code.

Explore default and optional arguments in Python, showing how default values work, how to omit them, and how non-default arguments must follow defaults; also learn list unpacking as an argument.

Learn how anonymous lambda functions create single-line, in-line operations in Python, including parameter handling, arbitrary arguments with args and kwargs, and simple map or reduce patterns.

Apply functional programming in Python by decomposing problems into functions, using lambda for inline operations, and employing map, reduce, and filter to transform and refine data collections.

Explore Python iterators as objects that yield elements at a time, using the __iter__ and __next__ methods, and see how for loops rely on the iterator protocol and stop iteration.

Learn how generators in Python replace heavy iterators with yield, producing values on demand, and explore generator expressions and practical examples.

Learn how Python decorators wrap functions to add behavior, with metaprogramming, apply them (including @decorator syntax), and a safe divide example that handles division by zero.

Learn list and dictionary comprehensions in Python, using the expression, for, and optional if structure. See practical examples that turn loops into concise one-line code and demonstrate real-world usage.

Learn Python object oriented programming by creating classes and objects, defining attributes and methods, using constructors, and exploring bound, unbound, and static methods.

Master basic inheritance in Python by deriving from a base class, using super, reducing code, and applying rectangle and square examples, while learning monkey patching.

Explore how Python implements multiple inheritance alongside basic inheritance, using a foobar example to combine attributes and methods from two parents, override methods, and use super to invoke base behavior.

Explore polymorphism in Python via dog and person classes, where the same methods produce different implementations through dynamic typing and a shared interface that invokes quark and feather behaviors.

Explore properties in object-oriented programming by modeling a Python game character, using read-only attributes like name, is_alive, is_wounded, and is_dead, with damage handling to manage health.

Learn operator overloading in Python by implementing magic methods to extend operators like plus and less-than, enabling vector addition and custom object behavior.

Explore Python exception handling with try, except, and finally blocks, manage division by zero and other errors, and learn about multiple exceptions and re-raising for debugging.

Explore python file handling with open modes, read and write operations, line-by-line reading, exception handling, and directory traversal to manage, read, and write files efficiently.

Learn the __name__ == '__main__' pattern, how Python defines special variables before execution, and how it distinguishes running as main versus importing.

Explore python's math module to perform rounding, floor, ceiling, and trunc operations. Compute the hypotenuse via sqrt, use trigonometric functions and degree and radian conversions, and handle infinity and NaN.

Learn to use the Python random module to perform random operations, import specific methods like choice and sample, and build a secure password generator with a seed for reproducibility.

Explore python's datetime module by creating date, time, and datetime objects, with aware and naive time zones. Learn to compute differences with time delta and format or parse date-time values.

Explore how to use the Python sqlite3 module to create a demo database, build a stocks table, and insert and query records with select, where, and commit.

Learn to use python's collections module to count elements with Counter and manage sequences with deque. Explore practical deque operations like append, appendleft, pop, and indexing.

Explore Python's os module to perform platform-independent low-level tasks: create and remove directories, check permissions with stat, and build or split paths using join and get current working directory.

Learn Python game development by building five professional games, starting with a simple, boilerplate-free approach and progressively creating minigames like Bakhmina and Dods while mastering event handling.

This lecture introduces python game development using the turtle model for minigames, demonstrates core turtle methods, 2D screen setup, and previews the upcoming advanced Bigham module.

Explore how magic methods enable operator overloading in Python and apply a vector-based data model to build mini games, with examples that draw lines and squares using simple graphics tools.

Explore simple animation using the total model and turtle for minigames. Create a vector-based player, set up the game window, and animate movement with on timer.

Introduction to the Python game vector class describes a 2d vector with x and y coordinates, rounding precision, and operator overloads for movement, equality, and position management.

Create a snake game layout using squares for the snake and food, initialize positions as vectors, and drive movement with the M method while handling on key events.

Implement a snake movement system with event handling on a 420 by 420 game screen, moving the head and rendering body squares every 100 milliseconds.

Drive snake movement and event handling; render food, and grow the snake when the head eats. Generate food at random positions and enforce boundaries to end the game on collision.

Build a Pacman game world by rendering a tile map of zeros and ones, with blue path tiles and black walls, a centered food dot, and four corner ghosts.

Demonstrate Pacman movement by handling keyboard input, validating moves against wall tiles and open paths, and mapping positions to tile indices with an offset for valid moves.

Implement Pacman movement on a tile grid by validating arrow-key moves and updating Pacman position. Render Pacman as a dot and eat pellets by updating tiles; initialize ghost positions.

Render ghosts at predefined positions with directional movement, validate moves against non-wall tiles, and implement simple collision checks with Pacman, then transition toward a Pygame-based capstone for more interactivity.

Introduces the pygame module, installing and importing it, creating a game screen, drawing a green rectangle, handling events and keyboard input to move the rectangle, and updating the display.

Use a pygame clock to cap the frame rate and keep the main rectangle movement within the boundary. See how 60 fps yields smooth motion, while lower fps reduces responsiveness.

Learn to load images in pygame by importing a ball image from your project, initialize the screen, manage quit events, and render with blit and display.flip.

Render the player car and green ellipse obstacles in Pygame, enabling left-right movement on the x-axis and random obstacles on the y-axis. Manage the game loop, events, and screen rendering.

Learn to render enemies in a Pygame dodge car capstone by spawning off-screen, moving downward, randomizing x positions, and increasing speed and width as the score rises.

Learn how to implement boundary checks and collision detection in a pygame car dodge capstone, including x bounds, car width, and enemy collisions, with a responsive game loop.

Learn to build a Pygame Pacman capstone by creating wall, food, and player characters; implement sprites, inheritance, event handling, and collision to drive Pacman and ghosts.

Build level one in pygame by defining walls, gates, food, and characters as sprites, grouping them, and scripting ghost tracks for automatic motion and player placement.

Create and render the Pacman game core by loading sprites, setting up the screen, building levels, and implementing the main game loop with keyboard controls and drawing routines.

Master pygame pacman capstone techniques by rendering ghosts, rotating sprites for directions, and enforcing wall collisions to block movement. Learn to flip pacman mouth and adjust orientation with keyboard input.

Master automatic ghost movement in a Pac-Man capstone by using track-based directions and timing, updating speed and position while respecting walls and gates.

Wrap up this Pygame Pac-Man capstone by implementing character movement, food collisions, score rendering with the Pygame font, and music, plus ghost collision handling.

Build a chain reaction clone from scratch, outlining a 10x10 grid, multiplayer atom placement, and overflow rules that determine the winner.

Explore basic math for chain reaction game development, including x and y axes, angle of rotation, and sine and cosine formulas to achieve smooth horizontal and vertical movement.

Learn to code a grid-based chain reaction game in Python using Pygame, defining spots, neighbors, and grid cells to simulate atoms and overflow.

Learn to initialize a 10x10 grid with 40-pixel blocks in pygame, draw roads and grid lines, and manage neighbor relationships for a Python game.

Master the game loop by initializing the grid inside a continuous while loop, updating the display via the display module, and creating game objects for a 10x10 grid.

Learn to build a 10x10 grid in pygame, handle mouse events, compute cell coordinates, and draw atoms as colored ellipses within grid cells.

Implement mouse-driven item placement on a grid, track and render per-player items, validate turns by border color, and cycle players as items accumulate in cells.

Render two atoms by drawing two side-by-side ellipses centered in a grid cell, colored by the atom; discuss three-item overflow and updating the display.

Render three atoms as ellipses inside a box, using rotation and trigonometry (sine and cosine) to place them, radians for angles, and handle overflow by disintegrating items to neighboring positions.

In this lecture, learn to implement overflow in a grid-based game by checking item counts against neighbor cells, disintegrating atoms, and propagating effects to surrounding cells, with color boundaries.

Introduce vibration for atoms in the grid with a vibrate parameter in the game loop. Pass it when rendering atoms and apply x axis fluctuations to enhance interactivity.

Master collision handling and game loops while building a space shooter from scratch in pygame. Import sounds, move the spaceship, and manage game objects and custom events in Python.

Create a Python Pygame shooter by configuring the player, enemies, and bullets as sprite groups and loading subsurfaces from the sprite image.

Learn to implement left and right player movement with boundary checks and a defined speed in pygame, keeping the player static at walls and rendering sprites from sprite sheets.

Build and render a game loop in pygame with a clock to control frame rate for smooth movement. Handle keyboard input for left and right movement and update the screen.

Move a spaceship with up, down, left, and right in pygame, enforcing boundaries using width and height and handling w, a, s, d key input.

Create a bullet class, initialize with the bullet image and start position, and move bullets upward using a group to draw and remove off-screen bullets for performance.

Render enemies as game objects with an enemy class and images, spawn them from the top at random horizontal positions, and move them downward while grouping for future collisions.

Implement collision handling between bullets and enemies and between enemies and the player using group collide and one-in-one checks; remove collided objects, trigger enemy down, player dies, and update score.

Render and display the player's score in a pygame game, updating on enemy kills, and show a centered game over screen with the final score in red.

Load the game over image and sounds from resources, render and center the game over screen with score, and play bullet, enemy down, and game over audio.

Learn to build the Solidaire solitaire game from scratch in pygame, implementing foundations (ace to king, same suit) and tabloid piles (descending, alternating colors) with stockpiles and undo features.

Master the basics of solitaire: 52 cards in four suits, ranks ace to king, with tableau piles, foundations, stockpile, and waste pile, plus draw three rules.

Learn how the pickle module serializes Python objects into byte streams and deserializes them back, enabling binary file storage and network transmission for dictionaries, lists, and other data structures.

Master the copy module and deep copy to create independent object copies, avoiding shared references when editing lists. Apply this to clone a deck of cards for the game project.

Import the UI file for the solitaire game, use the button class to render undo and pause controls, and focus on the backend game logic within a pygame front end.

Import the piles module and instantiate the Pile class to create tableau, foundation, stock, and waste piles, set their order and face-up states, and enable basic card movements for solitaire.

Create a card class for the solitaire game in Python game development, defining image name, size, rank, suit, color, face orientation, position, and mouse-click detection, plus string representations.

Develop a deck class in Python that builds a full deck from suits and ranks, loads card images including the card back, and manages selection, piles, and card attributes.

Learn to load and resize playing card images in Python game development by looping through suits and ranks, handling card backs, and organizing resources for 52 cards.

Instantiate tableau piles, foundations, stock, and waste to build the initial solitaire layout. Compute display size, card size, and spacing to position each pile for a clear and playable setup.

Learn to build a display system for a card game by looping piles (tableau, stock, foundations) and rendering cards with selection highlights, face-up images, and empty foundations.

Build the main game loop with pygame, render cards, piles, and foundations, and implement keyboard and mouse event handling to run your first playable version.

Create undo and redo buttons using the UI module’s button class, initializing with display dimensions, position, color, and text, then render them in the game loop with mouse position detection.

Implement mouse-based card movement in Python game development by adding click handling, deselection, and pile detection for four piles (diabolo, foundation, stock, waste), and use random sampling to shuffle cards.

Master mouse click handling in Pygame to move cards between piles. Learn how to select piles, validate moves, and transfer cards, with future work on stock handling.

Learn to implement valid move detection in a multi-pile card game by managing selection, stock, waste piles, and tableau moves, and updating the game state on click.

Define and call an update method to refresh all piles and the deck using the display height, update positions, and handle left and right clicks, valid moves, and undo actions.

Handle left and right mouse clicks to select and deselect cards. This lecture introduces a right-click handler and previews undo and history manager concepts for tracking card movements.

Implement a compressed deck with a CompressedDeck class to manage piles, decompress card images, and track faced up cards, while building a history manager and undo feature for valid moves.

Learn to implement a history manager that tracks decks and moves, supports undo operations, and uses deep copies to preserve game state.

Configure draw three options in a solitaire game by loading settings from the settings manager, saving and loading with a Python script, and enabling undo via a history manager.