Die Idee klingt verrückt: Aus einem Softwareprojekt ein funktionierendes Roguelike-Spiel machen – und das direkt in der Konsole. Doch genau das gelang einem Entwickler mit GitHub Dungeons, einer experimentellen Erweiterung für die GitHub Command Line. Das Projekt nutzt procedurale Generation, um aus dem Inhalt eines Repositories einen Dungeon zu erschaffen, der sich mit jedem Commit verändert. Doch wie genau entsteht aus Code ein spielbares Abenteuer?
Ein Spiel aus dem Nichts – dank künstlicher Intelligenz
Alles begann mit einer einfachen, aber ungewöhnlichen Idee: Ein Entwickler wollte einen GitHub CLI Befehl in Go erstellen, der ein Repository in ein Roguelike-Dungeon verwandelt. Der Auslöser war ein Wettbewerb der GitHub Copilot CLI Challenge, bei dem Teilnehmende kreative Lösungen für die Kommandozeile entwickeln sollten. Mit dem Befehl /yolo – einem Alias für /allow-all – startete der Entwickler das Projekt. Das Ergebnis war GitHub Dungeons, ein terminalbasiertes Spiel, das sich mit jedem Commit neu generiert.
Das Spielprinzip ist simpel: Der Spieler bewegt sich durch einen Dungeon, kämpft gegen „Bugs“ (Fehler) und sucht den Ausgang. Jeder Repository-Inhalt wird dabei in Räume, Korridore und Gegner umgewandelt. Fällt die Gesundheit auf null, beginnt das Spiel von Neuem – ein klassisches Merkmal von Roguelikes. Doch was dieses Projekt besonders macht, ist die Verbindung zwischen Softwareentwicklung und Spielmechanik.
Procedurale Generation: Wenn Code zu Dungeons wird
Procedurale Generation (auch „ProcGen“ genannt) ist eine Technik, bei der Inhalte wie Levels, Karten oder Gegner algorithmisch erzeugt werden. Statt einen Dungeon manuell zu gestalten, definiert man Regeln, die zufällige, aber konsistente Strukturen erzeugen. Genau das macht Roguelikes so reizvoll: Jeder Spielablauf ist einzigartig.
In GitHub Dungeons wird diese Technik genutzt, um aus dem Repository-Inhalt eine dynamische Spielwelt zu formen. Der Schlüssel liegt in der Seed-Generierung: Der Dungeon wird durch den Hash des letzten Commits deterministisch berechnet. Das bedeutet:
- Gleiche Commits erzeugen gleiche Dungeons
- Unterschiedliche Repositories führen zu strukturell verschiedenen Karten
- Jede Code-Änderung passt den Dungeon an
Diese Methode sorgt für eine enge Verbindung zwischen Softwareentwicklung und Spielgeschehen. Entwickler können ihren Code nicht nur verbessern, sondern auch spielerisch erkunden – quasi als interaktive Dokumentation.
Wie die Magie funktioniert: Binary Space Partitioning
Im Kern steht eine Technik namens Binary Space Partitioning (BSP), die Räume in kleinere Abschnitte unterteilt, bis eine strukturierte Dungeon-Karte entsteht. BSP ist besonders gut für Roguelikes geeignet, weil es:
- Strukturierte, aber zufällige Layouts erzeugt
- Effizient berechnet werden kann
- Flexibel anpassbar ist (z. B. für verschiedene Raumgrößen)
Der Prozess beginnt mit einem großen Rechteck, das schrittweise in kleinere Rechtecke unterteilt wird. Diese werden dann zu Räumen oder Korridoren verbunden. Das Ergebnis ist ein Dungeon, der sich natürlich anfühlt, aber dennoch jedes Mal anders aussieht.
Ein Beispiel für BSP in Aktion:
Ausgangsfläche:
+---------------------+
| |
| |
| |
+---------------------+
Nach erster Teilung:
+-----------+-----------+
| | |
| | |
| | |
+-----------+-----------+
Nach weiterer Teilung:
+-----+-----+-----+-----+
| | | | |
| | | | |
| | | | |
+-----+-----+-----+-----+Jeder dieser Abschnitte kann später als Raum oder Korridor genutzt werden. BSP sorgt dafür, dass der Dungeon eine klare Struktur hat, aber dennoch Überraschungen bietet.
Mit Copilot CLI: Vom Konzept zur Umsetzung
Der wahre Clou an diesem Projekt ist der Einsatz von GitHub Copilot CLI. Anstatt den gesamten Code manuell zu schreiben, beschrieb der Entwickler die gewünschten Funktionen in natürlicher Sprache und überließ die Umsetzung dem KI-Assistenten. Ein besonders nützliches Feature war der Befehl /delegate, der Aufgaben an Copilot übertrug, um sie asynchron auszuführen.
Ein Beispiel: Der Entwickler forderte Copilot auf, die Levels mit jeder Etage schwieriger zu gestalten. Das Ergebnis war ein Pull Request, der zusätzliche Gegner und Heiltränke einführte – eine typische Roguelike-Mechanik. Auch Easter Eggs wie unsichtbare Wände oder versteckte Räume wurden so implementiert.
Ein weiteres Highlight war die Erstellung eines „Dungeon Scribe“, einer KI-Agentur, die automatisch Dokumentation und ASCII-Kunst generierte, um die Dungeon-Generierung zu erklären. Diese Art von Automatisierung sparte nicht nur Zeit, sondern passte perfekt zum retro-inspirierten Spielstil.
„Mit Copilot CLI zu arbeiten, fühlt sich an, als hätte man ein ganzes Team von NPCs zur Verfügung, die alles für einen erledigen.“ — Lee Reilly, Schöpfer von GitHub Dungeons
Durch diese Herangehensweise konnte sich der Entwickler auf das Spieldesign konzentrieren, während Copilot die technische Umsetzung übernahm. Das Ergebnis ist ein Spiel, das nicht nur funktional ist, sondern auch eine kreative Verbindung zwischen Code und Spielwelten schafft.
Warum Roguelikes und Terminals perfekt zusammenpassen
Roguelikes wie Rogue (1980) oder NetHack haben eine lange Tradition in der Spielewelt. Ihr Kernmerkmal ist die procedurale Generation, die jedem Spielablauf eine einzigartige Erfahrung verleiht. Die textbasierte Darstellung macht sie zudem ideal für die Kommandozeile – ein Medium, das Entwickler täglich nutzen.
GitHub Dungeons knüpft an diese Tradition an und kombiniert sie mit moderner Softwareentwicklung. Das Spiel ist nicht nur ein Zeitvertreib, sondern auch ein innovatives Werkzeug, um Repositories interaktiv zu erkunden. Jeder Commit wird zu einem neuen Dungeon-Abschnitt, jeder Branch zu einem alternativen Pfad. Es ist eine visuelle und spielerische Art, den Fortschritt eines Projekts zu erleben.
Die Zukunft von GitHub Dungeons
Das Projekt ist noch in einer frühen Phase, aber die Möglichkeiten sind enorm. Mögliche Erweiterungen könnten sein:
- Integration von GitHub-APIs für dynamischere Dungeons
- Unterstützung für mehrere Spieler in einem Repository
- Automatisierte Spielberichte nach jedem Commit
GitHub Dungeons zeigt, wie kreativ Entwickler mit modernen Tools umgehen können. Es beweist, dass Software nicht nur funktional, sondern auch unterhaltsam sein kann – und dass die Kommandozeile ein perfektes Spielfeld für Experimente ist. Wer neugierig geworden ist, kann das Projekt selbst ausprobieren und seinen eigenen Code in ein Abenteuer verwandeln. Die nächste Spielsession könnte nur einen /yolo-Befehl entfernt sein.
KI-Zusammenfassung
GitHub Copilot CLI kullanarak kendi kod deposunu terminalde oynanabilir bir roguelike zindanına dönüştürmek mümkün. BSP algoritması ve Go diliyle nasıl yapıldığını keşfedin.
