So erstellen Sie eine Android-App mit Unity

Bevor ich anfange, sollte ich wahrscheinlich erwähnen, dass dies ein ziemlich langwieriges Tutorial sein wird. Bereiten Sie sich also vor. Am Ende dieses Tutorials können Sie die Welt erobern (im übertragenen Sinne).

Vor ungefähr 2 Jahren habe ich Neuland betreten und einen Kurs in Game Design belegt. Ich hatte vorher noch nie versucht, ein Spiel richtig zu machen. Ich hatte versucht, in die Programmierung einzusteigen, konnte mich aber nicht darauf festlegen. Ich habe vielleicht ein paar sehr einfache Befehlszeilenprogramme geschrieben, die ein paar Zeilen lang waren, und dann einfach aufgegeben, weil ich mich nicht darum kümmern konnte.

Als ich meinen Kurs tatsächlich begann, war ich definitiv nicht daran gewöhnt. In den zwei Jahren habe ich viel gelernt und sehr gute Fortschritte gemacht und sogar einige Spiele und Apps entworfen und programmiert, von denen 2 für Android sind.

Gehen Sie etwas detaillierter vor. Da dies ein Kurs war, musste ich alles lernen, was mit Spieldesign und -entwicklung zu tun hatte. Ich habe gelernt, wie man Spielideen generiert, wie man eine Geschichte für das Spiel schreibt, wie man Charaktere konzipiert (ich habe eigentlich keine Charaktere entworfen), wie man ein Spieldesign-Dokument erstellt (was sehr nützlich ist, es hat keine Um sehr detailliert zu sein, wenn Sie ein Indie-Entwickler sind), wie man Unity Game Engine verwendet, um das Spiel tatsächlich zu erstellen, wie man das Spiel richtig testet und wie man ein Spiel für verschiedene Plattformen erstellt.

Schritt 1: Inhaltsverzeichnis

  1. Inhaltsverzeichnis
  2. Dinge, die Sie wissen müssen, bevor Sie beginnen
  3. So richten Sie Unity & Android Studio ein
  4. Projekt einrichten und Partikelfertigungen erstellen
  5. Effektskript erstellen und hinzufügen
  6. Erstellen und Hinzufügen von Touch-Steuerelementen
  7. Testen
  8. Hauptmenü & HUD erstellen
  9. Hierarchie organisieren
  10. Fazit

Schritt 2: Dinge, die Sie wissen müssen, bevor Sie beginnen

Viele Leute haben möglicherweise die falsche Vorstellung, dass das Design / die Entwicklung von Spielen extrem schwierig ist und viel Vorwissen erfordert, um tatsächlich eines zu erstellen. Dies ist jedoch weit von der Wahrheit entfernt. Die Verwendung einer Spiel-Engine reduziert die Lernkurve drastisch und ermöglicht es Ihnen, sich mehr darauf zu konzentrieren, dass das Spiel Spaß macht. Es gibt eine Vielzahl verschiedener Spiel-Engines. Die beliebtesten Optionen sind:

  • Einheit
  • Unwirkliche Engine
  • CryEngine

Unity und Unreal Engine sind beliebter als CryEngine. Dies liegt daran, dass sie sich an Indie-Entwickler und AAA-Entwickler richten, im Gegensatz zu CryEngine, das sich nur an AAA-Entwickler richtet. Der Unterschied zwischen Indie und AAA:

Indies bestehen aus kleinen Teams, normalerweise 1-20 Personen, und sie haben keine großen Geldbeträge usw.

Einige Beispiele für Indie-Entwickler:

  • Coffee Stain Studios
  • Halfbrick Studios
  • Mojang
  • Ndmeic Kreationen

AAAs bestehen aus viel größeren Teams und haben viel Erfahrung in der Branche sowie viel Geld. Einige Beispiele:

  • EA
  • Ubisoft
  • Gameloft
  • Treyarch
  • Aktivierung

Eine Spiel-Engine ist ein Programm, das das Design / die Entwicklung von Spielen erheblich vereinfacht. Anstatt jeden einzelnen Aspekt des Spiels selbst codieren zu müssen, können Sie das Verhalten einfach mit einer Spiel-Engine skripten. Dies wird durch die Tatsache ermöglicht, dass Game-Engines einen Großteil der Arbeit für Sie erledigen und Dinge wie Physik, Beleuchtung, Rendering usw. für Sie erledigt werden. Alles, was Sie tun müssen, ist, die Spielobjekte zu erstellen (dies sind nur Container mit verschiedenen Elementen), die Reihenfolge und das Layout festzulegen, den Spielobjekten die relevanten Eigenschaften zuzuweisen und das Verhalten zu skripten.

Bei einigen Game-Engines können Sie tatsächlich ein ganzes Spiel erstellen, ohne dass eine Codierung erforderlich ist. Die beliebteste ist Unreal Engine. Es verfügt über ein Blueprints-System, das eine knotenbasierte Struktur verwendet (im Wesentlichen nur ein System, das Kästchen und Pfeile verwendet. Diese Kästchen und Pfeile sind verknüpft, wenn sie Teil derselben Funktion sind). Angenommen, Sie wollten die Tastatureingabe abfangen (dies bedeutet nur, dass das Programm nach einer Taste Ausschau halten soll, die auf der Tastatur gedrückt wird) und den Player dann bewegen, solange diese bestimmte Taste gedrückt gehalten wird. Sie würden einen Basisknoten erstellen, der die erforderlichen Unterfunktionen enthält. In diesem Basisknoten deklarieren Sie den Schlüssel, den Sie verwenden möchten, und erstellen dann einen weiteren Knoten, der dem Spiel mitteilt, was zu tun ist. Der Basisknoten wäre eine Box, die die Funktion zum Drücken der Taste enthält.

In diesem Fall würde der zweite Knoten den Spieler veranlassen, sich in eine Richtung (z. B. vorwärts) zu bewegen, solange die Taste „W“ gedrückt gehalten wird. Der zweite Knoten wäre eine andere Box, die mit der ersten Box verbunden ist. Dies ist nicht nur für Designer, sondern auch für Programmierer äußerst nützlich, da sie schnell Prototypen erstellen können. Unity verfügt auch über diese Funktion, die als visuelles Scripting bezeichnet wird. Es handelt sich jedoch um einen Vermögenswert, den Sie kaufen müssen.

Unity ist eigentlich besser für Anfänger, die Spiele machen möchten, da es Ihnen das Schreiben von Skripten beibringt. Unreal Engine ist viel weiter fortgeschritten, obwohl es visuelles Scripting bietet. Was bedeutet, dass es eine größere Lernkurve gibt.

Schritt 3: Einrichten von Unity & Android Studio

Jetzt wissen Sie etwas mehr über Spiel-Engines und deren Funktionsweise. In diesem Tutorial wird Unity 5.3.5 verwendet, die derzeit die neueste Version ist. Ich werde Ihnen beibringen, wie Sie eine ästhetisch ansprechende Android-App erstellen. In diesem Tutorial wird davon ausgegangen, dass Sie ein grundlegendes Verständnis für die Verwendung von Unity haben. Wenn Sie ein absoluter Anfänger sind und diesem Tutorial folgen möchten, besuchen Sie bitte diesen Link, um sich mit den Grundlagen von Unity vertraut zu machen: //pixelnest.io/tutorials/2d-game-unity/

Stellen Sie sicher, dass Sie immer über die neueste Version von Unity verfügen, da diese Fehlerbehebungen und Verbesserungen enthält. Wenn Sie eine ältere Version von Unity haben, können möglicherweise Fehler auftreten. Diese Fehler können normalerweise durch Aktualisierung behoben werden. Ich sollte auch erwähnen, dass für das Erstellen einer mobilen Plattform das entsprechende SDK auf Ihrem Computer installiert sein muss (für Android benötigen Sie Android Studio. Für iOS benötigen Sie einen Mac mit installiertem Xcode.) Um Android Studio herunterzuladen, folgen Sie bitte diesem Link und stellen Sie ihn ein Verwenden Sie dazu die Anweisungen auf der Website: //developer.android.com/studio/index.html

Nach der Installation müssen Sie die Treiber für Ihr Telefon installieren, indem Sie Android Studio öffnen, auf Konfigurieren> SDK-Manager und dann auf Standalone-SDK-Manager starten klicken. Ein neues Fenster wird geöffnet. Scrollen Sie ganz nach unten und stellen Sie sicher, dass sowohl Google USB als auch Web Drivers ausgewählt sind. Sie können die anderen Komponenten standardmäßig ausgewählt lassen. Klicken Sie dann unten rechts auf Pakete installieren und warten Sie, bis die Installation abgeschlossen ist. Gehen Sie anschließend zur App "Einstellungen" auf Ihrem Telefon> "Über / Über das Telefon"> "Software-Informationen" und suchen Sie den Header "Build-Nummer". Es sollte eine Sammlung von Zahlen sein, an deren Ende Dezimalstellen und „Release-Keys“ angehängt sind. Tippen Sie mehrmals auf die "Build-Nummer", bis "Herzlichen Glückwunsch, Sie sind jetzt Entwickler" oder ähnliches angezeigt wird. Kehren Sie dann zu Ihrer Seite mit den Haupteinstellungen zurück und suchen Sie nach "Entwickleroptionen". Klicken Sie darauf und suchen Sie das Kontrollkästchen "USB-Debugging". Stellen Sie sicher, dass dies angekreuzt ist. Schließen Sie dann Ihr Telefon an Ihren Computer an und stellen Sie sicher, dass in der Benachrichtigungsleiste "USB-Debugging aktiviert" oder ähnliches angezeigt wird. Sie müssen die Leiste höchstwahrscheinlich erweitern, um die Meldung anzuzeigen.

Unabhängig davon, ob Sie die Treiber für Ihr Telefon installieren möchten, um sie in Unity verwenden zu können, muss Android Studio installiert sein, da Sie ohne sie die App für Ihr Telefon nicht erstellen können. Wenn das Einrichten der Treiber zu langwierig ist, befolgen Sie die alternativen Optionen im Abschnitt Testen dieses Lernprogramms. Nachdem Sie Android Studio installiert und das USB-Debugging eingerichtet haben, können Sie dieses Tutorial befolgen.

Dieses Tutorial basiert auf einem anderen Tutorial. Ich werde den Link dazu bereitstellen, wenn Sie es ausprobieren möchten. //pixelnest.io/tutorials/unity-touch-controls ...

Mein Tutorial behandelt mehr als das Original (Menü, HUD und Testen). Die Programmiersprache, die ich für dieses Tutorial verwenden werde, ist C #. Unity unterstützt auch JavaScript. C # verfügt jedoch über erweiterte Funktionen, die jedoch etwas schwieriger zu erlernen sind. Sie können den C # -Code in JS konvertieren, wenn Sie JS bereits kennen. Leider kann ich keine sprachspezifischen Fehler berücksichtigen, wenn Sie ihn verwenden. Ich werde Ihnen auch einige Tipps und Tricks beibringen, die ich während meiner Zeit beim Spielen gelernt habe. Lass uns anfangen.

Schritt 4: Einrichten des Projekts und Erstellen von Partikel-Fertighäusern

Projekt einrichten

Stellen Sie nach erfolgreicher Erstellung Ihres Projekts sicher, dass sich in Ihrem Assets-Ordner die folgenden Ordner befinden:

  • Schriftarten
  • Materialien
  • Speisekarte
  • Fertighäuser
  • Szenen
  • Skripte
  • Texturen

Dies sind die einzigen Ordner, die Sie für dieses Projekt benötigen. Wenn Sie sich jedoch dazu entschließen, es zu erweitern, können Sie nach Belieben weitere Ordner hinzufügen (Sounds, Animationen usw.).

Nachdem Sie die oben genannten Ordner erstellt haben, gehen Sie zu Datei> Build-Einstellungen. Klicken Sie in diesem Fenster auf die Android-Option unter der Überschrift "Plattformen" und dann auf "Plattform wechseln" in der unteren linken Ecke. Dadurch wird Unity mitgeteilt, dass Sie für Android erstellen, und das Projekt wird jeweils eingerichtet. Sie müssen Android Studio installiert haben, damit dies funktioniert. Speichern Sie dann die Szene, indem Sie entweder Strg + S drücken oder "Datei speichern" im Menü "Datei" auswählen. Speichern Sie diese Szene als "Hauptszene" in Ihrem Ordner "Szenen".

Erstellen von Fertighäusern

Oben ist ein Bild eines Sterns mit einem schwarzen Hintergrund. Speichern Sie dieses Bild in Ihrem Texturenordner. Sie werden es für das Partikelsystem verwenden.

Stellen Sie den Texturtyp auf Textur ein, indem Sie auf das Bild in Ihrem Texturenordner klicken und im Inspektor den entsprechenden Wert auswählen und dann auf Übernehmen klicken. Stellen Sie sicher, dass das Kontrollkästchen "Alpha ist Transparenz" aktiviert ist. Dadurch wird der Hintergrund des Sterns transparent.

Erstellen Sie dann ein Partikelsystem und richten Sie es mit den im obigen Screenshot gezeigten Werten ein.

Sie können diese Werte jederzeit ändern, sie sind nur eine Richtlinie. Wenn Sie mit diesen Werten herumspielen, erhalten Sie ein besseres Verständnis für die Funktionsweise.

Stellen Sie sicher, dass die Textur des Partikelsystems auf die Sternentextur eingestellt ist, indem Sie den Shader erweitern und die Sternentextur im Feld rechts auswählen. Oder Sie ziehen das Bild einfach per Drag & Drop aus Ihrem Textures-Ordner in das Feld. Wählen Sie auch den Mobile / Partikel / Alpha Blended Shader aus, indem Sie auf das Dropdown-Feld neben Shader und dann auf Mobil> Partikel> Alpha Blended klicken. Dadurch wird das Partikelsystem angewiesen, den Hintergrund des Sterns transparent zu machen und ihn für Android zu optimieren. Ändern Sie den Namen oben im Inspektor in "Explosion" und machen Sie dasselbe in der Hierarchie. Ziehen Sie dann dieses Explosionspartikelsystem aus der Hierarchie in Ihren Prefabs-Ordner in der Projektansicht. Dadurch wird ein Fertighaus dieses Partikelsystems erstellt.

Als nächstes erstellen wir ein Trail Prefab, das einen Trail zeichnet, solange Sie Ihren Finger auf dem Bildschirm ziehen. Wenn Sie Ihren Finger anheben, verschwindet die Spur nach einigen Sekunden.

Erstellen Sie ein neues leeres Spielobjekt (klicken Sie mit der rechten Maustaste in die Hierarchie und wählen Sie "Leer erstellen") und nennen Sie es "Trails" oder ähnliches. Fügen Sie dann eine Trail Renderer-Komponente hinzu. Richten Sie es mit den im obigen Screenshot angegebenen Werten ein.

Erstellen Sie ein neues Material, indem Sie in der Projektansicht auf den Ordner Materialien klicken, dann in der Projektansicht mit der rechten Maustaste klicken und auf Erstellen> Material klicken. Nennen Sie das Material Trails Material oder Trails Mat.

Klicken Sie dann in der Hierarchie auf das Trails-Spielobjekt und ziehen Sie die Trails-Matte aus der Projektansicht in das Inspektorfenster. Dadurch wird das Material dem Trails-Spielobjekt zugewiesen. Ziehen Sie dann dieses Trails-Spielobjekt in Ihren Prefabs-Ordner, um es zu einem Prefab zu machen.

Schließlich werden wir ein weiteres Partikelsystem erstellen, das sich vom ersten unterscheidet. Dieser wird langsam nach außen explodieren, keine Schwerkraft haben und langsam verblassen. Erstellen Sie ein anderes Partikelsystem und bezeichnen Sie es als Pinch Explosion (wir verwenden eine Pinch-Geste, um es zu initialisieren). Stellen Sie sicher, dass das Sternmaterial diesem Partikelsystem zugeordnet ist, und fügen Sie es dann einem Fertighaus hinzu.

Dies sind alle Effekte, die wir verwenden werden. Fühlen Sie sich frei, mehr zu erstellen, wenn Sie möchten, oder die vorhandenen zu ändern. Eine letzte Sache, bevor wir mit der Programmierung fortfahren können. Klicken Sie in der Hierarchie auf die Hauptkamera. Ändern Sie die Hintergrundfarbe entweder in Schwarz oder in eine andere dunkle Farbe und ändern Sie die Größe (unter dem Dropdown-Feld Projektion) von 5 auf 10. Dadurch können Sie mehr vom Hintergrund sehen. Schauen Sie sich den letzten Screenshot oben an, wenn Sie verwirrt sind.

Schritt 5: Erstellen und Hinzufügen eines Effektskripts

Erstellen des Skripts

Nachdem wir alle Fertighäuser erstellt haben, können wir mit der Programmierung fortfahren. Sie müssen ziemlich viel Code schreiben, da dies ein fortgeschritteneres Tutorial ist. Ich habe tatsächlich ein Dokument, das die Grundlagen der Programmierung erklärt, wenn Sie interessiert sind. Dies ist auch eine weitere ausführliche Lektüre. Ich habe es auf Dropbox hochgeladen, hier ist der Link:

//bit.ly/29qhLDx

Erstellen Sie ein neues C # -Skript in Ihrem Skriptordner (klicken Sie auf den Skriptordner und dann mit der rechten Maustaste in das Projektfenster> Erstellen> C # -Skript) und kennzeichnen Sie dieses Skript als "SpecialEffects". Öffnen Sie es in Ihrer gewünschten IDE (Integrated Development Environment) und schreiben Sie den folgenden Code Wort für Wort aus. Der Grund, warum ich Ihnen sage, dass Sie es Wort für Wort schreiben sollen, anstatt es zu kopieren / einzufügen, ist, dass Sie durch Eingabe es verstehen können, was der Code besser macht. Außerdem lernen Sie, Ihren Code auf Fehler zu überprüfen. Hier ist der Code:

 {/ * Macht dieses Skript zu einer privaten Statik, was bedeutet, dass auf die Funktionen dieses Skripts außerhalb dieses Skripts nicht zugegriffen werden kann und seine Werte sich nie ändern, es sei denn, Sie weisen es ausdrücklich der Instanz * / private static SpecialEffects an. 
 // Dies sind die vorgefertigten öffentlichen PartikelSystem ExplosionEffect, pinchExplosionEffect; öffentliches GameObject TrailsPrefab; 
 / * Diese Funktion wird aktiviert, wenn das Skript zum ersten Mal vor der Startfunktion initialisiert wird. Für die Startfunktion muss dieses Skript aktiviert sein, die Awake-Funktion wird jedoch ausgeführt, unabhängig davon, ob dieses Skript aktiviert ist. * / Void Awake () {// Zuweisen des Instanzwerts zu dieser Skriptinstanz = this; }} 
 // Verwenden Sie dies für die Initialisierung void Start () {// Sicherstellen, dass alle Prefabs aktiviert sind, wenn (Explosionseffekt == null) Debug.LogError ("Fehlender Explosionseffekt"); if (pinchExplosionEffect == null) Debug.LogError ("Fehlender Pinch-Explosionseffekt"); if (TrailsPrefab == null) Debug.LogError ("Prefab für fehlende Trails"); }} 
 // Explosionseffekt public static ParticleSystem MakeExplosion (Position Vector3) {// Wenn dieses Skript deaktiviert ist, protokolliere einen Fehler if (instance == null) {Debug.LogError ("Es gibt kein SpecialEffects-Skript in der Szene"); return null; }} 
 // Erzeugt den Explosionseffekt an der angegebenen Position. ParticleSystem effect = Instantiate (instance.explosionEffect) as ParticleSystem; effect.transform.position = position; // Zerstört den Explosionseffekt nach Abschluss des Effekts Destroy (effect.gameObject, effect.duration); Rückgabeeffekt; }} 
 // Explosionseffekt kneifen public static ParticleSystem MakePinchExplosion (Position Vector3) {// Wenn dieses Skript deaktiviert ist, protokollieren Sie einen Fehler if (instance == null) {Debug.LogError ("Es gibt kein SpecialEffects-Skript in der Szene"); return null; }} 
 // Erzeugt eine Pinch Explosion an der angegebenen Position. ParticleSystem effect = Instantiate (instance.pinchExplosionEffect) as ParticleSystem; effect.transform.position = position; Rückgabeeffekt; }} 
 // Trail Effect public static GameObject MakeTrail (Position Vector3) {// Wenn dieses Skript deaktiviert ist, protokolliere einen Fehler if (instance == null) {Debug.LogError ("Es gibt kein SpecialEffects-Skript in der Szene"); return null; } // Erstellt einen neuen Trail an der festgelegten Position GameObject trail = Instantiate (instance.trailsPrefab) as GameObject; trail.transform.position = position; Rückweg; }} 

Hinzufügen des Skripts zur Szene

Sehen Sie, das war nicht zu schwer, oder? Nachdem wir dieses Skript fertig haben, können wir es der Szene hinzufügen. Erstellen Sie ein neues leeres Spielobjekt, kennzeichnen Sie es als Skripte und ziehen Sie das Skript aus Ihrem Skriptordner auf das Skript-Spielobjekt.

Weisen Sie nun die Variablen ihren jeweiligen Prefabs zu, indem Sie das Prefab aus dem Prefabs-Ordner in der Projektansicht auf die Skripteigenschaften im Inspektorfenster ziehen. Siehe den Screenshot oben als Referenz.

Schritt 6: Erstellen und Hinzufügen eines Touch Controls-Skripts

Erstellen des Skripts

Jetzt ist es Zeit, die Touch-Steuerelemente für diese App zu programmieren. Die Hauptfunktion dieser App besteht darin, Effekte auszulösen, wenn der Bildschirm berührt wird. Die drei Gesten, die wir verwenden werden, sind ein Tippen, ein Wischen und eine Prise zum Zoomen. Sie können auch weitere Gesten hinzufügen, wenn Sie dies wünschen, dies müssen Sie jedoch von sich aus tun.

Die von uns ausgelösten Effekte variieren je nach Art der Berührungseingabe (Tippen, Streichen, Drücken zum Zoomen usw.). Auf diese Weise können wir sicherstellen, dass die richtige Geste erkannt wird.

Die Methode, mit der wir diese Gesten erkennen, verwendet die Unity-Klasse „Input“, die alle Informationen zu jeder Art von Eingabe an einem Ort zusammenfasst. Einige Beispiele für andere Eingänge sind Tastatur, Konsolensteuerung oder Touch.

Unity hat eine bestimmte Unterklasse namens Input.touches und enthält die Ereignisse für die verschiedenen Arten von Berührungen sowie deren Status in einem bestimmten Frame.

Ein Touch ist ein Container, der die Informationen zu den verschiedenen Fingern enthält, die wir beim Programmieren der Touch-Steuerelemente betrachten werden.

Die erste Art der Berührungsmethode, die wir implementieren werden, ist eine Prise, dann das Tippen und dann das Streichen. Eine Prise ist, wenn der Bildschirm mit zwei Fingern berührt und entweder nach außen oder nach innen gezogen wird. Ein Tippen ist, wenn der Bildschirm für eine kurze Zeit (normalerweise eine Sekunde) berührt wird. Es ist ähnlich wie beim Klicken mit der Maus. Ein Wischen ist, wenn der Bildschirm mit einem Finger berührt und über den Bildschirm gezogen wird.

Erstellen Sie ein neues Skript in Ihrem Skriptordner und bezeichnen Sie es als "TouchControls". Geben Sie dann den folgenden Code unter der Funktion Aktualisieren ein.

 mit UnityEngine; using System.Collections.Generic; 
 öffentliche Klasse TouchControls: MonoBehaviour {private Dictionary Trails = neues Wörterbuch (); private Touch pinchFinger1, pinchFinger2; private Partikelsystem pinchExplosion; 
 // Verwenden Sie dies für die Initialisierung void Start () {} // Update wird einmal pro Frame aufgerufen void Update () {// Dies sind die Touch-Steuerelemente 
 // Verwendet eine Schleife, um nach allen Fingern zu suchen // Steuerelemente für Pinch To Zoom, funktioniert nur mit 2 Fingern // Wenn 2 Finger auf dem Bildschirm angezeigt werden if (Input.touchCount == 2) {// Weisen Sie diese 2 Finger zu zu ihren eigenen Variablen var finger1 = Input.GetTouch (0); var finger2 = Input.GetTouch (1); 
 if (finger1.phase == TouchPhase.Began && finger2.phase == TouchPhase.Began) {this.pinchFinger1 = finger1; this.pinchFinger2 = finger2; }} 
 // Wenn sich die Finger bewegt haben, aktualisieren Sie das Skript an der neuen Position, wenn (finger1.phase == TouchPhase.Moved || finger2.phase == TouchPhase.Moved) {float baseDistance = Vector2.Distance (this.pinchFinger1.position, this.pinchFinger2.position); float currentDistance = Vector2.Distance (finger1.position, finger2.position); 
 // Purcent float currentDistancePurcent = currentDistance / baseDistance; 
 // Erzeugt den Effekt zwischen den Fingern, wenn er derzeit nicht vorhanden ist if (pinchExplosion == null) {Vector3 finger1Position = Camera.main.ScreenToWorldPoint (this.pinchFinger1.position); Vector3 finger2Position = Camera.main.ScreenToWorldPoint (this.pinchFinger2.position); 
 // Findet die Mitte zwischen den beiden Fingern Vector3 pinchExplosionPosition = Vector3.Lerp (finger1Position, finger2Position, 0.5f); pinchExplosion = SpecialEffects.MakePinchExplosion (pinchExplosionPosition); }} 
 // Nimmt die Basisskala und erhöht oder verringert sie pinchExplosion.transform.localScale = Vector3.one * (currentDistancePurcent * 1.5f); }} 
 else {// Wenn die Prise freigegeben wurde if (pinchExplosion! = null) {// Explosionen erstellen für (int i = 0; i <10; i ++) {var Explosion = SpecialEffects.MakeExplosion (pinchExplosion.transform.position); Explosion.transform.localScale = pinchExplosion.transform.localScale; }} 
 // Pinch Explosionseffekt zerstören Destroy (pinchExplosion.gameObject); }} 
 // Effekt tippen // Überprüft alle Finger auf (int i = 0; i <Input.touchCount; i ++) {Touch touch = Input.GetTouch (i); 
 // Ein Tippen ist eine schnelle Berührung und Freigabe, wenn (touch.phase == TouchPhase.Ended && touch.tapCount == 1) {// Berührungen Bildschirmpositionen sind, diese werden in Weltpositionen konvertiert. Vector3 position = Camera.main. ScreenToWorldPoint (touch.position); 
 // Erzeugt den Explosionseffekt SpecialEffects.MakeExplosion ((position)); }} 
 else {// Steuerelemente für die Wischgeste if (touch.phase == TouchPhase.Began) {// Diesen neuen Wert speichern if (trails.ContainsKey (i) == false) {// Berührungen sind Bildschirmpositionen, diese werden konvertiert in zu Weltstandorten Vector3 position = Camera.main.ScreenToWorldPoint (touch.position); // Stellt sicher, dass die Spur sichtbar ist position.z = 0; 
 // Erstellt den Trails-Effekt GameObject trail = SpecialEffects.MakeTrail (position); 
 // Wenn der Trail noch aktiviert ist if (trail! = Null) {// Protokolliere den Trail Debug.Log (trail); // Weitere Trails hinzufügen Trails.Add (i, trail); }}} 
 sonst if (touch.phase == TouchPhase.Moved) {// Verschiebt den Trail if (trails.ContainsKey (i)) {// Array für die Trails GameObject trail = trail [i]; 
 // Konvertiert Berührungen in Weltstandorte Camera.main.ScreenToWorldPoint (touch.position); Vector3 position = Camera.main.ScreenToWorldPoint (touch.position); // Stellt sicher, dass die Spur sichtbar ist position.z = 0; 
 // Setzt die Position der Trails auf die Position des Fingers. Trail.transform.position = position; }} 
 sonst if (touch.phase == TouchPhase.Ended) {// Löscht alle sichtbaren Trails if (trails.ContainsKey (i)) {GameObject trail = trail [i]; 
 // Blendet Trails aus Destroy (trail, trail.GetComponent (). Time); Spuren.Entfernen (i); }}}}}}} 

Für die Tap-Funktion rufen wir die Position aller auf dem Bildschirm platzierten Finger ab, unabhängig davon, ob es sich um einen oder vier Finger handelt, und erzeugen dann einen Explosionseffekt, wenn der Finger an der Position vor dem Bildschirm vom Bildschirm genommen wurde Finger wurde abgenommen.

Für die Drag-Funktion wurde eine neue Variable erstellt. Wir brauchen diese Variable, um die Verbindung zwischen einem Finger und einem Trail herzustellen. Was der Code macht:

Wenn eine neue Berührung erstellt wurde, erstellen Sie einen neuen Pfad und verknüpfen Sie ihn über das Wörterbuch mit dem Finger.

Wenn der Finger bewegt wird, wird die Position des Trail-Spielobjekts zusammen mit dem Finger bewegt, solange mit dem Finger eine Spur verknüpft ist.

Wenn der Finger abgehoben wird, wird die Spur zerstört.

Für die Pinch-Funktion wurden drei weitere neue Variablen erstellt. Diese Variablen speicherten die erste Position der Finger, die wir dann verwendeten, um die Differenz zwischen dem Abstand der Finger zu berechnen. Eine Variable für den Pinch Explosion-Effekt wurde ebenfalls erstellt, damit wir ihn aktualisieren und zerstören können.

Die Pinch-Funktion war komplizierter, da wir nicht wollten, dass sie mit etwas anderem verwechselt wird.

Wenn für die Pinch-Funktion zwei Finger auf dem Bildschirm erkannt werden, wird zwischen den beiden Positionen ein neuer Pinch Explosion-Effekt erzeugt. Danach wird die Geste als Prise deklariert. Wenn die Finger bewegt werden, wird auch das Pinch Explosion Game Object bewegt und mit skaliert.

Sobald die Prisexplosion abgeschlossen ist oder wenn ein Finger vom Bildschirm gehoben wird, wechselt er zur normalen Tap-Explosion.

Hinzufügen des Skripts zur Szene

Nachdem das Steuerelement-Skript vollständig ist, fügen Sie es der Szene auf dieselbe Weise wie das vorherige Skript hinzu, da es sonst nicht funktioniert.

Das ist die Hauptprogrammierung. Wir müssen noch etwas mehr für das Menü und das HUD programmieren, aber es wird viel weniger und leichter zu verstehen sein. Bevor wir jedoch zum Menü gelangen, müssen wir die App tatsächlich testen, um festzustellen, ob sie ordnungsgemäß funktioniert.

Schritt 7: Testen

Das Testen ist entscheidend für die Entwicklung von Software. Ohne Tests würden Sie nicht wissen, ob alles so funktioniert, wie es sollte.

Im Idealfall sollten Sie testen, sobald Sie eine neue Funktion implementieren. Für die Zwecke dieses Lernprogramms testen wir jedoch, nachdem wir die meisten Funktionen implementiert haben.

Es gibt mehrere Testmethoden. Am effektivsten ist es, die App auf einem Android-Handy zu erstellen und auszuführen, während Sie fortfahren. Mit Unity können Sie dies einfach verwalten, vorausgesetzt, Sie haben die richtigen Treiber installiert.

Bevor Sie die App tatsächlich erstellen und testen können, müssen Sie einige Dinge einrichten. Gehen Sie zu Bearbeiten> Projekteinstellungen> Player. Oben im Inspektorfenster sehen Sie "Firmenname" und "Produktname". Ändern Sie diese nach Ihren Wünschen. Erweitern Sie dann die Registerkarte "Andere Einstellungen", falls dies noch nicht geschehen ist, und gehen Sie zu "Bundle Identifier". Ändern Sie dies in com.CompanyNameYouSet.ProductNameYouSet. In meinem Fall ist mein Firmenname U und mein Produktname Instructables, daher lautet meine Bundle-ID com.U.Instructables. Wenn Sie dies nicht ändern, können Sie die App nicht für Android erstellen.

Wenn Sie die Treiber installiert haben, gehen Sie einfach zu Dateieinstellungen im Menü Datei. Klicken Sie dann auf "Offene Szenen hinzufügen". Es sollte die "Hauptszene" zur Liste hinzufügen und ihr die Nummer "0" geben. Stellen Sie anschließend sicher, dass Ihre ausgewählte Plattform Android ist und Ihr Telefon mit Ihrem Computer verbunden ist, und klicken Sie dann auf "Erstellen und Ausführen". Unity beginnt mit der Erstellung Ihrer App. Bevor die Erstellung jedoch vollständig abgeschlossen werden kann, muss der Speicherort Ihres Android SDK angegeben werden. Um diesen Speicherort zu finden, öffnen Sie Android Studio> Einstellungen konfigurieren> SDK-Manager und suchen Sie oben nach dem Speicherort für Android SDK. Dies ist der Ort, auf den Sie Unity zeigen müssen. Sobald Unity weiß, wo sich das SDK befindet, wird Ihre App weiter erstellt. Sobald die App fertig erstellt wurde, wird sie automatisch auf Ihrem Telefon ausgeführt. Sie können dann mit der App herumspielen und Ihre harte Arbeit genießen. Probieren Sie alle Gesten aus, um sicherzustellen, dass sie alle funktionieren.

Eine andere einfache Testmethode wäre, auf "Erstellen" anstatt auf "Erstellen und Ausführen" zu klicken und dann einen Speicherort auszuwählen, an dem die APK (Android-Dateierweiterung für ihre Apps) gespeichert werden soll. Sobald diese Datei gespeichert und erstellt wurde, müssen Sie sie in den Speicher Ihres Telefons übertragen und manuell auf Ihrem Telefon installieren. Mit dieser Methode senden Sie Ihre App auf Wunsch an andere Personen.

Eine andere Möglichkeit zum Testen ist der Unity Editor. Durch Drücken der Wiedergabetaste oben auf dem Bildschirm in der Mitte erstellt Unity Ihre App / Ihr Spiel und führt sie aus. Dies erspart Ihnen die Verwendung Ihres Telefons für kleinere Tests. Wenn Sie diese Methode jedoch zum Testen Ihres Spiels auf Android verwenden möchten, müssen Sie Unity Remote 4 aus dem Google Play Store oder dem iOS App Store herunterladen. Mit der Unity-Fernbedienung können Sie Ihr Spiel in Unity testen, ohne jedes Mal einen vollständigen Build erstellen zu müssen. Das spart viel Zeit. Eine Sache zu erwähnen ist, dass es die Qualität der Grafiken auf Ihrem Telefon verringert. Das ist aber notwendig. Es zeigt Ihnen immer noch gut, wie Ihre App / Ihr Spiel auf Ihrem Telefon aussehen wird. Wenn Sie für PC (Windows) bauen, können Sie das Spiel im Editor ohne zusätzliche Tools testen. Stellen Sie sicher, dass Sie den Wiedergabemodus in Unity verlassen, nachdem Sie Ihr Spiel getestet haben, da alle an Komponenten vorgenommenen Änderungen beim Verlassen des Wiedergabemodus rückgängig gemacht werden.

Diese Methoden sind am effektivsten, wenn es darum geht, Ihr Spiel zu testen, da Sie tatsächlich sehen können, ob Ihr Code so funktioniert, wie er sollte. Es gibt jedoch auch andere Methoden, die Sie verwenden können. Diese Methoden gelten für Microsoft Visual Studio, die von mir verwendete IDE. Sie sollten jedoch auch mit anderen IDEs synonym sein.

Eine Methode sind Haltepunkte. Angenommen, Sie schreiben Code und führen dann einen Fehler aus. Sie wissen nicht genau, wo Ihr Code falsch läuft, aber Sie haben eine allgemeine Vorstellung. Sie würden also Haltepunkte über, unter und auf dem fehlerhaften Code hinzufügen. Die Haltepunkte stoppen das Programm, wenn es den Haltepunkt erreicht, und geben Ihnen Informationen über das Programm bis zu diesem Haltepunkt.

Um einen Haltepunkt zu erstellen, suchen Sie die Zeile, in der Ihr Code Ihrer Meinung nach falsch läuft, und klicken Sie auf den ersten Rand links. Es sollte eine hellere Farbe als die Hauptseite haben. Ein roter Punkt sollte erscheinen. Wenn Sie mit der Maus über den roten Punkt fahren, wird Ihnen die Position des Haltepunkts angezeigt. Siehe den Screenshot als Referenz.

Im Screenshot habe ich die Zeile "if (explosionsEffect == null" als Fehler verwendet. Wenn Sie den Haltepunkt noch in Visual Studio haben, klicken Sie auf Debug> Debugging starten oder drücken Sie F5 auf der Tastatur. Dadurch wird das Programm ausgeführt Vereinheitlichen und verknüpfen Sie es mit VS. Am unteren Rand des VS-Fensters wird ein roter Balken mit der Aufschrift „Bereit“ angezeigt.

Gehen Sie nun zu Unity und klicken Sie auf das Wiedergabesymbol. Dadurch wird die App / das Spiel bis zum Haltepunkt ausgeführt. An diesem Punkt kehren Sie zum VS-Fenster mit Informationen darüber zurück, wie das Programm bis zum Haltepunkt ausgeführt wird. Wenn Ihr Spiel / Ihre App bis zum Haltepunkt einwandfrei läuft, ist diese Zeile nicht die mit dem Fehler. Wenn Ihr Programm jedoch vor dem Haltepunkt einen Fehler auslöst oder überhaupt nicht ausgeführt wird, kann es sich um diese Zeile oder die darüber liegenden Zeilen handeln. Um die fehlerhafte Zeile zu finden, müssen Sie so lange Haltepunkte hinzufügen, bis Sie sie gefunden haben. Die schnellste Methode besteht darin, mehrere Haltepunkte gleichzeitig anstelle eines hinzuzufügen. Dies ist eine sehr gute Testmethode und ermöglicht es Ihnen, genauer zu sein.

Wenn Sie Ihre Tests abgeschlossen haben, drücken Sie entweder Umschalt + F5, um das Debuggen in VS zu beenden, oder kehren Sie zum Debug-Menü zurück und klicken Sie auf "Debugging beenden". Dadurch wird das Debuggen gestoppt und das Unity-Projekt kann normal abgespielt werden.

Stellen Sie beim Testen sicher, dass Sie eine Kombination dieser Methoden verwenden und nicht nur eine, da Sie so genau feststellen können, wo Sie einen Fehler gemacht haben.

Seien Sie auch vorsichtig mit Rechtschreibung und Syntax, Programmiersprachen können ziemlich unversöhnlich sein, und C # ist eine dieser Sprachen. Wenn Sie etwas falsch buchstabieren, wird ein Fehler angezeigt, und es wird schwierig sein, diesen Fehler zu finden, da weder VS noch Unity Rechtschreibfehler berücksichtigen. Ich habe stundenlang versucht, einen Fehler zu beheben, nur um herauszufinden, dass ich eine Funktion oder Variable falsch geschrieben habe. Das Überprüfen Ihrer Rechtschreibung und Syntax während des Vorgangs ist eine gute Angewohnheit, da Sie dadurch Stunden beim Debuggen sparen. Wenn Sie den Punkt erreicht haben, an dem Sie Ihren Code vierfach überprüft haben und immer noch nicht herausfinden können, was falsch ist, lassen Sie jemanden Ihren Code überprüfen. Idealerweise möchten Sie einen anderen Programmierer oder jemanden, der zumindest Programmierkenntnisse hat. Wenn Sie jedoch niemanden haben, der sich mit Programmieren auskennt, sollten Sie sich jemanden ansehen, der gerade bei Ihnen ist. Sagen Sie ihnen, sie sollen gezielt nach Rechtschreibfehlern suchen, da sie diese möglicherweise herausfinden können, wenn Sie dies nicht können.

Versuchen Sie, nicht zu frustriert zu werden, wenn Sie einen Rechtschreibfehler machen und es ewig dauert, bis Sie ihn finden. Es passiert jedem. Es ist eine der Freuden, Programmierer zu sein.

Nachdem wir uns mit dem Testen befasst haben, können wir mit der Erstellung des Menüs und des HUD fortfahren.

Schritt 8: Erstellen des Hauptmenüs und des HUD

Das Erstellen eines Menüs / HUD für Ihre App ist eigentlich ziemlich wichtig. Das Hauptmenü gibt dem Spieler Informationen zu Ihrer App und ermöglicht ihm normalerweise, bestimmte Aspekte der App zu steuern. In diesem Tutorial lernen wir nicht, wie man das Menü so programmiert, dass der Player die Einstellungen ändern kann, da der Player tatsächlich nichts ändern kann (es gibt keinen Sound, keine Musik usw.). Ich denke darüber nach, einige Soundeffekte hinzuzufügen und möglicherweise Musik, aber diese werden in einem späteren Tutorial kommen. Das Hauptmenü, das wir erstellen werden, ist eher einfach, aber dennoch ästhetisch ansprechend. Wir haben einen Titel und drei Schaltflächen (Wiedergabe, Hilfe und Beenden). Mit der Wiedergabetaste gelangen Sie einfach zur Hauptszene, mit der Hilfeschaltfläche gelangen Sie zu einem Bedienfeld mit der Hilfedatei, und die Schaltfläche Beenden wird einfach beendet das Spiel. Ich zeige Ihnen zwei Möglichkeiten, um die Schaltfläche Beenden zu implementieren. Die erste Methode ist etwas einfacher.

Sie können jede gewünschte Schriftart, jedes gewünschte Hintergrundbild usw. verwenden, sofern dies zum Thema des Spiels passt. Stellen Sie außerdem sicher, dass Ihre Assets für Ihr Spiel urheberrechtsfrei sind oder kommerziell verwendet werden können, wenn Sie vorhaben, sie in einem App Store zu veröffentlichen, da Sie sonst auf rechtliche Probleme stoßen könnten. Für dieses Tutorial werde ich dieses Bild der Region des Galaktischen Zentrums verwenden:

//bit.ly/29eP2jB

Und diese Schriftarten:

//www.dafont.com/fineliner-script.font

//www.dafont.com/post-it-penscript.font

Die Schriftarten werden am Ende dieses Schritts angehängt und das Bild befindet sich oben, wenn Sie diese Elemente für Ihre App verwenden möchten.

Nachdem Sie die gewünschten Schriftarten und Bilder heruntergeladen haben, importieren Sie sie in die entsprechenden Ordner in Ihr Unity-Projekt (Schriftarten befinden sich im Ordner "Schriftarten" und das Bild im Menüordner.)

Menü erstellen

Um das Menü zu erstellen, müssen wir eine neue Szene erstellen. Drücken Sie entweder Strg + N oder gehen Sie zu Datei> Neue Szene. Speichern Sie es als Menü oder Hauptmenü.

Nachdem wir unsere Szene haben, müssen wir eine Leinwand hinzufügen. Mit diesem Canvas können wir alle erforderlichen UI-Funktionen nutzen. Stellen Sie sich das als Overlay vor, das immer die exakte Größe Ihres Bildschirms hat.

Um eine Leinwand zu erstellen, klicken Sie mit der rechten Maustaste auf Hierarchie> Benutzeroberfläche> Leinwand. Stellen Sie im Inspektorfenster der Leinwand sicher, dass der Rendermodus auf Bildschirmbereich - Überlagerung eingestellt ist, und aktivieren Sie die Option Pixel perfekt. Ändern Sie unter der Canvas Scaler-Komponente den Skalierungsmodus von Konstante Pixelgröße in Mit Bildschirmgröße skalieren. Auf diese Weise können alle Komponenten des Canvas vergrößert oder verkleinert werden, wenn die Bildschirmauflösung zunimmt oder abnimmt. Ändern Sie die Referenzauflösung in die Auflösung Ihres Telefonbildschirms in der Querformatansicht (meine ist 1920 x 1080) und ändern Sie den Übereinstimmungswert von 0 auf 0, 5. Dadurch wird sichergestellt, dass die Komponenten in Breite und Höhe gleich skaliert werden.

Jetzt müssen Sie Ihre Spielansicht ändern, um sie an die Referenzauflösung Ihres Canvas anzupassen. Klicken Sie dazu oben auf die Registerkarte Spiel. Links sollte sich ein Pacman-Symbol befinden. Wenn Sie es nicht sehen können, gehen Sie zu Fenster> Spiel oder drücken Sie Strg + 2. Schauen Sie oben links im Spielfenster und Sie sollten ein Dropdown-Feld mit der Aufschrift Free Aspect sehen. Klick es an. Unten sollte sich ein Plus-Symbol befinden. Klicken Sie darauf und ändern Sie den Typ von Seitenverhältnis in Feste Auflösung. Beschriften Sie es mit der Bildschirmauflösung Ihres Telefons (meine ist 1080p) und ändern Sie die Breite und Höhe entsprechend Ihrer gewünschten Auflösung. Auf diese Weise können Sie Ihre Komponenten so skalieren, dass sie auf Ihrem Telefon korrekt angezeigt werden. Wenn Sie es auf Free Aspect belassen, ist es schwierig, Ihre Komponenten entsprechend zu skalieren.

Erstellen Sie ein Panel (genauso wie Sie den Canvas erstellt haben, wählen Sie nur dieses Mal stattdessen das Panel). Wenn Ihr Canvas bereits ausgewählt ist, sollte das Panel automatisch ein untergeordnetes Element des Canvas werden.

In der Einheit sind Kinder und Eltern äußerst wichtig. Ein Kind ist eine Teilmenge des Elternteils, es erbt bestimmte Eigenschaften vom Elternteil. So unterscheiden Sie zwischen einem Kind und einem Elternteil: Ein Elternteil hat links neben seinem Namen einen Pfeil, auf den Sie klicken können, um die Kinder anzuzeigen oder auszublenden.

Um ein untergeordnetes Objekt zu erstellen, müssen Sie entweder entweder mit der rechten Maustaste auf ein Objekt in der Hierarchie klicken und dann Ihr untergeordnetes Objekt aus dem daraufhin angezeigten Menü erstellen, oder Sie können ein Objekt auf ein anderes ziehen, um es zu einem untergeordneten Objekt dieses Objekts zu machen. Im obigen Screenshot habe ich ein leeres Spielobjekt erstellt und auf die Leinwand gezogen, um das leere Spielobjekt zu einem untergeordneten Element der Leinwand zu machen. Dies ist äußerst nützlich und in einigen Fällen kritisch. Wenn Sie beispielsweise ein Bedienfeld außerhalb des Canvas-Bereichs erstellt haben (wenn das Bedienfeld ein übergeordnetes Element war) und es auf die gleiche Größe wie das Canvas skalieren möchten, müssen Sie die Abmessungen des Canvas-Bereichs ermitteln und dann manuell festlegen Abmessungen des Panels müssen gleich sein. Wenn das Panel jedoch ein Kind der Leinwand war, können Sie es einfach mit den Ankern skalieren (was ich gleich erläutern werde). Wenn Sie das Panel als untergeordnetes Element des Canvas erstellt haben, wird das Panel automatisch auf das Canvas skaliert. Es gibt auch das leichte Problem, dass UI-Elemente nur sichtbar sind, wenn sie alle untergeordnete Elemente des Canvas sind. Eltern / Kinder sind auch nützlich für die Organisation der Hierarchie, auf die ich bald noch eingehen werde.

Nachdem wir dieses Panel haben, können wir das Hintergrundbild einrichten. Bevor wir dies tun, müssen wir sie entsprechend benennen, den Namen des Canvas in der Hierarchie in Menu Canvas ändern und den Namen des Panels in Hintergrundbild ändern. Klicken Sie nun auf das Hintergrundbildfenster und sehen Sie sich das Inspektorfenster an. Es sollte eine Image (Script) -Komponente angehängt sein. Suchen Sie nach dem Quellbild. Um dieses Bild zu ändern, ziehen Sie das heruntergeladene Bild entweder per Drag & Drop aus Ihrem Projektfenster in das Feld oder klicken Sie auf das Symbol eines Kreises mit einem kleinen Punkt in der Mitte. Das sollte ein weiteres Fenster mit der Bezeichnung Select Sprite öffnen. In diesem Fenster können Sie dann Ihren Hintergrund auswählen. Wenn Sie Ihr Bild nicht sehen können, stellen Sie sicher, dass der Bildtyp als Sprite (2D & UI) festgelegt ist.

Nachdem Sie Ihren Hintergrund ausgewählt haben, müssen Sie das Alpha erhöhen. Klicken Sie dazu auf das Feld Farbe. Unten befindet sich ein Schieberegler mit der Bezeichnung A. Ziehen Sie diesen ganz nach rechts, bis er am Ende von ist Der weiße Bereich und sein Wert sind auf 255 eingestellt. Sie können das Bild auch in diesem Fenster in einer bestimmten Farbe tönen, wenn Sie dies wünschen.

Erstellen Sie zum Einrichten des Titels ein Textobjekt als untergeordnetes Element des Hintergrundbilds. Benennen Sie es in Titel um. Ändern Sie die Farbe des Textes in Weiß und stellen Sie sicher, dass alle nachfolgenden von Ihnen erstellten Textspielobjekte ebenfalls weiß sind. Ändern Sie im Abschnitt "Text" von "Neuer Text" in den gewünschten Titel (in diesem Fall "Instructables") und ändern Sie die Schriftart in Ihre bevorzugte Schriftart (ich verwende die Postit-Penscript-Schriftart). Ändern Sie unter der Überschrift "Absatz" die Ausrichtung nach Ihren Wünschen. Ich zentriere meinen Text in der vertikalen und horizontalen Achse. Klicken Sie anschließend auf Best Fit und ändern Sie die maximale Größe so, dass sie am besten zu Ihrer Schriftart passt. Meine Schrift ist ziemlich dünn, daher verwende ich 90 als maximale Größe. Stellen Sie sicher, dass Sie für jedes nachfolgende von Ihnen erstellte Textspielobjekt auf die Option "Beste Anpassung" klicken.

Schauen Sie dann oben rechts unter der Überschrift "Rechteckentransformation" nach oben und links im Feld sollte ein Feld mit Linien und Text angezeigt werden. Es sollte oben in der Mitte und links in der Mitte stehen. Klicken Sie auf dieses Feld, halten Sie Alt und Umschalt gedrückt und klicken Sie auf das Symbol über dem mittleren / mittleren Symbol. Überprüfen Sie den Screenshot als Referenz. Wenn Sie nun das Feld schließen, sollte oben oben und links oben zentriert sein und Ihr Text sollte oben zentriert sein. Dies ist der Anker und äußerst nützlich beim Anordnen von Spielobjekten. Wenn Sie Alt gedrückt halten, wird die Position des Objekts auf den neuen Ankerpunkt gesetzt, und wenn Sie die Umschalttaste gedrückt halten, wird der Drehpunkt festgelegt. Sie müssen die Positionen der Objekte nicht manuell festlegen.

Wenn Sie rechts neben dem Feld "Rechteckentransformation" nachsehen, sollten Sie eine Reihe von Zahlen sehen. Dies sind die Abmessungen und die Position des Objekts. Sie möchten sich auf die Felder Pos X, Pos Y, Breite und Höhe konzentrieren. Die Breite und Höhe sind selbsterklärend. Die Position X bewegt das Objekt horizontal und die Position Y bewegt es vertikal. Diese Felder ändern sich jedoch je nach verwendetem Anker. Wenn Sie den Uniform Stretch Anchor verwenden, wechselt Pos X & Y zu Right, Left Top & Down, was dasselbe bewirkt, Ihnen jedoch mehr Kontrolle ermöglicht. Sie können entweder entlang der Beschriftung dieser Felder ziehen, um das Objekt zu verschieben, die Zahlen manuell eingeben oder sie mit den Unity-Werkzeugen verschieben. Ändern Sie die Position Y von 0 auf -10. Dadurch erhalten Sie 10 Pixel Platz vom oberen Rand des Hintergrundbilds, sodass es etwas sauberer aussieht.

Klicken Sie auf Komponente hinzufügen und fügen Sie einen Schatten und eine Gliederung hinzu. Erhöhen Sie das Alpha von beiden auf 255. Dadurch hebt es sich besser vom Hintergrund ab. Stellen Sie sicher, dass Sie jedem nachfolgenden von Ihnen erstellten Textspielobjekt eine Schatten- und Gliederungskomponente hinzufügen.

Jetzt, da wir unseren Hintergrund haben, ist es Zeit, die Schaltflächen einzurichten. Erstellen Sie als untergeordnetes Element des Hintergrundbildbedienfelds ein leeres Spielobjekt und nennen Sie es Schaltflächen-Layout-Manager. Klicken Sie im Inspektorfenster dieses leeren Spielobjekts auf Komponente hinzufügen, suchen Sie nach der vertikalen Layoutgruppe und fügen Sie sie dem Objekt hinzu. Dieses Spielobjekt hält die Platzierung der Schaltflächen konsistent. Ändern Sie den Anker in Stretch Uniform (unten rechts) und ändern Sie die Position und schwenken Sie damit. Der Schaltflächen-Layout-Manager sollte nun den gesamten Bildschirm einnehmen. Ziehen Sie es von oben nach unten, bis es 3 Rasterfelder einnimmt, und ziehen Sie es von rechts, bis es zwei Rasterfelder einnimmt. Wenn Sie das Raster nicht sehen können, schauen Sie oben im Szenenfenster nach, wo Gizmos steht. Klicken Sie darauf und dann auf Raster anzeigen.

Erstellen Sie nun ein weiteres Textspielobjekt als untergeordnetes Element des Hintergrundbilds und richten Sie es wie gewünscht ein. Beschriften Sie es Start. Wenn Sie mehrere Schriftarten verwenden, verwenden Sie Ihre zweite Schriftart für die Schaltfläche und behalten Sie die erste Schriftart nur für Ihre Titel bei. Ich werde die Schriftart Fineliner_Script für meine Schaltflächen verwenden. Sie können die Schaltflächen in jeder gewünschten Größe gestalten, sofern sie deutlich sichtbar sind. Eine gute Regel ist, die Tastengröße 10 oder 20 Pixel kleiner als der Titel zu machen. Wenn also der Titel auf Größe 90 eingestellt ist, würden Sie die Tastengröße auf 80 oder 70 einstellen. Ich werde meine Tastengröße auf 70 einstellen Ändern Sie den Text in Start und richten Sie die Ausrichtung nach Ihren Wünschen ein. Fügen Sie eine Schaltflächenkomponente hinzu und ändern Sie die hervorgehobenen und gepressten Farben in Ihre bevorzugten Farben. Stellen Sie sicher, dass die gepresste Farbe dunkler als die hervorgehobene ist. Ich werde meine Hervorhebung auf Hellblau und die gepresste Farbe auf Dunkelblau einstellen. Fügen Sie nun eine Schatten- und eine Gliederungskomponente hinzu und erhöhen Sie das Alpha auf voll.

Duplizieren Sie diese Schaltfläche zweimal (indem Sie mit der rechten Maustaste auf die Schaltfläche klicken und Duplizieren auswählen oder auf die Schaltfläche klicken und Strg + D drücken), sodass Sie insgesamt drei Schaltflächen erhalten. Rufen Sie eine der Hilfetasten und die andere Beenden auf. Ändern Sie den Text dieser, um ihre Beschriftungen wiederzugeben. Machen Sie sie zu Kindern des Layout Managers.

Erstellen Sie ein Panel, nennen Sie es Help Panel und stellen Sie das Quellbild so ein, dass es mit dem Hintergrundbild übereinstimmt. Es sollte bereits die richtige Größe haben. Erhöhen Sie das Alpha auf voll. Duplizieren Sie den Titel und machen Sie ihn zu einem untergeordneten Element des Hilfefensters. Ändern Sie den Namen des Spielobjekts in den Titel des Hilfefensters und den Text in das Hilfefenster. Es sollte sich bereits an der richtigen Stelle befinden.

Duplizieren Sie eine der Schaltflächen und benennen Sie sie in Zurück um. Machen Sie es zu einem untergeordneten Element des Hilfefensters und ändern Sie den Text der Schaltfläche in Zurück. Setzen Sie den Anker, positionieren und schwenken Sie nach unten links und ändern Sie die Position X auf 10.

Erstellen Sie ein anderes Textspielobjekt als untergeordnetes Element des Hilfefensters, beschriften Sie es als Hilfetextkörper und setzen Sie seinen Anker auf Stretch Uniform. Ändern Sie das obere Feld von 0 in 110. Ändern Sie das linke, rechte und untere Feld in 10. Richten Sie die Schriftart ein und verwenden Sie dieselbe Schriftart wie die Schaltflächen. Ändern Sie die maximale Größe auf 80. Zentrieren Sie den Text in beiden Achsen. Kopieren Sie dann den folgenden Text und fügen Sie ihn in das Textfeld ein:

Mit dieser App können Sie verschiedene Effekte auf Ihrem Telefon erstellen. Durch Tippen auf den Bildschirm wird eine Explosion ausgelöst, durch Drücken des Bildschirms wird eine größere Explosion ausgelöst, und durch Ziehen des Bildschirms wird eine Spur erstellt.

Oder erstellen Sie Ihren eigenen Hilfetext.

Gehen Sie nun zu Datei> Build-Einstellungen> Offene Szenen hinzufügen. Ihre Menüszene sollte jetzt hinzugefügt werden. Ziehen Sie Ihre Menüszene nach oben, sodass ihre Nummer 0 und die Hauptszene 1 ist. Wenn Sie dies nicht tun, können Sie Ihr Menü beim Erstellen der App nicht anzeigen und können es auch nicht um die Hauptszene zu laden, wenn Sie auf Start klicken.

Nachdem wir das Menü eingerichtet haben, können wir es so programmieren, dass es tatsächlich etwas bewirkt.

Menü programmieren

Erstellen Sie ein neues Skript und nennen Sie es Menü. Geben Sie dann den folgenden Code ein:

 mit UnityEngine; // Dieser Namespace wird benötigt, um UI-Komponenten mit UnityEngine.UI zu verwenden. // Dieser Namespace ist erforderlich, um den SceneManager mit UnityEngine.SceneManagement zu verwenden. using System.Collections; public class Menü: MonoBehaviour {// Dies sind alle Schaltflächen // ------------------------------- public Button start; öffentliche Button-Hilfe; öffentlicher Button-Ausgang; öffentlicher Knopf zurück; // ------------------------------- // Dies ist das öffentliche GameObject helpPanel des Hilfefensters. // ------------------------------- // Verwenden Sie dies für die Initialisierung void Start () {// Deaktiviert das Panel-HelpPanel .SetActive (false); } // Update wird einmal pro Frame aufgerufen void Update () {} // Funktion für Start Button, lädt Hauptszene public void StartPress () {SceneManager.LoadScene (1); } // Funktion für Hilfeschaltfläche, aktiviert das Hilfetool public void HelpPress () {helpPanel.SetActive (true); } // Funktion für Exit Button, beendet die Anwendung public void ExitPress () {Application.Quit (); } // Funktion für Zurück-Schaltfläche, deaktiviert das Hilfefenster public void BackPress () {helpPanel.SetActive (false); }} 

Ziehen Sie dieses Skript auf den Menübereich und scrollen Sie dann im Inspektorfenster nach unten. Du solltest haben:

Start

Hilfe

Ausgang

Zurück

Hilfe

Ziehen Sie die relevanten Spielobjekte in die entsprechenden Felder. Sehen Sie sich den Screenshot oben an, wenn Sie sich nicht sicher sind.

Klicken Sie nun bei gedrückter Strg-Taste auf die Schaltflächen Start, Hilfe, Beenden und Zurück und scrollen Sie nach unten zur Schaltfläche (Skript). Am Ende dieser Komponente befindet sich eine leere Liste mit der Aufschrift On Click (). Klicken Sie auf das Plus-Symbol. Ziehen Sie nun das Menü-Canvas-Spielobjekt in das Feld Keine (Objekt). Das Dropdown-Feld Keine Funktion sollte jetzt aktiv sein.

Klicken Sie auf die Schaltfläche Start, dann auf die Dropdown-Liste Keine Funktion und gehen Sie zum Ende der Liste, in der Menü steht. Klicken Sie dann auf StartPress (). Es sollte jetzt Menü sagen. StartPress in der Dropdown-Box. Machen Sie dasselbe für die Schaltflächen Hilfe, Beenden und Zurück, aber stellen Sie sicher, dass Sie die richtige Druckfunktion für sie auswählen. Die Hilfeschaltfläche sollte HelpPress, die Exit-Schaltfläche ExitPress und die Back-Schaltfläche BackPress enthalten. Klicken Sie nun auf das Wiedergabesymbol und testen Sie es, klicken Sie auf die Schaltfläche Hilfe und prüfen Sie, ob das Hilfefenster geladen wird. Wenn Sie auf die Schaltfläche Beenden klicken, wird nichts ausgeführt, es sei denn, Sie haben die App für Android erstellt. Sie müssen die Schaltfläche Beenden auf Ihrem Telefon testen. Durch Klicken auf die Schaltfläche Wiedergabe gelangen Sie zur Hauptszene.

Vielleicht ist jetzt ein guter Zeitpunkt, um Ihre App auf Ihrem Telefon zu testen. Erstellen Sie sie, führen Sie sie aus und stellen Sie sicher, dass Ihr Menü voll funktionsfähig ist.

Wie bereits erwähnt, gibt es mehrere Methoden zum Erstellen der Exit-Funktion. Ich habe dir nur den einfachsten Weg gezeigt. Dies ist die zweite Methode.

Erstellen Sie ein weiteres Panel als untergeordnetes Element des Hintergrundbilds und nennen Sie es "Panel beenden". Stellen Sie die Hintergrundfarbe so ein, dass sie mit dem Hintergrund übereinstimmt (ich habe ein Dunkelblau gewählt) und setzen Sie oben und unten auf 450 und rechts und links auf 760. Dadurch wird das Feld auf dem Bildschirm zentriert.

Duplizieren Sie den Titel und machen Sie ihn zu einem untergeordneten Element des Exit-Panels. Verringern Sie die Größe des Texts etwas, damit er sichtbar ist, aber nicht zu viel Platz beansprucht. Stellen Sie sicher, dass es oben zentriert ist.

Duplizieren Sie die Wiedergabetaste zweimal, machen Sie beide Duplikate zu untergeordneten Elementen des Exit-Bedienfelds und ändern Sie den Anker, die Position und den Drehpunkt einer der Tasten nach unten links. Ändern Sie den anderen nach rechts unten.

Ändern Sie den Namen der Schaltfläche unten rechts in Ja und machen Sie dasselbe mit dem Text. Ändern Sie die untere linke in Nein (Name und Text).

Öffnen Sie Ihr Menüskript und fügen Sie 2 Schaltflächen unter der Zurück-Schaltfläche und ein GameObject unter der Hilfe mit dem folgenden Code hinzu:

 öffentlicher Button ja; public Button no; 
 öffentliches GameObject exitPanel; 

Fügen Sie den folgenden Code in die Startfunktion unter helpPanel.SetActive (false) ein. Linie:

 exitPanel.SetActive (false); 

Ändern Sie die ExitPress-Funktion von

 Application.Quit (); 

zu

 exitPanel.SetActive (true); 

Scrollen Sie dann bis zum Ende des Skripts und fügen Sie unter der Funktion BackPress () den folgenden Code hinzu:

 public void YesPress () {Application.Quit (); } public void NoPress () {exitPanel.SetActive (false); }} 

Kehren Sie schließlich zu Unity zurück, klicken Sie auf die Schaltfläche Ja und ändern Sie die Funktion von StartPress () in YesPress () und ändern Sie die Schaltfläche Nein in NoPress (). Stellen Sie außerdem sicher, dass Sie die neuen öffentlichen Variablen im Menü-Canvas-Skript zuweisen (klicken Sie auf Menü-Canvas und ziehen Sie die Schaltflächen und das Bedienfeld in die entsprechenden Felder). Drücken Sie nun Play und testen Sie die Exit-Taste. Sie sollte das Exit-Panel laden und schließen, wenn Sie die No-Taste drücken. Wie Sie sehen können, ist diese Methode etwas länger, bietet jedoch Schutz für den Fall, dass der Spieler versehentlich auf die Schaltfläche Beenden klickt. Fühlen Sie sich frei, welche Methode Sie wählen.

Nun fahren wir mit dem letzten Schritt fort und erstellen das HUD, das äußerst einfach ist und aus einer Schaltfläche besteht. Ich könnte ein weiteres Tutorial hinzufügen, das ein umfangreicheres HUD abdeckt (mit einem Gesundheitsregler, einem Score-Zähler und einem tatsächlichen Pausenmenü), aber für den Moment wird dies ausreichen.

Erstellen und Programmieren des HUD

Kehren Sie zu Ihrer Hauptszene zurück und erstellen Sie eine neue Leinwand. Beschriften Sie es mit HUD Canvas und richten Sie es genauso ein wie das Hauptmenü Canvas.

Fügen Sie ein Textspielobjekt als untergeordnetes Element der Leinwand hinzu, nennen Sie es Zurück zum Hauptmenü und richten Sie die Schriftarten, die Größe und die Ausrichtung nach Ihren Wünschen ein. Alternativ können Sie eine der Hauptmenü-Schaltflächen zu einem Fertighaus machen und sie dann einfach auf Ihre Leinwand ziehen. Sobald Sie die Schaltfläche eingerichtet haben, ändern Sie ihren Anker, ihre Position und drehen Sie sie nach links unten. Erstellen Sie ein neues Skript mit dem Namen HUD und geben Sie den folgenden Code ein:

 mit UnityEngine; // Dieser Namespace wird benötigt, um UI-Komponenten mit UnityEngine.UI zu verwenden. // Dieser Namespace ist erforderlich, um den SceneManager mit UnityEngine.SceneManagement zu verwenden. using System.Collections; public class HUD: MonoBehaviour {// Button public Button backToMainMenu; // Verwenden Sie dies für die Initialisierung void Start () {} // Update wird einmal pro Frame aufgerufen void Update () {} // Funktion für BackToMainMenu Button, lädt die Menüszene public void BackToMainMenuPress () {SceneManager.LoadScene (0); }} 

Ziehen Sie dieses Skript auf die HUD-Leinwand und richten Sie das Skript auf die gleiche Weise wie das Hauptmenü ein (indem Sie das Spielobjekt Zurück zum Hauptmenü in das Feld Zurück zum Hauptmenü ziehen). Richten Sie dann die Schaltfläche ein, indem Sie den HUD-Canvas in das Feld On Click () ziehen. Wählen Sie die BackToMainMenuPress-Funktion und testen Sie die Schaltfläche, indem Sie auf das Wiedergabesymbol klicken und prüfen, ob Sie zum Hauptmenü zurückkehren.

Anhänge

  • Fineliner_Script.ttf herunterladen
  • Postit-Penscript.otf herunterladen

Schritt 9: Hierarchie organisieren

Erinnern Sie sich, wie ich sagte, dass das Erstellen leerer Spielobjekte Ihnen beim Organisieren der Hierarchie helfen wird? Nun, Sie haben das bereits mit Kindern und Eltern gemacht.

Die Hauptszene ist jedoch noch etwas unorganisiert. Kehren Sie zur Hauptszene zurück und erstellen Sie ein leeres Spielobjekt mit der Bezeichnung "Effekte". Ziehen Sie alle Explosions- und Trails-Spielobjekte in dieses Effektskript. Ziehen Sie dann dieses Effektspielobjekt unter die Skripte. Die Hauptkamera und das Event-System können so bleiben, wie sie sind.

Verwenden Sie dieses System, um jedes von Ihnen erstellte Projekt zu organisieren. Alles des gleichen Typs kann unter ein eigenes leeres Spielobjekt fallen (z. B. können mehrere Feinde Kinder eines feindlichen Spielobjekts sein, mehrere Kameras - Kameraspielobjekt usw.). Dadurch bleibt Ihre Hierarchie aufgeräumt und Sie können sich nicht selbst erhalten verwirrt, wenn Sie viele Spielobjekte erstellen

Schritt 10: Fazit

Puh. Das war schon eine Reise. Aber wir haben endlich das Ende erreicht (wahrscheinlich sind Sie alle froh darüber). Aber jetzt haben Sie eine voll funktionsfähige App, die Sie Ihren Freunden zeigen und verbessern können. Sie sollten stolz sein, wie bereits erwähnt, dies war ein fortgeschritteneres Tutorial. Nehmen Sie sich einen Moment Zeit und genießen Sie einfach Ihre Kreation.

Ich hoffe, dieses Tutorial war eine Hilfe. If you get stuck on anything, a good habit to get in to is searching Google for your error, then typing in Unity after it. Because Unity is so widely used, there is a lot of documentation available and there will most likely be at least one person who has had the same issue as you.

If you're not sure about any of the programming functions (void Update, void Start, public void etc.) then search for the function along with unity c# and check the official Unity documentation.

If you can't find an answer to your issues, you can leave a comment and i'll do my best to help you resolve the error.

If there is something you think I could add or if you want to learn how to program an actual game, feel free to leave a comment.

Thanks for taking the time to read this tutorial. Bis zum nächsten Mal!

Ähnlicher Artikel