Si usted es de los que disfruta jugando al juego de la serpiente, estoy seguro de que este artículo le resultará interesante.

En este artículo, le enseñaré cómo crear un sencillo juego de la serpiente que incluso un principiante en Python encontraría fácil de desarrollar.

Existen varias formas de crear este juego y una incluye el uso de la librería PyGame de Python que es una librería de Python que usamos para crear juegos.

La otra forma es mediante el uso de la biblioteca turtle. Este módulo viene preinstalado con Python y proporciona un lienzo virtual para que los usuarios puedan crear formas e imágenes.

Por lo tanto, en este artículo utilizaremos la biblioteca tortuga para implementar nuestro sencillo juego de la serpiente que es fácil de usar, especialmente para los desarrolladores novatos de Python.

Además de este módulo, también utilizaremos otros dos módulos, a saber;

  • Módulo de tiempo – Nos permitirá llevar la cuenta del número de segundos transcurridos desde el tiempo anterior.
  • Módulo Random – Genera números aleatoriamente en Python.

Otras herramientas básicas que necesitará utilizar incluyen un editor de texto de su elección. En este artículo utilizaré VSCode. Por supuesto, necesitará instalar Python 3 en su máquina si no lo tiene ya. También puede utilizar el compilador Geekflare.

¡Esto debería ser divertido!

Cómo funciona el juego de la serpiente

El objetivo final de este juego es que el jugador consiga la mayor puntuación controlando a la serpiente para que recoja la comida que muestra la pantalla.

El jugador controla la serpiente utilizando cuatro teclas de dirección que son relativas a la dirección hacia la que se mueve la serpiente. Si la serpiente choca contra un bloque o contra sí misma, el jugador pierde la partida.

Los siguientes pasos los seguiremos para implementar este juego.

  • Importar a nuestros programas los módulos preinstalados (tortuga, tiempo y aleatorio).
  • Creación de la pantalla del juego utilizando el módulo tortuga.
  • Configuración de las teclas para la dirección de desplazamiento de la serpiente por la pantalla.
  • La implementación del juego.

Cree un archivo snakegame.py en el que añadiremos el código de implementación.

Importar los módulos

En esta parte del código importaremos los módulos tortuga, tiempo y aleatorio que vienen preinstalados por defecto en Python. Además, estableceremos valores por defecto para la puntuación inicial del jugador, la puntuación más alta que alcanzará el jugador y el tiempo de retraso que tardará el jugador en cada movimiento. El módulo de tiempo se utiliza aquí para calcular el tiempo de retraso.

Añada el siguiente trozo de código a su archivo snakegame.py.

import tortuga
import aleatorio
import tiempo

puntuación_jugador = 0
puntuación_máxima = 0
tiempo_de_retraso = 0.1

Creación de la pantalla del juego

El módulo tortuga que importamos aquí nos permitirá crear un lienzo virtual que será la pantalla del juego. A partir de aquí, podemos crear el cuerpo de la serpiente y la comida que la serpiente recogerá. Nuestra pantalla también mostrará la puntuación seguida por el jugador.

Añada este código al archivo Python.

# pantalla de ventana creada
wind = tortuga.Pantalla()
wind.title("Laberinto de serpientes🐍")
wind.bgcolor("rojo")

# El tamaño de la pantalla
wind.setup(width=600, height=600)


# Creación de la serpiente 
serpiente = tortuga.Turtle()
serpiente.shape("cuadrado")
serpiente.color("negro")
serpiente.penup()
serpiente.goto(0, 0)
serpiente.dirección = "Stop"

# crear la comida
comida_serpiente = tortuga.Tortuga()
formas = random.choice('triángulo','círculo')
snake_food.shape(formas)
snake_food.color("azul")
snake_food.speed(0)
snake_food.penup()
snake_food.goto(0, 100)

pluma = tortuga.Tortuga()
pluma.velocidad(0)
pluma.forma('cuadrado')
pen.color('blanco')
pen.penup()
pen.hidetortuga()
pen.goto(0, 250)
pen.write("Su_puntuación: 0 Puntuación_más_alta : 0", align="center", 
font=("Arial", 24, "normal"))
tortuga.bucle_principal()

El fragmento de código anterior comienza inicializando la pantalla de la tortuga y le pasa un título y un color de fondo. Tras definir el tamaño de la ventana de nuestra pantalla, dibujamos la forma de la serpiente en el lienzo virtual.

El método penup() simplemente recoge el lápiz de la tortuga para que no se dibuje una línea mientras la tortuga se mueve. El método goto(x,y) contiene posiciones de coordenadas que mueven a la tortuga a una posición absoluta.

A continuación creamos la comida que recoge la serpiente. Querremos mostrar la puntuación del jugador cada vez que la serpiente recoja la comida y la puntuación más alta que alcance el jugador durante la partida. Por lo tanto, utilizamos el método pen.write() para implementar esto. La función hideturtle() oculta el icono de la tortuga de la pantalla en la sección de la cabecera en la que se escribe este texto.

Es importante añadir el turtle.mainloop() al final de su código, que mostrará la pantalla durante más tiempo para permitirle al usuario hacer algo en la pantalla.

Ejecute el archivo y debería tener la siguiente salida:

The snake and food display with the player's initial and highest score.

Configuración de las teclas de dirección para la serpiente

Aquí configuraremos teclas específicas que guiarán la dirección en la que la serpiente se moverá por la pantalla. Utilizaremos la ‘L’ para izquierda, ‘R’ para derecha, ‘U’ para arriba, ‘D’ para abajo. Implementaremos estas direcciones utilizando la función de dirección de la tortuga que llamaremos en la serpiente.

Añada el siguiente fragmento de código a su código.

# Asignación de direcciones
def movimientoizquierda():
    if serpiente.dirección != "derecha":
        snake.direction = "izquierda"

def moverderecha():
    if dirección.serpiente != "izquierda":
        snake.direction = "derecha"

def moverarriba():
    if dirección.serpiente != "abajo":
        snake.direction = "up"

def moverabajo():
    if dirección.serpiente != "arriba":
        snake.direction = "down"

def mover():
    if serpiente.dirección == "arriba":
        coord_y = serpiente.ycor()
        serpiente.sety(coord_y 20)

    si serpiente.dirección == "abajo
        coord_y = serpiente.ycor()
        serpiente.sety(coord_y-20)

    si serpiente.dirección == "derecha
        coord_x = serpiente.xcor()
        serpiente.setx(coord_x 20)

    si serpiente.dirección == "izquierda": coord_x = serpiente.xcor()
        coord_x = serpiente.xcor()
        serpiente.setx(coord_x-20)

wind.listen()
wind.onkeypress(moverizquierda, 'L')
wind.onkeypress(moverderecha, 'R')
wind.onkeypress(moverarriba, 'U')
wind.onkeypress(moverabajo, 'D')

La función move() anterior establece el movimiento de la serpiente en la posición definida dentro de un valor de coordenadas preciso.

La función listen() es un oyente de eventos que llama a los métodos que mueven la serpiente en una dirección determinada cuando el jugador pulsa la tecla.

La implementación del juego de la serpiente

Después de establecer el esquema básico de nuestro juego de la serpiente, tendremos que hacer que el juego sea en tiempo real.

Esto implicará lo siguiente

  • Aumentar la longitud de la serpiente cada vez que recoja la comida utilizando preferentemente un color diferente.
  • Incrementar la puntuación del jugador cada vez que la serpiente recoja la comida y hacer un seguimiento de la puntuación más alta.
  • El jugador puede controlar que la serpiente no choque con la pared o con su propio cuerpo.
  • El juego se reinicia cuando la serpiente choca.
  • La puntuación del jugador se pone a cero cuando el juego se reinicia, mientras que la pantalla conserva la puntuación más alta del jugador.

Añada el resto de este código a su archivo python.

segmentos = []

#Implementar la jugabilidad
while True
    wind.update()
    si serpiente.xcor() > 290 o serpiente.xcor() < -290 o serpiente.ycor() > 290 o serpiente.ycor() < -290:
        time.sleep(1)
        serpiente.goto(0, 0)
        snake.direction = "Stop"
        serpiente.shape("cuadrado")
        serpiente.color("verde")

        para segmento en segmentos
            segmento.goto(1000, 1000)
            segmentos.clear()
            puntuación_jugador = 0
            tiempo_retraso = 0.1
            pen.clear()
            pen.write("Puntuación_jugador: {} Puntuación_más_alta: {}".format(puntuación_jugador, puntuación_más_alta), align="center", font=("Arial", 24, "normal"))

        if serpiente.distancia(serpiente_comida) < 20:
            coord_x = random.randint(-270, 270)
            coord_y = random.randint(-270, 270)
            snake_food.goto(coord_x, coord_y)

            # Añadir segmento
            segmento_añadido = tortuga.tortuga()
            segmento_añadido.velocidad(0)
            segmento_añadido.shape("cuadrado")
            segmento_añadido.color("blanco")
            segmento_añadido.penup()
            segmentos.append(segmento_añadido)
            tiempo_retraso -= 0.001
            puntuación_jugador = 5

            si puntuación_jugador > puntuación_más_alta
                puntuación_más_alta = puntuación_jugador
                pen.clear()
                pen.write("Puntuación_jugador: {} Puntuación_más_alta: {}".format(puntuación_jugador, puntuación_más_alta), align="center", font=("Arial", 24, "normal"))

    # comprobación de colisiones
    for i in range(len(segmentos)-1, 0, -1):
        coord_x = segmentos[i-1].xcor()
        coord_y = segmentos[i-1].ycor()
        segmentos[i].goto(coord_x, coord_y)

    si len(segmentos) > 0
        coord_x = serpiente.xcor()
        coord_y = serpiente.ycor()
        segmentos[0].goto(coord_x, coord_y)
    mover()

    para segmento en segmentos
        si segmento.distancia(serpiente) < 20
            time.sleep(1)
            serpiente.goto(0, 0)
            snake.direction = "stop"
            serpiente.color('blanco')
            serpiente.forma('cuadrado')

            para segmento en segmentos
                segment.goto(1000, 1000)
                segmento.clear()
                puntuación_jugador = 0
                tiempo_retraso = 0.1
                pen.clear()
                pen.write("Puntuación_jugador: {} Puntuación_más_alta: {}".format(puntuación_jugador, puntuación_más_alta), align="center", font=("Arial", 24, "normal"))

     time.sleep(tiempo_retraso)

tortuga.bucleprincipal()

En el fragmento de código anterior, fijamos una posición aleatoria para la comida de la serpiente dentro de la pantalla. Cada vez que la serpiente recoge esta comida, su segmento corporal aumenta con un color diferente; blanco, en este caso, para distinguir su crecimiento.

Después de que la serpiente recoja la comida sin colisionar, ésta se coloca en una posición aleatoria dentro del rango de 270 coordenadas del tamaño de la pantalla. Cada vez que la serpiente recoge comida, la puntuación del jugador aumenta en 5. Cuando la serpiente colisiona, la puntuación del jugador se pone a 0 mientras que la pantalla conserva su puntuación más alta.

Ahora devuelva el archivo Python y debería ver la pantalla de su tortuga con este aspecto:

Conclusión 🐍

Usar la librería tortuga es una forma fácil y divertida de crear el juego de la serpiente como hemos visto en este artículo. Alternativamente, usted podría implementar lo mismo utilizando la biblioteca PyGame. Puede consultar el tutorial de PyGame aquí y ver cómo podría implementar el juego de forma diferente.

También puede probar un juego de adivinar números en Py thon o cómo obtener datos JSON en Python.
¡Disfrute codificando!