11 Schritt:Schritt 1: Einheit und Visual Studio Schritt 2: Hinzufügen von Virtual Reality Schritt 3: Mit und Scripting Oculus-Kamera Schritt 4: VR UI Schritt 5: Hinzufügen von EndGame UI and Controls Schritt 6: Einrichten des Kinect Schritt 7: Kinect Scripting Schritt 8: Hinzufügen von Kinect zu Unity Schritt 9: mit Handschaltung mit dem Kinect Schritt 10: Kinecting das Spiel Input Controller Schritt 11: Aktivieren / Deaktivieren der Bedienelemente

    Immersive Infinite Runner Benennen Sie Ihr Projekt. Jetzt hoffentlich Ihr Projekt ist etwas, das Sie bereits lieben, so wird es nicht schwer sein, sie zu nennen. Denken Sie Spaß! Denken Sie inspirieren. Think "Hölle, würde ich zu machen, dass ich will." Geben Sie eine kleine Zusammenfassung. Zum Beispiel: "Bauen Sie dieses tolle Selbstbewässerungsinnengarten. Alles was Sie brauchen ist ein wenig Kreativität, einige Programmierkenntnisse, ein paar 2x4s und ein Wochenende, um sich für die automatisierte Indoor-Garten den ganzen Winter einzurichten. " Gehen Sie voran und loslegen. Vorräte · Microsoft-Konto verbinden - https://www.microsoft.com/en-us/account/default.aspx · Visual Studio Community Edition 2013 oder 2015 - https://www.visualstudio.com/ · Visual Studio Unity Plugin - http://unityvs.com · Kinect SDK - https://www.microsoft.com/en-us/kinectforwindows/develop/downloads-docs.aspx · Kinect für Windows Hardware (stellen Sie sicher, Kinect Adapter für Windows haben) - https://www.microsoft.com/en-us/kinectforwindows/purchase/default.aspx#tab=2 · Unity3d Version 4 (aka Unity4.6.1 oder höher) oder Unity 3D-Version 5 (aka Unity5) · Oculus SDK · Oculus Runtime · Oculus - Unity 4 Integration (dies funktioniert in Unity5 als auch) · PC mit USB 2.0 und USB 3.0-Ports ** Mac-Anwender ** Sie werden nicht in der Lage, mit dem Kinect zu arbeiten, wenn Sie Bootcamp installiert haben (oder einen anderen Weg, um Ihre Festplatte partitionieren) mit einem Windows-Betriebssystem, sorry. Das Spiel Okay, so ist das erste, was Sie brauchen, um Ihr Spiel alle eingerichtet und ausgeführt wird, in Unity. Wenn Sie habe nach meinem Blog (http://kaharri.com - Unity Gaming-Serie), dann sollten Sie den Großteil der Spiel läuft. Http://github.com/katvharris - Wenn nicht, können Sie den gesamten Code in meinem GitHub Repo greifen. Dort finden Sie die voll funktionsfähige unendliche Läufer ohne die Kinect und Oculus Teile zu finden, dass ich mit, um aus der zu bauen. Schritt 1: Einheit und Visual Studio Einheit und Visual Studio Um den Code zu bearbeiten, müssen Sie die Einheit auf Ihrem Computer installiert haben. Ich erkläre es unten auch. Zuerst müssen Sie für Einheit laden Sie die Visual Studio Plugin. Zum http://unitvs.com Laden Sie die Version des Plugins, die die Version von Visual Studio haben Sie übereinstimmt. Einmal an einen Ort, den Sie sich leicht merken können heruntergeladen extrahieren Sie alle Dateien. Öffnen Sie das Spiel in Unity. Zum Assets> Import Package> Auftragspaket. Navigieren Sie zu dem Unity Visual Studio-Paket und wählen Sie es. BILD 1 oben Nach der Auswahl ist, wird Unity fordert Sie auf, das Paket zu importieren. Klicken Sie auf Importieren. Nun, da Sie dieses Paket einmal, um Unity importiert haben, müssen Sie nicht auf die Suche nach dem Paket wieder. Wenn Sie in der Nähe der Einheit, und erneut öffnen, werden Sie nun feststellen, dass, wenn Sie Assets gehen> Import Package wird es eine neue Option namens Visual Studio Tools sein. Als nächstes haben wir, um anzugeben, dass wir, um die Visual Studio IDE anstelle von MonoDevelop nutzen wollen. Um dies zu tun wir navigieren Sie Bearbeiten> Voreinstellungen BILD 2 oben Gehen Sie zu External Settings Bild 3 OBEN Und schalten Sie ihn von Mono zu entwickeln, um Visual Studio. Und dort haben Sie es! Eine kleine Einschränkung. Auf jedem neuen Projekt, das Sie erstellen, müssen Sie noch um Assets gehen> Import Package> Visual Studio-Tools, und bestätigen Sie den Import. Schritt 2: Hinzufügen von Virtual Reality Oculus Cool. So, jetzt, dass Sie das Spiel der virtuellen Realität Teil wird von der Oculus Verfügung gestellt werden. Es gibt einige andere Headsets aber derzeit Oculus SDK verfügt über die Dokumentation und daher, wenn Sie in einen Fehler laufen wird es leichter sein Online-Hilfe zu finden. Zunächst müssen wir die Oculus Stücke von ihrer Website zu greifen. Sie können ihre Download-Bereich zu gehen. Nun, wenn Sie einen Mac oder Linux haben, laden Sie die entsprechenden Links für diesen Betriebssystemen. BILD 1 Nachdem Sie die Links downloaden Sie jetzt brauchen, um die Laufzeit zu installieren. Dann starten Sie Ihren Computer. Integration in Unity Im Projekt erstellen Sie eine neue Szene, um die Oculus Stück zu testen. BILD 2 Extrahieren Sie die Dateien aus der Unity-Integrationspaket Sie heruntergeladen haben. Gehen Sie in Unity auf Assets> Import Package> Auftragspaket Finden Sie, wo Sie die Dateien extrahiert und navigieren Sie zum Unity Plugin. Bild 3 Dann doppelklicken Sie auf der Verpackung. Sobald Sie das tun, wird die Einheit alle Dateien im Paket hochziehen und fordert Sie auf, sie zu importieren. Hit Import. Bild 4 Nun sollten Sie einen neuen Ordner in Ihrem Assets genannt OVR. Bild 5 Dieser neue Ordner wird alle Dateien, die Sie benötigen, um virtuelle Realität ins Spiel haben. Schritt 3: Mit und Scripting Oculus-Kamera Alle 10 Artikel anzeigen Jetzt mit dem Oculus Package ist super einfach. Oculus bereits prefabs erstellt für Entwickler, um zu verwenden. Sie haben eine Fertig nur mit dem Kamera-Rig, sowie eine mit der Anlage und einem Charakter Motor. BILD 1 Um sie zu verwenden einfach klicken und ziehen Sie sie in Ihre Szene. Ich legte die OVRPlayerController bei 0, 2, 0. BILD 2 Nun versuchen Sie das Spiel. Sie sollten etwas, das wie folgt aussieht: Bild 3 Der Doppelkreis-Bildschirm ist, was mit Ihren Oculus zugeführt werden, und mit den Linsen und dem Headset sollte es ein Bild mit einem 3-dimensionale Gefühl zu werden. Normalerweise wird dieser Spieler Fertig Werke für die meisten Spiele, aber aus unbekannten Gründen die Collider und starren Körper des OVR Fertig nicht mit dem Spiel zu arbeiten. So haben wir einen weiteren Schritt. Die Kombination der FPS-Controller mit der OVR-Controller. Erstellen OVR Spieler Prefab Jetzt in der Szene die FPSprefab im Projekt bei der Suche nach es in dem Ordner Assets. Bild 4 Klicken Sie auf und ziehen Sie sie in die Szene, wie Sie mit dem OVRPlayer Prefab tat und legen Sie sie bei (0, 0, 0). Bild 5 Weiter Ziehen Sie den OVRCamera Prefab in die Szene unter dem Kopfstück des FPSPreFab. Bild 6 Bild 7 Danach deaktivieren Sie die First Person Kamera. Bild 8 Die OVRCamera Rig ist perfekt für diese Situation, da wir bereits eine funktionierende Spieler, den wir verwenden möchten. Bewegen Sie den FPSPreFab zu (0, 2, 0), und führen Sie das Spiel. Es sollte wie folgt aussehen: (und die Pfeiltasten oder "WASD" wird immer noch Bewegung und Maus / Kopf zu steuern wird kontrollieren, wo Sie suchen). Bild 9 Groß jetzt, da wir wissen, dass es funktioniert, müssen wir es auf der Hauptszene hinzuzufügen. So gehen Sie zu Datei> Öffnen Szene. Es sollte promt Sie diese Szene als auch speichern. Speichern Sie diese Szene und nennen es OVRTest da wir diese Umgebung, um die OVR-Bibliotheken testen. In der Open Scene Explorer-Fenster zu dem Ordner Scenes> wählen Sie dann Haupt IMAGE 10Step 4: Erstellen VR UI Alle 11 Artikel anzeigen Jetzt in unsere Szene, fügen Sie die OVRCamerRig auf die FPSPreFab wie wir vor. Wir müssen jetzt eine Benutzeroberfläche für das Oculus hinzufügen, weil das Rundfenster können keine HUD zeigt die gleiche Art und Weise regelmäßige Unity-Kameras können. Also auf diese Kopie des Canvas-Objekt zu tun und fügen Sie ihn unter dem OVRCameraRig und benennen Sie die Leinwand OVRCanvas. BILD 1 oben BILD 2 oben Wir müssen diese Leinwand bearbeiten ein wenig, bevor es funktioniert. 1) Wir brauchen diese UI im Weltraum sein. Wir tun dies, indem Sie die OVRCanvas und dann unter Unity Canvas> Rendermode und im Pull-Down-Auswahlweltraums. Bild 3 OBEN Bild 4 OBEN 2) Ändern Sie den Text Anleitung Bild 5 Bild 6 3) Deaktivieren Sie die Buttons - Buttons werden nicht benötigt, da wir mit dem Kinect. 4) Ändern Sie die Animation in der Gamecontroller an die neuen OVRCanvas gelten - Tun Sie dies, indem Sie folgende Zeilen in die Gamecontroller wach Verfahren: Gameobject ovrcanvas = GameObject.Find ("OVRCanvas"); startAnim = ovrcanvas.GetComponent (); 5) und kommentieren Sie die aktuelle startAnim Linie. // (StartAnim = canvas.GetComponent); Wir sind noch nicht fertig. Wir müssen auch das End Game UI neu einzustellen, aber wir können diese auf die gleiche Weise haben wir es mit dem StartUI erzielen. Wählen Sie die Start-UI aus der Hierarchie und wählen Sie das 2D-Button in der Szene Tab. In der Regel ist es einfacher, mit UI im 2D-Modus der Einheit zu arbeiten. BILD 7 oben Bild 8 OBEN Wir wissen nicht wirklich etwas sehen in der Szene. Das ist, weil zu Beginn des Spiels, das einzige, was in der Leinwand, die wir sehen wollen sind die Anweisungen. , Dagegen sehen wir ein Rechteck mit blauen Kreisen an den Ecken rund um das Segeltuch. Das Rechteck bezeichnet den Raum, in dem die End-Benutzeroberfläche wird angezeigt. Jetzt in Oculus der Sucher ist etwas begrenzt, da wir die Leinwand im Welt-Raum. Deshalb müssen wir den Inhalt des UI an den Sichtbereich der Nutzer Vision zu bewegen; das ist nun mal die Anleitung Box. Um es zu bewegen, müssen wir sicherstellen, dass die Ankerbewegung Werkzeug ausgewählt ist und nicht der reguläre Übergangswerkzeug. Bild 9 Bild 10 Dann können wir um den Inhalt in Richtung der Mitte des Bildschirms zu bewegen. Durch Klicken und Ziehen. Wenn Sie bestimmte Teile der Hierarchie ausgewählt ihre entsprechenden Positionen in der Szene wird die blaue Enge Rechteck um sie haben. Startknopf-UI In der Gamecontroller die Update-Methode brauchen wir eine bedingte, dass das Spiel hat noch nicht begonnen und die Animation nicht geladen wird qualifiziert, um hinzuzufügen. Conisidentaly wir dies bereits. In der Boolesche Variable gamestarted. Fügen Sie diese auf den Anfang des Update. if (! gamestarted) { if (Input.GetKey (KeyCode.KeypadEnter)) { Spiel beginnen(); } } Das Update sollte nun wie folgt aussehen: nichtig Update () { if (! gamestarted) { if (Input.GetKey (KeyCode.KeypadEnter)) { Spiel beginnen(); } } if (Laden) { Debug.log ("Anime beginnen sollte"); // ... Sagen, der Animator ist das Spiel vorbei. startAnim.SetTrigger ("StartGame"); // .. Inkrementieren einen Timer zu zählen bis zu einem Neustart. beginningTimer + = Time.deltaTime; // .. Wenn sie die Wiederanlaufverzögerung erreicht ... if (beginningTimer> = beginningDelay) { Debug.log ("TriggeringStart"); Lade = false; Spiel beginnen(); } } // Den angezeigten Text setzen, um das Wort zu sein "Score" durch den Score-Wert gefolgt. scoreText.text = "Ergebnis:" + punkten; finalScoreText.text = "Ergebnis:" + punkten; if (playerHealth.currentHealth <= 0 &&! gameended) InitializeEndGame (); if (gameended) { restartTimer + = Time.deltaTime; // .. Wenn sie die Wiederanlaufverzögerung erreicht ... if (restartTimer> = restart) { // .. Laden Sie dann die aktuell geladenen Ebene. Application.LoadLevel (Application.loadedLevel); } } } Im nächsten Schritt müssen wir abzuschließen ist, ändern Sie den Game-Controller, so kann es zu beenden und neu starten, das Spiel mit neuen Eingaben. Wir müssen auch die Plattformen der Szene zu zerstören, sonst wird es zu blockieren unsere Spieler zu sehen, wie das Bild unten. Bild 11 Auf der linken Seite ist, was die Spieler Ansicht sollten sehen, sondern sie sehen immer noch die platforms.Step 5: Hinzufügen EndGame UI and Controls Derzeit alle Plattformen im Spiel sind Kinder auf der Problem Solver-Spiel-Objekt. Dies ist, wie all die Drehungen angewendet, um die neu hervorgebracht Plattformen eben sein. So können wir leicht deaktivieren durch Deaktivieren der ProblemSolver. BILD 1 In den Game-Controller die Update-Methode gibt es diesen Codeabschnitt an der Unterseite: if (playerHealth.currentHealth <= 0 &&! gameended) InitializeEndGame (); if (gameended) { restartTimer + = Time.deltaTime; // .. Wenn sie die Wiederanlaufverzögerung erreicht ... if (restartTimer> = restart) { // .. Laden Sie dann die aktuell geladenen Ebene. Application.LoadLevel (Application.loadedLevel); } } Was das bedeutet ist angezeigt das Spiel End Animation Leinwand, die bereits erstellt ist, und nach einer bestimmten Zeit das Spiel neu gestartet. Wenn nun in der IntializeEndGame Verfahren die folgende Zeile: problemSolverObject.SetActive (false); Also das Verfahren sieht nun so aus: nichtig InitializeEndGame () { startAnim.SetTrigger ("Endspiel"); player.GetComponent () aktiviert = false. player.rigidbody.useGravity = false; // Platforms entfernen problemSolverObject.SetActive (false); } Nun, wenn das Spiel endet, können wir die End-Bildschirm zu sehen. BILD 2 oben Okay, so alles, was übrig ist zu tun, machen eine Tastatur Auslöser für den Neustart und ändern Sie die UI der EndGameCanavas um den Benutzer zu informieren, wie man das Spiel neu zu starten. Um den Text zu wiederholen, was wir mit dem StartUI änderte. Bild 3 OBEN Bild 4 OBEN Der Code hinter für den Neustart des Spiel passiert in der Update-Methode des Gamecontroller. Fügen Sie diese unter dem Player Gesundheit bedingte. if (playerHealth.currentHealth <= 0 &&! gameended) InitializeEndGame (); if (Input.GetKeyUp (KeyCode.Backspace) &&! gameended) RestartGame (); So starten Sie das Spiel erneut, und wenn du stirbst, sollten Sie den Weiß game over-Bildschirm mit dem neuen Text zu sehen und sollte neu starten, wenn Sie die Rücktaste getroffen. Bild 6 OBEN Schließlich sind wir mit der Oculus Komponente durchgeführt. Nun, für diese Kinect Steuerungen implementieren Schritt 6: Einrichten des Kinect Alle 12 Artikel anzeigen Software Setup Nun, bevor Sie anfangen, nur Einstecken in jedem Kinect aus zufälligen Xbox Ein oder Xbox 360, müssen Sie die entsprechende Software, damit Ihr Computer weiß, was man in sie Verstopfung sind. Sie können auch verwendet keine rando Kinect. Dieses Tutorial verwendet die Kinect v2; das ist die eine, die mit der Xbox One ausgeliefert wird. Allerdings, um den v2 mit Ihrem Computer verwenden, müssen Sie sicherstellen, dass Sie die Windows-Adapter haben! Lassen Sie uns zunächst installieren Sie das SDK. Wir müssen hier zu gehen: https: //www.microsoft.com/en-us/kinectforwindows/d ... Sie können auch auf die Kinect für Windows gehen Haupt-Website und gehen Sie zu ihrem Technische Dokumentation und Werkzeuge. Auf der technischen Dokumentation und Werkzeuge Seite haben sie eine Liste mit nützlichen Links zur Dokumentation und wesentliche Downloads, einschließlich der Unity-Plugin, das werden wir auch brauchen. BILD 1 Nachdem Sie das SDK heruntergeladen, führen Sie es. Sie werden mit einem Kinect für Windows-Setup-Assistenten dazu aufgefordert werden. BILD 2 Nachdem Sie das SDK installieren, sollten Sie einige neue Programme auf Ihrem Computer installiert haben. · SDK Browser · Kinect Studio v 2.0 · Kinect Gesture Builder Bild 3 Das SDK Browser wird die nützlichste der neuen Software sein, weil es Links zu allen anderen Programmen / Software sowie Demos und Beispiel-Code Sie verwenden können, enthält. Hardware-Setup Einrichten der Hardware ist ziemlich geradlinig, das ist toll! ** Mac-Anwender ** Sie werden nicht in der Lage, mit dem Kinect zu arbeiten, wenn Sie Bootcamp installiert haben (oder einen anderen Weg, um Ihre Festplatte partitionieren) mit einem Windows-Betriebssystem, sorry. Bild 4 Wenn Sie weitere Hilfe benötigen, die Einrichtung der Hardware ist hier eine hilfreiche Anleitung von Microsoft: https: //www.microsoft.com/en-us/kinectforwindows / ... Sobald Sie Stecken Sie den Kinect auf den USB3-Port Ihres Computers können wir die Verbindung mit den Kinect SDK-Anwendungen, die automatisch heruntergeladen wurden testen. Öffnen Sie den Browser SDK für Kinect. Das erste Programm in der Liste sollte die Kinect Configuration Verifier können. Starte es. Die Kinect Licht sollte jetzt einschalten, wenn es richtig angeschlossen ist und die Verifier wird ein Fenster zu öffnen, wenn alles korrekt ist, sollte es so aussehen: Bild 5 Wenn etwas nicht stimmt Sie erhalten ein rotes X Identifizierung der Fehlermeldung: Bild 6 Auch wenn ich eine Warnung über mein USB-Anschluss, mein Kinect läuft immer noch. Nun, um die durch die Kinect wir Kinect Studio laufen gesammelten Informationen anzuzeigen. Es wird das dritte Element in der SDK-Browser; oder Sie können es direkt aus Ihren Anwendungen zu öffnen. Kinect Studio sieht so aus: Bild 7 Keine Sorge, wenn Sie nicht sehen, nichts. Beim Start. Obwohl Ihr Kinect ist und Streaming-Daten auf Ihren Computer Kinect Studio noch nicht Einlesen dieser Daten. Sie müssen das Plug-Symbol in der linken oberen Ecke getroffen, so dass Sie nichts sehen können. Bild 8 Bild 9 Es gibt 7 Datenströme aus dem Kinect: 1) Körperrahmen 2) Körper Index 3) Kalibrierdaten 4) Tiefe 5) IR 6) Titel Audio 7) Unkomprimiert Farbe Sie können umschalten, was Streams von Informationen, die Sie, indem Sie das Kontrollkästchen auf der linken Seite erhalten möchten. Die wichtigsten Datenströme sind dem Körperrahmen / Body Index, Tiefe und Infrarot (IR). Sie können Kinect Studio schließen wir nicht mehr brauchen. Kinect und Unity Erste Schritt ist, laden Sie die Kinect für Windows Unity Package. : Sie können es unter diesem Link https: //www.microsoft.com/en-us/kinectforwindows / ... Bild 10 Um loszulegen werden wir die Schritte direkt in der Kinect für Windows Unity-Paket von Microsoft dargelegt zu verwenden; aber etwas bearbeitet, da wir bereits ein Projekt angelegt. 1) Öffnen der ZIP-Datei, und verschieben Kinect.2.0.1410.19000.UnityPackageto ein bekannter 2) Öffnen UnityPro (Sie brauchen, um eine Pro-Edition müssen in Custom-Pakete und Plugins ziehen) 3) Öffnen Sie die Unity-Projekt 4) Klicken Sie auf den Menüpunkt aktiv-> Import Package-> Benutzerdefinierte Package ... 5) Navigieren Sie zu der in Schritt 1 6) Wählen Sie die Kinect.2.0.1410.19000.UnityPackage 7) Klicken Sie auf "Öffnen" ** Bevor Sie das tun Schritt 8 hier ist eine wichtige Sache zu beachten - bei der Einfuhr Ankündigung, dass der Ordner heißt StandardAssets. Dies ist die gleichen Namen wie die Probe Assets aus der Unity Store. Wenn Sie mit Standard-Assets Paket Unity sind der Import-Manager wird die neuen Kinect-Dateien in die bereits vorhandenen Ordner einbetten. Achtung! Wenn Sie nicht halten Sie verfolgen, was Sie importieren Sie vielleicht Dateien innerhalb der zahlreichen Ordner Ihres Projektes zu verlieren. Also, um die Dinge organisiert Kenntnis von den Dateien, die nicht in Unterordnern und sind nur im Ordner Standard-Assets zu halten. In diesem Fall gibt es 10: · EventPump.cs · KinectBuffer.cs · KinectSpecialCases.cs · CameraIntrinsics Importeinstellungen · CollectionMap Importeinstellungen · ExecptionHelper Importeinstellungen · INativeWrapper Importeinstellungen · Nativeimporteinstellungen · SmartGCHandle Importeinstellungen · ThreadSafeDictionary Importeinstellungen Okay, jetzt wieder zu den Schritten ** 8) Klicken Sie auf "Import" in der unteren rechten Ecke des "Importieren Package" Dialog (die Einheit wird nach der Stufe 7 zu starten) 9) Wenn Sie die Kinect in Aktion sehen wollen, gibt es zwei Beispielszenen zur Verfügung aus dem zip. 10) Wenn Sie VisualGestureBuilder innerhalb Unity verwenden möchten, wiederholen Sie die Schritte 1 bis 8 mit Kinect.VisualGestureBuilder.2.0.1410.19000.unitypackage 11) Wenn Sie die Gesichts-Funktionalität innerhalb der Einheit nutzen möchten, wiederholen Sie die Schritte 1 bis 8 mit Kinect.Face.2.0.1410.19000.unitypackage Okay, können organisiert zu bleiben. Erstellen Sie einen neuen Ordner in Ihrem Ordner Assets KinectPackage. Fügen Sie dann die 10-Dateien, die ich oben als auch Windows-Ordner aus StandardAssets erwähnt. Bild 11 OBEN Schritt 7: Kinect Scripting Erstellen Sie einen neuen Ordner in Ihrem Ordner Scripts Genannt KinectScripts. Jetzt in diesem Ordner erstellen Sie zwei neue Skripte; nannte man BodyManger und der andere namens Bodyview. BILD 1 oben BodyManager Zunächst müssen wir BodyManager - diese Aufgabe wird die Kinect Sensor-Anschluss Mange und in allen Körperdaten, die von der Kinect zu lesen. Importieren Sie die Kinect-Bibliothek mit: Verwendung Windows.Kinect; Dann müssen wir einige Felder für die Manager zu speichern und die Daten und nutzen Sie Sensordaten. Private KinectSensor _Sensor; Private BodyFrameReader _Reader; Private Körper [] _Daten = null; Körperschaft des öffentlichen Rechts [] GetData () { zurück _Daten; } Okay, so jetzt in der Start-Methode wollen wir die Verbindung für die Kinect zu etablieren. void start () { _Sensor = KinectSensor.GetDefault (); if (_Sensor! = null) { _Reader = _Sensor.BodyFrameSource.OpenReader (); if (! _Sensor.IsOpen) { _Sensor.Open (); } } } Nun, da die Verbindung offen ist, und Einlesen der Daten müssen wir es im Körper Array zu speichern. Wir werden dies jedes Bild des Spiels zu tun, daher müssen wir die Update () Methode zu bearbeiten. Zuerst überprüfen wir, ob die _Reader wurde eingerichtet und die Verbindung beendet ist. Ist dies der Fall werden wir das letzte Bild zu nehmen, das Lesegerät in und wenn es nicht null, dann können wir überprüfen, ob die Daten besteht. nichtig Update () { if (_Reader! = null) { var frame = _Reader.AcquireLatestFrame (); if (frame =! = null) { if (_Daten == null) { // Write-Code hier } } } } Jetzt müssen wir die Körperdaten von der Senor bekommen. Um dies zu tun, müssen wir einen neuen Körper Array mit Daten aus dem Sensor.BodyFrameSource.BodyCount erstellen. Am Ende der Methode sollte wie folgt aussehen: nichtig Update () { if (_Reader! = null) { var frame = _Reader.AcquireLatestFrame (); if (Rahmen! = null) { if (_Daten == null) { _data = New Körper [_Sensor.BodyFrameSource.BodyCount]; } } } } Dann müssen wir den Strom von Daten aus dem Reader zu aktualisieren. Indem Sie den folgenden Code, um den Rahmen zu manipulieren. nichtig Update () { if (_Reader! = null) { var frame = _Reader.AcquireLatestFrame (); if (Rahmen! = null) { if (_Daten == null) { _data = New Körper [_Sensor.BodyFrameSource.BodyCount]; } frame.GetAndRefreshBodyData (_Daten); frame.Dispose (); Frame = null; } } } Die letzte Methode in der Body Manager Class ist OnApplicationQuit (), die den Reader Haus verfügt, und schließt den Sensor Strom, setzt sie auf null. nichtig OnApplicationQuit () { if (_Reader! = null) { _Reader.Dispose (); _Reader = Null; } if (_Sensor! = null) { if (_Sensor.IsOpen) { _Sensor.Close (); } _Sensor = Null; } } Körperansicht Das nächste Skript zu schreiben, ist eine, die Skelettstruktur zu ziehen. Wir werden nicht unbedingt benötigen, um das Skelett für das Spiel zu sehen, aber ich werde Ihnen zeigen, wie Skelettkörper Tracking zeigen. Wir müssen auch die Skelettdaten, um die Hände, deren Zustand wird die Controller-Befehle zu diktieren zu verfolgen. Aus diesem MonoBehavoir Klasse benötigen wir, ein Material, um die Knochen in der Unity-Szene zu zeichnen. A Gameobject die BodyManger zu speichern, um den Strom von der Kinect steuern. öffentliche Werkstoff BoneMaterial; öffentlichen Gameobject BodyManager; Wir brauchen auch eine BodyManager Objekt und ein Wörterbuch zu speichern die Körper verfolgt. Private Wörterbuch _Bodies = new Dictionary (); Private BodyManager _BodyManager; Als nächstes müssen wir kartieren alle Knochen durch die beiden Gelenke, die sie angeschlossen werden. Private Wörterbuch _BoneMap = new Dictionary () { {Kinect.JointType.FootLeft, Kinect.JointType.AnkleLeft} {Kinect.JointType.AnkleLeft, Kinect.JointType.KneeLeft} {Kinect.JointType.KneeLeft, Kinect.JointType.HipLeft} {Kinect.JointType.HipLeft, Kinect.JointType.SpineBase} {Kinect.JointType.FootRight, Kinect.JointType.AnkleRight} {Kinect.JointType.AnkleRight, Kinect.JointType.KneeRight} {Kinect.JointType.KneeRight, Kinect.JointType.HipRight} {Kinect.JointType.HipRight, Kinect.JointType.SpineBase} {Kinect.JointType.HandTipLeft, Kinect.JointType.HandLeft}, // dies für HandSates benötigen {Kinect.JointType.ThumbLeft, Kinect.JointType.HandLeft} {Kinect.JointType.HandLeft, Kinect.JointType.WristLeft} {Kinect.JointType.WristLeft, Kinect.JointType.ElbowLeft} {Kinect.JointType.ElbowLeft, Kinect.JointType.ShoulderLeft} {Kinect.JointType.ShoulderLeft, Kinect.JointType.SpineShoulder} {Kinect.JointType.HandTipRight, Kinect.JointType.HandRight}, // Needthis für Hand State {Kinect.JointType.ThumbRight, Kinect.JointType.HandRight} {Kinect.JointType.HandRight, Kinect.JointType.WristRight} {Kinect.JointType.WristRight, Kinect.JointType.ElbowRight} {Kinect.JointType.ElbowRight, Kinect.JointType.ShoulderRight} {Kinect.JointType.ShoulderRight, Kinect.JointType.SpineShoulder} {Kinect.JointType.SpineBase, Kinect.JointType.SpineMid} {Kinect.JointType.SpineMid, Kinect.JointType.SpineShoulder} {Kinect.JointType.SpineShoulder, Kinect.JointType.Neck} {Kinect.JointType.Neck, Kinect.JointType.Head} }; Bodyview Update () Jetzt in der Unity Update () Methode, die wir brauchen, um zu überprüfen, ob der Body Manager nicht null ist und dass sie die Daten hat. nichtig Update () { int state = 0; if (BodyManager == null) { zurück; } _BodyManager = BodyManager.GetComponent (); if (_BodyManager == null) { Rückkehr } Kinect.Body [] data = _BodyManager.GetData (); if (Daten == null) { zurück; } } Als nächstes, während noch in der update () -Methode, müssen wir die Menge der Körper in der Liste der Raupenkörper zu erhalten. Löschen Sie anschließend unbekannt Körper. Liste trackedIds = new List (); foreach (var Körper in Daten) { if (Körper == null) { fortzusetzen; } if (body.IsTracked) { trackedIds.Add (body.TrackingId); } } Liste knownIds = new List (_Bodies.Keys); // Erste löschen untracked Gremien foreach (ulong TrackingID in knownIds) { if (! trackedIds.Contains (TrackingID)) { Destroy (_Bodies [TrackingID]); _Bodies.Remove (TrackingID); } } Jetzt, da wir die Schlüssel für die Verfolgung der Körper müssen wir einen Körper Objekt mit diesem Tracking-ID-Schlüssel zu erstellen. Wir müssen zwei weitere Methoden zu schreiben. A CreateBodyObject () -Methode, die eine ulong id und ein RefreashBodyObject () -Methode, die eine Kinect.Body Objekt und ein Gameobject für den Körper stattfinden wird stattfinden wird. Wir werden diese Methoden verwenden, nachdem wir durch die Daten zu gehen, und wenn Körper im Inneren werden verfolgt oder nicht. Wenn sie verfolgt wird, aber keinen TrackingID haben, dann müssen wir einen Körper mit diesem TrackingID erstellen. Wenn es wird verfolgt und hat eine TrackingID dann müssen wir nur noch die ausge Körper zu aktualisieren. foreach (var Körper in Daten) { if (Körper == null) { fortzusetzen; } if (body.IsTracked) { if (! _Bodies.ContainsKey (body.TrackingId)) { _Bodies [Body.TrackingId] = CreateBodyObject (body.TrackingId); } RefreshBodyObject (Körper, _Bodies [body.TrackingId]); } } } CreateBodyObject () Die CreateBodyObject nimmt eine ID und gibt einen Körper Gameobject. So müssen wir zunächst einen Gameobject, das die entsprechenden Daten abgerufen speichern schaffen; dann brauchen wir eine for-Schleife, um durch jedes Gelenk zu gehen, um den Körper zu ziehen. Private Gameobject CreateBodyObject (ulong id) { Gameobject Körper = new Gameobject ("Body:" + id); für (Kinect.JointType jt = Kinect.JointType.SpineBase; jt <= Kinect.JointType.ThumbRight; jt ++) { } zurück Körpers; } Für jedes Gelenk im Körper schaffen wir einen Würfel und fügen Sie eine lineRenderer auf diesen Würfel. Der Würfel wird an jedem Gelenk gezogen werden, während die Linie Renderer gezogen werden, um die Gelenke zu verbinden. Private Gameobject CreateBodyObject (ulong id) { Gameobject Körper = new Gameobject ("Body:" + id); für (Kinect.JointType jt = Kinect.JointType.SpineBase; jt <= Kinect.JointType.ThumbRight; jt ++) { Gameobject jointObj = GameObject.CreatePrimitive (PrimitiveType.Cube); LineRenderer lr = jointObj.AddComponent (); lr.SetVertexCount (2); lr.material = BoneMaterial; lr.SetWidth (0.05f, 0.05f); jointObj.transform.localScale = new Vector3 (0.3f, 0.3f, 0.3f); jointObj.name = jt.ToString (); jointObj.transform.parent = body.transform; } zurück Körpers; } RefreashBodyObject () Nun, um die ResfreshBodyObject Methode schreiben. Bei dieser Methode müssen wir durch die einzelnen Gelenktyp möglich, so wie wir in der CreateBodyObject Methode hat zu gehen. Aber dieses Mal sind wir in der aktuellen Körper vorbei, ebenso wie die entsprechende Tracking-Nummer, damit wir nicht ziehen die Knochen für die falsche Person. private void RefreshBodyObject (Kinect.Body Körper, Gameobject bodyObject) { für (Kinect.JointType jt = Kinect.JointType.SpineBase; jt <= Kinect.JointType.ThumbRight; jt ++) { } } Innerhalb dieser Schleife für die wir brauchen, um die Schlüssel-Wert-Paare, bevor wir in den Knochen Schleife für jedes Gelenk gemacht zu bekommen. private void RefreshBodyObject (Kinect.Body Körper, Gameobject bodyObject) { für (Kinect.JointType jt = Kinect.JointType.SpineBase; jt <= Kinect.JointType.ThumbRight; jt ++) { Kinect.Joint sourceJoint = body.Joints [jt]; Kinect.Joint? targetJoint = null; if (_BoneMap.ContainsKey (jt)) { targetJoint = body.Joints [_BoneMap [jt]]; } } } Wir müssen auch die Skelette Position zu aktualisieren, so ist es in der genauen Stelle auf dem Bildschirm. Zu diesem Zweck müssen wir eine Methode, um die Vetcor3 vom sourceJoint bekommen zu schreiben. private static Vector3 GetVector3FromJoint (Kinect.Joint Gelenk) { zurück neue Vector3 (joint.Position.X * 10, * 10 joint.Position.Y, joint.Position.Z * 10); } Die Skala 10 ist zum Vergrößern das Skelett, die es einfacher zu handhaben wird. Jetzt haben wir der Lage, die Gameobjects Position zu korrigieren. private void RefreshBodyObject (Kinect.Body Körper, Gameobject bodyObject) { für (Kinect.JointType jt = Kinect.JointType.SpineBase; jt <= Kinect.JointType.ThumbRight; jt ++) { Kinect.Joint sourceJoint = body.Joints [jt]; Kinect.Joint? targetJoint = null; if (_BoneMap.ContainsKey (jt)) { targetJoint = body.Joints [_BoneMap [jt]]; } Transform jointObj = bodyObject.transform.FindChild (jt.ToString ()); jointObj.localPosition = GetVector3FromJoint (sourceJoint); } } Der nächste Schritt in der for-Schleife ist es, die linerenderer vom bodyObject, die der Würfel erstellen wir für jedes Gelenk war zu bekommen. Dann müssen wir sehen, ob Zielgelenk hat einen Wert. Wenn ja können wir dann ziehen Sie eine Linie von der ursprünglichen Joint zum Ziel. LineRenderer lr = jointObj.GetComponent (); if (targetJoint.HasValue) { lr.SetPosition (0, jointObj.localPosition); lr.SetPosition (1, GetVector3FromJoint (targetJoint.Value)); } sonst { lr.enabled = false; } Groß! So we are almost done with drawing the skeleton. There is a bit more information that will be helpful that the SDK gives you, which is tracking status. There are three states to choose from, Tracked, Inferred, or NotTracked. We can have the line renderer show us the state of tracking by changing it's color. To do this we need a method that will return a color based on the current state. private static Color GetColorForState(Kinect.TrackingState state) { switch (state){ case Kinect.TrackingState.Tracked: return Color.green; case Kinect.TrackingState.Inferred: return Color.red; default: return Color.black; } } Now we add one more line to the for loop of the RefreachBodyObject method and we are done. private void RefreshBodyObject(Kinect.Body body, GameObject bodyObject) { for (Kinect.JointType jt = Kinect.JointType.SpineBase; jt <= Kinect.JointType.ThumbRight; jt++) { Kinect.Joint sourceJoint = body.Joints[jt]; Kinect.Joint? targetJoint = null; if (_BoneMap.ContainsKey(jt)) { targetJoint = body.Joints[_BoneMap[jt]]; } Transform jointObj = bodyObject.transform.FindChild(jt.ToString()); jointObj.localPosition = GetVector3FromJoint(sourceJoint); LineRenderer lr = jointObj.GetComponent(); if (targetJoint.HasValue) { lr.SetPosition(0, jointObj.localPosition); lr.SetPosition(1, GetVector3FromJoint(targetJoint.Value)); lr.SetColors(GetColorForState(sourceJoint.TrackingState), GetColorForState(targetJoint.Value.TrackingState)); } else { lr.enabled = false; } } } And that's it for drawing the skeleton!Step 8: Adding Kinect to Unity Now in Unity I've created another scene by going to file new scene (it will prompt you to save your current scene if you haven't already). This empty scene will make it easier for you to test and see what you're doing. In the empty scene, which I have saved as kinectTest, create two empty game objects. Call them Body Manager and Body View. IMAGE 1 Attach the Body Manager script to the body manager object. Attach the Body View script to the BodyView object. IMAGE 2 Select the Body View object. In the inspector you need to fill in the Body Manager slot and Bone Material slot. Click and drag the BodyManager from the hierarchy to the slot. Then in your materials folder click and drag the Bone Material into the bone material slot. IMAGE 3 Now hit run. You should see nothing on your screen at first. This is because the Kinect hasn't registered your skeleton yet. Stand back about 4 ft, and you should see the skeleton appear. IMAGE 4 If you look closely you can tell that the legs of the skeleton are red. This is because the Kinect is interpreting that's where my legs should be. My desk was blocking the sensor from detecting where my legs actually were. But wait! You say. We don't need a skeleton in our game, just the hand gestures and states! So was all this a waste? NEIN! Of course it wasn't. We just don't need to draw the whole skeleton in the scene anymore. But we now have the know how if you need to in the future. YAY!Step 9: Hand Controls with the Kinect The next script we will create will be the one we use in our game along with the body manager script. It will detect the hand state and trigger the rotation for our game. Hand Manager Script Now create another script in the same folder as the body manager script and body view manager script. Call it HandManager. This script will look a lot like our Body View controller. Add the following from BodyView to our HandManager Script. using UnityEngine; using System.Collections; using System.Collections.Generic; using Kinect = Windows.Kinect; public class HandManager : MonoBehaviour { public GameObject BodyManager; private PlatformRotate platformRotate; private OVRInfinitePlayerController ovrPlayerScript; private InfinitePlayerController playerScript; private Dictionary _Bodies = new Dictionary (); private BodyManager _BodyManager; private float flipTimer; private float flipDelay = 2; int prevState = 0; private Dictionary _BoneMap = new Dictionary() { { Kinect.JointType.FootLeft, Kinect.JointType.AnkleLeft }, { Kinect.JointType.AnkleLeft, Kinect.JointType.KneeLeft }, { Kinect.JointType.KneeLeft, Kinect.JointType.HipLeft }, { Kinect.JointType.HipLeft, Kinect.JointType.SpineBase }, { Kinect.JointType.FootRight, Kinect.JointType.AnkleRight }, { Kinect.JointType.AnkleRight, Kinect.JointType.KneeRight }, { Kinect.JointType.KneeRight, Kinect.JointType.HipRight }, { Kinect.JointType.HipRight, Kinect.JointType.SpineBase }, { Kinect.JointType.HandTipLeft, Kinect.JointType.HandLeft }, //Need this for HandSates { Kinect.JointType.ThumbLeft, Kinect.JointType.HandLeft }, { Kinect.JointType.HandLeft, Kinect.JointType.WristLeft }, { Kinect.JointType.WristLeft, Kinect.JointType.ElbowLeft }, { Kinect.JointType.ElbowLeft, Kinect.JointType.ShoulderLeft }, { Kinect.JointType.ShoulderLeft, Kinect.JointType.SpineShoulder }, { Kinect.JointType.HandTipRight, Kinect.JointType.HandRight }, //Needthis for Hand State { Kinect.JointType.ThumbRight, Kinect.JointType.HandRight }, { Kinect.JointType.HandRight, Kinect.JointType.WristRight }, { Kinect.JointType.WristRight, Kinect.JointType.ElbowRight }, { Kinect.JointType.ElbowRight, Kinect.JointType.ShoulderRight }, { Kinect.JointType.ShoulderRight, Kinect.JointType.SpineShoulder }, { Kinect.JointType.SpineBase, Kinect.JointType.SpineMid }, { Kinect.JointType.SpineMid, Kinect.JointType.SpineShoulder }, { Kinect.JointType.SpineShoulder, Kinect.JointType.Neck }, { Kinect.JointType.Neck, Kinect.JointType.Head }, }; Now we added a variable that's not in our bodyview script which is the prevState variable. int prevState = 0; We have this variable to prevent constant rotating. In the regular input controls of the game we do this by only activating rotation when the key is that was pressed, goes up. With the Kinect it's good to have a rest state that must be achieved if we want to rotate or flip again. In our case the rest state is any hand state that does not signal a rotation; for example, when both hands are in fists. Now in the Update method we need to add the following: void Update() { int state = 0; if (BodyManager == null) { return; } _BodyManager = BodyManager.GetComponent(); if (_BodyManager == null) { return; } Kinect.Body[] data = _BodyManager.GetData(); if (data == null) { return; } List<ulong> trackedIds = new List<ulong>(); foreach (var body in data) { if (body == null) { continue; } if (body.IsTracked) { trackedIds.Add(body.TrackingId); } } List<ulong> knownIds = new List<ulong>(_Bodies.Keys); // First delete untracked bodies foreach (ulong trackingId in knownIds) { if (!trackedIds.Contains(trackingId)) { Destroy(_Bodies[trackingId]); _Bodies.Remove(trackingId); } } } All the code above is the same as Body View, which is helpful since we already know how it works. The only thing that is different is: int state = 0; This variable will hold the current hand state, and at the end of the Update method, we will save it in the previous state variable. The next part of the update method that is different is in the foreach loop. void Update() { int state = 0; if (BodyManager == null) { return; } _BodyManager = BodyManager.GetComponent (); if (_BodyManager == null) { return; } Kinect.Body[] data = _BodyManager.GetData(); if (data == null) { return; } List trackedIds = new List (); foreach (var body in data) { if (body == null) { continue; } if (body.IsTracked) { trackedIds.Add(body.TrackingId); } } List knownIds = new List (_Bodies.Keys); // First delete untracked bodies foreach (ulong trackingId in knownIds) { if (!trackedIds.Contains(trackingId)) { Destroy(_Bodies[trackingId]); _Bodies.Remove(trackingId); } } foreach (var body in data) { if (body == null) { continue; } if (body.IsTracked) { //Check Hand State if body is being Tracked state = CheckLeftHandState(body.HandLeftState) + (2*CheckRightHandState(body.HandRightState)); } } } We need to write the CheckLeftHandState and CheckRIghtHandState methods. These methods take the Kinect.HandState parameter that equates to an enumerable of Closed, Open, or Lasso. Both will return an int that we will set equal to the state variable to tell the game what command we want to implement. private int CheckRightHandState(Kinect.HandState handState2) { int result = 0; switch (handState2) { //Normal case Kinect.HandState.Closed: result = 0; break; //Stop case Kinect.HandState.Open: result = 0; break; //Flip case Kinect.HandState.Lasso: result = 1; break; default: result = 0; break; } return result; } private int CheckLeftHandState(Kinect.HandState handState1) { int result = 0; switch (handState1) { //Normal case Kinect.HandState.Closed: result = 0; break; //Flip case Kinect.HandState.Open: result = 3; break; //Left case Kinect.HandState.Lasso: result = 1; break; default: result = 0; break; } return result; } Originally the game flipped if both hands were in the lasso state, but that's harder to control, because for a frame one hand might be recognized slightly faster than the other, and thus the game assumes we are rotating instead of flipping. So now the game: rotates right if the right hand alone is in lasso state; rotates left if the left hand alone is in lasso state; and flips if the left hand is open. With both the CheckLeftHandState and CheckRightHandState methods done we can go back to the Update method and finish it off. Currently we just need to see if the Kinect registers our hand states properly. To do this we create a switch statement that uses the current state and then checks what the previous state was, preventing continuous rotation. If the previous state was the restful state we Rotate, or in this case print to the Debug screen. if (body.IsTracked) { //Check Hand State if body is being Tracked state = CheckLeftHandState(body.HandLeftState) + (2*CheckRightHandState(body.HandRightState)); switch (state) { case 0: break; case 1: //Left if (prevState == 0) Debug.Log("Left"); break; case 2: //Right if (prevState == 0) Debug.Log("Right"); break; case 3: //Both if (prevState == 0) { Debug.Log("Both"); } break; default: break; } prevState = state; } } } Okay so let's see if this works. In your scene create another empty game object and call it HandManager. Attach the handmanager script to it. Remember to drag the BodyManager from the hierarchy to the BodyManger placeholder in the HandManager Inspector. IMAGE 1 Run the code in Unity. IMAGE 2 Okay but we still see the skeleton. Well if we deactivate the bodyView by checking the left hand box in the inspector we can run the project again. IMAGE 3 BAM! There it is, and you know it's still working based on the Debugger even if you can't see the skeleton anymore! Okay now to add this into the game. First let's make the prefabs out of the HandManager and BodyManager objects. IMAGE 4 Once you've create them drag the Body Manager from the Hierarchy to the Body Manager Prefab you created. Do the same with the Hand Manager. Now as prefabs we can easily move those objects and functionality into our main game scene!Step 10: Kinecting the Game Input Controller See what I did there. Kinecting…like connecting…Jokes! Anyway, were on the last stretch of getting everything together! Switch back to your main scene. Add the prefabs into the Hierarchy. IMAGE 1 Now we have to do a few things before our hands can control the rotation and flipping of the world. First we have to link the HandManager to the Rotator object. Then we have to make sure we don't accidentally rotate at the beginning of the game. Add the following variables to the HandManager: public GameObject Rotator; private PlatformRotate platformRotate; We make the Rotator object public so we can set it inside of Unity later. Then in the start method set the platformRotate to the Rotators PlatformRotate; void Start() { platformRotate = Rotator.GetComponent(); } Now that our platformRotate is linked to the Rotators PlatfromRotate we can use it to call certain methods like TurnRight() and TurnLeft(). So let's implement that. Remember in our update method where we call the total state of what the hands are doing? Well that's where we are going to modify the code. if (body.IsTracked) { //Check Hand State if body is being Tracked state = CheckLeftHandState(body.HandLeftState) + (2*CheckRightHandState(body.HandRightState)); switch (state) { case 0: break; case 1: //Left Debug.Log("Left"); if (prevState == 0) platformRotate.TurnLeft(); break; case 2: //Right Debug.Log("Right"); if (prevState == 0) platformRotate.TurnRight(); break; case 3: //Both Debug.Log("Both"); if (prevState == 0) { platformRotate.Flip(); } break; default: break; } prevState = state; } } Okay so now we are so close to the finish line!! Now we need to make sure we don't call Flip or Rotate too soon, like on the instructions page.Step 11: Enabling/Disabling Controls Now to prevent the Kinect from sensing us too soon and accidentally trying to flip or rotate pieces of the game we need to disable the HandManager until the Enter button has been pressed. Disable/Enable Kinect controls on Load To do this go into the GameController script. Add the following variables to store the HandManger object that is in the scene and the HandManagerScript public GameObject handController; Then at the bottom of the Awake method add this line: handController.SetActive(false); Next find the StartGame() method and add the following line to the else: handController.SetActive(true); It should now look like this: public void StartGame()<br>{<br> if (startingPlay)<br> {<br> Debug.Log("Hit Button");<br> if (!gamestarted && !loading)<br> {<br> gamestarted = true;<br> loading = true;<br> Debug.Log("gameStarted and loading");<br> }<br> else<br> {<br> //loading complete, start true<br> Debug.Log("Spawning and Enabling Player");<br> handController.SetActive(true);<br> testSpawner.StartGeneration();<br> startingPlay = false;<br> }<br> }<br>} For those of you who are wondering about why we don't also do this to do BodyManager, the answer is: We still want to establish connection as soon as the game starts. AND WE ARE DONE!! Run the Game and look at the awesomeness that is INFINITE RUNNER WITH KINECT AND OCULUS INTEGRATION!!! All that's left is for you to publish it so your friends can playin too! Happy Coding!! -TheNappingKat$(function() {$("a.lightbox").lightBox();});

      19 Schritt:Schritt 1: Laden Sie die kostenlose Software Unity Schritt 2: Öffnen Sie Unity Schritt 3: Erstellen Sie Ihren ersten Spielobjekt Schritt 4: Fügen Sie eine Spieler Schritt 5: Fügen Sie etwas Leben Robot Schritt 6: Die Robotersteuerung Script Schritt 7: Lass Jumping - Spieler Controller Skript Fortsetzung Schritt 8: Machen Sie eine Mischung Baum Zeichentrick Schritt 9: Destroyers Schritt 10: Die Hand Schritt 11: Bleistiftlinie Schritt 12: Bewegen Sie die Kamera! Schritt 13: Fügen Sie eine Punktzahl Schritt 14: Bombs Away Schritt 15: Bomb Spawning Schritt 16: Platforms (oder Kritzeleien) Schritt 17: Bonuspunkt Pickups Schritt 18: Game Over Schritt 19: Dateien, etc

      In diesem Instructable, werde ich Ihnen zeigen, einen wirklich einfachen 2D-Video-Spiel zu machen. Es ist eine unendliche Läufer Stil Spiel, wie "With Me" Fly oder "DoodleJump". Probieren Sie es aus hier !! Ich habe eine zip der exe des Spiels werde ich zeigen Ihnen, wie Sie zur Verfügung gestellt. Laden Sie es und probieren Sie es aus. Es ist ganz unvollständige so weit wie ein Spiel geht, aber diente mir als eine fantastische Gelegenheit, um ein wenig von C # scripting zu lernen und das Wissen der Einheit habe ich da mit dem Download vor zwei Wochen aufgenommen zu verfestigen. Für die Zwecke des Teilens, beschloss ich, Instructables als Hauptfigur zu verwenden eigenen liebenswerten Roboter. Ich ging für eine vereinfachende Blick in Hommage an jene Karikaturen von einst im gleichen Stil. Ich habe immer geliebt, wenn der Stift interagiert mit der Karikatur. Ich muss sagen, dass Unity ist ein unglaubliches Werkzeug. Es gibt eine Fülle von Informationen im Lernbereich des Unity-Website, empfehle ich ihm einen Blick durch, nachdem Sie gesehen haben, wie einfach es ist, zu beginnen, 2D-Spiele. Alles, was ich hier zeigt Ihnen, von der habe ich gelernt, Unity-Website , sie haben einige große Tutorials und Video-Schulungen. Ich bin neu in Unity, wie Sie kann, muss aber nicht sein, so ist dies nur, um meine Liebe für die Umwelt und meine Lernerfahrung bisher zu teilen. Ich werde die Sprite-Vermögenswerte für jeden Schritt bereitzustellen, so dass Sie entlang folgen können, und machen das Spiel selbst. Ich empfehle, nicht mit meinem Code wie es ist, sondern folgende entlang und Schreiben Sie Ihre eigene Version von den gleichen Skripten. Ich habe wenig bis gar keine Erfahrung Programmierung in C, und doch war Scripting in C # sehr schnell .... es erinnert mich ein schreckliches Los Arduino und Processing, die ich kenne. Also selbst wenn Sie nicht vertraut mit der Programmierung zu haben, ich glaube, Sie könnten dies auch tun. Mindestens folgen zusammen mit meinem Abenteuer zu sehen, wie einfach es war.

      Seiten: