Juego de Serpiente con Python y Pygame

Introducción

Este proyecto te guiará a través del proceso de creación de un juego de serpiente utilizando Python y la biblioteca Pygame. El juego tendrá una ventana de juego, una serpiente, un poder-up y una puntuación. La serpiente se moverá por la ventana de juego y comerá el poder-up. Cuando la serpiente coma el poder-up, la longitud de la serpiente aumentará en uno. La puntuación se mostrará en la pantalla.

👀 Vista previa

🎯 Tareas

En este proyecto, aprenderás:

• Cómo crear una ventana de juego utilizando Pygame
• Cómo manejar la entrada del usuario para controlar el movimiento de la serpiente
• Cómo crear y actualizar la posición de la serpiente
• Cómo dibujar la serpiente y el poder-up en la pantalla
• Cómo detectar colisiones entre la serpiente y el poder-up
• Cómo llevar un registro de la puntuación
• Cómo mostrar la puntuación en la pantalla

🏆 Logros

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

• Utilizar Pygame para crear una ventana gráfica de juego
• Manejar la entrada del usuario para controlar el juego
• Crear y actualizar objetos del juego
• Detectar colisiones en un juego
• Mostrar y actualizar la puntuación del juego

Crear los archivos del proyecto

Crea un nuevo archivo llamado snake_game.py y dile que se abra en un editor de código.

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

Importar los módulos necesarios

En el archivo snake_game.py, importa los módulos pygame y random:

import pygame
import random

Inicializar Pygame

Después de importar los módulos, inicializa Pygame:

pygame.init()

Configurar la ventana del juego

Define el ancho, alto y fotogramas por segundo (FPS) de la ventana del juego:

ANCHO = 800
ALTO = 600
FPS = 10

Definir los colores

Define los colores que se utilizarán en el juego:

NEGRO = (0, 0, 0)
BLANCO = (255, 255, 255)
VERDE = (0, 255, 0)
ROJO = (255, 0, 0)
AZUL = (0, 0, 255)
AMARILLO = (255, 255, 0)
COLOR_DE_FONDO = (50, 50, 50)

Configurar la ventana del juego

Configura la ventana del juego con el ancho y alto definidos:

pantalla = pygame.display.set_mode((ANCHO, ALTO))
pygame.display.set_caption("Juego de la Serpiente")
reloj = pygame.time.Clock()

En el código anterior, pygame.display.set_mode() se utiliza para inicializar la pantalla con el ancho y alto especificados. pygame.display.set_caption() se utiliza para establecer el título de la ventana del juego. pygame.time.Clock() se utiliza para controlar el tiempo en el juego.

Configurar la serpiente

Define el tamaño del bloque y la velocidad de la serpiente:

tamaño_del_bloque_de_la_serpiente = 20
velocidad_de_la_serpiente = 5

Establecemos el tamaño del bloque en 20 y la velocidad en 5. Esto significa que la serpiente se moverá 5 píxeles a la vez.

Configurar las variables del juego

Define los estilos y tamaños de fuente para mostrar la puntuación:

estilo_de_fuente = pygame.font.SysFont(None, 50)
fuente_de_puntuación = pygame.font.SysFont(None, 35)

Configurar el poder-up

Define el tamaño del bloque del poder-up:

tamaño_del_bloque_del_poder-up = 20

Definir funciones

Define las siguientes funciones:

dibujar_serpiente(tamaño_del_bloque_de_la_serpiente, lista_de_serpiente)

Esta función dibuja la serpiente en la pantalla:

def dibujar_serpiente(tamaño_del_bloque_de_la_serpiente, lista_de_serpiente):
    for x in lista_de_serpiente:
        pygame.draw.rect(
            pantalla, VERDE, [x[0], x[1], tamaño_del_bloque_de_la_serpiente, tamaño_del_bloque_de_la_serpiente]
        )

En el código anterior, pygame.draw.rect() se utiliza para dibujar un rectángulo en la pantalla. El primer parámetro es la pantalla, el segundo parámetro es el color y el tercer parámetro es la posición y el tamaño del rectángulo.

dibujar_poder-up(x_del_poder-up, y_del_poder-up)

Esta función dibuja el poder-up en la pantalla:

def dibujar_poder-up(x_del_poder-up, y_del_poder-up):
    pygame.draw.rect(
        pantalla, ROJO, [x_del_poder-up, y_del_poder-up, tamaño_del_bloque_del_poder-up, tamaño_del_bloque_del_poder-up]
    )

En el código anterior, pygame.draw.rect() se utiliza para dibujar un rectángulo en la pantalla. El primer parámetro es la pantalla, el segundo parámetro es el color y el tercer parámetro es la posición y el tamaño del rectángulo.

mostrar_puntuación(puntuación)

Esta función muestra la puntuación en la pantalla:

def mostrar_puntuación(puntuación):
    valor = fuente_de_puntuación.render("Puntuación: " + str(puntuación), True, BLANCO)
    pantalla.blit(valor, [10, 10])

En el código anterior, fuente_de_puntuación.render() se utiliza para renderizar la puntuación en la pantalla. El primer parámetro es el texto a mostrar, el segundo parámetro es la antialiasing y el tercer parámetro es el color del texto. pantalla.blit() se utiliza para dibujar el texto en la pantalla. El primer parámetro es el texto a mostrar y el segundo parámetro es la posición del texto.

bucle_del_juego()

Esta función contiene el bucle principal del juego:

def bucle_del_juego():
    ## Código del bucle del juego va aquí

Completar el código del bucle del juego

Completa la función bucle_del_juego() agregando la lógica del juego dentro del bucle while.

def bucle_del_juego():
    juego_terminado = False
    juego_cerrado = False

    ## Establece la posición inicial de la serpiente
    x1 = ANCHO / 2
    y1 = ALTO / 2
    cambio_x1 = 0
    cambio_y1 = 0

    ## Establece el cuerpo de la serpiente
    lista_de_serpiente = []
    longitud_de_serpiente = 1

    ## Establece el poder-up
    x_del_poder-up = round(random.randrange(0, ANCHO - tamaño_del_bloque_del_poder-up) / 20) * 20
    y_del_poder-up = round(random.randrange(0, ALTO - tamaño_del_bloque_del_poder-up) / 20) * 20

    ## Establece el bucle del juego
    while not juego_terminado:
        while juego_cerrado:
            pantalla.fill(COLOR_DE_FONDO)
            mensaje = estilo_de_fuente.render("Presiona ESPACIO para jugar de nuevo", True, AMARILLO)
            pantalla.blit(mensaje, [ANCHO / 2 - 200, ALTO / 2 - 50])
            pygame.display.flip()

            for evento in pygame.event.get():
                if evento.type == pygame.QUIT:
                    juego_terminado = True
                    juego_cerrado = False
                if evento.type == pygame.KEYDOWN:
                    if evento.key == pygame.K_SPACE:
                        bucle_del_juego()

        for evento in pygame.event.get():
            if evento.type == pygame.QUIT:
                juego_terminado = True
            if evento.type == pygame.KEYDOWN:
                if evento.key == pygame.K_LEFT:
                    cambio_x1 = -tamaño_del_bloque_de_la_serpiente
                    cambio_y1 = 0
                elif evento.key == pygame.K_RIGHT:
                    cambio_x1 = tamaño_del_bloque_de_la_serpiente
                    cambio_y1 = 0
                elif evento.key == pygame.K_UP:
                    cambio_y1 = -tamaño_del_bloque_de_la_serpiente
                    cambio_x1 = 0
                elif evento.key == pygame.K_DOWN:
                    cambio_y1 = tamaño_del_bloque_de_la_serpiente
                    cambio_x1 = 0

        if x1 >= ANCHO or x1 < 0 or y1 >= ALTO or y1 < 0:
            juego_cerrado = True

        x1 += cambio_x1
        y1 += cambio_y1
        pantalla.fill(COLOR_DE_FONDO)
        pygame.draw.rect(
            pantalla, AZUL, [x_del_poder-up, y_del_poder-up, tamaño_del_bloque_del_poder-up, tamaño_del_bloque_del_poder-up]
        )

        cabeza_de_serpiente = []
        cabeza_de_serpiente.append(x1)
        cabeza_de_serpiente.append(y1)
        lista_de_serpiente.append(cabeza_de_serpiente)
        if len(lista_de_serpiente) > longitud_de_serpiente:
            del lista_de_serpiente[0]

        for x in lista_de_serpiente[:-1]:
            if x == cabeza_de_serpiente:
                juego_cerrado = True

        dibujar_serpiente(tamaño_del_bloque_de_la_serpiente, lista_de_serpiente)
        mostrar_puntuación(longitud_de_serpiente - 1)

        pygame.display.flip()

        if x1 == x_del_poder-up and y1 == y_del_poder-up:
            x_del_poder-up = round(random.randrange(0, ANCHO - tamaño_del_bloque_del_poder-up) / 20) * 20
            y_del_poder-up = (
                round(random.randrange(0, ALTO - tamaño_del_bloque_del_poder-up) / 20) * 20
            )
            longitud_de_serpiente += 1

        reloj.tick(velocidad_de_la_serpiente)

    pygame.quit()

En el código anterior, pygame.QUIT se utiliza para salir del juego. pygame.KEYDOWN se utiliza para comprobar si se presiona una tecla. pygame.K_LEFT, pygame.K_RIGHT, pygame.K_UP y pygame.K_DOWN se utilizan para comprobar si se presionan las flechas izquierda, derecha, arriba y abajo respectivamente. pygame.draw.rect() se utiliza para dibujar un rectángulo en la pantalla. El primer parámetro es la pantalla, el segundo parámetro es el color y el tercer parámetro es la posición y el tamaño del rectángulo. pygame.display.flip() se utiliza para actualizar la pantalla. pygame.time.Clock() se utiliza para controlar el tiempo en el juego. pygame.time.Clock.tick() se utiliza para establecer los FPS del juego.

Ejecutar el juego

Agrega lo siguiente al final del archivo para ejecutar el juego:

bucle_del_juego()
pygame.quit()

Finalmente, cambia a Escritorio y ejecuta el proyecto usando el siguiente comando:

python snake_game.py

Resumen

¡Felicidades! Has creado con éxito un juego de serpiente usando Python y la biblioteca Pygame. En este proyecto, aprendiste cómo configurar la ventana del juego, definir colores, dibujar la serpiente y el poder-up, mostrar la puntuación e implementar la lógica del juego. Ahora puedes ejecutar el juego y disfrutarlo.