Step 000 - Installation, Documentation and Examples
- Installation
install python
Pygame is not shipped together with Python, it is a 3rd-party-package. To install it on your computer you need a version of Python installed correctly on your computer that works good together with Pygame: Python2.x (recommended) or Python 3.x (experimental) <note warning>from Pygame FAQ: Does Pygame work with Python 3?Mostly yes. Only the scrap, _movie, surfarray for Numeric, and threads modules have not been ported. The Pygame alternative, pgreloaded (Pygame Reloaded), also supports Python 3. </note>
Install Pygame
Linux Users of Ubuntu Linux can type:sudo apt-get install python-pygame or install pygame using synaptic or the ubuntu software center.
Windows Install pygame from http://www.pygame.org/download.shtml
Mac Install pygame from http://www.pygame.org/download.shtml
source installing from source : http://www.pygame.org/download.shtml
- documentation
You can view the pygame documentation online at:
http://www.pygame.org/docs/
If you have no internet access, you can still read pygame's documentation offline in your browser.
Just open the file index.html in pygame's docs folder.
The File should be located inside your python installation: /dist-packages/pygame/docs/index.html
Linux /usr/lib/python2.6/dist-packages/pygame/docs/index.html
Windows ?
Mac ?
- Examples
pygame will install a bunch of highly useful examples inside the folder/dist-packages/pygame/examples.
It is a good idea to copy the whole example folder (including his sub-folders data and macosx) to another location like to your desktop.
In that way, you can modify all pygame examples without destroying the originals.
A short description of each pygame example can be found at pygames documentation homepage:
http://www.pygame.org/docs/ref/examples.html
Enjoy
Now it is time to enjoy your successfull installation of python and pygame.
How about a round of mindless alien shooting ?
Open a terminal and type:
python -m pygame.examples.aliens
- The Editor and Other Tools
Text Editor
To modify the python source code files (.py) in your favourite text editor, make sure that you are able to load, modify and start python files using your editor. Try to open and start the aliens example from within your text editor. Every OS is shipped with at least one very simple text editor, and python usually installs the IDLE text editor on your system. For a list of text editors and IDE and their features see http://wiki.python.org/moin/PythonEditorsGraphic Editor
For the next chapters, it is helpful if you know how to paint and modify images, especially in the .png format. Most image editors / viewers can display those graphics (even your webbrowser) but not every image editor can handle transparency (transparent backgrounds). You can download and install the free and open source image editor GIMP for every operation system, althoug you will only need very few of it's functions for the next chapters. A simple image viewer with rudimentary editing functions such as IrfanView for Windows or gthumb for Linux may be sufficient.Sound
For the next chapters, it is helpful if you can generate and manipulate (and record!) sound effects on your computer. You need functions to cut parts of recorded sound effects and ideally a noise reduction. Both functions are provided by the free and open source program audacity, wich can also generate sounds. For an specific sound effect generator, you may try out http://www.drpetter.se/project_sfxr.html- Download from Github
Source code examples and other necessary files like graphics and sounds will be hosted not on this wiki, but instead on github. While it is not necessary to create an account at github.com to download all code examples for this book, it may be useful if you want to publish your edits / comments back into this wiki. What you should know however is how to download code and files directly from github: Open this URL in your browser: https://github.com/horstjens/ThePythonGameBook and click on the big Downloads icon. choose Download .tar.gz for Linux, or Download .zip for Windows extract the archive file on your Desktop. All neccessary files for the next chapters are inside thepygame folder
Now you are ready, start with step001 and write your first pygame program !
Step 001 - Pygame Basics
The next few code examples demonstrate how to set up a working pygame program and move surfaces or sprites (2-dimensional shapes) around.
The important thing to understand is that (in those pygame examples) there is no real movement.
In fact, what you see as movement is an illusion only happening in your brain.
What you do see is a fast sequence of images, beamed at you from your computer monitor.
The same happens if you watch TV, cinema or even a flip book - or any computer game.
You see lots of similar pictures at a high frequency or frame rate (like 60 pictures per second).
If you see, let's say, a picture of a blue ball in the upper left corner in the first picture (or frame) and thus at each following picture (frame) the ball is a bit more right than in the previous picture, you think that the ball is moving from left to right.
Code Discussion and Source Code
In the next chapters (steps) you can always expect a short code discussion where the new concepts and matching code lines are explained followed by the complete source code example at the end of the page. The discussion of the code is written before the complete source code because the source code examples tend to be rather long. For best results do not copy & paste the source code examples but instead click on the name of the source code example (on top of the source code) to download and save it. If your browser or operating system allows you to open the source code example directly with a Python editor like geany or IDLE you can run the code examples directly from your editor.Step 002 - Window and Framerate
This first pygame example is very simple: It opens a window and displays the frame rate. You can close the program by pressing the ESCAPE key (on the top left of most keyboards) or by clicking on the close button in the window menubar.
Screenshot of 002_display_fps.py Screenshot of the improved variant 002_display_fps_pretty.py
Where Is the Source Code ?
The source code example to this “step” is always at the end of the page, at source code on github. The reason is that source code examples can be several 100 lines long and (like in this case) come in several variants or include several files. In ThePythonGameBook the full source code is always the last heading on a page.Code Discussion
Allow Special Chars
The first line is a very special kind of comment. If written in the first or second line, it allows the use of (national) special characters1) inside strings and comments in python2.x This special comment structure is no longer necessary in python3.x # -*- coding: utf-8 -*-Multi-Line Docstring
A docstring in triple quotes allows you to span a comment over several lines. Use comments to describe what the program should do. This cannot be overstated, use comments to describe what the code is supposed to do. You can also provide an email address, a project webpage or information about the author. """The following program simplifies gimmicks and enhances unicorns.""" The docstring with triple quotes explains what the program does.Import and Start Pygame
Because pygame is not yet included into python it must be correctly installed and imported. During this wiki book I will always writeimport pygame and never import pygame as pg or from pygame import *.
import pygame
pygame.init()
Screen and Background
The visible pygame window is called screen (in nearly all pygame code examples) and it describes what you see. Pygame has lot of commands to create and handle rectangular graphical areas, called pygame surfaces. Imagine a sheet of paper or a napkin, where you can draw or write. If you glue (blit) those papers on a single page of a flip_book (the screen) you would make them visible. In this code example, the background surface is filled with white colour - pygame colours are always tuples of (red, green, blue) values where each value can be an integer from 0 to 255. The tuple (255,0,0) describes the red color (full red and nothing else), while all colours together (255,255,255) describe white. Black is (0,0,0). After painting and writing on a surface but before blitting the surface it is a good idea to.convert() the surface.
This helps pygame to store the surface in memory optimized for fast blitting.
Note that surfaces with transparency need .convert_alpha() instead.
screen = pygame.display.set_mode((640,480)) # Set screen size of pygame window
background = pygame.Surface(screen.get_size()) # Create empty pygame surface
background.fill((255,255,255)) # Fill the background white color (red,green,blue)
background = background.convert() # Convert Surface to make blitting faster
Blitting the Background
After creating the background surface (and filling it with white color) this surface is not visible by itself. Only after blitting (~painting) it to the visible screen surface you actually see the white background. If you comment out this line you will see a black window only - freshly created surfaces like the screen are black by default. screen.blit(background, (0, 0)) Here, the destination surface is 'screen' on which you blit the surface 'background' to position (0, 0) so that the upper left corner of 'background' is on position (0, 0) on the 'screen' surface.Event Handler
Pygame creates a lot of events all the time (the mouse is moved, a key is pressed etc). You can react on those events with an event handler like the following example. If a key is pressed, the Pygame event queue registers a KEYDOWN event. There exists another method to ask what keys are pressed at the moment, see the next examples. The Pygame documentation at http://www.pygame.org/docs/ref/key.html lists all valid keyboard constants. for event in pygame.event.get(): if event.type == pygame.QUIT: mainloop = False # pygame window closed by user elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: mainloop = False # user pressed ESCUnderstanding Time
The objectpygame.time.Clock() (which will be stored in the variable clock) has a method tick() which returns the amount of milliseconds passed since the last frame.
Inside the mainloop, the code:
milliseconds = clock.tick(FPS) # do not go faster than this framerate
stores the number of milliseconds into the variable milliseconds.
The next code line
playtime += milliseconds / 1000.0 # add seconds to playtime
calculates the number of seconds passed (by dividing by 1000.0) and increases the value of the variable playtime.
Ideas
Change the screen resolution. Try blitting the background in the middle of the screen, not in the topleft corner. See keycodes and let the program print something as soon as you press the <key>space</key> key.Documentation
http://www.pygame.org/docs/ref/event.html#pygame.event.get http://www.pygame.org/docs/ref/time.html http://www.pygame.org/docs/ref/key.html http://www.pygame.org/docs/ref/surface.html#Surface.fill http://www.pygame.org/docs/ref/surface.html#Surface.blit http://www.pygame.org/docs/ref/surface.html#Surface.convertSource Code on Github
To run both variants of this example you need:https://github.com/horstjens/ThePythonGameBook/archives/master simple version 002_display_fps_pretty.py pygame OOP version There exist 2 code examples, a simple example from Horst and an object oriented variant of yipyip. Both versions have a similar functionality but implement this in a different manner. If you are new to python/pygame programming and have not yet worked with the class command you may want to try out the simple variant and come back if you are more familiar with>
Simple Version
This is the most basic meaningful pygame program. No fancy stuff. View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/002_display_fps.pyOOP Version
An object orientated version, which uses the pygame.font module for displaying frame rate and game duration as text. (See also →pygame text) https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/002_display_fps_pretty.py Click reload in your browser if you see no code.Step 003 - Surfaces and Drawing
Screenshot of 003_static_blit.py Screenshot of the improved variant 003_static_blit_pretty.py
This program is blitting two different pygame surfaces into the pygame window (called screen):
The (white) background surface and
the (blue-black) ball surface
Unlike the usual Cartesian_coordinate_system, Pygame use an x,y coordinates system where the position (0,0) is defined as the top left corner of the screen.
Moving down means having a higher y value, moving to the right means having a higher x value.
vs.
Cartesian coordinate system.
The point (0,0) is in the middle Pygame coordinate system.
The point (0,0) is in the top left corner
Code Discussion
Surfaces
Please note that despite the name the ball surface is a rectangular surface. Onto this surface the program draws a blue circle. Because the ball surface was not filled like the background surface, it remains black (Red Green Blue value: (0,0,0)). Also note that in this program nothing is blitted inside the mainloop, all painting and blitting occurs before the mainloop. The ball is visible on the screen because the background was blitted first and then the background the ball surface was blitted (quasi-on-top). Reverse the order of blitting and you should see only the white background. Blitting the background on the screen is a good method to clean all graphic artefacts from a screen.Drawing
Pygame knows a lot of drawing functions. In this code example, thepygame.draw.circle function is used.
All of Pygame's drawing function need a pygame surface to draw on.
Think of those surfaces like papers or beer mats.
The top left corner of the Pygame surface has the coordinate (0,0).
Let's take a look at the pygame.draw_circle documentation and the code lines in the source code example:
# create a rectangular surface for the ball
ballsurface = pygame.Surface((50,50))
# draw blue filled circle on ball surface
pygame.draw.circle(ballsurface, (0,0,255), (25,25),25)
In the first code line, a pygame surface is created with the dimensions 50 pixel width (x-axis) and 50 pixel height (y-axis).
This little pygame surface is named ball.
The second code line draws a circle on the surface ball with the colours
0 (no portion of red), 0 (no portion of green), 255 (full portion of blue) at the position (25,25) counted from the top left corner of the ball surface.
(25,25) is exactly the middle of (50,50).
This circle has a radius of 25 pixels, and because there is no line width argument, pygame falls back to the default width of 0 which results in a blue filled circle.
Some Drawing Functions
In the official pygame documentation, the chapter draw lists 9 drawing functions. 4 of them are used in this code example to draw green figures on the background surface. Try to change the values and see what happens: #------- try out some pygame draw functions -------- # pygame.draw.rect(Surface, color, Rect, width=0): return Rect pygame.draw.rect(background, (0,255,0), (50,50,100,25)) # rect: (x1, y1, width, height) # pygame.draw.circle(Surface, color, pos, radius, width=0): return Rect pygame.draw.circle(background, (0,200,0), (200,50), 35) # pygame.draw.polygon(Surface, color, pointlist, width=0): return Rect pygame.draw.polygon(background, (0,180,0), ((250,100),(300,0),(350,50))) # pygame.draw.arc(Surface, color, Rect, start_angle, stop_angle, width=1): return Rect pygame.draw.arc(background, (0,150,0),(400,10,150,100), 0, 3.14) # radiant instead of gradIdeas
Paint a giant pink circle on the middle of the screen Find out wich line you must out-comment (using #) to remove the blue ball and the black square Can you use the pygame.draw.polygon function to draw a pentagram:
Can you make an arc from the topright to the lower-left corner1)?
Use python's range function to draw a pretty pattern across the screen.
Start with this code and expand to all 4 corners:
for point in range(0,641,64): # range(start, stop, step)
pygame.draw.line(background, (255,0,255), (0,0), (480, point), 1)
Can you use the point variable also inside the color tuple to make each line with a different color?
Documentation
http://www.pygame.org/docs/ref/draw.html http://www.pygame.org/docs/ref/surface.html#Surface.blit http://www.pygame.org/docs/ref/surface.html#Surface.convert http://www.pygame.org/docs/ref/surface.html#Surface.convert_alphaSource Code on Github
https://github.com/horstjens/ThePythonGameBook/archives/master simple version 003_static_blit_pretty.py pygame pretty version
Simple Version
This version draws some lines and blits a surface. no fancy stuff. View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/003_static_blit.pyOOP Version
Improvements: using 2 different class objects, one for the game, one for the ball. See →sprites better text display, see →text https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/003_static_blit_pretty.pyStep 004 - Colorkey and Alpha Values
004_colorkey.py 004_alphademo.py 004_alphademo_pretty.py 004_per-pixel-alphademo.py In this page you will find 4 code examples: 004_colorkey.py , 004_alphademo.py , 004_alphademo_pretty.py and 004_per-pixel-alphademo.py. All examples demonstrate how to work with transparency and pygame surfaces. 004_colorkey.py is simple to understand. Compare it with 003_static_blit.py on the previous page and look at the blue circle. Do you notice a difference ? Right, the ugly black corners around the blue circle are gone. This is thanks to pygame's set_colorkey command. By defining a specific color on a pygame surface as colorkey, you make this color (in our example, the black color) transparent. There are 2 kind of image files: Those with in-build transparency , and those without. Only graphic files of the file type .png and .gif can have transparency1). Other file tpyes like the popular .jpg format can not have transparency. If you want transparency for such images you must add them manually with pygame. 004_alphademo.py shows you how to do that. Look at the slowly blinking colormonster (3rd from the left the second row). You can see the amount of alpha-value (the white text below the picture) necessary to make a picture fully visible or fully transparent. You can also press the keys <key>Ins</key>, <key>Dec</key>, <key>Home</key>, <key>End</key>,<key>PageUp</key>, <key>PageDown</key>, <key>Num+</key>, <key>Num–</key> to manually change the rgb and alpha values in the topright images. Press the keys to see what happens. For even more effects, you can change the Blit mode by pressing <key>ENTER</key>. This affects the mixing of rgb values from the image and those specified by the keys. 004_per-pixel-alphademo.py shows you an interesting effect by changing the alpha-value of individual pixels. Move the mouse around and use the scroll wheel.- Code Discussion 004_colorkey.py
Colorkey
There is only one important line in this example. To get rid of the ugly black corners of the blue ball surface we declare the color black (0.0.0) as transparent. #make black the transparent color (red,green,blue) ball.set_colorkey((0,0,0)) To make the blitting of a pygame surface faster, it is a good idea to use .convert() on the surface once all drawing on the surface is done. Note that if the surface contains transparent colors, you need to use convert.alpha() instead of .convert().Blitting on the Screen
The same ballsurface is blitted on the screen (not on the background!) twice in this example: once (the left ball) before the mainloop start and once inside the mainloop. Inside the mainloop a pattern of colourful lines is drawn each frame. The lines will draw on top of the left surface, but the right surface is drawn on top of the lines. Note that the “corners” of the ball surfaces are not simply white but transparent. The colourful lines are good visible “below” the corners of the right ball surface. Note that in this code example, inside the mainloop all commands draw directly on the screen surface.Documentation
http://www.pygame.org/docs/ref/surface.html#Surface.set_colorkey- Code Discussion 004_alphademo.py
004_alphademo.py shall show you the possibilities of alpha-values (transparency) and image files. Don't worry if you do not understand all of 004_alphademo.py yet - i don't understand all of it, neither. The important thing is to know how to use it. Some techniques like loading surfaces from files and using text will be explained in other pages. Also note that there are 2 ways of handling keyboard input in 004_alphademo.py. pressed_keys : to indicate of a specific key is pressed at this moment. key_pressed : to check if a specific key was (once) pressed and released. Both methods will be discussed in more detail in →step011.Blend Modes
From the different blit-modes, BLEND_RGBA_MULT (mode number 8) seems to be the most meaningful one. Using this blit mode, you can make an image all blue, red or green by setting the per-pixel-alpha values for the corresponding colour. At the same time, you can set an alpha value for the whole image. This works both for images without transparency such as .jpg images but also for images with in-build transparency such as .gif or .png images. def get_alpha_surface( surf, alpha=128, red=128, green=128, blue=128, mode=pygame.BLEND_RGBA_MULT): """ Allocate a new surface with user-defined values (0-255) for red, green, blue and alpha. Thanks to Claudio Canepa <ccanepacc@gmail.com>. """ tmp = pygame.Surface( surf.get_size(), pygame.SRCALPHA, 32) tmp.fill( (red,green,blue,alpha) ) tmp.blit(surf, (0,0), surf.get_rect(), mode) return tmp For an example of how to use this function, see this code snippet: tmp = get_alpha_surface(pngMonster3, a, r, g, b, mode) screen.blit(tmp, (600,10)) The different modes are integer values and can be found in the pygame documentation or by using python's interactive interpreter: >>>import pygame >>>help(pygame.constants)Alpha Value for the Whole Surface
If you have a pygame surface without in-build transparency (let's say loaded from an .jpg image) you can set an alpha-value (transparency) for the whole surface with a simple set_alpha() command as shown in this code snippet from 004_alphademo.py: jpgMonster2.set_alpha(alpha) # alpha (0-255) for whole surface screen.blit(jpgMonster2, (400,300)) # blit on screenDocumentation
http://www.pygame.org/docs/ref/surface.html#Surface.blit more about blend modes: http://stackoverflow.com/questions/601776/what-do-the-blend-modes-in-pygame-mean http://illusions.hu/effectwiki/doku.php?id=list_of_blendings- Ideas
<note tip>replacecolormonster.jpg with a picture of your own head.
rename the picture or the relevant code line inside 005_alphademo.py.
Can you make your face all blue or all purple just by pressing keys ?</note>
<note tip>set_aplpha() allows you to create fading effects for game intros, in-game cinematic or game-over screens.
Use a paint programm like Gimp, create a stunning game title (or game over message) and save it in the .jpg format.
Now try to let pygame fade in or fade out of this picture (ideally while playing music, see →step010)</note>
Source Code on Github
https://github.com/horstjens/ThePythonGameBook/archives/master This program runs stand-alone and does not need other files 004_alphademo.py pygame this program needs other files (see below) to run 004_alphademo_pretty.py pygame yipyip's version of alphademo. This program needs other files (see below) to run 800px-La_naissance_de_Venus.jpg
pygame/data source: wikipedia
colormonster.jpg 
pygame/data a .jpg graphic an not have in-build transparency.
(notice the white background)
colormonster.png 
pygame/data a .png (as well as .gif) graphic can have in-build transparency.
Notice the transparent background
ente.jpg 
pygame/data a picture of a duck2)
If you see no colourful source code below, click on “reload” on your browser.
Or follow the links to github.
004_colorkey.py
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/004_colorkey.py004_alphademo.py
This program need other graphic files to be located in a subfolder calleddata.
See the file table above for details.
To get the program working correctly, you best download and unpack the whole file archive (link in the file table above).
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/004_alphademo.py
004_alphademo_pretty.py
This program need other graphic files to be located in a subfolder calleddata.
See the file table above for details.
To get the program working correctly, you best download and unpack the whole file archive (link in the file table above).
<note tip>This version is for python 2.x only ! For python 3.x, see the next code example below</note>
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/004_alphademo_pretty.py
004_alphademo_pretty_python3x.py
This program need other graphic files to be located in a subfolder calleddata.
See the file table above for details.
To get the program working correctly, you best download and unpack the whole file archive (link in the file table above).
<note tip>This verison works with python3.x only.
For python 2x version, see the oode example above</note>
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/004_alphademo_pretty_python3x.py
004_per-pixel-alphademo.py
This program needs one other graphic file -ente.jpg- to be located in a subfolder calleddata.
See the file table above for details.
To get the program working correctly, you best download and unpack the whole file archive (link in the file table above).
Note: For Python 3.x, change the two instances of the xrange() function (which was deprecated in Python 3) to range().
https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/004_per-pixel-alphademo.py
Step 006 - Time-based Movement
Code Discussion
To avoid the hardware-dependence of frame-based movement you can force pygame to calculate time-based movement.
Please note that we still speak of the illusion of movement, because all what pygame does is blitting blobs (surfaces) to different positions - but in a more reliable way 
!
Time-based movement does not mean that your pygame program will run on crappy computers as smooth as on fast machines - pygame can not (yet) do that! Time-based movement just means that independent of the speed of the computer, in the source code example below the ball will always take the same amount of time to cross the screen.
On fast machines, the movement will appear very smooth, while on slow machines the movement will appear bumpy.
Calculating the passed Time
The secret to time-based movement is to let pygame calculate how much time was passed since the last cycle of the mainloop (to be exact: since the last call of the clock.tick command). Pygame provide this information in milliseconds. In the source code example below I convert this value into seconds 1). This time value is multiplied to the speed vector: #calculate new center of ball (time-based) ballx += dx * seconds # float, since seconds passed since last frame is a decimal value bally += dy * seconds Note that the value of seconds will be something like 0.05 seconds per frame 2) so you need rather high dx and dy values to see any movement at all. In this example dx and dy speed values are set at 60 pixel per second.Blitting on a clean Screen
In this pygame example, the whole background is blitted onto the screen each cycle (frame) of the mainloop. This will overwrite all old images of the ball surface. On top of the fresh background, the ball is blitted each frame. While this method of cleaning the whole screen allow you care-free programming, very big pygame windows (screen resolution) or slow computers will show a drop in the frame-rate. The next chapters will show you more time- and memory-efficient methods of cleaning only those parts of the screen that need cleaning. This is called dirty rects cleaning.Source Code on Github
To run this example you need:https://github.com/horstjens/ThePythonGameBook/archives/master View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/006_time_based_movement.py
Step 008 - Animation
Remember the Subsurfaces from the last step? And remember that the snake had always the same grinning facial expression? Now, let's make some animated sprites1) - not pygame sprites, but surfaces that show different images of an animation cycle, like a bird flapping its wings.
Instead of painting all the single pictures of an animation cycle myself, I prefer to use ready-made sprite sheets.
In the data folder, you will find a spritesheet2) from Ari Feldmann's Spritelib ( http://www.widgetworx.com/spritelib/ ) showing several pictures of an animal.
If you use Ari's sprite's, make sure to include his license information in your program.
With the help of pygame's subsurface command, I will show you how to extract single images from the sprite sheet and use them.
Code Discussion
Source Code on Github
To run this example you need:pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master char9.bmp
pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/008_animation.py
Step 009 - Tile-based Graphics
Escape the maze! In this code example, you can control a little red ball using the cursor keys <key>←</key> <key>→</key> <key>↑</key> <key>↓</key> and you must seek to escape a walled maze by finding the way to the orange goal.
Code Discussion
Source Code on Github
To run this example you need:simple but ugly verions
pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master 009_02_tile_based_graphic_(improved).py.py
improved version
pygame
Ugly Version
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/009_01_tile_based_graphic_(ugly).pyImproved Version
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/009_02_tile_based_graphic_(improved).pyStep 010 - Using Sound and Music
Code Discussion
Pygame has several commands to play sound. Pygame offers a set of Sound commands to load and play short sound files - usually.wav or .ogg files.
For longer files, pygame offers pygame.music commands to stream longer music / sound / voice files directly from the harddisk.
In the source code example below, loading sounds and music is done from a subfolder called data, like the graphic files in the previous source code example.
Initializing the Mixer
To get rid of a nasty delay between giving the play command for a sound and hearing it you need to initialize the pygame mixer. This is done before writing the pygame.init() command. Under Linux, I got best results with this line: pygame.mixer.pre_init(44100, -16, 2, 2048) # setup mixer to avoid sound lag pygame.init() #initialize pygameloading music and sound files
Note that loading the sound and music files from harddisk must be done after setting up the mixer. In the code-example below, an-turr.ogg is a longer music file while jump.wav and fail.wav are short sound effects: try: pygame.mixer.music.load(os.path.join('data', 'an-turr.ogg'))#load music jump = pygame.mixer.Sound(os.path.join('data','jump.wav')) #load sound fail = pygame.mixer.Sound(os.path.join('data','fail.wav')) #load sound except: raise UserWarning, "could not load or play soundfiles in 'data' folder :-("Playing Music and Sound from Files
After loading the sound effects or the music and thus creating pygame objects, you can simply call the.play() method of those objects.
Inside the brackets you write -1 for endless play or the number of times or the time length to play the sound.
#for sound effects:
#Sound.play(loops=0, maxtime=0, fade_ms=0): return Channel
jump.play() # play the jump sound effect once
The music is usually played endlessly:
#music is already the name of the music object
#pygame.mixer.music.play(loops=0, start=0.0): return None
music.play(-1) # play endless
<note tip>you hear just a short crack noise instead of a sound? Some sounds simply do not work with pygame.
Try to open (and edit) the sound with a sound editor like Audacity and save it again, preferable in the free .ogg (vorbis) format.</note>
versions with and without graphic
Note that you do not need pygame's graphic at all to play music files. One of the code examples below use graphical output, the other example use only text output. In text output, you still need to initialize pygame and set up the mixer.- Generate Sound Effects
Unlike music, sound effects are easy enough to generate and not worth the hassle of copyright fights. You may find good sound effects here: overview of resources at the pygame homepage: http://pygame.org/wiki/resources wikimedia commons: http://commons.wikimedia.org/wiki/Category:Sound To generate sound effects, you can either: plug a microphon1) in your computer and start the recording software of your OS. every OS is shipped with a primitive voice recording software. use a program that can generate sound effects, like: http://audacity.sourceforge.net/ http://www.drpetter.se/project_sfxr.html http://www.bfxr.net/ (online)Documentation
http://www.pygame.org/docs/ref/mixer.html#pygame.mixer.pre_init http://www.pygame.org/docs/ref/mixer.html#pygame.mixer.Sound http://www.pygame.org/docs/ref/music.html#pygame.mixer.music.load http://www.pygame.org/docs/ref/music.html#pygame.mixer.music.playSource Code on Github
To run this example you need:pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master 010_sound_only_no_graphic.py
pygame
an-turr.ogg from modarchive.org
pygame/data
fail.wav pygame/data
jum.wav pygame/data
without graphic
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/010_sound_only_no_graphic.pywith graphic
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/010_sound_and_music.pyStep 011 - Keys, Rotating and Zoom
Code Discussion
Pressed Keys
Surfaces can not only moved around, but also rotated and -unlike beer mats- zoomed.
The next source code examples introduce a new method of keyboard control.
Instead of checking a queued event with pygame.event.get() the function pygame.key.get_pressed() delivers the actual state of the complete keyboard.
This state is represented by a tuple of 0/1 values for each key.
A value of 0 signals an unpressed, a value of 1 signals a pressed State of a key.
You can access the value for a specific key with the K_<A_SPECIFIC_KEY> values defined in pygame.constants.
For example
pressedkeys = pygame.key.get_pressed()
if pressedkeys[pygame.K_x]:
do_something()
checks if the key “x” is pressed.
This method is ideal for constant movement, where a sprite moves or rotate as long as a specific key is pressed.
In the source code example bleow, the cursor keys <key>←</key> <key>↑</key> <key>→</key> <key>↓</key> are used to move the snake surface, while the keys <key>w</key> and <key>s</key> zoom/shrink the snake and the keys <key>a</key> and <key>d</key> rotate the snake.
It is possible to press several keys together, like left and right cursor, and the program will move the correctly (not at all in this case):
dx, dy = 0, 0 # no cursor key, no movement
if pressedkeys[pygame.K_LEFT]:
dx -= speed
if pressedkeys[pygame.K_RIGHT]:
dx += speed
Note that this method of keyboard control is less precise than the if pygame.event.type… - method because there is no guarantee that a fast key-pressing will be noticed by pygame.
Depending on how fast the computer can calculate each cycle of the main-loop, there could be a chance that you press and release a key just between 2 main loop cycles and pygame would not notice.
However, if your program runs around 30 frames per second, you would need lightning fast fingers to become not noticed by pygame.
Also note that this keyboard control method is not ideal for pre-defined movement like stones on a board game.
While you can control with the time-based movement the speed of a surface, it lay in the skill of the user and his dexterity in pressing and releasing a key to control how long a surface moves (and where its movements end exactly).
troublesome subsurface
Also note that the cleaning of the old surface (using thesubsurface method) is done inside a try…except block.
If the subsurface is no longer inside the surface, pygame would raise an error.
This can happen when you zoom or rotate the snake outside the screen.
# only blit the part of the background where the snake was (cleanrect)
try:
#if the subsurface is outside the screen pygame would raise an error
#this can happen when using rotozoom, therfore check inside try..except
#Surface.subsurface(Rect): return Surface
dirtyrect = background.subsurface((round(snakex,0),
round(snakey,0), snake.get_width(), snake.get_height()))
screen.blit(dirtyrect, (round(snakex,0), round(snakey,0)))
except:
screen.blit(background,(0,0)) # blit the whole background (slow but secure)
do not get lost in space !
Also note that in this code example there is no checking if the snake is inside the screen whatsoever. You can try to move the snake outside of the right , move it down, left and up and reappear from the left.Zooming around the Center
the pygame.transform.rotozoom command would rotate around the position (0,0) of a Surface - the topleft corner. To create a more pleasing rotation aroundthe center effect, we need some tricks: First, the original snake surface is copied into snake_original right after creation, to have always a not-manipulated image: snake_original = snake.copy() # store a unmodified copy of the snake surface <note tip> snake_original = snake would not work because both snake and snake_original would be just pointers to the same python object (the manipulated snake). If you need a copy of an object, use the .copy() method</note> Always the original_snake surface is zoomed and rotated with the current zoom and angle values by the pygame.transform.rotozoom command. But how to avoid a rotation around the topleft corner? For that, beforepygame.transform.rotozoom does its work, the current rectangle of the snake surface is stored into the variable oldrect by the surface.get_rect() command.
Pygame rects have several useful properties, like pre-defined constants for center, centerx, centery, width, height etc.
After rotating and now having a usually resized snake surface (pygame always calculate a rectangle around the visible surface, thus a rotated snake fits in a bigger rectangle than a non-rotated snake) the rectangle of the new surface is stored into the variable newrect.
This is also done with the surface.get_rect() command.
Now the code example simply blits the new surface so that its new center lays on the same spot as the center of the old rectangle - rotated around the center.
if turnfactor != 0 or zoomfactor !=1.0:
angle += turnfactor * turnspeed * seconds # time-based turning
zoom *= zoomfactor
# the surface shrinks and zooms and moves by rotating
oldrect = snake.get_rect() # store current surface rect
snake = pygame.transform.rotozoom(snake_original, angle, zoom)
newrect = snake.get_rect() # store new surface rect
# put new surface rect center on same spot as old surface rect center
snakex += oldrect.centerx - newrect.width / 2
snakey += oldrect.centery - newrect.height / 2
Documentation
http://www.pygame.org/docs/ref/rect.html http://www.pygame.org/docs/ref/transform.html#pygame.transform.rotozoom http://www.pygame.org/docs/ref/key.html#pygame.key.get_pressedSource Code on Github
To run this example you need:pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master background640x480_a.jpg
pygame/data
snake.gif 
pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/011_rotozoom.py
Step 012 - Text
Code Discussion
There are more ways to display text than the pygame.display.set_caption(“msg”) command.
You can render any text directly on a pygame surface.
This code example uses two defined functions to better seperate the text writing from the surface display commands.
Note that inside the second function is a call to the first function, generating a random colour tuple of (red, green, blue) values.
All the text rendering happens inside the write function:
def write(msg="pygame is cool"):
myfont = pygame.font.SysFont("None", random.randint(34,128))
mytext = myfont.render(msg, True, newcolour())
mytext = mytext.convert_alpha()
return mytext
Inside this write-function, text is written to a surface (pygame uses the system font if no specific font-file is loaded) using a randomized font size and randomized colour.
The text surface has already a transparent color and is returned to the function call inside the main loop:
# inside mainloop
textsurface = write("hello world")
Code Challenges:
prompt user for text to randomize
read in a text file of words to display, change the word on collision with wall
For fun, no cleanrect method is used here and the background is only blitted to the screen when the text surface touches the left screen border.
Documentation
http://www.pygame.org/docs/ref/font.html#pygame.font.SysFont http://www.pygame.org/docs/ref/freetype.html#Font.renderThe Flytext Function
This exmple is written as a big function, flytext(). The function flytext accept the two arguments msg (the text message to display) and duration. Example: To call the function and let it write “Python is cool” for seven seconds, use: flytext("Python is cool", 7) Note that if you start flytext without arguments, the last two codelines will run the function with default arguments, writing “hello World” for five seconds. You can change the default values in the line where the flytext function is defined: def flytext(msg="hello world", duration=5):Source Code on Github
To run this example you need:pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/012_text.py
Step 013 - Catch the Thief Game
How to Play
This code example should teach nearly nothing new but instead put all the wisdom from the previous steps together to create a little game.
In this catch-the-thief-game up to 2 players control sprites1) (the Pygame snake and the babytux bird) and are tasked to help the police (blue circle with white “P”) to catch a thief (red triangle with transparent “T”).
To make the game interesting (and difficult), the police moves toward the middle position between the both players (this position is marked with a black cross).
The thief moves randomly.
All sprites are controlled indirectly, like ships in water (or spaceships in space): The player point the mouse or press the cursor - keys <key>←</key> <key>→</key> <key>↑</key> <key>↓</key> in the direction the sprite should move.
The sprite will eventually move into this direction but will continue to do so even if it gets a new order.
Bouncing off the screen edge will change the direction.
If no orders are given, all sprites except the thief will eventually come to an halt because of friction.
The player can use an emergency break and force his sprite to halt by pressing <key>ENTER</key> or pressing the left mouse button.
Instead of the cursor keys, the player can also use <key>w</key>, <key>a</key>, <key>s</key>, <key>s</key>, <key>CTRL</key>.
If no second player is present, one skilled player can try to control both sprites with mouse & keyboard.
Code Discussion
In the code, those pygame surfaces are called sprites. Please note that pygame has it's own, very sophisticated pygame.Sprite>def. Most important are the last two lines, basically the only lines outside a function: if __name__ == "__main__": play_the_game() Those lines control if the game is started directly or imported from another program (like a program that manages a highscore list). If the programm is started directly, the internal variable __name__ has the value "__main__". In this case, the game start itself by calling the play_the_game() function. Because the loaded background image is larger than the pygame display screen resolution, the background image is resized using this command: background = pygame.transform.scale(background, (screen.get_width(), screen.get_height())) After defining some useful functions for later use the game creates several pygame surfaces: screen and background and several sprites: bird, snake, police, cross, thief where each sprite get the variables x, y, dx, dy with the spritename as prefix. X and Y control the position while dx and dy control the movement speed. Inside the mainloop, all sprites are cleaned, updated (player commands are computed here) and finally blittedn on the screen again. The mainloop switch into a special GameOver - mode after the playtime runs out. While in the GameOver mode, no sprites are displayed and only the score is rendered for the players information. The cleanblit function calls and a lot of headache could all be ignored and instead a simple line of #screen.blit(background, (0,0)) # not GameOver would do the job. However, framerate would drop when using large screen resolutions. Before blitting (drawing) the sprites, a check is made if the police sprite is near enough at the thief sprite to credit the players with a score point. There are some code lines to see if the pygame sound mixer is currently busy and if he is silent the spring.wav sound is played. Also because at each catching of the thief the screen is filled with a random colour, the code line checks if this frame (mainloop cycle) is the first of “normal” activity (no thief is catched) right after an “catch” frame. If yes, the old original background is blitted on the screen. catch_in_last_frame = catch_in_this_frame # save old catch info catch_in_this_frame = False if (distx < police.get_width() /2) and (disty < police.get_height()/2): catch_in_this_frame = True points += seconds screen.fill(randomcolour()) if not pygame.mixer.get_busy(): spring.play() # only play this sound if mixer is silent at the moment else: # no catch this time if catch_in_last_frame: screen.blit(background, (0,0)) # restore backgrounndIdeas
<note tip>ideas: head over to http://www.openstreetmap.org/ , find a map from your city, and use it ! (right-click on the map, select “save image as…”) Improve one-player modus by adding <key>w</key> <key>a</key> <key>s</key> <key>d</key> as control keys enable direct control for mouse or keyboard (like manipulating snakex, snakey instead of snakedx, snakedy) create additional sprites play a music file use proportional force (like a rubber band): the further away the police surface is from the cross, the faster it travels toward the cross split the code into a config file (with all the constants and variables) and into a game file dynamic score points: calculate the current distance between police and thief. Give points all the time, based on this distance (0 distance - max points) draw a line between police and thief. The line should become thicker if the distance police-thief becomes shorter </note>Trivia
<note>trivia: This games is inspired by the Austrian tv cult series Kottan. As the content and visuals of this series are -sadly- neither public domain nor creative-commons licensed i use free graphics. But on your own computer, you can replace the sprite graphics with some characters of your favorite TV show.</note>Documentation
http://www.pygame.org/docs/ref/transform.html#pygame.transform.scale http://www.pygame.org/docs/ref/mixer.html#pygame.mixer.get_busySource Code on Github
To run this example you need:pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master wien.jpg
pygame/data
snake.gif pygame/data
babytux.png 
from wikimedia commons
pygame/data
spring.wav from Battle of Wesnoth
pygame/data
time_is_up_game_over.ogg from Neverball
pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/013_catch_the_thief.py
Step 014 - Pygame sprites
code discussion
If you analyze the previous catch-the-thief game you will notice that most of the code in the main loop takes care of cleaning, calculating and blitting the pygame surfaces (the sprites).
Pygame provides a very powerful pygame.sprite class for more elegant and object-oriented sprite programming.
The advantages of using a sprite>self) but you can also use>pygame.sprite.Groups for mass processing
pygame provides easy-to-use collision detection between sprites
what is a>
Please refer to the python documentation or other tutorials for a better introduction into object-oriented programming.
For quick and dirty coding, it is enough if you compare using a sprite>Cookie_cutter you can construct many cookies.
Think of the cookie cutter as the class and of the cookies as the (constructed) instances of this>.
The>code example of a sprite>
+ 
= 
dough a cookie cutter many cookies
some coding >class Snake(pygame.sprite.Sprite):
"""the pygame Snake"""
image = pygame.image.load("Snake.gif")
image = image.convert_alpha()
def __init__(self, startpos):
pygame.sprite.Sprite.__init__(self,
self.groups)
self.pos = startpos
self.image = Snake.image
self.rect = self.image.get_rect()
def update(self):
self.rect.center = self.pos
discussion of sprite>
In the code example above (below the cookies) you can how a sprite>class
) with a beginning capital Letter, in this case Snake instead of snake.
Also note that this>derives from (is a child of) pygame's Sprite>class Snake(pygame.sprite.Sprite):
Directly after the> image = pygame.image.load("Snake.gif")
image = image.convert_alpha()
describe>class prefix self
Now comes the part describing each>self is used.
You could use another prefix but most python coders write self.
Each function need at least the argument self, even if no other parameter is passed to the function.
The first function that every pygame sprite>def __init__(self):
A part from the usual self, you can give the new born Snake as many arguments as you need, like initial position, behaviour, color etc.
In the next example, only a startpos is given, defaulting to (50,50) if the sprite is created without a startpos.
The sprite will not work until you tell pygame to do all the stuff that it needs doing to create a new sprite.
This is done by calling the __init__ function of the>, also a good way to handle pygame's sprite groups.
storing>
If you want to store any parameters for the sprite itself (so that other functions like an update or kill function can access them, you need to save the parameter into a>def __init__(self, startpos=(50,50)):
pygame.sprite.Sprite.__init__(self,self.groups) # never forget this line !
self.pos = startpos # store startpos into a>
call the property of the>
Now you are free to code all the property's of the>self
to indicate that a property (like the position) is valid or this individual snake (class instance) only.
Here, the starpos argument is stored into the variable self.pos:
self.pos = startpos
To access>self.image = Snake.image
useful stuff for each>
self.image …how the sprite look.
It's a pygame surface, loaded or created, and you can use the pygame.draw commands on it.
self.rect …very useful, get it with the command self.rect = self.image.get_rect() after you are done with creating self.image
self.radius … useful for circular collision detection
self.rect.center … if you have self.rect, use this to control the postion of a sprite on the screen.
update(self, time): … a function (best with the passed seconds since last frame as argument) where you can calculate what the sprite should do, like moving, bouncing of walls etc
kill(self) … very useful to destroy a sprite.
the call inside the>a complete sprite>
This is the complete code for the Birdcatcher>source code.
This>self.image.
class BirdCatcher(pygame.sprite.Sprite):
#>
image = pygame.Surface((100,100)) # created on the fly
image.set_colorkey((0,0,0)) # black transparent
pygame.draw.circle(self.image, (255,0,0), (50,50), 50, 2) # red circle
image = self.image.convert_alpha()
# code for each individual>
def __init__(self):
pygame.sprite.Sprite.__init__(self, self.groups) # THE most important line !
self.image = BirdCatcher.image # make>
self.rect = self.image.get_rect()
self.radius = 50 # for collide check
def update(self, seconds):
# no need for seconds but the other sprites need it
self.rect.center = pygame.mouse.get_pos()
before the main loop
Before the main loop starts, you define some pygame.sprite.Groups to contain all the sprites:
If you have a Sprite Snake and the two groups allgroup and snakegroup you can assign that all Snake sprites should be members of both groups:
allgroup = pygame.sprite.Group()
snakegroup = pygame.sprite.Group()
# each Snake sprite is automatically member of both groups:
Snake.groups = allgroup, snakegroup
# create a single Snake named "mypython"
mypython = Snake()
what to do in the mainloop
You must make sure that your sprites belong to a sprite group (like allsprites).
In the mainloop, you simply call those commands each frame:
allsprites.clear(screen, background)
allsprites.update(seconds)
allsprites.draw(screen)
pygame.display.flip()
documentation
http://www.pygame.org/docs/ref/sprite.html
http://www.pygame.org/docs/ref/examples.html (pygame version 1.9)
the aliens example: www.pygame.org
source code on github
To run this example you need:
file in folder download
014_sprites.py pygame Download the whole Archive with all files from Github:
https://github.com/horstjens/ThePythonGameBook/archives/master
babytux.png
pygame/data
babytux_neg.png
pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/014_sprites.py
Step 015 - Explosions, healthbars and gravity
code discussion
In the code example below (see source code) you can create and kill sprites by mouse click.
For each kill there is an explosion effect: a sound plays and a random amount of fragments is flying around.
The fragments are subject to a gravity force.
Also note:
Each Bird sprite has it's own livebar sprite (a green bar to display the remaining hitpoints).
Each bird create it's own hitbar inside the init method !
class Bird(pygame.sprite.Sprite):
# ..
def __init__(self, pos):
#..
Livebar(self) #create a Livebar for this Bird.
self is the Bird sprite as parameter
Each Livebar get his “boss” as parameter when created:
class Livebar(pygame.sprite.Sprite):
#..
def __init__(self, boss):
#..
self.boss = boss # the boss is the bird sprite
The main purpose of the code example is to demonstrate the difference between a bad and a good sprite collision detection.
As each Bird1) sprite moves around the screen, it is checked (in the mainloop) for collision with another Bird sprite.
(A even more clever way will be demonstrated in the next steps).
good
The efficient way to do so was friendly showed me by Gummbum from the pygame mailing list
#...before mainloop...
othergroup = [] #create empty list
#...inside mainloop...
while mainloop:
# ...
the usual mainloop code
# test if a bird collides with another bird
for bird in birdgroup:
othergroup[:] = birdgroup.sprites() # This is the correct code, no garbage collection
othergroup.remove(bird) # remove the actual bird, only all other birds remain
if pygame.sprite.spritecollideany(bird, othergroup):
bird.crashing = True
crashgroup = pygame.sprite.spritecollide(bird, othergroup, False )
for crashbird in crashgroup:
bird.dx -= crashbird.pos[0] - bird.pos[0]
bird.dy -= crashbird.pos[1] - bird.pos[1]
wrong
If you write instead of the othergroup[:] = …. line this code:
othergroup = birdgroup.copy() # WRONG ! THIS CODE MAKES UGLY TIME-CONSUMING GARBAGE COLLECTION !
you will notice longer delays between 2 frames as soon as many objects are on the screen.
The .copy() command, excecuted each frame, each up huge blocks of memory.
This block of memory has to be cleaned again from time to time and while pygame
does so, you can notice a huge pause…the game “hangs”.
This effect will only become visible if you have many sprites moving around.
Watch the max(ms) display in the pygame title or the length of the green Timebar bars.
In the source code example at the end of this page you can toggle efficient and inefficient coding by pressing <key>b</key>.
clever
Instead of creating another group for all Birds without the actual Bird you can also compare with the whole birdgroup and check the Bird's number attribute to make sure there is a collision between two different sprites:
# very clever coding
crashgroup = pygame.sprite.spritecollide(bird, birdgroup, False) # the actual Bird is also in birdgroup
for crashbird in crashgroup:
if crashbird.number != bird.number: #avoid collision with itself
In the source code example at the end of this page you can toggle clever coding by pressing <key>c</key>
overwriting a>
Take a look at the code of the def kill(self) method of the (huge) Bird sprite>Timebar sprite>self.kill() command, but you will find no def kill(self): function in the Timebar sprite>pygame.sprite.Sprite>def kill(self) method.
As the name suggest, self.kill() removes the actual sprite from the screen and from all groups.
class Timebar(pygame.sprite.Sprite):
#..
def update(self, time):
self.rect.centery = self.rect.centery - 7 # each timebar kill itself when it leaves the screen
if self.rect.centery < 0:
self.kill() # remove the sprite from screen and from all groups
over writing kill
However, the more complicated Bird sprite>def kill(self): function.
That is because I want to do some extra stuff before killing the sprite, like playing a sound effect and shattering fragments around the screen.
Also in this case I want to remove the Bird sprite from a special dictionary where I store each Bird sprite and its individual number.
Therefore, I overwrite the def kill(self): function, do my special things and finally call pygame's kill method directly: pygame.sprite.Sprite.kill(self)
Big Badda Boom!
class Bird(pygame.sprite.Sprite):
#..
def kill(self):
"""because i want to do some special effects (sound, dictionary etc.)
before killing the Bird sprite i have to write my own kill(self)
function and finally call pygame.sprite.Sprite.kill(self)
to do the 'real' killing"""
cry.play() #play sound effect
for _ in range(random.randint(3,15)):
Fragment(self.pos) # create Fragment sprites
Bird.birds[self.number] = None # kill Bird in sprite dictionary
pygame.sprite.Sprite.kill(self) # kill the actual Bird
Exploding fragments
The Fragment>2).
Note that you can toggle gravity by pressing <key>g</key> during the game.
The effect of the gravity is handled in the update method of the Fragment>class Fragment(pygame.sprite.Sprite):
"""a fragment of an exploding Bird"""
gravity = True # fragments fall down ?
def __init__(self, pos):
pygame.sprite.Sprite.__init__(self, self.groups)
self.pos = [0.0,0.0]
self.pos[0] = pos[0]
self.pos[1] = pos[1]
#...
self.dx = random.randint(-self.fragmentmaxspeed,self.fragmentmaxspeed)
self.dy = random.randint(-self.fragmentmaxspeed,self.fragmentmaxspeed)
def update(self, seconds):
#...
self.pos[0] += self.dx * seconds
self.pos[1] += self.dy * seconds
if Fragment.gravity:
self.dy += FORCE_OF_GRAVITY # gravity suck fragments down
self.rect.centerx = round(self.pos[0],0)
self.rect.centery = round(self.pos[1],0)
Layers
By default, pygame will blit the sprites in the order the sprites are added.
IF you prefer precise order of drawing the sprites (like the mouse pointer always before all other sprites) you can do two things:
use several clear, update and draw commands, one for each sprite group:
use the pygame.sprite-LayeredUpdates group instead of a sprite group and set a default layer for each group, like in the code example below:
# LayeredUpdates instead of group to draw in correct order
allgroup = pygame.sprite.LayeredUpdates() # important
#assign default groups to each sprite>
Livebar.groups = bargroup, allgroup
Timebar.groups = bargroup, allgroup
Bird.groups = birdgroup, allgroup
Fragment.groups = fragmentgroup, allgroup
BirdCatcher.groups = stuffgroup, allgroup
#assign default layer for each sprite (lower numer is background)
BirdCatcher._layer = 5 # top foreground
Fragment._layer = 4
Timebar._layer = 3
Bird._layer = 2
Livebar._layer = 1 #background
More about layers in the next step.
putting the whole game inside a function
You may have noticed that the whole game sits inside a function called def game():.
This is useful when we later make a game menu that starts the game.
Because it will be sensible to split the game code into a menu.py and a startgame.py file.
The menu.py file will import the startgame and call it when the user chooses the menu option.
To be more precise, the menu.py file will start a single function inside the startgame.py file.
(If there is no meaningful function defined inside startgame.py the menu file would start startgame.py right after importing it, before displaying a menu and waiting for the user's choice).
python modules
We have no menu.py (yet) but we can prepare for it by stuffing all interesting parts (shooting up penguins etc) inside a function - let's call the function game() (see below).
But how do we start the game directly? For that, we check the internal python variable __name__.
In this variable, python stores the name of the python module that imported the actual python program.
If we started the actual python program directly (from the terminal or from the python editor), then this variable gets the value __main__ from python.
Therefore you will find in many python modules3) those lines:
def game():
#..
all the interesting stuff
if __name__ == "__main__":
print "i was started directly and will start game()"
game() # start the interesting stuff
else:
print "i am imported by",__name__, "and will do nothing at the moment"
source code on github
To run this example you need:
file in folder download
015_more_sprites.py pygame Download the whole Archive with all files from Github:
https://github.com/horstjens/ThePythonGameBook/archives/master
babytux.png
pygame/data
babytux_neg.png
pygame/data
claws.ogg
from Battle of Wesnoth pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/015_more_sprites.py
click reload in your browser if you see no code here:
Step 016 - LayeredUpdates and Parallax scrolling
gameplay
The source code example below is not much of a game, but it demonstrates the uses of layers for sprites and Parallax_scrolling (the mountains).
Also, you can hide penguins behind blocks and mountains.
Additionally, you can aim with the mouse pointer and press <key>p</key> to print out information about the layers (at the text console).
Trivia:
According to wikipedia, Parallax scrolling was first introduced to computer games by the arcade game Moon_Patrol 1982.
The mountains (and in higher levels, futuristic buildings) moved at different speed to create the illusion of a side-scrolling computer game.
proposals to tinker:
Change the layer of the three types of>pevious step, let the Birds change _layer by random and explode them by mouseclick !
code discussion
- layers
Do you remember the sprite groups from the last step ? Sprite groups are basically containers where the sprites “live” in.
As soon as a sprite is killed (by it's kill() functoin) the sprite is not also removed from the screen but also from all containers holding it.
In the last two steps, i had two uses for sprite groups:
The allgroup (every sprite was member of this group), to clear, draw, and update all sprites from within the main loop
other groups like birdgroup, used to check each sprite in this group for collision detection (crashgroup)
You will note that there exist different variants of sprite groups:
the old spritegroup
the newer LayeredUpdate group
When using pygame.sprite.Layeredupdate() instead of pygame.sprite.Group() you can give each sprite a variable _layer as well as a variable groups to influence the drawing order of the sprite.
In the previous step those variables were defined outside the sprite>__init__(self) method of each sprite>
The sprite groups must exist (be defined in the mainloop) before you can assign sprites to the groups.
That means, inside the mainloop, before you create a Bird sprite or assign images to the Bird>before you call pygame.sprite.Sprite.__init__(self, *groups):
<note>#… means that i let away some not so important code lines</note>
class Bird(pygame.sprite.Sprite):
#...
def __init__(self, startpos=screen.get_rect().center):
self.groups = birdgroup, allgroup # assign groups BEFORE calling pygame.sprite.Sprite.__init__
self._layer = 7 # assign _layer BEFORE calling pygame.sprite.Sprite.__init__
pygame.sprite.Sprite.__init__(self, self.groups ) #call parent>
self.pos = starpos
# ...
# define sprite groups
birdgroup = bargroup = pygame.sprite.Group() # simple group for collision detection
allgroup = pygame.sprite.LayeredUpdates() # more sophisticated and modern group
# assign images to the Bird>
Bird()
pygame.sprite.LayeredUpdates
please see the official pygame doumentation at: http://www.pygame.org/docs/ref/sprite.html#pygame.sprite.LayeredUpdates
changing layers
The cool things about layers is: you can change them even at runtime, to place sprites more in the foreground or more in the background (see code example below).
The change_layer method does exaclty that.
Important: you need only to change the layer of the LayeredUpdates-group that actually draws the sprites on the screen.
In the code example below, this is the allgroup.
(Special thanks to Gummbum for helping me out here).
Because i want only to change the layer of the Bird sprites and their Lifebar sprites i loop over all sprites in the groups birdgroup and bargroup.
Each Bird sprite is a member of the allgroup as well as of the birdgroup.
Each Lifebar sprite is a member of the allgroup as well as of the bargroup.
if pygame.mouse.get_pressed()[0]:
if birdlayer < 10:
birdlayer += 1
cooldowntime = .5 # seconds
cry.play()
for bird in birdgroup:
allgroup.change_layer(bird, birdlayer) # allgroup draws the sprite
for bar in bargroup:
allgroup.change_layer(bar, birdlayer) # allgroup draws the sprite
- Textsprite
Up to now, i blitted all text to the screen or to the background with the write function.
In this example, you will see a new>Text, also printing a msg to the screen.
The Text sprite has no advantages over blitting directly to the background yet, but you can use it later to change the _layer of the Text sprite or if you want the Text sprite to move around.
Note that
the>newmsg to update the displaying text string.
def newmsg(self, birdlayer):
self.image = write("current Bird _layer = %i" % birdlayer)
self.rect = self.image.get_rect()
self.rect.center = (screen.get_width()/2,10)
- waiting Birds
Take a look at the Bird>Bird.waittime indicating how long a Bird should stay “invisible”.
Instead of messing around with drawing and not drawing, during his “invisible” waittime, each bird is simply teleported to the position (-100,-100), that is outside your screen.
If the waittime is over, the Bird sprite is teleported to his Bird.pos position and act like a normal Bird sprite - speeding around, crashing into walls and other birds, exploding.
Class Bird(pygame.sprite.Sprite):
waittime = 1.0 #seconds
#...
def update(self, seconds):
#---make Bird only visible after waiting time
self.lifetime += seconds
if self.lifetime > (self.waittime) and self.waiting:
self.newspeed()
self.waiting = False
self.rect.centerx = round(self.pos[0],0)
self.rect.centery = round(self.pos[1],0)
if self.waiting:
self.rect.center = (-100,-100)
else:
# speedcheck
#..
all the other things
But why the waittime ? The answer is a modification to the Fragment>def __init__(self, layer=4):
#...
Lifebar(self.number) #create a Lifebar for this Bird.
# starting implosion of blue fragments
for _ in range(8):
Fragment(self.pos, True)
See the for loop ? I simply wanted 8 (blue) Fragments, so i do not use an variable like a or b or x inside the for loop but simply an underscore.
The True parameter in the Fragment>dual-use Fragments
The fragment>if-else construct.
The new part is only valid for “bluefrag” Fragments.
After choosing per random from where (screen edge) the Fragment start, self.dx and self.dy are calculated… The Fragment should fly from the screen edge toward the position of the Bird sprite (self.target).
But how fast does the fragment fly ? Because in the update method of the fragment>unit of a sprite is measured in pixel per second.
Meaning each blue sprite will need exactly one second to travel from it's origin to the Bird sprite position.
But what if the waittime for each Birdsprite is 2 seconds ? or just a half second ? For this reason, dx and dy are multiplied by the factor ( 1.0 / Bird.waittime).
So if the Bird waits 2 seconds before appearing, the blue Fragments have more time and should travel slower: 1.0 / 2.0 = 0.5, the speed is reduced.
On the other hand, if the waittime is shorter (say 0.5 seconds) the Fragments should fly faster: ( 1.0 / 0.5 = 2); dx and dy is doubled.
For aesthetic reasons, i allow the blue Fragments to live up to a half second after reaching their target by adding to self.lifetime a value between 0 and 0.5: random.random() * 0.5.
Random.random() creates a float value between 0 and 1.
class Fragment(pygame.sprite.Sprite):
#...
def __init__(self, pos, bluefrag = False):
#...
self.bluefrag = bluefrag
self.pos=[0.0,0.0]
self.target = pos
if self.bluefrag: # blue frament implodes from screen edge toward Bird
self.color = (0,0,random.randint(25,255)) # blue
self.side = random.randint(1,4)
if self.side == 1: # left side
self.pos[0] = 0
self.pos[1] = random.randint(0,screen.get_height())
elif self.side == 2: # top
self.pos[0] = random.randint(0,screen.get_width())
#...
# calculating flytime for one second..
Bird.waittime should be 1.0
self.dx = (self.target[0] - self.pos[0]) * 1.0 / Bird.waittime
self.dy = (self.target[1] - self.pos[1]) * 1.0 / Bird.waittime
self.lifetime = Bird.waittime + random.random() * .5 # a bit more livetime after the Bird appears
else: # red fragment explodes from the bird toward screen edge
#...
all the stuff for red Fragments
def update(self, seconds):
# ...
self.pos[0] += self.dx * seconds
self.pos[1] += self.dy * seconds
# ...
self.rect.centerx = round(self.pos[0],0)
self.rect.centery = round(self.pos[1],0)
- scrolling mountains
You will notice that at the start of the game, the moutains “walk” in from right to left.
All moutnains are instances of the same mountain>type parameter (making blue, red or pink mountains).
Most of the work in this>__ini__-method:
class Mountain(pygame.sprite.Sprite):
#...
def __init__(self, type):
self.type = type
if self.type == 1:
self._layer = -1
self.dx = -100
self.color = (0,0,255) # blue mountains, close
elif self.type == 2:
self._layer = -2
self.color = (200,0,255) # pink mountains, middle
self.dx = -75
else:
self._layer = -3
self.dx = -35
self.color = (255,0,0) # red mountains, far away
self.groups = allgroup, mountaingroup
pygame.sprite.Sprite.__init__(self, self.groups) # THE Line
#...
Maybe the most interesting part here is the creation of the actual mountain.
This is done with the help of the random.random() function (creates an decimal number between 0.0 and 1.0) and the pygame.draw.polygon-method.
On each mountain surface, a filled triangle (polygon) is created from the lower left corner to a corner in the middle (x/2) and at a random height (the moutain peak) and back to the lower right corner.
The syntax for pygame.draw.poligon is: pygame.draw.polygon(surface, color, pointlist, width=0)
class Mountain(pygame.sprite.Sprite):
#...
def __init__(self, type):
#...
self.dy = 0
x = 100 * self.type * 1.5
y = screen.get_height() / 2 + 50 * (self.type -1)
self.image = pygame.Surface((x,y))
self.image.set_colorkey((0,0,0)) # black is transparent
pygame.draw.polygon(self.image, self.color,
((0,y),
(0,y-10*self.type),
(x/2, int(random.random()*y/2)),
(x,y-10*self.type),
(x,y),
(9,y)),0) # width=0 fills the polygon
self.image.convert_alpha()
self.rect = self.image.get_rect()
Each mountain has a .parent attribute, set to False in the __ini__-method.
In the update-method of the moutain>type is created and placed directly to it's right side (yet invisible because outside the screen border).
If a mountain travels too far to the left side, it is killed.
class Mountain(pygame.sprite.Sprite):
#...
def update(self, time):
if self.rect.centerx + self.rect.width/2+10 < 0:
self.kill()
# create new mountains if necessary
if not self.parent:
if self.rect.centerx < screen.get_width():
self.parent = True
Mountain(self.type) # new Mountain coming from the right side
source code on github
To run this example you need:
file in folder download
016_layers.py pygame Download the whole Archive with all files from Github:
https://github.com/horstjens/ThePythonGameBook/archives/master
babytux.png
pygame/data
babytux_neg.png
pygame/data
claws.ogg
from Battle of Wesnoth pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/016_layers.py
Step 017 - Rotating, shooting, inheritance, physics
Time to play! The source code example below is an actual playable game, demonstrating several different concepts:
Trigonometric_functions to rotate objects
Inheritance to build>Elastic collision between to physical objects (birds, but reduced to physical disc's).
<note important>Horst: what are physical discs?</note>
gameplay
With the source code example below you can shoot down little penguins (again).
This time, you steer a fat penguin and can rotate and move him with the <key>w</key>,<key>a</key>,<key>s</key>,<key>d</key> keys.
The movement is relative to the facing of the fat penguin; by pressing <key>w</key> he will not move upwards, but instead forward depending on his actual rotation.
You can still move sidewards by pressing <key>q</key> and <key>r</key>.
To calculate the forward movement of a rotated object in a cartesian (x,y) coordinate system some Trigonometric_functions are used.
To make the game more interesting, some small penguins are also in the game.
The player can shoot at them (using the <key>SPACE</key> key) and collide with them but should avoid the fragments when a small penguin explodes.
If a small penguin reaches the ground, he get some random “fuel”1) and moves upward (negative dy) until the “fuel” runs out.
Gravity, that the player can turn on and off with the <key>g</key>, will suck penguins, shots and fragments down.
The small objects (penguins, shots) are pushed around by forces (boost, gravity, impact of shots and fragments or other penguins), leading to diagonal movement (dx and dy).
While the rotation of the fat penguin dedicate it's movement, the movement of the small objects dedicate their rotation.
The goal of the game is too shoot down as many small penguins while trying to reach a 100% hit ratio.
Each time one small penguin is killed a new one is created.
The ratio of hits / misses will be calculated by the computer.
The game ends if the gametime runs out or the player was hit by too much red fragments.
to tinker
change the constants (all in CAPITAL LETTER) like GRAVITY, FRICTION etc.
uncomment out-commented lines in Bird.areacheck to let birds bounce off walls
uncomment out-commented lines in Bird.speedcheck to introduce a general speed limit
give the small birds more “fuel” to fly higher: change self.boostmax in Bird.__init__
code discussion
- some trigonometry for pygame
How to calculate sine and cosine for angle x Radiand vs.
Grad: 360° = 2 * π
π (Pi) = 3.1418….
While python will take care of most mathematics involved in rotating sprites for you, it may be a good to refresh some school wisdom.
In this example games, those trigometric functions are used:
The sine: takes an angle (in radiant) as argument, returns the y coordinate
The cosine: takes an angle (in radiant) as argument, returns the x coordinate
The arctangent: takes a fraction as argument, returns an angle (in radiant)
As you can see in the drawing at the right side, sine is the vertical coordinate of a given point ( D in the diagram) on a unit circle2) while the cosine is the horizontal coordinate of the same point.
The relation between those coordinates (vertical / horizontal) equals the tangent of the angle.
The arctangent function is the inverse function of the tangent: arctangent takes the relation (y/x) as argument and returns the angle.
grad and radiant
There are several methods to measure the angle:
divide a full circle into 360 degrees (grad) or
divide a full circle into 2 times Pi 3)
While python's pygame module can handle basic rotation of sprites and surfaces using the 360 degree method, for calculating sine, cosine and arctangent, you need python's math module.
Math functions use radians.
Two small functions help here:
import math
def radians_to_degrees(radians):
return (radians / math.pi) * 180.0
def degrees_to_radians(degrees):
return degrees * (math.pi / 180.0)
- calculating direction for a given rotation
The player's>BigBird knows the rotation of the sprite and need the movement vectors dx and dy to calculate.
Here is the code, not-so important bits are omitted:
import math
GRAD = math.pi / 180
class BigBird(pygame.sprites.Sprites):
#...
def __init__(self):
pressedkeys = pygame.key.get_pressed()
self.ddx = 0.0
self.ddy = 0.0
if pressedkeys[pygame.K_w]: # forward
self.ddx = -math.sin(self.angle*GRAD)
self.ddy = -math.cos(self.angle*GRAD)
if pressedkeys[pygame.K_s]: # backward
self.ddx = +math.sin(self.angle*GRAD)
self.ddy = +math.cos(self.angle*GRAD)
if pressedkeys[pygame.K_e]: # right side
self.ddx = +math.cos(self.angle*GRAD)
self.ddy = -math.sin(self.angle*GRAD)
if pressedkeys[pygame.K_q]: # left side
self.ddx = -math.cos(self.angle*GRAD)
self.ddy = +math.sin(self.angle*GRAD)
#...
self.dx += self.ddx * self.speed
self.dy += self.ddy * self.speed
#...
self.pos[0] += self.dx * seconds
self.pos[1] += self.dy * seconds
#...
- calculating rotation for a given direction
On the other hand, if you know dx and dy and need the fitting angle, you can use this code:
class Bullet(pygame.sprite.Sprite):
#...
def update(self, time):
#...
#--------- rotate into direction of movement ------------
#--- calculate with math.atan ---
#if self.dx != 0 and self.dy!=0:
# ratio = self.dy / self.dx
# if self.dx > 0:
# self.angle = -90-math.atan(ratio)/math.pi*180.0 # in grad
# else:
# self.angle = 90-math.atan(ratio)/math.pi*180.0 # in grad
#--- or calculate with math.atan2 ---
self.angle = math.atan2(-self.dx, -self.dy)/math.pi*180.0
self.image = pygame.transform.rotozoom(self.image0,self.angle,1.0)
Using math.atan2 function instead of math.atan save some code lines.
You can view the documentation for the math module online at http://docs.python.org/library/math.html :
<note>
math.atan(x)
Return the arc tangent of x, in radians.
math.atan2(y, x)
Return atan(y / x), in radians.
The result is between -pi and pi.
The vector in the plane from the origin to point (x, y) makes
this angle with the positive X axis.
The point of atan2() is that the signs of both inputs are known
to it, so it can compute the correct quadrant for the angle.
For
example, atan(1) and atan2(1, 1) are both pi/4,
but atan2(-1, -1) is -3*pi/4.
</note>
- using>
In this code example exist 2 kinds of birds: The big (fat) BigBird and many smalle SmallBird's.
Both have a common parent>elastic collision
Inside the game's mainloop is a tiny “physic engine” in use:
It checks with a crashgroup if one bird is actually crashing into another bird.
If so, both birds move away from each other.
This could be done with less sophisticated code like in the previous examples, like by simply giving the crashbird's new random values for dx and dy.
However Lenoard Michlmayr was so nice to help me out here with some code for an elastic collision:
Note that to simplify the calculation, each bird is calculated as a disc.
Also in the very special case that there is no speed (like if one bird is “beamed” into another bird) some random values for dx and dy are created.
# ...
def elastic_collision(sprite1, sprite2):
"""elasitc collision between 2 sprites (calculated as disc's).
The function alters the dx and dy movement vectors of both sprites.
The sprites need the property .mass, .radius, .pos[0], .pos[1], .dx, dy
pos[0] is the x postion, pos[1] the y position"""
# here we do some physics: the elastic
# collision
#
# first we get the direction of the push.
# Let's assume that the sprites are disk
# shaped, so the direction of the force is
# the direction of the distance.
dirx = sprite1.pos[0] - sprite2.pos[0]
diry = sprite1.pos[1] - sprite2.pos[1]
#
# the velocity of the centre of mass
sumofmasses = sprite1.mass + sprite2.mass
sx = (sprite1.dx * sprite1.mass + sprite2.dx * sprite2.mass) / sumofmasses
sy = (sprite1.dy * sprite1.mass + sprite2.dy * sprite2.mass) / sumofmasses
# if we sutract the velocity of the centre
# of mass from the velocity of the sprite,
# we get it's velocity relative to the
# centre of mass.
And relative to the
# centre of mass, it looks just like the
# sprite is hitting a mirror.
#
bdxs = sprite2.dx - sx
bdys = sprite2.dy - sy
cbdxs = sprite1.dx - sx
cbdys = sprite1.dy - sy
# (dirx,diry) is perpendicular to the mirror
# surface.
We use the dot product to
# project to that direction.
distancesquare = dirx * dirx + diry * diry
if distancesquare == 0:
# no distance? this should not happen,
# but just in case, we choose a random
# direction
dirx = random.randint(0,11) - 5.5
diry = random.randint(0,11) - 5.5
distancesquare = dirx * dirx + diry * diry
dp = (bdxs * dirx + bdys * diry) # scalar product
dp /= distancesquare # divide by distance * distance.
cdp = (cbdxs * dirx + cbdys * diry)
cdp /= distancesquare
# We are done.
(dirx * dp, diry * dp) is
# the projection of the velocity
# perpendicular to the virtual mirror
# surface.
Subtract it twice to get the
# new direction.
#
# Only collide if the sprites are moving
# towards each other: dp > 0
if dp > 0:
sprite2.dx -= 2 * dirx * dp
sprite2.dy -= 2 * diry * dp
sprite1.dx -= 2 * dirx * cdp
sprite1.dy -= 2 * diry * cdp
The function is called with 2 sprites as arguments during the mainloop.
Note that the elastic_collision function has no return values but
instead manipulates the .dx and .dy properties (the movement vectors) of both sprites.
# ...
inside mainloop
# ------ collision detection
for bird in birdgroup: # test if a bird collides with another bird
bird.crashing = False # make bird NOT blue
# check the Bird.number to make sure the bird is not crashing with himself
if not bird.waiting: # do not check birds outside the screen
crashgroup = pygame.sprite.spritecollide(bird, birdgroup, False )
for crashbird in crashgroup: # test bird with other bird collision
if crashbird.number > bird.number: #avoid checking twice
bird.crashing = True # make bird blue
crashbird.crashing = True # make other bird blue
if not (bird.waiting or crashbird.waiting):
elastic_collision(crashbird, bird) # change dx and dy of both birds
source code on github
To run this example you need:
file in folder download
017_turning_and_physic.py pygame Download the whole Archive with all files from Github:
https://github.com/horstjens/ThePythonGameBook/archives/master
babytux.png
pygame/data
babytux_neg.png
pygame/data
claws.ogg
from Battle of Wesnoth pygame/data
wormhole.ogg pygame/data
bomb.ogg pygame/data
shoot.ogg pygame/data
beep.ogg pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/017_turning_and_physic.py
Step 018 - Mask and pixel perfect collision detection
- gameplay
In this variation of the previous game, you can toggle with the <key>c</key> key between the three different methods for collision detection:
collide_rect - the default method, and the fastest of all.
sprites need a self.rect attribute
collide_circle - slower but better looking.
sprites need a self.radius attribute
collide_mask - the slowest but most precise method.
sprites need a self.mask attribute, taken from the sprites image.
Fly the smaller penguin around (with <key>w</key> <key>a</key> <key>s</key> <key>d</key> <key>q</key> <key>e</key>, shoot at the big penguin with <key>space</key> and check the pattern of the yellow impact “wounds” depending of the different collide methods.
A bitmask is like an image with only two colours: collision-relevant and non-relevant.
Like an black / white photograph.
You can create your own bitmask but pygame has a command to create a bitmaks from an image:
pygame.mask.from_surface(Surface, threshold = 127) -> Mask
Note that if you rotate a sprite and rotate the sprite's image, you must create a new mask from the rotated image.
- collision dedection
#..
inside mainloop
elif event.key == pygame.K_c:
if collision == "rect":
collision = "circle"
elif collision == "circle":
collision = "mask"
elif collision == "mask":
collision = "rect"
screentext2.newmsg("collsion detection: %s" % collision)
# ...
# ------ collision detection
for bird in birdgroup:
#...
if collision == "rect":
crashgroup = pygame.sprite.spritecollide(bird, bulletgroup, False, pygame.sprite.collide_rect)
elif collision == "circle":
crashgroup = pygame.sprite.spritecollide(bird, bulletgroup, False, pygame.sprite.collide_circle)
elif collision == "mask":
crashgroup = pygame.sprite.spritecollide(bird, bulletgroup, False, pygame.sprite.collide_mask)
for ball in crashgroup: # test for collision with bullet
# ...
- problem: sprites overshooting each other
There is a common problem if you test very small, very fast sprites for collisions with small objects: the fast sprite is “teleporting” or overshooting over the obstacle, not triggering a collision detection.
Some quick solutions are:
use slower, bigger sprites and bigger obstacles
use a higher framerate
use a self.radius value of a sprite that is far bigger than the actual sprite.
Use this self.radius together with pygame.sprite.collide_circle for collision detection
experts: calculate if 2 vectors, originating from self.pos with self.dx,self.dy cross each others.
- what's new
The code is nearly the same code as in the previous example.
The Fragment>source code on github
To run this example you need:
file in folder download
018_perfect_collision_detection.py pygame Download the whole Archive with all files from Github:
https://github.com/horstjens/ThePythonGameBook/archives/master
babytux.png
pygame/data
crossmonster.png
pygame/data
xmonster.png
pygame/data
claws.ogg
from Battle of Wesnoth pygame/data
bomb.ogg pygame/data
shoot.ogg pygame/data
beep.ogg pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/018_perfect_collision_detection.py
Step 019 - Homing missiles
In this example game, two players can fire bullets and rockets at each other or at big nasty monsters.
Bullets have a short range, but steal hitpoints if hitting a player or a monster.
There are 2 different kind of rockets:
a “light”, weak damage, fast flying variant.
Short lifetime.
Can be shot down.
a “heavy”, heavy damage, slow flying “sliding” variant.
Longer lifetime.
Can not be shot down, but it's flightpath can be disturbed if hit.
Both types of rockets aim automatically toward the target.
While the “light” rockets move in the direction of their heading (boring), the “heavy” rockets “slide” like in open space, making more interesting flight patterns.
A player can store a maximum ammo of 32 rockets (see class Player, self.rocketsmax).
The first 16 rockets are light rockets, the others are heavy rockets.
Not shooting increase the stock of missiles of each player (see the blue rocketbar above each player)
If no more monsters are present, the players can fight each other (duel mode).
New monsters can be created my pressing <key>m</key>.
If both players are shot down by monsters, the monsters start fighting themselves (Overtime).
You can press <key>o</key> to get more overtime and watch the monsters fighting each other.
Monster states
Each 15 seconds, (see class Monster, self.hunttime) the monster has a chance to select a new target.
Each monster has a primitive State_machine, cycling between the three states “do nothing”, “shoot bullets at target” and “shoot rockets at target”.
Each “state” is exactly 3 seconds long.
This is the code line to see in what “state” or “phase” a monster currently is (inside class Monster, def update):
self.phase = self.phases[int(self.alivetime) % 3 ]
Self.alivetime is a variable counting the time (in seconds) of existence of a monster.
The %-sign is the modulo operator.
It doesn't return the result of a division, but instead the remainder.
As you can see in this example, the remainder cycles between 0 , 1 and 2 if the divisor is 3:
for x in range(31): # python2.x
print x, "divided by 3 =", x/3, "remainder:", x%3,"float result:", x/3.0
output:
0 divided by 3 = 0 remainder: 0 float result: 0.0
1 divided by 3 = 0 remainder: 1 float result: 0.333333333333
2 divided by 3 = 0 remainder: 2 float result: 0.666666666667
3 divided by 3 = 1 remainder: 0 float result: 1.0
4 divided by 3 = 1 remainder: 1 float result: 1.33333333333
5 divided by 3 = 1 remainder: 2 float result: 1.66666666667
...
classes
All>
additional resources
data019.tar.gz
source code on github
To run this example you need:
file in folder download
019_homing_missiles.py pygame Download the whole Archive with all files from Github:
https://github.com/horstjens/ThePythonGameBook/archives/master
player_red2.png pygame/data
player_blue2.png pygame/data
xmonster_s.png pygame/data
xmonster_fire_s.png pygame/data
xmonster_left_s.png pygame/data
xmonster_right_s.png pygame/data
claws.ogg pygame/data
wormhole.ogg pygame/data
bomb.ogg pygame/data
shoot.ogg pygame/data
beep.ogg pygame/data
explode.ogg pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/019_homing_missiles.py
Step 020 - Shooting bullets from the end of a cannon barrel
video
Video link: http://www.youtube.com/watch?v=SDsomsEWl7E
video
description
In this example, two tanks can be controlled by the players (using both hands), moving forward and backward and rotating.
Additionally, the turrets can rotate also.
The turrets can shoot bullets out of the tanks's main cannon (please admire the recoil effect) and the tanks can fire tracer rounds from machine guns.
Each gun has a machine gun at the turret and at its bow (see graphic at the right).
This source code examples teaches nothing new but demonstrate how to solve a specific problem: Creating bullet-sprites not at the center of it's launcher, but at the end (and some space away) from it.
The most obvious solution for such a problem would be to create the bullet at the center of it's launcher (the Tank) and use the Layer system to make sure the Tank is drawn on top of the bullet.
But if you have a fine eye you will notice some ugly effects: if you rotate a cannon fast enough, it will look like the bullet exits at the side of the cannon instead of at it's end.
Also creating one Sprite at the exact position of another sprite will trigger a collision detection, needing more code to make sure that a tank cannot shoot itself.
source code discussion
To deal with the problem of creating a bullet sprite at the exact end of a rotated cannon sprite, see the source code below.
All you need is a little knowledge of the math.sin and math.cos function (remember to transform grad into radiant), like explained in step017 - rotating, shooting, inheritance.
If you like complicated explanations: What you do here is creating a vector and rotating it to find the coordinate of a point (the musszle).
This is done in the methods calculate_origin of the Bullet and the Tracer>Bullet
For the Bullet, shooting out of the muzzle of the tanks main gun the problem is this: It's boss sprite, the Tank turret, is rotated by turretAngle.
Also the cannon is very long, nearly as long as the side of the Tank.
def calculate_origin(self):
# - spawn bullet at end of turret barrel instead tank center -
# cannon is around Tank.side long, calculatet from Tank center
# later subtracted 20 pixel from this distance
# so that bullet spawns closer to tank muzzle
self.pos[0] += math.cos(degrees_to_radians(self.boss.turretAngle)) * (Tank.side-20)
self.pos[1] += math.sin(degrees_to_radians(-self.boss.turretAngle)) * (Tank.side-20)
def kill(self): function in the Timebar sprite>pygame.sprite.Sprite>def kill(self) method.
As the name suggest, self.kill() removes the actual sprite from the screen and from all groups.
class Timebar(pygame.sprite.Sprite):
#..
def update(self, time):
self.rect.centery = self.rect.centery - 7 # each timebar kill itself when it leaves the screen
if self.rect.centery < 0:
self.kill() # remove the sprite from screen and from all groups
over writing kill
However, the more complicated Bird sprite>def kill(self): function. That is because I want to do some extra stuff before killing the sprite, like playing a sound effect and shattering fragments around the screen. Also in this case I want to remove the Bird sprite from a special dictionary where I store each Bird sprite and its individual number. Therefore, I overwrite thedef kill(self): function, do my special things and finally call pygame's kill method directly: pygame.sprite.Sprite.kill(self)
Big Badda Boom!
class Bird(pygame.sprite.Sprite):
#..
def kill(self):
"""because i want to do some special effects (sound, dictionary etc.)
before killing the Bird sprite i have to write my own kill(self)
function and finally call pygame.sprite.Sprite.kill(self)
to do the 'real' killing"""
cry.play() #play sound effect
for _ in range(random.randint(3,15)):
Fragment(self.pos) # create Fragment sprites
Bird.birds[self.number] = None # kill Bird in sprite dictionary
pygame.sprite.Sprite.kill(self) # kill the actual Bird
Exploding fragments
The Fragment>2). Note that you can toggle gravity by pressing <key>g</key> during the game. The effect of the gravity is handled in the update method of the Fragment>class Fragment(pygame.sprite.Sprite): """a fragment of an exploding Bird""" gravity = True # fragments fall down ? def __init__(self, pos): pygame.sprite.Sprite.__init__(self, self.groups) self.pos = [0.0,0.0] self.pos[0] = pos[0] self.pos[1] = pos[1] #... self.dx = random.randint(-self.fragmentmaxspeed,self.fragmentmaxspeed) self.dy = random.randint(-self.fragmentmaxspeed,self.fragmentmaxspeed) def update(self, seconds): #... self.pos[0] += self.dx * seconds self.pos[1] += self.dy * seconds if Fragment.gravity: self.dy += FORCE_OF_GRAVITY # gravity suck fragments down self.rect.centerx = round(self.pos[0],0) self.rect.centery = round(self.pos[1],0)Layers
By default, pygame will blit the sprites in the order the sprites are added. IF you prefer precise order of drawing the sprites (like the mouse pointer always before all other sprites) you can do two things: use severalclear, update and draw commands, one for each sprite group:
use the pygame.sprite-LayeredUpdates group instead of a sprite group and set a default layer for each group, like in the code example below:
# LayeredUpdates instead of group to draw in correct order
allgroup = pygame.sprite.LayeredUpdates() # important
#assign default groups to each sprite>
Livebar.groups = bargroup, allgroup
Timebar.groups = bargroup, allgroup
Bird.groups = birdgroup, allgroup
Fragment.groups = fragmentgroup, allgroup
BirdCatcher.groups = stuffgroup, allgroup
#assign default layer for each sprite (lower numer is background)
BirdCatcher._layer = 5 # top foreground
Fragment._layer = 4
Timebar._layer = 3
Bird._layer = 2
Livebar._layer = 1 #background
More about layers in the next step.
putting the whole game inside a function
You may have noticed that the whole game sits inside a function calleddef game():.
This is useful when we later make a game menu that starts the game.
Because it will be sensible to split the game code into a menu.py and a startgame.py file.
The menu.py file will import the startgame and call it when the user chooses the menu option.
To be more precise, the menu.py file will start a single function inside the startgame.py file.
(If there is no meaningful function defined inside startgame.py the menu file would start startgame.py right after importing it, before displaying a menu and waiting for the user's choice).
python modules
We have no menu.py (yet) but we can prepare for it by stuffing all interesting parts (shooting up penguins etc) inside a function - let's call the function game() (see below). But how do we start the game directly? For that, we check the internal python variable __name__. In this variable, python stores the name of the python module that imported the actual python program. If we started the actual python program directly (from the terminal or from the python editor), then this variable gets the value __main__ from python. Therefore you will find in many python modules3) those lines: def game(): #.. all the interesting stuff if __name__ == "__main__": print "i was started directly and will start game()" game() # start the interesting stuff else: print "i am imported by",__name__, "and will do nothing at the moment"source code on github
To run this example you need:pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master babytux.png
pygame/data
babytux_neg.png 
pygame/data
claws.ogg from Battle of Wesnoth
pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/015_more_sprites.py
click reload in your browser if you see no code here:
Step 016 - LayeredUpdates and Parallax scrolling
gameplay
The source code example below is not much of a game, but it demonstrates the uses of layers for sprites and Parallax_scrolling (the mountains).
Also, you can hide penguins behind blocks and mountains.
Additionally, you can aim with the mouse pointer and press <key>p</key> to print out information about the layers (at the text console).
Trivia:
According to wikipedia, Parallax scrolling was first introduced to computer games by the arcade game Moon_Patrol 1982.
The mountains (and in higher levels, futuristic buildings) moved at different speed to create the illusion of a side-scrolling computer game.
proposals to tinker:
Change the layer of the three types of>pevious step, let the Birds change _layer by random and explode them by mouseclick !
code discussion
- layers
Do you remember the sprite groups from the last step ? Sprite groups are basically containers where the sprites “live” in. As soon as a sprite is killed (by it'skill() functoin) the sprite is not also removed from the screen but also from all containers holding it.
In the last two steps, i had two uses for sprite groups:
The allgroup (every sprite was member of this group), to clear, draw, and update all sprites from within the main loop
other groups like birdgroup, used to check each sprite in this group for collision detection (crashgroup)
You will note that there exist different variants of sprite groups:
the old spritegroup
the newer LayeredUpdate group
When using pygame.sprite.Layeredupdate() instead of pygame.sprite.Group() you can give each sprite a variable _layer as well as a variable groups to influence the drawing order of the sprite.
In the previous step those variables were defined outside the sprite>__init__(self) method of each sprite>
The sprite groups must exist (be defined in the mainloop) before you can assign sprites to the groups.
That means, inside the mainloop, before you create a Bird sprite or assign images to the Bird>before you call pygame.sprite.Sprite.__init__(self, *groups):
<note>#… means that i let away some not so important code lines</note>
class Bird(pygame.sprite.Sprite):
#...
def __init__(self, startpos=screen.get_rect().center):
self.groups = birdgroup, allgroup # assign groups BEFORE calling pygame.sprite.Sprite.__init__
self._layer = 7 # assign _layer BEFORE calling pygame.sprite.Sprite.__init__
pygame.sprite.Sprite.__init__(self, self.groups ) #call parent>
self.pos = starpos
# ...
# define sprite groups
birdgroup = bargroup = pygame.sprite.Group() # simple group for collision detection
allgroup = pygame.sprite.LayeredUpdates() # more sophisticated and modern group
# assign images to the Bird>
Bird()
pygame.sprite.LayeredUpdates
please see the official pygame doumentation at: http://www.pygame.org/docs/ref/sprite.html#pygame.sprite.LayeredUpdateschanging layers
The cool things about layers is: you can change them even at runtime, to place sprites more in the foreground or more in the background (see code example below). The change_layer method does exaclty that. Important: you need only to change the layer of the LayeredUpdates-group that actually draws the sprites on the screen. In the code example below, this is the allgroup. (Special thanks to Gummbum for helping me out here). Because i want only to change the layer of the Bird sprites and their Lifebar sprites i loop over all sprites in the groups birdgroup and bargroup. Each Bird sprite is a member of the allgroup as well as of the birdgroup. Each Lifebar sprite is a member of the allgroup as well as of the bargroup. if pygame.mouse.get_pressed()[0]: if birdlayer < 10: birdlayer += 1 cooldowntime = .5 # seconds cry.play() for bird in birdgroup: allgroup.change_layer(bird, birdlayer) # allgroup draws the sprite for bar in bargroup: allgroup.change_layer(bar, birdlayer) # allgroup draws the sprite- Textsprite
Up to now, i blitted all text to the screen or to the background with the write function. In this example, you will see a new>Text, also printing a msg to the screen. The Text sprite has no advantages over blitting directly to the background yet, but you can use it later to change the _layer of the Text sprite or if you want the Text sprite to move around. Note that the>newmsg to update the displaying text string. def newmsg(self, birdlayer): self.image = write("current Bird _layer = %i" % birdlayer) self.rect = self.image.get_rect() self.rect.center = (screen.get_width()/2,10)- waiting Birds
Take a look at the Bird>Bird.waittime indicating how long a Bird should stay “invisible”. Instead of messing around with drawing and not drawing, during his “invisible” waittime, each bird is simply teleported to the position (-100,-100), that is outside your screen. If the waittime is over, the Bird sprite is teleported to his Bird.pos position and act like a normal Bird sprite - speeding around, crashing into walls and other birds, exploding. Class Bird(pygame.sprite.Sprite): waittime = 1.0 #seconds #... def update(self, seconds): #---make Bird only visible after waiting time self.lifetime += seconds if self.lifetime > (self.waittime) and self.waiting: self.newspeed() self.waiting = False self.rect.centerx = round(self.pos[0],0) self.rect.centery = round(self.pos[1],0) if self.waiting: self.rect.center = (-100,-100) else: # speedcheck #.. all the other things But why the waittime ? The answer is a modification to the Fragment>def __init__(self, layer=4): #... Lifebar(self.number) #create a Lifebar for this Bird. # starting implosion of blue fragments for _ in range(8): Fragment(self.pos, True) See the for loop ? I simply wanted 8 (blue) Fragments, so i do not use an variable like a or b or x inside the for loop but simply an underscore. The True parameter in the Fragment>dual-use Fragments The fragment>if-else construct. The new part is only valid for “bluefrag” Fragments. After choosing per random from where (screen edge) the Fragment start, self.dx and self.dy are calculated… The Fragment should fly from the screen edge toward the position of the Bird sprite (self.target). But how fast does the fragment fly ? Because in the update method of the fragment>unit of a sprite is measured in pixel per second. Meaning each blue sprite will need exactly one second to travel from it's origin to the Bird sprite position. But what if the waittime for each Birdsprite is 2 seconds ? or just a half second ? For this reason, dx and dy are multiplied by the factor ( 1.0 / Bird.waittime). So if the Bird waits 2 seconds before appearing, the blue Fragments have more time and should travel slower: 1.0 / 2.0 = 0.5, the speed is reduced. On the other hand, if the waittime is shorter (say 0.5 seconds) the Fragments should fly faster: ( 1.0 / 0.5 = 2); dx and dy is doubled. For aesthetic reasons, i allow the blue Fragments to live up to a half second after reaching their target by adding to self.lifetime a value between 0 and 0.5:random.random() * 0.5.
Random.random() creates a float value between 0 and 1.
class Fragment(pygame.sprite.Sprite):
#...
def __init__(self, pos, bluefrag = False):
#...
self.bluefrag = bluefrag
self.pos=[0.0,0.0]
self.target = pos
if self.bluefrag: # blue frament implodes from screen edge toward Bird
self.color = (0,0,random.randint(25,255)) # blue
self.side = random.randint(1,4)
if self.side == 1: # left side
self.pos[0] = 0
self.pos[1] = random.randint(0,screen.get_height())
elif self.side == 2: # top
self.pos[0] = random.randint(0,screen.get_width())
#...
# calculating flytime for one second..
Bird.waittime should be 1.0
self.dx = (self.target[0] - self.pos[0]) * 1.0 / Bird.waittime
self.dy = (self.target[1] - self.pos[1]) * 1.0 / Bird.waittime
self.lifetime = Bird.waittime + random.random() * .5 # a bit more livetime after the Bird appears
else: # red fragment explodes from the bird toward screen edge
#...
all the stuff for red Fragments
def update(self, seconds):
# ...
self.pos[0] += self.dx * seconds
self.pos[1] += self.dy * seconds
# ...
self.rect.centerx = round(self.pos[0],0)
self.rect.centery = round(self.pos[1],0)
- scrolling mountains
You will notice that at the start of the game, the moutains “walk” in from right to left. All moutnains are instances of the same mountain>type parameter (making blue, red or pink mountains). Most of the work in this>__ini__-method: class Mountain(pygame.sprite.Sprite): #... def __init__(self, type): self.type = type if self.type == 1: self._layer = -1 self.dx = -100 self.color = (0,0,255) # blue mountains, close elif self.type == 2: self._layer = -2 self.color = (200,0,255) # pink mountains, middle self.dx = -75 else: self._layer = -3 self.dx = -35 self.color = (255,0,0) # red mountains, far away self.groups = allgroup, mountaingroup pygame.sprite.Sprite.__init__(self, self.groups) # THE Line #... Maybe the most interesting part here is the creation of the actual mountain. This is done with the help of the random.random() function (creates an decimal number between 0.0 and 1.0) and thepygame.draw.polygon-method.
On each mountain surface, a filled triangle (polygon) is created from the lower left corner to a corner in the middle (x/2) and at a random height (the moutain peak) and back to the lower right corner.
The syntax for pygame.draw.poligon is: pygame.draw.polygon(surface, color, pointlist, width=0)
class Mountain(pygame.sprite.Sprite):
#...
def __init__(self, type):
#...
self.dy = 0
x = 100 * self.type * 1.5
y = screen.get_height() / 2 + 50 * (self.type -1)
self.image = pygame.Surface((x,y))
self.image.set_colorkey((0,0,0)) # black is transparent
pygame.draw.polygon(self.image, self.color,
((0,y),
(0,y-10*self.type),
(x/2, int(random.random()*y/2)),
(x,y-10*self.type),
(x,y),
(9,y)),0) # width=0 fills the polygon
self.image.convert_alpha()
self.rect = self.image.get_rect()
Each mountain has a .parent attribute, set to False in the __ini__-method.
In the update-method of the moutain>type is created and placed directly to it's right side (yet invisible because outside the screen border).
If a mountain travels too far to the left side, it is killed.
class Mountain(pygame.sprite.Sprite):
#...
def update(self, time):
if self.rect.centerx + self.rect.width/2+10 < 0:
self.kill()
# create new mountains if necessary
if not self.parent:
if self.rect.centerx < screen.get_width():
self.parent = True
Mountain(self.type) # new Mountain coming from the right side
source code on github
To run this example you need:pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master babytux.png
pygame/data
babytux_neg.png pygame/data
claws.ogg from Battle of Wesnoth
pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/016_layers.py
Step 017 - Rotating, shooting, inheritance, physics
Time to play! The source code example below is an actual playable game, demonstrating several different concepts: Trigonometric_functions to rotate objects Inheritance to build>Elastic collision between to physical objects (birds, but reduced to physical disc's). <note important>Horst: what are physical discs?</note>gameplay
With the source code example below you can shoot down little penguins (again).
This time, you steer a fat penguin and can rotate and move him with the <key>w</key>,<key>a</key>,<key>s</key>,<key>d</key> keys.
The movement is relative to the facing of the fat penguin; by pressing <key>w</key> he will not move upwards, but instead forward depending on his actual rotation.
You can still move sidewards by pressing <key>q</key> and <key>r</key>.
To calculate the forward movement of a rotated object in a cartesian (x,y) coordinate system some Trigonometric_functions are used.
To make the game more interesting, some small penguins are also in the game.
The player can shoot at them (using the <key>SPACE</key> key) and collide with them but should avoid the fragments when a small penguin explodes.
If a small penguin reaches the ground, he get some random “fuel”1) and moves upward (negative dy) until the “fuel” runs out.
Gravity, that the player can turn on and off with the <key>g</key>, will suck penguins, shots and fragments down.
The small objects (penguins, shots) are pushed around by forces (boost, gravity, impact of shots and fragments or other penguins), leading to diagonal movement (dx and dy).
While the rotation of the fat penguin dedicate it's movement, the movement of the small objects dedicate their rotation.
The goal of the game is too shoot down as many small penguins while trying to reach a 100% hit ratio.
Each time one small penguin is killed a new one is created.
The ratio of hits / misses will be calculated by the computer.
The game ends if the gametime runs out or the player was hit by too much red fragments.
to tinker
change the constants (all in CAPITAL LETTER) like GRAVITY, FRICTION etc. uncomment out-commented lines inBird.areacheck to let birds bounce off walls
uncomment out-commented lines in Bird.speedcheck to introduce a general speed limit
give the small birds more “fuel” to fly higher: change self.boostmax in Bird.__init__
code discussion
- some trigonometry for pygame
How to calculate sine and cosine for angle x Radiand vs.
Grad: 360° = 2 * π π (Pi) = 3.1418…. While python will take care of most mathematics involved in rotating sprites for you, it may be a good to refresh some school wisdom. In this example games, those trigometric functions are used: The sine: takes an angle (in radiant) as argument, returns the y coordinate The cosine: takes an angle (in radiant) as argument, returns the x coordinate The arctangent: takes a fraction as argument, returns an angle (in radiant) As you can see in the drawing at the right side, sine is the vertical coordinate of a given point ( D in the diagram) on a unit circle2) while the cosine is the horizontal coordinate of the same point. The relation between those coordinates (vertical / horizontal) equals the tangent of the angle. The arctangent function is the inverse function of the tangent: arctangent takes the relation (y/x) as argument and returns the angle.
grad and radiant
There are several methods to measure the angle: divide a full circle into 360 degrees (grad) or divide a full circle into 2 times Pi 3) While python's pygame module can handle basic rotation of sprites and surfaces using the 360 degree method, for calculating sine, cosine and arctangent, you need python's math module. Math functions use radians. Two small functions help here: import math def radians_to_degrees(radians): return (radians / math.pi) * 180.0 def degrees_to_radians(degrees): return degrees * (math.pi / 180.0)- calculating direction for a given rotation
The player's>BigBird knows the rotation of the sprite and need the movement vectorsdx and dy to calculate.
Here is the code, not-so important bits are omitted:
import math
GRAD = math.pi / 180
class BigBird(pygame.sprites.Sprites):
#...
def __init__(self):
pressedkeys = pygame.key.get_pressed()
self.ddx = 0.0
self.ddy = 0.0
if pressedkeys[pygame.K_w]: # forward
self.ddx = -math.sin(self.angle*GRAD)
self.ddy = -math.cos(self.angle*GRAD)
if pressedkeys[pygame.K_s]: # backward
self.ddx = +math.sin(self.angle*GRAD)
self.ddy = +math.cos(self.angle*GRAD)
if pressedkeys[pygame.K_e]: # right side
self.ddx = +math.cos(self.angle*GRAD)
self.ddy = -math.sin(self.angle*GRAD)
if pressedkeys[pygame.K_q]: # left side
self.ddx = -math.cos(self.angle*GRAD)
self.ddy = +math.sin(self.angle*GRAD)
#...
self.dx += self.ddx * self.speed
self.dy += self.ddy * self.speed
#...
self.pos[0] += self.dx * seconds
self.pos[1] += self.dy * seconds
#...
- calculating rotation for a given direction
On the other hand, if you know dx and dy and need the fitting angle, you can use this code: class Bullet(pygame.sprite.Sprite): #... def update(self, time): #... #--------- rotate into direction of movement ------------ #--- calculate with math.atan --- #if self.dx != 0 and self.dy!=0: # ratio = self.dy / self.dx # if self.dx > 0: # self.angle = -90-math.atan(ratio)/math.pi*180.0 # in grad # else: # self.angle = 90-math.atan(ratio)/math.pi*180.0 # in grad #--- or calculate with math.atan2 --- self.angle = math.atan2(-self.dx, -self.dy)/math.pi*180.0 self.image = pygame.transform.rotozoom(self.image0,self.angle,1.0) Using math.atan2 function instead of math.atan save some code lines. You can view the documentation for the math module online at http://docs.python.org/library/math.html : <note> math.atan(x) Return the arc tangent of x, in radians. math.atan2(y, x) Return atan(y / x), in radians. The result is between -pi and pi. The vector in the plane from the origin to point (x, y) makes this angle with the positive X axis. The point of atan2() is that the signs of both inputs are known to it, so it can compute the correct quadrant for the angle. For example, atan(1) and atan2(1, 1) are both pi/4, but atan2(-1, -1) is -3*pi/4. </note>- using>
In this code example exist 2 kinds of birds: The big (fat) BigBird and many smalle SmallBird's.
Both have a common parent>elastic collision
Inside the game's mainloop is a tiny “physic engine” in use:
It checks with a crashgroup if one bird is actually crashing into another bird.
If so, both birds move away from each other.
This could be done with less sophisticated code like in the previous examples, like by simply giving the crashbird's new random values for dx and dy.
However Lenoard Michlmayr was so nice to help me out here with some code for an elastic collision:
Note that to simplify the calculation, each bird is calculated as a disc.
Also in the very special case that there is no speed (like if one bird is “beamed” into another bird) some random values for dx and dy are created.
# ...
def elastic_collision(sprite1, sprite2):
"""elasitc collision between 2 sprites (calculated as disc's).
The function alters the dx and dy movement vectors of both sprites.
The sprites need the property .mass, .radius, .pos[0], .pos[1], .dx, dy
pos[0] is the x postion, pos[1] the y position"""
# here we do some physics: the elastic
# collision
#
# first we get the direction of the push.
# Let's assume that the sprites are disk
# shaped, so the direction of the force is
# the direction of the distance.
dirx = sprite1.pos[0] - sprite2.pos[0]
diry = sprite1.pos[1] - sprite2.pos[1]
#
# the velocity of the centre of mass
sumofmasses = sprite1.mass + sprite2.mass
sx = (sprite1.dx * sprite1.mass + sprite2.dx * sprite2.mass) / sumofmasses
sy = (sprite1.dy * sprite1.mass + sprite2.dy * sprite2.mass) / sumofmasses
# if we sutract the velocity of the centre
# of mass from the velocity of the sprite,
# we get it's velocity relative to the
# centre of mass.
And relative to the
# centre of mass, it looks just like the
# sprite is hitting a mirror.
#
bdxs = sprite2.dx - sx
bdys = sprite2.dy - sy
cbdxs = sprite1.dx - sx
cbdys = sprite1.dy - sy
# (dirx,diry) is perpendicular to the mirror
# surface.
We use the dot product to
# project to that direction.
distancesquare = dirx * dirx + diry * diry
if distancesquare == 0:
# no distance? this should not happen,
# but just in case, we choose a random
# direction
dirx = random.randint(0,11) - 5.5
diry = random.randint(0,11) - 5.5
distancesquare = dirx * dirx + diry * diry
dp = (bdxs * dirx + bdys * diry) # scalar product
dp /= distancesquare # divide by distance * distance.
cdp = (cbdxs * dirx + cbdys * diry)
cdp /= distancesquare
# We are done.
(dirx * dp, diry * dp) is
# the projection of the velocity
# perpendicular to the virtual mirror
# surface.
Subtract it twice to get the
# new direction.
#
# Only collide if the sprites are moving
# towards each other: dp > 0
if dp > 0:
sprite2.dx -= 2 * dirx * dp
sprite2.dy -= 2 * diry * dp
sprite1.dx -= 2 * dirx * cdp
sprite1.dy -= 2 * diry * cdp
The function is called with 2 sprites as arguments during the mainloop.
Note that the elastic_collision function has no return values but
instead manipulates the .dx and .dy properties (the movement vectors) of both sprites.
# ...
inside mainloop
# ------ collision detection
for bird in birdgroup: # test if a bird collides with another bird
bird.crashing = False # make bird NOT blue
# check the Bird.number to make sure the bird is not crashing with himself
if not bird.waiting: # do not check birds outside the screen
crashgroup = pygame.sprite.spritecollide(bird, birdgroup, False )
for crashbird in crashgroup: # test bird with other bird collision
if crashbird.number > bird.number: #avoid checking twice
bird.crashing = True # make bird blue
crashbird.crashing = True # make other bird blue
if not (bird.waiting or crashbird.waiting):
elastic_collision(crashbird, bird) # change dx and dy of both birds
source code on github
To run this example you need:pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master babytux.png
pygame/data
babytux_neg.png pygame/data
claws.ogg from Battle of Wesnoth
pygame/data
wormhole.ogg pygame/data
bomb.ogg pygame/data
shoot.ogg pygame/data
beep.ogg pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/017_turning_and_physic.py
Step 018 - Mask and pixel perfect collision detection
- gameplay
In this variation of the previous game, you can toggle with the <key>c</key> key between the three different methods for collision detection:
collide_rect - the default method, and the fastest of all.
sprites need a self.rect attribute
collide_circle - slower but better looking.
sprites need a self.radius attribute
collide_mask - the slowest but most precise method.
sprites need a self.mask attribute, taken from the sprites image.
Fly the smaller penguin around (with <key>w</key> <key>a</key> <key>s</key> <key>d</key> <key>q</key> <key>e</key>, shoot at the big penguin with <key>space</key> and check the pattern of the yellow impact “wounds” depending of the different collide methods.
A bitmask is like an image with only two colours: collision-relevant and non-relevant.
Like an black / white photograph.
You can create your own bitmask but pygame has a command to create a bitmaks from an image:
pygame.mask.from_surface(Surface, threshold = 127) -> Mask
Note that if you rotate a sprite and rotate the sprite's image, you must create a new mask from the rotated image.
- collision dedection
#.. inside mainloop elif event.key == pygame.K_c: if collision == "rect": collision = "circle" elif collision == "circle": collision = "mask" elif collision == "mask": collision = "rect" screentext2.newmsg("collsion detection: %s" % collision) # ... # ------ collision detection for bird in birdgroup: #... if collision == "rect": crashgroup = pygame.sprite.spritecollide(bird, bulletgroup, False, pygame.sprite.collide_rect) elif collision == "circle": crashgroup = pygame.sprite.spritecollide(bird, bulletgroup, False, pygame.sprite.collide_circle) elif collision == "mask": crashgroup = pygame.sprite.spritecollide(bird, bulletgroup, False, pygame.sprite.collide_mask) for ball in crashgroup: # test for collision with bullet # ...- problem: sprites overshooting each other
There is a common problem if you test very small, very fast sprites for collisions with small objects: the fast sprite is “teleporting” or overshooting over the obstacle, not triggering a collision detection. Some quick solutions are: use slower, bigger sprites and bigger obstacles use a higher framerate use a self.radius value of a sprite that is far bigger than the actual sprite. Use this self.radius together with pygame.sprite.collide_circle for collision detection experts: calculate if 2 vectors, originating from self.pos with self.dx,self.dy cross each others.- what's new
The code is nearly the same code as in the previous example.
The Fragment>source code on github
To run this example you need:
pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master babytux.png
pygame/data
crossmonster.png 
pygame/data
xmonster.png 
pygame/data
claws.ogg from Battle of Wesnoth
pygame/data
bomb.ogg pygame/data
shoot.ogg pygame/data
beep.ogg pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/018_perfect_collision_detection.py
Step 019 - Homing missiles
In this example game, two players can fire bullets and rockets at each other or at big nasty monsters.
Bullets have a short range, but steal hitpoints if hitting a player or a monster.
There are 2 different kind of rockets:
a “light”, weak damage, fast flying variant.
Short lifetime.
Can be shot down.
a “heavy”, heavy damage, slow flying “sliding” variant.
Longer lifetime.
Can not be shot down, but it's flightpath can be disturbed if hit.
Both types of rockets aim automatically toward the target.
While the “light” rockets move in the direction of their heading (boring), the “heavy” rockets “slide” like in open space, making more interesting flight patterns.
A player can store a maximum ammo of 32 rockets (see class Player, self.rocketsmax).
The first 16 rockets are light rockets, the others are heavy rockets.
Not shooting increase the stock of missiles of each player (see the blue rocketbar above each player)
If no more monsters are present, the players can fight each other (duel mode).
New monsters can be created my pressing <key>m</key>.
If both players are shot down by monsters, the monsters start fighting themselves (Overtime).
You can press <key>o</key> to get more overtime and watch the monsters fighting each other.
Monster states
Each 15 seconds, (see class Monster, self.hunttime) the monster has a chance to select a new target. Each monster has a primitive State_machine, cycling between the three states “do nothing”, “shoot bullets at target” and “shoot rockets at target”. Each “state” is exactly 3 seconds long. This is the code line to see in what “state” or “phase” a monster currently is (inside class Monster, def update): self.phase = self.phases[int(self.alivetime) % 3 ] Self.alivetime is a variable counting the time (in seconds) of existence of a monster. The %-sign is the modulo operator. It doesn't return the result of a division, but instead the remainder. As you can see in this example, the remainder cycles between 0 , 1 and 2 if the divisor is 3: for x in range(31): # python2.x print x, "divided by 3 =", x/3, "remainder:", x%3,"float result:", x/3.0 output: 0 divided by 3 = 0 remainder: 0 float result: 0.0 1 divided by 3 = 0 remainder: 1 float result: 0.333333333333 2 divided by 3 = 0 remainder: 2 float result: 0.666666666667 3 divided by 3 = 1 remainder: 0 float result: 1.0 4 divided by 3 = 1 remainder: 1 float result: 1.33333333333 5 divided by 3 = 1 remainder: 2 float result: 1.66666666667 ...classes
All>
additional resources
data019.tar.gzsource code on github
To run this example you need:pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master player_red2.png
pygame/data
player_blue2.png pygame/data
xmonster_s.png pygame/data
xmonster_fire_s.png pygame/data
xmonster_left_s.png pygame/data
xmonster_right_s.png pygame/data
claws.ogg pygame/data
wormhole.ogg pygame/data
bomb.ogg pygame/data
shoot.ogg pygame/data
beep.ogg pygame/data
explode.ogg pygame/data
View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/019_homing_missiles.py
Step 020 - Shooting bullets from the end of a cannon barrel
video
Video link: http://www.youtube.com/watch?v=SDsomsEWl7E videodescription
In this example, two tanks can be controlled by the players (using both hands), moving forward and backward and rotating.
Additionally, the turrets can rotate also.
The turrets can shoot bullets out of the tanks's main cannon (please admire the recoil effect) and the tanks can fire tracer rounds from machine guns.
Each gun has a machine gun at the turret and at its bow (see graphic at the right).
This source code examples teaches nothing new but demonstrate how to solve a specific problem: Creating bullet-sprites not at the center of it's launcher, but at the end (and some space away) from it. The most obvious solution for such a problem would be to create the bullet at the center of it's launcher (the Tank) and use the Layer system to make sure the Tank is drawn on top of the bullet. But if you have a fine eye you will notice some ugly effects: if you rotate a cannon fast enough, it will look like the bullet exits at the side of the cannon instead of at it's end. Also creating one Sprite at the exact position of another sprite will trigger a collision detection, needing more code to make sure that a tank cannot shoot itself.
source code discussion
To deal with the problem of creating a bullet sprite at the exact end of a rotated cannon sprite, see the source code below. All you need is a little knowledge of the math.sin and math.cos function (remember to transform grad into radiant), like explained in step017 - rotating, shooting, inheritance. If you like complicated explanations: What you do here is creating a vector and rotating it to find the coordinate of a point (the musszle). This is done in the methods calculate_origin of the Bullet and the Tracer>BulletTracer
For the Tracer (shooting out of the red bow rectangle of the tank) the point of launching is the little red rectangle in the front of the Tank. Because the Tank can rotate it's turret independent of the tank's own rotation, the important variable here is tankangle. The bow machine gun rectangle is not so much distanced from the Tank's center (side/2), but it is a bit on the left side. De facto i created here an 2D-Vector, 30° from the Tank's center and with the lenght of Tank.side/2. This vector is rotated with the tankAngle to find the coordinates of the point of origin for the Tracer round. def calculate_origin(self): """overwriting because another point of origin is needed""" # - spawn bullet at end of bow rect (and some extra distance) # the bow rect is in the middle -left from the tank center # calculatet by going -30° from the Tank center for the half tank side self.pos[0] += math.cos(degrees_to_radians(30+self.boss.tankAngle)) * (Tank.side/2) self.pos[1] += math.sin(degrees_to_radians(-30-self.boss.tankAngle)) * (Tank.side/2)keyboard overflow problem
While playing you will notice that sometimes some keyboard command seem to be ignored when you press several keys at once. It also can happen that if you press some combinations of more than 2 keys at the same time, it seems like a different key was pressed (ghost) To test it out: run example tankdemo03.py from below. press <key>w</key> and <key>s</key> to move the tank forward and back (works) press <key>w</key> and <key>s</key> at the same time, to stop the tank movement (works also) if you press <key>d</key> and <key>a</key> at the same time, the tank does not rotate (correctly) while pressing <key>d</key> and <key>a</key>, also press <key>w</key> or <key>s</key>. This time, it works (the tank does not rotate, but moves forward & back). In this case, 3 keys are pressed simultaneously and interpreted correctly. the combinations <key>w</key> and <key>a</key> , <key>s</key> and <key>a</key>, <key>w</key> and <key>d</key>, <key>s</key> and <key>d</key> all work, letting the tank rotate and move at the same time while pressing <key>w</key> and <key>s</key> at the same time (no movement), also press <key>d</key> to rotate the tank. This does not work ! Worse, the bow mg start firing, but you have not pressed <key>LCTRL</key> ! (ghost key effect) This phenomenon is well known among game designer. Ultimately it is caused by the way how keyboards are constructed. A possible solution is to design games with fewer keys to be pressed and use keys like SHIFT, ALT and CTRL because those keys are better recognized by design of the hardware. Also think about accepting input from Mouse and Joysticks (see pygame documentation) or writing network-games where each player has his own keyboard. See the glossary entry keyboard for more information. You will find there a very cool program1) to test out how many keys you can press at the same time without confusing your keyboard. keyboardadditional resources
no additional resources necessary.classchart
ideas
<note tip>Can you add sound effects to the Tankdemo ? See step010 - using sound and music</note> <note tip>Can you create moving or stationary practice targets for the Tankdemo ? See step017 - rotating, shooting...</note>source code on github
To run this example you need:pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/020_shooting_from_tank.py
Step 021 - Rotating toward a target
video
Video link: http://www.youtube.com/watch?v=nfaOmkhK-V0 Bug: tank angle and turret angle is swapped in the video. The source code below is correct. videodescription
In the code example below, you can move both tanks (as in step020) or you can “teleport” the yellow tank toward the mouse pointer by clicking the left mouse button.
The blue tank will rotate it's turrent toward the position of the yellow tank.
The problem is to decide in wich direction the turret should move.
source code discussion
In the code example below this is solved by the Tank>aim_at_player. Note that the angle diff can result in values > than 360, so the result is divided by 360 and its modulo1), is saved. You will also note that very few lines are altered since step020, mostly the tank> def aim_at_player(self, targetnumber=0): #print "my pos: x:%.1f y:%.1f " % ( self.pos[0], self.pos[1]) #print "his pos: x:%.1f y:%.1f " % ( Tank.book[0].pos[0], Tank.book[0].pos[1]) deltax = Tank.book[targetnumber].pos[0] - self.pos[0] deltay = Tank.book[targetnumber].pos[1] - self.pos[1] angle = math.atan2(-deltax, -deltay)/math.pi*180.0 diff = (angle - self.turretAngle - 90) %360 #reset at 360 if diff == 0: self.turndirection = 0 elif diff > 180: self.turndirection = 1 else: self.turndirection = -1 return diff And also the mainloop's event handler is expanded. He now checks the MOUSEBUTTON event to teleport player1 tank around: # teleport player1 tank if left mousebutton is pressed elif event.type == pygame.MOUSEBUTTONDOWN: if pygame.mouse.get_pressed()[0]: #left mousebutton was pressed player1.pos[0]=pygame.mouse.get_pos()[0] player1.pos[1]=pygame.mouse.get_pos()[1] <note>
User yipyip has donated a very interesting solution to this problem, using Complex numbers.
See his source code here: yipyip's solution
</note>
ideas
<note tip>Do you remember the keyboard-rollover problem from step020 ? Now you could use less keyboard commands by letting both players turrets automatically rotate toward each other</note> <note tip>Can you code an Artificial_intelligence for the bow machine gun ? Let it firing as soon as it's Deflection angle is low enough: if -5 < tankDiffAngle < 5: Tracer(self) </note>additional resources
no additional resources neededsource code on github
To run this example you need:pygame Download the whole Archive with all files from Github: https://github.com/horstjens/ThePythonGameBook/archives/master View/Edit/Download the file directly in Github: https://github.com/horstjens/ThePythonGameBook/blob/master/pygame/021_targeting.py
Step 022 - Scrolling and mini-map
video
Video link: http://www.youtube.com/watch?v=DusPphBj98A videodescription
In this example you can control the 2 famous tanks from the previous step.
But some features were added:
The map or “playground” is larger than the screen resolution.
.
The player sprite(s) can be steered around the whole map (but not over the map edge).
The position of all Tank, Bullet and Tracer sprites and the current visible area of the map can be seen in the minimap or radar-map.
The minimap is always visible on the top right corner of the screen.
The minimap itself is also a Sprite, called Radarmap.
The dimensions of screen, the big map and the radarmap are all visible inside the Config>real-time-strategy games (rts-games).
