Logotipo de Zephyrnet

Inteligencia de datos generativa

Big Data

Crea tu primer juego con Python: Snake Game

Reeditado por Platón
Reeditado por Platón

Fecha:

Vistas: 97

Python es divertido y sencillo de usar. Con una amplia gama de bibliotecas disponibles, Python nos hace la vida más fácil al simplificar la creación de juegos y aplicaciones. En este artículo, crearemos un juego clásico que muchos de nosotros probablemente hayamos jugado en algún momento de nuestras vidas: el juego de la serpiente. Si no has experimentado este juego antes, ahora tienes la oportunidad de explorar y crear tu propia versión sin la necesidad de instalar bibliotecas pesadas en tu sistema. Todo lo que necesitas para comenzar a crear este nostálgico juego de serpientes es un conocimiento básico de Python y un editor de codificación en línea como repl.it.

El juego de la serpiente es un clásico arcade atemporal en el que el jugador controla una serpiente que crece a medida que consume comida. En esta implementación, analicemos el código para comprender cómo está estructurado el juego y cómo se utiliza la biblioteca Turtle para los gráficos y la interacción del usuario.

Tabla de contenidos.

Uso de Turtle Graphics para el desarrollo de juegos sencillos

Los gráficos de la tortuga. biblioteca en Python proporciona una forma divertida e interactiva de crear formas, dibujar en la pantalla y responder a las entradas del usuario. A menudo se utiliza con fines educativos, enseñando conceptos de programación a través de comentarios visuales. Este código utiliza Turtle para crear elementos del juego, como la serpiente, la comida y la visualización de la puntuación.

Editor de codificación en línea: Repl.it

Una plataforma de codificación web llamada Repl.it le permite desarrollar, ejecutar y colaborar en código directamente desde su navegador web. Admite muchos lenguajes de programación diferentes y tiene compiladores e intérpretes integrados, además de funciones como compartir código, control de versiones y trabajo en equipo. Los desarrolladores lo utilizan ampliamente para aprender, crear prototipos rápidamente y compartir código porque es fácil de usar y no requiere configuración.

Algoritmo

Comencemos a construir nuestro primer juego con Python. Para hacerlo debemos seguir ciertos pasos a continuación:

Crear archivo de respuesta

Paso 1: instalar las bibliotecas necesarias

Esto marca el paso inicial en el desarrollo del juego conocido como Snake. Tortuga, azar y tiempo se encuentran entre ellos.

  • Tortuga: Necesitamos esta biblioteca para crear los gráficos de nuestro juego. Podemos manipular los movimientos de la comida y la serpiente en la pantalla y dibujarlos.
  • Aleatorio: Para crear ubicaciones aleatorias para la comida en la pantalla, utilizamos la biblioteca aleatoria. Esto asegura que cada vez que se ingiere el alimento, éste aparezca en un lugar diferente.
  • Tiempo: La serpiente se mueve con un ligero retraso entre cada movimiento gracias a la biblioteca de tiempo. Esto hace que el juego sea más fácil de operar y más divertido para los jugadores.
import turtle
import time
import random

Paso 2: configurar el entorno del juego.

Esto incluye establecer las dimensiones de la pantalla, agregar un fondo azul y agregar un pequeño retraso para garantizar un juego fluido. También configuramos variables como high_score para retener la puntuación más alta obtenida, puntuación para monitorear la puntuación del jugador y segmentos para rastrear el cuerpo de la serpiente.

# Initialize the screen
sc = turtle.Screen()
sc.bgcolor("blue")
sc.setup(height=1000, width=1000)
delay = 0.1

# Initialize variables
segments = []
score = 0
high_score = 0
Salida

Paso 3: Creando la serpiente

Un objeto de tortuga con forma cuadrada simboliza la serpiente. Ubicamos el lápiz en el centro de la pantalla (goto(0, 100)), configuramos su color en negro, luego lo elevamos para evitar dibujar líneas. Originalmente configurada en "detener", la dirección de la serpiente permanece estacionaria hasta que el jugador comienza a moverla.

# Create the snake
snake = turtle.Turtle()
snake.shape("square")
snake.color("black")
snake.penup()
snake.goto(0, 100)
snake.direction = "stop"
Creando serpiente

Paso 4: Funciones de movimiento

Definimos las funciones de movimiento de la serpiente (move()) según su dirección en ese momento. Estas funciones controlan la capacidad de la serpiente para moverse hacia arriba, abajo, izquierda y derecha. Mueven la cabeza de la serpiente 20 unidades en la dirección apropiada cuando se les pide.

# Functions to move the snake
def move():
    if snake.direction == "up":
        y = snake.ycor()
        snake.sety(y + 20)
    if snake.direction == "down":
        y = snake.ycor()
        snake.sety(y - 20)
    if snake.direction == "left":
        x = snake.xcor()
        snake.setx(x - 20)
    if snake.direction == "right":
        x = snake.xcor()
        snake.setx(x + 20)

Paso 5: controlar la serpiente

Usando sc.listen() y sc.onkey(), configuramos oyentes clave para controlar la serpiente. Las rutinas relacionadas (go_up(), go_down(), go_left(), go_right()) alteran la dirección de la serpiente en respuesta a las pulsaciones de teclas en el teclado w, s, a o d.

# Functions to link with the keys
def go_up():
    snake.direction = "up"

def go_down():
    snake.direction = "down"

def go_left():
    snake.direction = "left"

def go_right():
    snake.direction = "right"

# Listen for key inputs
sc.listen()
sc.onkey(go_up, "w")
sc.onkey(go_down, "s")
sc.onkey(go_left, "a")
sc.onkey(go_right, "d")

Paso 6: crear la comida

La comida está representada por un objeto circular de tortuga de color rojo. Inicialmente colocado en las coordenadas (100, 100), sirve como objetivo para que la serpiente lo coma. Cuando la serpiente choca con la comida, la "come" y aparece una nueva en un lugar aleatorio.

# Create the food
food = turtle.Turtle()
food.shape("circle")
food.color("red")
food.penup()
food.goto(100, 100)
Creando la comida

Paso 7: Visualización de la puntuación

Un objeto tortuga (bolígrafo) muestra la puntuación del jugador y la puntuación más alta alcanzada. Esta información se actualiza cada vez que la serpiente come la comida.

# Create the score display
pen = turtle.Turtle()
pen.penup()
pen.goto(0, 100)
pen.hideturtle()
pen.write("Score: 0  High Score: 0", align="center", font=("Arial", 30, "normal")
Mostrando puntuación

Paso 8: bucle principal del juego

El núcleo del juego Snake es el bucle principal del juego. Gestiona las entradas del usuario, actualiza la pantalla, mueve la serpiente, busca colisiones y regula cómo se desarrolla el juego. Examinemos con más detalle las funciones específicas de cada sección del bucle principal:

while True:
    sc.update()  # Update the screen
    move()  # Move the snake
    time.sleep(delay)  # Introduce a slight delay for smooth gameplay
  • sc.update(): actualiza la pantalla para reflejar cualquier cambio realizado en el juego. Sin esto, la pantalla no se actualizaría y los jugadores no verían el movimiento de la serpiente ni la actualización de la puntuación.
  • move(): Esta función controla el movimiento de la serpiente en función de su dirección actual. Mueve la cabeza de la serpiente 20 unidades en la dirección especificada por la entrada del jugador. La serpiente se mueve continuamente en la dirección en la que fue dirigida por última vez hasta que el jugador cambia de dirección.
  • time.sleep(delay): introduce un ligero retraso entre cada movimiento de la serpiente. El delay la variable está configurada para 0.1 al principio del código. El objetivo de este retraso es controlar la velocidad del juego. Sin él, la serpiente se movería demasiado rápido para que el jugador reaccionara, lo que dificultaría el juego.

Comer comida y hacer crecer la serpiente

    if snake.distance(food) < 20:
        x = random.randint(-200, 200)
        y = random.randint(-200, 200)
        food.penup()
        food.goto(x, y)
        food.pendown()

        # Increase the length of the snake
        new_segment = turtle.Turtle()
        new_segment.shape("square")
        new_segment.color("grey")
        new_segment.penup()
        segments.append(new_segment)
        score += 1

        # Update score and high score
        if score > high_score:
            high_score = score
        pen.clear()
        pen.write("Score: {}  High Score: {}".format(score, high_score), align="center", font=("Arial", 30, "normal"))

Comiendo comida

  • Cuando la cabeza de la serpiente (snake) se encuentra a una distancia de 20 unidades del alimento (food), significa que la serpiente se ha “comido” la comida.
  • Luego, la posición de la comida se restablece a una nueva ubicación aleatoria en la pantalla usando random.randint().
  • Esta acción genera la ilusión de que la comida “reaparece” en diferentes lugares cada vez que se come.

Hacer crecer el cuerpo de la serpiente

  • Cuando la serpiente come la comida, el código agrega un nuevo segmento al cuerpo de la serpiente para hacerlo crecer.
  • Un nuevo objeto tortuga (new_segment), que pasa a formar parte del segments lista.
  • Esta lista realiza un seguimiento de todos los segmentos que forman el cuerpo de la serpiente.
  • La puntuación del jugador se incrementa (score += 1) cada vez que la serpiente come.

Actualización de puntuación

  • Después de comer y actualizar la puntuación, la visualización de la puntuación se actualiza utilizando el pen objeto.
  • El pen.clear() La función borra la visualización de puntuación anterior.
  • Luego, la puntuación actualizada y la puntuación más alta se escriben en la pantalla usando pen.write().

Moviendo el cuerpo de la serpiente

    for i in range(len(segments) - 1, 0, -1):
        x = segments[i - 1].xcor()
        y = segments[i - 1].ycor()
        segments[i].goto(x, y)

    # Move the first segment to follow the head
    if len(segments) > 0:
        x = snake.xcor()
        y = snake.ycor()
        segments[0].goto(x, y)
  • Esta sección de código es responsable de hacer que el cuerpo de la serpiente siga su cabeza.
  • Itera a través del segments lista, comenzando desde el último segmento (len(segments) - 1) hasta el segundo segmento (0), moviendo cada segmento a la posición del segmento frente a él.
  • Esto crea el efecto de que el cuerpo de la serpiente sigue a la cabeza mientras se mueve.

Actualización del primer segmento (encabezado)

  • Después de mover todos los segmentos del cuerpo, la posición del primer segmento (la cabeza) se actualiza para que coincida con la posición actual de la serpiente (snake).
  • Esto asegura que la cabeza de la serpiente continúe guiando al cuerpo mientras se mueve.

Nota final

Este código proporciona una estructura básica para un juego Snake utilizando la biblioteca de gráficos Turtle. El juego consiste en controlar una serpiente para comer y crecer mientras evita colisiones con las paredes y su propia cola. Es un excelente proyecto para principiantes para aprender sobre conceptos de desarrollo de juegos, programación básica de Python y trabajar con gráficos y entradas del usuario. ¡Siéntete libre de personalizar y ampliar este código para agregar funciones como detección de colisiones, aumentar la dificultad o agregar niveles para hacer que tu juego Snake sea aún más emocionante!

Si desea obtener más información sobre Python, inscríbase en nuestro curso gratuito de Python.

Lea también nuestros artículos más relacionados con Python aquí:

Podcast: Jugar en una ventana nueva | Descargar

punto_img

Información más reciente

punto_img

Derechos de autor @ 2024 Plato Technologies Inc.