1

sudo apt-get install python-pygame

1
2

>>> import pygame
>>> print pygame.ver

1
2
3

if pygame.font is None:
    print 'The font module is not available!'
    exit()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

background_image_filename = 'sushiplate.jpg'
mouse_image_filename = 'fugu.png'

import pygame
from pygame.locals import *
from sys import exit

pygame.init()

screen = pygame.display.set_mode((640, 480), 0, 32)
pygame.display.set_caption('Hello, World!')

background = pygame.image.load(background_image_filename).convert()
mouse_cursor = pygame.image.load(mouse_image_filename).convert_alpha()

while True:
    for event in pygame.event.get():
        if event.type == QUIT:
            exit()

    screen.blit(background, (0, 0))

    x, y = pygame.mouse.get_pos()
    x -= mouse_cursor.get_width() / 2
    y -= mouse_cursor.get_height() / 2
    screen.blit(mouse_cursor, (x, y))

    pygame.display.update()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

init(...)
    pygame.init(): return (numpass, numfail)
    initialize all imported pygame modules

set_mode(...)
    pygame.display.set_mode(resolution=(0,0), flags=0, depth=0): return Surface
    initialize a window or screen for display

set_caption(...)
    pygame.display.set_caption(title, icontitle=None): return None
    set the current window caption

load(...)
    pygame.image.load(filename): return Surface
    pygame.image.load(fileobj, namehint=): return Surface
    load new image from a file

convert(...)
    Surface.convert(Surface): return Surface
    Surface.convert(depth, flags=0): return Surface
    Surface.convert(masks, flags=0): return Surface
    Surface.convert(): return Surface
    change the pixel format of an image

convert_alpha(...)
    Surface.convert_alpha(Surface): return Surface
    Surface.convert_alpha(): return Surface
    change the pixel format of an image including per pixel alphas

get(...)
    pygame.event.get(): return Eventlist
    pygame.event.get(type): return Eventlist
    pygame.event.get(typelist): return Eventlist
    get events from the queue

blit(...)
    Surface.blit(source, dest, area=None, special_flags = 0): return Rect
    draw one image onto another

get_pos(...)
    pygame.mouse.get_pos(): return (x, y)
    get the mouse cursor position

get_width(...)
    Surface.get_width(): return width
    get the width of the Surface

get_height(...)
    Surface.get_height(): return height
    get the height of the Surface

update(...)
    pygame.display.update(rectangle=None): return None
    pygame.display.update(rectangle_list): return None
    update portions of the screen for software displays

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import pygame
from pygame.locals import *
from sys import exit

pygame.init()
SCREEN_SIZE = (800, 600)
screen = pygame.display.set_mode(SCREEN_SIZE, 0, 32)

font = pygame.font.SysFont('arial', 16)
font_height = font.get_linesize()
event_text = []

while True:
    event = pygame.event.wait()
    event_text.append(str(event))
    event_text = event_text[-SCREEN_SIZE[1]/font_height:]

    if event.type == QUIT:
        exit()

    screen.fill((255, 255, 255))

    y = SCREEN_SIZE[1] - font_height
    for text in reversed(event_text):
        screen.blit(font.render(text, True, (0, 0, 0)), (0, y))
        y -= font_height

    pygame.display.update()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

SysFont(name, size, bold=False, italic=False)
    pygame.font.SysFont(name, size, bold=False, italic=False) -> Font
    create a pygame Font from system font resources
    
    This will search the system fonts for the given font
    name. You can also enable bold or italic styles, and
    the appropriate system font will be selected if available.
    
    This will always return a valid Font object, and will
    fallback on the builtin pygame font if the given font
    is not found.
    
    Name can also be a comma separated list of names, in
    which case set of names will be searched in order. Pygame
    uses a small set of common font aliases, if the specific
    font you ask for is not available, a reasonable alternative
    may be used.

get_linesize(...)
    Font.get_linesize(): return int
    get the line space of the font text

wait(...)
    pygame.event.wait(): return Event
    wait for a single event from the queue

render(...)
    Font.render(text, antialias, color, background=None): return Surface
    draw text on a new Surface

fill(...)
    Surface.fill(color, rect=None, special_flags=0): return Rect
    fill Surface with a solid color

pump(...)
    pygame.event.pump(): return None
    internally process pygame event handlers

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

bg_file = 'sushiplate.jpg'

import pygame
from pygame.locals import *
from sys import exit

pygame.init()
screen = pygame.display.set_mode((640, 480), FULLSCREEN, 32)
background = pygame.image.load(bg_file).convert()

x, y = 0, 0
move_x, move_y = 0, 0

while True:
    for event in pygame.event.get():
        if event.type == QUIT:
            exit()
        if event.type == KEYDOWN:
            if event.key == K_LEFT:
                move_x = -1
            elif event.key == K_RIGHT:
                move_x = 1
            elif event.key == K_UP:
                move_y = -1
            elif event.key == K_DOWN:
                move_y = 1
        elif event.type == KEYUP:
            if event.key == K_LEFT or event.key == K_RIGHT:
                move_x = 0
            elif event.key == K_UP or event.key == K_DOWN:
                move_y = 0
    x += move_x
    y += move_y

    screen.fill((0, 0, 0))
    screen.blit(background, (x, y))

    pygame.display.update()

1
2
3
4
5
6
7
8
9

pygame.event.set_blocked(MOUSEMOTION)
pygame.event.set_blocked([KEYDOWN, KEYUP])
pygame.event.set_blocked(None)

set_blocked(...)
    pygame.event.set_blocked(type): return None
    pygame.event.set_blocked(typelist): return None
    pygame.event.set_blocked(None): return None
    control which events are allowed on the queue

1
2
3
4
5

set_allowed(...)
    pygame.event.set_allowed(type): return None
    pygame.event.set_allowed(typelist): return None
    pygame.event.set_allowed(None): return None
    control which events are allowed on the queue

1
2
3

get_blocked(...)
    pygame.event.get_blocked(type): return bool
    test if a type of event is blocked from the queue

1
2

my_event = pygame.event.Event(KEYDOWN, key=K_SPACE, mod=0, unicode=u' ')
pgame.event.post(my_event)

1
2
3
4
5
6
7
8

Event(...)
    pygame.event.Event(type, dict): return Event
    pygame.event.Event(type, **attributes): return Event
    create a new event object

post(...)
    pygame.event.post(Event): return None
    place a new event on the queue

1
2
3
4
5
6
7

CATONKEYBOARD = USEREVENT + 1
my_event = pygame.event.Event(CATONKEYBOARD, message="Bad cat!")
pgame.event.post(my_event)

for event in pygame.event.get():
    if event.type == CATONKEYBOARD:
        print event.message

1

screen = pygame.display.set_mode((640, 480), FULLSCREEN, 32)

1
2
3
4
5
6
7

>>> import pygame
>>> pygame.init()
>>> pygame.display.list_modes()

list_modes(...)
    pygame.display.list_modes(depth=0, flags=pygame.FULLSCREEN): return list
    get list of available fullscreen modes

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

background_image_filename = 'sushiplate.jpg'

import pygame
from pygame.locals import *
from sys import exit

pygame.init()
screen = pygame.display.set_mode((640, 480), 0, 32)
background = pygame.image.load(background_image_filename).convert()

Fullscreen = False

while True:
    for event in pygame.event.get():
        if event.type == QUIT:
            exit()

    if event.type == KEYDOWN:
        if event.key == K_f:
            Fullscreen = not Fullscreen
            if Fullscreen:
                screen = pygame.display.set_mode((640, 480), FULLSCREEN, 32)
            else:
                screen = pygame.display.set_mode((640, 480), 0, 32)

    screen.blit(background, (0, 0))
    pygame.display.update()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

background_image_filename = 'sushiplate.jpg'

import pygame
from pygame.locals import *
from sys import exit

SCREEN_SIZE = (640, 480)

pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE, RESIZABLE, 32)

background = pygame.image.load(background_image_filename).convert()

while True:
    event = pygame.event.wait()
    if event.type == QUIT:
        exit()
    if event.type == VIDEORESIZE:
        SCREEN_SIZE = event.size
        screen = pygame.display.set_mode(SCREEN_SIZE, RESIZABLE, 32)
        pygame.display.set_caption('Window resized to ' + str(event.size))

    screen_width, screen_height = SCREEN_SIZE
    for y in range(0, screen_height, background.get_height()):
        for x in range(0, screen_width, background.get_width()):
            screen.blit(background, (x, y))

    pygame.display.update()

1

screen = pygame.display.set_mode(SCREEN_SIZE, HWSURFACE | FULLSCREEN, 32)

1

screen = pygame.display.set_mode(SCREEN_SIZE, DOUBLEBUF | HWSURFACE | FULLSCREEN, 32)

1
2
3

flip(...)
    pygame.display.flip(): return None
    update the full display Surface to the screen

1

my_font = pygame.font.SysFont("arial", 16)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

my_font = pygame.font.Font("my_font.ttf", 16)

class Font(__builtin__.object)
 |  pygame.font.Font(filename, size): return Font
 |  pygame.font.Font(object, size): return Font
 |  create a new Font object from a file

get_fonts()
    pygame.font.get_fonts() -> list
    get a list of system font names
    
    Returns the list of all found system fonts. Note that
    the names of the fonts will be all lowercase with spaces
    removed. This is how pygame internally stores the font
    names for matching.

1
2
3
4
5

text_surface = my_font.render("Pygame is cool!", True, (0,0,0), (255, 255, 255))

render(...)
    Font.render(text, antialias, color, background=None): return Surface
    draw text on a new Surface

1
2
3
4
5
6
7

import pygame
pygame.init()

my_name = 'Smith'
my_font = pygame.font.SysFont('arial', 64)
name_surface = my_font.render(my_name, True, (0, 0, 0), (255, 255, 255))
pygame.image.save(name_surface, 'name.png')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

>>> import pygame
>>> screen = pygame.display.set_mode((640, 0))
Traceback (most recent call last):
File "<interactive input>", line 1, in ?
pygame.error: Cannot set 0 sized display mode

class error(exceptions.RuntimeError)
 |  Method resolution order:
 |      error
 |      exceptions.RuntimeError
 |      exceptions.StandardError
 |      exceptions.Exception
 |      exceptions.BaseException
 |      __builtin__.object

1
2
3
4
5
6

try:
    screen = pygame.display.set_mode(SCREEN_SIZE)
except pygame.error, e:
    print "Can't create the display :-("
    print e
    exit()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

background_image_filename = 'sushiplate.jpg'
SCREEN_SIZE = (640, 480)
message = '    This is a demonstration of the scrolly message script.    '

import pygame
from pygame.locals import *
from sys import exit

pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE)

font = pygame.font.SysFont('arial', 80)
text_surface = font.render(message, True, (0, 0, 255))

x = 0
y = (SCREEN_SIZE[1] - text_surface.get_height()) / 2

background = pygame.image.load(background_image_filename).convert()

while True:
    for event in pygame.event.get():
        if event.type == QUIT:
            exit()

    screen.blit(background, (0, 0))

    x -= 2
    if x < -text_surface.get_width():
        x = 0

    screen.blit(text_surface, (x, y))
    screen.blit(text_surface, (x + text_surface.get_width(), y))

    pygame.display.update()