From 3805d7ce6cae9f62e4c42950779f6a8ef8114082 Mon Sep 17 00:00:00 2001 From: Lion Kortlepel Date: Fri, 2 Apr 2021 00:44:23 +0200 Subject: [PATCH] Begin Lua Rewrite The idea is to move everything to TLuaEngine. --- .gitignore | 12 +++ include/TLuaEngine.h | 22 +++-- include/TLuaEvent.h | 7 ++ include/TLuaFile.h | 21 +++-- src/TLuaEngine.cpp | 200 ++++++++++++++++++++++++++++++++++++------- src/TLuaEvent.cpp | 2 + src/TLuaFile.cpp | 176 +++++-------------------------------- src/main.cpp | 2 + 8 files changed, 240 insertions(+), 202 deletions(-) create mode 100644 include/TLuaEvent.h create mode 100644 src/TLuaEvent.cpp diff --git a/.gitignore b/.gitignore index 8544c43..5fe3e85 100644 --- a/.gitignore +++ b/.gitignore @@ -468,3 +468,15 @@ cmake-build-debug/include/commandline/Makefile *.manifest *.rc *.res +changelog-2.0.txt +compile_commands.json +err.html +file.c +log.txt +nohup.out +notes/ +patch.patch +new-backend.txt +sanitizer.txt +speedcc.fit +socket.txt diff --git a/include/TLuaEngine.h b/include/TLuaEngine.h index 9e59964..6c8f91e 100644 --- a/include/TLuaEngine.h +++ b/include/TLuaEngine.h @@ -9,30 +9,42 @@ #include #include +#include +namespace fs = std::filesystem; + +struct TLuaArgs final { + std::vector Args; +}; + class TLuaEngine : public IThreaded { public: explicit TLuaEngine(TServer& Server, TNetwork& Network); - using TSetOfLuaFile = std::set>; + using TSetOfLuaFile = std::vector>; void operator()() override; - [[nodiscard]] const TSetOfLuaFile& LuaFiles() const { return mLuaFiles; } + std::any TriggerLuaEvent(const std::string& Event, bool local, std::weak_ptr Caller, std::shared_ptr arg, bool Wait); + [[nodiscard]] TServer& Server() { return mServer; } [[nodiscard]] const TServer& Server() const { return mServer; } [[nodiscard]] TNetwork& Network() { return mNetwork; } [[nodiscard]] const TNetwork& Network() const { return mNetwork; } - std::optional> GetScript(lua_State* L); + void UnregisterScript(std::shared_ptr Script); + std::shared_ptr GetLuaFileOfScript(lua_State* L); + std::shared_ptr InsertNewLuaFile(const fs::path& FileName, const std::string& PluginName); + void SendError(lua_State* L, const std::string& msg); private: void FolderList(const std::string& Path, bool HotSwap); - void RegisterFiles(const std::string& Path, bool HotSwap); - bool NewFile(const std::string& Path); + void RegisterFiles(const fs::path& Path, bool HotSwap); + bool IsNewFile(const std::string& Path); TNetwork& mNetwork; TServer& mServer; std::string mPath; bool mShutdown { false }; + mutable std::mutex mLuaFilesMutex; TSetOfLuaFile mLuaFiles; }; diff --git a/include/TLuaEvent.h b/include/TLuaEvent.h new file mode 100644 index 0000000..7fa2ee6 --- /dev/null +++ b/include/TLuaEvent.h @@ -0,0 +1,7 @@ +#pragma once + +#include +#include + +class TLuaEvent final { +}; diff --git a/include/TLuaFile.h b/include/TLuaFile.h index a94a6b8..adb1754 100644 --- a/include/TLuaFile.h +++ b/include/TLuaFile.h @@ -11,15 +11,14 @@ namespace fs = std::filesystem; -struct TLuaArg { - std::vector args; - void PushArgs(lua_State* State); -}; - class TLuaEngine; +class TLuaArgs; class TLuaFile { public: + explicit TLuaFile(TLuaEngine& Engine, bool Console = false); + ~TLuaFile(); + void RegisterEvent(const std::string& Event, const std::string& FunctionName); void UnRegisterEvent(const std::string& Event); void SetLastWrite(fs::file_time_type time); @@ -30,11 +29,8 @@ public: fs::file_time_type GetLastWrite(); lua_State* GetState(); std::string GetOrigin(); - std::mutex Lock; void Reload(); void Init(const std::string& PluginName, const std::string& FileName, fs::file_time_type LastWrote); - explicit TLuaFile(TLuaEngine& Engine, bool Console = false); - ~TLuaFile(); void SetStopThread(bool StopThread) { mStopThread = StopThread; } TLuaEngine& Engine() { return mEngine; } [[nodiscard]] std::string GetPluginName() const; @@ -43,8 +39,14 @@ public: [[nodiscard]] bool GetStopThread() const { return mStopThread; } [[nodiscard]] const TLuaEngine& Engine() const { return mEngine; } [[nodiscard]] std::string GetRegistered(const std::string& Event) const; + void PushArgs(const TLuaArgs& args); + + bool operator==(const TLuaFile& Other) const; + + void Load(); private: + std::mutex Lock; TLuaEngine& mEngine; std::set> mRegisteredEvents; lua_State* mLuaState { nullptr }; @@ -53,9 +55,6 @@ private: std::string mFileName {}; bool mStopThread = false; bool mConsole = false; - void Load(); }; -std::any TriggerLuaEvent(const std::string& Event, bool local, TLuaFile* Caller, std::shared_ptr arg, bool Wait); - #endif // TLUAFILE_H diff --git a/src/TLuaEngine.cpp b/src/TLuaEngine.cpp index 6db855a..6a2d911 100644 --- a/src/TLuaEngine.cpp +++ b/src/TLuaEngine.cpp @@ -1,18 +1,16 @@ #include "TLuaEngine.h" +#include "Client.h" +#include "CustomAssert.h" #include "TLuaFile.h" -#include -#include +#include -namespace fs = std::filesystem; - -// necessary as lua relies on global state -TLuaEngine* TheEngine; +extern TLuaEngine* TheLuaEngine; TLuaEngine::TLuaEngine(TServer& Server, TNetwork& Network) : mNetwork(Network) , mServer(Server) { - TheEngine = this; + TheLuaEngine = this; if (!fs::exists(Application::Settings.Resource)) { fs::create_directory(Application::Settings.Resource); } @@ -31,16 +29,27 @@ TLuaEngine::TLuaEngine(TServer& Server, TNetwork& Network) Start(); } +void TLuaEngine::UnregisterScript(std::shared_ptr Script) { + std::unique_lock Lock(mLuaFilesMutex); + auto Iter = std::find_if(mLuaFiles.begin(), mLuaFiles.end(), [&](const auto& ScriptPtr) { + return *Script == *ScriptPtr; + }); + if (Iter != mLuaFiles.end()) { + // found! + mLuaFiles.erase(Iter); + } +} + void TLuaEngine::operator()() { RegisterThread("LuaEngine"); info("Lua system online"); while (!mShutdown) { if (!mLuaFiles.empty()) { for (auto& Script : mLuaFiles) { - struct stat Info { }; - if (stat(Script->GetFileName().c_str(), &Info) != 0) { + const auto& filename = Script->GetFileName(); + if (!fs::is_regular_file(filename)) { Script->SetStopThread(true); - mLuaFiles.erase(Script); + UnregisterScript(Script); info(("[HOTSWAP] Removed removed script due to delete")); break; } @@ -57,47 +66,178 @@ void TLuaEngine::operator()() { } } -std::optional> TLuaEngine::GetScript(lua_State* L) { +std::any TLuaEngine::TriggerLuaEvent(const std::string& Event, bool local, std::weak_ptr Caller, std::shared_ptr arg, bool Wait) { + std::any R; + std::string Type; + int Ret = 0; + // TODO: lock + for (auto& Script : mLuaFiles) { + if (Script->IsRegistered(Event)) { + if (local) { + if (Script->GetPluginName() == Caller->GetPluginName()) { + R = FutureWait(Script.get(), Script->GetRegistered(Event), arg, Wait); + Type = R.type().name(); + if (Type.find("int") != std::string::npos) { + if (std::any_cast(R)) + Ret++; + } else if (Event == "onPlayerAuth") + return R; + } + } else { + R = FutureWait(Script.get(), Script->GetRegistered(Event), arg, Wait); + Type = R.type().name(); + if (Type.find("int") != std::string::npos) { + if (std::any_cast(R)) + Ret++; + } else if (Event == "onPlayerAuth") + return R; + } + } + } + return Ret; +} + +std::shared_ptr TLuaEngine::GetLuaFileOfScript(lua_State* L) { + std::unique_lock Lock(mLuaFilesMutex); for (auto& Script : mLuaFiles) { if (Script->GetState() == L) - return *Script; + return Script; } - return std::nullopt; + return nullptr; } void TLuaEngine::FolderList(const std::string& Path, bool HotSwap) { for (const auto& entry : fs::directory_iterator(Path)) { - auto pos = entry.path().filename().string().find('.'); - if (pos == std::string::npos) { - RegisterFiles(entry.path().string(), HotSwap); + if (fs::is_directory(entry)) { + RegisterFiles(entry.path(), HotSwap); } } } -void TLuaEngine::RegisterFiles(const std::string& Path, bool HotSwap) { - std::string Name = Path.substr(Path.find_last_of('\\') + 1); - if (!HotSwap) +void TLuaEngine::RegisterFiles(const fs::path& Path, bool HotSwap) { + std::string Name = Path.filename(); + if (!HotSwap) { info(("Loading plugin : ") + Name); + } for (const auto& entry : fs::directory_iterator(Path)) { - auto pos = entry.path().string().find((".lua")); - if (pos != std::string::npos && entry.path().string().length() - pos == 4) { - if (!HotSwap || NewFile(entry.path().string())) { - auto FileName = entry.path().string(); - std::unique_ptr ScriptToInsert(new TLuaFile(*this)); - auto& Script = *ScriptToInsert; - mLuaFiles.insert(std::move(ScriptToInsert)); - Script.Init(Name, FileName, fs::last_write_time(FileName)); - if (HotSwap) - info(("[HOTSWAP] Added : ") + Script.GetFileName().substr(Script.GetFileName().find('\\'))); + if (entry.is_regular_file() && entry.path().extension() == ".lua") { + if (!HotSwap || IsNewFile(entry.path().string())) { + InsertNewLuaFile(entry.path(), Path.filename()); + if (HotSwap) { + info(("[HOTSWAP] Added : ") + entry.path().filename().string()); + } } } } } -bool TLuaEngine::NewFile(const std::string& Path) { +bool TLuaEngine::IsNewFile(const std::string& Path) { + std::unique_lock Lock(mLuaFilesMutex); for (auto& Script : mLuaFiles) { + // TODO: use std::any_of if (Path == Script->GetFileName()) return false; } return true; } + +void TLuaEngine::SendError(lua_State* L, const std::string& msg) { + Assert(L); + auto MaybeS = GetLuaFileOfScript(L); + std::string a; + if (!MaybeS) { + a = ("_Console"); + } else { + // FIXME: GetFileName already returns the filename. This is redundant. + a = fs::path(MaybeS->GetFileName()).filename().string(); + } + warn(a + (" | Incorrect call of ") + msg); +} + +// ////////////////////////////////////////////// +// ////////// LUA *ONLY* BELOW ////////////////// +// ////////////////////////////////////////////// + +std::shared_ptr GetClient(TServer& Server, int ID) { + std::shared_ptr MaybeClient = nullptr; + Server.ForEachClient([&](std::weak_ptr CPtr) -> bool { + ReadLock Lock(Server.GetClientMutex()); + if (!CPtr.expired()) { + auto C = CPtr.lock(); + if (C->GetID() == ID) { + MaybeClient = C; + return false; + } + } + return true; + }); + return MaybeClient; +} + +int ServerLua_GetIdentifiers(lua_State* L) { + Assert(TheLuaEngine); + Assert(L); + if (lua_isnumber(L, 1)) { + // do not store this + // FIXME: should this not be lua_tointeger?! + auto MaybeClient = GetClient(TheLuaEngine->Server(), int(lua_tonumber(L, 1))); + if (MaybeClient) { + auto IDs = MaybeClient->GetIdentifiers(); + if (IDs.empty()) + return 0; + // FIXME: What does this entire thing do? Add comments. + lua_newtable(L); + for (const std::string& ID : IDs) { + lua_pushstring(L, ID.substr(0, ID.find(':')).c_str()); + lua_pushstring(L, ID.c_str()); + lua_settable(L, -3); + } + } else + return 0; + } else { + SendError(*TheLuaEngine, L, "lua_GetIdentifiers wrong arguments"); + return 0; + } + return 1; +} + + + +// LEAVE THIS AT THE **VERY** BOTTOM OF THE FILE + +std::shared_ptr TLuaEngine::InsertNewLuaFile(const fs::path& FileName, const std::string& PluginName) { + std::shared_ptr Script(new TLuaFile(*this)); + mLuaFiles.push_back(Script); + Script->SetPluginName(PluginName); + Script->SetFileName(FileName); + Script->SetLastWrite(fs::last_write_time(FileName)); + lua_State* State = Script->GetState(); + luaL_openlibs(State); + lua_register(State, "GetPlayerIdentifiers", ServerLua_GetIdentifiers); + lua_register(State, "TriggerGlobalEvent", lua_TriggerEventG); + lua_register(State, "TriggerLocalEvent", lua_TriggerEventL); + lua_register(State, "TriggerClientEvent", lua_RemoteEvent); + lua_register(State, "GetPlayerCount", lua_GetPlayerCount); + lua_register(State, "isPlayerConnected", lua_isConnected); + lua_register(State, "RegisterEvent", lua_RegisterEvent); + lua_register(State, "GetPlayerName", lua_GetPlayerName); + lua_register(State, "RemoveVehicle", lua_RemoveVehicle); + lua_register(State, "GetPlayerDiscordID", lua_TempFix); + lua_register(State, "CreateThread", lua_CreateThread); + lua_register(State, "GetPlayerVehicles", lua_GetCars); + lua_register(State, "SendChatMessage", lua_sendChat); + lua_register(State, "GetPlayers", lua_GetAllPlayers); + lua_register(State, "GetPlayerGuest", lua_GetGuest); + lua_register(State, "StopThread", lua_StopThread); + lua_register(State, "DropPlayer", lua_dropPlayer); + lua_register(State, "GetPlayerHWID", lua_HWID); + lua_register(State, "exit", lua_ServerExit); + lua_register(State, "Sleep", lua_Sleep); + lua_register(State, "print", lua_Print); + lua_register(State, "Set", lua_Set); + if (!Script->IsConsole()) { + Reload(); + } + debug("inserted new lua file: " + PluginName + " - " + FileName.string()); + return Script; +} diff --git a/src/TLuaEvent.cpp b/src/TLuaEvent.cpp new file mode 100644 index 0000000..6e873a6 --- /dev/null +++ b/src/TLuaEvent.cpp @@ -0,0 +1,2 @@ +#include "TLuaEvent.h" + diff --git a/src/TLuaFile.cpp b/src/TLuaFile.cpp index 99eb8ff..0d51d96 100644 --- a/src/TLuaFile.cpp +++ b/src/TLuaFile.cpp @@ -12,41 +12,13 @@ // TODO: REWRITE void SendError(TLuaEngine& Engine, lua_State* L, const std::string& msg); -std::any CallFunction(TLuaFile* lua, const std::string& FuncName, std::shared_ptr Arg); -std::any TriggerLuaEvent(TLuaEngine& Engine, const std::string& Event, bool local, TLuaFile* Caller, std::shared_ptr arg, bool Wait); +std::any CallFunction(TLuaFile* lua, const std::string& FuncName, std::shared_ptr Arg); +std::any TriggerLuaEvent(TLuaEngine& Engine, const std::string& Event, bool local, TLuaFile* Caller, std::shared_ptr arg, bool Wait); -extern TLuaEngine* TheEngine; - -static TLuaEngine& Engine() { - Assert(TheEngine); - return *TheEngine; -} - -std::shared_ptr CreateArg(lua_State* L, int T, int S) { - if (S > T) - return nullptr; - std::shared_ptr temp(new TLuaArg); - for (int C = S; C <= T; C++) { - if (lua_isstring(L, C)) { - temp->args.emplace_back(std::string(lua_tostring(L, C))); - } else if (lua_isinteger(L, C)) { - temp->args.emplace_back(int(lua_tointeger(L, C))); - } else if (lua_isboolean(L, C)) { - temp->args.emplace_back(bool(lua_toboolean(L, C))); - } else if (lua_isnumber(L, C)) { - temp->args.emplace_back(float(lua_tonumber(L, C))); - } - } - return temp; -} -void ClearStack(lua_State* L) { - lua_settop(L, 0); -} - -std::any Trigger(TLuaFile* lua, const std::string& R, std::shared_ptr arg) { +std::any Trigger(TLuaFile* lua, const std::string& R, std::shared_ptr arg) { RegisterThread(lua->GetFileName()); std::lock_guard lockGuard(lua->Lock); - std::packaged_task)> task([lua, R](std::shared_ptr arg) { return CallFunction(lua, R, arg); }); + std::packaged_task)> task([lua, R](std::shared_ptr arg) { return CallFunction(lua, R, arg); }); std::future f1 = task.get_future(); std::thread t(std::move(task), arg); t.detach(); @@ -56,9 +28,9 @@ std::any Trigger(TLuaFile* lua, const std::string& R, std::shared_ptr a SendError(lua->Engine(), lua->GetState(), R + " took too long to respond"); return 0; } -std::any FutureWait(TLuaFile* lua, const std::string& R, std::shared_ptr arg, bool Wait) { +std::any FutureWait(TLuaFile* lua, const std::string& R, std::shared_ptr arg, bool Wait) { Assert(lua); - std::packaged_task)> task([lua, R](std::shared_ptr arg) { return Trigger(lua, R, arg); }); + std::packaged_task)> task([lua, R](std::shared_ptr arg) { return Trigger(lua, R, arg); }); std::future f1 = task.get_future(); std::thread t(std::move(task), arg); t.detach(); @@ -70,35 +42,6 @@ std::any FutureWait(TLuaFile* lua, const std::string& R, std::shared_ptr arg, bool Wait) { - std::any R; - std::string Type; - int Ret = 0; - for (auto& Script : Engine().LuaFiles()) { - if (Script->IsRegistered(Event)) { - if (local) { - if (Script->GetPluginName() == Caller->GetPluginName()) { - R = FutureWait(Script.get(), Script->GetRegistered(Event), arg, Wait); - Type = R.type().name(); - if (Type.find("int") != std::string::npos) { - if (std::any_cast(R)) - Ret++; - } else if (Event == "onPlayerAuth") - return R; - } - } else { - R = FutureWait(Script.get(), Script->GetRegistered(Event), arg, Wait); - Type = R.type().name(); - if (Type.find("int") != std::string::npos) { - if (std::any_cast(R)) - Ret++; - } else if (Event == "onPlayerAuth") - return R; - } - } - } - return Ret; -} bool ConsoleCheck(lua_State* L, int r) { if (r != LUA_OK) { std::string msg = lua_tostring(L, -1); @@ -230,21 +173,7 @@ int lua_Sleep(lua_State* L) { } return 1; } -std::optional> GetClient(TServer& Server, int ID) { - std::optional> MaybeClient { std::nullopt }; - Server.ForEachClient([&](std::weak_ptr CPtr) -> bool { - ReadLock Lock(Server.GetClientMutex()); - if (!CPtr.expired()) { - auto C = CPtr.lock(); - if (C->GetID() == ID) { - MaybeClient = CPtr; - return false; - } - } - return true; - }); - return MaybeClient; -} + // CONTINUE int lua_isConnected(lua_State* L) { if (lua_isnumber(L, 1)) { @@ -311,27 +240,6 @@ int lua_GetAllPlayers(lua_State* L) { return 0; return 1; } -int lua_GetIdentifiers(lua_State* L) { - if (lua_isnumber(L, 1)) { - auto MaybeClient = GetClient(Engine().Server(), int(lua_tonumber(L, 1))); - if (MaybeClient && !MaybeClient.value().expired()) { - auto IDs = MaybeClient.value().lock()->GetIdentifiers(); - if (IDs.empty()) - return 0; - lua_newtable(L); - for (const std::string& ID : IDs) { - lua_pushstring(L, ID.substr(0, ID.find(':')).c_str()); - lua_pushstring(L, ID.c_str()); - lua_settable(L, -3); - } - } else - return 0; - } else { - SendError(Engine(), L, "lua_GetIdentifiers wrong arguments"); - return 0; - } - return 1; -} int lua_GetCars(lua_State* L) { if (lua_isnumber(L, 1)) { @@ -590,19 +498,7 @@ int lua_Print(lua_State* L) { int lua_TempFix(lua_State* L); void TLuaFile::Init(const std::string& PluginName, const std::string& FileName, fs::file_time_type LastWrote) { - // set global engine for lua_* functions - if (!TheEngine) { - TheEngine = &mEngine; - } Assert(mLuaState); - if (!PluginName.empty()) { - SetPluginName(PluginName); - } - if (!FileName.empty()) { - SetFileName(FileName); - } - SetLastWrite(LastWrote); - Load(); } TLuaFile::TLuaFile(TLuaEngine& Engine, bool Console) @@ -628,7 +524,7 @@ std::string TLuaFile::GetOrigin() { return fs::path(GetFileName()).filename().string(); } -std::any CallFunction(TLuaFile* lua, const std::string& FuncName, std::shared_ptr Arg) { +std::any CallFunction(TLuaFile* lua, const std::string& FuncName, std::shared_ptr Arg) { RegisterThread(lua->GetFileName()); lua_State* luaState = lua->GetState(); lua_getglobal(luaState, FuncName.c_str()); @@ -660,32 +556,6 @@ void TLuaFile::SetFileName(const std::string& Name) { } void TLuaFile::Load() { - Assert(mLuaState); - luaL_openlibs(mLuaState); - lua_register(mLuaState, "GetPlayerIdentifiers", lua_GetIdentifiers); - lua_register(mLuaState, "TriggerGlobalEvent", lua_TriggerEventG); - lua_register(mLuaState, "TriggerLocalEvent", lua_TriggerEventL); - lua_register(mLuaState, "TriggerClientEvent", lua_RemoteEvent); - lua_register(mLuaState, "GetPlayerCount", lua_GetPlayerCount); - lua_register(mLuaState, "isPlayerConnected", lua_isConnected); - lua_register(mLuaState, "RegisterEvent", lua_RegisterEvent); - lua_register(mLuaState, "GetPlayerName", lua_GetPlayerName); - lua_register(mLuaState, "RemoveVehicle", lua_RemoveVehicle); - lua_register(mLuaState, "GetPlayerDiscordID", lua_TempFix); - lua_register(mLuaState, "CreateThread", lua_CreateThread); - lua_register(mLuaState, "GetPlayerVehicles", lua_GetCars); - lua_register(mLuaState, "SendChatMessage", lua_sendChat); - lua_register(mLuaState, "GetPlayers", lua_GetAllPlayers); - lua_register(mLuaState, "GetPlayerGuest", lua_GetGuest); - lua_register(mLuaState, "StopThread", lua_StopThread); - lua_register(mLuaState, "DropPlayer", lua_dropPlayer); - lua_register(mLuaState, "GetPlayerHWID", lua_HWID); - lua_register(mLuaState, "exit", lua_ServerExit); - lua_register(mLuaState, "Sleep", lua_Sleep); - lua_register(mLuaState, "print", lua_Print); - lua_register(mLuaState, "Set", lua_Set); - if (!mConsole) - Reload(); } void TLuaFile::RegisterEvent(const std::string& Event, const std::string& FunctionName) { @@ -713,6 +583,12 @@ std::string TLuaFile::GetRegistered(const std::string& Event) const { } return ""; } + +bool TLuaFile::operator==(const TLuaFile& Other) const { + return mPluginName == Other.mPluginName + && mFileName == Other.mFileName; +} + std::string TLuaFile::GetFileName() const { return mFileName; } @@ -739,18 +615,6 @@ TLuaFile::~TLuaFile() { lua_close(mLuaState); } -void SendError(TLuaEngine& Engine, lua_State* L, const std::string& msg) { - Assert(L); - auto MaybeS = Engine.GetScript(L); - std::string a; - if (!MaybeS.has_value()) { - a = ("_Console"); - } else { - TLuaFile& S = MaybeS.value(); - a = fs::path(S.GetFileName()).filename().string(); - } - warn(a + (" | Incorrect Call of ") + msg); -} int lua_TempFix(lua_State* L) { if (lua_isnumber(L, 1)) { int ID = int(lua_tonumber(L, 1)); @@ -769,22 +633,22 @@ int lua_TempFix(lua_State* L) { return 1; } -void TLuaArg::PushArgs(lua_State* State) { - for (std::any arg : args) { +void TLuaFile::PushArgs(const TLuaArgs& args) { + for (const std::any& arg : args.Args) { if (!arg.has_value()) return; std::string Type = arg.type().name(); if (Type.find("bool") != std::string::npos) { - lua_pushboolean(State, std::any_cast(arg)); + lua_pushboolean(mLuaState, std::any_cast(arg)); } if (Type.find("basic_string") != std::string::npos || Type.find("char") != std::string::npos) { - lua_pushstring(State, std::any_cast(arg).c_str()); + lua_pushstring(mLuaState, std::any_cast(arg).c_str()); } if (Type.find("int") != std::string::npos) { - lua_pushinteger(State, std::any_cast(arg)); + lua_pushinteger(mLuaState, std::any_cast(arg)); } if (Type.find("float") != std::string::npos) { - lua_pushnumber(State, std::any_cast(arg)); + lua_pushnumber(mLuaState, std::any_cast(arg)); } } } diff --git a/src/main.cpp b/src/main.cpp index 699c3ff..cfee147 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -9,6 +9,8 @@ #include "TServer.h" #include +TLuaEngine* TheLuaEngine = nullptr; + #ifdef __unix #include