Juego de carreras con Pygame

Introducción

En este proyecto, aprenderás a crear un sencillo juego de carreras utilizando la biblioteca Pygame. El juego involucra un automóvil del jugador y múltiples automóviles enemigos. El automóvil del jugador se puede mover hacia la izquierda y hacia la derecha utilizando las teclas de flecha, mientras que los automóviles enemigos se mueven hacia abajo por la pantalla. El objetivo es evitar las colisiones con los automóviles enemigos durante el mayor tiempo posible. El juego mostrará una pantalla de fin de juego cuando ocurra una colisión y permitirá al jugador reiniciar el juego presionando la tecla "R".

👀 Vista previa

🎯 Tareas

En este proyecto, aprenderás:

• Cómo configurar la ventana del juego e importar las bibliotecas necesarias
• Cómo definir los colores y cargar las imágenes de los automóviles
• Cómo definir el automóvil del jugador
• Cómo definir los automóviles enemigos
• Cómo definir las variables y la fuente de fin de juego
• Cómo implementar la lógica del juego
• Cómo mostrar la pantalla de fin de juego
• Cómo salir del juego

🏆 Logros

Después de completar este proyecto, serás capaz de:

• Utilizar la biblioteca Pygame para crear una ventana de juego
• Cargar y mostrar imágenes en un juego
• Manejar las colisiones entre los objetos del juego
• Implementar un bucle de juego para un juego continuo
• Manejar la entrada del usuario para controlar los objetos del juego
• Mostrar texto en la pantalla utilizando el módulo de fuentes de Pygame

Crear los archivos del proyecto

1. Crea un nuevo archivo llamado racing_game.py.

cd ~/proyecto
touch racing_game.py

Configurar la ventana del juego e importar las bibliotecas necesarias

import pygame
import random

## Inicializar Pygame
pygame.init()

## Configurar la ventana del juego
window_width = 800
window_height = 600
window = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Racing Game")

En este paso, importamos la biblioteca pygame e inicializamosla. Luego, configuramos la ventana del juego con un ancho de 800 píxeles y un alto de 600 píxeles. También establecemos el título de la ventana como "Racing Game".

Instala la biblioteca pygame ejecutando el siguiente comando en la terminal:

sudo pip install pygame

Definir colores y cargar imágenes de automóvil

## Definir colores
background_color = (30, 30, 30)
player_car_color = (255, 255, 255)
enemy_car_color = (255, 0, 0)
text_color = (255, 255, 255)

## Cargar imágenes de automóvil
player_car_img = pygame.image.load("player_car.png").convert_alpha()
enemy_car_img = pygame.image.load("enemy_car.png").convert_alpha()

En este paso, definimos algunos colores utilizados en el juego: background_color, player_car_color, enemy_car_color y text_color. También cargamos las imágenes del automóvil del jugador y del automóvil enemigo utilizando la función pygame.image.load().

Las imágenes player_car.png y enemy_car.png se encuentran en el directorio ~/proyecto.

Definir el automóvil del jugador

## Definir el automóvil del jugador
player_car_width = player_car_img.get_width()
player_car_height = player_car_img.get_height()
player_car_x = window_width // 2 - player_car_width // 2
player_car_y = window_height - player_car_height - 10
player_car_speed = 5

En este paso, definimos las propiedades del automóvil del jugador: player_car_width y player_car_height se establecen en las dimensiones de la imagen del automóvil del jugador. player_car_x y player_car_y representan la posición inicial del automóvil del jugador en la pantalla. player_car_speed determina qué tan rápido puede moverse el automóvil del jugador.

Definir los automóviles enemigos

## Definir los automóviles enemigos
enemy_cars = []
num_enemy_cars = 3
enemy_car_width = 80
enemy_car_height = 160
for _ in range(num_enemy_cars):
    enemy_car_x = random.randint(0, window_width - enemy_car_width)
    enemy_car_y = random.randint(-window_height, -enemy_car_height)
    enemy_car_speed = random.randint(2, 5)
    enemy_cars.append({"x": enemy_car_x, "y": enemy_car_y, "speed": enemy_car_speed})

En este paso, definimos las propiedades de los automóviles enemigos: enemy_cars es una lista que almacenará los objetos de automóvil enemigo. num_enemy_cars determina el número de automóviles enemigos en el juego. enemy_car_width y enemy_car_height representan las dimensiones de la imagen del automóvil enemigo. Utilizamos un bucle para generar posiciones y velocidades aleatorias para cada automóvil enemigo y los agregamos a la lista enemy_cars.

Definir variables y fuente para el fin del juego

## Definir variables para el fin del juego
game_over = False
font = pygame.font.Font(None, 50)
game_over_text = font.render("Game Over", True, text_color)
restart_text = font.render("Presiona R para reiniciar", True, text_color)

En este paso, definimos las variables relacionadas con la pantalla de fin de juego: game_over es una variable booleana que indica si el juego ha terminado o no. font es un objeto de fuente de Pygame con un tamaño de 50. Renderizamos el texto "Game Over" y "Presiona R para reiniciar" usando la fuente y los almacenamos en las variables game_over_text y restart_text.

Bucle principal del juego

## Bucle principal del juego
running = True
clock = pygame.time.Clock()

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_r and game_over:
                game_over = False
                player_car_x = window_width // 2 - player_car_width // 2
                player_car_y = window_height - player_car_height - 10
                for enemy_car in enemy_cars:
                    enemy_car["x"] = random.randint(0, window_width - enemy_car_width)
                    enemy_car["y"] = random.randint(-window_height, -enemy_car_height)

    if not game_over:
        ## Código de lógica del juego va aquí...

        ## Actualizar la ventana
        window.fill(background_color)
        window.blit(player_car_img, (player_car_x, player_car_y))
        for enemy_car in enemy_cars:
            window.blit(enemy_car_img, (enemy_car["x"], enemy_car["y"]))
    else:
        ## Código de pantalla de fin de juego va aquí...

    pygame.display.update()
    clock.tick(60)

En este paso, configuramos el bucle principal del juego utilizando un bucle while. El bucle se ejecuta mientras la variable running sea True. Manejamos los eventos como cerrar el juego y reiniciarlo verificando los tipos de eventos y las teclas presionadas. Cuando el juego no ha terminado, se ejecuta el código dentro del bloque if not game_over, que incluye la lógica del juego y dibuja el automóvil del jugador y los automóviles enemigos en la pantalla. Cuando el juego ha terminado, se ejecuta el código dentro del bloque else, que muestra la pantalla de fin de juego. Finalmente, actualizamos la pantalla y establecemos la tasa de fotogramas en 60 fotogramas por segundo.

Código de lógica del juego

if not game_over:
    ## Mover el automóvil del jugador
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and player_car_x > player_car_speed:
        player_car_x -= player_car_speed
    if (
        keys[pygame.K_RIGHT]
        and player_car_x < window_width - player_car_width - player_car_speed
    ):
        player_car_x += player_car_speed

    ## Mover los automóviles enemigos
    for enemy_car in enemy_cars:
        enemy_car["y"] += enemy_car["speed"]
        if enemy_car["y"] > window_height:
            enemy_car["x"] = random.randint(0, window_width - enemy_car_width)
            enemy_car["y"] = random.randint(-window_height, -enemy_car_height)
            enemy_car["speed"] = random.randint(2, 5)

        ## Verificar colisión
        if player_car_y < enemy_car["y"] + enemy_car_height:
            if (
                player_car_x < enemy_car["x"] + enemy_car_width
                and player_car_x + player_car_width > enemy_car["x"]
            ):
                game_over = True

En este paso, implementamos el código de lógica del juego dentro del bucle principal del juego. Verificamos la entrada del usuario para mover el automóvil del jugador hacia la izquierda y hacia la derecha. Actualizamos las posiciones de los automóviles enemigos y verificamos si ha ocurrido alguna colisión entre el automóvil del jugador y los automóviles enemigos. Si ocurre una colisión, establecemos la variable game_over en True.

Código de pantalla de fin de juego

else:
    ## Pantalla de fin de juego
    window.fill(background_color)
    game_over_rect = game_over_text.get_rect(
        center=(window_width // 2, window_height // 2 - 50)
    )
    restart_rect = restart_text.get_rect(
        center=(window_width // 2, window_height // 2 + 50)
    )
    window.blit(game_over_text, game_over_rect)
    window.blit(restart_text, restart_rect)

En este paso, implementamos el código de la pantalla de fin de juego dentro del bucle principal del juego. Mostramos el texto "Fin del juego" y el texto de reinicio en la pantalla utilizando la función window.blit(). El texto se centra en la pantalla utilizando las propiedades get_rect() y center.

Salir del juego

## Salir del juego
pygame.quit()

En este último paso, salimos del juego y cerramos la ventana de Pygame cuando el bucle principal del juego termina.

Ahora, puedes ejecutar el juego usando el siguiente comando:

python racing_game.py

Resumen

¡Felicidades! Has creado con éxito un sencillo juego de carreras utilizando la biblioteca Pygame. El juego incluye un automóvil del jugador que se puede mover hacia la izquierda y hacia la derecha, así como múltiples automóviles enemigos. El objetivo es evitar las colisiones con los automóviles enemigos durante el mayor tiempo posible. El juego también tiene una pantalla de fin de juego y la capacidad de reiniciar el juego presionando la tecla "R". Sigue practicando y experimentando para mejorar tus habilidades de desarrollo de juegos.