Scripting:TestSkript0.11

Aus STNE-Wiki

(Unterschied zwischen Versionen)
Wechseln zu: Navigation, Suche
K (TestScript 0.11)
K (Methoden)
 
(Der Versionsvergleich bezieht 16 dazwischenliegende Versionen mit ein.)
Zeile 1: Zeile 1:
 +
{{Scriptingmenue}}
 +
 +
=TestScript 0.11=
=TestScript 0.11=
-
/* Test-Script, welche alle Funktionalitäten grob durchteset
+
Test-Script, welche alle Funktionalitäten grob durchteset
-
* Lauffähig unter der STNE-Script-Engine 0.1 pre Alpha :P
+
Lauffähig unter der STNE-Script-Engine 0.1 pre Alpha :P
-
* Unter anderem sind hiermit schon mal Kommentare getestet...
+
Unter anderem sind hiermit schon mal Kommentare getestet...
-
* Original by Arakis
+
Original by Arakis
-
* Modifikationen und Erweiterungen by Proximo
+
Modifikationen und Erweiterungen by Proximo
-
*/
+
-
/* WriteLine ist der Befehl mit welchem Texte bzw Zahlen
+
==WriteLine==
-
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
+
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.
-
Verwendung deklariert. Dies ist notwendig um Werte zu speichern */
+
-
Var obj;
+
-
/* Noch eine Deklaration, allerdings wird hier ein Startwert
+
WriteLine('Testscript gestartet.');
-
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');
+
==Deklaration==
-
/* Zur 3 Zeilen darüber deklarierte Variable "i" (wir
+
===Einfache Deklaration===
-
erinnern uns, mit dem Wert 100) wird nun 10 addiert. Dass was
+
Hier wird auf einfache weise eine Variable für spätere Verwendung deklariert. Dies ist notwendig um Werte zu speichern
-
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
+
Var obj;
-
demonstriert indem wir zuerst einfach "i" ausgeben (110) */
+
-
WriteLine(i);
+
-
/* Innerhalb der Klammer kann auch beliebig rumgerechnet werden,
+
===Deklaration mit Startwert===
-
zu beachten ist lediglich dass bei Verwendungen von diesen
+
Noch eine Deklaration, allerdings wird hier ein Startwert mitgegeben. Integer bedeutet einfach ausgedrückt "Zahl", die zugewiesene Zahl ist 100.
-
"Operationen" keine "'" verwendet werden müssen, da dies
+
-
"Text" (in Programmierersprache String) markiert */
+
-
WriteLine(i * 2 + 5);
+
Var i As Integer = 100;
-
WriteLine((i * 2) + 5);
+
-
WriteLine(i * (2 + 5));
+
-
WriteLine('Teste geschachtelte Funktionsaufrufe');
 
-
/* "Zufallszahl(100)" generiert uns eine zufällige Zahl zwischen
+
==Rechenausdrücke==
-
0 und 100. Diese geben wir mit "WriteLine" direkt aus. */
+
-
WriteLine(Zufallszahl(100));
+
-
/* Jetzt wird es etwas komplizierter. Wir erstellen eine Liste
+
Hinweis: Punkt vor Strichrechnung wird noch nicht gemacht, sollte so etwas nötig sein, bitte Klammern verwenden!
-
aus Werten (Variablen) und sortieren diese einfach hintereinander. */
+
-
WriteLine('Objekterstellung');
+
===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.
-
/* Dazu legen wir als erstes die Liste an. Dies funktioniert sehr
+
i = i + 10
-
ä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');
+
WriteLine kann auch Variablen ausgeben. Dies wird hier demonstriert indem wir zuerst einfach "i" ausgeben (110)
-
/* Wir fügen nun die Werte 33, 66 und 99 in diese Liste ein. WICHTIG!
+
WriteLine(i);
-
"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.
+
===Rechnen innerhalb eines Funktionsaufrufes===
-
Das Ergebnis wird also 99 sein! */
+
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(List.Item(2));
+
-
WriteLine('Vewende Unterobjekte');
+
WriteLine(i * 2 + 5);
-
/* Hier legen wir eine 2. Liste in gleicher Weise wie oben an. */
+
WriteLine((i * 2) + 5);
-
Var List2 As New ArrayList();
+
WriteLine(i * (2 + 5));
-
/* Diesmal fügen wir als 0. Object einen Text (String) ein. Genauer:
+
===Zufallszahl===
-
"abc" */
+
"Zufallszahl(100)" generiert uns eine zufällige Zahl zwischen 0 und 100. Diese geben wir mit "WriteLine" direkt aus.
-
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');
+
WriteLine(Zufallszahl(100));
-
/* 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
+
==Arrays==
-
bei 1! 1 ist demnach bereits die 2. Variable in unserem Array... also
+
 
-
"John" */
+
===Einfache Arrays===
-
WriteLine(names[1]);
+
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".
-
/* 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]);
WriteLine(ar[3]);
-
/* Wahrheitsbedingungen. Ist es wahr dass ...
+
===Einfache ArrayListe===
-
Bei Wahrheitsbedingungen gibt es nur 2 mögliche Antworten. Ja oder Nein,
+
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.
-
ein "Vielleicht" gibt es nicht. "False" bedeutet falsch, stimmt nicht.
+
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.
-
"True" bedeutet richtig, stimmt. */
+
 
-
WriteLine('Teste If-Bedingung');
+
Var List As New ArrayList();
-
/* 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
+
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.
-
einfach gemacht was danach in Klammer steht. */
+
 
 +
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));
 +
===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)) an, welches sich aber in Liste 2 befindet. Es ist eine Liste in einer 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)
if (true)
{
{
Zeile 134: Zeile 127:
}
}
-
/* Hier machen wir das nun umgekehrt. Wir sagen es ist "false" also falsch.
+
===Else (wenn nicht)===
-
Tritt dieser Fall ein, sucht der Computer nach einem "else" (was soll ich
+
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.
-
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');
+
if (false)
 +
{
 +
  WriteLine('True-Block. Es ist ein Fehler entstanden');
 +
}
 +
else
 +
{
 +
  WriteLIne('Else-Block');
 +
}
-
/* Wir erinnern uns an unser "i". Es ist in diesem Moment noch "110", nun
+
===While===
-
werden wir dies ändern. i = 0... i wird 0. */
+
-
i = 0;
+
-
/* Eine sogenannte "Schleife". Sie bedeutet "Wärend i kleiner ist als 5,
+
====Nach-Increpmentierung====
-
führe das aus was danach in klammer steht UND füge zu "i" + 1 hinzu."
+
Wir erinnern uns an unser "i". Es ist in diesem Moment noch "110", nun werden wir dies ändern. i = 0... i wird 0.
-
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');
+
i = 0;
-
/* 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');
+
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.
-
/* Wieder wird i auf 0 gestellt. */
+
While (i++ < 5)
-
i = 0;
+
{
-
/* Dies ist auch eine "While" schleife, allerdings wird erst der Code in der
+
  WriteLine(i);
-
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');
+
====Vor-Increpmentierung====
-
/* Die "For" schleife bedeutet "Solange wie" und erwartet keinen "Wahrheitswert"
+
Wir stellen "i" wieder auf "0".
-
(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');
+
i = 0;
-
/* 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
+
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.
-
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)
+
While (++i < 5)
-
{
+
{
-
  WriteLine('In Call -> ' & str);    
+
   WriteLine(i);
-
  WriteLine(i);
+
}
-
  i = 5;
+
-
}
+
-
/* Nun verwenden wir unsere "Methode" indem wir eine Zahl (wir wissen, m ist 10
+
===Do-Schleife===
-
und ein Text mit "'" eingerahmt wird als "String" bezeichnet. Wie in der Methode
+
Wieder wird i auf 0 gestellt.
-
ersichtlich (oben) wird 'In Call -> ' (einfach der Text der da steht... "In Call ->"
+
i = 0;
-
und der übergebene String "Hallo" ausgegeben. Innerhalb von dieser Methode heißt
+
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.
-
"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
+
Do
-
geworden, da ja "i" 5 geworden ist. Unser Beweiß dass i = m ist, auch wenn sie
+
{
-
unterschiedlich heißen. */
+
  WriteLine(i);
-
WriteLine(m);  
+
}
 +
While (i++ < 5);
-
WriteLine('Teste Exit');
+
===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.
-
/* Hier wird noch der Befehl "exit" präsentiert. Diese Schleife ist "true", das
+
For (i=10 To 5 Step -1)
-
bedeutet sie ist immer wahr und wird immer, bis in alle Ewigkeit, wiederholt. Um
+
{
-
sie zu unterbrechen, und trotzdem rauszuspringen, verwenden wir den Befehl
+
  WriteLine(i);
-
"exit" der programmbedingt in einem beliebigen Moment ausgelöst werden kann um die
+
}
-
Schleife zu verlassen. */
+
 
 +
===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)
+
while (true)
-
{
+
{
-
  exit while;
+
  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? ;)');
+
==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.
 +
 
 +
function 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 ;)
 +
 
 +
 
 +
[[Kategorie:Scripte|Testscript 0.11]]
 +
[[Kategorie:Scripting-Hilfe|Testscript 0.11]]

Aktuelle Version vom 4. September 2006, 11:03 Uhr

fertige Scripte | Anleitungen und FAQ | Überblick über die Scripting-Sektion | Hilfen zum Arbeiten im Wiki


Inhaltsverzeichnis

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


Deklaration

Einfache Deklaration

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

Var obj;

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

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

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

Persönliche Werkzeuge