Was ist Unity?
Unity ist eine Entwicklungsumgebung zur Erstellung und Gestaltung von Computerspielen. Mithilfe der integrierten Programmierumgebung
MonoDevelop haben Sie die Möglichkeit, die zahlreichen vorgefertigten Unity-Abläufe durch individuelle Programmierung in einer der
folgenden Sprachen aufzuwerten: UnityScript, C# (sprich: C-Sharp) oder Boo.
Unity-Projekte können auch zu Lern- und Trainingszwecken genutzt werden. Es kann sich dabei zum Beispiel um Projekte aus den Bereichen
VR (Virtual Reality = virtuelle Realität) oder AR (Augmented Reality = erweiterte Realität) handeln.
Unity wurde erstmals im Jahre 2004 vorgestellt. Aktuell gibt es Unity in der Version 2017.2. Unity wird in drei verschiedenen kommerziellen
Versionen, aber auch in der frei verfügbaren Version Unity Personal angeboten. Diese darf man privat oder innerhalb eines Unternehmens
nutzen, falls der Gewinn weniger als 100.000 US-Dollar pro Jahr beträgt.
Was machen wir mit Unity?
Unity bietet eine Vielfalt von Möglichkeiten. Man sollte sich zunächst mit den wichtigsten Elementen beschäftigen, die eine
selbständige Gestaltung und Programmierung der Projekte ermöglichen.
Ein Einstieg mit einfachen Flächen und Körpern vermittelt ein Verständnis für die Elemente im zweidimensionalen Raum und im
dreidimensionalen Raum. Darauf basierend lassen sich die Spiele Schritt für Schritt aufbauen. Man lernt, wie die Elemente
aufeinander reagieren, besonders unter physikalischen Bedingungen.
Die Elemente der Programmierung, zum Beispiel mit C#, sollte man von Grund auf kennenlernen, damit man vielseitige Spielabläufe
gestalten kann. Dadurch wird man in die Lage versetzt, die vorhandenen Spiele nach den eigenen Wünschen weiter zu verändern und
eigene Spiele selbständig zu entwickeln.
Man sollte nicht einfach vorgefertigte, komplexe Elemente miteinander kombinieren, wie sie zum Beispiel in großer Zahl im Asset
Store von Unity angeboten werden. Diese Elemente besitzen zwar eine Fülle von Fähigkeiten und bieten zahlreiche optische Effekte,
allerdings trägt das reine Einsetzen und punktuelle Verändern dieser Elemente nur wenig zum Verständnis ihres komplexen Aufbaus bei.
Sie vereinfachen auch nicht das Verständnis für den programmierten Spielablauf. Viele reichhaltig gestaltete Spielfiguren können
zudem nur mit externen Programmen erstellt werden und müssen danach zunächst in Unity importiert werden.
Es ist zu empfehlen, zunächst zweidimensionale Spiele (2D-Spiele) zu entwickeln. Dabei arbeitet man bereits mit vielen Unity-Elementen,
die später auch für die Entwicklung von dreidimensionalen Spielen (3D-Spiele) benötigt werden. 2D-Spiele finden ausschließlich auf der
Ebene des Bildschirms statt. Sie sind übersichtlicher und einfacher zu erfassen als 3D-Spiele. Man kann sich also auf das Erlernen der
Spiele-Entwicklung konzentrieren und muss sich nicht gleichzeitig mit der Orientierung, der Drehung und der Perspektive im dreidimensionalen
Raum befassen.
Ein Beispielprogramm
In diesem Abschnitt folgt als Beispiel ein Programmausschnitt aus einem 2D-Spiel, das Sie selber mithilfe von Unity entwickeln können.
Es verdeutlicht eine typische Spielsituation: Die Auswertung von Kollisionen zwischen Spielobjekten. Falls Sie bereits Kenntnisse
in einer Programmiersprache besitzen, finden Sie in dem Code, der in C# geschrieben ist, und in den kurzen Kommentaren viele bekannte
Elemente, aber auch Elemente, die für Unity und C# spezifisch sind.
Natürlich ist dieses Demo-Beispiel noch nicht zur gründlichen Einarbeitung in Unity geeignet. An dieser Stelle verweise ich auf mein
Buch beim Rheinwerk-Verlag.
Es handelt sich um ein einfaches Jump & Run-Spiel, siehe Abbildung 1. Ziel des Spiels ist es, Punkte zu sammeln und gleichzeitig Gefahren aus dem Wege zu gehen.
Abbildung 1: Jump & Run-Spiel, gesamte Spielfläche
Gemäß der Anleitung am oberen Rand des Spielfelds (siehe auch Abbildung 2) können Sie den schwarzen Spieler mit den Pfeiltasten Nach
Links und Nach Rechts in die entsprechenden Richtungen bewegen. Mit der Pfeiltaste Nach Oben können Sie den Spieler springen lassen.
Sie können den Spieler auch während eines Sprungs nach links oder rechts bewegen.
Abbildung 2: Jump & Run-Spiel, Anleitung (vergrößert)
Die weißen Plattformen können Sie für eine Landung und für einen weiteren Absprung nutzen. Berührt der Spieler bei einem Sprung den grünen Gewinn,
so erhalten Sie einen Punkt. Anschließend erscheint der Gewinn an einer anderen Stelle. Mit Verlauf des Spiels wird der Gewinn schwerer erreichbar,
da er weiter oben platziert wird. Nach dem Erreichen von sechs Punkten haben Sie das Spiel gewonnen. Die Zeit, die Sie dafür benötigt haben, wird
festgehalten.
Berührt der Spieler eine der roten, sich selbständig bewegenden Gefahren, so verliert er eines seiner drei Leben. Nach dem Verlust des
letzten Lebens ist das Spiel verloren.
Links oben in Abbildung 1 sehen Sie einige Anzeigen, siehe auch Abbildung 2:
- Ihren aktuellen Punktestand,
- die aktuelle Anzahl an Leben, die Ihnen noch verbleiben,
- die laufende Spielzeit seit der ersten Bewegung des Spielers und
- die Zeit die Sie beim vorherigen Versuch benötigt haben
Abbildung 3: Jump & Run-Spiel, Anzeige von Werten (vergrößert)
<
Rechts oben sehen Sie zwei Schaltflächen:
- zum Start eines neuen Spiels und
- zur Beendigung der gesamten Anwendung.
Am oberen Rande des Spielfelds erscheinen verschiedene Informationen. Zu Beginn steht dort die bereits erwähnte kurze Spielanleitung.
Nach Erlangen eines Punkts, nach Verlust eines Lebens und nach Spielende steht dort ein entsprechender Kommentar.
Es folgt der Ausschnitt des Programms, in dem die Kollisionen zwischen dem schwarzen Spieler, einem grünen Gewinn und einer roten Gefahr ausgewertet werden.
// Zusätzliche C#-Bibliotheken für Unity
using UnityEngine;
using UnityEngine.UI;
// Klasse, die das Verhalten des Spielers festlegt
public class Spieler : MonoBehaviour
{
...
// Funktion, die nach Eintreten einer Kollision durchlaufen wird
void OnCollisionEnter2D(Collision2D coll)
{
// Falls der schwarze Spieler mit einem grünen Gewinn kollidiert ist
if (coll.gameObject.tag == "Gewinn")
{
// Punktzahl des Spielers erhöhen
anzahlPunkte = anzahlPunkte + 1;
// Grünen Gewinn kurzzeitig deaktivieren
gewinn.SetActive (false);
// Falls das Spiel noch nicht zu Ende ist
if (anzahlPunkte < 6)
{
// Anzeige der Punktzahl aktualisieren
punkteAnzeige.text = "Punkte: " + anzahlPunkte;
if (anzahlPunkte == 1)
infoAnzeige.text = "Du hast bereits 1 Punkt!";
else
infoAnzeige.text = "Du hast bereits " + anzahlPunkte + " Punkte!";
// Grünen Gewinn nach zwei Sekunden wieder aktivieren
Invoke("NaechsterGewinn", 2);
}
// Falls das Spiel zu Ende ist
else
{
// Spiel-Ende anzeigen
infoAnzeige.text = "Du hast gewonnen!";
// Startzustand für nächstes Spiel herstellen
spielGestartet = false;
gameObject.SetActive (false);
// Spielzeit speichern
PlayerPrefs.SetFloat("zeitAlt", Time.time - zeitStart);
PlayerPrefs.Save();
}
}
// Falls der schwarze Spieler mit einer roten Gefahr kollidiert ist
else if (coll.gameObject.tag == "Gefahr")
{
// Anzahl der Leben des Spielers vermindern und anzeigen
anzahlLeben = anzahlLeben - 1;
lebenAnzeige.text = "Leben: " + anzahlLeben;
// Schwarzen Spieler kurzzeitig deaktivieren
gameObject.SetActive (false);
// Falls noch weitere Leben übrig sind
if (anzahlLeben > 0)
{
// Anzeige der Anzahl der Leben aktualisieren
infoAnzeige.text = "Du hast nur noch " + anzahlLeben + " Leben!";
// Schwarzen Spieler nach zwei Sekunden wieder aktivieren
Invoke ("NaechstesLeben", 2);
}
// Falls das letzte Leben verloren wurde
else
{
// Spiel-Ende anzeigen
infoAnzeige.text = "Du hast verloren!";
// Startzustand für nächstes Spiel herstellen
spielGestartet = false;
gewinn.SetActive (false);
}
}
}
// Grünen Gewinn an neuer Position wieder aktivieren
void NaechsterGewinn()
{
// Neue zufällige Position in x-Richtung ermitteln
float xNeu = Random.Range(-8.0f, 8.0f);
// Neue Position in y-Richtung ermitteln, abhängig vom Spielstand
float yNeu;
if (anzahlPunkte < 2) yNeu = -2.7f;
else if (anzahlPunkte < 4) yNeu = 0.15f;
else yNeu = 3;
// Grünen Gewinn auf die ermittelte Position setzen
gewinn.transform.position = new Vector3 (xNeu, yNeu, 0);
// Grünen Gewinn wieder aktivieren
gewinn.SetActive (true);
infoAnzeige.text = "";
}
// Schwarzen Spieler an Startposition wieder aktivieren
void NaechstesLeben()
{
// Startposition festlegen
transform.position = new Vector3(0, -4.4f, 0);
// Schwarzen Spieler wieder aktivieren
gameObject.SetActive(true);
infoAnzeige.text = "";
}
...
}
Aktuelle IT Jobs
» Informatiker / Softwareentwickler (m/w/d) Schwerpunkt .NET» Softwaretester (m/w/d)» (Junior) IT-Administrator / Server Engineer (m/w/d)» IT-Architekt*in IT-Infrastruktur Netzwerk und UCC (w/m/d)» IT-Architekt*in IT-Infrastruktur Arbeitsplatz und Verzeichnisdienste (w/m/d)» alle Jobs anzeigen