Unity3d. Lektionen von Unity 3D Student (B25-B28)

  • Tutorial
Hallo allerseits. Dies ist die letzte Serie grundlegender Unity 3D- Tutorials von Unity3DStudent . Dann gibt es noch zwei Zwischenstunden. Update: Die Pläne haben sich geändert. Diese Lektionen sind nicht mehr aktuell , da die zweite Lektion (in Animation) bereits veraltet ist und ich nicht den Sinn sehe, die Übersetzung von nur einer Lektion zu verbreiten. Lass ihn in seinem eigenen Arbeitszimmer bleiben =)

Links zu früheren Lektionen:


Basislektion 25 - Textur-GUI-Objekt- und Mausereignisse




In der Lektion wird das Erstellen einer einfachen Schaltfläche unter Verwendung der GUI-Textur und der Mausereignisse behandelt.

Wenn Sie eine einfache Benutzeroberfläche erstellen möchten, können Sie das GUI Texture- Objekt verwenden . Betrachten Sie dieses Objekt anhand des Beispiels für die Erstellung von Schaltflächen. Zunächst benötigen wir zwei Texturen: für die Schaltfläche im Normalzustand und für die Schaltfläche im Zustand, in dem sich der Mauszeiger darüber befindet. Wir bereiten die entsprechenden Dateien vor und fügen sie dem Projekt hinzu.



Klicken Sie nun auf die Datei button_normal und erstellen Sie eine GUI-Textur aus dem Menü GameObject - Create Other - GUI Texture . In der Szene wird ein neues Objekt angezeigt, auf das sofort die entsprechende Textur des Normalzustands der Schaltfläche angewendet wird.






Das erstellte Objekt besteht aus zwei Komponenten: Transform und GUITexture . Beachten Sie, dass das Ändern der Parameter der Transformationskomponente im Vergleich zu anderen Objekten in der Szene etwas anders funktioniert. In den Parametern Position und Skalierung werden nur Änderungen an der X- und Y- Achse verarbeitet , Änderungen an der Z- Achse werden ignoriert. Änderungen am Parameter Rotation werden vollständig ignoriert. Zusätzlich im Parameter PositionDie Werte werden nicht in der Welt, sondern in Bildschirmkoordinaten angegeben, wobei 0,0 die untere linke Ecke des Bildschirms und 1,1 die obere rechte Ecke des Bildschirms ist. Die Standardwerte sind 0,5,0,5, d.h. Mitte des Bildschirms. In der GUITexture- Komponente können Sie die Textur, die Farbe und den zusätzlichen Versatz von den Bildschirmrändern und dem Rand festlegen. Da wir vor dem Erstellen des Objekts eine bestimmte Textur ausgewählt haben, hat Unity diese Werte selbst festgelegt. Falls gewünscht, können sie geändert werden.

Wir haben also eine Schaltfläche in der Mitte des Bildschirms, die noch nichts bewirkt. Animieren wir es mit dem folgenden Skript:
JavaScript-Code:
var normalTex : Texture2D;
var hoverTex : Texture2D;
function OnMouseEnter () {
 guiTexture.texture = hoverTex;
}
function OnMouseExit(){
 guiTexture.texture = normalTex;
}
function OnMouseDown(){
 Debug.Log("clicked");
}

C # -Code:
public Texture2D normalTex;
public Texture2D hoverTex;
private void OnMouseEnter() 
{
    guiTexture.texture = hoverTex;
}
private void OnMouseExit()
{
    guiTexture.texture = normalTex;
}
private void OnMouseDown()
{
    Debug.Log("clicked");
}

Wir setzen die Variablen normalTex und hoverTex , um die Textur des normalen Zustands der Schaltfläche und die Textur der Schaltfläche unter dem Mauszeiger zu speichern. Dann verarbeiten wir drei Methoden: OnMouseEnter ( Bewegen Sie die Maus über ein Objekt), OnMouseExit ( Bewegen Sie den Mauszeiger nicht über das Objekt) und OnMouseDown (Klicken auf das Objekt). Diese Methoden werden nach den entsprechenden Mausereignissen aufgerufen, wenn das Objekt, an das das Skript angehängt ist, von der GUIElement- oder Collider- Klasse geerbt wird . Bei den Ein- / Ausgabemethoden des Mauszeigers setzen wir die entsprechende Textur auf das Objekt, bei der Klickmethode schreiben wir einfach eine Nachricht an die Konsole.

Wir hängen das Skript an unsere Schaltfläche an, geben die Texturdateien in die entsprechenden Felder ein:



Starten Sie die Szene und testen Sie die Schaltfläche. Die Schaltfläche ändert die Textur, wenn Sie mit der Maus darüber fahren, wenn Sie darauf klicken, und zeigt die Meldung "Angeklickt" in der Konsole an. Wenn der Cursor angezeigt wird, ändert sich die Textur zurück.



Link zur ursprünglichen Lektion

Zusätzliche Materialien:

Link zur Dokumentation der GUI-Komponente Komponente
Link zur Dokumentation der OnMouseEnter-Methode
Link zur Dokumentation der OnMouseExit-Methode Link zur Dokumentation
der OnMouseDown-Methode

Basislektion 26 - Verwenden der Mathf.Clamp-Methode zum Begrenzen von Werten




Die Lektion zeigt, wie Sie mit der Mathf.Clamp-Methode Werte in einem bestimmten Bereich begrenzen.

Bei der Entwicklung von Spielmechaniken müssen Sie manchmal einen bestimmten Wert innerhalb eines bestimmten Wertebereichs begrenzen. Sie schreiben beispielsweise einen einfachen Weltraum-Shooter und möchten, dass das spielergesteuerte Schiff nicht über die Bildschirmränder hinausfliegt. Die Clamp- Methode der Mathf- Klasse hilft uns dabei .

Verwenden Sie diese Methode in einer Szene, in der wir eine Kamera, eine Lichtquelle und einen einfachen Würfel haben .



Wir erkennen die Möglichkeit, den Würfel entlang der X- Achse zu bewegen, und es wird möglich sein, sich nur im Bereich von X = -10 bis X zu bewegen= 10. Schreiben Sie dazu das folgende Skript und fügen Sie es dem Cube hinzu:
JavaScript-Code:
function Update () {
 var xMove : float = Input.GetAxis("Horizontal") * Time.deltaTime * 20;
 transform.Translate(Vector3(xMove,0,0));
 transform.position.x = Mathf.Clamp(transform.position.x, -10, 10);
}

C # -Code:
void Update()
{
    float xMove = Input.GetAxis("Horizontal") * Time.deltaTime * 20;
    transform.Translate(new Vector3(xMove,0,0));
    transform.position = 
        new Vector3(Mathf.Clamp(transform.position.x, -10, 10), transform.position.y, transform.position.z);
}

Wir verschieben den Würfel mit dem Wert der virtuellen X- Achse und der Transform.Translate- Methode und begrenzen dann die Position des Würfels entlang der X- Achse, indem wir die Mathf.Clamp- Methode aufrufen . Die Methode akzeptiert drei Parameter: einen begrenzten Wert, eine minimale Bereichsgrenze und eine maximale Bereichsgrenze.

Wir starten die Szene, drücken A / D auf der Tastatur oder Links-Rechts-Pfeile. Der Würfel bewegt sich und kann die Grenzen des Bereichs X = -10..10 nicht überschreiten. ( Um sicherzugehen, können Sie den Positionswert entlang der X-Achse am Ende der Update-Methode zur Konsole hinzufügen. - Kommentar eines Übersetzers) .

Link zur ursprünglichen Lektion

Zusätzliche Materialien:

Verweis auf die Dokumentation der Mathf.Clamp-Methode

Grundlektion 27 - Implementieren einer Unterbrechung (Pause) in einem Spiel mithilfe von Time.timeScale




In der Lektion wird die Verwendung der Time.timeScale-Eigenschaft zum Anhalten / Fortsetzen eines Spiels erläutert.

Wenn Sie ein Spiel entwickeln, möchten Sie den Spielern wahrscheinlich die Möglichkeit geben, es anzuhalten und dann fortzusetzen. Arbeiten Sie dazu einfach ein wenig mit der statischen Eigenschaft timeScale der Klasse Time .

Zum Beispiel haben wir eine Szene, in der ein kleiner Ball über den Boden springt und wir seine Bewegung anhalten / wieder aufnehmen möchten. Zunächst benötigen wir ein Objekt, an das wir ein Skript für die Pausenimplementierung „hängen“. Dazu können Sie ein leeres Spielobjekt erstellen (Menü GameObject - Create Empty ), es an einer beliebigen Stelle platzieren und es beispielsweise als Manager bezeichnen .



Jetzt erstelle ein neues Skript und schreibe folgendes hinein:
JavaScript-Code:
var paused : boolean = false;
function Update () {
 if(Input.GetButtonUp("Jump")){
  if(!paused){
   Time.timeScale = 0;
   paused=true;
  }else{
   Time.timeScale = 1;
   paused=false;
  }
 }
}

C # -Code:
bool paused = false;
private void Update() 
{
   if(Input.GetButtonUp("Jump"))
   {
        if(!paused)
        {
            Time.timeScale = 0;
            paused=true;
        }
       else
        {
            Time.timeScale = 1;
            paused=false;
        }
    }
}

Im Skript haben wir variable pausiert für die Steuerung, Pause oder nicht. Wir unterbrechen die Update- Methode durch Drücken der "Jump" -Taste. Bei den Standardeingabeeinstellungen ist dies die Leertaste. Als nächstes prüfen wir, ob die Pause aus ist? In diesem Fall setzen Sie die Time.timeScale- Eigenschaft auf 0 , wodurch der Zeitfluss im Spiel gestoppt wird. und wir meinen, dass die Pause eingeschaltet ist - Pause = wahr . Andernfalls setzen Sie Time.timeScale auf 1 und deaktivieren Sie die Pause. Die Time.timeScale- Eigenschaft kann auch auf einen Wert zwischen 0 und 1 und größer als 1 festgelegt werden. Dadurch wird der Zeitablauf entsprechend verlangsamt und beschleunigt, wenn Sie ihn benötigen.

Fügen Sie dem Manager- Objekt ein Skript hinzu, und führen Sie die Szene aus. Sie können jederzeit auf die Leertaste klicken - der Ball bleibt stehen. Durch wiederholtes Drücken wird die Bewegung des Balls unterbrochen.

Link zur ursprünglichen Lektion

Zusätzliche Materialien:

Verknüpfen Sie mit der Dokumentation für die Time.timeScale-Eigenschaft

Basislektion 28 - Verwenden der SendMessage-Methode zum Aufrufen externer Methoden




In dieser Lektion wird beschrieben, wie Sie mit der SendMessage-Methode der GameObject-Klasse die Skriptmethode eines anderen Spielobjekts aufrufen.

Es gibt verschiedene Möglichkeiten, eine Verbindung zwischen dem Skript eines Spielobjekts und dem Skript eines anderen Spielobjekts herzustellen. Zuvor haben wir die GetComponent- Methode untersucht , mit der Sie die Komponenten eines Objekts einschließlich seiner Skripte abrufen können. Eine Alternative dazu wäre die Verwendung der SendMessage- Methode .

Stellen Sie sich eine Szene vor, in der ein blauer Ball auf eine rote Schalterbox fällt . Neben ihnen hängt ein schwarzer Blockblock in der Luft . Lassen Sie uns den Block die Textur ändern, wenn der Ball auf die Schachtel fällt und auch herunterfällt.



Zuerst müssen wir ein Skript für den Block schreiben. Erstellen Sie ein neues Skript, nennen Sie es Reactor und schreiben Sie Folgendes:
JavaScript-Code:
var downTexture : Texture2D;
function React () {
 renderer.material.mainTexture = downTexture;
 yield WaitForSeconds(1);
 gameObject.AddComponent(Rigidbody);
}

C # -Code:
public Texture2D downTexture;
private IEnumerator React() 
{
    renderer.material.mainTexture = downTexture;
    yield return new WaitForSeconds(1);
    gameObject.AddComponent(typeof(Rigidbody));
}

Wir haben die Variable downTexture für die Texturspeicherung deklariert und die React- Methode implementiert , bei der wir die Textur des Objekts ändern, eine kurze Verzögerung von 1 Sekunde durchführen und die Rigidbody- Komponente des Volumenkörpers hinzufügen, sodass das Objekt durch die Schwerkraft beeinflusst wird. Wir fügen dieses Skript sofort zum Block- Objekt hinzu und ziehen ein geeignetes Bild in das Skriptfeld "Down Texture" . In der Lektion ist dies ein Bild eines gelben Pfeils, der auf einen schwarzen Hintergrund zeigt.



Nehmen Sie sich Zeit, um die Szene zu starten, es wird sich vorerst nichts daran ändern. Als nächstes müssen wir ein Skript für den Ball machen Kugel . Nennen Sie es Switcher und schreiben Sie es hinein:
JavaScript-Code:
function OnCollisionEnter(col : Collision) {
 if(col.gameObject.name == "Switch"){
  gameObject.Find("Block").SendMessage("React");
 }
}

C # -Code:
private void OnCollisionEnter(Collision col) 
{
    if (col.gameObject.name == "Switch")
        GameObject.Find("Block").SendMessage("React");
}


Wir haben die OnCollisionEnter- Methode implementiert, die aufgerufen wird, wenn der Kollider des Balls mit dem Kollider eines anderen Objekts kollidiert. Wir sind an einer Kollision mit einer Switch- Box interessiert , also führen wir zuerst die entsprechende Prüfung durch. In diesem Fall suchen wir das Block- Objekt mit der GameObject.Find- Methode und geben den Namen des Blocks an. Für das gefundene Objekt wird die SendMessage- Methode aufgerufen , in die der Name der aufzurufenden Methode ( React ) übergeben wird. Danach wird diese Methode entsprechend ausgeführt.

Füge dem Ball ein Drehbuch hinzu und starte die Szene. Wenn nun ein Ball auf eine Kiste fällt, ändert der Block seine Textur und fällt nach einer Sekunde ebenfalls herunter.



Anmerkung des Übersetzers:Ein Nachteil der Verwendung von SendMessage ist die potenzielle Leistungsminderung im Vergleich zum direkten Aufrufen von Methoden. Hier auf dieser Seite, die sich mit Leistungsproblemen befasst, sprechen wir über den Unterschied von 100 mal zugunsten eines direkten Anrufs. Aus diesem Grund sollte diese Methode mit Vorsicht angewendet werden (wie die Methoden GetComponent , Find usw.). Wenn ihre Verwendung tatsächlich zu einem Leistungseinbruch führt, sollten Sie schnellere Lösungen verwenden.

Link zur ursprünglichen Lektion

Zusätzliche Materialien:

Link zur Dokumentation der GameObject.SendMessage-Methode

Jetzt auch beliebt: