Pygame es una de las herramientas más populares y accesibles para crear videojuegos con Python. Esta biblioteca de código abierto permite que programadores principiantes y expertos desarrollen juegos digitales de forma sencilla, gracias a su equilibrio entre facilidad de uso y funcionalidad.
A diferencia de otros entornos que requieren mucho tiempo de aprendizaje, Pygame permite a cualquier persona con conocimientos básicos de Python empezar a crear juegos en pocas horas.
Sus funciones para manejar gráficos, sonidos, controles de usuario y física básica son intuitivas y directas. Esta estructura permite que los desarrolladores se concentren en la creatividad y la lógica del juego sin perderse en complicaciones técnicas como ocurre con motores más avanzados como Unity o Unreal Engine. Para quienes comienzan en la programación de juegos, Pygame es un excelente punto de partida que conecta los conceptos básicos de programación con el desarrollo de experiencias interactivas.
Con estos conceptos en mente, te compartimos un tutorial completo que te guiará para crear un juego de carreras. Este proyecto está diseñado como una experiencia de aprendizaje paso a paso que abarca todos los aspectos básicos del desarrollo de videojuegos con Python, permitiéndote aplicar los principios de Pygame mientras construyes algo divertido y visualmente atractivo.
Es un juego de arcade de ritmo rápido donde el jugador controla un vehículo que avanza por una carretera con desplazamiento vertical. El objetivo principal consiste en evitar obstáculos mientras se recolectan objetos que aumentan la puntuación.
El juego incluye las siguientes características principales:
- Configuración de una ventana de juego con una tasa de fotogramas constante
- Implementación de movimiento fluido para el jugador
- Generación aleatoria de obstáculos
- Detección de colisiones para terminar el juego
- Sistema de seguimiento de puntuación
Ahora seguiremos este tutorial paso a paso para crear nuestro propio Neon Racer desde cero.
Paso 1: Instalación y configuración de Pygame
Antes de comenzar, debemos asegurarnos de tener Python instalado en nuestro sistema. Después, instalaremos Pygame a través de la terminal con el siguiente comando:
pip install pygamePara verificar que la instalación se ha completado correctamente, podemos ejecutar este código simple:
import pygame
print(pygame.__version__)Si aparece la versión de Pygame en la consola, nuestro sistema está listo para desarrollar juegos en Python.
Paso 2: Creación de la ventana del juego
El primer componente de nuestro juego será la ventana que servirá como lienzo para Neon Racer. Crearemos una ventana con una tasa de fotogramas constante utilizando el siguiente código:
import pygame
pygame.init()
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Neon Racer")
clock = pygame.time.Clock()
# Este código configura una ventana fluida a 60 FPS, sirviendo como base para tu juego en PythonAl ejecutar este fragmento, debería abrirse una ventana vacía. Esta será la base sobre la cual construiremos el resto de nuestro juego.
Paso 3: Implementación del movimiento del jugador
En Neon Racer, el jugador controla un vehículo neón. Ahora implementaremos un movimiento suave de izquierda a derecha para este vehículo:
# Inicializar propiedades del jugador
player_x = WIDTH // 2
player_y = HEIGHT - 120
player_speed = 7
def move_player(keys, x):
if keys[pygame.K_LEFT] and x > 0:
x -= player_speed
if keys[pygame.K_RIGHT] and x < WIDTH - 60:
x += player_speed
return x
# Para probar, llama a move_player dentro de tu bucle de juego y dibuja un rectángulo que represente el vehículo:
# pygame.draw.rect(screen, (0, 255, 255), (player_x, player_y, 60, 30))Este código ha sido diseñado para proporcionar una respuesta inmediata a las teclas de dirección. Después de integrarlo, deberías probar el movimiento para asegurarte de que el vehículo neón responde correctamente a las teclas de flecha.
Paso 4: Añadir un fondo de carretera con desplazamiento
Para dar al juego una sensación dinámica, añadiremos un fondo con desplazamiento que simule una carretera en movimiento:
# Crear dos rectángulos de fondo que se desplazan continuamente hacia abajo
road_y = 0
road_speed = 5
def update_road(y, speed):
y += speed
if y >= HEIGHT:
y = 0
return y
# En tu bucle de juego, actualiza road_y y dibuja dos rectángulos:
# pygame.draw.rect(screen, (50, 50, 50), (200, y, 400, HEIGHT))
# pygame.draw.rect(screen, (50, 50, 50), (200, y - HEIGHT, 400, HEIGHT))Este módulo actúa como una “pieza del rompecabezas” que, al ser añadida, proporciona una sensación de movimiento y profundidad a la experiencia de juego.
Paso 5: Generación de obstáculos
Neon Racer desafía al jugador a esquivar obstáculos. Estos obstáculos son generados en posiciones aleatorias en la parte superior de la pantalla y caen hacia el jugador:
import random
obstacles = []
obstacle_spawn_rate = 30 # fotogramas
obstacle_speed = 4
def spawn_obstacle():
x = random.randint(220, 800 - 220) # mantener los obstáculos dentro de los límites de la carretera
y = -50
speed = random.randint(4, 7)
obstacles.append([x, y, speed])
def update_obstacles(obstacles, current_speed=1.0):
for obstacle in obstacles[:]:
obstacle[1] += obstacle[2] * current_speed
if obstacle[1] > HEIGHT:
obstacles.remove(obstacle)
return obstaclesEs recomendable probar este módulo por separado para asegurarse de que los obstáculos aparecen y se mueven hacia abajo correctamente.
Paso 6: Añadir recolectables para puntos extra
Para hacer el juego más atractivo, añadiremos recolectables que el jugador puede recoger. Estos aumentan la puntuación o proporcionan ventajas temporales:
pickups = []
pickup_spawn_rate = 200 # basado en probabilidad
def spawn_pickup():
x = random.randint(220, WIDTH - 220)
y = -30
pickups.append([x, y])
def update_pickups(pickups):
for pickup in pickups[:]:
pickup[1] += 3
if pickup[1] > HEIGHT:
pickups.remove(pickup)
return pickupsDespués de integrar este código, deberías comprobar que los recolectables aparecen intermitentemente y se mueven hacia abajo en la pantalla.
Paso 7: Detección de colisiones y sistema de puntuación
El juego debe detectar cuándo el jugador colisiona con un obstáculo o recoge un objeto. Esta sección también actualiza la puntuación:
def check_collision(rect1, rect2):
return rect1.colliderect(rect2)
score = 0
def update_score(current_score):
return current_score + 1 # Incrementar puntuación con el tiempoDentro del bucle principal del juego, crearemos rectángulos para el jugador, los obstáculos y los recolectables utilizando pygame.Rect, y verificaremos las colisiones en consecuencia. Para los obstáculos, terminaremos el juego en caso de colisión; para los recolectables, aumentaremos la puntuación y eliminaremos el objeto.
Integración de todos los módulos en el juego final
Ahora que cada componente funciona individualmente, es momento de integrar todo en un único juego coherente. Este es el código completo de Neon Racer:
import pygame, random, sys
# Inicializar Pygame
pygame.init()
# Dimensiones y configuración de la pantalla
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Neon Racer")
clock = pygame.time.Clock()
# Colores y fuentes
BG_COLOR = (20, 20, 30)
PLAYER_COLOR = (0, 255, 255) # Cian neón para el jugador
OBSTACLE_COLOR = (255, 50, 50)
PICKUP_COLOR = (50, 255, 50)
ROAD_COLOR = (50, 50, 50)
font = pygame.font.Font(None, 36)
# Variables del juego
player_x = WIDTH // 2
player_y = HEIGHT - 120
player_speed = 7
obstacles = []
pickups = []
frame_count = 0
score = 0
# Variables de la carretera
road_y = 0
road_speed = 5
obstacle_spawn_rate = 30 # fotogramas
# Bucle principal del juego
running = True
while running:
screen.fill(BG_COLOR)
# Dibujar carretera con desplazamiento (dos secciones para desplazamiento continuo)
road_y += road_speed
if road_y >= HEIGHT:
road_y = 0
pygame.draw.rect(screen, ROAD_COLOR, (200, road_y, 400, HEIGHT))
pygame.draw.rect(screen, ROAD_COLOR, (200, road_y - HEIGHT, 400, HEIGHT))
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Movimiento del jugador
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT] and player_x > 200:
player_x -= player_speed
if keys[pygame.K_RIGHT] and player_x < 540: # 800 - 260 para mantenerse dentro de la carretera
player_x += player_speed
# Generar obstáculos
frame_count += 1
if frame_count % obstacle_spawn_rate == 0:
x = random.randint(220, 580)
obstacles.append([x, -50, random.randint(4, 7)])
# Generar recolectables ocasionalmente
if random.randint(1, 200) == 1:
x = random.randint(220, 580)
pickups.append([x, -30])
# Actualizar obstáculos y dibujarlos
for obstacle in obstacles[:]:
obstacle[1] += obstacle[2]
obs_rect = pygame.Rect(obstacle[0], obstacle[1], 40, 40)
pygame.draw.rect(screen, OBSTACLE_COLOR, obs_rect)
if obstacle[1] > HEIGHT:
obstacles.remove(obstacle)
# Actualizar recolectables y dibujarlos
for pickup in pickups[:]:
pickup[1] += 3
pick_rect = pygame.Rect(pickup[0]-15, pickup[1]-15, 30, 30)
pygame.draw.ellipse(screen, PICKUP_COLOR, pick_rect)
if pickup[1] > HEIGHT:
pickups.remove(pickup)
# Crear rectángulo del jugador y dibujarlo
player_rect = pygame.Rect(player_x, player_y, 60, 30)
pygame.draw.rect(screen, PLAYER_COLOR, player_rect)
# Detección de colisiones para obstáculos
for obstacle in obstacles:
obs_rect = pygame.Rect(obstacle[0], obstacle[1], 40, 40)
if player_rect.colliderect(obs_rect):
print("¡Juego terminado!")
running = False
# Detección de colisiones para recolectables
for pickup in pickups[:]:
pick_rect = pygame.Rect(pickup[0]-15, pickup[1]-15, 30, 30)
if player_rect.colliderect(pick_rect):
score += 100 # Bonificación por recoger un objeto
pickups.remove(pickup)
# Actualizar puntuación con el tiempo
score += 1
score_text = font.render(f"Puntuación: {score}", True, (255, 255, 255))
screen.blit(score_text, (10, 10))
pygame.display.update()
clock.tick(60)
pygame.quit()
sys.exit()Ahora que has creado la versión básica de Neon Racer, puedes considerar algunas mejoras para hacer el juego más atractivo:
- Añadir efectos de sonido: Pygame permite cargar y reproducir sonidos para eventos como colisiones, recolección de objetos o el fondo musical.
- Implementar una pantalla de “Game Over”: Muestra la puntuación final y ofrece la opción de reiniciar el juego.
- Crear niveles de dificultad progresiva: Aumenta la velocidad y frecuencia de los obstáculos a medida que avanza el tiempo.
- Añadir power-ups especiales: Implementa objetos que proporcionen invencibilidad temporal o velocidad reducida.
- Mejorar los gráficos: Reemplaza las formas geométricas básicas con sprites personalizados para el jugador, obstáculos y recolectables.
A través de este proyecto, has aprendido conceptos fundamentales como la configuración del entorno, la creación de un ciclo de juego, la implementación de controles de usuario, la detección de colisiones y el seguimiento de la puntuación. Estos conocimientos pueden ser aplicados a una amplia variedad de proyectos de desarrollo de juegos en el futuro.
Te animamos a experimentar con el código proporcionado, añadir tus propias características y compartir tus creaciones con la comunidad de Pygame. ¡El único límite es tu imaginación!
