Come implementare un sistema sanitario in PyGame

L'implementazione di un sistema sanitario in un gioco può migliorare notevolmente l'esperienza di gioco e aggiungere un ulteriore livello di sfida e strategia. PyGame fornisce un robusto set di strumenti e funzioni per incorporare il sistema sanitario, semplificando la creazione di esperienze interattive.

Crea un gioco semplice

Prima di iniziare, assicurati di averlo pip installato sul tuo sistema. Utilizzare questo comando per installare il file pygame biblioteca:

pip installa pygame

Successivamente, crea un file denominato gioco-semplice.py e inizia creando un semplice gioco in cui il giocatore può muoversi a destra ea sinistra.

Il codice utilizzato in questo articolo è disponibile in this Deposito GitHub ed è gratuito per l'uso con la licenza MIT.

In questo ciclo di gioco di base, l'obiettivo del giocatore sarà quello di evitare di scontrarsi con il nemico.

importare





instagram viewer
 pygame
importare casuale
# Inizializza PyGame
pygame.init()
# Imposta la finestra di gioco
window_width, window_height = 800, 600
finestra = pygame.display.set_mode((finestra_larghezza, finestra_altezza))
pygame.display.set_caption("Demo Sistema Sanitario")
# Attributi del giocatore
player_width, player_height = 50, 50
player_x, player_y = window_width // 2, altezza_finestra - altezza_giocatore - 10
player_speed = 1
# Attributi nemici
larghezza_nemica, altezza_nemica = 50, 50
nemico_x, nemico_y = random.randint(0, larghezza_finestra - larghezza_nemica), 0
nemico_velocità = 0.3
# Ciclo di gioco
correre = VERO
Mentre corsa:
per evento In pygame.event.get():
Se event.type == pygame. ESENTATO:
 correre = Falso
# Sposta il giocatore a sinistra oa destra
 chiavi = pygame.key.get_pressed()
Se chiavi[pygame. K_SINISTRA] E giocatore_x > 0:
 player_x -= player_speed
Se chiavi[pygame. K_DESTRA] E player_x < window_width - player_width:
 player_x += player_speed
# Sposta il nemico verso il basso
 nemico_y += velocità_nemico
# Disegna oggetti di gioco
 finestra.riempimento((0, 0, 0)) # Cancella lo schermo
 pygame.draw.rect (finestra, (255, 0, 0), 
 (giocatore_x, giocatore_y, 
 player_width, player_height)) 
 pygame.draw.rect (finestra, (0, 255, 0), 
 (nemico_x, nemico_y, 
 larghezza_nemica, altezza_nemica)) # Disegna il nemico
 pygame.display.update()
pygame.quit()

Esegui il codice e vedrai una finestra con un personaggio del giocatore che puoi controllare usando i tasti freccia sinistra e destra.

Ora che hai una configurazione di gioco di base, definisci le variabili e le costanti relative alla salute del giocatore. Puoi utilizzare un semplice sistema sanitario in cui puoi rappresentare la salute di un giocatore con un valore numerico. Puoi anche definire costanti per la salute massima del giocatore e la quantità di danni inflitti dal nemico.

Imposta la salute iniziale del giocatore su 100, definisci la salute massima su 100 e imposta il danno del nemico su 20. Questi valori possono essere regolati in base alle esigenze specifiche del tuo gioco.

# Salute del giocatore
player_health = 100
max_health = 100
nemico_danno = 20

Implementazione di meccanismi di danno e guarigione

Per introdurre meccaniche di danno e guarigione, devi rilevare le collisioni tra il giocatore e il nemico e gestire i corrispondenti cambiamenti di salute. Puoi anche implementare un meccanismo per curare il giocatore quando esce dallo schermo.

Controlla se c'è un collisione tra il giocatore e il nemico confrontando i loro rettangoli di delimitazione. Se viene rilevata una collisione, sottrai il valore del danno del nemico dalla salute del giocatore.

Inoltre, se il giocatore esce dalla parte superiore dello schermo (giocatore_y < 0), aggiungi 10 alla loro salute e assicurati che non superi la salute massima. Questo crea una meccanica di guarigione e reimposta la posizione del giocatore nella parte inferiore dello schermo.

Crea un nuovo file denominato danno-e-guarigione.py e aggiungi il codice con i seguenti aggiornamenti:

# All'interno del ciclo di gioco, dopo aver aggiornato la posizione del nemico
# Rileva la collisione tra giocatore e nemico
Se giocatore_x < nemico_x + nemico_larghezza E \
 player_x + player_width > nemico_x E \
 giocatore_y < nemico_y + altezza_nemico \
E player_y + player_height > nemico_y:
 player_health -= nemico_danno
 stampa (giocatore_salute)
# Cura il giocatore quando esce dallo schermo
Se giocatore_y < 0:
 giocatore_salute += 10
 stampa (giocatore_salute)
Se player_health > max_health:
 player_health = max_health
 player_y = window_height - player_height - 10

Di seguito è riportato l'output:

Gestione degli scenari di morte del giocatore e game over

Per gestire gli scenari di morte e game over del giocatore, devi verificare se la salute del giocatore raggiunge lo zero. In tal caso, visualizzare a Game Over messaggio e riavviare il gioco.

Aggiungi un controllo per vedere se la salute del giocatore scende al di sotto o è uguale a zero. Se questa condizione è vera, stampa Game Over e ripristinare la salute e la posizione del giocatore.

Crea un nuovo file denominato gestire-giocatore-morte.py e modificare il codice con i seguenti aggiornamenti:

# Dopo aver aggiornato la posizione del giocatore
# Controlla se la salute del giocatore raggiunge lo zero
Se player_health <= 0:
 stampa("Game Over")
 player_health = max_health
 player_x = window_width // 2
 player_y = window_height - player_height - 10

Comprese funzionalità aggiuntive

Per migliorare ulteriormente il sistema sanitario, è possibile incorporare funzionalità aggiuntive. Di seguito è riportato un esempio:

Potenziamento

Definire gli attributi dell'accensione, come le dimensioni e la posizione. Inoltre, imposta un valore di salute che il giocatore guadagnerà quando si scontra con il potenziamento.

All'interno del ciclo di gioco, rileva le collisioni tra il giocatore e il potenziamento. Se si verifica una collisione, aumenta la salute del giocatore del valore di salute del potenziamento, assicurandoti che non superi la salute massima. Quindi riposiziona l'accensione in modo casuale sullo schermo. Infine, disegna l'oggetto di accensione sullo schermo usando un rettangolo blu.

Crea un nuovo file denominato powerup.py e aggiungi il codice con i seguenti aggiornamenti:

# Definisci gli attributi di accensione
power_up_width, power_up_height = 30, 30
power_up_x, power_up_y = 200,200
power_up_health_value = 50
# All'interno del ciclo di gioco, dopo aver aggiornato la posizione del giocatore
# Rileva la collisione tra il giocatore e l'accensione
Se player_x < power_up_x + power_up_width E\
 player_x + player_width > power_up_x \
E player_y < power_up_y + power_up_height\
E player_y + player_height > power_up_y:
 player_health += power_up_health_value
Se player_health > max_health:
 player_health = max_health
 power_up_x, power_up_y = 200,200
# Disegna l'oggetto di accensione
pygame.draw.rect (finestra, (0, 0, 255), 
 (power_up_x, power_up_y, 
 power_up_width, 
 power_up_height))

Di seguito è riportato l'output:

Per ogni funzionalità aggiuntiva, puoi definire le variabili e le costanti necessarie e implementare le meccaniche corrispondenti all'interno del ciclo di gioco.

Buone Pratiche per il Sistema Sanitario

Quando implementi un sistema sanitario in PyGame, tieni a mente le seguenti best practice:

Implementa sistemi guidati dagli eventi

Invece di controllare continuamente le collisioni o i cambiamenti di salute all'interno del ciclo di gioco, prendi in considerazione l'utilizzo di sistemi basati sugli eventi. PyGame fornisce funzionalità di gestione degli eventi, che ti consentono di attivare azioni relative alla salute in base a eventi specifici, come eventi di collisione o eventi di raccolta dell'accensione.

Bilancia i valori della salute

Regola i valori di salute, i valori di danno e i tassi di guarigione nel tuo gioco per garantire un'esperienza di gioco equilibrata. Il test di gioco e la raccolta di feedback dai giocatori possono aiutarti a mettere a punto questi valori per un gameplay ottimale.

Fornire un feedback

Assicurati che il giocatore riceva un feedback chiaro e significativo sul suo stato di salute. Mostra la barra della salute in primo piano sullo schermo, usa segnali visivi come cambi di colore o animazioni per indicare danni o cure e fornire segnali sonori o visivi quando la salute del giocatore raggiunge livelli critici.

Seguendo queste best practice, puoi creare un sistema sanitario solido e coinvolgente che contribuisca a un'esperienza di gioco coinvolgente.

Rendi i giochi più coinvolgenti con la barra della salute

L'implementazione di un sistema sanitario non solo aggiunge uno strato di sfida, ma rende anche i giochi più coinvolgenti per i giocatori. Incorporando rappresentazioni visive della salute, come le barre della salute, i giocatori possono facilmente valutare il loro stato attuale e prendere decisioni strategiche. Inoltre, l'aggiunta di livelli al tuo gioco può migliorare ulteriormente l'esperienza di gioco.