Hi^^
Ich weiß das es für dieses Thema sehr viele Guides in google gibt, aber ich wollte mal eins zu MMORPG-Core bringen. Da das hier mein erster Guide ist freue ich mich über Feedback und Verbesserungs Vorschläge :-)
Aber nun fangen wir an:
[SIZE="4"][COLOR="Red"]1. History and Informations[/COLOR][/SIZE]
1-1 Was ist Lua?
1-2 Warum ist es besonders für uns praktisch?
[SIZE="4"][COLOR="Red"]2. Das berühmte Hello World Programm[/COLOR][/SIZE]
2-1 Die Header Dateien
2-2 Das Grundgerüst
2-3 Die Erweiterung
2-4 Das Finale
[SIZE="4"][COLOR="Red"]3. Der Funktionsaufruf[/COLOR][/SIZE]
3-1 Warum Aufrufen?
3-2 Der Code
[SIZE="4"][COLOR="Red"]4. Von Stacks, Variablen und Schiebungen[/COLOR][/SIZE]
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
[SIZE="4"][COLOR="Red"]5. Links und Quellen[/COLOR][/SIZE]
[COLOR="Red"][SIZE="5"]1. History and Informations[/SIZE][/COLOR]
[SIZE="4"]1-1) Was ist Lua?[/SIZE]
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.
[SIZE="4"]1-2) Warum ist es besonders für uns praktisch?[/SIZE]
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.
[COLOR="Red"][SIZE="5"]2. Das berühmte Hello World Programm[/SIZE][/COLOR]
[SIZE="4"]2-1 Die Header Dateien[/SIZE]
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:
- 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++)Da diese alle in C geschrieben sind, müssen wir das dem Compiler mitteilen. Das machen wir so:
extern "C"
{
}
Dort kommen alle unsere Lua Header Dateien rein. Also:
extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
Damit der Compiler eure Header laden kann, müssen sich diese im selben Ordner befinden wie euer Projekt. Vergesst das nicht ;-)
[SIZE="4"]2-2 Das Grundgerüst[/SIZE]
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:
//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);Nun fügen wird das noch unserem Quellcode an:
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;
}
Gut. Nun steht unser Grundgerüst :-)
[SIZE="4"]2-3 Die Erweiterung[/SIZE]
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:
//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
Jetzt wir kommen auf die Zielgerade :-) Nur noch schnell den Code in die Quelldatei.
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;
}[SIZE="4"]2-4 Das Finale[/SIZE]
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:
––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";
Nun das in eine txt Datei schreiben. Diese umbenennen in "Meine Lua.lua" und fertig ;-) Kommen wir noch zu unserem cpp Quellcode.
Man muss es nicht ändern der Code funktioniert auch so, aber ich schreibe es trozdem mal rein^^
[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;
}
Nach dem ihr den Code geändet habt (oder auch nicht^^) drückt ihr einfach F5 oder eure Taste zum kompilieren wartet während Fehler gesucht werden (Die hoffentlich nicht kommen^^ Ihr könnt sie gerne Posten...) und bestaunt den Schriftzug in eurer Konsole. Der zweite Teil des Guides ist jetzt hier zu Ende ich hoffe ihr habt die 10 min eures Lebens nicht vergeudet und hattet Spaß. Tja dann noch Have Fun at MMORPG-Core.com ;-)
[COLOR="Red"][SIZE="5"]3. Der Funktionsaufruf[/SIZE][/COLOR]
[SIZE="4"]3-1 Warum Aufrufen?[/SIZE]
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 ;-)
[SIZE="4"]3-2 Der Code[/SIZE]
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:
int Lua_Funktion(lua_State* Irgend_ein_Name)
{
std::cout << "Wenn du das lesen kannst, dann hast du eine Funktion aufgerufen :-)\n";
return 0;
}
Wie du siehst brauchen wir (wie auch sonst so gut wie immer) eine Instanz. Diese kommt in den Parameter der Funktion. Wir geben einen Integer Wert zurück. Dieser Wert gibt die Anzahl der Parameter zurück, die wir in den Lua-Stack (später) geschoben haben. In diesem Fall 0. Und nicht vergessen: Diese Funktion wird von der main() Funktion aufgerufen. Also vor die main() Funktion schreiben ;-)
Jetzt kommen 2 neue Befehle.
//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");
Sooo jetzt noch schnell das ganze in unseren Quellcode und es kann los gehen.
#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;
}
So unsere .cpp ist fertig. 50% geschafft^^ Jetzt kommt noch die Lua. Wie auch vohrer extrem einfach ;-)
//Wir rufen eine Funktion auf:
TestFunktion();
//Hier muss immer der lua_setglobal() Name angegeben werden. Also nicht vergessen ;-)
So damit währen wir hier fertig. Kompilieren und String ansehen^^ Ich weiß das dir der Funktionsaufruf noch nicht ganz klar ist aber wenn du den nächsten Abschnitt gelesen hast wird er dir klar sein :-)
[COLOR="Red"][SIZE="5"]4. Von Stacks, Variablen und Schiebungen[/SIZE][/COLOR]
[SIZE="4"]4-1 Wer oder Was ist der "Stack"?![/SIZE]
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 ;-)
[SIZE="4"]4-2 Wieso brauchen wir das?[/SIZE]
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.
[SIZE="4"]4-3 Den Stack auslesen[/SIZE]
Unser erstes Programm in dieser Sektion wird ein auslese Programm sein. Dazu werde ich dir erstmal die Befehle näher bringen:
//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);So jetzt kommen wir zu unserem ersten Test Programm. Damit lesen wir den Stack aus. Das ist der Code für die .cpp Datei.
#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;
}
Jetzt kommt der Code für die lua Datei.
TestFunktion("Hahaha SPAMM", 12, "Ich bin der beste :P");Soooooo Kompiliere und fertig^^ Unser Testprogramm ist/war ein voller Erfolg xD Ab zur nächsten Sektion. Da gehts dann mal richtig zur Sache ;-)
[SIZE="4"]4-4 Werte zurück geben[/SIZE]
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:
//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
Was das war es schon?! Tja ich fürchte ja. Also schnell zur .cpp ;-)
#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;
}
Jetzt noch die lua und dan ist finish ;-)
Wert1, Wert2 = TestFunktion(); ––Damit das Script weiß woher die Werte kommen––
print( "Wert1: ", Wert1 ); ––Einfach zum ausgeben––
print( "Wert2: ", Wert2 );
Sooooo F5 oder deine Taste halt :P Genieße das Wissen was du in den letzten Minuten gewonnen hast ;-)
[SIZE="4"]4-5 Der Abschluss[/SIZE]
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 MMORPG-Core.com :grin:
[COLOR="Red"][SIZE="5"]5. Links und Quellen[/SIZE][/COLOR]
Lua für Windows [Mit Header Dateien]