From 37c5d05d71b2dedafe2187dc2d3fb444b94cd913 Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Mon, 27 May 2019 12:23:05 +0200
Subject: [PATCH 01/25] Initial version of new style Lua argument parsing

---
 .../mods/deathmatch/logic/luadefs/CLuaDefs.h  |  39 ++-
 .../mods/deathmatch/logic/luadefs/CLuaDefs.h  |  37 +++
 .../deathmatch/logic/lua/CLuaFunctionParser.h | 223 +++++++++++++++
 Shared/mods/deathmatch/logic/lua/LuaBasic.cpp |  53 ++++
 Shared/mods/deathmatch/logic/lua/LuaBasic.h   |  97 +++++++
 .../logic/luadefs/CLuaCryptDefs.cpp           | 260 +++++-------------
 .../deathmatch/logic/luadefs/CLuaCryptDefs.h  |  22 +-
 Shared/sdk/SharedUtil.Template.h              |  68 +++++
 8 files changed, 604 insertions(+), 195 deletions(-)
 create mode 100644 Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
 create mode 100644 Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
 create mode 100644 Shared/mods/deathmatch/logic/lua/LuaBasic.h
 create mode 100644 Shared/sdk/SharedUtil.Template.h

diff --git a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
index d533baef6c1..a136499026a 100644
--- a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -64,4 +64,41 @@ class CLuaDefs
     static CClientDFFManager*         m_pDFFManager;
     static CClientColModelManager*    m_pColModelManager;
     static CRegisteredCommands*       m_pRegisteredCommands;
-};
\ No newline at end of file
+
+protected:
+    // Old style: Only warn on failure. This should
+    // not be used for new functions
+    template <auto T>
+    static inline int ArgumentParserWarn(lua_State* L)
+    {
+        int iReturnValue = CLuaFunctionParser<T>()(L);
+        if (iReturnValue < 0)
+        {
+            m_pScriptDebugging->LogCustom(L, "todo fix error message");
+            lua_pushboolean(L, false);
+            return 1;
+        }
+        return iReturnValue;
+    }
+
+    // New style: hard error on usage mistakes
+    template <auto T>
+    static inline int ArgumentParser(lua_State* L)
+    {
+        try
+        {
+            int iReturnValue = CLuaFunctionParser<T>()(L);
+            if (iReturnValue < 0)
+            {
+                luaL_error(L, "todo fix error message");
+                return 1;
+            }
+            return iReturnValue;
+        }
+        catch (CLuaError& e)
+        {
+            luaL_error(L, e.what());
+            return 0;
+        }
+    }
+};
diff --git a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
index 0fb4473690a..8f28da906dd 100644
--- a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -84,4 +84,41 @@ class CLuaDefs
     static CResourceManager*          m_pResourceManager;
     static CAccessControlListManager* m_pACLManager;
     static CMainConfig*               m_pMainConfig;
+
+protected:
+    // Old style: Only warn on failure. This should
+    // not be used for new functions
+    template <auto T>
+    static inline int ArgumentParserWarn(lua_State* L)
+    {
+        int iReturnValue = CLuaFunctionParser<T>()(L);
+        if (iReturnValue < 0)
+        {
+            m_pScriptDebugging->LogCustom(L, "todo fix error message");
+            lua_pushboolean(L, false);
+            return 1;
+        }
+        return iReturnValue;
+    }
+
+    // New style: hard error on usage mistakes
+    template <auto T>
+    static inline int ArgumentParser(lua_State* L)
+    {
+        try
+        {
+            int iReturnValue = CLuaFunctionParser<T>()(L);
+            if (iReturnValue < 0)
+            {
+                luaL_error(L, "todo fix error message");
+                return 1;
+            }
+            return iReturnValue;
+        }
+        catch (CLuaError& e)
+        {
+            luaL_error(L, e.what());
+            return 0;
+        }
+    }
 };
diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
new file mode 100644
index 00000000000..17224a49da3
--- /dev/null
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -0,0 +1,223 @@
+/*****************************************************************************
+ *
+ *  PROJECT:     Multi Theft Auto
+ *  LICENSE:     See LICENSE in the top level directory
+ *
+ *  Multi Theft Auto is available from http://www.multitheftauto.com/
+ *
+ *****************************************************************************/
+
+#include <optional>
+#include <variant>
+#include <SharedUtil.Template.h>
+#include "lua/LuaBasic.h"
+
+template <auto*>
+struct CLuaFunctionParser
+{
+};
+
+template <typename Ret, typename... Args, auto (*Func)(Args...)->Ret>
+struct CLuaFunctionParser<Func>
+{
+    std::size_t iIndex = 1;
+    bool        bFailed = false;
+
+    // Pop should remove a T from the Lua Stack after verifying that it is a valid type
+    // Pop may also throw a LuaArgumentError to indicate failure
+    template <typename T>
+    inline T Pop(lua_State* L, std::size_t& index)
+    {
+        if (!TypeMatch<T>(L, index))
+        {
+            // TODO: resolve error
+            bFailed = true;
+            return T{};
+        }
+        return PopUnsafe<T>(L, index);
+    }
+
+    // TypeMatch<T> should return true if the value on top of the Lua stack can be popped via
+    // PopUnsafe<T>. This must accurately reflect the associated PopUnsafe. Note that TypeMatch
+    // should only check for obvious type violations (e.g. false is not a string) but not
+    // for internal type errors (passing a vehicle to a function expecting a ped)
+    template <typename T>
+    inline bool TypeMatch(lua_State* L, std::size_t index)
+    {
+        int iArgument = lua_type(L, index);
+        // trivial types
+        if constexpr (std::is_same_v<T, std::string>)
+            return (iArgument == LUA_TSTRING || iArgument == LUA_TNUMBER);
+        if constexpr (std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> || std::is_same_v<T, short> ||
+                      std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short>)
+            return (iArgument == LUA_TSTRING || iArgument == LUA_TNUMBER);
+
+        // advanced types
+        // Enums are represented as strings to Lua
+        if constexpr (std::is_enum_v<T>)
+            return iArgument == LUA_TSTRING;
+        // std::optional is used for optional parameters
+        // which may also be in the middle of a parameter list
+        // therefore it is always valid to attempt to read an
+        // optional
+        if constexpr (is_specialization<T, std::optional>::value)
+            return true;
+
+        // std::vector is used for arrays built from tables
+        if constexpr (is_2specialization<T, std::vector>::value)
+            return iArgument == LUA_TTABLE;
+
+        // std::unordered_map<k,v> is used for maps built from tables
+        if constexpr (is_5specialization<T, std::unordered_map>::value)
+            return iArgument == LUA_TTABLE;
+
+        // CLuaFunctionRef is used for functions
+        if constexpr (std::is_same_v<T, CLuaFunctionRef>)
+            return iArgument == LUA_TFUNCTION;
+
+        // lua_State* can be taken as argument anywhere
+        if constexpr (std::is_same_v<T, lua_State*>)
+            return true;
+
+        // Catch all for class pointer types, assume all classes are valid script entities
+        // and can be fetched from a userdata
+        if constexpr (std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>)
+            return iArgument == LUA_TUSERDATA || iArgument == LUA_TLIGHTUSERDATA;
+    }
+
+    template <typename T>
+    inline T PopUnsafe(lua_State* L, std::size_t& index)
+    {
+        // trivial types are directly popped
+        if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> ||
+                      std::is_same_v<T, short> || std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short>)
+            return lua::PopTrivial<T>(L, index);
+        else if constexpr (std::is_enum_v<T>)
+        {
+            // Enums are considered strings in Lua
+            std::string strValue = lua::PopTrivial<std::string>(L, index);
+            T           eValue;
+            if (StringToEnum(strValue, eValue))
+                return eValue;
+            else
+            {
+                bFailed = true;
+                // TODO: resolve error
+                return static_cast<T>(0);
+            }
+        }
+        else if constexpr (is_specialization<T, std::optional>::value)
+        {
+            // optionals may either type match the desired value, or be nullopt
+            using param = typename is_specialization<T, std::optional>::param_t;
+            if (TypeMatch<param>(L, index))
+                return PopUnsafe<param>(L, index);
+            else
+                return std::nullopt;
+        }
+
+        else if constexpr (is_2specialization<T, std::vector>::value)            // 2 specialization due to allocator
+        {
+            using param = typename is_2specialization<T, std::vector>::param1_t;
+            T vecData;
+            lua_pushnil(L); /* first key */
+            while (lua_next(L, index) != 0)
+            {
+                if (!TypeMatch<param>(L, -1) || !TypeMatch<int>(L, -2))
+                {
+                    bFailed = true;
+                    // TODO: resolve error
+                    return vecData;
+                }
+
+                std::size_t i = -1;
+                vecData.emplace_back(PopUnsafe<param>(L, i));
+                lua_pop(L, 1);            // drop value, keep key for lua_next
+            }
+            ++index;
+            return vecData;
+        }
+        else if constexpr (is_5specialization<T, std::unordered_map>::value)
+        {
+            using key_t = typename is_5specialization<T, std::unordered_map>::param1_t;
+            using value_t = typename is_5specialization<T, std::unordered_map>::param2_t;
+            T map;
+            lua_pushnil(L); /* first key */
+            while (lua_next(L, index) != 0)
+            {
+                if (!TypeMatch<value_t>(L, -1) || !TypeMatch<key_t>(L, -2))
+                {
+                    bFailed = true;
+                    // TODO: resolve error
+                    return map;
+                }
+                
+
+                std::size_t i = -2;
+                auto        k = PopUnsafe<key_t>(L, i);
+                auto        v = PopUnsafe<value_t>(L, i);
+                map.emplace(std::move(k), std::move(v));
+                lua_pop(L, 1);            // drop value, keep key for lua_next
+            }
+            ++index;
+            return map;
+        }
+        else if constexpr (std::is_same_v<T, CLuaFunctionRef>)
+        {
+            return luaM_toref(L, index++);
+        }
+        if constexpr (std::is_same_v<T, lua_State*>)
+            return L;
+        // Catch all for class pointer types, assume all classes are valid script entities
+        // and can be fetched from a userdata
+        else if constexpr (std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>)
+        {
+            bool  isLightUserData = lua_type(L, index) == LUA_TLIGHTUSERDATA;
+            void* pValue = PopTrivial<void*>(L, index);
+            using class_t = std::remove_pointer_t<T>;
+            T result = nullptr;
+            if (isLightUserData)
+            {
+                result = UserDataCast<class_t>((class_t*)0, pValue, L);
+            }
+            else
+            {
+                result = UserDataCast<class_t>((class_t*)0, *reinterpret_cast<void**>(pValue), L);
+            }
+            if (result == nullptr)
+            {
+                bFailed = true;
+                // TODO: resolve error
+                return nullptr;
+            }
+            return result;
+        }
+    }
+
+    template <typename... Params>
+    inline auto Call(lua_State* L, Params&&... ps)
+    {
+        if (bFailed)
+        {
+            return -1;
+        }
+        if constexpr (sizeof...(Params) == sizeof...(Args))
+        {
+            if constexpr (std::is_same_v<Ret, void>)
+            {
+                Func(std::forward<Params>(ps)...);
+                return 0;
+            }
+            else
+            {
+                return lua::Push(L, Func(std::forward<Params>(ps)...));
+            }
+        }
+        else
+        {
+            return Call(L, ps..., Pop<typename nth_element_impl<sizeof...(Params), Args...>::type>(L, iIndex));
+        }
+    }
+
+    inline auto operator()(lua_State* L) { return Call(L); }
+};
diff --git a/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
new file mode 100644
index 00000000000..d5be1e51343
--- /dev/null
+++ b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
@@ -0,0 +1,53 @@
+/*****************************************************************************
+ *
+ *  PROJECT:     Multi Theft Auto
+ *  LICENSE:     See LICENSE in the top level directory
+ *
+ *  Multi Theft Auto is available from http://www.multitheftauto.com/
+ *
+ *****************************************************************************/
+#include <StdInc.h>
+#include "LuaBasic.h"
+
+namespace lua
+{
+    int Push(lua_State* L, int value)
+    {
+        lua_pushnumber(L, value);
+        return 1;
+    }
+
+    int Push(lua_State* L, bool value)
+    {
+        lua_pushboolean(L, value);
+        return 1;
+    }
+
+    int Push(lua_State* L, const std::string& value)
+    {
+        lua_pushlstring(L, value.data(), value.length());
+        return 1;
+    }
+
+
+    template <>
+    std::string PopTrivial<std::string>(lua_State* L, std::size_t& index)
+    {
+        uint        uiLength = lua_strlen(L, index);
+        std::string outValue;
+        outValue.assign(lua_tostring(L, index++), uiLength);
+        return outValue;
+    }
+
+    template <>
+    int PopTrivial<int>(lua_State* L, std::size_t& index)
+    {
+        return static_cast<int>(lua_tonumber(L, index++));
+    }
+
+    template <>
+    void* PopTrivial<void*>(lua_State* L, std::size_t& index)
+    {
+        return lua_touserdata(L, index++);
+    }
+}            // namespace mta::impl
diff --git a/Shared/mods/deathmatch/logic/lua/LuaBasic.h b/Shared/mods/deathmatch/logic/lua/LuaBasic.h
new file mode 100644
index 00000000000..ee7d5d8cd6d
--- /dev/null
+++ b/Shared/mods/deathmatch/logic/lua/LuaBasic.h
@@ -0,0 +1,97 @@
+/*****************************************************************************
+ *
+ *  PROJECT:     Multi Theft Auto
+ *  LICENSE:     See LICENSE in the top level directory
+ *
+ *  Multi Theft Auto is available from http://www.multitheftauto.com/
+ *
+ *****************************************************************************/
+#pragma once
+#include <optional>
+#include <variant>
+
+/*
+    Basic Lua operations:
+        int Push(L, T value)
+        T PopTrivial(L, std::size_t stackIndex)
+        bool TypeMatch(L, std::size_t stackIndex)
+*/
+
+
+namespace lua
+{
+    // PopTrival should read a simple value of type T from the stack without extra type checks
+    // If whatever is at that point in the stack is not convertible to T, the behavior is undefined
+    template <typename T>
+    inline T PopTrivial(lua_State* L, std::size_t& index);
+
+
+    // Push should push a value of type T to the Lua Stack
+    // The return value must be the amount of items pushed to the stack, which should
+    // be 1 for trivial types (e.g. Push<int>) but may be any number for special cases
+    // like tuples
+
+    template <typename... Ts>
+    int Push(lua_State* L, const std::variant<Ts...>&& val)
+    {
+        return std::visit([L](auto&& value) -> int { return Push(L, value); }, val);
+    }
+
+    template <typename T>
+    int Push(lua_State* L, const std::optional<T>&& val)
+    {
+        if (val.has_value())
+            return Push(L, val.value());
+        else
+            return Push(L, nullptr);
+     }
+
+    template <typename T>
+    int Push(lua_State* L, const std::vector<T>&& val)
+    {
+        lua_newtable(L);
+        int i = 1;
+        for (auto&& v : val)
+        {
+            Push(L, i++);
+            Push(L, v);
+            lua_settable(L, -3);
+        }
+        return 1;
+    }
+
+    template <typename K, typename V>
+    int Push(lua_State* L, const std::unordered_map<K, V>&& val)
+    {
+        lua_newtable(L);
+        for (auto&& [k, v] : val)
+        {
+            Push(L, k);
+            Push(L, v);
+            lua_settable(L, -3);
+        }
+        return 1;
+    }
+
+    template <typename T>
+    typename std::enable_if_t<std::is_enum_v<T>, int> Push(lua_State* L, const T&& val)
+    {
+        return Push(L, EnumToString(val));
+    }
+
+    template <typename T>
+    typename std::enable_if_t<(std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>), int> Push(lua_State* L, const T&& val)
+    {
+        lua_pushelement(L, val);
+        return 1;
+    }
+
+    int Push(lua_State* L, int val);
+    int Push(lua_State* L, const std::string& val);
+    int Push(lua_State* L, bool val);
+    int Push(lua_State* L, nullptr_t);
+    int Push(lua_State* L, float val);
+    int Push(lua_State* L, double val);
+    int Push(lua_State* L, unsigned int val);
+    int Push(lua_State* L, unsigned short val);
+}
diff --git a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
index ab444625b68..c367137e509 100644
--- a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
+++ b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
@@ -9,17 +9,19 @@
  *****************************************************************************/
 #include "StdInc.h"
 #include <SharedUtil.Crypto.h>
+#include <lua/CLuaFunctionParser.h>
+
 
 void CLuaCryptDefs::LoadFunctions()
 {
     std::map<const char*, lua_CFunction> functions{
-        {"md5", Md5},
-        {"sha256", Sha256},
-        {"hash", Hash},
-        {"teaEncode", TeaEncode},
-        {"teaDecode", TeaDecode},
-        {"base64Encode", Base64encode},
-        {"base64Decode", Base64decode},
+        {"md5", ArgumentParserWarn<Md5>},
+        {"sha256", ArgumentParserWarn<Sha256>},
+        {"hash", ArgumentParserWarn<Hash>},
+        {"teaEncode", ArgumentParserWarn<TeaEncode>},
+        {"teaDecode", ArgumentParserWarn<TeaDecode>},
+        {"base64Encode", ArgumentParserWarn<Base64encode>},
+        {"base64Decode", ArgumentParserWarn<Base64decode>},
         {"passwordHash", PasswordHash},
         {"passwordVerify", PasswordVerify},
         {"encodeString", EncodeString},
@@ -33,182 +35,87 @@ void CLuaCryptDefs::LoadFunctions()
     }
 }
 
-int CLuaCryptDefs::Md5(lua_State* luaVM)
-{
-    SString          strMd5 = "";
-    CScriptArgReader argStream(luaVM);
-    argStream.ReadString(strMd5);
 
-    if (!argStream.HasErrors())
-    {
-        MD5        md5bytes;
-        char       szResult[33];
-        CMD5Hasher hasher;
-        hasher.Calculate(strMd5, strMd5.length(), md5bytes);
-        hasher.ConvertToHex(md5bytes, szResult);
-        lua_pushstring(luaVM, szResult);
-        return 1;
-    }
-    else
-        m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
-
-    lua_pushboolean(luaVM, false);
-    return 1;
+std::string CLuaCryptDefs::Md5(std::string strMd5)
+{
+    MD5        md5bytes;
+    char       szResult[33];
+    CMD5Hasher hasher;
+    hasher.Calculate(strMd5.data(), strMd5.length(), md5bytes);
+    hasher.ConvertToHex(md5bytes, szResult);
+    return szResult;
 }
 
-int CLuaCryptDefs::Sha256(lua_State* luaVM)
+std::string CLuaCryptDefs::Sha256(std::string strSourceData)
 {
-    //  string sha256 ( string str )
-    SString strSourceData;
-
-    CScriptArgReader argStream(luaVM);
-    argStream.ReadString(strSourceData);
-
-    if (!argStream.HasErrors())
-    {
-        SString strResult = GenerateSha256HexString(strSourceData);
-        lua_pushstring(luaVM, strResult);
-        return 1;
-    }
-    else
-        m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
-
-    lua_pushboolean(luaVM, false);
-    return 1;
+    return GenerateSha256HexString(strSourceData);
 }
 
-int CLuaCryptDefs::Hash(lua_State* luaVM)
+std::string CLuaCryptDefs::Hash(EHashFunctionType hashFunction, std::string strSourceData)
 {
-    //  string hash ( string type, string data )
-    EHashFunctionType hashFunction;
-    SString           strSourceData;
-
-    CScriptArgReader argStream(luaVM);
-    argStream.ReadEnumString(hashFunction);
-    argStream.ReadString(strSourceData);
-
-    if (!argStream.HasErrors())
-    {
-        SString strResult = GenerateHashHexString(hashFunction, strSourceData);
-        lua_pushstring(luaVM, strResult.ToLower());
-        return 1;
-    }
-    else
-        m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
-
-    lua_pushboolean(luaVM, false);
-    return 1;
+    return GenerateHashHexString(hashFunction, strSourceData);
 }
 
-int CLuaCryptDefs::TeaEncode(lua_State* luaVM)
+std::string CLuaCryptDefs::TeaEncode(std::string str, std::string key)
 {
-    SString str;
-    SString key;
-
-    CScriptArgReader argStream(luaVM);
-    argStream.ReadString(str);
-    argStream.ReadString(key);
-
-    if (!argStream.HasErrors())
-    {
-        SString result;
-        SString humanReadableResult;
-        SharedUtil::TeaEncode(str, key, &result);
-        humanReadableResult = SharedUtil::Base64encode(result);
-        lua_pushstring(luaVM, humanReadableResult);
-        return 1;
-    }
-    else
-        m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
-
-    lua_pushboolean(luaVM, false);
-    return 1;
+    SString result;
+    SharedUtil::TeaEncode(str, key, &result);
+    return SharedUtil::Base64encode(result);
 }
 
-int CLuaCryptDefs::TeaDecode(lua_State* luaVM)
+std::string CLuaCryptDefs::TeaDecode(std::string str, std::string key)
 {
-    SString str;
-    SString key;
-
-    CScriptArgReader argStream(luaVM);
-    argStream.ReadString(str);
-    argStream.ReadString(key);
-
-    if (!argStream.HasErrors())
-    {
-        SString result = SharedUtil::Base64decode(str);
-        SharedUtil::TeaDecode(result, key, &str);
-        lua_pushstring(luaVM, str);
-        return 1;
-    }
-    else
-        m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
-
-    lua_pushboolean(luaVM, false);
-    return 1;
+    SString fixme = str;
+    SString result = SharedUtil::Base64decode(str);
+    SharedUtil::TeaDecode(result, key, &fixme);
+    return fixme;
 }
 
-int CLuaCryptDefs::Base64encode(lua_State* luaVM)
+std::string CLuaCryptDefs::Base64encode(std::string str)
 {
-    SString str;
-
-    CScriptArgReader argStream(luaVM);
-    argStream.ReadString(str);
-
-    if (!argStream.HasErrors())
-    {
-        lua_pushstring(luaVM, SharedUtil::Base64encode(str));
-        return 1;
-    }
-    else
-        m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
-
-    lua_pushboolean(luaVM, false);
-    return 1;
+    return SharedUtil::Base64encode(str);
 }
 
-int CLuaCryptDefs::Base64decode(lua_State* luaVM)
+std::string CLuaCryptDefs::Base64decode(std::string str)
 {
-    SString str;
-
-    CScriptArgReader argStream(luaVM);
-    argStream.ReadString(str);
+    return SharedUtil::Base64decode(str);
+}
 
-    if (!argStream.HasErrors())
+std::variant<std::string, bool> CLuaCryptDefs::PasswordHash(lua_State* luaVM, std::string password, PasswordHashFunction algorithm,
+                                                            std::unordered_map<std::string, std::string> options, std::optional<CLuaFunctionRef> luaFunctionRef)
+{
+    //  string password_hash(string password, string algorithm, table options = {} [, function callback])
+    if (algorithm != PasswordHashFunction::Bcrypt)
     {
-        SString result = SharedUtil::Base64decode(str);
-        lua_pushlstring(luaVM, result, result.length());
-        return 1;
+        throw std::invalid_argument("Invalid algorithm");
     }
-    else
-        m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
 
-    lua_pushboolean(luaVM, false);
-    return 1;
-}
+    // Set default value to 10
+    if (options["cost"].empty())
+        options["cost"] = "10";
 
-int CLuaCryptDefs::PasswordHash(lua_State* luaVM)
-{
-    //  string password_hash(string password, string algorithm, table options = {} [, function callback])
-    SString              password;
-    PasswordHashFunction algorithm;
-    CStringMap           options;
-    CLuaFunctionRef      luaFunctionRef;
+    std::stringstream ss(options["cost"]);
+    std::size_t       cost;
+    ss >> cost;
 
-    CScriptArgReader argStream(luaVM);
-    argStream.ReadString(password);
-    argStream.ReadEnumString(algorithm);
-    argStream.ReadStringMap(options);
+    if (ss.fail())
+        throw std::invalid_argument("Invalid value for field 'cost'");
 
-    if (argStream.NextIsFunction())
+    // Sync
+    if (!luaFunctionRef.has_value())
     {
-        argStream.ReadFunction(luaFunctionRef);
-        argStream.ReadFunctionComplete();
+        SString hash = SharedUtil::BcryptHash(password, options["salt"], cost);
+        if (!hash.empty())
+        {
+            return hash;
+        }
+        else
+            throw std::invalid_argument("Invalid value for field 'salt'");
     }
-
-    if (!argStream.HasErrors())
+    else            // Async
     {
-        if (algorithm == PasswordHashFunction::Bcrypt)
+        CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaVM);
+        if (pLuaMain)
         {
             // Set default value to 10
             if (options["cost"].empty())
@@ -244,43 +151,24 @@ int CLuaCryptDefs::PasswordHash(lua_State* luaVM)
                     CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaVM);
                     if (pLuaMain)
                     {
-                        CLuaShared::GetAsyncTaskScheduler()->PushTask<SString>(
-                            [password, salt = options["salt"], cost] {
-                                // Execute time-consuming task
-                                return SharedUtil::BcryptHash(password, salt, cost);
-                            },
-                            [luaFunctionRef](const SString& hash) {
-                                CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaFunctionRef.GetLuaVM());
-                                if (pLuaMain)
-                                {
-                                    CLuaArguments arguments;
+                        CLuaArguments arguments;
 
-                                    if (hash.empty())
-                                    {
-                                        m_pScriptDebugging->LogCustom(pLuaMain->GetVM(), "Invalid value for field 'salt'");
-                                        arguments.PushBoolean(false);
-                                    }
-                                    else
-                                        arguments.PushString(hash);
+                        if (hash.empty())
+                        {
+                            m_pScriptDebugging->LogCustom(pLuaMain->GetVM(), "Invalid value for field 'salt'");
+                            arguments.PushBoolean(false);
+                        }
+                        else
+                            arguments.PushString(hash);
 
-                                    arguments.Call(pLuaMain, luaFunctionRef);
-                                }
-                            });
-
-                        lua_pushboolean(luaVM, true);
-                        return 1;
+                        arguments.Call(pLuaMain, luaFunctionRef.value());
                     }
-                }
-            }
-            else
-                m_pScriptDebugging->LogWarning(luaVM, "Invalid value for field 'cost'");
+                });
+
+            return true;
         }
+        return false;
     }
-    else
-        m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
-
-    lua_pushboolean(luaVM, false);
-    return 1;
 }
 
 int CLuaCryptDefs::PasswordVerify(lua_State* luaVM)
diff --git a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.h b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.h
index 5c6e652b48a..99bb9c7f965 100644
--- a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.h
+++ b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.h
@@ -10,20 +10,26 @@
 
 #pragma once
 #include "luadefs/CLuaDefs.h"
+#include <optional>
+#include <variant>
 
 class CLuaCryptDefs : public CLuaDefs
 {
 public:
     static void LoadFunctions();
 
-    LUA_DECLARE(Md5);
-    LUA_DECLARE(Sha256);
-    LUA_DECLARE(Hash);
-    LUA_DECLARE(TeaEncode);
-    LUA_DECLARE(TeaDecode);
-    LUA_DECLARE(Base64encode);
-    LUA_DECLARE(Base64decode);
-    LUA_DECLARE(PasswordHash);
+    static std::string Md5(std::string strMd5);
+
+    static std::string Hash(EHashFunctionType hashFunction, std::string strSourceData);
+
+    static std::string TeaEncode(std::string str, std::string key);
+    static std::string TeaDecode(std::string str, std::string key);
+    static std::string Base64encode(std::string str);
+    static std::string Base64decode(std::string str);
+    static std::variant<std::string, bool> PasswordHash(lua_State* luaVM, std::string password, PasswordHashFunction algorithm,
+                                                        std::unordered_map<std::string, std::string> options,
+                             std::optional<CLuaFunctionRef> luaFunctionRef);
+    static std::string Sha256(std::string strSourceData);
     LUA_DECLARE(PasswordVerify);
     LUA_DECLARE(EncodeString);
     LUA_DECLARE(DecodeString);
diff --git a/Shared/sdk/SharedUtil.Template.h b/Shared/sdk/SharedUtil.Template.h
new file mode 100644
index 00000000000..d5284e563d5
--- /dev/null
+++ b/Shared/sdk/SharedUtil.Template.h
@@ -0,0 +1,68 @@
+#pragma once
+
+/**
+    is_Nspecialization
+
+    These structs allow testing whether a type is a specialization of a 
+    class template
+
+    Note: Take care of optional parameters. For example std::unordered_map 
+    has 5 template arguments, thus is_5specialization needs to be used, rather
+    than is_2specialization (Key, Value). 
+**/
+
+template <typename Test, template <typename> class Ref>
+struct is_specialization : std::false_type
+{
+};
+
+template <template <typename> class Ref, typename Args>
+struct is_specialization<Ref<Args>, Ref> : std::true_type
+{
+    using param_t = Args;
+};
+
+template <typename Test, template <typename, typename> class Ref>
+struct is_2specialization : std::false_type
+{
+};
+
+template <template <typename, typename> class Ref, typename Arg1, typename Arg2>
+struct is_2specialization<Ref<Arg1, Arg2>, Ref> : std::true_type
+{
+    using param1_t = Arg1;
+    using param2_t = Arg2;
+};
+
+template <typename Test, template <typename, typename, typename, typename, typename> class Ref>
+struct is_5specialization : std::false_type
+{
+};
+
+template <template <typename, typename, typename, typename, typename> class Ref, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+struct is_5specialization<Ref<Arg1, Arg2, Arg3, Arg4, Arg5>, Ref> : std::true_type
+{
+    using param1_t = Arg1;
+    using param2_t = Arg2;
+};
+
+/**
+    nth_element
+
+    Returns the nth element of a parameter pack
+**/
+
+template <std::size_t I, typename T, typename... Ts>
+struct nth_element_impl
+{
+    using type = typename nth_element_impl<I - 1, Ts...>::type;
+};
+
+template <typename T, typename... Ts>
+struct nth_element_impl<0, T, Ts...>
+{
+    using type = T;
+};
+
+template <std::size_t I, typename... Ts>
+using nth_element = typename nth_element_impl<I, Ts...>::type;

From 2c6277bc5c3b7d44ee169a2526eea9291a846d71 Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Thu, 30 May 2019 16:31:17 +0200
Subject: [PATCH 02/25] Clean up error handling logic

---
 .../mods/deathmatch/logic/luadefs/CLuaDefs.h  | 25 ++-----------
 .../mods/deathmatch/logic/luadefs/CLuaDefs.h  | 25 ++-----------
 .../deathmatch/logic/lua/CLuaFunctionParser.h | 35 ++++++++++++++++---
 3 files changed, 34 insertions(+), 51 deletions(-)

diff --git a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
index a136499026a..159fda06533 100644
--- a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -71,34 +71,13 @@ class CLuaDefs
     template <auto T>
     static inline int ArgumentParserWarn(lua_State* L)
     {
-        int iReturnValue = CLuaFunctionParser<T>()(L);
-        if (iReturnValue < 0)
-        {
-            m_pScriptDebugging->LogCustom(L, "todo fix error message");
-            lua_pushboolean(L, false);
-            return 1;
-        }
-        return iReturnValue;
+        return CLuaFunctionParser<false, T>()(L, m_pScriptDebugging);
     }
 
     // New style: hard error on usage mistakes
     template <auto T>
     static inline int ArgumentParser(lua_State* L)
     {
-        try
-        {
-            int iReturnValue = CLuaFunctionParser<T>()(L);
-            if (iReturnValue < 0)
-            {
-                luaL_error(L, "todo fix error message");
-                return 1;
-            }
-            return iReturnValue;
-        }
-        catch (CLuaError& e)
-        {
-            luaL_error(L, e.what());
-            return 0;
-        }
+        return CLuaFunctionParser<true, T>()(L, m_pScriptDebugging);
     }
 };
diff --git a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
index 8f28da906dd..7531bf2d4ee 100644
--- a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -91,34 +91,13 @@ class CLuaDefs
     template <auto T>
     static inline int ArgumentParserWarn(lua_State* L)
     {
-        int iReturnValue = CLuaFunctionParser<T>()(L);
-        if (iReturnValue < 0)
-        {
-            m_pScriptDebugging->LogCustom(L, "todo fix error message");
-            lua_pushboolean(L, false);
-            return 1;
-        }
-        return iReturnValue;
+        return CLuaFunctionParser<false, T>()(L, m_pScriptDebugging);
     }
 
     // New style: hard error on usage mistakes
     template <auto T>
     static inline int ArgumentParser(lua_State* L)
     {
-        try
-        {
-            int iReturnValue = CLuaFunctionParser<T>()(L);
-            if (iReturnValue < 0)
-            {
-                luaL_error(L, "todo fix error message");
-                return 1;
-            }
-            return iReturnValue;
-        }
-        catch (CLuaError& e)
-        {
-            luaL_error(L, e.what());
-            return 0;
-        }
+        return CLuaFunctionParser<true, T>()(L, m_pScriptDebugging);
     }
 };
diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index 17224a49da3..38cc48ffd51 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -12,16 +12,17 @@
 #include <SharedUtil.Template.h>
 #include "lua/LuaBasic.h"
 
-template <auto*>
+template <bool, auto*>
 struct CLuaFunctionParser
 {
 };
 
-template <typename Ret, typename... Args, auto (*Func)(Args...)->Ret>
-struct CLuaFunctionParser<Func>
+template <bool ErrorOnFailure, typename Ret, typename... Args, auto (*Func)(Args...)->Ret>
+struct CLuaFunctionParser<ErrorOnFailure, Func>
 {
     std::size_t iIndex = 1;
     bool        bFailed = false;
+    std::string strError = "todo fix error message";
 
     // Pop should remove a T from the Lua Stack after verifying that it is a valid type
     // Pop may also throw a LuaArgumentError to indicate failure
@@ -151,7 +152,6 @@ struct CLuaFunctionParser<Func>
                     // TODO: resolve error
                     return map;
                 }
-                
 
                 std::size_t i = -2;
                 auto        k = PopUnsafe<key_t>(L, i);
@@ -219,5 +219,30 @@ struct CLuaFunctionParser<Func>
         }
     }
 
-    inline auto operator()(lua_State* L) { return Call(L); }
+    inline int operator()(lua_State* L, CScriptDebugging* pScriptDebugging)
+    {
+        int iResult = 0; 
+        try
+        {
+            Call(L);
+        }
+        catch (std::invalid_argument& e)
+        {
+            strError = e.what();
+        }
+        if (bFailed)
+        {
+            if constexpr (ErrorOnFailure)
+            {
+                luaL_error(L, strError.c_str());
+            }
+            else
+            {
+                pScriptDebugging->LogCustom(L, strError.c_str());
+                lua_pushboolean(L, false);
+            }
+            return 1;
+        }
+        return iResult;
+    }
 };

From 2dd5e428865ff9f293375579e217307821f25ba5 Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Fri, 31 May 2019 09:35:42 +0200
Subject: [PATCH 03/25] Implement Push for float, unsigned int, double
 Implement Pop for variant, float, double, unsigned int, bool Fix bug
 introduced when cleaning up error types

---
 .../deathmatch/logic/lua/CLuaFunctionParser.h | 74 ++++++++++++++++++-
 Shared/mods/deathmatch/logic/lua/LuaBasic.cpp | 45 +++++++++++
 .../logic/luadefs/CLuaCryptDefs.cpp           |  1 -
 3 files changed, 115 insertions(+), 5 deletions(-)

diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index 38cc48ffd51..51cc6a2ab0f 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -38,6 +38,29 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         return PopUnsafe<T>(L, index);
     }
 
+    // Special type matcher for variants. Returns -1 if the type does not match
+    // returns n if the nth type of the variant matches
+    template <typename T>
+    inline int TypeMatchVariant(lua_State* L, std::size_t index)
+    {
+        if constexpr (std::is_same_v<T, std::variant<>>)
+            return -1;
+        else
+        {
+            using first_t = typename is_variant<T>::param1_t;
+            using next_t = typename is_variant<T>::rest_t;
+            if (TypeMatch<first_t>(L, index))
+                return 0;
+            else
+            {
+                int iResult = TypeMatchVariant<next_t>(L, index);
+                if (iResult == -1)
+                    return -1;
+                return 1 + iResult;
+            }
+        }
+    }
+
     // TypeMatch<T> should return true if the value on top of the Lua stack can be popped via
     // PopUnsafe<T>. This must accurately reflect the associated PopUnsafe. Note that TypeMatch
     // should only check for obvious type violations (e.g. false is not a string) but not
@@ -52,6 +75,8 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         if constexpr (std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> || std::is_same_v<T, short> ||
                       std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short>)
             return (iArgument == LUA_TSTRING || iArgument == LUA_TNUMBER);
+        if constexpr (std::is_same_v<T, bool>)
+            return (iArgument == LUA_TBOOLEAN);
 
         // advanced types
         // Enums are represented as strings to Lua
@@ -80,18 +105,51 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         if constexpr (std::is_same_v<T, lua_State*>)
             return true;
 
+        // variants can be used by any of the underlying types
+        // thus recursively use this function
+        if constexpr (is_variant<T>::value)
+            return TypeMatchVariant<T>(L, index) != -1;
+
         // Catch all for class pointer types, assume all classes are valid script entities
         // and can be fetched from a userdata
         if constexpr (std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>)
             return iArgument == LUA_TUSERDATA || iArgument == LUA_TLIGHTUSERDATA;
     }
 
+    // Special PopUnsafe for variants
+    template <typename T, std::size_t currIndex = 0>
+    inline T PopUnsafeVariant(lua_State* L, std::size_t& index, int vindex)
+    {
+        // As std::variant<> cannot be constructed, we simply return the first value
+        // in the error case. This is actually unreachable in the regular path,
+        // due to TypeMatch making sure that vindex < is_variant<T>::count
+        if constexpr (is_variant<T>::count == currIndex)
+        {
+            using type_t = typename is_variant<T>::param1_t;
+            return type_t{};
+        }
+        else
+        {
+            // If we have reached the target index, pop the right value
+            // else go to the next type
+            if (vindex == currIndex)
+            {
+                using type_t = std::remove_reference_t<decltype(std::get<currIndex>(T{}))>;
+                return PopUnsafe<type_t>(L, index);
+            }
+            else
+            {
+                return PopUnsafeVariant<T, currIndex + 1>(L, index, vindex);
+            }
+        }
+    }
+
     template <typename T>
     inline T PopUnsafe(lua_State* L, std::size_t& index)
     {
         // trivial types are directly popped
         if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> ||
-                      std::is_same_v<T, short> || std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short>)
+                      std::is_same_v<T, short> || std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short> || std::is_same_v<T, bool>)
             return lua::PopTrivial<T>(L, index);
         else if constexpr (std::is_enum_v<T>)
         {
@@ -166,8 +224,16 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         {
             return luaM_toref(L, index++);
         }
-        if constexpr (std::is_same_v<T, lua_State*>)
+        else if constexpr (std::is_same_v<T, lua_State*>)
             return L;
+        // variants can be used by any of the underlying types
+        // thus recursively use this function
+        else if constexpr (is_variant<T>::value)
+        {
+            int iMatch = TypeMatchVariant<T>(L, index);
+            return PopUnsafeVariant<T>(L, index, iMatch);
+        }
+
         // Catch all for class pointer types, assume all classes are valid script entities
         // and can be fetched from a userdata
         else if constexpr (std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>)
@@ -221,10 +287,10 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
 
     inline int operator()(lua_State* L, CScriptDebugging* pScriptDebugging)
     {
-        int iResult = 0; 
+        int iResult = 0;
         try
         {
-            Call(L);
+            iResult = Call(L);
         }
         catch (std::invalid_argument& e)
         {
diff --git a/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
index d5be1e51343..a2e25007102 100644
--- a/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
+++ b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
@@ -16,6 +16,21 @@ namespace lua
         lua_pushnumber(L, value);
         return 1;
     }
+    int Push(lua_State* L, unsigned int value)
+    {
+        lua_pushnumber(L, value);
+        return 1;
+    }
+    int Push(lua_State* L, float value)
+    {
+        lua_pushnumber(L, value);
+        return 1;
+    }
+    int Push(lua_State* L, double value)
+    {
+        lua_pushnumber(L, value);
+        return 1;
+    }
 
     int Push(lua_State* L, bool value)
     {
@@ -23,6 +38,12 @@ namespace lua
         return 1;
     }
 
+    int Push(lua_State* L, nullptr_t)
+    {
+        lua_pushnil(L);
+        return 1;
+    }
+
     int Push(lua_State* L, const std::string& value)
     {
         lua_pushlstring(L, value.data(), value.length());
@@ -45,6 +66,30 @@ namespace lua
         return static_cast<int>(lua_tonumber(L, index++));
     }
 
+    template <>
+    unsigned int PopTrivial<unsigned int>(lua_State* L, std::size_t& index)
+    {
+        return static_cast<unsigned int>(lua_tonumber(L, index++));
+    }
+
+    template <>
+    float PopTrivial<float>(lua_State* L, std::size_t& index)
+    {
+        return static_cast<float>(lua_tonumber(L, index++));
+    }
+
+    template <>
+    double PopTrivial<double>(lua_State* L, std::size_t& index)
+    {
+        return static_cast<double>(lua_tonumber(L, index++));
+    }
+    
+    template <>
+    bool PopTrivial<bool>(lua_State* L, std::size_t& index)
+    {
+        return static_cast<bool>(lua_toboolean(L, index++));
+    }
+
     template <>
     void* PopTrivial<void*>(lua_State* L, std::size_t& index)
     {
diff --git a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
index c367137e509..bfb78961863 100644
--- a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
+++ b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
@@ -35,7 +35,6 @@ void CLuaCryptDefs::LoadFunctions()
     }
 }
 
-
 std::string CLuaCryptDefs::Md5(std::string strMd5)
 {
     MD5        md5bytes;

From f6122e0110c0889b56eef26e80d194b8ee8ec208 Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Fri, 31 May 2019 09:39:47 +0200
Subject: [PATCH 04/25] Add is_variant<T> Attempt to fix Linux compilation

---
 .../mods/deathmatch/logic/luadefs/CLuaDefs.h  |  1 +
 .../deathmatch/logic/lua/CLuaFunctionParser.h |  1 +
 Shared/sdk/SharedUtil.Template.h              | 19 ++++++++++++++++---
 3 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
index 7531bf2d4ee..664f634a36c 100644
--- a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -31,6 +31,7 @@
 #include "../CVehicleManager.h"
 #include "../CRegistry.h"
 #include "../CDatabaseManager.h"
+#include <lua/CLuaFunctionParser.h>
 
 // Used by script handlers to verify elements
 #define SCRIPT_VERIFY_BLIP(blip) (m_pBlipManager->Exists(blip)&&!blip->IsBeingDeleted())
diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index 51cc6a2ab0f..587140b09f7 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -6,6 +6,7 @@
  *  Multi Theft Auto is available from http://www.multitheftauto.com/
  *
  *****************************************************************************/
+#pragma once 
 
 #include <optional>
 #include <variant>
diff --git a/Shared/sdk/SharedUtil.Template.h b/Shared/sdk/SharedUtil.Template.h
index d5284e563d5..58681b8d1a8 100644
--- a/Shared/sdk/SharedUtil.Template.h
+++ b/Shared/sdk/SharedUtil.Template.h
@@ -3,12 +3,12 @@
 /**
     is_Nspecialization
 
-    These structs allow testing whether a type is a specialization of a 
+    These structs allow testing whether a type is a specialization of a
     class template
 
-    Note: Take care of optional parameters. For example std::unordered_map 
+    Note: Take care of optional parameters. For example std::unordered_map
     has 5 template arguments, thus is_5specialization needs to be used, rather
-    than is_2specialization (Key, Value). 
+    than is_2specialization (Key, Value).
 **/
 
 template <typename Test, template <typename> class Ref>
@@ -46,6 +46,19 @@ struct is_5specialization<Ref<Arg1, Arg2, Arg3, Arg4, Arg5>, Ref> : std::true_ty
     using param2_t = Arg2;
 };
 
+template <typename Test>
+struct is_variant : std::false_type
+{
+};
+
+template <typename Arg1, typename... Args>
+struct is_variant<std::variant<Arg1, Args...>> : std::true_type
+{
+    using param1_t = Arg1;
+    using rest_t = std::variant<Args...>;
+    static constexpr auto count = sizeof...(Args) + 1;
+};
+
 /**
     nth_element
 

From 6034b9655d0f1069765a736baf1b99666bdb877f Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Fri, 31 May 2019 09:59:34 +0200
Subject: [PATCH 05/25] Fix Linux

---
 .../deathmatch/logic/lua/CLuaFunctionParser.h  |  3 ++-
 Shared/mods/deathmatch/logic/lua/LuaBasic.h    | 18 ++++++++++--------
 2 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index 587140b09f7..44a0d181514 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -11,6 +11,7 @@
 #include <optional>
 #include <variant>
 #include <SharedUtil.Template.h>
+#include "lua/CLuaFunctionParseHelpers.h"
 #include "lua/LuaBasic.h"
 
 template <bool, auto*>
@@ -240,7 +241,7 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         else if constexpr (std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>)
         {
             bool  isLightUserData = lua_type(L, index) == LUA_TLIGHTUSERDATA;
-            void* pValue = PopTrivial<void*>(L, index);
+            void* pValue = lua::PopTrivial<void*>(L, index);
             using class_t = std::remove_pointer_t<T>;
             T result = nullptr;
             if (isLightUserData)
diff --git a/Shared/mods/deathmatch/logic/lua/LuaBasic.h b/Shared/mods/deathmatch/logic/lua/LuaBasic.h
index ee7d5d8cd6d..0f9c5b5bc47 100644
--- a/Shared/mods/deathmatch/logic/lua/LuaBasic.h
+++ b/Shared/mods/deathmatch/logic/lua/LuaBasic.h
@@ -30,6 +30,16 @@ namespace lua
     // The return value must be the amount of items pushed to the stack, which should
     // be 1 for trivial types (e.g. Push<int>) but may be any number for special cases
     // like tuples
+    
+    int Push(lua_State* L, int val);
+    int Push(lua_State* L, const std::string& val);
+    int Push(lua_State* L, bool val);
+    int Push(lua_State* L, std::nullptr_t);
+    int Push(lua_State* L, float val);
+    int Push(lua_State* L, double val);
+    int Push(lua_State* L, unsigned int val);
+    int Push(lua_State* L, unsigned short val);
+
 
     template <typename... Ts>
     int Push(lua_State* L, const std::variant<Ts...>&& val)
@@ -86,12 +96,4 @@ namespace lua
         return 1;
     }
 
-    int Push(lua_State* L, int val);
-    int Push(lua_State* L, const std::string& val);
-    int Push(lua_State* L, bool val);
-    int Push(lua_State* L, nullptr_t);
-    int Push(lua_State* L, float val);
-    int Push(lua_State* L, double val);
-    int Push(lua_State* L, unsigned int val);
-    int Push(lua_State* L, unsigned short val);
 }

From 0c1bdee0477250cc1e8226cf2ba73177338a0c62 Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Fri, 31 May 2019 15:01:18 +0200
Subject: [PATCH 06/25] Add error string generation Fix map/vector to conform
 to existing behavior (keep reading on failure, skipping invalid values) Add
 value notes to errors

---
 .../deathmatch/logic/lua/CLuaFunctionParser.h | 152 ++++++++++++++----
 .../logic/luadefs/CLuaCryptDefs.cpp           |   1 -
 2 files changed, 123 insertions(+), 30 deletions(-)

diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index 44a0d181514..7e3cca45f23 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -6,7 +6,7 @@
  *  Multi Theft Auto is available from http://www.multitheftauto.com/
  *
  *****************************************************************************/
-#pragma once 
+#pragma once
 
 #include <optional>
 #include <variant>
@@ -23,8 +23,103 @@ template <bool ErrorOnFailure, typename Ret, typename... Args, auto (*Func)(Args
 struct CLuaFunctionParser<ErrorOnFailure, Func>
 {
     std::size_t iIndex = 1;
-    bool        bFailed = false;
-    std::string strError = "todo fix error message";
+    std::string strError = "";
+    std::string strErrorFoundType = "";
+
+    template <typename T>
+    inline void typeToNameVariant(SString& accumulator)
+    {
+        using param = typename is_variant<T>::param1_t;
+        if (accumulator.length() == 0)
+            accumulator = typeToName<param>();
+        else 
+            accumulator += "/" + typeToName<param>();
+
+        if constexpr (is_variant<T>::count != 1)
+            return typeToNameVariant<is_variant<T>::rest_t>(accumulator);
+    }
+
+    template <typename T>
+    inline SString typeToName()
+    {
+        if constexpr (std::is_same_v<T, std::string>)
+            return "string";
+        else if constexpr (std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> || std::is_same_v<T, short> ||
+                           std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short>)
+            return "number";
+        else if constexpr (std::is_same_v<T, bool>)
+            return "boolean";
+        else if constexpr (std::is_enum_v<T>)
+            return "enum";
+        else if constexpr (is_specialization<T, std::optional>::value)
+        {
+            using param_t = typename is_specialization<T, std::optional>::param_t;
+            return typeToName<param_t>();
+        }
+        else if constexpr (is_2specialization<T, std::vector>::value)
+            return "table";
+        else if constexpr (is_5specialization<T, std::unordered_map>::value)
+            return "table";
+        else if constexpr (std::is_same_v<T, CLuaFunctionRef>)
+            return "function";
+        else if constexpr (std::is_same_v<T, lua_State*>)
+            return "";            // not reachable
+        else if constexpr (is_variant<T>::value)
+        {
+            SString strTypes;
+            typeToNameVariant<T>(strTypes);    
+            return strTypes;
+        }
+
+        else if constexpr (std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>)
+            return GetClassTypeName((T)0);
+    }
+
+    static SString ResolveParameter(lua_State* L, std::size_t index)
+    {
+        switch (lua_type(L, index))
+        {
+            case LUA_TNUMBER:
+                return SString("number (%d)", lua_tonumber(L, index));
+            case LUA_TSTRING:
+            {
+                std::size_t iLen;
+                const char* szValue = lua_tolstring(L, index, &iLen);
+                std::string strValue(szValue, iLen);
+                if (strValue.length() > 10)
+                {
+                    strValue.resize(10);            // Limit to 10 characters
+                    strValue[9] = '.';
+                    strValue[8] = '.';
+                    strValue[7] = '.';
+                }
+                // Avoid printing binary data
+                if (std::find_if(strValue.begin(), strValue.end(), [](char ch) { return !(std::isprint(ch)); }) != strValue.end())
+                    return "string";
+                else
+                {
+                    return SString("string (\"%s\")", strValue.c_str());
+                }
+            }
+            case LUA_TBOOLEAN:
+                return SString("boolean (%s)", lua_toboolean(L, index) == 1 ? "true" : "false");
+            case LUA_TNIL:
+                return "nil";
+            case LUA_TNONE:
+                return "none";
+            case LUA_TTABLE:
+                return "table";
+            case LUA_TFUNCTION:
+                return "function";
+            case LUA_TTHREAD:
+                return "coroutine";
+            case LUA_TUSERDATA:
+                return GetUserDataClassName(*((void**)lua_touserdata(L, index)), L);
+            case LUA_TLIGHTUSERDATA:
+                return GetUserDataClassName(lua_touserdata(L, index), L);
+        }
+        return "";
+    }
 
     // Pop should remove a T from the Lua Stack after verifying that it is a valid type
     // Pop may also throw a LuaArgumentError to indicate failure
@@ -33,8 +128,10 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
     {
         if (!TypeMatch<T>(L, index))
         {
-            // TODO: resolve error
-            bFailed = true;
+            SString strReceived = ResolveParameter(L, index);
+            SString strExpected = typeToName<T>();
+            SString strMessage("Expected %s at argument %d, got %s", strExpected.c_str(), index, strReceived.c_str());
+            strError = strMessage;
             return T{};
         }
         return PopUnsafe<T>(L, index);
@@ -80,7 +177,7 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         if constexpr (std::is_same_v<T, bool>)
             return (iArgument == LUA_TBOOLEAN);
 
-        // advanced types
+        // Advanced types
         // Enums are represented as strings to Lua
         if constexpr (std::is_enum_v<T>)
             return iArgument == LUA_TSTRING;
@@ -162,8 +259,10 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
                 return eValue;
             else
             {
-                bFailed = true;
-                // TODO: resolve error
+                SString strReceived = ResolveParameter(L, index);
+                SString strExpected = GetEnumTypeName((T)0);
+                SString strMessage("Expected %s at argument %d, got %s", strExpected.c_str(), index, strReceived.c_str());
+                strError = strMessage;
                 return static_cast<T>(0);
             }
         }
@@ -184,11 +283,11 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
             lua_pushnil(L); /* first key */
             while (lua_next(L, index) != 0)
             {
-                if (!TypeMatch<param>(L, -1) || !TypeMatch<int>(L, -2))
+                if (!TypeMatch<param>(L, -1))
                 {
-                    bFailed = true;
-                    // TODO: resolve error
-                    return vecData;
+                    // skip
+                    lua_pop(L, 1);
+                    continue;
                 }
 
                 std::size_t i = -1;
@@ -208,9 +307,9 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
             {
                 if (!TypeMatch<value_t>(L, -1) || !TypeMatch<key_t>(L, -2))
                 {
-                    bFailed = true;
-                    // TODO: resolve error
-                    return map;
+                    // skip
+                    lua_pop(L, 1);
+                    continue;
                 }
 
                 std::size_t i = -2;
@@ -243,29 +342,24 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
             bool  isLightUserData = lua_type(L, index) == LUA_TLIGHTUSERDATA;
             void* pValue = lua::PopTrivial<void*>(L, index);
             using class_t = std::remove_pointer_t<T>;
-            T result = nullptr;
-            if (isLightUserData)
-            {
-                result = UserDataCast<class_t>((class_t*)0, pValue, L);
-            }
-            else
-            {
-                result = UserDataCast<class_t>((class_t*)0, *reinterpret_cast<void**>(pValue), L);
-            }
+            auto result =
+                isLightUserData ? UserDataCast<class_t>((class_t*)0, pValue, L) : UserDataCast<class_t>((class_t*)0, *reinterpret_cast<void**>(pValue), L);
             if (result == nullptr)
             {
-                bFailed = true;
-                // TODO: resolve error
+                SString strReceived = isLightUserData ? GetUserDataClassName(pValue, L) : GetUserDataClassName(*(void**)pValue, L);
+                SString strExpected = GetClassTypeName((T)0);
+                SString strMessage("Expected %s at argument %d, got %s", strExpected.c_str(), index, strReceived.c_str());
+                strError = strMessage;
                 return nullptr;
             }
-            return result;
+            return static_cast<T>(result);
         }
     }
 
     template <typename... Params>
     inline auto Call(lua_State* L, Params&&... ps)
     {
-        if (bFailed)
+        if (strError.length() != 0)
         {
             return -1;
         }
@@ -298,7 +392,7 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         {
             strError = e.what();
         }
-        if (bFailed)
+        if (strError.length() != 0)
         {
             if constexpr (ErrorOnFailure)
             {
diff --git a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
index bfb78961863..7b519bbad44 100644
--- a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
+++ b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
@@ -11,7 +11,6 @@
 #include <SharedUtil.Crypto.h>
 #include <lua/CLuaFunctionParser.h>
 
-
 void CLuaCryptDefs::LoadFunctions()
 {
     std::map<const char*, lua_CFunction> functions{

From 66d572b3657b85dec6c0cae47a094e2379cd375f Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Sat, 1 Jun 2019 15:13:49 +0200
Subject: [PATCH 07/25] Added CLuaStackChecker

---
 .../deathmatch/logic/lua/CLuaFunctionParser.h |  3 +
 .../deathmatch/logic/lua/CLuaStackChecker.h   | 56 +++++++++++++++++++
 2 files changed, 59 insertions(+)
 create mode 100644 Shared/mods/deathmatch/logic/lua/CLuaStackChecker.h

diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index 7e3cca45f23..b94af74d8da 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -12,6 +12,7 @@
 #include <variant>
 #include <SharedUtil.Template.h>
 #include "lua/CLuaFunctionParseHelpers.h"
+#include "lua/CLuaStackChecker.h"
 #include "lua/LuaBasic.h"
 
 template <bool, auto*>
@@ -246,6 +247,8 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
     template <typename T>
     inline T PopUnsafe(lua_State* L, std::size_t& index)
     {
+        // Expect no change in stack size
+        LUA_STACK_EXPECT(0); 
         // trivial types are directly popped
         if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> ||
                       std::is_same_v<T, short> || std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short> || std::is_same_v<T, bool>)
diff --git a/Shared/mods/deathmatch/logic/lua/CLuaStackChecker.h b/Shared/mods/deathmatch/logic/lua/CLuaStackChecker.h
new file mode 100644
index 00000000000..10b457db61c
--- /dev/null
+++ b/Shared/mods/deathmatch/logic/lua/CLuaStackChecker.h
@@ -0,0 +1,56 @@
+/*****************************************************************************
+ *
+ *  PROJECT:     Multi Theft Auto
+ *  LICENSE:     See LICENSE in the top level directory
+ *
+ *  Multi Theft Auto is available from http://www.multitheftauto.com/
+ *
+ *****************************************************************************/
+#pragma once
+#include <stdexcept>
+/*
+ * Simple utility to verify the Lua stack.
+ * The general idea is to simply write
+ *   LUA_STACK_EXPECT(N);
+ * at the beginning of a function, where N
+ * is the expected amount of change in the Lua
+ * stack size.
+ *
+ * As an example: A __index metamethod receives
+ * two parameters on the stack and returns a
+ * single value. Therefor each __index
+ * implementation should decrease the Lua stack
+ * size by one. Therefore write:
+ *   LUA_STACK_EXPECT(-1);
+ */
+namespace lua
+{
+    struct CLuaStackChecker
+    {
+        lua_State* L;
+        int        m_iTop = 0;
+        int        m_iExpected = 0;
+        CLuaStackChecker(lua_State* L, int expected) : L(L)
+        {
+            m_iTop = lua_gettop(L);
+            m_iExpected = expected;
+        }
+
+        ~CLuaStackChecker() noexcept(false)
+        {
+            int iNewtop = lua_gettop(L);
+            int iChange = iNewtop - m_iTop;
+            if (iChange != m_iExpected)
+            {
+                printf("Lua Stack Error: top should be %d is %d (change should be %d is %d)\n", m_iTop + m_iExpected, iNewtop, m_iExpected, iChange);
+                throw std::runtime_error("Lua Stack Error");
+            }
+        }
+    };
+}            // namespace lua
+
+#ifdef MTA_DEBUG
+#define LUA_STACK_EXPECT(i) lua::CLuaStackChecker invalidHiddenName(L, i)
+#else
+#define LUA_STACK_EXPECT(i)
+#endif

From e7b76f64e1fb21c32e5b868a84beb6ee113f015f Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Sun, 2 Jun 2019 19:26:45 +0200
Subject: [PATCH 08/25] Initial version of overload resolution logic Only works
 for overloads with the same number of parameters

---
 .../mods/deathmatch/logic/luadefs/CLuaDefs.h  | 13 +++
 .../mods/deathmatch/logic/luadefs/CLuaDefs.h  | 13 +++
 .../deathmatch/logic/lua/CLuaFunctionParser.h |  1 +
 .../deathmatch/logic/lua/CLuaOverloadParser.h | 90 +++++++++++++++++++
 Shared/sdk/SharedUtil.Template.h              | 67 +++++++++++++-
 5 files changed, 183 insertions(+), 1 deletion(-)
 create mode 100644 Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h

diff --git a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
index 159fda06533..bde21cb52da 100644
--- a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -74,10 +74,23 @@ class CLuaDefs
         return CLuaFunctionParser<false, T>()(L, m_pScriptDebugging);
     }
 
+    template <auto T, auto U>
+    static inline int ArgumentParserWarn(lua_State* L)
+    {
+        return CLuaFunctionParser<false, CLuaOverloadParser<T, U>::Call>()(L, m_pScriptDebugging);
+    }
+
     // New style: hard error on usage mistakes
     template <auto T>
     static inline int ArgumentParser(lua_State* L)
     {
         return CLuaFunctionParser<true, T>()(L, m_pScriptDebugging);
     }
+
+    // Overload variant
+    template <auto T, auto U>
+    static inline int ArgumentParser(lua_State* L)
+    {
+        return CLuaFunctionParser<true, CLuaOverloadParser<T, U>::Call>()(L, m_pScriptDebugging);
+    }
 };
diff --git a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
index 664f634a36c..b969d1189ea 100644
--- a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -95,10 +95,23 @@ class CLuaDefs
         return CLuaFunctionParser<false, T>()(L, m_pScriptDebugging);
     }
 
+    template <auto T, auto U>
+    static inline int ArgumentParserWarn(lua_State* L)
+    {
+        return CLuaFunctionParser<false, CLuaOverloadParser<T, U>::Call>()(L, m_pScriptDebugging);
+    }
+
     // New style: hard error on usage mistakes
     template <auto T>
     static inline int ArgumentParser(lua_State* L)
     {
         return CLuaFunctionParser<true, T>()(L, m_pScriptDebugging);
     }
+
+    // Overload variant
+    template <auto T, auto U>
+    static inline int ArgumentParser(lua_State* L)
+    {
+        return CLuaFunctionParser<true, CLuaOverloadParser<T, U>::Call>()(L, m_pScriptDebugging);
+    }
 };
diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index b94af74d8da..46e5f228ad5 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -11,6 +11,7 @@
 #include <optional>
 #include <variant>
 #include <SharedUtil.Template.h>
+#include "lua/CLuaOverloadParser.h"
 #include "lua/CLuaFunctionParseHelpers.h"
 #include "lua/CLuaStackChecker.h"
 #include "lua/LuaBasic.h"
diff --git a/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h b/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h
new file mode 100644
index 00000000000..8178b7c6aa8
--- /dev/null
+++ b/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h
@@ -0,0 +1,90 @@
+/*****************************************************************************
+ *
+ *  PROJECT:     Multi Theft Auto
+ *  LICENSE:     See LICENSE in the top level directory
+ *
+ *  Multi Theft Auto is available from http://www.multitheftauto.com/
+ *
+ *****************************************************************************/
+#pragma once
+
+#include <SharedUtil.Template.h>
+#include <type_traits>
+#include <variant>
+
+template <auto*, auto*>
+struct CLuaOverloadParser
+{
+};
+
+template <typename Ret, typename Ret2, typename... Args, typename... Args2, auto (*Func)(Args...)->Ret, auto (*Func2)(Args2...)->Ret2>
+struct CLuaOverloadParser<Func, Func2>
+{
+private:
+    enum class ChosenFunction
+    {
+        FUNCA,
+        FUNCB,
+        COMMON,
+        FAIL
+    };
+
+    template <std::size_t N, typename... Ts, typename... Us>
+    static ChosenFunction MakeAllChoice(std::variant<Ts...> var, Us... us)
+    {
+        ChosenFunction result = MakeChoice<0>(var);
+        if constexpr (sizeof...(Us) == 0)
+            return result;
+        else
+        {
+            ChosenFunction rest = MakeAllChoice<N + 1>(us...);
+            // If types match for overload X, use overload X
+            if (result == rest)
+                return result;
+            // If types don't match, check if this variable matches
+            // both. If so, use the other type
+            else if (result == ChosenFunction::COMMON)
+                return rest;
+            // If the rest matches both overloads, use the current one
+            else if (rest == ChosenFunction::COMMON)
+                return result;
+            // result != rest && result != 0 && rest != 0
+            // Type error
+            return ChosenFunction::FAIL;
+        }
+    }
+
+    // Chose an overload that the Nth paramter matches
+    template <std::size_t N, typename... T>
+    static ChosenFunction MakeChoice(std::variant<T...> var)
+    {
+        return std::visit(
+            [](auto&& f) {
+                using ft = decltype(f);
+                if constexpr (!std::is_convertible_v<ft, nth_element_t<N, Args...>>)
+                    return ChosenFunction::FUNCB;            // if it cannot match A, B it is
+                if constexpr (!std::is_convertible_v<ft, nth_element_t<N, Args2...>>)
+                    return ChosenFunction::FUNCA;            // if it cannot match A, B it is
+                return ChosenFunction::COMMON;               // Both match
+            },
+            var);
+    }
+
+public:
+    typename common_variant<Ret, Ret2>::type
+    static Call(typename common_variant<Args, Args2>::type... args)
+    {
+        ChosenFunction choice = MakeAllChoice<0>(args...);
+        if (choice == ChosenFunction::FUNCA)
+            return Func(std::get<Args>(args)...);
+        else if (choice == ChosenFunction::FUNCB)
+            return Func2(std::get<Args2>(args)...);
+        else if (choice == ChosenFunction::FAIL)
+        {
+            // User provided incorrect arguments
+            throw std::invalid_argument("Overload resolution failed.");
+        }
+        // If this exception is thrown, there is a bug in the overload, as they are not unique
+        throw std::invalid_argument("MTA:SA Bug. Please file an issue with the parameters used for calling.");
+    }
+};
diff --git a/Shared/sdk/SharedUtil.Template.h b/Shared/sdk/SharedUtil.Template.h
index 58681b8d1a8..21e2915caad 100644
--- a/Shared/sdk/SharedUtil.Template.h
+++ b/Shared/sdk/SharedUtil.Template.h
@@ -78,4 +78,69 @@ struct nth_element_impl<0, T, Ts...>
 };
 
 template <std::size_t I, typename... Ts>
-using nth_element = typename nth_element_impl<I, Ts...>::type;
+using nth_element_t = typename nth_element_impl<I, Ts...>::type;
+
+
+// common_variant
+// common_variant builds a single variant from types or variants
+//  bool, bool -> variant<bool>
+//  int, bool -> variant<int, bool>
+//  variant<int, bool>, bool -> variant<int, bool>
+//  variant<int, bool>, float -> variant<int, bool, float>
+//  variant<int, bool>, variant<bool, float> -> variant<int, bool, float>
+//  variant<int, bool>, variant<bool, float, double> -> variant<int, bool, float, double>
+
+// Two different types
+//  int, bool -> variant<int, bool>
+template <typename T, typename U>
+struct common_variant
+{
+    using type = std::variant<T, U>;
+};
+
+// Identical types
+//  int, int -> variant<int>
+template <typename T>
+struct common_variant<T, T>
+{
+    using type = std::variant<T>;
+};
+
+// Type + Variant which starts with the Type
+//  int, variant<int> -> variant<int>
+template <typename T, typename... Ts>
+struct common_variant<T, std::variant<T, Ts...>>
+{
+    using type = std::variant<T, Ts...>;
+};
+
+// Variant + Empty = Variant
+template <typename... Ts>
+struct common_variant<std::variant<Ts...>, std::variant<>>
+{
+    using type = std::variant<Ts...>;
+};
+// Empty + Variant = Variant
+template <typename... Ts>
+struct common_variant<std::variant<>, std::variant<Ts...>>
+{
+    using type = std::variant<Ts...>;
+};
+
+template <typename T, typename... Ts>
+struct common_variant<T, std::variant<Ts...>>
+{
+    using type = std::conditional_t<std::is_convertible_v<T, std::variant<Ts...>>, std::variant<Ts...>, std::variant<T, Ts...>>;
+};
+
+template <typename T, typename... Ts>
+struct common_variant<std::variant<Ts...>, T>
+{
+    using type = typename common_variant<T, std::variant<Ts...>>::type;
+};
+
+template <typename T, typename... Ts, typename... Us>
+struct common_variant<std::variant<T, Ts...>, std::variant<Us...>>
+{
+    using type = typename common_variant<std::variant<Ts...>, typename common_variant<T, std::variant<Us...>>::type>::type;
+};

From 2ed2efb6dfa0ea61cb802ac2dd9a83ff672f54e6 Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Tue, 4 Jun 2019 20:49:44 +0200
Subject: [PATCH 09/25] Full support for overloads

---
 .../mods/deathmatch/logic/luadefs/CLuaDefs.h  | 15 ++++--
 .../mods/deathmatch/logic/luadefs/CLuaDefs.h  | 15 ++++--
 .../deathmatch/logic/lua/CLuaFunctionParser.h | 21 ++++++---
 .../deathmatch/logic/lua/CLuaOverloadParser.h |  2 +-
 Shared/sdk/SharedUtil.Template.h              | 47 +++++++++++++++++++
 5 files changed, 85 insertions(+), 15 deletions(-)

diff --git a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
index bde21cb52da..8a12f23bf28 100644
--- a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -74,10 +74,14 @@ class CLuaDefs
         return CLuaFunctionParser<false, T>()(L, m_pScriptDebugging);
     }
 
-    template <auto T, auto U>
+    // Special cases for overloads
+    template <auto T, auto U, auto... Ts>
     static inline int ArgumentParserWarn(lua_State* L)
     {
-        return CLuaFunctionParser<false, CLuaOverloadParser<T, U>::Call>()(L, m_pScriptDebugging);
+        if constexpr (sizeof...(Ts) == 0)
+            return ArgumentParserWarn<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
+        else
+            return ArgumentParserWarn<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
     }
 
     // New style: hard error on usage mistakes
@@ -88,9 +92,12 @@ class CLuaDefs
     }
 
     // Overload variant
-    template <auto T, auto U>
+    template <auto T, auto U, auto... Ts>
     static inline int ArgumentParser(lua_State* L)
     {
-        return CLuaFunctionParser<true, CLuaOverloadParser<T, U>::Call>()(L, m_pScriptDebugging);
+        if constexpr (sizeof...(Ts) == 0)
+            return ArgumentParser<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
+        else
+            return ArgumentParser<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
     }
 };
diff --git a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
index b969d1189ea..b7d1360899d 100644
--- a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -95,10 +95,14 @@ class CLuaDefs
         return CLuaFunctionParser<false, T>()(L, m_pScriptDebugging);
     }
 
-    template <auto T, auto U>
+    // Special cases for overloads
+    template <auto T, auto U, auto... Ts>
     static inline int ArgumentParserWarn(lua_State* L)
     {
-        return CLuaFunctionParser<false, CLuaOverloadParser<T, U>::Call>()(L, m_pScriptDebugging);
+        if constexpr (sizeof...(Ts) == 0)
+            return ArgumentParserWarn<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
+        else
+            return ArgumentParserWarn<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
     }
 
     // New style: hard error on usage mistakes
@@ -109,9 +113,12 @@ class CLuaDefs
     }
 
     // Overload variant
-    template <auto T, auto U>
+    template <auto T, auto U, auto... Ts>
     static inline int ArgumentParser(lua_State* L)
     {
-        return CLuaFunctionParser<true, CLuaOverloadParser<T, U>::Call>()(L, m_pScriptDebugging);
+        if constexpr (sizeof...(Ts) == 0)
+            return ArgumentParser<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
+        else
+            return ArgumentParser<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
     }
 };
diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index 46e5f228ad5..dc2676c28e7 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -34,7 +34,7 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         using param = typename is_variant<T>::param1_t;
         if (accumulator.length() == 0)
             accumulator = typeToName<param>();
-        else 
+        else
             accumulator += "/" + typeToName<param>();
 
         if constexpr (is_variant<T>::count != 1)
@@ -69,12 +69,13 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         else if constexpr (is_variant<T>::value)
         {
             SString strTypes;
-            typeToNameVariant<T>(strTypes);    
+            typeToNameVariant<T>(strTypes);
             return strTypes;
         }
-
         else if constexpr (std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>)
             return GetClassTypeName((T)0);
+        else if constexpr (std::is_same_v<T, dummy_type>)
+            return "";
     }
 
     static SString ResolveParameter(lua_State* L, std::size_t index)
@@ -215,6 +216,11 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         // and can be fetched from a userdata
         if constexpr (std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>)
             return iArgument == LUA_TUSERDATA || iArgument == LUA_TLIGHTUSERDATA;
+        
+        // dummy type is used as overload extension if one overload has fewer arguments
+        // thus it is only allowed if there are no further args on the Lua side 
+        if constexpr (std::is_same_v<T, dummy_type>)
+            return iArgument == LUA_TNONE;
     }
 
     // Special PopUnsafe for variants
@@ -249,10 +255,13 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
     inline T PopUnsafe(lua_State* L, std::size_t& index)
     {
         // Expect no change in stack size
-        LUA_STACK_EXPECT(0); 
+        LUA_STACK_EXPECT(0);
+        // the dummy type is not read from Lua
+        if constexpr (std::is_same_v<T, dummy_type>)
+            return dummy_type{};
         // trivial types are directly popped
-        if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> ||
-                      std::is_same_v<T, short> || std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short> || std::is_same_v<T, bool>)
+        else if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> ||
+                           std::is_same_v<T, short> || std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short> || std::is_same_v<T, bool>)
             return lua::PopTrivial<T>(L, index);
         else if constexpr (std::is_enum_v<T>)
         {
diff --git a/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h b/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h
index 8178b7c6aa8..0ef999bbc00 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h
@@ -32,7 +32,7 @@ struct CLuaOverloadParser<Func, Func2>
     template <std::size_t N, typename... Ts, typename... Us>
     static ChosenFunction MakeAllChoice(std::variant<Ts...> var, Us... us)
     {
-        ChosenFunction result = MakeChoice<0>(var);
+        ChosenFunction result = MakeChoice<N>(var);
         if constexpr (sizeof...(Us) == 0)
             return result;
         else
diff --git a/Shared/sdk/SharedUtil.Template.h b/Shared/sdk/SharedUtil.Template.h
index 21e2915caad..7c6add60748 100644
--- a/Shared/sdk/SharedUtil.Template.h
+++ b/Shared/sdk/SharedUtil.Template.h
@@ -144,3 +144,50 @@ struct common_variant<std::variant<T, Ts...>, std::variant<Us...>>
 {
     using type = typename common_variant<std::variant<Ts...>, typename common_variant<T, std::variant<Us...>>::type>::type;
 };
+
+// dummy_type
+// generic dummy type
+struct dummy_type
+{
+};
+
+
+// n_tuple: Constructs a tuple of size N
+//  n_tuple<2>::type == std::tuple<dummy_type, dummy_type>
+template <std::size_t, bool B = false, typename... Args>
+struct n_tuple;
+
+template <std::size_t N, typename... Args>
+struct n_tuple<N, true, Args...>
+{
+    using type = std::tuple<Args...>;
+};
+
+template <std::size_t N, typename... Args>
+struct n_tuple<N, false, Args...>
+{
+    using type = typename n_tuple<N, sizeof...(Args) + 1 >= N, Args..., dummy_type>::type;
+};
+
+// pad_func_with_func
+// pads Func with as many dummy_type arguments as needed to 
+// have the same number of arguments as FuncB has
+template <auto* Func, typename T>
+struct pad_func_with_func_impl
+{
+};
+template <typename... Ts, typename Ret, typename... Args, auto (*Func)(Args...)->Ret>
+struct pad_func_with_func_impl<Func, std::tuple<Ts...>>
+{
+    static inline Ret Call(Args... arg, Ts... args) { return Func(arg...); }
+};
+
+template <auto*, auto*>
+struct pad_func_with_func
+{
+};
+template <typename Ret, typename... Args, auto (*Func)(Args...)->Ret, typename RetB, typename... ArgsB, auto (*FuncB)(ArgsB...)->RetB>
+struct pad_func_with_func<Func, FuncB> : pad_func_with_func_impl<Func, typename n_tuple<std::max(sizeof...(Args), sizeof...(ArgsB)) - sizeof...(Args),
+                                                                                        std::max(sizeof...(Args), sizeof...(ArgsB)) - sizeof...(Args) == 0>::type>
+{
+};

From dcf96daf399cb37edced6f2850ea11e71a45ed4e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pascal=20St=C3=BCcker?= <sbx320@sbx320.net>
Date: Tue, 4 Jun 2019 21:00:02 +0200
Subject: [PATCH 10/25] Fix mac build

---
 Server/mods/deathmatch/logic/CGame.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Server/mods/deathmatch/logic/CGame.h b/Server/mods/deathmatch/logic/CGame.h
index 47c56886099..6e2b90eaab2 100644
--- a/Server/mods/deathmatch/logic/CGame.h
+++ b/Server/mods/deathmatch/logic/CGame.h
@@ -57,6 +57,7 @@ class CGame;
 #include "lua/CLuaManager.h"
 
 #include "CLightsyncManager.h"
+#include "CBanManager.h"
 
 // Forward declarations
 class ASE;

From 0f29bb0f907bea5ea1333132d75982da5e938f8e Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Sat, 8 Jun 2019 22:12:58 +0200
Subject: [PATCH 11/25] Improve code generation by using a common base class
 Disallow NaN for float/double

---
 .../deathmatch/logic/lua/CLuaFunctionParser.h | 39 +++++++++++++------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index dc2676c28e7..3e33e1dc510 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -16,13 +16,7 @@
 #include "lua/CLuaStackChecker.h"
 #include "lua/LuaBasic.h"
 
-template <bool, auto*>
-struct CLuaFunctionParser
-{
-};
-
-template <bool ErrorOnFailure, typename Ret, typename... Args, auto (*Func)(Args...)->Ret>
-struct CLuaFunctionParser<ErrorOnFailure, Func>
+struct CLuaFunctionParserBase
 {
     std::size_t iIndex = 1;
     std::string strError = "";
@@ -91,7 +85,8 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
                 std::string strValue(szValue, iLen);
                 if (strValue.length() > 10)
                 {
-                    strValue.resize(10);            // Limit to 10 characters
+                    // Limit to 10 characters
+                    strValue.resize(10);
                     strValue[9] = '.';
                     strValue[8] = '.';
                     strValue[7] = '.';
@@ -216,9 +211,9 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         // and can be fetched from a userdata
         if constexpr (std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>)
             return iArgument == LUA_TUSERDATA || iArgument == LUA_TLIGHTUSERDATA;
-        
+
         // dummy type is used as overload extension if one overload has fewer arguments
-        // thus it is only allowed if there are no further args on the Lua side 
+        // thus it is only allowed if there are no further args on the Lua side
         if constexpr (std::is_same_v<T, dummy_type>)
             return iArgument == LUA_TNONE;
     }
@@ -260,9 +255,20 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
         if constexpr (std::is_same_v<T, dummy_type>)
             return dummy_type{};
         // trivial types are directly popped
-        else if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> ||
-                           std::is_same_v<T, short> || std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short> || std::is_same_v<T, bool>)
+        else if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, int> || std::is_same_v<T, short> || std::is_same_v<T, bool> ||
+                           std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short>)
             return lua::PopTrivial<T>(L, index);
+        // floats/doubles may not be NaN
+        else if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>)
+        {
+            T value = lua::PopTrivial<T>(L, index);
+            if (std::isnan(value))
+            {
+                SString strMessage("Expected number at argument %d, got NaN", index);
+                strError = strMessage;
+            }
+            return value;
+        }
         else if constexpr (std::is_enum_v<T>)
         {
             // Enums are considered strings in Lua
@@ -368,7 +374,16 @@ struct CLuaFunctionParser<ErrorOnFailure, Func>
             return static_cast<T>(result);
         }
     }
+};
+
+template <bool, auto*>
+struct CLuaFunctionParser
+{
+};
 
+template <bool ErrorOnFailure, typename Ret, typename... Args, auto (*Func)(Args...)->Ret>
+struct CLuaFunctionParser<ErrorOnFailure, Func> : CLuaFunctionParserBase
+{
     template <typename... Params>
     inline auto Call(lua_State* L, Params&&... ps)
     {

From ba8671cfcc38f81f7933ecb9ee754e8b773f591e Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Tue, 11 Jun 2019 03:25:59 +0200
Subject: [PATCH 12/25] Allow passing the return value for warn-style errors

---
 Client/mods/deathmatch/logic/luadefs/CLuaDefs.h   | 15 ++++++++-------
 Server/mods/deathmatch/logic/luadefs/CLuaDefs.h   | 15 ++++++++-------
 .../deathmatch/logic/lua/CLuaFunctionParser.h     |  8 ++++----
 .../deathmatch/logic/luadefs/CLuaCryptDefs.cpp    | 14 +++++++-------
 4 files changed, 27 insertions(+), 25 deletions(-)

diff --git a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
index 8a12f23bf28..85c4aed5d34 100644
--- a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -67,28 +67,29 @@ class CLuaDefs
 
 protected:
     // Old style: Only warn on failure. This should
-    // not be used for new functions
-    template <auto T>
+    // not be used for new functions. First template argument
+    // Is a value used as result on invalid argument
+    template <auto Ret, auto T>
     static inline int ArgumentParserWarn(lua_State* L)
     {
-        return CLuaFunctionParser<false, T>()(L, m_pScriptDebugging);
+        return CLuaFunctionParser<false, Ret, T>()(L, m_pScriptDebugging);
     }
 
     // Special cases for overloads
-    template <auto T, auto U, auto... Ts>
+    template <auto Ret, auto T, auto U, auto... Ts>
     static inline int ArgumentParserWarn(lua_State* L)
     {
         if constexpr (sizeof...(Ts) == 0)
-            return ArgumentParserWarn<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
+            return ArgumentParserWarn<Ret, CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
         else
-            return ArgumentParserWarn<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
+            return ArgumentParserWarn<Ret, CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
     }
 
     // New style: hard error on usage mistakes
     template <auto T>
     static inline int ArgumentParser(lua_State* L)
     {
-        return CLuaFunctionParser<true, T>()(L, m_pScriptDebugging);
+        return CLuaFunctionParser<true, nullptr, T>()(L, m_pScriptDebugging);
     }
 
     // Overload variant
diff --git a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
index b7d1360899d..d652fdddaac 100644
--- a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -88,28 +88,29 @@ class CLuaDefs
 
 protected:
     // Old style: Only warn on failure. This should
-    // not be used for new functions
-    template <auto T>
+    // not be used for new functions. First template argument 
+    // Is a value used as result on invalid argument
+    template <auto Ret, auto T>
     static inline int ArgumentParserWarn(lua_State* L)
     {
-        return CLuaFunctionParser<false, T>()(L, m_pScriptDebugging);
+        return CLuaFunctionParser<false, Ret, T>()(L, m_pScriptDebugging);
     }
 
     // Special cases for overloads
-    template <auto T, auto U, auto... Ts>
+    template <auto Ret, auto T, auto U, auto... Ts>
     static inline int ArgumentParserWarn(lua_State* L)
     {
         if constexpr (sizeof...(Ts) == 0)
-            return ArgumentParserWarn<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
+            return ArgumentParserWarn<Ret, CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
         else
-            return ArgumentParserWarn<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
+            return ArgumentParserWarn<Ret, CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
     }
 
     // New style: hard error on usage mistakes
     template <auto T>
     static inline int ArgumentParser(lua_State* L)
     {
-        return CLuaFunctionParser<true, T>()(L, m_pScriptDebugging);
+        return CLuaFunctionParser<true, nullptr, T>()(L, m_pScriptDebugging);
     }
 
     // Overload variant
diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index 3e33e1dc510..e88aae7d05f 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -376,13 +376,13 @@ struct CLuaFunctionParserBase
     }
 };
 
-template <bool, auto*>
+template <bool, auto, auto*>
 struct CLuaFunctionParser
 {
 };
 
-template <bool ErrorOnFailure, typename Ret, typename... Args, auto (*Func)(Args...)->Ret>
-struct CLuaFunctionParser<ErrorOnFailure, Func> : CLuaFunctionParserBase
+template <bool ErrorOnFailure, auto ReturnOnFailure, typename Ret, typename... Args, auto (*Func)(Args...)->Ret>
+struct CLuaFunctionParser<ErrorOnFailure, ReturnOnFailure, Func> : CLuaFunctionParserBase
 {
     template <typename... Params>
     inline auto Call(lua_State* L, Params&&... ps)
@@ -429,7 +429,7 @@ struct CLuaFunctionParser<ErrorOnFailure, Func> : CLuaFunctionParserBase
             else
             {
                 pScriptDebugging->LogCustom(L, strError.c_str());
-                lua_pushboolean(L, false);
+                lua::Push(L, ReturnOnFailure);
             }
             return 1;
         }
diff --git a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
index 7b519bbad44..a15d0311e41 100644
--- a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
+++ b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
@@ -14,13 +14,13 @@
 void CLuaCryptDefs::LoadFunctions()
 {
     std::map<const char*, lua_CFunction> functions{
-        {"md5", ArgumentParserWarn<Md5>},
-        {"sha256", ArgumentParserWarn<Sha256>},
-        {"hash", ArgumentParserWarn<Hash>},
-        {"teaEncode", ArgumentParserWarn<TeaEncode>},
-        {"teaDecode", ArgumentParserWarn<TeaDecode>},
-        {"base64Encode", ArgumentParserWarn<Base64encode>},
-        {"base64Decode", ArgumentParserWarn<Base64decode>},
+        {"md5", ArgumentParserWarn<false, Md5>},
+        {"sha256", ArgumentParserWarn<false, Sha256>},
+        {"hash", ArgumentParserWarn<false, Hash>},
+        {"teaEncode", ArgumentParserWarn<false, TeaEncode>},
+        {"teaDecode", ArgumentParserWarn<false, TeaDecode>},
+        {"base64Encode", ArgumentParserWarn<false, Base64encode>},
+        {"base64Decode", ArgumentParserWarn<false, Base64decode>},
         {"passwordHash", PasswordHash},
         {"passwordVerify", PasswordVerify},
         {"encodeString", EncodeString},

From a32246f3ab49323dac4d4eade9ae5079f44469a6 Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Tue, 11 Jun 2019 03:34:14 +0200
Subject: [PATCH 13/25] Clarify ArgumentParser

---
 .../mods/deathmatch/logic/luadefs/CLuaDefs.h  | 42 ++++++++++++-------
 .../mods/deathmatch/logic/luadefs/CLuaDefs.h  | 42 ++++++++++++-------
 2 files changed, 52 insertions(+), 32 deletions(-)

diff --git a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
index 85c4aed5d34..85225465fb5 100644
--- a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -67,22 +67,27 @@ class CLuaDefs
 
 protected:
     // Old style: Only warn on failure. This should
-    // not be used for new functions. First template argument
-    // Is a value used as result on invalid argument
-    template <auto Ret, auto T>
+    // not be used for new functions. ReturnOnError 
+    // must be a value to use as result on invalid argument
+    template <auto ReturnOnError, auto T>
     static inline int ArgumentParserWarn(lua_State* L)
     {
-        return CLuaFunctionParser<false, Ret, T>()(L, m_pScriptDebugging);
+        return CLuaFunctionParser<false, ReturnOnError, T>()(L, m_pScriptDebugging);
     }
 
-    // Special cases for overloads
-    template <auto Ret, auto T, auto U, auto... Ts>
+    // Special case for overloads
+    // This combines multiple functions into one (via CLuaOverloadParser)
+    template <auto ReturnOnError, auto FunctionA, auto FunctionB, auto... Functions>
     static inline int ArgumentParserWarn(lua_State* L)
     {
-        if constexpr (sizeof...(Ts) == 0)
-            return ArgumentParserWarn<Ret, CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
-        else
-            return ArgumentParserWarn<Ret, CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
+        // Pad functions to have the same number of parameters by 
+        // filling both up to the larger number of parameters with dummy_type arguments
+        using PaddedFunctionA = pad_func_with_func<FunctionA, FunctionB>;
+        using PaddedFunctionB = pad_func_with_func<FunctionB, FunctionA>;
+        // Combine functions
+        using Overload = CLuaOverloadParser<PaddedFunctionA::Call, PaddedFunctionB::Call>;
+
+        return ArgumentParserWarn<Ret, Overload::Call, Functions...>(L);
     }
 
     // New style: hard error on usage mistakes
@@ -92,13 +97,18 @@ class CLuaDefs
         return CLuaFunctionParser<true, nullptr, T>()(L, m_pScriptDebugging);
     }
 
-    // Overload variant
-    template <auto T, auto U, auto... Ts>
+    // Special case for overloads
+    // This combines multiple functions into one (via CLuaOverloadParser)
+    template <auto FunctionA, auto FunctionB, auto... Functions>
     static inline int ArgumentParser(lua_State* L)
     {
-        if constexpr (sizeof...(Ts) == 0)
-            return ArgumentParser<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
-        else
-            return ArgumentParser<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
+        // Pad functions to have the same number of parameters by
+        // filling both up to the larger number of parameters with dummy_type arguments
+        using PaddedFunctionA = pad_func_with_func<FunctionA, FunctionB>;
+        using PaddedFunctionB = pad_func_with_func<FunctionB, FunctionA>;
+        // Combine functions
+        using Overload = CLuaOverloadParser<PaddedFunctionA::Call, PaddedFunctionB::Call>;
+
+        return ArgumentParser<Overload::Call, Functions...>(L);
     }
 };
diff --git a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
index d652fdddaac..c1842db205e 100644
--- a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -88,22 +88,27 @@ class CLuaDefs
 
 protected:
     // Old style: Only warn on failure. This should
-    // not be used for new functions. First template argument 
-    // Is a value used as result on invalid argument
-    template <auto Ret, auto T>
+    // not be used for new functions. ReturnOnError
+    // must be a value to use as result on invalid argument
+    template <auto ReturnOnError, auto T>
     static inline int ArgumentParserWarn(lua_State* L)
     {
-        return CLuaFunctionParser<false, Ret, T>()(L, m_pScriptDebugging);
+        return CLuaFunctionParser<false, ReturnOnError, T>()(L, m_pScriptDebugging);
     }
 
-    // Special cases for overloads
-    template <auto Ret, auto T, auto U, auto... Ts>
+    // Special case for overloads
+    // This combines multiple functions into one (via CLuaOverloadParser)
+    template <auto ReturnOnError, auto FunctionA, auto FunctionB, auto... Functions>
     static inline int ArgumentParserWarn(lua_State* L)
     {
-        if constexpr (sizeof...(Ts) == 0)
-            return ArgumentParserWarn<Ret, CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
-        else
-            return ArgumentParserWarn<Ret, CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
+        // Pad functions to have the same number of parameters by
+        // filling both up to the larger number of parameters with dummy_type arguments
+        using PaddedFunctionA = pad_func_with_func<FunctionA, FunctionB>;
+        using PaddedFunctionB = pad_func_with_func<FunctionB, FunctionA>;
+        // Combine functions
+        using Overload = CLuaOverloadParser<PaddedFunctionA::Call, PaddedFunctionB::Call>;
+
+        return ArgumentParserWarn<Ret, Overload::Call, Functions...>(L);
     }
 
     // New style: hard error on usage mistakes
@@ -113,13 +118,18 @@ class CLuaDefs
         return CLuaFunctionParser<true, nullptr, T>()(L, m_pScriptDebugging);
     }
 
-    // Overload variant
-    template <auto T, auto U, auto... Ts>
+    // Special case for overloads
+    // This combines multiple functions into one (via CLuaOverloadParser)
+    template <auto FunctionA, auto FunctionB, auto... Functions>
     static inline int ArgumentParser(lua_State* L)
     {
-        if constexpr (sizeof...(Ts) == 0)
-            return ArgumentParser<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call>(L);
-        else
-            return ArgumentParser<CLuaOverloadParser<pad_func_with_func<T, U>::Call, pad_func_with_func<U, T>::Call>::Call, Ts...>(L);
+        // Pad functions to have the same number of parameters by
+        // filling both up to the larger number of parameters with dummy_type arguments
+        using PaddedFunctionA = pad_func_with_func<FunctionA, FunctionB>;
+        using PaddedFunctionB = pad_func_with_func<FunctionB, FunctionA>;
+        // Combine functions
+        using Overload = CLuaOverloadParser<PaddedFunctionA::Call, PaddedFunctionB::Call>;
+
+        return ArgumentParser<Overload::Call, Functions...>(L);
     }
 };

From 338afa97d46812d833917447c74d44c15257064a Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Tue, 11 Jun 2019 03:35:32 +0200
Subject: [PATCH 14/25] Remove CBanManager forward declaration

---
 Server/mods/deathmatch/logic/CGame.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Server/mods/deathmatch/logic/CGame.h b/Server/mods/deathmatch/logic/CGame.h
index 6e2b90eaab2..d93fd914f46 100644
--- a/Server/mods/deathmatch/logic/CGame.h
+++ b/Server/mods/deathmatch/logic/CGame.h
@@ -63,7 +63,6 @@ class CGame;
 class ASE;
 class CAccessControlListManager;
 class CAccountManager;
-class CBanManager;
 class CBlipManager;
 class CClock;
 class CColManager;

From 9a717b440cdf4b9de7cd899218cb37284a0585da Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Tue, 11 Jun 2019 04:27:07 +0200
Subject: [PATCH 15/25] Add further documentation to templates Remove fixme Fix
 naming convention

---
 .../deathmatch/logic/lua/CLuaFunctionParser.h | 79 ++++++++++---------
 Shared/mods/deathmatch/logic/lua/LuaBasic.cpp | 14 ++--
 Shared/mods/deathmatch/logic/lua/LuaBasic.h   | 17 ++--
 .../logic/luadefs/CLuaCryptDefs.cpp           |  6 +-
 Shared/sdk/SharedUtil.Template.h              | 60 +++++++++++++-
 5 files changed, 120 insertions(+), 56 deletions(-)

diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index e88aae7d05f..a755dca6d4e 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -22,21 +22,23 @@ struct CLuaFunctionParserBase
     std::string strError = "";
     std::string strErrorFoundType = "";
 
+    // Translates a variant type to a list of names separated by slashes
+    // std::variant<bool, int, float> => bool/int/float
     template <typename T>
-    inline void typeToNameVariant(SString& accumulator)
+    inline void TypeToNameVariant(SString& accumulator)
     {
         using param = typename is_variant<T>::param1_t;
         if (accumulator.length() == 0)
-            accumulator = typeToName<param>();
+            accumulator = TypeToName<param>();
         else
-            accumulator += "/" + typeToName<param>();
+            accumulator += "/" + TypeToName<param>();
 
         if constexpr (is_variant<T>::count != 1)
-            return typeToNameVariant<is_variant<T>::rest_t>(accumulator);
+            return TypeToNameVariant<is_variant<T>::rest_t>(accumulator);
     }
 
     template <typename T>
-    inline SString typeToName()
+    inline SString TypeToName()
     {
         if constexpr (std::is_same_v<T, std::string>)
             return "string";
@@ -50,7 +52,7 @@ struct CLuaFunctionParserBase
         else if constexpr (is_specialization<T, std::optional>::value)
         {
             using param_t = typename is_specialization<T, std::optional>::param_t;
-            return typeToName<param_t>();
+            return TypeToName<param_t>();
         }
         else if constexpr (is_2specialization<T, std::vector>::value)
             return "table";
@@ -63,7 +65,7 @@ struct CLuaFunctionParserBase
         else if constexpr (is_variant<T>::value)
         {
             SString strTypes;
-            typeToNameVariant<T>(strTypes);
+            TypeToNameVariant<T>(strTypes);
             return strTypes;
         }
         else if constexpr (std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>)
@@ -72,7 +74,9 @@ struct CLuaFunctionParserBase
             return "";
     }
 
-    static SString ResolveParameter(lua_State* L, std::size_t index)
+    // Reads the parameter type (& value in some cases) at a given index 
+    // For example a 42 on the Lua stack is returned as 'number (42)'
+    static SString ReadParameterAsString(lua_State* L, std::size_t index)
     {
         switch (lua_type(L, index))
         {
@@ -120,14 +124,13 @@ struct CLuaFunctionParserBase
     }
 
     // Pop should remove a T from the Lua Stack after verifying that it is a valid type
-    // Pop may also throw a LuaArgumentError to indicate failure
     template <typename T>
     inline T Pop(lua_State* L, std::size_t& index)
     {
         if (!TypeMatch<T>(L, index))
         {
-            SString strReceived = ResolveParameter(L, index);
-            SString strExpected = typeToName<T>();
+            SString strReceived = ReadParameterAsString(L, index);
+            SString strExpected = TypeToName<T>();
             SString strMessage("Expected %s at argument %d, got %s", strExpected.c_str(), index, strReceived.c_str());
             strError = strMessage;
             return T{};
@@ -140,21 +143,24 @@ struct CLuaFunctionParserBase
     template <typename T>
     inline int TypeMatchVariant(lua_State* L, std::size_t index)
     {
+        // If the variant is empty, we have exhausted all options
+        // The type therefore doesn't match the variant
         if constexpr (std::is_same_v<T, std::variant<>>)
             return -1;
         else
         {
+            // Try to match the first type of the variant
+            // If it matches, we've found our index
             using first_t = typename is_variant<T>::param1_t;
             using next_t = typename is_variant<T>::rest_t;
             if (TypeMatch<first_t>(L, index))
                 return 0;
-            else
-            {
-                int iResult = TypeMatchVariant<next_t>(L, index);
-                if (iResult == -1)
-                    return -1;
-                return 1 + iResult;
-            }
+            
+            // Else try the remaining types of the variant
+            int iResult = TypeMatchVariant<next_t>(L, index);
+            if (iResult == -1)
+                return -1;
+            return 1 + iResult;
         }
     }
 
@@ -166,7 +172,7 @@ struct CLuaFunctionParserBase
     inline bool TypeMatch(lua_State* L, std::size_t index)
     {
         int iArgument = lua_type(L, index);
-        // trivial types
+        // primitive types
         if constexpr (std::is_same_v<T, std::string>)
             return (iArgument == LUA_TSTRING || iArgument == LUA_TNUMBER);
         if constexpr (std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> || std::is_same_v<T, short> ||
@@ -179,6 +185,7 @@ struct CLuaFunctionParserBase
         // Enums are represented as strings to Lua
         if constexpr (std::is_enum_v<T>)
             return iArgument == LUA_TSTRING;
+
         // std::optional is used for optional parameters
         // which may also be in the middle of a parameter list
         // therefore it is always valid to attempt to read an
@@ -198,9 +205,9 @@ struct CLuaFunctionParserBase
         if constexpr (std::is_same_v<T, CLuaFunctionRef>)
             return iArgument == LUA_TFUNCTION;
 
-        // lua_State* can be taken as argument anywhere
+        // lua_State* can be taken as first argument of any function
         if constexpr (std::is_same_v<T, lua_State*>)
-            return true;
+            return index == 0;
 
         // variants can be used by any of the underlying types
         // thus recursively use this function
@@ -232,17 +239,13 @@ struct CLuaFunctionParserBase
         }
         else
         {
-            // If we have reached the target index, pop the right value
-            // else go to the next type
-            if (vindex == currIndex)
-            {
-                using type_t = std::remove_reference_t<decltype(std::get<currIndex>(T{}))>;
-                return PopUnsafe<type_t>(L, index);
-            }
-            else
-            {
+            // If we haven't reached the target index go to the next type
+            if (vindex != currIndex)
                 return PopUnsafeVariant<T, currIndex + 1>(L, index, vindex);
-            }
+
+            // Pop the actual type
+            using type_t = std::remove_reference_t<decltype(std::get<currIndex>(T{}))>;
+            return PopUnsafe<type_t>(L, index);
         }
     }
 
@@ -254,14 +257,14 @@ struct CLuaFunctionParserBase
         // the dummy type is not read from Lua
         if constexpr (std::is_same_v<T, dummy_type>)
             return dummy_type{};
-        // trivial types are directly popped
+        // primitive types are directly popped
         else if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, int> || std::is_same_v<T, short> || std::is_same_v<T, bool> ||
                            std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short>)
-            return lua::PopTrivial<T>(L, index);
+            return lua::PopPrimitive<T>(L, index);
         // floats/doubles may not be NaN
         else if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>)
         {
-            T value = lua::PopTrivial<T>(L, index);
+            T value = lua::PopPrimitive<T>(L, index);
             if (std::isnan(value))
             {
                 SString strMessage("Expected number at argument %d, got NaN", index);
@@ -272,13 +275,13 @@ struct CLuaFunctionParserBase
         else if constexpr (std::is_enum_v<T>)
         {
             // Enums are considered strings in Lua
-            std::string strValue = lua::PopTrivial<std::string>(L, index);
+            std::string strValue = lua::PopPrimitive<std::string>(L, index);
             T           eValue;
             if (StringToEnum(strValue, eValue))
                 return eValue;
             else
             {
-                SString strReceived = ResolveParameter(L, index);
+                SString strReceived = ReadParameterAsString(L, index);
                 SString strExpected = GetEnumTypeName((T)0);
                 SString strMessage("Expected %s at argument %d, got %s", strExpected.c_str(), index, strReceived.c_str());
                 strError = strMessage;
@@ -359,7 +362,7 @@ struct CLuaFunctionParserBase
         else if constexpr (std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>)
         {
             bool  isLightUserData = lua_type(L, index) == LUA_TLIGHTUSERDATA;
-            void* pValue = lua::PopTrivial<void*>(L, index);
+            void* pValue = lua::PopPrimitive<void*>(L, index);
             using class_t = std::remove_pointer_t<T>;
             auto result =
                 isLightUserData ? UserDataCast<class_t>((class_t*)0, pValue, L) : UserDataCast<class_t>((class_t*)0, *reinterpret_cast<void**>(pValue), L);
@@ -418,6 +421,8 @@ struct CLuaFunctionParser<ErrorOnFailure, ReturnOnFailure, Func> : CLuaFunctionP
         }
         catch (std::invalid_argument& e)
         {
+            // This exception can only be thrown from the called function
+            // as an additional way to provide further argument errors
             strError = e.what();
         }
         if (strError.length() != 0)
diff --git a/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
index a2e25007102..29adc26e0ba 100644
--- a/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
+++ b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
@@ -52,7 +52,7 @@ namespace lua
 
 
     template <>
-    std::string PopTrivial<std::string>(lua_State* L, std::size_t& index)
+    std::string PopPrimitive<std::string>(lua_State* L, std::size_t& index)
     {
         uint        uiLength = lua_strlen(L, index);
         std::string outValue;
@@ -61,37 +61,37 @@ namespace lua
     }
 
     template <>
-    int PopTrivial<int>(lua_State* L, std::size_t& index)
+    int PopPrimitive<int>(lua_State* L, std::size_t& index)
     {
         return static_cast<int>(lua_tonumber(L, index++));
     }
 
     template <>
-    unsigned int PopTrivial<unsigned int>(lua_State* L, std::size_t& index)
+    unsigned int PopPrimitive<unsigned int>(lua_State* L, std::size_t& index)
     {
         return static_cast<unsigned int>(lua_tonumber(L, index++));
     }
 
     template <>
-    float PopTrivial<float>(lua_State* L, std::size_t& index)
+    float PopPrimitive<float>(lua_State* L, std::size_t& index)
     {
         return static_cast<float>(lua_tonumber(L, index++));
     }
 
     template <>
-    double PopTrivial<double>(lua_State* L, std::size_t& index)
+    double PopPrimitive<double>(lua_State* L, std::size_t& index)
     {
         return static_cast<double>(lua_tonumber(L, index++));
     }
     
     template <>
-    bool PopTrivial<bool>(lua_State* L, std::size_t& index)
+    bool PopPrimitive<bool>(lua_State* L, std::size_t& index)
     {
         return static_cast<bool>(lua_toboolean(L, index++));
     }
 
     template <>
-    void* PopTrivial<void*>(lua_State* L, std::size_t& index)
+    void* PopPrimitive<void*>(lua_State* L, std::size_t& index)
     {
         return lua_touserdata(L, index++);
     }
diff --git a/Shared/mods/deathmatch/logic/lua/LuaBasic.h b/Shared/mods/deathmatch/logic/lua/LuaBasic.h
index 0f9c5b5bc47..1362467c5d7 100644
--- a/Shared/mods/deathmatch/logic/lua/LuaBasic.h
+++ b/Shared/mods/deathmatch/logic/lua/LuaBasic.h
@@ -13,8 +13,7 @@
 /*
     Basic Lua operations:
         int Push(L, T value)
-        T PopTrivial(L, std::size_t stackIndex)
-        bool TypeMatch(L, std::size_t stackIndex)
+        T PopPrimitive(L, std::size_t stackIndex)
 */
 
 
@@ -23,13 +22,13 @@ namespace lua
     // PopTrival should read a simple value of type T from the stack without extra type checks
     // If whatever is at that point in the stack is not convertible to T, the behavior is undefined
     template <typename T>
-    inline T PopTrivial(lua_State* L, std::size_t& index);
+    inline T PopPrimitive(lua_State* L, std::size_t& index);
 
 
     // Push should push a value of type T to the Lua Stack
-    // The return value must be the amount of items pushed to the stack, which should
-    // be 1 for trivial types (e.g. Push<int>) but may be any number for special cases
-    // like tuples
+    // The return value must be the net amount of items pushed to the stack, which should
+    // be 1 for most types (e.g. Push<int>) but may be any number for special cases
+    // like tuples, in order to allow returning multiple values from a function
     
     int Push(lua_State* L, int val);
     int Push(lua_State* L, const std::string& val);
@@ -67,6 +66,8 @@ namespace lua
             Push(L, v);
             lua_settable(L, -3);
         }
+
+        // Only the table remains on the stack
         return 1;
     }
 
@@ -80,15 +81,19 @@ namespace lua
             Push(L, v);
             lua_settable(L, -3);
         }
+
+        // Only the table remains on the stack
         return 1;
     }
 
+    // Overload for enum types only
     template <typename T>
     typename std::enable_if_t<std::is_enum_v<T>, int> Push(lua_State* L, const T&& val)
     {
         return Push(L, EnumToString(val));
     }
 
+    // Overload for pointers to classes. We boldly assume that these are script entities
     template <typename T>
     typename std::enable_if_t<(std::is_pointer_v<T> && std::is_class_v<std::remove_pointer_t<T>>), int> Push(lua_State* L, const T&& val)
     {
diff --git a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
index a15d0311e41..5dfb1b6ec41 100644
--- a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
+++ b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
@@ -63,10 +63,10 @@ std::string CLuaCryptDefs::TeaEncode(std::string str, std::string key)
 
 std::string CLuaCryptDefs::TeaDecode(std::string str, std::string key)
 {
-    SString fixme = str;
     SString result = SharedUtil::Base64decode(str);
-    SharedUtil::TeaDecode(result, key, &fixme);
-    return fixme;
+    SString strOutResult;
+    SharedUtil::TeaDecode(result, key, &strOutResult);
+    return strOutResult;
 }
 
 std::string CLuaCryptDefs::Base64encode(std::string str)
diff --git a/Shared/sdk/SharedUtil.Template.h b/Shared/sdk/SharedUtil.Template.h
index 7c6add60748..f038d78f53d 100644
--- a/Shared/sdk/SharedUtil.Template.h
+++ b/Shared/sdk/SharedUtil.Template.h
@@ -9,6 +9,23 @@
     Note: Take care of optional parameters. For example std::unordered_map
     has 5 template arguments, thus is_5specialization needs to be used, rather
     than is_2specialization (Key, Value).
+
+    Usage can be the following:
+    if constexpr(is_2specialization<std::vector, T>::value)
+    {
+        // T is a vector!
+        using param_t = typename is_2specialization<std::vector, T>::param_t
+        // param_t is the type of the content of the vector
+    }
+
+    For each version of is_Nspecialization we have two class templates: 
+        - The first one (inheriting from std::false_type) is used to provide a 
+          default case, where something isn't a match. It does not impose restrictions
+          on anything apart from the Test parameter (which is required to take N template 
+          parameters). Thus it matches anything.
+
+        - The second one (std::true_type) is used to perform the actual match
+          by specializting the template for Test<Arg, Arg2>
 **/
 
 template <typename Test, template <typename> class Ref>
@@ -44,8 +61,16 @@ struct is_5specialization<Ref<Arg1, Arg2, Arg3, Arg4, Arg5>, Ref> : std::true_ty
 {
     using param1_t = Arg1;
     using param2_t = Arg2;
+    using param3_t = Arg3;
+    using param4_t = Arg4;
+    using param5_t = Arg5;
 };
 
+// is_variant
+//  Returns whether a T is a variant
+//  If T is a variant, it also allows accessing the individual types
+//  of the variant via param1_t (first type) and rest_t (which is a 
+//  variant of the remaining types).
 template <typename Test>
 struct is_variant : std::false_type
 {
@@ -62,15 +87,22 @@ struct is_variant<std::variant<Arg1, Args...>> : std::true_type
 /**
     nth_element
 
-    Returns the nth element of a parameter pack
+    Returns the nth element of a parameter pack by recursively 
+    discarding and counting down until the index is zero, at which
+    point the type is returned
 **/
 
+// Recursive case, I is larger than 1, therefore
+// we need to look at the I-1 case by discarding the
+// first type. 
 template <std::size_t I, typename T, typename... Ts>
 struct nth_element_impl
 {
     using type = typename nth_element_impl<I - 1, Ts...>::type;
 };
 
+// Base case: If we ask for the 0th element, the current element
+// is the one we're looking for
 template <typename T, typename... Ts>
 struct nth_element_impl<0, T, Ts...>
 {
@@ -120,6 +152,7 @@ struct common_variant<std::variant<Ts...>, std::variant<>>
 {
     using type = std::variant<Ts...>;
 };
+
 // Empty + Variant = Variant
 template <typename... Ts>
 struct common_variant<std::variant<>, std::variant<Ts...>>
@@ -127,18 +160,26 @@ struct common_variant<std::variant<>, std::variant<Ts...>>
     using type = std::variant<Ts...>;
 };
 
+// T + Variant = Variant or a new variant consisting of T + Variant
+// This is done by checking if T is convertible to the variant
 template <typename T, typename... Ts>
 struct common_variant<T, std::variant<Ts...>>
 {
     using type = std::conditional_t<std::is_convertible_v<T, std::variant<Ts...>>, std::variant<Ts...>, std::variant<T, Ts...>>;
 };
 
+// Variant + T = Variant or a new variant consisting of T + Variant
+// Simply calls the above case
 template <typename T, typename... Ts>
 struct common_variant<std::variant<Ts...>, T>
 {
     using type = typename common_variant<T, std::variant<Ts...>>::type;
 };
 
+
+// Variant + Variant = Combined Variant
+// This recursively calls itself and deconstructs the first variant, while 
+// adding the first type in the first variant to the second variant (via the T + variant overload)
 template <typename T, typename... Ts, typename... Us>
 struct common_variant<std::variant<T, Ts...>, std::variant<Us...>>
 {
@@ -152,17 +193,20 @@ struct dummy_type
 };
 
 
-// n_tuple: Constructs a tuple of size N
+// n_tuple: Constructs a tuple of size N (with dummy_type as parameter types)
 //  n_tuple<2>::type == std::tuple<dummy_type, dummy_type>
-template <std::size_t, bool B = false, typename... Args>
+template <std::size_t, bool HasEnough = false, typename... Args>
 struct n_tuple;
 
+// Second parameter is true -> We have reached N types in Args
 template <std::size_t N, typename... Args>
 struct n_tuple<N, true, Args...>
 {
     using type = std::tuple<Args...>;
 };
 
+// Second parameter is false -> Add a dummy type and 
+// decide if sizeof...(Args) + 1 is enough
 template <std::size_t N, typename... Args>
 struct n_tuple<N, false, Args...>
 {
@@ -176,6 +220,11 @@ template <auto* Func, typename T>
 struct pad_func_with_func_impl
 {
 };
+
+// pad_func_with_func_impl takes a tuple of additional arguments, which are then 
+// taken as parameter. This allows us to discard exactly sizeof...(Ts) function
+// arguments. Effectively this means Call is a function that is identical in behavior
+// to Func, but takes additional sizeof...(Ts) dummy arguments that are discarded.
 template <typename... Ts, typename Ret, typename... Args, auto (*Func)(Args...)->Ret>
 struct pad_func_with_func_impl<Func, std::tuple<Ts...>>
 {
@@ -186,6 +235,11 @@ template <auto*, auto*>
 struct pad_func_with_func
 {
 };
+
+// pad_func_with_func initially needs to figure out the maximum number of parameters for the two functions
+// It then determines how many parameters need to be added to Func, in order to have parity in argument count
+// By using n_tuple, we build a Tuple of exactly the amout of parameters that need to be added to Func, which 
+// is then applied via the impl function above
 template <typename Ret, typename... Args, auto (*Func)(Args...)->Ret, typename RetB, typename... ArgsB, auto (*FuncB)(ArgsB...)->RetB>
 struct pad_func_with_func<Func, FuncB> : pad_func_with_func_impl<Func, typename n_tuple<std::max(sizeof...(Args), sizeof...(ArgsB)) - sizeof...(Args),
                                                                                         std::max(sizeof...(Args), sizeof...(ArgsB)) - sizeof...(Args) == 0>::type>

From 38ee1f26871f84b7f42584299fa1738edfe9b84c Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Tue, 11 Jun 2019 04:34:58 +0200
Subject: [PATCH 16/25] Fix typo

---
 Client/mods/deathmatch/logic/luadefs/CLuaDefs.h | 2 +-
 Server/mods/deathmatch/logic/luadefs/CLuaDefs.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
index 85225465fb5..de1a300220b 100644
--- a/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Client/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -87,7 +87,7 @@ class CLuaDefs
         // Combine functions
         using Overload = CLuaOverloadParser<PaddedFunctionA::Call, PaddedFunctionB::Call>;
 
-        return ArgumentParserWarn<Ret, Overload::Call, Functions...>(L);
+        return ArgumentParserWarn<ReturnOnError, Overload::Call, Functions...>(L);
     }
 
     // New style: hard error on usage mistakes
diff --git a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
index c1842db205e..bce533c5dde 100644
--- a/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
+++ b/Server/mods/deathmatch/logic/luadefs/CLuaDefs.h
@@ -108,7 +108,7 @@ class CLuaDefs
         // Combine functions
         using Overload = CLuaOverloadParser<PaddedFunctionA::Call, PaddedFunctionB::Call>;
 
-        return ArgumentParserWarn<Ret, Overload::Call, Functions...>(L);
+        return ArgumentParserWarn<ReturnOnError, Overload::Call, Functions...>(L);
     }
 
     // New style: hard error on usage mistakes

From 43fa9e6f3c81116746891a650274173e78f273ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pascal=20St=C3=BCcker?= <sbx320@sbx320.net>
Date: Wed, 12 Jun 2019 20:23:59 +0200
Subject: [PATCH 17/25] Fix typo in CLuaOverloadParser.h

Co-Authored-By: Qais Patankar <qaisjp@gmail.com>
---
 Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h b/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h
index 0ef999bbc00..7c81b2ad6e1 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h
@@ -64,7 +64,7 @@ struct CLuaOverloadParser<Func, Func2>
                 if constexpr (!std::is_convertible_v<ft, nth_element_t<N, Args...>>)
                     return ChosenFunction::FUNCB;            // if it cannot match A, B it is
                 if constexpr (!std::is_convertible_v<ft, nth_element_t<N, Args2...>>)
-                    return ChosenFunction::FUNCA;            // if it cannot match A, B it is
+                    return ChosenFunction::FUNCA;            // if it cannot match B, A it is
                 return ChosenFunction::COMMON;               // Both match
             },
             var);

From 037df3ddae939a87c9ff1fe68c9a6da1e08a9900 Mon Sep 17 00:00:00 2001
From: Qais Patankar <qaisjp@gmail.com>
Date: Wed, 11 Mar 2020 19:26:34 +0000
Subject: [PATCH 18/25] Move CRemoteCalls.h higher

---
 Server/mods/deathmatch/StdInc.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Server/mods/deathmatch/StdInc.h b/Server/mods/deathmatch/StdInc.h
index 801dc017ea3..d9f5672ecdb 100644
--- a/Server/mods/deathmatch/StdInc.h
+++ b/Server/mods/deathmatch/StdInc.h
@@ -113,6 +113,9 @@ struct SAclRequest;
 #include "packets/CServerInfoSyncPacket.h"
 #include "packets/CDiscordJoinPacket.h"
 
+// has to be included early to prevent "unknown type name 'CRemoteCall'" in CLuaFunctionParser.h
+#include "CRemoteCalls.h"
+
 // Lua function definitions
 #include "luadefs/CLuaElementDefs.h"
 #include "luadefs/CLuaAccountDefs.h"
@@ -142,9 +145,6 @@ struct SAclRequest;
 #include "luadefs/CLuaWaterDefs.h"
 #include "luadefs/CLuaWorldDefs.h"
 
-// has to be included before CLuaFunctionParseHelpers to prevent "invalid use of incomplete type ‘class CRemoteCalls´
-#include "CRemoteCalls.h"
-
 // Lua includes
 #include "lua/LuaCommon.h"
 #include "lua/CLuaMain.h"

From 6e640ab8440479b33051dd0cdbc14eae6404a3f4 Mon Sep 17 00:00:00 2001
From: Qais Patankar <qaisjp@gmail.com>
Date: Wed, 11 Mar 2020 19:26:34 +0000
Subject: [PATCH 19/25] Move CRemoteCalls.h higher

---
 .../logic/luadefs/CLuaCryptDefs.cpp           | 89 ++++++++++---------
 .../deathmatch/logic/luadefs/CLuaCryptDefs.h  |  4 +-
 2 files changed, 49 insertions(+), 44 deletions(-)

diff --git a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
index 5dfb1b6ec41..96a87258deb 100644
--- a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
+++ b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.cpp
@@ -79,41 +79,28 @@ std::string CLuaCryptDefs::Base64decode(std::string str)
     return SharedUtil::Base64decode(str);
 }
 
-std::variant<std::string, bool> CLuaCryptDefs::PasswordHash(lua_State* luaVM, std::string password, PasswordHashFunction algorithm,
-                                                            std::unordered_map<std::string, std::string> options, std::optional<CLuaFunctionRef> luaFunctionRef)
+int CLuaCryptDefs::PasswordHash(lua_State* luaVM)
 {
     //  string password_hash(string password, string algorithm, table options = {} [, function callback])
-    if (algorithm != PasswordHashFunction::Bcrypt)
-    {
-        throw std::invalid_argument("Invalid algorithm");
-    }
-
-    // Set default value to 10
-    if (options["cost"].empty())
-        options["cost"] = "10";
+    SString              password;
+    PasswordHashFunction algorithm;
+    CStringMap           options;
+    CLuaFunctionRef      luaFunctionRef;
 
-    std::stringstream ss(options["cost"]);
-    std::size_t       cost;
-    ss >> cost;
-
-    if (ss.fail())
-        throw std::invalid_argument("Invalid value for field 'cost'");
+    CScriptArgReader argStream(luaVM);
+    argStream.ReadString(password);
+    argStream.ReadEnumString(algorithm);
+    argStream.ReadStringMap(options);
 
-    // Sync
-    if (!luaFunctionRef.has_value())
+    if (argStream.NextIsFunction())
     {
-        SString hash = SharedUtil::BcryptHash(password, options["salt"], cost);
-        if (!hash.empty())
-        {
-            return hash;
-        }
-        else
-            throw std::invalid_argument("Invalid value for field 'salt'");
+        argStream.ReadFunction(luaFunctionRef);
+        argStream.ReadFunctionComplete();
     }
-    else            // Async
+
+    if (!argStream.HasErrors())
     {
-        CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaVM);
-        if (pLuaMain)
+        if (algorithm == PasswordHashFunction::Bcrypt)
         {
             // Set default value to 10
             if (options["cost"].empty())
@@ -149,26 +136,46 @@ std::variant<std::string, bool> CLuaCryptDefs::PasswordHash(lua_State* luaVM, st
                     CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaVM);
                     if (pLuaMain)
                     {
-                        CLuaArguments arguments;
+                        CLuaShared::GetAsyncTaskScheduler()->PushTask<SString>(
+                            [password, salt = options["salt"], cost] {
+                                // Execute time-consuming task
+                                return SharedUtil::BcryptHash(password, salt, cost);
+                            },
+                            [luaFunctionRef](const SString& hash) {
+                                CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaFunctionRef.GetLuaVM());
+                                if (pLuaMain)
+                                {
+                                    CLuaArguments arguments;
 
-                        if (hash.empty())
-                        {
-                            m_pScriptDebugging->LogCustom(pLuaMain->GetVM(), "Invalid value for field 'salt'");
-                            arguments.PushBoolean(false);
-                        }
-                        else
-                            arguments.PushString(hash);
+                                    if (hash.empty())
+                                    {
+                                        m_pScriptDebugging->LogCustom(pLuaMain->GetVM(), "Invalid value for field 'salt'");
+                                        arguments.PushBoolean(false);
+                                    }
+                                    else
+                                        arguments.PushString(hash);
 
-                        arguments.Call(pLuaMain, luaFunctionRef.value());
-                    }
-                });
+                                    arguments.Call(pLuaMain, luaFunctionRef);
+                                }
+                            });
 
-            return true;
+                        lua_pushboolean(luaVM, true);
+                        return 1;
+                    }
+                }
+            }
+            else
+                m_pScriptDebugging->LogWarning(luaVM, "Invalid value for field 'cost'");
         }
-        return false;
     }
+    else
+        m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
+
+    lua_pushboolean(luaVM, false);
+    return 1;
 }
 
+
 int CLuaCryptDefs::PasswordVerify(lua_State* luaVM)
 {
     //  bool passwordVerify(string password, string hash [, table options, function callback])
diff --git a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.h b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.h
index 99bb9c7f965..5da930a1865 100644
--- a/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.h
+++ b/Shared/mods/deathmatch/logic/luadefs/CLuaCryptDefs.h
@@ -26,9 +26,7 @@ class CLuaCryptDefs : public CLuaDefs
     static std::string TeaDecode(std::string str, std::string key);
     static std::string Base64encode(std::string str);
     static std::string Base64decode(std::string str);
-    static std::variant<std::string, bool> PasswordHash(lua_State* luaVM, std::string password, PasswordHashFunction algorithm,
-                                                        std::unordered_map<std::string, std::string> options,
-                             std::optional<CLuaFunctionRef> luaFunctionRef);
+    LUA_DECLARE(PasswordHash);
     static std::string Sha256(std::string strSourceData);
     LUA_DECLARE(PasswordVerify);
     LUA_DECLARE(EncodeString);

From bb0dedb02d7581b6907922be9b02b88fbdb5e33f Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Fri, 3 Apr 2020 01:15:55 +0200
Subject: [PATCH 20/25] Add missing PopPrimitive overload for std::size_t

---
 Shared/mods/deathmatch/logic/lua/LuaBasic.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
index 29adc26e0ba..944a03e9857 100644
--- a/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
+++ b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
@@ -72,6 +72,12 @@ namespace lua
         return static_cast<unsigned int>(lua_tonumber(L, index++));
     }
 
+    template <>
+    std::size_t PopPrimitive<std::size_t>(lua_State* L, std::size_t& index)
+    {
+        return static_cast<std::size_t>(lua_tonumber(L, index++));
+    }
+
     template <>
     float PopPrimitive<float>(lua_State* L, std::size_t& index)
     {

From 7f545f7f3c23865b4f0a6c101b7f73f97c56b092 Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Fri, 3 Apr 2020 17:09:14 +0200
Subject: [PATCH 21/25] Fix windows build Add overload for std::string_view to
 PopPrimitive

---
 Shared/mods/deathmatch/logic/lua/LuaBasic.cpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
index 944a03e9857..88f14de7c1a 100644
--- a/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
+++ b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
@@ -60,6 +60,15 @@ namespace lua
         return outValue;
     }
 
+    
+    template <>
+    std::string_view PopPrimitive<std::string_view>(lua_State* L, std::size_t& index)
+    {
+        uint        uiLength = lua_strlen(L, index);
+        std::string_view outValue(lua_tostring(L, index++), uiLength);
+        return outValue;
+    }
+
     template <>
     int PopPrimitive<int>(lua_State* L, std::size_t& index)
     {
@@ -73,9 +82,9 @@ namespace lua
     }
 
     template <>
-    std::size_t PopPrimitive<std::size_t>(lua_State* L, std::size_t& index)
+    uint64_t PopPrimitive<uint64_t>(lua_State* L, std::size_t& index)
     {
-        return static_cast<std::size_t>(lua_tonumber(L, index++));
+        return static_cast<uint64_t>(lua_tonumber(L, index++));
     }
 
     template <>

From 6eeaeb31506ec352b9bf99e7ec8bece9a8521c1e Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Fri, 3 Apr 2020 19:20:13 +0200
Subject: [PATCH 22/25] Improve error messages to include function names Add
 missing if constexpr for std::string_view

---
 .../deathmatch/logic/lua/CLuaFunctionParser.h | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index a755dca6d4e..98877fc71f3 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -40,7 +40,7 @@ struct CLuaFunctionParserBase
     template <typename T>
     inline SString TypeToName()
     {
-        if constexpr (std::is_same_v<T, std::string>)
+        if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, std::string_view>)
             return "string";
         else if constexpr (std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> || std::is_same_v<T, short> ||
                            std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short>)
@@ -131,7 +131,8 @@ struct CLuaFunctionParserBase
         {
             SString strReceived = ReadParameterAsString(L, index);
             SString strExpected = TypeToName<T>();
-            SString strMessage("Expected %s at argument %d, got %s", strExpected.c_str(), index, strReceived.c_str());
+            SString strMessage("Bad argument @ '%s' [Expected %s at argument %d, got %s]", lua_tostring(L, lua_upvalueindex(1)), strExpected.c_str(), index,
+                               strReceived.c_str());
             strError = strMessage;
             return T{};
         }
@@ -173,7 +174,7 @@ struct CLuaFunctionParserBase
     {
         int iArgument = lua_type(L, index);
         // primitive types
-        if constexpr (std::is_same_v<T, std::string>)
+        if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, std::string_view>)
             return (iArgument == LUA_TSTRING || iArgument == LUA_TNUMBER);
         if constexpr (std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double> || std::is_same_v<T, short> ||
                       std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short>)
@@ -259,7 +260,7 @@ struct CLuaFunctionParserBase
             return dummy_type{};
         // primitive types are directly popped
         else if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, int> || std::is_same_v<T, short> || std::is_same_v<T, bool> ||
-                           std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short>)
+                           std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned short> || std::is_same_v<T, std::string_view>)
             return lua::PopPrimitive<T>(L, index);
         // floats/doubles may not be NaN
         else if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>)
@@ -268,6 +269,8 @@ struct CLuaFunctionParserBase
             if (std::isnan(value))
             {
                 SString strMessage("Expected number at argument %d, got NaN", index);
+                SString strMessage("Bad argument @ '%s' [Expected number at argument %d, got NaN]", lua_tostring(L, lua_upvalueindex(1)), strExpected.c_str(),
+                                   index);
                 strError = strMessage;
             }
             return value;
@@ -283,7 +286,8 @@ struct CLuaFunctionParserBase
             {
                 SString strReceived = ReadParameterAsString(L, index);
                 SString strExpected = GetEnumTypeName((T)0);
-                SString strMessage("Expected %s at argument %d, got %s", strExpected.c_str(), index, strReceived.c_str());
+                SString strMessage("Bad argument @ '%s' [Expected %s at argument %d, got %s]", lua_tostring(L, lua_upvalueindex(1)), strExpected.c_str(), index,
+                                   strReceived.c_str());
                 strError = strMessage;
                 return static_cast<T>(0);
             }
@@ -370,7 +374,8 @@ struct CLuaFunctionParserBase
             {
                 SString strReceived = isLightUserData ? GetUserDataClassName(pValue, L) : GetUserDataClassName(*(void**)pValue, L);
                 SString strExpected = GetClassTypeName((T)0);
-                SString strMessage("Expected %s at argument %d, got %s", strExpected.c_str(), index, strReceived.c_str());
+                SString strMessage("Bad argument @ '%s' [Expected %s at argument %d, got %s]", lua_tostring(L, lua_upvalueindex(1)),
+                                   strExpected.c_str(), index, strReceived.c_str());
                 strError = strMessage;
                 return nullptr;
             }
@@ -421,7 +426,7 @@ struct CLuaFunctionParser<ErrorOnFailure, ReturnOnFailure, Func> : CLuaFunctionP
         }
         catch (std::invalid_argument& e)
         {
-            // This exception can only be thrown from the called function
+            // This exception can be thrown from the called function
             // as an additional way to provide further argument errors
             strError = e.what();
         }

From 9da3e95fa624867caead3eb4099df9fe771e0f46 Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Fri, 3 Apr 2020 19:20:45 +0200
Subject: [PATCH 23/25] Improve inlining by moving some functions to LuaBasic.h

---
 Shared/mods/deathmatch/logic/lua/LuaBasic.cpp | 40 ----------------
 Shared/mods/deathmatch/logic/lua/LuaBasic.h   | 46 +++++++++++++++----
 2 files changed, 37 insertions(+), 49 deletions(-)

diff --git a/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
index 88f14de7c1a..8a99072e661 100644
--- a/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
+++ b/Shared/mods/deathmatch/logic/lua/LuaBasic.cpp
@@ -11,46 +11,6 @@
 
 namespace lua
 {
-    int Push(lua_State* L, int value)
-    {
-        lua_pushnumber(L, value);
-        return 1;
-    }
-    int Push(lua_State* L, unsigned int value)
-    {
-        lua_pushnumber(L, value);
-        return 1;
-    }
-    int Push(lua_State* L, float value)
-    {
-        lua_pushnumber(L, value);
-        return 1;
-    }
-    int Push(lua_State* L, double value)
-    {
-        lua_pushnumber(L, value);
-        return 1;
-    }
-
-    int Push(lua_State* L, bool value)
-    {
-        lua_pushboolean(L, value);
-        return 1;
-    }
-
-    int Push(lua_State* L, nullptr_t)
-    {
-        lua_pushnil(L);
-        return 1;
-    }
-
-    int Push(lua_State* L, const std::string& value)
-    {
-        lua_pushlstring(L, value.data(), value.length());
-        return 1;
-    }
-
-
     template <>
     std::string PopPrimitive<std::string>(lua_State* L, std::size_t& index)
     {
diff --git a/Shared/mods/deathmatch/logic/lua/LuaBasic.h b/Shared/mods/deathmatch/logic/lua/LuaBasic.h
index 1362467c5d7..37bd4ed0ed6 100644
--- a/Shared/mods/deathmatch/logic/lua/LuaBasic.h
+++ b/Shared/mods/deathmatch/logic/lua/LuaBasic.h
@@ -29,16 +29,44 @@ namespace lua
     // The return value must be the net amount of items pushed to the stack, which should
     // be 1 for most types (e.g. Push<int>) but may be any number for special cases
     // like tuples, in order to allow returning multiple values from a function
-    
-    int Push(lua_State* L, int val);
-    int Push(lua_State* L, const std::string& val);
-    int Push(lua_State* L, bool val);
-    int Push(lua_State* L, std::nullptr_t);
-    int Push(lua_State* L, float val);
-    int Push(lua_State* L, double val);
-    int Push(lua_State* L, unsigned int val);
-    int Push(lua_State* L, unsigned short val);
+    inline int Push(lua_State* L, int value)
+    {
+        lua_pushnumber(L, value);
+        return 1;
+    }
+    inline int Push(lua_State* L, unsigned int value)
+    {
+        lua_pushnumber(L, value);
+        return 1;
+    }
+    inline int Push(lua_State* L, float value)
+    {
+        lua_pushnumber(L, value);
+        return 1;
+    }
+    inline int Push(lua_State* L, double value)
+    {
+        lua_pushnumber(L, value);
+        return 1;
+    }
 
+    inline int Push(lua_State* L, bool value)
+    {
+        lua_pushboolean(L, value);
+        return 1;
+    }
+
+    inline int Push(lua_State* L, nullptr_t)
+    {
+        lua_pushnil(L);
+        return 1;
+    }
+
+    inline int Push(lua_State* L, const std::string& value)
+    {
+        lua_pushlstring(L, value.data(), value.length());
+        return 1;
+    }
 
     template <typename... Ts>
     int Push(lua_State* L, const std::variant<Ts...>&& val)

From 8d6f6a1e90f7b7c67f4e9726184eb45c2d07fc65 Mon Sep 17 00:00:00 2001
From: sbx320 <sbx320@sbx320.net>
Date: Fri, 3 Apr 2020 20:07:34 +0200
Subject: [PATCH 24/25] Fix typo

---
 Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
index 98877fc71f3..f126a3f49dc 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaFunctionParser.h
@@ -268,9 +268,7 @@ struct CLuaFunctionParserBase
             T value = lua::PopPrimitive<T>(L, index);
             if (std::isnan(value))
             {
-                SString strMessage("Expected number at argument %d, got NaN", index);
-                SString strMessage("Bad argument @ '%s' [Expected number at argument %d, got NaN]", lua_tostring(L, lua_upvalueindex(1)), strExpected.c_str(),
-                                   index);
+                SString strMessage("Bad argument @ '%s' [Expected number at argument %d, got NaN]", lua_tostring(L, lua_upvalueindex(1)), index);
                 strError = strMessage;
             }
             return value;

From ba6fdc198c1bf1f8d65e7a017c091ccc61a2b2b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pascal=20St=C3=BCcker?= <sbx320@sbx320.net>
Date: Sun, 5 Apr 2020 18:38:17 +0200
Subject: [PATCH 25/25] Add link to issue tracker when overload resolution
 fails

Co-Authored-By: Qais Patankar <qaisjp@gmail.com>
---
 Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h b/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h
index 7c81b2ad6e1..a8883afbd63 100644
--- a/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h
+++ b/Shared/mods/deathmatch/logic/lua/CLuaOverloadParser.h
@@ -85,6 +85,6 @@ struct CLuaOverloadParser<Func, Func2>
             throw std::invalid_argument("Overload resolution failed.");
         }
         // If this exception is thrown, there is a bug in the overload, as they are not unique
-        throw std::invalid_argument("MTA:SA Bug. Please file an issue with the parameters used for calling.");
+        throw std::invalid_argument("MTA:SA Bug. Please file an issue at https://git.io/blue-issues with the parameters used for calling.");
     }
 };