Cum se creează un meniu Start și un ecran Game Over cu PyGame

PyGame este o bibliotecă populară pentru crearea de proiecte cu Python și oferă un set puternic de instrumente pentru dezvoltarea jocurilor. În acest articol, veți învăța cum să creați un meniu de pornire și un joc peste ecran pentru un joc simplu folosind PyGame.

Crearea unui joc simplu

Înainte de a crea meniul de pornire și jocul peste ecran, să facem mai întâi un joc simplu. În acest joc, vei controla un personaj cu tastele săgeți și vei încerca să eviți obstacolele. Pentru a menține lucrurile simple, încercați să nu folosiți nicio imagine.

Pentru a începe, trebuie să importați modulele necesare. Veți folosi pygame modul pentru a accesa funcțiile PyGame. Pentru a instala modulul, puteți utilizați managerul de pachete pip:

pip instalare pygame

Acum că modulul nostru este gata de utilizare, să creăm un joc simplu cu un jucător care se poate deplasa la stânga sau la dreapta folosind tastele săgeți și un obstacol. Dacă te ciocnești de obstacol, jocul se va termina. Iată codul pentru același lucru:

import pygame
pygame.init()
screen_width = 750
screen_height = 450
ecran = pygame.display.set_mode((screen_width, screen_height))
obstacol_x = 400
obstacol_y = 400
lățime_obstacol = 40
înălțimea_obstacolului = 40
player_x = 200
player_y = 400
player_width = 20
înălțimea_jucătorului = 20
in timp ceAdevărat:

pentruevenimentînpygame.eveniment.obține():

 if event.type == pygame. PĂRĂSI:
pygame.părăsi()
 părăsi()

 taste = pygame.key.get_pressed()
dacăchei[pygame. K_LEFT]:
 player_x -= 5
dacăchei[pygame. K_DREPTA]:
 player_x += 5

 dacă player_x + player_width > obstacol_x și player_x < obstacol_x + lățime_obstacolșiplayer_y + înălțimea_jucătorului > obstacol_y și jucător_y < obstacol_y + obstacol_height:
 game_over = Adevărat

ecran.completati((0, 0, 0))
pygame.a desena.rect(ecran, (255, 0, 0), (obstacol_x, obstacol_y, lățime_obstacol, înălțimea_obstacolului))
pygame.a desena.rect(ecran, (0, 255, 0), (player_x, player_y, player_width, înălțimea_jucătorului))
pygame.afişa.Actualizați()

În codul de mai sus, ați configurat fereastra jocului și ați declarat variabilele jocului. De asemenea, te-ai ocupat de intrarea utilizatorului și ai desenat elementele pe ecran.

Crearea meniului Start

Acum că aveți un joc de bază, să creăm un meniu de pornire. Pentru a face acest lucru, va trebui să declarați o variabilă globală pentru starea jocului. Această variabilă va ține evidența stării curente a jocului, cum ar fi dacă meniul de pornire este activ sau dacă jocul rulează. Trebuie să adăugați această variabilă la începutul codului de joc:

joc_state = "start_meniu"

Apoi, veți adăuga o funcție pentru a desena meniul de pornire pe ecran. Puteți folosi funcțiile PyGame pentru a desena textul, butoanele și alte elemente de pe ecran.

defdraw_start_menu():
ecran.completati((0, 0, 0))
 font = pygame.font. SysFont("arial", 40)
 titlu = font.render('Jocul meu', Adevărat, (255, 255, 255))
 start_button = font.render('Start', Adevărat, (255, 255, 255))
 screen.blit (titlu, (screen_width/2 - title.get_width()/2, screen_height/2 - title.get_height()/2))
 screen.blit (button_start, (screen_width/2 - start_button.get_width()/2, screen_height/2 + start_button.get_height()/2))
pygame.afişa.Actualizați()

Apoi puteți adăuga draw_start_menu() funcția la bucla principală a jocului.

in timp ceAdevărat: 
pentruevenimentînpygame.eveniment.obține(): 
 if event.type == pygame. PĂRĂSI:
pygame.părăsi()
 părăsi()
dacă joc_state == "start_meniu":
 draw_start_menu()

dacă joc_state == "joc":
 taste = pygame.key.get_pressed()
# restul codului

Acum, meniul de pornire va fi desenat pe ecran. Ultimul pas este gestionarea intrării utilizatorului. Puteți adăugați o declarație if la bucla principală a jocului pentru a verifica dacă utilizatorul a apăsat butonul de pornire.

dacă joc_state == "start_meniu":
 taste = pygame.key.get_pressed()
dacăchei[pygame. K_SPACE]:
 player_x = 200
 player_y = 400
 joc_state = "joc"
 game_over = Fals

Cu acest cod, jocul va începe când utilizatorul apasă butonul de pornire.

Implementarea ecranului Game Over

Acum că aveți meniul de pornire, să creăm jocul peste ecran. Această funcție ar trebui să afișeze scorul final și un mesaj de final de joc.

defdraw_game_over_screen():
ecran.completati((0, 0, 0))
 font = pygame.font. SysFont("arial", 40)
 titlu = font.render('Joc încheiat', Adevărat, (255, 255, 255))
 restart_button = font.render(„R - Reporniți”, Adevărat, (255, 255, 255))
 quit_button = font.render(„Î - Ieșire”, Adevărat, (255, 255, 255))
 screen.blit (titlu, (screen_width/2 - title.get_width()/2, screen_height/2 - title.get_height()/3))
 screen.blit (button_repornire, (lățimea_ecranului/2 - restart_button.get_width()/2, înălțimea_ecranului/1.9 + restart_button.get_height()))
 screen.blit (button_quit, (screen_width/2 - quit_button.get_width()/2, screen_height/2 + quit_button.get_height()/2))
pygame.afişa.Actualizați()

Puteți adăuga apoi această funcție în bucla principală a jocului.

dacă joc_state == "start_meniu":
 draw_start_menu()
dacă joc_state == "joc încheiat":
 draw_game_over_screen()

dacă joc_state == "joc":
 taste = pygame.key.get_pressed()
dacăchei[pygame. K_LEFT]:
 player_x -= 5
dacăchei[pygame. K_DREPTA]:
 player_x += 5

dacă player_x + player_width > obstacol_x și player_x < obstacol_x + lățime_obstacolșiplayer_y + înălțimea_jucătorului > obstacol_y și jucător_y < obstacol_y + obstacol_height:
 game_over = Adevărat
 joc_state = "joc încheiat"

În cele din urmă, trebuie să gestionați intrarea utilizatorului pentru a gestiona alegerea utilizatorului. Puteți adăuga o declarație if în bucla principală a jocului pentru a verifica dacă utilizatorul a apăsat butonul de repornire sau de ieșire.

dacă joc_state == "start_meniu":
 taste = pygame.key.get_pressed()
dacăchei[pygame. K_SPACE]:
 joc_state = "joc"
 player_x = 200
 player_y = 400
 joc_state = "joc"
 game_over = Fals
dacă joc_state == "joc încheiat":
 taste = pygame.key.get_pressed()
dacăchei[pygame. K_r]:
 joc_state = "start_meniu"
dacăchei[pygame. K_q]:
pygame.părăsi()
 părăsi()

Cu acest cod, jocul va reporni atunci când utilizatorul apasă butonul „R” și se va renunța când utilizatorul apasă butonul „Q” de pe tastatură.

Mai jos este codul complet:

import pygame
pygame.init()
screen_width = 750
screen_height = 450
ecran = pygame.display.set_mode((screen_width, screen_height))
obstacol_x = 400
obstacol_y = 400
lățime_obstacol = 40
înălțimea_obstacolului = 40
player_x = 200
player_y = 400
player_width = 20
înălțimea_jucătorului = 20
joc_state = "start_meniu"
defdraw_start_menu():
ecran.completati((0, 0, 0))
 font = pygame.font. SysFont("arial", 40)
 titlu = font.render('Jocul meu', Adevărat, (255, 255, 255))
 start_button = font.render('Start', Adevărat, (255, 255, 255))
 screen.blit (titlu, (screen_width/2 - title.get_width()/2, screen_height/2 - title.get_height()/2))
 screen.blit (button_start, (screen_width/2 - start_button.get_width()/2, screen_height/2 + start_button.get_height()/2))
pygame.afişa.Actualizați()
defdraw_game_over_screen():
ecran.completati((0, 0, 0))
 font = pygame.font. SysFont("arial", 40)
 titlu = font.render('Joc încheiat', Adevărat, (255, 255, 255))
 restart_button = font.render(„R - Reporniți”, Adevărat, (255, 255, 255))
 quit_button = font.render(„Î - Ieșire”, Adevărat, (255, 255, 255))
 screen.blit (titlu, (screen_width/2 - title.get_width()/2, screen_height/2 - title.get_height()/3))
 screen.blit (button_repornire, (lățimea_ecranului/2 - restart_button.get_width()/2, înălțimea_ecranului/1.9 + restart_button.get_height()))
 screen.blit (button_quit, (screen_width/2 - quit_button.get_width()/2, screen_height/2 + quit_button.get_height()/2))
pygame.afişa.Actualizați()
in timp ceAdevărat:
pentruevenimentînpygame.eveniment.obține():
 if event.type == pygame. PĂRĂSI:
pygame.părăsi()
 părăsi()
dacă joc_state == "start_meniu":
 draw_start_menu()
 taste = pygame.key.get_pressed()
dacăchei[pygame. K_SPACE]:
 player_x = 200
 player_y = 400
 joc_state = "joc"
 game_over = Fals
elif joc_state == "joc încheiat":
 draw_game_over_screen()
 taste = pygame.key.get_pressed()
dacăchei[pygame. K_r]:
 joc_state = "start_meniu"
dacăchei[pygame. K_q]:
pygame.părăsi()
 părăsi()

elif joc_state == "joc":
 taste = pygame.key.get_pressed()
dacăchei[pygame. K_LEFT]:
 player_x -= 5
dacăchei[pygame. K_DREPTA]:
 player_x += 5

 dacă player_x + player_width > obstacol_x și player_x < obstacol_x + lățime_obstacolșiplayer_y + înălțimea_jucătorului > obstacol_y și jucător_y < obstacol_y + obstacol_height:
 game_over = Adevărat
 joc_state = "joc încheiat"

ecran.completati((0, 0, 0))
pygame.a desena.rect(ecran, (255, 0, 0), (obstacol_x, obstacol_y, lățime_obstacol, înălțimea_obstacolului))
pygame.a desena.rect(ecran, (0, 255, 0), (player_x, player_y, player_width, înălțimea_jucătorului))
pygame.afişa.Actualizați()

elif joc încheiat:
 joc_state = "joc încheiat"
 game_over = Fals

Codul începe prin importul pygame modul și inițializarea acestuia. Apoi creează o fereastră de joc și declară variabilele de joc necesare, inclusiv poziția jucătorului și obstacolului, dimensiunea și starea jocului.

Codul definește două funcții, draw_start_menu() și draw_game_over_screen(), pentru a desena meniul de pornire și jocul peste ecran. Aceste funcții folosesc funcțiile PyGame pentru a desena text și butoane pe ecran.

Bucla principală a jocului începe prin gestionarea evenimentelor și verificarea stării jocului. Dacă starea jocului este start_meniu, meniul de pornire este desenat pe ecran. Dacă starea jocului este joc încheiat, ecranul de terminare a jocului este atras pe ecran. Dacă starea jocului este altceva, jocul se actualizează și atrage jucătorul și obstacolul pe ecran.

Jocul se actualizează prin gestionarea apăsărilor de taste și verificând o coliziune între jucător și obstacol. Dacă există o coliziune, jocul stabilește joc încheiat steag la Adevărat și setează starea jocului la joc încheiat.

După ce jocul este actualizat, jucătorul și obstacolul sunt atrase pe ecran. În cele din urmă, codul verifică dacă joc încheiat steag este setat, iar dacă este, resetează steag și setează starea jocului la joc încheiat.

Acest proces se repetă continuu până când fereastra jocului este închisă.

Creșteți implicarea utilizatorilor cu o interfață de utilizare atractivă din punct de vedere vizual

Utilizarea unei interfețe de utilizator (UI) bine concepută poate crește foarte mult implicarea utilizatorului într-un joc PyGame. Un font clar și ușor de citit, grafică atractivă din punct de vedere vizual, navigare ușoară și feedback-ul utilizatorilor sunt toate elementele importante de luat în considerare atunci când proiectați interfața de utilizare. Prin implementarea acestor elemente, puteți crea o interfață de utilizare care ajută la menținerea jucătorului interesat și cufundat în joc.

Nu uitați să vă testați interfața de utilizare și să adunați feedback de la jucători pentru a vă asigura că este eficient în creșterea angajamentului. În general, alocarea timpului pentru a crea o interfață de utilizare puternică poate îmbunătăți considerabil experiența jucătorului și plăcerea jocului tău.