Kapitel 6: Variablenbehandlung (auch: Variablen fuer Fortgeschrittene)

6.1 Was bisher geschah... oder: Was bisher bekannt sein sollte:
Du solltest in der Lage sein, einfache Objekte zu programmieren, die
mudspezifisch sind, und die Grundlagen der Vererbung beruecksichtigen.
Zusaetzlich kannst Du bereits Funktionen selbst schreiben.
Frage: Welche 3 Dinge machen jede Funktion aus?
In diesem Kapitel werden wir lernen, wie man in Funktionen Variablen
manipuliert.

6.2 Werte und Objekte
Grundsaetzlich unterscheidet man im MUD Objekte anhand von diesen beiden
Punkten:
1) Einige haben unterschiedliche Funktionen
2) Alle haben unterschiedliche Werte

Beispielsweise haben alle Spielerobjekte dieselben Funktionen. Sie
unterscheiden sich jedoch anhand verschiedener Werte. Beispielsweise
unterscheidet sich das Spielerobjekt "Inwe" von dem Spielerobjekt "Pina"
zumindest dadurch, dass die Variable P_NAME die Werte "Inwe" und "Pina" hat.
Alle Properties sind Variablen, die zur Kommunikation zwischen den
Objekten gedacht sind.

Aenderungen im Spiel verursachen Aenderungen in den Werten in den Objekten,
die beteiligt sind. Funktionen werden genutzt, um spezifische Prozesse zur
Variablenmanipulation zu benennen. Beispielsweise ist die Funktion create()
die Funktion, die zur Initialisierung der Werte des Objektes benutzt wird.
Innerhalb dieser Funktion werden andere Funktionen zur Setzung und Manipulation
dieser Variablen aufgerufen.

6.3 Lokale und globale Variablen
LPC-Variablen koennen (wie in den Datentyp-Betrachtungen bereits kurz
erwaehnt) als lokale oder globale Variablen deklariert werden.
Lokale Variablen werden innerhalb einer Funktion deklariert und nur innerhalb
der Funktion verwendet, sie sind auch ausserhalb nicht verwendbar.
Sie werden nur im Speicher gehalten, waehrend die Funktion ausgefuehrt wird.
Im Gegensatz dazu stehen globale Variablen allen Funktionen innerhalb des
Objektes zur Verfuegung. Diese Variablen belegen solange das Objekt
existiert, Arbeitsspeicher und werden erst dann entfernt, wenn das Objekt
aus dem Spiel entfernt wird.
Vergleiche dazu das Beispiel aus Kapitel 2.

6.4 Manipulation von Werten von Variablen
Zuweisungen werden verwendet, um Variablenwerte zu manipulieren.
Ein Beispiel koennte so aussehen:
x = 5;
Damit wird der Variable x der Wert 5 zugewiesen. Es gibt ein paar interessante
Konzepte, die hier zum Zuge kommen, die allgemein mit Ausdruecken zu tun hat.
Ausdruecke sind beliebige Aneinanderreihungen von Symbolen, die Werte
besitzen. Im obigen Beispiel wurde der Variable x der Wert ders Ausdruckes 5
zugewiesen. Konstante Werte sind die einfachste Form von Ausdruecken.
Konstanten (also konstante Werte) sind zB int 5 oder string "hallo".
Das letzte Konzept ist der Operator. In dem obigen Beispiel wurde der
Zuweisungsoperator(=) benutzt.

Es gibt viele Operatoren in LPC und die Ausdruecke koennen sehr komplex
werden. Wir erhoehen einmal einmal den Schwierigkeitsgrad:

y = 5;
x = y + 2;

Die erste Anweisung benutzt einen Zuweisungsoperator, um der Variable y den
konstanten Ausdruck 5 zuzuweisen. Aber das hast Du sicher sofort erkannt.
Die zweite Anweisung weist der Variable x den Ausdruck y + 2 zu.
Dieser Ausdruck wird durch den Inkrementoperator(+), der den Wert der Variable
y und die Konstante 2 verbindet. Klingt kompliziert?

Um es anders auszudruecken: Operatoren koennen benutzt werden, um komplexe
Ausdruecke zu erstellen. Im obigen Beispiel gibt es zwei Ausdruecke:
1) y+2
2) x=y+2
Wie bereits erwaehnt haben alle Ausdruecke Werte. Der Ausdruck y+2 hat hier
Wert der Summe aus y und 2 (hier 7).
Der zweite Ausdruck x=y+2 hat auch den Wert von 7.
Operatoren haben wichtige Aufgaben:
1) Sie koennen sich bei Eingabe wie eine Funktion verhalten
2) Sie koennen selbst einen Wert besitzen.
Nicht alle Operatoren verhalten sich so, wie in 1) beschrieben. Der
Zuweisungsoperator(+) weist den Wert, der sich rechts von ihm befindet, der
Variable, die sich links von ihm befindet, zu.
Der Inkrementoperator(+) als Solches tut nichts, jedoch haben Beide ihren
Wert.
Neben dem Inkrementoperator gibt es noch mehrere gleichwertige Operatoren, die
die anderen Grundrechenoperatinen durchfuehren.
Es werden hier nur die moeglichen Operatoren erwaehnt, jedoch nicht alle
ausfuehrlich behandelt.
Ist ein Ausdruck mit mehreren Operatoren verbunden, wird anhand der Vorraenge
von 1-15 zusammengefasst. Sind mehrere gleichwertige Operatoren vorhanden,
werden sie nach der dritten Spalte entweder linksbuendig oder rechtsbuendig
ausgewertet.

Ale Vorraenge von Operatoren auf einen Blick:
 1. () [] ->  				linksbuendig
 2. ! ~ ++ -- (auch + - als Vorzeichen)	rechtsbuendig
 3. * / %				linksbuendig
 4. + - (als Inkrement/Dekrement)	linksbuendig
 5. << >> 				linksbuendig
 6. < > <= >=				linksbuendig
 7. == != (Vergleiche)			linksbuendig
 8. &					linksbuendig
 9. ^					linksbuendig
10. |					linksbuendig
11. &&	(logisches UND)			linksbuendig
12. ||  (logisches ODER)		linksbuendig
13. ?: 					rechtsbuendig
14. = += -= *= /= %=			rechtsbuendig
15. ,					linksbuendig

Frage:
x=5;
y=7;
z=x+2*y+4;
Welchen Wert hat z?
z=x*x+2*y*(x-y);
Welchen Wert hat hier z?

Weitere, haeufig gebrauchte Operatoren sind:
ein logisches NICHT, also die Negierung des folgenden Ausdruckes.

++/--:
die Erhoehung/Senkung der Variable um 1. (Spezialfaelle von Vorrang 14)
Diese Operatoren koennen als postfix (i++) oder prefix(++i)-Operatoren
verwendet werden.
Als Prefix wird, die Modifikation durchgefuehrt, bevor ein Wert zugewiesen wird.
Als Postfix wird es nach der Wertzuweisung passieren.
x=0;
y=5;
x=++y; // x=6, y=6
y=5;
x=y++; // x=5, y=6
An diesem kleinen, aber feinen Beispiel kannst Du den Unterschied sicher
erkennen.

%:
der Modulooperator, Bei der Division von ganzzahligen Werten kann ja
nur ein ganzzahliger Wert herauskommen. Den Rest ermittelt der %-Operator.

/>:
logische Vergleichsoperatoren. kleiner/kleiner oder gleich/
groesser oder gleich/groesser, liefern 0 bei falsch und 1 bei wahr

== :
logischer Vergleichsoperator ist gleich, Achtung, nicht mit dem
Zuweisungsoperator (=) zu verwechseln!

logischer Vergleichsoperator ungleich

+=/ -=/ *=/ /=:
der linke Teil des Ausdruckes wird um den rechten Teil nach den
Grundrechenoperatoren modifiziert.
i++ ist grundsaetzlich dasselbe wie i+=1 oder i=i+1, wenn man davon absieht,
dass die erste Version eine hoehere Prioritaet hat.

?: :
ein Dreikomponenten-Operator, der eine einfache Alternativzuweisung erlaubt.
AUSDRUCK?WAHR:FALSCH
Wenn der Ausdruck vor dem ? wahr ist, wird der Wahrzweig ausgefuehrt, sonst der
Falschzweig (also der hinter dem

6.5 Komplexe Ausdruecke
Wie Du vielleicht bemerkt haben solltest, hat der Ausdruck x=5 selbst schon
einen Wert von 5.
Da auch LPC-Operatoren Werte haben, koennen irgendwelche Ausdruecke, wie Dieses
auftauchen:
i=(is=sizeof(inv=all_inventory(environment(this_object()))))?j=5:j=0;
Frage:
Welche Werte haben i, is, inv und j bei der Ausfuehrung?
Welche Datentypen werden i, is, inv und j haben?

6.6 Zusammenfassung
Es ist bekannt, wie man Variablen deklariert und wie man sie global und lokal
nutzt. Ausserdem sind die Unterschiede zwischen global und lokal bekannt.
Ausserdem weisst Du, was efuns des Drivers sind und auch was LPC-Operatoren
sind. Die wichtigsten Operatoren sind bekannt und man kann Dich mit komplexen
Ausdruecken nicht mehr frustrieren. Du weisst, wie man Variablen mit Hilfe
von Operatoren manipuliert. Das ist nuetzlich, wenn Du zum Beispiel wissen
willst, wieviele Aepfel oder Kirschen der Spieler bereits vom Birnenbaum
gepflueckt hat und wie man erfaehrt, ob eine bestimmte Anzahl gepflueckt
wurde, damit kein Spieler mehr pfluecken kann.
Dazu ein Hinweis: Es ist immer besser, die maximale Zahl, die pflueckbar sind,
einzustellen und die dann herunterzuzaehlen anstatt den anderen Weg zu
beschreiten.
Frage: Wie saehe die Abfrage mit dem ?-Operator aus, wenn die Variable i
die Kirschenanzahl enthaelt und 5x gepflueckt werden darf.
Dass das spaeter mit einer speziellen Funktion, der sogenannten if-Funktion,
besser geloest wird, da dann auch Texte ausgegeben werden und so weiter, was
mit dem ?-Operator so einfach nicht funktioniert, ausser man lagert die
positive wie negative Aussage in eine weitere Funktion aus, ist eine andere
Frage. Du hast damit die wichtigsten theoretischen Dinge gelernt, die es Dir
ermoeglichen, eine mehr oder weniger komplexe Subregion zu schreiben.
Auf die Funktionen wie SetProp oder AddExit gehe ich hier explizit nicht ein,
da das nicht direkt zu LPC gehoert, und verweise dafuer auf die entsprechenden
man-Pages im MUD.