Doriți să îmbunătățiți modul în care jocul dvs. gestionează pericolul? Transformă viețile în sănătate și adaugă o dimensiune suplimentară jocului tău.

Adăugarea unui sistem de sănătate la jocul dvs. arcade poate îmbunătăți experiența jucătorului și poate adăuga un strat suplimentar de provocare și implicare. Puteți crea o experiență de joc mai captivantă, cu o afișare a sănătății și mecanicii jucătorului pentru daune și vindecare.

Din fericire, implementarea unui sistem de sănătate în Python folosind biblioteca Arcade este simplă și necesită doar câțiva pași.

Creați un joc simplu

Primul, instalați pip pe dispozitivul dvs și utilizați comanda de mai jos pentru a instala biblioteca arcade:

pip install arcade

După aceea, începeți prin a crea un joc simplu folosind biblioteca Arcade. Acest joc va prezenta un personaj jucător care se poate mișca la stânga, la dreapta, în sus și în jos și un obiect inamic care reprezintă o amenințare pentru jucător.

Codul folosit în acest articol este disponibil în acest articol Depozitul GitHub și este gratuit pentru utilizare sub licența MIT.

instagram viewer

Creați un fișier nou numit joc simplu.py si adauga codul de mai jos:

import arcadă
# Setați dimensiunile ferestrei
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


# Setați viteza de mișcare a jucătorului
PLAYER_MOVEMENT_SPEED = 5
alb = arcade.culoare. ALB
albastru = arcade.culoare. ALBASTRU
roșu = arcade.culoare. ROȘU


clasăGame Window(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
 super().__init__(lățime, înălțime)
 arcade.set_background_color (alb)


# Creați obiecte jucător și inamic
 self.player = arcade. SpriteCircle(30, albastru)
 self.enemy = arcade. SpriteCircle(30, roșu)
 self.player.center_x = 100
 self.player.center_y = 100
 self.enemy.center_x = 400
 self.enemy.center_y = 300


defon_draw(de sine):
 arcade.start_render()
 self.player.draw()
 sine.dușman.trage()


defActualizați(self, delta_time):
trece


defon_key_press(sine, cheie, modificatori):
dacă cheie == arcade.key. STÂNGA:
 self.player.center_x -= PLAYER_MOVEMENT_SPEED
elif cheie == arcade.key. DREAPTA:
 self.player.center_x += PLAYER_MOVEMENT_SPEED
elif cheie == arcade.key. SUS:
 self.player.center_y += PLAYER_MOVEMENT_SPEED
elif cheie == arcade.key. JOS:
 self.player.center_y -= PLAYER_MOVEMENT_SPEED


defprincipal():
 joc = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
dacă __nume__ == "__principal__":
 principal()

Ar trebui să vedeți o fereastră care conține două caractere, reprezentate prin cercuri albastre și roșii:

Pentru implementarea sistemului de sănătate, definiți variabile și constante legate de sănătate. Le vei folosi pentru a ține evidența sănătății actuale a jucătorului și pentru a determina regulile pentru daune și vindecare. Adăugați următorul cod în interiorul Game Window clasă:

clasăGame Window(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
# ...
# Variabile și constante legate de sănătate
 self.player_health = 100
# Puncte de sănătate vindecate pe secundă
 self.heal_rate = 1


# Cronometru pentru vindecare
 self.heal_timer = 0


defActualizați(self, delta_time):
# ...
# Actualizați cronometrul de vindecare
 self.heal_timer += delta_time


# Vindecă sănătatea jucătorului la fiecare 2 secunde
dacă self.heal_timer >= 2:
 self.player_health += self.heal_rate
 self.heal_timer = 0
# Asigurați-vă că sănătatea nu depășește valoarea maximă
dacă self.player_health > 100:
 self.player_health = 100

Implementarea daunelor și a mecanicii de vindecare

Pentru a implementa mecanismele de deteriorare și de vindecare, detectează coliziuni între jucător și inamic. Reduceți sănătatea jucătorului când se ciocnește de inamicul și vindecați sănătatea jucătorului la fiecare 2 secunde când nu se ciocnește. Modificați Actualizați() metoda și adăugați următorul cod:

clasăGame Window(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
# ...
defActualizați(self, delta_time):
# Detectează coliziunile între jucător și inamic
dacă arcade.check_for_collision (self.player, self.enemy):
 self.player_health -= 5
# ...

Gestionarea morții jucătorilor și scenariilor Game Over

Pentru a gestiona scenariile de moarte și de final de joc, verificați dacă starea de sănătate a jucătorului ajunge la zero sau mai jos. Dacă sănătatea scade la zero, considerați jucătorul mort și încheiați jocul. Modificați Actualizați() metoda cu următorul cod:

clasăGame Window(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
# ...
defActualizați(self, delta_time):
# ...


# Verificați dacă sănătatea jucătorului este zero sau mai mică
dacă sine.sănătatea_jucătorului <= 0:
# Încheiați jocul
 arcade.close_window()
# ...

Vizualizarea barei de sănătate

O reprezentare vizuală a stării de sănătate a jucătorului poate îmbunătăți considerabil experiența de joc. Creați o bară de sănătate folosind dreptunghiuri pentru a afișa nivelul actual de sănătate. Creați un fișier nou numit health-bar.py și adăugați codul cu actualizările de mai jos:

clasăGame Window(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
# ...
defon_draw(de sine):
 arcade.start_render()
 self.player.draw()
 sine.dușman.trage()
 gri = arcade.culoare. GRI DESCHIS
 verde = arcade.culoare. VERDE


# Desenați bara de sănătate
 arcade.draw_rectangle_filled (SCREEN_WIDTH // 2, 20, 
 SCREEN_WIDTH, 20, gri)


 health_width = self.player_health / 100 * SCREEN_WIDTH
 arcade.draw_rectangle_filled (health_width // 2, 20, 
 health_width, 20, verde)

Mai jos este rezultatul:

Inclusiv caracteristici suplimentare

Puteți îmbunătăți și mai mult sistemul de sănătate cu mai multe funcții, cum ar fi cele de mai jos.

Afișaj numeric de sănătate

Pe lângă bara de sănătate, puteți afișa starea de sănătate rămasă ca valoare numerică pe ecran. Aceasta oferă o indicație precisă a stării de sănătate a jucătorului. Adăugați următorul cod în interiorul on_draw() metodă:

# În interiorul metodei on_draw().
negru = arcade.culoare. NEGRU
text = f"Sănătate: {self.player_health}"
arcade.draw_text (text, 10, 10, negru, 14)

Îmbunătățiri de sănătate

Pentru a introduce îmbunătățiri pentru sănătate, puteți crea obiecte speciale care îmbunătățesc sănătatea jucătorului atunci când se ciocnesc de ele. Iată un exemplu despre cum puteți implementa această funcție:

# În cadrul metodei update().
dacă arcade.check_for_collision (self.player, self.power_up):
 self.player_health += 20
# Scoateți pornirea din joc
 self.power_up.kill()

Tipuri variate de inamici

Pentru a adăuga profunzime jocului tău, poți introduce diferite tipuri de inamici care provoacă diferite niveluri de daune jucătorului. Acest lucru adaugă un element strategic și permite experiențe de joc mai diverse. Iată o implementare a acestei caracteristici:

# În cadrul metodei update().
dacă arcade.check_for_collision (self.player, self.enemy):
dacă auto.inamic.tip == "slab":
 self.player_health -= 5
elif auto.inamic.tip == "puternic":
 self.player_health -= 20

Încorporând aceste caracteristici suplimentare în implementarea sistemului dvs. de sănătate, puteți crea experiențe de joc mai dinamice și mai provocatoare pentru jucătorii dvs.

Cele mai bune practici pentru sistemul de sănătate

Când implementați un sistem de sănătate în jocul dvs. arcade, este important să urmați cele mai bune practici pentru a vă asigura că sistemul este robust și eficient. Iată câteva dintre cele mai bune practici de reținut:

Fă-l modular

Păstrați funcționalitatea sistemului de sănătate într-o clasă sau un modul separat pentru a-l menține modular și ușor de reutilizat în diferite proiecte de joc. Acest lucru promovează organizarea codului și separarea preocupărilor.

Validarea intrărilor și garanții

Implementați validarea intrării pentru a împiedica codul dvs. să atribuie valori de sănătate nevalide. Aceleași măsuri de protecție ar trebui să protejeze împotriva valorilor de sănătate invalide atunci când au loc leziuni sau vindecare.

Mecanism de salvare și încărcare

Implementați un mecanism de salvare și încărcare care include starea de sănătate a jucătorului. Acest lucru permite jucătorilor să reia jocul cu progresul intact, inclusiv sănătatea lor, chiar și după părăsirea jocului.

Testare și tratare a erorilor

Testați cu atenție implementarea sistemului de sănătate pentru a verifica corectitudinea și fiabilitatea acestuia. Utilizați tehnici adecvate de tratare a erorilor pentru a gestiona în mod eficient excepțiile și cazurile marginale.

Feedback consecvent asupra sănătății

Oferă jucătorului feedback consecvent și clar despre starea de sănătate. Puteți adăuga efecte audio, indicii vizuale sau chiar feedback haptic, asigurându-se că jucătorii își cunosc starea de sănătate în joc și pot lua decizii informate în timpul jocului.

Urmând aceste bune practici, puteți crea un sistem de sănătate robust și eficient care îmbunătățește experiența de joc a jocului dvs. arcade, menținând în același timp calitatea și lizibilitatea codului.

Faceți jocurile mai distractive cu sistemul de sănătate

Adăugarea unui sistem de sănătate la jocul tău poate îmbunătăți semnificativ experiența generală a jucătorului. Introduce un element de risc și provocare, făcând jocul mai captivant și mai plin de satisfacții.

O reprezentare vizuală a sănătății permite jucătorilor să își evalueze cu ușurință starea actuală, sporind imersiunea și luarea deciziilor strategice.