Einheit - Kurzanleitung

Unity ist eine plattformübergreifende Spiel-Engine, die ursprünglich von veröffentlicht wurde Unity TechnologiesDer Schwerpunkt von Unity liegt in der Entwicklung von 2D- und 3D-Spielen sowie interaktiven Inhalten. Einheit unterstützt jetzt vorbei20 verschiedene Zielplattformen für die Bereitstellung, während die beliebtesten Plattformen die PC-, Android- und iOS-Systeme sind.

Unity bietet ein vollständiges Toolkit zum Entwerfen und Erstellen von Spielen, einschließlich Schnittstellen für Grafik-, Audio- und Levelbuilding-Tools, für die nur minimale externe Programme für die Arbeit an Projekten erforderlich sind.

In dieser Serie werden wir -

• Lernen, wie man die verschiedenen Grundlagen der Einheit benutzt
• Verstehen, wie alles im Motor funktioniert
• Grundlegende Konzepte des Spieldesigns verstehen
• Erstellen und Erstellen von tatsächlichen Beispielspielen
• Erfahren Sie, wie Sie Ihre Projekte auf dem Markt bereitstellen

Beginnen wir jetzt.

Um Inhalte mit Unity zu erstellen, müssen Sie hauptsächlich die Unity-Engine und die Entwicklungsumgebung herunterladen. Neben der Core Engine können Sie auch optional herunterladenmodules für die Bereitstellung auf verschiedenen Plattformen sowie Tools zur Integration von Unity-Skripten in Visual Studio.

Um Unity zu installieren, gehen Sie zu Dies . Klicken Sie dort auf -

• Choose your Unity + Download.

Klicken Sie auf der nächsten Seite auf Try Now Knopf unter Personal. Dies ist die kostenlose Version von Unity, die alle Kernfunktionen enthält. Zu Beginn dieser Serie ist es besser zu lernen, wie man den Motor benutzt, bevor man über einen Kauf nachdenktPlus oder Pro.

Scrollen Sie auf der nächsten Seite nach unten und klicken Sie, um zu bestätigen, dass Sie oder Ihr Unternehmen nicht mehr als 100.000 USD Jahresumsatz erzielen. In diesem Fall dürfen Sie Unity Free nicht testen, obwohl Sie sich möglicherweise für eine kostenlose 30-Tage-Testversion der Pro-Version anmelden.

Klicken Sie anschließend auf die gewünschte Plattform, um Unity zu installieren. In dieser Reihe beschäftigen wir uns mit demWindowsVersion des Motors. Es ist auch möglich, Unity auf zu installierenUbuntuund einige zusätzliche Linux-Systeme finden Sie hier für weitere Informationen

Es ist auch highlyEs wird empfohlen, die neueste Version von Visual Studio zu installieren , die viele nützliche Tools über die mit Unity gelieferte Standard-MonoDevelop-IDE bietet.

Nachdem das Installationsprogramm heruntergeladen wurde, gehen Sie es durch, bis Sie ein Menü zur Auswahl der Komponenten erreichen, die Sie mit Unity installieren möchten.

Wählen Sie hier die Komponenten aus, die Sie benötigen. Für diese Serie möchten wir die Komponenten installieren, die Sie im Bild sehen. Diese Auswahl umfasst die Engine selbst, die Dokumentation für die Engine, eine IDE; Erstellen Sie Tools für Android und eine Sammlung von Assets, die Sie später in Ihr Projekt aufnehmen können.

Klicken Sie auf Weiter, befolgen Sie die Anweisungen und Optionen und lassen Sie Unity herunterladen und auf Ihrem Computer installieren.

Öffne Unity und in der nächsten Lektion werden wir unser erstes Projekt erstellen.

Erstellen Sie Ihr erstes Projekt

Unity eignet sich gleichermaßen für 2D- und 3D-Spiele. Alle in Unity erstellten Spiele beginnen alsProjects vom Startbildschirm.

Öffnen Sie Ihre neu installierte Kopie von Unity. Ein Bildschirm wird wie unten gezeigt angezeigt -

Ihre vorhandenen Projekte werden wie im obigen Bild im unscharfen Bereich angezeigt.

In der oberen rechten Ecke des Fensters sehen Sie die NewSymbol wie oben gezeigt. Wenn Sie auf das Symbol klicken, wird der Bildschirm "Projekteinrichtung" angezeigt.

Hier können Sie Ihrem Projekt einen Namen geben, den Speicherort festlegen, den Projekttyp festlegen und vorhandene Assets hinzufügen.

Lassen Sie uns vorerst unser erstes Projekt "Hallo Welt!" Nennen. und setzen Sie es auf2D Modus.

Klicken Create Projectund lassen Sie Unity die Kerndateien Ihres Projekts einrichten. Dies kann abhängig von der Geschwindigkeit Ihres Computers, den vorab hinzugefügten Assets und der Art des Projekts einige Zeit dauern.

Den Motor kennen

Sobald Ihr neues Projekt erstellt und Unity geöffnet wurde, wird der folgende Bildschirm angezeigt:

Lassen Sie uns einen kurzen Überblick darüber geben, was in diesem Fenster sichtbar ist. Derzeit beschäftigen wir uns mit vier Hauptregionen -

In diesem Fenster werden wir unsere bauen Scenes. Szenen sindlevelsin dem alles in deinem Spiel stattfindet. Wenn Sie auf das kleine klickenGameAuf der Registerkarte können Sie ein Vorschaufenster sehen, wie das Spiel für den Spieler aussieht. Im Moment sollte es ein einfacher blauer Hintergrund sein.

Diese Region ist die Inspector. Es ist vorerst leer, weil wir keine Objekte in unserer Szene haben. Wir werden später sehen, wie der Inspektor verwendet wird.

Dieses Fenster ist das Scene Hierarchy. Hier werden alle Objekte in Ihrer aktuell geöffneten Szene zusammen mit ihrer Eltern-Kind-Hierarchie aufgelistet. Wir werden dieser Liste in Kürze Objekte hinzufügen.

Schließlich ist diese Region die Project AssetsFenster. Alle Assets in Ihrem aktuellen Projekt werden hier gespeichert und aufbewahrt. Alle extern importierten Assets wie Texturen, Schriftarten und Audiodateien werden hier ebenfalls gespeichert, bevor sie in einer Szene verwendet werden.

In der nächsten Lektion werden wir den Workflow und die Arbeitsweise eines Spiels in Unity diskutieren.

Wie funktioniert die Einheit?

In Unity findet das gesamte Gameplay in statt scenes. Szenen sind Ebenen, in denen alle Aspekte Ihres Spiels wie Spielstufen, Titelbildschirm, Menüs und Schnittszenen stattfinden.

Standardmäßig hat eine neue Szene in Unity eine Camera Objekt in der Szene namens Main Camera. Es ist möglich, der Szene mehrere Kameras hinzuzufügen, aber wir werden uns vorerst nur mit der Hauptkamera befassen.

Die Hauptkamera rendert alles, was sie in einer bestimmten Region namens "sieht" oder "erfasst" viewport. Alles, was in diese Region kommt, wird für den Spieler sichtbar.

Sie können dieses Ansichtsfenster als graues Rechteck anzeigen, indem Sie die Maus in der Szenenansicht platzieren und nach unten scrollen, um die Szenenansicht zu verkleinern. (Sie können dies auch tun, indem Sie die Alt-Taste gedrückt halten und mit der rechten Maustaste ziehen.)

EIN scene selbst besteht aus objects, namens GameObjects. GameObjects können alles sein, vom Modell des Spielers bis zur GUI auf dem Bildschirm, von Schaltflächen und Feinden bis zu unsichtbaren „Managern“ wie Tonquellen.

GameObjects haben eine Reihe von components an sie gebunden, die beschreiben, wie sie sich in der Szene verhalten und wie sie auf andere in der Szene reagieren.

Tatsächlich können wir das jetzt untersuchen. Klick auf dasMain Camera in dem Scene Hierarchy und schau dir das an Inspector. Es wird jetzt nicht leer sein; Stattdessen enthält es eine Reihe von „Modulen“.

Die wichtigste Komponente für jedes GameObject ist seine TransformKomponente. Jedes Objekt, das in einer Szene vorhanden ist, hat einetransform, das seine Position, Rotation und Skalierung in Bezug auf die Spielwelt oder seine Eltern, falls vorhanden, definiert.

Die zusätzlichen Komponenten können durch Klicken auf ein Objekt angehängt werden Add Componentund Auswählen der gewünschten Komponente. In unseren nachfolgenden Lektionen werden wir auch anhängenScripts zu GameObjects, damit wir ihnen programmiertes Verhalten geben können.

Betrachten wir nun einige Beispiele für Komponenten -

• Renderer - Verantwortlich für das Rendern und Sichtbarmachen von Objekten.

• Collider - Definieren Sie die physischen Kollisionsgrenzen für Objekte.

• Rigidbody - Gibt einem Objekt in Echtzeit physikalische Eigenschaften wie Gewicht und Schwerkraft.

• Audio Source - Gibt Objekteigenschaften zum Abspielen und Speichern von Sound.

• Audio Listener - Die Komponente, die Audio tatsächlich „hört“ und an die Lautsprecher des Players ausgibt. Standardmäßig ist eine in der Hauptkamera vorhanden.

• Animator - Ermöglicht einem Objekt den Zugriff auf das Animationssystem.

• Light - Das Objekt verhält sich wie eine Lichtquelle mit verschiedenen Effekten.

In diesem Diagramm können wir sehen, wie Einheit composes selbst durch GameObjects in Szenen.

In der nächsten Lektion werden wir unser erstes GameObject erstellen und uns mit Skripten befassen.

Sprites sind einfache 2D-Objekte mit grafischen Bildern (genannt textures) auf sie. Unity verwendet standardmäßig Sprites, wenn sich die Engine im 2D-Modus befindet. Bei Betrachtung im 3D-Raum erscheinen Sprites hauchdünn, da sie keine Z-Breite haben.

Sprites stehen der Kamera immer in einem senkrechten Winkel gegenüber, es sei denn, sie werden im 3D-Raum gedreht.

Immer wenn Unity ein neues Sprite erstellt, wird eine Textur verwendet. Diese Textur wird dann auf ein neues GameObject angewendet und aSprite RendererKomponente ist daran angeschlossen. Dies macht unser gameObject mit unserer Textur sichtbar und verleiht ihm Eigenschaften, die sich darauf beziehen, wie es auf dem Bildschirm aussieht.

Um ein Sprite in Unity zu erstellen, müssen wir den Motor mit einem versorgen texture.

Lassen Sie uns zuerst unsere Textur erstellen. Rufen Sie eine Standardbilddatei wie PNG oder JPG ab, die Sie verwenden möchten, speichern Sie sie und ziehen Sie das Bild in dieAssets Region der Einheit.

Ziehen Sie als Nächstes das Bild aus dem Assets in die Scene Hierarchy. Sie werden feststellen, dass in der Liste ein neues GameObject mit dem Namen Ihrer Textur angezeigt wird, sobald Sie die Maustaste loslassen. Sie sehen das Bild jetzt auch in der Mitte des Bildschirms in derScene View.

Berücksichtigen wir beim Erstellen eines Sprites die folgenden Punkte:

• Durch Ziehen von einer externen Quelle in Unity fügen wir eine hinzu Asset.

• Dieses Asset ist ein Bild, daher wird es zu einem texture.

• Durch Ziehen dieser Textur in die Szenenhierarchie erstellen wir ein neues GameObject mit demselben Namen wie unsere Textur, an das ein Sprite-Renderer angehängt ist.

• Dieser Sprite-Renderer verwendet diese Textur, um das Bild im Spiel zu zeichnen.

Wir haben jetzt eine erstellt sprite in unserer Szene.

In der nächsten Lektion werden wir uns einige ansehen modifiers für die Sprites, die wir haben.

Das soeben importierte Sprite kann auch auf verschiedene Arten bearbeitet werden, um das Aussehen zu ändern.

Wenn Sie sich die obere linke Ecke der Engine-Oberfläche ansehen, finden Sie eine Symbolleiste wie unten gezeigt -

Lassen Sie uns die Funktionen dieser Schaltflächen diskutieren.

• Das Hand Mit dem Werkzeug können Sie sich in der Szene bewegen, ohne Objekte zu beeinflussen.

• Als nächstes haben wir die MoveWerkzeug. Dies wird verwendet, um Objekte in der Spielwelt zu bewegen.

• In der Mitte haben wir die Rotate Werkzeug, um Objekte entlang der Z-Achse der Spielwelt (oder des übergeordneten Objekts) zu drehen.

• Das ScalingWerkzeug ist nach oben positioniert. Mit diesem Werkzeug können Sie die Größe (Skalierung) von Objekten entlang bestimmter Achsen ändern.

• Endlich haben wir die RectWerkzeug. Dieses Tool verhält sich wie eine Kombination ausMove und die ScalingWerkzeug, ist aber anfällig für Genauigkeitsverlust. Es ist nützlicher beim Anordnen der UI-Elemente.

Diese Tools erweisen sich mit zunehmender Komplexität des Projekts als würdig.

Als wir gerade angefangen haben, haben wir diskutiert, wie die Transformation eines gameObject wohl seine wichtigste Komponente ist. Lassen Sie uns die Komponente in diesem Kapitel ausführlich diskutieren. Zusätzlich lernen wir das Konzept von kennenObject Parenting.

Transformationen haben drei sichtbare Eigenschaften - die position, das rotation, und die scale. Jeder von diesen hat drei Werte für die drei Achsen. 2D-Spiele konzentrieren sich bei der Positionierung normalerweise nicht auf die Z-Achse. Die häufigste Verwendung der Z-Achse in 2D-Spielen ist die Erzeugung von Parallaxen .

Die Rotationseigenschaften definieren den Grad der Rotation (in Grad), um den ein Objekt in Bezug auf die Spielwelt oder das übergeordnete Objekt um diese Achse gedreht wird.

Die Größe eines Objekts definiert, wie largees ist im Vergleich zu seiner ursprünglichen oder nativen Größe. Nehmen wir zum Beispiel ein Quadrat mit den Abmessungen 2x2. Wenn dieses Quadrat gegen die X-Achse um 3 und die Y-Achse um 2 skaliert wird, haben wir ein Quadrat der Größe 6x4.

In unserem folgenden Abschnitt werden wir diskutieren, was Object Parenting ist.

Was ist Objekterziehung?

In Unity folgen Objekte a HierarchySystem. Mit diesem System können GameObjects "Eltern" anderer GameObjects werden.

Wenn ein GameObject ein übergeordnetes Element hat, führt es alle Transformationsänderungen in Bezug auf ein anderes GameObject anstelle der Spielwelt durch.

Beispielsweise befindet sich ein Objekt ohne übergeordnetes Element bei (10, 0 und 0) in einem Abstand von 10 Einheiten vom Zentrum der Spielwelt.

A gameObject with a parent placed bei (10, 0, 0) wird das berücksichtigt parent’s aktuelle Position als Zentrum.

GameObjects können einfach durch Ziehen und Ablegen auf das gewünschte übergeordnete Element übergeordnet werden. Ein "untergeordnetes" Objekt wird in der Objektliste mit einem kleinen Einzug zusammen mit einem Pfeil neben dem übergeordneten Objekt dargestellt.

Parenting GameObjects hat eine Reihe von Verwendungsmöglichkeiten. Beispielsweise können alle verschiedenen Teile eines Panzers separate GameObjects sein, die unter einem einzigen GameObject mit dem Namen "Panzer" zusammengefasst sind. Auf diese Weise bewegen sich alle Teile, wenn sich dieses übergeordnete „Panzer“ -Spielobjekt bewegt, mit, da ihre Positionierung entsprechend dem übergeordneten Element ständig aktualisiert wird.

In unserer nächsten Lektion werden wir die internen Assets diskutieren. Wir werden auch lernen, wie Sie die Assets in unserem Projekt erstellen und verwalten.

Neben den externen Assets, die Sie aus anderen Programmen wie Audiodateien, Bildern, 3D-Modellen usw. importieren, bietet Unity auch die Erstellung von InternalVermögenswerte. Diese Assets, die in Unity selbst erstellt werden und als solche kein externes Programm zum Erstellen oder Ändern benötigen.

Einige wichtige Beispiele für internal Vermögenswerte sind wie unten gezeigt -

• Scenes - Diese fungieren als "Ebenen".

• Animations - Diese enthalten Daten für die Animationen eines gameObject.

• Materials - Diese definieren, wie sich die Beleuchtung auf das Erscheinungsbild eines Objekts auswirkt.

• Scripts - Der Code, der für die gameObjects geschrieben wird.

• Prefabs - Diese dienen als „Blaupausen“ für GameObjects, sodass sie zur Laufzeit generiert werden können.

Einige andere wichtige Elemente sind Platzhalter, Sprites und Modelle. Diese werden verwendet, wenn Sie schnelle Platzhalter benötigen, damit sie später durch geeignete Grafiken und Modelle ersetzt werden können.

Um ein internes Asset zu erstellen, klicken Sie mit der rechten Maustaste in den Ordner "Assets" und gehen Sie zu Create.

In diesem Beispiel erstellen wir eine Triangle und ein Square.

Scrollen Sie über die Sprites Auswahl und klicken Sie auf Triangle.

Wiederholen Sie den Vorgang für Square, und Sie sollten zwei neue grafische Elemente haben.

Im weiteren Verlauf werden wir mehr von diesen internen Assets untersuchen, da sie für den Aufbau eines richtigen Spiels von entscheidender Bedeutung sind.

Am Ende des Tages, wenn Sie mit einer angemessenen Menge an Arbeit fertig sind, möchten Sie Ihren Fortschritt speichern. Wenn Sie in Unity Strg + S drücken, wird Ihr Projekt nicht direkt gespeichert.

Alles in der Einheit geschieht in Szenen. Speichern und Laden auch; Sie müssen Ihre aktuelle Arbeit als Szene (Erweiterung .unity) in Ihrem Vermögen speichern.

Probieren wir es aus. Wenn wir Strg + S drücken und unserer Szene einen Namen geben, wird uns ein neues Asset in unserer Assets-Region präsentiert. Dies ist die Szenendatei.

Lassen Sie uns nun versuchen, eine neue Szene zu erstellen. Klicken Sie dazu mit der rechten Maustaste in die Assets und gehen Sie zu Erstellen → Szene. Geben Sie Ihrer neuen Szene einen Namen und drücken Sie die Eingabetaste.

Im Editor-Modus (wenn das Spiel nicht läuft) können Szenen durch Doppelklick in den Editor geladen werden. Wenn Sie eine Szene mit nicht gespeicherten Änderungen in Ihre aktuelle Szene laden, werden Sie aufgefordert, Ihre Änderungen zu speichern oder zu verwerfen.

Dein erstes Skript

Das Importieren von Bildern und das Stillhalten in Ihrem Spiel bringt Sie nicht wirklich weiter. Es wäre vielleicht ein schöner Bilderrahmen, aber kein Spiel.

Scriptingist unerlässlich, um Spiele in Unity zu machen. Scripting ist der Prozess des Schreibensblocksvon Code, der wie Komponenten an GameObjects in der Szene angehängt ist. Scripting ist eines der mächtigsten Werkzeuge, die Ihnen zur Verfügung stehen, und es kann ein gutes Spiel machen oder brechen.

Die Skripterstellung in Unity erfolgt entweder über C # oder durch die Implementierung von JavaScript in Unity, das als UnityScript bezeichnet wird (mit dem Zyklus 2018 beginnt UnityScript jedoch mit der Verfallsphase, daher wird empfohlen, es nicht zu verwenden). Für die Zwecke dieser Serie verwenden wir C #.

Um ein neues Skript zu erstellen, klicken Sie mit der rechten Maustaste in Ihre Assets und gehen Sie zu Create → C# Script. Sie können auch die verwendenAssets Registerkarte in der oberen Leiste des Motors.

Wenn Sie ein neues Skript erstellen, sollte ein neues Asset angezeigt werden. Lassen Sie den Namen vorerst unverändert und doppelklicken Sie darauf. Ihre Standard-IDE sollte zusammen mit dem Skript geöffnet werden. Schauen wir uns an, was es eigentlich ist.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class NewBehaviourScript : MonoBehaviour {
   // Use this for initialization
   void Start() { 
   }
   // Update is called once per frame
   void Update() {

   }
}

Sie sehen Ihren Skriptnamen als class Ableiten von MonoBehaviour. Was ist MonoBehaviour? Es ist eine riesige Bibliothek von Klassen und Methoden. Es hilft allen Skripten in Unity, auf die eine oder andere Weise abzuleiten. Je mehr Sie Skripte in Unity schreiben, desto mehr werden Sie erkennen, wie nützlich MonoBehaviour tatsächlich ist.

Im weiteren Verlauf haben wir zwei private Skripte, die keine Rückgabetypen haben, nämlich das Start und UpdateMethoden. DasStart Methode läuft once Für das erste Frame, für das das GameObject verwendet wird, ist dieses in der Szene aktiv.

Das UpdateMethode führt jeden Frame des Spiels nach der Start-Methode aus. Normalerweise laufen Spiele in Unity mit 60 FPS oder Frames pro Sekunde, was bedeutet, dass dieUpdate Die Methode wird 60 Mal pro Sekunde aufgerufen, während das Objekt aktiv ist.

Mit Unity-Skripten können Sie die gesamte MonoBehaviour-Klasse sowie die wichtigsten C # -Funktionen wie generische Sammlungen, Lambda-Ausdrücke und XML-Analyse nutzen, um nur einige zu nennen. In der nächsten Lektion werden wir unseren ersten Code schreiben!

In dieser Lektion schreiben wir Code, mit dem sich ein gameObject basierend auf den Benutzereingaben nach oben, unten, links und rechts bewegt. Dies soll uns helfen, den Workflow von Unity-Skripten leichter zu verstehen.

Denken Sie daran, dass jedes GameObject mindestens eine Komponente hat - Transform. Das Besondere ist, dass die Transformation eines gameObject auch als Variablen auf der Skriptseite von Unity angezeigt wird, sodass wir sie über Code ändern können. Dies ist auch nicht auf die Transformation beschränkt; Alle Komponenten in Unity verfügen über Eigenschaften, auf die über Variablen in Skripten zugegriffen werden kann.

Beginnen wir mit unserem Bewegungsskript. Erstellen Sie ein neues Skript und nennen Sie es "Bewegung".

Öffnen Sie nun das Skript und Sie sollten das gleiche Material sehen, das Sie in der letzten Lektion gesehen haben.

Erstellen wir eine öffentliche Float-Variable mit dem Namen speed. Eine Variable erstellenpublic in der Einheit hat einen großen Vorteil -

• Die Variable wird als modifizierbares Feld im Editor angezeigt, sodass Sie die Werte im Code nicht manuell anpassen müssen.

public class Movement : MonoBehaviour {
   public float speed;
}

Wenn wir dieses Skript speichern, ohne die anderen Methoden zu berühren, sollte es in Unity kompiliert werden.

(Sie können sehen, wann es kompiliert wird, indem Sie das

Symbol in der unteren rechten Ecke verwenden.)

Nächster, drag and dropdas Skript aus den Assets auf das GameObject. Wenn Sie es richtig machen, sollten Sie dies in den Eigenschaften des GameObject sehen -

Da der Geschwindigkeitswert einstellbar ist und nicht ständig im Code geändert werden muss, können wir anstelle von start () die update () -Methode verwenden.

Betrachten wir nun die Ziele für die Update-Methode -

• Überprüfen Sie die Benutzereingaben.

• Wenn eine Benutzereingabe vorliegt, lesen Sie die Eingaberichtungen.

• Ändern Sie die Positionswerte der Objekttransformation basierend auf ihrer Geschwindigkeit und Richtung. Dazu fügen wir den folgenden Code hinzu:

void Update() {
   float h = Input.GetAxisRaw(“Horizontal”);
   float v = Input.GetAxisRaw(“Vertical”);
   
   gameObject.transform.position = new Vector2 (transform.position.x + (h * speed), 
      transform.position.y + (v * speed));

Lassen Sie uns nun den Code in Kürze diskutieren.

Zunächst erstellen wir eine Gleitkommavariable mit dem Namen h (für horizontal), und sein Wert wird durch die gegeben Input.GetAxisRawMethode. Diese Methode gibt -1, 0 oder 1 zurück, je nachdem, welche Taste der Spieler auf den Pfeilen nach oben / unten / links / rechts gedrückt hat.

Die Eingabeklasse ist dafür verantwortlich, Eingaben vom Benutzer in Form von Tastendrücken, Mauseingaben, Controller-Eingaben usw. zu erhalten. Die GetAxisRaw-Methode ist etwas schwieriger zu verstehen, daher werden wir später darauf zurückkommen.

Als nächstes sind wir updating Die Position unseres GameObjects auf eine neue Position, die durch Erstellen einer neuen Position definiert wird Vector2. Der Vector2 akzeptiert 2 Parameter, nämlich seinex and yWerte jeweils. Für den x-Wert geben wir die Summe der Objekte ancurrent Position und seine speedDadurch wird bei jedem Frame, bei dem die Taste an ihre Position gedrückt wird, ein gewisser Betrag hinzugefügt.

Speichern Sie dieses Skript und kehren Sie zu Unity zurück. Unity aktualisiert automatisch alle Skripte, sobald es erfolgreich kompiliert wurde, sodass Sie das Skript nicht immer wieder neu anhängen müssen.

Nachdem Sie fertig sind, ändern Sie den Wert von speedin den Eigenschaften des GameObjects sagen 0,8. Dies ist wichtig, da ein höherer Wert den Spieler zu schnell bewegen lässt.

Klicken Sie nun auf Play und sehen Sie Ihr erstes kleines Spiel in Aktion!

Versuchen Sie, die Pfeiltasten zu drücken und sich zu bewegen. Um das Spiel zu beenden, drücken Sie einfach erneut auf Wiedergabe. Sie können die Geschwindigkeit sogar in Echtzeit einstellen, sodass Sie sie nicht ständig anhalten und starten müssen.

In der nächsten Lektion lernen wir starre Körper und Kollisionen kennen.

Kollisionen in Unity werden vom eigentlichen Sprite selbst getrennt, als separate Komponenten angehängt und selbst berechnet. Lassen Sie uns nun die Ursache dafür lernen.

Everythingin deinem Spiel ist ein GameObject. Sogar die einzelnen Kacheln, aus denen Ihr Level besteht, sind GameObjects für sich.

Wenn wir jede Komponente als GameObject betrachten, erkennen wir, dass es eine geben könnte thousandsvon GameObjects in einer Szene, die auf irgendeine Weise miteinander interagieren. Sie können sich vorstellen, dass es für die Engine unpraktisch wäre, Kollisionen für jedes einzelne GameObject zu berechnen, wenn Unity jedem einzelnen GameObject Kollisionen hinzufügt.

Wir werden eine einfache „Wand“ hinzufügen, gegen die unser Spielercharakter kollidieren kann. Erstellen Sie dazu ein weiteres Sprite und skalieren Sie es mit dem Rect-Werkzeug. Wir werden es auch durch das rot färbenColor Eigenschaft in der Sprite Renderer-Komponente.

Jetzt geh zu Add ComponentGeben Sie im Inspektor "Box Collider 2D" ein. Klicken Sie auf die erste Komponente, die angezeigt wird, und eine neue Komponente sollte angezeigt werden.

Sie sehen eine hellgrüne Linie am Umfang Ihres GameObject. Dies ist dascollision boundary. Es ist das, was das Wirkliche definiertshape der kollidierbaren Objekte.

Wiederholen Sie dies auch mit unserem beweglichen GameObject.

Kollisionen in Unity beschränken sich natürlich nicht nur auf Boxen. Sie können in einer Vielzahl von Formen und Größen variieren und sind nicht unbedingt Nachbildungen der Objektparameter.

Sie können auch polygonale Formen annehmen.

Es ist nicht ungewöhnlich, dass Entwickler und Designer diese verwenden approximateFormen in ihren Kollisionsgrenzen, um ihre Kollider zu vereinfachen und unnötige Berechnungen für den Motor zu vermeiden. Wir werden bald lernen, wie wir mit unseren Collidern verschiedene Formen und Größen erstellen können.

Nachdem wir unsere Kollisionsgrenzen festgelegt haben, klicken Sie auf "Spielen" und sehen Sie es in Aktion.

Sie werden feststellen, dass sich unser bewegliches Objekt nicht normal verhält. Wir werden das Verhalten des Objekts in unserem nachfolgenden Kapitel diskutieren.

Das Hauptproblem bei den Kollisionen im letzten Kapitel war der Code. We will now modify the values of the GameObject’s position directly. Wir fügen der Position einfach einen Wert hinzu, wenn der Spieler eine Taste drückt. Wir brauchen eine Möglichkeit, den Spieler so zu bewegen, dass er richtig auf Grenzen und andere GameObjects reagiert.

Dazu müssen wir verstehen, was rigidbodiessind. Rigidbodies sind Komponenten, auf die ein GameObject reagieren kannreal-time physics. Dies schließt Reaktionen auf Kräfte und Schwerkraft, Masse, Widerstand und Impuls ein.

Sie können einen Rigidbody an Ihr GameObject anhängen, indem Sie einfach auf klicken Add Component und geben Sie Rigidbody2D in das Suchfeld ein.

Durch Klicken auf Rigidbody2D wird die Komponente an Ihr GameObject angehängt. Jetzt, da es angehängt ist, werden Sie feststellen, dass sich viele neue Felder geöffnet haben.

Mit den Standardeinstellungen fällt das GameObject vertikal downaufgrund der Schwerkraft. Um dies zu vermeiden, stellen Sie dieGravity Scale bis 0.

Jetzt zeigt das Spielen des Spiels keinen sichtbaren Unterschied, da das GameObject noch nichts mit seiner Physikkomponente zu tun hat.

Um unser Problem zu lösen, öffnen wir unseren Code erneut und schreiben ihn neu.

public class Movement : MonoBehaviour {
   public float speed;
   public Rigidbody2D body;
   // Update is called once per frame
   void Update() {
      float h = Input.GetAxisRaw(“Horizontal”);
      float v = Input.GetAxisRaw(“Vertical”);
      body.velocity = new Vector2(h * speed, v * speed);
   }
}

Wir können sehen, dass wir eine schaffen referencezu einem Rigidbody2D in den Deklarationen, und unser Aktualisierungscode arbeitet mit dieser Referenz anstelle der Transformation des Objekts. Dies bedeutet, dass der starre Körper nun die Verantwortung für den Umzug erhalten hat.

Sie können das erwarten bodyVerweis auf NullReferenceException, da wir ihm nichts zugewiesen haben. Wenn Sie das Spiel so kompilieren und ausführen, wie es ist, wird unten links im Editor der folgende Fehler angezeigt

Um dies zu beheben, betrachten wir die vom Skript erstellte Komponente. Denken Sie daran, dass öffentliche Eigenschaften in Unity ihre eigenen Felder erstellen, wie wir es mit der Geschwindigkeitsvariablen getan haben.

Stellen Sie die Geschwindigkeit auf einen höheren Wert ein, etwa 5, und spielen Sie das Spiel.

Ihre Kollisionen funktionieren jetzt korrekt!

In diesem Kapitel erfahren Sie mehr über benutzerdefinierte Kollisionsgrenzen. Wir werden auch lernen, wie wir die Größe und Form unserer Collider anpassen können.

Beginnen wir mit unserem Box Collider. Der Box Collider (2D) hat 4 einstellbare Seiten und ist wie ein Rechteck geformt. Klicken Sie in der Collider-Komponente auf dieses Feld -

Auf dem Collider werden 4 „Griffe“ angezeigt. Sie können diese Griffe verschieben, um ihre Größe anzupassen.

Bei einfachen Formen erkennt Unity auch die bestmögliche Passform für die Form des Colliders, vorausgesetzt, Sie wählen die richtige aus. Wenn Sie beispielsweise den Kreiscollider in einem Kreissprite auswählen, wird er an seinen Radius angepasst.

Bei komplexeren Formen versucht Unity, die einfachste und zugleich aufwändigste Collider-Form zu erstellen. Dafür müssen Sie die verwendenPolygon Collider 2D.

Versuchen Sie, auf die Schaltfläche Collider bearbeiten zu klicken, und experimentieren Sie mit dem Anpassen der Collider.

Das Instanziieren und Zerstören von Objekten wird während des Spiels als sehr wichtig angesehen. Instanziieren heißt einfach ins Leben rufen. Gegenstände erscheinen oder "erscheinen" im Spiel, Feinde sterben, GUI-Elemente verschwinden und Szenen werden die ganze Zeit im Spiel geladen. Noch wichtiger wird es, zu wissen, wie man nicht benötigte Objekte richtig entfernt und wie man diese einbringt.

Lassen Sie uns zuerst verstehen, was prefabssind. Fertighäuser werden als wichtig angesehen, um zu verstehen, wie Instanziierung in Unity funktioniert.

Prefabs sind wie blueprintseines GameObject. Fertighäuser sind in gewisser Weise acopyeines GameObjects, das dupliziert und in eine Szene eingefügt werden kann, auch wenn es zum Zeitpunkt der Erstellung der Szene nicht vorhanden war; Mit anderen Worten, Fertighäuser können verwendet werdendynamically generate GameObjects.

Um ein Fertighaus zu erstellen, müssen Sie lediglich das gewünschte GameObject aus Ihrer Szenenhierarchie in das Projekt ziehen Assets.

Um ein GameObject zu instanziieren, rufen wir das auf Instantiate()Methode in unserem Skript. Diese Methode, definiert inMonoBehaviour, nimmt ein GameObject als Parameter auf, damit es weiß, welches GameObject erstellt / dupliziert werden soll. Es gibt auch verschiedene Überschreibungen zum Ändern der Transformation des neu instanziierten Objekts sowie zur Elternschaft.

Versuchen wir, ein neues zu instanziieren hexagon wann immer die Space Taste gedrückt.

Erstellen Sie ein neues Skript mit dem Namen Instantiatorund öffne es. In demUpdate Methode, geben Sie den unten angegebenen Code ein.

Hier verwenden wir die GetKeyDown Methode der InputKlasse, um zu überprüfen, ob der Spieler während des letzten Frames eine bestimmte Taste gedrückt hat. Da wir möchten, dass es weiter überprüft wird, setzen wir es einUpdate, die 60 mal pro Sekunde läuft. Die GetKeyDown-Methode wird zurückgegebentrue wenn der von der KeyCode In diesem Frame wird enum (das alle möglichen Tasten einer Standardtastatur auflistet) gedrückt.

public class Instantiator : MonoBehaviour {
   public GameObject Hexagon;
   // Update is called once per frame
   void Update () {
      if (Input.GetKeyDown(KeyCode.Space)) {
         Instantiate(Hexagon);
      }
   }
}

Die öffentliche GameObject-Deklaration oben erstellt einen ähnlichen Slot wie den, den wir in unseren vorherigen Lektionen für Rigidbody2D erstellt haben. Dieser Slot akzeptiert nurprefabs (in Editorzeit) und gameObjects (zur Laufzeit) jedoch.

Speichern Sie das Skript und lassen Sie es kompilieren. Sobald es fertig ist, erstellen Sie eine neue,empty GameObject, indem Sie mit der rechten Maustaste auf das Menü Ihrer Objekthierarchie gehen und auswählen Create Empty.

Nennen Sie dieses Objekt etwas Erkennbares wie Instatiator Objectund hängen Sie unser neu erstelltes Skript daran an. Ziehen Sie in den für das GameObject angezeigten Slot das von uns erstellte Fertighaus.

Wenn wir das Spiel jetzt ausführen, wird durch Drücken der Leertaste ein neues Hexagon-Objekt erstellt, das mit dem Objekt identisch ist, mit dem wir das Fertighaus erstellt haben. Sie können sehen, dass jedes Sechseck in der Objekthierarchie erstellt wird. Der Grund, warum Sie sie nicht im Spiel sehen können, ist, dass sie vorerst alle erstellt werdenexactly übereinander.

In unserer nächsten Lektion werden wir das Konzept der Objektzerstörung verstehen.

Die Zerstörung von GameObjects ist ebenso wichtig wie die Instanziierung. In diesem Kapitel erfahren Sie, wie Sie die GameObjects zerstören.

Glücklicherweise ist das Zerstören von GameObjects so einfach wie das Erstellen. Sie benötigen lediglich einen Verweis auf das zu zerstörende Objekt und rufen das aufDestroy() Methode mit dieser Referenz als Parameter.

Versuchen wir nun, 5 Sechsecke herzustellen, die sich selbst zerstören, wenn eine zugewiesene Taste gedrückt wird.

Lassen Sie uns ein neues Skript namens erstellen HexagonDestroyerund öffnen Sie es in Visual Studio. Wir werden damit beginnen, eine Öffentlichkeit zu machenKeyCodeVariable. Ein KeyCode wird verwendet, um eine Taste auf einer Standardtastatur anzugeben, und die Input-Klasse in ihren Methoden verwendet sie. Indem wir diese Variable wie zuvor bei Rigidbody und Prefabs öffentlich machen, können wir sie über den Editor zugänglich machen. Wenn die Variable veröffentlicht wird, brauchen wir das nichthardcodeWerte wie "KeyCode.A" in den Code. Der Code kann mit beliebig vielen Objekten flexibel gestaltet werden.

public class HexagonDestroyer : MonoBehaviour {
   
   public KeyCode keyToDestroy;

   // Update is called once per frame
   void Update () {
      
      if (Input.GetKeyDown(keyToDestroy)) {
         Destroy (gameObject);
      }
   }
}

Beobachten Sie, wie wir die Variable "gameObject" (kleines g, Großbuchstabe O) in der Methode verwendet haben. Das neugameObject Variable (vom Typ GameObject) wird verwendet, um auf das gameObject zu verweisen, an das dieses Skript angehängt ist. Wenn Sie dieses Skript an mehrere Objekte anhängen, reagieren alle gleich, wenn diese Variable betroffen ist.

Verwechseln Sie die beiden jedoch nicht.

• GameObject mit einem Großbuchstaben G und O ist die class Dies umfasst alle GameObjects und bietet Standardmethoden wie Instantiate, Destroy und Methoden zum Abrufen von Komponenten.

• gameObject mit einem small g und Kapital O ist das Spezifische instance eines GameObjects, das verwendet wird, um auf das gameObject zu verweisen, an das dieses Skript derzeit angehängt ist.

Lassen Sie uns jetzt unseren Code kompilieren und zu Unity zurückkehren.

Jetzt erstellen wir ein neues Hexagon-Sprite und hängen unser Skript daran an. Klicken Sie anschließend mit der rechten Maustaste auf das gameObject in der Hierarchie und wählen SieDuplicate. In der Hierarchie wird ein neues Sprite erstellt. Sie sollten die verwendenMoveWerkzeug, um es neu zu positionieren. Wiederholen Sie die Schritte, um ähnliche Sechsecke zu erstellen.

Klicken Sie auf jedes der Sechsecke und sehen Sie sich deren Skriptkomponenten an. Sie können jetzt die einzelnen Tasten so einstellen, dass sich ein GameObject selbst zerstört, wenn diese Taste gedrückt wird. Lassen Sie uns zum Beispiel 5 Sechsecke erstellen und sie so einstellen, dass sie zerstört werden, wenn die Tasten A, S, D, F und G gedrückt werden.

Sie können dieselbe Taste auf mehrere Sechsecke setzen, und alle zerstören sich gleichzeitig, wenn die Taste gedrückt wird. Dies ist ein Beispiel für die Verwendung dergameObject Referenz, mit der Sie mithilfe des Skripts auf einzelne Objekte verweisen können, ohne sie einzeln festlegen zu müssen.

Dieselbe Taste kann auf mehrere Sechsecke eingestellt werden, und alle zerstören sich gleichzeitig, wenn die Taste gedrückt wird. Dies ist ein Beispiel für die Verwendung dergameObject Referenz, mit der Sie mithilfe des Skripts auf einzelne Objekte verweisen können, ohne sie einzeln festlegen zu müssen.

Es ist wichtig zu verstehen, dass das Zerstören eines GameObjects nicht bedeutet, dass ein Objekt zersplittert oder explodiert. Das Zerstören eines Objekts beendet einfach (und sofort) seine Existenz, was das Spiel (und seinen Code) betrifft. Die Links zu diesem Objekt und seinen Referenzen sind jetzt fehlerhaft, und der Versuch, auf eines dieser Objekte zuzugreifen oder es zu verwenden, führt normalerweise zu Fehlern und Abstürzen.

Coroutinen sind die hilfreichsten Werkzeuge beim Erstellen von Spielen in Unity. Betrachten wir die unten gezeigte Codezeile, um zu verstehen, worum es bei Coroutinen geht.

IEnumerator MyCoroutineMethod() {
   // Your code here…
   
   yield return null;
}

Wenn Sie eine Funktion in Unity (oder wirklich in C #) aufrufen, wird die Funktion im Allgemeinen von Anfang bis Ende ausgeführt. Dies ist, was Sie als "normales" Verhalten in Bezug auf Ihren Code betrachten würden. Manchmal möchten wir eine Funktion jedoch absichtlich verlangsamen oder länger als die von ihr ausgeführte Sekundenbruchteil warten lassen . Eine Coroutine kann genau das: Eine Coroutine ist eine Funktion, die dazu in der Lage istwaiting und timing seinen Prozess, sowie es ganz anzuhalten.

Betrachten wir ein Beispiel, um zu verstehen, wie eine Coroutine funktioniert. Angenommen, wir möchten ein Quadrat erstellen, dessen Farbe in Intervallen von 1 Sekunde zwischen Rot und Blau wechselt.

Zunächst erstellen wir ein Sprite. Erstellen Sie als Nächstes ein neues Skript und benennen Sie esColorChanger. In diesem Skript erhalten wir einen Verweis auf dieSprite Rendererdes Sprites. Wir werden jedoch eine andere Methode verwenden, um die Komponente zu erhalten. Anstatt die Komponente wie bisher in einen Steckplatz zu ziehen und dort abzulegen, werden wir den Code bitten, die Komponente selbst zu erkennen.

Dies geschieht durch die GetComponentMethode, die die erste übereinstimmende Komponente zurückgibt, die erkannt wird. Da wir nur einen Sprite-Renderer pro Objekt verwenden, können wir mit dieser Methode jedes Mal automatisch einen Verweis auf unseren Renderer erkennen und abrufen.

Denken Sie daran, dass der Renderer dafür verantwortlich ist, dass das Sprite tatsächlich auf dem Bildschirm angezeigt wird. Der Renderer hat einecolorEigenschaft, die die globale Farbe des Sprites beeinflusst; Dies ist der Wert, der geändert werden soll. Das machenColor Mit den Werten public können wir sie über den Editor im Standard-Farbauswahlprogramm Ihres Betriebssystems auswählen.

private SpriteRenderer sr;

public Color color1;
public Color color2;

void Start () {
   sr = GetComponent<SpriteRenderer>();
   StartCoroutine(ChangeColor());
}

IEnumerator ChangeColor() {
   
   while (true) {
      
      if (sr.color == color1)
         sr.color = color2;
      
      else
         sr.color = color1;
      
      yield return new WaitForSeconds(3);
   }
}

Jetzt werden wir unsere Coroutine-Funktion in einer while-Schleife einfangen.

Um eine Coroutine in C # zu erstellen, erstellen wir einfach eine Methode, die zurückgibt IEnumerator. Es braucht auch eineyield returnErklärung. Die Renditeerklärung ist etwas Besonderes. Es ist das, was Unity tatsächlich anweist, das Skript anzuhalten und mit dem nächsten Frame fortzufahren.

Es gibt eine Reihe von Möglichkeiten, um eine Rendite zu erzielen. Eine davon ist das Erstellen einer Instanz vonWaitForSecondsKlasse. Dadurch wartet die Coroutine einige Sekunden in der realen Welt, bevor sie fortfährt.

Lassen Sie uns unseren Code kompilieren und zu Unity zurückkehren. Wir werden einfach unsere abwechselnden Farben auswählen und auf "Spielen" klicken. Unser Objekt sollte nun in 3-Sekunden-Intervallen zwischen den beiden Farben wechseln. Sie können das Intervall zu einer öffentlichen Variablen machen und auch die Häufigkeit der Farbänderungen anpassen.

Coroutinen werden häufig für verwendet timedMethoden, wie wir sie gerade gemacht haben. Die Vielfalt vonWaitForXMethoden haben ihre eigenen Verwendungen. Coroutinen werden auch verwendet, um "nebenbei" -Prozesse auszuführen, die von selbst ausgeführt werden, während das Spiel gleichzeitig ausgeführt wird. Dies ist beispielsweise nützlich, um Teile eines großen Levels außerhalb des Bildschirms zu laden, während der Player an einem Punkt startet.

In der Konsole werden wir die lesen DeveloperAusgänge. Diese Ausgänge können zum schnellen Testen von Codebits verwendet werden, ohne dass zusätzliche Funktionen zum Testen bereitgestellt werden müssen.

Es gibt drei Arten von Nachrichten, die in der Standardkonsole angezeigt werden. Diese Nachrichten können sich auf die meisten Compiler-Standards beziehen -

• Errors
• Warnings
• Messages

Fehler

Fehler sind Probleme oder Ausnahmen, die die Ausführung des Codes verhindern at all.

Warnungen

Warnungen sind Probleme, die die Ausführung Ihres Codes nicht verhindern, aber zur Laufzeit Probleme verursachen können.

Mitteilungen

Nachrichten sind Ausgaben, die dem Benutzer etwas vermitteln. Normalerweise werden Probleme nicht hervorgehoben.

Wir können sogar die Konsole unsere eigenen Nachrichten, Warnungen und Fehler ausgeben lassen. Dazu verwenden wir die Debug-Klasse. DasDebug class ist ein Teil von MonoBehaviour, das uns Methoden zum Schreiben von Nachrichten in die Konsole bietet, ähnlich wie Sie normale Ausgabenachrichten in Ihren Starterprogrammen erstellen würden.

Sie finden die Konsole auf der beschrifteten Registerkarte über dem Bereich "Assets".

Die Ausgänge der Konsole sind für die programmer, nicht der Endbenutzer oder Spieler.

Versuchen wir, eine einfache Nachricht an die Konsole zu schreiben. Dies benachrichtigt uns, wenn die Leertaste gedrückt wurde. Dafür werden wir die verwendenLog Methode, die eine Object als Parameter, in dem wir einen String verwenden werden.

Sie können mit einem neuen Skript beginnen oder ein vorhandenes ändern.

void Update() {
   if (Input.GetKeyDown(KeyCode.Space))
      Debug.Log(“Space key was pressed!”);
}

Wenn Sie diesen Code speichern, kompilieren und ausführen (natürlich durch Anhängen an ein GameObject), versuchen Sie, die Leertaste zu drücken.

Note - Beachten Sie, dass die Meldung unten im Editor angezeigt wird.

Wenn Sie auf die Registerkarte Konsole klicken, wird Ihre Nachricht ausgedruckt.

In ähnlicher Weise können Sie auch Warnungen ausgeben, indem Sie die LogWarning Methode und Fehler mit dem LogError Methode. Diese werden sich als nützlich erweisen, um kleine Codebits zu testen, ohne sie tatsächlich implementieren zu müssen, wie Sie später sehen werden.

Es gibt einen Grund, warum Spiele den Schwerpunkt auf Audio legen. Es ist sehr wichtig, dem Spiel einen ästhetischen Wert zu verleihen. Von Anfang anPongMan kann Pieptöne und Boops vom Ball hören, die abwechselnd auf die Paddel schlagen. Es war damals ein wirklich einfaches kurzes Rechteckwellen-Sample, aber was will man mehr vom Großvater aller Videospiele?

Im wirklichen Leben beeinflussen viele Dinge die Art und Weise, wie Sie Geräusche wahrnehmen. die Geschwindigkeit des Objekts, in welcher Art von Szenario es sich befindet und aus welcher Richtung es kommt.

Es gibt eine Reihe von Faktoren, die unseren Motor unnötig belasten können. Stattdessen versuchen wir, eine Vorstellung davon zu bekommen, wie unser Sound in unserem Spiel funktionieren würde, und bauen darauf auf. Dies wird besonders bei 3D-Spielen deutlich, bei denen 3 Achsen zu bewältigen sind.

In Unity haben wir spezielle Komponenten für die Audiowahrnehmung und -wiedergabe. Diese Komponenten arbeiten zusammen, um ein glaubwürdiges Soundsystem zu schaffen, das sich für das Spiel natürlich anfühlt.

Unity bietet uns eine Reihe nützlicher Werkzeuge und Effekte wie Hall, Doppler-Effekt, Echtzeit-Mixing und Effekte usw. Wir werden dies in unseren folgenden Kapiteln erfahren.

Die Audiokomponenten

In diesem Abschnitt lernen wir die drei Hauptkomponenten kennen, die sich auf Audio in Unity beziehen.

Audio quelle

Die AudioSource-Komponente ist die Hauptkomponente, die Sie an ein GameObject anhängen, damit es wiedergegeben wird. Es wird ein wiedergegebenAudioClip wenn durch den Mixer ausgelöst, durch Code oder standardmäßig, wenn es aufwacht.

Ein AudioClip ist einfach eine Audiodatei, die in eine AudioSource geladen wird. Dies kann eine beliebige Standard-Audiodatei sein, z. B. MP3, WAV usw. Ein AudioClip ist auch eine Komponente in sich.

AudioListener

Ein AudioListener ist die Komponente, die listenszu allen Audiodaten, die in der Szene abgespielt werden, und überträgt sie auf die Lautsprecher des Computers. Es verhält sich wie dasearsdes Spiels. Alle Audiodaten, die Sie hören, beziehen sich auf die Positionierung dieses AudioListeners. Es sollte sich nur ein AudioListener in einer Szene befinden, damit er ordnungsgemäß funktioniert. Standardmäßig ist an der Hauptkamera der Listener angeschlossen. Der Listener hat keine exponierten Eigenschaften, um die sich der Designer kümmern möchte.

Audiofilter

Die Ausgabe einer AudioSource oder die Aufnahme eines AudioListener kann mit Hilfe von Audiofiltern geändert werden. Dies sind bestimmte Komponenten, die den Hall, den Chorus, die Filterung usw. ändern können. Jeder spezifische Filter wird als eigene Komponente mit exponierten Werten geliefert, um den Klang zu optimieren.

Einen Sound abspielen

Versuchen wir, eine Schaltfläche zu erstellen, die beim Klicken einen Ton wiedergibt. Um loszulegen, werden wirCreate ein Kreis Sprite, und machen Sie es rot.

Lassen Sie uns nun eine anhängen Audio Source zu diesem Sprite.

Damit das Objekt einen Sound spielt, müssen wir ihm einen geben. Lassen Sie uns diesen Soundeffekt für unseren Zweck verwenden.

http://www.orangefreesounds.com/ding-sfx/

Laden Sie den Soundeffekt herunter und ziehen Sie ihn in die Assets.

Wenn Unity dieses Asset als Audiodatei importiert, wird es automatisch in eine konvertiert AudioClip. Daher können Sie diesen Soundclip aus den Assets direkt in den Audio-Clip-Steckplatz in der Audioquelle unseres Sprites ziehen.

Nachdem Sie den Soundclip aus den Assets direkt in den Audio-Clip-Steckplatz in der Audioquelle unseres Sprites gezogen haben, müssen Sie in den Audio Source-Eigenschaften die Option "Play on Awake" deaktivieren. Wenn Sie dies nicht tun, wird der Sound in dem Moment abgespielt, in dem das Spiel beginnt.

Lassen Sie uns nun in unseren Code springen. Erstellen Sie ein neues Skript namens "BellSound" und öffnen Sie es.

Da unsere Audioquelle über Code gesteuert wird, möchten wir zunächst einen Verweis darauf erhalten. Wir werden die GetComponent-Methode wie zuvor verwenden.

public class BellSound : MonoBehaviour {
   AudioSource mySource;
   // Use this for initialization
   void Start () {
      mySource = GetComponent<AudioSource>();
}

Lassen Sie uns nun die Methode einrichten, um das angeklickte Objekt zu erkennen. MonoBehaviour bietet uns genau die Methode, die wir dafür benötigen: OnMouseDown. Die Methode wird immer dann aufgerufen, wenn die Maus im Bereich von a klicktcollider dieses gameObject.

Da wir noch keinen Collider an unseren Button angehängt haben, lassen Sie uns dies jetzt tun.

Wir werden keinen starren Körper für diesen brauchen; Wir müssen auch nicht per Code auf diesen Collider zugreifen. Es muss nur da sein, damit die Methode funktioniert.

Lassen Sie uns die Methode testen und sehen, ob sie funktioniert. Schreiben Sie den folgenden Code in Ihr Skript und hängen Sie ihn an die Schaltfläche an.

void OnMouseDown() {
   Debug.Log(“Clicked!”);
}

Sobald Sie das Skript gespeichert und angehängt haben, spielen Sie das Spiel. Durch Klicken auf die Schaltfläche sollte eine Nachricht in der Konsole angezeigt werden.

Sie sind jetzt einen Schritt vom Abspielen des Sounds entfernt. Jetzt müssen Sie nur noch die anrufenPlay Methode in der Audio Source-Instanz.

void OnMouseDown() {
   mySource.Play();
}

Speichern Sie Ihr Skript und führen Sie es im Spiel aus. Klicken Sie auf die Schaltfläche und Sie sollten den Ton hören!

Note- Überlegen Sie, ob Sie bei jedem Klick eine Schaltfläche erstellen möchten, deren Tonhöhe steigt. VerwendenmySource.pitch und einen Zähler und sehen, ob Sie es herausfinden können.)

In diesem Abschnitt erfahren Sie mehr über den Entwurfsprozess für Benutzeroberflächen- oder Benutzeroberflächenelemente in Unity. Dies umfasst das Basis-Setup sowie eine Übersicht über die allgemeinen Elemente, die im Lieferumfang von Unity enthalten sind.

Der Workflow zum Entwerfen der Benutzeroberfläche in Unity folgt einem etwas anderen Pfad als dem, den wir bisher durchlaufen haben. Für den Anfang sind UI-Elemente keine Standard-GameObjects und können nicht als solche verwendet werden. UI-Elemente sind unterschiedlich gestaltet. Eine Menüschaltfläche, die in einer Auflösung von 4: 3 korrekt aussieht, kann in einer Auflösung von 16: 9 gestreckt oder verzerrt aussehen, wenn sie nicht richtig eingerichtet ist.

UI-Elemente in Unity werden nicht direkt in der Szene platziert. Sie werden immer als Kinder eines speziellen GameObjects namens the platziertCanvas. Die Leinwand ist wie ein „Zeichenblatt“ für die Benutzeroberfläche in der Szene, in der alle Elemente der Benutzeroberfläche gerendert werden. Erstellen eines UI-Elements aus demCreate Das Kontextmenü ohne vorhandenen Canvas generiert automatisch einen.

Schauen wir uns jetzt das Canvas GameObject an, um mehr über die zusätzlichen neuen Komponenten zu erfahren.

Das Rect Transform oben scheint es viele neue Eigenschaften zu geben, die eine Standard-GameObject-Transformation nicht hat.

Dies liegt daran, dass die Transformation eines normalen GameObjects ein Imaginäres beschreibt point im 3D-Raum a RectTransform definiert ein imaginäres rectangle. Dies bedeutet, dass wir zusätzliche Eigenschaften benötigen, um genau zu definieren, wo sich das Rechteck befindet, wie groß es ist und wie es ausgerichtet ist.

Wir können einige Standardeigenschaften eines Rechtecks ​​wie Höhe und Breite sowie zwei neue Eigenschaften sehen, die aufgerufen werden Anchors. Anker sind Punkte, an die sich andere Objekte im Canvas-Bereich „binden“ können. Dies bedeutet, dass, wenn ein UI-Element (z. B. eine Schaltfläche) rechts im Canvas verankert ist, durch Ändern der Größe des Canvas sichergestellt wird, dass sich die Schaltfläche immer im relativen Bereich befindetright der Leinwand.

Standardmäßig können Sie die Form des Canvas-Bereichs nicht ändern, und es handelt sich um eine vergleichbare Form gigantic Rechteck um Ihre Szene.

Als nächstes kommt die CanvasKomponente. Dies ist die Hauptkomponente, die einige universelle Optionen zum Zeichnen der Benutzeroberfläche enthält.

Die erste Option, die wir sehen, ist die Render Mode. Diese Eigenschaft definiert die Methode, mit der der Canvas in die Ansicht des Spiels gezeichnet wird.

Wir haben drei Optionen in der Dropdown-Liste. Lassen Sie uns in den folgenden Abschnitten mehr über die Optionen erfahren.

Bildschirmbereich - Überlagerung

Dieser Modus ist der Standard für Menüs, HUDs usw. Die Benutzeroberfläche wird über alles in der Szene gerendert, genau wie sie angeordnet ist und ausnahmslos. Es skaliert auch die Benutzeroberfläche, wenn sich die Größe des Bildschirms oder des Spielfensters ändert. Dies ist der Standard-Rendermodus im Canvas-Bereich.

Bildschirmfläche - Kamera

Bildschirmbereich - Die Kamera erstellt eine imaginäre Projektionsebene, einen festgelegten Abstand von der Kamera, und projiziert die gesamte Benutzeroberfläche darauf. Dies bedeutet, dass das Erscheinungsbild der Benutzeroberfläche in der Szene stark von den von der Kamera verwendeten Einstellungen abhängt. Dies schließt Perspektive, Sichtfeld usw. ein.

Weltraum

Im Weltraummodus verhalten sich UI-Elemente so, als wären sie normale GameObjects, die in die Welt gestellt werden. Sie ähneln jedoch Sprites, sodass sie normalerweise als Teil der Spielwelt und nicht für den Spieler verwendet werden, wie z. B. Monitore und Displays im Spiel. Aus diesem Grund können Sie die Werte von Canvas RectTransform in diesem Modus direkt ändern.

Das Canvas Scalerist eine Reihe von Optionen, mit denen Sie den Maßstab und das Erscheinungsbild der UI-Elemente genauer anpassen können. Hier können Sie definieren, wie UI-Elemente verwendet werdenresizeselbst, wenn sich die Größe des Bildschirms ändert. Beispielsweise können UI-Elemente unabhängig von und im Verhältnis zur Bildschirmgröße dieselbe Größe beibehalten oder gemäß a skaliert werdenReference Resolution.

Der Graphics Raycaster befasst sich hauptsächlich mit Raycasting (Link zur Unity-Dokumentation für Raycasting) der Benutzeroberflächenelemente und stellt sicher, dass vom Benutzer initiierte Ereignisse wie Klicks und Drags korrekt funktionieren.

In diesem Kapitel erfahren Sie, wie Sie UI-Elemente in unsere Szene einfügen und mit ihnen arbeiten.

Beginnen wir mit einem Button. Um eine Schaltfläche einzufügen, klicken Sie mit der rechten Maustaste in die Szenenhierarchie und gehen Sie zuCreate → UI → Button. Wenn Sie keinen Canvas und kein EventSystem haben, erstellt Unity automatisch einen für Sie und platziert die Schaltfläche auch im Canvas.

Denken Sie daran, in OverlayIm Rendering-Modus, dem Standardmodus, ist die Größe des Canvas unabhängig von der Größe der Kamera. Sie können dies testen, indem Sie auf klickenGame Tab.

Wenn Sie die Szene abspielen, werden Sie feststellen, dass die Schaltfläche bereits über einige Standardfunktionen verfügt, z. B. das Erkennen, wann die Maus darüber bewegt wird, und das Ändern der Farbe beim Drücken.

Eine Schaltfläche erfordert Funktionen, die in der Benutzeroberfläche tatsächlich nützlich sind. Diese Funktionalität kann über seine Eigenschaften hinzugefügt werden.

Lassen Sie uns ein neues Skript erstellen und es aufrufen ButtonBehaviour.

public class ButtonBehaviour : MonoBehaviour {
   int n;
   public void OnButtonPress(){
      n++;
      Debug.Log("Button clicked " + n + " times.");
   }
}

Wir haben eine einfache Methode entwickelt, die protokolliert, wie oft wir auf die Schaltfläche gedrückt haben.

Note- Diese Methode muss öffentlich sein; Andernfalls wird es von der Funktionalität des Buttons nicht bemerkt.

Lassen Sie uns ein leeres GameObject erstellen und dieses Skript anhängen. Wir tun dies, weil ein Knopf nichts alleine macht; Es ruft nur die angegebene Methode in seinem Skript auf.

Gehen Sie nun in die Eigenschaften des Buttons und suchen Sie die OnClick() Eigentum.

Klicken Sie auf das + -Symbol auf der unteren Registerkarte. Ein neuer Eintrag sollte in der Liste angezeigt werden.

Dieser Eintrag definiert, auf welches Objekt der Tastendruck wirkt und welche Funktion des Skripts dieses Objekts aufgerufen wird. Aufgrund des beim Tastendruck verwendeten Ereignissystems können Sie mehrere Funktionen auslösen, indem Sie sie einfach zur Liste hinzufügen.

Ziehen Sie das leere GameObject, das das enthält, per Drag & Drop ButtonManager Skript, das wir erstellt haben, auf die None (Object) Slot.

Navigieren Sie zum No Function Dropdown-Liste, und suchen Sie nach unserer OnButtonPressMethode. (Denken Sie daran, dass es beliebig benannt werden kann. OnButtonPress ist einfach eine standardisierte Namenskonvention.) Sie sollten es in der findenButtonBehaviour Sektion.

Wenn Sie das Spiel jetzt spielen, können Sie die Taste testen und die Konsole druckt mit Sicherheit aus, wie oft Sie die Taste gedrückt haben.

Die in Unity integrierte Text-Benutzeroberfläche ist ein guter Ausgangspunkt für Lernende, um mit dem Entwerfen der Benutzeroberfläche zu beginnen, auch wenn sie tendenziell von leistungsfähigeren und effizienteren Community-Assets überschattet wird.

Für unseren Zweck ist das Vanille-Text-Element mehr als ausreichend, um loszulegen.

Text, der ein eigenständiges UI-Element ist, ist in erster Linie auf das zurückzuführen dynamismdieses Elements. Zum Beispiel erfordert das Drucken der aktuellen Punktzahl des Spielers auf dem Bildschirm, dass der numerische Wert der Punktzahl in eine Zeichenfolge konvertiert wird, im Allgemeinen über die.toString() Methode, bevor es angezeigt wird.

Um ein Text-UI-Element einzufügen, gehen Sie zur Szenen-Heirarchie. Create → UI → Text.

In Ihrer Canvas-Region sollte ein neues Textelement angezeigt werden. Wenn wir uns seine Eigenschaften ansehen, werden wir einige sehr nützliche Optionen sehen.

Am wichtigsten ist jedoch die Text field. Sie können eingeben, was das Textfeld in diesem Feld sagen soll, aber wir möchten noch einen Schritt weiter gehen.

Um die Schriftart des Textes zu ändern, müssen Sie zuerst die importieren font filevon Ihrem Computer in Unity als Asset. Eine Schriftart muss nicht aktiv an irgendetwas in der Szene angehängt werden und kann direkt aus den Assets referenziert werden.

Auf das Textelement kann auch über Skripte zugegriffen werden. Hier liegt die Bedeutung vondynamic Benutzeroberfläche kommt herein.

Geben Sie anstelle der Konsole aus, wie oft die Taste wie im vorherigen Kapitel gedrückt wurde. Lassen Sie es uns tatsächlich auf dem Spielbildschirm ausdrucken. Zu diesem Zweck öffnen wir unser ButtonBehaviour-Skript aus der vorherigen Lektion und nehmen einige Änderungen daran vor.

using UnityEngine;
using UnityEngine.UI;
public class ButtonBehaviour : MonoBehaviour {
   int n;
   public Text myText;
   public void OnButtonPress(){
      n++;
      myText.text = "Button clicked " + n + " times.";
   }
}

Die erste Änderung bestand darin, eine neue Namespace-Referenz hinzuzufügen. Diese Referenz wird verwendet, um mit den UI-Komponenten von Unity zu arbeiten. Daher fügen wir die Verwendung hinzuUnityEngine.UI Linie.

Als Nächstes erstellen wir eine öffentliche Textvariable, auf die wir unser Text-UI-Element ziehen und ablegen können.

Schließlich greifen wir auf den eigentlichen Text zu, den dieses UI-Element enthält myText.text.

Wenn wir unser Skript speichern, sehen wir jetzt einen neuen Slot für das Text UI-Element in unserem ButtonManager. Ziehen Sie einfach das gameObject mit diesem Textelement auf den Steckplatz und klicken Sie auf die Schaltfläche "Abspielen".

In diesem Kapitel lernen wir das letzte UI-Element in dieser Reihe kennen. Der Schieberegler wird häufig verwendet, wenn ein bestimmter Wert zwischen einem Maximal- und einem Minimalwertpaar festgelegt werden soll. Eine der häufigsten Anwendungen ist die Lautstärke oder die Bildschirmhelligkeit.

Um einen Schieberegler zu erstellen, gehen Sie zu Erstellen → Benutzeroberfläche → Schieberegler. Eine neueSlider Element sollte in Ihrer Szene angezeigt werden.

Wenn Sie zu den Eigenschaften dieses Schiebereglers gehen, werden Sie eine Reihe von Optionen zum Anpassen feststellen.

Lassen Sie uns versuchen, eine zu machen volumeSchieberegler aus diesem Schieberegler heraus. Öffnen Sie dazu das ButtonBehaviour-Skript (Sie können das ButtonManager GameObject umbenennen, da es sicherlich mehr als nur eine Schaltfläche jetzt verwaltet) und fügen Sie einen Verweis auf den Schieberegler hinzu. Wir werden den Code auch noch einmal etwas ändern.

public class ButtonBehaviour : MonoBehaviour {
   int n;
   public Text myText;
   public Slider mySlider;
   void Update() {
      myText.text = "Current Volume: " + mySlider.value;
   }
}

Verstehen Sie, wie wir die Update-Methode verwenden, um den Wert von myText.text ständig zu aktualisieren.

Aktivieren Sie in den Slider-Eigenschaften das Kontrollkästchen "Ganze Zahlen" und setzen Sie den Maximalwert auf 100.

Wir werden die Farbe des Textes durch seine Eigenschaften für eine sichtbarere Farbe einstellen.

Gehen wir genauso vor, wie Sie das Slider GameObject auf den neuen Slot ziehen und auf Play klicken.

Es wird dringend empfohlen, dass Sie auch die anderen Steuerelemente der Benutzeroberfläche untersuchen und damit experimentieren, um festzustellen, welche auf welche Weise funktionieren.

In unserem nachfolgenden Abschnitt erfahren Sie mehr über Beleuchtung, Materialien und Shader.

In diesem Kapitel lernen wir kurz Materialien und Shader kennen. Um besser zu verstehen, werden wir eine neue erstellen3D Projectanstelle unserer aktuellen 2D. Dies wird uns helfen, die verschiedenen Änderungen zu erkennen.

Wenn Sie das neue Projekt erstellt haben, gehen Sie zur Hierarchie, klicken Sie mit der rechten Maustaste und gehen Sie 3D Object → Cube. Dadurch wird in der Mitte der Szene ein neuer Würfel erstellt. Sie können sich im Würfel umsehen, indem Sie mit der rechten Maustaste gedrückt halten und die Maus in der Szenenansicht ziehen. Sie können auch mit dem Scrollrad hinein- und herauszoomen.

Klicken Sie nun auf den Würfel und sehen Sie sich seine Eigenschaften an.

Die unterste Eigenschaft scheint ein Standardmaterial und a zu haben Standard Shader.

Was ist ein Material?

In Unity (und in vielen 3D-Modellierungsaspekten) a Materialist eine Datei, die Informationen zur Beleuchtung eines Objekts mit diesem Material enthält. Beachten Sie, wie eine graue Kugel das Material kennzeichnet, wobei etwas Licht von oben hereinkommt.

Verwechseln Sie sich jetzt nicht mit dem Namen. Ein Material hat nichts mit Masse, Kollisionen oder sogar Physik im Allgemeinen zu tun. Ein Material wird verwendet, um zu definieren, wie sich die Beleuchtung auf ein Objekt mit diesem Material auswirkt.

Versuchen wir, unser eigenes Material zu erstellen. Klicken Sie mit der rechten Maustaste in den Bereich "Assets" und gehen Sie zuCreate → Material und geben Sie ihm einen Namen wie "Mein Material".

Diese Eigenschaften sind mit nichts vergleichbar, was wir bisher untersucht haben. Dies liegt daran, dass dies Eigenschaften sind, die in der programmiert sindshader, nicht das Material.

Materialien machen Ihre Objekte in erster Linie sichtbar. Selbst in 2D verwenden wir ein spezielles Material, für das keine Beleuchtung erforderlich ist. Natürlich generiert und wendet Unity es für uns auf alles an, sodass wir nicht einmal bemerken, dass es da ist.

Was ist ein Shader?

Ein Shader ist ein Programm, das definiert, wie every single pixelwird auf dem Bildschirm gezeichnet. Shader sind überhaupt nicht in C # oder sogar in einer OOPS-Sprache programmiert. Sie sind in a programmiertC-like Sprache namens GLSL, die der GPU direkte Anweisungen für eine schnelle Verarbeitung geben kann.

Partikelsysteme helfen dabei, auf effiziente Weise eine große Anzahl von Partikeln mit geringer Lebensdauer zu erzeugen. Diese Systeme werden einem separaten Rendering-Prozess unterzogen. Sie können Partikel instanziieren, selbst wenn Hunderte oder Tausende von Objekten vorhanden sind.

Jetzt, particlessind ein mehrdeutiger Begriff im Partikelsystem; einparticleist jede einzelne Textur, Materialinstanz oder Entität, die vom Partikelsystem erzeugt wird. Dies sind nicht unbedingt Punkte, die im Raum herumschweben (obwohl dies möglich ist!), Und sie können für eine Vielzahl verschiedener Szenarien verwendet werden.

Ein GameObject verwaltet ein Partikelsystem mit der angeschlossenen Partikelsystemkomponente. Für die Einrichtung von Partikelsystemen sind keine Assets erforderlich, obwohl je nach gewünschtem Effekt unterschiedliche Materialien erforderlich sein können.

Fügen Sie zum Erstellen eines Partikelsystems entweder die Komponente hinzu Particle System über die Einstellung Komponente hinzufügen oder gehen Sie zur Hierarchie und wählen Sie Create → Effects → Particle System. Dadurch wird ein neues GameObject mit angeschlossenem Partikelsystem generiert.

Wenn Sie sich die Eigenschaften des Partikelsystems ansehen, werden Sie feststellen, dass es viele umfasst modules. Standardmäßig sind nur drei Module aktiv. dasEmission, Shape und die Renderer. Andere Module können durch Klicken auf den kleinen Kreis neben ihrem Namen aktiviert werden.

Rechts neben einigen Werten sehen Sie möglicherweise einen kleinen schwarzen Pfeil. Auf diese Weise können Sie die Werte jedes einzelnen Partikels besser steuern. Zum Beispiel können Sie die einstellenStart Size zu Random between Two Constants um das Partikelsystem anzuweisen, zufällige Partikel unterschiedlicher Größe wie einen Wasserschlauch zu rendern.

Der Asset Store ist eine der größten Stärken von Unity auf dem Markt für Game-Engines. Es umfasst eine große Anzahl von Assets, Tools, Skripten und sogar ganze vorgefertigte Projekte, die Sie herunterladen können.

Um den Asset Store nutzen zu können, benötigen Sie eine gültige Unity ID. Wenn Sie noch keine haben, können Sie eine auf der Unity-Website erstellen.

Wenn Sie eine Unity-ID erstellt haben, klicken Sie auf Asset Store Registerkarte in derselben Zeile wie die Scene View.

Sobald Sie sich angemeldet haben, sollte Ihr Benutzername oben rechts angezeigt werden.

In diesem Beispiel importieren wir das Survival Shooter TutorialProjekt. Dazu suchen wir auf der Registerkarte danach und klicken auf das von Unity veröffentlichte Asset.

Wir werden auf Download klicken und es vervollständigen lassen. Sobald es fertig ist, wird dieDownload Schaltfläche ändert sich zu Import;; Klicken Sie erneut darauf, um Ihr neues Asset in das aktuell geöffnete Projekt zu importieren.

(Hinweis - In diesem speziellen Fall importieren wir ein vollständiges Projekt. Wenn Unity Sie davor warnt, erstellen Sie ein neues Projekt oder überschreiben Sie das vorhandene, wenn Sie möchten. In beiden Fällen ist dies in Ordnung.)

Ein neues Fenster wird geöffnet, in dem der gesamte Inhalt des gerade importierten neuen Assets aufgelistet wird. Je nachdem, was Sie heruntergeladen haben, kann dies eine einzelne Datei oder eine Reihe von Dateien oder ein ganzer Baum mit Hierarchien von Ordnern und Dateien sein. Standardmäßig importiert Unity alle Asset-Komponenten, wenn Sie auf klickenImport, was wir wollen. Lassen Sie uns jetzt auf klickenImport for Unity machen ihren Job.

Der Versuch, Assets herunterzuladen, ohne dafür zu bezahlen, ist illegal und birgt immer die Möglichkeit von Viren, Fehlern oder fehlenden Updates.