»Lua Core«

Tables

Häufig kommt es vor, dass man in einem Script jede Menge Variablen des gleichen Datentyps benötigt und diesen Variablen voneinander abhängige Werte zuweisen will. Dabei wäre es äußerst mühsam, jede Variable beim Namen zu nennen und ihr einen neuen Wert zuzuweisen.Wesentlich vorteilhafter wäre dafür ein automatisierter Ablauf. Auch kommt es oft vor, dass man mit Daten-blocks hantieren muss. Angenommen man möchte ein Spiel mit mehreren Spielern erstellen, und jeder Spieler bekommt für seine Daten die Variablen spieler1leben, spieler1punkte, wie sollte man denn dann weitere Spieler hinzufügen? Automatisiert kann man nämlich leider keine Variablen spieler2leben und spieler2punkte hinzufügen lassen. Mithilfe von Tables ist das aber möglich, denn dort kann man automatisiert Einträge hinzufügen lassen.

Was genau ist aber eine Table? Eine Table wird in vielen Programmiersprachen auch als Array bezeichnet und ist im Grunde nichts anderes als eine Tabelle mit Spalten und Zeilen, die man selbst definiert. Mit speziellen Funktionen, die der Lua Core bereithält, lässt sich die Anzahl der vorhandenen Einträge in einer Table auslesen und auch verändern. Ein kleines Beispielscript soll das veranschaulichen.

spieler = {"hans","fritz","peter"}

for i=1,table.getn(spieler) do print(spieler[i]) end

In diesem Beispielscript wird zuerst eine neue Table namens "spieler" erstellt (die Daten einer Table müssen immer von geschweiften Klammern eingeschlossen werden). Die Table besteht im Moment aus nur einer Zeile, aber drei Elementen ("Spalten"), die da wären: hans, fritz, peter. Die 3 Elemente werden jeweils durch ein Komma voneinander getrennt und können Zeichenketten und/oder Zahlen enthalten (ein Mix aus beiden Datentypen ist möglich). Hier kommt nun auch die for-Schleife wieder ins Spiel, mit der man viel Schreibart sparen kann und die Funktionalität des Programms erhöhen kann. In diesem Fall startet die for-Schleife mit dem Initialwert 1. Die Obergrenze wird mittels table.getn(spieler) festgelegt. Hierbei handelt es sich um eine Funktion für Tables aus dem Lua Core, mit dem die Anzahl der Einträge in einer Table ermittelt werden kann. In diesem Fall hätte table.getn(spieler) den Rückgabewert 3, da die Table spieler aus 3 Elementen besteht. Praktischerweise könnten wir ein paar weitere Elemente hinzufügen. Das hat aber keinerlei Beeinträchtigung der Funktionalität der for-Schleife zur Folge. Anstatt von 1 bis 3 "rennt" sie nun von 1 bis zur neuen Anzahl an Elementen in der Table spieler. Die for-Schleife muss hierbei nicht editiert werden! In einem Programm, dass für diese Aktion simple Variablen verwendet, wäre diese Automatisierung und diese Interaktivität gar nicht möglich. Genau genommen könnte man die Anzahl an Spielern während der Laufzeit des Scriptes gar nicht erhöhen.

spieler = {"hans","fritz","peter","ludwig","walter","franz","vincent","juergen"}

for i=1,table.getn(spieler) do print(spieler[i]) end

Neben Variablen vom Typ String und vom Typ Zahl kann ein Tableelement ebenso eine Variable vom Typ Table beziehungsweise eine Table selbst beinhalten. Dass wiederum bedeutet, dass man unendlich verschachtelte Tables erzeugen kann und es meist sogar genügt, für allgemeinere Gruppierungen nur eine einzige Table zu verwenden:

spieler =   {
        {"hans",leben=100,1,schild=150,slogan="ich habe es drauf!"},
        {"fritz",leben=90,3,schild=137,slogan="Fritz flitzt!"},
        {"peter",leben=89,2,schild=110,slogan="Peter 4 president"},
        {"ludwig",leben=100,11,schild=150,slogan="Ludwig, gestatten!"},
        {"walter",leben=56,2,schild=29,slogan="ich habe es auch drauf!"},
        {"franz",leben=100,9,schild=150,slogan="franz kanns!"},
        {"vincent",leben=12,1,schild=135,slogan="ich kann es leider nicht..."},
        {"juergen",leben=100,4,schild=150,slogan="ich schon!"}
      }

for i=1,table.getn(spieler) do print("Spieler: "..spieler[i][1]) print(" | ") print("Lebenspunkte: "..spieler[i].leben) print(" | ") print("Level: "..spieler[i][3]) print(" | ") print("Ruestung: "..spieler[i].schild) print(" | ") print("Slogan: "..spieler[i].slogan) print("\n") end

Die Table spieler enthält also immer noch 8 Elemente auf der Hauptebene. Allerdings handelt es sich bei jedem Element selbst wieder um eine Table, welche selbst jeweils 5 Elemente besitzt. Die for-schleife arbeitet sich nun durch die 8 Hauptelemente im Intervall i[1;8]. Jedes dieser Elemente, welches wiederum eine Table mit Elementen ist, enthält weitere 5 Elemente, die in der Regel über spieler[i][Elementposition] angesprochen werden können. Es gibt aber auch Ausnahmen und somit die Möglichkeiten, in einem Element nicht nur einen Wert, sondern sogar eine Variablendefinition selbst (hier am Beispiel von leben=100, schild=150 und slogan="blablabla") zu speichern. Abgerufen werden kann dieser Wert dann nicht über table[Elementposition][Elementposition], sondern über table[Elementposition].variablenname . Mit table[Elementposition][Elementposition] und table[Elementposition].variablenname lässt sich aber nicht nur der Wert eines Tableelements auslesen, sondern auch editieren,und dass mithilfe der Operatoren, die für "ganz normale" Variablen gelten:

spieler =   {
        {"hans",leben=100,1,schild=150,slogan="ich habe es drauf!"},
        {"fritz",leben=90,3,schild=137,slogan="Fritz flitzt!"},
        {"peter",leben=89,2,schild=110,slogan="Peter 4 president"},
        {"ludwig",leben=100,11,schild=150,slogan="Ludwig, gestatten!"}
        ,,
        {"franz",leben=100,9,schild=150,slogan="franz kanns!"},
        {"vincent",leben=12,1,schild=135,slogan="ich kann es leider nicht..."},
        {"juergen",leben=100,4,schild=150,slogan="ich schon!"}
      }

spieler[5] = {} spieler[5][1] = "walter" spieler[5].leben=56 spieler[5][3]=2 spieler[5].schild=29 spieler[5].slogan="ich habe es auch drauf!"

for i=1,table.getn(spieler) do print("Spieler: "..spieler[i][1]) print(" | ") print("Lebenspunkte: "..spieler[i].leben) print(" | ") print("Level: "..spieler[i][3]) print(" | ") print("Ruestung: "..spieler[i].schild) print(" | ") print("Slogan: "..spieler[i].slogan) print("\n") end

Tables können aufgrund ihrer Komplexität manchmal sehr "erschlagend" wirken. Der beste Weg, um mit ihnen vertraut zu werden, ist und bleibt ein und der selbe: Übung.

Schleifen

Nachdem wir uns mit der Struktur des "if-Blocks" befasst haben, gehen wir nun über zu der so genannten Struktur der "Schleifen". Die Struktur der Schleifen kann untergliedert werden in die for-Schleife, die while-Schleife und die repeat-until-Schleife. Generell handelt es sich bei einer Schleife, im Englischen auch als "loop" bezeichnet, um eine elementare Struktur der Lua-Syntax, die ähnlich wie der if-Block aufgebaut ist. Allerdings können Schleifen mehr als nur einmal "durchlaufen" werden. Während die Fallunterscheidung in einem if-Block einmal statt findet und der Lua-Interpreter nach dessen Ausführung den nachfolgenden Code weiter interpretiert und ausführt, können Schleifen wiederholt werden. Je nach Bedingung kann der Lua-Interpreter nach der Ausführung der Schleife wieder zum Beginn der Schleife "zurückspringen" und die Schleife erneut "durchlaufen". Schleifen können dabei auch unendlich oft wiederholt werden, was von sehr großem Nutzen sein kann.

Die wohl elementarste Schleifenstruktur ist die while-Schleife:

mampfi = 1

while mampfi == 1 do print("es geht!") end

Wie für Variablen gibt es auch für Schleifen einige wichtige Operatoren. Man kann zwischen den folgenden Operatoren unterscheiden:

== ist der Vergleichsoperator und gibt einen gültigen Wahrheitswert zurück, falls die Variable mit dem Vergleichswert übereinstimmt

= ist der Operator für Größer-Gleich-Vergleiche und gibt einen gültigen Wahrheitswert zurück, falls die Variable größer oder gleich dem Vergleichswert ist <= ist der Operator für Kleiner-Gleich-Vergleiche und gibt einen gültigen Wahrheitswert zurück, falls die Variable kleiner oder gleich dem Vergleichswert ist ~= ist der Ungleichheitsoperator und gibt einen gültigen Wahrheitswert zurück, falls die Variable nicht mit dem Vergleichswert übereinstimmt not ist der Operator für die Existenzüberprüfung einer Varaible und gibt einen gültigen Wahrheitswert zurück, falls die Variable nicht existiert

Die Variable selbst als Bedingung gibt einen gültigen Wahrheitswert zurück, falls sie existiert. Die Vergleichswerte, also die Werte die rechts vom Operator stehen, können jeden Wert, wie er auch in einer Variablen gespeichert werden kann, annehmen.

Im obigen Beispiel wird eine neue Variable namens mampfi erstellt und ihr der Zahlenwert 1 zugewiesen. Die Nedingung der while-Schleife überprüft, ob mampfi wirklich den Wert 1 enthält. Ist das der Fall, wird der Codeblock, der sich innerhalb der Schleife befindet, ausgeführt. In diesem konkreten Fall wird nach der Ausführung die Schleife unendlich oft erneut ausgeführt, denn mampfi ändert seinen Wert nicht und die Bedingung bleibt unendlich lange wahr (mampfi ist gleich 1). Selbstverständlich kann man die Zeit der Durchläufe, beziehungsweise die Anzahl der Durchläufe selbst bestimmen:

mampfi = 1

while mampfi <= 10 do print("es geht!") mampfi = mampfi + 1 end

In diesem Fall erhält mampfi den Initialwert 1. Die Bedingung der while-Schleife prüft, ob der Wert von mampfi kleiner oder gleich 10 ist. Dies ist zu Beginn der Fall, daher wird der Inhalt der Schleife ausgeführt. Dabei wird der Text "es geht!" ausgegeben und die Variable mampfi um 1 erhöht. Daraufhin wird die Schleife noch neun weitere Male wiederholt, bis mampfi letztendlich den Wert 11 annimmt. Speziell für Fälle dieser Art mit begrenzter Anzahl an Ausführungen und einer kontinuierlichen Vergrößerung eines Varaiblenwerts wurde eine weitere Schleifenstruktur eingeführt: die for-Schleife.

for mampfi = 1,10 do
  print("es geht!")
end

Diese for-Schleife hat exakt das selbe Ergebnis zur Folge wie vorher die while-Schleife. Allerdings ist die Struktur der for-Schleife in diesem Fall um einiges übersichtlicher und einfacher. Im Gegensatz zur while-Schleife wird innerhalb der Bedingung der for-Schleife eine neue Variable mampfi mit dem Initialwert 1 eingeführt. Abgetrennt durch ein Komma folgt der Endwert 10. Während des Durchlaufs des Lua-Interpreters wird diese Variable selbstständig bis zum Endwert erhöht. Es hat sich allerdings eingebürgert, dass man anstatt mampfi die Variable mit dem Namen i verwendet; i steht dabei für Index. Selbstverständlich kann dort aber auch jede andere Namenskonvention stehen. Besonders zu beachten ist bei der for-Schleife, dass es nur einen einzigen Operator gibt, nämlich den Zuweisungsoperator, wie er ganz konventionell für Variablen gilt. In späteren Kapiteln werden die Vorteile der for-Schleife gegenüber der while-Schleife in einigen speziellen Fällen noch wesentlich deutlicher.

Die dritte und letzte Schleifenstruktur in Lua nennt sich "repeat-until"-Schleife. Diese Schleife lässt sich auch als Negierung der while-Schleife bezeichnen. Während die while-Schleife zuerst die Bedingung überprüft und anschließend den eingebetteten Code ausführt, wird die repeat-until-Schleife zuerst ausgeführt und dann die Bedingung überprüft. Ein Beispiel soll diesen elementaren Unterschied erklären:

mampfi = 30

repeat print (mampfi) mampfi = mampfi - 1 until mampfi <= 10

Für die repeat-until-Schleife sind dieselben Operatoren verfügbar wie auch für den if-Block und die while-Schleife. Obiges Beispiel gibt den Wert der Variablen mampfi aus, verringert ihren Wert um 1 und wiederholt diesen Vorgang, solange mampfi nicht den Wert kleiner oder gleich 10 annimmt.

Blöcke

Bisher hast du dich bei der Programmierung in Lua absolut auf lineare Anwendungen, also Programme ohne irgendwelche Sprünge und Auslassungen, konzentriert. Ein Programm lebt aber davon, dass es interaktiv ist, und nicht nur der Reihe nach Text ausgibt. Dem wollen wir nur nun mehr und mehr Abhilfe schaffen. Um dem Programm "Interaktivität" zu verleihen, gibt es in der Lua-Syntax so allerhand Strukturen mit denen man beispielsweise Fallunterscheidungen, Auflistungen und Wiederholungen erzeugen kann. Diese Strukturen werden als "Schleifen" bezeichnet, eine bestimmte dieser Strukturen auch als "Block".

Ohne lange Erklärungen starten wir direkt mit der Implementierung der Block-Struktur, der so genannte "if-Block". Der "if-Block" stellt die Struktur der Fallunterscheidung dar und ermöglicht die Ausführung individueller Codeblöcke unter speziellen Bedingungen. Ein kleines Beispiel soll die Funktionsweise des "if-Blocks" veranschaulichen:

mampfi = 1
doppelmampfi = 2
 
ganz_was_anderes = "hi, wie gehts"
 
if mampfi == 1 then
  print(ganz_was_anderes.."? - sehr gut!")
end
if doppelmampfi == 2 then
  print(ganz_was_anderes.."? - "..mampfi.."a")
end

Ganz banal erscheint wieder die Ausgabe "hi, wie gehts? - sehr gut" und "hi, wie gehts? - 1a". Was passiert aber nun, wenn man "if mampfi == 1 then" zu "if mampfi == 2 then" ändert? Der Text "hi, wie gehts? - sehr gut" ist ganz plötzlich verschwunden. Und das aus einem sehr trivialen Grund. Die Struktur "if-Block" überprüft eine Bedingung auf ihren Wahrheitswert. Stimmt dieser Wahrheitswert, dann wird der interne Codeblock, in diesem Fall print(ganzwasanderes.."? - sehr gut!") ausgeführt. In letzterem fall müsste mampfi also wirklich dem Wert 2 entsprechen, um eine Ausgabe des Textes "hi, wie gehts? - sehr gut" zu ermöglichen. Die Bedingung eines if-blocks kann also folgendermaßen formuliert werden:

if mampfi == 1 then ...
if mampfi > 0 then ...
if mampfi < 2 then ...
if mapfi >= 1 then ...
if mampfi <= 1 then ...
if mampfi ~= 0 then ...
if not mampfi then ...
if mampfi then ...
if mampfi == 1 and brot >= 0 then ...
if mampfi <= 1 or (mampfi == 1 and brot >= 1 and wort == "hallo") then ...

Wie für Variablen gibt es auch für if-Blocks einige wichtige Operatoren. Man kann zwischen den folgenden Operatoren unterscheiden:

== ist der Vergleichsoperator und gibt einen gültigen Wahrheitswert zurück, falls die Variable mit dem Vergleichswert übereinstimmt

= ist der Operator für Größer-Gleich-Vergleiche und gibt einen gültigen Wahrheitswert zurück, falls die Variable größer oder gleich dem Vergleichswert ist <= ist der Operator für Kleiner-Gleich-Vergleiche und gibt einen gültigen Wahrheitswert zurück, falls die Variable kleiner oder gleich dem Vergleichswert ist ~= ist der Ungleichheitsoperator und gibt einen gültigen Wahrheitswert zurück, falls die Variable nicht mit dem Vergleichswert übereinstimmt not ist der Operator für die Existenzüberprüfung einer Varaible und gibt einen gültigen Wahrheitswert zurück, falls die Variable nicht existiert

Die Variable selbst als Bedingung gibt einen gültigen Wahrheitswert zurück, falls sie existiert. Die Vergleichswerte, also die Werte die rechts vom Operator stehen, können jeden Wert, wie er auch in einer Variablen gespeichert werden kann, annehmen. Ein if-Block kann neben einer verschachtelten Bedingungskomposition auch selbst einen komplexeren Bau beziehungsweise mehrfache Blöcke darstellen:

mampfi = 1
doppelmampfi = 2
 
ganz_was_anderes = "hi, wie gehts"
 
if mampfi == 1 then
  print(ganz_was_anderes.."? - sehr gut!")
elseif doppelmampfi == 2 then
  print(ganz_was_anderes.."? - "..mampfi.."a")
else
  print("weder mampfi noch doppelmampfi stimmen mit dem Vergleichswert überein!"
end

Mehrere if-Blöcke kann man also mit "elseif" verknüpfen. Mit "else" kann man einen alternativen Block erstellen, der ausgeführt wird, wenn die Variable mit dem Vergleichswert je nach Operator übereinstimmt beziehungsweise nicht übereinstimmt, wenn also der zurückgegebene Wahrheitswert des Operators falsch ist. Selbstverständlich kann man if-Blocks noch tiefer verschachteln, man kann in einen if-Block noch jede Menge weitere if-Blocks einbauen. Um Verwirrungen weitgehend auszuschliessen folgt nun noch eine Komplettübersicht über den Aufbau des if-Blocks:

if (not) variable (==/<=/>=/~=) (zeichenkette/zahl/variable) then
  --deine aktion
[elseif (not) variable (==/<=/>=/~=) (zeichenkette/zahl/variable) then
  --deine aktion]
[else
  --deine aktion]
end

Die Konstruktionen, die in eckige oder runde Klammern eingefasst sind, sind nicht zwingend erforderlich. Werden diese Konstruktionen weggelassen, bleibt die elementarste mögliche Struktur eines if-Blocks zurück. In der Regel wird aber weitaus mehr benötigt als nur diese elementare Struktur.

Variablen

Variablen sind ein weiterer grundlegender Teil von Lua. Grundsätzlich kann man Variablen als "Container" oder "Topf" sehen, in dem man Werte ablegen kann. Das können Zahlen, Zeichenketten und "Boolsche Werte" sein. Um die Notwendigkeit von Variablen im Allgemeinen verstehen zu können, ist ein wenig "Hardwarekunde" notwendig. Genauer gesagt muss der RAM, oder auch Arbeitsspeicher, genannt ein wenig genauer unter die Lupe genommen werden.

Der Arbeitsspeicher ist ein wesentlicher Bauteil eines jeden Computers oder "computerähnlichen" Geräts. Jedes mal, wenn eine Anwendung ausgeführt wird, wird sie vollständig in den RAM geladen. Den RAM kann man sich dabei als eine gigantische Ansammlung von aneinandergereihten Töpfen vorstellen, wobei jeder Topf eine Kombination aus acht 1en und 0en enthalten kann. Der Computer kennt nämlich aufgrund seiner physikalischen Beschaffenheit nur die Zustände 1 und 0, also Strom fliesst, oder Strom fliesst nicht. Diese Eigenschaft lässt sich wunderbar in Hardwareschaltungen ausnutzen, es können Berechnungen mit den 1en und 0en ausgeführt werden. So können durch ein Zusammenspiel von Chemie und Physik "Hardwaregatter" gebaut werden, die zum Beispiel eine Addition von zwei Zuständen im Binärsystem ermöglichen. Uns ist dieses "Binärsystem" aber nicht vertraut, wir rechnen selbst alltäglich nur im "Dezimalsystem". Die Folgen von Bits (1en und 0en) lassen sich aber problemlos ins Dezimalsystem, und auch umgekehrt, umwandeln. Die Folge 11010111 steht zum Beispiel für die Zahl 215. Eine Bitfolge, bestehend aus acht 1en und 0en, wurde als Byte festgelegt. Die größte, darin speicherbare Bitfolge ist 11111111 und steht für die Dezimalzahl 255. Im Arbeitsspeicher können alle Werte eines Programms gespeichert werden, allerdings in Form von 1en und 0en. Kommazahlen werden dabei in einer anderen Kodierung gespeichert als natürliche Zahlen. In vielen Programmiersprachen muss daher angegeben werden, um was für einen Zahlentypen, man spricht auch vom Dateitypen, es sich dabei handelt. Das ist in Lua nicht der Fall, der Interpreter erledigt das alles vollkommen automatisch.

Fazit: Variablennamen und ihr zugewiesener Wert werden im Arbeitsspeicher des Computers in Form von 1en und 0en abgelegt. Variablenname und Wert sind dabei eng verknüpft, über den Variablennamen gelangt man an den darin gespeicherten Wert.

Eine ganze Menge Theorie dürfte nun für Verwirrung gesorgt haben. Daher widmen wir uns jetzt der Erstellung und dem Gebrauch von Variablen:

mampfi = 1
doppelmampfi = 2
 
ganz_was_anderes = "hi, wie gehts"

Hierbei handelt es sich um die Variablen "mampfi", "doppelmampfi" und "ganzwasanderes". Wie sich erkennen lässt ist eine Variable nichts anderes als eine Zeichenfolge, bestehend aus Buchstaben von A-Z und Zahlen 0-9. Variablennamen dürfen nur aus Buchstaben von A-Z (a-z) und Zahlen von 0-9 bestehen, Sonderzeichen und alleinstehende Zahlen sind nicht erlaubt. Die Variable "mampfi" ist nach der Zuweisung eines Zahlenwerts mittels des "Zuweisungsoperators" "=" gleichwertig mit der Zahl 1, "doppelmampfi" ist gleichwertig mit der Zahl 2 und "ganzwasanderes" speichert die Zeichenkette "hi, wie gehts". Die Werte können jederzeit abgerufen werden, aber auch wieder geändert werden. Diese Eigenschaften sind durchaus nützlich. An Variablen führt absolut kein weg vorbei. Ein paar wenige Beispielprogramme sollen dies veranschaulichen:

mampfi = 1
 
print(mampfi)
print("mampfi")

Hier liegt das Augenmerk auf der Ausgabe. Die erste Textausgabe gibt die Zahl 1 aus, die zweite Textausgabe hingegen gibt die Zeichenkette "mampfi" aus. Das kommt daher, weil die Variable "mampfi" den Wert 1 enthält. Bei der zweiten Textausgabe aber ist das Argument der print-Funktion nicht die Variable "mampfi", sondern eine Zeichenkette!

Fazit: Zeichenketten werden grundsätzlich von Anführungszeichen umhüllt. Variablen müssen immer ohne Anführungszeichen stehen, Variablennamen sind selbst keine anzeigbaren Zeichenketten, sonder nur Synonyme für eine Zahl oder Zeichenkette.

Selbstverständlich kann man auch eine Variable mit print() ausgeben, die eine Zeichenkette enthält:

ganz_was_anderes = "hi, wie gehts"
print(ganz_was_anderes)

Ebenso sind mathematische Rechenoperation mit Variablen möglich:

mampfi = 1
doppelmampfi = 2
 
print(mampfi+mampfi)
print(2*mampfi)
print(doppelmampfi)
print(doppelmampfi-2*mampfi)

Wie auch in der Mathematik gilt hier die Regel: Potenz vor Klammer vor Punkt vor Strich.

  • ist der Operator für die Multiplikation / ist der Operator für die Division % ist der Operator für die Modulo-Division
  • ist der Operator für die Addition
  • ist der Operator für die Subtraktion ^ ist der Operator für Potenzen

Zuletzt folgt noch ein kurzes Beispiel, wie man Variablen für die Textausgabe verknüpfen beziehungsweise mit Zeichenketten mischen kann.

mampfi = 1
doppelmampfi = 2
 
ganz_was_anderes = "hi, wie gehts"
 
print(ganz_was_anderes.."? - sehr gut!")
print(ganz_was_anderes.."? - "..mampfi.."a")

Wenn es Fragen geben sollte, poste diese doch bitte ins Forum auf http://www.bumuckl.com.

Entwicklungsumgebung für Lua

Da der Lua-Interpreter nun installiert ist sollst du nicht lange auf die Folter gespannt, sondern gleich mit dem ersten Script konfrontiert werden. Dazu wird allerdings noch ein Editor benötigt, mit dem man Lua programmieren kann. Du kannst dafür zwar den vom Betriebssystem mitgelieferten Standardeditor verwenden, dieser ist aber meist recht unkomfortabel. Viel besser eignen sich speziell für Programmierarbeiten gefertigte Editoren, die beispielsweise "Syntax Highlighting" (markiert Code in mehreren Farben, zeigt Zeilen an etc) und "Code Completion" (vervollständigt den Code automatisch, setzt Klammern etc) besitzen.

Komfortable Editoren:

Notepad++ - schöner, schlanker Editor mit Syntax Highlighting für zahlreiche Programmiersprachen, unter anderem auch für Lua Download: http://notepad-plus.sourceforge.net/de/site.htm

LuaEdit - eine speziell für Lua ausgerichtete Entwicklungsumgebung mit Syntax Highlighting, Hilfestellungen und einem eingebauten Lua-Interpreter Download: http://luaedit.luaforge.net/

Es gibt selbstverständlich noch viel mehr verschiedene Editoren und Entwicklungsumgebungen für Lua. Wer mit der Schlichtheit von Notepad++ oder mit LuaEdit nicht zufrieden ist, kann sich natürlich auch mit Google über Alternativen informieren.

Nachdem du dir einen geeigneten Editor besorgt und installiert hast, sollst du aber nun endlich in den Genuss eines Lua-Codes kommen.

Categories

Tags