Invent Your Own Computer Games with Python, 2nd Edition

Book Description:

"Invent Your Own Computer Games with Python" teaches you computer programming in the Python programming language. Each chapter gives you the complete source code for a new game and teaches the programming concepts from these examples. The book is available under a Creative Commons license and can be downloaded in full for free from http://inventwithpython.com "Invent with Python" was written to be understandable by kids as young as 10 to 12 years old, although it is great for anyone of any age who has never programmed before. This second edition has revised and expanded content, including using the Pygame library to make games with graphics, animation, and sound.

TABLE OF CONTENTS 

Installing Python .............................................................................................................................. 1 

Downloading and Installing Python ............................................................................................. 2 

Windows Instructions .................................................................................................................. 3 

Mac OS X Instructions ................................................................................................................. 4 

Ubuntu and Linux Instructions .................................................................................................... 4 

Starting Python............................................................................................................................. 4 

How to Use This Book ................................................................................................................. 5 

The Featured Programs ................................................................................................................ 5 

Line Numbers and Spaces ............................................................................................................ 6 

Text Wrapping in This Book ................................................................................................... 6 

Tracing the Program Online ......................................................................................................... 7 

Checking Your Code Online ........................................................................................................ 7 

Summary ...................................................................................................................................... 7 

The Interactive Shell ........................................................................................................................ 8 

Some Simple Math Stuff .............................................................................................................. 8 

Integers and Floating Point Numbers ........................................................................................... 9 

Expressions ................................................................................................................................ 10 

Evaluating Expressions .............................................................................................................. 11 

Expressions Inside Other Expressions ....................................................................................... 12 

Storing Values in Variables ....................................................................................................... 12 

Using More Than One Variable ................................................................................................. 15 

Overwriting Variables ................................................................................................................ 16 

Summary .................................................................................................................................... 17 

Strings ............................................................................................................................................ 18 

Strings ........................................................................................................................................ 18 

String Concatenation .................................................................................................................. 19 viii 

 

Writing Programs in IDLE’s File Editor .................................................................................... 20 

Hello World! .............................................................................................................................. 20 

hello.py ...................................................................................................................................... 21 

Saving Your Program ................................................................................................................ 22 

Opening The Programs You’ve Saved ....................................................................................... 23 

How the “Hello World” Program Works ................................................................................... 24 

Comments .................................................................................................................................. 24 

Functions .................................................................................................................................... 25 

The print() function ............................................................................................................. 25 

The input() function ............................................................................................................. 25 

Ending the Program ................................................................................................................... 26 

Variable Names .......................................................................................................................... 27 

Summary .................................................................................................................................... 27 

Guess the Number .......................................................................................................................... 29 

The “Guess the Number” Game................................................................................................. 29 

Sample Run of “Guess the Number” ......................................................................................... 30 

Guess the Number’s Source Code .............................................................................................. 30 

The import statement .............................................................................................................. 32 

The random.randint() function ........................................................................................ 33 

Calling Functions that are Inside Modules ................................................................................ 35 

Passing Arguments to Functions ................................................................................................ 35 

Welcoming the Player ................................................................................................................ 36 

Loops ......................................................................................................................................... 37 

Blocks ........................................................................................................................................ 37 

The Boolean Data Type ............................................................................................................. 38 

Comparison Operators ............................................................................................................... 38 

Conditions .................................................................................................................................. 39 

Experiment with Booleans, Comparison Operators, and Conditions......................................... 39 

Looping with while statements ............................................................................................... 41 ix 

 

The Player Guesses .................................................................................................................... 43 

Converting Strings to Integers with the int() function .......................................................... 43 

Incrementing Variables .............................................................................................................. 45 

if statements ............................................................................................................................. 45 

Is the Player’s Guess Too Low? ............................................................................................. 45 

Is the Player’s Guess Too High? ............................................................................................ 47 

Leaving Loops Early with the break statement ....................................................................... 47 

Check if the Player Won ............................................................................................................ 48 

Check if the Player Lost ............................................................................................................. 48 

Summary: What Exactly is Programming? ................................................................................ 49 

A Web Page for Program Tracing.............................................................................................. 50 

Jokes ............................................................................................................................................... 52 

Making the Most of print() .................................................................................................. 52 

Sample Run of Jokes .................................................................................................................. 52 

Joke’s Source Code .................................................................................................................... 53 

How the Code Works ................................................................................................................. 53 

Escape Characters ...................................................................................................................... 54 

Some Other Escape Characters .................................................................................................. 54 

Quotes and Double Quotes ........................................................................................................ 55 

The end Keyword Argument .................................................................................................... 56 

Summary .................................................................................................................................... 56 

Dragon Realm ................................................................................................................................ 58 

Introducing Functions ................................................................................................................ 58 

How to Play “Dragon Realm” .................................................................................................... 59 

Sample Run of Dragon Realm ................................................................................................... 59 

Dragon Realm’s Source Code .................................................................................................... 59 

How the Code Works ................................................................................................................. 61 

Defining the displayIntro() Function ......................................................................................... 61 

def Statements .......................................................................................................................... 62 x 

 

Defining the chooseCave() Function................................................................................... 62 

Boolean Operators ..................................................................................................................... 63 

Evaluating an Expression That Contains Boolean Operators .................................................... 63 

Experimenting with the and and or Operators ........................................................................ 64 

Experimenting with the not Operator ...................................................................................... 65 

Truth Tables ............................................................................................................................... 66 

Getting the Player’s Input ........................................................................................................... 66 

Return Values............................................................................................................................. 67 

Variable Scope ........................................................................................................................... 67 

Global Scope and Local Scope .................................................................................................. 68 

Defining the checkCave() Function ..................................................................................... 69 

Parameters .................................................................................................................................. 70 

Where to Put Function Definitions ............................................................................................ 71 

Displaying the Game Results ..................................................................................................... 72 

Deciding Which Cave has the Friendly Dragon ........................................................................ 72 

The Colon : ................................................................................................................................ 74 

Where the Program Really Begins ............................................................................................. 74 

Calling the Functions in Our Program ....................................................................................... 74 

Asking the Player to Play Again ................................................................................................ 75 

Designing the Program .............................................................................................................. 76 

Summary .................................................................................................................................... 77 

Using the Debugger ....................................................................................................................... 78 

Bugs! .......................................................................................................................................... 78 

The Debugger............................................................................................................................. 80 

Starting the Debugger ................................................................................................................ 80 

Stepping ..................................................................................................................................... 82 

Click the Step button twice to run the two import lines. .................................................... 82 

Click the Step button three more times to execute the three def statements. ....................... 82 

Click the Step button again to define the playAgain variable. .......................................... 82 xi 

 

The Go and Quit Buttons ........................................................................................................... 83 

Stepping Into, Over, and Out ..................................................................................................... 83 

Find the Bug ............................................................................................................................... 85 

Break Points ............................................................................................................................... 88 

Example of Using Break Points ................................................................................................. 89 

Summary .................................................................................................................................... 91 

Flow Charts .................................................................................................................................... 92 

How to Play “Hangman” ........................................................................................................... 92 

Sample Run of “Hangman” ....................................................................................................... 92 

ASCII Art ................................................................................................................................... 94 

Designing a Program with a Flowchart ...................................................................................... 95 

Creating the Flow Chart ............................................................................................................. 97 

Branching from a Flowchart Box............................................................................................... 98 

Ending or Restarting the Game ................................................................................................ 100 

Guessing Again ........................................................................................................................ 101 

Offering Feedback to the Player .............................................................................................. 103 

Summary: The Importance of Planning Out the Game ............................................................ 104 

Hangman ...................................................................................................................................... 106 

Hangman’s Source Code .......................................................................................................... 107 

How the Code Works ............................................................................................................... 110 

Multi-line Strings ..................................................................................................................... 111 

Constant Variables ................................................................................................................... 112 

Lists .......................................................................................................................................... 112 

Changing the Values of List Items with Index Assignment .................................................... 114 

List Concatenation ................................................................................................................... 115 

The in Operator ...................................................................................................................... 115 

Removing Items from Lists with del Statements ................................................................... 116 

Lists of Lists ............................................................................................................................. 117 

Methods ................................................................................................................................... 118 xii 

 

The lower() and upper() String Methods ....................................................................... 118 

The reverse() and append() List Methods .................................................................... 119 

The Difference Between Methods and Functions .................................................................... 120 

The split() List Method ..................................................................................................... 120 

How the Code Works ............................................................................................................... 121 

Displaying the Board to the Player .......................................................................................... 122 

The range() and list() Functions ................................................................................... 124 

for Loops ............................................................................................................................... 124 

A while Loop Equivalent of a for Loop ......................................................................... 127 

Slices and Slicing ..................................................................................................................... 128 

Displaying the Secret Word with Blanks ................................................................................. 129 

Replacing the Underscores with Correctly Guessed Letters .................................................... 129 

Get the Player’s Guess .............................................................................................................. 131 

elif (“Else If”) Statements .................................................................................................... 132 

Making Sure the Player Entered a Valid Guess ....................................................................... 134 

Asking the Player to Play Again .............................................................................................. 135 

Review of the Functions We Defined ...................................................................................... 136 

The Main Code for Hangman .................................................................................................. 138 

Setting Up the Variables .......................................................................................................... 138 

Displaying the Board to the Player .......................................................................................... 138 

Letting the Player Enter Their Guess ................................................................................... 138 

Checking if the Letter is in the Secret Word ........................................................................ 139 

Checking if the Player has Won ........................................................................................... 139 

When the Player Guesses Incorrectly .................................................................................. 141 

Making New Changes to the Hangman Program ..................................................................... 143 

Dictionaries .............................................................................................................................. 145 

Getting the Size of Dictionaries with len() .......................................................................... 145 

The Difference Between Dictionaries and Lists ...................................................................... 146 

Sets of Words for Hangman ..................................................................................................... 148 xiii 

 

The random.choice() Function ....................................................................................... 148 

Evaluating a Dictionary of Lists .............................................................................................. 149 

Multiple Assignment ................................................................................................................ 151 

Printing the Word Category for the Player .............................................................................. 152 

Summary .................................................................................................................................. 152 

Tic Tac Toe .................................................................................................................................. 153 

Sample Run of Tic Tac Toe ..................................................................................................... 154 

Source Code of Tic Tac Toe .................................................................................................... 155 

Designing the Program ............................................................................................................ 160 

Representing the Board as Data ............................................................................................... 161 

Game AI ................................................................................................................................... 162 

How the Code Works: Lines 1 to 81 ........................................................................................ 163 

The Start of the Program ...................................................................................................... 163 

Printing the Board on the Screen ......................................................................................... 164 

Letting the Player be X or O ................................................................................................ 167 

Deciding Who Goes First ..................................................................................................... 168 

Asking the Player to Play Again .......................................................................................... 169 

Placing a mark on the Board .................................................................................................... 169 

List References......................................................................................................................... 169 

Using List References in makeMove() .................................................................................... 173 

Checking if the Player Has Won .............................................................................................. 174 

Duplicating the Board Data ..................................................................................................... 177 

Checking if a Space on the Board is Free ................................................................................ 177 

Letting the Player Enter Their Move ....................................................................................... 177 

Short-Circuit Evaluation .......................................................................................................... 178 

An Example of Short-Circuit Evaluation ................................................................................. 179 

The First if statement (Cats and Dogs) .............................................................................. 181 

The Second if statement (Hello and Goodbye) .................................................................. 181 

The Third if statement (Spam and Cheese) ....................................................................... 181 xiv 

 

The Fourth if statement (Red and Blue) ............................................................................ 181 

How the Code Works: Lines 83 to 94 ...................................................................................... 182 

Choosing a Move from a List of Moves .............................................................................. 182 

The None Value ...................................................................................................................... 183 

How the Code Works: Lines 96 to 187 .................................................................................... 183 

Creating the Computer’s Artificial Intelligence ................................................................... 183 

The Computer Checks if it Can Win in One Move .............................................................. 184 

The Computer Checks if the Player Can Win in One Move ................................................ 184 

Checking the Corner, Center, and Side Spaces (in that Order) ............................................ 185 

Checking if the Board is Full ............................................................................................... 185 

The Start of the Game .......................................................................................................... 186 

Deciding the Player’s Mark and Who Goes First ................................................................. 186 

Running the Player’s Turn .................................................................................................... 187 

Running the Computer’s Turn .............................................................................................. 188 

Summary: Creating Game-Playing Artificial Intelligences ..................................................... 190 

Bagels ........................................................................................................................................... 191 

Sample Run .............................................................................................................................. 192 

Bagel’s Source Code ................................................................................................................ 192 

Designing the Program ............................................................................................................ 194 

How the Code Works: Lines 1 to 9 .......................................................................................... 196 

Shuffling a Unique Set of Digits .............................................................................................. 196 

The random.shuffle() Function ..................................................................................... 196 

Getting the Secret Number from the Shuffled Digits............................................................... 197 

Augmented Assignment Operators .......................................................................................... 198 

How the Code Works: Lines 11 to 24 ...................................................................................... 198 

The sort() List Method ....................................................................................................... 200 

The join() String Method .................................................................................................... 200 

How the Code Works: Lines 29 to 53 ...................................................................................... 201 

Checking if a String Only has Numbers .............................................................................. 201 xv 

 

Finding out if the Player Wants to Play Again .................................................................... 202 

The Start of the Game .......................................................................................................... 202 

String Interpolation .................................................................................................................. 203 

How the Code Works: Lines 55 to 76 ...................................................................................... 204 

Creating the Secret Number ................................................................................................. 204 

Getting the Player’s Guess ................................................................................................... 205 

Getting the Clues for the Player’s Guess .............................................................................. 205 

Checking if the Player Won or Lost ..................................................................................... 205 

Asking the Player to Play Again .......................................................................................... 206 

Summary: Getting Good at Bagels .......................................................................................... 206 

Cartesian Coordinates .................................................................................................................. 208 

Grids and Cartesian Coordinates.............................................................................................. 209 

Negative Numbers ................................................................................................................... 210 

Math Tricks .............................................................................................................................. 213 

Trick 1: “A Minus Eats the Plus Sign on its Left” ............................................................... 213 

Trick 2: “Two Minuses Combine Into a Plus” ..................................................................... 213 

Trick 3: The Commutative Property of Addition ................................................................. 214 

Absolute Values and the abs() Function .............................................................................. 215 

Coordinate System of a Computer Monitor ............................................................................. 216 

Summary: Using this Math in Games ...................................................................................... 217 

Sonar ............................................................................................................................................ 218 

Sample Run .............................................................................................................................. 219 

Sonar’s Source Code ................................................................................................................ 222 

Designing the Program ............................................................................................................ 228 

How the Code Works: Lines 1 to 38 ........................................................................................ 229 

Drawing the Game Board ........................................................................................................ 229 

Drawing the X-coordinates Along the Top .............................................................................. 230 

Drawing the Rows of the Ocean .............................................................................................. 231 

Drawing the X-coordinates Along the Bottom ........................................................................ 232 xvi 

 

Getting the State of a Row in the Ocean .................................................................................. 232 

How the Code Works: Lines 40 to 62 ...................................................................................... 233 

Creating a New Game Board ................................................................................................... 233 

Creating the Random Treasure Chests ..................................................................................... 235 

Determining if a Move is Valid ............................................................................................... 235 

How the Code Works: Lines 64 to 91 ...................................................................................... 236 

Placing a Move on the Board ............................................................................................... 236 

An Algorithm for Finding the Closest Treasure Chest ............................................................ 237 

The remove() List Method .................................................................................................. 240 

How the Code Works: Lines 94 to 162 .................................................................................... 241 

Getting the Player’s Move ........................................................................................................ 241 

Asking the Player to Play Again .............................................................................................. 243 

Printing the Game Instructions for the Player .......................................................................... 243 

How the Code Works: Lines 165 to 217 .................................................................................. 245 

The Start of the Game .......................................................................................................... 245 

Displaying the Game Status for the Player .......................................................................... 245 

Getting the Player’s Move .................................................................................................... 246 

Finding a Sunken Treasure Chest ........................................................................................ 247 

Checking if the Player has Won ........................................................................................... 247 

Checking if the Player has Lost ........................................................................................... 248 

Asking the Player to Play Again, and the sys.exit() Function.............................................. 249 

Summary: Review of our Sonar Game .................................................................................... 249 

Caesar Cipher ............................................................................................................................... 250 

About Cryptography ................................................................................................................ 250 

The Caesar Cipher .................................................................................................................... 251 

ASCII, and Using Numbers for Letters ................................................................................... 253 

The chr() and ord() Functions .......................................................................................... 254 

Sample Run of Caesar Cipher .................................................................................................. 255 

Caesar Cipher’s Source Code ................................................................................................... 256 xvii 

 

How the Code Works: Lines 1 to 34 ........................................................................................ 257 

Deciding to Encrypt or Decrypt ........................................................................................... 258 

Getting the Message from the Player ................................................................................... 258 

Getting the Key from the Player .......................................................................................... 258 

Encrypt or Decrypt the Message with the Given Key .......................................................... 259 

The isalpha() String Method ............................................................................................. 259 

The isupper() and islower() String Methods .............................................................. 260 

How the Code Works: Lines 36 to 57 ...................................................................................... 261 

Encrypting or Decrypting Each Letter ................................................................................. 261 

The Start of the Program ...................................................................................................... 262 

Brute Force............................................................................................................................... 263 

Adding the Brute Force Mode to Our Program ................................................................... 263 

Summary: Reviewing Our Caesar Cipher Program ................................................................. 265 

Reversi ......................................................................................................................................... 267 

Sample Run .............................................................................................................................. 270 

Reversi’s Source Code.............................................................................................................. 273 

How the Code Works ............................................................................................................... 281 

The Game Board Data Structure .......................................................................................... 281 

Importing Other Modules..................................................................................................... 281 

Drawing the Board Data Structure on the Screen ................................................................ 282 

Resetting the Game Board ....................................................................................................... 284 

Setting Up the Starting Pieces .............................................................................................. 284 

Creating a New Game Board Data Structure ....................................................................... 285 

Checking if a Move is Valid ................................................................................................ 285 

Checking Each of the Eight Directions ................................................................................ 287 

Finding Out if There are Pieces to Flip Over ........................................................................... 288 

Checking for Valid Coordinates .............................................................................................. 289 

Getting a List with All Valid Moves .................................................................................... 290 

The bool() Function ............................................................................................................. 291 xviii 

 

Getting the Score of the Game Board .................................................................................. 292 

Getting the Player’s Tile Choice .......................................................................................... 292 

Determining Who Goes First ............................................................................................... 293 

Asking the Player to Play Again .......................................................................................... 293 

Placing Down a Tile on the Game Board ............................................................................ 293 

Copying the Board Data Structure ....................................................................................... 294 

Determining if a Space is on a Corner ................................................................................. 295 

Getting the Player’s Move .................................................................................................... 295 

Getting the Computer’s Move .............................................................................................. 297 

Corner Moves are the Best Moves ....................................................................................... 297 

Get a List of the Best Scoring Moves .................................................................................. 298 

Simulate All Possible Moves on Duplicate Board Data Structures ..................................... 298 

Printing the Scores to the Screen ......................................................................................... 299 

The Start of the Game .......................................................................................................... 300 

Running the Player’s Turn .................................................................................................... 300 

Handling the Quit or Hints Commands ................................................................................ 301 

Make the Player’s Move ....................................................................................................... 302 

Running the Computer’s Turn .............................................................................................. 302 

Drawing Everything on the Screen ...................................................................................... 303 

Ask the Player to Play Again ............................................................................................... 304 

Changing the drawBoard() Function .............................................................................. 304 

Summary: Reviewing the Reversi Game ................................................................................. 305 

AI Simulation ............................................................................................................................... 307 

Making the Computer Play Against Itself ................................................................................ 308 

How the AISim1.py Code Works ............................................................................................ 309 

Making the Computer Play Itself Several Times ................................................................. 310 

How the AISim2.py Code Works ............................................................................................ 312 

Percentages .............................................................................................................................. 313 

Division Evaluates to Floating Point ....................................................................................... 313 xix 

 

The round() function ........................................................................................................... 314 

Displaying the Statistics ........................................................................................................... 315 

Comparing Different AI Algorithms........................................................................................ 316 

How the AISim3.py Code Works ............................................................................................ 318 

Comparing the Random Algorithm Against the Regular Algorithm ................................... 318 

Comparing the Random Algorithm Against Itself ............................................................... 319 

Comparing the Regular Algorithm Against the CornersSideBest Algorithm ...................... 320 

Comparing the Regular Algorithm Against the Worst Algorithm ....................................... 321 

Comparing the Regular Algorithm Against the WorstCorner Algorithm ............................ 321 

Comparing the Worst Algorithm Against the WorstCorner Algorithm ............................... 322 

Summary: Learning New Things by Running Simulation Experiments ................................. 322 

Graphics and Animation .............................................................................................................. 324 

Installing Pygame..................................................................................................................... 325 

Hello World in Pygame ........................................................................................................... 326 

Hello World’s Source Code ...................................................................................................... 327 

Running the Hello World Program .......................................................................................... 328 

Importing the Pygame Module ............................................................................................ 329 

The pygame.init() Function ........................................................................................ 330 

The pygame.display.set_mode() and pygame.display.set_caption() 

Functions .............................................................................................................................. 330 

Colors in Pygame ..................................................................................................................... 331 

Fonts, and the pygame.font.SysFont() Function ...................................................................... 333 

The render() Method for Font Objects ............................................................................ 333 

Attributes ................................................................................................................................. 334 

The get_rect() Methods for pygame.font.Font and pygame.Surface Objects

 ............................................................................................................................................. 336 

Constructor Functions and the type() Function ................................................................... 336 

The fill() Method for Surface Objects............................................................................... 337 

The pygame.draw.polygon() Function ......................................................................... 337 xx 

 

The pygame.draw.line() Function ............................................................................................ 338 

The pygame.draw.circle() Function ........................................................................... 338 

The pygame.draw.ellipse() Function ......................................................................... 339 

The pygame.draw.rect() Function ................................................................................ 339 

The pygame.PixelArray Data Type ................................................................................ 339 

The blit() Method for Surface Objects............................................................................... 340 

The pygame.display.update() Function .................................................................... 340 

Events and the Game Loop ...................................................................................................... 341 

The pygame.event.get() Function ................................................................................ 341 

The pygame.quit() Function ............................................................................................ 342 

Animation ................................................................................................................................ 342 

The Animation Program’s Source Code ................................................................................... 342 

How the Animation Program Works ....................................................................................... 345 

Moving and Bouncing the Blocks ........................................................................................ 345 

Creating and Setting Up Pygame and the Main Window .................................................... 346 

Setting Up Constant Variables for Direction ....................................................................... 347 

Setting Up Constant Variables for Color ............................................................................. 348 

Setting Up The Block Data Structures ................................................................................. 348 

Running the Game Loop .......................................................................................................... 349 

Moving Each Block ............................................................................................................. 350 

Checking if the Block has Bounced ..................................................................................... 350 

Changing the Direction of the Bouncing Block ................................................................... 351 

Drawing the Blocks on the Window in Their New Positions .............................................. 352 

Drawing the Window on the Screen .................................................................................... 352 

Some Small Modifications ....................................................................................................... 353 

Drawing as Fast as Possible ................................................................................................. 353 

Drawing Trails of Blocks ..................................................................................................... 353 

Summary: Pygame Programming ............................................................................................ 354 

Collision Detection and Input ...................................................................................................... 355 xxi 

 

The Collision Detection Program’s Source Code ..................................................................... 356 

Importing the Modules ......................................................................................................... 360 

The Collision Detection Function ............................................................................................ 360 

Determining if a Point is Inside a Rectangle ............................................................................ 362 

The pygame.time.Clock Object and tick() Method .............................................. 363 

Setting Up the Window and Data Structures ....................................................................... 364 

Drawing the Bouncer on the Screen ........................................................................................ 365 

Colliding with the Food Squares .............................................................................................. 366 

Don’t Add to or Delete from a List while Iterating Over It ...................................................... 366 

Removing the Food Squares ................................................................................................ 367 

Drawing the Food Squares on the Screen ............................................................................ 367 

The Keyboard Input Program’s Source Code ........................................................................... 367 

Setting Up the Window and Data Structures ........................................................................... 370 

Events and Handling the KEYDOWN Event .......................................................................... 371 

Setting the Four Keyboard Variables ................................................................................... 373 

Handling the KEYUP Event.................................................................................................. 374 

Teleporting the Player .......................................................................................................... 375 

Handling the MOUSEBUTTONUP Event .......................................................................... 375 

Moving the Bouncer Around the Screen .............................................................................. 375 

The colliderect() Method .............................................................................................. 376 

Summary: Collision Detection and Pygame Input ................................................................... 376 

Sound and Images ........................................................................................................................ 378 

Image and Sound Files ............................................................................................................. 380 

Sprites and Sounds Program .................................................................................................... 380 

The Sprites and Sounds Program’s Source Code ..................................................................... 380 

Setting Up the Window and the Data Structure ....................................................................... 384 

The pygame.transform.scale() Function .................................................................. 385 

Setting Up the Music and Sounds ........................................................................................ 385 

Toggling the Sound On and Off ........................................................................................... 386 xxii 

 

Drawing the Player on the Window ......................................................................................... 387 

Checking if the Player Has Collided with Cherries ............................................................. 387 

Draw the Cherries on the Window ....................................................................................... 388 

Summary: Games with Graphics and Sounds .......................................................................... 388 

Dodger ......................................................................................................................................... 389 

Review of the Basic Pygame Data Types ................................................................................ 389 

Dodger’s Source Code .............................................................................................................. 391 

Importing the Modules ............................................................................................................. 396 

Setting Up the Constant Variables ........................................................................................... 397 

Defining Functions ................................................................................................................... 398 

Initializing Pygame and Setting Up the Window ..................................................................... 400 

Fullscreen Mode....................................................................................................................... 401 

Display the Start Screen ........................................................................................................... 402 

Start of the Main Game Code .................................................................................................. 403 

The Game Loop ....................................................................................................................... 405 

Event Handling ........................................................................................................................ 405 

The move_ip() Method for Rect objects ............................................................................. 409 

Adding New Baddies ............................................................................................................... 410 

Moving the Player’s Character ............................................................................................. 411 

The pygame.mouse.set_pos() Function ...................................................................... 412 

Implementing the Cheat Codes ................................................................................................ 413 

Removing the Baddies ............................................................................................................. 413 

Drawing the Window ............................................................................................................... 414 

Drawing the Player’s Score ...................................................................................................... 415 

Drawing the Player’s Character ................................................................................................ 415 

Collision Detection .................................................................................................................. 416 

The Game Over Screen ............................................................................................................ 416 

Modifying the Dodger Game ................................................................................................... 417 

Summary: Creating Your Own Games .................................................................................... 418 xxiii 

 

The print() Function and the print statement............................................................. 420 

The input() and raw_input() Functions ................................................................... 421 

The range() Function’s Return Value .............................................................................. 421 

Division with the / Operator ............................................................................................... 421 

Formatting Strings with the format() Method and %s ................................................... 422 

Statements ................................................................................................................................ 424 

Assignment Statements ........................................................................................................ 424 

break Statements ............................................................................................................... 425 

continue Statements ........................................................................................................ 425 

def Statements .................................................................................................................... 426 

del Statements .................................................................................................................... 427 

for Loop Statements .......................................................................................................... 427 

import Statements ............................................................................................................. 428 

if, elif, else Statements ............................................................................................... 428 

return Statements ............................................................................................................. 429 

while Loop Statements ...................................................................................................... 429 

Functions .................................................................................................................................. 429 

The abs() Function ........................................................................................................... 429 

The bool() Function ......................................................................................................... 430 

The chr() Function ........................................................................................................... 430 

The float() Function ...................................................................................................... 430 

The input() Function ...................................................................................................... 430 

The int() Function ........................................................................................................... 431 

The list() Function ......................................................................................................... 431 

The ord() Function ........................................................................................................... 431 

The print() Function ...................................................................................................... 431 

The range() Function ...................................................................................................... 432 

The round() Function ...................................................................................................... 433 xxiv 

 

The str() Function ........................................................................................................... 433 

The type() Function ......................................................................................................... 433 

Functions in the random Module ....................................................................................... 434 

The random.choice() Function ................................................................................... 434 

The random.randint() Function ................................................................................. 434 

The random.shuffle() Function ................................................................................. 434 

Functions in the sys Module .............................................................................................. 435 

The sys.exit() Function ............................................................................................... 435 

Functions in the time Module .............................................................................................. 435 

The time.sleep() Function .......................................................................................... 435 

Methods ................................................................................................................................... 435 

Dict Methods ........................................................................................................................ 435 

The keys() Dict Method ................................................................................................... 435 

The values() Dict Method .............................................................................................. 436 

List Methods ........................................................................................................................ 436 

The append() List Method............................................................................................... 436 

The reverse() List Method.................................................................................................... 436 

The sort() List Method ......................................................................................................... 436 

String Methods ..................................................................................................................... 437 

The endswith() String Method ...................................................................................... 437 

The isalpha() String Method ......................................................................................... 437 

The isdigit() String Method ......................................................................................... 437 

The islower() string Method ......................................................................................... 438 

The isupper() String Method ......................................................................................... 438 

The join() String Method ................................................................................................ 438 

The lower() String Method ............................................................................................. 438 

The split() String Method ............................................................................................. 439 

The startswith() String Method ................................................................................. 439 xxv 

 

The upper() String Method ............................................................................................. 439 

Step 1: Download and Install py2exe ...................................................................................... 441 

Step 2: Create Your setup.py Script ......................................................................................... 442 

Step 3: Run Your setup.py Script............................................................................................. 442 

Step 4: Distribute Your Program ............................................................................................. 443 

Summary .................................................................................................................................. 443 

SyntaxError: invalid syntax ................................................................................................. 444 

ImportError: No module named raandom ............................................................................ 445 

SyntaxError: EOL while scanning string literal ................................................................... 445 

AttributeError: ’str’ object has no attribute ’lowerr’ .............................................................. 445 

IndentationError: expected an indented block ..................................................................... 445 

IndentationError: unexpected indent .................................................................................... 446 

IndentationError: unindent does not match any outer indentation level .............................. 446 

TypeError: bad operand type for abs(): ’str’ ......................................................................... 446 

TypeError: abs() takes exactly one argument (2 given) ....................................................... 446 

IndexError: list index out of range ....................................................................................... 446 

KeyError: ’spam’ .................................................................................................................. 447