Spieleraktionen in Godot steuern

Nachdem wir unseren Sprite mit einem Script zum Rotieren gebracht haben, ist es an der Zeit, ihm Interaktion mit der Spieler:in zu ermöglichen. Input ist ein zentraler Bestandteil der meisten Spiele. Wie reagiert unser Spiel auf die Eingaben der Spieler:in (Tastatur, Maus, Gamepad)? Godot hat dafür ein sehr flexibles System, die Input Map. Anstatt direkt auf Tasten wie „W“ oder „Up Arrow“ zu prüfen, definieren wir Input Actions. Eine Action ist ein abstrakter Befehl, wie z.B. „move_up“, „attack“ oder „move_right“. Diesen Actions können wir dann eine oder mehrere Tasten/Mausbuttons/Gamepad-Buttons zuweisen. Das hat den Vorteil, dass wir die Steuerung später leicht ändern können, ohne den Script-Code anpassen zu müssen.

Schritt 1: Input Actions definieren

Wir beginnen damit, unsere Bewegungs-Actions in den Project Settings zu definieren:

Gehe im Menü oben auf Project -> Project Settings….
Wähle oben den Tab Input Map.
Oben siehst du ein Feld „Add New Action“. Gib hier den Namen unserer ersten Action ein, z.B. move_right.
Klicke auf den Button „+ Add“ daneben. Die Action move_right erscheint in der Liste.
Klicke neben der Action move_right auf das „+“ Symbol.
Ein Fenster öffnet sich, das dich auffordert, eine Taste auszuwählen. Drücke die Rechte Pfeiltaste. Es erscheint „Right or Right (physical) or Right (Unicode) im Eingabefeld über der Liste und in der Liste wird der Eintrag „Right“ ausgweählt. Klicke auf „OK“.
(Optional) Klicke erneut auf das „+“ neben move_right und drücke die Taste „D“, um „D“ ebenfalls für die Bewegung nach rechts zu konfigurieren.
Wiederhole die Schritte 3-6/7 für die anderen drei Bewegungsrichtungen:
- move_left (z.B. Linke Pfeiltaste und „A“)
- move_up (z.B. Obere Pfeiltaste und „W“)
- move_down (z.B. Untere Pfeiltaste und „S“)
Wenn du alle vier Actions definiert und die gewünschten Tasten zugewiesen hast, schließe das Fenster Project Settings. Die Änderungen werden automatisch gespeichert.

Schritt 2: Input Actions im Script abfragen

Jetzt kehren wir zu unserem Player.gd Script zurück. Wir erweitern die _process-Funktion, um auf diese Input Actions zu reagieren und den Sprite zu bewegen.

Öffne dein Script (klicke im Filesystem Dock doppelt auf Player.gd, falls es nicht mehr geöffnet ist).

Wir fügen eine Variable für die Geschwindigkeit hinzu und ändern dann die _process-Funktion:

class_name Player extends Sprite2D
var speed = 200 # Einheit: Pixel pro Sekunde
# Called when the node enters the scene tree for the first time.
func _ready():
    pass
# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta):
    # Rotation (behalten wir erstmal)
    rotation_degrees += 45 * delta
    # Bewegung Input verarbeiten
    var direction = Vector2.ZERO
    if Input.is_action_pressed("move_right"):
        direction.x += 1 # Bewegung nach rechts addiert 1 zur X-Koordinate
    if Input.is_action_pressed("move_left"):
        direction.x -= 1 # Bewegung nach links subtrahiert 1 von der X-Koordinate
    if Input.is_action_pressed("move_down"):
        direction.y += 1 # Bewegung nach unten addiert 1 zur Y-Koordinate
    if Input.is_action_pressed("move_up"):
        direction.y -= 1 # Bewegung nach oben subtrahiert 1 von der Y-Koordinate
    # Normalisieren bei diagonaler Bewegung
    if direction.length() > 0: # Prüfen, ob überhaupt eine Richtung aktiv ist
        direction = direction.normalized() # Normalisieren auf Vektor der Länge 1
    # Bewegung anwenden: Aktuelle Position + (Richtung * Geschwindigkeit * Zeit seit letztem Frame)
    position += direction * speed * delta

class_name Player extends Sprite2D

var speed = 200 # Einheit: Pixel pro Sekunde

# Called when the node enters the scene tree for the first time.

func _ready():

pass

# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta):

# Rotation (behalten wir erstmal)

rotation_degrees += 45 * delta

# Bewegung Input verarbeiten

var direction = Vector2.ZERO

if Input.is_action_pressed("move_right"):

direction.x += 1 # Bewegung nach rechts addiert 1 zur X-Koordinate

if Input.is_action_pressed("move_left"):

direction.x -= 1 # Bewegung nach links subtrahiert 1 von der X-Koordinate

if Input.is_action_pressed("move_down"):

direction.y += 1 # Bewegung nach unten addiert 1 zur Y-Koordinate

if Input.is_action_pressed("move_up"):

direction.y -= 1 # Bewegung nach oben subtrahiert 1 von der Y-Koordinate

# Normalisieren bei diagonaler Bewegung

if direction.length() > 0: # Prüfen, ob überhaupt eine Richtung aktiv ist

direction = direction.normalized() # Normalisieren auf Vektor der Länge 1

# Bewegung anwenden: Aktuelle Position + (Richtung * Geschwindigkeit * Zeit seit letztem Frame)

position += direction * speed * delta

Erklärung des neuen Codes:

var speed = 200: Eine neue Variable speed wird deklariert und initialisiert. var ist das Schlüsselwort für Variablen. Sie speichert, wie viele Pixel pro Sekunde sich der Sprite bewegen soll.
var direction = Vector2.ZERO: Vector2 ist ein eingebauter Godot-Datentyp, der ein Paar von 2D-Koordinaten (x, y) darstellt. Perfekt für Positionen, Richtungen oder Geschwindigkeiten in 2D. Vector2.ZERO ist eine Abkürzung für Vector2(0, 0). Wir initialisieren hiermit einen Vektor, der die aktuelle Bewegungsrichtung speichern wird.
Input.is_action_pressed("..."): Dies ist die Funktion, um abzufragen, ob die Taste(n) für die genannte Input Action gerade gedrückt werden. Sie gibt true oder false zurück.
direction.x += 1, etc.: Abhängig davon, welche Bewegungstasten gedrückt sind, addieren oder subtrahieren wir 1 zu den X- oder Y-Komponenten unseres direction-Vektors. Zum Beispiel, wenn nur „move_right“ gedrückt wird, ist direction am Ende Vector2(1, 0). Wenn „move_right“ und „move_down“ gleichzeitig gedrückt werden, wird direction Vector2(1, 1).
Hinweis: in Godot 2D geht Y nach unten.
if direction.length() > 0: direction = direction.normalized(): Wenn wir diagonal laufen (z.B. rechts und runter, Vector2(1, 1)), ist die Länge des Richtungsvektors größer als 1 (genau: Wurzel von $2$ ). Um zu verhindern, dass die diagonale Bewegung schneller ist als die horizontale oder vertikale, normalisieren wir den Vektor. normalized() gibt einen neuen Vektor mit derselben Richtung, aber der Länge 1 zurück. So hat die Richtung immer die Länge 0 (kein Input) oder 1 (Input in eine beliebige Richtung). Wir prüfen length() > 0, damit wir nicht versuchen, einen Nullvektor zu normalisieren, was einen Fehler geben würde.
position += direction * speed * delta: Dies ist die Zeile, die die Position des Sprites tatsächlich aktualisiert. position ist eine eingebaute Eigenschaft, die die aktuelle Position des Nodes speichert (ein Vector2). Wir addieren zu der aktuellen Position den Bewegungsvektor. Dieser Bewegungsvektor wird berechnet, indem wir die normierte direction (Länge 0 oder 1) mit unserer speed (Pixel pro Sekunde) und delta (Zeit seit letztem Frame in Sekunden) multiplizieren. Das Ergebnis ist die Strecke, die der Sprite in diesem einen Frame zurücklegen soll. Das += addiert diese Strecke zur aktuellen position.

Schritt 3: Script speichern und Scene ausführen

Speichere dein Script (Strg + S).
Führe die Scene aus (F6 oder F5).

Ergebnis:

Du siehst nun das rotierende Godot-Logo, das du mit den von dir konfigurierten Tasten (Pfeiltasten oder WASD) bewegen kannst!

Dein nächster Schritt

Du hast gelernt, wie man Input Actions in Godot definiert und diese dann in GDScript nutzt, um unseren Sprite mit der Tastatur zu bewegen. Du verstehst jetzt die grundlegende Struktur für Spieler-Input und die Bedeutung von Vector2 sowie delta für eine flüssige, bildratenunabhängige Bewegung.

Als Nächstes tauchen wir in das Thema Kollisionen ein – wie unser Sprite mit anderen Objekten in der Welt interagieren kann.

Staratnights Blog

Mein erweitertes Gedächtnis – free for all