PyGame se compone de distintos módulos que se utilizan para acceder a los distintos dispositivos o recursos que gestiona, estos son:

• pygame.cdrom - Acceso a los lectores de cd.
• pygame.cursors - Acceso al cursor.
• pygame.display - Acceso a la pantalla\ventana.
• pygame.draw - Dibujo.
• pygame.event - Encargado de gestionar eventos.
• pygame.font - Encargado del uso de las fuentes del sistema.
• pygame.image - Acciones con las imágenes.
• pygame.joystick - Acceso a joysticks y dispositivos de entrada.
• pygame.key - Lectura de teclado.
• pygame.mixer - Acciones con sonido.
• pygame.mouse - Gestiona el ratón.
• pygame.movie - Gestiona la reproducción de archivos de video.
• pygame.music - Gestiona el trabajo de archivos de audio (en streaming).
• pygame.overlay -
• pygame - Funciones de PyGame
• pygame.rect - Gestión de áreas rectangulares.
• pygame.sndarray - Gestiona datos de audio.
• pygame.sprite - Gestiona el movimiento de imágenes.
• pygame.surface - Gestiona la relación entre las imágenes y la ventana.
• pygame.surfarray - Manipula el array de píxels.
• pygame.time - Gestiona el tiempo.
• pygame.transform - Realiza los movimientos de imágenes.

Es posible que un módulo no esté activo, esto puede ser debido a que, por ejemplo, no estén instalados los lectores de cds. En ese caso ese módulo queda asignado como None.

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

Para utilizar estos módulos, al principio de cada script deberemos importar pygame y luego pygame.locals que es donde están todas las funciones y constantes.

import pygame
from pygame.locals import *

Para inicializar los módulos podemos hacerlo llamando a la función init de cada uno de los módulos por separado (por ejemplo, pygame.sound.init()) o llamar a la función dentro de pygame.

pygame.init()

Una ventana, a partir de ahora display, puede estar en modo normal, como una ventana del sistema, o en fullscreen. La llamada a pygame.display.set_mode retorna el objeto Surface que representa a dicha ventana. Este método recibe tres parámetros, de los cuales sólo el primero es necesario:

• Una tupla de dos elementos correspondientes al ancho y alto de la ventana.
• Los flags de creación que podremos combinar mediante el signo de OR (|), estos pueden ser:
  • FULLSCREEN, que crea una ventana en fullscreen.
  • DOUBLEBUF, crea una ventana con doble buffer. Recomendada para HWSURFACE o OPENGL.
  • HWSURFACE, que crea una ventana con aceleración de hardware, ha de ser combinada con la flag de FULLSCREEN.
  • OPENGL, que crea una ventana OpenGL.
  • RESIZABLE, crea una ventana que puede cambiar de tamaño.
  • NOFRAME, crea una ventana sin bordes.
• El bit de profundidad de color (24, 32…). Si ponemos 0 se pondrá el del escritorio.

Si todo ha ido bien en la llamada a set_mode se retornará el objeto Suface. El método de pygame.display.set_caption colocará el título en la ventana.

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

Otros métodos:

• flip: Actualiza toda la ventana (que no la surface).
• set_icon: Cambia el icono de la ventana.
• get_driver: Devuelve el nombre del driver que está utilizando pygame.

La función pygame.image.load carga una imágen como Surface. Los objetos Surface tienen métodos que hacen la imágen compatible con nuestra ventana y a la vez permiten manipularla. Para dibujar una imágen en la ventana haremos: <surface>.blit(<surface>,<tupla, posición>):

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

Para saber el ancho y el alto de un objeto imágen utilizaremos sus métodos get_width y get_height.

Para ello usaremos la función: master_image.subsurface. Por ejemplo la siguiente función devuelve un array de imágenes indicándole la imágen inicial y el número de subimágenes que contiene, entonces va cogiendolas y agregándolas a un array:

def load_sliced_sprites(num, filename):
    images = []
    master_image = pygame.image.load(filename).convert_alpha()
    master_width, master_height = master_image.get_size()
    w = master_width / num
    for i in range(0, num):
        images.append(master_image.subsurface((i*w,0,w,master_height)))
    return images

• Ejemplo de animación

A partir de pygame.draw podemos dibujar elementos como:

• line, una línea. Se le pasan la surface, el color, la posición incial y la final.
• rect
• circle

import pygame
from pygame.locals import *
import sys
 
w = 640
h = 489
screen = pygame.display.set_mode((w,h))
pygame.draw.line(screen, (255, 0, 0), (0,0), (w,h))
pygame.display.flip()
 
while True:
    for event in pygame.event.get():
        if event.type == QUIT:
            sys.exit()
    pygame.display.update()

Los eventos se encuentran en una cola en pygame.event, recogeremos dichos eventos llamando al método get(); estos tendrán un tipo (type), los posibles están definidos en pygame.locals y significan:

• QUIT que el usuario ha hecho click en el botón de cerrar.
• KEYDOWN o KEYUP que el usuario ha pulsado una tecla, tendrán una propiedad llamada key que define (como K_XXX) la tecla pulsada.
• Respecto al uso del ratón los eventos posibles son MOUSEMOTION (que tiene las propiedades pos, rel, buttons) o MOUSEBUTTONUP y MOUSEBUTTONDOWN (que tienen las propiedades pos y button).

for event in pygame.event.get():
	if event.type == QUIT:
		exit()
	if event.type == KEYDOWN:
		if event.key == K_LEFT:
			self.snake.direction = [-1, 0]
		elif event.key == K_RIGHT:
			self.snake.direction = [1, 0]
		elif event.key == K_UP:
			self.snake.direction = [0, -1]
		elif event.key == K_DOWN:
			self.snake.direction = [0, 1]
		elif event.key == K_ESCAPE:
			exit()
        if event.type == pygame.MOUSEMOTION:
                x, y = event.pos

• Mediante el método pygame.event.clear() eliminaremos los eventos existentes en la cola.
• Mediante pygame.event.post(Event) agregaremos un evento a la cola.
• El objeto correspondiente a un evento es el pygame.event.Event. Su constructor recibe el tipo y un diccionario de los atributos.

Existe una clase en pygame denominada pygame.sprite.Sprite que puede ser usada como clase base para trabajar con sprites.

En pygame.time tenemos clases y funciones para controlar\monitorizar el tiempo.

• get_ticks: Recoge los milisegundos que han pasado desde que se llamó a pygame.init.
• delay: Pausa el proceso el número de milisegundos indicado.
• set_timer: Crea un evento al cual se llamará cada x milisegundos indicados.

Es la clase helper para ayudar a controlar el tiempo. Tiene los siguientes métodos:

• tick
• tick_busy_loop
• get_time
• get_rawtime
• get_fps

• Coger la posición actual del mouse mediante la línea x, y = pygame.mouse.get_pos()

Para así utilizar otro motor de rendirazado o realizar test… Antes de importar pygame definimos las variables con las que se inicializará este.

import os
os.environ['SDL_VIDEODRIVER'] = 'dummy'
import pygame
 
pygame.init()
pygame.display.set_mode((1,1))
 
while 1:
    events = pygame.event.get()
    for e in events:
        pass

def toggle_fullscreen():
    screen = pygame.display.get_surface()
    tmp = screen.convert()
    caption = pygame.display.get_caption()
    cursor = pygame.mouse.get_cursor()  # Duoas 16-04-2007 
 
    w,h = screen.get_width(),screen.get_height()
    flags = screen.get_flags()
    bits = screen.get_bitsize()
 
    pygame.display.quit()
    pygame.display.init()
 
    screen = pygame.display.set_mode((w,h),flags^FULLSCREEN,bits)
    screen.blit(tmp,(0,0))
    pygame.display.set_caption(*caption)
 
    pygame.key.set_mods(0) #HACK: work-a-round for a SDL bug??
 
    pygame.mouse.set_cursor( *cursor )  # Duoas 16-04-2007
 
    return screen

import pygame, random
pygame.init()
screen = pygame.display.set_mode([300,100])
screen.fill([255,255,255])
mainloop, x,y, color, fontsize, delta, fps =  True, 25 , 0, (32,32,32), 35, 1, 30
clock = pygame.time.Clock() # create clock object
while mainloop:
    tick_time = clock.tick(fps) # milliseconds since last frame
    pygame.display.set_caption("press Esc to quit. FPS: %.2f" % (clock.get_fps()))
    fontsize = random.randint(35, 150)
    myFont = pygame.font.SysFont("None", fontsize)
    color = (random.randint(0,255), random.randint(0,255), random.randint(0,255))
    screen.fill((255,255,255))
    screen.blit(myFont.render("I love the pygame cookbook", 0, (color)), (x,y))
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            mainloop = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                mainloop = False
    pygame.display.update()

Es un paquete que se encuentra en http://code.google.com/p/gameobjects/ con varias clases de ayuda para la creación de juegos con Python.

• gameobjects.0.0.3.rar