Pygame Tutorial

Pygame
1
Pygame
About the Tutorial

Pygame is a popular Python library used for developing video games. It is free, open source
and cross-platform wrapper around Simple DirectMedia Library (SDL). Abstraction of SDL
functions provided by Pygame makes development of multi-media applications using
Python very easy.
Audience
This tutorial is designed for software programmers who want to develop video games using
Python Programming language.
Prerequisites
Before proceeding with this tutorial, you need a basic knowledge on Python Programming
language, and an understanding of the game that is to be developed is also essential.
Copyright & Disclaimer

 Copyright 2021 by Tutorials Point (I) Pvt. Ltd.
All the content and graphics published in this e-book are the property of Tutorials Point (I)
Pvt. Ltd. The user of this e-book is prohibited to reuse, retain, copy, distribute or republish
any contents or a part of contents of this e-book in any manner without written consent
of the publisher.
We strive to update the contents of our website and tutorials as timely and as precisely as
possible, however, the contents may contain inaccuracies or errors. Tutorials Point (I) Pvt.
Ltd. provides no guarantee regarding the accuracy, timeliness or completeness of our
website or its contents including this tutorial. If you discover any errors on our website or
in this tutorial, please notify us at [email protected]
2
Pygame
Table of Contents
About the Tutorial ........................................................................................................................................... 2
Audience .......................................................................................................................................................... 2
Prerequisites .................................................................................................................................................... 2
Copyright & Disclaimer .................................................................................................................................... 2
Table of Contents ............................................................................................................................................ 3
1. Pygame — Overview ................................................................................................................................. 5
Environment Setup .......................................................................................................................................... 5
2. Pygame — Hello World ............................................................................................................................. 8
3. Pygame — Display modes ....................................................................................................................... 10
4. Pygame — Locals module ....................................................................................................................... 11
5. Pygame — Color object ........................................................................................................................... 12
6. Pygame — Event objects ......................................................................................................................... 14
7. Pygame — Keyboard events ................................................................................................................... 15
8. Pygame — Mouse events ........................................................................................................................ 17
9. Pygame —Drawing shapes ...................................................................................................................... 19
10. Pygame — Loading image ....................................................................................................................... 22
11. Pygame — Displaying Text in Window .................................................................................................... 26
12. Pygame — Moving an image ................................................................................................................... 31
13. Pygame — Moving with Numeric pad keys ............................................................................................. 34
14. Pygame — Moving with mouse............................................................................................................... 36
15. Pygame — Moving Rectangular objects .................................................................................................. 37
16. Pygame — Use Text as Buttons ............................................................................................................... 45
17. Pygame — Transforming Images ............................................................................................................. 49
18. Pygame — Sound objects ........................................................................................................................ 56
19. Pygame — Mixer channels ...................................................................................................................... 59
20. Pygame — Playing music ........................................................................................................................ 60
3
Pygame
21. Pygame — Playing Movie ........................................................................................................................ 63
22. Pygame — Using Camera module ........................................................................................................... 65
23. Pygame — Load cursor............................................................................................................................ 67
24. Pygame — Access CDROM ...................................................................................................................... 69
25. Pygame — The Sprite Module ................................................................................................................. 71
26. Pygame — PyOpenGL ............................................................................................................................. 74
27. Pygame — Errors and Exception ............................................................................................................. 79
4
1. Pygame — Overview Pygame
Pygame is a popular Python library used for developing video games. It is free, open source
and cross-platform wrapper around Simple DirectMedia Library (SDL). Abstraction of SDL
functions provided by Pygame makes development of multi-media applications using
Python very easy.
Originally developed by Peter Shinners, Lenard Lindstrom, René Dudfield and others in Oct
2000, latest version of Pygame is 2.0.1, released in Dec 2020. In addition to SDL
functionality, Pygame also provides other features such as vector maths, collision
detection, camera and MIDI support etc. Pygame applications can be used on Android
based mobile phones also.
Environment Setup
Easiest way to install Pygame on any machine is by using PIP installer that comes with
standard Python distribution. Ensure that you have latest version of pip. It is recommended
to install Pygame in a new virtual environment using following command:
pip3 install pygame
For Raspberri Pi, Pygame is pre-installed in raspbian Linus distribution. As far as

installation on MacOS is concerned, newer versions require Pygame 2.0. Prebuilt binary
packages are available for many flavours of Linux. They can be installed using respective
package manager utilities.
For Ubuntu, following is the command:
sudo apt-get install pygame
For Fedora, the following is the command:
sudo yum install pygame
It is also possible to compile Pygame’s source code (available at

https://github.com/pygame/pygame) and install on desired operating system with the
help of respective C/C++ compiler and Python’s setuptools library.
To verify if Pygame has been successfully installed, try and import pygame package and
check its version.
(pygmenv) C:\pygmenv>python
Python 3.7.4 (tags/v3.7.4:e09359112e, Jul 8 2019, 20:34:20) [MSC v.1916 64 bit
(AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import pygame
pygame 2.0.1 (SDL 2.0.14, Python 3.7.4)
5
Pygame
Hello from the pygame community. https://www.pygame.org/contribute.html
Pygame library consists of following modules:
pygame._sdl2.touch to work with touch input
pygame.camera camera use
pygame.cdrom audio cdrom control
pygame.cursors cursor resources
pygame.display to control the display window and screen
pygame.draw drawing shapes
pygame.event interacting with events and queues
pygame.examples module of example programs
pygame.fastevent interacting with events and queues from multiple

threads.
pygame.font loading and rendering fonts
pygame.freetype loading and rendering computer fonts
pygame.gfxdraw drawing shapes
pygame.image image transfer
pygame.joystick interacting with joysticks, gamepads, and trackballs.
pygame.key to work with the keyboard
pygame.locals pygame constants
pygame.mask image masks.
pygame.math vector classes
pygame.midi interacting with midi input and output.
pygame.mixer loading and playing sounds
pygame.mixer.music controlling streamed audio
pygame.mouse to work with the mouse
pygame.pixelcopy general pixel array copying
pygame.scrap clipboard support.
pygame.sndarray accessing sound sample data
pygame.sprite basic game object classes
pygame.surfarray accessing surface pixel data using array interfaces
pygame.tests unit test suite package
6
Pygame
pygame.time monitoring time
pygame.transform to transform surfaces
7
2. Pygame — Hello World Pygame
First step is to import and initialize pygame modules with the help of init() function.
import pygame
pygame.init()
We now set up Pygame display window of preferred size, and give it a caption.
screen = pygame.display.set_mode((640, 480))

pygame.display.set_caption("Hello World")
This will render a game window which needs to be put in an infinite event loop. All event
objects generated by user interactions such as mouse movement and click etc. are stored
in an event queue. We shall terminate the event loop when pygame.QUIT is intercepted.
This event is generated when user clicks the CLOSE button on the title bar.
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
Complete code for displaying Pygame window with Hello World caption is as follows:
import pygame, sys
pygame.init()
while True:
pygame.quit()
sys.exit()
Save above script as hello.py and run to get following output:
8
Pygame
This window will be closed only if the close (X) button is clicked.
9
3. Pygame — Display modes Pygame
As in the above example, a display surface is created by set_mode() function defined in

pygame.display module.
pygame.display.set_mode(size, flags, depth, display, vsync)
The size parameter is a tuple of width and height in pixels. If size is not set, the surface
will have the size of current resolution.
The flags parameter controls the type of display represented by following predefined
constants:
pygame.FULLSCREEN create a fullscreen display
pygame.DOUBLEBUF recommended for HWSURFACE or OPENGL
pygame.HWSURFACE hardware accelerated, only in FULLSCREEN
pygame.OPENGL create an OpenGL-renderable display
pygame.RESIZABLE display window should be sizeable
pygame.NOFRAME display window will have no border or controls
pygame.SCALED resolution depends on desktop size and scale graphics
pygame.SHOWN window is opened in visible mode (default)
pygame.HIDDEN window is opened in hidden mode
If the vsync parameter is set to 1, it is possible to get a display with vertical sync, but you
are not guaranteed to get one. The request only works at all for calls to set_mode() with
the pygame.OPENGL or pygame.SCALED flags set.
The display index 0 means the default display is used. Depth parameter will default to the
best and fastest color depth for the system. For given width and height, Pygame will
choose best mode available from list_modes().
>>> print (pygame.display.list_modes())

[(1366, 768), (1360, 768), (1280, 768), (1280, 720), (1024, 768), (800, 600),
(640, 480)]
pygame.display.mode_ok()
This function Pick the best color depth for a display mode. It is used to determine if a
requested display mode is available. It will return 0 if the display mode cannot be set.
Otherwise it will return a pixel depth that best matches the display asked for.
pygame.display.update()
This function will update the contents of the entire display.
10
4. Pygame — Locals module Pygame
This module contains definitions of various constants used frequently in a Pygame

application. Although, these constants are defined in respective modules, it becomes
easier to use them from locals module.
For example, Key or Mouse events (such as KEYDOWN or MOUSEBUTTONDOWN) are

defined as pygame.key.KEYDOWN or pygame.mouse.MOUSEBUTTON respectively, these
constants can be used without qualifying the module name by importing from locals
module.
Here, we are using QUIT event from locals module.
import pygame,sys
from pygame.locals import *
pygame.init()
canvas=pygame.display.set_mode((400,300))
pygame.display.set_caption("Hello")
canvas.fill((0,0,0))
while True:
if(event.type == QUIT):
pygame.quit()
sys.exit(1)
11
5. Pygame — Color object Pygame
The Color class in Pygame is used to represent color of screen background, text, shapes
and all other Pygame objects. It constructed by passing color values for Red, Green, Blue
colors and optionally alpha value that represents opaque value. Each of these values range
between 0 to 255.
color = pygame.Color(r, g, b, a=255)
Default value of alpha is 255, meaning fully opaque. Individual attributes are accessible
and can be set.
pygame.Color.r Gets or sets the red value of the Color.
pygame.Color.g Gets or sets the green value of the Color.
pygame.Color.b Gets or sets the blue value of the Color.
pygame.Color.a Gets or sets the alpha value of the Color.
Alternative color models like CMY, HSVA, HSLA and i1i2i3 can also be used.
pygame.Color.cmy Gets or sets the CMY representation of the Color. Cyan,

Magenta, Yellow
pygame.Color.hsva Gets or sets the HSVA representation of the Color. Hue,

Saturation, Value
pygame.Color.hsla Gets or sets the HSLA representation of the Color. Hue,

Saturation, Lightness
pygame.Color.i1i2i3 Gets or sets the I1I2I3 representation of the Color.
We can use predefined string constants to represent RGBA color combinations. Some of
the predefined colors are listed below:
 'black': (0, 0, 0, 255)

 'blue': (0, 0, 255, 255),
 'cyan': (0, 255, 255, 255),
 'gold': (255, 215, 0, 255),
 'gray': (190, 190, 190, 255),
 'green': (0, 255, 0, 255),
 'orange': (255, 165, 0, 255),
 'purple': (160, 32, 240, 255),
 'red': (255, 0, 0, 255),
 'violet': (238, 130, 238, 255)
 'yellow': (255, 255, 0, 255),
12
Pygame
 'white': (255, 255, 255, 255)
To enlist all predefined colors run following for loop:
for k, v in THECOLORS.items():
THECOLORS[unicode_(k)] = v
13
6. Pygame — Event objects Pygame
All events are instances of pygame.event.EventType class. Pygame identifies following

event types:
Event Type attributes
QUIT None
ACTIVEEVENT gain, state
KEYDOWN unicode, key, mod
KEYUP key, mod
MOUSEMOTION pos, rel, buttons
MOUSEBUTTONUP pos, button
MOUSEBUTTONDOWN pos, button
JOYAXISMOTION joy, axis, value
JOYBALLMOTION joy, ball, rel
JOYHATMOTION joy, hat, value
JOYBUTTONUP joy, button
JOYBUTTONDOWN joy, button
VIDEORESIZE size, w, h
VIDEOEXPOSE None
USEREVENT Code
14
7. Pygame — Keyboard events Pygame
Pygame recognizes KEYUP and KEYDOWN events. The pygame.key module defines
functions useful for handling keyboard interaction. pygame.KEYDOWN and pygame.KEYUP
events are inserted in event queue when the keys are pressed and released. key attribute
is an integer ID representing every key on the keyboard.
import pygame, sys
pygame.init()
while True:
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN:
key=pygame.key.name(event.key)
print (key, "Key is pressed")
if event.type == pygame.KEYUP:
key=pygame.key.name(event.key)
print (key, "Key is released")
Run the above code and press various keys while the Pygame window is active. Following
is a sample output on Python console.
q Key is pressed
q Key is released
right shift Key is released
1 Key is pressed
1 Key is released
enter Key is pressed
enter Key is released
backspace Key is pressed
backspace Key is released
x Key is pressed
x Key is released
15
Pygame
home Key is pressed

home Key is released
f1 Key is pressed
f1 Key is released
left Key is pressed
left Key is released
right Key is pressed
right Key is released
up Key is pressed
up Key is released
down Key is pressed
down Key is released
As we see, event.key attribute returns a unique identifier associated with each key. The
arrow keys left, right, up and down are used very often in a game situation. We can right
appropriate logic if a particular key press is detected.
Other useful attributes in pygame.key module are listed below:
pygame.key.get_pressed get the state of all keyboard buttons
pygame.key.get_mods determine which modifier keys are being held
pygame.key.set_repeat control how held keys are repeated
pygame.key.get_repeat see how held keys are repeated
pygame.key.name get the name of a key identifier
pygame.key.key_code get the key identifier from a key name
pygame.key.start_text_input start handling Unicode text input events
pygame.key.stop_text_input stop handling Unicode text input events
16
8. Pygame — Mouse events Pygame
Pygame recongnizes three mouse events, namely, MOUSEMOTION, MOUSEBUTTONUP,

and MOUSEBUTTONDOWN. The corresponding event object returns the coordinates of
position at which mouse is pressed/released and the button number.
For example, a MOUSEBUTTONDOWN event object will display following result:
<Event(1025-MouseButtonDown {'pos': (398, 328), 'button': 1, 'window': None})>
To obtain the coordinates of position of button down, we can use get_pos() function
associated with event object.
import pygame, sys
pygame.init()
while True:
pygame.quit()
sys.exit()
if event.type == pygame.MOUSEBUTTONDOWN:
pos=pygame.mouse.get_pos()
btn=pygame.mouse
print ("x = {}, y = {}".format(pos[0], pos[1]))
Run above code and press the mouse button at random positions on the game window.
x = 192, y = 160
x = 419, y = 245
x = 204, y = 405
x = 449, y = 17
x = 12, y = 15
The MOUSEMOTION event object captures instantaneous position of moving mouse

location.
if event.type == pygame.MOUSEMOTION:
pos=event.pos
17
Pygame
print ("x = {}, y = {}".format(pos[0], pos[1]))
Other important functions and attributes in pygame.mouse module are as follows:
pygame.mouse.get_pressed get the state of the mouse buttons
pygame.mouse.get_pos get the mouse cursor position
pygame.mouse.get_rel get the amount of mouse movement
pygame.mouse.set_pos set the mouse cursor position
pygame.mouse.set_visible hide or show the mouse cursor
pygame.mouse.get_visible get the current visibility state of the mouse cursor
pygame.mouse.get_focused check if the display is receiving mouse input
pygame.mouse.set_cursor set the image for the mouse cursor
pygame.mouse.set_system_cursor set the mouse cursor to a system variant
Pygame defines following system cursors:
pygame.SYSTEM_CURSOR_ARROW arrow
pygame.SYSTEM_CURSOR_IBEAM i-beam
pygame.SYSTEM_CURSOR_WAIT wait
pygame.SYSTEM_CURSOR_CROSSHAIR crosshair
pygame.SYSTEM_CURSOR_SIZENWSE double arrow pointing northwest and

southeast
pygame.SYSTEM_CURSOR_SIZENESW double arrow pointing northeast and

southwest
pygame.SYSTEM_CURSOR_SIZEWE double arrow pointing west and east
pygame.SYSTEM_CURSOR_SIZENS double arrow pointing north and south
pygame.SYSTEM_CURSOR_SIZEALL four pointed arrow
pygame.SYSTEM_CURSOR_NO slashed circle or crossbones
pygame.SYSTEM_CURSOR_HAND hand
Following statement will set the game window cursor to crosshair.
pygame.mouse.set_system_cursor(pygame.SYSTEM_CURSOR_CROSSHAIR)
18
9. Pygame —Drawing shapes Pygame
Different shapes such as rectangle, circle, ellipse, polygon and line can be drawn on the
game window by using functions in pygame.draw module:
draw a rectangle rect(surface, color, rect)
draw a polygon polygon(surface, color, points)
draw a circle circle(surface, color, center, radius)
draw an ellipse ellipse(surface, color, rect)
draw an elliptical arc arc(surface, color, rect, start_angle, stop_angle)
draw a straight line line(surface, color, start_pos, end_pos, width)
Following example uses these functions to draw different shapes:
import pygame
pygame.init()
done = False
red = (255,0,0)
green = (0,255,0)
blue = (0,0,255)
white = (255,255,255)
while not done:
done = True
pygame.draw.rect(screen, red, pygame.Rect(100, 30, 60, 60))
pygame.draw.polygon(screen, blue,
((25,75),(76,125),(275,200),(350,25),(60,280)))
pygame.draw.circle(screen, white, (180,180), 60)
pygame.draw.line(screen, red, (10,200), (300,10), 4)
pygame.draw.ellipse(screen, green, (250, 200, 130, 80))
19
Pygame
Output
If an optional integer parameter is added to the functions, the shape will be drawn with
specified color as outline color. Number corresponds to thickness of the outline and
background color inside the shape.
pygame.draw.rect(screen, red, pygame.Rect(100, 30, 60, 60),1)

pygame.draw.circle(screen, white, (180,180), 60,2)
pygame.draw.ellipse(screen, green, (250, 200, 130, 80),5)
Result
20
Pygame
21
10. Pygame — Loading image Pygame
The pygame.image module contains functions for loading and saving images from file or
file like object. An image is loaded as a Surface object which eventually is rendered on
Pygame display window.
First we obtain a Surface object by load() function.
img = pygame.image.load('pygame.png')
Next we obtain a rect object out of this Surface and then use Surface.blit() function to
render the image:
rect = img.get_rect()
rect.center = 200, 150
screen.blit(img, rect)
The complete program for displaying Pygame logo on the display window is as follows:
import pygame
pygame.init()
img = pygame.image.load('pygame.png')
done = False
bg = (127,127,127)
while not done:
screen.fill(bg)
rect.center = 200, 150
screen.blit(img, rect)
done = True
Output
The output for the above code is as follows:
22
Pygame
The blit() function can take an optional special-flags parameter with one of the following
values:
BLEND_RGBA_ADD
BLEND_RGBA_SUB
BLEND_RGBA_MULT
BLEND_RGBA_MIN
BLEND_RGBA_MAX
BLEND_RGB_ADD
BLEND_RGB_SUB
BLEND_RGB_MULT
BLEND_RGB_MIN
BLEND_RGB_MAX
The pygame.Surface module also has a convert() function which optimizes the image
format and makes drawing faster.
The pygame.image module has a save() function that saves contents of Surface object to
an image file. Pygame supports the following image formats:
Loading image formats Saving image formats
JPG BMP
PNG TGA
GIF (non-animated) PNG
BMP JPEG
23
Pygame
PCX
TGA (uncompressed)
TIF
LBM (and PBM)
PBM (and PGM, PPM)
XPM
Following program draws three circles on the display surface and save it as a circles.png
file using image.save() function.
import pygame
pygame.init()
done = False
white=(255,255,255)
red = (255,0,0)
green = (0,255,0)
blue = (0,0,255)
bg = (127,127,127)
while not done:
screen.fill(bg)
done = True
pygame.draw.circle(screen, red, (200,150), 60,2)
pygame.draw.circle(screen, green, (200,150), 80,2)
pygame.draw.circle(screen, blue, (200,150), 100,2)
pygame.image.save(screen, "circles.png")
Output
24
Pygame
The circles.png should be created in the current working folder.
25
11. Pygame — Displaying Text in Window Pygame
To display text on the Pygame window, we need to obtain a font object first, with the help
of SysFont() function defined in pygame.font module.
Fnt= SysFont(name, size, bold=False, italic=False)
List of fonts installed in current machine can be obtained by get_fonts() function.
fonts = pygame.font.get_fonts()
for f in fonts:
print(f)
Let us define a font object representing Arial font of 36 point size.
font = pygame.font.SysFont("Arial", 36)
Next we obtain a new Surface object for rendering Hello World text in the newly created
font with render() method of Font object.
txtsurf = font.render("Hello, World", True, white)
First argument is a one-line string, second argument represents antialias. If it is set to

False, the rendered image is an 8-bit image, and 24-bit if true. An optional background
color argument can also be used.
We now need to blit the text Surface at the center of screen window.
screen.blit(txtsurf,(200 - txtsurf.get_width() // 2, 150 - txtsurf.get_height()

// 2))
Following is the complete code:
import pygame
pygame.init()
done = False
white=(255,255,255)
red = (255,0,0)
green = (0,255,0)
blue = (0,0,255)
bg = (127,127,127)
26
Pygame
while not done:

screen.fill(bg)
done = True
txtsurf = font.render("Hello, World", True, white)
screen.blit(txtsurf,(200 - txtsurf.get_width() // 2, 150 -
txtsurf.get_height() // 2))
Output
In addition to SysFont() method, a Font object can also be obtained from a font file (having
.ttf extension) or a Python file object pointing towards the ttf file. It is also possible to
construct a font object with .ttc file. The font class defines following methods:
bold() Gets or sets whether the font should be rendered in bold.
italic() Gets or sets whether the font should be rendered in italics.
underline() Gets or sets whether the font should be rendered with an

underline.
render() draw text on a new Surface
size() calculate size needed to render text
27
Pygame
set_underline() control if text is rendered with an underline
get_underline() check if text will be rendered with an underline
set_bold() enable fake rendering of bold text
get_bold() check if text will be rendered bold
set_italic() enable fake rendering of italic text
metrics() gets the metrics for each character
get_italic() check if the text will be rendered italic
get_linesize() get the line space of the font text
get_height() get the height of the font
get_ascent() get the ascent of the font
get_descent() get the descent of the font
Given below is example to use ttf and ttc files to render text
font1 = pygame.font.SysFont('chalkduster.ttf', 72)
img1 = font1.render('Hello World', True, BLUE)
font2 = pygame.font.SysFont('didot.ttc', 72)
img2 = font2.render('Hello Pygame', True, GREEN)
screen.blit(img1, (20, 50))
screen.blit(img2, (20, 120))
In the above example, a predefined string has been rendered as a surface object. However,
it is possible to read key value of KEYDOWN event to interactively enter a string and
display it.
To begin with, we render an empty string. Next, we define the bounding rectangle and
then a cursor rectangle which is placed to overlap the text bounding rectangle. Each
keystroke identified in KEYDOWN event is appended to original empty string and
repeatedly rendered.
Following code initially displays a blank window. Each letter pressed will be displayed
alongside each other.
import pygame
pygame.init()
done = False
white=(255,255,255)
28
Pygame
red = (255,0,0)
green = (0,255,0)
blue = (0,0,255)
bg = (127,127,127)
text=""
while not done:
screen.fill(bg)
done = True
text=text+event.unicode
img = font.render(text, True, white)
cursor = pygame.Rect(rect.topright, (3, rect.height))
img = font.render(text, True, white)
rect.size=img.get_size()
cursor.topleft = rect.topright
screen.blit(img,(200 - img.get_width() // 2, 150 - img.get_height() //
2))
Run the above code and enter some text. Sample output is as follows:
29
Pygame
30
12. Pygame — Moving an image Pygame
Movement of an object is an important aspect of any computer game. A computer game

creates illusion of movement by drawing and erasing an object at incremental position.
Following code draws an image by incrementing x coordinate position in an event loop and
erasing it with the background color.
image_filename = 'pygame.png'
import pygame
from sys import exit
pygame.init()
screen = pygame.display.set_mode((400,300), 0, 32)
pygame.display.set_caption("Moving Image")
img = pygame.image.load(image_filename)
x = 0
while True:
screen.fill((255,255,255))
if event.type == QUIT:
exit()
screen.blit(img, (x, 100))
x= x+0.5
if x > 400:
x = x-400
The Pygame logo image starts displaying at left border and repeatedly shifts towards right.
If it reaches right border, its position is reset to left.
31
Pygame
In the following program, the image is displayed at (0,150) position to begin with. When
user presses arrow keys (left, right, up, down), the image changes its location by 5 pixels.
If a KEYDOWN event occurs, the program checks if the key value is K_LEFT, K_RIGHT,
K_UP or K_DOWN. The x coordinate changes by +5 or -5 if it is K_LEFT or K_RIGHT. Value
of y coordinate changes by -5 or +5 if key value is K_UP or K_DOWN.
import pygame
pygame.init()
screen = pygame.display.set_mode((400,300))
pygame.display.set_caption("Moving with arrows")
x = 0
y= 150
while True:
screen.fill((255,255,255))
screen.blit(img, (x, y))
exit()
if event.type == KEYDOWN:
if event.key == K_RIGHT:
32
Pygame
x= x+5
if event.key == K_LEFT:
x=x-5
if event.key == K_UP:
y=y-5
if event.key == K_DOWN:
y=y+5
33
13. Pygame — Moving with Numeric pad keys Pygame
If we want to effect diagonal movement of an object on game window, we need to use

numeric key pad keys. While keys 4,6,8 and 2 correspond to left, right, up and down
arrows, num keys 7, 9, 3 and 1 can be used to move the object in up-left, up-right, down-
right and down-left diagonal movements. These keys are identified by Pygame with
following values:
K_KP1 keypad 1
K_KP2 keypad 2
K_KP3 keypad 3
K_KP4 keypad 4
K_KP5 keypad 5
K_KP6 keypad 6
K_KP7 keypad 7
K_KP8 keypad 8
K_KP9 keypad 9
For left, right, up and down arrow press, x and y coordinates are
incremented/decremented as before. For diagonal movement, both coordinates are
changed as per direction. For instance, for K_KP7 key-press, both x and y are decremented
by 5, for K_KP9 x is incremented and y is decremented.
import pygame
pygame.init()
pygame.display.set_caption("Moving with arrows")
x = 0
y= 150
while True:
screen.fill((255,255,255))
screen.blit(img, (x, y))
exit()
34
Pygame
if event.key == K_KP6:
x= x+5
x=x-5
y=y-5
y=y+5
x=x-5
y=y-5
x=x+5
y=y-5
x=x+5
y=y+5
x=x-5
y=y+5
35
14. Pygame — Moving with mouse Pygame
Moving an object according to movement of mouse pointer is easy. The pygame.mouse

module defines get_pos() method. It returns a two-item tuple corresponding to x and y
coordinates of current position of mouse.
(mx,my) = pygame.mouse.get_pos()
After capturing mx and my positions, the image is rendered with the help of bilt() function
on the Surface object at these coordinates.
Following program continuously renders the given image at moving mouse cursor position.
filename = 'pygame.png'
import pygame
pygame.init()
pygame.display.set_caption("Moving with mouse")
img = pygame.image.load(filename)
x = 0
y= 150
while True:
mx,my=pygame.mouse.get_pos()
screen.fill((255,255,255))
screen.blit(img, (mx, my))
exit()
36
15. Pygame — Moving Rectangular objects Pygame
The Pygame.Rect class has functionality to store and manipulate rectangular areas. A Rect
object can be constructed from left, top, width and height values. Functions in Rect class
enable copying, moving nd resizing the Rect object.
A Rect object has following virtual attributes:
In addition to movement, Rect class has methods to test collision between rectangles.
copy() Returns a new rectangle having the same position and size as the
original.
move() Returns a new rectangle that is moved by the given offset. The x
and y arguments can be any integer value, positive or negative.
move_ip() Same as the Rect.move() method, but operates in place.
inflate(x,y) Returns a new rectangle with the size changed by the given offset.
Negative values will shrink the rectangle.
inflate_ip(x, y) Same as the Rect.inflate() method, but operates in place.
clamp(Rect) Returns a new rectangle that is moved to be completely inside the

argument Rect.
clip(Rect) Returns a new rectangle that is cropped to be completely inside

the argument Rect.
union(Rect) Returns a new rectangle that completely covers the area of the
two provided rectangles.
union_ip(Rect) Same as the Rect.union() method, but operates in place.
contains(Rect) Returns true when the argument is completely inside the Rect.
collidepoint((x,y)) Returns true if the given point is inside the rectangle.
colliderect(Rect) Returns true if any portion of either rectangle overlap
37
Pygame
In the following program, a Rect object is drawn with red outline. Using copy() method,
its clone is created for movement. The movement is effected by move_ip() method. The
arrow keys move the position of copied rectangle by incrementing/decrementing x/y
coordinate by + or -5 pixels.
import pygame
pygame.init()
rect1 = Rect(50, 60, 200, 80)
rect2=rect1.copy()
running = True
x=0
y=0
while running:
running = False
if event.key==K_LEFT:
x= -5
y=0
x=5
y=0
x=0
y = -5
x=0
y=5
rect2.move_ip(x,y)
38
Pygame
screen.fill((127,127,127))
pygame.draw.rect(screen, (255,0,0), rect1, 1)
pygame.quit()
The following output shows rectangle with red outline is the original rectangle. Its copy
keeps moving responding to arrow keys and has blue outline
Changing the move_ip() method to inflate_ip() method to grow/shrink the rectangle

depending upon the arrow pressed.
while running:
running = False
if event.key==K_LEFT:
x= -5
y=0
x=5
39
Pygame
y=0
x = 0
y = -5
x = 0
y = 5
rect2.inflate_ip(x,y)
screen.fill((127,127,127))
The following is the screenshot of the arrow key-press activity:
To make the rectangle move by detecting MOUSEMOTION event, we need to first press
the mouse inside the original rectangle. To verify whether mouse position is inside the
rectangle, we use collidepoint() method of the Rect object. While the mouse is in motion,
the rectangle object is moved in place by move_ip() method. Movement shall stop when
mouse is released.
import pygame
40
Pygame

pygame.init()
rect = Rect(50, 60, 200, 80)
moving = False
running = True
while running:
running = False
elif event.type == MOUSEBUTTONDOWN:
if rect.collidepoint(event.pos):
moving = True
elif event.type == MOUSEBUTTONUP:
moving = False
elif event.type == MOUSEMOTION and moving:
rect.move_ip(event.rel)
screen.fill((127,127,127))
pygame.draw.rect(screen, (255,0,0), rect)
if moving:
pygame.draw.rect(screen, (0,0,255), rect, 4)
pygame.display.flip()
pygame.quit()
41
Pygame
To draw rectangle by mouse, capture the mouse pointer coordinates in

MOUSEBUTTONDOWN and MOUSEBUTTONUP events, calculate the topleft coordinates,
width and height and call rect() function.
import pygame
pygame.init()
pygame.display.set_caption("Draw Rectangle with Mouse")
42
Pygame
screen.fill((127,127,127))
x=0
y=0
w=0
h=0
drawmode=True
running = True
while running:
running = False
if event.type == MOUSEBUTTONDOWN:
x,y = pygame.mouse.get_pos()
drawmode = True
if event.type == MOUSEBUTTONUP:
x1,y1 = pygame.mouse.get_pos()
w=x1-x
h=y1-y
drawmode= False
rect = pygame.Rect(x,y,w,h)
if drawmode == False:
pygame.draw.rect(screen, (255,0,0), rect)
pygame.quit()
Output
43
Pygame
44
16. Pygame — Use Text as Buttons Pygame
Button is an important element in a typical game window. We can use a text or image
surface object as button, so that when clicked it can fire a certain action.
Let us try to display three buttons with text captions.
text1=font.render(" START ", True, white)

text2=font.render(" PLAY ", True, white)
text3=font.render(" STOP ", True, white)
In order to draw a border around these buttons obtain their Rect object.
rect1 = text1.get_rect(topleft=(10,10))
rect2 = text2.get_rect(topleft= (100,10))
Inside the event loop, blit the text buttons with red border around them.
screen.blit(text1, rect1)
pygame.draw.rect(screen, (255,0,0),rect1,2)
Use collidepoint() function of Rect object to identify which button has been clicked.
if rect1.collidepoint(event.pos):
msg = "START Button was pressed"
msg = "PLAY Button was pressed"
msg = "STOP Button was pressed"
Display appropriate message as a text surface:
img=font.render(msg, True, (0,0,255))

imgrect=img.get_rect()
imgrect.center = (200 , 150 )
45
Pygame
pygame.draw.rect(screen, bg, imgrect)

screen.blit(img, imgrect)
Following is the complete code:
import pygame
pygame.init()
done = False

text1=font.render(" START ", True, white)
bg = (127,127,127)
msg=" "
screen.fill(bg)
while not done:
done = True
msg = "START Button was pressed"
46
Pygame
msg = "PLAY Button was pressed"

msg = "STOP Button was pressed"
img=font.render(msg, True, (0,0,255))

imgrect=img.get_rect()
imgrect.center = (200 , 150 )
pygame.draw.rect(screen, bg, imgrect)
screen.blit(img, imgrect)
When each button is clicked, display window shows the following output:
47
Pygame
48
17. Pygame — Transforming Images Pygame
The pygame.ransform module contains definitions of a number of functions for

manipulation of Surface objects obtained out of image or text blocks. Manipulation of a
surface include flipping, rotation, scaling, resizing and zooming the object.
Following functions are found in pygame.transform module:
flip() flip vertically and horizontally
scale() resize to new resolution
rotate() rotate an image
rotozoom() filtered scale and rotation
scale2x() specialized image doubler
smoothscale() scale a surface to an arbitrary size smoothly
get_smoothscale_backend() return smoothscale filter version in use - 'GENERIC',

'MMX', or 'SSE'
set_smoothscale_backend() set smoothscale filter version to one of - 'GENERIC',

'MMX', or 'SSE'
chop() gets a copy of an image with an interior area removed
laplacian() find edges in a surface
average_surfaces() find the average surface from many surfaces.
average_color() finds the average color of a surface
threshold() finds which, and how many pixels in a surface are

within a threshold of a 'search_color' or a 'search_surf'.
Let us first use the flip() function whose syntax is as follows:
flip(Surface, xbool, ybool)
This function can flip the surface object either horizontally, vertically or both. The
orientation is decied by two bool parameters.
To flip the image horizontally, use the following command:
pygame.transform.flip(img2,True, False)
To flip vertically, use the following command:
pygame.transform.flip(img2,False, True)
49
Pygame
In the following example, pygame logo image is displayed normally and flipping in both
directions. First obtained flipped surface from original image object, fetch its Rect object
and then blit it. To render horizontally fliiped image,
img1 = pygame.image.load('pygame.png')
img2=img1
img2=pygame.transform.flip(img2,True, False)
#inside event loop
rect2 = img2.get_rect()
rect2.center = 200, 150
screen.blit(img2, rect2)
The complete code for rendering original Pygame logo and its flipped images is as follows:
import pygame
pygame.init()
pygame.display.set_caption("Flip image")
img2=img1
img3=img1
img2=pygame.transform.flip(img2,True, False)
img3=pygame.transform.flip(img3, False, True)
done = False
bg = (127,127,127)
while not done:
screen.fill(bg)
50
Pygame
done = True
The rotate() function takes following arguments:
rotate(Surface, angle)
Negative value of angle rotates the surface in clockwise direction.
import pygame
pygame.init()
pygame.display.set_caption("rotate image")
img2=img1
img3=img1
img2=pygame.transform.rotate(img2,90)
img3=pygame.transform.rotate(img3, -90)
done = False
bg = (127,127,127)
while not done:
screen.fill(bg)
51
Pygame
rect3.center = 300,200
done = True
The laplacian() function extracts outline of the surface object. The function just takes one
argument, the image object itself.
import pygame
pygame.init()
pygame.display.set_caption("Laplacian of image")
52
Pygame
img2=img1
img2=pygame.transform.laplacian(img2)
done = False
bg = (127,127,127)
while not done:
screen.fill(bg)
done = True
To make the Surface object move along with mouse movement, calculate the x, y
coordinates from the center of the image. We also calculate the center-mouse distance d.
The atan2(y, x) math function allows to find the rotation angle. We need to transform
radians in degrees. From the distance mouse-center we calculate the scale argument.
mouse = event.pos
53
Pygame
x = mouse[0] - 200
y = mouse[1] - 150
d = math.sqrt(x ** 2 + y ** 2)
angle = math.degrees(-math.atan2(y, x))
scale = abs(5 * d / 400)
Finally, we use rotzoom() function which performs combined rotation and scaling
transform.
rotozoom(Surface, angle, scale)
Following code renders Pygame logo image that can be rotated in accordance with mouse
movement.
import pygame , math

pygame.init()
pygame.display.set_caption("Move image with mouse")
done = False
bg = (127,127,127)
while not done:
screen.fill(bg)
done = True
if event.type == MOUSEMOTION:
mouse = event.pos
x = mouse[0] - 200
y = mouse[1] - 150
d = math.sqrt(x ** 2 + y ** 2)
angle = math.degrees(-math.atan2(y, x))
scale = abs(5 * d / 400)
img2 = pygame.transform.rotozoom(img1, angle, scale)
rect = img2.get_rect()
rect.center = (200,150)
screen.blit(img2, rect)
54
Pygame
Run above code, try and move mouse cursor along display window. The image shall rotate
and either shrink or grow accordingly.
55
18. Pygame — Sound objects Pygame
Use of music and sounds make any computer game more engaging. Pygame library
supports this feature through pygame.mixer module. This module contains Sound class
for loading Sound objects and controlling playback. All sound playback is mixed in
background threads. For less laggy sound use a smaller buffer size.
To obtain Sound object from a sound file or file object, use following constructor:
pygame.mixer.Sound(filename or file object)
The Sound class defines following methods for controlling playback:
play(loops=0, Begin playback of the Sound (i.e., on the computer's

maxtime=0, fade_ms=0) speakers) on an available Channel. Loops parameter is for
repeated play.
stop() This will stop the playback of this Sound on any active
Channels.
fadeout(time) This will stop playback of the sound after fading it out over
the time argument in milliseconds.
set_volume(value) This will set the playback volume for this

Sound,immediately affecting the Sound if it is playing and
any future playback of this Sound. volume in the range of
0.0 to 1.0
get_length() Return the length of this Sound in seconds.
In following example, a text button is rendered at the bottom of display window. A space
key fires an arrow upwards accompanied by a sound playing.

text1=font.render(" SHOOT ", True, bg)
rect1 = text1.get_rect(midbottom=(200,300))
img=pygame.image.load("arrow.png")
rect2=img.get_rect(midtop=(200, 270))
Inside the game event loop, for a space key detected, an arrow object is place above the
SHOOT button and repeatedly rendered with decrementing y coordinate. The shooting
sound is also played at the same time.
sound=pygame.mixer.Sound("sound.wav")img=pygame.image.load("arrow.png")
if event.key == pygame.K_SPACE:
56
Pygame
print ("space")
if kup==0:
screen.blit(img, (190,y))
kup=1
if kup==1:
y=y-1
sound.play()
if y<=0:
kup=0
y=265
Following listing demonstrates use of Sound object.
import pygame
pygame.init()
done = False
white = (255,255,255)
bg = (127,127,127)
sound=pygame.mixer.Sound("sound.wav")
text1=font.render(" SHOOT ", True, bg)
rect1 = text1.get_rect(midbottom=(200,300))
img=pygame.image.load("arrow.png")
kup=0
psmode=True
screen.fill(white)
y=265
while not done:

57
Pygame
sound.stop()
done = True
if event.key == pygame.K_SPACE:
print ("space")
if kup==0:
kup=1
if kup==1:
y=y-1
sound.play()
if y<=0:
kup=0
y=265
58
19. Pygame — Mixer channels Pygame
The Sound object can be played on a specific channel instead of the default channel
automatically chosen. First create a channel object using the following command:
pygame.mixer.Channel(id)
Following functions are defined in the mixer.channel class:
play(Sound, loops=0, This will begin playback of a Sound on a specific Channel.

maxtime=0, fade_ms=0)
stop() Stop sound playback on a channel. After playback is

stopped the channel becomes available for new Sounds to
play on it
pause() Temporarily stop the playback of sound on a channel.
unpause() Resume the playback on a paused channel.
set_volume(value) Set the volume (loudness) of a playing sound. The value

argument is between 0.0 and 1.0.
queue(Sound) When a Sound is queued on a Channel, it will begin playing

immediately after the current Sound is finished.
59
20. Pygame — Playing music Pygame
The mixer also has a special streaming channel for music playback and is accessed through
the pygame.mixer.musicpygame module for controlling streamed audio module. The
difference between the music playback and regular Sound playback is that the music is
streamed, and never actually loaded all at once. The mixer system only supports a single
music stream at once.
First of all, we need to load the music from a music file. Pygame can load WAV, MP3, or
OGG files.
pygame.mixer.music.load(filename or object)
This will load a music filename/file object and prepare it for playback. If a music stream is
already playing it will be stopped. This does not start the music playing. The playback is
controlled by following functions:
play(loops=0, start=0.0, fade_ms = 0)
This will play the loaded music stream. If the music is already playing it will be restarted.
loops argument tells how many times to repeat the music. The music repeats indefinitely
if this argument is set to -1. start denotes the music starts playing from. The position as
time in seconds. fade_ms argument makes the music start playing at 0 volume and fade
up to full volume over the given time.
Other useful functions are given below:
rewind() Resets playback of the current music to the beginning.
stop() Stops the music playback if it is currently playing. It Won't

Unload the music.
pause() Temporarily stop playback of the music stream.
unpause() This will resume the playback of a music stream after it has been
paused.
fadeout(time) Fade out and stop the currently playing music.
set_volume(volume) Set the volume of the music playback.
set_pos(pos) This sets the position in the music file where playback will start.
In the following program, a music file starts playing on clicking PLAY button. The PAUSE
button acts as a toggle to pause/unpause play. Click on STOP stops the playback.
import pygame
pygame.init()
60
Pygame
done = False
white = (255,255,255)
pygame.mixer.music.load("mario_theme.wav")
text2=font.render(" PAUSE ", True, white)
bg = (127,127,127)
psmode=True
screen.fill(bg)
while not done:
done = True
pygame.mixer.music.play()
if psmode==True:
pygame.mixer.music.pause()
psmode=False
else:
if psmode==False:
pygame.mixer.music.unpause()
psmode=True
61
Pygame
pygame.mixer.music.stop()
62
21. Pygame — Playing Movie Pygame
Pygame has discontinued support for video files in its latest version. However, earlier
versions on Python 2.7 distributions, it can be still used. For this section, Pygame 1.9.2
and Python 2.7.18 has been used.
The pygame.movie module supports playback video and audio from basic encoded MPEG-
1 video files. Movie playback happens in background threads, which makes playback easy
to manage. the pygame.mixerpygame module for loading and playing sounds module must
be uninitialized if the movie’s sound is to be played.
To begin with obtain a Movie object by following syntax:
movie = pygame.movie.Movie('sample.mpg')
The Movie class provides following methods to control playback.
pygame.movie.Movie.play start playback of a movie
pygame.movie.Movie.stop stop movie playback
pygame.movie.Movie.pause temporarily stop and resume playback
pygame.movie.Movie.skip advance the movie playback position
pygame.movie.Movie.rewind restart the movie playback
pygame.movie.Movie.get_time get the current vide playback time
pygame.movie.Movie.get_length the total length of the movie in seconds
pygame.movie.Movie.get_size get the resolution of the video
pygame.movie.Movie.has_audio check if the movie file contains audio
pygame.movie.Movie.set_volume set the audio playback volume
pygame.movie.Movie.set_display set the video target Surface
Following code plays a .MPG file on the Pygame display window.
import pygame
FPS = 60
63
Pygame
pygame.init()
clock = pygame.time.Clock()
movie = pygame.movie.Movie('sample_640x360.mpg')
screen = pygame.display.set_mode(movie.get_size())
movie_screen = pygame.Surface(movie.get_size()).convert()
movie.set_display(movie_screen)
movie.play()
playing = True
while playing:
movie.stop()
playing = False
screen.blit(movie_screen,(0,0))
clock.tick(FPS)
pygame.quit()
64
22. Pygame — Using Camera module Pygame
Earlier versions of Pygame upto 1.9.6 contain pygame.camera module. This module
contains functionality to capture camera feed on the game window and grab an image
from it. The camera devices available to the system are enumerated in a list returned by
list_cameras() method.
pygame.camera.list_cameras()
To initialize a camera object, use camera id, resolution and format arguments.
pygame.camera.Camera(device, (width, height), format)
The default format is RGB. Width and height parameters are by default 640x480.
The camera module has following methods defined in Camera class.
pygame.camera.Camera.start() opens, initializes, and starts capturing
pygame.camera.Camera.stop() stops, uninitializes, and closes the camera
pygame.camera.Camera.get_controls() gets current values of user controls
pygame.camera.Camera.set_controls() changes camera settings if supported by the

camera
pygame.camera.Camera.get_size() returns the dimensions of the images being

recorded
pygame.camera.Camera.query_image() checks if a frame is ready
pygame.camera.Camera.get_image() captures an image as a Surface
pygame.camera.Camera.get_raw() returns an unmodified image as a string
Following programs captures live feed from computer’s default web camera.
import pygame
import pygame.camera
pygame.init()
gameDisplay = pygame.display.set_mode((640,480))
pygame.camera.init()
print (pygame.camera.list_cameras())
cam = pygame.camera.Camera(0)
cam.start()
65
Pygame
while True:
img = cam.get_image()
gameDisplay.blit(img,(0,0))
for event in pygame.event.get() :
if event.type == pygame.QUIT :
cam.stop()
pygame.quit()
exit()
Please note that on Windows OS, you may have to install Videocapture module.
pip3 install VideoCapture
66
23. Pygame — Load cursor Pygame
Pygame can let you control system cursor. Onlu black and white cursors can be used in
Pygame. The pygame.cursors module defines contain predefined cursor enumerations.
 pygame.cursors.arrow
 pygame.cursors.diamond
 pygame.cursors.broken_x
 pygame.cursors.tri_left
 pygame.cursors.tri_right
The arrow cursor is the default choice. To use another cursor, we use set_cursor() function
in pygame.mouse module.
pygame.mouse.set_cursor(pygame.cursors.broken_x)
In the following example, this cursor can be seen on the display window.
import pygame,sys
pygame.init()
pygame.mouse.set_cursor(pygame.cursors.broken_x)
canvas=pygame.display.set_mode((400,300))
pygame.display.set_caption("Cursor")
while True:
if(event.type == QUIT):
pygame.quit()
sys.exit(1)
Output
67
Pygame
This module also contains a few cursors as formatted strings. To use them, use
pygame.cursors.compile() function.
 pygame.cursors.thickarrow_strings
 pygame.cursors.sizer_x_strings
 pygame.cursors.sizer_y_strings
 pygame.cursors.sizer_xy_strings
 pygame.cursor.textmarker_strings
cursor = pygame.cursors.compile(pygame.cursors.textmarker_strings)
pygame.mouse.set_cursor((10,10), (0, 0), *cursor)
68
24. Pygame — Access CDROM Pygame
The pygame library has pygame.cdrom module that enables the program to manage
playback from audio CDs and DVDs. We need to explicitly initialize this module for its use.
>>> import pygame

>>> pygame.cdrom.init()
The module defines all important CD class to represent the CDROM device. The constructor
requires ID of CDROM drive available, starting with 0.
>>> obj=pygame.cdrom.CD(0)
The CDROM object has access to following useful functions to control the playback.
init() initialize a cdrom drive for use
quit() uninitialize a cdrom drive for use
play() start playing audio
stop() stop audio playback
pause() temporarily stop audio playback
resume() unpause audio playback
eject() eject or open the cdrom drive
get_busy() true if the drive is playing audio
get_paused() true if the drive is paused
get_empty() False if a cdrom is in the drive
get_numtracks() the number of tracks on the cdrom
get_track_audio() true if the cdrom track has audio data
get_track_start() start time of a cdrom track
get_track_length() length of a cdrom track
First, initialize the object.
>>> obj.init()
To find out how many tracks are present in the current CD:
>>> obj.get_numtracks()
8
69
Pygame
To start playing the required track, give its number to play() function.
>>> obj.play(4)
To pause, resume and stop the playback, we can use relevant functions listed above.
70
25. Pygame — The Sprite Module Pygame
Any bitmap that is drawn in our game window and that can move around is called a Sprite.
The pygame.sprite module contains classes and functionality useful in game development.
Along with a Sprite class to create collection of sprite objects, there are functions that
enable collision of sprite objects.
The Sprite class serves as a base class for different objects in the game. You may have to
put one more objects in groups. for that purpose, group classes are also provided.
Let us first develop a Sprite class by subclassing the sprite.Sprite class. Each object of this
Block class is a rectangular block filled with black color.
class Block(pygame.sprite.Sprite):
def __init__(self, color, width, height):

super().__init__()
self.image = pygame.Surface([width, height])

self.image.fill(color)
self.rect = self.image.get_rect()
We shall create 50 block objects and put them in a list.
for i in range(50):
block = Block(BLACK, 20, 15)
# Set a random location for the block

block.rect.x = random.randrange(screen_width)
block.rect.y = random.randrange(screen_height)
# Add the block to the list of objects

block_list.add(block)
all_sprites_list.add(block)
We create a block with red color call it player, and add it too to the list.
# Create a RED player block

player = Block(RED, 20, 15)
71
Pygame
all_sprites_list.add(player)
Inside the game’s event loop, detect the collision of red block (player) as it moves along
with mouse motion and black block and count the collisions.
The event loop code is as follows:
while not done:

done = True
# Clear the screen

screen.fill(WHITE)
# Get the current mouse position. This returns the position

# as a list of two numbers.
pos = pygame.mouse.get_pos()
# Fetch the x and y out of the list,

# just like we'd fetch letters out of a string.
# Set the player object to the mouse location
player.rect.x = pos[0]
player.rect.y = pos[1]
# See if the player block has collided with anything.

blocks_hit_list = pygame.sprite.spritecollide(player, block_list, True)
# Check the list of collisions.

for block in blocks_hit_list:
score += 1
print(score)
# Draw all the spites

all_sprites_list.draw(screen)
# Go ahead and update the screen with what we've drawn.

72
Pygame
# Limit to 60 frames per second

clock.tick(60)
pygame.quit()
Run the above code. Move the player block to capture as many black blocks. The score
will be echoed on the console.
73
26. Pygame — PyOpenGL Pygame
OpenGL is a cross-language, cross-platform API for rendering 2D and 3D vector graphics.

By interacting with a graphics processing unit (GPU), it achieves hardware-accelerated
rendering. PyOpenGL library is Python’s binding for OpenGL.
We need to install it using pip utility:
pip3 install pyopengl
First we shall import functions from OpenGL.GL and OpenGL.GLU (utility functions)
modules.
OpenGL specifies objects within the space by defining vertices or nodes. Lines between
vertices are called edges. The OpenGL code is written between glBegin and glEnd.
In our example, we shall draw a cube with following vertices and edges:
verticies = (
(1, -1, -1),
(1, 1, -1),
(-1, 1, -1),
(-1, -1, -1),
(1, -1, 1),
(1, 1, 1),
(-1, -1, 1),
(-1, 1, 1)
)
edges = (
(0,1),
(0,3),
(0,4),
(2,1),
(2,3),
(2,7),
(6,3),
(6,4),
(6,7),
(5,1),
74
Pygame
(5,4),
(5,7)
)
The cube() function performs OpenGL drawing:
def Cube():
glBegin(GL_LINES)
for edge in edges:
for vertex in edge:
glVertex3fv(verticies[vertex])
glEnd()
The GL_LINES attribute to glBegin() tells that lines are to be drawn.
We need to specify OPENGL and DOUBLEBUF flags in set_mode() function that sets up the
display.
pygame.display.set_mode(display, DOUBLEBUF|OPENGL)
Then call the gluPerspective() determines the perspective. The first parameter is the
degree of the field of view. The second value is the aspect ratio. The next two values here
are the znear and zfar, which are the near and far clipping planes.
gluPerspective(45, (display[0]/display[1]), 0.1, 50.0)

glTranslatef(0.0,0.0, -5)
Inside the Pygame event loop, first rotate the current matrix, clear the color buffer and
depth buffer, and call cube() function. Finally, we update the display window.
while True:
pygame.quit()
quit()
glRotatef(1, 3, 1, 1)
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
Cube()
pygame.time.wait(10)
The complete code of the example is as follows:
import pygame
75
Pygame
from OpenGL.GL import *

from OpenGL.GLU import *
verticies = (
(1, -1, -1),
(1, 1, -1),
(-1, 1, -1),
(-1, -1, -1),
(1, -1, 1),
(1, 1, 1),
(-1, -1, 1),
(-1, 1, 1)
)
edges = (
(0,1),
(0,3),
(0,4),
(2,1),
(2,3),
(2,7),
(6,3),
(6,4),
(6,7),
(5,1),
(5,4),
(5,7)
)
def Cube():
glBegin(GL_LINES)
for edge in edges:
for vertex in edge:
glVertex3fv(verticies[vertex])
76
Pygame
glEnd()
def main():
pygame.init()
display = (800,600)
pygame.display.set_mode(display, DOUBLEBUF|OPENGL)
gluPerspective(45, (display[0]/display[1]), 0.1, 50.0)
glTranslatef(0.0,0.0, -5)
while True:
pygame.quit()
quit()
glRotatef(1, 3, 1, 1)
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
Cube()
pygame.time.wait(10)
main()
Run the above code. You will see a rotating cube on Pygame’s window surface. This is a
short demonstration of capability of PyOpenGL. A detailed discussion of this library is
beyond the scope of this tutorial.
77
Pygame
78
27. Pygame — Errors and Exception Pygame
Top level pygame module defines pygame.error as a standard Pygame exception. This
exception is raised whenever a pygame or SDL operation fails. You can catch any
anticipated problems and deal with the error. The exception is always raised with a
descriptive message about the problem.
>>> import pygame

pygame 1.9.6
Hello from the pygame community. https://www.pygame.org/contribute.html
>>> screen = pygame.display.set_mode((640, -1))
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
screen = pygame.display.set_mode((640, -1))
pygame.error: Cannot set negative sized display mode
Being derived from the RuntimeError exception, which can also be used to catch these
raised errors.
>>> try:
screen = pygame.display.set_mode((640, -1))
except pygame.error as e:
print ("unable to set display: ", e)
unable to set display Cannot set: negative sized display mode
There are two more functions in this module to set and retrieve error message.
set_error(error_msg)
SDL maintains an internal error message. When pygame.error()standard pygame
exception is raised, this string is used as error message.
It gets the current error message.
get_error()
It returns the string as error message of pygame.error() message.
79

Pygame Tutorial

Uploaded by

Copyright:

Available Formats

Pygame Tutorial

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Pygame Tutorial

Uploaded by

Copyright:

Available Formats

Pygame

About the Tutorial

Copyright & Disclaimer

Copyright & Disclaimer .................................................................................................................................... 2

Table of Contents ............................................................................................................................................ 3

1. Pygame — Overview ................................................................................................................................. 5

Environment Setup .......................................................................................................................................... 5

2. Pygame — Hello World ............................................................................................................................. 8

3. Pygame — Display modes ....................................................................................................................... 10

4. Pygame — Locals module ....................................................................................................................... 11

5. Pygame — Color object ........................................................................................................................... 12

6. Pygame — Event objects ......................................................................................................................... 14

7. Pygame — Keyboard events ................................................................................................................... 15

8. Pygame — Mouse events ........................................................................................................................ 17

9. Pygame —Drawing shapes ...................................................................................................................... 19

10. Pygame — Loading image ....................................................................................................................... 22

11. Pygame — Displaying Text in Window .................................................................................................... 26

12. Pygame — Moving an image ................................................................................................................... 31

13. Pygame — Moving with Numeric pad keys ............................................................................................. 34

14. Pygame — Moving with mouse............................................................................................................... 36

15. Pygame — Moving Rectangular objects .................................................................................................. 37

16. Pygame — Use Text as Buttons ............................................................................................................... 45

17. Pygame — Transforming Images ............................................................................................................. 49

18. Pygame — Sound objects ........................................................................................................................ 56

19. Pygame — Mixer channels ...................................................................................................................... 59

20. Pygame — Playing music ........................................................................................................................ 60

21. Pygame — Playing Movie ........................................................................................................................ 63

22. Pygame — Using Camera module ........................................................................................................... 65

23. Pygame — Load cursor............................................................................................................................ 67

24. Pygame — Access CDROM ...................................................................................................................... 69

25. Pygame — The Sprite Module ................................................................................................................. 71

26. Pygame — PyOpenGL ............................................................................................................................. 74

27. Pygame — Errors and Exception ............................................................................................................. 79

pip3 install pygame

For Raspberri Pi, Pygame is pre-installed in raspbian Linus distribution. As far as

For Ubuntu, following is the command:

sudo apt-get install pygame

For Fedora, the following is the command:

sudo yum install pygame

It is also possible to compile Pygame’s source code (available at

Hello from the pygame community. https://www.pygame.org/contribute.html

Pygame library consists of following modules:

pygame._sdl2.touch to work with touch input

pygame.camera camera use

pygame.cdrom audio cdrom control

pygame.cursors cursor resources

pygame.display to control the display window and screen

pygame.draw drawing shapes

pygame.event interacting with events and queues

pygame.examples module of example programs

pygame.fastevent interacting with events and queues from multiple

pygame.font loading and rendering fonts

pygame.freetype loading and rendering computer fonts

pygame.gfxdraw drawing shapes

pygame.image image transfer

pygame.joystick interacting with joysticks, gamepads, and trackballs.

pygame.key to work with the keyboard

pygame.locals pygame constants

pygame.mask image masks.