Rail-Sim.de - Train Simulator Wiki - Benutzerbeiträge [de]

Sichtfeld einstellen

2012-06-02T16:16:01Z

Patrick:

[[Datei:Sichtwinkel.jpg|miniatur|300px|Das Bild mit dem Sichtwinkel von 45° wirkt deutlich realistischer. ]]Das [http://de.wikipedia.org/wiki/Sichtfeld Sichtfeld] (Fachwort: Field of View, FOV) beschreibt einen Blickwinkel der Kamera.

Im RailWorks wird dieser Blickwinkel in Grad angegeben und besitzt einen Standardwert von 65°. Da ein Sichtwinkel von 65° unrealistisch ist und für abnormale Verzerrungen der Objekte sorgt, ist es ratsam, diesen auf einen Winkel von 45° einzustellen.

== Manuelles einstellen des Winkels ==

Um dies zu erreichen, ist folgende Vorgehensweise notwendig:

# Öffnen Sie das RailWorks-Stammverzeichnis.
# Öffnen Sie den Datei "dev\scripts\engineScript.lua", Kontextmenü -> Öffnen mit... -> Editor.
# In den Funktionen autorunDEBUG() und autorun()...
# ...ersetzen Sie das Argument in setFOV() mit dem gewünschten Winkel (45 empfohlen).
# Datei speichern.

Erstellen Sie sich eine Sicherheitskopie von der Datei, wenn Sie im Umgang mit Lua-Scripten nicht vertraut sind.

In der Funktion setDof() können Sie die Entfernungen für die [http://de.wikipedia.org/wiki/Sch%C3%A4rfentiefe Tiefenunschärfe] (Fachwort: Depth of Field, DOF) einstellen. Das erste Argument beschreibt die Entfernung, in der die Tiefenunschärfe beginnt; Das zweite Argument beschreibt die Entfernung, in der die Tiefenunschärfe voll ausgeprägt ist.

== Hintergrundinformationen ==

Die Perspektive wird in visuellen Programmen mithilfe einer Perspektivenmatrix (Fachwort: Perspective Matrix) gesteuert. Das Resultat einer Perspektivenmatrix ist ein View Frostum, in dem Objekte projeziert werden. Durch die Projektion werden Punkte aus dem Sichtraum (Fachwort: View Space) in das richtige Bildverhältnis gesetzt.

Die Perspektivenmatrix wird aus dem Field of View, Aspect Ratio, minimalen Sichttiefe und maximalen Sichttiefe beschrieben. Das Aspect Ratio ist hierbei ein Verhältnis, das via Bildbreite/Bildhöhe berechnet wird.

[[Kategorie:Tutorials]]

Sichtfeld einstellen

2012-06-02T10:19:17Z

Patrick:

[[Datei:Sichtwinkel.jpg|miniatur|300px|Das Bild mit dem Sichtwinkel von 45° wirkt deutlich realistischer. ]]Das [http://de.wikipedia.org/wiki/Sichtfeld Sichtfeld] (Fachwort: Field of View, FOV) beschreibt einen Blickwinkel der Kamera.

Im RailWorks wird dieser Blickwinkel in Grad angegeben und besitzt einen Standardwert von 65°. Da ein Sichtwinkel von 65° unrealistisch ist und für abnormale Verzerrungen der Objekte sorgt, ist es ratsam, diesen auf einen Winkel von 45° einzustellen.

== Manuelles einstellen des Winkels ==

Um dies zu erreichen, ist folgende Vorgehensweise notwendig:

# Öffnen Sie das RailWorks-Stammverzeichnis.
# Öffnen Sie den Datei "dev\scripts\engineScript.lua", Kontextmenü -> Öffnen mit... -> Editor.
# In den Funktionen autorunDEBUG() und autorun()...
# ...ersetzen Sie das Argument in setFOV() mit dem gewünschten Winkel (45 empfohlen).
# Datei speichern.

Erstellen Sie sich eine Sicherheitskopie von der Datei, wenn Sie im Umgang mit Lua-Scripten nicht vertraut sind.

In der Funktion setDof() können Sie die Entfernungen für die [http://de.wikipedia.org/wiki/Sch%C3%A4rfentiefe Tiefenunschärfe] (Fachwort: Depth of Field, DOF) einstellen. Das erste Argument beschreibt die Entfernung, in der die Tiefenunschärfe beginnt; Das zweite Argument beschreibt die Entfernung, in der Sie voll ausgeprägt ist.

== Hintergrundinformationen ==

Die Perspektive wird in visuellen Programmen mithilfe einer Perspektivenmatrix (Fachwort: Perspective Matrix) gesteuert. Das Resultat einer Perspektivenmatrix ist ein View Frostum, in dem Objekte projeziert werden. Durch die Projektion werden Punkte aus dem Sichtraum (Fachwort: View Space) in das richtige Bildverhältnis gesetzt.

Die Perspektivenmatrix wird aus dem Field of View, Aspect Ratio, minimalen Sichttiefe und maximalen Sichttiefe beschrieben. Das Aspect Ratio ist hierbei ein Verhältnis, das via Bildbreite/Bildhöhe berechnet wird.

[[Kategorie:Tutorials]]

Sichtfeld einstellen

2012-06-02T10:16:21Z

Patrick:

[[Datei:Sichtwinkel.jpg|miniatur|300px|Das Bild mit dem Sichtwinkel von 45° wirkt deutlich realistischer. ]]Das [http://de.wikipedia.org/wiki/Sichtfeld Sichtfeld] (Fachwort: Field of View, FOV) beschreibt einen Blickwinkel der Kamera.

Im RailWorks wird dieser Blickwinkel in Grad angegeben und besitzt einen Standardwert von 65°. Da ein Sichtwinkel von 65° unrealistisch ist und für abnormale Verzerrungen der Objekte sorgt, ist es ratsam, diesen auf einen Winkel von 45° einzustellen.

== Manuelles einstellen des Winkels ==

Um dies zu erreichen, ist folgende Vorgehensweise notwendig:

# Öffnen Sie das RailWorks-Stammverzeichnis.
# Öffnen Sie den Datei "dev\scripts\engineScript.lua", Kontextmenü -> Öffnen mit... -> Editor.
# In den Funktionen autorunDEBUG() und autorun()...
# ...ersetzen Sie das Argument in setFOV() mit dem gewünschten Winkel (45 empfohlen).
# Datei speichern.

Erstellen Sie sich eine Sicherheitskopie von der Datei, wenn Sie im Umgang mit Lua-Scripten nicht vertraut sind.

In der Funktion setDof() können Sie die Entfernungen für die [http://de.wikipedia.org/wiki/Sch%C3%A4rfentiefe Tiefenunschärfe] (Fachwort: Depth of Field, DOF) einstellen. Das erste Argument beschreibt die Entfernung, in der die Tiefenunschärfe beginnt; Das zweite Argument beschreibt die Entfernung, in der Sie voll ausgeprägt ist.

== Hintergrundinformationen ==

Die Perspektive wird in visuellen Programmen mithilfe einer Perspektivenmatrix (Fachwort: Perspective Matrix) gesteuert. Das Resultat einer Perspektivenmatrix ist ein View Frostum, in dem Objekte projeziert werden. Durch die Projektion werden Punkte aus dem Sichtraum (Fachwort: View Space) in das richtige Bildverhältnis gesetzt.

Die Perspektivenmatrix wird aus dem Field of View, Aspect Ratio, minimalen Sichttiefe und maximalen Sichttiefe beschrieben. Das Aspect Ratio ist hierbei ein Verhältnis, das via Bildbreite/Bildhöhe berechnet wird.

Datei:Sichtwinkel.jpg

2012-06-02T10:08:44Z

Patrick: Der korrekte Sichtwinkel beträgt 45°. Der falsche Standardwert von RailWorks beträgt 65°. Das Bild mit dem Sichtwinkel von 45° wirkt deutlich realistischer.

Der korrekte Sichtwinkel beträgt 45°. Der falsche Standardwert von RailWorks beträgt 65°. Das Bild mit dem Sichtwinkel von 45° wirkt deutlich realistischer.

Sichtfeld einstellen

2012-06-02T09:29:00Z

Patrick:

Das [http://de.wikipedia.org/wiki/Sichtfeld Sichtfeld] (Fachwort: Field of View, FOV) beschreibt einen Blickwinkel der Kamera.

Im RailWorks wird dieser Blickwinkel in Grad angegeben und besitzt einen Standardwert von 65°. Da ein Sichtwinkel von 65° unrealistisch ist und für abnormale Verzerrungen der Objekte sorgt, ist es ratsam, diesen auf einen Winkel von 45° einzustellen.

== Manuelles einstellen des Winkels ==

Um dies zu erreichen, ist folgende Vorgehensweise notwendig:

# Öffnen Sie das RailWorks-Stammverzeichnis.
# Öffnen Sie den Datei "dev\scripts\engineScript.lua", Kontextmenü -> Öffnen mit... -> Editor.
# In den Funktionen autorunDEBUG() und autorun()...
# ...ersetzen Sie das Argument in setFOV() mit dem gewünschten Winkel (45 empfohlen).
# Datei speichern.

Erstellen Sie sich eine Sicherheitskopie von der Datei, wenn Sie im Umgang mit Lua-Scripten nicht vertraut sind.

In der Funktion setDof() können Sie die Entfernungen für die [http://de.wikipedia.org/wiki/Sch%C3%A4rfentiefe Tiefenunschärfe] (Fachwort: Depth of Field, DOF) einstellen. Das erste Argument beschreibt die Entfernung, in der die Tiefenunschärfe beginnt; Das zweite Argument beschreibt die Entfernung, in der Sie voll ausgeprägt ist.

== Hintergrundinformationen ==

Die Perspektive wird in visuellen Programmen mithilfe einer Perspektivenmatrix (Fachwort: Perspective Matrix) gesteuert. Das Resultat einer Perspektivenmatrix ist ein View Frostum, in dem Objekte projeziert werden. Durch die Projektion werden Punkte aus dem Sichtraum (Fachwort: View Space) in das richtige Bildverhältnis gesetzt.

Die Perspektivenmatrix wird aus dem Field of View, Aspect Ratio, minimalen Sichttiefe und maximalen Sichttiefe beschrieben. Das Aspect Ratio ist hierbei ein Verhältnis, das via Bildbreite/Bildhöhe berechnet wird.

Sichtfeld einstellen

2012-06-02T09:28:22Z

Patrick:

== Beschreibung ==

Das [http://de.wikipedia.org/wiki/Sichtfeld Sichtfeld] (Fachwort: Field of View, FOV) beschreibt einen Blickwinkel der Kamera.

Im RailWorks wird dieser Blickwinkel in Grad angegeben und besitzt einen Standardwert von 65°. Da ein Sichtwinkel von 65° unrealistisch ist und für abnormale Verzerrungen der Objekte sorgt, ist es ratsam, diesen auf einen Winkel von 45° einzustellen.

== Manuelles einstellen des Winkels ==

Um dies zu erreichen, ist folgende Vorgehensweise notwendig:

# Öffnen Sie das RailWorks-Stammverzeichnis.
# Öffnen Sie den Datei "dev\scripts\engineScript.lua", Kontextmenü -> Öffnen mit... -> Editor.
# In den Funktionen autorunDEBUG() und autorun()...
# ...ersetzen Sie das Argument in setFOV() mit dem gewünschten Winkel (45 empfohlen).
# Datei speichern.

Erstellen Sie sich eine Sicherheitskopie von der Datei, wenn Sie im Umgang mit Lua-Scripten nicht vertraut sind.

In der Funktion setDof() können Sie die Entfernungen für die [http://de.wikipedia.org/wiki/Sch%C3%A4rfentiefe Tiefenunschärfe] (Fachwort: Depth of Field, DOF) einstellen. Das erste Argument beschreibt die Entfernung, in der die Tiefenunschärfe beginnt; Das zweite Argument beschreibt die Entfernung, in der Sie voll ausgeprägt ist.

== Hintergrundinformationen ==

Die Perspektive wird in visuellen Programmen mithilfe einer Perspektivenmatrix (Fachwort: Perspective Matrix) gesteuert. Das Resultat einer Perspektivenmatrix ist ein View Frostum, in dem Objekte projeziert werden. Durch die Projektion werden Punkte aus dem Sichtraum (Fachwort: View Space) in das richtige Bildverhältnis gesetzt.

Die Perspektivenmatrix wird aus dem Field of View, Aspect Ratio, minimalen Sichttiefe und maximalen Sichttiefe beschrieben. Das Aspect Ratio ist hierbei ein Verhältnis, das via Bildbreite/Bildhöhe berechnet wird.

Sichtfeld einstellen

2012-06-02T09:27:14Z

Patrick: Die Seite wurde neu angelegt: „= Beschreibung = Das [http://de.wikipedia.org/wiki/Sichtfeld Sichtfeld] (Fachwort: Field of View, FOV) beschreibt einen Blickwinkel der Kamera. Im RailWorks …“

= Beschreibung =

Das [http://de.wikipedia.org/wiki/Sichtfeld Sichtfeld] (Fachwort: Field of View, FOV) beschreibt einen Blickwinkel der Kamera.

Im RailWorks wird dieser Blickwinkel in Grad angegeben und besitzt einen Standardwert von 65°. Da ein Sichtwinkel von 65° unrealistisch ist und für abnormale Verzerrungen der Objekte sorgt, ist es ratsam, diesen auf einen Winkel von 45° einzustellen.

= Manuelles einstellen des Winkels =

Um dies zu erreichen, ist folgende Vorgehensweise notwendig:

# Öffnen Sie das RailWorks-Stammverzeichnis.
# Öffnen Sie den Datei "dev\scripts\engineScript.lua", Kontextmenü -> Öffnen mit... -> Editor.
# In den Funktionen autorunDEBUG() und autorun()...
# ...ersetzen Sie das Argument in setFOV() mit dem gewünschten Winkel (45 empfohlen).
# Datei speichern.

Erstellen Sie sich eine Sicherheitskopie von der Datei, wenn Sie im Umgang mit Lua-Scripten nicht vertraut sind.

In der Funktion setDof() können Sie die Entfernungen für die [http://de.wikipedia.org/wiki/Sch%C3%A4rfentiefe Tiefenunschärfe] (Fachwort: Depth of Field, DOF) einstellen. Das erste Argument beschreibt die Entfernung, in der die Tiefenunschärfe beginnt; Das zweite Argument beschreibt die Entfernung, in der Sie voll ausgeprägt ist.

= Hintergrundinformationen =

Die Perspektive wird in visuellen Programmen mithilfe einer Perspektivenmatrix (Fachwort: Perspective Matrix) gesteuert. Das Resultat einer Perspektivenmatrix ist ein View Frostum, in dem Objekte projeziert werden. Durch die Projektion werden Punkte aus dem Sichtraum (Fachwort: View Space) in das richtige Bildverhältnis gesetzt.

Die Perspektivenmatrix wird aus dem Field of View, Aspect Ratio, minimalen Sichttiefe und maximalen Sichttiefe beschrieben. Das Aspect Ratio ist hierbei ein Verhältnis, das via Bildbreite/Bildhöhe berechnet wird.

Scriptsprache Lua

2011-09-19T15:36:48Z

Patrick: Hinzufügung des Tutorials #2.

Übersicht über Tutorials mit dem Thema LUA Scripting.

* [[Das Lua-Tutorial - 1 Grundlagen|Das Lua-Tutorial - #1 Grundlagen]]
* [[Das Lua-Tutorial - 2 Tipps und Bibliotheken|Das Lua-Tutorial - #2 Tipps und Bibliotheken]]

[[Kategorie:Tutorials]]

Das Lua-Tutorial - 2 Tipps und Bibliotheken

2011-09-19T15:35:03Z

Patrick: Die Seite wurde neu angelegt: „= Das Lua-Tutorial - #2 Tipps und Bibliotheken = Im ersten Teil wurde geklärt, was eine Skriptsprache ist, welchen Editor man für die Bearbeitung nehmen sollte.…“

= Das Lua-Tutorial - #2 Tipps und Bibliotheken =
Im ersten Teil wurde geklärt, was eine Skriptsprache ist, welchen Editor man für die Bearbeitung nehmen sollte. 
Es wurden die wichtigsten Sprachelemente wie Variablen, If-Else-Verzweigungen, Schleifen, Funktionen und Tabellen vorgestellt.

Am Ende dieses Teils beherrscht man folgende Grundlagen
* Lösen von Programmierfehlern
* Zurechtfinden im offiziellen Lua-Handbuch
* Vereinfachen gängiger Arbeiten
* Projektorganisation und Teamarbeit
* Allgemeine Funktionen und die math-Bibliothek

== Lösen von Programmierfehlern ==

Die meisten Fehlerquellen kennt jeder:
* Tippfehler
* Nichtbeachtung der Großschreibung
* Übergabe eines fehlerhaften Parameters
* Illegaler Aufruf einer Funktion
* Zugriff auf eine Variable, die nicht existiert
* Logikfehler
Doch wenn diese Fehler auftreten, können besonders die letzteren viel Suchzeit in Arbeit beanspruchen, sogar einige Tage.

[[Datei:PP_LUATUT02_01_Fehlermeldung.png|rahmenlos|links|397px]][[Datei:PP_LUATUT02_02_Bug_Report.png|rahmenlos|links|397px]]
Tippfehler sind schnell zu finden: Stimmt der Quellcode nicht, meldet der Interpreter, dass etwas nicht stimmt und benennt 
möglichst genau die betroffene Stelle. Dazu klickt im Dialog der Fehlermeldung auf „Show Bug Report“ und findet Informationen 
zum System, den Prozessen und vor allem: Welcher Fehler eingetreten ist (und eventuell warum) – Rot eingerahmt. 
In diesem Fall habe ich zum Beispiel statt „function“ „funktion“ für einen Funktionsrumpf geschrieben (Zeile 20).

Man sieht: Diese Fehlerquelle ist leicht zu finden und schnell zu lösen.

Die Nichtbeachtung der Groß- und Kleinschreibung führt schnell zu fehlerhaften Funktionsnamen und Variablen.

Hier helfen nur drei Methoden:
* Folge dem Quellcode und schaue nach, ob irgendetwas falsch geschrieben wurde.
* Halte dazu beim Programmieren für Funktionen, Variablen und Tabellen eine einheitliche Namensgebung ein (siehe unten).
* Untersuche Argumente und Variablen mit einer selbstgebauten DebugMessage()-Funktion (siehe Teil 1).

Die Prüfung eines fehlerhaften Arguments kann schnell erledigt sein. Dazu gibt es folgende Möglichkeiten:
* Gib mit der Funktion DebugMessage() eine Informationsnachricht mit den Parametern aus.
* Prüfe die Werte auf Gültigkeit, indem der Wertebereich überprüft wird. Überprüfe Variablen auch auf den Wert nil.

Ein illegaler Aufruf einer Funktion kann einen fatalen Fehler auslösen: Solche Fehler lösen einen zwanghaften Fehlerdialog aus. 
Bekommt eine Funktion Argumente, die außerhalb des zu erwartenden Wertebereiches sind, kann sie entweder Fehlermeldungen ausgeben
oder löst ein unvorhergesehenes Verhalten aus.

Möchte man prüfen, ob eine Variable ungültig ist, muss man Sie nur gegen den Wertebereich oder nil prüfen. 
Da es allerdings viele Variablen im Quellcode gibt, ist dieses Verfahren sehr aufwendig.

Logikfehler lösen ein unerwartetes Programmverhalten aus. Hier gibt es nur eine Lösung:
* Verhalten beobachten, schildern
* Auf dem Papier das Ganze an einem Worst-Case-Szenario durcharbeiten. Tipp: Mit Microsoft® Visio® kann man die Logik an Flussdiagrammen visualisieren.
* Logik verändern und beobachten was passiert

Fehler sind vielschichtig, doch für alles gibt es eine Lösung. Es hilft auch, wenn man seine persönlichen Lieblingsfehler kennt, 
denn dann weiß man, wo man anfangen soll!

Eine weitere Lösung kann das Kommentieren sein: Diese Kommunikationsaufgabe hilft Fehler schneller zu verstehen!

== Das Lua-Handbuch ==
Zur Skriptsprache Lua gibt es ein offizielles Handbuch. Das Handbuch ist im Dokumentationsbereich auf der offiziellen Seite 
von Lua (http://www.lua.org) zu finden. Der Direktlink zum Lua 5.1 Reference Manual lautet http://www.lua.org/manual/5.1/.

Es ist zu beachten, dass das Handbuch nur auf Englisch verfügbar ist nur alle Funktionen allgemein schreibt. 
Teilweise ist Vorwissen aus anderen Programmiersprachen notwendig, um die Hintergründe zu verstehen. 
Für uns sind die Punkte „2 - The Language“ und „5 - Standard Libraries“ wichtig. Die restlichen Punkte sind für 
Anwendungsprogrammierer oder Sprachentwickler wichtig.

Die Sprachdokumentation ist allgemein als Text mit Beispielen beschrieben. 
Die Funktionen werden mit der Definition vorgestellt, was diese Bewirkt und deren Voraussetzungen, 
die Bedeutung der Parameter und der Wertebereich der Argumente sowie die zu erwartenden Rückgabewerte.

Die Inhaltsübersicht auf der Hauptseite listet die einzelnen Themen auf. Scrollt man auf der Hauptseite herunter, 
sind alle eigenen Lua-Funktionen aufgelistet. Auf der rechten Spalte findet man unter dem Namen „C API“ und „auxilary library“ 
eine Dokumentation für Anwendungsprogrammierer.

== Vereinfachen gängiger Arbeiten ==
Dieser Abschnitt hätte auch den Titel „Tipps zum Überleben“ bekommen können. Und darum geht es jetzt: Tipps, 
damit das Chaos vermieden wird. Die Funktion von Kommentaren wurde im ersten Teil geklärt. 
Dennoch gibt es viele Fragen, wie man diese sinnvoll anwendet. Es folgen ein paar Tipps und Vorlagen:

=== Informationen zur Datei ===
Wie beschrieben sollten hier Informationen stehen, was die Datei allgemein macht, wer sie geschrieben hat, 
wann sie geschrieben und was an ihr verändert wurde. Zusatzinformationen wie die verwendete Lizenz, 
die Dokumentationssprache und der Name der Gruppe tragen ebenfalls zur Übersicht bei und sind teilweise Pflicht. 
Das folgende Bild zeigt eine exemplarische Dokumentation (ohne Lizenz):

[[Datei:PP_LUATUT02_03_HeaderDoc.png|rahmenlos|605px]]

=== Beschreibung globaler Definitionen ===
Im Grunde müssen globale Definitionen nur beschreiben, was diese bedeuten. Beispiel:

[[Datei:PP_LUATUT02_04_GlobalVar.png|rahmenlos|830px]]

=== Funktionen ===
Funktionen benötigen ebenfalls eine Dokumentation (ganz wichtig!):
* Was macht die Funktion?
* Welche Parameter gibt es? Welche Argumente sind gültig? Abhängigkeiten?
* Welche Rückgabewerte sind zu erwarten? Fehlerbehandlung?

Hierzu ein Beispiel:

[[Datei:PP_LUATUT02_05_Funktionen.png|rahmenlos|604px]]

Aufgabenfelder / Programmblöcke / Rümpfe

Hier sollte man nicht beschreiben, was die Sprachkonstrukte machen, sondern warum bestimmte Prozesse notwendig sind und wie diese zusammenhängen. Diese Dokumentation sollte den Logikprozess abbilden – und nicht die Sprache. Ein Beispiel siehe oben bei den Funktionen (Warum interessiert mich die Nachricht überhaupt nicht?).

Wie benennt man Variablen und Funktionen?

Nach dem vereinbarten Muster der Gruppe. Doch es gibt Grundregeln: '''P'''ascal'''C'''ase oder '''c'''amel'''C'''ase.

Globale Definitionen werden oftmals <code>KOMPLETT_GROSS</code> und mit Unterstrich in Worte getrennt: 
<code>pxpPZB_MGN_2000</code> ist so ein Beispiel. Der Name der Gruppe (<code>pxp</code>) wurde hier vor der Definition klein angefügt. 
Ansonsten schreibe ich Variablen im PascalCase: <code>TrainSpeed</code>.

Globalen Variablen bekommen bei mir ein sogenanntes Prefix: <code>g_</code>. Damit ist eindeutig, dass diese Variable global ist. 
Beispiel: <code>g_TrainData</code>.

Wenn möglich, schreibe ich Funktionen im camelCase. Damit die Funktionsgruppe erkennbar ist, 
nutze ich ein Verb: <code>create</code>, <code>release</code>, <code>get</code>, <code>set</code>, <code>is</code> oder <code>has</code>. Beispiel:

<code>function isPZBContactActive()</code>

Das ganze Prinzip wird in den folgenden Beispielprojekten (z.B. Signale) sicherlich klar.

== Projektorganisation und Teamarbeit ==
Projekte sollten einen eigenen Ordner bekommen, wenn dies möglich ist. 
Alle Dateien eines Projekts sollten in einem eigenen Ordner nach Funktion sortiert werden. Z.B.
* Objekte in „Meshes“
* Texturen in „Textures“
* Vorlagen in „Templates“
* Skripte in „Scripts“
* Grundmodelle in „Template Meshes“

Wichtig ist, dass man alle Daten einer bestimmten Version zuordnen kann, damit der Austausch der Dateien einfach vonstattengeht.

Die Versionsverwaltung kann man für relativ kleine Projekte manuell selbst auf einem Downloadserver durchführen. 
Ein paar FTP-Accounts und schon kann das Austauschen beginnen. Eine Teamplattform ist natürlich von Vorteil.

Für größere Projekte, an denen viele Mitarbeiter (ab 5) arbeiten, empfiehlt es sich eine Software zu nehmen 
und einen Online-Server, auf denen man mit wenigen Klicks alles austauschen kann.

Eine solche Software ist zum Beispiel TortoiseSVN mit einem passenden Onlinespeicher. Dieses Verfahren 
wird in einem anderen Tutorial beschrieben, da es den Rahmen dieses Tutorials sprengen würde.

'''Wichtig ist: Sei auf den neuesten Stand und gib Bescheid, wenn Daten aktualisiert worden sind. 
Und dokumentiere was wo wann geändert wurde.'''

== Die Mathematikbibliothek ==
Dieser Abschnitt stellt die wichtigsten Funktionen und die Mathematikbibliothek vor.

=== Allgemeine Funktionen ===
{| class="wikitable"
|-
| assert(value[, message]) || Löst einen fatalen Fehler aus, wenn value false oder nil ist. Gibt die Nachricht message aus.
|-
| dofile(filepath) || Führt eine Datei aus. Der Arbeitsordner (Current Working Directory) bezieht sich auf den Ordner, in dem sich die RailWorks.exe befindet.
|-
| print(text) || Schreibt text in die Konsole bzw. schreibt ihn in die Log-Datei.
|-
| tonumber(text) || Wandelt text in eine Zahl um. Gibt nil zurück, wenn es nicht funktionierte.
|-
| tostring(value) || Wandelt einen Wert in einen Text um.
|-
| type(value) || Gibt den Datentyp von value in Textform zurück: „nil“, „number“, „string“, „table“, „function“, „boolean“, „thread“ oder „userdata“.
|-
| key, value = inpairs(table) || Für die generische For-Schleife. Iteriert eine Tabelle. key besitzt den Namen des Schlüssels, value den Wert.
|}

[[Datei:PP_LUATUT02_06_Math.png|rahmenlos|267px]]

=== Die Bibliothek math ===
Der Zugriff auf die math-Bibliothek erfolgt über die Tabelle math: math.(Funktion). Die wichtigsten Funktionen sind fett markiert.

{| class="wikitable"
|-
| '''abs(x)''' || '''Gibt den absoluten Wert von x zurück.'''
|-
| acos(x) || Gibt den Arkuscosinus von x in Radiant zurück.
|-
| asin(x) || Gibt den Arkussinus von x in Radiant zurück.
|-
| atan(x) || Gibt den Arkustangens von x in Radiant zurück.
|-
| '''ceil(x)''' || '''Rundet die Zahl x auf (Ganzzahl).'''
|-
| cos(x) || Berechnet den Cosinus von x in Radiant.
|-
| cosh(x) || Berechnet den Cosinus Hyperbolicus von x in Radiant.
|-
| deg(radian) || Berechnet den Winkel in Grad von radian.
|-
| exp(x) || Berechnet e^x.
|-
| '''floor(x)''' || '''Rundet x ab'''.
|-
| fmod(x, y) || Gibt den Rest der Division x/y zurück. Er ist zwischen [0 und < y).
|-
| frexp(x) || Gibt m und e so zurück, dass x = m * pow(2, e) gilt. e ist eine Ganzzahl und der absolute Wert von m ist zwischen [0.5 und 1) – oder 0 wenn x 0 ist.
|-
| huge (Variable) || Der größte anzunehmende Zahlenwert.
|-
| ldexp(m, e) || Berechnet m * exp(x).
|-
| log(x) || Berechnet den natürlichen Logarithmus 〖log〗_e (x).
|-
| log10(x) || Berechnet 〖log〗_10 (x).
|-
| max(a, b, …) || Gibt den größten aller Werte zurück.
|-
| min(a, b, …) || Gibt den kleinsten aller Werte zurück.
|-
| modf(x) || Gibt zwei Werte von x zurück: Den Integralen (Ganzzahl) und den Rationalen.
|-
| pi (Variable) || π (3.1415…)
|-
| '''pow(x, n)''' || '''Berechnet x^n'''.
|-
| rad(degree) || Wandelt einen Winkel von Grad nach Radiant um.
|-
| '''random([max[, min])''' || '''Berechnet eine Zufallszahl. Wenn max angegeben ist, ist der Wert zwischen 0 bis max. Wenn min angegeben ist, zwischen min bis max. Ansonsten von 0 bis 1.'''
|-
| randomseed(x) || Setzt den Seed des Zufallsgenerators.
|-
| sin(x) || Berechnet den Sinus von x in Radiant.
|-
| sinh(x) || Berechnet den Sinus Hyperbolicus von x in Radiant.
|-
| '''sqrt(x)''' || '''Wurzel aus x. x muss größer als 0 sein.'''
|-
| tan(x) || Berechnet den Tangens von x in Radiant.
|-
| tanh(x) || Berechnet den Tangens Hyperbolicus von x in Radiant.
|}

== Zusammenfassung des Teils ==
In diesem Teil wurden Programmiertipps gegeben. Zudem wurden die wichtigsten Funktionen und die Mathematikbibliothek vorgestellt. 
Es gibt noch weitere Bibliotheken: Dazu ist ein Blick in die offizielle Dokumentation unverzichtbar: „5 - Standard Libraries“.

Im nächsten Teil werden Besonderheiten bezüglich RailWorks 3 vorgestellt.

Datei:PP LUATUT02 06 Math.png

2011-09-19T15:34:11Z

Patrick: Ausgabe von Zufallswerten in Lua.

Ausgabe von Zufallswerten in Lua.

Datei:PP LUATUT02 05 Funktionen.png

2011-09-19T15:32:53Z

Patrick: Beispielhafte Funktionsdokumentation in Lua.

Beispielhafte Funktionsdokumentation in Lua.

Datei:PP LUATUT02 04 GlobalVar.png

2011-09-19T15:31:52Z

Patrick: Beispielhafte Dokumentation von globalen Variablen in Lua.

Beispielhafte Dokumentation von globalen Variablen in Lua.

Datei:PP LUATUT02 03 HeaderDoc.png

2011-09-19T15:30:38Z

Patrick: Beispiel einer Lua-Headerdokumentation.

Beispiel einer Lua-Headerdokumentation.

Datei:PP LUATUT02 02 Bug Report.png

2011-09-19T15:26:11Z

Patrick: Lua Error Report in LuaEdit.

Lua Error Report in LuaEdit.

Datei:PP LUATUT02 01 Fehlermeldung.png

2011-09-19T15:24:39Z

Patrick: Fehlermeldung-Dialog in LuaEdit.

Fehlermeldung-Dialog in LuaEdit.

Das Lua-Tutorial - 1 Grundlagen

2011-09-18T21:53:09Z

Patrick: /* Schleifen */

[[Kategorie:Scriptsprache Lua]]

= Das Lua-Tutorial - 1 Grundlagen =

Diese Artikelserie zeigt, wie man mit Lua eigene Funktionen in das Programm einbinden kann. „#1 – Grundlagen“ erklärt das Fundament von Lua und wie man damit arbeitet. Es ist spezifisch für RailWorks ausgelegt.

== Was ist Lua und was benötige ich? ==

Lua ist eine Formsprache, mit der man ein Programm von außen steuern kann. Was heißt „außen“ und wie ist das gemeint?

Ein Programm besitzt einen inneren Kern, der immer gleich abläuft – er ist fest verankert und damit von „innen“ gesteuert.
Wir können ihn mit normalen Mitteln nicht verändern. Lässt ein Programm zu, dass es veränderbar ist,
dann lässt es eine Steuerung von außen zu. Das kann mit einer Konfigurationsdatei („Bildschirmauflösung einstellen“)
oder einem Script gelöst sein. Das Script sagt was der Kern erledigen soll.
Und diese Scripte werden zum Beispiel mit Lua geschrieben – darum geht es hier.

Um solche Scripte zu schreiben, muss man einer Formsprache exakt folgen. Das ist wie Tangotanzen auf der Showbühne: Nur das unser Tanzpartner die Tastatur ist. Die Formsprache beschreibt uns die Regeln, wie etwas zu formulieren ist, welche Möglichkeiten gegeben sind und was dadurch ausgelöst wird.

Natürlich passiert es schnell, dass mal nicht alles glatt läuft. Und zum Glück gibt es Programme, die uns unterstützen, Fehler durch korrekten Text zu ersetzen. Diesen Text den wir schreiben, nennt man Quellcode.

Ein Programm, das ich sehr gerne nutze und empfehle, ist [http://luaforge.net/frs/?group_id=84&release_id=553 LuaEdit 3.03RC]. Es ist einfach organisiert und ermöglicht eine schnelle Überprüfung der Formsprache. So sieht das Programm aus, wenn man Scripte schreibt (siehe rechts).

[[Datei:PP_LUATUT01_01_LuaEdit_3.03RC.png|miniatur|Die Entwicklungsumgebung [http://luaforge.net/frs/?group_id=84&release_id=553 LuaEdit 3.03RC] ]]
Oben haben wir ein Menü. Es ermöglicht allgemeine Operationen, Sichteinstellungen, Projektverwaltung, einen Test durchzuführen und das starten von Tools.

In der oberen Toolleiste finden wir in der ersten Gruppe Felder zum erzeugen neuer Dateien oder Projekte.
In der zweiten Gruppe können wir Dateien öffnen und speichern. In der dritten Gruppe können wir
Dateien zu Projekten zuordnen. Die vierte Gruppe ermöglicht das Drucken. Die fünfte Gruppe kann
den Testdurchlauf beeinflussen. Die sechste Gruppe ermöglicht das Prüfen der Syntax und
das Erstellen von kompilierten Scripten. Die siebente Gruppe ermöglicht das Suchen und
das Setzen von Haltepunkten im Script, wenn wir einen Testdurchlauf durchführen.

Die untere Toolleiste vereinfacht das Bearbeiten von Text. Dazu zählt zum Beispiel
das automatische Ein- und Auskommentieren oder Verrücken von Text.
Am besten probiert man an einem Testtext, was der jeweiligen Schalter bewirkt :-).

Ich habe bei der Beschreibung das Wort „Kompilieren“ in den Raum geworfen.
Das ganze muss man sich so vorstellen: Wir schreiben Text in lesbarer Form,
den wir verändern können. Kompilieren wir den Text, wird unser geschriebenes
interpretiert und mit programmeigenen Anweisungen übersetzt. Die programmeigenen
Anweisungen können wir natürlich nicht ohne weiteres frei bearbeiten.
Das ganze macht man, damit man Zeit spart, weil die Interpretation manchmal
ganz schön lange dauern kann, wenn man sehr viele Scriptdateien hat.
Aber damit müssen wir uns in RailWorks nicht herumärgern: Das macht RailWorks für uns, leider.

== Kommentieren hilft ==

Scripten ist eine Gemeinschaftsaufgabe. Schreiben wir Quellcode, müssen wir später verstehen,
was wir geschrieben haben. Und unseren Mitgliedern hilft es, Fehler schneller und leichter zu entlarven,
um sie auszumerzen. Ein Kommentar ist dabei etwas, was nicht vom Interpreter (dem „Leser“) beachtet wird.

Er wird mit zwei arabischen Zahlstrichen angefangen (--) und gilt für die eine Zeile. Etwa so:

-- Kommentare sind für folgende Fälle gedacht:

* '''Hinweise am Anfang der Dateien'''
** wer, was, wann und wie etwas geändert hat.
** Falls notwendig: Nenne
*** die verwendete Sprache
*** den Namen der Gruppe
*** oder die Lizenz (und/oder deren Bedingungen).
* '''Eigenschaften der Funktionen'''
** Was sie machen sollen oder bewirken
** Wann sie verwendet werden dürfen
** Welche Parameter zulässig sind und was sie bedeuten – die Einheiten
** Rückgabewerte, wenn Sie vorhanden sind
* '''Beschreibung der Aufgabenfelder'''
** was wie erledigt werden soll
** welche Werte warum besondere Rollen spielen.

Es ist ein logischer Prozess und wird eine Menge Schreibarbeit verursachen. Aber das Tutorial ist so ausgelegt, dass die „Kommunikationsaufgabe Kommentieren“ als Routine ein leichtes Spiel wird.

== Variablen und Werte ==

Informationen müssen gespeichert werden: Dieser Aufgabe werden Variablen gerecht. Ihre Werte werden durch logische Berechnungsprozesse oder festgelegte Logik bestimmt.

Damit man unterscheiden kann, was Werte beinhalten, unterteilt man diese in Dateitypen. Für uns wichtig kann sein:

{| class="wikitable"
|-
! Datentyp !! Beschreibung !! Beispiel
|-
| string || Ein Text aus einer Verkettung von Zeichen. || „Hallo Welt“
|-
| number || Eine Zahl. Bei Gleitkommazahlen schreibt man mit Punkt statt mit Komma. Ein „f“ kann zusätzlich stehen und hat für uns keine Bedeutung. || 3, 5, 9 2.6, 3.1415f
|-
| Boolean || Ein Wahrheitswert. Wahr oder Falsch. || Wert: true oder false
|-
| nil || Eine Variable, die keinen Wert hat: Datentyplos. || Wert: nil
|-
| table || Eine Tabelle: „Array“. || Definition: { }
|}

Der Datentyp wird zur Laufzeit gewählt und ist bei vielen Typen austauschbar. So kann ein string zum Beispiel zu einer Zahl umgewandelt werden, wenn dies möglich ist. Ein Wahrheitswert, eine Zahl oder auch nil kann zu einem Text umgewandelt werden.

Die Definition einer Variable ist einfach – man schreibt sie in folgender Form auf:

[Name] = [Wert]

Dazu ein paar Beispiele:

[[Datei:PP_LUATUT01_02_Variablendefinitionen.png|rahmenlos|231px|Variablendefinitionen in Lua.]]

Ganz links ist die Zeilennummer, Einzustellen in den Optionen von LuaEdit.
Die Namensgebung von Variablen entspricht den obigen Beispielen: Sie darf mit einem Buchstaben anfangen, der keine Nummer ist. Nach dem ersten Buchstaben darf man Nummern verwenden – das meidet man allerdings.

== Operatoren ==

Beim Programmieren unterscheidet man in drei Arten von Operationen:
* Arithmetische Operationen (Rechenoperationen)
* Relationale Operationen (Vergleichsoperationen) und
* Logische Operationen

Jede Gruppe deckt bestimmte Aufgabenfelder ab. So dienen arithmetische Operationen der Berechnung von Werten und relationale und logische Operationen dem Vergleich von Werten.

Dieser Abschnitt beschäftigt sich mit Rechenoperationen. Das sind die Operatoren

* "=" --> Zuweisungsoperator
* "+" --> Additionsoparator
* "-" --> Subtraktionsoperator oder auch Negationsoperator
* "*" --> Multiplikationsoperator
* "/" --> Divisionsoperator
* ".." --> Verknüpfungsoperator

Um diese Funktion zu verdeutlichen, dienen folgende Beispiele:

[[Datei:PP_LUATUT01_03_ArOperationen.png|rahmenlos|534px|Operatorenbeispiele in Lua]]

== Kontrollstrukturen und Schleifen ==

=== Anweisungen und Rümpfe ===

Jede Anweisung wird in einem Rumpf ausgeführt. Dabei unterscheidet man in
* Anweisungsrümpfe
* Branchrümpfe
* Branchrümpfe der If-Else-Kontrollstrukturen

Branchrümpfe begrenzen einen Programmblock und benötigen eine Bedingung:
<code>(Bedingung) '''then''' 
(Anweisung) 
'''end'''</code>

Sie werden mit then eingeleitet und mit end beendet.

Anweisungsrümpfe der If-Else-Kontrollstrukturen werden wie Anweisungsrümpfe definiert, können jedoch ohne das Schlüsselwort end beendet werden, wenn sie mit elseif oder else beendet werden.

<code>'''if''' (Bedingung) '''then''' 
(Anweisung) 
'''elseif''' (Bedingung) '''...'''</code>

Anweisungen wie a = 2 können mit einem Semikolon angeschlossen werden, wie es in anderen Programmiersprachen üblich ist: a = 2;

=== Wenn-Kontrollstrukturen ===
Im vorigen Abschnitt wurden logische Operatoren genannt – diese sind Bestandteil der Kontrollstrukturen und Schleifen. Unter Kontrollstrukturen kann man sich einfache Wenn-Verzweigungen vorstellen. Schleifen werden hingegen solange ausgeführt, wie die Bedingung zutrifft.

Eine Verzweigung wird mit einer if-Bedingung realisiert: 
<code>'''if''' (Bedingung) '''then''' 
(Anweisungen) 
'''end'''</code>

Die Bedingungen werden mit Operatoren geprüft oder verknüpft. Die Vergleichsoperationen sind:

{| class="wikitable"
|-
! Operator !! Bedeutung !! Beispiel
|-
| == || Gleichheitsoperator. Wahr wenn beide Werte gleich sind. || 5 == 5 --> Wahr
|-
| ~= || Ungleichheitsoperator. Wahr wenn beide Werte nicht gleich sind. || 5 ~= 5 --> Falsch
|-
| < || Kleiner-als-Operator. Wahr wenn der zu prüfende Wert kleiner ist als der andere. || 4 < 5 --> Wahr
|-
| <= || Kleiner-als-oder-gleich-Operator. Wahr wenn der zu prüfende Wert kleiner oder gleich dem anderen ist. || 5 <= 5 --> Wahr
|-
| > || Größer-als-Operator. Wahr wenn der zu prüfende Wert größer ist als der andere. || 6 > 5 --> Wahr
|-
| >= || Größer-als-oder-gleich-Operator. Wahr wenn der zu prüfende Wert größer oder gleich dem Anderen ist. || 5 >= 5 --> Wahr
|}

Vergleichsoperationen können verknüpft werden. Dazu dienen folgende Vergleichsoperationen:

{| class="wikitable"
|-
! Operator !! Bedeutung !! Beispiel
|-
| and || Und-Operator. Gibt wahr zurück, wenn beide Operanden wahr sind. || true and true --> Wahr true and false --> Falsch
|-
| or || Oder-Operator. Gibt wahr zurück, wenn ein Operand wahr ist. || false or false --> Falsch true or false --> Wahr
|-
| not || Wahrheits-Negations-Operator. Mach ein Wahr zu Falsch und ein Falsch zu wahr. || not true wird zu false not false wird zu true
|}
Zusatzbemerkung: not ist vorrangig zu den arithmetischen Operatoren. Logikoperationen zu Vergleichsoperationen. Arithmetische Operationen vorrangig zu Logikoperationen. Zu Wahrheitswerten ist kein Vergleichsoperator notwendig – er wird immer gegen true geprüft.

Oftmals ist es notwendig, weitere Fall-Abzweige zu programmieren. Vom Prinzip: wenn das… oder wenn das… oder das. Dies wird wird else-if-Kontrollstrukturen realisiert.

Der Aufbau dieser Kontrollstrukturen ist der Folgende:

<code>
'''if''' (Bedingung) '''then''' 
(Anweisungsblock den Fall) 
'''else''' 
(Anweisungsblock für unbehandelte Fälle) 
'''end''' 

'''if''' (Bedingung A) '''then''' 
(Anweisungsblock für Fall A) 
'''elseif''' (Bedingung B) '''then''' 
(Anweisungsblock für Fall B) 
(''optional'': '''else''' 
(Anweisungsblock für unbehandelte Fälle)) 
'''end'''</code>

Um das ganze System zu verdeutlichen, dienen folgende Beispiele:

[[Datei:PP_LUATUT01_06_Vergleiche.png|473px]]

=== Schleifen ===
Schleifen dienen zur Wiederholung einer Anweisung, solange eine bestimmte Bedingung gültig ist.

Die einfachste Schleife ihrer Art ist die while-Schleife. Solange die Bedingung gültig ist, wird deren Anweisung im then-end-Block ausgeführt:

<code>'''while''' (Bedingung) '''do''' 
(Anweisung) 
'''end'''</code>

Das Folgende Beispiel lässt den Wert c solange herunterzählen, bis c Null ist:

[[Datei:PP_LUATUT01_07_While-Schleife.png|402px]]

Dekrementieren = Zahl um 1 verringern. Inkrementieren = Zahl um 1 erhöhen.

Manchmal ist es Notwendig, dass der Anweisungsblock vor der Bedingungsprüfung notwendig ist. Dazu dienen repeat-until-Schleifen – auch bekannt als do-while-Schleife. 
<code>'''repeat''' 
(Anweisungen) 
'''until''' (Bedingung)</code>

[[Datei:PP_LUATUT01_09_Repeat-Until-Schleife.png|310px]]

Eine weitere interessante Schleife ist die numerische for-Schleife. In ihr ist die Deklaration, Zielwert und Schrittweite definiert. Folgende Form ist dabei zu beachten: 
<code>'''for''' ''(Deklaration)'', ''(Zielwert)''(optional:, ''(Schrittweite)'') '''do''' 
(Anweisung)
'''end'''</code>

Ist die Schrittweite nicht definiert (weil optional), wird 1 als Standardwert verwendet.

Das folgende Beispiel berechnet c von 0 bis 10 als Folge:

[[Datei:PP_LUATUT01_08_For-Schleife.png|501px]]

== Funktionen ==

Funktionen werden wie folgt aufgerufen: 
<code>'''Funktionsname''' '''(''' ''Argument'', ''Argument'', ''...'' ''')'''</code>

Beispiel: 
<code>SendSignalMessage(PZB_500, ““, 1, 1, linkIndex)</code>

Möchte man eigene Funktionen programmieren, verwendet man folgende Form: 
<code>'''function''' ''Funktionsname''(''Parameter'', ''Parameter'', ''...'') 
(Anweisungen) 
end</code>

Es sei noch zu erwähnen, dass man an Funktionen Argumente (Werte) übergibt und bei der Definition Parameter definiert. Folglich nennt man die übergebenen Argumente innerhalb einer Funktion Argument.

Das folgende Beispiel zeigt die Deklaration der Funktion DebugMessage() und deren Aufruf.

[[Datei:PP_LUATUT01_10_Funktionen.png|604px]]

Möchte man Rückgabewerte zurückgeben, wird dies mit dem Schlüsselwort <code>'''return'''</code> eingeleitet. In Lua ist es möglich mehrere Rückgabewerte zurückzuliefern. Das folgende Beispiel zeigt, wie das geht:

[[Datei:PP_LUATUT01_11_Rückgabewerte.png|605px]]

== Tabellen ==

Fast geschafft. Im letzten „Lernkapitel“ werden Tabellen behandelt. Tabellen werden auch als Arrays bezeichnet. Sie beinhalten Daten in Form von Schlüssel-Wert-Paaren.

Eine Tabelle wird wie folgend deklariert: 
<code>Variable = '''{}'''</code>

Es ist ebenfalls möglich, zur Deklaration Werte in Tabellen schreiben: 
<code>Variable = '''{''' ''VariablenName'' = ''Wert'', ''...'' '''}'''</code>

Der Zugriff ist vielseitig. Entweder greift man über eckige Klammern auf ein Schlüssel-Wert-Paar zu. Der Zugriff funktioniert auch über ein Tabelle-Punkt-Variablenname-System:

[[Datei:PP_LUATUT01_12_Tabellen.png|538px]]

Eine weitere Schleifenart ist die generische for-Schleife. Sie wird für Tabellen benutzt. Um sie zu realisieren benutzt man die Funktion <code>'''inpairs(Tabelle)'''</code>. Das folgende Beispiel zeigt die Syntax:

[[Datei:PP_LUATUT01_13_For-Generisch.png|377px]]

== Ein paar Hinweise ==

Dieser Artikel gab einen Einblick in Lua und hat Grundlagen der Sprache vorgestellt. Nun beherrscht man die Sprache Lua im Allgemeinen.

Doch was würde man ohne die Standardbibliotheken machen? Es gibt vorgefertigte Funktionen, zum Beispiel eine Mathematikbibliothek.

Zudem wurde noch nicht auf Besonderheiten bezüglich RailWorks eingegangen.

Dies folgt in den Artikeln: 
[[Das Lua-Tutorial - 2 Tipps und Bibliotheken|Das Lua-Tutorial: #2 – Die Lua-Bibliotheken]] 
[[Das Lua-Tutorial - 3 RailWorks: Besonderheiten und Funktionsübersucht|Das Lua-Tutorial: #3 – Besonderheiten und Funktionsübersucht]]

Das Lua-Tutorial - 1 Grundlagen

2011-09-18T21:52:48Z

Patrick: /* Schleifen */

[[Kategorie:Scriptsprache Lua]]

= Das Lua-Tutorial - 1 Grundlagen =

Diese Artikelserie zeigt, wie man mit Lua eigene Funktionen in das Programm einbinden kann. „#1 – Grundlagen“ erklärt das Fundament von Lua und wie man damit arbeitet. Es ist spezifisch für RailWorks ausgelegt.

== Was ist Lua und was benötige ich? ==

Lua ist eine Formsprache, mit der man ein Programm von außen steuern kann. Was heißt „außen“ und wie ist das gemeint?

Ein Programm besitzt einen inneren Kern, der immer gleich abläuft – er ist fest verankert und damit von „innen“ gesteuert.
Wir können ihn mit normalen Mitteln nicht verändern. Lässt ein Programm zu, dass es veränderbar ist,
dann lässt es eine Steuerung von außen zu. Das kann mit einer Konfigurationsdatei („Bildschirmauflösung einstellen“)
oder einem Script gelöst sein. Das Script sagt was der Kern erledigen soll.
Und diese Scripte werden zum Beispiel mit Lua geschrieben – darum geht es hier.

Um solche Scripte zu schreiben, muss man einer Formsprache exakt folgen. Das ist wie Tangotanzen auf der Showbühne: Nur das unser Tanzpartner die Tastatur ist. Die Formsprache beschreibt uns die Regeln, wie etwas zu formulieren ist, welche Möglichkeiten gegeben sind und was dadurch ausgelöst wird.

Natürlich passiert es schnell, dass mal nicht alles glatt läuft. Und zum Glück gibt es Programme, die uns unterstützen, Fehler durch korrekten Text zu ersetzen. Diesen Text den wir schreiben, nennt man Quellcode.

Ein Programm, das ich sehr gerne nutze und empfehle, ist [http://luaforge.net/frs/?group_id=84&release_id=553 LuaEdit 3.03RC]. Es ist einfach organisiert und ermöglicht eine schnelle Überprüfung der Formsprache. So sieht das Programm aus, wenn man Scripte schreibt (siehe rechts).

[[Datei:PP_LUATUT01_01_LuaEdit_3.03RC.png|miniatur|Die Entwicklungsumgebung [http://luaforge.net/frs/?group_id=84&release_id=553 LuaEdit 3.03RC] ]]
Oben haben wir ein Menü. Es ermöglicht allgemeine Operationen, Sichteinstellungen, Projektverwaltung, einen Test durchzuführen und das starten von Tools.

In der oberen Toolleiste finden wir in der ersten Gruppe Felder zum erzeugen neuer Dateien oder Projekte.
In der zweiten Gruppe können wir Dateien öffnen und speichern. In der dritten Gruppe können wir
Dateien zu Projekten zuordnen. Die vierte Gruppe ermöglicht das Drucken. Die fünfte Gruppe kann
den Testdurchlauf beeinflussen. Die sechste Gruppe ermöglicht das Prüfen der Syntax und
das Erstellen von kompilierten Scripten. Die siebente Gruppe ermöglicht das Suchen und
das Setzen von Haltepunkten im Script, wenn wir einen Testdurchlauf durchführen.

Die untere Toolleiste vereinfacht das Bearbeiten von Text. Dazu zählt zum Beispiel
das automatische Ein- und Auskommentieren oder Verrücken von Text.
Am besten probiert man an einem Testtext, was der jeweiligen Schalter bewirkt :-).

Ich habe bei der Beschreibung das Wort „Kompilieren“ in den Raum geworfen.
Das ganze muss man sich so vorstellen: Wir schreiben Text in lesbarer Form,
den wir verändern können. Kompilieren wir den Text, wird unser geschriebenes
interpretiert und mit programmeigenen Anweisungen übersetzt. Die programmeigenen
Anweisungen können wir natürlich nicht ohne weiteres frei bearbeiten.
Das ganze macht man, damit man Zeit spart, weil die Interpretation manchmal
ganz schön lange dauern kann, wenn man sehr viele Scriptdateien hat.
Aber damit müssen wir uns in RailWorks nicht herumärgern: Das macht RailWorks für uns, leider.

== Kommentieren hilft ==

Scripten ist eine Gemeinschaftsaufgabe. Schreiben wir Quellcode, müssen wir später verstehen,
was wir geschrieben haben. Und unseren Mitgliedern hilft es, Fehler schneller und leichter zu entlarven,
um sie auszumerzen. Ein Kommentar ist dabei etwas, was nicht vom Interpreter (dem „Leser“) beachtet wird.

Er wird mit zwei arabischen Zahlstrichen angefangen (--) und gilt für die eine Zeile. Etwa so:

-- Kommentare sind für folgende Fälle gedacht:

* '''Hinweise am Anfang der Dateien'''
** wer, was, wann und wie etwas geändert hat.
** Falls notwendig: Nenne
*** die verwendete Sprache
*** den Namen der Gruppe
*** oder die Lizenz (und/oder deren Bedingungen).
* '''Eigenschaften der Funktionen'''
** Was sie machen sollen oder bewirken
** Wann sie verwendet werden dürfen
** Welche Parameter zulässig sind und was sie bedeuten – die Einheiten
** Rückgabewerte, wenn Sie vorhanden sind
* '''Beschreibung der Aufgabenfelder'''
** was wie erledigt werden soll
** welche Werte warum besondere Rollen spielen.

Es ist ein logischer Prozess und wird eine Menge Schreibarbeit verursachen. Aber das Tutorial ist so ausgelegt, dass die „Kommunikationsaufgabe Kommentieren“ als Routine ein leichtes Spiel wird.

== Variablen und Werte ==

Informationen müssen gespeichert werden: Dieser Aufgabe werden Variablen gerecht. Ihre Werte werden durch logische Berechnungsprozesse oder festgelegte Logik bestimmt.

Damit man unterscheiden kann, was Werte beinhalten, unterteilt man diese in Dateitypen. Für uns wichtig kann sein:

{| class="wikitable"
|-
! Datentyp !! Beschreibung !! Beispiel
|-
| string || Ein Text aus einer Verkettung von Zeichen. || „Hallo Welt“
|-
| number || Eine Zahl. Bei Gleitkommazahlen schreibt man mit Punkt statt mit Komma. Ein „f“ kann zusätzlich stehen und hat für uns keine Bedeutung. || 3, 5, 9 2.6, 3.1415f
|-
| Boolean || Ein Wahrheitswert. Wahr oder Falsch. || Wert: true oder false
|-
| nil || Eine Variable, die keinen Wert hat: Datentyplos. || Wert: nil
|-
| table || Eine Tabelle: „Array“. || Definition: { }
|}

Der Datentyp wird zur Laufzeit gewählt und ist bei vielen Typen austauschbar. So kann ein string zum Beispiel zu einer Zahl umgewandelt werden, wenn dies möglich ist. Ein Wahrheitswert, eine Zahl oder auch nil kann zu einem Text umgewandelt werden.

Die Definition einer Variable ist einfach – man schreibt sie in folgender Form auf:

[Name] = [Wert]

Dazu ein paar Beispiele:

[[Datei:PP_LUATUT01_02_Variablendefinitionen.png|rahmenlos|231px|Variablendefinitionen in Lua.]]

Ganz links ist die Zeilennummer, Einzustellen in den Optionen von LuaEdit.
Die Namensgebung von Variablen entspricht den obigen Beispielen: Sie darf mit einem Buchstaben anfangen, der keine Nummer ist. Nach dem ersten Buchstaben darf man Nummern verwenden – das meidet man allerdings.

== Operatoren ==

Beim Programmieren unterscheidet man in drei Arten von Operationen:
* Arithmetische Operationen (Rechenoperationen)
* Relationale Operationen (Vergleichsoperationen) und
* Logische Operationen

Jede Gruppe deckt bestimmte Aufgabenfelder ab. So dienen arithmetische Operationen der Berechnung von Werten und relationale und logische Operationen dem Vergleich von Werten.

Dieser Abschnitt beschäftigt sich mit Rechenoperationen. Das sind die Operatoren

* "=" --> Zuweisungsoperator
* "+" --> Additionsoparator
* "-" --> Subtraktionsoperator oder auch Negationsoperator
* "*" --> Multiplikationsoperator
* "/" --> Divisionsoperator
* ".." --> Verknüpfungsoperator

Um diese Funktion zu verdeutlichen, dienen folgende Beispiele:

[[Datei:PP_LUATUT01_03_ArOperationen.png|rahmenlos|534px|Operatorenbeispiele in Lua]]

== Kontrollstrukturen und Schleifen ==

=== Anweisungen und Rümpfe ===

Jede Anweisung wird in einem Rumpf ausgeführt. Dabei unterscheidet man in
* Anweisungsrümpfe
* Branchrümpfe
* Branchrümpfe der If-Else-Kontrollstrukturen

Branchrümpfe begrenzen einen Programmblock und benötigen eine Bedingung:
<code>(Bedingung) '''then''' 
(Anweisung) 
'''end'''</code>

Sie werden mit then eingeleitet und mit end beendet.

Anweisungsrümpfe der If-Else-Kontrollstrukturen werden wie Anweisungsrümpfe definiert, können jedoch ohne das Schlüsselwort end beendet werden, wenn sie mit elseif oder else beendet werden.

<code>'''if''' (Bedingung) '''then''' 
(Anweisung) 
'''elseif''' (Bedingung) '''...'''</code>

Anweisungen wie a = 2 können mit einem Semikolon angeschlossen werden, wie es in anderen Programmiersprachen üblich ist: a = 2;

=== Wenn-Kontrollstrukturen ===
Im vorigen Abschnitt wurden logische Operatoren genannt – diese sind Bestandteil der Kontrollstrukturen und Schleifen. Unter Kontrollstrukturen kann man sich einfache Wenn-Verzweigungen vorstellen. Schleifen werden hingegen solange ausgeführt, wie die Bedingung zutrifft.

Eine Verzweigung wird mit einer if-Bedingung realisiert: 
<code>'''if''' (Bedingung) '''then''' 
(Anweisungen) 
'''end'''</code>

Die Bedingungen werden mit Operatoren geprüft oder verknüpft. Die Vergleichsoperationen sind:

{| class="wikitable"
|-
! Operator !! Bedeutung !! Beispiel
|-
| == || Gleichheitsoperator. Wahr wenn beide Werte gleich sind. || 5 == 5 --> Wahr
|-
| ~= || Ungleichheitsoperator. Wahr wenn beide Werte nicht gleich sind. || 5 ~= 5 --> Falsch
|-
| < || Kleiner-als-Operator. Wahr wenn der zu prüfende Wert kleiner ist als der andere. || 4 < 5 --> Wahr
|-
| <= || Kleiner-als-oder-gleich-Operator. Wahr wenn der zu prüfende Wert kleiner oder gleich dem anderen ist. || 5 <= 5 --> Wahr
|-
| > || Größer-als-Operator. Wahr wenn der zu prüfende Wert größer ist als der andere. || 6 > 5 --> Wahr
|-
| >= || Größer-als-oder-gleich-Operator. Wahr wenn der zu prüfende Wert größer oder gleich dem Anderen ist. || 5 >= 5 --> Wahr
|}

Vergleichsoperationen können verknüpft werden. Dazu dienen folgende Vergleichsoperationen:

{| class="wikitable"
|-
! Operator !! Bedeutung !! Beispiel
|-
| and || Und-Operator. Gibt wahr zurück, wenn beide Operanden wahr sind. || true and true --> Wahr true and false --> Falsch
|-
| or || Oder-Operator. Gibt wahr zurück, wenn ein Operand wahr ist. || false or false --> Falsch true or false --> Wahr
|-
| not || Wahrheits-Negations-Operator. Mach ein Wahr zu Falsch und ein Falsch zu wahr. || not true wird zu false not false wird zu true
|}
Zusatzbemerkung: not ist vorrangig zu den arithmetischen Operatoren. Logikoperationen zu Vergleichsoperationen. Arithmetische Operationen vorrangig zu Logikoperationen. Zu Wahrheitswerten ist kein Vergleichsoperator notwendig – er wird immer gegen true geprüft.

Oftmals ist es notwendig, weitere Fall-Abzweige zu programmieren. Vom Prinzip: wenn das… oder wenn das… oder das. Dies wird wird else-if-Kontrollstrukturen realisiert.

Der Aufbau dieser Kontrollstrukturen ist der Folgende:

<code>
'''if''' (Bedingung) '''then''' 
(Anweisungsblock den Fall) 
'''else''' 
(Anweisungsblock für unbehandelte Fälle) 
'''end''' 

'''if''' (Bedingung A) '''then''' 
(Anweisungsblock für Fall A) 
'''elseif''' (Bedingung B) '''then''' 
(Anweisungsblock für Fall B) 
(''optional'': '''else''' 
(Anweisungsblock für unbehandelte Fälle)) 
'''end'''</code>

Um das ganze System zu verdeutlichen, dienen folgende Beispiele:

[[Datei:PP_LUATUT01_06_Vergleiche.png|473px]]

=== Schleifen ===
Schleifen dienen zur Wiederholung einer Anweisung, solange eine bestimmte Bedingung gültig ist.

Die einfachste Schleife ihrer Art ist die while-Schleife. Solange die Bedingung gültig ist, wird deren Anweisung im then-end-Block ausgeführt:

<code>'''while''' (Bedingung) '''do''' 
(Anweisung) 
'''end'''</code>

Das Folgende Beispiel lässt den Wert c solange herunterzählen, bis c Null ist:

[[Datei:PP_LUATUT01_07_While-Schleife.png|402px]]

Dekrementieren = Zahl um 1 verringern. Inkrementieren = Zahl um 1 erhöhen.

Manchmal ist es Notwendig, dass der Anweisungsblock vor der Bedingungsprüfung notwendig ist. Dazu dienen repeat-until-Schleifen – auch bekannt als do-while-Schleife. 
<code>'''repeat''' 
(Anweisungen) 
'''until''' (Bedingung)</code>

[[Datei:PP_LUATUT01_09_Repeat-Until-Schleife.png|310px]]

Eine weitere interessante Schleife ist die numerische for-Schleife. In ihr ist die Deklaration, Zielwert und Schrittweite definiert. Folgende Form ist dabei zu beachten: 
<code>'''for''' ''(Deklaration)'', ''(Zielwert)''(optional:, ''(Schrittweite)'') '''do''' 
(Anweisung)
'''end'''</code>

Ist die Schrittweite nicht definiert (weil optional), wird 1 als Standardwert verwendet.

Das folgende Beispiel berechnet c von 0 bis 10 als Folge:

[[Datei:PP_LUATUT01_08_For-Schleife.png|501px]}

== Funktionen ==

Funktionen werden wie folgt aufgerufen: 
<code>'''Funktionsname''' '''(''' ''Argument'', ''Argument'', ''...'' ''')'''</code>

Beispiel: 
<code>SendSignalMessage(PZB_500, ““, 1, 1, linkIndex)</code>

Möchte man eigene Funktionen programmieren, verwendet man folgende Form: 
<code>'''function''' ''Funktionsname''(''Parameter'', ''Parameter'', ''...'') 
(Anweisungen) 
end</code>

Es sei noch zu erwähnen, dass man an Funktionen Argumente (Werte) übergibt und bei der Definition Parameter definiert. Folglich nennt man die übergebenen Argumente innerhalb einer Funktion Argument.

Das folgende Beispiel zeigt die Deklaration der Funktion DebugMessage() und deren Aufruf.

[[Datei:PP_LUATUT01_10_Funktionen.png|604px]]

Möchte man Rückgabewerte zurückgeben, wird dies mit dem Schlüsselwort <code>'''return'''</code> eingeleitet. In Lua ist es möglich mehrere Rückgabewerte zurückzuliefern. Das folgende Beispiel zeigt, wie das geht:

[[Datei:PP_LUATUT01_11_Rückgabewerte.png|605px]]

== Tabellen ==

Fast geschafft. Im letzten „Lernkapitel“ werden Tabellen behandelt. Tabellen werden auch als Arrays bezeichnet. Sie beinhalten Daten in Form von Schlüssel-Wert-Paaren.

Eine Tabelle wird wie folgend deklariert: 
<code>Variable = '''{}'''</code>

Es ist ebenfalls möglich, zur Deklaration Werte in Tabellen schreiben: 
<code>Variable = '''{''' ''VariablenName'' = ''Wert'', ''...'' '''}'''</code>

Der Zugriff ist vielseitig. Entweder greift man über eckige Klammern auf ein Schlüssel-Wert-Paar zu. Der Zugriff funktioniert auch über ein Tabelle-Punkt-Variablenname-System:

[[Datei:PP_LUATUT01_12_Tabellen.png|538px]]

Eine weitere Schleifenart ist die generische for-Schleife. Sie wird für Tabellen benutzt. Um sie zu realisieren benutzt man die Funktion <code>'''inpairs(Tabelle)'''</code>. Das folgende Beispiel zeigt die Syntax:

[[Datei:PP_LUATUT01_13_For-Generisch.png|377px]]

== Ein paar Hinweise ==

Dieser Artikel gab einen Einblick in Lua und hat Grundlagen der Sprache vorgestellt. Nun beherrscht man die Sprache Lua im Allgemeinen.

Doch was würde man ohne die Standardbibliotheken machen? Es gibt vorgefertigte Funktionen, zum Beispiel eine Mathematikbibliothek.

Zudem wurde noch nicht auf Besonderheiten bezüglich RailWorks eingegangen.

Dies folgt in den Artikeln: 
[[Das Lua-Tutorial - 2 Tipps und Bibliotheken|Das Lua-Tutorial: #2 – Die Lua-Bibliotheken]] 
[[Das Lua-Tutorial - 3 RailWorks: Besonderheiten und Funktionsübersucht|Das Lua-Tutorial: #3 – Besonderheiten und Funktionsübersucht]]

Das Lua-Tutorial - 1 Grundlagen

2011-09-18T21:51:41Z

Patrick: Stellt die Sprache Lua vor und ganz kurz die IDE.

[[Kategorie:Scriptsprache Lua]]

= Das Lua-Tutorial - 1 Grundlagen =

Diese Artikelserie zeigt, wie man mit Lua eigene Funktionen in das Programm einbinden kann. „#1 – Grundlagen“ erklärt das Fundament von Lua und wie man damit arbeitet. Es ist spezifisch für RailWorks ausgelegt.

== Was ist Lua und was benötige ich? ==

Lua ist eine Formsprache, mit der man ein Programm von außen steuern kann. Was heißt „außen“ und wie ist das gemeint?

Ein Programm besitzt einen inneren Kern, der immer gleich abläuft – er ist fest verankert und damit von „innen“ gesteuert.
Wir können ihn mit normalen Mitteln nicht verändern. Lässt ein Programm zu, dass es veränderbar ist,
dann lässt es eine Steuerung von außen zu. Das kann mit einer Konfigurationsdatei („Bildschirmauflösung einstellen“)
oder einem Script gelöst sein. Das Script sagt was der Kern erledigen soll.
Und diese Scripte werden zum Beispiel mit Lua geschrieben – darum geht es hier.

Um solche Scripte zu schreiben, muss man einer Formsprache exakt folgen. Das ist wie Tangotanzen auf der Showbühne: Nur das unser Tanzpartner die Tastatur ist. Die Formsprache beschreibt uns die Regeln, wie etwas zu formulieren ist, welche Möglichkeiten gegeben sind und was dadurch ausgelöst wird.

Natürlich passiert es schnell, dass mal nicht alles glatt läuft. Und zum Glück gibt es Programme, die uns unterstützen, Fehler durch korrekten Text zu ersetzen. Diesen Text den wir schreiben, nennt man Quellcode.

Ein Programm, das ich sehr gerne nutze und empfehle, ist [http://luaforge.net/frs/?group_id=84&release_id=553 LuaEdit 3.03RC]. Es ist einfach organisiert und ermöglicht eine schnelle Überprüfung der Formsprache. So sieht das Programm aus, wenn man Scripte schreibt (siehe rechts).

[[Datei:PP_LUATUT01_01_LuaEdit_3.03RC.png|miniatur|Die Entwicklungsumgebung [http://luaforge.net/frs/?group_id=84&release_id=553 LuaEdit 3.03RC] ]]
Oben haben wir ein Menü. Es ermöglicht allgemeine Operationen, Sichteinstellungen, Projektverwaltung, einen Test durchzuführen und das starten von Tools.

In der oberen Toolleiste finden wir in der ersten Gruppe Felder zum erzeugen neuer Dateien oder Projekte.
In der zweiten Gruppe können wir Dateien öffnen und speichern. In der dritten Gruppe können wir
Dateien zu Projekten zuordnen. Die vierte Gruppe ermöglicht das Drucken. Die fünfte Gruppe kann
den Testdurchlauf beeinflussen. Die sechste Gruppe ermöglicht das Prüfen der Syntax und
das Erstellen von kompilierten Scripten. Die siebente Gruppe ermöglicht das Suchen und
das Setzen von Haltepunkten im Script, wenn wir einen Testdurchlauf durchführen.

Die untere Toolleiste vereinfacht das Bearbeiten von Text. Dazu zählt zum Beispiel
das automatische Ein- und Auskommentieren oder Verrücken von Text.
Am besten probiert man an einem Testtext, was der jeweiligen Schalter bewirkt :-).

Ich habe bei der Beschreibung das Wort „Kompilieren“ in den Raum geworfen.
Das ganze muss man sich so vorstellen: Wir schreiben Text in lesbarer Form,
den wir verändern können. Kompilieren wir den Text, wird unser geschriebenes
interpretiert und mit programmeigenen Anweisungen übersetzt. Die programmeigenen
Anweisungen können wir natürlich nicht ohne weiteres frei bearbeiten.
Das ganze macht man, damit man Zeit spart, weil die Interpretation manchmal
ganz schön lange dauern kann, wenn man sehr viele Scriptdateien hat.
Aber damit müssen wir uns in RailWorks nicht herumärgern: Das macht RailWorks für uns, leider.

== Kommentieren hilft ==

Scripten ist eine Gemeinschaftsaufgabe. Schreiben wir Quellcode, müssen wir später verstehen,
was wir geschrieben haben. Und unseren Mitgliedern hilft es, Fehler schneller und leichter zu entlarven,
um sie auszumerzen. Ein Kommentar ist dabei etwas, was nicht vom Interpreter (dem „Leser“) beachtet wird.

Er wird mit zwei arabischen Zahlstrichen angefangen (--) und gilt für die eine Zeile. Etwa so:

-- Kommentare sind für folgende Fälle gedacht:

* '''Hinweise am Anfang der Dateien'''
** wer, was, wann und wie etwas geändert hat.
** Falls notwendig: Nenne
*** die verwendete Sprache
*** den Namen der Gruppe
*** oder die Lizenz (und/oder deren Bedingungen).
* '''Eigenschaften der Funktionen'''
** Was sie machen sollen oder bewirken
** Wann sie verwendet werden dürfen
** Welche Parameter zulässig sind und was sie bedeuten – die Einheiten
** Rückgabewerte, wenn Sie vorhanden sind
* '''Beschreibung der Aufgabenfelder'''
** was wie erledigt werden soll
** welche Werte warum besondere Rollen spielen.

Es ist ein logischer Prozess und wird eine Menge Schreibarbeit verursachen. Aber das Tutorial ist so ausgelegt, dass die „Kommunikationsaufgabe Kommentieren“ als Routine ein leichtes Spiel wird.

== Variablen und Werte ==

Informationen müssen gespeichert werden: Dieser Aufgabe werden Variablen gerecht. Ihre Werte werden durch logische Berechnungsprozesse oder festgelegte Logik bestimmt.

Damit man unterscheiden kann, was Werte beinhalten, unterteilt man diese in Dateitypen. Für uns wichtig kann sein:

{| class="wikitable"
|-
! Datentyp !! Beschreibung !! Beispiel
|-
| string || Ein Text aus einer Verkettung von Zeichen. || „Hallo Welt“
|-
| number || Eine Zahl. Bei Gleitkommazahlen schreibt man mit Punkt statt mit Komma. Ein „f“ kann zusätzlich stehen und hat für uns keine Bedeutung. || 3, 5, 9 2.6, 3.1415f
|-
| Boolean || Ein Wahrheitswert. Wahr oder Falsch. || Wert: true oder false
|-
| nil || Eine Variable, die keinen Wert hat: Datentyplos. || Wert: nil
|-
| table || Eine Tabelle: „Array“. || Definition: { }
|}

Der Datentyp wird zur Laufzeit gewählt und ist bei vielen Typen austauschbar. So kann ein string zum Beispiel zu einer Zahl umgewandelt werden, wenn dies möglich ist. Ein Wahrheitswert, eine Zahl oder auch nil kann zu einem Text umgewandelt werden.

Die Definition einer Variable ist einfach – man schreibt sie in folgender Form auf:

[Name] = [Wert]

Dazu ein paar Beispiele:

[[Datei:PP_LUATUT01_02_Variablendefinitionen.png|rahmenlos|231px|Variablendefinitionen in Lua.]]

Ganz links ist die Zeilennummer, Einzustellen in den Optionen von LuaEdit.
Die Namensgebung von Variablen entspricht den obigen Beispielen: Sie darf mit einem Buchstaben anfangen, der keine Nummer ist. Nach dem ersten Buchstaben darf man Nummern verwenden – das meidet man allerdings.

== Operatoren ==

Beim Programmieren unterscheidet man in drei Arten von Operationen:
* Arithmetische Operationen (Rechenoperationen)
* Relationale Operationen (Vergleichsoperationen) und
* Logische Operationen

Jede Gruppe deckt bestimmte Aufgabenfelder ab. So dienen arithmetische Operationen der Berechnung von Werten und relationale und logische Operationen dem Vergleich von Werten.

Dieser Abschnitt beschäftigt sich mit Rechenoperationen. Das sind die Operatoren

* "=" --> Zuweisungsoperator
* "+" --> Additionsoparator
* "-" --> Subtraktionsoperator oder auch Negationsoperator
* "*" --> Multiplikationsoperator
* "/" --> Divisionsoperator
* ".." --> Verknüpfungsoperator

Um diese Funktion zu verdeutlichen, dienen folgende Beispiele:

[[Datei:PP_LUATUT01_03_ArOperationen.png|rahmenlos|534px|Operatorenbeispiele in Lua]]

== Kontrollstrukturen und Schleifen ==

=== Anweisungen und Rümpfe ===

Jede Anweisung wird in einem Rumpf ausgeführt. Dabei unterscheidet man in
* Anweisungsrümpfe
* Branchrümpfe
* Branchrümpfe der If-Else-Kontrollstrukturen

Branchrümpfe begrenzen einen Programmblock und benötigen eine Bedingung:
<code>(Bedingung) '''then''' 
(Anweisung) 
'''end'''</code>

Sie werden mit then eingeleitet und mit end beendet.

Anweisungsrümpfe der If-Else-Kontrollstrukturen werden wie Anweisungsrümpfe definiert, können jedoch ohne das Schlüsselwort end beendet werden, wenn sie mit elseif oder else beendet werden.

<code>'''if''' (Bedingung) '''then''' 
(Anweisung) 
'''elseif''' (Bedingung) '''...'''</code>

Anweisungen wie a = 2 können mit einem Semikolon angeschlossen werden, wie es in anderen Programmiersprachen üblich ist: a = 2;

=== Wenn-Kontrollstrukturen ===
Im vorigen Abschnitt wurden logische Operatoren genannt – diese sind Bestandteil der Kontrollstrukturen und Schleifen. Unter Kontrollstrukturen kann man sich einfache Wenn-Verzweigungen vorstellen. Schleifen werden hingegen solange ausgeführt, wie die Bedingung zutrifft.

Eine Verzweigung wird mit einer if-Bedingung realisiert: 
<code>'''if''' (Bedingung) '''then''' 
(Anweisungen) 
'''end'''</code>

Die Bedingungen werden mit Operatoren geprüft oder verknüpft. Die Vergleichsoperationen sind:

{| class="wikitable"
|-
! Operator !! Bedeutung !! Beispiel
|-
| == || Gleichheitsoperator. Wahr wenn beide Werte gleich sind. || 5 == 5 --> Wahr
|-
| ~= || Ungleichheitsoperator. Wahr wenn beide Werte nicht gleich sind. || 5 ~= 5 --> Falsch
|-
| < || Kleiner-als-Operator. Wahr wenn der zu prüfende Wert kleiner ist als der andere. || 4 < 5 --> Wahr
|-
| <= || Kleiner-als-oder-gleich-Operator. Wahr wenn der zu prüfende Wert kleiner oder gleich dem anderen ist. || 5 <= 5 --> Wahr
|-
| > || Größer-als-Operator. Wahr wenn der zu prüfende Wert größer ist als der andere. || 6 > 5 --> Wahr
|-
| >= || Größer-als-oder-gleich-Operator. Wahr wenn der zu prüfende Wert größer oder gleich dem Anderen ist. || 5 >= 5 --> Wahr
|}

Vergleichsoperationen können verknüpft werden. Dazu dienen folgende Vergleichsoperationen:

{| class="wikitable"
|-
! Operator !! Bedeutung !! Beispiel
|-
| and || Und-Operator. Gibt wahr zurück, wenn beide Operanden wahr sind. || true and true --> Wahr true and false --> Falsch
|-
| or || Oder-Operator. Gibt wahr zurück, wenn ein Operand wahr ist. || false or false --> Falsch true or false --> Wahr
|-
| not || Wahrheits-Negations-Operator. Mach ein Wahr zu Falsch und ein Falsch zu wahr. || not true wird zu false not false wird zu true
|}
Zusatzbemerkung: not ist vorrangig zu den arithmetischen Operatoren. Logikoperationen zu Vergleichsoperationen. Arithmetische Operationen vorrangig zu Logikoperationen. Zu Wahrheitswerten ist kein Vergleichsoperator notwendig – er wird immer gegen true geprüft.

Oftmals ist es notwendig, weitere Fall-Abzweige zu programmieren. Vom Prinzip: wenn das… oder wenn das… oder das. Dies wird wird else-if-Kontrollstrukturen realisiert.

Der Aufbau dieser Kontrollstrukturen ist der Folgende:

<code>
'''if''' (Bedingung) '''then''' 
(Anweisungsblock den Fall) 
'''else''' 
(Anweisungsblock für unbehandelte Fälle) 
'''end''' 

'''if''' (Bedingung A) '''then''' 
(Anweisungsblock für Fall A) 
'''elseif''' (Bedingung B) '''then''' 
(Anweisungsblock für Fall B) 
(''optional'': '''else''' 
(Anweisungsblock für unbehandelte Fälle)) 
'''end'''</code>

Um das ganze System zu verdeutlichen, dienen folgende Beispiele:

[[Datei:PP_LUATUT01_06_Vergleiche.png|473px]]

=== Schleifen ===
Schleifen dienen zur Wiederholung einer Anweisung, solange eine bestimmte Bedingung gültig ist.

Die einfachste Schleife ihrer Art ist die while-Schleife. Solange die Bedingung gültig ist, wird deren Anweisung im then-end-Block ausgeführt:

<code>'''while''' (Bedingung) '''do''' 
(Anweisung) 
'''end'''</code>

Das Folgende Beispiel lässt den Wert c solange herunterzählen, bis c Null ist:

[[Datei:PP_LUATUT01_07_While-Schleife.png|402px]]

Dekrementieren = Zahl um 1 verringern. Inkrementieren = Zahl um 1 erhöhen.

Manchmal ist es Notwendig, dass der Anweisungsblock vor der Bedingungsprüfung notwendig ist. Dazu dienen repeat-until-Schleifen – auch bekannt als do-while-Schleife. 
<code>'''repeat''' 
(Anweisungen) 
'''until''' (Bedingung)</code>

[[Datei:PP_LUATUT01_09_Repeat-Until-Schleife.png|310px]]

Eine weitere interessante Schleife ist die numerische for-Schleife. In ihr ist die Deklaration, Zielwert und Schrittweite definiert. Folgende Form ist dabei zu beachten: 
<code>'''for''' ''(Deklaration)'', ''(Zielwert)''(optional:, ''(Schrittweite)'') '''do''' 
(Anweisung)
'''end'''</code>

Ist die Schrittweite nicht definiert (weil optional), wird 1 als Standardwert verwendet.

Das folgende Beispiel berechnet c von 0 bis 10 als Folge:

[[Datei:PP_LUATUT01_08_For-Schleife.png|501px]

== Funktionen ==

Funktionen werden wie folgt aufgerufen: 
<code>'''Funktionsname''' '''(''' ''Argument'', ''Argument'', ''...'' ''')'''</code>

Beispiel: 
<code>SendSignalMessage(PZB_500, ““, 1, 1, linkIndex)</code>

Möchte man eigene Funktionen programmieren, verwendet man folgende Form: 
<code>'''function''' ''Funktionsname''(''Parameter'', ''Parameter'', ''...'') 
(Anweisungen) 
end</code>

Es sei noch zu erwähnen, dass man an Funktionen Argumente (Werte) übergibt und bei der Definition Parameter definiert. Folglich nennt man die übergebenen Argumente innerhalb einer Funktion Argument.

Das folgende Beispiel zeigt die Deklaration der Funktion DebugMessage() und deren Aufruf.

[[Datei:PP_LUATUT01_10_Funktionen.png|604px]]

Möchte man Rückgabewerte zurückgeben, wird dies mit dem Schlüsselwort <code>'''return'''</code> eingeleitet. In Lua ist es möglich mehrere Rückgabewerte zurückzuliefern. Das folgende Beispiel zeigt, wie das geht:

[[Datei:PP_LUATUT01_11_Rückgabewerte.png|605px]]

== Tabellen ==

Fast geschafft. Im letzten „Lernkapitel“ werden Tabellen behandelt. Tabellen werden auch als Arrays bezeichnet. Sie beinhalten Daten in Form von Schlüssel-Wert-Paaren.

Eine Tabelle wird wie folgend deklariert: 
<code>Variable = '''{}'''</code>

Es ist ebenfalls möglich, zur Deklaration Werte in Tabellen schreiben: 
<code>Variable = '''{''' ''VariablenName'' = ''Wert'', ''...'' '''}'''</code>

Der Zugriff ist vielseitig. Entweder greift man über eckige Klammern auf ein Schlüssel-Wert-Paar zu. Der Zugriff funktioniert auch über ein Tabelle-Punkt-Variablenname-System:

[[Datei:PP_LUATUT01_12_Tabellen.png|538px]]

Eine weitere Schleifenart ist die generische for-Schleife. Sie wird für Tabellen benutzt. Um sie zu realisieren benutzt man die Funktion <code>'''inpairs(Tabelle)'''</code>. Das folgende Beispiel zeigt die Syntax:

[[Datei:PP_LUATUT01_13_For-Generisch.png|377px]]

== Ein paar Hinweise ==

Dieser Artikel gab einen Einblick in Lua und hat Grundlagen der Sprache vorgestellt. Nun beherrscht man die Sprache Lua im Allgemeinen.

Doch was würde man ohne die Standardbibliotheken machen? Es gibt vorgefertigte Funktionen, zum Beispiel eine Mathematikbibliothek.

Zudem wurde noch nicht auf Besonderheiten bezüglich RailWorks eingegangen.

Dies folgt in den Artikeln: 
[[Das Lua-Tutorial - 2 Tipps und Bibliotheken|Das Lua-Tutorial: #2 – Die Lua-Bibliotheken]] 
[[Das Lua-Tutorial - 3 RailWorks: Besonderheiten und Funktionsübersucht|Das Lua-Tutorial: #3 – Besonderheiten und Funktionsübersucht]]

Kategorie:Scriptsprache Lua

2011-09-18T20:37:04Z

Patrick: Das ist die Kategorieseite für die Lua-Tutorials.

[[Kategorie:Tutorials]]

Datei:PP LUATUT01 13 For-Generisch.png

2011-09-18T20:33:12Z

Patrick: Generische For-Schleife in Lua.

Generische For-Schleife in Lua.

Datei:PP LUATUT01 12 Tabellen.png

2011-09-18T20:32:44Z

Patrick: Lua Tabellen.

Lua Tabellen.

Datei:PP LUATUT01 11 Rückgabewerte.png

2011-09-18T20:32:26Z

Patrick: Return values in Lua.

Return values in Lua.

Datei:PP LUATUT01 10 Funktionen.png

2011-09-18T20:32:00Z

Patrick: Lua Funktionen.

Lua Funktionen.

Datei:PP LUATUT01 09 Repeat-Until-Schleife.png

2011-09-18T20:31:35Z

Patrick: Die repeat-until-Schleife in Lua.

Die repeat-until-Schleife in Lua.

Datei:PP LUATUT01 08 For-Schleife.png

2011-09-18T20:31:02Z

Patrick: Die for-Schleife in Lua.

Die for-Schleife in Lua.

Datei:PP LUATUT01 07 While-Schleife.png

2011-09-18T20:30:38Z

Patrick: Die while-Schleife in Lua.

Die while-Schleife in Lua.

Datei:PP LUATUT01 06 Vergleiche.png

2011-09-18T20:30:14Z

Patrick: If-Else-Branches in Lua.

If-Else-Branches in Lua.

Datei:PP LUATUT01 03 ArOperationen.png

2011-09-18T20:29:10Z

Patrick: Arithmetische Operationen in Lua.

Arithmetische Operationen in Lua.

Datei:PP LUATUT01 02 Variablendefinitionen.png

2011-09-18T20:28:35Z

Patrick: Definition von Variablen in Lua.

Definition von Variablen in Lua.

Datei:PP LUATUT01 01 LuaEdit 3.03RC.png

2011-09-18T20:27:23Z

Patrick: Das Programm LuaEdit 3.03RC

Das Programm LuaEdit 3.03RC