Create pull_request_template.md (#262)

Depends on #260

.github/FUNDING.yml

@@ -1 +0,0 @@
-patreon: BeamMP

.github/pull_request_template.md

@@ -0,0 +1,7 @@
+<!-- 
+The following is a disclaimer. Since all content in the repository is licensed under AGPL-3.0, 
+the terms of the license apply to your contributions as well.
+Please make sure that all code or other content you're contributing is your own, or is licensed under
+an AGPL-3.0 compatible license.
+-->
+These contributions are my own and I own all rights to them. I understand and agree that these contributions are licensed under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html).

.github/workflows/linux.yml

@@ -1,11 +1,7 @@
 name: Linux
 
-on:
-  push:
-    branches:
-      - 'develop'
-      - 'minor'
-  pull_request:
+on: [push]
+
 
 env: 
   VCPKG_BINARY_SOURCES: "clear;x-gha,readwrite"

.github/workflows/windows.yml

@@ -1,11 +1,6 @@
 name: Windows
 
-on:
-  push:
-    branches:
-      - 'develop'
-      - 'minor'
-  pull_request:
+on: [push]
 
 env:
   VCPKG_DEFAULT_TRIPLET: x64-windows-static

CMakeLists.txt

@@ -49,7 +49,6 @@ set(PRJ_HEADERS
     include/TServer.h
     include/VehicleData.h
     include/Env.h
-    include/Profiling.h
 )
 # add all source files (.cpp) to this, except the one with main()
 set(PRJ_SOURCES
@@ -73,7 +72,6 @@ set(PRJ_SOURCES
     src/TServer.cpp
     src/VehicleData.cpp
     src/Env.cpp
-    src/Profiling.cpp
 )
 
 find_package(Lua REQUIRED)
@@ -143,7 +141,6 @@ endif(UNIX)
 
 if (WIN32)
     add_compile_options("-D_WIN32_WINNT=0x0601")
-    add_compile_options("/bigobj")
 endif(WIN32)
 
 
@@ -197,7 +194,6 @@ target_compile_definitions(${PROJECT_NAME} PRIVATE ${PRJ_DEFINITIONS} ${PRJ_WARN
 )
 
 if(MSVC)
-    target_compile_options(${PROJECT_NAME} PUBLIC "/bigobj")
     target_link_options(${PROJECT_NAME} PRIVATE "/SUBSYSTEM:CONSOLE")
 endif(MSVC)
 

CONTRIBUTING.md

@@ -53,28 +53,11 @@ Do **NOT** pull with merge. This is the default git behavior for `git pull`, but
 
 The only acceptable merge commits are those which actually merge functionally different branches into each other, for example for merging one feature branch into another.
 
-## Workflow
-
-### Making an issue and fixing it
-
-1. Create an issue detailing the feature or bug.
-2. Assign a milestone to the issue, or wait for a maintainer to add a milestone to your issue.
-3. Fork the repository and base your work on the branch mentioned in the milestone attached to your issue (e.g. `v3.0.0 (develop)` -> `develop`).
-4. Program your feature or bug fix.
-5. Open a PR that references the issue by number in the format: `#12345`.
-6. Someone will review your PR and merge it, or ask for changes.
-
-### Fixing an existing issue
-
-1. Fork the repository and base your work on the branch mentioned in the milestone attached to your issue (e.g. `v3.0.0 (develop)` -> `develop`).
-2. Program your feature or bug fix.
-3. Open a PR that references the issue by number in the format: `#12345`.
-4. Someone will review your PR and merge it, or ask for changes.
-
 ## Branches
 
-- `minor`: Minor releases, like `v1.2.3` -> `v1.3.0` or `v1.2.3` -> `v1.2.4`.
-- `develop`: Major releases, like `v1.2.3` -> `v2.0.0`, and larger feature/minor releases.
+### Which branch should I base my work on?
+
+Each *feature* or *bug-fix* is implemented on a new Git branch, branched off of the branch it should be based on. The `master` branch is usually stable, so we don't do development on it. It is always a safe bet to branch off of `master`, but it may be more work to merge later. Branches to base your work on are usually branches like `rc-v3.3.0`, when the latest public version is `3.2.0`, for example. These can often be found in Pull-Requests on GitHub which are tagged `Release Candidate`.
 
 ## Unit tests & CI/CD
 

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::high_resolution_clock::now();
+    std::chrono::time_point<std::chrono::high_resolution_clock> mLastPingTime;
 };
 
 std::optional<std::weak_ptr<TClient>> GetClient(class TServer& Server, int ID);

include/Common.h

@@ -106,6 +106,8 @@ public:
     static std::vector<std::string> GetBackendUrlsInOrder() {
         return {
             "backend.beammp.com",
+            "backup1.beammp.com",
+            "backup2.beammp.com"
         };
     }
 
@@ -150,7 +152,7 @@ private:
     static inline std::mutex mShutdownHandlersMutex {};
     static inline std::deque<TShutdownHandler> mShutdownHandlers {};
 
-    static inline Version mVersion { 3, 4, 1 };
+    static inline Version mVersion { 3, 2, 2 };
 };
 
 void SplitString(std::string const& str, const char delim, std::vector<std::string>& out);
@@ -212,10 +214,6 @@ void RegisterThread(const std::string& str);
         do {                                                                                  \
             Application::Console().Write(_this_location + std::string("[LUA ERROR] ") + (x)); \
         } while (false)
-    #define beammp_lua_log(level, plugin, x)                                                               \
-        do {                                                                                 \
-            Application::Console().Write(_this_location + fmt::format("[{}] [{}] ", plugin, level) + (x)); \
-        } while (false)
     #define beammp_lua_warn(x)                                                               \
         do {                                                                                 \
             Application::Console().Write(_this_location + std::string("[LUA WARN] ") + (x)); \
@@ -271,7 +269,6 @@ void RegisterThread(const std::string& str);
     #define beammp_tracef(...) beammp_trace(fmt::format(__VA_ARGS__))
     #define beammp_lua_errorf(...) beammp_lua_error(fmt::format(__VA_ARGS__))
     #define beammp_lua_warnf(...) beammp_lua_warn(fmt::format(__VA_ARGS__))
-    #define beammp_lua_log(level, plugin, x) /* x */
 
 #endif // DOCTEST_CONFIG_DISABLE
 

include/Env.h

@@ -25,8 +25,6 @@ namespace Env {
 enum class Key {
     // provider settings
     PROVIDER_UPDATE_MESSAGE,
-    PROVIDER_DISABLE_CONFIG,
-    PROVIDER_PORT_ENV,
 };
 
 std::optional<std::string> Get(Key key);

include/Profiling.h

@@ -1,72 +0,0 @@
-#pragma once
-
-#include <boost/thread/synchronized_value.hpp>
-#include <chrono>
-#include <cstddef>
-#include <limits>
-#include <unordered_map>
-
-namespace prof {
-
-using Duration = std::chrono::duration<double, std::milli>;
-using TimePoint = std::chrono::high_resolution_clock::time_point;
-
-/// Returns the current time.
-TimePoint now();
-
-/// Returns a sub-millisecond resolution duration between start and end.
-Duration duration(const TimePoint& start, const TimePoint& end);
-
-struct Stats {
-    double mean;
-    double stdev;
-    double min;
-    double max;
-    size_t n;
-};
-
-/// Calculates and stores the moving average over K samples of execution time data
-/// for some single unit of code. Threadsafe.
-struct UnitExecutionTime {
-    UnitExecutionTime();
-
-    /// Adds a sample to the collection, overriding the oldest sample if needed.
-    void add_sample(const Duration& dur);
-
-    /// Calculates the mean duration over the `measurement_count()` measurements,
-    /// as well as the standard deviation.
-    Stats stats() const;
-
-    /// Returns the number of elements the moving average is calculated over.
-    size_t measurement_count() const;
-
-private:
-    mutable std::mutex m_mtx {};
-    size_t m_total_calls {};
-    double m_sum {};
-    // sum of measurements squared (for running stdev)
-    double m_measurement_sqr_sum {};
-    double m_min { std::numeric_limits<double>::max() };
-    double m_max { std::numeric_limits<double>::min() };
-};
-
-/// Holds profiles for multiple units by name. Threadsafe.
-struct UnitProfileCollection {
-    /// Adds a sample to the collection, overriding the oldest sample if needed.
-    void add_sample(const std::string& unit, const Duration& duration);
-
-    /// Calculates the mean duration over the `measurement_count()` measurements,
-    /// as well as the standard deviation.
-    Stats stats(const std::string& unit);
-
-    /// Returns the number of elements the moving average is calculated over.
-    size_t measurement_count(const std::string& unit);
-
-    /// Returns the stats for all stored units.
-    std::unordered_map<std::string, Stats> all_stats();
-
-private:
-    boost::synchronized_value<std::unordered_map<std::string, UnitExecutionTime>> m_map;
-};
-
-}

include/TConfig.h

@@ -35,11 +35,11 @@ public:
     [[nodiscard]] bool Failed() const { return mFailed; }
 
     void FlushToFile();
-    void PrintDebug();
 
 private:
     void CreateConfigFile();
     void ParseFromFile(std::string_view name);
+    void PrintDebug();
     void TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, const std::string_view& Env, std::string& OutValue);
     void TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, const std::string_view& Env, bool& OutValue);
     void TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, const std::string_view& Env, int& OutValue);
@@ -48,6 +48,5 @@ private:
     std::string TagsAsPrettyArray() const;
     bool IsDefault();
     bool mFailed { false };
-    bool mDisableConfig { false };
     std::string mConfigFileName;
 };

include/TConsole.h

@@ -58,7 +58,6 @@ private:
     void Command_Status(const std::string& cmd, const std::vector<std::string>& args);
     void Command_Settings(const std::string& cmd, const std::vector<std::string>& args);
     void Command_Clear(const std::string&, const std::vector<std::string>& args);
-    void Command_Version(const std::string& cmd, const std::vector<std::string>& args);
 
     void Command_Say(const std::string& FullCommand);
     bool EnsureArgsCount(const std::vector<std::string>& args, size_t n);
@@ -76,7 +75,6 @@ private:
         { "settings", [this](const auto& a, const auto& b) { Command_Settings(a, b); } },
         { "clear", [this](const auto& a, const auto& b) { Command_Clear(a, b); } },
         { "say", [this](const auto&, const auto&) { Command_Say(""); } }, // shouldn't actually be called
-        { "version", [this](const auto& a, const auto& b) { Command_Version(a, b); } },
     };
 
     std::unique_ptr<Commandline> mCommandline { nullptr };

include/TLuaEngine.h

@@ -18,11 +18,9 @@
 
 #pragma once
 
-#include "Profiling.h"
 #include "TNetwork.h"
 #include "TServer.h"
 #include <any>
-#include <chrono>
 #include <condition_variable>
 #include <filesystem>
 #include <initializer_list>
@@ -30,7 +28,6 @@
 #include <lua.hpp>
 #include <memory>
 #include <mutex>
-#include <nlohmann/json.hpp>
 #include <queue>
 #include <random>
 #include <set>
@@ -39,34 +36,19 @@
 #include <vector>
 
 #define SOL_ALL_SAFETIES_ON 1
-#define SOL_USER_C_ASSERT SOL_ON
-#define SOL_C_ASSERT(...) \
-    beammp_lua_errorf("SOL2 assertion failure: Assertion `{}` failed in {}:{}. This *should* be a fatal error, but BeamMP Server overrides it to not be fatal. This may cause the Lua Engine to crash, or cause other issues.", #__VA_ARGS__, __FILE__, __LINE__)
 #include <sol/sol.hpp>
 
-struct JsonString {
-    std::string value;
-};
-
-// value used to keep nils in a table or array, across serialization boundaries like
-// JsonEncode, so that the nil stays at the same index and isn't treated like a special
-// value (e.g. one that can be ignored or discarded).
-const inline std::string BEAMMP_INTERNAL_NIL = "BEAMMP_SERVER_INTERNAL_NIL_VALUE";
-
 using TLuaStateId = std::string;
 namespace fs = std::filesystem;
 /**
  * std::variant means, that TLuaArgTypes may be one of the Types listed as template args
  */
-using TLuaValue = std::variant<std::string, int, JsonString, bool, std::unordered_map<std::string, std::string>, float>;
-enum TLuaType {
-    String = 0,
-    Int = 1,
-    Json = 2,
-    Bool = 3,
-    StringStringMap = 4,
-    Float = 5,
-};
+using TLuaArgTypes = std::variant<std::string, int, sol::variadic_args, bool, std::unordered_map<std::string, std::string>>;
+static constexpr size_t TLuaArgTypes_String = 0;
+static constexpr size_t TLuaArgTypes_Int = 1;
+static constexpr size_t TLuaArgTypes_VariadicArgs = 2;
+static constexpr size_t TLuaArgTypes_Bool = 3;
+static constexpr size_t TLuaArgTypes_StringStringMap = 4;
 
 class TLuaPlugin;
 
@@ -114,7 +96,7 @@ public:
     struct QueuedFunction {
         std::string FunctionName;
         std::shared_ptr<TLuaResult> Result;
-        std::vector<TLuaValue> Args;
+        std::vector<TLuaArgTypes> Args;
         std::string EventName; // optional, may be empty
     };
 
@@ -167,7 +149,7 @@ public:
     void ReportErrors(const std::vector<std::shared_ptr<TLuaResult>>& Results);
     bool HasState(TLuaStateId StateId);
     [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueScript(TLuaStateId StateID, const TLuaChunk& Script);
-    [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueFunctionCall(TLuaStateId StateID, const std::string& FunctionName, const std::vector<TLuaValue>& Args);
+    [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueFunctionCall(TLuaStateId StateID, const std::string& FunctionName, const std::vector<TLuaArgTypes>& Args);
     void EnsureStateExists(TLuaStateId StateId, const std::string& Name, bool DontCallOnInit = false);
     void RegisterEvent(const std::string& EventName, TLuaStateId StateId, const std::string& FunctionName);
     /**
@@ -187,7 +169,7 @@ public:
         }
 
         std::vector<std::shared_ptr<TLuaResult>> Results;
-        std::vector<TLuaValue> Arguments { TLuaValue { std::forward<ArgsT>(Args) }... };
+        std::vector<TLuaArgTypes> Arguments { TLuaArgTypes { std::forward<ArgsT>(Args) }... };
 
         for (const auto& Event : mLuaEvents.at(EventName)) {
             for (const auto& Function : Event.second) {
@@ -206,7 +188,7 @@ public:
             return {};
         }
         std::vector<std::shared_ptr<TLuaResult>> Results;
-        std::vector<TLuaValue> Arguments { TLuaValue { std::forward<ArgsT>(Args) }... };
+        std::vector<TLuaArgTypes> Arguments { TLuaArgTypes { std::forward<ArgsT>(Args) }... };
         const auto Handlers = GetEventHandlersForState(EventName, StateId);
         for (const auto& Handler : Handlers) {
             Results.push_back(EnqueueFunctionCall(StateId, Handler, Arguments));
@@ -243,8 +225,8 @@ private:
         StateThreadData(const StateThreadData&) = delete;
         virtual ~StateThreadData() noexcept { beammp_debug("\"" + mStateId + "\" destroyed"); }
         [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueScript(const TLuaChunk& Script);
-        [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueFunctionCall(const std::string& FunctionName, const std::vector<TLuaValue>& Args);
-        [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueFunctionCallFromCustomEvent(const std::string& FunctionName, const std::vector<TLuaValue>& Args, const std::string& EventName, CallStrategy Strategy);
+        [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueFunctionCall(const std::string& FunctionName, const std::vector<TLuaArgTypes>& Args);
+        [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueFunctionCallFromCustomEvent(const std::string& FunctionName, const std::vector<TLuaArgTypes>& Args, const std::string& EventName, CallStrategy Strategy);
         void RegisterEvent(const std::string& EventName, const std::string& FunctionName);
         void AddPath(const fs::path& Path); // to be added to path and cpath
         void operator()() override;
@@ -271,9 +253,6 @@ private:
         sol::table Lua_FS_ListFiles(const std::string& Path);
         sol::table Lua_FS_ListDirectories(const std::string& Path);
 
-        prof::UnitProfileCollection mProfile {};
-        std::unordered_map<std::string, prof::TimePoint> mProfileStarts;
-
         std::string mName;
         TLuaStateId mStateId;
         lua_State* mState;
@@ -289,7 +268,6 @@ private:
         std::recursive_mutex mPathsMutex;
         std::mt19937 mMersenneTwister;
         std::uniform_real_distribution<double> mUniformRealDistribution01;
-        std::vector<sol::object> JsonStringToArray(JsonString Str);
     };
 
     struct TimedEvent {

include/TNetwork.h

@@ -55,7 +55,6 @@ private:
     TResourceManager& mResourceManager;
     std::thread mUDPThread;
     std::thread mTCPThread;
-    std::mutex mOpenIDMutex;
 
     std::vector<uint8_t> UDPRcvFromClient(ip::udp::endpoint& ClientEndpoint);
     void HandleDownload(TConnection&& TCPSock);

src/Client.cpp

@@ -121,14 +121,6 @@ void TClient::SetCarData(int Ident, const std::string& Data) {
 }
 
 int TClient::GetCarCount() const {
-    // mVechileData holds both unicycle and cars which both count towards the maximum car count
-    // spawning a unicycle meant reaching the max, hence being unable to spawn car. this dirty fixes the problem for now.
-    std::unique_lock lock(mVehicleDataMutex);
-    for (auto& v : mVehicleData) {
-        if (v.ID() == mUnicycleID) {
-            return int(mVehicleData.size() - 1);
-        }
-    }
     return int(mVehicleData.size());
 }
 

src/Common.cpp

@@ -222,7 +222,7 @@ void Application::CheckForUpdates() {
             auto RemoteVersion = Version(VersionStrToInts(Response));
             if (IsOutdated(MyVersion, RemoteVersion)) {
                 std::string RealVersionString = std::string("v") + RemoteVersion.AsString();
-                const std::string DefaultUpdateMsg = "NEW VERSION IS OUT! Please update to the new version ({}) of the BeamMP-Server! Download it here: https://beammp.com/! For a guide on how to update, visit: https://docs.beammp.com/server/server-maintenance/#updating-the-server";
+                const std::string DefaultUpdateMsg = "NEW VERSION IS OUT! Please update to the new version ({}) of the BeamMP-Server! Download it here: https://beammp.com/! For a guide on how to update, visit: https://wiki.beammp.com/en/home/server-maintenance#updating-the-server";
                 auto UpdateMsg = Env::Get(Env::Key::PROVIDER_UPDATE_MESSAGE).value_or(DefaultUpdateMsg);
                 UpdateMsg = fmt::vformat(std::string_view(UpdateMsg), fmt::make_format_args(RealVersionString));
                 beammp_warnf("{}{}{}", ANSI_YELLOW_BOLD, UpdateMsg, ANSI_RESET);

src/Env.cpp

@@ -33,12 +33,6 @@ std::string_view Env::ToString(Env::Key key) {
     case Key::PROVIDER_UPDATE_MESSAGE:
         return "BEAMMP_PROVIDER_UPDATE_MESSAGE";
         break;
-    case Key::PROVIDER_DISABLE_CONFIG:
-        return "BEAMMP_PROVIDER_DISABLE_CONFIG";
-        break;
-    case Key::PROVIDER_PORT_ENV:
-        return "BEAMMP_PROVIDER_PORT_ENV";
-        break;
     }
     return "";
 }

src/LuaAPI.cpp

@@ -60,11 +60,7 @@ std::string LuaAPI::LuaToString(const sol::object Value, size_t Indent, bool Quo
         }
     case sol::type::number: {
         std::stringstream ss;
-        if (Value.is<int>()) {
-            ss << Value.as<int>();
-        } else {
-            ss << Value.as<float>();
-        }
+        ss << Value.as<float>();
         return ss.str();
     }
     case sol::type::lua_nil:
@@ -565,11 +561,7 @@ static void JsonEncodeRecursive(nlohmann::json& json, const sol::object& left, c
         key = left.as<std::string>();
         break;
     case sol::type::number:
-        if (left.is<int>()) {
-            key = std::to_string(left.as<int>());
-        } else {
-            key = std::to_string(left.as<double>());
-        }
+        key = std::to_string(left.as<double>());
         break;
     default:
         beammp_assert_not_reachable();
@@ -597,31 +589,22 @@ 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: {
-        if (right.is<int>()) {
-            value = right.as<int>();
-        } else {
-            value = right.as<double>();
-        }
+    case sol::type::number:
+        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: {
-        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);
+        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);
+        }
         break;
     }
     default:
@@ -637,19 +620,15 @@ static void JsonEncodeRecursive(nlohmann::json& json, const sol::object& left, c
 std::string LuaAPI::MP::JsonEncode(const sol::table& object) {
     nlohmann::json json;
     // table
-    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);
+    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);
+    }
     return json.dump();
 }
 

src/Profiling.cpp

@@ -1,60 +0,0 @@
-#include "Profiling.h"
-#include <limits>
-
-prof::Duration prof::duration(const TimePoint& start, const TimePoint& end) {
-    return end - start;
-}
-prof::TimePoint prof::now() {
-    return std::chrono::high_resolution_clock::now();
-}
-prof::Stats prof::UnitProfileCollection::stats(const std::string& unit) {
-    return m_map->operator[](unit).stats();
-}
-
-size_t prof::UnitProfileCollection::measurement_count(const std::string& unit) {
-    return m_map->operator[](unit).measurement_count();
-}
-
-void prof::UnitProfileCollection::add_sample(const std::string& unit, const Duration& duration) {
-    m_map->operator[](unit).add_sample(duration);
-}
-
-prof::Stats prof::UnitExecutionTime::stats() const {
-    std::unique_lock lock(m_mtx);
-    Stats result {};
-    // calculate sum
-    result.n = m_total_calls;
-    result.max = m_min;
-    result.min = m_max;
-    // calculate mean: mean = sum_x / n
-    result.mean = m_sum / double(m_total_calls);
-    // calculate stdev: stdev = sqrt((sum_x2 / n) - (mean * mean))
-    result.stdev = std::sqrt((m_measurement_sqr_sum / double(result.n)) - (result.mean * result.mean));
-    return result;
-}
-
-void prof::UnitExecutionTime::add_sample(const Duration& dur) {
-    std::unique_lock lock(m_mtx);
-    m_sum += dur.count();
-    m_measurement_sqr_sum += dur.count() * dur.count();
-    m_min = std::min(dur.count(), m_min);
-    m_max = std::max(dur.count(), m_max);
-    ++m_total_calls;
-}
-
-prof::UnitExecutionTime::UnitExecutionTime() {
-}
-
-std::unordered_map<std::string, prof::Stats> prof::UnitProfileCollection::all_stats() {
-    auto map = m_map.synchronize();
-    std::unordered_map<std::string, Stats> result {};
-    for (const auto& [name, time] : *map) {
-        result[name] = time.stats();
-    }
-    return result;
-}
-size_t prof::UnitExecutionTime::measurement_count() const {
-    std::unique_lock lock(m_mtx);
-    return m_total_calls;
-}
-

src/TConfig.cpp

@@ -18,7 +18,6 @@
 
 #include "Common.h"
 
-#include "Env.h"
 #include "TConfig.h"
 #include <cstdlib>
 #include <fstream>
@@ -88,9 +87,7 @@ TEST_CASE("TConfig::TConfig") {
 TConfig::TConfig(const std::string& ConfigFileName)
     : mConfigFileName(ConfigFileName) {
     Application::SetSubsystemStatus("Config", Application::Status::Starting);
-    auto DisableConfig = Env::Get(Env::Key::PROVIDER_DISABLE_CONFIG).value_or("false");
-    mDisableConfig = DisableConfig == "true" || DisableConfig == "1";
-    if (!mDisableConfig && (!fs::exists(mConfigFileName) || !fs::is_regular_file(mConfigFileName))) {
+    if (!fs::exists(mConfigFileName) || !fs::is_regular_file(mConfigFileName)) {
         beammp_info("No config file found! Generating one...");
         CreateConfigFile();
     }
@@ -146,7 +143,7 @@ void TConfig::FlushToFile() {
     SetComment(data["Misc"][StrSendErrorsMessageEnabled.data()].comments(), " You can turn on/off the SendErrors message you get on startup here");
     std::stringstream Ss;
     Ss << "# This is the BeamMP-Server config file.\n"
-          "# Help & Documentation: `https://docs.beammp.com/server/server-maintenance/`\n"
+          "# Help & Documentation: `https://wiki.beammp.com/en/home/server-maintenance`\n"
           "# IMPORTANT: Fill in the AuthKey with the key you got from `https://keymaster.beammp.com/` on the left under \"Keys\"\n"
        << data;
     auto File = std::fopen(mConfigFileName.c_str(), "w+");
@@ -164,9 +161,7 @@ void TConfig::FlushToFile() {
 
 void TConfig::CreateConfigFile() {
     // build from old config Server.cfg
-    if (mDisableConfig) {
-        return;
-    }
+
     try {
         if (fs::exists("Server.cfg")) {
             // parse it (this is weird and bad and should be removed in some future version)
@@ -186,9 +181,6 @@ void TConfig::TryReadValue(toml::value& Table, const std::string& Category, cons
             return;
         }
     }
-    if (mDisableConfig) {
-        return;
-    }
     if (Table[Category.c_str()][Key.data()].is_string()) {
         OutValue = Table[Category.c_str()][Key.data()].as_string();
     }
@@ -202,9 +194,6 @@ void TConfig::TryReadValue(toml::value& Table, const std::string& Category, cons
             return;
         }
     }
-    if (mDisableConfig) {
-        return;
-    }
     if (Table[Category.c_str()][Key.data()].is_boolean()) {
         OutValue = Table[Category.c_str()][Key.data()].as_boolean();
     }
@@ -217,9 +206,6 @@ void TConfig::TryReadValue(toml::value& Table, const std::string& Category, cons
             return;
         }
     }
-    if (mDisableConfig) {
-        return;
-    }
     if (Table[Category.c_str()][Key.data()].is_integer()) {
         OutValue = int(Table[Category.c_str()][Key.data()].as_integer());
     }
@@ -227,18 +213,11 @@ void TConfig::TryReadValue(toml::value& Table, const std::string& Category, cons
 
 void TConfig::ParseFromFile(std::string_view name) {
     try {
-        toml::value data {};
-        if (!mDisableConfig) {
-            data = toml::parse<toml::preserve_comments>(name.data());
-        }
+        toml::value data = toml::parse<toml::preserve_comments>(name.data());
         // GENERAL
         TryReadValue(data, "General", StrDebug, EnvStrDebug, Application::Settings.DebugModeEnabled);
         TryReadValue(data, "General", StrPrivate, EnvStrPrivate, Application::Settings.Private);
-        if (Env::Get(Env::Key::PROVIDER_PORT_ENV).has_value()) {
-            TryReadValue(data, "General", StrPort, Env::Get(Env::Key::PROVIDER_PORT_ENV).value(), Application::Settings.Port);
-        } else {
-            TryReadValue(data, "General", StrPort, EnvStrPort, Application::Settings.Port);
-        }
+        TryReadValue(data, "General", StrPort, EnvStrPort, Application::Settings.Port);
         TryReadValue(data, "General", StrMaxCars, EnvStrMaxCars, Application::Settings.MaxCars);
         TryReadValue(data, "General", StrMaxPlayers, EnvStrMaxPlayers, Application::Settings.MaxPlayers);
         TryReadValue(data, "General", StrMap, EnvStrMap, Application::Settings.MapName);
@@ -259,18 +238,13 @@ void TConfig::ParseFromFile(std::string_view name) {
         Application::SetSubsystemStatus("Config", Application::Status::Bad);
         return;
     }
+    PrintDebug();
 
     // Update in any case
-    if (!mDisableConfig) {
-        FlushToFile();
-    }
+    FlushToFile();
     // all good so far, let's check if there's a key
     if (Application::Settings.Key.empty()) {
-        if (mDisableConfig) {
-            beammp_error("No AuthKey specified in the environment.");
-        } else {
-            beammp_error("No AuthKey specified in the \"" + std::string(mConfigFileName) + "\" file. Please get an AuthKey, enter it into the config file, and restart this server.");
-        }
+        beammp_error("No AuthKey specified in the \"" + std::string(mConfigFileName) + "\" file. Please get an AuthKey, enter it into the config file, and restart this server.");
         Application::SetSubsystemStatus("Config", Application::Status::Bad);
         mFailed = true;
         return;
@@ -282,9 +256,6 @@ void TConfig::ParseFromFile(std::string_view name) {
 }
 
 void TConfig::PrintDebug() {
-    if (mDisableConfig) {
-        beammp_debug("Provider turned off the generation and parsing of the ServerConfig.toml");
-    }
     beammp_debug(std::string(StrDebug) + ": " + std::string(Application::Settings.DebugModeEnabled ? "true" : "false"));
     beammp_debug(std::string(StrPrivate) + ": " + std::string(Application::Settings.Private ? "true" : "false"));
     beammp_debug(std::string(StrPort) + ": " + std::to_string(Application::Settings.Port));

src/TConsole.cpp

@@ -247,8 +247,7 @@ void TConsole::Command_Help(const std::string&, const std::vector<std::string>&
         lua [state id]          switches to lua, optionally into a specific state id's lua
         settings [command]      sets or gets settings for the server, run `settings help` for more info
         status                  how the server is doing and what it's up to
-        clear                   clears the console window
-        version                 displays the server version)";
+        clear                   clears the console window)";
     Application::Console().WriteRaw("BeamMP-Server Console: " + std::string(sHelpString));
 }
 
@@ -268,14 +267,6 @@ void TConsole::Command_Clear(const std::string&, const std::vector<std::string>&
     mCommandline->write("\x1b[;H\x1b[2J");
 }
 
-void TConsole::Command_Version(const std::string& cmd, const std::vector<std::string>& args) {
-    if (!EnsureArgsCount(args, 0)) {
-        return;
-    }
-
-    Application::Console().WriteRaw("Current version: v" + Application::ServerVersionString());
-}
-
 void TConsole::Command_Kick(const std::string&, const std::vector<std::string>& args) {
     if (!EnsureArgsCount(args, 1, size_t(-1))) {
         return;

src/TLuaEngine.cpp

@@ -18,17 +18,14 @@
 
 #include "TLuaEngine.h"
 #include "Client.h"
-#include "Common.h"
 #include "CustomAssert.h"
 #include "Http.h"
 #include "LuaAPI.h"
-#include "Profiling.h"
 #include "TLuaPlugin.h"
 #include "sol/object.hpp"
 
 #include <chrono>
 #include <condition_variable>
-#include <fmt/core.h>
 #include <nlohmann/json.hpp>
 #include <random>
 #include <thread>
@@ -353,7 +350,7 @@ std::shared_ptr<TLuaResult> TLuaEngine::EnqueueScript(TLuaStateId StateID, const
     return mLuaStates.at(StateID)->EnqueueScript(Script);
 }
 
-std::shared_ptr<TLuaResult> TLuaEngine::EnqueueFunctionCall(TLuaStateId StateID, const std::string& FunctionName, const std::vector<TLuaValue>& Args) {
+std::shared_ptr<TLuaResult> TLuaEngine::EnqueueFunctionCall(TLuaStateId StateID, const std::string& FunctionName, const std::vector<TLuaArgTypes>& Args) {
     std::unique_lock Lock(mLuaStatesMutex);
     return mLuaStates.at(StateID)->EnqueueFunctionCall(FunctionName, Args);
 }
@@ -362,30 +359,17 @@ void TLuaEngine::CollectAndInitPlugins() {
     if (!fs::exists(mResourceServerPath)) {
         fs::create_directories(mResourceServerPath);
     }
-
-    std::vector<fs::path> PluginsEntries;
-    for (const auto& Entry : fs::directory_iterator(mResourceServerPath)) {
-        if (Entry.is_directory()) {
-            PluginsEntries.push_back(Entry);
+    for (const auto& Dir : fs::directory_iterator(mResourceServerPath)) {
+        auto Path = Dir.path();
+        Path = fs::relative(Path);
+        if (!Dir.is_directory()) {
+            beammp_error("\"" + Dir.path().string() + "\" is not a directory, skipping");
         } else {
-            beammp_error("\"" + Entry.path().string() + "\" is not a directory, skipping");
+            TLuaPluginConfig Config { Path.stem().string() };
+            FindAndParseConfig(Path, Config);
+            InitializePlugin(Path, Config);
         }
     }
-
-    std::sort(PluginsEntries.begin(), PluginsEntries.end(), [](const fs::path& first, const fs::path& second) {
-        auto firstStr = first.string();
-        auto secondStr = second.string();
-        std::transform(firstStr.begin(), firstStr.end(), firstStr.begin(), ::tolower);
-        std::transform(secondStr.begin(), secondStr.end(), secondStr.begin(), ::tolower);
-        return firstStr < secondStr;
-    });
-
-    for (const auto& Dir : PluginsEntries) {
-        auto Path = fs::relative(Dir);
-        TLuaPluginConfig Config { Path.stem().string() };
-        FindAndParseConfig(Path, Config);
-        InitializePlugin(Path, Config);
-    }
 }
 
 void TLuaEngine::InitializePlugin(const fs::path& Folder, const TLuaPluginConfig& Config) {
@@ -446,52 +430,13 @@ std::set<std::string> TLuaEngine::GetEventHandlersForState(const std::string& Ev
     return mLuaEvents[EventName][StateId];
 }
 
-std::vector<sol::object> TLuaEngine::StateThreadData::JsonStringToArray(JsonString Str) {
-    auto LocalTable = Lua_JsonDecode(Str.value).as<std::vector<sol::object>>();
-    for (auto& value : LocalTable) {
-        if (value.is<std::string>() && value.as<std::string>() == BEAMMP_INTERNAL_NIL) {
-            value = sol::object {};
-        }
-    }
-    return LocalTable;
-}
-
 sol::table TLuaEngine::StateThreadData::Lua_TriggerGlobalEvent(const std::string& EventName, sol::variadic_args EventArgs) {
-    auto Table = mStateView.create_table();
-    int i = 1;
-    for (auto Arg : EventArgs) {
-        switch (Arg.get_type()) {
-        case sol::type::none:
-        case sol::type::userdata:
-        case sol::type::lightuserdata:
-        case sol::type::thread:
-        case sol::type::function:
-        case sol::type::poly:
-            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.set(i, BEAMMP_INTERNAL_NIL);
-            break;
-        case sol::type::string:
-        case sol::type::number:
-        case sol::type::boolean:
-        case sol::type::table:
-            Table.set(i, Arg);
-            break;
-        }
-        ++i;
-    }
-    JsonString Str { LuaAPI::MP::JsonEncode(Table) };
-    beammp_debugf("json: {}", Str.value);
-    auto Return = mEngine->TriggerEvent(EventName, mStateId, Str);
+    auto Return = mEngine->TriggerEvent(EventName, mStateId, EventArgs);
     auto MyHandlers = mEngine->GetEventHandlersForState(EventName, mStateId);
-
-    sol::variadic_results LocalArgs = JsonStringToArray(Str);
     for (const auto& Handler : MyHandlers) {
         auto Fn = mStateView[Handler];
         if (Fn.valid()) {
-            auto LuaResult = Fn(LocalArgs);
+            auto LuaResult = Fn(EventArgs);
             auto Result = std::make_shared<TLuaResult>();
             if (LuaResult.valid()) {
                 Result->Error = false;
@@ -522,13 +467,11 @@ 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.set(i, Value->Result);
-                ++i;
+                Result.add(Value->Result);
             }
             return Result;
         });
@@ -538,14 +481,12 @@ 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.set(i, FnRet);
-                ++i;
+                Result.add(FnRet);
             } else {
                 sol::error Err = FnRet;
                 beammp_lua_error(std::string("TriggerLocalEvent: ") + Err.what());
@@ -717,7 +658,6 @@ static void AddToTable(sol::table& table, const std::string& left, const T& valu
 static void JsonDecodeRecursive(sol::state_view& StateView, sol::table& table, const std::string& left, const nlohmann::json& right) {
     switch (right.type()) {
     case nlohmann::detail::value_t::null:
-        AddToTable(table, left, sol::lua_nil_t {});
         return;
     case nlohmann::detail::value_t::object: {
         auto value = table.create();
@@ -889,40 +829,6 @@ TLuaEngine::StateThreadData::StateThreadData(const std::string& Name, TLuaStateI
     MPTable.set_function("Set", &LuaAPI::MP::Set);
 
     auto UtilTable = StateView.create_named_table("Util");
-    UtilTable.set_function("LogDebug", [this](sol::variadic_args args) {
-        std::string ToPrint = "";
-        for (const auto& arg : args) {
-            ToPrint += LuaAPI::LuaToString(static_cast<const sol::object>(arg));
-            ToPrint += "\t";
-        }
-        if (Application::Settings.DebugModeEnabled) {
-            beammp_lua_log("DEBUG", mStateId, ToPrint);
-        }
-    });
-    UtilTable.set_function("LogInfo", [this](sol::variadic_args args) {
-        std::string ToPrint = "";
-        for (const auto& arg : args) {
-            ToPrint += LuaAPI::LuaToString(static_cast<const sol::object>(arg));
-            ToPrint += "\t";
-        }
-        beammp_lua_log("INFO", mStateId, ToPrint);
-    });
-    UtilTable.set_function("LogWarn", [this](sol::variadic_args args) {
-        std::string ToPrint = "";
-        for (const auto& arg : args) {
-            ToPrint += LuaAPI::LuaToString(static_cast<const sol::object>(arg));
-            ToPrint += "\t";
-        }
-        beammp_lua_log("WARN", mStateId, ToPrint);
-    });
-    UtilTable.set_function("LogError", [this](sol::variadic_args args) {
-        std::string ToPrint = "";
-        for (const auto& arg : args) {
-            ToPrint += LuaAPI::LuaToString(static_cast<const sol::object>(arg));
-            ToPrint += "\t";
-        }
-        beammp_lua_log("ERROR", mStateId, ToPrint);
-    });
     UtilTable.set_function("JsonEncode", &LuaAPI::MP::JsonEncode);
     UtilTable.set_function("JsonDecode", [this](const std::string& str) {
         return Lua_JsonDecode(str);
@@ -941,30 +847,6 @@ TLuaEngine::StateThreadData::StateThreadData(const std::string& Name, TLuaStateI
     UtilTable.set_function("RandomIntRange", [this](int64_t min, int64_t max) -> int64_t {
         return std::uniform_int_distribution(min, max)(mMersenneTwister);
     });
-    UtilTable.set_function("DebugExecutionTime", [this]() -> sol::table {
-        sol::state_view StateView(mState);
-        sol::table Result = StateView.create_table();
-        auto stats = mProfile.all_stats();
-        for (const auto& [name, stat] : stats) {
-            Result[name] = StateView.create_table();
-            Result[name]["mean"] = stat.mean;
-            Result[name]["stdev"] = stat.stdev;
-            Result[name]["min"] = stat.min;
-            Result[name]["max"] = stat.max;
-            Result[name]["n"] = stat.n;
-        }
-        return Result;
-    });
-    UtilTable.set_function("DebugStartProfile", [this](const std::string& name) {
-        mProfileStarts[name] = prof::now();
-    });
-    UtilTable.set_function("DebugStopProfile", [this](const std::string& name) {
-        if (!mProfileStarts.contains(name)) {
-            beammp_lua_errorf("DebugStopProfile('{}') failed, because a profile for '{}' wasn't started", name, name);
-            return;
-        }
-        mProfile.add_sample(name, prof::duration(mProfileStarts.at(name), prof::now()));
-    });
 
     auto HttpTable = StateView.create_named_table("Http");
     HttpTable.set_function("CreateConnection", [this](const std::string& host, uint16_t port) {
@@ -1012,7 +894,7 @@ std::shared_ptr<TLuaResult> TLuaEngine::StateThreadData::EnqueueScript(const TLu
     return Result;
 }
 
-std::shared_ptr<TLuaResult> TLuaEngine::StateThreadData::EnqueueFunctionCallFromCustomEvent(const std::string& FunctionName, const std::vector<TLuaValue>& Args, const std::string& EventName, CallStrategy Strategy) {
+std::shared_ptr<TLuaResult> TLuaEngine::StateThreadData::EnqueueFunctionCallFromCustomEvent(const std::string& FunctionName, const std::vector<TLuaArgTypes>& Args, const std::string& EventName, CallStrategy Strategy) {
     // TODO: Document all this
     decltype(mStateFunctionQueue)::iterator Iter = mStateFunctionQueue.end();
     if (Strategy == CallStrategy::BestEffort) {
@@ -1034,7 +916,7 @@ std::shared_ptr<TLuaResult> TLuaEngine::StateThreadData::EnqueueFunctionCallFrom
     }
 }
 
-std::shared_ptr<TLuaResult> TLuaEngine::StateThreadData::EnqueueFunctionCall(const std::string& FunctionName, const std::vector<TLuaValue>& Args) {
+std::shared_ptr<TLuaResult> TLuaEngine::StateThreadData::EnqueueFunctionCall(const std::string& FunctionName, const std::vector<TLuaArgTypes>& Args) {
     auto Result = std::make_shared<TLuaResult>();
     Result->StateId = mStateId;
     Result->Function = FunctionName;
@@ -1102,7 +984,6 @@ void TLuaEngine::StateThreadData::operator()() {
                 std::chrono::milliseconds(500),
                 [&]() -> bool { return !mStateFunctionQueue.empty(); });
             if (NotExpired) {
-                auto ProfStart = prof::now();
                 auto TheQueuedFunction = std::move(mStateFunctionQueue.front());
                 mStateFunctionQueue.erase(mStateFunctionQueue.begin());
                 Lock.unlock();
@@ -1120,21 +1001,19 @@ void TLuaEngine::StateThreadData::operator()() {
                             continue;
                         }
                         switch (Arg.index()) {
-                        case TLuaType::String:
+                        case TLuaArgTypes_String:
                             LuaArgs.push_back(sol::make_object(StateView, std::get<std::string>(Arg)));
                             break;
-                        case TLuaType::Int:
+                        case TLuaArgTypes_Int:
                             LuaArgs.push_back(sol::make_object(StateView, std::get<int>(Arg)));
                             break;
-                        case TLuaType::Json: {
-                            auto LocalArgs = JsonStringToArray(std::get<JsonString>(Arg));
-                            LuaArgs.insert(LuaArgs.end(), LocalArgs.begin(), LocalArgs.end());
+                        case TLuaArgTypes_VariadicArgs:
+                            LuaArgs.push_back(sol::make_object(StateView, std::get<sol::variadic_args>(Arg)));
                             break;
-                        }
-                        case TLuaType::Bool:
+                        case TLuaArgTypes_Bool:
                             LuaArgs.push_back(sol::make_object(StateView, std::get<bool>(Arg)));
                             break;
-                         case TLuaType::StringStringMap: {
+                        case TLuaArgTypes_StringStringMap: {
                             auto Map = std::get<std::unordered_map<std::string, std::string>>(Arg);
                             auto Table = StateView.create_table();
                             for (const auto& [k, v] : Map) {
@@ -1163,9 +1042,6 @@ void TLuaEngine::StateThreadData::operator()() {
                     Result->ErrorMessage = BeamMPFnNotFoundError; // special error kind that we can ignore later
                     Result->MarkAsReady();
                 }
-                auto ProfEnd = prof::now();
-                auto ProfDuration = prof::duration(ProfStart, ProfEnd);
-                mProfile.add_sample(FnName, ProfDuration);
             }
         }
     }
@@ -1225,7 +1101,7 @@ void TLuaResult::MarkAsReady() {
 void TLuaResult::WaitUntilReady() {
     std::unique_lock readyLock(*this->ReadyMutex);
     // wait if not ready yet
-    if (!this->Ready)
+    if(!this->Ready)
         this->ReadyCondition->wait(readyLock);
 }
 

src/TNetwork.cpp

@@ -630,7 +630,6 @@ void TNetwork::OnDisconnect(const std::weak_ptr<TClient>& ClientPtr) {
 }
 
 int TNetwork::OpenID() {
-    std::unique_lock OpenIDLock(mOpenIDMutex);
     int ID = 0;
     bool found;
     do {

src/TPPSMonitor.cpp

@@ -65,18 +65,15 @@ void TPPSMonitor::operator()() {
                 V += c->GetCarCount();
             }
             // kick on "no ping"
-            if (c->SecondsSinceLastPing() > (20 * 60) ){
-                beammp_debugf("client {} ({}) timing out: {}", c->GetID(), c->GetName(), c->SecondsSinceLastPing());
-                TimedOutClients.push_back(c);
-            } else if (c->IsSynced() && c->SecondsSinceLastPing() > (1 * 60)) {
-                beammp_debugf("client {} ({}) timing out: {}", c->GetName(), c->GetID(), c->SecondsSinceLastPing());
+            if (c->SecondsSinceLastPing() > (20 * 60)) {
+                beammp_debug("client " + std::string("(") + std::to_string(c->GetID()) + ")" + c->GetName() + " timing out: " + std::to_string(c->SecondsSinceLastPing()) + ", pps: " + Application::PPS());
                 TimedOutClients.push_back(c);
             }
 
             return true;
         });
         for (auto& ClientToKick : TimedOutClients) {
-            ClientToKick->Disconnect("Timeout");
+            Network().ClientKick(*ClientToKick, "Timeout (no ping for way too long)");
         }
         TimedOutClients.clear();
         if (C == 0 || mInternalPPS == 0) {

src/main.cpp

@@ -30,7 +30,6 @@
 #include "TResourceManager.h"
 #include "TServer.h"
 
-#include <cstdint>
 #include <iostream>
 #include <thread>
 
@@ -41,9 +40,6 @@ USAGE:
 ARGUMENTS:
     --help              
                         Displays this help and exits.
-    --port=1234
-                        Sets the server's listening TCP and
-                        UDP port. Overrides ENV and ServerConfig.
     --config=/path/to/ServerConfig.toml
                         Absolute or relative path to the 
                         Server Config file, including the
@@ -95,7 +91,6 @@ int BeamMPServerMain(MainArguments Arguments) {
     Parser.RegisterArgument({ "help" }, ArgsParser::NONE);
     Parser.RegisterArgument({ "version" }, ArgsParser::NONE);
     Parser.RegisterArgument({ "config" }, ArgsParser::HAS_VALUE);
-    Parser.RegisterArgument({ "port" }, ArgsParser::HAS_VALUE);
     Parser.RegisterArgument({ "working-directory" }, ArgsParser::HAS_VALUE);
     Parser.Parse(Arguments.List);
     if (!Parser.Verify()) {
@@ -140,24 +135,6 @@ int BeamMPServerMain(MainArguments Arguments) {
         }
         return 1;
     }
-
-    // override port if provided via arguments
-    if (Parser.FoundArgument({ "port" })) {
-        auto Port = Parser.GetValueOfArgument({ "port" });
-        if (Port.has_value()) {
-            auto P = int(std::strtoul(Port.value().c_str(), nullptr, 10));
-            if (P == 0 || P < 0 || P > UINT16_MAX) {
-                beammp_errorf("Custom port requested via --port is invalid: '{}'", Port.value());
-                return 1;
-            } else {
-                Application::Settings.Port = P;
-                beammp_info("Custom port requested via commandline arguments: " + Port.value());
-            }
-        }
-    }
-
-    Config.PrintDebug();
-
     Application::InitializeConsole();
     Application::Console().StartLoggingToFile();
 

test/Server/JsonTests/main.lua

@@ -1,66 +0,0 @@
-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")