Quelltext der Seite RGSS für Dummköpfe/Der Kontrollfluss Teil III

{{Tutorial|RGSS für Dummköpfe|Max Jet|6|http://rpg-xp.net/forum/}}
==Loops (Schleifen)==
Ein bedingter Ausdruck prüft einfach, ob eine Bedingung wahr oder falsch ist und initiiert schließlich je nach Wert einen folgenden Code. Eine Schleife führt immer wieder einen Code aus, bis eine Bedingung erfüllt wurde. Beim Programmieren überprüfst du meistens nur die Eingabe, führst ein paar Berechnungen durch und zeichnest zum Schluss einfach irgendetwas. So könnte dein Quellencode des Spiels aussehen: 

 Eingabe überprüfen 
 Rechnung durchführen 
 Anzeigen

Leider gibt es da noch ein Problem und zwar, dass alles Zeile für Zeile ausgeführ wird, zuerst überprüft es deine Eingabe, führt die Berechnung durch, also bestimmt wohin dein Held jetzt läuft und zeigt dann auf dem Bildschirm den Gang an. Das Problem mit diesem Code allerdigns ist, dass Schluss ist, sobald die letzte Zeile ausgeführt wurde. Das programm eignet isch höchstens dazu den Held einen Schritt zu bewegen und steht dann still. Du könntest nun den Computer befehlen es noch einmal zu tun. 

 Eingabe überprüfen 
 Berechnung durchführen 
 Anzeigen 
 Eingabe abfragen 
 Rechnung durchführen 
 Anzeigen 
 ... 

Doch auch, wenn du hundert Zeilen schreibst, kommt das Programm irgendwann zu einem Ende. Du brauchst einen Befehl, welcher dem Computer sagt, er solle den Code immer und immer wieder wiederholen, bis der Spieler das Spiel verlässt, indem er Escape drückt oder so etwas. So etwas, wie das hier: 

 while (Esc ist nicht gedrückt) 
   Eingabe überprüfen 
   Rechnung durchführen 
   Anzeigen 
 Ende

So funktionieren „loops“ oder auch Schleifen, Die Bedingung am Anfang des Codes wird überprüft und sofern sie erfüllt wird, wird der Code immer und immer wieder ausgeführt. Mit jedem „loop“ wird die Bedingung überprüft, also wird dein Code irgendwann aus der Schleife ausbrechen müssen. „Loops“ ermöglichen es dir, interaktive Programme herzustellen, die nicht „sterben“, was den parallelen Prozessen und „auto start“ Events im RPGM sehr ähnelt. Anstatt, dass sie irgendwo aufhören, beginnen sie wieder von Neuem.

==while (während)==

 while (Bedingung) 
   mach etwas 
 end

Der Code zwischen der Bedingung und Ende (mach etwas), wird so lange ausgeführt, wie die Bedingung als wahr ausgewertet wird. Doch sollte die Bedingung als falsch ausgewertet warden, endet der loop und der Code nach dem „loop” wird ausgeführt. Wie beim „if statement“, brauchst du die Klammern nicht wirklich. 
until (bis) 

 until (Bedingung) 
   mach etwas 
 end

“Until“, also bis, führt den Code zwischen der Bedingung und dem Ende aus, bis die Bedingung wahr ist, oder während die Bedingung falsch ist. Dies ist das gegnteil, von während. 

==Ranges (Reichweiten)==
Ein „Range“ ist eine befohlene Abfolge von Objekten (Zahlen, strings, alles…), nicht im geringsten ein “loop”, obwohl sie dir helfen können diese zu verstehen, (was als nächstes besprochen wird) Ein „Range“, geschrieben als (0..3) enthält 4 Zahlen: 0, 1, 2 und 3. Die Reichweite, „Range“ ('A'..'D') enthält: A, B, C und D. Ein „Range“ ist nichts weiteres also eine Folge, die besagt(Beginn..Ende). Du kannst es auch als (start...end) schreiben(3 Punkte in dieser Version, 2 Punkte in früheren Beispielen), das zu machen wird ein 'end' aus dem Set ausschließen, zum Beispiel, 0...3 ienthält 0, 1 und 2. „Ranges“ können auch in Variablen gehortet werden. 

==for (für)==

 for varname in range/array 
   mach etwas 
 end 

Ruby’s „loop“ Variante unterscheidet sich von der in anderen Programmiersprachen. Es folgt einfach einer Folge (Range/Array) und die Variable nach dem for (varname) wird den Wert des Range/Array Elements halten. Beispiel: 

 for x in (0..10) 
   print x 
 end

Die Nummern 0 bis 10 werden dir damit angezeigt. Wie? Für „loops“ über den Elementen in der „Range“(0..10) also jedem loop x, wird einem Element zugeordnet (0, dann 1, dann 2, etc.), also zeigen wir einfach den Wert von x an. Würdest du etwas ähnliches mit „while“ schrieben wollen, wärde das so. 

 x = 0 
 while (x < 11) 
   print x 
   x += 1 
 end

Siehst du? Man braucht mehr Zielen um es so hinzukriegen. Du fragst dich bestimmt, was x += 1 bedeutet, Es ist nur ein anderer Weg x = x + 1 zu sagen. Du kannst ebenso x -= number, x *= number, x /= number, etc. sagen. 
Warum benutzen wir den nun „for“? Warum müssen wir mit jedem „loop“ ein Zahl erhöhen? Hauptsächlich werden „loops“ gebraucht um sich mit „arrays“ zu beschäftigen, Was im nächsten Tutorial besprochen wird. Ein “array” ist nur ein Name, der mehrere Werte enthält. Jeder Wert ist mit einer Nummer versehen, die wir Index nennen. Manchmal musst du auch alle Werte in einem „array“ anzeigen lassen oder verändern und du benutzt den „for loop“, oder eine „array methode“. Mehr darüber im nächsten Tutorial.

=0loop==

 loop do 
   mach etwas 
 end 

Der einfachste „loop“. Er überprüft keine Bedingung und läuft einfach munter drauf los. Natürlich ist ein ewiges loopen nicht gut, denn irgendwann will der Nutzer das Programm, Script, Spiel verlassen wollen. Der einzige Weg ist einen „loop“ zu brechen. 

==break, next, retry, redo==
Vielleicht willst du deine „loops“ manchmal kontrollieren und benutzt dazu break, next, retry oder/und redo für das. „Break” beendet den “loop” und die Ausführung folgt dem Code, direkt nach der Schleife. „Next” überspringt alles Folgende und beginnt eine neue iteration. Retry beginnt den „loop“ von Anfang an, redo wiederholt die gegenwärtige iteration vom Anfang. 

 # Die Ausgabe des folgenden loops wäre 0 1 2 3 4 5 
 # wir überprüfen ob x gleich 6 ist und beenden die Schleife 
 for x in (0..10) 
   if (x == 6) 
     break 
   end 
   p x 
 end 
 # Die Asugabe wäre: 0 1 2 3 4 6 7 8 9 10 
 # SBemerkst du, dass die 5 fehlt? .When x is 5, next 
 # wird alles nach dem if (also p x) überspringen und den nächsten „loop“ starten (6) 
 for x in (0..10) 
   if (x == 5) 
     next 
   end 
   p x 
 end

Retry und Redo. “Redo” wird sich immer zum Beginn des “loops” begeben, wenn dui m vorherigen Beispiel nach dem “if” ein “redo” anhängst, hieße die Ausgabe 0 1 2 3 4 und dann würdest du einen unendlichen „loop” erhalten (Weil es den print Befehl nie erreichen wird!) (p x) und würde if x == 5 wieder und wieder überprüfen. Retry verhält sich ähnlich dem redo, aber es begiebt sich zum begin des loops, anstatt der iteration. Ein „retry“ dem „if“ im vorherigen Beispiel hinzuzufügen, würde einen unendlichen „loop“ mit folgendem Auswurf bringen: 0 1 2 3 4 0 1 2 3 4 0 1 2 .... 

==Aussagen Modifizierer==
in den „break“ und „end“ Beispielen, hatten wir „if“ Aussagem, wie: 

 if (x == 6) 
   break 
 end

Du könntest es als nervig betrachten alles in unterschiedliche Zeilen zu packen, darum wäre das die Alternative: 

 break if (x == 6)

Dieses „if“ bezeichnet man als „If modifier“ und es wirkt, wie ein Operand in einer Zeile. Eigentlich kann man es auch einem Block anhängen, aber das ist eine andere Geschichte. Du kannst auch „unless“, „while“ und „until“ „modifier“ haben. 

 do something unless condition 
 do something while condition 
 do something until condition 

==Ergebnis==
Ich weiß diese Tutorial war langweilig, aber bedingte Uassagen und Schleifen zu verstehen ist für fortgeschrittene Themen unablässlich. Ich glaube es ist nicht schwer dem zu folgen, weil es logisch ist. Das nächste Tutorial wird dir arrays, hashes, methods und noch ein paar andere Dinge beibringen. 

==Zusammenfassung==
*Schleifen „loops“ führen ein Programm aus, bis eine Bedingung erfüllt wurde.

{{RGSS-Tut-Max}}