Aflați cum să afișați butoanele personalizate în scene separate pentru a acționa ca simple meniuri pe ecran pentru jocurile dvs.

Recomandări cheie

  • Meniurile personalizate din Godot pot îmbunătăți implicarea și experiența utilizatorului, oferind navigare ușoară și acces rapid la funcțiile jocului.
  • Godot oferă un set de instrumente puternic pentru crearea de meniuri personalizate de UI folosind nodurile de control din motorul de joc.
  • Puteți crea meniuri precum meniuri de pornire, meniuri de pauză și ecrane de joc în Godot, adăugând noduri adecvate și implementând funcționalitatea acestora folosind GDScript.

Meniurile personalizate pot îmbunătăți foarte mult angajamentul și experiența utilizatorului jocului tău Godot. Prin crearea de meniuri intuitive și atractive din punct de vedere vizual, puteți oferi jucătorilor o navigare ușoară și acces rapid la diferite funcții ale jocului.

Din fericire, Godot oferă un set de instrumente puternic pentru crearea de meniuri UI personalizate folosind noduri de control.

instagram viewer

Configurarea jocului Godot

Pentru a începe, creați o scenă de joc 2D în motorul de joc Godot. Adauga o KinematicBody2D nod pentru personajul jucător și atașați a CollisionShape2D nod la acesta, definiți o formă dreptunghiulară care reprezintă zona de coliziune a jucătorului.

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

În plus, includeți a Sprite2D nod pentru a afișa vizual personajul jucătorului. Mai jos este un fragment de cod GDScript pentru a permite mișcarea jucătorului:

extinde KinematicBody2D
const SPEED = 200
const GRAVITATEA = 500
var viteza = Vector2.ZERO


func _physics_process (delta):
 var move_direction = 0


dacă Input.is_action_pressed("ui_right"):
 mișcare_direcție += 1


dacă Input.is_action_pressed("ui_left"):
 mișcare_direcție -= 1
 viteza.x = mișcare_direcție * SPEED
 viteza.y += GRAVITATE * delta
 viteza = move_and_slide (viteza, Vector2.UP)

În acest cod, definiți o constantă VITEZĂ pentru a controla viteza de mișcare a jucătorului. Actualizați variabila viteză ca răspuns la intrarea utilizatorului și apelați muta_si_glisa() pentru a muta jucătorul ținând cont de coliziuni și de gravitatea jocului.

Creați un meniu Start

Pentru a crea un meniu de pornire în Godot, adăugați un nod de control ca rădăcină a scenei. Adăugați un nod Etichetă ca copil al acestui nod de control și setați textul acestuia la Joc simplu. Puteți personaliza fontul, dimensiunea și culoarea etichetei pentru a se potrivi cu stilul jocului dvs.

După aceea, adăugați un nod Button ca copil al nodului Control. Setați textul butonului la Joaca jocul. Scrieți codul personalizat pentru Joaca jocul butonul pentru a gestiona funcționalitatea acestuia:

extinde Controlul
func _ready():
 var playButton = $Button
 playButton.connect("presat", de sine, „_on_PlayButton_apăsat”)
func _on_PlayButton_pressed():
# Încărcați scena jocului
 var gameScene = preload(„res://GameScene.tscn”)

# Tranziție la scena jocului
 get_tree().change_scene (gameScene)

Acest cod conectează presat semnal al playButton la _on_PlayButton_apăsat funcţie. Această funcție încarcă scena jocului folosind preîncărcare() și creează o instanță a acesteia. Apoi folosește schimbare_scenă() pentru a trece la scena jocului.

În mod similar, puteți adăuga un Ieșire buton pe care jucătorii îl pot folosi pentru a părăsi jocul:

func _ready():
 var playButton = $Button
 var exitButton = $Button2
 playButton.connect("presat", de sine, „_on_PlayButton_apăsat”)
 exitButton.connect("presat", de sine, „_on_ExitButton_apăsat”)
func _on_ExitButton_pressed():
# Închide jocul
 get_tree().quit()

Acest cod conectează presat semnalul butonului de ieșire către _on_ExitButton_apăsat funcţie. Acea funcție cheamă părăsi() pentru a ieși din joc.

Creați meniul de pauză

Pentru a adăuga un meniu de pauză jocului Godot, creați o scenă nouă cu un nod de control ca rădăcină a meniului de pauză. Proiectați elementele vizuale ale meniului, inclusiv o etichetă pentru Întrerupt și butoane pentru a relua jocul, a reveni la meniul principal și a ieși din joc.

Adăugați scena ca nod copil al jocului principal. În scriptul atașat la nodul Control, adăugați următorul cod:

extinde Controlul
func _ready():
 $btnResume.connect("presat", de sine, „_on_resume_button_apăsat”)
 $btnHome.connect("presat", de sine, „_on_menu_button_apasat”)
 $btnExit.connect("presat", de sine, „_on_exit_button_apăsat”)
 pause_mode = Nod. PAUSE_MODE_PROCESS
 get_tree().paused = false
 self.hide()

func _input (eveniment):
dacă event.is_action_pressed("ui_cancel"):
dacănu self.is_visible_in_tree():
# Întrerupeți jocul când meniul de pauză nu este vizibil
 self.show()
 get_tree().paused = true
altfel:
# Anulați jocul când meniul de pauză este deja vizibil
 self.hide()
 get_tree().paused = false


func _on_resume_button_pressed():
# Ascundeți meniul de pauză și reluați jocul
 self.hide()
 get_tree().paused = false


func _on_menu_button_pressed():
# Reveniți la meniul principal
 get_tree().schimbare_scenă(„res://StartMenu.tscn”)
func _on_exit_button_pressed():
# Închide jocul
 get_tree().quit()

În _gata() funcția, conectați presat semnal al butoanelor de reluare, acasă și de ieșire la funcțiile lor respective: _on_resume_button_pressed(), _on_menu_button_apasat(), și _on_exit_button_apăsat().

Seteaza pause_mode a nodului la Nodul. PAUSE_MODE_PROCESS. Acest lucru permite jocului să continue să ruleze în timp ce meniul de pauză este vizibil. În mod implicit, ascundeți meniul de pauză folosind self.hide() și setați get_tree().paused la fals pentru a vă asigura că jocul nu este întrerupt inițial.

Următorul, utilizați o declarație if în _input (eveniment) funcția pentru a verifica dacă ui_cancel acțiunea este apăsată. Dacă meniul de pauză nu este vizibil în prezent, puteți întrerupe jocul afișând meniul de pauză și setările get_tree().paused la Adevărat.

Creați un joc peste ecran

Pentru a implementa un joc peste ecran în Godot, creați o scenă separată numită GameOver.tscn pentru a-și defini elementele și funcționalitatea UI. Puteți adăuga această scenă ca nod copil atunci când jucătorul traversează granițele ecranului, indicând sfârșitul jocului.

Deschideți o scenă nouă în Godot și adăugați un nod de control ca rădăcină a scenei. În interiorul nodului Control, adăugați un nod Etichetă pentru a afișa Joc încheiat text. Personalizați fontul, dimensiunea și culoarea etichetei în funcție de stilul vizual al jocului dvs.

Apoi, adăugați noduri Button pentru Joaca din nou și Ieșire Opțiuni. Poziționați-le corespunzător pe ecran.

Conectați semnalele butoanelor la funcțiile lor respective pentru a gestiona acțiunile atunci când faceți clic. De exemplu, conectați Joaca din nou butonul la o funcție numită onPlayAgainPressed si Ieșire butonul la o funcție numită onExitPressed.

Pentru a gestiona funcționalitatea butonului, trebuie să definiți funcțiile corespunzătoare în codul GDScript al scenei game over. Iată un exemplu:

extinde Controlul
func _ready():
 $Button.connect("presat", de sine, „onPlayAgainPressed”)
 $Button2.connect("presat", de sine, „onExitPressed”)
func onPlayAgainPressed():
 var gameScenePath = „res://GameScene.tscn”
 get_tree().change_scene (gameScenePath)

func onExitPressed():
 get_tree().quit() # Închideți aplicația de joc

Odată ce ați configurat GameOver.tscn scena și a definit funcționalitatea necesară a butonului, puteți utiliza următorul cod în scena principală a jocului pentru a afișa jocul pe ecran:

extinde KinematicBody2D
func _physics_process (delta):
# Verificați dacă jucătorul a depășit granițele ecranului
 var screen_size = get_viewport_rect().size
dacă viteza.y > dimensiunea_ecranului.y sau viteza.y < 0:
 show_game_over_screen()
func show_game_over_screen():
 get_tree().schimbare_scenă(„res://GameOver.tscn”)

Ecranul Game Over va arăta cam așa, cu butoane pentru ca jucătorul să repornească sau să iasă:

Inclusiv caracteristici suplimentare

Când creați meniuri UI personalizate în Godot folosind noduri de control, aveți flexibilitatea de a adăuga diverse funcții pentru a îmbunătăți funcționalitatea și atractivitatea vizuală a meniurilor dvs. Iată câteva idei de luat în considerare.

Tranziții animate

Adăugați tranziții fluide între diferite ecrane de meniu, cum ar fi fade-in-uri, slide-in-uri sau efecte de scalare. Puteți realiza acest lucru modificând în timp proprietățile nodurilor de control folosind interpolari sau playere de animație.

Efecte sonore

Implementați efecte sonore pentru a oferi feedback audio atunci când jucătorul apasă butoanele de meniu. Puteți reda sunete diferite pentru clicuri pe butoane, tranziții de meniu sau alte interacțiuni pentru a face meniurile să pară mai receptive și mai captivante.

Sistemul audio încorporat al lui Godot facilitează redarea sunetelor la momente adecvate.

Efecte vizuale

Utilizați shadere sau sisteme de particule pentru a adăuga efecte vizuale meniurilor dvs. De exemplu, puteți aplica un efect de strălucire subtil la butoanele selectate sau puteți crea efecte de particule care se declanșează atunci când apar anumite acțiuni din meniu. Aceste efecte pot adăuga o senzație șlefuită și captivantă interfeței dvs. de utilizare.

Muzica de fundal

Luați în considerare jocul muzică de fundal fără drepturi de autor specific fiecărui ecran de meniu pentru a crea o atmosferă mai captivantă. Puteți utiliza fluxuri audio sau autobuze audio în Godot pentru a gestiona muzica de fundal și pentru a asigura tranziții fără întreruperi între diferite melodii pe măsură ce playerul navighează prin meniuri.

Suport pentru localizare

Dacă intenționați să vă traduceți jocul în mai multe limbi, luați în considerare adăugarea suportului de localizare la meniurile interfeței dvs. de utilizare.

Furnizați un mecanism pentru modificarea dinamică a conținutului text al etichetelor și al butoanelor în funcție de limba selectată. Instrumentele și resursele de localizare Godot pot ajuta la gestionarea elementelor UI multilingve.

Nu uitați să testați și să repetați meniurile cu utilizatori reali pentru a vă asigura că funcțiile suplimentare îmbunătățesc experiența generală a utilizatorului și sunt intuitive pentru navigare. Acordați atenție considerentelor de performanță, în special atunci când utilizați animații și efecte vizuale, pentru a asigura interacțiuni fluide și receptive cu interfața de utilizare.

Faceți jocurile Godot mai captivante cu meniul personalizat al interfeței de utilizare

Meniurile personalizate ale interfeței de utilizare pot juca un rol crucial în implicarea jucătorilor. Acestea oferă navigare intuitivă, permit acces ușor la caracteristicile jocului și îmbunătățesc atractivitatea vizuală generală a jocului dvs.

Cu puțină creativitate și puțină codare, puteți crea meniuri care nu numai că oferă funcționalități esențiale, ci și captivează jucătorii și le îmbunătățesc experiența generală de joc. Așadar, începeți să explorați și să vă creați propriile meniuri unice pentru a vă face jocurile Godot să iasă în evidență din mulțime.