Use hard disconnect instead of ClientKick in timeout (#320)

When adding elements to a table, the .add() function does not behave as
expected in various cases, making it really shit and difficult to use.
Instead, we keep our own index and just add one by one. It works, and
it's easy to understand.

This may lead to indices which are nil, i.e. non-fully-sequential
tables, but I can't be asked to worry about it because that shouldn't be
an issue when we use .set() everywhere.

include/Client.h

@@ -128,7 +128,7 @@ private:
     std::string mRole;
     std::string mDID;
     int mID = -1;
-    std::chrono::time_point<std::chrono::high_resolution_clock> mLastPingTime;
+    std::chrono::time_point<std::chrono::high_resolution_clock> mLastPingTime = std::chrono::high_resolution_clock::now();
 };
 
 std::optional<std::weak_ptr<TClient>> GetClient(class TServer& Server, int ID);

include/Common.h

@@ -150,7 +150,7 @@ private:
     static inline std::mutex mShutdownHandlersMutex {};
     static inline std::deque<TShutdownHandler> mShutdownHandlers {};
 
-    static inline Version mVersion { 3, 4, 0 };
+    static inline Version mVersion { 3, 4, 1 };
 };
 
 void SplitString(std::string const& str, const char delim, std::vector<std::string>& out);

src/LuaAPI.cpp

@@ -60,7 +60,11 @@ std::string LuaAPI::LuaToString(const sol::object Value, size_t Indent, bool Quo
         }
     case sol::type::number: {
         std::stringstream ss;
-        ss << Value.as<float>();
+        if (Value.is<int>()) {
+            ss << Value.as<int>();
+        } else {
+            ss << Value.as<float>();
+        }
         return ss.str();
     }
     case sol::type::lua_nil:
@@ -561,7 +565,11 @@ static void JsonEncodeRecursive(nlohmann::json& json, const sol::object& left, c
         key = left.as<std::string>();
         break;
     case sol::type::number:
-        key = std::to_string(left.as<double>());
+        if (left.is<int>()) {
+            key = std::to_string(left.as<int>());
+        } else {
+            key = std::to_string(left.as<double>());
+        }
         break;
     default:
         beammp_assert_not_reachable();
@@ -589,21 +597,30 @@ static void JsonEncodeRecursive(nlohmann::json& json, const sol::object& left, c
     case sol::type::string:
         value = right.as<std::string>();
         break;
-    case sol::type::number:
-        value = right.as<double>();
+    case sol::type::number: {
+        if (right.is<int>()) {
+            value = right.as<int>();
+        } else {
+            value = right.as<double>();
+        }
         break;
+    }
     case sol::type::function:
         beammp_lua_warn("unsure what to do with function in JsonEncode, ignoring");
         return;
     case sol::type::table: {
-        bool local_is_array = true;
-        for (const auto& pair : right.as<sol::table>()) {
-            if (pair.first.get_type() != sol::type::number) {
-                local_is_array = false;
+        if (right.as<sol::table>().empty()) {
+            value = nlohmann::json::object();
+        } else {
+            bool local_is_array = true;
+            for (const auto& pair : right.as<sol::table>()) {
+                if (pair.first.get_type() != sol::type::number) {
+                    local_is_array = false;
+                }
+            }
+            for (const auto& pair : right.as<sol::table>()) {
+                JsonEncodeRecursive(value, pair.first, pair.second, local_is_array, depth + 1);
             }
-        }
-        for (const auto& pair : right.as<sol::table>()) {
-            JsonEncodeRecursive(value, pair.first, pair.second, local_is_array, depth + 1);
         }
         break;
     }
@@ -620,14 +637,18 @@ static void JsonEncodeRecursive(nlohmann::json& json, const sol::object& left, c
 std::string LuaAPI::MP::JsonEncode(const sol::table& object) {
     nlohmann::json json;
     // table
-    bool is_array = true;
-    for (const auto& pair : object.as<sol::table>()) {
-        if (pair.first.get_type() != sol::type::number) {
-            is_array = false;
+    if (object.as<sol::table>().empty()) {
+        json = nlohmann::json::object();
+    } else {
+        bool is_array = true;
+        for (const auto& pair : object.as<sol::table>()) {
+            if (pair.first.get_type() != sol::type::number) {
+                is_array = false;
+            }
+        }
+        for (const auto& entry : object) {
+            JsonEncodeRecursive(json, entry.first, entry.second, is_array);
         }
-    }
-    for (const auto& entry : object) {
-        JsonEncodeRecursive(json, entry.first, entry.second, is_array);
     }
     return json.dump();
 }

src/TLuaEngine.cpp

@@ -458,7 +458,8 @@ std::vector<sol::object> TLuaEngine::StateThreadData::JsonStringToArray(JsonStri
 
 sol::table TLuaEngine::StateThreadData::Lua_TriggerGlobalEvent(const std::string& EventName, sol::variadic_args EventArgs) {
     auto Table = mStateView.create_table();
-    for (const sol::stack_proxy& Arg : EventArgs) {
+    int i = 1;
+    for (auto Arg : EventArgs) {
         switch (Arg.get_type()) {
         case sol::type::none:
         case sol::type::userdata:
@@ -466,19 +467,20 @@ sol::table TLuaEngine::StateThreadData::Lua_TriggerGlobalEvent(const std::string
         case sol::type::thread:
         case sol::type::function:
         case sol::type::poly:
-            Table.add(BEAMMP_INTERNAL_NIL);
+            Table.set(i, BEAMMP_INTERNAL_NIL);
             beammp_warnf("Passed a value of type '{}' to TriggerGlobalEvent(\"{}\", ...). This type can not be serialized, and cannot be passed between states. It will arrive as <nil> in handlers.", sol::type_name(EventArgs.lua_state(), Arg.get_type()), EventName);
             break;
         case sol::type::lua_nil:
-            Table.add(BEAMMP_INTERNAL_NIL);
+            Table.set(i, BEAMMP_INTERNAL_NIL);
             break;
         case sol::type::string:
         case sol::type::number:
         case sol::type::boolean:
         case sol::type::table:
-            Table.add(Arg);
+            Table.set(i, Arg);
             break;
         }
+        ++i;
     }
     JsonString Str { LuaAPI::MP::JsonEncode(Table) };
     beammp_debugf("json: {}", Str.value);
@@ -520,11 +522,13 @@ sol::table TLuaEngine::StateThreadData::Lua_TriggerGlobalEvent(const std::string
             sol::state_view StateView(mState);
             sol::table Result = StateView.create_table();
             auto Vector = Self.get<std::vector<std::shared_ptr<TLuaResult>>>("ReturnValueImpl");
+            int i = 1;
             for (const auto& Value : Vector) {
                 if (!Value->Ready) {
                     return sol::lua_nil;
                 }
-                Result.add(Value->Result);
+                Result.set(i, Value->Result);
+                ++i;
             }
             return Result;
         });
@@ -534,12 +538,14 @@ sol::table TLuaEngine::StateThreadData::Lua_TriggerGlobalEvent(const std::string
 sol::table TLuaEngine::StateThreadData::Lua_TriggerLocalEvent(const std::string& EventName, sol::variadic_args EventArgs) {
     // TODO: make asynchronous?
     sol::table Result = mStateView.create_table();
+    int i = 1;
     for (const auto& Handler : mEngine->GetEventHandlersForState(EventName, mStateId)) {
         auto Fn = mStateView[Handler];
         if (Fn.valid() && Fn.get_type() == sol::type::function) {
             auto FnRet = Fn(EventArgs);
             if (FnRet.valid()) {
-                Result.add(FnRet);
+                Result.set(i, FnRet);
+                ++i;
             } else {
                 sol::error Err = FnRet;
                 beammp_lua_error(std::string("TriggerLocalEvent: ") + Err.what());

src/TPPSMonitor.cpp

@@ -76,7 +76,7 @@ void TPPSMonitor::operator()() {
             return true;
         });
         for (auto& ClientToKick : TimedOutClients) {
-            Network().ClientKick(*ClientToKick, "Timeout (no ping for way too long)");
+            ClientToKick->Disconnect("Timeout");
         }
         TimedOutClients.clear();
         if (C == 0 || mInternalPPS == 0) {

test/Server/JsonTests/main.lua

@@ -0,0 +1,66 @@
+local function assert_eq(x, y, explain)
+	if x ~= y then
+		print("assertion '"..explain.."' failed:\n\tgot:\t", x, "\n\texpected:", y)
+	end
+end
+
+---@param o1 any|table First object to compare
+---@param o2 any|table Second object to compare
+---@param ignore_mt boolean True to ignore metatables (a recursive function to tests tables inside tables)
+function equals(o1, o2, ignore_mt)
+    if o1 == o2 then return true end
+    local o1Type = type(o1)
+    local o2Type = type(o2)
+    if o1Type ~= o2Type then return false end
+    if o1Type ~= 'table' then return false end
+
+    if not ignore_mt then
+        local mt1 = getmetatable(o1)
+        if mt1 and mt1.__eq then
+            --compare using built in method
+            return o1 == o2
+        end
+    end
+
+    local keySet = {}
+
+    for key1, value1 in pairs(o1) do
+        local value2 = o2[key1]
+        if value2 == nil or equals(value1, value2, ignore_mt) == false then
+            return false
+        end
+        keySet[key1] = true
+    end
+
+    for key2, _ in pairs(o2) do
+        if not keySet[key2] then return false end
+    end
+    return true
+end
+
+
+local function assert_table_eq(x, y, explain)
+	if not equals(x, y, true) then
+		print("assertion '"..explain.."' failed:\n\tgot:\t", x, "\n\texpected:", y)
+	end
+end
+
+assert_eq(Util.JsonEncode({1, 2, 3, 4, 5}), "[1,2,3,4,5]", "table to array")
+assert_eq(Util.JsonEncode({"a", 1, 2, 3, 4, 5}), '["a",1,2,3,4,5]', "table to array")
+assert_eq(Util.JsonEncode({"a", 1, 2.0, 3, 4, 5}), '["a",1,2.0,3,4,5]', "table to array")
+assert_eq(Util.JsonEncode({hello="world", john={doe = 1, jane = 2.5, mike = {2, 3, 4}}, dave={}}), '{"dave":{},"hello":"world","john":{"doe":1,"jane":2.5,"mike":[2,3,4]}}', "table to obj")
+assert_eq(Util.JsonEncode({a = nil}), "{}", "null obj member")
+assert_eq(Util.JsonEncode({1, nil, 3}), "[1,3]", "null array member")
+assert_eq(Util.JsonEncode({}), "{}", "empty array/table")
+assert_eq(Util.JsonEncode({1234}), "[1234]", "int")
+assert_eq(Util.JsonEncode({1234.0}), "[1234.0]", "double")
+
+assert_table_eq(Util.JsonDecode("[1,2,3,4,5]"), {1, 2, 3, 4, 5}, "decode table to array")
+assert_table_eq(Util.JsonDecode('["a",1,2,3,4,5]'), {"a", 1, 2, 3, 4, 5}, "decode table to array")
+assert_table_eq(Util.JsonDecode('["a",1,2.0,3,4,5]'), {"a", 1, 2.0, 3, 4, 5}, "decode table to array")
+assert_table_eq(Util.JsonDecode('{"dave":{},"hello":"world","john":{"doe":1,"jane":2.5,"mike":[2,3,4]}}'), {hello="world", john={doe = 1, jane = 2.5, mike = {2, 3, 4}}, dave={}}, "decode table to obj")
+assert_table_eq(Util.JsonDecode("{}"), {a = nil}, "decode null obj member")
+assert_table_eq(Util.JsonDecode("[1,3]"), {1, 3}, "decode null array member")
+assert_table_eq(Util.JsonDecode("{}"), {}, "decode empty array/table")
+assert_table_eq(Util.JsonDecode("[1234]"), {1234}, "decode int")
+assert_table_eq(Util.JsonDecode("[1234.0]"), {1234.0}, "decode double")