Im Play Store findest du mittlerweile hundert tausende verschiedenster Spiele. Doch wie entwickelt man eigentlich so ein Spiel für Android? In diesem Artikel zeigen wir dir, wie du ein schönes 2D-Spiel von der Idee bis zur Veröffentlichung für Android entwickelst. Am Ende kannst du das fertige Spiel über den Play Store herunterladen und spielen.
Inhaltsverzeichnis
Schritt 1: Die Idee und das Konzept
Eine Idee zu haben ist schonmal eine gute Sache. Bevor du aber mit der eigentlichen Arbeit oder dem Konzept beginnst, solltest du noch ein paar Sachen im Vorfeld klären:
Die Entwicklungsumgebung
Grundsätzlich kann man Spiele mit Android-Boardmitteln mit Android Studio nativ entwickeln (wie z.B. das von uns entwickelte Spiel Levi der Ritter). Der große Nachteil ist hier allerdings, dass man das Spiel (bis auf die Grafiken) nochmal komplett neu programmieren muss, sollte man es irgendwann auch für andere Plattformen wie z.B. für iOs anbieten wollen.
Für diesen Fall haben sich einige Hersteller Gedanken gemacht und spezielle Entwicklungsumgebungen (Engines) extra für Spiele zur Verfügung gestellt, mit denen man ein Spiel 1x entwickelt, dieses dann aber auf einfache Art und Weise für die verschiedensten Plattformen exportieren kann. Einige dieser Entwicklungsumgebungen sind z.B.:
 |
 |
Ein weiterer, riesiger Vorteil dieser Engines ist, dass sie Physik-Komponenten, Animations-Frameworks und vieles mehr “Out of the Box“ mitbringen. Nicht nur, dass man hier enorm viel Arbeit abgenommen bekommt. Viele dieser Engines bieten sogar noch eigene Asset Stores an, über die man Skripte, Animationen, Charaktere und Grafiken von anderen Entwicklern und Designern kaufen kann. Man muss das Rad ja schließlich nicht jedes Mal neu erfinden.
Für unser Spiel entscheiden wir uns für Unity3D. Mit dieser Engine kann man gleichermaßen 2D- und 3D-Spiele entwickeln. Dies kann man zwar auch mit der UnrealEngine, Unity3D bietet aber den größeren Asset Store und zudem die größere Community. Im Endeffekt ist es aber einfach Geschmacksache, für welche Engine man sich letztendlich entscheidet.
2D oder 3D (oder 2.5D ?)
Im Gegensatz zu 3D-Spielen sind 2D-Spiele grundsätzlich erst einmal einfacher umzusetzen.
In 2D-Spielen werden die einzelnen Grafiken als Sprites bezeichnet. Diese werden vorzugsweise in Vektoren-Programmen wie Adobe Illustrator oder Gimp erstellt. Eine Vektorgrafik ist hierbei nichts anderes, als dass man diese in einem Vektorprogramm ohne Qualitätsverlust beliebig vergrößern kann. Exportiert man diese Vektorgrafik dann am Ende in der gewünschten Auflösung, so erhält man eine .png oder .bmp Grafik, so wie wir sie kennen.
Für 3D-Spiele braucht man, wie der Name schon verrät, 3D-Objekte. Diese werden auch Models genannt und werden mit Programmen wie z.B. Blender oder Cinema4D erstellt.
Mit 2D oder 3D sind hier aber nicht alleine die Grafiken gemeint, sondern auch, wie das Spiel im Hintergrund aufgebaut ist. Entwicklungsumgebungen wie Unity3D sind immer in Koordinatensystemen aufgebaut. Es gibt eine X-Achse, eine Y-Achse und eine Z-Achse. Bei einem 2D-Spiel stehen einem nur die X- und Y-Achse zur Verfügung. Hier kann man sich quasi nach links und rechts sowie nach oben und unten bewegen. Bei einem 3D-Spiel hingegen hat man noch die Z-Achse. Diese steht für die Raumtiefe.
Und was sind nun 2.5D-Spiele?
Das ist im Grunde ganz einfach: Bei 2.5D-Spielen wird z.B. die 3D-Spielfigur in einem 2D-Koordinatensystem verwendet. Man bewegt sich darin also mit seiner 3D-Spielfigur in einer 3D-Grafikwelt nach links, rechts, oben und unten, hat aber nicht die Möglichkeit “in die Tiefe” zu gehen.
Schritt 2: Das Konzept
Jetzt konnten wir im Vorfeld schon einige Sachen klären, sodass wir nun das Konzept erarbeiten können.
So ein Konzept ist eigentlich keine große Sache und man muss hier im Privatbereich auch keine Romane schreiben. Es ist aber sinnvoll sich einfach ein paar grundlegende Gedanken zum Spielablauf zu machen:
- Wie sollen die einzelnen Level aufgebaut sein?
- Wie soll der Schwierigkeitsgrad pro Level gesteigert werden?
- Wie sieht die Steuerung aus?
- usw.
Die Grundidee
Wir werden ein kleines Weltraum Jump’n Run entwickeln. Es wäre ganz cool ein kleines Alien zu haben, das von Planet zu Planet springt. Damit der Spieler weiß, in welche Richtung er zum Ziel gelangt, zeigen wir in der Ecke einen kleinen Kompass an. Die Planeten soll der Spieler selbst erzeugen und somit die Richtung selbst bestimmen können, in die er sich bewegt.
Planeten besitzen ja Gravitation. Also soll die Spielfigur auf den Planeten herumlaufen können. Um in späteren Level noch Hindernisse einbauen zu können wäre es gut, wenn man auch über diese drüberspringen kann.
Die Steuerung soll sehr einfach und intuitiv sein. Auf keinen Fall wollen wir den Spieler mit zu vielen Steuerungs-Controls verwirren. Wenn der Spieler also 1x auf sein Display tippt, dann führt unser Alien einen Sprung aus. Tippt der Spieler 2x hintereinander auf das Display, so springt das Alien ein wenig kräftiger ab und überwindet so die Gravitation des Planeten. Um die ganze Sache etwas schwieriger zu gestalten soll das Alien automatisch laufen. So muß der Spieler genau abschätzen, wann er zum Doppelsprung ansetzt, um den nächsten Planeten zu erreichen.
Als Ziel soll das Alien eine Galaxie erreichen, die den Spieler zum nächsten Level bringt.
Verschiedene Level
- Level 1 – Der erste Level soll eine Art Tutorial sein. Damit der Spieler erst einmal die Steuerung kennenlernen kann, gibt es in diesem Level noch keinerlei Gefahren und er ist auch relativ kurz gehalten.
- Level 2 – Hier bauen wir ein größeres Hindernis ein, um das der Spieler herum navigieren muss, damit er zum Ziel gelangen kann.
- Ab Level 3 – Hier wird es dann schon interessanter. Auf dem Planeten selbst sollen sporadisch Hindernisse wie Felsbrocken erscheinen, über die das Alien drüberspringen muss. Und es werden einige Items “gespawned”, mittels denen das Alien dann die Richtung wechselt. Außerdem brauchen wir noch ein wenig mehr Aktion in den unendlichen Weiten des Weltalls. Also fügen wir ab Level 3 nach und nach noch ein paar Ufos und Asteroiden hinzu.
Die Menüführung
Wir möchten das Spiel erst einmal ganz einfach halten. Daher verzichten wir für den Anfang auf grafisch aufwändig gestaltete Dialoge. Hier reichen uns ein paar Dialoganzeigen ohne Rahmen, die den notwendigen Text beinhalten, aus. Diese müssen, wenn aktiv, natürlich das Spiel überlagern und werden bei Game Over, oder wenn ein Level beendet wurde, eingeblendet. Auch ein Pause-Button darf in einem Spiel natürlich nicht fehlen.
Schritt 3: Grafiken, Animationen und die Spielfigur
Der Spielfigur Leben einhauchen
Da ein Spielercharakter nicht einfach nur stumm in einer Ecke steht müssen wir uns überlegen, welche Aktionen dieser im Spiel ausführen können soll. Das könnte beispielsweise sein:
- Laufen
- Stehen bleiben (Idle)
- Schießen
- Springen
Grundsätzlich ist es so, dass man für jede dieser Aktionen in 2D-Spielen eine eigene Animation erstellt. Möchte man es gerne etwas aufwändiger betreiben, so erstellt man für das Springen eine Animation, und dann für das Fallen wiederum eine andere. Genauso könnte es sein, dass der Spielercharakter einmal langsam läuft, und dann rennt. Das wären auch hier zwei verschiedene Animationen. Und bleibt der Charakter stehen brauchen wir eine Idle-Animation, bei der sich nur der Brustkorb etwas hebt, um eine Atmung nachzustellen.
Wir wollen es bei unserem Alien aber etwas einfacher halten. Daher beschränken wir uns auf die folgenden Aktionen:
- Stehen bleiben (Idle)
- Laufen
- Springen
Sobald man einen neuen Level erreicht hat läuft das Alien noch nicht gleich los. Es befindet sich erst einmal in einer Idle-Animation. Das Alien wird dann nach Levelstart automatisch loslaufen und dabei nicht wieder anhalten. Daher folgt hier dann die Lauf-Animation. Wenn der Spieler dann einen Sprung ausführt wechselt das Alien zur Sprung-Animation. Und wenn das Alien anschließend wieder “Boden unter den Füßen” hat, geht es zurück zur Lauf-Animation.
Soviel zur Theorie. Doch wie erstellt man aber nun diese Grafiken? Auch hier gibt es 2 unterschiedliche Vorgehensweisen.
Animationsgrafiken über SpriteSheets
Bei SpriteSheets versucht man die Bewegung eines Charakters Stück für Stück wie in einem Daumenkino abzubilden. Um das zu verdeutlichen hier einmal die Lauf- und Angriffsanimation eines kleinen Drachen unseres Spiels Legends of Bubble Bobble:
Für die Laufanimation haben wir hier 16 Bilder erstellt, die in einer Schleife abgespielt werden. Ist das letzte Bild erreicht, startet die Animation wieder beim ersten Bild. So bekommt der Spieler den Eindruck, dass die Figur läuft.
Die Angriffsanimation ist hierbei weniger aufwändig, weshalb wir hier nur 8 Bilder benötigen. Je mehr Bilder man aber in so eine Animation einfügt, desto flüssiger bewegt sich der Charakter dann letztendlich im Spiel.
Die Verwendung von SpriteSheets hat gewisse Vor- aber auch Nachteile. Ein riesiger Vorteil ist, dass man Animationen sehr detailliert gestalten kann. Allerdings kann der Grafikaufwand hierbei enorm groß werden. Möchte man eine Spielfigur z.B. mit einem Helm ausrüsten, müsste man sämtliche Grafiken noch einmal mit einem Helm neu zeichnen. Und kommt dann noch ein Brustpanzer hinzu, benötigen wir einmal die Grafiken komplett ohne Rüstung, dann nur mit Helm, nur mit Brustpanzer und schließlich mit Helm UND Brustpanzer. Du siehst, so ein Vorgehen kann schnell in enorme Arbeit ausarten.
Die andere Möglichkeit, die wir hier stattdessen einsetzen können, ist das Unity3D Animation Framework.
Animationsgrafiken über das Unity3D Animation-Framework
Das Konzept hinter dem Animation-Framework ist schnell erklärt: Teilen wir unser Alien doch einmal auf. Es hat also einen Kopf, einen Rumpf, 2 Arme und 2 Beine. Und wir brauchen vielleicht noch einen Helm, damit das Alien nicht im Weltraum erstickt :-) Für jedes dieser Elemente erstellen wir nun eine eigene Grafik:
Soweit so gut. Nun erstellen wir in Unity3D das Hauptelement Alien und darunter dann Unterelemente für Kopf, Rumpf, Arm links, Arm rechts, Bein links und Bein rechts. Den Helm bringen wir dann in dem Element Kopf unter.
Und nun weisen wir jedem dieser Elemente die entsprechende Grafik zu:
Nach dem Hinzufügen sehen die Elemente noch etwas durcheinander gewürfelt aus. Deshalb müssen wir die Elemente jetzt händisch in die richtig Grundposition verschieben, damit ein adrettes Alien dabei herauskommt.
Geschafft! Nun haben wir ein Alien, aufgeteilt in einzelne Elemente (auch Objekte genannt). Was man jetzt mit dem Unity3D Animation Framework macht ist, jedes einzelne dieser Elemente zeitgesteuert in der X- und Y-Achse zu verschieben. So erstellt man nun eine Animation Laufen und bestimmt in dieser, wie sich jedes einzelne der Elemente während dieser Animation bewegen soll.
Der große Vorteil bei dieser Vorgehensweise ist, dass man deutlich weniger Grafiken für eine Spielfigur benötigt. Auch wenn man Rüstungsteile oder Waffen hinzufügen möchte erstellt man dazu einfach ein neues Unterelement in dem Alien und fügt diesem die jeweilige Grafik hinzu und erweitert anschließend einfach die Animation.
Der große Nachteil ist allerdings, dass die Figuren weniger detailliert aussehen. Für unser kleines Casual Games mag das aber lange genügen.
Weitere Grafiken erstellen
Unser Alien steht jetzt schon einmal in den Startlöchern. Nun brauchen wir aber noch ein paar weitere Grafiken wie Planeten, Sterne und vielleicht noch ein paar Hindernisse, die uns im Laufe des Spiels begegnen. Die Planeten sind schnell gemacht und hierfür brauchen wir auch gar keine Animationen. Genauso wenig für die Sterne.
Schritt 4: Gravitation, Steuerung und Collider
Gravitation
In unserem Weltraum-Spiel haben alle Planeten eine gewisse Gravitation. Der Spieler soll sich ja auf den Planeten fortbewegen bzw. auch springen können. Die Anziehungskraft muss also so stark sein, dass ein normalen Sprung problemlos möglich ist. Das Alien muss allerdings mittels Doppelsprung die Anziehungskraft des Planeten überwinden können. Im Weltraum selbst gibt es keine Gravitation. Hier soll das Alien dann schweben.
Aber wie „baut“ man so eine Gravitation? Hier macht es sich nun richtig bezahlt, dass wir auf eine Entwicklungsumgebung wie Unity3D gesetzt haben. Hätten wir das Spiel nativ entwickelt, so müssten wir nun das Verhalten der Gravitation selbst programmieren, was ziemlich aufwändig ist. Unity3D hingegen bringt von Haus aus schon viele Komponenten mit, die man auch ohne selber programmieren zu müssen einfach verwenden kann.
Schauen wir uns das doch einmal in der Entwicklungsumgebung genauer an. Wir haben also unser Alien mit seinen Unterelementen gebaut und fügen dem obersten Element (quasi dem Wurzel-Element) einen Rigidbody2D hinzu. Als Rigidbody wird in Unity3D die Physik-Komponente bezeichnet.
Hier können wir nun angeben, wie viel Masse und Gravitation unser Alien haben soll. Wir tragen nun einen Wert ein, starten das Spiel und schauen einfach mal, was passiert:
Das Alien fällt nun. Wir sehen in dem Beispiel auch, dass das Alien durch den fiktiven Boden fällt, den wir zu Demonstrationszwecken eingefügt haben. Damit ein Objekt wie das Alien mit einem anderen Objekt in Unity3D interagieren kann (wie z.B. Planeten oder Gegner), müssen wir alle diese Objekte mit so genannten Collidern ausstatten.
Collider
Collider sind im Grunde nichts anderes als Rahmen, die wir um ein Objekt (Alien, Planet, oder Gegner) legen. Es gibt Collider in Form von Kreisen, Rechtecken oder Polygonen. Je nachdem, für welchen Einsatzzweck man sie eben benötigt.
Ein Objekt kann dabei mehrere Collider haben. Diese kann man nämlich auf 2 Arten nutzen: Einmal lässt man die “isTrigger”-Option deaktiviert. Das bedeutet dann, dass dieser Collider nicht mit einem anderen Collider “reagiert”. Man setzt das z.B. ein, wenn eine Spielfigur nicht durch den Boden fallen soll. Der Boden hat dann einen Collider und die Spielfigur hat dann ebenfalls einen Collider. Bei beiden ist die “isTrigger”-Option deaktiviert.
Die andere Möglichkeit die Collider zu verwenden ist die “isTrigger”-Option zu aktivieren. Hierbei hat dann beispielsweise unser Alien diesen Collider sowie ein Gegner. Treffen diese beiden dann aufeinander wird ein Event ausgelöst (OnTriggerEnter), bei welchem wir ausprogrammieren müssen, was in diesem Fall passieren soll. Üblicherweise bekommt unser Alien dann Leben abgezogen. Man kann aber auch eine Gewehrkugel mit einem solchen Collider ausstatten, der dann dem Gegner Gesundheit abzieht.
Bei unserem Spiel haben die Planeten z.B. auch mehrere Collider. Einmal einen Trigger-Collider, mit dem wir dann die Gravitation bei dem Alien aktivieren und einen Nicht-Trigger-Collider, der den Boden des Planet darstellt und auf dem unser Alien laufen kann.
Die Steuerung
Unser Alien hat nun Schwerkraft, fällt nicht mehr durch den Planeten hindurch und die Animationen sind auch schon fertig. Jetzt muß unser Alien nur noch laufen und hüpfen können. Wir erstellen in unserer Entwicklungsumgebung ein neues Skript und fügen dieses unserem Alien als Komponente hinzu.
Hier haben wir einmal angegeben, dass unser Alien automatisch laufen soll, und zwar per Default nach rechts. Double-Jump soll ebenfalls möglich sein. Die Lauf-Geschwindigkeit, Gravitation, etc. haben wir auch angegeben und welche Elemente in diesem Spiel als „Ground“, also als Boden, gelten sollen. Das wären in unserem Fall die Planeten.
Dieses Verhalten muß man vorher natürlich ausprogrammieren. In Unity3D geschieht dies in C# oder in JavaScript. Wie so etwas aussehen kann zeige ich dir hier beispielhaft:
Schritt 5: Die Spiel-Kamera
Mit der Kamera ist im Grunde die Sicht des Spielers auf das Spiel gemeint. Stell dir dazu am Besten ein Autorennen vor: Du kannst dein Auto einmal aus der Cockpit-Sicht spielen, oder aber aus der Verfolgungssicht bzw. aus der Perspektive schräg über dem Fahrzeug. Für jede dieser Sichtweisen wird eine eigene Kamera erstellt.
Und so verhält es sich auch bei unserem Spiel: Wir haben einmal die Entwicklungsumgebung, in der wir als Entwickler in dem Spiel herumscrollen können, wie es uns beliebt. Und dann gibt es noch die Spielersicht. Hier haben wir für die Spieler-Kamera z.B. festgelegt, dass diese das Spiel für den Spieler in einer Auflösung von 1080×1920 darstellen soll. Außerdem haben wir ein kleines Skript geschrieben und der Kamera als Komponente hinzugefügt. Dieses sagt der Kamera, dass sie den Spieler immer im Zentrum behalten soll. Damit stellen wir sicher, dass die Kamera das kleine Alien verfolgt und das Alien niemals aus der Kamera verschwindet.
Ein weiterer riesiger Vorteil von Game Engines ist, dass diese die Spiele vollkommen automatisch auf die richtige Displaygröße skalieren. Es gibt tausende von verschiedenen Smartphones mit unterschiedlichen Displaygrößen und -auflösungen. Entwickelt man nativ muss man selbst dafür sorgen, dass das Spiel auf jedem Smartphone ordentlich dargestellt wird. Diese Arbeit wird uns hier von Unity3D fast gänzlich abgenommen.
Zeit ist alles (Frames)
Jeder von uns kennt ja von früher noch das Daumenkino. Durch das schnelle Durchblättern des Daumenkinos sieht es für uns so aus, als ob sich die Figuren darin flüssig zu bewegen scheinen. Tatsächlich aber werden einfach nur einzelne Bilder der Reihe nach durchgespielt.
Und genauso verhält es sich bei Computerspielen: Jedes einzelne Bild, welches auf dem Smartphone-Display (oder Monitor) dargestellt wird, nennt man Frame. Der Prozess des Zeichnens wiederum nennt man Rendern. Unity3D (sowie alle anderen Game Engines) spielen diese einzelnen Frames also einfach sehr schnell hintereinander ab. Damit ein Spiel nun aber flüssig läuft, müssen mindestens 30 Frames pro Sekunde (fps) dargestellt werden. Das reicht dann für einfache Strategiespiele bzw. weniger actionreiche Games. Aber aufwändige Rennsimulationen oder Egoshooter würden bei 30 fps anfangen zu ruckeln. Daher ist es hier besser auf 50-60 fps zu setzen.
Der erste Level
Bevor wir mit dem Levelbauen anfangen, möchte ich kurz noch etwas ausholen. Es gibt nämlich verschiedene Vorgehensweisen Level zu bauen. Zum Einen kann man das per Hand machen und zum Anderen kann man auf prozedurale Levelgenerierung setzen.
Möchtest du z.B. einen Endlos-Runner entwickeln und planst für diesen mehrere hundert Level, so artet es in richtig viel Arbeit aus, solltest du jeden einzelnen Level per Hand erstellen wollen. Hier kommt dann die prozedurale Levelgenerierung ins Spiel.
Die prozedurale Levelgenerierung
Hierbei programmiert man sich einen Mechanismus und sagt diesem, der erste Level soll z.B. aus 20 Plattformen bestehen. Eine Plattform wiederum besteht aus sagen wir mal 20 einzelnen Kacheln.
Nun gibt man noch an, wie viele Gefahren auf einer Plattform existieren sollen. Gefahren können hier einmal Gegner sein, oder Fallen, spitze Stacheln auf dem Boden, oder eben eine Schlucht. Solch einen Mechanismus kann man beliebig kompliziert gestalten. Ist er aber erst einmal fertig hat man die Möglichkeit in kürzester Zeit eine Unmengen an neuen Level zu generieren. Als Entwickler legt man sich neue Gefahren einfach als eine Art Entwurf in seinem Projekt ab. Und diese Entwürfe gibt man dem Mechanismus dann einfach mit, möchte man z.B. neue Gegner bzw. Gefahren hinzufügen wollen.
Der Nachteil der prozeduralen Levelgenerierung ist, dass man in der Individualität der einzelnen Level eingeschränkt ist. Man hat sich quasi eine Vorlage für alle Level erstellt und diese gibt vor, wie die Level auszusehen haben.
Level per Hand erstellen
Hier kommt es natürlich in erster Linie darauf an, wie aufwändig dein Spiel werden bzw. wie viele Level es letztendlich haben soll und wie groß dein Entwicklungsteam ist. Da wir nur ein kleines Casual-Game entwickeln und wir keine große Entwicklungsschmiede sind machen wir für den Anfang erst einmal einige wenige Level. Falls das Spiel im Play Store Fuß fassen kann und man einen Trend sieht, dass es viele Leute herunterladen und spielen, können wir später dann noch weitere Level hinzufügen. Wir gehen hier also erst einmal nach dem Minimalprinzip vor und wollen nicht mit Kanonen auf Spatzen schießen. Das bedeutet aber nicht, dass wir das Spiel unfertig veröffentlichen. Jeder von uns erstellte Level wird komplett fertig, getestet und durchdesigned sein.
Wir erstellen uns in unserem Unity-Projekt nun eine neue Szene. Als Szene wird in Unity jeder einzelne Level bezeichnet. Nun erstellen wir alle Elemente, die wir in unserem Level haben möchten genau so, wie wir es mit dem Alien in den vorigen Kapiteln getan haben. Die Reihenfolge bzw. die Anordnung auf unserem Spielfeld ist hierbei erst einmal vollkommen egal, denn wir wollen alle Elemente erst einmal als Entwürfe in unserem Projekt ablegen. Diese können wir dann später beliebig oft in unserem Projekt verwenden. Dazu dann aber später mehr.
Haben wir alle Elemente erstellt, geht es nun los. Zuerst sagen wir der Kamera, dass der Hintergrund im Spiel schwarz sein soll. Denn der Weltraum ist nunmal meistens schwarz ;-). Anschließend fügen wir so viele von unseren Sternen-Entwürfen hinzu, sodass unser Level damit komplett abgedeckt ist.
Ist das erledigt fügen wir unseren Spieler hinzu sowie den Planeten Erde als Startplanet.
Jetzt starten wir unser Spiel doch einfach mal. Das Alien läuft auf dem Planeten. Die Skripte für die Erdanziehungskraft und dass das Alien auf dem Planeten läuft haben wir natürlich vorher bereits ausprogrammiert und dem Alien bzw. dem Planeten als Komponenten hinzugefügt.
Wie geht es nun weiter? Wir möchten gerne, dass das Alien die Planeten selbst erzeugen kann. So kann der Spieler dann bestimmen, in welche Richtung er sich mit dem Alien bewegen möchte. Hierzu erstellen wir oben, unten, links und rechts des Planeten ein kleines Element, dass das Alien durch einen einfachen Sprung erreichen kann. Dieses Element startet dann die Routine zum Erzeugen eines neuen Planeten.
Damit das aber nicht zu langweilig aussieht erstellen wir hierfür Spezialeffekte.
Special Effects
In Unity existiert ein Partikelsystem. Dies ist ein System, mit dem man sich selbst Effekte bauen kann. Das ist im Grunde gar nicht so kompliziert, erfordert aber etwas Einarbeitungszeit. Möchte man sich etwas Zeit sparen kann man sich hier auch gerne einmal im Unity Asset Store umschauen. Hier gibt es eine Vielzahl an hervorragenden Grafiken, Sounds, ParticleEffects, Skripte, usw. Viele davon sind kostenlos und dürfen im eigenen Projekt verwendet werden. Andere wiederum kosten Geld. Wir bedienen uns für unser Spiel ebenfalls aus dem Unity Asset Store:
Wir setzen noch ein paar weitere Effekte in unserem Spiel ein, aber das hier sind die Eindrucksvollsten. Nun haben wir alle Elemente in unserem Spiel als Entwürfe angelegt. Als Nächstes fügen wir sie in unser Spiel ein, ordnen sie und bauen unsere ersten Level:
Beim ersten Level soll der Spieler erst einmal die Steuerung kennenlernen. Daher gibt es hier nur einen Startpunkt und ein Ziel.
Beim zweiten Level fügen wir noch eine Sonne hinzu und erhöhen die Entfernung zwischen Start und Ziel.
Später kommen dann noch Ufos als Gegner hinzu, die vorgegebene Wegpunkte abfahren.
Jedem Level spendieren wir nun links oben in der Ecke noch einen Pfeil, der ständig anzeigt, in welcher Richtung sich das Ziel befindet. So weiß der Spieler immer ganz genau, in welche Richtung er sich bewegen muss. Außerdem gibt es noch einen Pause-Button und eine Anzeige, wie viele Planeten man bisher erzeugt hat.
Das Menüsystem
Wir haben nun einige Level erstellt. Diese sind aber alle noch nicht miteinander verbunden. Wir müssen nun ein Menüsystem mit Dialogen bauen, um den Spieler im Spiel zu führen. Das beinhaltet einen Start-Dialog, einen GameOver Dialog und einen Dialog zum nächsten Level. Wir halten uns bei den Dialogen in unserem Spiel nun ebenfalls an das Minimalprinzip und statten diese nur mit Text aus.
Sounds
Unser Spiel ist nun schonmal spielbar. Was jetzt noch fehlt sind Soundeffekte und Musik. Im Internet gibt es eine Menge freier Sounds. Hier muss man vor der Verwendung aber immer die Lizenzen überprüfen. Möchte man mit seinem Spiel Geld verdienen (dazu gehört auch die Anzeige von Werbung), dann ist es vielleicht besser sich Sounds zu kaufen. Eine gute Quelle hierfür ist z.B. Pond5.
Schritt 6: Betatests und die Veröffentlichung im Play Store
Betatests
Betatests sind ungemein wichtig. Denn nichts ist für einen Spieler frustrierender, als wenn er merkt, dass ein Spiel nicht richtig fertig bzw. voller Fehler ist. Auch wenn man als Entwickler nach besten Wissen und Gewissen programmiert und getestet hat, so sieht man manchmal den Wald vor lauter Bäumen nicht.
Zum Beispiel erzeugen wir ja die Planeten über eine Routine. Hierbei muss aber sichergestellt sein, dass neue Planeten nicht „in“ anderen Planeten, Sonnen, oder in der Zielgalaxie erzeugt werden. Diese Planeten müssen zudem noch einen gewissen Abstand zu anderen Planeten besitzen, damit sich die Planetengravitationen nicht in die Quere kommen. Da wir die Planeten in dieser Routine auch jedes Mal in einer variablen Größe erzeugen existiert hier viel Fehlerpotential, welches man durch ausgiebiges Testen zu minimieren versucht.
Weiterhin existieren dort draußen abertausende Smartphones mit den verschiedensten Displaygrößen, Auflösungen, Pixeldichten, Leistungen und Android-Versionen. Und unser Spiel soll auf so vielen Geräten wie möglich reibungslos funktionieren. Da sich aber nicht jeder Entwickler mit dutzenden Smartphones eindecken kann, bietet der freie Markt einige Emulatoren an, die einem dabei helfen. Der Android-Emulator aus Android Studio ist mittlerweile nicht schlecht. Aber auch Genymotion darf hier nicht unerwähnt bleiben. Weiterhin bieten Entwickler im Unity Asset Store tolle Erweiterungen (wie z.B. xARM: Aspect and Resolution Master) an, um direkt in der Entwicklungsumgebung auf verschiedenen emulierten Geräten zu testen.
Am Besten suchst du dir für die Betatests ein paar gute Freunde und Kollegen und gibst ihnen das Spiel zum Testen. Sind diese nach 1-2 Wochen mit dem Testen durch kannst du deine Betatests erweitern, indem Du in der Google Play Developer Console eine Betatest-Gruppe erstellst. Hierüber lädst du dann mehrere Dutzend Leute ein, die sich im Play Store dann entsprechend dafür registrieren. Diese Funktion kannst du übrigens auch später noch für alle deine Spiel-Updates nutzen. Bevor du also ein Spiel direkt für alle Nutzer veröffentlichst, machst du das zuerst nur für die Betatester und wenn die dir das Okay geben, gibst du diese Version für alle frei.
Veröffentlichung im Play Store
Die Veröffentlichung auf Google Play ist bei Android ziemlich einfach. Du musst das Spiel in Unity3D zuerst für Android exportieren und erhältst hierbei eine apk-Datei. In der Developer Console legst du nun ein neues Spiel an, vergibst einen Namen und lädst die Apk-Datei hoch.
Als Nächstes geht es darum den Store-Eintrag vorzubereiten. Wir möchten unser Spiel weltweit anbieten. Daher legen wir zuerst Englisch als Standardsprache fest und fügen anschließend Deutsch als weitere Sprache hinzu. Dies machen wir deshalb in dieser Reihenfolge, da ansonsten alle Menschen ausserhalb der USA unseren Store-Eintrag in deutsch sehen würden.
Nun fügen wir unserem Spiel noch eine Beschreibung (einmal in Deutsch und einmal in Englisch), Screenshots und eine Kategorie hinzu.
Im nächsten Schritt erfolgt die Einstufung des Inhalts. Hier müssen wir eine Altersgrenze festlegen und im Zuge dessen gewisse Fragen beantworten, ob unser Spiel z.B. Gewaltszenen beinhaltet.
Nun kümmern wir uns noch um die Preisgestaltung und den Vertrieb. Wir bieten das Spiel kostenlos und ohne Werbung an und möchten, dass es in 141 Ländern + dem Rest der Welt verfügbar sein soll.
Nun sind wir auch schon bereit zur Veröffentlichung.
Fazit und Download
Und damit sind wir am Ende unseres Artikels angelangt und ich hoffe, ich konnte dir einen guten Einblick vermitteln, wie man ein Spiel für Android entwickelt und veröffentlicht. Unser Spiel Gravity Joe kannst du nun im Play Store herunterladen und spielen.
