Wir bauen uns ein Space Shoot em Up [Teil 1 - Schiffssteuerung]

[Mark]

In dieser Tutorial reihe wollen wir uns mithilfe von Unity und der Programmiersprache C# einen Space Shooter basteln. Dabei werde ich euch sanft mit Unity und C# vertraut machen. Deshalb ist diese Reihe sowohl für absolute Anfänger in Sachen Unity als auch im Programmieren geeignet.

 

Im ersten Teil wollen wir unseren Grundstein legen, wir wollen unser Spieler Raumschiff mithilfe der Tastatur steuern.

 

Das Spielerraumschiff stellen wir uns zuerst als einfachen Würfel zur Verfügung.

In einem späteren Tutorial werden wir diesen Würfel durch komplexere Gebilde austauschen.

 

Folgendes soll unser Raumschiff in der ersten Version können:

- Beschleunigen wenn wir die Vorwärtstaste drücken

- Negativ Beschleunigen wenn wir die Rückwärtstaste drücken

- Nach links drehen wenn wir die Linkstaste drücken

- Und nach rechts drehen wenn wir die Rechtstaste drücken

 

Wir beginnen das ganze indem wir uns ein neues Projekt in Unity erstellen, komplett leer ohne Schnickschnack.

 

Wählt dazu, innerhalb von Unity den Menüpunkt "File"->"New Project.." aus und wählt im darauf folgenden Dialog einen geeigneten Namen und Speicherort

für euer Projekt aus. Selektiert zusätzlich die Option "3D" unter dem Punkt "Setup defaults to" im unteren Bereich des Dialoges. Klickt danach auf OK.

 

Wir erstellen nun unser Raumschiff. Dazu wählen wir im Menü "GameObject"->"Create Other"->"Cube". Dies erzeugt uns unser erstes GameObject,

einen Würfel mit dem Namen "Cube". Da der Name "Cube" wenig aussagt benennen wir ihn kurzerhand in "Spieler Raumschiff" um:

 

Wählt dazu den Würfel in der Ansicht die "Hierarchy" genannt wird (ganz links) aus. Dann könnt ihr im Fenster welches "Inspector" genannt wird (ganz rechts)

den Namen ändern indem ihr in das Textfeld mit dem Inhalt "Cube" klickt und dort den Text "Spieler Raumschiff" eintippt. Die Anführungszeichen bitte weglassen.

 

Ihr könnt zum Umbenennen eines GameObjectes auch, nachdem ihr es in der "Hierarchy" Ansicht ausgewählt habt, die F2 Taste drücken und dort den Namen eintippen.

 

Das Spieler Raumschiff ist nun noch etwas ungünstig positioniert und um das zu ändern wählen wir es wie bereits getan aus und ändern in der "Inspector"

Ansicht die Position. Dies kann gemacht werden indem ihr unter "Position" alle 3 Werte (X, Y und Z) auf 0 ändert.

 

Um auch die Kamera etwas passender zu positionieren und zu drehen wählen wir nun auch das "Main Camera" GameObject aus und ändern im Inspektor die Position

auf: X = 0, Y = 6 und Z = -2

Sowie die Rotation auf X = 70

 

Dadurch schaut unsere Kamera auf unser Raumschiff.

Speichert nun die Scene ab indem ihr Strg+S drückt. Unity wird euch darauf hin fragen wie die Scene heißen soll. Ich habe meine Scene "Scene0" genannt.

 

Wärend der Entwicklung solltet ihr darauf achten immer wieder Strg+S zu drücken um eure Zwischenstände beim verändern der Scenen auch zu speichern.

Nichts ist ärgerlicher als zuvor gemachte Änderungen wiederholen zu müssen. Weil Unity zB abgestürzt ist.

 

Damit sind die Vorbereitungen abgeschlossen und wir können uns nun ein Script erstellen welches unser Raumschiff steuert.

 

Dazu klicken wir mit der rechten Maustaste in den "Assets" Bereich (ganz unten) und wählen den Kontextmenüpunkt "Create"->"C# Script"

Anschließend wählen wir als Namen für dieses Script "PlayerControler". "PlayerControler" deshalb weil dies unser Script ist welches das Spieler Schiff kontrolliert.

Wir werden in dieser TutorialReihe englische Bezeichner verwenden sofern es sich um das Programmieren handelt. In Unity ist der Name des Scriptes gleichbedeutend

mit dem Klassennamen. Dazu aber gleich mehr.

 

Um nun dieses Script zu editieren könnt ihr es doppelt anklicken. Darauf hin sollte sich ein Editor öffnen und ihr seht folgendes:

 

using UnityEngine;
using System.Collections;

public class PlayerController : MonoBehaviour {

// Use this for initialization
void Start () {

}

// Update is called once per frame
void Update () {

}
}

 

Die ersten beiden Zeilen (die die mit using beginnen) helfen dabei uns einige Grundfunktionen zu geben die wir in unserem Script verwenden können.

using UnityEngine gibt uns alle Funktionen die direkt mit Unity zu tun haben. using System.Collections gibt uns einige Hilfsmittel um Ansammlungen von Daten

zu verwalten, zB eine Reihe von Werten die wachsen kann und aus der Elemente entfernt werden können. Ausserdem stellt es uns etwas bereit was wir benötigen

sobald es um Coroutinen geht.

 

Die nächste Zeile definiert den Namen unseres Scriptes (PlayerController) und gibt an was genau es sein soll (class, eine Klasse) und von wem es einige

Grundfunktionen bekommen soll (MonoBehaviour).

 

Jedes Script welches wir auf GameObjects legen können leitet von MonoBehaviour ab. "leitet" bedeutet hier dass unser Script zugleich selbst ein MonoBehaviour ist

und damit einige Grundfunktionen beherbergt die dieses MonoBehaviour selbst bereit stellt. Stellt euch einfach ein Auto vor. Ein Auto leitet zB von Fahrzeug ab und kann dadurch

gefahren werden.

 

Die Zeile mit void Start() bedeutet dass wir hier eine Methode definieren die Start heißt. Im Bezug auf Unity bedeutet dies dass diese Methode automatisch

von Unity aufgerufen wird wenn das Script auf ein GameObject liegt und die Scene betritt. Innerhalb des Bereiches der durch { und } eingegrenzt ist können

wir schreiben was unser Script machen soll wenn es startet. Der durch { und } eingegrenzte Bereich wird Scope genannt.

 

Die Zeile Update ist ähnlich wie Start, nur wird diese Update Methode nicht aufgerufen wenn unser Script die Welt betritt sondern in jedem Framedurchgang wenn

unser GameObject und Script aktiv sind. Frame bedeutet der Moment in dem ein Bild fertig gezeichnet wurde. Je schneller ein Computer desto mehr Frames in einer

Sekunde können erreicht werden.

 

In der Update Methode können wir überprüfen ob der Spieler eine Taste gedrückt hat und dies werden wir nun auch tun.

Mithilfe der Input Klasse von Unity können wir abfragen ob eine Taste gedrückt wurde, wir erweitern deshalb die Update Methode um folgendes:

 

if (Input.GetKey(KeyCode.UpArrow))
{
print("Power!");
}

 

Denkt daran: Schreibt das ganze zwischen { und } der Update Methode.

 

Das if ist ein Schlüsselwort von C# welches besagt dass hier eine Abfrage statt finden soll und das innerhalb der Klammern ist die Bedingung die dazu erfüllt

sein muss damit der darauf folgende Bereich (Scope) innerhalb der { und } Zeichen ausgeführt wird. Input gibt eine Klasse an welche die GetKey Methode bereit stellt.

Die GetKey Methode benötigt einen Parameter der besagt welche Taste geprüft werden soll und dies definieren wir mit KeyCode.UpArrow.

 

Input.GetKey liefert einen bool Wert zurück. bool bedeutet dass es 2 verschiedene Werte gibt, entweder true, was wahr oder ja bedeutet, oder false,

welches unwahr, nein oder falsch bedeutet. Bedingungen erwarten immer ein bool welches sie auswerten können. Nur wenn dieses bool true ist wird

die Ausführung des Scopes vom if gestartet.

 

Die print Methode gibt den String aus der ihr als Parameter übergeben wurde. Ein String ist eine Zeichenkette, ein Text.

Wenn wir direkt einen Text angeben wollen so müssen wir ihn innerhalb der Anführungszeichen schreiben.

 

Dann speichern wir das ganze und wechseln zurück zu Unity. Unity wird nun dieses von uns gespeicherte Script kompilieren (in Maschinencode umwandeln)

und uns auf eventuelle Fehler hinweisen.

 

Wenn alles erfolgreich kompiliert wurde können wir unser Script auf unser Spieler Raumschiff zuweisen. Dazu wählt das Spieler Raumschiff aus und klickt im unteren

Inspektor Bereich (möglicherweise müsst ihr nach unten scrollen) auf den Knopf "Add Component" wählt dann "Scripts"->"Player Controller" aus.

 

Unser Script sollte nun unserem Raumschiff zugewiesen worden sein. Das zuweisen ist auch möglich indem man das Script aus dem Asset Bereich auf das Raumschiff schiebt.

 

Jetzt können wir auf den Play Knopf drücken (das Dreieck im oberen Bereich von Unity).

 

Wenn wir nun die nach Oben Taste drücken sollte im unteren linken Bereich von Unity der Text "Power!" stehen.

 

Glückwunsch du hast soeben dein erstes Script geschrieben und es einem GameObjekt zugewiesen und siehst nun noch wie es agiert.

 

Das Raumschiff bewegt sich aber dennoch nicht, was ziemlich öde ist und schleunigst geändert werden sollte.

 

Unser Raumschiff benötigt dazu die Möglichkeit physikalisch bewegt zu werden, dies geht indem wir dem Raumschiff die Rigidbody Komponente (Komponenten sind Scripte!)

zuweisen. Dazu klicken wir wieder im Inspektor den Knopf "Add Component" aus und benutzen "Physics"->"Rigidbody".

 

Im Inspektor erscheint nun ein zusätzlicher Bereich mit dem Titel "Rigidbody". Hier müssen wir auch noch einige Änderungen vornehmen, zB müssen wir

dafür sorgen dass unser Raumschiff nicht nach unten fällt. Dazu deaktivieren wir die Checkbox "Use Gravity".

 

Nun können wir mithilfe des Rigidbodies unser Raumschiff steuern. Dazu gehen wir wieder in unser PlayerController Script und entfernen die Zeile

mit dem print("Power!") und ersetzen die Zeile durch die Anweisung welche unser Raumschiff beschleunigt:

 

rigidbody.AddForce(transform.forward);

 

rigidbody ist eine Abkürzung die es uns erlaubt ohne extra Code direkt auf unser Rigidbody zuzugreifen, diese Abkürzung gibt es in ähnlicher

Form auch für andere Komponenten, zB der Transform Komponente (transform). AddForce ist eine Methode der Rigidbody Komponente die wir aufrufen können

um etwas Kraft auf das rigidbody auszuüben. Da wir es vorwärts, entlang der Blickrichtung des Objektes beschleunigen wollen, benutzen wir transform.forward

als Parameter.

 

transform ist die Abkürzung auf die Transform Komponente welche Position, Richtung, Skalierung des GameObjektes beinhaltet. Und forward ist ein

Richtungsvector der dorthin zeigt wo das GameObjekt "hin blickt".

 

Wenn wir nun das Script speichern und uns das Resultat in Unity ansehen (Play drücken) dann können wir sehen wie sich unser Raumschiff bewegt wenn wir die nach

Oben Taste drücken. Leider ist diese Beschleunigung stark von der Anzahl der Frames pro Sekunde abhängig. Was bedeutet das auf schnelleren Computer die Beschleunigung höher

ist als auf langsameren Computern. Ausserdem können wir die Beschleunigung nicht genauer regeln und entspricht immer der Länge des Richtungsvectors.

 

Um das zu ändern erweitern wir unser Script wieder ein wenig.

 

Als aller erstes machen wir die Beschleunigung unabhängig von der Anzahl der Frames pro Sekunde:

 

aus

 

rigidbody.AddForce(transform.forward);

 

wird deswegen:

 

rigidbody.AddForce(transform.forward * Time.deltaTime);

 

Time ist die Klasse von Unity die einiges an Operationen und Variablen bereit stellt die etwas mit der Zeit zu tun haben. deltaTime zB ist die Zeit

in Sekunden die der letzte Frame benötigte. Indem wir transform.forward mit diesem Wert multiplizieren bleibt unsere Beschleunigung auch dann konstant wenn wir

einen sehr langsamen oder sehr schnellen Computer verwenden.

 

Wenn wir nun das ganze in Unity ausprobieren werden wir allerdings ein unangenehmes Wunder erleben. Unser Würfel bewegt nur sehr langsam.

Deswegen werden wir nur die Kraft erhöhen.

 

Dazu erweitern wir unser Script indem wir innerhalb der Klassendefinition über void Start folgendes schreiben:

 

public float Acceleration = 10.0f;

 

public besagt dass die float Variable öffentlich erreichbar ist, also jeder der unser Script zu fassen bekommt diesen Wert lesen und/oder verändern kann.

Dies besagt zB auch dass dieser Wert im Inspektor von Unity angepasst werden kann. Acceleration ist der Name unserer Variable und float der Datentyp.

float gibt an dass wir einen Zahlentyp wollen der Kommawerte darstellen kann. Ein Zahlentyp der nur ganze Zahlen darstellen kann wäre zB int.

 

Wir verwenden unsere Acceleration Variable nun indem wir unser Zeile in der wir Kraft auf das Rigidbody wirken lassen erweitern und zwar:

 

rigidbody.AddForce(transform.forward * Time.deltaTime * Acceleration);

 

Wir multiplizieren also unsere Frame unabhängige Kraft mit unserer Variable. Dies ermöglicht es uns nun anzugeben wie Stark die Beschleunigung ist.

Wenn wir nun wieder das ganze innerhalb von Unity testen sehen wir dass unser Würfel sich schneller bewegt als zuvor. Wir können diesen Wert anpassen indem

wir im Inspektor nach unsererm Script Player Controller suchen und dort den Eintrag mit dem Namen "Acceleration" ändern.

 

Unser Script sollte aktuell wie folgt aussehen:

 

using UnityEngine;
using System.Collections;

public class PlayerController : MonoBehaviour {

public float Acceleration = 10.0f;

// Use this for initialization
void Start () {

}

// Update is called once per frame
void Update () {
	if (Input.GetKey(KeyCode.UpArrow))
	{
		rigidbody.AddForce(transform.forward * Time.deltaTime * Acceleration);
	}
}
}

 

Da wir nun schon das Beschleunigen haben werden wir nun noch das Abbremsen hinzufügen. Das ganze ist ziemlich identisch zum Beschleunigen und

ist eine Ideale Übung zum selber probieren des bereits erlernten.

 

Wenn ihr euch ausgetobt habt oder einfach nur weiter machen wollt, hier ist der Code welcher auch die negative Beschleunigung beinhaltet:

 

using UnityEngine;
using System.Collections;

public class PlayerController : MonoBehaviour {

public float Acceleration = 10.0f;
public float Deacceleration = 10.0f;

// Use this for initialization
void Start () {

}

// Update is called once per frame
void Update () {
	if (Input.GetKey(KeyCode.UpArrow))
	{
		rigidbody.AddForce(transform.forward * Time.deltaTime * Acceleration);
	}
	if (Input.GetKey(KeyCode.DownArrow))
	{
		rigidbody.AddForce(-transform.forward * Time.deltaTime * Deacceleration);
	}
}
}

 

Was nun noch fehlt ist das Drehen unseres Raumschiffes. Dies funktioniert auf leicht ähnliche Weise wie das Beschleunigen und Abbremsen.

Deswegen legen wir uns wieder eine Variable an welche angibt wie schnell die Drehung statt finden soll.

 

public float RotationAcceleration = 30.0f;

 

Als Nächstes müssen wir nun noch auf den Tastendruck reagieren der das Drehen veranlassen soll, ich werde mit dem nach rechts drehen anfangen

was relativ einfach auf eine links Drehung erweitert werden kann:

 

if (Input.GetKey(KeyCode.RightArrow))
{
rigidbody.AddTorque(0, Time.deltaTime * RotationAcceleration, 0);
}

 

So wie AddForce fügt AddTorque etwas an unser Rigidbody. und zwar ein Drehmoment. Wir beschleunigen das Drehmoment unseres Rigidbdies um die Y Achse.

Wenn wir das Ganze nun in Unity testen können wir unseren Cube schon vor der Kamera bewegen.

 

Nur fühlt es sich momentan so an als würden wir auf dem Eis laufen. Dies liegt daran dass wir direkt Kräfte auf unseren Würfel anwenden,

was ansich realistisch ist, aber leider das ganze schwieriger Steuerbar macht.

 

Die Lösung dazu?

Wir steuern durch das Beschleunigen oder Abbremsen die Kraft die unser Antrieb pro Frame automatisch auf den Würfel anwenden soll.

Dazu fügen wir eine Reihe weiterer Variablen ein die dafür zuständig sind die maximale und minimale Kraft zu regeln als auch die momentane Kraft

die unser Antrieb generieren soll zu speichern:

 

public float MaxForce = 1000.0f;
public float MinForce = -200.0f;
public float CurrentForce = 0.0f;

 

Nachdem wir das nun haben müssen wir natürlich auch die Handhabung der nach Oben und Unten Tasten ändern. Wir ändern hierbei jeweils die AddForce Zeilen

indem wir den Frame unabhängigen Acceleration Wert zu CurrentForce hinzu addieren und den Deacceleration Wert abziehen.

 

if (Input.GetKey(KeyCode.UpArrow))
{
CurrentForce += Time.deltaTime * Acceleration;
}
if (Input.GetKey(KeyCode.DownArrow))
{
CurrentForce -= Time.deltaTime * Deacceleration;
}

 

+= bedeutet hierbei dass der Wert rechts von += zu den Wert links vom += addiert werden soll. Das ganze ist gleich zu a = a + b

-= bedeutet dass der Wert abgezogen anstatt hinzugefügt wird.

 

Jetzt haben wir die CurrentForce zwar angepasst aber noch kann sie sowohl zu hoch als zu niedrig werden und verwenden tun wir diesen Wert ebenso wenig.

 

Daher grenzen wir CurrentForce zuerst ein. Dies geht indem wir die Clamp Methode der Mathf Klasse von Unity verwenden. Schreibe folgendes ans Ende

der Update Methode:

 

CurrentForce = Mathf.Clamp(CurrentForce, MinForce, MaxForce);

 

Mathf.Clamp begrenzt den Wert im ersten Parameter innerhalb von den Wert des zweiten und dritten Parameters und gibt das Resultat wieder zurück.

Damit ist sicher gestellt dass die CurrentForce niemals größer oder kleiner unserer Grenzwerte wird.

 

Nun müssen wir CurrentForce nur noch irgendwie auf unser Raumschiff angewendet bekommen. Hierfür benutzen wir einfach unser rigidbody.AddForce wieder.

 

Wir multiplizieren CurrentForce mit der Zeit die der letzte Frame zum ausführen brauchte und der Richtung unseres Raumschiffes:

 

rigidbody.AddForce(CurrentForce * Time.deltaTime * transform.forward);

 

Der aktuelle Code des PlayerController Scriptes sollte nun so aussehen:

 

using UnityEngine;
using System.Collections;

public class PlayerController : MonoBehaviour {

public float Acceleration = 100.0f;
public float Deacceleration = 100.0f;
public float RotationAcceleration = 30.0f;

public float MaxForce = 1000.0f;
public float MinForce = -200.0f;
public float CurrentForce = 0.0f;

// Use this for initialization
void Start () {

}

// Update is called once per frame
void Update () {
	if (Input.GetKey(KeyCode.UpArrow))
	{
		CurrentForce += Time.deltaTime * Acceleration;
	}
	if (Input.GetKey(KeyCode.DownArrow))
	{
		CurrentForce -= Time.deltaTime * Deacceleration;
	}

	if (Input.GetKey(KeyCode.RightArrow))
	{
		rigidbody.AddTorque(0, Time.deltaTime * RotationAcceleration, 0);
	}
	if (Input.GetKey(KeyCode.LeftArrow))
	{
		rigidbody.AddTorque(0, -Time.deltaTime * RotationAcceleration, 0);
	}

	CurrentForce = Mathf.Clamp(CurrentForce, MinForce, MaxForce);
	rigidbody.AddForce(CurrentForce * Time.deltaTime * transform.forward);
}
}

 

Das Raumschiff beschleunigt nun immer mit der aktuellen Antriebskraft in die aktuelle Schiffsrichtung.

Das fühlt sich nun schon alles viel besser an als vorher, die Steuerung ist leichter zu beherrschen, aber etwas fehlt noch..

 

Spielt ein wenig mit den Werten Im Inspektor der Rigidbody und PlayerController Komponenten herum um ein leichtes Gefühl dafür zu bekommen

wie sich jeder Wert auswirkt.

 

Gute Werte sind zB folgende:

 

PlayerController:

Acceleration 100

Deacceleration 50

Rotation Acceleration 100

Max Force 100

Min Force -20

 

Rigidbody:

Mass 1

Drag 0

Angular Drag 10

 

Das war es für den ersten Teil der Tutorial Reihe. Im nächsten Teil werden wir die Kamera so umbauen dass diese immer auf das Spieler Raumschiff gerichtet ist.

 

Feedback ist gern gesehen.

 

Teil2:

http://forum.unity-c...__fromsearch__1

[Helishcoffe]

Wow. Habs zwar jetzt nur überflogen, aber ein sehr schönes und auch leicht verständliches Tutorial.

[malzbie]

Sehr schön Marrrk!

Ich finde es toll, dass du auch auf die kleinsten Codebestandteile eingehst.

Verständlicher kann man es eigentlich nicht mehr machen. Daumen hoch!

[Mr 3d]

Erste Klasse!

Wenn du die Reihe bis zu einem gewissen Punkt durchziehst, dann könntest du alles zu einem Buch zusammen-kopieren und verkaufen!

Auf jeden Fall ein super Tutorial, ich freu mich schon auf die Fortsetzung

[Mark]

Danke

 

Der nächste Teil ist auch schon Online:

 

http://forum.unity-community.de/topic/7097-wir-bauen-uns-ein-space-shoot-em-up-teil-2-camera/page__fromsearch__1

[Mr 3d]

Unsere Lehrer sagen immer: "Können ist Leistung pro Zeit!"

 

Also,

große Leistung / wenig Zeit = Top!

 

EDIT:

uups,

sollte eigentlich unter Teil 2

Aber passt hier genau so gut

[Aragom]

Tolles Tutorial.... Genjal zum lernen, bitte weiter machen...

[Venom]

Sehr geniale Tutorial Reihe

[Alexej]

Sehr ausführlich, vielen Dank ! Habe es jetzt mal angefangen.

Bitte im oberen drittel noch PlayerController mit zwei ll schreiben. Danke.

[Alexej]

Habe das erste nun durch, liest sich super.

Als mögliche Ergänzung/Anpassung vielleicht noch zwei Kleinigkeiten:

1. Auf das Kommentieren sollte noch eingegangen werden, das der Scripter bei einigen Zeilen sich mit // Kommentare hinzufügen kann und erklären warum das kommentieren wichtig ist, z.B. Teamarbeiten, damit man in den nächsten Monnden noch weis, was man fabriziert hat, usw.

2. Da alles in Unity in englisch ist, sollte das "Spieler Raumschiff" vielleicht auch gleich in "space ship" umbenannt werden. Nicht das es später zu Problemen mit Umlauten in dem Code kommt. Den Scripter vielleicht auch darauf hinweisen.

 

Ich steige gerade von JavaScript auf C# und dieses ausführliche Tutorial kommt gerade passsend.

[Mark]

Ja Kommentare sind natürlich wichtig, ich sollte wirklich darauf eingehen, nun aber sind schon 10 Teile fertig und ich hab sie nicht erwähnt :/ Es gibt Gründe wieso ich sie in hier nicht verwendet habe, aber das war ein Fehler, grade für Anfänger.

 

Das mit den deutschen Namen war auch ein Fehler, aber mit dem muss ich nun weiter leben

 

Ich hätte wirklich alle englisch halten sollen, so wie in den Scripten selber.

[gerrusimo]

Ich will mich auch daran versuchen!

Vielen Dank für dieses tolle Tutorial!

 

P.S: Etwas Bildmaterial wäre das "i-Tüpfelchen"

[Damon93]

Weiter so! Hilft wirklich ungemein!!!!!!

[FranklynDC]

Anschließend wählen wir als Namen für dieses Script "PlayerControler". "PlayerControler" deshalb weil dies unser Script ist welches das Spieler Schiff kontrolliert.

 

Das Scipt sollte man im Assests "PlayerController" nennen. Lediglich nur mit zwei "l" wird das Script ausgeführt. Mit einem "l" kommt bei mir die Fehlermeldung "The referenced script on this Behaviour is missing!"

 

Aber sonst ein hervoragendes Tutorial. Ich beschäftige mich jetzt seit 2 Wochen mit Unity und habe das Tutorial sehr gut verstanden.

[shnipzl]

ich gutes tut, aber ich komme nicht weiter, weil rigidbody.AddForce offenbar ab unity 5(5) nicht mehr unterstützt wird. was gebe ich ein?

[Hrungdak]

Willkommen im Forum.

 

Dass AddForce nicht mehr unterstützt wird, kann ich mir nicht vorstellen. Welcher Fehler tritt auf? Wie sieht dein Code aus?

[malzbie]

rigidbody ist nicht mehr automatisch die Referenz vom Rigidbody. Das ist aber schon seit der 5.0 so. Außer der Transformkomponente muss man jetzt alle Komponenten selber referenzieren.

Also einfach eine Variable vom Typ Rigidbody deklarieren und in der Awake dann :

 

rb=GetComponent<Rigidbody>();

 

machen. Schon kann man mit rb.AddForce arbeiten.

[shnipzl]

Hey Hrungdak und malzbie,

 

vielen Dank für eure Antworten. Ich glaube ich habe es hinbekommen mit:

 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerControler : MonoBehaviour {
   public Rigidbody rb;
   // Use this for initialization
   void Start () {
    rb = GetComponent<Rigidbody>();
   }

// Update is called once per frame
void Update () {

    if (Input.GetKey(KeyCode.UpArrow))

    {

	    rb.AddForce(transform.forward * Time.deltaTime);
    }
   }
}

 

Ist es normal, dass ich meiner Scriptkomponente noch den Rigidbody hinzufügen musste, oder habe ich einige Schritte zuviel gemacht?

 

Darüber hinaus habe ich noch zwei Fehler im Visual Studio:

 

Schweregrad Code Beschreibung Projekt Datei Zeile Unterdrückungszustand

Fehler MissingComponentException: There is no 'Rigidbody' attached to the "Spieler Raumschiff" game object, but a script is trying to access it.

You probably need to add a Rigidbody to the game object "Spieler Raumschiff". Or your script needs to check if the component is attached before using it. Projektmappe "spaceshoottutorial" ‎(Projekt 1) C:/buildslave/unity/build/artifacts/generated/common/modules/Physics/DynamicsBindings.gen.cs 1263

 

 

und

 

Schweregrad Code Beschreibung Projekt Datei Zeile Unterdrückungszustand

Fehler UnassignedReferenceException: The variable rb of PlayerControler has not been assigned.

You probably need to assign the rb variable of the PlayerControler script in the inspector. Projektmappe "spaceshoottutorial" ‎(Projekt 1) C:/buildslave/unity/build/artifacts/generated/common/modules/Physics/DynamicsBindings.gen.cs 1263

 

 

Bin noch blutiger Anfänger, daher bitte ich um Nachsicht

[Hrungdak]

You probably need to add a Rigidbody to the game object "Spieler Raumschiff".

Na ja, die Lösung wird ja gleich vorgeschlagen. Hat dein Raumschiff eine Rigidbody-Komponente angehängt?

Unser Raumschiff benötigt dazu die Möglichkeit physikalisch bewegt zu werden, dies geht indem wir dem Raumschiff die Rigidbody Komponente (Komponenten sind Scripte!)

zuweisen. Dazu klicken wir wieder im Inspektor den Knopf "Add Component" aus und benutzen "Physics"->"Rigidbody".

[Sascha]

Ich merke gerade, dass das im Tutorial anders steht, aber ersetze mal "void Update" durch "void FixedUpdate". Wenn ein Rigidbody im Spiel ist, und außerdem meistens bei gameplay-relevanten Sachen, gehört der Code in FixedUpdate.

[shnipzl]

Na ja, die Lösung wird ja gleich vorgeschlagen. Hat dein Raumschiff eine Rigidbody-Komponente angehängt?

Ok, hier war offenbar ein Fehler im Visual Studio, ich hatte gestern noch das Rigidbody hinzugefügt und VS hat es wohl irgendwie nicht mitbekommen. Hab jetzt keine Fehler mehr.

 

Ich merke gerade, dass das im Tutorial anders steht, aber ersetze mal "void Update" durch "void FixedUpdate". Wenn ein Rigidbody im Spiel ist, und außerdem meistens bei gameplay-relevanten Sachen, gehört der Code in FixedUpdate.

 

Wo ist denn der Unterschied zwischen void Update und void FixedUpdate?

Und nochmal zu meiner Frage: "Ist es normal, dass ich meiner Scriptkomponente noch den Rigidbody hinzufügen musste, oder habe ich einige Schritte zuviel gemacht?" < Weil davon auch nichts im Tutorial steht.

 

Ich fühle mich etwas schlecht unter solch guten Tutorial soviele Fragen zu stellen, sollte ich vllt. einen eigenen Thread öffnen?

[Sascha]

Die Frage hat Hrungdak doch schon beantwortet? Dass du eine Rigidbody-Komponente hinzufügen sollst, steht im Tutorial.

 

Was den eigenen Thread angeht: Ist eine gute Idee.