¿Quiere escribir su primer juego pero no sabe por dónde empezar con el desarrollo de videojuegos? Pygame elimina esa barrera. Usted escribe en Python puro e inmediatamente ve el resultado en pantalla: un sprite que se mueve, respuesta a la entrada del teclado, mecánicas vivas. Sin motores pesados, sin miles de líneas de código repetitivo.

El problema con la mayoría de los tutoriales es que o lo entierran en 40 páginas de teoría o lo dejan con un «termínelo usted mismo». Aquí tomaremos el camino intermedio: explicar lo justo para que entienda cada línea y construir de inmediato un juego funcional con un personaje que se mueve por la pantalla usando WASD. El código completo cabe en 60 líneas.

💡 Resumen rápido:

• Instale Pygame vía pip y cree un archivo de juego, toma un par de minutos
• Comprenda el bucle de juego: eventos, cálculos, renderizado, tres fases que viven en un while True infinito
• Escriba una clase de jugador y dele vida: las teclas WASD mueven el sprite, la pantalla se redibuja 60 veces por segundo
• Comprenda el sistema de coordenadas y el manejo de color, dos pilares que sostienen cualquier gráfico 2D

Qué es Pygame y por qué elegirlo

Pygame es una biblioteca para Python que envuelve la multimedia SDL (Simple DirectMedia Layer) en una API de Python conveniente. SDL maneja el trabajo de bajo nivel con gráficos, sonido y dispositivos de entrada, mientras que Pygame proporciona acceso a través de clases y métodos familiares. La versión actual, 2.6.0, tiene mantenimiento activo y funciona en Windows, macOS y Linux.

Para principiantes, Pygame tiene tres ventajas innegables. Primero, baja barrera de entrada: usted usa código Python ordinario, sin un nuevo lenguaje ni editor visual. Segundo, retroalimentación instantánea: escribe pygame.draw.rect(...) y un rectángulo aparece en pantalla, sin magia. Tercero, comprensión de los fundamentos: Pygame no le oculta el bucle de juego ni la cola de eventos, usted ve cómo funciona cualquier juego por dentro. Después de Pygame, migrar a Godot o Unity será más fácil porque ya sabe qué son el delta time y el sondeo de eventos.

La biblioteca no intenta ser un motor de juego. No tiene sistema de escenas, física ni editor de niveles integrado, y esa es una decisión deliberada. Usted controla cada píxel y cada tic, lo que significa que aprende a pensar como un desarrollador de videojuegos, no como un operador de la herramienta de otro.

Instalar Pygame en dos minutos

¿Ya tiene Python 3.9 o más reciente? Entonces abra una terminal y ejecute un comando:

1
pip install pygame

Para aislamiento del proyecto, es mejor crear un entorno virtual:

1
python -m venv game_env
2
game_env\Scripts\activate     # Windows
3
source game_env/bin/activate  # macOS / Linux
4
pip install pygame

Verifique que la biblioteca esté instalada:

1
import pygame
2
print(pygame.version.ver)

Si obtiene 2.6.0 como respuesta (o más reciente, puede consultar la versión actual en pygame.org), está listo. Cree una carpeta de proyecto, coloque dentro cualquier imagen de sprite de 80×80 píxeles llamada player.png y un archivo de texto game.py, comenzaremos con eso.

Cómo funciona el bucle de juego: eventos, cálculos, renderizado

El corazón de cualquier juego es el bucle principal. Mientras el juego se ejecuta, dentro de un while True infinito, se alternan tres fases:

• Procesamiento de eventos, ¿qué ocurrió desde el último fotograma? ¿Se presionó una tecla? ¿Se movió el ratón? ¿Se cerró la ventana? Pygame reúne todos los eventos en una cola y nosotros iteramos sobre ella con for event in pygame.event.get().

• Cálculo de lógica, ¿cómo cambió el mundo en respuesta a los eventos? El jugador presionó W, incremente la coordenada Y. La bala colisionó con el asteroide, marque ambos para eliminación.

• Renderizado, dibuje todo lo que debería estar en pantalla. Rellene el fondo, coloque los sprites en las nuevas coordenadas, llame a pygame.display.update() y el jugador ve un fotograma.

Estos tres pasos se repiten 60 veces por segundo, exactamente la tasa de fotogramas (FPS) que fijaremos en el temporizador. La ilusión de movimiento se construye sobre el desplazamiento del sprite un par de píxeles entre fotogramas, mientras el ojo percibe esto como animación continua.

Escribir el primer código: mover un sprite por la pantalla

Aquí está el código completo del juego. Guárdelo como game.py y coloque player.png en la misma carpeta:

1
#!/usr/bin/env python3
2
 
3
import pygame
4
import sys
5
 
6
WIDTH, HEIGHT = 360, 480
7
WHITE = (255, 255, 255)
8
 
9
class Player(pygame.sprite.Sprite):
10
 
11
    def __init__(self, image_path):
12
        super().__init__()
13
        self.image = pygame.image.load(image_path)
14
        self.x = WIDTH / 2
15
        self.y = HEIGHT / 2
16
        self.speed = 5
17
 
18
    def move(self, dx, dy):
19
        self.x += dx
20
        self.y += dy
21
 
22
def main():
23
    pygame.init()
24
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
25
    pygame.display.set_caption("First Game on Pygame")
26
 
27
    clock = pygame.time.Clock()
28
    fps = 60
29
 
30
    player = Player("player.png")
31
    dx, dy = 0, 0
32
 
33
    running = True
34
    while running:
35
        for event in pygame.event.get():
36
            if event.type == pygame.QUIT:
37
                running = False
38
 
39
            elif event.type == pygame.KEYDOWN:
40
                if event.key == pygame.K_d:
41
                    dx = player.speed
42
                elif event.key == pygame.K_a:
43
                    dx = -player.speed
44
                elif event.key == pygame.K_w:
45
                    dy = -player.speed
46
                elif event.key == pygame.K_s:
47
                    dy = player.speed
48
 
49
            elif event.type == pygame.KEYUP:
50
                if event.key in (pygame.K_d, pygame.K_a):
51
                    dx = 0
52
                elif event.key in (pygame.K_w, pygame.K_s):
53
                    dy = 0
54
 
55
        player.move(dx, dy)
56
        screen.fill(WHITE)
57
        screen.blit(player.image, (player.x, player.y))
58
        pygame.display.update()
59
        clock.tick(fps)
60
 
61
    pygame.quit()
62
    sys.exit()
63
 
64
if __name__ == "__main__":
65
    main()

Ejecute python game.py, se abrirá una ventana con fondo blanco y su sprite en el centro. Mantenga presionada W, A, S o D, el personaje se mueve. Suéltela, se detiene. Esto ya es un juego real, aunque mínimo.

Qué se mejoró respecto a los tutoriales clásicos: se agregó el manejador KEYUP para la liberación de teclas. Sin él, el sprite viajaría fuera de la pantalla para siempre tras la primera pulsación. Y el código está envuelto en la construcción if __name__ == "__main__", una buena práctica que permite importar el archivo como módulo sin lanzar el juego.

Sistema de coordenadas y manejo de color

En Pygame, las coordenadas se cuentan desde la esquina superior izquierda: (0, 0), el extremo superior izquierdo. Moverse a la derecha incrementa X, moverse hacia abajo incrementa Y. Esto difiere del sistema de coordenadas escolar donde Y crece hacia arriba, solo recuérdelo y compruébelo en las dos primeras ejecuciones: presionó S, el sprite bajó; presionó W, subió.

El color se especifica mediante una tupla de tres números (R, G, B), cada uno de 0 a 255. El blanco corresponde a (255, 255, 255), el negro a (0, 0, 0), el rojo a (255, 0, 0). El método screen.fill(WHITE) rellena toda la pantalla con el color seleccionado antes de renderizar cada fotograma. Si no lo hace, el sprite dejará un rastro de sus posiciones anteriores.

Qué sucede bajo el capó: desglose línea por línea

La clase Player hereda de pygame.sprite.Sprite, la clase integrada de Pygame para objetos de juego. En el constructor, cargamos la imagen mediante pygame.image.load() y establecemos la posición inicial en el centro de la pantalla: WIDTH / 2 y HEIGHT / 2. El método move(dx, dy) recibe el desplazamiento y lo suma a las coordenadas actuales, aritmética pura, sin magia.

La función main() reúne todo. pygame.init() inicia los subsistemas internos. pygame.display.set_mode() crea una ventana, y screen es una superficie sobre la que dibujamos. pygame.time.Clock() crea un temporizador: su método tick(fps) al final del bucle le dice a Pygame «espera hasta que haya pasado 1/60 de segundo desde el último fotograma», así es como fijamos la tasa de fotogramas y no desperdiciamos CPU.

El bucle principal while running gira hasta que la bandera running se vuelve False. Dentro, las tres fases de las que hablamos arriba:

En el bucle for event in pygame.event.get(), sondeamos la cola de eventos. pygame.QUIT es la señal «el usuario hizo clic en el botón de cerrar ventana»: establezca running = False y en la siguiente iteración el bucle terminará. pygame.KEYDOWN se dispara cuando se presiona una tecla, y KEYUP cuando se libera. Para D y A cambiamos dx, para W y S cambiamos dy. Cuando se libera la tecla, ponemos a cero el componente de velocidad correspondiente, el sprite se detiene.

screen.blit(player.image, (player.x, player.y)), el método que «superpone» una imagen sobre otra. En nuestro caso, el sprite del jugador sobre la superficie principal de la pantalla en las coordenadas actuales. pygame.display.update() refresca la ventana y el jugador ve el fotograma terminado.

Nota: player.move() se llama antes de screen.fill(). Si los intercambia, el sprite se borrará en el mismo milisegundo en que aparece, simplemente no lo verá en pantalla. El orden de las operaciones en el bucle de juego es crítico.

Haga clic en el botón de cerrar, pygame.quit() descarga correctamente los subsistemas de Pygame y sys.exit() termina el proceso de Python. Sin pygame.quit() la ventana puede congelarse al cerrar, un pequeño detalle, pero el código debe ser limpio.

Video corto sobre el tema

Si la instrucción en texto no termina de encajar, aquí hay un excelente videocurso en inglés donde construyen Space Invaders en Pygame paso a paso. Todos los conceptos del artículo se muestran en vivo:

⁉️🤔 Preguntas frecuentes

¿Necesito saber POO para Pygame?

Sí, a nivel básico. Clases, métodos, herencia y self los necesitará desde el primer día: jugador, enemigos, balas y bonificaciones encajan naturalmente en un modelo de objetos. Si ha completado algún curso introductorio de Python que explicara class y __init__, es suficiente. El resto lo aprenderá sobre la marcha: Pygame no requiere patrones de diseño, la herencia ordinaria de Sprite es suficiente para docenas de prototipos. Un objeto de juego en Pygame es una clase que hereda de pygame.sprite.Sprite. En el constructor, carga el sprite mediante pygame.image.load(), establece las coordenadas iniciales y la velocidad. El método update() (o uno propio, como move()) cambia la posición cada fotograma. El bucle principal llama a update() en todos los objetos, luego los renderiza mediante screen.blit(). Sin magia, solo llamar a los métodos en el orden correcto 60 veces por segundo.

¿Pygame se ralentiza con gráficos 2D complejos?

Con una cantidad razonable de sprites, no. Las superficies en Pygame residen en RAM y blit es copia rápida de píxeles, no renderizado por software. Con mil objetos moviéndose simultáneamente podría alcanzar el límite de rendimiento de Python, pero para un plataformas, un shooter cenital o un tower defense hay margen. Si necesita exprimir el máximo rendimiento, use pygame.sprite.Group con renderizado automático y dirty rectangles para actualizaciones parciales de pantalla.

¿Puedo agregar sonido y música en Pygame?

Sí, de serie. El módulo pygame.mixer puede reproducir WAV y MP3. Un sonido de disparo se lanza mediante pygame.mixer.Sound("shoot.wav").play(), y la música de fondo se carga con pygame.mixer.music.load("theme.mp3") y pygame.mixer.music.play(-1) (la bandera -1 la reproduce en bucle). La única salvedad: pygame.mixer.init() debe llamarse antes de cargar sonidos, y para MP3 en Linux podría necesitar la biblioteca libmpg123.

¿Tiene sentido aprender Pygame en 2026 cuando existen Godot y Unity?

Absolutamente. Pygame no es un competidor de Godot, es una herramienta educativa y una capa ligera para prototipos 2D. Usted no aprende C# solo para mover un cuadrado, ni descifra el sistema de nodos para el Pong. Pygame le da una comprensión de cómo funcionan los juegos a un nivel más bajo: bucle de juego, almacenamiento en búfer de fotogramas, colisiones. Los programadores que comenzaron con Pygame lo tienen más fácil con Unity y Godot porque ven las mecánicas vivas detrás de las abstracciones del motor. Se escriben proyectos indie reales en Pygame, incluidos algunos comerciales; un pequeño plataformas o puzle puede lanzarse en Steam sin tocar C++.

¿Qué hacer si el sprite se sale de la pantalla?

Agregue verificación de límites al método move(): si self.x < 0, establézcalo en 0; si self.x + sprite_width > WIDTH, establézcalo en WIDTH - sprite_width. Lo mismo para Y. Esto se llama clamping, y sin ello el personaje eventualmente viajará a un área invisible. En juegos más avanzados, los límites son muros de nivel definidos mediante una cuadrícula de tiles o un array de colisiones.

¿Listo para lanzar su primer juego?

Copie el código de la sección «Escribir el primer código», guárdelo como game.py, coloque cualquier imagen de sprite junto a él y en pocos segundos verá una ventana con un personaje en movimiento. Este es el punto de entrada al desarrollo de videojuegos: no leer, sino lanzar y empezar a ajustar parámetros.

Cambie WIDTH y HEIGHT, la ventana se hará más grande. Establezca player.speed = 10, el personaje acelerará. Reemplace WHITE con (35, 35, 35), obtendrá un fondo oscuro. Experimente y comprenderá que un programa de juego no es magia, sino una secuencia de pasos que usted controla.

Una vez que domine el movimiento, aborde las colisiones (pygame.sprite.collide_rect()), la animación (cambio de fotogramas en una hoja de sprites) y la generación procedural de niveles. Para empezar, basta con un archivo game.py y el deseo de entender cómo funciona.