Chapter 1 
Installing Python and Pygame
If your operating system is Ubuntu or Linux, start IDLE by opening a terminal window and then 
type 
idle3‖ and press Enter
. You may also be able to click on Applications at the top of the 
screen, and then select Programming, then IDLE 3. 
The window that appears when you first run IDLE is called the interactive shell. A shell is a 
program that lets you type instructions into the computer. The Python shell lets you type Python 
instructions, and the shell sends these instructions to the Python interpreter to perform. 
Installing Pygame 
Pygame does not come with Python. Like Python, Pygame is available for free. You will have to 
download and install Pygame, which is as easy as downloading and installing the Python 
interpreter. In a web browser, go to the URL http://pygame.org 
and click on the ―Downloads‖ 
link on the left side of the web site. This book assumes you have the Windows operating system, 
but Pygame works the same for every operating system. You need to download the Pygame 
installer for your operating system and the version of Python you have installed. 
You do 
not want to download the ―source‖ for Pygame, but rather the Pygame ―binary‖ for your 
operating system. For Windows, download the pygame-1.9.1.win32-py3.2.msi file. (This is 
Pygame for Python 3.2 on Windows. If you installed a different version of Python (such as 2.7 or 
2.6) download the .msi file for your version of Python.) The current version of Pygame at the 
time this book was written is 1.9.1. If you see a newer version on the website, download and 
install the newer Pygame.  
For Mac OS X, download the .zip or .dmg file for the version of Python you have and run it. 
For Linux, 
open a terminal and run ―sudo apt-get install python-pygame
On Windows, double click on the downloaded file to install Pygame. To check that Pygame is 
install correctly, type the following into the interactive shell: 
>>> import pygame 
Pdf security password - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF
Help to Improve the Security of Your PDF File by Adding Digital Signatures
pdf password encryption; decrypt a pdf
Pdf security password - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures
convert locked pdf to word doc; copy text from encrypted pdf
4    
http://inventwithpython.com/pygame
Email questions to the author: al@inventwithpython.com 
If nothing appears after you hit the Enter key, then you know Pygame has successfully been 
installed. If the error 
ImportError: No module named pygame
appears, then try to 
install Pygame again (and make sure you typed 
import pygame
correctly). 
This chapter has five small programs that demonstrate how to use the different features that 
Pygame provides. In the last chapter, you will use these features for a complete game written in 
Python with Pygame. 
A video tutorial of how to install Pygame is available from this book's website at 
http://invpy.com/videos. 
How to Use This Book 
―Making Games with Python & Pygame‖
is different from other programming books because it 
focuses on the complete source code for several game programs. Instead of teaching you 
programming concepts and leaving it up to you to figure out how to make programs with those 
concepts, this book shows you some programs and then explains how they are put together. 
In general, you should read these chapters in order. There are many concepts that are used over 
and over in these games, and they are only explained in detail in the first game they appear in. 
But if there is a game you think is interesting, go ahead and jump to that chapter. You can always 
read the previous chapters later if you got ahead of yourself. 
The Featured Programs 
Each chapter focuses on a single game program and explain how different parts of the code work. 
It is very helpful to copy these programs by typing in the code line by line from this book. 
However, you can also download the source code file from this book's website. In a web browser, 
go to the URL http://invpy.com/source and follow the instructions to download the source code 
file. But typing in the code yourself really helps you learn the code better. 
Downloading Graphics and Sound Files 
While you can just type in the code you read out of this book, you will need to download the 
graphics and sound files used by the games in this book from http://invpy.com/downloads. Make 
sure that these image and sound files are located in the same folder as the .py Python file 
otherwise your Python program will not be able to find these files. 
Line Numbers and Spaces 
When entering the source code yourself, do not type the line numbers that appear at the beginning 
of each line. For example, if you see this in the book: 
VB.NET PDF Password Library: add, remove, edit PDF file password
RasterEdge XDoc.PDF SDK provides some PDF security settings about password to help protect your PDF document in VB.NET project.
change security settings pdf reader; decrypt pdf with password
C# PDF Password Library: add, remove, edit PDF file password in C#
Permission Using C#.NET. Help C# Developers to Improve the Security of Your PDF Document by Setting Password in C# .NET Application.
change pdf security settings reader; change security settings on pdf
Chapter 1 
Installing Python and Pygame
1. number = random.randint(1, 20) 
2. spam = 42 
3. print('Hello world!') 
You do not need to type the 
1.
on the left side, or the space that immediately follows it. Just 
type it like this: 
number = random.randint(1, 20) 
spam = 42 
print('Hello world!') 
Those numbers are only used so that this book can refer to specific lines in the code. They are not 
a part of the actual program. 
Aside from the line numbers, be sure to enter the code exactly as it appears. Notice that some of 
the lines don
t begin at the leftmost edge of the page, but are indented by four or eight or more 
spaces. Be sure to put in the correct number of spaces at the start of each line. (Since each 
character in IDLE is the same width, you can count the number of spaces by counting the number 
of characters above or below the line you're looking at.) 
For example in the code below, you can see that the second line is indented by four spaces 
because the four characters (
whil
) on the line above are over the indented space. The third line 
is indented by another four spaces (the four characters, 
if n
are above the third line's indented 
space): 
while spam < 10: 
if number == 42: 
print('Hello') 
Text Wrapping in This Book 
Some lines of code are too long to fit on one line on the pages in this book, and the text of the 
code will wrap around to the next line. When you type these lines into the file editor, enter the 
code all on one line without pressing Enter. 
You can tell when a new line starts by looking at the line numbers on the left side of the code. For 
example, the code below has only two lines of code, even though the first line wraps around: 
1. print('This is the first line! xxxxxxxxxxxxxxxxxxxxxxxxxxxxx 
xxxxxxxxxxxxxx’) 
2. print('This is the second line, not the third line.') 
Online Remove password from protected PDF file
hlep protect your PDF document in C# project, XDoc.PDF provides some PDF security settings. On this page, we will talk about how to achieve this via password.
copy locked pdf; pdf encryption
VB.NET PDF Library SDK to view, edit, convert, process PDF file
XDoc.PDF SDK allows users to perform PDF document security settings in VB.NET program. Password, digital signature and PDF text, image and page redaction will
decrypt pdf file; secure pdf remove
6    
http://inventwithpython.com/pygame
Email questions to the author: al@inventwithpython.com 
Checking Your Code Online 
Some of the programs in this book are a little long. Although it is very helpful to learn Python by 
typing out the source code for these programs, you may accidentally make typos that cause your 
programs to crash. It may not be obvious where the typo is. 
You can copy and paste the text of your source code to t
he online diff tool on the book’
s website. 
The diff tool will show any differences between the source code in the book and the source code 
you’
ve typed. This is an easy way of finding any typos in your program. 
Copying and pasting text is a very useful computer skill, especially for computer programming. 
There is a video tutorial on copying and pa
sting at this book’
s website at 
http://invpy.com/copypaste. 
The online diff tool is at this web page: http://invpy.com/diff/pygame. There is also a video 
tutorial on how to use this tool on the book’s website
More Info Links on http://invpy.com 
There is a lot that you can learn about programming
. But you don’t need to learn all of it now. 
There are several times in this book where you might like to learn these additional details and 
explanations, but if I included them in this book then it would add many more pages. If this 
larger, heavier book accidentally fell on you the weight of these many additional pages would 
crush you, resulting in death
. Instead, I have included ―more info‖ links in this book that you can 
follow on 
this book’s website. You do not h
ave to read this additional information to understand 
anything in this book, but it is there if you are curious. These (and other) links have been 
shortened and begin with http://invpy.com. 
All of the information from these ―more info‖ links can also be do
wnloaded from 
http://invpy.com/pygamemoreinfo. 
Even though this book is not dangerously heavy, please do not let it fall on you anyway. 
C# HTML5 Viewer: Deployment on AzureCloudService
RasterEdge.XDoc.PDF.HTML5Editor.dll. system.webServer> <validation validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
add security to pdf file; change pdf document security properties
C# HTML5 Viewer: Deployment on ASP.NET MVC
RasterEdge.XDoc.PDF.HTML5Editor.dll. system.webServer> <validation validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
pdf file security; copy paste encrypted pdf
Chapter 2 
Pygame Basics
C
HAPTER 
2
P
YGAME 
B
ASICS
Just like how Python comes with several modules like 
random
math
, or 
time
that provide 
additional functions for your programs, the Pygame framework includes several modules with 
functions for drawing graphics, playing sounds, handling mouse input, and other things. 
This chapter will cover the basic modules and functions that Pygame provides and assumes you 
already know basic Python programming. If you have trouble with some of the programming 
concepts, you can read through the ―Invent Your Own Computer Games with Python‖ book 
online at http://invpy.com/book. This book is aimed at complete beginners to programming. 
The ―Invent with Python‖ book also has a few chapters covering Pygame. You can read them 
online at http://invpy.com/chap17. 
Once you learn more about Pygame, you can view the other modules that Pygame provides from 
the online documentation at http://pygame.org/docs. 
GUI vs. CLI 
The Python programs that you can write with Python’s built
-in functions only deal with text 
through the 
print()
and 
input()
functions. Your program can display text on the screen and 
let the user type in text from the keyboard. This type of program has a command line interface
or CLI (which is pronounced 
like the first part of ―climb‖ and rhymes with ―sky‖). These 
programs are somewhat limited 
because they can’t
display graphics, have colors, or use the 
mouse. These CLI programs only get input from the keyboard with the 
input()
function and 
even then user must press Enter before the program can respond to the input. This means real-
time (that is, continuing to run code without waiting for the user) action games are impossible to 
make. 
Pygame provides functions for creating programs with a graphical user interface, or GUI 
(pronounced, ―gooey‖). 
Instead of a text-based CLI, programs with a graphics-based GUI can 
show a window with images and colors. 
Source Code for Hello World with Pygame 
Our first program made with Pygame is a small program that makes a window that says 
―Hello 
World!‖ appear on the screen. Open a new file editor window by clicking on IDLE’s 
File menu, 
then New Window. Type in the following code into ID
LE’s file editor 
and save it as 
blankpygame.py. Then run the program by pressing F5 or selecting Run > Run Module from the 
menu at the top of the file editor. 
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
DNN (DotNetNuke), SharePoint. Security PDF component download. Online source codes for quick evaluation in VB.NET class. A good external
decrypt pdf password online; pdf unlock
.NET PDF SDK - Description of All PDF Processing Control Feastures
Easy to change PDF original password; Options for setting PDF security level; PDF text content, image and pages redact options. PDF Digital Signature.
change pdf document security; convert locked pdf to word online
8    
http://inventwithpython.com/pygame
Email questions to the author: al@inventwithpython.com 
Remember, do not type the numbers or the periods at the beginning of each line (that’s just for 
reference in this book). 
1. import pygame, sys 
2. from pygame.locals import * 
3.  
4. pygame.init() 
5. DISPLAYSURF = pygame.display.set_mode((400, 300)) 
6. pygame.display.set_caption('Hello World!') 
7. while True: # main game loop 
8.     for event in pygame.event.get(): 
9.         if event.type == QUIT: 
10.             pygame.quit() 
11.             sys.exit() 
12.     pygame.display.update() 
When you run this program, a black window like this will appear: 
Yay! 
You’ve just made the world’s most borin
g video game! 
It’s 
just a blank window with 
―Hello 
World!‖ at the top of the window
(in what is called the window’s 
title bar, which holds the 
caption text). But creating a window is the first step to making graphical games. When you click 
on the X button in the corner of the window, the program will end and the window will disappear. 
Calling the 
print()
function to make text appear in the window 
won’t work because 
print()
is a function for CLI programs. The same goes for 
input()
to get keyboard input 
from the user. Pygame uses other functions for input and output which are explained later in this 
chapter. 
For now, let’s look at each line in our ―Hello World‖ program in more detail.
Setting Up a Pygame Program 
The first few lines of code in the Hello World program are lines that will begin almost every 
program you write that uses Pygame. 
1. import pygame, sys 
Chapter 2 
Pygame Basics
Line 1 is a simple 
import
statement that imports the 
pygame
and 
sys
modules so that our 
program can use the functions in them. All of the Pygame functions dealing with graphics, sound, 
and other features that Pygame provides are in the 
pygame
module. 
Note that when you import the 
pygame
module you automatically import all the modules that 
are in the 
pygame
module as well, such as 
pygame.images
and 
pygame.mixer.music
There’s no need to import these modules
-inside-modules with additional 
import
statements. 
2. from pygame.locals import * 
Line 2 is also an 
import
statement. However, instead of the 
import modulename
format, it 
uses the 
from modulename import *
format. Normally if you want to call a function that 
is in a module, you must use the 
modulename.functionname()
format after importing the 
module. However, with 
from modulename import *
, you can skip the 
modulename.
portion and simply use 
functionname()
(just like Python’s built
-in functions). 
The reason we use this form of 
import
statement for 
pygame.locals
is because 
pygame.locals
contains several constant variables that are easy to identify as being in the 
pygame.locals
module without 
pygame.locals.
in front of them. For all other modules, 
you generally want to use the regular 
import modulename
format. (There is more 
information about why you want to do this at http://invpy.com/namespaces.) 
4. pygame.init() 
Line 4 is the 
pygame.init()
function call, which always needs to be called after importing 
the 
pygame
module and before calling any other 
Pygame function. You don’t need to know what 
this function does, you just need to know that it needs to be called first in order for many Pygame 
functions to work. If you ever see an error message like 
pygame.error: font not 
initialized
, check to see if you forgot to call 
pygame.init()
at the start of your 
program. 
5. DISPLAYSURF = pygame.display.set_mode((400, 300)) 
Line 5 is a call to the 
pygame.display.set_mode()
function, which returns the 
pygame.Surface
object for the window. (Surface objects are described later in this chapter.) 
Notice that we pass a tuple value of two integers to the function: 
(400, 300)
. This tuple tells 
the 
set_mode()
function how wide and how high to make the window in pixels. 
(400, 
300)
will make a window with a width of 400 pixels and height of 300 pixels.  
10    
http://inventwithpython.com/pygame
Email questions to the author: al@inventwithpython.com 
Remember to pass a tuple of two integers to 
set_mode()
, not just two integers themselves. The 
correct way to call the function is like this: 
pygame.display.set_mode((400, 300))
A function call like 
pygame.display.set_mode(400, 300)
will cause an error that 
looks like this: 
TypeError: argument 1 must be 2-item sequence, not int
The 
pygame.Surface
object (we will just call them Surface objects for short) returned is 
stored in a variable named 
DISPLAYSURF
6. pygame.display.set_caption('Hello World!') 
Line 6 sets the caption text that will appear at the top of the window by calling the 
pygame.display.set_caption()
function. The string value 
'Hello World!'
is 
passed in this function call to make that text appear as the caption: 
Game Loops and Game States 
7. while True: # main game loop 
8.     for event in pygame.event.get(): 
Line 7 is a 
while
loop that has a condition of simply the value 
True
. This means that it never 
exits due to its condition evaluating to 
False
. The only way the program execution will ever 
exit the loop is if a 
break
statement is executed (which moves execution to the first line after the 
loop) or 
sys.exit()
(which terminates the program). If a loop like this was inside a function, 
return
statement will also move execution out of the loop (as well as the function too). 
The games in this book all have these 
while True
loops in them along with a comment calling 
it th
e ―main game loop‖. 
game loop (also called a main loop) is a loop where the code does 
three things: 
1.  Handles events. 
2.  Updates the game state. 
3.  Draws the game state to the screen.  
The game state is simply a way of referring to a set of values for all the variables in a game 
program. In many games, the game state includes the values in the variables that tracks the 
player’s health and position, 
the health and position of any enemies, which marks have been 
made on a board, the score, or whose turn it is. Whenever something happens like the player 
Chapter 2 
Pygame Basics
11 
taking damage (which lowers their health value), or an enemy moves somewhere, or something 
happens in the game world we say that the game state has changed. 
If you’ve ever played a game that let you saved, the ―save state‖ is the game state at the point that 
you’ve saved it. In most games, pausing the game will prevent the game state from changing.
Since the game state is usually updated in response to events (such as mouse clicks or keyboard 
presses) or the passage of time, the game loop is constantly checking and re-checking many times 
a second for any new events that have happened. Inside the main loop is code that looks at which 
events have been created (with Pygame, this is done by calling the 
pygame.event.get()
function). The main loop also has code that updates the game state based on which events have 
been created. This is usually called event handling
pygame.event.Event Objects 
Any time the user does one of several actions (they are listed later in this chapter) such as 
pressing a keyboard key or moving 
the mouse on the program’s window, a 
pygame.event.Event
object is created by the Pygame library 
to record this ―event‖
. (This is 
a type of object called 
Event
that exists in the 
event
module, which itself is in the 
pygame
module.) We can find out which events have happened by calling the 
pygame.event.get()
function, which returns a list of 
pygame.event.Event
objects (which we will just call Event 
objects for short). 
The list of Event objects will be for each event that has happened since the last time the 
pygame.event.get()
function was called. (Or, if 
pygame.event.get()
has never been 
called, the events that have happened since the start of the program.) 
12    
http://inventwithpython.com/pygame
Email questions to the author: al@inventwithpython.com 
7. while True: # main game loop 
8.     for event in pygame.event.get(): 
Line 8 is a 
for
loop that will iterate over the list of Event objects that was returned by 
pygame.event.get()
. On each iteration through the 
for
loop, a variable named 
event
will be assigned the value of the next event object in this list. The list of Event objects returned 
from 
pygame.event.get()
will be in the order that the events happened. If the user clicked 
the mouse and then pressed a keyboard key, the Event object for the mouse click would be the 
first item in the list and the Event object for the keyboard press would be second. If no events 
have happened, then 
pygame.event.get()
will return a blank list. 
The QUIT Event and pygame.quit() Function 
9.         if event.type == QUIT: 
10.             pygame.quit() 
11.             sys.exit() 
Event
objects have a member variable (also called attributes or properties) named 
type
which tells us what kind of event the object represents. Pygame has a constant variable for each 
of possible types in the 
pygame.locals
modules. Line 9 checks if the Event 
object’s type
is 
equal to the constant 
QUIT
. Remember that since we used the 
from pygame.locals 
import *
form of the 
import
statement, we only have to type 
QUIT
instead of 
pygame.locals.QUIT
If the Event object is a quit event, then the 
pygame.quit()
and 
sys.exit()
functions are 
called. The 
pygame.quit()
function is sort of the opposite of the 
pygame.init()
function: it runs code that deactivates the Pygame library. Your programs should always call 
pygame.quit()
before they call 
sys.exit()
to terminate the program. 
Normally it doesn’t 
really matter since Python closes it when the program exits anyway. But there is a bug in IDLE 
that causes IDLE to hang if a Pygame program terminates before 
pygame.quit()
is called. 
Since we have no 
if
statements that run code for other types of Event object, there is no event-
handling code for when the user clicks the mouse, presses keyboard keys, or causes any other 
type of Event objects to be created. The user can do things to create these Event objects but it 
doesn’t 
change anything in the program because the program does not have any event-handling 
code for these types of Event objects. After the 
for
loop on line 8 is done handling all the Event 
objects that have been returned by 
pygame.event.get(),
the program execution continues 
to line 12. 
12.     pygame.display.update() 
Documents you may be interested
Documents you may be interested