Îmbunătățiți-vă experiența de joc în Godot prin încorporarea unui sistem de sănătate și daune.

Un sistem de sănătate și daune le permite jucătorilor să primească daune și să piardă puncte de sănătate atunci când întâlnesc obstacole sau inamici. De asemenea, le permite să restabilească sănătatea prin diverse mijloace, cum ar fi power-up-uri sau pachete de sănătate.

Godot, un popular motor de jocuri open-source, oferă o abordare simplă și flexibilă pentru implementarea unor astfel de sisteme. Puteți crea cu ușurință un joc 2D cu un personaj jucător, un inamic și o bară de sănătate pentru a reprezenta vizual sănătatea jucătorului.

Configurarea jocului Godot

Mai întâi, configurați structura de bază a proiectului în motorul de joc Godot și creați nodurile necesare.

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

Creați o scenă nouă pentru personajul jucătorului. Adauga o KinematicBody2D nod și în interiorul acestuia, adăugați a

instagram viewer
CollisionShape2D cu o formă dreptunghiulară pentru a reprezenta hitbox-ul jucătorului. Atașați a Sprite nodul la KinematicBody2D pentru a afișa caracterul jucătorului.

# Player.gd
extends KinematicBody2D
const SPEED = 200


var velocity = Vector2.ZERO
var health = 100


func _physics_process(delta):
 velocity.x = 0
 velocity.y = 0


if Input.is_action_pressed("ui_right"):
 velocity.x += SPEED
elif Input.is_action_pressed("ui_left"):
 velocity.x -= SPEED


if Input.is_action_pressed("ui_down"):
 velocity.y += SPEED
elif Input.is_action_pressed("ui_up"):
 velocity.y -= SPEED
 move_and_collide(velocity * delta)

Acum, aveți un personaj de bază în proiectul Godot. Puteți muta jucătorul folosind tastele săgeți, dar încă nu există un sistem de sănătate.

Proiectarea elementelor de interfață pentru bara de sănătate

Acum, puteți adăuga elemente de interfață pentru a reprezenta vizual starea de sănătate a jucătorului. Godot oferă un control încorporat numit TextureProgress care funcționează bine în acest scop.

Creați un nou nod pentru HUD (heads-up display). Adauga o CanvasLayer nod și în interiorul acestuia, adăugați a TextureProgress nodul. Personalizați aspectul TextureProgress nod în funcție de stilul și tema jocului dvs.

Pentru a afișa bara de sănătate folosind TextureProgress în HUD, trebuie să îi atribui o textură. TextureProgress folosește două texturi: una pentru fundal și alta pentru porțiunea umplută (progres).

În panoul Inspector, localizați Textură secțiune. Sub Textură, veți găsi proprietăți numite Sub și Peste. Apasă pe Sarcină butonul pentru fiecare proprietate și selectați imaginile corespunzătoare.

Atașați un script la scena HUD pentru a actualiza bara de sănătate în funcție de starea de sănătate a jucătorului:

# HUD.gd
extends CanvasLayer
onready var healthBar := $TextureProgress


func _ready():
 update_health_bar()
func update_health_bar():
 var hb = get_parent().get_node("KinematicBody2D")
 healthBar.value = hb.health

Gestionarea sănătății jucătorului

Pentru a reduce starea de sănătate a jucătorului când trec granița ecranului, puteți adăuga un verificare condiționată folosind o instrucțiune if. Dacă jucătorul trece dincolo de ecran, îi puteți reduce sănătatea. Iată cum puteți realiza acest lucru:

# player.gd
extends KinematicBody2D
const SPEED = 200
const DAMAGE_AMOUNT = 0.1


var velocity = Vector2.ZERO
var health = 100


# Screen boundaries
var screen_size
var margin = 20


func _ready():
 screen_size = get_viewport_rect().size


func _physics_process(delta):
#... (existing movement code)
 move_and_collide(velocity * delta)


 var c1 = position.x < -margin
 var c2 = position.x > screen_size.x + margin
 var c3 = position.y < -margin
 var c4 = position.y > screen_size.y + margin


# Check if the player is outside the screen boundaries
if c1 or c2 or c3 or c4:
 take_damage_on_screen_exit()
func take_damage_on_screen_exit():
 health -= DAMAGE_AMOUNT
if health <= 0:
 health = 0
# Game over logic here 

 update_health_ui()

Adaugă update_health_ui() funcţia în player.gd script pentru a apela scriptul HUD și pentru a actualiza bara de sănătate.

# Player.gd
extends KinematicBody2D
#... (other code)
func update_health_ui():
 var hud = get_parent().get_node("HUD")
if hud:
 hud.update_health_bar()

Cu aceste modificări, jucătorul va suferi acum daune atunci când trece granița ecranului, iar interfața de utilizare a barei de sănătate se va actualiza în consecință.

Inclusiv caracteristici suplimentare

Sistemul de sănătate și daune poate fi extins cu diverse funcții suplimentare pentru a îmbunătăți experiența de joc. Unele idei includ:

Preluări de sănătate

Implementați colectări de sănătate care permit jucătorului să-și restabilească sănătatea atunci când sunt colectate. Picturile de sănătate pot fi obiecte de colecție împrăștiate în întreaga lume a jocului sau recompense pentru înfrângerea inamicilor.

Când jucătorul interacționează cu o creștere a sănătății, sănătatea sa ar trebui să crească cu o anumită sumă, până la o valoare maximă. Puteți utiliza un nou script pentru elementul de preluare a sănătății și puteți gestiona logica de coliziune și restabilire a sănătății.

Putere de invincibilitate

Creați power-up-uri care oferă jucătorului invincibilitate temporară pentru o perioadă limitată de timp. Când jucătorul colectează o putere de invincibilitate, devine imun la daunele de la inamici sau alte pericole.

Implementați un cronometru pentru a urmări durata rămasă a stării de invincibilitate, iar când cronometrul se termină, jucătorul revine la starea sa vulnerabilă.

Diferite tipuri de inamici

Proiectați o varietate de inamici cu diferite modele de atac, valori ale daunelor și comportamente. Fiecare tip de inamic poate prezenta provocări unice pentru jucător și necesită strategii diferite pentru a-l învinge.

De exemplu, unii inamici se pot mișca mai repede, pot provoca mai multe daune sau pot avea anumite puncte slabe pe care jucătorul le poate exploata. Adăugarea diversității la întâlnirile cu inamicii menține jocul captivant și împiedică ca acesta să devină monoton.

Regenerarea Sănătății

Implementați regenerarea sănătății în timp pentru a recompensa jucătorii pentru evitarea daunelor. Când jucătorul nu primește daune pentru o anumită durată, sănătatea lui se regenerează treptat până la un anumit prag.

Cu toate acestea, asigurați-vă că rata de regenerare este echilibrată pentru a evita situațiile în care jucătorul poate aștepta pur și simplu ca sănătatea să-și revină complet fără nicio provocare.

Feedback audio și vizual

Oferă feedback audio și vizual convingător atunci când jucătorul primește daune, restabilește sănătatea sau învinge inamicii.

Impact efecte sonore fără drepturi de autor, tremurăturile ecranului, efectele de particule și indiciile vizuale pot spori imersiunea jucătorului și pot face ca sistemul de sănătate și daune să se simtă mai dinamic și mai captivant.

Nu uitați să luați în considerare echilibrul general al caracteristicilor suplimentare pe care le introduceți. Continuați să testați și să strângeți feedback pentru a vă asigura că jocul rămâne provocator, plăcut și ritmat pe tot parcursul jocului.

Faceți jocurile Godot mai atractive cu sistemul de sănătate și daune

Integrarea unui sistem de sănătate și daune în jocul tău Godot adaugă profunzime și provocare, făcând jocul mai captivant pentru jucători. Introduce un element risc-recompensă, deoarece jucătorii trebuie să stabilească o strategie și să-și gestioneze sănătatea în mod eficient pentru a progresa în joc.

În plus, reprezentarea vizuală a barei de sănătate oferă jucătorilor un feedback important cu privire la starea lor actuală, sporindu-le sentimentul de imersiune.