​Husi's Variablen Tutorial

      ​Husi's Variablen Tutorial

      Hallo,
      in diesem Tutorial erkläre ich dir, was Variablen und Arrays sind,
      wie man sie benutzt und welchen Gültigkeitsbereich (Scope) sie haben.

      Variablen sind einfach gesagt Platzhalter, die im Arbeitsspeicher abgespeichert werden.
      Sie stehen für einen Wert (Text,Zahl oder Status). Variablen sind in der Programmierung unverzichtbar,
      weil sie alle möglichen Werte zwischenspeichern können. Zum Beispiel möchte man den Namen vom Spieler abfragen,
      muss dieser irgendwo „gemerkt“ werden und genau hier benutzt man Variablen.

      Der Name wäre ein Text (Zeichenkette/String). Wenn man ein Alter abspeichert, wäre es hilfreich dieses als Zahl abzuspeichern.
      Man muss den Unterschied in einer kleinen Sache beachten, worauf ich gleich noch zurückkomme.

      Eine Variable trägt einen Namen, mit dem man sie ansprechen kann. Diesen kann man fast frei wählen.
      Folgende Regeln müssen beachtet werden:
      1. keine Sonderzeichen dürfen enthalten sein
      2. Zahlen dürfen nicht am Anfang stehen
      3. Namen dürfen nicht den Namen von Funktionen oder Konstanten(„schreibgeschützte“ Variablen, sind auch Ressourcennamen von zB. Objekten,Sprites usw.) haben

      Hinweis: Groß- und Kleinschreibung spielt eine Rolle!

      Und jetzt geht's endlich mal an die Praxis:

      Man erstellt eine Variable so:

      GML-Quellcode

      1. variabletext = "Text";
      2. variablezahl = 10.1;


      Hinweis:
      • Semikolon kommt immernach einem Befehl
      • Bei Zahlen Kommas mit einem Punk
      • Text immer in Anführungszeichen (auch möglich mit ' um dann die "im String zu haben: 'Anführungszeichen im "Text"')

      Mit dem Gleichzeichen sagt man, dass man der Variable einen Wert geben möchte.

      Wie ich eben erklärt habe, kann man auch einen Status in einer Variable festhalten.
      Dafür gibt es zwei Werte (Konstanten) true und false. Diese Werte sind die selben wie 1 und 0
      (Wozu man diese braucht usw. erfährst du in dem Tutorial: Husi's If Bedingungen Tutorial)



      Als nächstes kommen die
      Berechnungen
      Am Computer gibt es folgende Grundrechenoperatoren:
      Plus: +
      Minus: -
      Mal: *
      Geteilt: /

      Hier kann man jetzt einfache Mathematik benutzen und mit Zahlen rechnen:
      5*4 = 20 usw.

      Gleichungen kann man aber nicht aufstellen.
      Außerdem muss man den Wert irgendwo hin geben. Hier zB. an eine Variable:

      GML-Quellcode

      1. ausgerechnet= 5*4;


      Andererseits kann man auch Variablen verrechnen:

      GML-Quellcode

      1. zahl1 = 10;
      2. zahl2 = zahl1/5; //Ergebnis 2


      Statt aber so etwas zu schreiben:

      GML-Quellcode

      1. zahl = zahl+5;

      kannst du auch

      GML-Quellcode

      1. zahl += 5;

      schreiben.
      (gilt natürlich für alle +-*/)

      Um Schreibarbeit zu sparen, kann man sogar statt
      ​zahl += 1; einfach zahl++; schreiben.

      Genauso aber auch ++zahl; Wo ist da der Unterschied? Wenn man das so macht
      wie ich gerade, ist gar keiner da. Hier aber schon:

      GML-Quellcode

      1. zahl2 = zahl++;


      Was habe ich gemacht? zahl2 bekommt den Wert von zahl. Nach der „Übergabe“ wird zahl mit 1 addiert.

      Und bei zahl2 = ++zahl; kann man sich schon denken:
      zahl wird mit 1 addiert und dann zahl2 übergeben.

      Das spart zeit und ist Übersichtlich.

      Man kann auch Strings mit einander addieren. Das wäre sozusagen eine Art Verschmelzung zu einem String.

      Beispiel:

      GML-Quellcode

      1. string1 = "Hallo";
      2. string2 = "Welt";
      3. ausgabe = string1+" "+string2; //ausgabe gleich "Hallo Welt"

      Hier geht es auch mit

      GML-Quellcode

      1. ​variable += "Text";


      Bei dem Text gibt es aber Einschränkungen:
      Was mache ich, wenn ich ein Text mit einer Zahl verbinden will?

      GML-Quellcode

      1. variable = "Ergebnis: "+10;

      würde ein Fehler ausgeben lassen. Man muss 10 irgendwie in ein String umwandeln, um das ganze dann zu addieren…
      Und da gibt’s die
      Lösung: die Funktion string(val)!

      Nimmt man das Beispiel von oben und
      verbessert es:

      GML-Quellcode

      1. variable = "Ergebnis: "+string(10);

      Und alles klappt!
      Umgekehrt geht es auch:

      GML-Quellcode

      1. variable = 10+"5";

      macht auch ein Fehler und es gibt hierfür
      die Funktion real(str)
      Verbessert:

      GML-Quellcode

      1. ​variable = 10+real("5");




      Weiter geht’s mit dem
      Gültigkeitsbereich
      von Variablen

      Auch Variablen werden irgendwann aus dem Arbeitsspeicher geschmissen.
      Natürlich geschieht dies spätestens nach dem Beenden des Spiels.
      Es gibt aber noch viele andere Faktoren.

      Eine einfach erstellte Variable wie im ersten Beispiel gezeigt, gilt nur für die jeweilige Instanz, in der die Variable erstellt wurde.
      Sie existiert dort, bis die Instanz zerstört wurde.

      Eine andere Möglichkeit wäre es, vor der Variable ein var zu machen.

      GML-Quellcode

      1. var variable = 1;

      Jetzt ist diese nur in diesem Event, bzw. Skript verfügbar
      (und wird danach gelöscht).
      Man kann über var auch mehrere Variablen gleichzeitig erstellen:

      GML-Quellcode

      1. var var1,var2,var3;

      oder

      GML-Quellcode

      1. var var1=1,var2=500,var3=0;

      Zu guter Letzt kann man die auch Variablen für alle Instanzen zugänglich machen, also global machen.
      Hier gibt es zwei Möglichkeiten. Einerseits über global.variablenname:

      GML-Quellcode

      1. global.zahl = 4;

      Die Variable muss dann aber immer über global.variablenname angesprochen werden.

      Es geht aber auch über globalvar, welches man wie var benutzt, mit der Ausnahme, dass man ihr beim „global machen“
      (globalisieren wäre wahrscheinlich nicht die richtige Bezeichnung)
      keinen Wert geben kann. Hier muss man dann kein global. davor setzen.

      GML-Quellcode

      1. globalvar globale_variable;
      2. globale_variable = 7;

      Wenn du auf eine Variable, die nur in einer Instanz gültig ist, zugreifen möchtest, ist auch dies möglich.
      Das geht über:
      • objektname.variable oder
      • objektid.variable
      bei der ersten Möglichkeit, werden die Variablen je nach Situation alle existierende Objekte des angegebenen Namens geändert bzw. aufgerufen.



      Abschließend wollte ich noch die
      Arrays
      benennen.

      Ich vergleiche einfach mal die Schreibweise mit einem Beispiel, ohne groß drum herum zu reden,
      Variablen Waffensprites zu geben um die Waffe, die getragen wird später zu zeichnen:

      GML-Quellcode

      1. //Create
      2. waffe1 = spr_waffe1;
      3. waffe2 = spr_waffe2;
      4. waffe3 = spr_waffe3;
      5. traegt_waffe = 1;
      6. //Draw
      7. if(traegt_waffe==1)
      8. draw_sprite(waffe1,…);
      9. if(traegt_waffe==2)
      10. draw_sprite(waffe2,…);
      11. if(traegt_waffe==3)
      12. draw_sprite(waffe3,…);

      Schon sehr aufwändig ^^
      oder ganz einfach:

      GML-Quellcode

      1. //Create
      2. waffe[0] = spr_waffe1;
      3. waffe[1] = spr_waffe2;
      4. waffe[2] = spr_waffe3;
      5. traegt_waffe = 0;
      6. //Draw
      7. draw_sprite(waffe[traegt_waffe],…);


      Ein Array ist sozusagen eine nummerierte Variable, bzw. eine Liste.

      Die Nummerierung fängt wie fast alles in der Informatik bei 0 an
      und der Index/die Position wird in eckigen Klammern geschrieben.

      Deshalb kann man auch eine andere Variable in die Klammern packen um dem
      ganzen Code eine Flexibilität geben.

      Eigentlich müsste ich auch den ganzen Code vom Create umdrehen:

      GML-Quellcode

      1. waffe[2]=..
      2. waffe[1]=..
      3. waffe[0]=..


      Einfach deshalb, weil es schneller ist.
      (Warum haben wir mal hier nebenbei besprochen)

      Was ich gerade gezeigt habe, ist ein 1D Array.
      Es gibt aber auch einen 2 Dimensionalen Array. Hier hat man eine ganze Tabelle.

      GML-Quellcode

      1. tabelle[0,0] = 1;
      2. tabelle[1,0] = 2;
      3. tabelle[0,1] = 3;
      4. tabelle[1,1] = 4;


      Würde ungefähr so aussehen
      12
      34

      Die Werte, die man angeben muss, kann man sich auch als Koordinaten vorstellen:
      tabelle[x,y]

      Zu Arrays gibt es noch folgende Funktionen:

      is_array(variable) prüft, ob die angegebene Variable ein Array ist

      array_length_1d(array) gibt an, wie groß das 1d array ist. Im Beispiel von oben mit waffe, würde die Funktion 3 zurückgeben.

      array_height_2d(array) gibt die Anzahl der Zeilen des 2D Arrays aus.

      array_length_2d(array,n) gibt die Anzahl der Spalten des 2D Arrays, der Zeile n, aus.

      Da Arrays etwas größer im Arbeitsspeicher werden können, kann man sie auch löschen.
      Man gibt dem Array einen Wert wie einer Variable:

      GML-Quellcode

      1. array = 0;

      und der Speicher ist wieder frei.


      Das war's auch schon! Ich hoffe ich konnte euch weiterhelfen. :)
      Ein Bug ist mehr als nur ein Bug, es ist ein... Käfer!
      Egal, wie gut du eine Mauer baust, sie fällt um.... der klügere gibt nach :D

      Willst du mit mir auf Discord Chatten/Quatschen?
      Meine Husi's Tutorial Reihe
      Kleine Ergänzung übrigens: Falls jemand noch mehr über den ++ Operator wissen will, und was der Unterschied zwischen x++ und ++x auf grundlegender Ebene ist, gab es hier mal eine Diskussion dazu. Das geht aber über die Arbeit mit dem Gamemaker hinaus und macht einen kurzen Sprung in die Welt von Assemblersprachen und Compilern, betrachtet das also eher nur als kurzen Blick übern Tellerrand.