GODOT 3.3.X

Einleitung

Variablen können als Zwischenspeicher für verschiedenste Werte verwendet, z.B. HP, Leben,
Position des Spielers, aber auch Listen (Inventar-Liste), Funktionen und komplette Objekte, wie z.B. die Spielfigur, mit allen in diesen Objekt vorhandenen Variablen (HP, Leben, Position, Spielername).
Diese Variablen können mit mathematischen Funktionen manipuliert werden (Add/Subtraktion, Multiplikation, Division). Man diese aber auch abfragen und miteinander vergleichen IF-Anweisungen.

Code (Grundlagen)

Da GD-Script Python nachempfunden wurde ist die Definierung einer Variable sehr einfach, da
GD-Script für uns den Datentyp der Werte “errät” und auch während des Programm Ablaufs verändern kann, wenn wir nicht den Datentyp zuvor definiert haben (dazu kommen wir später noch zurück!).
Variablen werden mit dem Befehl var gefolgt von einem sinnvollen Namen erstellt. Man kann Variablen gleich bei der Definition mit Werten besetzen oder aber auch diese vorerst leer lassen und im Nachhinein mit Werten versehen:

var hit_points = 77.7
var leben
var spielername = "Davo"

func _ready():
   leben = 3
   print(hit_points)
   print(leben)
   print(spielername)

Hier haben wir uns drei Variablen erstellt, deren Wert Definiert und auch gleich in der Konsole ausschreiben lassen. Nun wollen wir aber auch mit diesen Operationen durchführen, z.B. dass HP entzogen werden, wenn der Spieler von einem Gegner getroffen wird. Um die Beispiele leicht zu halten werden wir vorerst “händisch” einprogrammieren (Hard Coded).

var hp = 100

func _ready():
   print(hp)
   hit_player()
   print(hp)

func hit_player():
   hp = hp - 10

ABLAUF: Wir definieren die Variable “hp” mit dem Wert 100, lassen diese ausschreiben (-> 100), der Spieler wird von einem Gegner getroffen (Funktion “hit_player()”), es werden 10 von der Variable “hp” abgezogen und zuletzt lassen wir wieder die Variable ausschreiben (-> 90)
Wir lesen raus, dass wir 10 von HP Subtrahieren. Nun kann man die Subtraktion in eine Addition umwandeln und anstatt eines “Minus” ein “Plus” anwenden und dem Spieler 10 HP hinzufügen.

var hp = 70

func _ready():
   print(hp)
   add_hp()
   print(hp)

func add_hp():
   hp += 30

ABLAUF: Dem Spieler werden 30 HP hinzugefügt, wir bemerken aber auch, dass die Addition im Vergleich zur Subtraktion anders aussieht (“hp += 30“). Das hilft uns den Code sauber/lesbarer zu halten.

VAR = VAR + WERT ist das gleiche wie VAR += WERT

Je nach Verwendungszweck können wir anstatt des + auch –, * und / verwenden

Code (Globale/Lokale Variablen)

In den vorigen Beispielen haben wir Globale Variablen erstellt und verwendet. Globale Variablen sind von überall erreichbar, d.h. jede Funktion im Script aber auch Funktionen von anderen Objekten können auf diese zugreifen!

func _ready():
   var hp = 100
   print(hp)
   hit_player()

func hit_player():
   hp -= 10

In diesem Beispiel wurden die HP vom Spieler lokal in der Funktion “_ready()” erstellt und definiert. Nun wird der Spieler wie im ersten Beispiel getroffen und die Funktion “hit_player()” soll wieder 10 von HP abziehen, was aber in einer Fehlermeldung endet, da die Funktion “hit_player()” keinen Zugriff auf die lokale Variable HP in der Funktion “_ready()” hat.
Globale/Lokale Variablen werden auch public/private Variablen genannt!

Code (Datentypen)

Im ersten Beispiel wurden verschieden Datentypen als Wert in die Variablen gesetzt (77.7, 3 und “Davo”)
77.7 ist eine Rationale Zahl (float), 3 is eine Ganze Zahl (int) und “Davo” ist eine Zeichenkette (string). Nun analysiert GD-Script was für ein Wert in die Variablen gesetzt wird und stellt automatisch den Datentyp der Variablen fest. Dies kann unter anderem Folgendes Problem hervorrufen:

var wert = 100

func _ready():
   print(wert)
   wert = "Wert"
   print(wert)

Dieser Code definiert zuerst die Variable “wert” mit 100 (int), gibt 100 in der Konsole aus, besetzt nun die Variable mit der Zeichenkette “Wert” (string) und schreibt nun “Wert” in die Konsole. Anfangs denkt man sich nicht viel dabei, aber dieser Wechsel, dass eine Variable anfangs eine Ganze Zahl ist und später höchstwahrscheinlich aus Versehen in eine Zeichenkette geändert wird hebt folgende Fehler hervor:

var wert_1 = 100
var wert_2 = 47
var ergebnis

func _ready():
   ergebnis = wert_1 + wert_2
   print(ergebnis)
   andere_funktion()
   ergebnis = wert_1 + wert_2
   print(ergebnis)

func andere_funktion():
   wert_1 = "Fehler"

Hier haben wir anfangs zwei Werte (100, 47), welche zusammenaddiert werden und in einer neuen Variable “ergebnis” gespeichert werden. Das Ergebnis 147 wird in der Konsole ausgegeben. Nun wird “wert_1” in einer anderen Funktion in die Zeichenkette “Fehler” geändert und die zwei Werte werden wieder zusammenaddiert -> Das Programm bricht hier ab und gibt uns einen Fehler aus… Wir wollten ja auch in der zweiten Addition eine Zahl mit einer Zeichenkette addieren…

Nun ist dieses Beispiel sehr einfach und man erkennt auf den ersten Blick, dass das nicht stimmen kann, nur wenn man anfängt größere Projekte zu programmieren und diese “andere_funktion()” aus einem anderen Skript ausgeführt wird und das nicht unbedingt immer zum gleichen Zeitpunkt, ist es nicht mehr so ersichtlich, dass wir einen Fehler gemacht haben.

Solche leichten aber nervigen Fehler können wir verhindern in dem wir den Datentyp bei der Variablen Definition auf folgende Weise setzen:

var wert_1: int = 100
var wert_2: int = 47
var ergebnis: int

func _ready():
   ergebnis = wert_1 + wert_2
   print(ergebnis)
   andere_funktion()
   ergebnis = wert_1 + wert_2
   print(ergebnis)

func andere_funktion():
   wert_1 = "Fehler"

Der Fehler ist in diesem Beispiel weiterhin vorhanden, aber Godot weist sofort darauf hin, dass wir ein Fehler gemacht haben, bevor wir überhaupt das Programm gestartet haben, was nicht der Fall sein würde, wenn wir davor nicht die Datentypen der Variablen definiert hätten!

AUSNAHME: Die Datenvariablen int und float geben keine Warnung aus und funktionieren miteinander.

var wert_1: int = 100
var wert_2: float = 47.7

func _ready():
   var ergebnis = wert_1 + wert_2
   print(ergebnis)


--> 147.7

var wert_1: int = 100
var wert_2: float = 47.7
var ergebnis: int

func _ready():
   ergebnis = wert_1 + wert_2
   print(ergebnis)

--> 147

Zudem kann uns Godot, wenn wir Variablen definieren nützlichere Vorschlägen bei schreiben des Codes geben. Wenn wir uns in der Godot Dokumentation den Datentyp String anschauen finden wir unter anderen Methoden, die Methode to_upper(). to_upper() nimmt den String und gibt jeden Charakter als Großbuchstabe aus.

Methoden sind Funktionen, die von bestimmten Objekten angewandt werden können!
In unserem Beispiel, können wir nicht und würde auch keinen Sinn machen to_upper()
an einem int oder float anzuwenden.

Hier sehen wir, dass einen String mit dem Wert “Davo” den wir in der Konsole ausgeben wollen. Wir kennen mittlerweile, dass Strings die Funktion “to_upper()” besitzt die wir anwenden wollen.

Es reicht einfach den Variablennamen zu schreiben gefolgt von einem Punkt. Godot gibt uns gleich eine Liste mit allen verfügbaren Methoden die wie anwenden können. Die Liste wird angepasst, wenn wir nach dem Punkt “to” schreiben und wir haben ein leichteres Spiel die richtige Methode zu finden.

Code (Arrays und Dictionaries)

Man kann auch Variablen erstellen, die eine Reihe an Daten beinhalten. Nützlich können solche Listen z.B. für ein Inventar System oder Highscore Tabelle in einem Multiplayer Spiel sein. Listen können eine Mischung an verschiedenen Datentypen beinhalten!

Fangen wir mit einem Array an, welches Informationen über einen Spieler beinhalten soll. Im Array wollen wir dessen Spielername, Leben und Highscore speichern

var player_info: Array = ["Davo", 3, 16700]

func _ready():
   print(player_info[0])      --> KONSOLE: Davo
   print(player_info[1])      --> KONSOLE: 3
   print(player_info[2])      --> KONSOLE: 16700

Wir erstellen also ein Array mit einer Definition und setzen Inhalt in das Array in eckigen Klammern, der Inhalt getrennt durch ein Komma untereinander.
Um Inhalt aus dem Array auszulesen nennen wir das Array mit dem dazugehörigen Index wo sich der Inhalt befindet. Man beachte, dass der Index eines Arrays bei 0 beginnt!

Genau so wie wir Arrays auslesen, können wir diese auch beschreiben und Operationen durchführen:

var player_info: Array = ["Davo", 3, 16700]

func _ready():
   player_info[0] = "Muro"
   player_info[1] -= 1
   player_info[2] += 4300

   print(player_info[0])      --> KONSOLE: Muro
   print(player_info[1])      --> KONSOLE: 1
   print(player_info[2])      --> KONSOLE: 21000

Arrays werden etwas anders beschrieben als andere Datentypen. Wie wir in den letzten zwei Beispiel gesehen haben, können Arrays eine Anzahl an Inhalten mit verschiedenen Datentypen beinhalten. In der Dokumentation finden wir folgende Methode: append()
Diese Methode fügt ein beliebiges Element an das Ende des Arrays hinzu. Wir erstellen jetzt ein leeres Array und wollen dieses dann mit Daten beschreiben

var player_info: Array = []

func _ready():
   player_info.append("Davo")
   player_info.append(3)
   player_info.append(16700)

   print(player_info)      --> KONSOLE: ["Davo", 3, 16700]

   print(player_info[0])   --> KONSOLE: Davo
   print(player_info[1])   --> KONSOLE: 3
   print(player_info[2])   --> KONSOLE: 16700

Es ist auch möglich Arrays in Arrays zu speichern. Ein solches Array wird dann zu einem sogennanten zwei Dimensionalen-Array. Man kann auch Arrays in “ArrayArrays” hinzufügen, was aber komplizierter wird später auszulesen

var player_1: Array =    ["Davo", 3, 16700]
var player_2: Array =    ["Muro", 2, 21000]
var all_players: Array = []

func _ready():
   
   all_players.append(player_1)
   all_players.append(player_2)

   print(all_players)            --> KONSOLE: [["Davo", 3, 16700], ["Muro", 2, 21000]]

   print(all_players[0][0])      --> KONSOLE: Davo
   print(all_players[1][2])      --> KONSOLE: 21000

Der erste Index von all_players bezieht sich auf die äußere Klammer des Arrays, d.h. entweder das Array mit den Daten von player_1 oder player_2 (Nicht vergessen, der Index beginnt bei 0!).
Der zweite Index von all_players bezieht sich dann auf die Daten vom zuvor ausgewählten Array

TO BE CONTINUED, I’LL BE BACK

                       ______
                     <((((((\\\
                     /      . }\
                     ;--..--._|}
  (\                 '--/\--'  )
   \\                | '-'  :'|
    \\               . -==- .-|
     \\               \.__.'   \--._
     [\\          __.--|       //  _/'--.
     \ \\       .'-._ ('-----'/ __/      \
      \ \\     /   __>|      | '--.       |
       \ \\   |   \   |     /    /       /
        \ '\ /     \  |     |  _/       /
         \  \       \ |     | /        /
          \  \      \        /