Die drei Game-Creation-Systeme GDevelop, Godot und jMonkeyEngine vereinfachen die Spieleprogrammierung mit passenden Bibliotheken, den sogenannten Engines, und passenden Entwicklerwerkzeugen. So erstellen Einsteiger wie Fortgeschrittene im Handumdrehen schicke Spiele.

In den Entwicklungsumgebungen GDevelop, Godot und jMonkeyEngine müssen Sie zur Spieleprogrammierung lediglich ein paar Grafiken importieren, diese mit der Maus zu einem netten Level arrangieren, dann in einem komfortablen Editor etwas Programmcode hinterlegen und schließlich mit einem Knopfdruck das fertige Spiel erzeugen. Eine spezielle Bibliothek, die sogenannte Engine, erleichtert dabei die Programmierung. Sie vereinfacht die Ausgabe von Bildern, Tönen und Animationen sowie die Netzwerkkommunikation drastisch. Weil GDevelop, Godot und jMonkeyEngine damit ein Rundum-sorglos-Paket bereitstellen, bezeichnet man sie im Englischen auch als Game Creation System oder kurz GCS. Zwar lassen sich mit ihnen beliebige Spiele erstellen, doch weist jeder der drei Kandidaten auch einige limitierende Nachteile auf.

GDevelop

Möchten Sie ohne Programmierkenntnisse ein Spiel erstellen, greifen Sie zu GDevelop [1]. In der Entwicklungsumgebung des Franzosen Florian Rival klicken Sie sich einfach mit der Maus das komplette Spiel zusammen. Die Benutzeroberfläche spricht sogar teilweise Deutsch (Abbildung 1). GDevelop erstellt ausschließlich 2D-Spiele, wobei die Ausgabe der Grafik auf dem Bildschirm über die 3D-Schnittstelle OpenGL erfolgt.

Abbildung 1: Die Benutzeroberfläche von GDevelop wirkt aufgeräumt, die einzelnen Funktionen fassen Register am oberen Rand zusammen (“Ribbons”). Hier entsteht ein Rennspiel.

In der Entwicklungsumgebung importieren Sie zunächst 2D-Grafiken, die Sie anschließend zu einer kompletten Szene zusammensetzen. Den Spielablauf legen Sie fest, indem Sie wichtige Ereignissen, wie etwa “linke Maustaste gedrückt”, passende Aktionen zuordnen, wie etwa “bewege Objekt ‘Raumschiff’ 10 Pixel nach oben” (Abbildung 2). Die Ereignisse lassen sich über einfache Bedingungen (wie ein logisches Oder) verknüpfen, Aktionen über Schleifen wiederholen. Die auf diese Weise entstehenden Ablaufpläne kapseln Sie bei Bedarf zur Wiederverwendung in Funktionen.

Abbildung 2: In GDevelop klicken Sie sich die Programmlogik zusammen, was allerdings schon bei einfacheren Spielen zu unübersichtlichen Ablaufplänen führt.

Die Grafiken lassen sich auf verschiedene Ebenen (Layer) verteilen und so wie Folien übereinanderlegen. Dies erlaubt auch den sogenannten Parallax-Effekt, bei dem optisch entfernte Objekte langsamer über den Bildschirm gleiten als nahe. Weitere Funktionen kommen in Form von Erweiterungen. Über diesen Weg holen Sie unter anderem eine Physiksimulation, eine automatische Wegfindung für Gegner oder ein Partikelsystem hinzu. Letzteres sorgt für sprühende Funken oder effektvolle Explosionen. Über eine Tile-Map lassen sich größere Spielfelder aus Kacheln zusammensetzen.

GDevelop erstellt Programme für Windows, Mac OS X und Linux. Darüber hinaus exportiert die Entwicklungsumgebung das Spiel auf Wunsch auch als HTML5-Anwendung, die in jedem Browser läuft. Allerdings müssen Sie sich schon zu Beginn für eine native oder eine Webanwendung entscheiden. Abhängig von der Wahl stehen dann unterschiedliche Erweiterungen bereit. So müssen etwa HTML5-Spiele auf das Partikelsystem verzichten, erkennen im Gegenzug aber exklusiv Touchscreen- und Multitouch-Gesten. Bei nativen Linux-Spielen dürfen Sie wiederum einen Debugger und einen Profiler einsetzen (Abbildung 3). Mit Letzterem kontrollieren Sie Geschwindigkeitsprobleme und die Prozessorauslastung. Die Engine steht unter der MIT-Lizenz, die Entwicklungsumgebung unter der GPLv3.

Abbildung 3: In GDevelop zeichnet der Profiler die jeweilige Spielgeschwindigkeit auf – je höher die Zacken, desto langsamer läuft das Autorennen. Über den Debugger lässt sich das Geschehen auch vorübergehend anhalten.

Bislang sind mit GDevelop hauptsächlich kleine Freeware-Spiele entstanden, wie das durchaus sehenswerte “Blazing Inferno of Space” [2]. Die Dokumentation besteht aus einem englischsprachigen Wiki, das zwar etwas verschachtelt aufgebaut ist, aber dafür Programmieranfänger mit Tutorials an die Hand nimmt. Die Entwicklungsumgebung bringt zudem zahllose Beispiel-Spiele mit, darunter das Rennspiel aus Abbildung 1. Offene Fragen klären der Entwickler und die Anwender gemeinsam in einem Forum.

Godot

Im Februar 2014 veröffentlichte das argentinische OKAM Studio den kompletten Quellcode seiner bis dahin nur für eigene Spiele genutzten Entwicklungsumgebung. Obwohl die Godot getaufte Software schon mehrere Jahre im Einsatz war, erreichte sie erst im Dezember 2014 die Versionsnummer 1.0. Die Weiterentwicklung erfolgt offen auf GitHub unter der MIT-Lizenz, Sponsor ist weiterhin OKAM Studio [3].

Godot enthält eine 2D- und eine 3D-Engine, die in einem Spiel abwechselnd aktiv sein dürfen (Abbildung 4). Die Darstellungsformen lassen sich auch mischen und so etwa 3D-Figuren vor einen gemalten 2D-Hintergrund setzen (Abbildung 5). Wie bei GDevelop importieren Sie in der Entwicklungsumgebung zunächst Grafikobjekte, die Sie dann in einzelnen Szenen anordnen. Die Objekte bilden dabei jeweils sogenannte Knoten, die der Spieleprogrammierer in einer Hierarchie anordnen muss. Auf diese Weise lässt sich etwa ein Haus aus einem Dach und vier Wänden zusammensetzen. Dieses gewöhnungsbedürftige Konzept erleichtert die Wiederverwendung von Objekten und erlaubt einige Automatismen. So muss man etwa bei einem Auto nicht jedes Rad separat weiterbewegen.

Abbildung 4: Dank gleich zweier enthaltener Engines lassen sich mit Godot sowohl 2D-Spiele entwickeln, als auch …

Abbildung 5: … 3D-Spiele, die nicht zwingend so kantig aussehen müssen. Dieses Jump-and-Run-Spiel liegt Godot als Beispiel bei.

Die Einzelteile von 2D-Figuren, wie etwa Arme und Beine, lassen sich an passenden Stellen aneinanderheften und animieren – ähnlich wie bei den Figuren in der Zeichentrickserie “South Park”. Des Weiteren gibt es ein Partikelsystem, das unter anderem für hübsche Explosionen sorgt. Die einzelnen Grafikobjekte ordnen Sie gegebenenfalls auf Ebenen (Layer) an, was wiederum Parallax-Scrolling erlaubt. Über einen Tile-Map-Editor bauen Sie zudem schnell 2D-Level aus einzelnen Kacheln.

Die 3D-Engine kann fertige Modelle aus bekannten Grafikprogrammen importieren, so etwa aus Maya und Blender. Godot unterstützt die Animationstechniken Skeleton Deform und Blend Shape, mit denen sich beispielsweise natürlich wirkende Lippenbewegungen erstellen lassen. Zudem stehen zahlreiche Grafikeffekte parat, darunter ein einfacher Schattenwurf (über sogenannte Shadow Maps), Antialiasing, HDR, Weichzeichnereffekte und eine Nebelsimulation. Die Materialeigenschaften der 3D-Objekte lassen Sie von entsprechenden Mini-Programmen erstellen, den sogenannten Shadern.

Die 2D- und die 3D-Engine bringen getrennte, von den Godot-Machern selbst entwickelte Physiksimulationen und Kollisionserkennungen mit. Der Spieleentwickler muss dabei nicht umlernen, sondern kann die beiden Systeme über die gleichen Schnittstellen ansprechen. Des Weiteren animiert Godot sämtliche Eigenschaften eines Objekts über die Zeit. Die Veränderungen lassen sich dabei auf einer Zeitleiste mit sogenannten Keyframes bildgenau steuern, die Auswirkungen zwischen zwei Keyframes berechnet Godot. Wer schon einmal mit Synfig oder einem anderen Animationsprogramm gearbeitet hat, kennt das Prinzip.

Zum Erstellen von Benutzeroberflächen bietet Godot zahlreiche vorgefertigte Schaltflächen, Regler und Listen. Das Aussehen der Kontrollelemente passen Sie über Skins an. Des Weiteren unterstützt Godot das Lokalisieren der Spiele, wobei Sie die Übersetzungen in eigenen Textdateien anliefern müssen. Genügen die Möglichkeiten Ihren Ansprüchen noch nicht, können Sie den Funktionsumfang der Engine über eine C++-Schnittstelle erweitern und so etwa zeitkritischen Programmcode auslagern.

Die Programmlogik des Spiels entsteht in einer eigenen Skriptsprache namens GDScript (Abbildung 6). Der Code-Editor färbt unter anderem den Quellcode ein (Syntax Highlighting) und schlägt automatisch passende Schlüsselwörter vor (Code Completion). Die Ausführung des Spiels halten Sie über im Code gesetzte Marken (Breakpoints) gezielt an. Auf Wunsch springt der integrierte Debugger per Tastendruck von Befehl zu Befehl und zeigt die aktuellen Werte aller Variablen. Der Performance-Analyzer liefert Informationen zur Speicher- und Prozessorauslastung, womit sich wiederum das Spiel optimieren lässt. Godot kann Versionskontrollsysteme wie Git oder SVN einbinden.

Abbildung 6: Die Skriptsprache von Godot lehnt sich stark an Python an und markiert insbesondere Codeblöcke durch Einrückungen.

Die mit Godot erstellten Spiele laufen unter Windows, Mac OS X sowie Linux und daneben auch auf iOS und Android sowie der Playstation 3 und PS Vita. Die beiden zuletzt genannten Plattformen setzen allerdings eine (teure) Entwicklerlizenz von Sony voraus. Eine Exportmöglichkeit für HTML5 und Windows Phone ist derzeit in Arbeit. Zum Redaktionsschluss stand die Version 1.1 kurz vor der Veröffentlichung, die über eine generalüberholte 2D-Engine verfügt, eine verbesserte Auto-Vervollständigung im Code-Editor bietet und einen visuellen Shader-Editor mitbringt (Abbildung 7). Die noch lückenhafte Dokumentation zu Godot findet sich im Github-Wiki und besteht im Wesentlichen aus einer Reihe Tutorials.

Abbildung 7: Im neuen Shader-Editor von Godot 1.1 beschreiben Sie die Shader nicht mehr über eine einfache Shader-Sprache, sondern setzen sie bequem über Knoten zusammen.

jMonkeyEngine

Laut Eigenwerbung handelt es sich bei jMonkeyEngine um eine “Cross-Plattform Game-Engine für abenteuerlustige Java-Programmierer” [4]. Die eigentliche Engine erlaubt ausschließlich das Erstellen von 3D-Spielen und ist komplett in Java geschrieben. Diese Programmiersprache steht im Ruf, recht langsame Anwendungen zu produzieren. Die Macher der jMonkeyEngine versprechen jedoch “hoch performante 3D-Spiele, die sich auf Augenhöhe mit jeder anderen Engine befinden.” Wer sich davon selbst überzeugen möchte, sollte einen Blick auf die mit der jMonkeyEngine erstellten Spiele wie “Bang! Howdy” [5] oder “Grappling Hook” [6] werfen.

Das von den Machern bereitgestellte Software Development Kit (SDK) enthält neben der eigentlichen Engine auch die leicht angepasste Entwicklungsumgebung NetBeans [7]. Im Kern besteht sie aus einem leistungsfähigen Code-Editor, der unter anderem den Quellcode automatisch einfärbt, eine automatische Quellcode-Vervollständigung bietet und während des Tippens eine kleine Referenz der jeweiligen Funktion einblendet (Abbildung 8). Hinzu kommen Funktionen zum Aufräumen des Quellcodes (Refactoring), ein Debugger, ein Profiler und eine Anbindung an die Versionskontrollsysteme Git, Mercurial und Subversion. Die Entwicklungsumgebung unterstützt zudem das Übersetzen des Spiels in andere Sprachen. Um den Funktionsumfang auszubauen, können Sie sämtliche erhältlichen NetBeans-Plugins weiterverwenden.

Abbildung 8: Ein leicht erweitertes NetBeans stellt die Entwicklungsumgebung der jMonkeyEngine.

Die vollständig in Java zu verfassenden Spiele laufen unter Windows, Mac OS X, Linux, Android und auf der Ouya-Konsole. In der kommenden Version 3.1 soll jMonkeyEngine auch iOS und VR-Brillen wie etwa die Oculus Rift unterstützen. Für Windows, Mac OS X und Linux lässt sich das Spiel als JAR-Archiv oder in Form eines ausführbaren Programms exportieren.

Bei der Spieleentwicklung arbeiten Sie hauptsächlich direkt mit Quellcode. Im Gegensatz zur Konkurrenz bietet die Entwicklungsumgebung nur ein paar einfache Arbeitshilfen an: So importiert ein Assistent in Blender erstellte 3D-Objekte, die sich anschließend in einem sehr rudimentären visuellen Editor zu einer kompletten Szene arrangieren lassen (Abbildung 9). Die jMonkeyEngine-Macher empfehlen Blender als bevorzugtes Modellierwerkzeug, die Entwicklungsumgebung importiert aber auch Ogre- und Wavefront-Objekte.

Abbildung 9: Im jMonkeyEngine SDK ordnen Sie im rudimentären Scene-Composer die 3D-Objekte an. Die Eigenschaften des ausgewählten Objekts erscheinen in einer Tabelle auf der rechten Seite.

Ähnlich wie bei Godot fügen Sie die einzelnen 3D-Objekte über Knoten der Szene hinzu. Die Knoten lassen sich in einer Hierarchie anordnen, was ermöglicht, Beziehungen zwischen den 3D-Objekten zu bilden. Die Materialeigenschaften der 3D-Objekte entstehen wie bei Godot über programmierbare Shader. Eine TerraMonkey genannte Komponente erstellt auf Wunsch aus einem Bild mit einer topografischen Karte (Highmap) eine entsprechende 3D-Landschaft.

Die jMonkeyEngine simuliert verschiedenartige Lichtquellen, Techniken wie Screen Space Ambient Occlusion (SSAO) zaubern realistische Schatten auf den Schirm. Des Weiteren bietet jMonkeyEngine zahlreiche Spezialeffekte, wie ein Partikelsystem, eine Rauch- und Wassersimulation sowie (Licht-)Spiegelungen. Sogenannte Post-Processor-Filter wirken sich auf die angezeigte Szene aus und erlauben etwa am Level-Ende ein sanftes Überblenden auf einen schwarzen Bildschirm (Fade Out). Die jMonkeyEngine unterstützt neben Tastaturen und Joysticks auch Touchscreens als Eingabegeräte.

Menüs und Einstellungsfenster realisieren Sie über die Java-Bibliothek NiftyGUI [8]. Sie liegt jMonkeyEngine bei und erlaubt die Konstruktion der Benutzeroberfläche über XML-Markup oder Java-Code. Physikalisch korrekte Abläufe steuert mit jBullet eine Java-Portierung der beliebten Bullet-Bibliothek [9]. Sie ermöglicht auch eine sogenannte Ragdoll-Physik, die korrekte Bewegungen der Gliedmaßen einer Figur simuliert. Mit dem beigelegten jUnit-Framework testen Sie den Quellcode Ihrer Spiele. Schlaue Computergegner lassen sich mit der in einem separaten Projekt entwickelten MonkeyBrains-Engine umsetzen [10]. Dank der BSD-Lizenz darf jeder Entwickler den Quellcode der jMonkeyEngine nach Belieben verändern und auch in kommerziellen Projekten verwenden.

Die Dokumentation besteht aus einem extrem umfangreichen und vorbildlichen Wiki, das Tutorials für Anfänger und ausführliche Artikel für fortgeschrittene Programmierer bereithält. Zudem existieren mehrere englischsprachige Bücher. Nach der Lektüre noch offene Fragen klärt ein Forum.

Fazit

GDevelop ermöglicht auch Nicht-Programmierern das Erstellen einfacher Spiele. In nicht einmal einer Stunde klicken Sie ein komplettes kleines Action-Spiel zusammen. Damit eignet sich dieses GCS auch zum schnellen Erzeugen von Prototypen. Spieleentwickler bleiben allerdings auf relativ einfache 2D-Spiele beschränkt, zudem fallen die Listen mit den Ereignissen und Aktionen schnell recht unübersichtlich aus.

Godot eignet sich gleichermaßen für 2D- und 3D-Spiele und ähnelt dem beliebten kommerziellen Unity 3D (siehe Kasten “Kommerzielle Konkurrenz”). Hier müssen Sie allerdings eine eigene Skriptsprache erlernen, die aber zumindest für Python-Kenner vertraut wirken sollte. Der Funktionsumfang liegt deutlich über dem von GDevelop, kommt aber an den der jMonkeyEngine nicht heran.

Die wiederum richtet sich an erfahrene Java-Programmierer und setzt auf viele bekannte Standardkomponenten, wie etwa die Bullet-Physiksimulation. Wer noch nicht mit NetBeans gearbeitet hat, muss sich zunächst in die komplexe Entwicklungsumgebung einarbeiten – oder aber auf deren Hilfe verzichten und die Engine direkt in sein Programm einbinden. Punkten kann das Projekt zudem mit einer extrem umfangreichen Dokumentation.