View source for DE/Lua Tutorial

__TOC__

==Vorwort==
Da es bis auf einige knappe und teils unprofessionelle Tutorials kein deutsches Lua Tutorial gibt, habe ich beschlossen, nun ein eigenes zu schreiben, welches alle für MTA notwendigen Grundlagen einfach und übersichtlich erklärt.
Weiterführende Möglichkeiten und Funktionen können der [http://www.lua.org/manual/5.1/ Offiziellen Lua Dokumentation] entnommen werden, die es jedoch nicht auf Deutsch gibt.

Ein weiterer Grund ist, dass ich schon von einigen gehört habe und auch so schon den Verdacht hatte, dass MTA einfach so wenige deutsche Spieler und vor allem Server hat (gibt es überhaupt '''einen''' deutschen?), weil die meisten Probleme mit den englischen Dokumentationen haben oder der Meinung sind, dass für MTA ja sowieso kein deutscher Support vorhanden ist.

Soviel nun dazu, wie es zu der Idee des deutschen Lua Tutorials kam.
Fangen wir an mit dem Erlernen einer neuen Sprache!


==Grundlagen==
===Lua, eine Skriptsprache===
Lua (portugiesisch für Mond) ist eine Skriptsprache zum Einbinden in Programme, um diese leichter weiterentwickeln und warten zu können. Insbesondere die geringe Größe des Interpreters von 120 KB und die hohe Geschwindigkeit verglichen mit anderen Skriptsprachen überzeugen viele Entwickler davon, Lua einzusetzen.

Die Syntax lehnt sich an die von Pascal an, was besonders Anfängern den Einstieg in Lua erleichtert. Im Gegensatz zu von Pascal abgeleiteten Sprachen nutzt Lua jedoch „==“ und nicht „=“ als Vergleichsoperator.

(Quelle: [http://de.wikipedia.org/wiki/Lua Wikipedia])

Einige werden sich bei dieser Einführung vielleicht gefragt haben, was der Unterschied zwischen Skript- und Programmiersprache ist und was ein Interpreter sein soll. Im folgenden will ich diese beiden Fragen so kurz und einfach wie möglich klären.

Eine '''Programmiersprache''' (z.B. C, C++, Pascal, Delphi) wird - wie der Name schon sagt - verwendet, um Programme zu schreiben. Ein Programm liegt bekannterweise in Form einer Executable (*.exe) vor. Diese kann weitgehend unabhängig von irgendwelchen Betriebssystemen oder der Umgebung selbstständig ausgeführt werden (z.B. durch Doppelklick). Weitgehend deswegen, da einige Programme aufgrund von Speicherersparnissen sogenannte Programmbibliotheken (original Dynamic Link Library, kurz dll) benötigen, um zu funktionieren. Erklärungen dazu findet ihr [http://de.wikipedia.org/wiki/Dynamic_Link_Library hier].<br>
Um einen Programmquellcode, d.h. einen Text, der in einer Programmiersprache geschrieben wurde, aus dem Textdokumentformat in eine Anwendung (original Executable, kurz exe) umzuwandeln, benötigt man nun einen Compiler (zu Deutsch Kompilierer oder Übersetzer), der die Programmiersprache aus der menschenlesbaren Form in die maschinenlesbare Form umwandelt. Neben dieser Hauptaufgabe übernimmt der Compiler natürlich noch weitere Aufgaben, auf die ich jetzt aber nicht genauer eingehen werde. Infos dazu findet ihr [http://de.wikipedia.org/wiki/Compiler hier].<br>
Die maschinenlesbare Form ist für Menschen unlesbar.

Eine '''Skriptsprache''' (z.B. JavaScript, DOS-Batch(Win) bzw. Shell-Scripts(UNIX)) hingegen liegt standardmäßig in der menschenlesbaren Form vor. Skriptsprachen werden - wie im ersten Satz bereits erwähnt - vor allem von Programmen benutzt, um benutzerdefinierte Abläufe verwenden zu können. Zur Ausführung von Scripts wird ein sogenannter Interpreter benötigt, der das Skript liest und es Schritt für Schritt in die Maschinensprache umwandelt und ausführt. Manche Skriptsprachen kann man mit einem Precompiler (zu Deutsch Vorkompilierer oder Vorübersetzer) vorkompilieren. Diesen könnte man auch den Vorkauer vom Interpreter nennen, da er das Script schon zum Teil in die Maschinensprache umwandelt, jedoch nicht so extrem wie der Compiler der Programmiersprachen. Das Ergebnis davon ist logischerweise die schnellere Ausführung des Skripts.

Genug der langweiligen Definitionen. Klären wir lieber, was man denn alles braucht, um ein Lua Script zu schreiben.

===Materialien===
Lua Skripte werden üblicherweise als Textdateien mit der Endung .lua gespeichert. Die Endung ist jedoch nicht von belang. Es kann jede beliebige Endung gewählt werden.

Wie jede normale Textdatei kann man also auch Lua Skripte mit dem standard Texteditor des vorhandenen Betriebssystems schreiben, editieren und lesen. Ich persönlich empfehle jedoch das Programm Notepad++, welches [http://notepad-plus.sourceforge.net/de/site.htm hier] heruntergeladen werden kann. Das Programm ist Freeware und wird regelmäßig aktualisiert und erweitert. Der Vorteil daran ist, dass es ein professionelles Syntax-Highlighting eingebaut hat, welches Schlagwörter und Standardfunktionen farblich oder anderweitig hervorhebt und somit die Übersichtlichkeit erheblich verbessert.<br>
Standardmäßig wird die Sprache Lua automatisch an der Dateiendung .lua erkannt, solltest Du eine andere Endung verwenden und trotzdem das Lua Syntax-Highlighting verwenden wollen, kannst Du es oben im Menü „Sprachen“ einstellen.

Wer ohne MTA seine kleinen Lua Skripte testen oder ausführen möchte, kann sich [http://luabinaries.luaforge.net/download.html hier] einen kostenlosen standalone Interpreter herunterladen. Wenn Du Dir nicht sicher bist, welche Windows Edition Du hast, dann hast Du wahrscheinlich eine 32 Bit Version, welche auf dieser Seite der „Windows x86 Executables“ entspricht. Die aktuelle Version (Win 32 Bit) dafür gibt es bei einem Klick auf [http://luaforge.net/frs/download.php/3134/lua5_1_3_Win32_bin.zip lua5_1_3_Win32_bin.zip].<br>
Nach dem Download kann der Standalone Interpreter mit einem Doppelklick auf die „lua5.1.exe“ gestartet werden. Dort kann man dann direkt Lua Befehle eingeben oder ein Script laden. Dies geht wie folgt:
<syntaxhighlight lang="lua">dofile("dateiname.lua")</syntaxhighlight>

==Kommentare==
Um sein Skript übersichtlicher zu gestalten, kann man mit Kommentaren bestimmte Zeilen eräutern, Bereiche abgrenzen, alten Code deaktivieren, ohne ihn zu entfernen und generell das Skript übersichtlicher gestalten.<br>
Kommentare werden vom Interpreter vollkommen ignoriert und sind nur für den Menschen lesbar und von Belang.

===Einzeilig===
<syntaxhighlight lang="lua">-- Dies ist ein einzeiliger Kommentar. Er gilt von -- bis zum Ende dieser Zeile. Automatische Zeilenumbrüche, die eingefügt werden, wenn die Zeilenlänge überschritten wurde, zählen nicht.</syntaxhighlight>

===Mehrzeilig===
<syntaxhighlight lang="lua">--[[ Dieser Kommentar
     geht über beliebig viele Zeilen
     und endet mit ]]</syntaxhighlight>


==Variablen==
===Einführung===
Eine Variable kann man sich wie eine kleine Kiste vorstellen, auf der außen ein Bezeichner (oder Name) steht und die einen Wert enthält. Während der Bezeichner immer gleich ist, kann der Inhalt variieren.
Jede Variable hat einen Variablentypen, der bei Programmiersprachen normalerweise zu Beginn des Programmes fest definiert wird und sich nicht ändern kann. Da Lua aber ja keine Programmiersprache ist, muss der Variablentyp zu Beginn und auch sonst nie festgelegt werden und kann sich beliebig oft verändern. Der Interpreter erkennt Variablentypen automatisch und nimmt dem Skripter somit eine Menge Arbeit (vor allem bzgl. der Planung) ab.

===Typen===
Im Folgenden will ich die wichtigsten Variablentypen auflisten und kurz beschreiben.
;Integer (ganze Zahlen)
:Umfasst alle Ganzzahlen, sowohl negative als auch positive.
:Beispiele: -8, 0, 12, 2
;Float (Komma- bzw. gebrochene Zahlen)
:Umfasst alle Fließkommazahlen, sowohl negative als auch positive. Wichtig dabei ist, dass anstelle des Kommas (,) ein Dezimalpunkt (.) zum Trennen des ganzen vom gebrochenen Teil verwendet werden muss.
:Beispiele: -77.2, 0.0, 3.14159, 9.81
;String (Zeichenkette)
:Kann jedes beliebige Zeichen enthalten. Eine maximale Länge ist mir nicht bekannt. Strings müssen immer in Anführungszeichen(" oder ') eingschlossen werden.
:Beispiele: "hallo", 'Lua ist toll!', "", " :D "
;Boolean (Schalter)
:Kann zwei verschiedene Werte enthalten: ''true'' (dt. wahr bzw. an) oder ''false'' (dt. falsch bzw. aus). ''true'' entspricht dabei nicht dem Wert 1 und ''false'' nicht dem Wert 0.
:Beispiele: ''true'', ''false''
;Nil (Leer oder Nichts)
:''nil'' ist sowohl ein Wert als auch ein Typ. Eine Variable vom Typ ''nil'' enthält automatisch den Wert ''nil''. ''nil'' bedeutet ganz einfach nichts. Wenn eine Variable ''nil'' ist, existiert sie nicht. ''nil'' entspricht weder dem Wert 0 noch dem Wert ''false'' noch dem Wert ""!
:Beispiele: ''nil''
Ich werde auf jeden Variablentypen noch detaillierter eingehen. Außerdem wurden hier die Variablentypen '''function''', '''table''' und '''userdata''' nicht aufgeführt, da diese jeweils ein eigenes Kapitel bekommen.

===Deklaration===
Eine Variable deklarieren bedeutet im Grunde genommen eine Variable anlegen. In Lua muss einer Variable bei der Deklaration ein Wert zugewiesen werden. ''nil'' ist dabei als Wert auch möglich, macht jedoch wenig Sinn, da jede beliebige Variablenbezeichnung automatisch den Wert ''nil'' enthält.

Man unterscheidet zwischen '''lokalen''' und '''globalen''' Variablen. Um eine Variable als lokal zu definieren muss das Schlüsselwort ''local'' davor geschrieben werden. Lokal bedeutet für uns im Moment noch ganz einfach, dass die Variable nur im aktuellen Script verfügbar ist. Sollten also z.B. von einem Programm zwei verschiedene Lua Skripte geladen sein und benutzt werden, können diese untereinander auf die globalen Variablen des jeweils anderen Skripts zugreifen, auf die lokalen jedoch nicht. Generell empfiehlt es sich, immer lokale Variablen zu nehmen, falls man nicht explizit eine globale benötig, da so vermieden wird, dass mehrere parallel laufende Skripte aufgrund von gleichen Variablenbezeichnern durcheinander kommen.

====Einzeln====
Deklarieren wir uns also nun unsere erste lokale Variable und geben ihr einen Ganzzahligen Inhalt:
<syntaxhighlight lang="lua">local zahl = 7 -- weist der lokalen Variable zahl den Wert 7 zu</syntaxhighlight>

Eine globale Variable erhält man, indem man einfach das ''local'' weglässt:
<syntaxhighlight lang="lua">gZahl = 13 -- weist der globalen Variable gZahl den Wert 13 zu</syntaxhighlight>

Das selbe geht natürlich nun auch mit allen anderen Variablentypen:
<syntaxhighlight lang="lua">local ganzzahl = -5
local kommazahl = 0.008
local zeichenkette = "Hello World"
local schalter = true
local nichts = nil -- diese Zeile kann man sich im Grunde genommen sparen, da jede nicht deklarierte Variable automatisch den Wert nil hat</syntaxhighlight>

Längere Strings mit mehreren Zeilenumbrüchen können in einer vereinfachten Weise zugewiesen werden. Dies funktioniert so ähnlich wie bei Kommentaren. Anstelle von Anführungszeichen verwendet man [[ als Anfangs- und ]] als Endmarkierung des Strings.
<syntaxhighlight lang="lua">local text = [[Willkommen auf unserem Server.
Bitte halte Dich an die Regeln.
MfG die Administration]]</syntaxhighlight>
Alternativ kann in einem String, der in doppelten Anführungszeichen (") eingeschlossen ist, folgende Steuerzeichen enthalten:
;\n
:Entspricht einem Zeilenumbruch.
;\t
:Entspricht einem Tabulator.
;\"
:Wird verwendet, um doppelte Anführungszeichen in einem String, der von doppelten Anführungszeichen eingeschlossen ist, darzustellen, ohne dass der Interpreter diese fälschlicherweise als Stringende auffasst.
;\'
:Wie \", nur gilt dies in Strings, die von einfachen Anführungszeichen eingeschlossen sind.
;\\
:Entspricht einem Backslash (\)

====Mehrere====
Man kann in einer Zeile mehrere Variablen deklarieren, indem man sie mit Kommas voneinander trennt. Die Variablentypen können dabei alle unterschiedlich sein. Hier mal ein Beispiel:
<syntaxhighlight lang="lua">local frucht, anzahl, reif = "apfel", 4, true</syntaxhighlight>
''local'' darf dabei nur einmal am Zeilenanfang stehen und bewirkt, dass alle dahinter aufgelisteten Variablen lokal werden.<br>
Sollten links neben dem Gleichheitszeichen mehr Variablenbezeichner stehen als rechts Werte, so bleiben die überschüssigen Variablen ''nil''. Im umgekehrten Fall werden überschüssige Werte rechts einfach ignoriert.

Der Unterstrich (_) kann verwendet werden, wenn ein Wert auf der rechten Seite ignoriert werden soll.
<syntaxhighlight lang="lua">local _, farbe = 7, "blau"</syntaxhighlight>
Dabei wird der Wert 7 komplett ignoriert und der Variable farbe der Wert "blau" zugewiesen. Diese Methode wird erst Sinn ergeben, wenn wir uns mit Funktionen und deren Rückgabewerte beschäftigen. Ich wollte sie jedoch der Vollständigkeit halber hier schon einmal erwähnen.


==Operatoren==
===Arithmetische===
Arithmetische Operatoren werden verwendet, um Berechnungen durchzuführen. Somit kann man entweder mit Variablen, festen Zahlen oder einer Mischung neue Werte berechnen oder verändern.<br>
Bei Berechnungen gilt stets: '''Punkt- vor Strichrechnung'''.
<br><br>
;Plus (+)
:Addiert zwei Werte miteinander.
<syntaxhighlight lang="lua">local a, b = 3, 8
local c = a + b -- a + b entspricht hier der Rechnung 3 + 8, c erhält nun also den Wert 11</syntaxhighlight>
;Minus (-)
:Subtrahiert den zweiten vom ersten Wert.
<syntaxhighlight lang="lua">local a, b = 3, 8
local c = a - b -- a - b entspricht hier der Rechnung 3 - 8, c erhält nun also den Wert -5</syntaxhighlight>
;Mal (*)
:Multipliziert zwei Werte miteinander.
<syntaxhighlight lang="lua">local a, b = 3, 8
local c = a * b -- a * b entspricht hier der Rechnung 3 * 8, c erhält nun also den Wert 24</syntaxhighlight>
;Geteilt (/)
:Dividiert den ersten durch den zweiten Wert. Hierbei entsteht in den meisten Fällen eine Kommazahl!
<syntaxhighlight lang="lua">local a, b = 3, 8
local c = a / b -- a / b entspricht hier der Rechnung 3 / 8, c erhält nun also den Wert 0.375</syntaxhighlight>
<br>
;Modulo (%)
:Ermittelt den Rest, der übrig bleibt, wenn man die erste Zahl durch die zweite teilt.
:Der Modulo-Operator gehört zur Punktrechnung.
<syntaxhighlight lang="lua">local a, b = 14, 3
local c = a % b -- a % b entspricht hier der Rechnung 14 % 3, c erhält nun also den Wert 2, da 14 / 3 = 4 REST 2</syntaxhighlight>
;Minus (-) (als Vorzeichen)
:Dient zur Darstellung einer negativen Zahl, also einer Zahl unter 0.
<syntaxhighlight lang="lua">local a = -3 -- entspricht der Rechnung a = 0 - 3</syntaxhighlight>
;Hoch (^)
:Potenziert die erste Zahl mit der zweiten.
:Potenzen werden noch '''vor''' der Punktrechnung ausgerechnet.
<syntaxhighlight lang="lua">local a, b = 3, 8
local c = a ^ b -- a ^ b entspricht hier der Rechnung 3 ^ 8 (3<sup>8</sup>), c erhält nun also den Wert 6561</syntaxhighlight>
<br>

===Logische===
Logische Operatoren werden Benutzt, um Werte miteinander zu vergleichen und mehrere Bedingungen zu verknüpfen. Wir werden genauer auf sie zurückkommen, wenn es um Bedingungen geht. Bis dahin reicht es, wenn man sich merkt, dass ein logischer Vergleich entweder ''true'' (wenn die Aussage wahr ist) oder ''false'' (wenn die Aussage falsch ist) ergibt.
<br><br>
;Gleich (==)
:Prüft, ob zwei Werte gleich sind.
<syntaxhighlight lang="lua">local a = (5 == 5) -- a ist true, da die Aussage wahr ist
local b = (5 == 8) -- b ist false, da die Aussage falsch ist</syntaxhighlight>
;Ungleich (~=)
:Prüft, ob zwei Werte ungleich sind.
<syntaxhighlight lang="lua">local a = (5 ~= 5) -- a ist false, da die Aussage falsch ist
local b = (5 == 8) -- b ist true, da die Aussage wahr ist</syntaxhighlight>
;Größer als (>)
:Prüft, ob der erste Wert größer als der zweite ist.
<syntaxhighlight lang="lua">local a = (5 > 5) -- a ist false, da die Aussage falsch ist
local b = (5 > 8) -- b ist false, da die Aussage falsch ist
local c = (8 > 5) -- c ist true, da die Aussage wahr ist</syntaxhighlight>
;Größer als oder gleich (>=)
:Prüft, ob der erste Wert größer als der zweite ist oder dem zweiten gleicht.
<syntaxhighlight lang="lua">local a = (5 >= 5) -- a ist true, da die Aussage wahr ist
local b = (5 >= 8) -- b ist false, da die Aussage falsch ist
local c = (8 >= 5) -- c ist true, da die Aussage wahr ist</syntaxhighlight>
;Kleiner als (<)
:Prüft, ob der erste Wert kleiner als der zweite ist.
<syntaxhighlight lang="lua">local a = (5 < 5) -- a ist false, da die Aussage falsch ist
local b = (5 < 8) -- b ist true, da die Aussage wahr ist
local c = (8 < 5) -- c ist false, da die Aussage falsch ist</syntaxhighlight>
;Kleiner als (<=)
:Prüft, ob der erste Wert kleiner als der zweite ist oder dem zweiten gleicht.
<syntaxhighlight lang="lua">local a = (5 <= 5) -- a ist true, da die Aussage wahr ist
local b = (5 <= 8) -- b ist true, da die Aussage wahr ist
local c = (8 <= 5) -- c ist false, da die Aussage falsch ist</syntaxhighlight>
<br>
;Und (and)
:Verknüpft zwei Bedingungen miteinander.
<syntaxhighlight lang="lua">local a = (true and false) -- a ist false, da nicht beide Aussagen wahr sind
local b = (5 < 8) and (7 == 7) -- b ist true, da beide Aussagen wahr sind
local c = (8 > 5) and (1 ~= 2) and (0 <= -7) -- c ist false, da die dritte Aussage falsch ist</syntaxhighlight>
;Oder (or)
:Verknüpft zwei Bedingungen miteinander.
<syntaxhighlight lang="lua">local a = (true or false) -- a ist true, da die erste Aussage wahr ist
local b = (5 < 8) or (7 == 7) -- b ist true, da mindestens eine der Aussagen wahr ist
local c = (8 > 5) or (1 ~= 2) or (0 <= -7) -- c ist true, da mindestens eine der Aussagen wahr ist</syntaxhighlight>
;Nicht (not)
:Kehrt einen Booleanwert um.
<syntaxhighlight lang="lua">local a = not true -- a ist false
local b = not false -- b ist true
local c = not (0 == 8) -- c ist true, da die Aussage falsch ist</syntaxhighlight>
<br>
===Sonstige===
Lua hat noch zwei weitere Operatoren, die sich jedoch nicht in die oberen Gruppen eingliedern lassen.
<br>
;Länge (#)
:Steht für die Länge eines Strings oder einer Table.
<syntaxhighlight lang="lua">local sprache = "deutsch"
local laenge = #sprache -- laenge wird hier auf 7 gesetzt, da das Wort "deutsch" 7 Buchstaben hat</syntaxhighlight>
;Verknüpfung (..)
:Verknüpft zwei Strings miteinander.
<syntaxhighlight lang="lua">local geschlecht, alter = "männlich", "18"
local satz = "Ich bin "..geschlecht.." und "..alter.." Jahre alt." -- weist satz den Wert "Ich bin männlich und 18 Jahre alt." zu</syntaxhighlight>
<br><br>
Natürlich können auch alle anderen Variablentypen mit- und untereinander verglichen werden.<br>
Der Längenoperator (#) sowie der Verknüpfungsoperator (..) sind nur für Strings gedacht, wobei der erste später noch bei Tables eine Rolle spielen wird und der zweite es nicht so genau nimmt mit den Variablentypen. Bei Booleans und ''nil'' jedoch führt er in jedem Fall zu einem Fehler. Wir kommen später noch darauf zu sprechen, wie man soetwas umgeht.<br>
Für Integer und Floats sind alle Vergleichsoperatoren und die arithmetischen verfügbar. Strings unterstützen nur die Vergleichsoperatoren, wobei man mit den größer/kleiner Operatoren zwei Strings nach dem Alphabet ordnen kann.
<syntaxhighlight lang="lua">"a" < "b" -- ergibt true, da a vor b im Alphabet kommt</syntaxhighlight>
Strings, Booleans und ''nil'' kann man nur untereinander vergleichen, nicht miteinander. Miteinander führt in jedem Fall zu ''false''.


==Funktionen==
===Einführung===
Eine Funktion ist mehr oder weniger ein Variablentyp.