In diesem Kurs lernen Sie, wie Sie einfache Skripte für Planet schreiben.
In jedes 3D-Objekt können Sie Skripte einfügen, die ausgeführt werden und das Objekt zum Leben erwecken.
Um ein Skript zu erstellen :
// mein erstes Skript
event start ()
{
say ("Salut les amis !");
say ("Comment allez-vous ?");
}
Klicken Sie auf die Taste "Übernehmen": Das Skript wird kompiliert, dann ausgeführt und zeigt im Fenster Konversation Folgendes an :
Salut les amis ! Comment allez-vous ?
So, jetzt haben Sie Ihr erstes Skript geschrieben!
Betrachten wir nun dieses erste Programm im Detail.
// mon premier script
Die erste Zeile beginnt mit dem Zeichen //, das einen Kommentar kennzeichnet. Sie wird daher ignoriert.
event start ()
Die zweite Zeile ist ein Auslöser.
Event bedeutet Ereignis, wenn also etwas passiert, wacht das Skript auf und es führt die Zeilen in den geschweiften Klammern aus. Das Ereignis start wird automatisch ausgelöst, wenn das Skript startet.
{
say ("Salut les amis !");
say ("Comment allez-vous ?");
}
Die geschweiften Klammern { } umschließen eine Folge von Anweisungen, die ausgeführt werden sollen. Die Anweisung say() dient dazu, einen Text in der Chatanzeige anzuzeigen. Jede Anweisung muss mit einem Semikolon (;) enden.
say ist eigentlich eine Funktion. Um sie auszuführen, gibt man einfach ihren Namen (hier say) und eventuelle Argumente in Klammern an (hier "Salut les amis !"). Wenn es keine Argumente gibt, fügt man einfach ein Paar leere Klammern () hinzu.
Während der Kompilierung des Skripts wird es vollständig überprüft und kontrolliert, wobei Syntaxfehler auftreten können.
Wenn Sie zum Beispiel die abschließende geschweifte Klammer } am Ende vergessen hätten,
hätten Sie ganz unten eine Fehlermeldung bekommen
die Ihnen genau sagt, wo das Problem liegt :
line 5 col 1 : syntax error : '}' expected here
Gehen Sie dann einfach zu Zeile 5 Spalte 1 in Ihrem Skript, korrigieren Sie den Text und klicken Sie erneut auf "Anwenden".
Um Syntaxfehler zu vermeiden und auch das Lesen zu erleichtern, ist es wichtig, einen klaren Schreibstil zu haben.
Beispiel :
// mein zweites Skript
event start ()
{
string(32) s;
int i;
s = "";
for (i=0; i<16; i++)
{
s = s + chr(0,i);
}
say ("icons : " + s);
}
Sie sehen im obigen Beispiel, dass die Zeilen zwischen den geschweiften Klammern { } jedes Mal um zwei Leerzeichen nach rechts verschoben sind. Außerdem befindet sich eine geschweifte Klammer { immer senkrecht über einer geschweiften Klammer }. Diese Angewohnheit sollten Sie sich unbedingt angewöhnen, denn sie verhindert, dass Sie geschweifte Klammern vergessen!
Das folgende Skript funktioniert auch, ist aber absolut nicht empfehlenswert, weil man nichts mehr versteht!
Beispiel :
// mein 3. Skript (nicht zu empfehlen)
event start ()
{
string(32) s;
int i;
s = "";
for (i=0; i<16; i++)
{
s = s + chr(0,i);
}
say ("icons : " + s);
}
Wenn Sie ein Skript in einer Gruppe oder einem Forum veröffentlichen, ändern Sie die Schriftart in "Courier New", da bei dieser Schriftart
bleiben die Verschiebungen erhalten.
Scheuen Sie sich nicht, zur Verdeutlichung eines Skripts jede Menge Kommentarzeilen an beliebiger Stelle in Ihr Skript einzufügen.
Dazu muss man eine Zeile nur mit // beginnen.
Diese Zeilen werden bei der Kompilierung ignoriert.
Beispiel:
// hier ist mein erstes Skript
// das ich erstellt habe,
// um ein wenig meinen Raum zu gestalten.
// Copyright der Scripter
event start ()
{
// der Befehl say wird einen Text auf dem Chat anzeigen!
say ("Salut les amis !");
}
Eine Variable ist eine Zelle im RAM-Speicher des PCs, der ein Name gegeben wird.
Jede numerische Variable enthält einen Wert zwischen -2147483648 und +2147483647 (etwas mehr als 2 Milliarden).
Dieser Wert ändert sich in der Regel während des Programmablaufs.
Um eine numerische Variable zu erstellen, müssen Sie sie 'deklarieren', d. h. Sie müssen den Speicherplatz für ihren Inhalt reservieren, und zwar mithilfe einer 'int'-Deklaration.
int compteur; // ich erstelle meinen Zähler
Um einen Wert in eine Variable zu setzen, schreibt man eine 'Zuweisung', die so aussieht:
compteur = 2; // jetzt hat compteur den Wert 2
Um den Wert einer Variablen zu ändern, geben Sie ihr einfach einen neuen Wert :
compteur = 5; // jetzt hat compteur den Wert 5
Man kann auch Berechnungen durchführen.
Im folgenden Beispiel sehen wir in jeder Zeile:
. links vom = Zeichen die Variable, in der das Ergebnis der Berechnung gespeichert wird,
. rechts vom = Zeichen eine Formel für den zu berechnenden Wert.
compteur = 2 + 5 * 7; // jetzt hat compteur den Wert 37 compteur = 5 / 2; // jetzt hat compteur den Wert 2 compteur = -45; // jetzt hat compteur den Wert -45 compteur = 100 - 101; // jetzt hat compteur den Wert -1
Sie haben wahrscheinlich schon erraten, dass das Sternchen zum Multiplizieren verwendet wird. Hier ist eine Liste der häufig verwendeten Symbole : (auswendig lernen!)
Operation Symbol
--------------------- -------
Addition +
Subtraktion -
Multiplikation *
Division /
Rest der Division %
Wenn Sie gut aufgepasst haben, waren Sie vielleicht auch erstaunt, dass das vorherige Beispiel als Ergebnis 37 und nicht 49 hat.
compteur = 2 + 5 * 7; // jetzt hat compteur den Wert 37
Der Grund dafür ist, dass wie in der Mathematik zuerst Multiplikationen und Divisionen durchgeführt werden, während Additionen und Subtraktionen erst danach folgen. Wenn Sie sich über die Priorität der Operationen nicht sicher sind, können Sie Klammern einfügen um die Reihenfolge der Berechnungen zu erzwingen, z. B. so:
compteur = (2 + 5) * 7; // jetzt hat compteur den Wert 49
Ebenso hat Sie das vorherige Beispiel wohl verwirrt.
compteur = 5 / 2; // jetzt hat compteur den Wert 2
Tatsächlich ist das Ergebnis von 5 geteilt durch 2 2. Wir ignorieren den gebrochenen Teil, weil Zähler vom Typ 'int' ist und daher nur ganze Zahlen speichern kann.
Wir möchten noch auf die "shift"-Operatoren hinweisen:
compteur = 3 << 3; // jetzt hat compteur den Wert 24 compteur = 35 >> 1; // jetzt hat compteur den Wert 17
Die Operatoren << und >> multiplizieren oder dividieren mit einer Potenz von 2.
So entspricht (a << b) in der Mathematik a . ( 2 b )
und (a >> b) ist äquivalent zu a / ( 2 b )
So erhöhen Sie den Wert einer Variablen um 1 :
compteur = compteur + 1; // berechnet compteur + 1 und speichert das Ergebnis in compteur
Es gibt jedoch eine abgekürzte Art, das Gleiche zu tun, die Inkrementierung :
compteur++; // erhöht compteur um 1
Auf die gleiche Weise wird eine Variable um 1 verringert, indem man eine Dekrementierung durchführt.
compteur--; // verringert compteur um 1
So erhöhen Sie den Wert einer Variablen um 10 :
compteur = compteur + 10; // berechnet compteur + 10 und speichert das Ergebnis in compteur
Es gibt jedoch eine abgekürzte Art, das Gleiche zu tun, nämlich die Zuweisung mit Addition :
compteur += 10; // erhöht compteur um 10
Auf die gleiche Weise, um eine Variable um 10 zu verringern :
compteur -= 10; // verringert compteur um 10
Um eine Variable mit 3 zu multiplizieren :
compteur *= 3; // multipliziere compteur mit 3
Es gibt eine Operation, die das Skript mit einem Fehler abbricht, nämlich durch Null zu teilen, das ist verboten!
compteur = 3 / 0; // Fehler compteur = 3 % 0; // Fehler
Nachdem wir uns im vorherigen Kapitel mit dem Typ 'int' beschäftigt haben, wollen wir uns nun den Typ 'float' ansehen. der zum Speichern von gebrochenen numerischen Variablen verwendet wird.
Beispiel:
float f; f = 15.2476; f = 67.762 + 87.126; f *= 1.2;
Sie werden feststellen, dass beim Typ 'float' die Werte immer einen obligatorischen Punkt haben, auch wenn es keine Nachkommastellen gibt. Um beispielsweise den Wert 12 anzugeben, müssen Sie 12.0 schreiben.
Eine Variable vom Typ 'float' kann sehr große Zahlen speichern, bis zu 38 Stellen. Trotzdem nimmt sie im RAM denselben Platz ein wie eine Variable vom Typ 'int'. Wie ist das möglich?
Tatsächlich speichert eine 'Float'-Variable nur die 6 oder 7 signifikantesten Ziffern des Wertes sowie einen Exponenten, der angibt, wie viele Nullen hinzugefügt werden müssen.
f = 3.12345678901234567890; // wird gespeichert als 3.12345600000000000 f = 3.12e8; // f gilt für 3.12 x 10_exponent_8, also 31200000.0 f = 0.5; // f gilt für ein halb f = 5.0e-1; // f gilt auch für ein halb
Auf Planet wird der Typ 'float' häufig verwendet, um Entfernungen in Metern, Drehwinkel, oder Zeiten in Sekunden zu speichern.
Der Typ 'float' erlaubt folgende Operationen:
Operation Symbol
--------------------- -------
Addition +
Subtraktion -
Multiplikation *
Division /
Darüber hinaus stehen folgende Funktionen zur Verfügung:
float fabs (float value); // absoluter Wert float sin (float angle); // sin, mit Winkel in Grad float cos (float angle); // cos, mit Winkel in Grad float atan2 (float y, float x); // arc tangeante, berechnet einen Winkel in Grad float sqrt (float angle); // Quadratwurzel float trunc (float angle); // entfernt den gebrochenen Teil durch Kürzen float round (float angle); // entfernt den Bruchteil durch Abrunden string ftos (float value, int width=0, int decimals = 3); // wandelt eine Float in eine String um
Beispiel:
event start()
{
float n = sin(34.0);
say ("sin(34) = " + ftos(n));
}
// was Folgendes anzeigt : sin(34) = 0.55919
Es gibt noch eine dritte Art von Variablen: Stringvariablen, im Englischen als 'string' bezeichnet.
Diese enthalten keine Zahlen, sondern Zeichenketten. (Buchstaben, Zahlen, Satzzeichen usw ..).
Beispiel:
string(100) nom; // ich erstelle eine String-Variable mit maximal 100 Zeichen
Um den Wert einer String-Variablen zu ändern, führt man eine 'Zuweisung' durch, die folgendermaßen aussieht:
nom = "Bonjour"; // jetzt hat nom den Wert "Bonjour"
Beachten Sie, dass der Wert in Anführungszeichen gesetzt ist.
Um den Wert der Variable zu ändern, geben Sie ihr einfach einen neuen Wert :
nom = "Bonsoir"; // jetzt hat nom den Wert "Bonsoir"
Man kann mehrere Strings mit dem Operator "+" zusammenfügen.
nom = "Bon" + "soir"; // jetzt hat nom den Wert "Bonsoir" nom = nom + " mes amis"; // jetzt hat nom den Wert "Bonsoir mes amis"
Achtung: Die Länge einer String-Variablen darf 1024 Zeichen nicht überschreiten.
Um eine String-Variable zu löschen, können Sie ihr einen leeren String zuweisen.
nom = ""; // jetzt ist nom leer
Le type 'string' permet les opérations suivantes :
int len (string value); // berechnet die Länge der Zeichenkette string chr (int c1, int c2, int c3, ..., int c16); // wandelt Ascii-Codes in Strings um int asc (string value, int index=1); // wandelt das n-te Zeichen des Strings in Ascii-Code um string left (string value, int count); // die ersten N Zeichen nehmen string right (string value, int count); // die letzten N Zeichen nehmen string mid (string value, int index, int count=); // die N Zeichen nehmen, die mit dem i-ten Zeichen beginnen int pos (string phrase, string word); // findet die Position eines Strings in einem anderen string dup (string value, int count); // einen String N-mal duplizieren string upper (string value); // entfernt Akzente und wandelt in Großbuchstaben um string lower (string value); // entfernt Akzente und wandelt in Kleinbuchstaben um string trim (string value); // entfernt die Leerzeichen davor und danach string ltrim (string value); // entfernt die Leerzeichen davor string rtrim (string value); // entfernt die Leerzeichen danach
Man kann eine numerische Variable in eine Stringvariable umwandeln, mit der Funktion itos(). Dieser Name bedeutet eigentlich i zu s, also int zu string.
Beispiel:
int compteur; string(32) nom; compteur = 12; nom = itos(compteur); // jetzt hat nom den Wert "12" nom = "compteur = " + itos(compteur); // jetzt hat nom den Wert "compteur = 12"
Umgekehrt kann man eine Stringvariable mithilfe der Funktion stoi() in eine numerische Variable umwandeln.
int compteur;
string(32) nom;
nom = "12";
compteur = stoi (nom); // jetzt hat nom den Wert 12
compteur = stoi ("13"); // jetzt hat nom den Wert 13
compteur = stoi ("ab"); // dies wird einen Fehler ergeben, der das Skript stoppt,
// da "ab" nicht in einen numerischen Wert umgewandelt werden kann!
Die Anzeige im Konversationsfenster erfolgt mithilfe der Prozedur say()
Beispiel:
say ("Bonjour !");
say (nom);
Es ist nicht erlaubt, say() eine numerische Variable zu geben, z. B. wird dies nicht funktionieren:
say (compteur); // fehler
Um den Wert eines Zählers anzuzeigen, müssen Sie ihn zunächst in eine Zeichenkette umwandeln :
say (itos(compteur));
Man kann dies kombinieren, indem man mehrere Strings zusammenfügt:
say ("la valeur de compteur égale " + itos(compteur));
Mit Bedingungen werden Variablen "getestet".
Wir können per Beispiel sagen: "Wenn die Variable gleich 50 ist, mach dies...".
Aber es wäre doch schade, wenn Sie nur die Gleichheit testen könnten!
Es sollte auch möglich sein, zu testen, ob die Variable kleiner als 50 ist, kleiner oder gleich 50, größer oder gleich ist.
Keine Sorge, die Skriptsprache hat alles im Griff (aber das haben Sie ja nicht bezweifelt, oder?)
Bevor wir uns ansehen, wie man eine Bedingung vom Typ "if... else" schreibt, müssen Sie daher 2-3 grundlegende Symbole kennen. Diese Symbole sind für die Realisierung von Bedingungen unerlässlich.
Hier ist eine kleine Tabelle mit Symbolen, die Sie auswendig kennen sollten:
Symbol Bedeutung
======= =============
== Ist gleich
> Ist größer als
< Ist kleiner als
>= Ist größer oder gleich
<= Ist kleiner oder gleich
!= Ist verschieden von
Seien Sie sehr aufmerksam, denn es gibt zwei "=="-Symbole, um die Gleichheit zu testen. Ein häufiger Fehler, den Anfänger machen, ist, nur ein "="-Symbol zu verwenden. Ich werde dies weiter unten noch einmal erläutern.
Greifen wir nun ohne weitere Verzögerung an. Wir werden einen einfachen Test durchführen, der dem Computer sagt:
WENN die Variable so lautet DANN tue dies
Wir könnten zum Beispiel eine Variable "age" testen, die Ihr Alter enthält. Hier zum Üben: Wir testen, ob Sie volljährig sind, d. h. ob Ihr Alter größer oder gleich 18 ist:
Beispiel:
if (age >= 18)
{
say ("Sie sind volljährig!");
}
Das Symbol >= steht für "Größer oder gleich", wie wir vorhin in der Tabelle gesehen haben.
Wenn zwischen den geschweiften Klammern nur eine Anweisung steht,
dann werden die geschweiften Klammern optional.
Sie können also schreiben:
if (age >= 18)
say ("Sie sind volljährig!");
Wenn Sie die vorherigen Codes testen wollen, um zu sehen, wie das if funktioniert, müssen Sie das if innerhalb eines start-Ereignisses platzieren und nicht vergessen, eine Variable age zu deklarieren, der Sie einen beliebigen Wert geben.
Das mag für manche offensichtlich sein, aber anscheinend nicht für alle, also habe ich dieses Beispiel hinzugefügt :
// Beispiel:
event start ()
{
int age;
age = 20;
if (age >= 18)
say ("Sie sind volljährig!");
}
Hier hat die Variable age den Wert 20, also wird "Sie sind volljährig!" angezeigt.
Versuchen Sie, den Anfangswert der Variable zu ändern, um zu sehen, was passiert. Setzen Sie z. B. 15: Die Bedingung wird falsch sein und daher wird "Sie sind volljährig!" diesmal nicht angezeigt.
Verwenden Sie diesen Basiscode, um die nächsten Beispiele des Kapitels zu testen.
Es ist nicht wichtig, wie Sie die geschweiften Klammern setzen, Ihr Programm wird genauso gut funktionieren, wenn Sie alles in eine Zeile schreiben.
Zum Beispiel :
if (age >= 18) { say ("Sie sind volljährig!"); }
Auch wenn es möglich ist, so zu schreiben, ist davon abzuraten! Wenn Sie alles in eine Zeile schreiben, wird Ihr Code schwer lesbar.
Wenn Sie sich nicht schon jetzt angewöhnen, Ihren Code zu lüften, werden Sie sich später, wenn Sie größere Programme schreiben, nicht mehr zurechtfinden!
Versuchen Sie doch einmal, Ihren Quellcode so zu präsentieren, wie ich es tue: eine geschweifte Klammer in einer Zeile, dann Ihre Anweisungen (mit zwei vorangestellten Leerzeichen, um sie "nach rechts zu verschieben"), dann die schließende geschweifte Klammer in einer Zeile.
Es gibt viele gute Möglichkeiten, seinen Quellcode zu präsentieren.
Das ändert nichts an der Funktionsweise des endgültigen Programms, aber es ist eine Frage des "Computerstils", wenn Sie so wollen. Wenn Sie einen Code von jemand anderem sehen, der etwas anders dargestellt wird, dann codiert er in einem anderen Stil.
Die Hauptsache ist, dass ihr Code übersichtlich und lesbar bleibt.
Da wir nun wissen, wie man einen einfachen Test durchführt, gehen wir einen Schritt weiter: Wenn der Test nicht funktioniert hat (er ist falsch), werden wir dem Computer sagen, dass er weitere Anweisungen ausführen soll.
Auf Deutsch schreiben wir also etwas, das wie folgt aussieht:
WENN die Variable so lautet DANN tue dies SONST mache das
Fügen Sie einfach das Wort else nach der schließenden Klammer von if hinzu.
Kleines Beispiel :
if (age >= 18) // Wenn das Alter 18 oder höher ist
{
say ("Sie sind volljährig!");
}
else // Sonst...
{
say ("Sie sind minderjährig!");
}
Die Dinge sind recht einfach: Wenn die Variable age größer oder gleich 18 ist, wird die Meldung "Sie sind volljährig!" angezeigt, andernfalls "Sie sind minderjährig".
Wir haben gesehen, wie man ein "wenn" und ein "sonst" bildet. Es ist auch möglich, ein "sonst wenn" zu bilden.
Wir sagen in diesem Fall zum Computer:
WENN die Variable so lautet DANN tue dies SONST WENN die Variable so lautet DANN tu dies SONST mache das
Übersetzung:
if (age >= 18) // Wenn das Alter 18 oder höher ist
{
say ("Sie sind volljährig!");
}
else if (age > 4) // Ansonsten, wenn das Alter mindestens 4 ist
{
say ("Du bist aber nicht zu jung....");
}
else // sonst...
{
say ("Aga gaa aga gaaa gaaa"); // Babysprache, Sie können es nicht verstehen ;o)
}
Der Computer führt die Tests in der Reihenfolge :
Zunächst testet er das erste if: Wenn die Bedingung wahr ist, dann führt er das aus, was zwischen den ersten geschweiften Klammern steht.
Andernfalls geht er zum "else if" und führt erneut einen Test durch: Wenn dieser Test wahr ist, dann führt er die entsprechenden Anweisungen zwischen den geschweiften Klammern aus.
Schließlich, wenn keiner der vorherigen Tests funktioniert hat, führt er die Anweisungen im "else" aus.
Das "else" und das "else if" sind nicht zwingend erforderlich. Um eine Bedingung zu machen, braucht man nur mindestens ein "if" (logisch, werden Sie sagen, sonst gibt es keine Bedingung!).
Beachten Sie, dass man so viele "else if" einfügen kann, wie man will. Wir können also schreiben:
WENN die Variable so lautet DANN tue dies SONST WENN die Variable so lautet DANN tu dies SONST WENN die Variable so lautet DANN tu dies SONST WENN die Variable so lautet DANN tu dies SONST mache das
Es kann auch sinnvoll sein, in Ihrer if mehrere Tests auf einmal durchzuführen.
Beispielsweise möchten Sie testen, ob das Alter größer als 18 UND das Alter kleiner als 25 ist.
Um dies zu tun, müssen Sie neue Symbole verwenden:
Symbol Bedeutung
======= =============
&& UND
|| ODER
! NICHT
Wenn wir den Test durchführen wollen, den ich oben erwähnt habe, müssen wir schreiben :
if (age > 18 && age < 25)
Die beiden Symbole "&&" stehen für UND.
Unsere Bedingung würde auf Deutsch lauten:
"Wenn das Alter über 18 UND wenn das Alter unter 25 ist"
Um ein ODER zu bilden, verwenden wir die beiden Zeichen ||. Ich muss zugeben, dass dieses Zeichen auf unseren Tastaturen nicht leicht zugänglich ist. Um es auf einer französischen AZERTY-Tastatur einzugeben, müssen Sie Alt Gr + 6 drücken. Auf einer belgischen Tastatur müssen Sie Alt Gr + & drücken.
Stellen wir uns ein dummes Programm vor, das darüber entscheidet, ob eine Person ein Bankkonto eröffnen darf. Um ein Bankkonto zu eröffnen, sollte man entweder nicht zu jung sein (wir sagen willkürlich, dass man mindestens 30 Jahre alt sein muss) oder viel Geld haben (denn dann wird man auch mit 10 Jahren mit offenen Armen aufgenommen).
Unser Test, ob der Kunde das Recht hat, ein Bankkonto zu eröffnen, könnte lauten:
if (age > 30 || argent > 100000)
{
say ("Willkommen bei Dagobert Duck Bank!");
}
else
{
say ("Geh mir aus den Augen, du Elender!");
}
Dieser Test ist nur gültig, wenn die Person über 30 Jahre alt ist oder mehr als 100.000 Euro besitzt.
Das letzte Symbol, das wir noch testen müssen, ist das Ausrufezeichen.
In der Informatik bedeutet das Ausrufezeichen "Nein".
Sie müssen dieses Zeichen vor Ihre Bedingung setzen, um zu sagen "Wenn es nicht wahr ist" :
Beispiel:
if (!(age < 18))
Dies könnte mit "Wenn die Person nicht minderjährig ist" übersetzt werden.
Hätte man das "!" davor weggelassen, hätte es das Gegenteil bedeutet: "Wenn die Person minderjährig ist".
Wenn wir testen wollen, ob die Person gerade mal 18 Jahre alt ist, müssen wir schreiben:
if (age == 18)
{
say ("Sie sind gerade volljährig geworden!");
}
Denken Sie daran, in einem if zwei Gleichheitszeichen zu setzen, wie hier: ==
Ein weiterer häufiger Anfängerfehler ist, dass Sie manchmal ein Semikolon an das Ende einer if-Zeile setzen. Nun ist ein if aber eine Bedingung, und ein Semikolon setzt man nur am Ende einer Anweisung und nicht am Ende einer Bedingung.
Der folgende Code wird nicht wie erwartet funktionieren, da am Ende des if ein Semikolon steht:
if (age == 18); // Beachten Sie das Semikolon hier, das NICHT da sein sollte
say ("Du bist gerade erst volljährig");
Der Computer wird das obige fehlerhafte Beispiel wie folgt interpretieren:
if (age == 18)
; // Beachten Sie das Semikolon hier, das NICHT da sein sollte
say ("Du bist gerade erst volljährig");
Das bedeutet, dass say() immer ausgeführt wird, unabhängig vom Ergebnis von if!
Wir werden nun genauer auf die Funktionsweise einer Bedingung vom Typ if... else eingehen.
Bei Bedingungen kommt nämlich etwas ins Spiel, das in der Informatik Booleans genannt wird.
Das ist ein sehr wichtiges Konzept, also sperren Sie Ihre Ohren (äh, Augen eher) weit auf.
Im Physik- und Chemieunterricht pflegte mein Lehrer uns mit einigen kleinen Experimenten beginnen zu lassen, bevor er einen neuen Begriff einführte. Heute mache ich es ihm ein wenig nach.
Hier ist ein sehr einfacher Quellcode, den Sie bitte testen sollen:
if (true)
{
say ("Das ist wahr");
}
else
{
say ("Das ist falsch");
}
Ergebnis :
Das ist wahr
Aber ???? Wir haben keine Bedingung in das if gesetzt, nur true (wahr auf Deutsch). Was bedeutet das, dass es keinen Sinn macht?
Doch, das tut es, Sie werden es verstehen.
Führen Sie jetzt einen weiteren Test durch, indem Sie das true durch ein false ersetzen:
if (false)
{
say ("Das ist wahr");
}
else
{
say ("Das ist falsch");
}
Ergebnis :
Das ist falsch
Tatsächlich gibt dieser Test jedes Mal, wenn Sie einen Test in einem if durchführen, den Wert true zurück, wenn er wahr ist, und false, wenn er falsch ist.
Zum Beispiel :
if (age >= 18)
Hier ist der Test, den Sie durchführen, "age >= 18".
Angenommen, age ist 23. Dann ist der Test wahr, und der Computer "ersetzt" sozusagen "age >= 18" durch true.
Anschließend erhält der Computer (in seinem Kopf) ein "if (true)".
Wenn der Wert, wie wir gesehen haben, true ist, sagt der Computer, dass die Bedingung wahr ist, also zeigt er "Es ist wahr" an!
Wenn die Bedingung falsch ist, ersetzt er age >= 18 durch false und die Bedingung ist falsch: Der Computer liest die "else"-Anweisungen.
Testen Sie nun einen weiteren Trick: Senden Sie das Ergebnis Ihrer Bedingung in eine Variable, als wäre es eine Operation (denn für den Computer ist es eine Operation!).
Beispiel:
int age;
bool majeur;
age = 20;
majeur = age >= 18;
if (majeur)
say ("volljährig");
else
say ("Minderjährig");
Wie Sie sehen, hat die Bedingung age >= 18 den Wert true zurückgegeben, da sie wahr ist. Daher ist unsere Variable majeur auf true gesetzt.
Führen Sie denselben Test durch, indem Sie z. B. age = 10 setzen. Dieses Mal wird majeur den Wert false haben.
Diese Variable "majeur" ist ein Boolean! Sie sehen, wie wir sie deklariert haben:
bool majeur;
Merken Sie sich Folgendes: Eine Variable, die man die Werte false und true annehmen lässt, bezeichnet man als Boolean.
Häufig werden wir einen "if"-Test auf eine boolesche Variable machen:
bool majeur;
majeur = true;
if (majeur)
{
say ("Du bist volljährig !");
}
else
{
say ("Du bist minderjährig");
}
Da majeur true ist, ist die Bedingung wahr, also wird "Du bist volljährig!" angezeigt.
Sehr praktisch ist, dass die Bedingung von einem Menschen leicht gelesen werden kann.
Wir sehen "if (majeur)", was mit "Wenn du volljährig bist" übersetzt werden kann.
Tests auf Booleans sind daher leicht zu lesen und zu verstehen, vorausgesetzt, Sie haben Ihren Variablen verständliche Namen gegeben.
Hier ist ein weiterer imaginärer Test:
if (majeur && garcon)
Dieser Test bedeutet "Wenn du volljährig bist UND ein Junge bist".
garcon ist hier eine weitere boolesche Variable, die true ist, wenn Sie ein Junge sind, und false, wenn Sie... ein Mädchen sind! Bravo, Sie haben alles verstanden!
Booleans dienen also dazu, auszudrücken, ob etwas wahr oder falsch ist.
Das ist sehr hilfreich, und was ich Ihnen gerade erklärt habe, wird Ihnen später viele Dinge verständlich machen.
Die "if... else"-Bedingung, die wir gerade gesehen haben, ist die am häufigsten verwendete Art von Bedingung.
Tatsächlich gibt es nicht 36 verschiedene Möglichkeiten, eine Bedingung zu erstellen. Mit "if... else" können alle Fälle behandelt werden.
Beispiel:
if (age == 2)
{
say ("Hallo Baby !");
}
else if (age == 6)
{
say ("Hallo Junge !");
}
else if (age == 12)
{
say ("Hallo junger Mensch !");
}
else if (age == 16)
{
say ("Hallo Teenager !");
}
else if (age == 18)
{
say ("Gruß Erwachsener !");
}
else if (age == 68)
{
say (Hallo Opa !");
}
else
{
say ("Ich habe keinen Satz für dein Alter parat. ");
}
Wenn Sie wie im obigen Beispiel eine Reihe von Gleichheiten testen müssen, gibt es auch die Anweisung 'switch', mit der Sie das sauberer schreiben können:
switch (age)
{
case 2:
say ("Hallo Baby !");
break;
case 6;
say ("Hallo Junge !");
break;
case 12:
say ("Hallo junger Mensch !");
break;
case 16:
say ("Hallo Teenager !");
break;
case 18:
say ("Gruß Erwachsener !");
break;
case 68:
say (Hallo Opa !");
break;
default:
say ("Ich habe keinen Satz für dein Alter parat. ");
break;
}
Bedingungen können auch auf die Typen 'float' und 'string' angewendet werden.
Zum Beispiel schreiben wir (f >= 1.0 && f <= 2.0), um zu testen, ob f zwischen 1 und 2 liegt.
Ebenso wird (name >= "ARBRE" && name <= "CROCO") getestet, ob name zwischen ARBRE und CROCO in lexikografischer Reihenfolge (Reihenfolge des Wörterbuchs) liegt.
Was ist eine Schleife?
Das ist eine Technik, mit der Sie dieselben Anweisungen mehrmals wiederholen können.
Genau wie bei Bedingungen gibt es auch bei Schleifen verschiedene Möglichkeiten.
Letztendlich läuft es darauf hinaus, dass Sie immer das Gleiche tun: die gleichen Anweisungen eine bestimmte Anzahl von Malen wiederholen.
In allen Fällen ist das Schema das gleiche:
<----------
Anweisungen ^
Anweisungen ^
Anweisungen ^
Anweisungen ^
-----------^
Der Reihe nach passiert Folgendes:
Der Computer liest die Anweisungen von oben nach unten (wie üblich).
Dann, wenn er am Ende der Schleife angekommen ist, beginnt er wieder mit der ersten Anweisung.
Dann beginnt er erneut, die Anweisungen von oben nach unten zu lesen ... ... Und er beginnt wieder am Anfang der Schleife.
Das Problem bei diesem System ist, dass es, wenn wir es nicht stoppen, ist der Computer in der Lage, die Anweisungen endlos zu wiederholen!
Er ist nicht der Typ, der sich beschwert, wissen Sie, er tut, was man ihm befiehlt .
Und hier kommen wir wieder ins Spiel ... Bedingungen!
Wenn wir eine Schleife erstellen, geben wir immer eine Bedingung an.
Diese Bedingung wird bedeuten: "Wiederhole die Schleife, solange diese Bedingung wahr ist".
Wie ich Ihnen bereits gesagt habe, gibt es verschiedene Möglichkeiten, dies zu tun. Schauen wir uns ohne weitere Umschweife an, wie man eine Schleife vom Typ "while" erstellt.
So baut man eine while-Schleife auf :
while ( Bedingung )
{
// Anweisungen zum Wiederholen
}
So einfach ist das. While bedeutet "solange wie".
Wir sagen dem Computer also: "Solange die Bedingung wahr ist: Wiederhole die Anweisungen in den geschweiften Klammern".
Wir wollen, dass unsere Schleife eine bestimmte Anzahl von Malen wiederholt wird.
Dazu erstellen wir eine Variable "Zähler", die zu Beginn des Programms 0 ist. hat und die wir im Laufe des Programms immer weiter inkrementieren werden.
Erinnern Sie sich noch an die Inkrementierung? Dabei wird 1 zur Variablen hinzugefügt, indem man "variable++;" sagt.
Schauen Sie sich dieses Stück Code genau an und versuchen Sie vor allem, es zu verstehen:
int compteur;
compteur = 0;
while (compteur < 5)
{
say ("Salut !");
compteur++;
}
Ergebnis :
Salut ! Salut ! Salut ! Salut ! Salut !
Dieser Code wiederholt die Anzeige von "Salut!" fünfmal.
Wie funktioniert das genau?
Am Anfang haben wir eine Variable compteur, die auf 0 initialisiert ist, sodass sie zu Beginn des Programms 0 ist.
Die while-Schleife ordnet die Wiederholung an, SO LANGE compteur kleiner als 5 ist.
Da compteur am Anfang 0 ist, gehen wir in die Schleife.
Wir geben den Satz "Salut!" über ein say aus.
Wir erhöhen den Wert der Variablen compteur mit der Anweisung "compteur+++;".
Der Wert von compteur war 0, jetzt ist er 1.
Wir sind am Ende der Schleife angelangt (schließende Klammer), also beginnen wir wieder am Anfang mit dem while.
Wir wiederholen den while-Test: "Ist compteur immer kleiner als 5?".
Ja, der compteur ist 1. Wir beginnen also erneut mit den Anweisungen der Schleife.
Und so weiter und so fort... compteur wird schrittweise 0, 1, 2, 3, 4, 5 wert sein.
Wenn compteur 5 ist, ist die Bedingung "compteur < 5" falsch.
Da die Anweisung falsch ist, verlassen wir die Schleife.
Man könnte übrigens sehen, dass die Variable compteur in der Schleife nach und nach größer wird, indem man sie mit einem say anzeigt :
int compteur;
compteur = 0;
while (compteur < 5)
{
say ("die Zählervariable hat den Wert " + itos(compteur));
compteur++;
}
Dies wird anzeigen:
die Zählervariable hat den Wert 0 die Zählervariable hat den Wert 1 die Zählervariable hat den Wert 2 die Zählervariable hat den Wert 3 die Zählervariable hat den Wert 4
So, wenn Sie das verstanden haben, haben Sie alles richtig gemacht.
Sie können sich den Spaß machen, die Grenze für die Anzahl der Schleifen zu erhöhen ("< 10" statt "< 5").
Wenn Sie eine Schleife erstellen, achten Sie immer darauf, dass sie an einem bestimmten Punkt anhalten kann! Wenn die Bedingung immer wahr ist, wird Ihr Programm nie aufhören!
Hier ist ein Beispiel für eine Endlosschleife :
while (true)
{
say ("Endlosschleife");
}
Erinnern Sie sich an Booleans. Hier ist die Bedingung immer wahr, daher wird dieses Programm immer wieder "Endlosschleife" anzeigen!
Seien Sie also sehr vorsichtig: Vermeiden Sie um jeden Preis, in eine Endlosschleife zu geraten.
Theoretisch kann man mit der while-Schleife jede beliebige Schleife ausführen.
In manchen Fällen ist es jedoch sinnvoll, ein anderes, "komprimierteres" Schleifensystem zu haben, das schneller zu schreiben ist.
for-Schleifen werden in der Programmierung sehr häufig verwendet.
Ich habe keine Statistiken zur Hand, aber Sie sollten wissen, dass Sie wahrscheinlich genauso viele for- wie while-Schleifen verwenden werden, also müssen Sie mit beiden Schleifenarten umgehen können.
Wie ich Ihnen schon sagte, sind for-Schleifen nur eine andere Art, eine while-Schleife zu machen.
Hier ist ein Beispiel für eine while-Schleife, die wir vorhin gesehen haben :
int compteur;
compteur = 0;
while (compteur < 10)
{
say ("Salut !");
compteur++;
}
Hier ist nun das Äquivalent in einer for-Schleife :
int compteur;
for (compteur = 0 ; compteur < 10 ; compteur++)
{
say ("Salut !");
}
Welche Unterschiede gibt es?
Es steht viel in den Klammern nach dem for (wir werden das später noch genauer erläutern).
Es gibt keinen Zähler+++; mehr in der Schleife.
Wir wollen uns mit dem beschäftigen, was sich zwischen den Klammern befindet, denn das ist das Interessante an der for-Schleife. Es gibt drei komprimierte Anweisungen, die jeweils durch ein Semikolon getrennt sind:
Die erste ist die Initialisierung: Diese erste Anweisung wird verwendet, um unsere Zählervariable vorzubereiten. In unserem Fall initialisieren wir die Variable mit 0.
Die zweite ist die Bedingung: Wie bei der while-Schleife ist es die Bedingung, die sagt, ob die Schleife wiederholt werden soll oder nicht. Solange die Bedingung wahr ist, wird die for-Schleife fortgesetzt.
Schließlich gibt es noch die Inkrementierung: Diese letzte Anweisung wird am Ende jeder Schleifenrunde ausgeführt, um die Zählervariable zu aktualisieren.
Die meiste Zeit wird eine Inkrementierung durchgeführt, aber man kann auch eine Dekrementierung (Variable--;) oder jede andere Operation durchführen (Variable += 2;, um z. B. von 2 zu 2 weiterzugehen).
Kurz gesagt: Wie Sie sehen, ist die for-Schleife nichts anderes als eine Zusammenfassung von while. Sie werden sie mehr als einmal brauchen!
Die Anweisung break dient zum Abbrechen und Verlassen einer Schleife.
for (i=0; i<5; i++)
{
if (i == 3)
break; // exit here
say (itos(i));
}
wird Folgendes anzeigen
0 1 2
Die Anweisung continue dient dazu, sofort zur nächsten Schleifenrunde überzugehen.
for (i=0; i<5; i++)
{
if (i == 1 || i == 3)
continue;
say (itos(i));
}
wird Folgendes anzeigen
0 2 4
In den vorherigen Kapiteln konnten Sie Skripte schreiben, die von selbst liefen und die Avatare völlig ignorierten.
Jetzt kommen wir zu einer anderen Art von Skripten: solche, die mit den Avataren interagieren und auf sie reagieren!
Avatare bewirken nämlich Aktionen, z. B. :
- sie klicken auf das Objekt
- sie schreiben Textzeilen
usw ...
Jedes Mal, wenn eine Aktion stattfindet, wird das entsprechende Ereignis ausgeführt.
Beispiel :
// mit einer Nachricht reagieren, wenn der Chatter das Objekt berührt
event touch()
{
say ("Bienvenue " + avatar_name(touched_avatar()));
}
Im Ereignis haben wir Zugriff auf eine ganze Reihe von Parametern, die sich auf die Aktion beziehen: z. B. touched_avatar() gibt einen Schlüssel über den Avatar zurück, der berührt hat. Diesen Schlüssel kann man an die Funktion avatar_name() weitergeben, um den Namen des berührten Avatars zu erhalten.
Man muss wissen, dass ein Skript 99% der Zeit nichts tut, es schläft!
Aber sobald ein Avatar eine Aktion auslöst, wacht das Skript auf!
Es führt dann die wenigen Anweisungen aus, die in einem Ereignis enthalten sind (zum Beispiel zeigt es eine Nachricht an), und wenn es fertig ist, schläft das Skript weiter und wartet auf die nächste Aktion.
Zwischen zwei Aktionen, also während es schläft, hat das Skript seinen Speicher komplett verloren, d. h. alle Variablen werden auf null zurückgesetzt!
Es gibt nur eine Ausnahme von dieser Regel, und das sind die globalen Variablen (die, die ganz oben im Skript deklariert sind). Diese sind daher sehr nützlich, da sie ihren Wert behalten, solange das Skript läuft!
Sie sollten sich jedoch bewusst sein, dass globale Variablen die Kosten des Skripts erhöhen, während die weiter unten deklarierten Variablen nichts kosten. Globale Variablen sollten Sie also nur dann verwenden, wenn ihr Wert zwischen zwei Ereignissen erhalten bleiben soll.
Das folgende Skript sagt jedem Avatar, wie viele Avatare das Objekt vor ihm berührt haben. Dazu verwendet es eine Variable, die am Anfang des Skripts deklariert wurde.
// ein Skript, das die Chatter zählt
int g_compteur = 0;
event touch()
{
say ("Bienvenue " + avatar_name(touched_avatar()));
g_compteur++;
say ("du bist die " + itos(g_compteur) + " person, die mich berührt, seit mein script läuft");
}
Häufig beginnen Variablen, die ganz oben im Skript deklariert werden, mit g_, um global anzuzeigen.
Dies ist nicht zwingend erforderlich, aber unter Informatikern eine Konvention.
Anstatt eine einzelne Variable zu reservieren, kann man auch eine ganze Tabelle von Variablen reservieren.
Beispiel:
int[100] compteur; // ich lege 100 Zähler an
Tatsächlich werden im obigen Beispiel die folgenden 100 Zähler erstellt :
compteur[0] compteur[1] compteur[2] compteur[3] ... compteur[99]
Um die gesamte Tabelle auf einmal zu löschen (alle Zähler auf Null zu setzen), verwenden wir die Anweisung clear :
clear compteur;
In diesen Zählern können wir Werte speichern, etwa so:
compteur[5] = 12; // 12 in Zähler Nummer 5 speichern compteur[5]++; // den Zähler 5 um 1 erhöhen compteur[i] = 13; // 13 im Zähler i speichern
Das letzte Beispiel oben wird einen Skriptfehler ausgeben, wenn die Variable "i" keinen Wert zwischen 0 und 99 hat.
Strukturen sind ein weiterer Mechanismus, um mehrere Variablen zu deklarieren, allerdings von einem anderen Typ. Zum Beispiel werden wir hier eine Struktur INFO erstellen, die aus zwei Feldern besteht: name und cost:
struct INFO
{
string(32) name;
int cost;
}
Sobald die Struktur erstellt ist, kann man Variablen davon deklarieren, z. B. :
INFO info;
und man kann ihr Werte zuweisen:
info = {name => "Marc", cost => 10};
Um nur auf ein Feld in der Struktur zuzugreifen, verwenden Sie einen Punkt, gefolgt vom Namen des Feldes. Beispiel:
say (info.name);
Man kann Struktur und Array kombinieren, z. B. kann man ein Array mit 100 Strukturen INFO deklarieren:
INFO[100] table;
Um eine große Variable auf einmal zu löschen, ist die Anweisung clear praktisch:
clear table;
Um den Wert 2 in das Feld cost des fünften Elements der Tabelle zu schreiben, schreiben wir :
table[5].cost = 2;
Was ist eine Funktion? Nun, zum Beispiel "atan2()", mit der man die Invtangente berechnen kann.
float f = atan2 (30.0, 40.0);
Sie kennen auch "say()", mit der Sie einen Text auf dem Bildschirm anzeigen können.
say ("hello");
Diese beiden Funktionen werden mit dem folgenden Formalismus deklariert:
float atan2 (float y, float x); void say (string s);Dieser Formalismus besagt, dass :
Eigentlich ist eine Funktion, die mit void beginnt, ein Befehl, während eine Funktion ohne void ein Ergebnis berechnet. Ansonsten sind sich beide sehr ähnlich.
Wir werden uns einige gängige Funktionen ansehen, um zu sehen, wie sie funktionieren:
date_time now (); // Funktion, die das aktuelle Datum berechnet. int rnd (int a,int b); // gibt eine Zufallszahl zwischen a und b zurück.
Die Funktion now() ist einfach: Sie hat keine Parameter und berechnet das Datum und die Uhrzeit des PCs. Zum Beispiel können wir schreiben:
event start()
{
date_time ma_date;
ma_date = now(); // das Datum in my_date setzen
say (itos(ma_date.day, 2, "0")
+ "/"
+ itos(ma_date.month, 2, "0")
+ "/"
+ itos(ma_date.year, 2, "0"));
}
was zum Beispiel drucken wird:
02/12/2020
Mit der Funktion rnd() können Sie eine Zufallszahl ziehen, was für Spiele sehr nützlich ist.
Beispiel:
event touch()
{
int i;
i = rnd (1, 100); // Eine Zahl von 1 bis 100 auswählen, die in i eingesetzt werden soll.
say ("on choisit " + itos(i));
}
In der Dokumentation der Skriptsprache finden Sie eine Liste aller vordefinierten Prozeduren und Funktionen.
Man kann auch eigene Funktionen erstellen. Wenn wir zum Beispiel eine Funktion tan() erstellen wollen, die den Tangens berechnet, könnten wir Folgendes schreiben:
float tan (float a)
{
float t = sin (a) / cos (a);
return t;
}
Sie sehen, dass wir die Funktion mit dem Formalismus deklariert haben (aber ohne Semikolon am Ende), dann in geschweiften Klammern eine Folge von Anweisungen zur Berechnung des Wertes gesetzt haben und schließlich die Funktion mit der Anweisung "return" beenden, die die Funktion beendet und den Wert des Ergebnisses angibt.
Hier ist eine weitere Funktion, die "Hallo" sagt:
void say_hello (key k)
{
say ("Hello " + avatar_name (k));
}
event touch()
{
say_hello (k => touched_avatar());
}
Das Ereignis touch wird die Funktion say_hello aufrufen und als Parameter einen Avatarschlüssel angeben, und diese Funktion wird auf dem Bildschirm Hello und den Namen dieses Avatars anzeigen.
Wenn wir eine void Funktion beenden wollen, können wir einfach "return;" schreiben.
// nur Frauen Hallo sagen
void say_hello_to_female (key k)
{
if (avatar_gender (k) != 1)
return;
say ("Hello " + avatar_name (k));
}
event touch()
{
say_hello_to_female (k => touched_avatar());
}
Hier testet die Funktion das Geschlecht des Avatars. Wenn es sich nicht um eine Frau handelt,
wird die Funktion sofort mit return beendet, ohne etwas anzuzeigen. Andernfalls fahren wir fort, um hello anzuzeigen.
Wenn Sie denselben Wert mehrmals in einem langen Skript verwenden, können Sie diesen Wert am Anfang des Skripts durch eine Konstante deklarieren. Wenn Sie den Wert ändern, müssen Sie ihn nur an einer Stelle ändern, und Sie können ihn leicht wiederfinden.
Beispiel: numerische und String-Konstanten
const int NOMBRE_DE_PLACES = 4; const float SECONDES = 30.0; const string ACCUEIL_1 = "Bonjour, j'ai "; const string ACCUEIL_2 = " places"; say (ACCUEIL_1 + itos(NOMBRE_DE_PLACES) + ACCUEIL_2);
Oft werden Konstanten in Großbuchstaben geschrieben, das ist eine Konvention unter Informatikern.
Beispiel: Array-Konstanten
const string(23)[3] MENU1 = {"Jeu contre l'ordinateur", "Play against computer", "Spiel gegen Computer"};
Beispiel: Konstanten von Tabellen von Strukturen
struct BOISSON
{
string(16) name;
}
const int MAX_OBJECTS = 5;
const BOISSON G_BOISSON[MAX_OBJECTS] =
{
{name => "Bière"},
{name => "Soda coca"},
{name => "Soda orange"},
{name => "Becher Kaffee"},
{name => "Becher Tee"},
};
Dies ist ein Skript, das alle zehn Sekunden einen Text wiederholt.
event start()
{
start_timer (0, 10.0);
}
event timer (int nr)
{
say ("Salut les amis !");
say ("J'espère que vous allez bien :p");
start_timer (0, 10.0);
}
Die Prozedur start_timer(0, 10.0); bedeutet: "löse Timer Nummer 0 in 10 Sekunden aus".
Wenn der Event-Timer ausgeführt wird, schreibt er den Text, und der start_timer löst ihn in 10 Sekunden erneut aus, usw. ... und das Ganze läuft in einer Schleife!
Mit der Prozedur say() können Sie einen Text anzeigen, z. B. :
say ("Bonjour !");
Man kann mehrere Textstücke zusammenfügen, indem man z. B. den Operator + (plus) verwendet:
say ("Bonjour " + "Chers Amis !");
gut, in diesem Fall hätte man auch schreiben können:
say ("Bonjour Chers Amis !");
Aber hier ist ein interessanterer Fall:
say ("Bonjour " + userid + " !");
hier werden Hallo und der Name des Chatters zusammengefügt.
Beachten Sie, dass Sie einen Fehler erhalten, wenn Sie dies schreiben :
say (count);
weil say() nur String-Variablen akzeptiert!
Um einen Wert anzuzeigen, müssen Sie ihn zunächst mit der Funktion itos() in Text umwandeln.
Beispiel :
say ("tu es la " + itos(count) + " personne qui me touche depuis que mon script tourne");
Um in verschiedenen Stilen zu schreiben, können Sie folgende Funktionen verwenden:
color (0xFFFFFF) : changer de couleur
font (5) : numéro de font
style (underlined => true, italic => true, bold => true) : changer de style souligné italique ou gras
Beispiel:
// Begrüßungstext
string font(int f) { return chr(1, f); }
string style(bool underlined, bool italic, bool bold) { int s=0; if (underlined) s++; if (italic) s+=2; if (bold) s+=4; return chr(2, s); }
string color(int col) { return chr(4, col & 0xFFFF, col>>16); }
event touch ()
{
say ("big "
+ color(0x8080FF)
+ "kiss"
+ font(9)
+ color(0x00FF00)
+ style(underlined => true, italic => true, bold => true)
+ " from Didi");
}
Dieses Beispiel zeigt die Willkommensnachricht in Rot an!
Aber gut, wenn Sie viel roten Text anzeigen, ist das nicht praktisch.
Denn an dem Tag, an dem Sie die Farbe ändern wollen, müssen Sie alle color(0x8080FF) in Ihrem Programm ändern.
Was Sie tun können, ist, Ihre eigene Funktion zum Ändern der Farbe zu schreiben.
Beispiel:
// message d'accueil
string font(int f) { return chr(1, f); }
string style(bool underlined, bool italic, bool bold) { int s=0; if (underlined) s++; if (italic) s+=2; if (bold) s+=4; return chr(2, s); }
string color(int col) { return chr(4, col & 0xFFFF, col>>16); }
string ftitle ()
{
return color(0x8080FF) + font(8); // couleur rouge + font Impact
}
event touch ()
{
say (ftitle() + "Bonjour !");
}
Wenn Sie also die Farben oder die Schriftart ändern wollen, müssen Sie nur die Funktion ftitle bearbeiten.
Hier ist ein weiteres Beispiel, das zeigt, dass man einen ganzen Text in die Funktion einfügen kann:
Beispiel:
// message d'accueil
string font(int f) { return chr(1, f); }
string style(bool underlined, bool italic, bool bold) { int s=0; if (underlined) s++; if (italic) s+=2; if (bold) s+=4; return chr(2, s); }
string color(int col) { return chr(4, col & 0xFFFF, col>>16); }
string red ()
{
return color(0x8080FF);
}
string Impact ()
{
return font(8);
}
string Bienvenue (string userid)
{
return red() + Impact() + "Bienvenue " + userid + " !";
}
event touch ()
{
say (Bienvenue (avatar_name(touched_avatar())));
}
Beachten Sie im obigen Beispiel, dass wir den Parameter userid an die Funktion Bienvenue() übergeben haben, weil sie ihn brauchte!
Eine andere Möglichkeit wäre gewesen, statt einer Funktion eine Prozedur zu verwenden. Der Unterschied zwischen den beiden ist sehr gering: Eine Funktion gibt einen Wert oder einen Text zurück, eine Prozedur gibt nichts zurück ! (nichts heisst 'void' in English)
Beispiel:
// message d'accueil
string font(int f) { return chr(1, f); }
string style(bool underlined, bool italic, bool bold) { int s=0; if (underlined) s++; if (italic) s+=2; if (bold) s+=4; return chr(2, s); }
string color(int col) { return chr(4, col & 0xFFFF, col>>16); }
string red ()
{
return color(0x8080FF);
}
string Impact ()
{
return font(8);
}
void Bienvenue (string userid)
{
say (red() + Impact() + "Bienvenue " + userid + " !");
}
event touch ()
{
Bienvenue (avatar_name(touched_avatar()));
}
Oben sehen Sie, dass sich die Prozedur say() nicht mehr im Ereignis touch befindet, sondern in der Prozedur Bienvenue.
Wie zeigt man eine zufällige Willkommensnachricht an?
Mithilfe der Funktion rnd()!
Beispiel:
// zufällige Willkommensnachricht
event touch ()
{
int n;
n = rnd (1, 3); // zieht eine Zufallszahl zwischen 1 und 3
if (n == 1)
say ("salut, ça va ?");
else if (n == 2)
say ("oula, toi je ne t'aime pas !");
else
say ("reviens plus tard, j'suis pas là :p");
}
Beachten Sie hier, dass die Variable 'n' nicht am Anfang des Skripts, sondern in der Prozedur deklariert wurde: Sie verliert also ihren Wert zwischen zwei Aktionen, während das Skript schläft, was in Ordnung ist, da man sie ja nicht behalten möchte.
Das folgende Skript wird einen zufälligen Begrüßungstext aus einer Datei auswählen, die Sie in den Skriptordner des Objekts gelegt haben :
// zufälligen Begrüßungstext
event touch ()
{
// zählt die Anzahl der Zeilen in der Datei bienvenue.txt
int count = count_lines ("bienvenue.txt");
// zieht eine Zufallszahl zwischen 1 und count
int n = rnd (1, count);
// extrahiert die ausgewählte Zeile aus der Datei
string(128) s = read_line ("bienvenue.txt", n);
// zeigt die Zeile
say (s);
}
Sie wissen, dass die am Anfang des Skripts deklarierten Variablen ihren Wert zwischen zwei Aktionen beibehalten. Aber was passiert, wenn das Skript geändert wird? Sie werden natürlich gelöscht .
Was wir brauchen, ist eine Möglichkeit, die Daten dauerhaft auf der Festplatte zu speichern ...
Wir verwenden dazu die Funktionen store und fetch, mit denen wir Informationen auf den Planet-Server schreiben und später wieder einlesen können.
store (tiroir, valeur); // speichert den Wert in der Schublade des Servers
// Beispiel: store ("JEU-DEVINE", "1 35 16 32 89 12");
s = fetch (tiroir); // gibt den Wert zurück, der in der Schublade enthalten ist
// Beispiel: fetch ("JEU-DEVINE") == "1 35 16 32 89 12"
Wie funktioniert das?
Stellen Sie sich vor, Sie stehen in einer großen Bibliothek und haben eine Wand mit Schubladen vor sich.
Auf jeder Schublade steht ein Name.
Wenn Sie eine Schublade öffnen, können Sie einen Wert hineinlegen und sie wieder schließen. Später können Sie die Schublade wieder öffnen und den Wert, den Sie hineingelegt haben, wieder herausholen.
Genau so funktionieren store und fetch.
Es steht Ihnen natürlich frei, einen beliebigen Wert in die Schublade zu legen. Das kann eine Punktzahl sein, Punkte, wie oft ein Chatter den Raum betreten hat, Datum und Uhrzeit seines letzten Besuchs oder jede andere Information.