Crea un juego de Pong con Python y Pygame | Tutorial de programación

Introducción

En este proyecto, aprenderás a crear un juego de Pong utilizando Python y la biblioteca Pygame. Pong es un juego arcade clásico para dos jugadores en el que los jugadores controlan palas para golpear una pelota pasado el otro.

Para completar este proyecto, necesitarás seguir los pasos siguientes. Empezaremos creando los archivos del proyecto y configurando la ventana del juego. Luego, definiremos los colores y configuraremos las palas y la pelota. Finalmente, movemos las palas y la pelota, manejamos las colisiones y dibujamos los elementos del juego.

👀 Vista previa

Captura de pantalla de vista previa del juego Pong

🎯 Tareas

En este proyecto, aprenderás:

Cómo crear los archivos del proyecto
Cómo configurar la ventana del juego
Cómo configurar las palas y la pelota
Cómo configurar las variables del juego
Cómo configurar el bucle del juego
Cómo mover las palas
Cómo mover la pelota
Cómo manejar las colisiones de la pelota
Cómo actualizar los puntajes y restablecer la pelota
Cómo manejar las colisiones y el movimiento de los power-up
Cómo dibujar los elementos del juego
Cómo dibujar el puntaje
Cómo actualizar la pantalla
Cómo establecer los fotogramas por segundo (FPS)
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
Configurar y mover objetos del juego como palas y una pelota
Manejar las colisiones entre objetos del juego
Actualizar y mostrar los puntajes del juego
Establecer los fotogramas por segundo (FPS) para el juego
Salir del juego correctamente

Crea los archivos del proyecto

Crea un archivo llamado pong_game.py en tu editor de código o IDE preferido. Este será el archivo principal donde escribirás el código para el juego de Pong.

cd ~/proyecto
touch pong_game.py
sudo pip install pygame

Configura la ventana del juego

Dentro del archivo pong_game.py, importa las bibliotecas necesarias al principio del código:

import pygame
import random

Luego, inicializa Pygame llamando a pygame.init():

## Inicializa Pygame
pygame.init()

A continuación, configura la ventana del juego definiendo el ancho, alto y fotogramas por segundo (FPS):

## Configura la ventana del juego
ANCHO = 800
ALTO = 400
FPS = 60

Define los colores utilizados en el juego:

## Define los colores
NEGRO = (0, 0, 0)
BLANCO = (255, 255, 255)
AZUL = (0, 0, 255)
NARANJA = (255, 165, 0)
COLOR_FONDO = (50, 50, 50)

Crea la ventana del juego, establece el título de la ventana y crea un objeto reloj para controlar la tasa de fotogramas:

## Configura la ventana del juego
pantalla = pygame.display.set_mode((ANCHO, ALTO))
pygame.display.set_caption("Juego de Pong")
reloj = pygame.time.Clock()

Configura las paletas y la pelota

Define las propiedades de las palas, como ancho, alto, velocidad y color:

## Set up the paddles
PADDLE_WIDTH = 10
PADDLE_HEIGHT = 60
PADDLE_SPEED = 5
PADDLE_COLOR = WHITE

Crea dos objetos de pala utilizando el constructor pygame.Rect() y posiciónalos en el centro de cada lado de la ventana del juego:

paddle1 = pygame.Rect(0, HEIGHT / 2 - PADDLE_HEIGHT / 2, PADDLE_WIDTH, PADDLE_HEIGHT)
paddle2 = pygame.Rect(
    WIDTH - PADDLE_WIDTH, HEIGHT / 2 - PADDLE_HEIGHT / 2, PADDLE_WIDTH, PADDLE_HEIGHT
)

Configura las propiedades de la pelota, como ancho, alto, velocidad y color:

## Set up the ball
BALL_WIDTH = 10
BALL_HEIGHT = 10
BALL_SPEED_X = 3
BALL_SPEED_Y = 3
BALL_COLOR = WHITE

Crea un objeto de pelota utilizando el constructor pygame.Rect() y posiciónalo en el centro de la ventana del juego:

ball = pygame.Rect(
    WIDTH / 2 - BALL_WIDTH / 2, HEIGHT / 2 - BALL_HEIGHT / 2, BALL_WIDTH, BALL_HEIGHT
)

Establece la velocidad inicial de la pelota en las direcciones x e y de forma aleatoria:

ball_speed_x = BALL_SPEED_X * random.choice((1, -1))
ball_speed_y = BALL_SPEED_Y * random.choice((1, -1))

Configura los power-ups, como ancho, alto, velocidad y color:

## Set up the power-ups
POWERUP_WIDTH = 10
POWERUP_HEIGHT = 10
POWERUP_SPEED = 2
POWERUP_COLOR = ORANGE

powerup = pygame.Rect(
    WIDTH / 2 - POWERUP_WIDTH / 2,
    HEIGHT / 2 - POWERUP_HEIGHT / 2,
    POWERUP_WIDTH,
    POWERUP_HEIGHT,
)
powerup_speed_x = POWERUP_SPEED * random.choice((1, -1))
powerup_speed_y = POWERUP_SPEED * random.choice((1, -1))
powerup_active = False

Configura las variables del juego

Configura las variables para llevar un registro de los puntajes de los jugadores, crea un objeto de fuente del juego y define el color para la visualización del puntaje:

## Configura las variables del juego
puntaje1 = 0
puntaje2 = 0
fuente_juego = pygame.font.SysFont(None, 48)
COLOR_PUNTAJE = BLANCO

Configura el bucle del juego

Crea una variable booleana ejecutando y configúrala en True para iniciar el bucle del juego:

## Configura el bucle del juego
ejecutando = True
while ejecutando:

Dentro del bucle del juego, maneja los eventos iterando a través de los eventos que han ocurrido:

    for evento in pygame.event.get():
        if evento.type == pygame.QUIT:
            ejecutando = False

Mueve las paletas

Dentro del bucle del juego, revisa la entrada del teclado para mover las palas:

    ## Mueve las palas
    teclas = pygame.key.get_pressed()
    if teclas[pygame.K_w] and pala1.y > 0:
        pala1.y -= VELOCIDAD_PALA
    if teclas[pygame.K_s] and pala1.y < ALTO - ALTO_PALA:
        pala1.y += VELOCIDAD_PALA
    if teclas[pygame.K_UP] and pala2.y > 0:
        pala2.y -= VELOCIDAD_PALA
    if teclas[pygame.K_DOWN] and pala2.y < ALTO - ALTO_PALA:
        pala2.y += VELOCIDAD_PALA

Mueve la pelota

Dentro del bucle del juego, actualiza la posición de la pelota:

    ## Mueve la pelota
    pelota.x += velocidad_pelota_x
    pelota.y += velocidad_pelota_y

Maneja las colisiones de la pelota

Dentro del bucle del juego, maneja las colisiones de la pelota con las palas y las paredes:

    ## Colisión de la pelota con las palas
    if pelota.colliderect(pala1) or pelota.colliderect(pala2):
        velocidad_pelota_x *= -1

    ## Colisión de la pelota con las paredes
    if pelota.y > ALTO - ALTO_PELOTA or pelota.y < 0:
        velocidad_pelota_y *= -1

Actualiza los puntajes y reinicia la pelota

Dentro del bucle del juego, actualiza los puntajes y reinicia la pelota cuando sale más allá de la pala:

    ## Incrementa el puntaje y reinicia la pelota
    if pelota.x < 0:
        puntaje2 += 1
        pelota.center = (ANCHO / 2, ALTO / 2)
        velocidad_pelota_x *= random.choice((1, -1))
        velocidad_pelota_y *= random.choice((1, -1))
    if pelota.x > ANCHO:
        puntaje1 += 1
        pelota.center = (ANCHO / 2, ALTO / 2)
        velocidad_pelota_x *= random.choice((1, -1))
        velocidad_pelota_y *= random.choice((1, -1))

Manejar las colisiones y el movimiento de los power-ups

Dentro del bucle del juego, maneja las colisiones de los potenciadores con las palas y mueve el potenciador:

    ## Colisión del potenciador con las palas
    if potenciador.colliderect(pala1) or potenciador.colliderect(pala2):
        potenciador_activo = True
        potenciador.x = ANCHO / 2 - ANCHO_POTENCIADOR / 2
        potenciador.y = ALTO / 2 - ALTO_POTENCIADOR / 2

    ## Movimiento del potenciador
    if potenciador_activo:
        potenciador.x += velocidad_potenciador_x
        potenciador.y += velocidad_potenciador_y

        if potenciador.x > ANCHO - ANCHO_POTENCIADOR or potenciador.x < 0:
            velocidad_potenciador_x *= -1
        if potenciador.y > ALTO - ALTO_POTENCIADOR or potenciador.y < 0:
            velocidad_potenciador_y *= -1

Dibuja los elementos del juego

Dentro del bucle del juego, dibuja las palas, la pelota, el potenciador y el puntaje en la ventana del juego:

    ## Dibuja los elementos del juego
    pantalla.fill(COLOR_FONDO)
    pygame.draw.rect(pantalla, COLOR_PALA, pala1)
    pygame.draw.rect(pantalla, COLOR_PALA, pala2)
    pygame.draw.ellipse(pantalla, COLOR_PELOTA, pelota)
    pygame.draw.rect(pantalla, COLOR_POTENCIADOR, potenciador)

Dibuja la puntuación

Dentro del bucle del juego, dibuja los puntajes en el centro superior de la ventana del juego:

    ## Dibuja el puntaje
    texto_puntaje = fuente_juego.render(f"{puntaje1} : {puntaje2}", True, COLOR_PUNTAJE)
    pantalla.blit(texto_puntaje, (ANCHO / 2 - texto_puntaje.get_width() / 2, 10))

Actualiza la pantalla

Dentro del bucle del juego, actualiza la pantalla para mostrar los cambios:

    ## Actualiza la pantalla
    pygame.display.flip()

Establece los FPS

Dentro del bucle del juego, establece la tasa de fotogramas para controlar la velocidad del juego:

    ## Establece la FPS
    reloj.tick(FPS)

Salir del juego

Después del bucle del juego, agrega la siguiente línea para cerrar Pygame cuando el juego termine:

## Cierra el juego
pygame.quit()

Cambia a la escritorio y ejecuta el proyecto usando el siguiente comando:

python pong_game.py

Ahora, puedes jugar al juego Pong usando las flechas del teclado y las teclas W y S.

Captura de pantalla del juego Pong

Resumen

¡Felicidades! Has completado el proyecto paso a paso de creación de un juego Pong usando Python y Pygame. Has aprendido cómo configurar la ventana del juego, definir las propiedades de las paletas y la pelota, manejar los eventos del juego, mover las paletas y la pelota, manejar las colisiones y dibujar los elementos del juego. Experimenta con diferentes modificaciones para agregar tus propios mejoramientos al juego y diviértete jugándolo.

Juego clásico de Pong usando Python y Pygame