Lär dig hur du visar anpassade knappar i separata scener för att fungera som enkla skärmmenyer för dina spel.

Viktiga takeaways

  • Anpassade menyer i Godot kan förbättra engagemanget och användarupplevelsen genom att ge enkel navigering och snabb åtkomst till spelfunktioner.
  • Godot tillhandahåller en kraftfull verktygsuppsättning för att skapa anpassade UI-menyer med hjälp av kontrollnoder i spelmotorn.
  • Du kan skapa menyer som startmenyer, pausmenyer och game over-skärmar i Godot genom att lägga till lämpliga noder och implementera deras funktionalitet med GDScript.

Anpassade menyer kan avsevärt förbättra engagemanget och användarupplevelsen av ditt Godot-spel. Genom att skapa intuitiva och visuellt tilltalande menyer kan du ge spelare enkel navigering och snabb tillgång till olika spelfunktioner.

Lyckligtvis tillhandahåller Godot en kraftfull verktygsuppsättning för att skapa anpassade UI-menyer med hjälp av kontrollnoder.

Konfigurera Godot-spelet

Till att börja, skapa en 2D-spelscen i spelmotorn Godot

. Lägg till en KinematicBody2D nod för spelarkaraktären och bifoga en CollisionShape2D nod till den, definiera en rektangelform som representerar spelarens kollisionsområde.

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.

Inkludera dessutom en Sprite2D nod för att visa spelarkaraktären visuellt. Nedan finns ett GDScript-kodavsnitt för att möjliggöra spelarrörelse:

utökar KinematicBody2D
const SPEED = 200
const GRAVITY = 500
var hastighet = Vector2.NOLL


func _physics_process (delta):
 var move_direction = 0


om Input.is_action_pressed("ui_right"):
 move_direction += 1


om Input.is_action_pressed("ui_left"):
 move_direction -= 1
 hastighet.x = move_direction * SPEED
 hastighet.y += GRAVITY * delta
 hastighet = move_and_slide (hastighet, Vector2.UP)

I den här koden definierar du en konstant FART för att kontrollera spelarens rörelsehastighet. Uppdatera hastighetsvariabeln som svar på användarinmatning och anrop move_and_slide() att flytta spelaren samtidigt som kollisioner och spelets gravitation beaktas.

Skapa en startmeny

För att skapa en startmeny i Godot, lägg till en kontrollnod som roten till scenen. Lägg till en etikettnod som underordnad denna kontrollnod och ställ in dess text till Enkelt spel. Du kan anpassa teckensnitt, storlek och färg på etiketten för att matcha ditt spels stil.

Lägg sedan till en knappnod som underordnad kontrollnod. Ställ in knappens text till Spela spel. Skriv anpassad kod för Spela spel knapp för att hantera dess funktionalitet:

utökar kontrollen
func _ready():
 var playButton = $Button
 playButton.connect("nedtryckt", själv, "_on_PlayButton_pressed")
func _on_PlayButton_pressed():
# Ladda spelscenen
 var gameScene = preload("res://GameScene.tscn")

# Övergång till spelscenen
 get_tree().change_scene (gameScene)

Denna kod ansluter nedtryckt signal från play-knappen till _on_PlayButton_pressed fungera. Den funktionen laddar spelscenen med hjälp av preload() och skapar en instans av det. Den använder sedan change_scene() för att övergå till spelscenen.

På samma sätt kan du lägga till en Utgång knapp som spelare kan använda för att avsluta spelet:

func _ready():
 var playButton = $Button
 var exitButton = $Button2
 playButton.connect("nedtryckt", själv, "_on_PlayButton_pressed")
 exitButton.connect("nedtryckt", själv, "_on_ExitButton_pressed")
func _on_ExitButton_pressed():
# Avsluta spelet
 get_tree().quit()

Denna kod ansluter nedtryckt signal från utgångsknappen till _on_ExitButton_pressed fungera. Den funktionen anropar sluta med() för att avsluta spelet.

Skapa pausmenyn

För att lägga till en pausmeny till ditt Godot-spel, skapa en ny scen med en kontrollnod som roten till pausmenyn. Designa de visuella delarna av menyn, inklusive en etikett för Pausad och knappar för att återuppta spelet, återgå till huvudmenyn och avsluta spelet.

Lägg till scenen som en barnnod i huvudspelet. Lägg till följande kod i skriptet som är bifogat till kontrollnoden:

utökar kontrollen
func _ready():
 $btnResume.connect("nedtryckt", själv, "_på_resume_button_pressed")
 $btnHome.connect("nedtryckt", själv, "_on_menu_button_pressed")
 $btnExit.connect("nedtryckt", själv, "_on_exit_button_pressed")
 pause_mode = Nod. PAUSE_MODE_PROCESS
 get_tree().paused = false
 self.hide()

func _input (händelse):
om event.is_action_pressed("ui_cancel"):
ominte self.is_visible_in_tree():
# Pausa spelet när pausmenyn inte är synlig
 self.show()
 get_tree().paused = sant
annan:
# Avbryt paus i spelet när pausmenyn redan är synlig
 self.hide()
 get_tree().paused = false


func _on_resume_button_pressed():
# Göm pausmenyn och återuppta spelet
 self.hide()
 get_tree().paused = false


func _on_menu_button_pressed():
# Återgå till huvudmenyn
 get_tree().change_scene("res://StartMenu.tscn")
func _on_exit_button_pressed():
# Avsluta spelet
 get_tree().quit()

I den _redo() funktion, anslut nedtryckt signal från knapparna återuppta, hem och avsluta till deras respektive funktioner: _on_resume_button_pressed(), _on_menu_button_pressed(), och _on_exit_button_pressed().

Ställ in pause_mode av noden till Nod. PAUSE_MODE_PROCESS. Detta gör att spelet kan fortsätta köras medan pausmenyn är synlig. Som standard, dölj pausmenyn med self.hide() och ställ in get_tree().pausad till falsk för att säkerställa att spelet inte pausas initialt.

Nästa, använd ett if-uttalande i _input (händelse) funktion för att kontrollera om ui_cancel åtgärden trycks ned. Om pausmenyn inte är synlig för närvarande kan du pausa spelet genom att visa pausmenyn och inställningen get_tree().pausad till Sann.

Skapa ett spel över skärmen

För att implementera ett spel över skärmen i Godot, skapa en separat scen som heter GameOver.tscn för att definiera dess UI-element och funktionalitet. Du kan lägga till den här scenen som en barnnod när spelaren passerar skärmens gränser, vilket indikerar slutet på spelet.

Öppna en ny scen i Godot och lägg till en kontrollnod som roten till scenen. Inuti kontrollnoden lägger du till en etikettnod för att visa Game Over text. Anpassa teckensnitt, storlek och färg på etiketten enligt ditt spels visuella stil.

Lägg sedan till knappnoder för Spela igen och Utgång alternativ. Placera dem på rätt sätt på skärmen.

Anslut knappsignalerna till deras respektive funktioner för att hantera åtgärderna när du klickar på dem. Anslut till exempel Spela igen knappen till en funktion som kallas på PlayAgainPressed och den Utgång knappen till en funktion som kallas onExitPressed.

För att hantera knappfunktionaliteten måste du definiera motsvarande funktioner i GDScript-koden för spelet över scenen. Här är ett exempel:

utökar kontrollen
func _ready():
 $Button.connect("nedtryckt", själv, "på PlayAgainPressed")
 $Button2.connect("nedtryckt", själv, "onExitPressed")
func onPlayAgainPressed():
 var gameScenePath = "res://GameScene.tscn"
 get_tree().change_scene (gameScenePath)

func onExitPressed():
 get_tree().quit() # Stäng spelapplikationen

När du har ställt in GameOver.tscn scen och definierade den nödvändiga knappfunktionaliteten kan du använda följande kod i huvudspelscenen för att visa spelet över skärmen:

utökar KinematicBody2D
func _physics_process (delta):
# Kontrollera om spelaren har passerat skärmens gränser
 var screen_size = get_viewport_rect().size
om hastighet.y > skärmstorlek.y eller hastighet.y < 0:
 show_game_over_screen()
func show_game_over_screen():
 get_tree().change_scene("res://GameOver.tscn")

Game Over-skärmen kommer att se ut ungefär så här, med knappar för spelaren att starta om eller avsluta:

Inklusive ytterligare funktioner

När du skapar anpassade UI-menyer i Godot med hjälp av kontrollnoder, har du flexibiliteten att lägga till olika funktioner för att förbättra funktionaliteten och visuella tilltalande av dina menyer. Här är några idéer att överväga.

Animerade övergångar

Lägg till mjuka övergångar mellan olika menyskärmar, till exempel fade-in, slide-in eller skalningseffekter. Du kan uppnå detta genom att modifiera egenskaperna för kontrollnoderna över tid med interpoleringar eller animationsspelare.

Ljudeffekter

Implementera ljudeffekter för att ge ljudåterkoppling när spelaren trycker på menyknapparna. Du kan spela olika ljud för knappklick, menyövergångar eller andra interaktioner för att få menyerna att kännas mer lyhörda och engagerande.

Godots inbyggda ljudsystem gör det enkelt att spela upp ljud vid lämpliga tidpunkter.

Visuella effekter

Använd shaders eller partikelsystem för att lägga till visuella effekter till dina menyer. Du kan till exempel använda en subtil glödeffekt på valda knappar eller skapa partikeleffekter som utlöses när vissa menyåtgärder inträffar. Dessa effekter kan lägga till en polerad och uppslukande känsla till ditt användargränssnitt.

Bakgrundsmusik

Överväg att spela upphovsrättsfri bakgrundsmusik specifika för varje menyskärm för att skapa en mer uppslukande atmosfär. Du kan använda ljudströmmar eller ljudbussar i Godot för att hantera bakgrundsmusiken och säkerställa sömlösa övergångar mellan olika spår när spelaren navigerar genom menyerna.

Lokaliseringsstöd

Om du planerar att översätta ditt spel till flera språk, överväg att lägga till lokaliseringsstöd till dina UI-menyer.

Tillhandahåll en mekanism för att dynamiskt ändra textinnehållet i etiketter och knappar baserat på det valda språket. Godots lokaliseringsverktyg och resurser kan hjälpa till med att hantera flerspråkiga UI-element.

Kom ihåg att testa och iterera på dina menyer med riktiga användare för att säkerställa att de extra funktionerna förbättrar den övergripande användarupplevelsen och är intuitiva att navigera. Var uppmärksam på prestandaöverväganden, särskilt när du använder animationer och visuella effekter, för att säkerställa smidig och lyhörd gränssnittsinteraktion.

Gör Godot-spel mer engagerande med anpassad UI-meny

Anpassade UI-menyer kan spela en avgörande roll för spelarens engagemang. De ger intuitiv navigering, ger enkel åtkomst till spelfunktioner och förbättrar ditt spels övergripande visuella tilltalande.

Med lite kreativitet och lite kodning kan du designa menyer som inte bara ger viktig funktionalitet utan också fängslar spelare och förbättrar deras övergripande spelupplevelse. Så börja utforska och skapa dina egna unika menyer för att få dina Godot-spel att sticka ut från mängden.