Sådan implementeres et sundhedssystem i PyGame

Implementering af et sundhedssystem i et spil kan i høj grad forbedre gameplay-oplevelsen og tilføje et ekstra lag af udfordring og strategi. PyGame giver et robust sæt værktøjer og funktioner til at inkorporere sundhedssystemet, hvilket gør det nemt at skabe interaktive oplevelser.

Opret et simpelt spil

Før du starter, skal du sikre dig, at du har pip installeret på dit system. Brug denne kommando til at installere pygame bibliotek:

pip installer pygame

Derefter skal du oprette en fil med navnet simple-game.py og start med at lave et simpelt spil, hvor spilleren kan bevæge sig til venstre og højre.

Koden brugt i denne artikel er tilgængelig i denne GitHub-depot og er gratis for dig at bruge under MIT-licensen.

I denne grundlæggende spilløkke vil spillerens mål være at undgå at kollidere med fjenden.

importere pygame
importere tilfældig
# Initialiser PyGame
pygame.init()
# Indstil spilvinduet





instagram viewer

vinduesbredde, vindueshøjde = 800, 600
vindue = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Health System Demo")

# Spilleregenskaber
player_width, player_height = 50, 50
player_x, player_y = window_width // 2, vindueshøjde - spillerhøjde - 10
player_speed = 1
# Fjendens egenskaber
enemy_width, enemy_height = 50, 50
enemy_x, enemy_y = random.randint(0, window_width - enemy_width), 0
enemy_speed = 0.3
# Spilløkke
kører = Rigtigt
mens kører:
til begivenhed i pygame.event.get():
hvis event.type == pygame. AFSLUT:
 kører = Falsk
# Flyt afspilleren til venstre eller højre
 keys = pygame.key.get_pressed()
hvis nøgler[pygame. K_LEFT] og player_x > 0:
 player_x -= player_speed
hvis nøgler[pygame. K_RIGHT] og player_x < window_width - player_width:
 player_x += player_speed
# Flyt fjenden nedad
 enemy_y += enemy_speed
# Tegn spilobjekter
 window.fill((0, 0, 0)) # Ryd skærmen
 pygame.draw.rect (vindue, (255, 0, 0), 
 (player_x, player_y, 
 player_width, player_height)) 
 pygame.draw.rect (vindue, (0, 255, 0), 
 (enemy_x, enemy_y, 
 enemy_width, enemy_height)) # Tegn fjende
 pygame.display.update()
pygame.quit()

Kør koden, og du vil se et vindue med en spillerkarakter, som du kan styre ved hjælp af venstre og højre piletaster.

Nu hvor du har en grundlæggende spilopsætning, skal du definere variablerne og konstanterne relateret til spillerens helbred. Du kan bruge et simpelt sundhedssystem, hvor du kan repræsentere en spillers helbred med en numerisk værdi. Du kan også definere konstanter for spillerens maksimale helbred og mængden af ​​skader påført af fjenden.

Indstil den indledende spillersundhed til 100, definer den maksimale sundhed som 100, og indstil fjendens skade til 20. Disse værdier kan justeres i henhold til de specifikke behov i dit spil.

# Spillerens sundhed
player_health = 100
max_health = 100
enemy_damage = 20

Implementering af skades- og helingsmekanik

For at introducere skader og helbredende mekanikker skal du opdage kollisioner mellem spilleren og fjenden og håndtere de tilsvarende sundhedsændringer. Du kan også implementere en mekanisme til at helbrede spilleren, når de bevæger sig væk fra skærmen.

Tjek om der er en kollision mellem spilleren og fjenden ved at sammenligne deres afgrænsende rektangler. Hvis en kollision opdages, skal du trække fjendens skadeværdi fra spillerens helbred.

Derudover, hvis afspilleren bevæger sig væk fra toppen af ​​skærmen (spiller_y < 0), tilføje 10 til deres helbred og sikre, at det ikke overstiger det maksimale helbred. Dette skaber en helbredende mekaniker og nulstiller spillerens position til bunden af ​​skærmen.

Opret en ny fil med navnet damage-and-healing.py og tilføj koden med nedenstående opdateringer:

# Inde i spilløkken efter opdatering af fjendens position
# Registrer kollision mellem spiller og fjende
hvis player_x < enemy_x + enemy_width og \
 player_x + player_width > enemy_x og \
 player_y < enemy_y + enemy_height \
og player_y + player_height > enemy_y:
 player_health -= enemy_damage
 print (player_health)
# Helbred spilleren, når de bevæger sig væk fra skærmen
hvis player_y < 0:
 player_health += 10
 print (player_health)
hvis player_health > max_health:
 player_health = max_health
 player_y = window_height - player_height - 10

Nedenfor er output:

Håndtering af spillerdøds- og Game Over-scenarier

For at håndtere spillerens døds- og game-over-scenarier skal du kontrollere, om spillerens helbred når nul. Hvis det gør det, skal du vise en Game Over besked og genstart spillet.

Tilføj en kontrol for at se, om spillerens helbred falder under eller er lig med nul. Hvis denne betingelse er sand, skal du udskrive Game Over og nulstil spillerens helbred og position.

Opret en ny fil med navnet manage-player-death.py og rediger koden med nedenstående opdateringer:

# Efter opdatering af spillerens position
# Tjek om spillerens helbred når nul
hvis player_health <= 0:
 Print("Game over")
 player_health = max_health
 player_x = vinduesbredde // 2
 player_y = window_height - player_height - 10

Inklusiv yderligere funktioner

For yderligere at forbedre sundhedssystemet kan du inkorporere yderligere funktioner. Nedenfor er et eksempel:

Power-ups

Definer egenskaberne for opstarten, såsom dens dimensioner og position. Indstil også en sundhedsværdi, som spilleren får, når den kolliderer med power-up.

Inden for spilsløjfen kan du registrere kollisioner mellem spilleren og power-up. Hvis der opstår en kollision, skal du øge spillerens helbred med power-ups sundhedsværdi, og sørg for, at den ikke overstiger den maksimale sundhed. Flyt derefter opstarten tilfældigt på skærmen. Til sidst tegner du opstartsobjektet på skærmen ved hjælp af et blåt rektangel.

Opret en ny fil med navnet power-up.py og tilføj koden med nedenstående opdateringer:

# Definer power-up attributter
power_up_width, power_up_height = 30, 30
power_up_x, power_up_y = 200,200
power_up_health_value = 50
# Inde i spilløkken efter opdatering af spillerens position
# Registrer kollision mellem afspiller og opstart
hvis player_x < power_up_x + power_up_width og\
 player_x + player_width > power_up_x \
og player_y < power_up_y + power_up_height\
og player_y + player_height > power_up_y:
 player_health += power_up_health_value
hvis player_health > max_health:
 player_health = max_health
 power_up_x, power_up_y = 200,200
# Tegn opstartsobjekt
pygame.draw.rect (vindue, (0, 0, 255), 
 (power_up_x, power_up_y, 
 power_up_width, 
 power_up_height))

Nedenfor er output:

For hver ekstra funktion kan du definere de nødvendige variabler og konstanter og implementere den tilsvarende mekanik i spilløkken.

Bedste praksis for sundhedssystemet

Når du implementerer et sundhedssystem i PyGame, skal du huske på følgende bedste praksis:

Implementer begivenhedsdrevne systemer

I stedet for løbende at tjekke for kollisioner eller helbredsændringer i spilløkken, kan du overveje at bruge hændelsesdrevne systemer. PyGame tilbyder hændelseshåndteringsfunktioner, så du kan udløse helbredsrelaterede handlinger baseret på specifikke hændelser, såsom kollisionshændelser eller power-up pickup hændelser.

Afbalancere sundhedsværdier

Juster sundhedsværdierne, skadesværdierne og helingshastighederne i dit spil for at sikre en afbalanceret spiloplevelse. Playtesting og indsamling af feedback fra spillere kan hjælpe dig med at finjustere disse værdier for optimalt gameplay.

Give feedback

Sørg for, at spilleren modtager klar og meningsfuld feedback vedrørende deres helbredstilstand. Vis sundhedsbjælken fremtrædende på skærmen, brug visuelle signaler såsom farveændringer eller animationer for at indikere skade eller heling, og give lyd- eller visuelle signaler når spillerens helbred når kritiske niveauer.

Ved at følge disse bedste praksisser kan du skabe et robust og engagerende sundhedssystem, der bidrager til en fordybende spiloplevelse.

Gør spil mere engagerende med Health Bar

Implementering af et sundhedssystem tilføjer ikke kun et lag af udfordring, men gør også spil mere engagerende for spillere. Ved at inkorporere visuelle repræsentationer af sundhed, såsom sundhedsbarer, kan spillere nemt vurdere deres nuværende status og træffe strategiske beslutninger. Desuden kan tilføjelse af niveauer til dit spil forbedre gameplay-oplevelsen yderligere.