Chuleta de pygame
Última actualización
Configuración y bucle del juego
Todo programa de pygame abre una ventana y luego repite un bucle hasta que el jugador sale.
| Operación | Código |
|---|---|
| Instalar pygame-ce | python3 -m pip install pygame-ce |
| Importar e iniciar pygame | import pygame
pygame.init() |
| Abrir una ventana | screen = pygame.display.set_mode((640, 480)) |
| Poner el título de la ventana | pygame.display.set_caption("My Game") |
| Crear un reloj | clock = pygame.time.Clock() |
| El bucle del juego | running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
screen.fill("black")
pygame.display.flip()
clock.tick(60) |
| Cerrar pygame al salir del bucle | pygame.quit() |
Pantalla
La pantalla es una Surface; no se ve nada hasta que llamas a flip.
| Operación | Código |
|---|---|
| Mostrar el fotograma terminado | pygame.display.flip() |
| Mostrar solo algunas zonas | pygame.display.update([rect1, rect2]) |
| Limpiar la pantalla | screen.fill((30, 30, 46)) |
| Tamaño de la ventana | screen.get_size(), screen.get_width() |
| La pantalla como Rect | screen.get_rect() |
| Ventana redimensionable | pygame.display.set_mode((640, 480), pygame.RESIZABLE) |
| Pantalla completa al tamaño del escritorio | pygame.display.set_mode((0, 0), pygame.FULLSCREEN) |
Colores y dibujo
Las funciones de pygame.draw reciben una superficie, un color y una posición. width=0 rellena.
| Operación | Código |
|---|---|
| Color en RGB | (255, 140, 0) |
| Color por nombre o hexadecimal | "tomato", "#ff8c00", pygame.Color("gold") |
| Rectángulo | pygame.draw.rect(screen, "red", (x, y, w, h)) |
| Borde y esquinas redondeadas | pygame.draw.rect(screen, "red", rect, width=2, border_radius=8) |
| Círculo (por su centro) | pygame.draw.circle(screen, "blue", (cx, cy), radius) |
| Línea | pygame.draw.line(screen, "white", (x1, y1), (x2, y2), 3) |
| Polígono | pygame.draw.polygon(screen, "green", [(0, 0), (40, 0), (20, 30)]) |
| Elipse dentro de una caja | pygame.draw.ellipse(screen, "purple", (x, y, w, h)) |
Rect
Un Rect guarda una posición y un tamaño como números enteros.
| Operación | Código |
|---|---|
| Crear un Rect | player = pygame.Rect(x, y, width, height) |
| Colocar por cualquier punto | player.center = (320, 240), player.bottom = 400 |
| Bordes y esquinas | left, right, top, bottom, topleft, midbottom |
| Mover en el sitio | player.move_ip(dx, dy) |
| Copia movida | moved = player.move(dx, dy) |
| Mantener dentro de la pantalla | player.clamp_ip(screen.get_rect()) |
| Agrandar alrededor del centro | bigger = player.inflate(20, 20) |
| Posiciones con decimales (pygame-ce) | pygame.FRect(10.5, 20.25, 40, 40) |
Imágenes, Surfaces y blit
Carga las imágenes una vez, antes del bucle, y luego haz blit de ellas en cada fotograma.
| Operación | Código |
|---|---|
| Cargar una imagen con transparencia | img = pygame.image.load("player.png").convert_alpha() |
| Cargar una imagen opaca | bg = pygame.image.load("sky.png").convert() |
| Dibujar una imagen | screen.blit(img, (x, y)) |
| Dibujar centrada | screen.blit(img, img.get_rect(center=(320, 240))) |
| Nueva Surface vacía | panel = pygame.Surface((200, 100)) |
| Surface transparente | layer = pygame.Surface((200, 100), pygame.SRCALPHA) |
| Atenuar una Surface entera | img.set_alpha(128) |
| Recortar un fotograma de una hoja de sprites | frame = sheet.subsurface((0, 0, 32, 32)) |
| Guardar una captura de pantalla | pygame.image.save(screen, "shot.png") |
Transformaciones
Cada función devuelve una Surface nueva; transforma el original, no el último resultado.
| Operación | Código |
|---|---|
| Redimensionar | pygame.transform.scale(img, (64, 64)) |
| Escalar por un factor | pygame.transform.scale_by(img, 2) |
| Redimensionar con suavizado | pygame.transform.smoothscale(img, (64, 64)) |
| Rotar (antihorario, en grados) | pygame.transform.rotate(img, 45) |
| Rotar alrededor del centro | rotated = pygame.transform.rotate(original, angle)
rect = rotated.get_rect(center=rect.center) |
| Reflejar en horizontal | pygame.transform.flip(img, True, False) |
Eventos y teclado
Usa eventos para pulsaciones sueltas y get_pressed() para teclas mantenidas.
| Operación | Código |
|---|---|
| Leer los eventos de este fotograma | for event in pygame.event.get(): |
| Ventana cerrada | event.type == pygame.QUIT |
| Se pulsó una tecla | event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE |
| Se soltó una tecla | event.type == pygame.KEYUP |
| Carácter escrito | event.unicode |
| Teclas mantenidas ahora | keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
x -= 5 |
| Dirección con dos teclas | dx = keys[pygame.K_RIGHT] - keys[pygame.K_LEFT] |
| Teclas pulsadas en este fotograma (pygame-ce) | pygame.key.get_just_pressed()[pygame.K_SPACE] |
| Constantes de teclas | K_a...K_z, K_0...K_9, K_UP, K_RETURN, K_ESCAPE, K_LSHIFT |
| Nombre de una tecla | pygame.key.name(event.key) |
| Evento propio | HIT = pygame.event.custom_type()
pygame.event.post(pygame.event.Event(HIT)) |
Ratón
Botones: 1 izquierdo, 2 central, 3 derecho.
| Operación | Código |
|---|---|
| Se pulsó un botón | event.type == pygame.MOUSEBUTTONDOWN and event.button == 1 |
| Dónde se pulsó | event.pos |
| Posición actual del puntero | x, y = pygame.mouse.get_pos() |
| Botones mantenidos ahora | left, middle, right = pygame.mouse.get_pressed() |
| El ratón se movió | event.type == pygame.MOUSEMOTION, event.rel |
| Se giró la rueda | event.type == pygame.MOUSEWHEEL, event.y |
| Clic dentro de un botón | button_rect.collidepoint(event.pos) |
| Ocultar el puntero | pygame.mouse.set_visible(False) |
Sprites y grupos
Un sprite guarda una image y un rect; un grupo actualiza y dibuja muchos.
| Operación | Código |
|---|---|
| Clase de sprite | class Coin(pygame.sprite.Sprite):
def __init__(self, pos):
super().__init__()
self.image = coin_img
self.rect = self.image.get_rect(center=pos) |
| Crear un grupo | coins = pygame.sprite.Group() |
| Añadir a un grupo | coins.add(Coin((100, 50))) |
| Actualizar todos los sprites | coins.update() |
| Dibujar todos los sprites | coins.draw(screen) |
| Quitar un sprite de todos los grupos | coin.kill() |
| Grupo con un solo sprite | player = pygame.sprite.GroupSingle(Player()) |
Colisiones
Dos Rect chocan cuando se solapan; tocarse solo por los bordes no cuenta.
| Operación | Código |
|---|---|
| Dos rectángulos | a.colliderect(b) |
| Punto dentro | rect.collidepoint(x, y) |
| El primero de varios | rect.collidelist(walls) # index or -1 |
| Sprite contra un grupo | hits = pygame.sprite.spritecollide(player, coins, True) |
| Cualquier choque | pygame.sprite.spritecollideany(player, enemies) |
| Grupo contra grupo | pygame.sprite.groupcollide(bullets, enemies, True, True) |
| Al píxel | pygame.sprite.spritecollide(a, group, False, pygame.sprite.collide_mask) |
| Círculos | pygame.Vector2(a).distance_to(b) < r1 + r2 |
Texto y fuentes
Renderiza el texto en una Surface y luego haz blit.
| Operación | Código |
|---|---|
| Fuente por defecto | font = pygame.font.Font(None, 36) |
| Fuente del sistema | font = pygame.font.SysFont("arial", 24) |
| Archivo de fuente | font = pygame.font.Font("pixel.ttf", 32) |
| Renderizar texto | text = font.render("Score: 10", True, "white") |
| Dibujarlo centrado | screen.blit(text, text.get_rect(center=(320, 40))) |
| Ajustar texto largo (pygame-ce) | font.render(story, True, "white", None, 400) |
| Tamaño sin renderizar | font.size("Hello") |
| Fuentes instaladas | pygame.font.get_fonts() |
Sonido y música
Carga los sonidos una vez. La música reproduce una pista en streaming desde su archivo.
| Operación | Código |
|---|---|
| Cargar un sonido | jump = pygame.mixer.Sound("jump.ogg") |
| Reproducirlo | jump.play() |
| Volumen del sonido | jump.set_volume(0.5) |
| Cargar música | pygame.mixer.music.load("theme.ogg") |
| Repetir la música sin fin | pygame.mixer.music.play(-1) |
| Pausar y reanudar | pygame.mixer.music.pause(), pygame.mixer.music.unpause() |
| Parar la música | pygame.mixer.music.stop() |
Tiempo y temporizadores
Los ticks se miden en milisegundos.
| Operación | Código |
|---|---|
| Limitar los fotogramas por segundo | clock.tick(60) |
| Delta time en segundos | dt = clock.tick(60) / 1000 |
| Fotogramas por segundo actuales | clock.get_fps() |
| Milisegundos desde init | pygame.time.get_ticks() |
| Evento de temporizador que se repite | SPAWN = pygame.event.custom_type()
pygame.time.set_timer(SPAWN, 1000) |
| Temporizador de una sola vez | pygame.time.set_timer(SPAWN, 2000, loops=1) |
| Parar un temporizador | pygame.time.set_timer(SPAWN, 0) |
Vector2
Decimales para posiciones y velocidades.
| Operación | Código |
|---|---|
| Crear un vector | pos = pygame.Vector2(100, 200) |
| Mover según una velocidad | pos += velocity * dt |
| Longitud | velocity.length() |
| Misma velocidad en diagonal | if direction.length() > 0:
direction = direction.normalize() |
| Distancia entre puntos | pos.distance_to(target) |
| Rotar | velocity.rotate(90) |
| Avanzar hacia un punto (pygame-ce) | pos.move_towards_ip(target, 5) |
El código de pygame que necesitas al hacer un juego 2D en Python, agrupado por tarea: el bucle del juego, la pantalla, los colores y el dibujo, Rect, las imágenes y blit, escalar y rotar, la entrada de teclado y ratón, los sprites y los grupos, las colisiones, el texto, el sonido, los temporizadores y Vector2. Cada fila es un fragmento corto para pegar, junto a lo que hace.
Todo aquí está escrito para pygame-ce 2.5, la edición comunitaria de pygame, que se sigue importando con import pygame. Las filas marcadas con pygame-ce usan sus novedades; el resto también funciona en el pygame original. Prueba cualquier fragmento en el playground de pygame, que ejecuta pygame en tu navegador sin instalar nada. ¿Eres nuevo en Python? Empieza por la chuleta de Python.
Preguntas frecuentes sobre la chuleta de pygame
¿Esta chuleta de pygame es gratis?
Sí. Es gratis y no hace falta registrarse. Guárdala en marcadores, o imprímela en PDF desde el navegador, y vuelve cuando necesites la llamada exacta para un grupo de sprites, un sonido o una comprobación de colisión.
¿Esta chuleta sirve para pygame y pygame-ce?
Sí. Los dos se importan con
import pygame y comparten casi toda la API. Las filas marcadas con pygame-ce (FRect, scale_by, get_just_pressed, el ajuste de texto y move_towards_ip) necesitan pygame-ce, y todo lo demás funciona en cualquiera de los dos.¿Por qué mi ventana de pygame no responde?
El bucle del juego no está leyendo los eventos. Llama a
pygame.event.get() una vez en cada fotograma, aunque ignores los eventos, y termina cada fotograma con pygame.display.flip() y clock.tick(60).¿Uso eventos o key.get_pressed() para la entrada?
Usa un evento
KEYDOWN para acciones que ocurren una vez por pulsación, como saltar o abrir un menú. Usa pygame.key.get_pressed() para acciones que duran mientras se mantiene una tecla, como caminar.Recursos relacionados
Más hojas de referencia
