Aus STNE-Wiki

(Unterschied zwischen Versionen)

Version vom 15. Mai 2006, 13:47 Uhr

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

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.');

Declaration

Einfache Declaration

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

Var obj;

Declaration mit Startwert

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;

Rechenausdrücke

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

Einfache Addition

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);

Rechnen innerhalb eines Funktionsaufrufes

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));

Zufallszahl

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

WriteLine(Zufallszahl(100));

Arrays

Einfache Arrays

Arrays sind eine Ansammlung von Variablen. Arrays müssen immer deklariert werden, wie dies auch bei einfachen Variablen geschiet. Schreiben wir "String" sind es Texte, schreiben wir "Integer" sind es Zahlen und bei "MyShip" sind es Raumschiffe, die einem selber gehören.

Var names[] As String = {'Hans', 'John', 'Marc'};

WICHTIG! Es 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]);

Einfache ArrayListe

Die einfache ArrayListe ist den Arrays sehr ähnlich, nur muss hier kein Datentype angegeben werden. Außerdem kann die Liste auf einfache Weise durchgeblättert werden. Als 1. legen wir eine Liste an. Man beachte das Wörtchen "New" welches eine Speicherallokierung (Reservierung von Ram oder einfach Platz für unsere Daten) markiert.

Var List As New ArrayList();

Wir fügen nun die Werte 33, 66 und 99 in diese Liste ein. Es ist nicht notwendig eine Position anzugeben, die Daten werden einfach hintereinander eingeordnet. Sollte ein Datensatz gelöscht werden, rutschen alle nach ohne ein Loch zu hinterlassen.

List.Add(33);
List.Add(66);
List.Add(99);

WICHTIG! "ArrayList" beginnt auch bei 0 zu zählen, nicht bei 1! Demnach ist die 0. Zahl 33, die 1. Zahl 66 und die 2. Zahl 99. Das Ergebnis wird demnach 99 (die 3. Zahl) sein!

WriteLine(List.Item(2));

2-Dimensionale ArrayListe

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)) an, welches sich aber in Liste 2 befindet. Es ist eine 2-Dimensionale Liste, vorstellbar 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));

Wahrheitsbedingungen

Bei Wahrheitsbedingungen gibt es nur 2 mögliche Antworten. Ja oder Nein, ein "Vielleicht" u.ä. gibt es nicht. "False" bedeutet falsch, stimmt nicht. "True" bedeutet richtig, stimmt.

If (wenn)

If (wenn) "true" (wahr). DH: Er macht dies nur wenn es "wahr" ist, da hier aber keine Variable, die möcherweise true oder false sein kann, sondern gleich der Wert "True" steht, wird einfach gemacht was danach in Klammer steht.

if (true) {

   WriteLine('True-Block');

}

Else (wenn nicht)

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.

if (false)
{
WriteLine('True-Block. Es ist ein Fehler entstanden');
}
else
{
WriteLIne('Else-Block');
}

While

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);
}

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);
}

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);

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);
}

Exit - Das ende der Schleife

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;
}

Methoden

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 mit einer einprogrammierten Vorgehensweise, eine Blackbox die ein Ergebnis zurückgibt oder etwas ausführt. Wir können da etwas reinschreiben was wir von woanders auf einfache Weise verwenden wollen. "Sub MyMethode" Unsere Methode "MyMethode"... Sie aktzeptiert 2 Werte, "ByRef i As Integer" kurzgesagt eine Zahl welche dann, egal wie sie vorher geheißen hat, i heißt, die Ursprungszahl fühlt sich aber immernoch angesprochen (durch das "ByRef"), also ein Wolf im Schafspelz. "str As String" aktzeptiert zusätzlich beliebige Daten im Text-Format (String). Egal wie sie vorher geheißen haben, oder ob es eine Variable war, sie heißt dann string, allerings ist es nurnoch eine Copy, die Originaldaten werden nicht angefasst.

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 "str" mit dem Text "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 Anderungen 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);

Das wars erstmal mit Lektion 1, ich werde eine eigene Lektion 2 über Schiffe schreiben, sobald ich etwas Zeit dafür habe ;)

@@ Zeile 25: / Zeile 25: @@
 * Var i As Integer = 100;
 ==Rechenausdrücke==
@@ Zeile 50: / Zeile 51: @@
 * WriteLine(Zufallszahl(100));
 ==Arrays==

Scripting:TestSkript0.11