Aus Spielregeln in einer Tabelle einen datengetriebenen Spielprototyp entwickeln

Erstelle mit KI aus Spielregeln in einer Tabelle einen spielbaren, datengetriebenen Prototyp. Ordne die Quelldaten den Spielsystemen zu und überprüfe einen klar abgegrenzten Spielablauf.

Seele Editorial TeamAktualisiert 16. November 2026

Eine Tabelle kann weit mehr als Notizen zum Balancing enthalten. Sie kann Figuren, Gegenstände, Begegnungen, Upgrades oder Bedingungen beschreiben, die festlegen, was nach einer Spieleraktion passiert. Damit aus diesen Zeilen ein Spielprototyp wird, musst du sie gezielt übertragen. Für jede Angabe muss klar sein, was sie bedeutet, wo sie zur Laufzeit verwendet wird und woran sich erkennen lässt, dass die Regel wie vorgesehen wirkt.

Als Beispiel dient Ember Circuit, ein fiktives rundenbasiertes Erkundungsspiel. Figuren, Tabelle, Regeln, Implementierung und Ergebnisse sind frei erfunden. Es wurden weder eine Quelltabelle noch Projektdateien oder ein spielbarer Build bereitgestellt oder getestet.

Wähle eine Frage, die sich im Spiel prüfen lässt

Beginne mit einer Frage, die der Prototyp beantworten soll, etwa: „Wenn der Scan eines Raums eine Energieeinheit kostet, wird dabei eine Route sichtbar, bevor die Gefahr voranschreitet?“ Das lässt sich leichter prüfen als „Können wir die gesamte Designtabelle umwandeln?“ Wähle die wenigen Zeilen aus, die du für einen Ausgangszustand, eine Spieleraktion, eine regelbedingte Zustandsänderung und eine sichtbare Rückmeldung brauchst.

Beschreibe in einfachen Worten, wie der Zustand vor und nach der Aktion aussehen soll. In der fiktiven Tabelle zu Ember Circuit beginnt ein Kundschafter mit drei Ladungseinheiten, ein Scan kostet eine Einheit, und ein erfolgreicher Scan enthüllt das Symbol einer versiegelten Tür. Die Zahlen und der Ablauf dienen nur als Beispiele. In einem echten Projekt sollte der Game Designer beides bestätigen, bevor daraus Code oder Spielinhalte entstehen.

Aus Spielregeln in einer Tabelle entsteht eine fiktive, spielbare und datengetriebene Begegnung.
Beginne mit einem kurzen Spielablauf, bei dem sich die Quelldaten mit dem Ergebnis für den Spieler abgleichen lassen.

Behandle die Tabelle als Datenquelle

Erfasse die Tabellenblätter und halte fest, wozu jedes dient. Ein Blatt namens „Items“ kann Gegenstandsdefinitionen, Preise im Shop und Freischaltungen im Spielverlauf enthalten. Eine Spalte namens „Power“ kann an einer Stelle den Schaden und an einer anderen die Herstellungsstufe bezeichnen. Geh nicht davon aus, dass Beschriftungen, Farben, Formeln oder verbundene Zellen eine verlässliche Vorgabe für die Verarbeitung zur Laufzeit bilden.

Kläre für jedes Feld, das der Prototyp braucht, wer dafür verantwortlich ist und welchen Datentyp es hat: Textkennung, Ganzzahl, Dezimalzahl, boolescher Wert, Kategorie oder Verweis auf eine andere Zeile. Halte fest, ob das Feld Pflicht ist, ob Duplikate zulässig sind und was eine leere Zelle bedeutet. Wenn eine Spalte mehrere Bedeutungen hat oder Freitext enthält, sollte die für die Regeln zuständige Person die Mehrdeutigkeit klären, bevor du dich auf die Spalte stützt.

Erstelle eine kompakte Zuordnungstabelle. Halte für jedes Quellblatt und jede Quellspalte fest, welches Spielkonzept und welche Validierungsregel dazugehören und welcher Teil des Spiels die Daten zur Laufzeit verwendet. Eine Zeilenkennung könnte zur stabilen Gegenstands-ID werden. Ein Wert aus „cost“ könnte in die Prüfung einfließen, ob die Ressourcen für eine Aktion ausreichen. Eine Kategorie aus „result“ könnte bestimmen, welcher Zustandsübergang stattfindet. Erkläre in der Zuordnung, wie diese Elemente zusammenhängen. Die Spaltennamen einfach als Variablennamen zu übernehmen, reicht dafür nicht aus.

Lege den Datenvertrag vor der Codegenerierung fest

Lege für jeden Zeilentyp fest, welche Felder mindestens vorhanden sein müssen. Eine fiktive Begegnung könnte beispielsweise eine ID, einen Startwert für die Energie, eine Aktions-ID, Energiekosten, einen Folgezustand und eine Rückmeldung enthalten. Trenne Definitionen vom aktuellen Spielzustand. In der Quelltabelle kann stehen, dass ein Scan eine Energieeinheit kostet. Der Spielerzustand zur Laufzeit hält fest, ob dieser Spieler den Raum bereits gescannt hat.

Stabile IDs sind wichtiger als die Position einer Zeile. Wenn eine andere Zeile auf „den dritten Gegenstand“ verweist, kann das Sortieren der Tabelle den Verweis ungültig machen. Verwende beispielsweise item_crystal_lantern als Referenz und prüfe, ob es für jeden Verweis einen passenden Eintrag gibt. Vermeide Anzeigenamen als Kennungen, wenn die Namen übersetzt oder bearbeitet werden können.

KI kann ein Schema vorschlagen oder wahrscheinliche Abhängigkeiten zusammenfassen. Solche Vorschläge bleiben Annahmen. Lass mehrdeutige Formeln, Einheiten, Stapelregeln und die Reihenfolge vom Game Designer bestätigen. Dokumentiere, aus welcher Version der Tabelle die Daten stammen, damit sich jeder generierte oder importierte Wert bei der Prüfung zurückverfolgen lässt.

Importiere und validiere eine kleine Stichprobe

Die Unity-Dokumentation führt CSV und JSON unter den Formaten auf, die als Text Assets importiert werden und deren Text der Projektcode lesen kann. Der Import allein legt die Bedeutung der Spalten nicht fest. Das Spiel braucht weiterhin einen Parser und explizite Prüfungen. Je nach Projekt kann sich das Team für einen anderen Umgang mit den Daten entscheiden. Prüfe den gewählten Weg in der tatsächlich verwendeten Engine und Build-Umgebung.

Prüfe vor der Verwendung im Prototyp Pflichtfelder, doppelte IDs, Zahlenbereiche, unbekannte Kategorien, fehlende Referenzen und fehlerhaft formatierte Zeilen. Gib eine aussagekräftige Fehlermeldung aus, die Zeile und Feld nennt. Eine Meldung wie „Ungültige Daten“ mag einen Absturz verhindern, hilft dem Game Designer bei der Korrektur der Tabelle aber kaum. Ersetze einen fehlenden Schadenswert nicht stillschweigend durch null. Wenn null als Ersatzwert vorgesehen ist, muss das erkennbar sein.

Teste den Parser nach Möglichkeit getrennt vom Spielablauf. Gib ihm eine gültige Zeile und bewusst ungültige Beispiele: eine leere Kennung, negative Kosten, eine unbekannte Aktion, eine doppelte ID oder einen Verweis auf eine nicht vorhandene Tür. Solche Fehler sollen bereits bei der Eingabe auffallen, bevor sie später eine Begegnung im Spiel zum Scheitern bringen.

Tabellenzeilen werden validiert und fließen in Spielregeln und Rückmeldungen an den Spieler ein.
Ein klarer Datenvertrag verbindet die Quellspalten mit dem Verhalten zur Laufzeit und einem für den Spieler sichtbaren Ergebnis.

Verknüpfe die Daten mit einem sichtbaren Spielablauf

Halte den ersten Ablauf im Spiel bewusst klein. Lade den Ausgangszustand, biete die Aktion an, prüfe ihre Bedingungen, ziehe die Kosten ab, aktualisiere den Zustand der Spielwelt und zeige die Änderung an. Wenn ein Scan ein Türsymbol enthüllen soll, braucht der Spieler eine sichtbare Rückmeldung, etwa eine Änderung auf der Karte, ein neues Objekt, mit dem er interagieren kann, oder eine kurze Meldung. Dass sich eine Zahl im Speicher ändert, zeigt noch nicht, ob die Regel verständlich ist.

Lege fest, welche Datenquelle maßgeblich ist. Ist es die Tabelle, oder bearbeiten die Game Designer Ressourcen im nativen Format der Engine und exportieren sie anschließend in die Tabelle? Wenn sich zwei Kopien unabhängig voneinander bearbeiten lassen, werden sie irgendwann voneinander abweichen. Entscheide dich für eine Richtung und dokumentiere den Import- oder Exportschritt.

Mache jede wichtige Regel überprüfbar. In einem rundenbasierten Prototyp könnte ein Protokoll den aktuellen Energiestand, die Aktionskosten, das Ergebnis der Bedingungsprüfung, den Zustandsübergang und die ID der Rückmeldung anzeigen. So lässt sich das beobachtete Verhalten leichter mit dem erwarteten Verhalten aus der Quellzeile abgleichen. Das Protokoll hilft bei der Prüfung auch dann, wenn die Regel den falschen Zweig nimmt.

Teste Normalfälle und Grenzfälle

Halte vor dem Test des Prototyps die erwarteten Ergebnisse fest. Berücksichtige einen normalen Erfolgsfall, einen Fehlschlag wegen einer fehlenden Ressource und einen Grenzfall, bei dem die Energie beispielsweise gerade für die Aktion reicht. Wenn der Parser Teil der Änderung ist, ergänze einen Testfall mit fehlenden oder ungültigen Daten. Jeder Test sollte auf eine stabile Eingabezeile oder dokumentierte Testdaten zurückführbar sein.

Vergleiche den tatsächlichen Zustand und die sichtbare Rückmeldung mit dem erwarteten Ergebnis. Dokumentiere die Version der Quelle, die Build-Version, den Eingabefall, die beobachtete Ausgabe und etwaige Abweichungen. Wenn sich die Tabelle ändert, passe die erwarteten Ergebnisse gezielt an. Eine neuere Tabelle ist nicht automatisch die richtige.

Bitte jemanden, den Ablauf zu spielen, der die Regel nicht selbst umgesetzt hat. Kann die Person erkennen, warum die Aktion erfolgreich war oder fehlgeschlagen ist? Passt die sichtbare Rückmeldung zum tatsächlichen Spielzustand? Damit prüfst du gezielt die Verständlichkeit. Eine umfassendere Prüfung des Balancings oder der Barrierefreiheit bleibt eine eigene Aufgabe.

Ein Entwickler gleicht einen kleinen datengetriebenen Spielprototyp mit Testfällen aus der Datenquelle ab.
Halte zu jedem Testergebnis kurz fest, welche Eingabedaten und welche Datenversion verwendet wurden.

Nutze KI als Hilfe und prüfe ihre Ergebnisse

KI kann Spalten zusammenfassen, wahrscheinliche Referenzen erkennen, Validierungsregeln entwerfen, einen beispielhaften Parser skizzieren oder vorläufige visuelle Konzepte erstellen. Offene Fragen zur Bedeutung von Spielregeln sollte sie nicht entscheiden. Eine Formel kann eine beabsichtigte Ausnahme enthalten, eine leere Zelle kann „Wert erben“ bedeuten, und die Einheit eines Werts ist möglicherweise nur an anderer Stelle dokumentiert.

Lass jede generierte Zuordnung prüfen und eine repräsentative Stichprobe mit der Quelle vergleichen. Versioniere Eingaben und Ausgaben gemeinsam. Wenn sich eine Zuordnung ändert, führe die davon abhängigen Validierungstests erneut aus. So bleibt nachvollziehbar, wie der Import zustande kam und welche Prüfungen durchgeführt wurden.

Erweitere den Prototyp, sobald der erste Ablauf zuverlässig funktioniert

Sobald ein datenbasierter Spielablauf wie erwartet funktioniert, füge weitere Zeilen in kleinen Gruppen hinzu. Halte die Validierung der Inhalte sichtbar, behalte stabile IDs bei und setze automatisierte Prüfungen ein, wo das Projekt sie unterstützt. Wenn du ein ganzes Tabellenblatt auf einmal importierst, kann es unnötig schwierig werden, einen fehlerhaften Wert oder eine widersprüchliche Regel aufzuspüren.

Tabellendaten verbinden Spieldesign und Prototyp, wenn ihre Bedeutung eindeutig ist und sich ihre Auswirkungen überprüfen lassen. Beginne mit einer Frage zum Spiel, lege den Datenvertrag fest, validiere die Daten und gleiche den laufenden Spielablauf mit den Fällen aus der Quelle ab. Mehr zum Einsatz von KI in der Spieleentwicklung findest du in diesen Praxishinweisen zum Arbeitsablauf.

Häufig gestellte Fragen

Wie mache ich aus Regeln in einer Tabelle einen spielbaren Prototyp?

Gliedere die Tabelle nach Entitäten, Aktionen, Bedingungen, Effekten und Spielfortschritt. Weise jeder wichtigen Spalte eine klar definierte Aufgabe zur Laufzeit zu. Importiere eine kleine Stichprobe, prüfe Pflichtwerte und Referenzen und baue einen kurzen Spielablauf mit einem Erfolgs- und einem Fehlerfall. Vergleiche das Verhalten im laufenden Spiel mit den Quellzeilen, bevor du weitere Inhalte hinzufügst oder den Prototyp als korrekt einstufst.

Kann KI aus einer Tabelle ein Spiel erstellen?

KI kann Spalten erklären, wahrscheinliche Zusammenhänge erkennen, ein Datenschema entwerfen oder einen kleinen Prototyp vorschlagen. Ohne Projektkontext und Tests kann sie nicht wissen, ob eine mehrdeutige Formel die beabsichtigte Regel ausdrückt oder ob sich importierte Daten wie vorgesehen verhalten. Bewahre eine Kopie der Quelle auf, prüfe die generierten Zuordnungen und teste repräsentative Grenzfälle im laufenden Spiel.

Sollte ich Spielregeln in CSV oder JSON speichern?

Wähle das Format danach, wie das Team Daten bearbeitet, validiert und lädt. Unity importiert CSV- und JSON-Dateien als Text Assets, deren Text für den Projektcode zugänglich ist. Die Anwendung braucht weiterhin Logik zum Einlesen und Validieren. Ein strukturiertes Format kann verschachtelte Objekte direkter abbilden. CSV kann für zeilenbasierte Inhalte praktisch sein. Teste den gewählten Weg in der Ziel-Engine und im Build.

Wie verhindere ich Fehler durch Tabellendaten im Spiel?

Definiere vor dem Import Pflichtspalten, zulässige Wertebereiche, eindeutige Kennungen und Regeln für Referenzen. Prüfe auf leere Zellen, doppelte IDs, unbekannte Kategorien, ungültige Formeln und fehlende Referenzen. Gib für jedes Problem die Zeile und Spalte an. Brich das Laden ab oder nutze einen bewusst festgelegten Ersatzwert, damit sich die Regel nicht unbemerkt ändert. Halte die Versionen der Quelle und der importierten Daten für die Prüfung zusammen.

Wie viele Tabelleninhalte sollte ein Prototyp verwenden?

Verwende nur so viele Zeilen, wie du brauchst, um einen aussagekräftigen Spielablauf zu prüfen. Dazu gehören ein Ausgangszustand, eine Spielerentscheidung, ein geänderter Spielzustand und ein sichtbares Ergebnis. Berücksichtige einen Normalfall und einen Grenzfall, etwa einen fehlenden Wert oder einen Maximalwert. Bei einer kleinen Stichprobe lassen sich die Daten leichter zur Quelle zurückverfolgen. Füge weitere Inhalte hinzu, sobald klar ist, wie die Daten verarbeitet werden und wie sich die Regeln im Spiel auswirken.

SEELE AI

Mach aus diesem Leitfaden ein spielbares Projekt.

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

Jetzt erstellen