Aus STNE-Wiki

TestScript 0.11

/* Test-Script, welche alle Funktionalitäten grob durchteset

• Lauffähig unter der STNE-Script-Engine 0.1 pre Alpha :P
• Unter anderem sind hiermit schon mal Kommentare getestet...
• Original by Arakis
• Modifikationen und Erweiterungen by Proximo
• /

/* WriteLine ist der Befehl mit welchem Texte bzw Zahlen ausgegeben werden können. Hier sehen wir die einfache Methode bei der einfach ein Text reingeschrieben wird. */ WriteLine('Testscript gestartet.'); WriteLine('Teste Declaration');

/* Hier wird auf einfache weise eine Variable für spätere Verwendung deklariert. Dies ist notwendig um Werte zu speichern */ Var obj;

/* Noch eine Deklaration, allerdings wird hier ein Startwert mitgegeben. Integer bedeutet einfach ausgedrückt "Zahl", die zugewiesene Zahl ist 100. */ Var i As Integer = 100;

/* Hinweis: Punkt vor Strichrechnung wird noch nicht gemacht, sollte so etwas nötig sein, bitte Klammern verwenden! */

WriteLine('Teste Rechenausdrücke');

/* Zur 3 Zeilen darüber deklarierte Variable "i" (wir erinnern uns, mit dem Wert 100) wird nun 10 addiert. Dass was vor dieser Rechnung steht (i =), ist die Variable in welche das neue Ergebnis (110) gespeichert wird. Da sie ebenfalls "i" ist, wird i von 100 auf 110 geändert. */ i = i + 10

/* WriteLine kann auch Variablen ausgeben. Dies wird hier demonstriert indem wir zuerst einfach "i" ausgeben (110) */ WriteLine(i);

/* Innerhalb der Klammer kann auch beliebig rumgerechnet werden, zu beachten ist lediglich dass bei Verwendungen von diesen "Operationen" keine "'" verwendet werden müssen, da dies "Text" (in Programmierersprache String) markiert */

WriteLine(i * 2 + 5); WriteLine((i * 2) + 5); WriteLine(i * (2 + 5));

WriteLine('Teste geschachtelte Funktionsaufrufe');

/* "Zufallszahl(100)" generiert uns eine zufällige Zahl zwischen 0 und 100. Diese geben wir mit "WriteLine" direkt aus. */ WriteLine(Zufallszahl(100));

/* Jetzt wird es etwas komplizierter. Wir erstellen eine Liste aus Werten (Variablen) und sortieren diese einfach hintereinander. */

WriteLine('Objekterstellung');

/* Dazu legen wir als erstes die Liste an. Dies funktioniert sehr ähnlich wie das anlegen einer Variablen, allerdings beachte man das Wörtchen "New" welches eine Speicherallokierung (Reservierung von Ram oder einfach Platz für unsere Daten) markiert. */ Var List As New ArrayList();

WriteLine('Verwende Objekt');

/* Wir fügen nun die Werte 33, 66 und 99 in diese Liste ein. WICHTIG! "ArrayList" beginnt bei 0 zu zählen, nicht bei 1! Demnach ist die 0. Zahl 33, die 1. Zahl 66 und die 2. Zahl 99. */ List.Add(33); List.Add(66); List.Add(99);

/* Hier geben wir die 2. Zahl (von 0 aus gezählt also die 3. Zahl) aus. Das Ergebnis wird also 99 sein! */ WriteLine(List.Item(2));

WriteLine('Vewende Unterobjekte'); /* Hier legen wir eine 2. Liste in gleicher Weise wie oben an. */ Var List2 As New ArrayList();

/* Diesmal fügen wir als 0. Object einen Text (String) ein. Genauer: "abc" */ List2.Add('abc'); /* In diesem Fall fügen wir die ganze "Liste2" IN Liste1 ein, und zwar an der 0. Stelle. Sprich, eine Liste in einer Liste. */ List.Insert(0, List2) /* Wir sprechen nun das 0. Object (List.Item(0)) welches sich aber in Liste 2 befindet. Man nennt dies auch "2-dimensionales-Array". Vorstellen kann man sich dies als Tabelle welche sowohl Zeilen als auch Spalten hat. Liste ist eine Spalte und Liste2 eine Zeile davon wie in Exel. Liste.Item(0).Item(0) ist also Liste2.item(0) in Liste.item(0). Im Exel "A1". "B1" wäre also Liste.Item(0).item(1). */ WriteLine(List.Item(0).Item(0));

WriteLine('Teste Arrays');

/* Einfache Arrays sind ähnlich wie ArrayListen. Um die Verwendung zu erleichtern, stellen wir uns einfach vor, dass wir hier im Vorhinnein definieren welcher Art unsere Daten sind. Schreiben wir "String" sind es Texte, schreiben wir "Integer" sind es Zahlen und bei "MyShip" sind es Raumschiffe. */ Var names[] As String = {'Hans', 'John', 'Marc'};

/* Weiterhin ist zu beachten, dass wir bei 0 anfangen zu zählen, nicht bei 1! 1 ist demnach bereits die 2. Variable in unserem Array... also "John" */ WriteLine(names[1]);

/* Hier legen wir, wie schon oben, ein Array an, man beachte aber die Zahl zwischen den eckigen Klammern "10". Sie beschreibt dass wir gleich 10 leere (ACHTUNG! Nicht 11, hier wird nicht von 0 weg gezählt!) Variablen vom Type "Integer" (Zahlen) anlegen. */ Var ar[10] As Integer; /* Der 4. Variablen in diesem Array weisen wir nun "77" zu. */ ar[3] = 77; /* Dann geben wir "ar[3]" (Variable 4 vom Array "ar") wieder aus. Das Ergebnis ist natürlich "77". */ WriteLine(ar[3]);

/* Wahrheitsbedingungen. Ist es wahr dass ... Bei Wahrheitsbedingungen gibt es nur 2 mögliche Antworten. Ja oder Nein, ein "Vielleicht" gibt es nicht. "False" bedeutet falsch, stimmt nicht. "True" bedeutet richtig, stimmt. */ WriteLine('Teste If-Bedingung'); /* If (wenn) "true" (wahr). DH: Er macht dies nur wenn es "wahr" ist, da hier aber keine Variable, sondern gleich der Wert "True" steht, wird dies einfach gemacht was danach in Klammer steht. */ if (true) {

   WriteLine('True-Block');

}

/* Hier machen wir das nun umgekehrt. Wir sagen es ist "false" also falsch. Tritt dieser Fall ein, sucht der Computer nach einem "else" (was soll ich bitteschön machen wenn es nicht wahr ist?!). Das was dort zwischen den geschwungenen Klammern steht, wird gemacht, sollte es nicht wahr sein. */ WriteLine('Teste Else-Bedingung'); if (false) {

   WriteLine('True-Block. Es ist ein Fehler entstanden');

} else {

 WriteLIne('Else-Block');

}

WriteLine('Teste While und Nach-Increpmentierung');

/* Wir erinnern uns an unser "i". Es ist in diesem Moment noch "110", nun werden wir dies ändern. i = 0... i wird 0. */ i = 0;

/* Eine sogenannte "Schleife". Sie bedeutet "Wärend i kleiner ist als 5, führe das aus was danach in klammer steht UND füge zu "i" + 1 hinzu." i++ bedeutet "i + 1, aber erst nachdem diese Bedingung erfüllt ist (i < 5). Die 1. Schleife wär also: 0 < 5... das stimmt... es ist "true" (wahr). Jetzt rechnet der Computer noch 1 hinzu und bei "WriteLine(i);" kommt also "1" raus */ While (i++ < 5) {

   WriteLine(i);

}

WriteLine('Teste While-Schleife und Vor-Increpmentierung'); /* Wir stellen "i" wieder auf "0". */ i = 0; /* Nun machen wir das gleiche wie vorher, allerdings zählen wir zu "i" 1 hinzu BEVOR die Wahrheit der Aussage überprüft wird. Die 1. Überprüfung wird also folgende sein "1 < 5". Ist 1 wirklich kleiner wie 5? Ja. allerdings wird diese schleife hier nur 4 mal ausgeführt werden, die obere 5 mal. Sollte diese Aussage niemals zutreffen (zb i++ < 0) wird aber zu "i" trotzdem 1 hinzugezählt werden. */ While (++i < 5) {

   WriteLine(i);

}

WriteLine('Teste Do-Schleife');

/* Wieder wird i auf 0 gestellt. */ i = 0; /* Dies ist auch eine "While" schleife, allerdings wird erst der Code in der Schleife ausgeführt, und dann erst überprüft ob sie nochmal ausgeführt werden soll. Es wird also gemacht, egal ob die "While-Bedingung" wahr ist oder nicht, nur möglicherweise wird die Schleife danach noch öfter ausgeführt. */ Do {

   WriteLine(i);

} While (i++ < 5);

WriteLine('Teste For-Schleife'); /* Die "For" schleife bedeutet "Solange wie" und erwartet keinen "Wahrheitswert" (true oder false) sondern alles so, wie es hier da steht. Eine Variable (i zb) dann das "To" (zählen bis) 5 "Step" (in Schritten von) -1. Also die 1. Ausführung wird "10 - 1" lauten, und die Schleife ausführen. Sobald diese 5 mal ausgeführt worden ist, wird "i" den Wert 5 erreichen. Dann wird die Schleife übersprungen. */ For (i=10 To 5 Step -1) {

   WriteLine(i);

}

WriteLine('Teste Funktionen'); /* Wir legen wiedermal eine Variable an. Sie heißt "m" (frei wählbar, kann auch "butterkuchen" heißen), ist ein "Integer" (eine Zahl) und hat den Wert 10 */ Var m As Integer = 10;

/* Eine "Methode" beschreibt, wie etwas gemacht wird. Eine Art Modul oder Vorgehensweise. Wir können da etwas reinschreiben was wir von woandeers auf einfache Weise verwenden wollen. "Sub MyMethode" Unsere Methode "MyMethode"... Sie aktzeptiert 2 Werte, "ByRef i As Integer" kurzgesagt eine Zahl, "str As String" und einen Text. */

Sub MyMethod (ByRef i As Integer, str As String) {

 WriteLine('In Call -> ' & str);    
 WriteLine(i);
 i = 5;

}

/* Nun verwenden wir unsere "Methode" indem wir eine Zahl (wir wissen, m ist 10 und ein Text mit "'" eingerahmt wird als "String" bezeichnet. Wie in der Methode ersichtlich (oben) wird 'In Call -> ' (einfach der Text der da steht... "In Call ->" und der übergebene String "Hallo" ausgegeben. Innerhalb von dieser Methode heißt "m" ganz einfach "i" (haben wir bestimmt als wir "ByRef i As Integer" geschrieben haben). Trotzdem wirken sich änderungen auf "i" auch auf "m" aus (bitte drüber nachdenken und nochmal von oben durchlesen, da möglicherweise etwas kompliziert. Dies wird durch einen "Zeiger" in den Speicher ermöglicht (für unsere Programmierer die sich das tatsächlich durchlesen). MyMethod(m, 'Hallo');

/* Nun geben wir "m" einfach aus, und wir stellen erstaunt fest, "m" ist 5 geworden, da ja "i" 5 geworden ist. Unser Beweiß dass i = m ist, auch wenn sie unterschiedlich heißen. */ WriteLine(m);

WriteLine('Teste Exit');

/* Hier wird noch der Befehl "exit" präsentiert. Diese Schleife ist "true", das bedeutet sie ist immer wahr und wird immer, bis in alle Ewigkeit, wiederholt. Um sie zu unterbrechen, und trotzdem rauszuspringen, verwenden wir den Befehl "exit" der programmbedingt in einem beliebigen Moment ausgelöst werden kann um die Schleife zu verlassen. */

while (true) {

 exit while;

} /* Das wars erstmal mit Lektion 1, ich werde eine eigene Lektion 2 über Schiffe schreiben, sobald ich etwas Zeit dafür habe ;) */ WriteLine('Test abgeschlossen. Gar nicht mal so schlecht für den Anfang, ne? ;)');