![[Guide] C++ Programmierung mit Lua 5.1](https://www.elitepvpers.com/forum/iconimages/coding-tutorials/guide-c-programmierung-mit-lua-5-1-a_ltr.gif){kind=small}
Da ich dort mit Chaosduckman ein und die selbe Person bin sollte das klar gehen.
Hi^^
Ich weiß das es für dieses Thema sehr viele Guides in google gibt, aber ich wollte mal eins zu elitepvpers bringen. Da das hier mein erster Guide ist freue ich mich über Feedback und Verbesserungs Vorschläge :-)
Aber nun fangen wir an:
1. History and Informations
1-1 Was ist Lua?
1-2 Warum ist es besonders für uns praktisch?
2. Das berühmte Hello World Programm
2-1 Die Header Dateien
2-2 Das Grundgerüst
2-3 Die Erweiterung
2-4 Das Finale
3. Der Funktionsaufruf
3-1 Warum Aufrufen?
3-2 Der Code
4. Von Stacks, Variablen und Schiebungen
4-1 Wer oder Was ist der "Stack"?!
4-2 Wieso brauchen wir das?
4-3 Den Stack auslesen
4-4 Werte zurück geben
4-5 Der Abschluss
5. Links und Quellen
1. History and Informations
1-1) Was ist Lua?
Lua ist eine Skriptsprache zur Einbindung in Programmen um diese leichter Warten zu können. Sie wurde 1993 von der Computer Graphics Technology Group der Päpstlichen Katholischen Universität in Rio de Janeiro entwickelt. Lua ist eine freie Software und kann damit kostenlos genutzt werden. Außerdem ist sie Platform unabhängig, was ihr viele Pluspunkte einbringt. Man kann zwar mit Lua ein eigenes Programm schreiben nur wird sie meistens als Zusatz für C/C++ Programme verwendet. Oft auch in Spielen.
1-2) Warum ist es besonders für uns praktisch?
Wir können dort Programm Abschnitte auslagern und ändern ohne das Programm neu kompilieren zu müssen. Das bietet sich besonders für Plugins oder Konfigurationsdateien an. Glücklicherweise haben uns die Lua Programmierer eigene Header Datein zu Verfügung gestellt. Damit ist ein perfektes Zusammenspiel von C/C++ und Lua möglich.
2. Das berühmte Hello World Programm
2-1 Die Header Dateien
So nun wird es ernst. Wie bei jedem guten Programm fangen wir mit den Header Dateien an. (Die Header Dateien kannst du bei den Links runterladen) Nach dem wir die exe installiert haben, gehen wir in den Installations Ordner und kopieren den Inhalt von Include in deinen Projekt Ordner. Solltest du nicht mit VC++ arbeiten, musst du die Header in den selben Ordner kopieren wie deine .cpp, in der du die Header Included hast. Es gibt 3 Dateien mit denen wir Arbeiten werden:
Code:
- lua.h //Hier stehen die Funktionen für das Grundgerüst drin. - lualib.h //Hier die standart libraries. - lauxlib.h //Und hier die verschiedenen Script Funktionen (z.B. Für das Ausführen des Scripts in C++)
Code:
extern "C"
{
}
Code:
extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
2-2 Das Grundgerüst
Nun da wir die Funktionen der Header Dateien kennen und diese auch erfolgreich eingebunden haben kann es jetzt weiter gehen. Und zwar mit dem Grundgerüst für euer C++ Programm. Diese sehen wie folgt aus:
Code:
//Wir brauchen zu erst eine Instanz. Diese erstellen wir mit lua_State* Irgend_ein_Name; //Diese muss ja auch initialisiert werden. Das passiert mit Irgend_ein_Name = lua_open(); //Und zum Abschluss der Befehl der die Instanz wieder frei gibt. lua_close(Irgend_ein_Name);
Code:
extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
int main()
{
lua_State* Irgend_ein_Name; //Das Erstellen
Irgend_ein_Name = lua_open(); //Das Initialisieren
lua_close(Irgend_ein_Name); //Das Freigeben
return 0;
}
2-3 Die Erweiterung
Wie du siehst kommen wir dem Ergebnis langsam näher. Jetzt werde ich dir die Befehle zeigen, mit denen du die lua Datein ausführe kannst. Also ab zu Reference:
Code:
//Nun müssen wir festlegen was wir mit der lua Datei machen wollen. Wenn du einen einfachen Code ausführen willst reicht diese Bibliothek: luaopen_base(Irgend_ein_Name); //Das heißt nicht das es nicht noch mehr gibt. Es gibt noch: luaopen_string(Irgend_ein_Name); luaopen_table(Irgend_ein_Name); luaopen_math(Irgend_ein_Name); luaopen_debug(Irgend_ein_Name); //So nun kommt der wohl wichtigste Befehl: luaL_dofile(Irgend_ein_Name, "Meine Lua.lua"); //Jeder der ein bisschen Englisch versteht sollte wissen was das heißt aber ich sage es gerne trotzdem. Dieser Befehl führt die angegebene Lua Datei aus. In diesem Fall Meine Lua.lua
Code:
extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
int main()
{
lua_State* Irgend_ein_Name; //Das Erstellen
Irgend_ein_Name = lua_open(); //Das Initialisieren
luaopen_base(Irgend_ein_Name); //Die Bibliothek
luaL_dofile(Irgend_ein_Name, "Meine Lua.lua" ); //Der Ausführen Befehl
lua_close(Irgend_ein_Name); //Das Freigeben
return 0;
}
Wir haben so lange gewartet (max. 10 min) und jetzt ist er da. Endlich das Finale ;-) Der Code in unserer .cpp Datei ist nun so gut wie Fertig. Jetzt kümmern wir uns noch um die lua und schmücken den Quellcode der .cpp noch ein bisschen aus. Also reden wir mal nicht um den heißen Brei herrum sondern fangen gleich an :-) Für die lua ist der Code denkbar einfach:
Code:
––Das gibt einfach nur Hello World aus ;-) Lua Befehle müssen nicht mit einem Semikolon abgeschlossen werden. Ich mache das aber sieht besser aus ;-)–– print "Hello World";
Man muss es nicht ändern der Code funktioniert auch so, aber ich schreibe es trozdem mal rein^^
Code:
[COLOR="Red"]#include <iostream> [/COLOR]//Siehe unten
extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
int main()
{
lua_State* Irgend_ein_Name [COLOR="Red"]= NULL[/COLOR]; //Damit durch den Speicher keine Fehler kommen können.
Irgend_ein_Name = lua_open(); //Das Initialisieren
luaopen_base(Irgend_ein_Name); //Die Bibliothek
luaL_dofile(Irgend_ein_Name, "Meine Lua.lua" ); //Der Ausführen Befehl
lua_close(Irgend_ein_Name); //Das Freigeben
[COLOR="Red"]std::cin.get();[/COLOR] //Damit wir den Hello World Schriftzug auch bestaunen können ;-)
return 0;
}
3. Der Funktionsaufruf
3-1 Warum Aufrufen?
Das Aufrufen von Funktionen ist eine feine Sache. Damit können wir z.B. fast den kompletten Programm Code auslagern und ändern ohne das Programm neu kompilieren. Oder wir liefern ein Programm aus, das sehr individuell eingestellt werden muss. Das Funktioniert alles mit dieser Sprache ;-)
3-2 Der Code
Da wir nun schon die Grundkentnisse von Lua in C/C++ kennen, wird dieser Abschnitt nicht mehr so lang. Aber lets so ;-) Zu erst brauchen wir eine Funktion in unserem cpp Code:
Code:
int Lua_Funktion(lua_State* Irgend_ein_Name)
{
std::cout << "Wenn du das lesen kannst, dann hast du eine Funktion aufgerufen :-)\n";
return 0;
}
Jetzt kommen 2 neue Befehle.
Code:
//Mit dieser Funktion pushen wir die Funktion auf den Lua-Stack. Die Null steht für den return Wert (steht oben). Aber dazu später mehr. lua_pushcclosure(Irgend_ein_Name, Lua_Funktion,0); //Damit geben wir der gepushten Funktion (oben) einen Namen für den Stack. In diesem Fall TestFunktion. lua_setglobal(Irgend_ein_Name, "TestFunktion");
Code:
#include <iostream>
extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
int Lua_Funktion(lua_State* Irgend_ein_Name)
{
std::cout << "Wenn du das lesen kannst, dann hast du eine Funktion aufgerufen :-)\n";
return 0;
}
int main()
{
lua_State* Irgend_ein_Name = NULL;
Irgend_ein_Name = lua_open();
luaopen_base(Irgend_ein_Name);
lua_pushcclosure(Irgend_ein_Name, Lua_Funktion,0);
lua_setglobal(Irgend_ein_Name, "TestFunktion");
luaL_dofile(Irgend_ein_Name, "Meine Lua.lua" );
lua_close(Irgend_ein_Name);
std::cin.get();
return 0;
}
Code:
//Wir rufen eine Funktion auf: TestFunktion(); //Hier muss immer der lua_setglobal() Name angegeben werden. Also nicht vergessen ;-)
4. Von Stacks, Variablen und Schiebungen
4-1 Wer oder Was ist der "Stack"?!
Diese Frage habe ich mir bis heute morgen auch gestellt. Aber nun habe ich eine Antwort^^ Der Stack (Auch Stapelspeicher oder Kellerspeicher genannt) ist ein bestimmter Speicherbereich der Objekte aufnehmen kann. Dabei gibt es ein bestimmtes Verfahren wie der Stack beschrieben oder entleert wird. Das Last In – First Out-Prinzip. Stelle dir einfach mal einen Stapel Bücher vor. Diese liegen übereinander. Jetzt kommt der Befehl push. Nun nimmst du ein neues Buch und legst es oben auf den Stapel. Jetzt ist der Befehl zu Ende. Danach kommt der Befehl pop. Jetzt nimmst du das oberste Buch wieder runter und liest es :P So funktioniert das System. Was noch wichtig ist, das du nur auf das oberste Objekt zugreifen kannst. Das kümmert uns aber wenig ;-)
4-2 Wieso brauchen wir das?
Nur durch den Stack können C/C++ und Lua zusammenarbeiten. Die Funktion die wir vohrer erstellt haben wurde auch in den Stack geschrieben. Auch Variablen werde vom Stack geholt. Also stelle dich darauf ein mit dem Stack zu arbeiten.
4-3 Den Stack auslesen
Unser erstes Programm in dieser Sektion wird ein auslese Programm sein. Dazu werde ich dir erstmal die Befehle näher bringen:
Code:
//Bei diesem Baby wird dir die Anzahl der Parameter auf dem Stack ausgegeben. lua_gettop(Irgend_ein_Name); //Damit Befreit man den Stack von den Parametern lua_pop(Irgend_ein_Name, lua_gettop(Irgend_ein_Name) ); //Hiermit überprüft man die Gültigkeit eines Parameters lua_isnil(Irgend_ein_Name, -StackNummer); //Mit dieser Funktion kann man Parameter in Strings umwandeln lua_tostring(Irgend_ein_Name, StackNummer);
Code:
#include <iostream>
extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
int Lua_Funktion(lua_State* Irgend_ein_Name)
{
int ParameterAnzahl = lua_gettop(Irgend_ein_Name);
std::cout << "Es gibt " << ParameterAnzahl << " Parameter" << "\n";
while(ParameterAnzahl)
{
std::string Parameter = "";
if(!lua_isnil(Irgend_ein_Name, -ParameterAnzahl) )
{
Parameter = lua_tostring(Irgend_ein_Name, -ParameterAnzahl );
std::cout << "Parameter:" << Parameter.c_str() << "\n";
}
--ParameterAnzahl;
}
lua_pop(Irgend_ein_Name, lua_gettop(Irgend_ein_Name) );
return 0;
}
int main()
{
lua_State* Irgend_ein_Name = NULL;
Irgend_ein_Name = lua_open();
luaopen_base(Irgend_ein_Name);
lua_pushcclosure(Irgend_ein_Name, Lua_Funktion,0);
lua_setglobal(Irgend_ein_Name, "TestFunktion");
luaL_dofile(Irgend_ein_Name, "Meine Lua.lua" );
lua_close(Irgend_ein_Name);
std::cin.get();
return 0;
}
Code:
TestFunktion("Hahaha SPAMM", 12, "Ich bin der beste :P");
4-4 Werte zurück geben
Das wird unsere letzte Sektion sein, in der wir etwas Sinnvolles machen^^ Also genieße es xD Jetzt lernen wir, wie wir einen Rückgabewert einfädeln. Also pass gut auf ;-) Fangen wir wie immer mit den neuen Funktionen an:
Code:
//Für Strings nehmen wir lua_pushstring(Irgend_ein_Name, "Hier dein String"); //Für Zahlen aller Art lua_pushnumber(Irgend_ein_Name, 12); //Es gibt noch mehr Typen (z.B. boolean also true oder false) aber auf die werde ich nicht eingeben, da man mit den oben genannten so gut wie alles machen kann
Code:
#include <iostream>
extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
int Lua_Funktion(lua_State* Irgend_ein_Name)
{
lua_pushstring(Irgend_ein_Name, "ACHTUNG!!! Das ist ein Test!!!" );
lua_pushnumber(Irgend_ein_Name, 12 );
return 2; //Da wir 2 Sachen auf den Stack pushen. Wir erinnern uns return gibt die Anzahl der Objekte an die auf den Stack gepusht werden ;-)
}
int main()
{
lua_State* Irgend_ein_Name = NULL;
Irgend_ein_Name = lua_open();
luaopen_base(Irgend_ein_Name);
lua_pushcclosure(Irgend_ein_Name, Lua_Funktion,0);
lua_setglobal(Irgend_ein_Name, "TestFunktion");
luaL_dofile(Irgend_ein_Name, "Meine Lua.lua" );
lua_close(Irgend_ein_Name);
std::cin.get();
return 0;
}
Code:
Wert1, Wert2 = TestFunktion(); ––Damit das Script weiß woher die Werte kommen–– print( "Wert1: ", Wert1 ); ––Einfach zum ausgeben–– print( "Wert2: ", Wert2 );
4-5 Der Abschluss
So jetzt noch eine Checkliste was du können solltest :P
:check: Ich kann mit C++ Lua Code in einer Lua Datei ausführen.
:check: Ich kann C++ Funktionen mit einer Lua Datei ausführen.
:check: Ich kann Parameter zwischen den verschieden Sprachen tauschen.
Wenn du das kannst war mein Guide ein voller Erfolg :-)
Solltes du Fragen, Anregungen oder etwas einfach nicht verstanden haben verwende deine Fähigkeit einen Post zu machen ;-)
Sonst noch viel Spaß bei elitepvpers
5. Links und Quellen
Lua Wikipedia
Stack Wikipedia
griegst ein thx
