Tài liệu Making Games with Python & Pygame pptx

Making Games with

Python & Pygame

By Al Sweigart

Email questions to the author: [email protected]

Copyright © 2012 by Albert Sweigart

Some Rights Reserved. ―Making Games with Python & Pygame‖) is licensed under a Creative

Commons Attribution-Noncommercial-Share Alike 3.0 United States License.

You are free:

To Share — to copy, distribute, display, and perform the work

To Remix — to make derivative works

Under the following conditions:

Attribution — You must attribute the work in the manner specified by the author or

licensor (but not in any way that suggests that they endorse you or your use of the work).

(Visibly include the title and author's name in any excerpts of this work.)

Noncommercial — You may not use this work for commercial purposes.

Share Alike — If you alter, transform, or build upon this work, you may distribute

the resulting work only under the same or similar license to this one.

This summary is located here: http://creativecommons.org/licenses/by-nc-sa/3.0/us/

Your fair use and other rights are in no way affected by the above. There is a human-readable

summary of the Legal Code (the full license), located here:

http://creativecommons.org/licenses/by-nc-sa/3.0/us/legalcode

Book Version 2

If you've downloaded this book from a torrent, it’s probably out of date. Go

to http://inventwithpython.com/pygame to download the latest version.

ISBN (978-1469901732)

1st Edition

For Calvin Chaos

Email questions to the author: [email protected]

Who is this book for? i

WHO IS THIS BOOK FOR?

When you get down to it, programming video games is just about lighting up pixels to make

pretty pictures appear on the screen in response to keyboard and mouse input.

And there are very few things that are as fun.

This book will teach you how to make graphical computer games in the Python programming

language using the Pygame library. This book assumes you know a little bit about Python or

programming in general. If you don’t know how to program, you can learn by downloading the

free book ―Invent Your Own Computer Games with Python‖ from http://inventwithpython.com.

Or you can jump right into this book and mostly pick it up along the way.

This book is for the intermediate programmer who has learned what variables and loops are, but

now wants to know, ―What do actual game programs look like?‖ There was a long gap after I first

learned programming but didn’t really know how to use that skill to make something cool. It’s

my hope that the games in this book will give you enough ideas about how programs work to

provide a foundation to implement your own games.

The full text of this book is available in HTML or PDF format at

http://inventwithpython.com/pygame.

-Al Sweigart

ii http://inventwithpython.com/pygame

Email questions to the author: [email protected]

ABOUT THIS BOOK

Hello! This book will teach you how to make graphical computer games with the Pygame

framework (also called the Pygame library) in the Python programming language. Pygame makes

it easy to create programs with 2D graphics. Both Python and the Pygame framework can be

downloaded for free from http://python.org and http://pygame.org. All you need is a computer

and this book to begin making your own games.

This book is an intermediate programming book. If you are completely new to programming,

you can still try to follow along with the source code examples and figure out how programming

works. However, it might be easier to learn how to program in Python first. ―Invent Your Own

Computer Games with Python‖ is a book that is available completely for free from

http://inventwithpython.com. That book teaches programming by making non-graphical, text￾based games for complete beginners, and also has a few chapters about using the Pygame library.

However, if you already know how to program in Python (or even some other language, since

Python is so easy to pick up) and want to start making games beyond just text, then this is the

book for you. The book starts with a short introduction to how the Pygame library works and the

functions it provides. Then it provides the complete source code for some actual games and

explains how the code works, so you can understand how actual game programs make use of

Pygame.

This book features seven different games that are clones of popular games that you’ve probably

already played. The games are a lot more fun and interactive than the text-based games in ―Invent

with Python‖, but are still fairly short. All of the programs are less than 600 lines long. This is

pretty small when you consider that professional games you download or buy in a store can be

hundreds of thousands of lines long. These games require an entire team of programmers and

artists working with each other for months or years to make.

The website for this book is http://inventwithpython.com/pygame. All the programs and files

mentioned in this book can be downloaded for free from this website, including this book itself.

Programming is a great creative activity, so please share this book as widely as possible. The

Creative Commons license that this book is released under gives you the right to copy and

duplicate this book as much as you want (as long as you don’t charge money for it).

If you ever have questions about how these programs work, feel free to email me at

[email protected].

About This Book iii

TABLE OF CONTENTS

Who is this book for?........................................................................................................................i

About This Book..............................................................................................................................ii

Chapter 1 – Installing Python and Pygame......................................................................................1

What You Should Know Before You Begin................................................................................1

Downloading and Installing Python.............................................................................................1

Windows Instructions ..................................................................................................................1

Mac OS X Instructions.................................................................................................................2

Ubuntu and Linux Instructions ....................................................................................................2

Starting Python.............................................................................................................................2

Installing Pygame.........................................................................................................................3

How to Use This Book.................................................................................................................4

The Featured Programs................................................................................................................4

Downloading Graphics and Sound Files......................................................................................4

Line Numbers and Spaces............................................................................................................4

Text Wrapping in This Book .......................................................................................................5

Checking Your Code Online........................................................................................................6

More Info Links on http://invpy.com...........................................................................................6

Chapter 2 – Pygame Basics..............................................................................................................7

GUI vs. CLI .................................................................................................................................7

Source Code for Hello World with Pygame ................................................................................7

Setting Up a Pygame Program.....................................................................................................8

Game Loops and Game States...................................................................................................10

pygame.event.Event Objects...........................................................................................11

The QUIT Event and pygame.quit() Function ..................................................................12

Pixel Coordinates.......................................................................................................................13

iv http://inventwithpython.com/pygame

Email questions to the author: [email protected]

A Reminder About Functions, Methods, Constructor Functions, and Functions in Modules (and

the Difference Between Them)..................................................................................................14

Surface Objects and The Window .............................................................................................15

Colors.........................................................................................................................................16

Transparent Colors.....................................................................................................................17

pygame.Color Objects..........................................................................................................18

Rect Objects...............................................................................................................................18

Primitive Drawing Functions.....................................................................................................20

pygame.PixelArray Objects..............................................................................................23

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

Animation ..................................................................................................................................24

Frames Per Second and pygame.time.Clock Objects.......................................................27

Drawing Images with pygame.image.load() and blit() ............................................28

Fonts...........................................................................................................................................28

Anti-Aliasing..............................................................................................................................30

Playing Sounds...........................................................................................................................31

Summary....................................................................................................................................32

Chapter 3 – Memory Puzzle ..........................................................................................................33

How to Play Memory Puzzle .....................................................................................................33

Nested for Loops.....................................................................................................................33

Source Code of Memory Puzzle ................................................................................................34

Credits and Imports....................................................................................................................42

Magic Numbers are Bad ............................................................................................................42

Sanity Checks with assert Statements...................................................................................43

Telling If a Number is Even or Odd ..........................................................................................44

Crash Early and Crash Often!....................................................................................................44

Making the Source Code Look Pretty........................................................................................45

Using Constant Variables Instead of Strings .............................................................................46

Making Sure We Have Enough Icons........................................................................................47

Tuples vs. Lists, Immutable vs. Mutable ...................................................................................47

About This Book v

One Item Tuples Need a Trailing Comma .................................................................................48

Converting Between Lists and Tuples.......................................................................................49

The global statement, and Why Global Variables are Evil....................................................49

Data Structures and 2D Lists .....................................................................................................51

The ―Start Game‖ Animation.....................................................................................................52

The Game Loop .........................................................................................................................52

The Event Handling Loop..........................................................................................................53

Checking Which Box The Mouse Cursor is Over .....................................................................54

Handling the First Clicked Box .................................................................................................55

Handling a Mismatched Pair of Icons........................................................................................56

Handling If the Player Won .......................................................................................................56

Drawing the Game State to the Screen ......................................................................................57

Creating the ―Revealed Boxes‖ Data Structure .........................................................................58

Creating the Board Data Structure: Step 1 – Get All Possible Icons.........................................58

Step 2 – Shuffling and Truncating the List of All Icons............................................................59

Step 3 – Placing the Icons on the Board ....................................................................................59

Splitting a List into a List of Lists..............................................................................................60

Different Coordinate Systems....................................................................................................61

Converting from Pixel Coordinates to Box Coordinates ...........................................................62

Drawing the Icon, and Syntactic Sugar......................................................................................63

Syntactic Sugar with Getting a Board Space’s Icon’s Shape and Color....................................64

Drawing the Box Cover .............................................................................................................64

Handling the Revealing and Covering Animation.....................................................................65

Drawing the Entire Board ..........................................................................................................66

Drawing the Highlight ...............................................................................................................67

The ―Start Game‖ Animation.....................................................................................................67

Revealing and Covering the Groups of Boxes...........................................................................68

The ―Game Won‖ Animation ....................................................................................................68

Telling if the Player Has Won ...................................................................................................69

vi http://inventwithpython.com/pygame

Email questions to the author: [email protected]

Why Bother Having a main() Function? ................................................................................69

Why Bother With Readability?..................................................................................................70

Summary, and a Hacking Suggestion ........................................................................................74

Chapter 4 – Slide Puzzle ................................................................................................................77

How to Play Slide Puzzle...........................................................................................................77

Source Code to Slide Puzzle ......................................................................................................77

Second Verse, Same as the First ................................................................................................85

Setting Up the Buttons...............................................................................................................86

Being Smart By Using Stupid Code ..........................................................................................87

The Main Game Loop................................................................................................................88

Clicking on the Buttons .............................................................................................................89

Sliding Tiles with the Mouse .....................................................................................................90

Sliding Tiles with the Keyboard ................................................................................................90

―Equal To One Of‖ Trick with the in Operator........................................................................91

WASD and Arrow Keys ............................................................................................................91

Actually Performing the Tile Slide ............................................................................................92

IDLE and Terminating Pygame Programs.................................................................................92

Checking for a Specific Event, and Posting Events to Pygame’s Event Queue ........................92

Creating the Board Data Structure .............................................................................................93

Not Tracking the Blank Position................................................................................................94

Making a Move by Updating the Board Data Structure ............................................................94

When NOT to Use an Assertion ................................................................................................95

Getting a Not-So-Random Move ...............................................................................................96

Converting Tile Coordinates to Pixel Coordinates ....................................................................97

Converting from Pixel Coordinates to Board Coordinates........................................................97

Drawing a Tile ...........................................................................................................................97

The Making Text Appear on the Screen ....................................................................................98

Drawing the Board.....................................................................................................................99

Drawing the Border of the Board...............................................................................................99

About This Book vii

Drawing the Buttons................................................................................................................100

Animating the Tile Slides ........................................................................................................100

The copy() Surface Method .................................................................................................101

Creating a New Puzzle.............................................................................................................103

Animating the Board Reset......................................................................................................104

Time vs. Memory Tradeoffs ....................................................................................................105

Nobody Cares About a Few Bytes...........................................................................................106

Nobody Cares About a Few Million Nanoseconds..................................................................107

Summary..................................................................................................................................107

Chapter 5 – Simulate....................................................................................................................108

How to Play Simulate ..............................................................................................................108

Source Code to Simulate..........................................................................................................108

The Usual Starting Stuff ..........................................................................................................114

Setting Up the Buttons.............................................................................................................115

The main() Function.............................................................................................................115

Some Local Variables Used in This Program..........................................................................116

Drawing the Board and Handling Input...................................................................................117

Checking for Mouse Clicks .....................................................................................................118

Checking for Keyboard Presses...............................................................................................118

The Two States of the Game Loop ..........................................................................................119

Figuring Out if the Player Pressed the Right Buttons..............................................................119

Epoch Time..............................................................................................................................121

Drawing the Board to the Screen .............................................................................................122

Same Old terminate() Function .......................................................................................122

Reusing The Constant Variables..............................................................................................123

Animating the Button Flash .....................................................................................................123

Drawing the Buttons................................................................................................................126

Animating the Background Change.........................................................................................126

The Game Over Animation......................................................................................................127

viii http://inventwithpython.com/pygame

Email questions to the author: [email protected]

Converting from Pixel Coordinates to Buttons........................................................................129

Explicit is Better Than Implicit................................................................................................129

Chapter 6 – Wormy......................................................................................................................131

How to Play Wormy ................................................................................................................131

Source Code to Wormy............................................................................................................131

The Grid...................................................................................................................................137

The Setup Code........................................................................................................................137

The main() Function.............................................................................................................138

A Separate runGame() Function ..........................................................................................139

The Event Handling Loop........................................................................................................139

Collision Detection ..................................................................................................................140

Detecting Collisions with the Apple ........................................................................................141

Moving the Worm....................................................................................................................142

The insert() List Method...................................................................................................142

Drawing the Screen..................................................................................................................143

Drawing ―Press a key‖ Text to the Screen...............................................................................143

The checkForKeyPress() Function................................................................................143

The Start Screen.......................................................................................................................144

Rotating the Start Screen Text .................................................................................................145

Rotations Are Not Perfect........................................................................................................146

Deciding Where the Apple Appears ........................................................................................147

Game Over Screens..................................................................................................................147

Drawing Functions...................................................................................................................148

Don’t Reuse Variable Names...................................................................................................151

Chapter 7 - Tetromino..................................................................................................................153

How to Play Tetromino............................................................................................................153

Some Tetromino Nomenclature...............................................................................................153

Source Code to Tetromino .......................................................................................................154

The Usual Setup Code .............................................................................................................166

About This Book ix

Setting up Timing Constants for Holding Down Keys............................................................166

More Setup Code .....................................................................................................................166

Setting Up the Piece Templates...............................................................................................168

Splitting a ―Line of Code‖ Across Multiple Lines...................................................................171

The main() Function.............................................................................................................172

The Start of a New Game.........................................................................................................173

The Game Loop .......................................................................................................................174

The Event Handling Loop........................................................................................................174

Pausing the Game ....................................................................................................................174

Using Movement Variables to Handle User Input...................................................................175

Checking if a Slide or Rotation is Valid ..................................................................................175

Finding the Bottom ..................................................................................................................178

Moving by Holding Down the Key..........................................................................................179

Letting the Piece ―Naturally‖ Fall............................................................................................182

Drawing Everything on the Screen ..........................................................................................182

makeTextObjs(), A Shortcut Function for Making Text..................................................183

The Same Old terminate() Function................................................................................183

Waiting for a Key Press Event with the checkForKeyPress() Function........................183

showTextScreen(), A Generic Text Screen Function .....................................................184

The checkForQuit() Function..........................................................................................185

The calculateLevelAndFallFreq() Function ..........................................................185

Generating Pieces with the getNewPiece() Function .......................................................188

Adding Pieces to the Board Data Structure .............................................................................189

Creating a New Board Data Structure......................................................................................189

The isOnBoard() and isValidPosition() Functions...............................................190

Checking for, and Removing, Complete Lines........................................................................192

Convert from Board Coordinates to Pixel Coordinates ...........................................................195

Drawing a Box on the Board or Elsewhere on the Screen.......................................................195

Drawing Everything to the Screen...........................................................................................196

x http://inventwithpython.com/pygame

Email questions to the author: [email protected]

Drawing the Score and Level Text ..........................................................................................196

Drawing a Piece on the Board or Elsewhere on the Screen.....................................................197

Drawing the ―Next‖ Piece........................................................................................................197

Summary..................................................................................................................................198

Chapter 8 – Squirrel Eat Squirrel.................................................................................................200

How to Play Squirrel Eat Squirrel............................................................................................200

The Design of Squirrel Eat Squirrel.........................................................................................200

Source Code to Squirrel Eat Squirrel.......................................................................................201

The Usual Setup Code .............................................................................................................211

Describing the Data Structures ................................................................................................212

The main() Function.............................................................................................................213

The pygame.transform.flip() Function....................................................................214

A More Detailed Game State than Usual.................................................................................214

The Usual Text Creation Code.................................................................................................215

Cameras ...................................................................................................................................215

The ―Active Area‖ ...................................................................................................................217

Keeping Track of the Location of Things in the Game World ................................................218

Starting Off with Some Grass..................................................................................................219

The Game Loop .......................................................................................................................219

Checking to Disable Invulnerability ........................................................................................219

Moving the Enemy Squirrels...................................................................................................219

Removing the Far Away Grass and Squirrel Objects ..............................................................221

When Deleting Items in a List, Iterate Over the List in Reverse .............................................221

Adding New Grass and Squirrel Objects.................................................................................223

Camera Slack, and Moving the Camera View.........................................................................223

Drawing the Background, Grass, Squirrels, and Health Meter................................................224

The Event Handling Loop........................................................................................................226

Moving the Player, and Accounting for Bounce......................................................................228

Collision Detection: Eat or Be Eaten .......................................................................................229

About This Book xi

The Game Over Screen............................................................................................................231

Winning ...................................................................................................................................232

Drawing a Graphical Health Meter..........................................................................................232

The Same Old terminate() Function................................................................................232

The Mathematics of the Sine Function ....................................................................................233

Backwards Compatibility with Python Version 2....................................................................236

The getRandomVelocity() Function..............................................................................237

Finding a Place to Add New Squirrels and Grass....................................................................237

Creating Enemy Squirrel Data Structures................................................................................238

Flipping the Squirrel Image .....................................................................................................239

Creating Grass Data Structures................................................................................................239

Checking if Outside the Active Area .......................................................................................240

Summary..................................................................................................................................241

Chapter 9 – Star Pusher................................................................................................................242

How to Play Star Pusher ..........................................................................................................242

Source Code to Star Pusher......................................................................................................242

The Initial Setup.......................................................................................................................256

Data Structures in Star Pusher .................................................................................................271

The ―Game State‖ Data Structure ............................................................................................271

The ―Map‖ Data Structure .......................................................................................................271

The ―Levels‖ Data Structure ....................................................................................................272

Reading and Writing Text Files...............................................................................................272

Text Files and Binary Files......................................................................................................272

Writing to Files........................................................................................................................273

Reading from Files...................................................................................................................274

About the Star Pusher Map File Format ..................................................................................274

Recursive Functions.................................................................................................................280

Stack Overflows.......................................................................................................................281

Preventing Stack Overflows with a Base Case ........................................................................283