Schnelleinstieg in Lua-Scripting

Lua ist eine leichte, effiziente und einfach zu erlernende Skriptsprache und zählt zu einer der beliebtesten Skriptsprachen für die Einbettung in Anwendungen, um den Nutzern eine Schnittstelle bereitzustellen, mit der die Anwendung nach eigenen Bedürfnissen angepasst und gesteuert werden kann.

Der Hauptvorteil von Lua liegt in seiner Einfachheit und Flexibilität. Lua-Code ist leicht verständlich und erfordert nur minimale Programmierkenntnisse, um loszulegen. Ein Lua-Script muss vor der Ausführung nicht kompiliert werden. Dies ermöglicht eine schnelle und einfache Anpassung des Codes bei Bedarf.

In VxCraft wird Lua für verschiedene Bereiche wie z. B. Einstellungen, Werkzeugskripten und insbesondere Postprozessoren verwendet.

Grundlagen

Auch wenn Lua eine einfache Skriptsprache ist, würde eine vollständige Dokumentation den Rahmen dieses Handbuchs sprengen. Daher konzentriert sich dieses Kapitel nur auf das absolut Notwendigste und bietet einen kurzen Überblick über die Grundlagen von Lua. Dennoch sollte es ausreichend sein, um eigene Anpassungen an vorhandenen Skripten vorzunehmen und einfache Skripte selbst zu erstellen.

Für weiterführende Informationen zu Lua gibt es zahlreiche Online-Ressourcen, die leicht zugänglich sind.

In den Skript-Beispielen dieses Kapitels wird die Funktion vxPrint() zur Ausgabe auf dem Bildschirm genutzt. vxPrint() ist eine von VxCraft bereitgestellte Funktion, die dazu dient, Inhalte in der Postprozessor-Konsole anzuzeigen. Es ist wichtig zu beachten, dass diese Funktion keine native Lua-Funktion ist, sondern speziell für die Verwendung in VxCraft entwickelt wurde.

Kommentare

Kommentare sind eine wichtige Ergänzung in einem Skript, um den Code verständlicher zu machen und anderen Entwicklern oder auch sich selbst Hinweise und Erklärungen zu hinterlassen. In Lua gibt es zwei Arten von Kommentaren:

Einzeilige Kommentare

Einzeilige Kommentare beginnen mit zwei Bindestrichen (--) und erstrecken sich bis zum Ende der Zeile. Lua ignoriert alles nach den Bindestrichen und interpretiert es nicht als Code.

local myvar = 1+2 -- Dies ist ein einzeiliger Kommentar nach einem Ausdruck

Mehrzeilige Kommentare

Mehrzeilige Kommentare beginnen mit --[[ und enden mit ]]. Alles zwischen diesen Markierungen wird als Kommentar behandelt und vom Interpreter ignoriert.

local myvar_a = 1+2 --[[
Dies ist ein mehrzeiliger Kommentar
und erstreckt sich über
mehrere Zeilen.]]
local myvar_b = 2+myvar_a

Lua-Case-Sensitivität

Es ist wichtig zu beachten, dass Lua, wie viele andere Programmiersprachen, case-sensitiv ist. Das bedeutet, dass Groß- und Kleinschreibung in Variablennamen, Funktionsnamen und Schlüsselwörtern unterschieden werden. Zum Beispiel werden die Variablen myVariable und MyVariable als zwei verschiedene Variablen behandelt. Achten Sie daher stets darauf, die richtige Schreibweise zu verwenden, um Fehler und unerwartete Verhaltensweisen zu vermeiden.

Variablen und Datentypen

Lua unterstützt verschiedene Datentypen wie nil, number, string, boolean, table, function und userdata. Variablen müssen nicht deklariert werden und erhalten den Datentyp automatisch, wenn ihnen ein Wert zugewiesen wird. Zum Beispiel:

Bedingungen und Kontrollstrukturen

Bedingungen und Kontrollstrukturen sind grundlegende Elemente jeder Programmiersprache und ermöglichen es, den Programmablauf je nach Bedingungen zu steuern. In Lua gibt es mehrere Kontrollstrukturen, wie if-then-else, while und for-Schleifen.

if-then-else

Die if-then-else-Struktur in Lua ist eine Kontrollstruktur, die es ermöglicht, unterschiedliche Codeblöcke basierend auf einer oder mehreren Bedingungen auszuführen. Mit dieser Struktur können Sie den Ablauf Ihres Programms steuern, indem Sie alternative Codepfade abhängig von einer bestimmten Bedingung bereitstellen.

Die grundlegende Syntax der if-then-else-Struktur lautet wie folgt:

if Bedingung1 then
  -- Codeblock1 wird ausgeführt, wenn Bedingung1 wahr ist
elseif Bedingung2 then
  -- Codeblock2 wird ausgeführt, wenn Bedingung1 falsch ist und Bedingung2 wahr ist
else
  -- Codeblock3 wird ausgeführt, wenn alle vorherigen Bedingungen falsch sind
end

Die if-then-else-Struktur beginnt mit dem Schlüsselwort if, gefolgt von einer Bedingung, die entweder wahr oder falsch sein kann. Wenn die Bedingung wahr ist, wird der Codeblock nach dem then-Schlüsselwort ausgeführt. Wenn die Bedingung falsch ist, wird der Codeblock nach dem else-Schlüsselwort ausgeführt, sofern vorhanden.

Der optionale 'elseif'-Skriptblock kann verwendet werden, um zusätzliche Bedingungen zu prüfen, wenn die vorherigen Bedingungen falsch sind. Es ist möglich, mehrere elseif-Blöcke in der if-then-else-Struktur zu verwenden, um verschiedene Bedingungen nacheinander zu prüfen. Die Struktur endet mit dem end-Schlüsselwort.

Die folgende Tabelle zeigt die Vergleichsoperatoren in Lua und ihre Bedeutung:

while-Schleife

Eine while-Schleife wird verwendet, um einen Codeblock so lange auszuführen, wie eine bestimmte Bedingung erfüllt ist.

local i = 1
while i <= 5 do
  vxPrint("Wert von i: ", i, "\n")
  i = i + 1
end

Wert von i: 1
Wert von i: 2
Wert von i: 3
Wert von i: 4
Wert von i: 5

for-Schleife

Die for-Schleife ist eine weitere Art von Schleife, die es ermöglicht, einen Codeblock für eine bestimmte Anzahl von Iterationen auszuführen. Lua unterstützt numerische for-Schleifen und generische for-Schleifen.

Numerische for-Schleife:

local i = 1
for i = 1, 5 do
  vxPrint("Wert von i:", i)
end

Wert von i: 1
Wert von i: 2
Wert von i: 3
Wert von i: 4
Wert von i: 5

Generische for-Schleife:

local t = {"rot", "grün", "blau"}
for k, v in pairs(t) do
  vxPrint("Key: ", k, " Value: ", v, "\n")
end

Key: 1 Value: rot
Key: 2 Value: grün
Key: 3 Value: blau

Funktionen

Funktionen sind wiederverwendbare Codeblöcke, die eine bestimmte Aufgabe ausführen. Sie können Parameter akzeptieren und Werte zurückgeben. Funktionen sind hilfreich, um Code besser zu organisieren und wiederholende Aufgaben zu vermeiden.

Um eine Funktion in Lua zu definieren, verwenden Sie das Schlüsselwort "function" gefolgt von einem Namen für die Funktion und Klammern, die die Parameter enthalten. Der Funktionskörper wird durch das Schlüsselwort "end" abgeschlossen.

function printPosition(x, y, z)
  vxPrint("Pos X: ", x, " Pos Y: ", y, " Pos Z: ", z, "\n")
end

Um die Funktion mit den gewünschten Koordinaten aufzurufen, verwenden Sie den Funktionsnamen gefolgt von Klammern und den entsprechenden Parametern:

printPosition(1, 3.5, 50.0)

Pos X: 1 Pos Y: 3.5 Pos Z: 50.0

Im nächsten Beispiel wird eine Funktion erstellt, die die X- und Y-Koordinaten einer Position um einen bestimmten Winkel um die Z-Achse rotiert und die neu berechneten Koordinaten zurückgibt.

-- Rotiert x und y um den angegebenen 
-- Winkel um die Z-Achse 
function rotateZ(x, y, deg)
  local rad = math.rad(deg)
  local newX = x * math.cos(rad) - y * math.sin(rad)
  local newY = x * math.sin(rad) + y * math.cos(rad)
  return newX, newY
end

local pos_x = 10
local pos_y = 20
local pos_z = 50
printPosition(pos_x, pos_y, pos_z)
--Dreht die Koordinaten um 45° 
--mit Hilfe der rotateZ-Funktion:
pos_x, pos_y = rotateZ(10, 20, 45.0)
printPosition(pos_x, pos_y, pos_z)

Pos X: 10 Pos Y: 20 Pos Z: 50
Pos X: -7.071 Pos Y: 21.213 Pos Z: 50

Skriptablauf und Funktionsaufrufe

In diesem Unterkapitel wird der grundlegende Ablauf von Lua-Skripten und die Verwendung von Funktionen erläutert. Es ist wichtig zu verstehen, wie Lua-Skripte ausgeführt werden und wie Funktionen in diesem Ablauf verwendet werden.

Ein Lua-Skript wird von oben nach unten ausgeführt. Das bedeutet, dass der Code in der Reihenfolge ausgeführt wird, in der er im Skript erscheint. Wenn eine Funktion im Skript definiert ist, wird sie jedoch nicht automatisch ausgeführt. Eine Funktion wird nur dann ausgeführt, wenn sie im Skript explizit aufgerufen wird.

Beachten Sie, dass Funktionen vor ihrem Aufruf im Skript definiert sein müssen. Andernfalls kann Lua die Funktion nicht finden und es kommt zu einem Fehler. Stellen Sie also sicher, dass Ihre Funktionen immer vor ihrem ersten Aufruf definiert werden.

Hier ein einfaches Beispiel, um diese Konzepte zu verdeutlichen:

--Variablen
local home_x = -200;
local home_y =  200;
local home_z =  100;

--Funktion, welche eine fix definierte Home-Position ausgibt
function printHome()
  vxPrint("Homeposition: ", 
           home_x, " ", 
           home_y, " ", 
           home_z, "\n")
end

-- Hauptteil des Skripts
vxPrint("Dies ist der Beginn des Skripts.\n")
vxPrint("Es folgt nun die Ausgabe der Home-Position:\n")
printHome()
vxPrint("nach der Ausgabe der Home-Position,\n"
        .."setz sich das Skript hier fort.")
        
-- Ende des Skripts

Dies ist der Beginn des Skripts.
Es folgt nun die Ausgabe der 
Home-Position:
Homeposition: -200 200 100
nach der Ausgabe der Home-Position,
setz sich das Skript hier fort.

In diesem Beispiel wird der Code von oben nach unten ausgeführt. Zuerst werden die Variablen home_x, home_y und home_z definiert, dann wird die Funktion printHome() definiert, die die vordefinierte Home-Position ausgibt. Anschließend wird der Hauptteil des Skripts ausgeführt, wobei die printHome()-Funktion aufgerufen wird, um die Home-Position auszugeben. Schließlich wird die letzte Zeile des Skripts ausgeführt, die besagt, dass das Skript hier fortgesetzt wird.