So wird aus UI-Mockups ein spielbares, UI-gesteuertes Spiel

Entwickle mit KI aus UI-Mockups ein spielbares, UI-gesteuertes Spiel. Verknüpfe die entworfenen Ansichten mit Spielzustand, Eingaben und einem vollständigen Spielablauf.

Seele Editorial TeamAktualisiert 16. November 2026

Ein ausgearbeitetes Mockup einer Spieloberfläche kann zeigen, wo eine Schaltfläche sitzt, ohne zu zeigen, was sie auslöst. Damit die Oberfläche spielbar wird, braucht jede Ansicht einen Zweck, jedes Bedienelement eine Aktion und jede Aktion eine Reaktion des Spiels. Ein brauchbarer Prototyp verbindet das visuelle Design mit dem tatsächlichen Spielzustand und ermöglicht es, eine kleine Aufgabe abzuschließen.

Dieser Leitfaden verwendet das fiktive Taktikspiel Lantern Guild als Beispiel. Seine Ansichten, sein Held, seine Ressourcen, Aktionen und Ergebnisse sind frei erfunden. Es wurden weder eine UI-Quelldatei noch ein Spielprojekt bereitgestellt oder getestet.

Die erste spielbare Aufgabe festlegen

Wähle eine Aufgabe, bei der Oberfläche und Spielablauf zusammenspielen. Öffne zum Beispiel die Gruppenansicht, wähle eine Späherfähigkeit, gib einen Fokuspunkt aus und beobachte, wie ein versperrter Weg in der Spielwelt sichtbar wird. In diesem fiktiven Beispiel ist damit klar, welches Ergebnis die Oberfläche ermöglichen soll. Stimme bei einer realen Funktion die Aktion und das gewünschte Ergebnis mit den Verantwortlichen für Design und Gameplay ab.

Halte den Ausgangszustand, die Spieleraktion, die Voraussetzungen, den resultierenden Zustand und die Rückmeldung fest. Ein Ansichtswechsel allein ergibt noch keinen Spielablauf. Wer spielt, sollte erkennen können, was sich geändert hat, ob die Aktion erfolgreich war und was als Nächstes zu tun ist.

Aus Mockups einer Spieloberfläche entsteht eine spielbare Fähigkeitsauswahl mit sichtbarer Rückmeldung.
Der erste Prototyp soll zeigen, dass eine Interaktion von der Eingabe bis zum sichtbaren Ergebnis funktioniert.

Ansichten und Zustände erfassen

Liste die bereitgestellten Ansichten mit ihrem jeweiligen Zweck auf, etwa Start, Inventar, Karte, Einstellungen, Dialog oder Ergebnisanzeige. Halte für jede Ansicht fest, wie man sie öffnet und verlässt, welche Bedienelemente sie enthält und welche Daten sie anzeigt. Kennzeichne offene Fragen, ohne das Verhalten zu erraten. Ein Screenshot zeigt selten, ob ein Bedienelement immer verfügbar ist, was bei einem leeren Wert passiert oder wie die Ansicht auf eine Aktion reagiert.

Liste für jede Ansicht die möglichen Zustände auf. Elemente können sich im Normalzustand befinden, ausgewählt, fokussiert oder deaktiviert sein. Hinzu kommen Lade-, Fehler-, Leer-, Erfolgs- und Bestätigungszustände. Welche Zustände nötig sind, hängt von der Ansicht ab. Ermittle die relevanten Zustände, bevor du dich bei der Gestaltung allein auf den Idealfall konzentrierst. Bei einer deaktivierten Aktion sollte die Oberfläche den Grund anzeigen, wenn diese Information bei der Entscheidung hilft.

Erstelle eine Übersicht der Übergänge. Notiere, wodurch sich die Ansicht öffnet, mit welcher Aktion man sie verlässt, welcher Zustand sich ändert, ob das Spiel pausiert und wo der Fokus landet, wenn die nächste Ansicht erscheint. So haben Design und Entwicklung eine gemeinsame Checkliste und können früh erkennen, wo eine Möglichkeit zum Verlassen einer Ansicht fehlt.

Bedienelemente mit der Spiellogik verknüpfen

Lege für jedes Bedienelement fest, welche Aktion es auslöst und wer dafür zuständig ist. Eine Schaltfläche kann den Einsatz einer Fähigkeit anfordern, einen Kauf bestätigen, einen Gegenstand ausrüsten oder einen anderen Bereich öffnen. Definiere die Prüfregeln, etwa für Ressourcenkosten, Inventarkapazität, den aktuellen Spielzug und die Berechtigung, die Aktion auszuführen. Lege anschließend fest, welches System den verbindlichen Zustand verwaltet. Die Oberfläche soll den Spielzustand anzeigen. Eine unbemerkt geführte zweite, unabhängige Kopie könnte davon abweichen.

In Unity UI Toolkit stellt ein Button den Callback clicked bereit und unterstützt Bindungsinformationen. Zum UI Toolkit gehören außerdem eine Laufzeit-UI, ein Ereignissystem und Funktionen zur Datenbindung. Diese Funktionen stellt das Framework bereit. Der Spielablauf muss im Projekt umgesetzt werden. Dazu muss das Projekt das Ereignis mit der Spiellogik verbinden, die die Aktion prüft, und den resultierenden Zustand in der Oberfläche anzeigen.

Trenne Anfrage, Ergebnis und Anzeige. Klickt jemand auf „Fähigkeit einsetzen“, kann die Oberfläche eine Aktionsanfrage senden. Die Spiellogik prüft den aktuellen Spielzug und die verfügbare Ressource. Das Ergebnis aktualisiert das Zustandsmodell und die Ansicht zeigt die entsprechende Rückmeldung an. So lässt sich vermeiden, dass die Schaltfläche bereits einen Punkt als ausgegeben anzeigt, bevor das Spiel die Aktion akzeptiert hat.

Die Zustände der Spieloberfläche verbinden Eingaben mit der Spiellogik und der Rückmeldung im Spiel.
Mach den Weg vom Eingabeereignis über die geprüfte Zustandsänderung bis zur sichtbaren Rückmeldung nachvollziehbar.

Eingaben über den Mausklick hinaus einplanen

Kläre, welche Eingabemethoden das Spiel unterstützt. Je nachdem, ob Mauszeiger, Touch-Oberfläche, Tastatur oder Gamepad zum Einsatz kommen, kann die Navigation zwischen Bedienelementen unterschiedlich funktionieren. Lege die Fokusreihenfolge fest und definiere, wie ausgewählte Elemente aussehen. Beim Öffnen einer Ansicht sollte der Fokus an einer sinnvollen Stelle landen. Beim Schließen sollte er zu einem passenden Bedienelement zurückkehren.

Teste, was passiert, wenn jemand eine Aktion zweimal auslöst, während eines Übergangs die Zurück-Taste drückt oder die Ansicht wechselt, während das Ergebnis noch aktualisiert wird. Verhindere doppelte Käufe oder einen wiederholten Einsatz von Fähigkeiten in der Spiellogik. Die Schaltfläche kurz auszublenden reicht dafür allein nicht aus. Hebe nicht verfügbare Aktionen visuell ab und stelle sicher, dass der Fokus nicht auf einem Element außerhalb des sichtbaren Bereichs landet.

Im fiktiven Lantern Guild springt der Fokus beim Öffnen der Karte zur aktuellen Region. Richtungseingaben wechseln zwischen Markierungen, und eine Bestätigung zeigt eine Routenvorschau an. Diese Details dienen als Beispiele. Das tatsächliche Verhalten muss den Eingabekonventionen und Barrierefreiheitszielen des Projekts entsprechen.

Rückmeldungen und Wege zum Fortfahren gestalten

Jede wichtige Aktion braucht eine verständliche Rückmeldung. Das kann ein geänderter Wert, eine Animation, ein aktualisiertes Objekt in der Spielwelt, ein Ton, eine kurze Meldung oder eine Kombination mehrerer Signale sein. Eine Klickanimation zeigt lediglich, dass die Schaltfläche die Eingabe registriert hat. Ob die angeforderte Aktion erfolgreich war, bleibt dabei offen.

Gestalte Fehlerzustände und zeige, wie es danach weitergeht. Fehlt eine Ressource, erkläre die Voraussetzung oder zeige die entsprechenden Kosten an. Solange ein Netzwerk- oder Speichervorgang läuft, zeige den Fortschritt an und verhindere, dass die Anfrage versehentlich erneut gesendet wird. Sind keine Gegenstände verfügbar, zeige eine leere Ansicht mit einem Hinweis darauf, was als Nächstes möglich ist. Verwende für diese Zustände dieselbe Informationshierarchie und Bildsprache wie in der normalen Ansicht.

Formuliere knapp und verwende die Begriffe des Spiels einheitlich. Wenn eine Ressource im HUD anders heißt als in der Fähigkeitsansicht, könnten Spielende annehmen, dass sich die Werte auf unterschiedliche Dinge beziehen. Teste kurze Beschriftungen im kleinsten unterstützten Anzeigebereich und auch mit lokalisierten Texten, falls die Funktion später übersetzt wird.

Einen Prototyp mit Fokus auf das Verhalten bauen

Verbinde eine Ansicht mit einem repräsentativen Spielzustand und implementiere eine vollständige Aktion. Verwende bei Bedarf Platzhaltergrafiken. Halte Größe und Hierarchie der Komponenten nah genug am freigegebenen Design, damit Layoutprobleme auffallen. Setze den Erfolgsfall und mindestens einen relevanten Fehlerfall um. Prüfe die sichtbaren Auswirkungen der Aktion sowohl in der Oberfläche als auch in der Spielwelt.

Halte in einer kleinen Tabelle fest, wie die Bedienelemente einer Ansicht den Spielzustand beeinflussen. Erfasse dazu den Namen des Bedienelements, das Ereignis, die Voraussetzung, die Zustandsänderung, die Rückmeldung und den Weg zum Fortfahren. Dokumentiere Abweichungen vom freigegebenen Mockup und lass Änderungen von der designverantwortlichen Person bestätigen. Wenn KI Beschriftungen, Komponentencode oder aus den Ansichten abgeleitete Interaktionen vorschlägt, halte die Vorschläge so fest, dass sie überprüfbar und den jeweiligen Ansichten zuzuordnen sind.

Eine Person testet eine fiktive Spieloberfläche mit Controller und Tastatur.
Beobachte im laufenden Prototyp, wie Eingaben verarbeitet werden, wohin sich der Fokus bewegt, wie sich Zustände ändern und wie es nach einem Fehler weitergeht.

Eine Aufgabe von Anfang bis Ende testen

Gib einer Person, die die Funktion zum ersten Mal testet, ein Ziel, ohne ihr zu sagen, wohin sie klicken soll. Beobachte, ob sie die Aktion findet, ihre Voraussetzung versteht, das Ergebnis erkennt und zum Spiel zurückkehren kann. Teste die unterstützten Eingabemethoden, Seitenverhältnisse und relevanten Zustandsvarianten. Erfasse Build-Version, Gerät, Ausgangszustand, Eingabemethode, beobachtetes Verhalten und Abweichungen vom Mockup.

Vergleiche das beobachtete Verhalten mit dem freigegebenen Design und der vorgesehenen Spielregel. Sah das Bedienelement aktiv aus, obwohl es deaktiviert war? Wanderte der Fokus in eine unerwartete Richtung? Zeigte die Ansicht bereits einen Erfolg an, bevor das Spiel die Aktion akzeptiert hatte? Solche Beobachtungen liefern konkretere Ansatzpunkte als der allgemeine Kommentar, die Oberfläche „fühlt sich irgendwie falsch an“.

Teste nach Änderungen an der Zustandslogik, am Layout oder an der Eingabeverarbeitung erneut. Ein neuer Bereich kann verhindern, dass der Fokus zurückkehrt. Eine überarbeitete Regel kann ändern, unter welchen Bedingungen eine Aktion deaktiviert ist. Ein anderer Anzeigebereich kann Rückmeldungen verdecken. Mockups helfen, das gewünschte Verhalten abzustimmen. Erst der laufende Prototyp zeigt, wie sich die Oberfläche tatsächlich verhält.

Vom Mockup zum vollständigen Spielablauf

Beginne mit einer Aufgabe für die Spielenden und einem klaren Zustandsübergang. Erfasse jede Ansicht, definiere ihre Zustände, verknüpfe die Bedienelemente mit der Spiellogik, die den verbindlichen Zustand verwaltet, und zeige an, was passiert und wie es nach einem Fehler weitergeht. Beobachte dann, wie jemand die Aufgabe im laufenden Prototyp abschließt, und vergleiche das Ergebnis mit dem freigegebenen Design. Erweitere die Oberfläche erst, wenn der erste Ablauf verständlich ist und zuverlässig funktioniert.

Häufig gestellte Fragen

Wie mache ich aus einem UI-Mockup eine spielbare Spieloberfläche?

Halte für jede Ansicht ihren Zweck, ihre Bedienelemente, die sichtbaren Zustände und die Übergänge fest. Verbinde dann eine Ansicht mit dem tatsächlichen Spielzustand und einer kleinen Spieleraktion. Baue einen Prototyp mit funktionierender Eingabe, Rückmeldungen, deaktivierten Zuständen, Fehlerzuständen und einem Weg zurück. Vergleiche das Verhalten im laufenden Prototyp mit dem freigegebenen Mockup und teste es je nach Spiel mit Maus, Tastatur oder Controller.

Kann KI aus UI-Mockups ein Spiel machen?

KI kann die Inhalte von Ansichten zusammenfassen, Interaktionsabläufe vorschlagen, Platzhalter-Assets erzeugen oder Komponentencode entwerfen. Sie kann weder alle verborgenen Zustände ableiten noch nachweisen, dass ein Bedienelement auf dem Zielgerät verständlich ist. Prüfe die von der KI abgeleiteten Annahmen mit der designverantwortlichen Person, verbinde die Bedienelemente mit dem tatsächlichen Spielzustand und teste Fokus, Eingabe, Rückmeldungen und Navigation in einem laufenden Build.

Wie verknüpfe ich eine Schaltfläche der Spieloberfläche mit dem Gameplay?

Definiere die Aktion und ihre Voraussetzungen, verknüpfe die Schaltfläche mit einem Event-Handler, aktualisiere den verbindlichen Spielzustand und zeige das Ergebnis klar an. Verhindere doppelte oder ungültige Aktionen und aktualisiere die Anzeige, wenn sich der zugrunde liegende Wert ändert. In Unity UI Toolkit stellt Button den Callback clicked bereit. Die Wirkung im Spiel muss der Projektcode umsetzen.

Was sollte ein spielbarer UI-Prototyp enthalten?

Setze mindestens einen vollständigen Ablauf um, bei dem man eine Ansicht öffnet, den aktuellen Zustand prüft, eine Aktion ausführt, eine Rückmeldung erhält und weiterspielen oder nach einem Fehler fortfahren kann. Ergänze bei Bedarf deaktivierte Zustände sowie Fehler-, Leer- und Erfolgszustände. Prüfe, wie sich die Oberfläche im vorgesehenen Seitenverhältnis und mit jeder unterstützten Eingabemethode verhält. Ein statisches Bild kann diese Übergänge nicht zeigen.

Wie teste ich eine Spieloberfläche, die auf Mockups basiert?

Verwende einen Build mit einem repräsentativen Spielzustand und bitte jemanden, der die Funktion noch nicht kennt, eine kurze Aufgabe abzuschließen. Achte auf die Fokusreihenfolge, die Rückmeldungen der Schaltflächen, Zustandsänderungen und missverständliche Beschriftungen. Beobachte auch, ob die Person nach einer ungültigen Aktion fortfahren kann. Vergleiche das Verhalten mit dem freigegebenen Design, dokumentiere die Geräte- und Build-Versionen und teste nach Änderungen erneut.

SEELE AI

Mach aus diesem Leitfaden ein spielbares Projekt.

Beginne mit einem klaren Briefing und entwickle es im Seele AI Workspace weiter.

Jetzt erstellen