Erfahren Sie, wie Sie benutzerdefinierte Schaltflächen in separaten Szenen anzeigen, um als einfache Bildschirmmenüs für Ihre Spiele zu fungieren.

Die zentralen Thesen

  • Benutzerdefinierte Menüs in Godot können das Engagement und die Benutzererfahrung verbessern, indem sie eine einfache Navigation und schnellen Zugriff auf Spielfunktionen ermöglichen.
  • Godot bietet ein leistungsstarkes Toolset zum Erstellen benutzerdefinierter UI-Menüs mithilfe von Steuerknoten in der Spiel-Engine.
  • Sie können in Godot Menüs wie Startmenüs, Pausenmenüs und Game-Over-Bildschirme erstellen, indem Sie entsprechende Knoten hinzufügen und deren Funktionalität mithilfe von GDScript implementieren.

Benutzerdefinierte Menüs können das Engagement und die Benutzererfahrung Ihres Godot-Spiels erheblich verbessern. Durch die Erstellung intuitiver und optisch ansprechender Menüs können Sie den Spielern eine einfache Navigation und schnellen Zugriff auf verschiedene Spielfunktionen bieten.

Glücklicherweise bietet Godot ein leistungsstarkes Toolset zum Erstellen benutzerdefinierter UI-Menüs mithilfe von Steuerknoten.

instagram viewer

Einrichten des Godot-Spiels

Erstellen Sie zunächst eine 2D-Spielszene in die Godot-Spiel-Engine. Füge hinzu ein KinematicBody2D Knoten für den Spielercharakter und fügen Sie einen hinzu CollisionShape2D Definieren Sie mithilfe eines Knotens eine rechteckige Form, die den Kollisionsbereich des Spielers darstellt.

Der in diesem Artikel verwendete Code ist hier verfügbar GitHub-Repository Die Nutzung steht Ihnen unter der MIT-Lizenz kostenlos zur Verfügung.

Fügen Sie außerdem a hinzu Sprite2D Knoten, um den Spielercharakter visuell darzustellen. Unten ist ein GDScript-Codeausschnitt, um Spielerbewegungen zu ermöglichen:

erweitert KinematicBody2D
const GESCHWINDIGKEIT = 200
const GRAVITY = 500
var Geschwindigkeit = Vector2.ZERO


func _physics_process (delta):
 var move_direction = 0


Wenn Input.is_action_pressed(„ui_right“):
 Bewegungsrichtung += 1


Wenn Input.is_action_pressed(„ui_left“):
 Bewegungsrichtung -= 1
 Velocity.x = Bewegungsrichtung * GESCHWINDIGKEIT
 Geschwindigkeit.y += SCHWERKRAFT * Delta
 Geschwindigkeit = move_and_slide (Geschwindigkeit, Vector2.UP)

Definieren Sie in diesem Code eine Konstante GESCHWINDIGKEIT um die Bewegungsgeschwindigkeit des Spielers zu steuern. Aktualisieren Sie die Geschwindigkeitsvariable als Reaktion auf Benutzereingaben und rufen Sie auf move_and_slide() um den Spieler unter Berücksichtigung von Kollisionen und der Schwerkraft des Spiels zu bewegen.

Erstellen Sie ein Startmenü

Um ein Startmenü in Godot zu erstellen, fügen Sie einen Steuerknoten als Stammverzeichnis der Szene hinzu. Fügen Sie einen Label-Knoten als untergeordnetes Element dieses Steuerknotens hinzu und legen Sie seinen Text auf fest Einfaches Spiel. Sie können Schriftart, Größe und Farbe der Beschriftung anpassen, um sie an den Stil Ihres Spiels anzupassen.

Fügen Sie anschließend einen Button-Knoten als untergeordnetes Element des Control-Knotens hinzu. Legen Sie den Text der Schaltfläche fest auf Spiel spielen. Schreiben Sie benutzerdefinierten Code für Spiel spielen Klicken Sie auf die Schaltfläche, um die Funktionalität zu verwalten:

erweitert die Kontrolle
func _ready():
 var playButton = $Button
 playButton.connect(„gedrückt“, selbst, „_on_PlayButton_pressed“)
func _on_PlayButton_pressed():
# Laden Sie die Spielszene
 var gameScene = preload(„res://GameScene.tscn“)

# Übergang zur Spielszene
 get_tree().change_scene (gameScene)

Dieser Code verbindet die gedrückt Signal der PlayButton zum _on_PlayButton_pressed Funktion. Diese Funktion lädt die Spielszene mit vorladen() und erstellt eine Instanz davon. Es nutzt dann change_scene() zum Übergang zur Spielszene.

Ebenso können Sie eine hinzufügen Ausfahrt Schaltfläche, mit der Spieler das Spiel beenden können:

func _ready():
 var playButton = $Button
 var exitButton = $Button2
 playButton.connect(„gedrückt“, selbst, „_on_PlayButton_pressed“)
 exitButton.connect(„gedrückt“, selbst, „_on_ExitButton_pressed“)
func _on_ExitButton_pressed():
# Das Spiel verlassen
 get_tree().quit()

Dieser Code verbindet die gedrückt Signal der Ausgangstaste an die _on_ExitButton_pressed Funktion. Diese Funktion ruft auf aufhören() um das Spiel zu verlassen.

Erstellen Sie das Pausenmenü

Um Ihrem Godot-Spiel ein Pausenmenü hinzuzufügen, erstellen Sie eine neue Szene mit einem Kontrollknoten als Stammverzeichnis des Pausenmenüs. Entwerfen Sie die visuellen Elemente des Menüs, einschließlich einer Beschriftung für Angehalten Mit den Tasten und können Sie das Spiel fortsetzen, zum Hauptmenü zurückkehren und das Spiel beenden.

Fügen Sie die Szene als untergeordneten Knoten des Hauptspiels hinzu. Fügen Sie im an den Steuerknoten angehängten Skript den folgenden Code hinzu:

erweitert die Kontrolle
func _ready():
 $btnResume.connect(„gedrückt“, selbst, „_on_resume_button_pressed“)
 $btnHome.connect(„gedrückt“, selbst, „_on_menu_button_pressed“)
 $btnExit.connect(„gedrückt“, selbst, „_on_exit_button_pressed“)
 pause_mode = Knoten. PAUSE_MODE_PROCESS
 get_tree().paused = false
 self.hide()

func _input (Ereignis):
Wenn event.is_action_pressed(„ui_cancel“):
Wennnicht self.is_visible_in_tree():
# Unterbrechen Sie das Spiel, wenn das Pausenmenü nicht sichtbar ist
 self.show()
 get_tree().paused = true
anders:
# Unterbrechen Sie die Spielpause, wenn das Pausenmenü bereits sichtbar ist
 self.hide()
 get_tree().paused = false


func _on_resume_button_pressed():
# Blenden Sie das Pausenmenü aus und setzen Sie das Spiel fort
 self.hide()
 get_tree().paused = false


func _on_menu_button_pressed():
# Zurück zum Hauptmenü
 get_tree().change_scene(„res://StartMenu.tscn“)
func _on_exit_button_pressed():
# Das Spiel verlassen
 get_tree().quit()

Im _bereit() Funktion, verbinden Sie die gedrückt Signal der Resume-, Home- und Exit-Tasten an ihre jeweiligen Funktionen: _on_resume_button_pressed(), _on_menu_button_pressed(), Und _on_exit_button_pressed().

Stellen Sie die ein pause_mode des Knotens zu Knoten. PAUSE_MODE_PROCESS. Dadurch kann das Spiel weiterlaufen, während das Pausenmenü sichtbar ist. Blenden Sie das Pausenmenü standardmäßig mit aus self.hide() und eingestellt get_tree().paused Zu FALSCH um sicherzustellen, dass das Spiel zunächst nicht pausiert.

Nächste, Verwenden Sie eine if-Anweisung im _input (Ereignis) Funktion, um zu überprüfen, ob die ui_cancel Aktion gedrückt wird. Wenn das Pausenmenü derzeit nicht sichtbar ist, können Sie das Spiel anhalten, indem Sie das Pausenmenü und die Einstellung anzeigen get_tree().paused Zu WAHR.

Erstellen Sie einen Game Over-Bildschirm

Um einen Game-Over-Bildschirm in Godot zu implementieren, erstellen Sie eine separate Szene namens GameOver.tscn um seine UI-Elemente und Funktionalität zu definieren. Sie können diese Szene als untergeordneten Knoten hinzufügen, wenn der Spieler die Bildschirmgrenzen überschreitet und so das Ende des Spiels anzeigt.

Öffnen Sie eine neue Szene in Godot und fügen Sie einen Kontrollknoten als Stammverzeichnis der Szene hinzu. Fügen Sie innerhalb des Control-Knotens einen Label-Knoten hinzu, um den anzuzeigen Spiel ist aus Text. Passen Sie Schriftart, Größe und Farbe des Etiketts an den visuellen Stil Ihres Spiels an.

Als nächstes fügen Sie Button-Knoten für hinzu Nochmal abspielen Und Ausfahrt Optionen. Positionieren Sie sie entsprechend auf dem Bildschirm.

Verbinden Sie die Schaltflächensignale mit ihren jeweiligen Funktionen, um die Aktionen beim Klicken zu verarbeiten. Verbinden Sie zum Beispiel die Nochmal abspielen Schaltfläche zu einer aufgerufenen Funktion onPlayAgainPressed und das Ausfahrt Schaltfläche zu einer aufgerufenen Funktion onExitPressed.

Um die Schaltflächenfunktionalität zu handhaben, müssen Sie die entsprechenden Funktionen im GDScript-Code der Game-Over-Szene definieren. Hier ist ein Beispiel:

erweitert die Kontrolle
func _ready():
 $Button.connect(„gedrückt“, selbst, „onPlayAgainPressed“)
 $Button2.connect(„gedrückt“, selbst, „onExitPressed“)
Funktion onPlayAgainPressed():
 var gameScenePath = „res://GameScene.tscn“
 get_tree().change_scene (gameScenePath)

Funktion onExitPressed():
 get_tree().quit() # Schließen Sie die Spielanwendung

Sobald Sie das eingerichtet haben GameOver.tscn Szene erstellt und die erforderliche Schaltflächenfunktionalität definiert haben, können Sie den folgenden Code in der Hauptspielszene verwenden, um den Game-Over-Bildschirm anzuzeigen:

erweitert KinematicBody2D
func _physics_process (delta):
# Überprüfen Sie, ob der Player die Bildschirmgrenzen überschritten hat
 var screen_size = get_viewport_rect().size
Wenn Geschwindigkeit.y > Bildschirmgröße.y oder Geschwindigkeit.y < 0:
 show_game_over_screen()
func show_game_over_screen():
 get_tree().change_scene(„res://GameOver.tscn“)

Der Game Over-Bildschirm sieht in etwa so aus, mit Schaltflächen, mit denen der Spieler neu starten oder beenden kann:

Inklusive zusätzlicher Funktionen

Beim Erstellen benutzerdefinierter UI-Menüs in Godot mithilfe von Steuerknoten haben Sie die Flexibilität, verschiedene Funktionen hinzuzufügen, um die Funktionalität und visuelle Attraktivität Ihrer Menüs zu verbessern. Hier sind einige Ideen, die Sie berücksichtigen sollten.

Animierte Übergänge

Fügen Sie sanfte Übergänge zwischen verschiedenen Menübildschirmen hinzu, z. B. Einblendungen, Einblendungen oder Skalierungseffekte. Sie können dies erreichen, indem Sie die Eigenschaften der Steuerknoten im Laufe der Zeit mithilfe von Tweens oder Animationsplayern ändern.

Soundeffekte

Implementieren Sie Soundeffekte, um Audio-Feedback zu geben, wenn der Player die Menütasten drückt. Sie können verschiedene Sounds für Tastenklicks, Menüübergänge oder andere Interaktionen abspielen, um die Menüs reaktionsschneller und ansprechender zu gestalten.

Das integrierte Audiosystem von Godot erleichtert das Abspielen von Tönen zu passenden Zeiten.

Visuelle Effekte

Verwenden Sie Shader oder Partikelsysteme, um Ihren Menüs visuelle Effekte hinzuzufügen. Sie können beispielsweise einen subtilen Leuchteffekt auf ausgewählte Schaltflächen anwenden oder Partikeleffekte erstellen, die ausgelöst werden, wenn bestimmte Menüaktionen ausgeführt werden. Diese Effekte können Ihrer Benutzeroberfläche ein ausgefeiltes und immersives Gefühl verleihen.

Hintergrundmusik

Erwägen Sie das Spielen Urheberrechtsfreie Hintergrundmusik spezifisch für jeden Menübildschirm, um eine noch intensivere Atmosphäre zu schaffen. Sie können in Godot Audiostreams oder Audiobusse verwenden, um die Hintergrundmusik zu verwalten und nahtlose Übergänge zwischen verschiedenen Titeln sicherzustellen, während der Player durch die Menüs navigiert.

Lokalisierungsunterstützung

Wenn Sie planen, Ihr Spiel in mehrere Sprachen zu übersetzen, sollten Sie in Erwägung ziehen, Ihren UI-Menüs Lokalisierungsunterstützung hinzuzufügen.

Stellen Sie einen Mechanismus bereit, um den Textinhalt von Beschriftungen und Schaltflächen basierend auf der ausgewählten Sprache dynamisch zu ändern. Die Lokalisierungstools und -ressourcen von Godot können bei der Verwaltung mehrsprachiger UI-Elemente hilfreich sein.

Denken Sie daran, Ihre Menüs mit echten Benutzern zu testen und zu iterieren, um sicherzustellen, dass die zusätzlichen Funktionen das gesamte Benutzererlebnis verbessern und intuitiv zu navigieren sind. Achten Sie auf Leistungsaspekte, insbesondere bei der Verwendung von Animationen und visuellen Effekten, um reibungslose und reaktionsschnelle Interaktionen mit der Benutzeroberfläche sicherzustellen.

Machen Sie Godot-Spiele mit einem benutzerdefinierten UI-Menü ansprechender

Benutzerdefinierte UI-Menüs können eine entscheidende Rolle bei der Spielereinbindung spielen. Sie bieten eine intuitive Navigation, ermöglichen einen einfachen Zugriff auf Spielfunktionen und verbessern die optische Gesamtattraktivität Ihres Spiels.

Mit ein wenig Kreativität und etwas Programmierung können Sie Menüs entwerfen, die nicht nur wesentliche Funktionen bieten, sondern auch Spieler fesseln und ihr gesamtes Spielerlebnis verbessern. Beginnen Sie also mit der Erkundung und Gestaltung Ihrer eigenen, einzigartigen Menüs, um Ihre Godot-Spiele von der Masse abzuheben.