Hur man implementerar ett hälsosystem i PyGame

Att implementera ett hälsosystem i ett spel kan avsevärt förbättra spelupplevelsen och lägga till ett extra lager av utmaning och strategi. PyGame tillhandahåller en robust uppsättning verktyg och funktioner för att integrera hälsosystemet, vilket gör det enkelt att skapa interaktiva upplevelser.

Skapa ett enkelt spel

Innan du börjar, se till att du har pip installerad på ditt system. Använd det här kommandot för att installera pygame bibliotek:

pip installera pygame

Efter det skapar du en fil med namnet simple-game.py och börja med att skapa ett enkelt spel där spelaren kan flytta åt vänster och höger.

Koden som används i den här artikeln är tillgänglig i denna GitHub-förråd och är gratis för dig att använda under MIT-licensen.

I denna grundläggande spelloop kommer spelarens mål att vara att undvika att kollidera med fienden.

importera pygame
importera slumpmässig
# Initiera PyGame
pygame.init()





instagram viewer

# Ställ in spelfönstret
window_width, window_height = 800, 600
fönster = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Demo av hälsosystem")
# Spelarattribut
player_width, player_height = 50, 50
player_x, player_y = window_width // 2, window_height - player_height - 10
player_speed = 1
# Fiendens attribut
enemy_width, enemy_height = 50, 50
enemy_x, enemy_y = random.randint(0, window_width - enemy_width), 0
enemy_speed = 0.3
# Spelslinga
springer = Sann
medan löpning:
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
 springer = Falsk
# Flytta spelaren åt vänster eller höger
 keys = pygame.key.get_pressed()
om nycklar[pygame. K_LEFT] och player_x > 0:
 player_x -= player_speed
om nycklar[pygame. K_RIGHT] och player_x < window_width - player_width:
 player_x += player_speed
# Flytta fienden nedåt
 enemy_y += enemy_speed
# Rita spelobjekt
 window.fill((0, 0, 0)) # Rensa skärmen
 pygame.draw.rect (fönster, (255, 0, 0), 
 (spelare_x, spelare_y, 
 player_width, player_height)) 
 pygame.draw.rect (fönster, (0, 255, 0), 
 (fiende_x, fiende_y, 
 enemy_width, enemy_height)) # Rita fiende
 pygame.display.update()
pygame.quit()

Kör koden så ser du ett fönster med en spelarkaraktär som du kan styra med hjälp av vänster och höger piltangenter.

Nu när du har en grundläggande spelinställning, definiera variabler och konstanter relaterade till spelarens hälsa. Du kan använda ett enkelt hälsosystem där du kan representera en spelares hälsa med ett numeriskt värde. Du kan också definiera konstanter för spelarens maximala hälsa och mängden skada som tillfogats av fienden.

Ställ in den initiala spelarhälsan till 100, definiera den maximala hälsan som 100 och ställ in fiendens skada till 20. Dessa värden kan justeras efter de specifika behoven i ditt spel.

# Spelarens hälsa
player_health = 100
max_health = 100
enemy_damage = 20

Implementering av skade- och läkningsmekanik

För att introducera skada och läkningsmekanik måste du upptäcka kollisioner mellan spelaren och fienden och hantera motsvarande hälsoförändringar. Du kan också implementera en mekanism för att hela spelaren när de flyttar från skärmen.

Kontrollera om det finns en kollision mellan spelaren och fienden genom att jämföra deras avgränsande rektanglar. Om en kollision upptäcks, subtrahera fiendens skadevärde från spelarens hälsa.

Dessutom, om spelaren flyttar från toppen av skärmen (player_y < 0), lägg till 10 till deras hälsa och se till att den inte överskrider den maximala hälsan. Detta skapar en helande mekaniker och återställer spelarens position till botten av skärmen.

Skapa en ny fil med namnet damage-and-healing.py och lägg till koden med följande uppdateringar:

# Inuti spelslingan, efter att ha uppdaterat fiendens position
# Upptäck kollision mellan spelare och fiende
om player_x < enemy_x + enemy_width och \
 player_x + player_width > enemy_x och \
 player_y < enemy_y + enemy_height \
och player_y + player_height > enemy_y:
 player_health -= enemy_damage
 print (player_health)
# Läka spelaren när de flyttar från skärmen
om player_y < 0:
 player_health += 10
 print (player_health)
om player_health > max_health:
 player_health = max_health
 player_y = window_height - player_height - 10

Nedan är utgången:

Hantera Player Death and Game Over Scenarios

För att hantera spelarens död och game-over-scenarier måste du kontrollera om spelarens hälsa når noll. Om den gör det, visa en Game Over meddelande och starta om spelet.

Lägg till en kontroll för att se om spelarens hälsa faller under eller är lika med noll. Om detta villkor är sant, skriv ut Game Over och återställ spelarens hälsa och position.

Skapa en ny fil med namnet manage-player-death.py och ändra koden med följande uppdateringar:

# Efter uppdatering av spelarens position
# Kontrollera om spelarens hälsa når noll
om player_health <= 0:
 skriva ut("Game Over")
 player_health = max_health
 player_x = window_width // 2
 player_y = window_height - player_height - 10

Inklusive ytterligare funktioner

För att ytterligare förbättra hälsosystemet kan du införliva ytterligare funktioner. Nedan är ett exempel:

Power-ups

Definiera attributen för power-up, såsom dess dimensioner och position. Ställ också in ett hälsovärde som spelaren kommer att få när den kolliderar med power-up.

Inom spelslingan, upptäck kollisioner mellan spelaren och power-upen. Om en kollision inträffar, öka spelarens hälsa med power-upens hälsovärde, se till att den inte överskrider den maximala hälsan. Placera sedan om uppstarten slumpmässigt på skärmen. Rita slutligen uppstartobjektet på skärmen med hjälp av en blå rektangel.

Skapa en ny fil med namnet power-up.py och lägg till koden med följande uppdateringar:

# Definiera power-up attribut
power_up_width, power_up_height = 30, 30
power_up_x, power_up_y = 200,200
power_up_health_value = 50
# Inuti spelslingan, efter uppdatering av spelarens position
# Upptäck kollision mellan spelare och start
om player_x < power_up_x + power_up_width och\
 player_x + player_width > power_up_x \
och player_y < power_up_y + power_up_height\
och player_y + player_height > power_up_y:
 player_health += power_up_health_value
om player_health > max_health:
 player_health = max_health
 power_up_x, power_up_y = 200,200
# Rita uppstartsobjekt
pygame.draw.rect (fönster, (0, 0, 255), 
 (power_up_x, power_up_y, 
 power_up_width, 
 power_up_height))

Nedan är utgången:

För varje ytterligare funktion kan du definiera nödvändiga variabler och konstanter och implementera motsvarande mekanik i spelslingan.

Bästa praxis för hälsosystemet

När du implementerar ett hälsosystem i PyGame, tänk på följande bästa praxis:

Implementera händelsedrivna system

Istället för att kontinuerligt leta efter kollisioner eller hälsoförändringar i spelslingan, överväg att använda händelsedrivna system. PyGame tillhandahåller händelsehanteringsfunktioner, så att du kan utlösa hälsorelaterade åtgärder baserat på specifika händelser, såsom kollisionshändelser eller uppstartshändelser.

Balansera hälsovärden

Justera hälsovärdena, skadevärdena och läkningshastigheterna i ditt spel för att säkerställa en balanserad spelupplevelse. Speltestning och insamling av feedback från spelare kan hjälpa dig att finjustera dessa värden för optimalt spelande.

Ge feedback

Se till att spelaren får tydlig och meningsfull feedback angående sin hälsostatus. Visa hälsofältet väl synligt på skärmen, använd visuella signaler som färgförändringar eller animationer för att indikera skada eller läkning, och ge ljud eller visuella signaler när spelarens hälsa når kritiska nivåer.

Genom att följa dessa bästa metoder kan du skapa ett robust och engagerande hälsosystem som bidrar till en uppslukande spelupplevelse.

Gör spel mer engagerande med Health Bar

Att implementera ett hälsosystem lägger inte bara till ett lager av utmaningar utan gör också spel mer engagerande för spelare. Genom att införliva visuella representationer av hälsa, såsom hälsobarer, kan spelare enkelt bedöma sin nuvarande status och fatta strategiska beslut. Att lägga till nivåer i ditt spel kan dessutom förbättra spelupplevelsen ytterligare.