Up to date

This page is up to date for Godot 4.2. If you still find outdated information, please open an issue.

Eingabe-Beispiele¶

Einführung¶

In diesem Tutorial lernen Sie, wie Sie das InputEvent-System von Godot verwenden, um Spielereingaben zu erfassen. Es gibt viele verschiedene Arten von Eingaben, die Ihr Spiel verwenden kann - Tastatur, Gamepad, Maus, etc. - und viele verschiedene Möglichkeiten, diese Eingaben in Aktionen in Ihrem Spiel umzusetzen. Dieses Dokument zeigt Ihnen einige der häufigsten Szenarien, die Sie als Ausgangspunkt für Ihre eigenen Projekte verwenden können.

Bemerkung

Einen detaillierten Überblick über die Funktionsweise von Godots Eingabe-Event-System finden Sie unter Verwendung von InputEvent.

Events vs. Polling¶

Manchmal möchten Sie, dass Ihr Spiel auf ein bestimmtes Eingabe-Event reagiert, z.B. auf das Drücken des "Sprung"-Buttons. In anderen Situationen möchten Sie vielleicht, dass etwas passiert, solange eine Taste gedrückt wird, wie zum Beispiel eine Bewegung. Im ersten Fall können Sie die Funktion _input() verwenden, die immer dann aufgerufen wird, wenn ein Eingabe-Event auftritt. Im zweiten Fall bietet Godot das Singleton Input, mit dem Sie den Zustand einer Eingabe abfragen können.

Beispiele:

func _input(event):
    if event.is_action_pressed("jump"):
        jump()


func _physics_process(delta):
    if Input.is_action_pressed("move_right"):
        # Move as long as the key/button is pressed.
        position.x += speed * delta

public override void _Input(InputEvent @event)
{
    if (@event.IsActionPressed("jump"))
    {
        Jump();
    }
}

public override void _PhysicsProcess(double delta)
{
    if (Input.IsActionPressed("move_right"))
    {
        // Move as long as the key/button is pressed.
        position.X += speed * (float)delta;
    }
}

Dies gibt Ihnen die Flexibilität, die Art der durchführenden Eingabeverarbeitung zu kombinieren.

Im weiteren Verlauf dieses Tutorials konzentrieren wir uns auf die Erfassung einzelner Ereignisse in _input ().

Eingabe-Events¶

Eingabe-Events sind Objekte, die von InputEvent erben. Je nach Event-Typ enthält das Objekt spezifische Propertys, die sich auf das jeweilige Event beziehen. Um zu sehen, wie Events tatsächlich aussehen, fügen Sie einen Node hinzu und hängen das folgende Skript an:

extends Node


func _input(event):
    print(event.as_text())

using Godot;

public partial class Node : Godot.Node
{
    public override void _Input(InputEvent @event)
    {
        GD.Print(@event.AsText());
    }
}

Wenn Sie Tasten drücken, die Maus bewegen oder andere Eingaben machen, sehen Sie, wie die einzelnen Evebts im Ausgabefenster vorbeiscrollen. Hier ist ein Beispiel für die Ausgabe:

A
Mouse motion at position ((971, 5)) with velocity ((0, 0))
Right Mouse Button
Mouse motion at position ((870, 243)) with velocity ((0.454937, -0.454937))
Left Mouse Button
Mouse Wheel Up
A
B
Shift
Alt+Shift
Alt
Shift+T
Mouse motion at position ((868, 242)) with velocity ((-2.134768, 2.134768))

Wie Sie sehen können, sind die Ergebnisse für die verschiedenen Arten von Eingaben sehr unterschiedlich. Tasten-Events werden sogar als ihre Tasten-Symbole ausgegeben. Betrachten wir zum Beispiel InputEventMouseButton. Sie erbt von den folgenden Klassen:

InputEvent - Die Basisklasse für alle Eingabe-Events
InputEventWithModifiers - fügt die Fähigkeit hinzu, zu überprüfen, ob Modifikatoren gedrückt werden, wie Shift oder Alt.
InputEventMouse - fügt Maus-Event-Propertys hinzu, wie z.B. Position
InputEventMouseButton - enthält den Index der Taste, die gedrückt wurde, und ob es sich um einen Doppelklick handelte, usw.

Tipp

Es ist eine gute Idee, die Klassenreferenz geöffnet zu lassen, während Sie mit Events arbeiten, damit Sie die verfügbaren Propertys und Methoden des Event-Typs überprüfen können.

Sie können auf Fehler stoßen, wenn Sie versuchen, auf eine Property eines Eingabetyps zuzugreifen, der sie nicht enthält - zum Beispiel, wenn Sie Position auf InputEventKey aufrufen. Um dies zu vermeiden, stellen Sie sicher, dass Sie den Event-Typ zuerst testen:

func _input(event):
    if event is InputEventMouseButton:
        print("mouse button event at ", event.position)

public override void _Input(InputEvent @event)
{
    if (@event is InputEventMouseButton mouseEvent)
    {
        GD.Print("mouse button event at ", mouseEvent.Position);
    }
}

InputMap¶

Die InputMap ist der flexibelste Weg, eine Vielzahl von Eingaben zu verarbeiten. Sie verwenden sie, indem Sie benannte Eingabe-Aktionen erstellen, denen Sie eine beliebige Anzahl von Eingabe-Events zuordnen können, wie z.B. Tastendrücke oder Mausklicks. Um diese zu sehen und Ihre eigenen hinzuzufügen, öffnen Sie Projekt -> Projekteinstellungen und wählen Sie den InputMap-Tab:

Tipp

Ein neues Godot-Projekt enthält eine Reihe von bereits definierten Standardaktionen. Um diese zu sehen, schalten Sie im Dialogfeld "InputMap" die Option Built-in-Aktionen zeigen ein.

Aktionen aufnehmen¶

Sobald Sie Ihre Aktionen definiert haben, können Sie diese in Ihren Skripten mit is_action_pressed() und is_action_released() verarbeiten, indem Sie den Namen der gesuchten Aktion übergeben:

func _input(event):
    if event.is_action_pressed("my_action"):
        print("my_action occurred!")

public override void _Input(InputEvent @event)
{
    if (@event.IsActionPressed("my_action"))
    {
        GD.Print("my_action occurred!");
    }
}

Tastatur-Events¶

Tastatur-Events werden in InputEventKey erfasst. Es wird zwar empfohlen, stattdessen Eingabeaktionen zu verwenden, aber es kann Fälle geben, in denen Sie speziell nach Tastenereignissen suchen möchten. In diesem Beispiel wollen wir nach dem T suchen:

func _input(event):
    if event is InputEventKey and event.pressed:
        if event.keycode == KEY_T:
            print("T was pressed")

public override void _Input(InputEvent @event)
{
    if (@event is InputEventKey keyEvent && keyEvent.Pressed)
    {
        if (keyEvent.Keycode == Key.T)
        {
            GD.Print("T was pressed");
        }
    }
}

Tipp

Siehe @GlobalScope_Key für eine Liste von Tastencode-Konstanten.

Warnung

Aufgrund von Tastatur-Ghosting werden möglicherweise nicht alle Tasteneingaben zu einem bestimmten Zeitpunkt registriert, wenn Sie zu viele Tasten gleichzeitig drücken. Aufgrund ihrer Position auf der Tastatur sind bestimmte Tasten anfälliger für Ghosting als andere. Einige Tastaturen verfügen über eine Antighosting-Funktion auf Hardware-Ebene, aber diese Funktion ist bei einfachen Tastaturen und Laptop-Tastaturen im Allgemeinen nicht vorhanden.

Es wird daher empfohlen, ein Default-Tastaturlayout zu verwenden, das für eine Tastatur ohne Anti-Ghosting geeignet ist. Weitere Informationen finden Sie in dieser Gamedev Stack Exchange-Frage.

Tastaturmodifikatoren¶

Modifikator-Propertys werden von InputEventWithModifiers geerbt. Damit können Sie mit booleschen Propertys auf Modifikator-Kombinationen prüfen. Nehmen wir an, Sie wollen, dass etwas passiert, wenn die Taste T gedrückt wird, aber etwas anderes, wenn die Taste Shift + T gedrückt wird:

func _input(event):
    if event is InputEventKey and event.pressed:
        if event.keycode == KEY_T:
            if event.shift_pressed:
                print("Shift+T was pressed")
            else:
                print("T was pressed")

public override void _Input(InputEvent @event)
{
    if (@event is InputEventKey keyEvent && keyEvent.Pressed)
    {
        switch (keyEvent.Keycode)
        {
            case Key.T:
                GD.Print(keyEvent.ShiftPressed ? "Shift+T was pressed" : "T was pressed");
                break;
        }
    }
}

Tipp

Siehe @GlobalScope_Key für eine Liste von Tastencode-Konstanten.

Maus-Events¶

Maus-Events stammen von der Klasse InputEventMouse und sind in zwei Typen unterteilt: InputEventMouseButton und InputEventMouseMotion. Beachten Sie, dass dies bedeutet, dass alle Maus-Events eine Property Position enthalten.

Maustasten¶

Die Erfassung von Maustasten ist der Behandlung von Tasten-Events sehr ähnlich. @GlobalScope_MouseButton enthält eine Liste von MOUSE_BUTTON_*-Konstanten für jede mögliche Taste, die in der button_index-Eigenschaft des Events gemeldet werden. Beachten Sie, dass das Scrollrad auch als Taste zählt - zwei Tasten, um genau zu sein, wobei sowohl MOUSE_BUTTON_WHEEL_UP als auch MOUSE_BUTTON_WHEEL_DOWN separate Events sind.

func _input(event):
    if event is InputEventMouseButton:
        if event.button_index == MOUSE_BUTTON_LEFT and event.pressed:
            print("Left button was clicked at ", event.position)
        if event.button_index == MOUSE_BUTTON_WHEEL_UP and event.pressed:
            print("Wheel up")

public override void _Input(InputEvent @event)
{
    if (@event is InputEventMouseButton mouseEvent && mouseEvent.Pressed)
    {
        switch (mouseEvent.ButtonIndex)
        {
            case MouseButton.Left:
                GD.Print($"Left button was clicked at {mouseEvent.Position}");
                break;
            case MouseButton.WheelUp:
                GD.Print("Wheel up");
                break;
        }
    }
}

Mausbewegung¶

InputEventMouseMotion-Events treten auf, wenn sich die Maus bewegt. Sie können die Entfernung der Bewegung mit der relativ-Property ermitteln.

Hier ein Beispiel für die Verwendung von Mouse Events zum Verschieben eines Sprite2D Nodes per Drag&Drop:

extends Node


var dragging = false
var click_radius = 32 # Size of the sprite.


func _input(event):
    if event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_LEFT:
        if (event.position - $Sprite2D.position).length() < click_radius:
            # Start dragging if the click is on the sprite.
            if not dragging and event.pressed:
                dragging = true
        # Stop dragging if the button is released.
        if dragging and not event.pressed:
            dragging = false

    if event is InputEventMouseMotion and dragging:
        # While dragging, move the sprite with the mouse.
        $Sprite2D.position = event.position

using Godot;

public partial class MyNode2D : Node2D
{
    private bool _dragging = false;
    private int _clickRadius = 32; // Size of the sprite.

    public override void _Input(InputEvent @event)
    {
        Sprite2D sprite = GetNodeOrNull<Sprite2D>("Sprite2D");
        if (sprite == null)
        {
            return; // No suitable node was found.
        }

        if (@event is InputEventMouseButton mouseEvent && mouseEvent.ButtonIndex == MouseButton.Left)
        {
            if ((mouseEvent.Position - sprite.Position).Length() < _clickRadius)
            {
                // Start dragging if the click is on the sprite.
                if (!_dragging && mouseEvent.Pressed)
                {
                    _dragging = true;
                }
            }
            // Stop dragging if the button is released.
            if (_dragging && !mouseEvent.Pressed)
            {
                _dragging = false;
            }
        }
        else
        {
            if (@event is InputEventMouseMotion motionEvent && _dragging)
            {
                // While dragging, move the sprite with the mouse.
                sprite.Position = motionEvent.Position;
            }
        }
    }
}

Touch-Events¶

Wenn Sie ein Touchscreen-Gerät verwenden, können Sie Touch-Events erzeugen: InputEventScreenTouch entspricht einem Mausklick-Event, und InputEventScreenDrag funktioniert ähnlich wie eine Mausbewegung.

Tipp

Um Ihre Touch-Events auf einem Nicht-Touchscreen-Gerät zu testen, öffnen Sie die Projekteinstellungen und gehen Sie zum Abschnitt "Eingabegeräte/Zeigen". Aktivieren Sie "Touch durch Maus emulieren", damit Ihr Projekt Mausklicks und Bewegungen als Touch Events interpretiert.