Cómo crear un menú de inicio y una pantalla Game Over con PyGame

PyGame es una biblioteca popular para crear proyectos con Python y proporciona un poderoso conjunto de herramientas para el desarrollo de juegos. En este artículo, aprenderá cómo crear un menú de inicio y una pantalla de fin de juego para un juego simple usando PyGame. ​​​​​​

Crear un juego simple

Antes de crear el menú de inicio y la pantalla de finalización del juego, primero hagamos un juego simple. En este juego, controlarás a un personaje con las teclas de flecha e intentarás evitar los obstáculos. Para mantener las cosas simples, trate de no usar ninguna imagen.

Para comenzar, debe importar los módulos necesarios. Utilizará el módulo pygame para acceder a las funciones de PyGame. Para instalar el módulo, puede usar el administrador de paquetes pip:

pip install pygame

Ahora que nuestro módulo está listo para usar, creemos un juego simple con un jugador que puede moverse hacia la izquierda o hacia la derecha usando las teclas de flecha y un obstáculo. Si chocas con el obstáculo, el juego terminará. Aquí está el código para el mismo:

import pygame
pygame.init()


screen_width = 750
screen_height = 450
screen = pygame.display.set_mode((screen_width, screen_height))

    screen.fill((0, 0, 0))
    pygame.draw.rect(screen, (255, 0, 0), (obstacle_x, obstacle_y, obstacle_width, obstacle_height))
    pygame.draw.rect(screen, (0, 255, 0), (player_x, player_y, player_width, player_height))
    pygame.display.update()

En el código anterior, configuraste la ventana del juego y declaraste las variables del juego. También manejó la entrada del usuario y dibujó los elementos en la pantalla.

Creación del menú de inicio

Ahora que tienes un juego básico, creemos un menú de inicio. Para hacer esto, deberá declarar una variable global para el estado del juego. Esta variable hará un seguimiento del estado actual del juego, como si el menú de inicio está activo o si el juego se está ejecutando. Debes agregar esta variable al comienzo del código de tu juego:

game_state = "start_menu"

A continuación, agregará una función para dibujar el menú de inicio en la pantalla. Puede usar las funciones de PyGame para dibujar el texto, los botones y otros elementos en la pantalla.

def draw_start_menu():
    screen.fill((0, 0, 0))
    font = pygame.font.SysFont('arial', 40)
    title = font.render('My Game', True, (255, 255, 255))
    start_button = font.render('Start', True, (255, 255, 255))
    screen.blit(title, (screen_width/2 - title.get_width()/2, screen_height/2 - title.get_height()/2))
    screen.blit(start_button, (screen_width/2 - start_button.get_width()/2, screen_height/2 + start_button.get_height()/2))
    pygame.display.update()


Luego puede agregar la función draw_start_menu() al ciclo principal del juego.

while True:


   for event in pygame.event.get():
       if event.type == pygame.QUIT:
           pygame.quit()
           quit()

   if game_state == "game":
       keys = pygame.key.get_pressed()
       # rest of the code


Ahora, el menú de inicio se dibujará en la pantalla. El último paso es manejar la entrada del usuario. Puede agregar una declaración if al bucle principal del juego para verificar si el usuario presionó el botón de inicio.

if game_state == "start_menu":
    keys = pygame.key.get_pressed()
    if keys[pygame.K_SPACE]:
        player_x = 200
        player_y = 400
        game_state = "game"
        game_over = False

Con este código, el juego comenzará cuando el usuario presione el botón de inicio.

Implementando la pantalla Game Over

Ahora que tienes el menú de inicio, vamos a crear la pantalla de finalización del juego. Esta función debería mostrar la puntuación final y un mensaje de finalización del juego.

def draw_game_over_screen():
   screen.fill((0, 0, 0))
   font = pygame.font.SysFont('arial', 40)
   title = font.render('Game Over', True, (255, 255, 255))
   restart_button = font.render('R - Restart', True, (255, 255, 255))
   quit_button = font.render('Q - Quit', True, (255, 255, 255))
   screen.blit(title, (screen_width/2 - title.get_width()/2, screen_height/2 - title.get_height()/3))
   screen.blit(restart_button, (screen_width/2 - restart_button.get_width()/2, screen_height/1.9 + restart_button.get_height()))
   screen.blit(quit_button, (screen_width/2 - quit_button.get_width()/2, screen_height/2 + quit_button.get_height()/2))
   pygame.display.update()


Luego puede agregar esta función al bucle principal del juego.

if game_state == "start_menu":
    draw_start_menu()
if game_state == "game_over":
    draw_game_over_screen()


if game_state == "game":
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]:
        player_x -= 5
    if keys[pygame.K_RIGHT]:
        player_x += 5

Finalmente, debe manejar la entrada del usuario para manejar la elección del usuario. Puede agregar una declaración if al bucle principal del juego para verificar si el usuario presionó el botón reiniciar o salir.

if game_state == "start_menu":
    keys = pygame.key.get_pressed()
    if keys[pygame.K_SPACE]:
        game_state = "game"
       player_x = 200
       player_y = 400
       game_state = "game"
       game_over = False


if game_state == "game_over":
    keys = pygame.key.get_pressed()
    if keys[pygame.K_r]:
        game_state = "start_menu"
    if keys[pygame.K_q]:
        pygame.quit()
        quit()

Con este código, el juego se reiniciará cuando el usuario presione el botón ‘R’ y se cerrará cuando el usuario presione el botón ‘Q’ en el teclado.

A continuación se muestra el código completo:

import pygame


pygame.init()
screen_width = 750
screen_height = 450
screen = pygame.display.set_mode((screen_width, screen_height))
obstacle_x = 400
obstacle_y = 400
obstacle_width = 40
obstacle_height = 40
player_x = 200
player_y = 400
player_width = 20
player_height = 20
game_state = "start_menu"

   elif game_over:
       game_state = "game_over"
       game_over = False

El código comienza importando el módulo pygame e inicializándolo. A continuación, crea una ventana de juego y declara las variables de juego necesarias, incluida la posición, la dimensión y el estado del juego del jugador y del obstáculo.

El código define dos funciones, draw_start_menu() y draw_game_over_screen() , para dibujar el menú de inicio y la pantalla de finalización del juego. Estas funciones utilizan las funciones de PyGame para dibujar texto y botones en la pantalla.

El ciclo principal del juego comienza manejando eventos y verificando el estado del juego. Si el estado del juego es start_menu , el menú de inicio se dibuja en la pantalla. Si el estado del juego es game_over , la pantalla de game-over se dibuja en la pantalla. Si el estado del juego es diferente, el juego se actualiza y atrae al jugador y al obstáculo a la pantalla.

El juego se actualiza manejando las pulsaciones de teclas y comprobando si hay una colisión entre el jugador y el obstáculo. Si hay una colisión, el juego establece el indicador game_over en True y establece el estado del juego en game_over .

Después de actualizar el juego, el jugador y el obstáculo se dibujan en la pantalla. Finalmente, el código verifica si el indicador game_over está establecido y, si lo está, restablece el indicador y establece el estado del juego en game_over .

Este proceso se repite continuamente hasta que se cierra la ventana del juego.

Aumente la participación del usuario con una interfaz de usuario visualmente atractiva

El uso de una interfaz de usuario (UI) bien diseñada puede aumentar en gran medida la participación del usuario en un juego de PyGame. Una fuente clara y fácil de leer, gráficos visualmente atractivos, navegación fácil y comentarios de los usuarios son elementos importantes a tener en cuenta al diseñar la interfaz de usuario. Al implementar estos elementos, puede crear una interfaz de usuario que ayude a mantener al jugador interesado e inmerso en el juego.

Recuerde probar su interfaz de usuario y recopilar comentarios de los jugadores para asegurarse de que sea eficaz para aumentar la participación. En general, tomarse el tiempo para crear una interfaz de usuario sólida puede mejorar en gran medida la experiencia del jugador y el disfrute de su juego.