I lettori come te aiutano a sostenere MUO. Quando effettui un acquisto utilizzando i link sul nostro sito, potremmo guadagnare una commissione di affiliazione. Per saperne di più.

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 pygame modulo per accedere alle funzioni di PyGame. Per installare il modulo, puoi usa il gestore di pacchetti pip:

pippo installare 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:

instagram viewer 

importare pygame
pygame.dentro()
larghezza_schermo = 750
altezza_schermo = 450
schermo = pygame.display.set_mode((screen_width, screen_height))


ostacolo_x = 400
ostacolo_y = 400
larghezza_ostacolo = 40
altezza_ostacolo = 40
giocatore_x = 200
giocatore_y = 400
player_width = 20
player_height = 20


MentreVERO:

pereventoInpygame.evento.Ottenere():

 if event.type == pygame. ESENTATO:
pygame.esentato()
 esentato()



 chiavi = pygame.key.get_pressed()
Sechiavi[pygame. K_SINISTRA]:
 giocatore_x -= 5
Sechiavi[pygame. K_DESTRA]:
 giocatore_x += 5



 se giocatore_x + larghezza_giocatore > ostacolo_x e giocatore_x < ostacolo_x + larghezza_ostacoloEgiocatore_y + giocatore_altezza > ostacolo_y e giocatore_y < ostacolo_y + altezza_ostacolo:
 game_over = VERO

schermo.riempire((0, 0, 0))
pygame.disegno.rett(schermo, (255, 0, 0), (ostacolo_x, ostacolo_y, larghezza_ostacolo, altezza_ostacolo))
pygame.disegno.rett(schermo, (0, 255, 0), (giocatore_x, giocatore_y, player_width, giocatore_altezza))
pygame.Schermo.aggiornamento()

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 = "menu iniziale"

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.

defdraw_start_menu():
schermo.riempire((0, 0, 0))
 carattere = pygame.font. SysFont('ariale', 40)
 titolo = font.render('Il mio gioco', VERO, (255, 255, 255))
 start_button = font.render('Inizio', VERO, (255, 255, 255))
 screen.blit (titolo, (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.Schermo.aggiornamento()

È quindi possibile aggiungere il draw_start_menu() funzione al ciclo di gioco principale.

MentreVERO: 
pereventoInpygame.evento.Ottenere(): 
 if event.type == pygame. ESENTATO:
pygame.esentato()
 esentato()
Se game_state == "menu iniziale":
 draw_start_menu()

Se game_state == "gioco":
 chiavi = pygame.key.get_pressed()
# resto del codice

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.

Se game_state == "menu iniziale":
 chiavi = pygame.key.get_pressed()
Sechiavi[pygame. K_SPACE]:
 giocatore_x = 200
 giocatore_y = 400
 game_state = "gioco"
 game_over = Falso

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.

defdraw_game_over_screen():
schermo.riempire((0, 0, 0))
 carattere = pygame.font. SysFont('ariale', 40)
 titolo = font.render('Game Over', VERO, (255, 255, 255))
 pulsante_riavvio = font.render('R - Riavvia', VERO, (255, 255, 255))
 quit_button = font.render('Q - Esci', VERO, (255, 255, 255))
 screen.blit (titolo, (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.Schermo.aggiornamento()

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

Se game_state == "menu iniziale":
 draw_start_menu()
Se game_state == "game Over":
 draw_game_over_screen()

Se game_state == "gioco":
 chiavi = pygame.key.get_pressed()
Sechiavi[pygame. K_SINISTRA]:
 giocatore_x -= 5
Sechiavi[pygame. K_DESTRA]:
 giocatore_x += 5

se giocatore_x + larghezza_giocatore > ostacolo_x e giocatore_x < ostacolo_x + larghezza_ostacoloEgiocatore_y + giocatore_altezza > ostacolo_y e giocatore_y < ostacolo_y + altezza_ostacolo:
 game_over = VERO
 game_state = "game Over"

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.

Se game_state == "menu iniziale":
 chiavi = pygame.key.get_pressed()
Sechiavi[pygame. K_SPACE]:
 game_state = "gioco"
 giocatore_x = 200
 giocatore_y = 400
 game_state = "gioco"
 game_over = Falso
Se game_state == "game Over":
 chiavi = pygame.key.get_pressed()
Sechiavi[pygame. K_r]:
 game_state = "menu iniziale"
Sechiavi[pygame. K_q]:
pygame.esentato()
 esentato()

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:

importare pygame
pygame.dentro()
larghezza_schermo = 750
altezza_schermo = 450
schermo = pygame.display.set_mode((screen_width, screen_height))
ostacolo_x = 400
ostacolo_y = 400
larghezza_ostacolo = 40
altezza_ostacolo = 40
giocatore_x = 200
giocatore_y = 400
player_width = 20
player_height = 20
game_state = "menu iniziale"


defdraw_start_menu():
schermo.riempire((0, 0, 0))
 carattere = pygame.font. SysFont('ariale', 40)
 titolo = font.render('Il mio gioco', VERO, (255, 255, 255))
 start_button = font.render('Inizio', VERO, (255, 255, 255))
 screen.blit (titolo, (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.Schermo.aggiornamento()


defdraw_game_over_screen():
schermo.riempire((0, 0, 0))
 carattere = pygame.font. SysFont('ariale', 40)
 titolo = font.render('Game Over', VERO, (255, 255, 255))
 pulsante_riavvio = font.render('R - Riavvia', VERO, (255, 255, 255))
 quit_button = font.render('Q - Esci', VERO, (255, 255, 255))
 screen.blit (titolo, (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.Schermo.aggiornamento()
MentreVERO:
pereventoInpygame.evento.Ottenere():
 if event.type == pygame. ESENTATO:
pygame.esentato()
 esentato()
Se game_state == "menu iniziale":
 draw_start_menu()
 chiavi = pygame.key.get_pressed()
Sechiavi[pygame. K_SPACE]:
 giocatore_x = 200
 giocatore_y = 400
 game_state = "gioco"
 game_over = Falso
elif game_state == "game Over":
 draw_game_over_screen()
 chiavi = pygame.key.get_pressed()
Sechiavi[pygame. K_r]:
 game_state = "menu iniziale"
Sechiavi[pygame. K_q]:
pygame.esentato()
 esentato()

elif game_state == "gioco":
 chiavi = pygame.key.get_pressed()
Sechiavi[pygame. K_SINISTRA]:
 giocatore_x -= 5
Sechiavi[pygame. K_DESTRA]:
 giocatore_x += 5

 se giocatore_x + larghezza_giocatore > ostacolo_x e giocatore_x < ostacolo_x + larghezza_ostacoloEgiocatore_y + giocatore_altezza > ostacolo_y e giocatore_y < ostacolo_y + altezza_ostacolo:
 game_over = VERO
 game_state = "game Over"

schermo.riempire((0, 0, 0))
pygame.disegno.rett(schermo, (255, 0, 0), (ostacolo_x, ostacolo_y, larghezza_ostacolo, altezza_ostacolo))
pygame.disegno.rett(schermo, (0, 255, 0), (giocatore_x, giocatore_y, player_width, giocatore_altezza))
pygame.Schermo.aggiornamento()

elif game Over:
 game_state = "game Over"
 game_over = Falso

Il codice inizia importando il file pygame modulo 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 è menu iniziale, il menu di avvio viene visualizzato sullo schermo. Se lo stato del gioco è game Over, la schermata di fine partita 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. Se c'è una collisione, il gioco imposta il game Over bandiera a VERO 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 file game Over flag è impostato e, se lo è, 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.