Angepinnt [Guide] C++ Programme mit Lua 5.0

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • [Guide] C++ Programme mit Lua 5.0

      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:

      Quellcode

      1. - lua.h //Hier stehen die Funktionen für das Grundgerüst drin.
      2. - lualib.h //Hier die standart libraries.
      3. - 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:

      Quellcode

      1. extern "C"
      2. {
      3. }

      Dort kommen alle unsere Lua Header Dateien rein. Also:

      Quellcode

      1. extern "C"
      2. {
      3. #include "lua.h"
      4. #include "lualib.h"
      5. #include "lauxlib.h"
      6. }

      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:

      Quellcode

      1. //Wir brauchen zu erst eine Instanz. Diese erstellen wir mit
      2. lua_State* Irgend_ein_Name;
      3. //Diese muss ja auch initialisiert werden. Das passiert mit
      4. Irgend_ein_Name = lua_open();
      5. //Und zum Abschluss der Befehl der die Instanz wieder frei gibt.
      6. lua_close(Irgend_ein_Name);
      Nun fügen wird das noch unserem Quellcode an:

      Quellcode

      1. extern "C"
      2. {
      3. #include "lua.h"
      4. #include "lualib.h"
      5. #include "lauxlib.h"
      6. }
      7. int main()
      8. {
      9. lua_State* Irgend_ein_Name; //Das Erstellen
      10. Irgend_ein_Name = lua_open(); //Das Initialisieren
      11. lua_close(Irgend_ein_Name); //Das Freigeben
      12. return 0;
      13. }
      Alles anzeigen

      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:

      Quellcode

      1. //Nun müssen wir festlegen was wir mit der lua Datei machen wollen. Wenn du einen einfachen Code ausführen willst reicht diese Bibliothek:
      2. luaopen_base(Irgend_ein_Name);
      3. //Das heißt nicht das es nicht noch mehr gibt. Es gibt noch:
      4. luaopen_string(Irgend_ein_Name);
      5. luaopen_table(Irgend_ein_Name);
      6. luaopen_math(Irgend_ein_Name);
      7. luaopen_debug(Irgend_ein_Name);
      8. //So nun kommt der wohl wichtigste Befehl:
      9. luaL_dofile(Irgend_ein_Name, "Meine Lua.lua");
      10. //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
      Alles anzeigen

      Jetzt wir kommen auf die Zielgerade :-) Nur noch schnell den Code in die Quelldatei.

      Quellcode

      1. extern "C"
      2. {
      3. #include "lua.h"
      4. #include "lualib.h"
      5. #include "lauxlib.h"
      6. }
      7. int main()
      8. {
      9. lua_State* Irgend_ein_Name; //Das Erstellen
      10. Irgend_ein_Name = lua_open(); //Das Initialisieren
      11. luaopen_base(Irgend_ein_Name); //Die Bibliothek
      12. luaL_dofile(Irgend_ein_Name, "Meine Lua.lua" ); //Der Ausführen Befehl
      13. lua_close(Irgend_ein_Name); //Das Freigeben
      14. return 0;
      15. }
      Alles anzeigen


      [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:

      Quellcode

      1. ––Das gibt einfach nur Hello World aus ;-) Lua Befehle müssen nicht mit einem Semikolon abgeschlossen werden. Ich mache das aber sieht besser aus ;-)––
      2. 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^^

      Quellcode

      1. [COLOR="Red"]#include <iostream> [/COLOR]//Siehe unten
      2. extern "C"
      3. {
      4. #include "lua.h"
      5. #include "lualib.h"
      6. #include "lauxlib.h"
      7. }
      8. int main()
      9. {
      10. lua_State* Irgend_ein_Name [COLOR="Red"]= NULL[/COLOR]; //Damit durch den Speicher keine Fehler kommen können.
      11. Irgend_ein_Name = lua_open(); //Das Initialisieren
      12. luaopen_base(Irgend_ein_Name); //Die Bibliothek
      13. luaL_dofile(Irgend_ein_Name, "Meine Lua.lua" ); //Der Ausführen Befehl
      14. lua_close(Irgend_ein_Name); //Das Freigeben
      15. [COLOR="Red"]std::cin.get();[/COLOR] //Damit wir den Hello World Schriftzug auch bestaunen können ;-)
      16. return 0;
      17. }
      Alles anzeigen

      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:

      Quellcode

      1. int Lua_Funktion(lua_State* Irgend_ein_Name)
      2. {
      3. std::cout << "Wenn du das lesen kannst, dann hast du eine Funktion aufgerufen :-)\n";
      4. return 0;
      5. }

      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.

      Quellcode

      1. //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.
      2. lua_pushcclosure(Irgend_ein_Name, Lua_Funktion,0);
      3. //Damit geben wir der gepushten Funktion (oben) einen Namen für den Stack. In diesem Fall TestFunktion.
      4. lua_setglobal(Irgend_ein_Name, "TestFunktion");

      Sooo jetzt noch schnell das ganze in unseren Quellcode und es kann los gehen.

      Quellcode

      1. #include <iostream>
      2. extern "C"
      3. {
      4. #include "lua.h"
      5. #include "lualib.h"
      6. #include "lauxlib.h"
      7. }
      8. int Lua_Funktion(lua_State* Irgend_ein_Name)
      9. {
      10. std::cout << "Wenn du das lesen kannst, dann hast du eine Funktion aufgerufen :-)\n";
      11. return 0;
      12. }
      13. int main()
      14. {
      15. lua_State* Irgend_ein_Name = NULL;
      16. Irgend_ein_Name = lua_open();
      17. luaopen_base(Irgend_ein_Name);
      18. lua_pushcclosure(Irgend_ein_Name, Lua_Funktion,0);
      19. lua_setglobal(Irgend_ein_Name, "TestFunktion");
      20. luaL_dofile(Irgend_ein_Name, "Meine Lua.lua" );
      21. lua_close(Irgend_ein_Name);
      22. std::cin.get();
      23. return 0;
      24. }
      Alles anzeigen

      So unsere .cpp ist fertig. 50% geschafft^^ Jetzt kommt noch die Lua. Wie auch vohrer extrem einfach ;-)

      Quellcode

      1. //Wir rufen eine Funktion auf:
      2. TestFunktion();
      3. //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:

      Quellcode

      1. //Bei diesem Baby wird dir die Anzahl der Parameter auf dem Stack ausgegeben.
      2. lua_gettop(Irgend_ein_Name);
      3. //Damit Befreit man den Stack von den Parametern
      4. lua_pop(Irgend_ein_Name, lua_gettop(Irgend_ein_Name) );
      5. //Hiermit überprüft man die Gültigkeit eines Parameters
      6. lua_isnil(Irgend_ein_Name, -StackNummer);
      7. //Mit dieser Funktion kann man Parameter in Strings umwandeln
      8. 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.

      Quellcode

      1. #include <iostream>
      2. extern "C"
      3. {
      4. #include "lua.h"
      5. #include "lualib.h"
      6. #include "lauxlib.h"
      7. }
      8. int Lua_Funktion(lua_State* Irgend_ein_Name)
      9. {
      10. int ParameterAnzahl = lua_gettop(Irgend_ein_Name);
      11. std::cout << "Es gibt " << ParameterAnzahl << " Parameter" << "\n";
      12. while(ParameterAnzahl)
      13. {
      14. std::string Parameter = "";
      15. if(!lua_isnil(Irgend_ein_Name, -ParameterAnzahl) )
      16. {
      17. Parameter = lua_tostring(Irgend_ein_Name, -ParameterAnzahl );
      18. std::cout << "Parameter:" << Parameter.c_str() << "\n";
      19. }
      20. --ParameterAnzahl;
      21. }
      22. lua_pop(Irgend_ein_Name, lua_gettop(Irgend_ein_Name) );
      23. return 0;
      24. }
      25. int main()
      26. {
      27. lua_State* Irgend_ein_Name = NULL;
      28. Irgend_ein_Name = lua_open();
      29. luaopen_base(Irgend_ein_Name);
      30. lua_pushcclosure(Irgend_ein_Name, Lua_Funktion,0);
      31. lua_setglobal(Irgend_ein_Name, "TestFunktion");
      32. luaL_dofile(Irgend_ein_Name, "Meine Lua.lua" );
      33. lua_close(Irgend_ein_Name);
      34. std::cin.get();
      35. return 0;
      36. }
      Alles anzeigen

      Jetzt kommt der Code für die lua Datei.

      Quellcode

      1. 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:

      Quellcode

      1. //Für Strings nehmen wir
      2. lua_pushstring(Irgend_ein_Name, "Hier dein String");
      3. //Für Zahlen aller Art
      4. lua_pushnumber(Irgend_ein_Name, 12);
      5. //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 ;-)

      Quellcode

      1. #include <iostream>
      2. extern "C"
      3. {
      4. #include "lua.h"
      5. #include "lualib.h"
      6. #include "lauxlib.h"
      7. }
      8. int Lua_Funktion(lua_State* Irgend_ein_Name)
      9. {
      10. lua_pushstring(Irgend_ein_Name, "ACHTUNG!!! Das ist ein Test!!!" );
      11. lua_pushnumber(Irgend_ein_Name, 12 );
      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 ;-)
      13. }
      14. int main()
      15. {
      16. lua_State* Irgend_ein_Name = NULL;
      17. Irgend_ein_Name = lua_open();
      18. luaopen_base(Irgend_ein_Name);
      19. lua_pushcclosure(Irgend_ein_Name, Lua_Funktion,0);
      20. lua_setglobal(Irgend_ein_Name, "TestFunktion");
      21. luaL_dofile(Irgend_ein_Name, "Meine Lua.lua" );
      22. lua_close(Irgend_ein_Name);
      23. std::cin.get();
      24. return 0;
      25. }
      Alles anzeigen

      Jetzt noch die lua und dan ist finish ;-)

      Quellcode

      1. Wert1, Wert2 = TestFunktion(); ––Damit das Script weiß woher die Werte kommen––
      2. print( "Wert1: ", Wert1 ); ––Einfach zum ausgeben––
      3. 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]

      Lua Wikipedia
      Stack Wikipedia
      Help Guide 1
      Help Guide 2
    • Werbung zur Unterstützung des Forums ( Bitte AddBlocker deaktivieren )

    • [FONT="Comic Sans MS"][COLOR="DeepSkyBlue"][SIZE="3"]Hmm muss sagen, nach der schönen Diskussion letztens über LUA und ini's sowie die Tatsache, dass wir bei einer .inc Datei einen Header haben, ist so ein Guide doch mal was nettes.
      Freut mich, dass du den gemacht hast.
      Sofern du den 3. Teil nachträgst wärs noch besser, aber lass dir Zeit und verstehs selbst erstmal, damit zu keinen Problemen gibt.
      Wäre mal nett, wenn weitere Guides auftauchen würden, hier im gesamten Coding ists momentan biss leer.

      #thx
      Und zum Abschluss
      #sticked (Auch wenn wenig los ist, trotzdem mal wieder ein stick.)[/SIZE][/COLOR][/FONT]
    • [FONT="Comic Sans MS"][COLOR="DeepSkyBlue"][SIZE="3"]Mit dem Sticky, war bei mri auch so, ich kam her, hatte am ersten tag nen Guide poriert und bekam Sticky + Karma (da hatten wir noch Karma-Addon)
      Von daher.
      Ausserdem, gute Sachen verdienen eben auch mal was.
      KÖnntest ja vll mal noch schaun, wie es sich bei C# verhält, vll wärs was für mcih.[/SIZE][/COLOR][/FONT]
    • Sry aber mit C# muss ich ja wieder die Grundlagen lernen^^ Keinen Bock drauf :P
      Ich habe mir gedacht, da ich ja gerade an der Spieleprogrammierung mit C++ dran bin einen Guide darüber zu schreiben wie ich Direct3D benutzen kann :/ Aber ich glaube für einen Guide langt mein Wissen nicht aus xD Und noch eine Off Topic Frage: Kann ich Visual C++ auf Ubuntu benutzen?^^
    • Chaosduckman;137383 schrieb:

      Sry aber mit C# muss ich ja wieder die Grundlagen lernen^^ Keinen Bock drauf :P
      Ich habe mir gedacht, da ich ja gerade an der Spieleprogrammierung mit C++ dran bin einen Guide darüber zu schreiben wie ich Direct3D benutzen kann :/ Aber ich glaube für einen Guide langt mein Wissen nicht aus xD Und noch eine Off Topic Frage: Kann ich Visual C++ auf Ubuntu benutzen?^^


      Visual C++ is von Microsoft, damit dürfte die Frage schon geklärt sein. Mit Wine theoretisch, aber da solltest du lieber auf z.B. Dev C++ zurückgreifen.
    • nicht ganz so gut erklärtes tut z.b.

      Nach dem wir die exe installiert haben, gehen wir in den Installations Ordner und kopieren den Inhalt von Include in deinen Projekt Ordner. Es gibt 3 Dateien mit denen wir Arbeiten werden:


      welchen projekt ordner ? welche 3 in deinen tut steht nirgens
      wo und wann man ein projekt erstellt O.o
    • [COLOR="DeepSkyBlue"]
      welchen projekt ordner ?

      Also wenn du mit VC++ Arbeitest brauchst du einen sonst geht nichts, aber ich werde es schnell anfügen ;-)
      welche 3 in deinen tut steht nirgens

      Wenn du ein bisschen weiter ließt kommen die Datein :-)
      wo und wann man ein projekt erstellt O.o

      Siehe 1

      Aber Danke für deine Kritik :D

      Edit:
      So angefügt :
      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.


      [/COLOR]
    • Duck, du willst Feedback - du kriegst Feedback.

      Ich bin dabei LUA in mein Projekt einzubinden. Ich benutze CodeBlocks mit MinGW. Ich habe alle LUA Dateien in das Projekt aufgenommen und die Header wie beschrieben includiert. Beim ersten Versuch erhielt ich die Fehlermeldung "multiple definition of main". Da stellte ich fest, daß in lua.c bereits eine main ist.

      Nun mal sehen wie es weitergeht. Ich plane das ganze Programm luagesteuert zu gestalten. Ich glaub, das krieg ich schon hin. Wolte es nur mal berichten.