Ihr erstes Skript erstellen¶

In dieser Lektion programmieren Sie Ihr erstes Skript, um das Godot-Symbol mithilfe von GDScript im Kreis drehen zu lassen. Wie wir in der Einführung erwähnt haben, gehen wir davon aus, dass Sie Programmiergrundlagen haben. Der entsprechende C#-Code wurde der Einfachheit halber in eine andere Registerkarte eingefügt.

../../_images/scripting_first_script_rotating_godot.gif

Siehe auch

Um mehr über GDScript, seine Schlüsselwörter und seine Syntax zu erfahren, besuchen Sie die GDScript-Referenz.

Siehe auch

Weitere Informationen zu C# finden Sie auf der Seite C#-Grundlagen.

Projektkonfiguration¶

Bitte legen Sie ein neues Projekt an, um mit einer blanken Fläche zu beginnen. Ihr Projekt sollte ein Bild enthalten: das Godot-Symbol, das wir häufig für die Prototypenerstellung in der Community verwenden.

Wir müssen ein Sprite-Node erstellen, um es im Spiel anzuzeigen. Klicken Sie im Szenen-Dock auf die Schaltfläche Anderes Node.

../../_images/scripting_first_script_click_other_node.png

Geben Sie „Sprite“ in die Suchleiste ein, um Nodes zu filtern, und doppelklicken Sie auf Sprite, um das Node zu erstellen.

Die Registerkarte "Szene" sollte jetzt nur noch ein Sprite-Node enthalten.

../../_images/scripting_first_script_scene_tree.png

Ein Sprite-Node braucht eine Textur, um angezeigt zu werden. Im Inspektor auf der rechten Seite sehen Sie, dass die Eigenschaft Textur "[leer]" lautet. Um das Godot-Symbol anzuzeigen, klicken Sie auf die Datei icon.png und ziehen Sie sie aus dem FileSystem-Dock auf den Textur-Slot.

../../_images/scripting_first_script_setting_texture.png

Bemerkung

Sie können Sprite-Nodes automatisch durch Ziehen und Ablegen von Bildern auf das Ansichtsfenster erstellen.

Klicken und ziehen Sie dann das Symbol in das Ansichtsfenster, um es in der Spielansicht zu zentrieren.

Ein neues Skript erstellen¶

Um ein neues Skript zu erstellen und an unseres Node anzuhängen, klicken Sie mit der rechten Maustaste auf Sprite im Szenendock und wählen Sie „Skript hinzufügen“.

../../_images/scripting_first_script_attach_script.png

Im Fenster Node-Skript hinzufügen wird angezeigt. Hier können Sie unter anderem die Sprache des Skripts und den Dateipfad auswählen.

Ändern Sie die Vorlage von "Standard" in "Leer", um mit einer sauberen Datei zu beginnen. Belassen Sie die anderen Optionen in der Standardeinstellung und klicken Sie auf die Schaltfläche Erstellen, um das Skript zu erstellen.

../../_images/scripting_first_script_attach_node_script.png

Der Skript-Arbeitsbereich sollte mit der neuen Datei Sprite.gd und der folgenden Codezeile geöffnet werden:

extends Sprite

public class Sprite : Godot.Sprite
// Declare member variables here. Examples:
// private int a = 2;
// private string b = "text";

// Called when the node enters the scene tree for the first time.
public override void _Ready()
{

}

//  // Called every frame. 'delta' is the elapsed time since the previous frame.
//  public override void _Process(float delta)
//  {
//
//  }

Jede GDScript-Datei ist implizit eine Klasse. Das Schlüsselwort extends definiert die Klasse, die dieses Skript erbt oder erweitert. In diesem Fall ist es Sprite, was bedeutet, dass unser Skript Zugriff auf alle Eigenschaften und Funktionen des Sprite-Nodes erhält, einschließlich der Klassen, die es erweitert, wie Node2D, CanvasItem, und Node.

Bemerkung

Wenn Sie in GDScript die Zeile mit dem Schlüsselwort extends weglassen, erweitert Ihre Klasse implizit Reference, die Godot verwendet, um den Speicher Ihrer Anwendung zu verwalten.

Zu den vererbten Eigenschaften gehören die, welche Sie im Inspektor-Dock sehen können, wie z. B. texture in unserem Node.

Bemerkung

Standardmäßig zeigt der Inspektor die Eigenschaften eines Nodes in „Titelschreibweise“ an, wobei großgeschriebene Wörter durch ein Leerzeichen getrennt werden. Im GDScript-Code befinden sich diese Eigenschaften in "snake_case", also Kleinbuchstaben mit Wörtern, die durch einen Unterstrich getrennt sind.

Sie können den Mauszeiger über den Namen einer Eigenschaft im Inspektor bewegen, um eine Beschreibung und den Bezeichner im Code zu sehen.

Hallo, Welt!¶

Unser Skript tut derzeit nichts. Lassen wir es den Text "Hallo, Welt!" in das untere Ausgabefeld drucken, um loszulegen.

Fügen Sie den folgenden Code in Ihr Skript ein:

func _init():
    print("Hello, world!")

public Sprite()
{
    GD.Print("Hello, world!");
}

Schauen wir uns das mal an. Das Schlüsselwort func definiert eine neue Funktion namens _init. Dies ist ein spezieller Name für den Konstruktor unserer Klasse. Die Engine ruft _init() bei jedem Objekt oder Node auf, wenn es im Speicher erstellt wird, wenn Sie diese Funktion definieren.

Bemerkung

GDScript ist eine einrückungsbasierte Sprache. Der Tab am Anfang der Zeile mit der Aufschrift print() ist notwendig, damit der Code funktioniert. Wenn Sie es weglassen oder eine Zeile nicht richtig einrücken, hebt der Editor dies rot hervor und zeigt die folgende Fehlermeldung an: "Eingerückter Block erwartet".

Speichern Sie die Szene, falls Sie dies noch nicht getan haben, und drücken Sie dann F6 (Cmd + R unter macOS), um sie auszuführen. Sehen Sie sich das untere Feld Ausgabe an, das erweitert wird. Es sollte "Hello, world!" anzeigen.

../../_images/scripting_first_script_print_hello_world.png

Löschen Sie die Funktion _init(), so dass nur die Zeile extends Sprite übrig bleibt.

Umdrehen¶

Es ist an der Zeit, unser Node zu bewegen und zu drehen. Dazu fügen wir zwei Variablen zu unserem Skript hinzu: die Bewegungsgeschwindigkeit in Pixeln pro Sekunde und die Winkelgeschwindigkeit in Bogenmaß pro Sekunde.

var speed = 400
var angular_speed = PI

private int Speed = 400;
private float AngularSpeed = Mathf.Pi;

Member-Variablen befinden sich am Anfang des Skripts, nach allen "extends"-Zeilen, aber vor Funktionen. Jede Nodeinstanz, an die dieses Skript angehängt ist, hat eine eigene Kopie der Eigenschaften speed und angular_speed.

Bemerkung

Winkel in Godot funktionieren standardmäßig im Bogenmaß, aber Sie haben integrierte Funktionen und Eigenschaften zur Verfügung, wenn Sie es vorziehen, Winkel stattdessen in Grad zu berechnen.

Um unser Symbol zu bewegen, müssen wir seine Position und Drehung in jedem Frame der Spielschleife aktualisieren. Wir können die virtuelle Funktion _process() der Klasse Node verwenden. Wenn Sie die Funktion in einer Klasse definieren, welche die Klasse Node erweitert, wie z.B. Sprite, ruft Godot die Funktion bei jedem Frame auf und übergibt ihr ein Argument namens delta, die seit dem letzten Frame verstrichene Zeit.

Bemerkung

Bei Spielen werden viele Bilder pro Sekunde gerendert, die als Frames bezeichnet werden, und zwar in einer Schleife. Wir messen die Rate, mit der ein Spiel Bilder produziert, in Frames Per Second (FPS). Die meisten Spiele streben 60 FPS an, obwohl man bei langsameren Mobilgeräten auch Werte wie 30 FPS oder bei Virtual-Reality-Spielen 90 bis 240 FPS finden kann.

Die Engine und die Spieleentwickler tun ihr Bestes, um die Spielwelt zu aktualisieren und Bilder in einem konstanten Zeitintervall zu rendern, aber es gibt immer kleine Schwankungen bei den Renderzeiten der Frames. Deshalb liefert uns die Engine diesen Delta-Zeitwert, der unsere Bewegung unabhängig von unserer Framerate macht.

Definieren Sie am Ende des Skripts die Funktion:

func _process(delta):
    rotation += angular_speed * delta

public override void _Process(float delta)
{
    Rotation += AngularSpeed * delta;
}

Das Schlüsselwort func definiert eine neue Funktion. Danach müssen wir den Namen der Funktion und die Argumente, die sie benötigt, in Klammern setzen. Ein Doppelpunkt beendet die Definition, und die folgenden eingerückten Blöcke sind der Inhalt oder die Anweisungen der Funktion.

Bemerkung

Beachten Sie, dass _process(), wie _init(), mit einem führenden Unterstrich beginnt. Godot's virtuelle Funktionen, d.h. eingebaute Funktionen, die Sie überschreiben können, um mit der Engine zu kommunizieren, beginnen mit einem Unterstrich.

Die Zeile innerhalb der Funktion, rotation += angular_speed * delta, erhöht die Rotation unseres Sprites in jedem Frame. Hier ist rotation eine Eigenschaft, die von der Klasse Node2D geerbt wurde, die Sprite erweitert. Sie steuert die Drehung unseres Nodes und arbeitet mit Bogenmaß.

Tipp

Im Code-Editor können Sie bei gedrückter Strg-Taste auf jede eingebaute Eigenschaft oder Funktion klicken, z. B. position, rotation, oder _process, um die entsprechende Dokumentation in einem neuen Tab zu öffnen.

Führen Sie die Szene aus, um zu sehen, wie sich das Godot-Symbol an Ort und Stelle dreht.

../../_images/scripting_first_script_godot_turning_in_place.gif

Vorwärtskommen¶

Lassen Sie uns nun das Node verschieben. Fügen Sie der Funktion _process() die folgenden beiden Zeilen hinzu und achten Sie darauf, dass die neuen Zeilen genauso eingerückt werden wie die vorherigen.

var velocity = Vector2.UP.rotated(rotation) * speed

position += velocity * delta

var velocity = Vector2.Up.Rotated(Rotation) * Speed;

Position += velocity * delta;

Wie wir bereits gesehen haben, definiert das Schlüsselwort var eine neue Variable. Wenn Sie es an den Anfang des Skripts setzen, definiert es eine Eigenschaft der Klasse. Innerhalb einer Funktion definiert es eine lokale Variable: Sie existiert nur innerhalb des Funktionsbereichs.

Wir definieren eine lokale Variable namens velocity, einen 2D-Vektor, der sowohl eine Richtung als auch eine Geschwindigkeit darstellt. Um das Node vorwärts zu bewegen, gehen wir von der Konstante Vector2.UP der Klasse Vector2 aus, einem nach oben zeigenden Vektor, und drehen ihn durch Aufruf der Methode Vector2.rotated(). Dieser Ausdruck, Vector2.UP.rotated(rotation), ist ein Vektor, der relativ zu unserem Symbol nach vorne zeigt. Multipliziert mit unserer Eigenschaft speed ergibt sich eine Geschwindigkeit, mit der wir das Node vorwärts bewegen können.

Wir fügen velocity * delta zu der Nodes position hinzu, um ihn zu verschieben. Die Position selbst ist vom Typ Vector2, einem eingebauten Typ in Godot, der einen 2D-Vektor darstellt.

Führen Sie die Szene aus, um den Godot-Kopf im Kreis laufen zu sehen.

Bemerkung

Beim Verschieben eines solchen Nodes werden Kollisionen mit Wänden oder dem Boden nicht berücksichtigt. In Dein erstes 2D-Spiel lernen Sie einen anderen Ansatz, um Objekte zu bewegen und dabei Kollisionen zu erkennen.

Unser Node bewegt sich derzeit von selbst. Im nächsten Teil Eingaben des Spielers abhören werden wir es mit Spielereingaben steuern.

Vollständiges Skript¶

Hier ist die vollständige Sprite.gd-Datei als Referenz.

extends Sprite

var speed = 400
var angular_speed = PI

func _process(delta):
    rotation += angular_speed * delta

    var velocity = Vector2.UP.rotated(rotation) * speed

    position += velocity * delta

using Godot;

public class Sprite : Godot.Sprite
{
    private int Speed = 400;
    private float AngularSpeed = Mathf.Pi;

    public override void _Process(float delta)
    {
        Rotation += AngularSpeed * delta;
        var velocity = Vector2.Up.Rotated(Rotation) * Speed;

        Position += velocity * delta;

    }
}