Eingabe in Unity: Von klassisch zu modern

Klassische Eingabe (Legacy Input Manager) — Veraltet

Dieses Eingabesystem wurde in Unity über viele Jahre hinweg verwendet. In neueren Unity-Versionen ist es standardmäßig nicht mehr aktiviert und gilt als veraltet. Dennoch funktioniert es weiterhin, wenn es manuell in den Projekteinstellungen aktiviert wird, und eignet sich aufgrund seiner Einfachheit gut zum Lernen. Die meisten älteren Tutorials basieren auf diesem System.

Die Einstellungen für die klassische Eingabe findest du unter Edit → Project Settings → Input Manager. Dort sind die Standardachsen und -tasten definiert, auf die wir im Code per Namen zugreifen.

Achsen (Axes)

Beispiel: Input.GetAxis("Horizontal")

Diese Methode liefert einen Gleitkommawert im Bereich von -1 bis 1.

• -1 — Bewegung nach links
• 0 — keine Eingabe
• 1 — Bewegung nach rechts

Das ist praktisch für flüssige Bewegungen. Auf der Tastatur simuliert Unity eine Art Trägheit, während der Wert bei einem Gamepad davon abhängt, wie weit der Stick ausgelenkt wird.

using UnityEngine;

void Update()
{
    float x = Input.GetAxis("Horizontal");
    Debug.Log(x);
}

Maustasten und Cursorposition

Beispiel: Input.GetMouseButtonDown(0)

Die Methode erwartet den Index der Maustaste:

• 0 — linke Maustaste
• 1 — rechte Maustaste
• 2 — Mausrad

Es gibt drei verschiedene Abfragen:

• GetMouseButtonDown — wird einmal beim Drücken ausgelöst
• GetMouseButtonUp — wird beim Loslassen ausgelöst
• GetMouseButton — wird in jedem Frame ausgeführt, solange die Taste gedrückt ist

using UnityEngine;

void Update()
{
    if (Input.GetMouseButtonDown(0))
    {
        Debug.Log("Linke Maustaste gedrückt");
    }
}

Zusätzlich zu Tastendrücken erlaubt das klassische Eingabesystem, die Position des Mauszeigers auf dem Bildschirm auszulesen. Dies geschieht über die Eigenschaft Input.mousePosition, die die Cursor-Koordinaten in Pixeln relativ zur linken unteren Ecke des Bildschirms zurückgibt.

Die Cursorposition wird häufig zum Zielen, zum Auswählen von Objekten mit der Maus oder zur Bestimmung einer Aktionsrichtung verwendet. In 2D-Spielen werden Bildschirmkoordinaten oft mithilfe der Kamera in Weltkoordinaten umgerechnet.

using UnityEngine;

void Update()
{
    Vector3 mouseScreenPos = Input.mousePosition;
    Vector3 mouseWorldPos = Camera.main.ScreenToWorldPoint(mouseScreenPos);

    Debug.Log(mouseWorldPos);
}

Tastaturtasten

Beispiel: Input.GetKeyDown(KeyCode.Space)

Dabei handelt es sich um einen direkten Zugriff auf eine konkrete physische Taste über die KeyCode-Enumeration.

Dieser Ansatz ist nützlich, wenn eine Aktion schnell an eine bestimmte Taste gebunden werden soll — zum Beispiel Escape für ein Menü oder R zum Nachladen.

using UnityEngine;

void Update()
{
    if (Input.GetKeyDown(KeyCode.Space))
    {
        Debug.Log("Sprung");
    }
}

⚠️ Wichtig:
Ist im Projekt ausschließlich das neue Input System aktiviert, funktioniert dieser Code nicht. Um die klassische Eingabe zu unterstützen, muss in den Player-Einstellungen folgender Modus gesetzt sein:
Edit → Project Settings → Player → Active Input Handling → Both

Zusammenfassung: Die klassische Eingabe ist eine einfache, schnelle und leicht verständliche Methode zur Steuerung, besonders für Lernzwecke und Prototypen. Für moderne Projekte gilt sie jedoch als veraltet.

Input Actions erstellen (Action Asset)

Im neuen Eingabesystem von Unity werden Steuerungen über Input Actions definiert. Diese repräsentieren die Aktionen des Spielers (zum Beispiel Bewegung, Springen oder Schießen), die anschließend mit Tastaturtasten, Maustasten oder einem Gamepad verknüpft werden.

In manchen Projekten erstellt Unity eine solche Datei bereits automatisch als Standardvorlage. Sie funktioniert zwar, ist jedoch meist zu allgemein und für Lernzwecke nicht ideal. Deshalb erstellen wir in diesem Tutorial unser eigenes Asset von Grund auf, um jeden Schritt nachvollziehen zu können.

Erstelle ein neues Asset: Klicke mit der rechten Maustaste im Project-Fenster (im Ordner Assets) → Create → Input Actions. Benenne die Datei PlayerControls.

Bewegung als Vektor einrichten (Vector2)

Im neuen Eingabesystem wird Bewegung am besten nicht über einzelne Tasten, sondern über einen Richtungsvektor beschrieben. Dieser Ansatz funktioniert gleichermaßen für Tastatur und Gamepad und erfordert später kein Umschreiben der Logik.

Wähle das erstellte Action Asset PlayerControls aus und doppelklicke darauf, um den Input Actions Editor zu öffnen.

Klicke in der linken Spalte Action Maps auf + und erstelle eine neue Action Map mit dem Namen Player. Klicke in der mittleren Spalte Actions auf + und erstelle eine Action mit dem Namen Move.

Lege auf der rechten Seite des Fensters in den Einstellungen der Action Move Folgendes fest:

• Action Type: Value
• Control Type: Vector2

Das bedeutet, dass die Action die Bewegungsrichtung als Vektor (x, y) zurückgibt und nicht nur ein einfaches „gedrückt / nicht gedrückt“-Signal.

Als Nächstes fügen wir Tastenzuweisungen hinzu. Klicke bei der Action Move auf + und wähle Add Up/Down/Left/Right Composite.

Dieses Composite fasst vier Richtungen zu einem einzigen Bewegungsvektor zusammen, den Unity automatisch berechnet.

Klicke für jede Richtung auf die Schaltfläche Listen und drücke einfach die entsprechende Taste auf der Tastatur:

• Up — W oder ↑
• Down — S oder ↓
• Left — A oder ←
• Right — D oder →

Als Ergebnis kombiniert Unity die Eingaben automatisch zu einem einzigen Bewegungsvektor: nach oben, unten, links, rechts oder diagonal.

Diese Einrichtung sorgt für saubere und universelle Steuerung. Im Code erhältst du eine fertige Bewegungsrichtung, ohne dich um einzelne Tasten kümmern zu müssen.

💡 Vergiss nicht, deine Änderungen zu speichern. Klicke nach dem Konfigurieren der Actions und Bindings auf Save Asset in der rechten oberen Ecke des Input Actions Editors, damit Unity alle Änderungen übernimmt.

Jump-Action hinzufügen

Zusätzlich zur Bewegung wird häufig eine separate Action benötigt, die nur einmal ausgelöst wird — zum Beispiel ein Sprung. Zu diesem Zweck verwendet das Input System eine Action vom Typ Button.

Klicke in derselben Player-Action-Map in der Spalte Actions auf + und erstelle eine neue Action mit dem Namen Jump. Setze in den Einstellungen den Action Type auf Button.

Füge anschließend ein Binding hinzu und weise die Taste Space zu. Am einfachsten geht das über die Schaltfläche Listen, indem du einfach die Leertaste auf der Tastatur drückst.

Diese Art von Action funktioniert als Ereignis — sie liefert keine Richtung oder keinen Wert, sondern meldet lediglich, dass die Taste gedrückt wurde.

💡 Vergiss nicht, auf Save Asset zu klicken, um die neu hinzugefügte Action und ihr Binding zu speichern.

Input-Action-Asset projektweit zuweisen

In Unity kann immer nur ein Input-Action-Asset gleichzeitig für das gesamte Projekt aktiv sein. In neuen Projekten ist dies häufig die von Unity automatisch erstellte Standarddatei.

Wenn du ein eigenes PlayerControls-Asset erstellst, musst du dieses als primäres Asset für das Projekt festlegen. Andernfalls verwendet Unity weiterhin das vorherige (Standard-)Asset, und die Eingabe funktioniert möglicherweise nicht wie erwartet.

Wähle die Datei PlayerControls im Project-Fenster aus. Klicke im Inspector auf die Schaltfläche Assign as the Project-wide Input Actions, sofern sie angezeigt wird.

💡 Wenn die Schaltfläche Assign as the Project-wide Input Actions nicht angezeigt wird, ist dieses Asset bereits als aktiv festgelegt, und es sind keine weiteren Schritte erforderlich.

Standard-Input-Action-Asset entfernen (falls vorhanden)

In neuen Unity-Projekten kann automatisch ein Input-Action-Asset als Standard erstellt werden. Es bleibt als normale Datei im Projekt und kann Actions mit denselben Namen enthalten wie in unserem PlayerControls-Asset.

Dadurch können bei der Auswahl von Actions oder Events doppelte Namen erscheinen, was leicht zu Verwirrung führt — insbesondere in Lern- und Tutorialprojekten.

Wenn du das Standard-Asset nicht verwendest, kannst du es einfach löschen: Klicke mit der rechten Maustaste auf die Datei im Project-Fenster und wähle Delete.

Nach dem Entfernen bleibt nur noch das PlayerControls-Asset im Projekt, und die Auswahl der Actions ist eindeutig.

💡 Das Entfernen des Standard-Input-Action-Assets ist unbedenklich, solange es im Projekt nicht verwendet wird. Für dieses Tutorial wird es nicht benötigt.

PlayerInputDemo-Skript erstellen

Jetzt schreiben wir ein einfaches Skript, das Ereignisse aus dem Input System empfängt und sie in sichtbares Verhalten des Objekts umsetzt. Wir bewegen das Objekt direkt über Transform, ohne Physik, um uns ausschließlich auf die Eingabeverarbeitung zu konzentrieren.

Klicke im Ordner Assets mit der rechten Maustaste → Create → MonoBehaviour Script und benenne die Datei PlayerInputDemo. Öffne sie anschließend und ersetze den Inhalt durch den folgenden Code.

using UnityEngine;
using UnityEngine.InputSystem;

// Dieses Skript empfängt Eingaben aus dem Input System
// und steuert das Objekt direkt über Transform
public class PlayerInputDemo : MonoBehaviour
{
    // Bewegungsgeschwindigkeit des Objekts
    // Kann im Inspector angepasst werden
    public float moveSpeed = 5f;

    // Speichert die aktuelle Bewegungsrichtung
    // (zum Beispiel: (-1,0), (1,0), (0,1) oder (0,0))
    private Vector2 moveInput;

    // Diese Methode wird vom Player Input aufgerufen,
    // wenn die Move-Action ausgelöst wird
    public void OnMove(InputAction.CallbackContext context)
    {
        // Liest den Vector2-Wert aus dem Input System
        // Er beschreibt die Bewegungsrichtung
        moveInput = context.ReadValue<Vector2>();
    }

    // Diese Methode wird aufgerufen, wenn die Jump-Action gedrückt wird
    public void OnJump(InputAction.CallbackContext context)
    {
        // Sicherstellen, dass die Action tatsächlich ausgeführt wurde
        // und nicht abgebrochen oder noch im Übergang ist
        if (!context.performed) return;

        // Als einfacher visueller Effekt
        // wird das Objekt um 90 Grad gedreht
        transform.Rotate(0f, 0f, 90f);
    }

    // Update wird einmal pro Frame aufgerufen
    void Update()
    {
        // Bewegt das Objekt in jedem Frame,
        // solange eine Bewegungsrichtung vorhanden ist
        transform.position +=
            (Vector3)(moveInput * moveSpeed * Time.deltaTime);
    }
}

💡 Was ist InputAction.CallbackContext?
Dies ist der „Ausführungskontext“ einer Action aus dem Input-Action-Asset. Unity stellt hier bereits aufbereitete Eingabedaten bereit — nicht eine konkrete Taste, sondern den Wert, der aus deinen Einstellungen (Action Type, Control Type und Bindings) resultiert.

Wie liest man die Daten?
Für wertbasierte Actions (Value) lesen wir die Daten mit ReadValue<T>() aus: zum Beispiel Vector2 für Bewegung (Move) oder float für eine Achse. Bei Buttons (Button) ist der exakte Wert meist weniger wichtig als der Auslösezeitpunkt — deshalb prüfen wir die Phase, zum Beispiel mit context.performed.

Beachte einen wichtigen Punkt: Die Methoden OnMove und OnJump bewegen das Objekt nicht in jedem Frame direkt. Sie aktualisieren lediglich den Eingabezustand oder reagieren auf ein Ereignis.

Die eigentliche Bewegung findet in Update() statt. Dieser Ansatz macht den Code klarer und vorhersehbarer: Die Eingabe vermittelt die Absicht des Spielers, während die Bewegungslogik separat verarbeitet wird.

💡 Dasselbe Prinzip wird auch in komplexeren Projekten verwendet: Das Input System kümmert sich um die Eingaben, und die Spielsysteme sind für das Verhalten verantwortlich.

Spielersteuerung mit Player Input einrichten

Zunächst erstellen wir ein einfaches Spielerobjekt. Füge der Szene ein Dreiecks-Sprite hinzu: GameObject → 2D Object → Sprite → Triangle. Es dient als anschauliches Beispiel für ein steuerbares Objekt.

Wähle das erstellte Objekt aus und füge ihm zwei Komponenten hinzu: Player Input und PlayerInputDemo.

Stelle in der Player Input-Komponente sicher, dass im Feld Actions das Asset PlayerControls eingetragen ist (oder wähle es manuell aus).

Setze das Feld Default Map auf Player. Dies ist der Name der Action Map, die wir im PlayerControls-Asset erstellt haben, und sie wird beim Start der Szene aktiv.

Setze die Option Behavior auf Invoke Unity Events. Dadurch lösen die Actions aus dem Input System entsprechende Events aus, die wir mit Skriptmethoden verknüpfen können.

Öffne den Abschnitt Events und anschließend die Gruppe Player. Darin siehst du zwei Events — Move und Jump — die den im PlayerControls-Asset definierten Actions entsprechen.

Füge im Event Move einen neuen Callback hinzu. Wähle als Zielobjekt das erstellte Dreiecksobjekt aus und als Methode OnMove aus dem PlayerInputDemo-Skript.

Wähle analog dazu im Event Jump dasselbe Objekt aus und weise die Methode OnJump aus dem PlayerInputDemo-Skript zu.

Wenn du die Szene nun startest, kannst du das Objekt mit den Bewegungstasten steuern und es durch Drücken von Space drehen.

Was man über das Input System verstehen sollte

In diesem Tutorial haben wir die grundlegenden Prinzipien von Unitys neuem Input System behandelt. In der Praxis bietet es deutlich mehr Möglichkeiten — Unterstützung für Gamepads, Tasten-Neubelegung, mehrere Steuerungskontexte und komplexe Eingabeszenarien. All das lässt sich je nach Bedarf schrittweise in einem konkreten Projekt einführen.

Zu Beginn ist es wichtig, sich eine zentrale Idee zu merken: Eingabe in Unity ist kein einzelner Vorgang, sondern eine Abfolge von Schritten.

1. Eingabedaten beschreiben.
   Zuerst legst du fest, welche Art von Daten dich interessiert: eine Taste, eine Zahl, ein Richtungsvektor usw. Dies wird über die Einstellungen Action Type und Control Type im Input-Action-Asset bestimmt.
2. Daten an den Code weitergeben.
   Anschließend übergibt Unity diese Daten auf die gewählte Weise an deinen Code — über Events (Invoke Unity Events), Messages oder direkte Callbacks. In diesem Schritt wird rohe Eingabe zu einem klaren Signal für die Spiellogik.
3. Daten verarbeiten.
   Erst danach entscheidest du, was mit der Eingabe geschehen soll: ein Objekt bewegen, eine Aktion auslösen, einen Zustand ändern oder die Daten an andere Spielsysteme weiterreichen.

Dieser Ansatz trennt die Verantwortlichkeiten klar: Das Input System ist für das Erfassen und Interpretieren der Eingaben zuständig, während der Spielcode das Verhalten der Objekte steuert. Dadurch werden Projekte flexibler und leichter verständlich — besonders mit wachsender Komplexität.

💡 Du musst nicht sofort alle Funktionen des Input Systems nutzen. Für Lernzwecke und einfache Tutorials reicht es aus, diese Abfolge von Schritten zu verstehen — alles Weitere kann ergänzt werden, wenn es wirklich erforderlich ist.

Direkte Eingabe mit dem Input System

Da Tutorials auf dieser Website häufig nicht der Reihe nach gelesen werden, würde das Einrichten von Input Actions für jedes Beispiel unnötige Vorbereitungszeit kosten. Zudem ist nicht garantiert, dass alle Leser in Unity dieselbe Eingabekonfiguration verwenden.

Aus diesem Grund verwenden wir häufig direkten Zugriff auf Eingabegeräte über das neue Input System, ohne zuvor Assets und Action Maps einzurichten.

Dieser Ansatz ist nicht besonders flexibel und für komplexe Projekte ungeeignet, er erfordert jedoch keinerlei Vorbereitung und ermöglicht es, sofort mit dem Erlernen von Spielmechaniken zu beginnen. Dadurch eignet er sich gut für einfache Beispiele und leichte Prototypen, einschließlich Lern-Tutorials.

Vom Prinzip her ähnelt diese Methode dem alten Input Manager: Wir fragen den Zustand von Tastatur und Maus direkt ab. In den meisten Fällen reichen zwei Bewegungsachsen und die Maus-Eingabe vollkommen aus.

Im nächsten Schritt sehen wir uns an, wie diese Art der Eingabe funktioniert und wie sie in einfachen Szenarien ohne zusätzliche Einrichtung genutzt werden kann.

Direkte Eingabe für die meisten Tutorials

In Lern-Tutorials beschränkt sich die Steuerung meist auf einen einfachen Satz von Eingaben: Bewegung mit WASD oder Pfeiltasten, eine einzelne Aktionstaste (meist Space), die Position des Mauszeigers sowie zwei Maustasten — links und rechts.

Für solche Szenarien ist es nicht notwendig, Input Actions, Action Maps oder zusätzliche Assets zu konfigurieren. Stattdessen kann direkt über das neue Input System auf die Eingabegeräte zugegriffen werden.

Vergiss nicht, den Namespace des neuen Input Systems einzubinden:

using UnityEngine.InputSystem;

Danach hast du direkten Zugriff auf Tastatur und Maus und kannst ihren Zustand im Code auslesen. Vom Prinzip her ähnelt dieser Ansatz dem alten Input Manager, nutzt jedoch eine moderne API und ist unabhängig von den Projekteinstellungen.

Unten findest du Beispielskripte für Bewegung, Tasten und Mausposition bei dieser Art der Eingabe. Dieser Funktionsumfang reicht für die meisten einfachen Prototypen und Lernbeispiele vollkommen aus.

💡 Direkte Eingabe eignet sich gut für Tutorials und schnelle Prototypen. Die flexibleren Möglichkeiten des Input Systems (Action Assets, Kontexte, Remapping) sollten erst dann eingesetzt werden, wenn das Projekt sie wirklich benötigt.

Direkte Eingabe: Tastatur und Maus

Unten siehst du Beispiele für direkte Eingabe über das neue Input System. Dieser Ansatz eignet sich für die meisten Tutorials und einfachen Prototypen, bei denen grundlegende Steuerung ohne vorherige Asset- Konfiguration benötigt wird.

Bewegung (WASD / Pfeiltasten)

Wir setzen die Bewegungsrichtung manuell zusammen, ähnlich wie früher bei den Achsen im alten Input Manager.

using UnityEngine.InputSystem;

float x = 0f;
float y = 0f;

if (Keyboard.current != null)
{
    if (Keyboard.current.aKey.isPressed || Keyboard.current.leftArrowKey.isPressed)
        x -= 1f;

    if (Keyboard.current.dKey.isPressed || Keyboard.current.rightArrowKey.isPressed)
        x += 1f;

    if (Keyboard.current.sKey.isPressed || Keyboard.current.downArrowKey.isPressed)
        y -= 1f;

    if (Keyboard.current.wKey.isPressed || Keyboard.current.upArrowKey.isPressed)
        y += 1f;
}

Vector2 move = new Vector2(x, y);

Mauszeigerposition

Auslesen der Cursorposition in Bildschirmkoordinaten.

using UnityEngine.InputSystem;

Vector2 mouseScreenPos = Mouse.current.position.ReadValue();

Falls nötig, können Bildschirmkoordinaten mithilfe der Kamera in Weltkoordinaten umgerechnet werden.

Vector3 mouseWorldPos =
    Camera.main.ScreenToWorldPoint(mouseScreenPos);

Maustasten

Abfrage von Klicks der linken und rechten Maustaste.

using UnityEngine.InputSystem;

if (Mouse.current != null)
{
    if (Mouse.current.leftButton.wasPressedThisFrame)
        Debug.Log("Linke Maustaste");

    if (Mouse.current.rightButton.wasPressedThisFrame)
        Debug.Log("Rechte Maustaste");
}

Leertaste (Aktionstaste)

Abfrage eines einzelnen Tastendrucks der Space-Taste.

using UnityEngine.InputSystem;

if (Keyboard.current != null &&
    Keyboard.current.spaceKey.wasPressedThisFrame)
{
    Debug.Log("Leertaste gedrückt");
}

Diese Beispiele decken die meisten Steuerungsszenarien in Lernprojekten ab. Die Spiellogik bleibt dabei einfach und übersichtlich, während die Eingabe ohne zusätzliche Einrichtung verarbeitet wird.

Zusammenfassung: Welchen Ansatz solltest du wählen?

Das Eingabesystem von Unity hat sich stark weiterentwickelt, und heute hängt die Wahl des подходs nicht davon ab, was „richtig“ oder „falsch“ ist, sondern vom Umfang und den Zielen deines Projekts.

In den meisten Lektionen auf dieser Website verwenden wir Direct Input — das direkte Abfragen von Tastatur und Maus. Dadurch sparen wir uns die Konfiguration von Assets in jedem Beispiel und können uns auf das Wesentliche konzentrieren: das Entwickeln von Spielmechaniken.

Wichtig ist: Es gibt keinen „richtigen“ oder „falschen“ Weg, mit Eingaben zu arbeiten. Entscheidend ist, den Ansatz zu wählen, der das Problem in der jeweiligen Situation effizient und ohne unnötige Komplexität löst.