Come creare un menu di avvio e una schermata di Game Over con PyGame

PyGame è una popolare libreria per la creazione di progetti con Python e fornisce un potente set di strumenti per lo sviluppo di giochi. In questo articolo imparerai come creare un menu di avvio e una schermata di gioco per un semplice gioco usando PyGame. ​​​​​​

Creazione di un gioco semplice

Prima di creare il menu di avvio e la schermata di game over, creiamo prima un semplice gioco. In questo gioco controllerai un personaggio con i tasti freccia e cercherai di evitare gli ostacoli. Per semplificare le cose, cerca di non utilizzare alcuna immagine.

Per iniziare, devi importare i moduli necessari. Utilizzerai il modulo pygame per accedere alle funzioni di PyGame. Per installare il modulo, puoi utilizzare il gestore di pacchetti pip:

pip install pygame

Ora che il nostro modulo è pronto per l’uso, creiamo un semplice gioco con un giocatore che può muoversi a sinistra oa destra usando i tasti freccia e un ostacolo. Se ti scontri con l’ostacolo, il gioco finirà. Ecco il codice per lo stesso:

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()

Nel codice sopra, hai impostato la finestra del gioco e dichiarato le variabili del gioco. Hai anche gestito l’input dell’utente e disegnato gli elementi sullo schermo.

Creazione del menu di avvio

Ora che hai un gioco di base, creiamo un menu di avvio. Per fare ciò, dovrai dichiarare una variabile globale per lo stato del gioco. Questa variabile terrà traccia dello stato attuale del gioco, ad esempio se il menu di avvio è attivo o se il gioco è in esecuzione. Devi aggiungere questa variabile all’inizio del codice del tuo gioco:

game_state = "start_menu"

Successivamente, aggiungerai una funzione per disegnare il menu di avvio sullo schermo. Puoi utilizzare le funzioni di PyGame per disegnare il testo, i pulsanti e altri elementi sullo schermo.

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()


Puoi quindi aggiungere la funzione draw_start_menu() al ciclo di gioco principale.

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


Ora, il menu di avvio verrà disegnato sullo schermo. L’ultimo passaggio consiste nel gestire l’input dell’utente. Puoi aggiungere un’istruzione if al ciclo di gioco principale per verificare se l’utente ha premuto il pulsante di avvio.

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 questo codice, il gioco inizierà quando l’utente preme il pulsante di avvio.

Implementazione della schermata Game Over

Ora che hai il menu di avvio, creiamo la schermata del game over. Questa funzione dovrebbe visualizzare il punteggio finale e un messaggio di game over.

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()


È quindi possibile aggiungere questa funzione al ciclo di gioco principale.

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

Infine, è necessario gestire l’input dell’utente per gestire la scelta dell’utente. Puoi aggiungere un’istruzione if al ciclo di gioco principale per verificare se l’utente ha premuto il pulsante di riavvio o di uscita.

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 questo codice, il gioco si riavvierà quando l’utente preme il pulsante “R” e si chiude quando l’utente preme il pulsante “Q” sulla tastiera.

Di seguito il codice 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

Il codice inizia importando il modulo pygame e inizializzandolo. Quindi crea una finestra di gioco e dichiara le variabili di gioco necessarie, tra cui la posizione del giocatore e dell’ostacolo, la dimensione e lo stato del gioco.

Il codice definisce due funzioni, draw_start_menu() e draw_game_over_screen() , per disegnare il menu di avvio e la schermata di game over. Queste funzioni usano le funzioni PyGame per disegnare testo e pulsanti sullo schermo.

Il ciclo di gioco principale inizia gestendo gli eventi e controllando lo stato del gioco. Se lo stato del gioco è start_menu , il menu di avvio viene visualizzato sullo schermo. Se lo stato del gioco è game_over , la schermata di game over viene disegnata sullo schermo. Se lo stato del gioco è diverso, il gioco si aggiorna e attira il giocatore e l’ostacolo sullo schermo.

Il gioco si aggiorna gestendo la pressione dei tasti e controllando la collisione tra il giocatore e l’ostacolo. In caso di collisione, il gioco imposta il flag game_over su True e imposta lo stato del gioco su game_over .

Dopo che il gioco è stato aggiornato, il giocatore e l’ostacolo vengono disegnati sullo schermo. Infine, il codice verifica se il flag game_over è impostato e, in tal caso, reimposta il flag e imposta lo stato del gioco su game_over .

Questo processo viene ripetuto continuamente fino alla chiusura della finestra di gioco.

Aumenta il coinvolgimento degli utenti con un’interfaccia utente visivamente accattivante

L’utilizzo di un’interfaccia utente (UI) ben progettata può aumentare notevolmente il coinvolgimento degli utenti in un gioco PyGame. Un carattere chiaro e di facile lettura, una grafica visivamente accattivante, una facile navigazione e il feedback degli utenti sono tutti elementi importanti da considerare durante la progettazione dell’interfaccia utente. Implementando questi elementi, puoi creare un’interfaccia utente che aiuta a mantenere il giocatore interessato e immerso nel gioco.

Ricorda di testare la tua interfaccia utente e raccogliere feedback dai giocatori per assicurarti che sia efficace nell’aumentare il coinvolgimento. Nel complesso, dedicare del tempo alla creazione di un’interfaccia utente forte può migliorare notevolmente l’esperienza del giocatore e il divertimento del gioco.