update dlhttp

add /modlist endpoint, DownloadThreads config option
update dlhttp, make / work
2026-07-13 18:24:16 +00:00 · 2022-07-27 09:20:21 +02:00 · 2022-07-26 17:57:19 +02:00 · 2022-07-24 15:29:20 +02:00 · 2022-07-24 14:19:49 +02:00 · 2022-07-20 16:08:56 +02:00
43 changed files with 1135 additions and 732 deletions
@@ -7,38 +7,72 @@ env:

 jobs:
  linux-build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04

    steps:
-    - uses: actions/checkout@v2
-      with:
-          submodules: 'recursive'
+      - uses: actions/checkout@v2
+        with:
+          submodules: "recursive"

-    - name: Install Dependencies
-      env:
-        beammp_sentry_url: ${{ secrets.BEAMMP_SECRET_SENTRY_URL }}
-      run: |
+      - name: Install Dependencies
+        env:
+          beammp_sentry_url: ${{ secrets.BEAMMP_SECRET_SENTRY_URL }}
+        run: |
          echo ${#beammp_sentry_url}
          sudo apt-get update
-          sudo apt-get install -y libz-dev rapidjson-dev liblua5.3 libssl-dev libwebsocketpp-dev libcurl4-openssl-dev
+          sudo apt-get install -y libz-dev rapidjson-dev liblua5.3 libssl-dev libwebsocketpp-dev libcurl4-openssl-dev cmake g++-10

-    - name: Create Build Environment
-      run: cmake -E make_directory ${{github.workspace}}/build-linux
+      - name: Create Build Environment
+        run: cmake -E make_directory ${{github.workspace}}/build-linux

-    - name: Configure CMake
-      shell: bash
-      working-directory: ${{github.workspace}}/build-linux
-      env:
-        beammp_sentry_url: ${{ secrets.BEAMMP_SECRET_SENTRY_URL }}
-      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_CXX_COMPILER=g++-10 -DBEAMMP_SECRET_SENTRY_URL="$beammp_sentry_url"
+      - name: Configure CMake
+        shell: bash
+        working-directory: ${{github.workspace}}/build-linux
+        env:
+          beammp_sentry_url: ${{ secrets.BEAMMP_SECRET_SENTRY_URL }}
+        run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_CXX_COMPILER=g++-10 -DBEAMMP_SECRET_SENTRY_URL="$beammp_sentry_url"

-    - name: Build
-      working-directory: ${{github.workspace}}/build-linux
-      shell: bash
-      run: cmake --build . --config $BUILD_TYPE -t BeamMP-Server --parallel
+      - name: Build Server
+        working-directory: ${{github.workspace}}/build-linux
+        shell: bash
+        run: cmake --build . --config $BUILD_TYPE -t BeamMP-Server --parallel

-    - name: Archive artifacts
-      uses: actions/upload-artifact@v2
-      with:
-        name: BeamMP-Server-linux
-        path: ${{github.workspace}}/build-linux/BeamMP-Server
+      - name: Build Tests
+        working-directory: ${{github.workspace}}/build-linux
+        shell: bash
+        run: cmake --build . --config $BUILD_TYPE -t BeamMP-Server-tests --parallel
+
+      - name: Archive server artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: BeamMP-Server-linux
+          path: ${{github.workspace}}/build-linux/BeamMP-Server
+
+      - name: Archive test artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: BeamMP-Server-linux-tests
+          path: ${{github.workspace}}/build-linux/BeamMP-Server-tests
+
+  run-tests:
+    needs: linux-build
+    runs-on: ubuntu-20.04
+
+    steps:
+      - uses: actions/download-artifact@master
+        with:
+          name: BeamMP-Server-linux-tests
+          path: ${{github.workspace}}
+    
+      - name: Install Runtime Dependencies
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y liblua5.3 openssl 
+
+      - name: Test
+        working-directory: ${{github.workspace}}
+        shell: bash
+        run: |
+            chmod +x ./BeamMP-Server-tests
+            ./BeamMP-Server-tests
@@ -48,7 +48,7 @@ jobs:
        working-directory: ${{github.workspace}}/build-windows
        shell: bash
        run: |
-          cmake --build . --config Debug -t BeamMP-Server --parallel
+          cmake --build . --config Debug
      
      - name: Archive debug artifacts
        uses: actions/upload-artifact@v2
@@ -57,7 +57,7 @@ jobs:
      - name: Build
        working-directory: ${{github.workspace}}/build-linux
        shell: bash
-        run: cmake --build . --config $BUILD_TYPE -t BeamMP-Server --parallel
+        run: cmake --build . --config $BUILD_TYPE

      - name: Upload Release Asset
        id: upload-release-asset 
@@ -101,7 +101,7 @@ jobs:
      - name: Build
        working-directory: ${{github.workspace}}/build-windows
        shell: bash
-        run: cmake --build . --config $BUILD_TYPE -t BeamMP-Server --parallel
+        run: cmake --build . --config $BUILD_TYPE

      - name: Upload Release Asset
        id: upload-release-asset 
@@ -1,9 +1,6 @@
 [submodule "deps/commandline"]
 	path = deps/commandline
 	url = https://github.com/lionkor/commandline
-[submodule "deps/fmt"]
-	path = deps/fmt
-	url = https://github.com/fmtlib/fmt
 [submodule "deps/asio"]
 	path = deps/asio
 	url = https://github.com/chriskohlhoff/asio
@@ -28,3 +25,12 @@
 [submodule "deps/json"]
 	path = deps/json
 	url = https://github.com/nlohmann/json
+[submodule "deps/fmt"]
+	path = deps/fmt
+	url = https://github.com/fmtlib/fmt
+[submodule "deps/doctest"]
+	path = deps/doctest
+	url = https://github.com/doctest/doctest
+[submodule "deps/dlhttp"]
+	path = deps/dlhttp
+	url = https://github.com/lionkor/dlhttp
@@ -9,16 +9,20 @@ project(BeamMP-Server
    HOMEPAGE_URL https://beammp.com
    LANGUAGES CXX C)

-find_package(Git REQUIRED)
-# Update submodules as needed
-option(GIT_SUBMODULE "Check submodules during build" ON)
-if(GIT_SUBMODULE)
-    message(STATUS "Submodule update")
-    execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                    RESULT_VARIABLE GIT_SUBMOD_RESULT)
-    if(NOT GIT_SUBMOD_RESULT EQUAL "0")
-        message(FATAL_ERROR "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}, please checkout submodules")
+option(BEAMMP_RUN_GIT "Run git to make sure submodules are updated (leave this on unless you know what you're doing)" ON)
+
+if (BEAMMP_RUN_GIT)
+    find_package(Git REQUIRED)
+    # Update submodules as needed
+    option(GIT_SUBMODULE "Check submodules during build" ON)
+    if(GIT_SUBMODULE)
+        message(STATUS "Submodule update")
+        execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
+                        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                        RESULT_VARIABLE GIT_SUBMOD_RESULT)
+        if(NOT GIT_SUBMOD_RESULT EQUAL "0")
+            message(FATAL_ERROR "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}, please checkout submodules")
+        endif()
    endif()
 endif()

@@ -26,17 +30,16 @@ endif()
 set(HTTPLIB_REQUIRE_OPENSSL ON)
 set(SENTRY_BUILD_SHARED_LIBS OFF)

-include_directories("${PROJECT_SOURCE_DIR}/deps/asio/asio/include")
-include_directories("${PROJECT_SOURCE_DIR}/deps/rapidjson/include")
-include_directories("${PROJECT_SOURCE_DIR}/deps/websocketpp")
-include_directories("${PROJECT_SOURCE_DIR}/deps/commandline")
-include_directories("${PROJECT_SOURCE_DIR}/deps/sol2/include")
-include_directories("${PROJECT_SOURCE_DIR}/deps/cpp-httplib")
-include_directories("${PROJECT_SOURCE_DIR}/deps/toml11")
-include_directories("${PROJECT_SOURCE_DIR}/deps/json/single_include")
-include_directories("${PROJECT_SOURCE_DIR}/deps")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/deps/asio/asio/include")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/deps/rapidjson/include")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/deps/websocketpp")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/deps/commandline")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/deps/sol2/include")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/deps/cpp-httplib")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/deps/json/single_include")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/deps")

-add_compile_definitions(CPPHTTPLIB_OPENSSL_SUPPORT)
+add_compile_definitions(CPPHTTPLIB_OPENSSL_SUPPORT=1)

 # ------------------------ APPLE ---------------------------------
 if(APPLE)
@@ -51,18 +54,12 @@ elseif (WIN32)
    message(STATUS "MSVC -> forcing use of statically-linked runtime.")
    STRING(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE})
    STRING(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
-    if (MSVC)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")
-        set(SENTRY_BUILD_RUNTIMESTATIC ON)
-    endif ()
-    set(VcpkgRoot ${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET})
-    include_directories(${VcpkgRoot}/include)
-    link_directories(${VcpkgRoot}/lib)
 # ------------------------ LINUX ---------------------------------
 elseif (UNIX)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic -static-libstdc++ -static-libgcc")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic")
    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g")
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2 -fno-builtin")
+    option(SANITIZE "Turns on thread and UB sanitizers" OFF)
    if (SANITIZE)
        message(STATUS "sanitize is ON")
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined,thread")
@@ -70,7 +67,7 @@ elseif (UNIX)
 endif ()

 include_directories("include/sentry-native/include")
-
+set(BUILD_SHARED_LIBS OFF)
 # ------------------------ SENTRY ---------------------------------
 message(STATUS "Checking for Sentry URL")
 # this is set by the build system.
@@ -87,57 +84,62 @@ add_subdirectory("deps/sentry-native")

 # ------------------------ C++ SETUP ---------------------------------
 set(CMAKE_CXX_STANDARD 17)
+if (MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")
+endif ()

 # ------------------------ DEPENDENCIES ------------------------------
 message(STATUS "Adding local source dependencies")
 # this has to happen before -DDEBUG since it wont compile properly with -DDEBUG
 add_subdirectory(deps)

-# ------------------------ BEAMMP SERVER -----------------------------
-
-add_executable(BeamMP-Server
-        src/main.cpp
-        include/TConsole.h src/TConsole.cpp
-        include/TServer.h src/TServer.cpp
-        include/Compat.h src/Compat.cpp
-        include/Common.h src/Common.cpp
-        include/Client.h src/Client.cpp
-        include/VehicleData.h src/VehicleData.cpp
-        include/TConfig.h src/TConfig.cpp
-        include/TLuaEngine.h src/TLuaEngine.cpp
-        include/TLuaPlugin.h src/TLuaPlugin.cpp
-        include/TResourceManager.h src/TResourceManager.cpp
-        include/THeartbeatThread.h src/THeartbeatThread.cpp
-        include/Http.h src/Http.cpp
-        include/TSentry.h src/TSentry.cpp
-        include/TPPSMonitor.h src/TPPSMonitor.cpp
-        include/TNetwork.h src/TNetwork.cpp
-        include/LuaAPI.h src/LuaAPI.cpp
-        include/TScopedTimer.h src/TScopedTimer.cpp
-        include/SignalHandling.h src/SignalHandling.cpp
-        include/ArgsParser.h src/ArgsParser.cpp
-        include/Environment.h)
-
-target_compile_definitions(BeamMP-Server PRIVATE SECRET_SENTRY_URL="${BEAMMP_SECRET_SENTRY_URL}")
-include_directories(BeamMP-Server PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
-
-target_include_directories(BeamMP-Server PUBLIC 
-    "${CMAKE_CURRENT_SOURCE_DIR}/include" 
-    "${CMAKE_CURRENT_SOURCE_DIR}/commandline")
+# ------------------------ VARIABLES ---------------------------------

 include(FindLua)
 include(FindOpenSSL)
 include(FindThreads)
 include(FindZLIB)

-target_include_directories(BeamMP-Server PUBLIC 
-    ${LUA_INCLUDE_DIR} 
-    ${CURL_INCLUDE_DIRS}
-    "include/tomlplusplus" 
-    "include/sentry-native/include"
-    "include/curl/include")
+set(BeamMP_Sources
+    include/TConsole.h src/TConsole.cpp
+    include/TServer.h src/TServer.cpp
+    include/Compat.h src/Compat.cpp
+    include/Common.h src/Common.cpp
+    include/Client.h src/Client.cpp
+    include/VehicleData.h src/VehicleData.cpp
+    include/TConfig.h src/TConfig.cpp
+    include/TLuaEngine.h src/TLuaEngine.cpp
+    include/TLuaPlugin.h src/TLuaPlugin.cpp
+    include/TResourceManager.h src/TResourceManager.cpp
+    include/THeartbeatThread.h src/THeartbeatThread.cpp
+    include/Http.h src/Http.cpp
+    include/TSentry.h src/TSentry.cpp
+    include/TPPSMonitor.h src/TPPSMonitor.cpp
+    include/TNetwork.h src/TNetwork.cpp
+    include/LuaAPI.h src/LuaAPI.cpp
+    include/TScopedTimer.h src/TScopedTimer.cpp
+    include/SignalHandling.h src/SignalHandling.cpp
+    include/ArgsParser.h src/ArgsParser.cpp
+    include/TPluginMonitor.h src/TPluginMonitor.cpp
+    include/Environment.h
+)

-target_link_libraries(BeamMP-Server 
+set(BeamMP_Includes
+    "${CMAKE_CURRENT_SOURCE_DIR}/include"
+    "${CMAKE_CURRENT_SOURCE_DIR}/commandline"
+    ${LUA_INCLUDE_DIR}
+    ${CURL_INCLUDE_DIRS}
+    "include/tomlplusplus"
+    "include/sentry-native/include"
+    "include/curl/include"
+)
+
+set(BeamMP_Definitions
+    SECRET_SENTRY_URL="${BEAMMP_SECRET_SENTRY_URL}"
+)
+
+set(BeamMP_Libraries
+    doctest::doctest
    OpenSSL::SSL
    OpenSSL::Crypto
    sol2::sol2
@@ -146,8 +148,56 @@ target_link_libraries(BeamMP-Server
    ZLIB::ZLIB
    ${LUA_LIBRARIES}
    commandline
-    sentry)
+    sentry
+    dlhttp
+)

 if (WIN32)
-    target_link_libraries(BeamMP-Server wsock32 ws2_32)
+    set(BeamMP_PlatformLibs wsock32 ws2_32)
 endif ()
+
+# ------------------------ BEAMMP SERVER -----------------------------
+
+add_executable(BeamMP-Server
+        src/main.cpp
+        ${BeamMP_Sources}
+)
+
+target_compile_definitions(BeamMP-Server PRIVATE
+    ${BeamMP_Definitions}
+    DOCTEST_CONFIG_DISABLE
+)
+
+target_include_directories(BeamMP-Server PUBLIC 
+    ${BeamMP_Includes}
+)
+
+target_link_libraries(BeamMP-Server
+    ${BeamMP_Libraries}
+    ${BeamMP_PlatformLibs}
+)
+
+# ------------------------ BEAMMP SERVER TESTS -----------------------
+
+option(BUILD_TESTS "Build BeamMP-Server tests" ON)
+
+if(BUILD_TESTS)
+    add_executable(BeamMP-Server-tests
+            test/test_main.cpp
+            ${BeamMP_Sources}
+    )
+
+    target_compile_definitions(BeamMP-Server-tests PRIVATE
+        ${BeamMP_Definitions}
+    )
+
+    target_include_directories(BeamMP-Server-tests PUBLIC
+        ${BeamMP_Includes}
+    )
+
+    target_link_libraries(BeamMP-Server-tests
+        ${BeamMP_Libraries}
+        ${BeamMP_PlatformLibs}
+    )
+endif()
+
@@ -1,10 +1,18 @@
+
 # v3.1.0

 - ADDED Tab autocomplete in console, smart tab autocomplete (understands lua tables and types) in the lua console
 - ADDED lua debug facilities (type `:help` when attached to lua via `lua`)
 - ADDED MP.JsonEncode() and MP.JsonDecode(), which turn lua tables into json and vice-versa
 - ADDED FS.ListFiles and FS.ListDirectories
+- ADDED onFileChanged event, triggered when a server plugin file changes
+- FIXED `ip` in MP.GetIdentifiers
 - FIXED issue with client->server events which contain ':'
+- FIXED a fatal exception on LuaEngine startup if Resources/Server is a symlink
+- FIXED onInit not being called on hot-reload
+- FIXED incorrect timing calculation of Lua EventTimer loop
+- FIXED bug which caused hot-reload not to report syntax errors
+- FIXED missing error messages on some event handler calls

 # v3.0.2

@@ -15,6 +23,7 @@
 - FIXED `MP.CreateEventTimer` filling up the queue (see <https://wiki.beammp.com/en/Scripting/new-lua-scripting#mpcreateeventtimerevent_name-string-interval_ms-number-strategy-number-since-v302>)
 - FIXED `MP.TriggerClientEvent` not kicking the client if it failed
 - FIXED Lua result queue handling not checking all results
+- FIXED bug which caused ServerConfig.toml to generate incorrectly

 # v3.0.1

@@ -109,7 +109,7 @@ On windows, use git-bash for these commands. On Linux, these should work in your
 1. Make sure you have all [prerequisites](#prerequisites) installed
 2. Clone the repository in a location of your choice with `git clone --recurse-submodules https://github.com/BeamMP/BeamMP-Server`. 
 3. Ensure that all submodules are initialized by running `git submodule update --init --recursive`. Then change into the cloned directory by running `cd BeamMP-Server`.
-4. Checkout the branch of the release you want to compile (`master` is often unstable), for example `git checkout tags/v2.3.3` for version 2.3.3. You can find the latest version [here](https://github.com/BeamMP/BeamMP-Server/tags).
+4. Checkout the branch of the release you want to compile (`master` is often unstable), for example `git checkout tags/v3.0.1` for version 3.0.1. You can find the latest version [here](https://github.com/BeamMP/BeamMP-Server/tags).
 5. Run `cmake . -DCMAKE_BUILD_TYPE=Release` (with `.`)
 6. Run `make`
 7. You will now have a `BeamMP-Server` file in your directory, which is executable with `./BeamMP-Server` (`.\BeamMP-Server.exe` for windows). Follow the (windows or linux, doesnt matter) instructions on the [wiki](https://wiki.beammp.com/en/home/Server_Mod) for further setup after installation (which we just did), such as port-forwarding and getting a key to actually run the server.
@@ -1,7 +1,14 @@
-
 include_directories("${PROJECT_SOURCE_DIR}/deps")
 include_directories("${PROJECT_SOURCE_DIR}/deps/commandline")

 add_subdirectory("${PROJECT_SOURCE_DIR}/deps/commandline")
-add_subdirectory("${PROJECT_SOURCE_DIR}/deps/fmt")
-add_subdirectory("${PROJECT_SOURCE_DIR}/deps/sol2")
+if (NOT TARGET fmt)
+    add_subdirectory("${PROJECT_SOURCE_DIR}/deps/fmt")
+endif()
+if (NOT TARGET sol2)
+    add_subdirectory("${PROJECT_SOURCE_DIR}/deps/sol2")
+endif()
+if (NOT TARGET doctest)
+    add_subdirectory("${PROJECT_SOURCE_DIR}/deps/doctest")
+endif()
+add_subdirectory("${PROJECT_SOURCE_DIR}/deps/dlhttp")
@@ -12,9 +12,14 @@ extern TSentry Sentry;
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <shared_mutex>
 #include <sstream>
 #include <zlib.h>

+#include <doctest/doctest.h>
+#include <filesystem>
+namespace fs = std::filesystem;
+
 #include "Compat.h"

 #include "TConsole.h"
@@ -42,12 +47,15 @@ public:
        std::string Resource { "Resources" };
        std::string MapName { "/levels/gridmap_v2/info.json" };
        std::string Key {};
+        std::string SSLKeyPath { "./.ssl/HttpServer/key.pem" };
+        std::string SSLCertPath { "./.ssl/HttpServer/cert.pem" };
        bool HTTPServerEnabled { false };
        int MaxPlayers { 8 };
        bool Private { true };
        int MaxCars { 1 };
        bool DebugModeEnabled { false };
        int Port { 30814 };
+        int DownloadThreads { 4 };
        std::string CustomIP {};
        bool LogChat { true };
        bool SendErrors { true };
@@ -90,6 +98,8 @@ public:
    static void CheckForUpdates();
    static std::array<uint8_t, 3> VersionStrToInts(const std::string& str);
    static bool IsOutdated(const Version& Current, const Version& Newest);
+    static bool IsShuttingDown();
+    static void SleepSafeSeconds(size_t Seconds);

    static void InitializeConsole() {
        if (!mConsole) {
@@ -115,10 +125,14 @@ public:
    static void SetSubsystemStatus(const std::string& Subsystem, Status status);

 private:
+    static void SetShutdown(bool Val);
+
    static inline SystemStatusMap mSystemStatusMap {};
    static inline std::mutex mSystemStatusMapMutex {};
    static inline std::string mPPS;
    static inline std::unique_ptr<TConsole> mConsole;
+    static inline std::shared_mutex mShutdownMtx {};
+    static inline bool mShutdown { false };
    static inline std::mutex mShutdownHandlersMutex {};
    static inline std::deque<TShutdownHandler> mShutdownHandlers {};

@@ -129,97 +143,126 @@ std::string ThreadName(bool DebugModeOverride = false);
 void RegisterThread(const std::string& str);
 #define RegisterThreadAuto() RegisterThread(__func__)

-#define KB 1024
-#define MB (KB * 1024)
+#define KB 1024llu
+#define MB (KB * 1024llu)
+#define GB (MB * 1024llu)
 #define SSU_UNRAW SECRET_SENTRY_URL

 #define _file_basename std::filesystem::path(__FILE__).filename().string()
 #define _line std::to_string(__LINE__)
 #define _in_lambda (std::string(__func__) == "operator()")

-// we would like the full function signature 'void a::foo() const'
-// on windows this is __FUNCSIG__, on GCC it's __PRETTY_FUNCTION__,
-// feel free to add more
-#if defined(WIN32)
-#define _function_name std::string(__FUNCSIG__)
-#elif defined(__unix) || defined(__unix__)
-#define _function_name std::string(__PRETTY_FUNCTION__)
-#else
-#define _function_name std::string(__func__)
-#endif
-
-#ifndef NDEBUG
-#define DEBUG
-#endif
-
-#if defined(DEBUG)
-
-// if this is defined, we will show the full function signature infront of
-// each info/debug/warn... call instead of the 'filename:line' format.
-#if defined(BMP_FULL_FUNCTION_NAMES)
-#define _this_location (ThreadName() + _function_name + " ")
-#else
-#define _this_location (ThreadName() + _file_basename + ":" + _line + " ")
-#endif
-#define SU_RAW SSU_UNRAW
-
-#else // !defined(DEBUG)
-
-#define SU_RAW RAWIFY(SSU_UNRAW)
-#define _this_location (ThreadName())
-
-#endif // defined(DEBUG)
-
-#define beammp_warn(x) Application::Console().Write(_this_location + std::string("[WARN] ") + (x))
-#define beammp_info(x) Application::Console().Write(_this_location + std::string("[INFO] ") + (x))
-#define beammp_error(x)                                                               \
-    do {                                                                              \
-        Application::Console().Write(_this_location + std::string("[ERROR] ") + (x)); \
-        Sentry.AddErrorBreadcrumb((x), _file_basename, _line);                        \
-    } while (false)
-#define beammp_lua_error(x)                                                               \
-    do {                                                                                  \
-        Application::Console().Write(_this_location + std::string("[LUA ERROR] ") + (x)); \
-    } while (false)
-#define beammp_lua_warn(x)                                                               \
-    do {                                                                                 \
-        Application::Console().Write(_this_location + std::string("[LUA WARN] ") + (x)); \
-    } while (false)
-#define luaprint(x) Application::Console().Write(_this_location + std::string("[LUA] ") + (x))
-#define beammp_debug(x)                                                                   \
-    do {                                                                                  \
-        if (Application::Settings.DebugModeEnabled) {                                     \
-            Application::Console().Write(_this_location + std::string("[DEBUG] ") + (x)); \
-        }                                                                                 \
-    } while (false)
-#define beammp_event(x)                                                                   \
-    do {                                                                                  \
-        if (Application::Settings.DebugModeEnabled) {                                     \
-            Application::Console().Write(_this_location + std::string("[EVENT] ") + (x)); \
-        }                                                                                 \
-    } while (false)
 // for those times when you just need to ignore something :^)
 // explicity disables a [[nodiscard]] warning
 #define beammp_ignore(x) (void)x
-// trace() is a debug-build debug()
-#if defined(DEBUG)
-#define beammp_trace(x)                                                                   \
-    do {                                                                                  \
-        if (Application::Settings.DebugModeEnabled) {                                     \
-            Application::Console().Write(_this_location + std::string("[TRACE] ") + (x)); \
-        }                                                                                 \
-    } while (false)
-#else
-#define beammp_trace(x)
-#endif // defined(DEBUG)

-#define beammp_errorf(...) beammp_error(fmt::format(__VA_ARGS__))
-#define beammp_infof(...) beammp_info(fmt::format(__VA_ARGS__))
-#define beammp_warnf(...) beammp_warn(fmt::format(__VA_ARGS__))
-#define beammp_debugf(...) beammp_debug(fmt::format(__VA_ARGS__))
-#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__))
+// clang-format off
+#ifdef DOCTEST_CONFIG_DISABLE
+
+    // we would like the full function signature 'void a::foo() const'
+    // on windows this is __FUNCSIG__, on GCC it's __PRETTY_FUNCTION__,
+    // feel free to add more
+    #if defined(WIN32)
+        #define _function_name std::string(__FUNCSIG__)
+    #elif defined(__unix) || defined(__unix__)
+        #define _function_name std::string(__PRETTY_FUNCTION__)
+    #else
+        #define _function_name std::string(__func__)
+    #endif
+    
+    #ifndef NDEBUG
+        #define DEBUG
+    #endif
+    
+    #if defined(DEBUG)
+        
+        // if this is defined, we will show the full function signature infront of
+        // each info/debug/warn... call instead of the 'filename:line' format.
+        #if defined(BMP_FULL_FUNCTION_NAMES)
+            #define _this_location (ThreadName() + _function_name + " ")
+        #else
+            #define _this_location (ThreadName() + _file_basename + ":" + _line + " ")
+        #endif
+
+    #endif // defined(DEBUG)
+    
+    #define beammp_warn(x) Application::Console().Write(_this_location + std::string("[WARN] ") + (x))
+    #define beammp_info(x) Application::Console().Write(_this_location + std::string("[INFO] ") + (x))
+    #define beammp_error(x)                                                               \
+        do {                                                                              \
+            Application::Console().Write(_this_location + std::string("[ERROR] ") + (x)); \
+            Sentry.AddErrorBreadcrumb((x), _file_basename, _line);                        \
+        } while (false)
+    #define beammp_lua_error(x)                                                               \
+        do {                                                                                  \
+            Application::Console().Write(_this_location + std::string("[LUA ERROR] ") + (x)); \
+        } while (false)
+    #define beammp_lua_warn(x)                                                               \
+        do {                                                                                 \
+            Application::Console().Write(_this_location + std::string("[LUA WARN] ") + (x)); \
+        } while (false)
+    #define luaprint(x) Application::Console().Write(_this_location + std::string("[LUA] ") + (x))
+    #define beammp_debug(x)                                                                   \
+        do {                                                                                  \
+            if (Application::Settings.DebugModeEnabled) {                                     \
+                Application::Console().Write(_this_location + std::string("[DEBUG] ") + (x)); \
+            }                                                                                 \
+        } while (false)
+    #define beammp_event(x)                                                                   \
+        do {                                                                                  \
+            if (Application::Settings.DebugModeEnabled) {                                     \
+                Application::Console().Write(_this_location + std::string("[EVENT] ") + (x)); \
+            }                                                                                 \
+        } while (false)
+    // trace() is a debug-build debug()
+    #if defined(DEBUG)
+        #define beammp_trace(x)                                                                   \
+            do {                                                                                  \
+                if (Application::Settings.DebugModeEnabled) {                                     \
+                    Application::Console().Write(_this_location + std::string("[TRACE] ") + (x)); \
+                }                                                                                 \
+            } while (false)
+    #else
+        #define beammp_trace(x)
+    #endif // defined(DEBUG)
+    
+    #define beammp_errorf(...) beammp_error(fmt::format(__VA_ARGS__))
+    #define beammp_infof(...) beammp_info(fmt::format(__VA_ARGS__))
+    #define beammp_debugf(...) beammp_debug(fmt::format(__VA_ARGS__))
+    #define beammp_warnf(...) beammp_warn(fmt::format(__VA_ARGS__))
+    #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__))
+
+#else // DOCTEST_CONFIG_DISABLE
+
+    #define beammp_error(x) /* x */
+    #define beammp_lua_error(x) /* x */
+    #define beammp_warn(x) /* x */
+    #define beammp_lua_warn(x) /* x */
+    #define beammp_info(x) /* x */
+    #define beammp_event(x) /* x */
+    #define beammp_debug(x) /* x */
+    #define beammp_trace(x) /* x */
+    #define luaprint(x) /* x */
+    #define beammp_errorf(...) beammp_error(fmt::format(__VA_ARGS__))
+    #define beammp_infof(...) beammp_info(fmt::format(__VA_ARGS__))
+    #define beammp_warnf(...) beammp_warn(fmt::format(__VA_ARGS__))
+    #define beammp_debugf(...) beammp_debug(fmt::format(__VA_ARGS__))
+    #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__))
+
+#endif // DOCTEST_CONFIG_DISABLE
+
+#if defined(DEBUG)
+    #define SU_RAW SSU_UNRAW
+#else
+    #define SU_RAW RAWIFY(SSU_UNRAW)
+    #define _this_location (ThreadName())
+#endif
+
+// clang-format on

 void LogChatMessage(const std::string& name, int id, const std::string& msg);

@@ -17,10 +17,6 @@

 namespace fs = std::filesystem;

-class TServer;
-class TNetwork;
-class TResourceManager;
-
 namespace Http {
 std::string GET(const std::string& host, int port, const std::string& target, unsigned int* status = nullptr);
 std::string POST(const std::string& host, int port, const std::string& target, const std::string& body, const std::string& ContentType, unsigned int* status = nullptr, const httplib::Headers& headers = {});
@@ -32,19 +28,13 @@ const std::string ErrorString = "-1";
 namespace Server {
    class THttpServerInstance {
    public:
-        THttpServerInstance(TServer&, TNetwork&, TResourceManager&);
-        ~THttpServerInstance();
-        static fs::path KeyFilePath;
-        static fs::path CertFilePath;
+        THttpServerInstance();

    protected:
        void operator()();

    private:
        std::thread mThread;
-        TServer& mServer;
-        TNetwork& mNetwork;
-        TResourceManager& mResourceManager;
    };
 }
 }
@@ -6,7 +6,7 @@
 #include <filesystem>

 #define TOML11_PRESERVE_COMMENTS_BY_DEFAULT
-#include <toml.hpp> // header-only version of TOML++
+#include <toml11/toml.hpp> // header-only version of TOML++

 namespace fs = std::filesystem;

@@ -19,7 +19,7 @@ public:
    void FlushToFile();

 private:
-    void CreateConfigFile(std::string_view name);
+    void CreateConfigFile();
    void ParseFromFile(std::string_view name);
    void PrintDebug();
    void TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, std::string& OutValue);
@@ -35,6 +35,7 @@ private:
    void Command_List(const std::string& cmd, const std::vector<std::string>& args);
    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_Say(const std::string& FullCommand);
    bool EnsureArgsCount(const std::vector<std::string>& args, size_t n);
@@ -50,6 +51,7 @@ private:
        { "list", [this](const auto& a, const auto& b) { Command_List(a, b); } },
        { "status", [this](const auto& a, const auto& b) { Command_Status(a, b); } },
        { "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
    };

@@ -15,7 +15,6 @@ private:
    std::string GenerateCall();
    std::string GetPlayers();

-    bool mShutdown = false;
    TResourceManager& mResourceManager;
    TServer& mServer;
 };
@@ -13,7 +13,7 @@
 #include <queue>
 #include <random>
 #include <set>
-#include <toml.hpp>
+#include <toml11/toml.hpp>
 #include <unordered_map>
 #include <vector>

@@ -48,6 +48,7 @@ struct TLuaPluginConfig {
    static inline const std::string FileName = "PluginConfig.toml";
    TLuaStateId StateId;
    // TODO: Add execute list
+    // TODO: Build a better toml serializer, or some way to do this in an easier way
 };

 struct TLuaChunk {
@@ -59,20 +60,7 @@ struct TLuaChunk {
    std::string PluginPath;
 };

-class TPluginMonitor : IThreaded {
-public:
-    TPluginMonitor(const fs::path& Path, TLuaEngine& Engine, std::atomic_bool& Shutdown);
-
-    void operator()();
-
-private:
-    TLuaEngine& mEngine;
-    fs::path mPath;
-    std::atomic_bool& mShutdown;
-    std::unordered_map<std::string, fs::file_time_type> mFileTimes;
-};
-
-class TLuaEngine : IThreaded {
+class TLuaEngine : public std::enable_shared_from_this<TLuaEngine>, IThreaded {
 public:
    enum CallStrategy : int {
        BestEffort,
@@ -131,7 +119,6 @@ public:
    [[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);
-    template <typename... ArgsT>
    /**
     *
     * @tparam ArgsT Template Arguments for the event (Metadata) todo: figure out what this means
@@ -140,6 +127,7 @@ public:
     * @param Args
     * @return
     */
+    template <typename... ArgsT>
    [[nodiscard]] std::vector<std::shared_ptr<TLuaResult>> TriggerEvent(const std::string& EventName, TLuaStateId IgnoreId, ArgsT&&... Args) {
        std::unique_lock Lock(mLuaEventsMutex);
        beammp_event(EventName);
@@ -159,6 +147,21 @@ public:
        }
        return Results; //
    }
+    template <typename... ArgsT>
+    [[nodiscard]] std::vector<std::shared_ptr<TLuaResult>> TriggerLocalEvent(const TLuaStateId& StateId, const std::string& EventName, ArgsT&&... Args) {
+        std::unique_lock Lock(mLuaEventsMutex);
+        beammp_event(EventName + " in '" + StateId + "'");
+        if (mLuaEvents.find(EventName) == mLuaEvents.end()) { // if no event handler is defined for 'EventName', return immediately
+            return {};
+        }
+        std::vector<std::shared_ptr<TLuaResult>> Results;
+        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));
+        }
+        return Results;
+    }
    std::set<std::string> GetEventHandlersForState(const std::string& EventName, TLuaStateId StateId);
    void CreateEventTimer(const std::string& EventName, TLuaStateId StateId, size_t IntervalMS, CallStrategy Strategy);
    void CancelEventTimers(const std::string& EventName, TLuaStateId StateId);
@@ -184,7 +187,7 @@ private:

    class StateThreadData : IThreaded {
    public:
-        StateThreadData(const std::string& Name, std::atomic_bool& Shutdown, TLuaStateId StateId, TLuaEngine& Engine);
+        StateThreadData(const std::string& Name, TLuaStateId StateId, TLuaEngine& Engine);
        StateThreadData(const StateThreadData&) = delete;
        ~StateThreadData() noexcept { beammp_debug("\"" + mStateId + "\" destroyed"); }
        [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueScript(const TLuaChunk& Script);
@@ -215,7 +218,6 @@ private:
        sol::table Lua_FS_ListDirectories(const std::string& Path);

        std::string mName;
-        std::atomic_bool& mShutdown;
        TLuaStateId mStateId;
        lua_State* mState;
        std::thread mThread;
@@ -244,9 +246,7 @@ private:

    TNetwork* mNetwork;
    TServer* mServer;
-    TPluginMonitor mPluginMonitor;
-    std::atomic_bool mShutdown { false };
-    fs::path mResourceServerPath;
+    const fs::path mResourceServerPath;
    std::vector<std::shared_ptr<TLuaPlugin>> mLuaPlugins;
    std::unordered_map<TLuaStateId, std::unique_ptr<StateThreadData>> mLuaStates;
    std::recursive_mutex mLuaStatesMutex;
@@ -32,7 +32,6 @@ private:
    TServer& mServer;
    TPPSMonitor& mPPSMonitor;
    SOCKET mUDPSock {};
-    bool mShutdown { false };
    TResourceManager& mResourceManager;
    std::thread mUDPThread;
    std::thread mTCPThread;
@@ -48,4 +47,5 @@ private:
    void SendFile(TClient& c, const std::string& Name);
    static bool TCPSendRaw(TClient& C, SOCKET socket, char* Data, int32_t Size);
    static void SplitLoad(TClient& c, size_t Sent, size_t Size, bool D, const std::string& Name);
+    static uint8_t* SendSplit(TClient& c, SOCKET Socket, uint8_t* DataPtr, size_t Size);
 };
@@ -22,6 +22,5 @@ private:

    TServer& mServer;
    std::optional<std::reference_wrapper<TNetwork>> mNetwork { std::nullopt };
-    bool mShutdown { false };
    int mInternalPPS { 0 };
-};
+};
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Common.h"
+#include "IThreaded.h"
+
+#include <atomic>
+#include <memory>
+#include <unordered_map>
+
+class TLuaEngine;
+
+class TPluginMonitor : IThreaded, public std::enable_shared_from_this<TPluginMonitor> {
+public:
+    TPluginMonitor(const fs::path& Path, std::shared_ptr<TLuaEngine> Engine);
+
+    void operator()();
+
+private:
+    std::shared_ptr<TLuaEngine> mEngine;
+    fs::path mPath;
+    std::unordered_map<std::string, fs::file_time_type> mFileTimes;
+};
@@ -1,13 +1,10 @@
 #pragma once

-#include <nlohmann/json.hpp>
 #include <string>

-using json = nlohmann::json;
-
 class TVehicleData final {
 public:
-    TVehicleData(int ID, const std::string& Data);
+    TVehicleData(int ID, std::string Data);
    ~TVehicleData();
    // We cannot delete this, since vector needs to be able to copy when it resizes.
    // Deleting this causes some wacky template errors which are hard to decipher,
@@ -22,12 +19,9 @@ public:

    bool operator==(const TVehicleData& v) const { return mID == v.mID; }

-    const json& Json() const;
-
 private:
    int mID { -1 };
    std::string mData;
-    json mJson;
 };

 // TODO: unused now, remove?
@@ -1,135 +0,0 @@
-openapi: "3.0.2"
-info:
-  title: BeamMP-Server
-  version: "api-v1"
-  description: |
-    The BeamMP-Server optionally runs an HTTP server
-    which can be used to query information about the server's 
-    status, health, players, etc.
-servers:
-  - url: http://localhost:{port}/api/v1
-    description: BeamMP-Server API v1
-    variables:
-      port:
-        default: "8000"
-
-paths:
-  /player/{name}/vehicles:
-    parameters:
-      - name: "name"
-        in: path
-        required: true
-        schema:
-          type: string
-          example: "LionKor"
-    get:
-      summary: vehicles this player has spawend
-      responses:
-        "200":
-          description: OK
-          content:
-            "application/json":
-              schema:
-                type: array
-                items:
-                  type: object
-                  properties:
-                    jbm:
-                      type: string
-                      example: "bolide"
-  /version:
-    get:
-      summary: server version
-      description: |
-        Server version in 'major.minor.patch' semver format
-      responses:
-        "200":
-          description: OK
-          content:
-            "text/plain":
-              schema:
-                type: string
-                example: "3.1.0"
-  /players:
-    get:
-      summary: list of players on this server
-      responses:
-        "200":
-          description: OK
-          content:
-            "application/json":
-              schema:
-                type: array
-                example:
-                  - "LionKor"
-                  - "Titch"
-                items:
-                  type: string
-  /config:
-    get:
-      summary: describes server configuration
-      description: |
-        An overview over the configuration currently
-        used by this server.
-      responses:
-        "200":
-          description: OK
-          content:
-            "application/json":
-              schema:
-                type: object
-                properties:
-                  name:
-                    type: string
-                    example: "my awesome beammp server"
-                  description:
-                    type: string
-                    example: "join!"
-                  max_players:
-                    type: integer
-                    example: 7
-                  max_cars:
-                    type: integer
-                    example: 2
-                  map:
-                    type: string
-                    example: "/levels/gridmap_v2/info.json"
-                  private:
-                    type: boolean
-  /ready:
-    get:
-      summary: whether the server has started fully
-      description: |
-        True once all subsystems have started up.
-        This doesn't tell you whether they're healthy, 
-        check /health for that information.
-      responses:
-        "200":
-          description: OK
-          content:
-            "text/plain":
-              schema:
-                type: boolean
-  /health:
-    get:
-      summary: health of the server's systems
-      responses:
-        "200":
-          description: OK
-          content:
-            "application/json":
-              schema:
-                type: object
-                properties:
-                  healthy:
-                    type: boolean
-                  good:
-                    type: array
-                    items:
-                      type: string
-                      example: "Heartbeat"
-                  bad:
-                    type: array
-                    items:
-                      type: string
-                      example: "ResourceManager"
@@ -1,6 +1,7 @@
 #include "ArgsParser.h"
 #include "Common.h"
 #include <algorithm>
+#include <doctest/doctest.h>

 void ArgsParser::Parse(const std::vector<std::string_view>& ArgList) {
    for (const auto& Arg : ArgList) {
@@ -92,3 +93,78 @@ void ArgsParser::ConsumeLongFlag(const std::string& Arg) {
        beammp_warn("Argument '" + Name + "' was supplied but isn't a known argument, so it is likely being ignored.");
    }
 }
+
+TEST_CASE("ArgsParser") {
+    ArgsParser parser;
+
+    SUBCASE("Simple args") {
+        parser.RegisterArgument({ "a" }, ArgsParser::Flags::NONE);
+        parser.RegisterArgument({ "hello" }, ArgsParser::Flags::NONE);
+        parser.Parse({ "--a", "--hello" });
+        CHECK(parser.Verify());
+        CHECK(parser.FoundArgument({ "a" }));
+        CHECK(parser.FoundArgument({ "hello" }));
+        CHECK(parser.FoundArgument({ "a", "hello" }));
+        CHECK(!parser.FoundArgument({ "b" }));
+        CHECK(!parser.FoundArgument({ "goodbye" }));
+    }
+
+    SUBCASE("No args") {
+        parser.RegisterArgument({ "a" }, ArgsParser::Flags::NONE);
+        parser.RegisterArgument({ "hello" }, ArgsParser::Flags::NONE);
+        parser.Parse({});
+        CHECK(parser.Verify());
+        CHECK(!parser.FoundArgument({ "a" }));
+        CHECK(!parser.FoundArgument({ "hello" }));
+        CHECK(!parser.FoundArgument({ "a", "hello" }));
+        CHECK(!parser.FoundArgument({ "b" }));
+        CHECK(!parser.FoundArgument({ "goodbye" }));
+        CHECK(!parser.FoundArgument({ "" }));
+    }
+
+    SUBCASE("Value args") {
+        parser.RegisterArgument({ "a" }, ArgsParser::Flags::HAS_VALUE);
+        parser.RegisterArgument({ "hello" }, ArgsParser::Flags::HAS_VALUE);
+        parser.Parse({ "--a=5", "--hello=world" });
+        CHECK(parser.Verify());
+        REQUIRE(parser.FoundArgument({ "a" }));
+        REQUIRE(parser.FoundArgument({ "hello" }));
+        CHECK(parser.GetValueOfArgument({ "a" }).has_value());
+        CHECK(parser.GetValueOfArgument({ "a" }).value() == "5");
+        CHECK(parser.GetValueOfArgument({ "hello" }).has_value());
+        CHECK(parser.GetValueOfArgument({ "hello" }).value() == "world");
+    }
+
+    SUBCASE("Mixed value & no-value args") {
+        parser.RegisterArgument({ "a" }, ArgsParser::Flags::HAS_VALUE);
+        parser.RegisterArgument({ "hello" }, ArgsParser::Flags::NONE);
+        parser.Parse({ "--a=5", "--hello" });
+        CHECK(parser.Verify());
+        REQUIRE(parser.FoundArgument({ "a" }));
+        REQUIRE(parser.FoundArgument({ "hello" }));
+        CHECK(parser.GetValueOfArgument({ "a" }).has_value());
+        CHECK(parser.GetValueOfArgument({ "a" }).value() == "5");
+        CHECK(!parser.GetValueOfArgument({ "hello" }).has_value());
+    }
+
+    SUBCASE("Required args") {
+        SUBCASE("Two required, two present") {
+            parser.RegisterArgument({ "a" }, ArgsParser::Flags::REQUIRED);
+            parser.RegisterArgument({ "hello" }, ArgsParser::Flags::REQUIRED);
+            parser.Parse({ "--a", "--hello" });
+            CHECK(parser.Verify());
+        }
+        SUBCASE("Two required, one present") {
+            parser.RegisterArgument({ "a" }, ArgsParser::Flags::REQUIRED);
+            parser.RegisterArgument({ "hello" }, ArgsParser::Flags::REQUIRED);
+            parser.Parse({ "--a" });
+            CHECK(!parser.Verify());
+        }
+        SUBCASE("Two required, none present") {
+            parser.RegisterArgument({ "a" }, ArgsParser::Flags::REQUIRED);
+            parser.RegisterArgument({ "hello" }, ArgsParser::Flags::REQUIRED);
+            parser.Parse({ "--b" });
+            CHECK(!parser.Verify());
+        }
+    }
+}
@@ -12,6 +12,9 @@
 #include "CustomAssert.h"
 #include "Http.h"

+// global, yes, this is ugly, no, it cant be done another way
+TSentry Sentry {};
+
 Application::TSettings Application::Settings = {};

 void Application::RegisterShutdownHandler(const TShutdownHandler& Handler) {
@@ -22,6 +25,7 @@ void Application::RegisterShutdownHandler(const TShutdownHandler& Handler) {
 }

 void Application::GracefullyShutdown() {
+    SetShutdown(true);
    static bool AlreadyShuttingDown = false;
    static uint8_t ShutdownAttempts = 0;
    if (AlreadyShuttingDown) {
@@ -61,6 +65,23 @@ std::array<uint8_t, 3> Application::VersionStrToInts(const std::string& str) {
    return Version;
 }

+TEST_CASE("Application::VersionStrToInts") {
+    auto v = Application::VersionStrToInts("1.2.3");
+    CHECK(v[0] == 1);
+    CHECK(v[1] == 2);
+    CHECK(v[2] == 3);
+
+    v = Application::VersionStrToInts("10.20.30");
+    CHECK(v[0] == 10);
+    CHECK(v[1] == 20);
+    CHECK(v[2] == 30);
+
+    v = Application::VersionStrToInts("100.200.255");
+    CHECK(v[0] == 100);
+    CHECK(v[1] == 200);
+    CHECK(v[2] == 255);
+}
+
 bool Application::IsOutdated(const Version& Current, const Version& Newest) {
    if (Newest.major > Current.major) {
        return true;
@@ -73,6 +94,65 @@ bool Application::IsOutdated(const Version& Current, const Version& Newest) {
    }
 }

+bool Application::IsShuttingDown() {
+    std::shared_lock Lock(mShutdownMtx);
+    return mShutdown;
+}
+
+void Application::SleepSafeSeconds(size_t Seconds) {
+    // Sleeps for 500 ms, checks if a shutdown occurred, and so forth
+    for (size_t i = 0; i < Seconds * 2; ++i) {
+        if (Application::IsShuttingDown()) {
+            return;
+        } else {
+            std::this_thread::sleep_for(std::chrono::milliseconds(500));
+        }
+    }
+}
+
+TEST_CASE("Application::IsOutdated (version check)") {
+    SUBCASE("Same version") {
+        CHECK(!Application::IsOutdated({ 1, 2, 3 }, { 1, 2, 3 }));
+    }
+    // we need to use over 1-2 digits to test against lexical comparisons
+    SUBCASE("Patch outdated") {
+        for (uint8_t Patch = 0; Patch < 10; ++Patch) {
+            for (uint8_t Minor = 0; Minor < 10; ++Minor) {
+                for (uint8_t Major = 0; Major < 10; ++Major) {
+                    CHECK(Application::IsOutdated({ uint8_t(Major), uint8_t(Minor), uint8_t(Patch) }, { uint8_t(Major), uint8_t(Minor), uint8_t(Patch + 1) }));
+                }
+            }
+        }
+    }
+    SUBCASE("Minor outdated") {
+        for (uint8_t Patch = 0; Patch < 10; ++Patch) {
+            for (uint8_t Minor = 0; Minor < 10; ++Minor) {
+                for (uint8_t Major = 0; Major < 10; ++Major) {
+                    CHECK(Application::IsOutdated({ uint8_t(Major), uint8_t(Minor), uint8_t(Patch) }, { uint8_t(Major), uint8_t(Minor + 1), uint8_t(Patch) }));
+                }
+            }
+        }
+    }
+    SUBCASE("Major outdated") {
+        for (uint8_t Patch = 0; Patch < 10; ++Patch) {
+            for (uint8_t Minor = 0; Minor < 10; ++Minor) {
+                for (uint8_t Major = 0; Major < 10; ++Major) {
+                    CHECK(Application::IsOutdated({ uint8_t(Major), uint8_t(Minor), uint8_t(Patch) }, { uint8_t(Major + 1), uint8_t(Minor), uint8_t(Patch) }));
+                }
+            }
+        }
+    }
+    SUBCASE("All outdated") {
+        for (uint8_t Patch = 0; Patch < 10; ++Patch) {
+            for (uint8_t Minor = 0; Minor < 10; ++Minor) {
+                for (uint8_t Major = 0; Major < 10; ++Major) {
+                    CHECK(Application::IsOutdated({ uint8_t(Major), uint8_t(Minor), uint8_t(Patch) }, { uint8_t(Major + 1), uint8_t(Minor + 1), uint8_t(Patch + 1) }));
+                }
+            }
+        }
+    }
+}
+
 void Application::SetSubsystemStatus(const std::string& Subsystem, Status status) {
    switch (status) {
    case Status::Good:
@@ -95,6 +175,20 @@ void Application::SetSubsystemStatus(const std::string& Subsystem, Status status
    mSystemStatusMap[Subsystem] = status;
 }

+void Application::SetShutdown(bool Val) {
+    std::unique_lock Lock(mShutdownMtx);
+    mShutdown = Val;
+}
+
+TEST_CASE("Application::SetSubsystemStatus") {
+    Application::SetSubsystemStatus("Test", Application::Status::Good);
+    auto Map = Application::GetSubsystemStatuses();
+    CHECK(Map.at("Test") == Application::Status::Good);
+    Application::SetSubsystemStatus("Test", Application::Status::Bad);
+    Map = Application::GetSubsystemStatuses();
+    CHECK(Map.at("Test") == Application::Status::Bad);
+}
+
 void Application::CheckForUpdates() {
    Application::SetSubsystemStatus("UpdateCheck", Application::Status::Starting);
    static bool FirstTime = true;
@@ -152,6 +246,25 @@ std::string ThreadName(bool DebugModeOverride) {
    return "";
 }

+TEST_CASE("ThreadName") {
+    RegisterThread("MyThread");
+    auto OrigDebug = Application::Settings.DebugModeEnabled;
+
+    // ThreadName adds a space at the end, legacy but we need it still
+    SUBCASE("Debug mode enabled") {
+        Application::Settings.DebugModeEnabled = true;
+        CHECK(ThreadName(true) == "MyThread ");
+        CHECK(ThreadName(false) == "MyThread ");
+    }
+    SUBCASE("Debug mode disabled") {
+        Application::Settings.DebugModeEnabled = false;
+        CHECK(ThreadName(true) == "MyThread ");
+        CHECK(ThreadName(false) == "");
+    }
+    // cleanup
+    Application::Settings.DebugModeEnabled = OrigDebug;
+}
+
 void RegisterThread(const std::string& str) {
    std::string ThreadId;
 #ifdef BEAMMP_WINDOWS
@@ -169,6 +282,11 @@ void RegisterThread(const std::string& str) {
    threadNameMap[std::this_thread::get_id()] = str;
 }

+TEST_CASE("RegisterThread") {
+    RegisterThread("MyThread");
+    CHECK(threadNameMap.at(std::this_thread::get_id()) == "MyThread");
+}
+
 Version::Version(uint8_t major, uint8_t minor, uint8_t patch)
    : major(major)
    , minor(minor)
@@ -182,6 +300,12 @@ std::string Version::AsString() {
    return fmt::format("{:d}.{:d}.{:d}", major, minor, patch);
 }

+TEST_CASE("Version::AsString") {
+    CHECK(Version { 0, 0, 0 }.AsString() == "0.0.0");
+    CHECK(Version { 1, 2, 3 }.AsString() == "1.2.3");
+    CHECK(Version { 255, 255, 255 }.AsString() == "255.255.255");
+}
+
 void LogChatMessage(const std::string& name, int id, const std::string& msg) {
    if (Application::Settings.LogChat) {
        std::stringstream ss;
@@ -193,7 +317,9 @@ void LogChatMessage(const std::string& name, int id, const std::string& msg) {
            ss << name << "";
        }
        ss << msg;
+#ifdef DOCTEST_CONFIG_DISABLE
        Application::Console().Write(ss.str());
+#endif
    }
 }

@@ -1,5 +1,8 @@
 #include "Compat.h"

+#include <cstring>
+#include <doctest/doctest.h>
+
 #ifndef WIN32

 static struct termios old, current;
@@ -20,6 +23,23 @@ void resetTermios(void) {
    tcsetattr(0, TCSANOW, &old);
 }

+TEST_CASE("init and reset termios") {
+    if (isatty(STDIN_FILENO)) {
+        struct termios original;
+        tcgetattr(0, &original);
+        SUBCASE("no echo") {
+            initTermios(false);
+        }
+        SUBCASE("yes echo") {
+            initTermios(true);
+        }
+        resetTermios();
+        struct termios current;
+        tcgetattr(0, &current);
+        CHECK(std::memcmp(&original, &current, sizeof(struct termios)) == 0);
+    }
+}
+
 char getch_(int echo) {
    char ch;
    initTermios(echo);
@@ -4,9 +4,6 @@
 #include "Common.h"
 #include "CustomAssert.h"
 #include "LuaAPI.h"
-#include "TNetwork.h"
-#include "TResourceManager.h"
-#include "TServer.h"
 #include "httplib.h"

 #include <map>
@@ -145,115 +142,29 @@ std::string Http::Status::ToString(int Code) {
    }
 }

-#define API_V1 "/api/v1"
-
-Http::Server::THttpServerInstance::THttpServerInstance(TServer& Server, TNetwork& Network, TResourceManager& ResMan)
-    : mServer(Server)
-    , mNetwork(Network)
-    , mResourceManager(ResMan) {
-    Application::SetSubsystemStatus("HTTPServer", Application::Status::Starting);
-    mThread = std::thread(&Http::Server::THttpServerInstance::operator(), this);
+TEST_CASE("Http::Status::ToString") {
+    CHECK(Http::Status::ToString(200) == "OK");
+    CHECK(Http::Status::ToString(696969) == "696969");
+    CHECK(Http::Status::ToString(-1) == "Invalid Response Code");
 }

-Http::Server::THttpServerInstance::~THttpServerInstance() {
+Http::Server::THttpServerInstance::THttpServerInstance() {
+    Application::SetSubsystemStatus("HTTPServer", Application::Status::Starting);
+    mThread = std::thread(&Http::Server::THttpServerInstance::operator(), this);
    mThread.detach();
 }

 void Http::Server::THttpServerInstance::operator()() try {
-    beammp_infof("HTTP Server starting on [{}]:{}", Application::Settings.HTTPServerIP, Application::Settings.HTTPServerPort);
-    if (Application::Settings.Private
-        && Application::Settings.HTTPServerIP != "::"
-        && Application::Settings.HTTPServerIP != "localhost"
-        && Application::Settings.HTTPServerIP != "127.0.0.1") {
-        beammp_warnf("HTTP Server is running on a possibly public IP ({}), but the server is private. The server's HTTP API supports viewing config, players, and other information, even though the server is private. (this is not an error)", Application::Settings.HTTPServerIP);
-    }
-    std::unique_ptr<httplib::Server> Server = std::make_unique<httplib::Server>();
-
-    Server->Get(API_V1 R"(/player/(.+)/vehicles)", [this](const httplib::Request& Req, httplib::Response& Res) {
-        if (Req.matches.empty()) {
-            Res.status = 404;
-        } else {
-            const std::string PlayerName = Req.matches[1];
-            bool Found = false;
-            json Result = json::array();
-            mServer.ForEachClient([&](std::weak_ptr<TClient> ClientPtr) {
-                if (!ClientPtr.expired()) {
-                    const auto Client = ClientPtr.lock();
-                    if (Client->GetName() == PlayerName) {
-                        const auto [Cars, Lock] = Client->GetAllCars();
-                        for (const auto& Car : *Cars) {
-                            Result.emplace_back().at("jbm") = Car.Json().at("jbm");
-                        }
-                        Found = true;
-                    }
-                }
-                return true;
-            });
-            if (!Found) {
-                Res.status = 404;
-            } else {
-                Res.status = 200;
-                Res.set_content(Result.dump(), "application/json");
-            }
-        }
+    beammp_info("HTTP(S) Server started on port " + std::to_string(Application::Settings.HTTPServerPort));
+    std::unique_ptr<httplib::Server> HttpLibServerInstance;
+    HttpLibServerInstance = std::make_unique<httplib::Server>();
+    // todo: make this IP agnostic so people can set their own IP
+    HttpLibServerInstance->Get("/", [](const httplib::Request&, httplib::Response& res) {
+        res.set_content("<!DOCTYPE html><article><h1>Hello World!</h1><section><p>BeamMP Server can now serve HTTP requests!</p></section></article></html>", "text/html");
    });
-
-    Server->Get(API_V1 "/players", [this](const httplib::Request&, httplib::Response& res) {
-        res.status = 200;
-        json Players = json::array();
-        mServer.ForEachClient([&](std::weak_ptr<TClient> ClientPtr) {
-            if (!ClientPtr.expired()) {
-                Players.push_back(ClientPtr.lock()->GetName());
-            }
-            return true;
-        });
-        res.set_content(Players.dump(),
-            "application/json");
-    });
-
-    Server->Get(API_V1 "/version", [](const httplib::Request&, httplib::Response& res) {
-        res.status = 200;
-        res.set_content(Application::ServerVersionString(), "text/plain");
-    });
-
-    Server->Get(API_V1 "/config", [](const httplib::Request&, httplib::Response& res) {
-        res.status = 200;
-        res.set_content(json {
-                            { "name", Application::Settings.ServerName },
-                            { "description", Application::Settings.ServerDesc },
-                            { "max_players", Application::Settings.MaxPlayers },
-                            { "max_cars", Application::Settings.MaxCars },
-                            { "map", Application::Settings.MapName },
-                            { "private", Application::Settings.Private },
-                        }
-                            .dump(),
-            "application/json");
-    });
-
-    Server->Get(API_V1 "/ready", [](const httplib::Request&, httplib::Response& res) {
-        auto Statuses = Application::GetSubsystemStatuses();
-        bool Started = true;
-        for (const auto& NameStatusPair : Statuses) {
-            switch (NameStatusPair.second) {
-            case Application::Status::Starting:
-            case Application::Status::ShuttingDown:
-            case Application::Status::Shutdown:
-                Started = false;
-                break;
-            case Application::Status::Good:
-            case Application::Status::Bad:
-                break;
-            }
-        }
-        res.status = 200;
-        res.set_content(Started ? "true" : "false", "text/plain");
-    });
-
-    Server->Get(API_V1 "/health", [](const httplib::Request&, httplib::Response& res) {
+    HttpLibServerInstance->Get("/health", [](const httplib::Request&, httplib::Response& res) {
        size_t SystemsGood = 0;
        size_t SystemsBad = 0;
-        json Good = json::array();
-        json Bad = json::array();
        auto Statuses = Application::GetSubsystemStatuses();
        for (const auto& NameStatusPair : Statuses) {
            switch (NameStatusPair.second) {
@@ -261,44 +172,30 @@ void Http::Server::THttpServerInstance::operator()() try {
            case Application::Status::ShuttingDown:
            case Application::Status::Shutdown:
            case Application::Status::Good:
-                Good.push_back(NameStatusPair.first);
                SystemsGood++;
                break;
            case Application::Status::Bad:
-                Bad.push_back(NameStatusPair.first);
                SystemsBad++;
                break;
            }
        }
        res.set_content(
            json {
-                { "healthy", SystemsBad == 0 },
-                { "good", Good },
-                { "bad", Bad },
+                { "ok", SystemsBad == 0 },
            }
                .dump(),
            "application/json");
        res.status = 200;
    });
    // magic endpoint
-    Server->Get({ 0x2f, 0x6b, 0x69, 0x74, 0x74, 0x79 }, [](const httplib::Request&, httplib::Response& res) {
+    HttpLibServerInstance->Get({ 0x2f, 0x6b, 0x69, 0x74, 0x74, 0x79 }, [](const httplib::Request&, httplib::Response& res) {
        res.set_content(std::string(Magic), "text/plain");
    });
-    Server->set_logger([](const httplib::Request& Req, const httplib::Response& Res) {
+    HttpLibServerInstance->set_logger([](const httplib::Request& Req, const httplib::Response& Res) {
        beammp_debug("Http Server: " + Req.method + " " + Req.target + " -> " + std::to_string(Res.status));
    });
-    Server->set_error_handler([](const httplib::Request&, httplib::Response& Res) {
-        if (Res.status >= 400 && Res.body.empty()) {
-            Res.set_content("Error: " + std::to_string(Res.status) + " " + Map.at(Res.status), "text/plain");
-        }
-    });
-    Server->set_exception_handler([](const httplib::Request& Req, httplib::Response& Res, std::exception& e) {
-        Res.status = 500;
-        Res.set_content("Internal Server Error", "text/plain");
-        beammp_errorf("Exception in http server serving '{}': {}", Req.target, e.what());
-    });
    Application::SetSubsystemStatus("HTTPServer", Application::Status::Good);
-    auto ret = Server->listen(Application::Settings.HTTPServerIP.c_str(), Application::Settings.HTTPServerPort);
+    auto ret = HttpLibServerInstance->listen(Application::Settings.HTTPServerIP.c_str(), Application::Settings.HTTPServerPort);
    if (!ret) {
        beammp_error("Failed to start http server (failed to listen). Please ensure the http server is configured properly in the ServerConfig.toml, or turn it off if you don't need it.");
    }
@@ -102,6 +102,14 @@ void LuaAPI::Print(sol::variadic_args Args) {
    luaprint(ToPrint);
 }

+TEST_CASE("LuaAPI::MP::GetServerVersion") {
+    const auto [ma, mi, pa] = LuaAPI::MP::GetServerVersion();
+    const auto real = Application::ServerVersion();
+    CHECK(ma == real.major);
+    CHECK(mi == real.minor);
+    CHECK(pa == real.patch);
+}
+
 static inline bool InternalTriggerClientEvent(int PlayerID, const std::string& EventName, const std::string& Data) {
    std::string Packet = "E:" + EventName + ":" + Data;
    if (PlayerID == -1)
@@ -176,50 +184,57 @@ void LuaAPI::MP::Set(int ConfigID, sol::object NewValue) {
        if (NewValue.is<bool>()) {
            Application::Settings.DebugModeEnabled = NewValue.as<bool>();
            beammp_info(std::string("Set `Debug` to ") + (Application::Settings.DebugModeEnabled ? "true" : "false"));
-        } else
+        } else {
            beammp_lua_error("set invalid argument [2] expected boolean");
+        }
        break;
    case 1: // private
        if (NewValue.is<bool>()) {
            Application::Settings.Private = NewValue.as<bool>();
            beammp_info(std::string("Set `Private` to ") + (Application::Settings.Private ? "true" : "false"));
-        } else
+        } else {
            beammp_lua_error("set invalid argument [2] expected boolean");
+        }
        break;
    case 2: // max cars
        if (NewValue.is<int>()) {
            Application::Settings.MaxCars = NewValue.as<int>();
            beammp_info(std::string("Set `MaxCars` to ") + std::to_string(Application::Settings.MaxCars));
-        } else
+        } else {
            beammp_lua_error("set invalid argument [2] expected integer");
+        }
        break;
    case 3: // max players
        if (NewValue.is<int>()) {
            Application::Settings.MaxPlayers = NewValue.as<int>();
            beammp_info(std::string("Set `MaxPlayers` to ") + std::to_string(Application::Settings.MaxPlayers));
-        } else
+        } else {
            beammp_lua_error("set invalid argument [2] expected integer");
+        }
        break;
    case 4: // Map
        if (NewValue.is<std::string>()) {
            Application::Settings.MapName = NewValue.as<std::string>();
            beammp_info(std::string("Set `Map` to ") + Application::Settings.MapName);
-        } else
+        } else {
            beammp_lua_error("set invalid argument [2] expected string");
+        }
        break;
    case 5: // Name
        if (NewValue.is<std::string>()) {
            Application::Settings.ServerName = NewValue.as<std::string>();
            beammp_info(std::string("Set `Name` to ") + Application::Settings.ServerName);
-        } else
+        } else {
            beammp_lua_error("set invalid argument [2] expected string");
+        }
        break;
    case 6: // Desc
        if (NewValue.is<std::string>()) {
            Application::Settings.ServerDesc = NewValue.as<std::string>();
            beammp_info(std::string("Set `Description` to ") + Application::Settings.ServerDesc);
-        } else
+        } else {
            beammp_lua_error("set invalid argument [2] expected string");
+        }
        break;
    default:
        beammp_warn("Invalid config ID \"" + std::to_string(ConfigID) + "\". Use `MP.Settings.*` enum for this.");
@@ -255,7 +270,9 @@ void LuaAPI::MP::PrintRaw(sol::variadic_args Args) {
        ToPrint += LuaToString(static_cast<const sol::object>(Arg));
        ToPrint += "\t";
    }
+#ifdef DOCTEST_CONFIG_DISABLE
    Application::Console().WriteRaw(ToPrint);
+#endif
 }

 int LuaAPI::PanicHandler(lua_State* State) {
@@ -278,7 +295,7 @@ static std::pair<bool, std::string> FSWrapper(FnT Fn, ArgsT&&... Args) {
 std::pair<bool, std::string> LuaAPI::FS::CreateDirectory(const std::string& Path) {
    std::error_code errc;
    std::pair<bool, std::string> Result;
-    fs::create_directories(fs::relative(Path), errc);
+    fs::create_directories(Path, errc);
    Result.first = errc == std::error_code {};
    if (!Result.first) {
        Result.second = errc.message();
@@ -286,6 +303,33 @@ std::pair<bool, std::string> LuaAPI::FS::CreateDirectory(const std::string& Path
    return Result;
 }

+TEST_CASE("LuaAPI::FS::CreateDirectory") {
+    std::string TestDir = "beammp_test_dir";
+    fs::remove_all(TestDir);
+    SUBCASE("Single level dir") {
+        const auto [Ok, Err] = LuaAPI::FS::CreateDirectory(TestDir);
+        CHECK(Ok);
+        CHECK(Err == "");
+        CHECK(fs::exists(TestDir));
+    }
+    SUBCASE("Multi level dir") {
+        const auto [Ok, Err] = LuaAPI::FS::CreateDirectory(TestDir + "/a/b/c");
+        CHECK(Ok);
+        CHECK(Err == "");
+        CHECK(fs::exists(TestDir + "/a/b/c"));
+    }
+    SUBCASE("Already exists") {
+        const auto [Ok, Err] = LuaAPI::FS::CreateDirectory(TestDir);
+        CHECK(Ok);
+        CHECK(Err == "");
+        CHECK(fs::exists(TestDir));
+        const auto [Ok2, Err2] = LuaAPI::FS::CreateDirectory(TestDir);
+        CHECK(Ok2);
+        CHECK(Err2 == "");
+    }
+    fs::remove_all(TestDir);
+}
+
 std::pair<bool, std::string> LuaAPI::FS::Remove(const std::string& Path) {
    std::error_code errc;
    std::pair<bool, std::string> Result;
@@ -297,10 +341,30 @@ std::pair<bool, std::string> LuaAPI::FS::Remove(const std::string& Path) {
    return Result;
 }

+TEST_CASE("LuaAPI::FS::Remove") {
+    const std::string TestFileOrDir = "beammp_test_thing";
+    SUBCASE("Remove existing directory") {
+        fs::create_directory(TestFileOrDir);
+        const auto [Ok, Err] = LuaAPI::FS::Remove(TestFileOrDir);
+        CHECK(Ok);
+        CHECK_EQ(Err, "");
+        CHECK(!fs::exists(TestFileOrDir));
+    }
+    SUBCASE("Remove non-existing directory") {
+        fs::remove_all(TestFileOrDir);
+        const auto [Ok, Err] = LuaAPI::FS::Remove(TestFileOrDir);
+        CHECK(Ok);
+        CHECK_EQ(Err, "");
+        CHECK(!fs::exists(TestFileOrDir));
+    }
+    // TODO: add tests for files
+    // TODO: add tests for files and folders without access permissions (failure)
+}
+
 std::pair<bool, std::string> LuaAPI::FS::Rename(const std::string& Path, const std::string& NewPath) {
    std::error_code errc;
    std::pair<bool, std::string> Result;
-    fs::rename(fs::relative(Path), fs::relative(NewPath), errc);
+    fs::rename(Path, NewPath, errc);
    Result.first = errc == std::error_code {};
    if (!Result.first) {
        Result.second = errc.message();
@@ -308,10 +372,25 @@ std::pair<bool, std::string> LuaAPI::FS::Rename(const std::string& Path, const s
    return Result;
 }

+TEST_CASE("LuaAPI::FS::Rename") {
+    const auto TestDir = "beammp_test_dir";
+    const auto OtherTestDir = "beammp_test_dir_2";
+    fs::remove_all(OtherTestDir);
+    fs::create_directory(TestDir);
+    const auto [Ok, Err] = LuaAPI::FS::Rename(TestDir, OtherTestDir);
+    CHECK(Ok);
+    CHECK_EQ(Err, "");
+    CHECK(!fs::exists(TestDir));
+    CHECK(fs::exists(OtherTestDir));
+
+    fs::remove_all(OtherTestDir);
+    fs::remove_all(TestDir);
+}
+
 std::pair<bool, std::string> LuaAPI::FS::Copy(const std::string& Path, const std::string& NewPath) {
    std::error_code errc;
    std::pair<bool, std::string> Result;
-    fs::copy(fs::relative(Path), fs::relative(NewPath), fs::copy_options::recursive, errc);
+    fs::copy(Path, NewPath, fs::copy_options::recursive, errc);
    Result.first = errc == std::error_code {};
    if (!Result.first) {
        Result.second = errc.message();
@@ -319,30 +398,86 @@ std::pair<bool, std::string> LuaAPI::FS::Copy(const std::string& Path, const std
    return Result;
 }

+TEST_CASE("LuaAPI::FS::Copy") {
+    const auto TestDir = "beammp_test_dir";
+    const auto OtherTestDir = "beammp_test_dir_2";
+    fs::remove_all(OtherTestDir);
+    fs::create_directory(TestDir);
+    const auto [Ok, Err] = LuaAPI::FS::Copy(TestDir, OtherTestDir);
+    CHECK(Ok);
+    CHECK_EQ(Err, "");
+    CHECK(fs::exists(TestDir));
+    CHECK(fs::exists(OtherTestDir));
+
+    fs::remove_all(OtherTestDir);
+    fs::remove_all(TestDir);
+}
+
 bool LuaAPI::FS::Exists(const std::string& Path) {
-    return fs::exists(fs::relative(Path));
+    return fs::exists(Path);
+}
+
+TEST_CASE("LuaAPI::FS::Exists") {
+    const auto TestDir = "beammp_test_dir";
+    const auto OtherTestDir = "beammp_test_dir_2";
+    fs::remove_all(OtherTestDir);
+    fs::create_directory(TestDir);
+
+    CHECK(LuaAPI::FS::Exists(TestDir));
+    CHECK(!LuaAPI::FS::Exists(OtherTestDir));
+
+    fs::remove_all(OtherTestDir);
+    fs::remove_all(TestDir);
 }

 std::string LuaAPI::FS::GetFilename(const std::string& Path) {
    return fs::path(Path).filename().string();
 }

+TEST_CASE("LuaAPI::FS::GetFilename") {
+    CHECK(LuaAPI::FS::GetFilename("test.txt") == "test.txt");
+    CHECK(LuaAPI::FS::GetFilename("/test.txt") == "test.txt");
+    CHECK(LuaAPI::FS::GetFilename("place/test.txt") == "test.txt");
+    CHECK(LuaAPI::FS::GetFilename("/some/../place/test.txt") == "test.txt");
+}
+
 std::string LuaAPI::FS::GetExtension(const std::string& Path) {
    return fs::path(Path).extension().string();
 }

+TEST_CASE("LuaAPI::FS::GetExtension") {
+    CHECK(LuaAPI::FS::GetExtension("test.txt") == ".txt");
+    CHECK(LuaAPI::FS::GetExtension("/test.txt") == ".txt");
+    CHECK(LuaAPI::FS::GetExtension("place/test.txt") == ".txt");
+    CHECK(LuaAPI::FS::GetExtension("/some/../place/test.txt") == ".txt");
+    CHECK(LuaAPI::FS::GetExtension("/some/../place/test") == "");
+    CHECK(LuaAPI::FS::GetExtension("/some/../place/test.a.b.c") == ".c");
+    CHECK(LuaAPI::FS::GetExtension("/some/../place/test.") == ".");
+    CHECK(LuaAPI::FS::GetExtension("/some/../place/test.a.b.") == ".");
+}
+
 std::string LuaAPI::FS::GetParentFolder(const std::string& Path) {
    return fs::path(Path).parent_path().string();
 }

+TEST_CASE("LuaAPI::FS::GetParentFolder") {
+    CHECK(LuaAPI::FS::GetParentFolder("test.txt") == "");
+    CHECK(LuaAPI::FS::GetParentFolder("/test.txt") == "/");
+    CHECK(LuaAPI::FS::GetParentFolder("place/test.txt") == "place");
+    CHECK(LuaAPI::FS::GetParentFolder("/some/../place/test.txt") == "/some/../place");
+}
+
+// TODO: add tests
 bool LuaAPI::FS::IsDirectory(const std::string& Path) {
    return fs::is_directory(Path);
 }

+// TODO: add tests
 bool LuaAPI::FS::IsFile(const std::string& Path) {
    return fs::is_regular_file(Path);
 }

+// TODO: add tests
 std::string LuaAPI::FS::ConcatPaths(sol::variadic_args Args) {
    fs::path Path;
    for (size_t i = 0; i < Args.size(); ++i) {
@@ -18,6 +18,7 @@ static constexpr std::string_view StrDescription = "Description";
 static constexpr std::string_view StrResourceFolder = "ResourceFolder";
 static constexpr std::string_view StrAuthKey = "AuthKey";
 static constexpr std::string_view StrLogChat = "LogChat";
+static constexpr std::string_view StrDownloadThreads = "DownloadThreads";

 // Misc
 static constexpr std::string_view StrSendErrors = "SendErrors";
@@ -27,15 +28,42 @@ static constexpr std::string_view StrHideUpdateMessages = "ImScaredOfUpdates";
 // HTTP
 static constexpr std::string_view StrHTTPServerEnabled = "HTTPServerEnabled";
 static constexpr std::string_view StrHTTPServerUseSSL = "UseSSL";
+static constexpr std::string_view StrSSLKeyPath = "SSLKeyPath";
+static constexpr std::string_view StrSSLCertPath = "SSLCertPath";
 static constexpr std::string_view StrHTTPServerPort = "HTTPServerPort";
 static constexpr std::string_view StrHTTPServerIP = "HTTPServerIP";

+TEST_CASE("TConfig::TConfig") {
+    const std::string CfgFile = "beammp_server_testconfig.toml";
+    fs::remove(CfgFile);
+
+    TConfig Cfg(CfgFile);
+
+    CHECK(fs::file_size(CfgFile) != 0);
+
+    std::string buf;
+    {
+        buf.resize(fs::file_size(CfgFile));
+        auto fp = std::fopen(CfgFile.c_str(), "r");
+        std::fread(buf.data(), 1, buf.size(), fp);
+        std::fclose(fp);
+    }
+    INFO("file contents are:", buf);
+
+    const auto table = toml::parse(CfgFile);
+    CHECK(table.at("General").is_table());
+    CHECK(table.at("Misc").is_table());
+    CHECK(table.at("HTTP").is_table());
+
+    fs::remove(CfgFile);
+}
+
 TConfig::TConfig(const std::string& ConfigFileName)
    : mConfigFileName(ConfigFileName) {
    Application::SetSubsystemStatus("Config", Application::Status::Starting);
    if (!fs::exists(mConfigFileName) || !fs::is_regular_file(mConfigFileName)) {
        beammp_info("No config file found! Generating one...");
-        CreateConfigFile(mConfigFileName);
+        CreateConfigFile();
    }
    if (!mFailed) {
        if (fs::exists("Server.cfg")) {
@@ -61,7 +89,8 @@ void SetComment(CommentsT& Comments, const std::string& Comment) {
 * whether it is in TConfig.cpp or the configuration file.
 */
 void TConfig::FlushToFile() {
-    auto data = toml::parse<toml::preserve_comments>(mConfigFileName);
+    // auto data = toml::parse<toml::preserve_comments>(mConfigFileName);
+    auto data = toml::value {};
    data["General"][StrAuthKey.data()] = Application::Settings.Key;
    SetComment(data["General"][StrAuthKey.data()].comments(), " AuthKey has to be filled out in order to run the server");
    data["General"][StrLogChat.data()] = Application::Settings.LogChat;
@@ -75,6 +104,8 @@ void TConfig::FlushToFile() {
    data["General"][StrMap.data()] = Application::Settings.MapName;
    data["General"][StrDescription.data()] = Application::Settings.ServerDesc;
    data["General"][StrResourceFolder.data()] = Application::Settings.Resource;
+    data["General"][StrDownloadThreads.data()] = Application::Settings.DownloadThreads;
+    SetComment(data["General"][StrDownloadThreads.data()].comments(), " How many simultaneous downloads may run at the same time");
    // Misc
    data["Misc"][StrHideUpdateMessages.data()] = Application::Settings.HideUpdateMessages;
    SetComment(data["Misc"][StrHideUpdateMessages.data()].comments(), " Hides the periodic update message which notifies you of a new server version. You should really keep this on and always update as soon as possible. For more information visit https://wiki.beammp.com/en/home/server-maintenance#updating-the-server. An update message will always appear at startup regardless.");
@@ -83,16 +114,34 @@ void TConfig::FlushToFile() {
    data["Misc"][StrSendErrorsMessageEnabled.data()] = Application::Settings.SendErrorsMessageEnabled;
    SetComment(data["Misc"][StrSendErrorsMessageEnabled.data()].comments(), " If SendErrors is `true`, the server will send helpful info about crashes and other issues back to the BeamMP developers. This info may include your config, who is on your server at the time of the error, and similar general information. This kind of data is vital in helping us diagnose and fix issues faster. This has no impact on server performance. You can opt-out of this system by setting this to `false`");
    // HTTP
+    data["HTTP"][StrSSLKeyPath.data()] = Application::Settings.SSLKeyPath;
+    data["HTTP"][StrSSLCertPath.data()] = Application::Settings.SSLCertPath;
    data["HTTP"][StrHTTPServerPort.data()] = Application::Settings.HTTPServerPort;
    SetComment(data["HTTP"][StrHTTPServerIP.data()].comments(), " Which IP to listen on. Pick 0.0.0.0 for a public-facing server with no specific IP, and 127.0.0.1 or 'localhost' for a local server.");
    data["HTTP"][StrHTTPServerIP.data()] = Application::Settings.HTTPServerIP;
+    data["HTTP"][StrHTTPServerUseSSL.data()] = Application::Settings.HTTPServerUseSSL;
+    SetComment(data["HTTP"][StrHTTPServerUseSSL.data()].comments(), " Recommended to have enabled for servers which face the internet. With SSL the server will serve https and requires valid key and cert files");
    data["HTTP"][StrHTTPServerEnabled.data()] = Application::Settings.HTTPServerEnabled;
    SetComment(data["HTTP"][StrHTTPServerEnabled.data()].comments(), " Enables the internal HTTP server");
-    std::ofstream Stream(mConfigFileName, std::ios::trunc | std::ios::out);
-    Stream << data << std::flush;
+    std::stringstream Ss;
+    Ss << "# This is the BeamMP-Server config file.\n"
+          "# Help & Documentation: `https://wiki.beammp.com/en/home/server-maintenance`\n"
+          "# IMPORTANT: Fill in the AuthKey with the key you got from `https://beammp.com/k/dashboard` on the left under \"Keys\"\n"
+       << data;
+    auto File = std::fopen(mConfigFileName.c_str(), "w+");
+    if (!File) {
+        beammp_error("Failed to create/write to config file: " + GetPlatformAgnosticErrorString());
+        throw std::runtime_error("Failed to create/write to config file");
+    }
+    auto Str = Ss.str();
+    auto N = std::fwrite(Str.data(), sizeof(char), Str.size(), File);
+    if (N != Str.size()) {
+        beammp_error("Failed to write to config file properly, config file might be misshapen");
+    }
+    std::fclose(File);
 }

-void TConfig::CreateConfigFile(std::string_view name) {
+void TConfig::CreateConfigFile() {
    // build from old config Server.cfg

    try {
@@ -104,32 +153,7 @@ void TConfig::CreateConfigFile(std::string_view name) {
        beammp_error("an error occurred and was ignored during config transfer: " + std::string(e.what()));
    }

-    { // create file context
-        std::ofstream ofs(name.data());
-    }
-
    FlushToFile();
-
-    size_t FileSize = fs::file_size(name);
-    std::fstream ofs { std::string(name), std::ios::in | std::ios::out };
-    if (ofs.good()) {
-        std::string Contents {};
-        Contents.resize(FileSize);
-        ofs.readsome(Contents.data(), FileSize);
-        ofs.seekp(0);
-        ofs << "# This is the BeamMP-Server config file.\n"
-               "# Help & Documentation: `https://wiki.beammp.com/en/home/server-maintenance`\n"
-               "# IMPORTANT: Fill in the AuthKey with the key you got from `https://beammp.com/k/dashboard` on the left under \"Keys\"\n"
-            << '\n'
-            << Contents;
-        beammp_error("There was no \"" + std::string(mConfigFileName) + "\" file (this is normal for the first time running the server), so one was generated for you. It was automatically filled with the settings from your Server.cfg, if you have one. Please open ServerConfig.toml and ensure your AuthKey and other settings are filled in and correct, then restart the server. The old Server.cfg file will no longer be used and causes a warning if it exists from now on.");
-        mFailed = true;
-        ofs.close();
-    } else {
-        beammp_error("Couldn't create " + std::string(name) + ". Check permissions, try again, and contact support if it continues not to work.");
-        Application::SetSubsystemStatus("Config", Application::Status::Bad);
-        mFailed = true;
-    }
 }

 void TConfig::TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, std::string& OutValue) {
@@ -165,14 +189,18 @@ void TConfig::ParseFromFile(std::string_view name) {
        TryReadValue(data, "General", StrResourceFolder, Application::Settings.Resource);
        TryReadValue(data, "General", StrAuthKey, Application::Settings.Key);
        TryReadValue(data, "General", StrLogChat, Application::Settings.LogChat);
+        TryReadValue(data, "General", StrDownloadThreads, Application::Settings.DownloadThreads);
        // Misc
        TryReadValue(data, "Misc", StrSendErrors, Application::Settings.SendErrors);
        TryReadValue(data, "Misc", StrHideUpdateMessages, Application::Settings.HideUpdateMessages);
        TryReadValue(data, "Misc", StrSendErrorsMessageEnabled, Application::Settings.SendErrorsMessageEnabled);
        // HTTP
+        TryReadValue(data, "HTTP", StrSSLKeyPath, Application::Settings.SSLKeyPath);
+        TryReadValue(data, "HTTP", StrSSLCertPath, Application::Settings.SSLCertPath);
        TryReadValue(data, "HTTP", StrHTTPServerPort, Application::Settings.HTTPServerPort);
        TryReadValue(data, "HTTP", StrHTTPServerIP, Application::Settings.HTTPServerIP);
        TryReadValue(data, "HTTP", StrHTTPServerEnabled, Application::Settings.HTTPServerEnabled);
+        TryReadValue(data, "HTTP", StrHTTPServerUseSSL, Application::Settings.HTTPServerUseSSL);
    } catch (const std::exception& err) {
        beammp_error("Error parsing config file value: " + std::string(err.what()));
        mFailed = true;
@@ -197,20 +225,26 @@ void TConfig::ParseFromFile(std::string_view name) {
 }

 void TConfig::PrintDebug() {
-    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));
-    beammp_debug(std::string(StrMaxCars) + ": " + std::to_string(Application::Settings.MaxCars));
-    beammp_debug(std::string(StrMaxPlayers) + ": " + std::to_string(Application::Settings.MaxPlayers));
-    beammp_debug(std::string(StrMap) + ": \"" + Application::Settings.MapName + "\"");
-    beammp_debug(std::string(StrName) + ": \"" + Application::Settings.ServerName + "\"");
-    beammp_debug(std::string(StrDescription) + ": \"" + Application::Settings.ServerDesc + "\"");
-    beammp_debug(std::string(StrLogChat) + ": \"" + (Application::Settings.LogChat ? "true" : "false") + "\"");
-    beammp_debug(std::string(StrResourceFolder) + ": \"" + Application::Settings.Resource + "\"");
-    beammp_debug(std::string(StrHTTPServerPort) + ": \"" + std::to_string(Application::Settings.HTTPServerPort) + "\"");
-    beammp_debug(std::string(StrHTTPServerIP) + ": \"" + Application::Settings.HTTPServerIP + "\"");
+    beammp_debugf("{}: {}", StrDebug, Application::Settings.DebugModeEnabled ? "true" : "false");
+    beammp_debugf("{}: {}", StrPrivate, Application::Settings.Private ? "true" : "false");
+    beammp_debugf("{}: {}", StrPort, Application::Settings.Port);
+    beammp_debugf("{}: {}", StrMaxCars, Application::Settings.MaxCars);
+    beammp_debugf("{}: {}", StrMaxPlayers, Application::Settings.MaxPlayers);
+    beammp_debugf("{}: '{}'", StrMap, Application::Settings.MapName);
+    beammp_debugf("{}: '{}'", StrName, Application::Settings.ServerName);
+    beammp_debugf("{}: '{}'", StrDescription, Application::Settings.ServerDesc);
+    beammp_debugf("{}: {}", StrLogChat, Application::Settings.LogChat ? "true" : "false");
+    beammp_debugf("{}: '{}'", StrResourceFolder, Application::Settings.Resource);
+    beammp_debugf("{}: '{}'", StrSSLKeyPath, Application::Settings.SSLKeyPath);
+    beammp_debugf("{}: '{}'", StrSSLCertPath, Application::Settings.SSLCertPath);
+    beammp_debugf("{}: {}", StrHTTPServerPort, Application::Settings.HTTPServerPort);
+    beammp_debugf("{}: '{}'", StrHTTPServerIP, Application::Settings.HTTPServerIP);
+    beammp_debugf("{}: {}", StrDownloadThreads, Application::Settings.DownloadThreads);
+    if (Application::Settings.DownloadThreads < 1) {
+        beammp_warnf("'{}' of <1 is not allowed, will use 1", StrDownloadThreads);
+    }
    // special!
-    beammp_debug("Key Length: " + std::to_string(Application::Settings.Key.length()) + "");
+    beammp_debugf("Key Length: {}", Application::Settings.Key.length());
 }

 void TConfig::ParseOldFormat() {
@@ -14,6 +14,17 @@ static inline bool StringStartsWith(const std::string& What, const std::string&
    return What.size() >= StartsWith.size() && What.substr(0, StartsWith.size()) == StartsWith;
 }

+TEST_CASE("StringStartsWith") {
+    CHECK(StringStartsWith("Hello, World", "Hello"));
+    CHECK(StringStartsWith("Hello, World", "H"));
+    CHECK(StringStartsWith("Hello, World", ""));
+    CHECK(!StringStartsWith("Hello, World", "ello"));
+    CHECK(!StringStartsWith("Hello, World", "World"));
+    CHECK(StringStartsWith("", ""));
+    CHECK(!StringStartsWith("", "hello"));
+}
+
+// Trims leading and trailing spaces, newlines, tabs, etc.
 static inline std::string TrimString(std::string S) {
    S.erase(S.begin(), std::find_if(S.begin(), S.end(), [](unsigned char ch) {
        return !std::isspace(ch);
@@ -25,6 +36,21 @@ static inline std::string TrimString(std::string S) {
    return S;
 }

+TEST_CASE("TrimString") {
+    CHECK(TrimString("hel lo") == "hel lo");
+    CHECK(TrimString(" hel lo") == "hel lo");
+    CHECK(TrimString(" hel lo ") == "hel lo");
+    CHECK(TrimString("hel lo     ") == "hel lo");
+    CHECK(TrimString("     hel lo") == "hel lo");
+    CHECK(TrimString("hel lo     ") == "hel lo");
+    CHECK(TrimString("    hel lo     ") == "hel lo");
+    CHECK(TrimString("\t\thel\nlo\n\n") == "hel\nlo");
+    CHECK(TrimString("\n\thel\tlo\n\t") == "hel\tlo");
+    CHECK(TrimString("  ") == "");
+    CHECK(TrimString(" \t\n\r ") == "");
+    CHECK(TrimString("") == "");
+}
+
 std::string GetDate() {
    std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
    time_t tt = std::chrono::system_clock::to_time_t(now);
@@ -201,7 +227,8 @@ void TConsole::Command_Help(const std::string&, const std::vector<std::string>&
        say <message>           sends the message to all players in chat
        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)";
+        status                  how the server is doing and what it's up to
+        clear                   clears the console window)";
    Application::Console().WriteRaw("BeamMP-Server Console: " + std::string(sHelpString));
 }

@@ -214,6 +241,13 @@ std::string TConsole::ConcatArgs(const std::vector<std::string>& args, char spac
    return Result;
 }

+void TConsole::Command_Clear(const std::string&, const std::vector<std::string>& args) {
+    if (!EnsureArgsCount(args, 0, size_t(-1))) {
+        return;
+    }
+    mCommandline.write("\x1b[;H\x1b[2J");
+}
+
 void TConsole::Command_Kick(const std::string&, const std::vector<std::string>& args) {
    if (!EnsureArgsCount(args, 1, size_t(-1))) {
        return;
@@ -7,6 +7,7 @@
 #include <rapidjson/rapidjson.h>
 #include <sstream>

+namespace json = rapidjson;

 void THeartbeatThread::operator()() {
    RegisterThread("Heartbeat");
@@ -19,7 +20,7 @@ void THeartbeatThread::operator()() {
    static std::chrono::high_resolution_clock::time_point LastNormalUpdateTime = std::chrono::high_resolution_clock::now();
    bool isAuth = false;
    size_t UpdateReminderCounter = 0;
-    while (!mShutdown) {
+    while (!Application::IsShuttingDown()) {
        ++UpdateReminderCounter;
        Body = GenerateCall();
        // a hot-change occurs when a setting has changed, to update the backend of that change.
@@ -56,7 +57,7 @@ void THeartbeatThread::operator()() {
        auto Target = "/heartbeat";
        unsigned int ResponseCode = 0;

-        rapidjson::Document Doc;
+        json::Document Doc;
        bool Ok = false;
        for (const auto& Url : Application::GetBackendUrlsInOrder()) {
            T = Http::POST(Url, 443, Target, Body, "application/x-www-form-urlencoded", &ResponseCode, { { "api-v", "2" } });
@@ -163,7 +164,6 @@ THeartbeatThread::THeartbeatThread(TResourceManager& ResourceManager, TServer& S
    Application::RegisterShutdownHandler([&] {
        Application::SetSubsystemStatus("Heartbeat", Application::Status::ShuttingDown);
        if (mThread.joinable()) {
-            mShutdown = true;
            mThread.join();
        }
        Application::SetSubsystemStatus("Heartbeat", Application::Status::Shutdown);
@@ -16,26 +16,29 @@
 TLuaEngine* LuaAPI::MP::Engine;

 TLuaEngine::TLuaEngine()
-    : mPluginMonitor(fs::path(Application::Settings.Resource) / "Server", *this, mShutdown) {
+    : mResourceServerPath(fs::path(Application::Settings.Resource) / "Server") {
    Application::SetSubsystemStatus("LuaEngine", Application::Status::Starting);
    LuaAPI::MP::Engine = this;
    if (!fs::exists(Application::Settings.Resource)) {
        fs::create_directory(Application::Settings.Resource);
    }
-    fs::path Path = fs::path(Application::Settings.Resource) / "Server";
-    if (!fs::exists(Path)) {
-        fs::create_directory(Path);
+    if (!fs::exists(mResourceServerPath)) {
+        fs::create_directory(mResourceServerPath);
    }
-    mResourceServerPath = Path;
    Application::RegisterShutdownHandler([&] {
        Application::SetSubsystemStatus("LuaEngine", Application::Status::ShuttingDown);
-        mShutdown = true;
        if (mThread.joinable()) {
            mThread.join();
        }
        Application::SetSubsystemStatus("LuaEngine", Application::Status::Shutdown);
    });
-    Start();
+    IThreaded::Start();
+}
+
+TEST_CASE("TLuaEngine ctor & dtor") {
+    Application::Settings.Resource = "beammp_server_test_resources";
+    TLuaEngine engine;
+    Application::GracefullyShutdown();
 }

 void TLuaEngine::operator()() {
@@ -54,30 +57,28 @@ void TLuaEngine::operator()() {

    auto ResultCheckThread = std::thread([&] {
        RegisterThread("ResultCheckThread");
-        while (!mShutdown) {
+        while (!Application::IsShuttingDown()) {
            std::unique_lock Lock(mResultsToCheckMutex);
-            mResultsToCheckCond.wait_for(Lock, std::chrono::milliseconds(20));
            if (!mResultsToCheck.empty()) {
                mResultsToCheck.remove_if([](const std::shared_ptr<TLuaResult>& Ptr) -> bool {
                    if (Ptr->Ready) {
-                        return true;
-                    } else if (Ptr->Error) {
-                        if (Ptr->ErrorMessage != BeamMPFnNotFoundError) {
-                            beammp_lua_error(Ptr->Function + ": " + Ptr->ErrorMessage);
+                        if (Ptr->Error) {
+                            if (Ptr->ErrorMessage != BeamMPFnNotFoundError) {
+                                beammp_lua_error(Ptr->Function + ": " + Ptr->ErrorMessage);
+                            }
                        }
                        return true;
                    }
                    return false;
                });
+            } else {
+                mResultsToCheckCond.wait_for(Lock, std::chrono::milliseconds(20));
            }
        }
    });
    // event loop
    auto Before = std::chrono::high_resolution_clock::now();
-    while (!mShutdown) {
-        if (mLuaStates.size() == 0) {
-            std::this_thread::sleep_for(std::chrono::seconds(100));
-        }
+    while (!Application::IsShuttingDown()) {
        { // Timed Events Scope
            std::unique_lock Lock(mTimedEventsMutex);
            for (auto& Timer : mTimedEvents) {
@@ -103,12 +104,18 @@ void TLuaEngine::operator()() {
                }
            }
        }
-        const auto Expected = std::chrono::milliseconds(10);
-        if (auto Diff = std::chrono::high_resolution_clock::now() - Before;
-            Diff < Expected) {
-            std::this_thread::sleep_for(Expected - Diff);
+        if (mLuaStates.size() == 0) {
+            beammp_trace("No Lua states, event loop running extremely sparsely");
+            Application::SleepSafeSeconds(10);
        } else {
-            beammp_trace("Event loop cannot keep up! Running " + std::to_string(Diff.count()) + "s behind");
+            constexpr double NsFactor = 1000000.0;
+            constexpr double Expected = 10.0; // ms
+            const auto Diff = (std::chrono::high_resolution_clock::now() - Before).count() / NsFactor;
+            if (Diff < Expected) {
+                std::this_thread::sleep_for(std::chrono::nanoseconds(size_t((Expected - Diff) * NsFactor)));
+            } else {
+                beammp_tracef("Event loop cannot keep up! Running {}ms behind", Diff);
+            }
        }
        Before = std::chrono::high_resolution_clock::now();
    }
@@ -155,7 +162,7 @@ void TLuaEngine::AddResultToCheck(const std::shared_ptr<TLuaResult>& Result) {
    mResultsToCheckCond.notify_one();
 }

-std::unordered_map<std::string /*event name */, std::vector<std::string> /* handlers */> TLuaEngine::Debug_GetEventsForState(TLuaStateId StateId) {
+std::unordered_map<std::string /* event name */, std::vector<std::string> /* handlers */> TLuaEngine::Debug_GetEventsForState(TLuaStateId StateId) {
    std::unordered_map<std::string, std::vector<std::string>> Result;
    std::unique_lock Lock(mLuaEventsMutex);
    for (const auto& EventNameToEventMap : mLuaEvents) {
@@ -269,6 +276,9 @@ std::shared_ptr<TLuaResult> TLuaEngine::EnqueueFunctionCall(TLuaStateId StateID,
 }

 void TLuaEngine::CollectAndInitPlugins() {
+    if (!fs::exists(mResourceServerPath)) {
+        fs::create_directories(mResourceServerPath);
+    }
    for (const auto& Dir : fs::directory_iterator(mResourceServerPath)) {
        auto Path = Dir.path();
        Path = fs::relative(Path);
@@ -318,7 +328,7 @@ void TLuaEngine::EnsureStateExists(TLuaStateId StateId, const std::string& Name,
    std::unique_lock Lock(mLuaStatesMutex);
    if (mLuaStates.find(StateId) == mLuaStates.end()) {
        beammp_debug("Creating lua state for state id \"" + StateId + "\"");
-        auto DataPtr = std::make_unique<StateThreadData>(Name, mShutdown, StateId, *this);
+        auto DataPtr = std::make_unique<StateThreadData>(Name, StateId, *this);
        mLuaStates[StateId] = std::move(DataPtr);
        RegisterEvent("onInit", StateId, "onInit");
        if (!DontCallOnInit) {
@@ -606,9 +616,8 @@ sol::table TLuaEngine::StateThreadData::Lua_JsonDecode(const std::string& str) {
    return table;
 }

-TLuaEngine::StateThreadData::StateThreadData(const std::string& Name, std::atomic_bool& Shutdown, TLuaStateId StateId, TLuaEngine& Engine)
+TLuaEngine::StateThreadData::StateThreadData(const std::string& Name, TLuaStateId StateId, TLuaEngine& Engine)
    : mName(Name)
-    , mShutdown(Shutdown)
    , mStateId(StateId)
    , mState(luaL_newstate())
    , mEngine(&Engine) {
@@ -811,7 +820,7 @@ void TLuaEngine::StateThreadData::RegisterEvent(const std::string& EventName, co

 void TLuaEngine::StateThreadData::operator()() {
    RegisterThread("Lua:" + mStateId);
-    while (!mShutdown) {
+    while (!Application::IsShuttingDown()) {
        { // StateExecuteQueue Scope
            std::unique_lock Lock(mStateExecuteQueueMutex);
            if (!mStateExecuteQueue.empty()) {
@@ -981,69 +990,3 @@ bool TLuaEngine::TimedEvent::Expired() {
 void TLuaEngine::TimedEvent::Reset() {
    LastCompletion = std::chrono::high_resolution_clock::now();
 }
-
-TPluginMonitor::TPluginMonitor(const fs::path& Path, TLuaEngine& Engine, std::atomic_bool& Shutdown)
-    : mEngine(Engine)
-    , mPath(Path)
-    , mShutdown(Shutdown) {
-    if (!fs::exists(mPath)) {
-        fs::create_directories(mPath);
-    }
-    for (const auto& Entry : fs::recursive_directory_iterator(mPath)) {
-        // TODO: trigger an event when a subfolder file changes
-        if (Entry.is_regular_file()) {
-            mFileTimes[Entry.path().string()] = fs::last_write_time(Entry.path());
-        }
-    }
-    Start();
-}
-
-void TPluginMonitor::operator()() {
-    RegisterThread("PluginMonitor");
-    beammp_info("PluginMonitor started");
-    while (!mShutdown) {
-        std::this_thread::sleep_for(std::chrono::seconds(3));
-        std::vector<std::string> ToRemove;
-        for (const auto& Pair : mFileTimes) {
-            try {
-                auto CurrentTime = fs::last_write_time(Pair.first);
-                if (CurrentTime != Pair.second) {
-                    mFileTimes[Pair.first] = CurrentTime;
-                    // grandparent of the path should be Resources/Server
-                    if (fs::equivalent(fs::path(Pair.first).parent_path().parent_path(), mPath)) {
-                        beammp_info("File \"" + Pair.first + "\" changed, reloading");
-                        // is in root folder, so reload
-                        std::ifstream FileStream(Pair.first, std::ios::in | std::ios::binary);
-                        auto Size = std::filesystem::file_size(Pair.first);
-                        auto Contents = std::make_shared<std::string>();
-                        Contents->resize(Size);
-                        FileStream.read(Contents->data(), Contents->size());
-                        TLuaChunk Chunk(Contents, Pair.first, fs::path(Pair.first).parent_path().string());
-                        auto StateID = mEngine.GetStateIDForPlugin(fs::path(Pair.first).parent_path());
-                        auto Res = mEngine.EnqueueScript(StateID, Chunk);
-                        // TODO: call onInit
-                        mEngine.AddResultToCheck(Res);
-                    } else {
-                        // TODO: trigger onFileChanged event
-                        beammp_trace("Change detected in file \"" + Pair.first + "\", event trigger not implemented yet");
-                        /*
-                        // is in subfolder, dont reload, just trigger an event
-                        auto Results = mEngine.TriggerEvent("onFileChanged", "", Pair.first);
-                        mEngine.WaitForAll(Results);
-                        for (const auto& Result : Results)  {
-                            if (Result->Error) {
-                                beammp_lua_error(Result->ErrorMessage);
-                            }
-                        }*/
-                    }
-                }
-            } catch (const std::exception& e) {
-                ToRemove.push_back(Pair.first);
-            }
-        }
-        for (const auto& File : ToRemove) {
-            mFileTimes.erase(File);
-            beammp_warn("file '" + File + "' couldn't be accessed, so it was removed from plugin hot reload monitor (probably got deleted)");
-        }
-    }
-}
@@ -6,6 +6,7 @@
 #include <Http.h>
 #include <array>
 #include <cstring>
+#include <dlhttp/dlhttp.h>

 TNetwork::TNetwork(TServer& Server, TPPSMonitor& PPSMonitor, TResourceManager& ResourceManager)
    : mServer(Server)
@@ -25,7 +26,6 @@ TNetwork::TNetwork(TServer& Server, TPPSMonitor& PPSMonitor, TResourceManager& R
    Application::RegisterShutdownHandler([&] {
        Application::SetSubsystemStatus("UDPNetwork", Application::Status::ShuttingDown);
        if (mUDPThread.joinable()) {
-            mShutdown = true;
            mUDPThread.detach();
        }
        Application::SetSubsystemStatus("UDPNetwork", Application::Status::Shutdown);
@@ -33,7 +33,6 @@ TNetwork::TNetwork(TServer& Server, TPPSMonitor& PPSMonitor, TResourceManager& R
    Application::RegisterShutdownHandler([&] {
        Application::SetSubsystemStatus("TCPNetwork", Application::Status::ShuttingDown);
        if (mTCPThread.joinable()) {
-            mShutdown = true;
            mTCPThread.detach();
        }
        Application::SetSubsystemStatus("TCPNetwork", Application::Status::Shutdown);
@@ -68,7 +67,7 @@ void TNetwork::UDPServerMain() {
    Application::SetSubsystemStatus("UDPNetwork", Application::Status::Good);
    beammp_info(("Vehicle data network online on port ") + std::to_string(Application::Settings.Port) + (" with a Max of ")
        + std::to_string(Application::Settings.MaxPlayers) + (" Clients"));
-    while (!mShutdown) {
+    while (!Application::IsShuttingDown()) {
        try {
            sockaddr_in client {};
            std::string Data = UDPRcvFromClient(client); // Receives any data from Socket
@@ -150,9 +149,15 @@ void TNetwork::TCPServerMain() {
    }
    Application::SetSubsystemStatus("TCPNetwork", Application::Status::Good);
    beammp_info("Vehicle event network online");
+    const auto ThreadCount = std::max(1, Application::Settings.DownloadThreads);
+    beammp_debugf("Using {} download threads", ThreadCount);
+    dlhttp::AsyncContext Ctx(ThreadCount);
+    dlhttp::EndpointHandlerMap Map {
+        { "/modlist", [this]() -> dlhttp::Response { return { mResourceManager.FileList() }; } },
+    };
    do {
        try {
-            if (mShutdown) {
+            if (Application::IsShuttingDown()) {
                beammp_debug("shutdown during TCP wait for accept loop");
                break;
            }
@@ -175,6 +180,15 @@ void TNetwork::TCPServerMain() {
            if (ret < 0) {
                throw std::runtime_error("setsockopt recv timeout: " + GetPlatformAgnosticErrorString());
            }
+
+            // check for http
+            if (dlhttp::is_http(client.Socket)) {
+                beammp_info("IS HTTP!");
+                dlhttp::handle_http(client.Socket, Ctx, Map);
+            } else {
+                beammp_info("IS NOT HTTP!");
+            }
+
            std::thread ID(&TNetwork::Identify, this, client);
            ID.detach(); // TODO: Add to a queue and attempt to join periodically
        } catch (const std::exception& e) {
@@ -194,6 +208,7 @@ void TNetwork::TCPServerMain() {
 #undef GetObject // Fixes Windows

 #include "Json.h"
+namespace json = rapidjson;

 void TNetwork::Identify(const TConnection& client) {
    RegisterThreadAuto();
@@ -238,13 +253,26 @@ void TNetwork::HandleDownload(SOCKET TCPSock) {
    });
 }

+static int get_ip_str(const struct sockaddr* sa, char* strBuf, size_t strBufSize) {
+    switch (sa->sa_family) {
+    case AF_INET:
+        inet_ntop(AF_INET, &(((struct sockaddr_in*)sa)->sin_addr), strBuf, strBufSize);
+        break;
+    case AF_INET6:
+        inet_ntop(AF_INET6, &(((struct sockaddr_in6*)sa)->sin6_addr), strBuf, strBufSize);
+        break;
+    default:
+        return 1;
+    }
+    return 0;
+}
+
 void TNetwork::Authentication(const TConnection& ClientConnection) {
    auto Client = CreateClient(ClientConnection.Socket);
-    char AddrBuf[64];
-    // TODO: IPv6 would need this to be changed
-    auto str = inet_ntop(AF_INET, reinterpret_cast<const void*>(&ClientConnection.SockAddr), AddrBuf, sizeof(ClientConnection.SockAddr));
-    beammp_trace("This thread is ip " + std::string(str));
-    Client->SetIdentifier("ip", str);
+    char AddrBuf[INET6_ADDRSTRLEN];
+    get_ip_str(&ClientConnection.SockAddr, AddrBuf, sizeof(AddrBuf));
+    beammp_trace("This thread is ip " + std::string(AddrBuf));
+    Client->SetIdentifier("ip", AddrBuf);

    std::string Rc; // TODO: figure out why this is not default constructed
    beammp_info("Identifying new ClientConnection...");
@@ -280,7 +308,7 @@ void TNetwork::Authentication(const TConnection& ClientConnection) {
        Rc = Http::POST(Application::GetBackendUrlForAuth(), 443, Target, RequestString, "application/json", &ResponseCode);
    }

-    rapidjson::Document AuthResponse;
+    json::Document AuthResponse;
    AuthResponse.Parse(Rc.c_str());
    if (Rc == Http::ErrorString || AuthResponse.HasParseError()) {
        ClientKick(*Client, "Invalid key! Please restart your game.");
@@ -760,14 +788,63 @@ void TNetwork::SendFile(TClient& c, const std::string& UnsafeName) {
    }
 }

+static std::pair<size_t /* count */, size_t /* last chunk */> SplitIntoChunks(size_t FullSize, size_t ChunkSize) {
+    if (FullSize < ChunkSize) {
+        return { 0, FullSize };
+    }
+    size_t Count = FullSize / (FullSize / ChunkSize);
+    size_t LastChunkSize = FullSize - (Count * ChunkSize);
+    return { Count, LastChunkSize };
+}
+
+TEST_CASE("SplitIntoChunks") {
+    size_t FullSize;
+    size_t ChunkSize;
+    SUBCASE("Normal case") {
+        FullSize = 1234567;
+        ChunkSize = 1234;
+    }
+    SUBCASE("Zero original size") {
+        FullSize = 0;
+        ChunkSize = 100;
+    }
+    SUBCASE("Equal full size and chunk size") {
+        FullSize = 125;
+        ChunkSize = 125;
+    }
+    SUBCASE("Even split") {
+        FullSize = 10000;
+        ChunkSize = 100;
+    }
+    SUBCASE("Odd split") {
+        FullSize = 13;
+        ChunkSize = 2;
+    }
+    SUBCASE("Large sizes") {
+        FullSize = 10 * GB;
+        ChunkSize = 125 * MB;
+    }
+    auto [Count, LastSize] = SplitIntoChunks(FullSize, ChunkSize);
+    CHECK((Count * ChunkSize) + LastSize == FullSize);
+}
+
+uint8_t* /* end ptr */ TNetwork::SendSplit(TClient& c, SOCKET Socket, uint8_t* DataPtr, size_t Size) {
+    if (TCPSendRaw(c, Socket, reinterpret_cast<char*>(DataPtr), Size)) {
+        return DataPtr + Size;
+    } else {
+        return nullptr;
+    }
+}
+
 void TNetwork::SplitLoad(TClient& c, size_t Sent, size_t Size, bool D, const std::string& Name) {
    std::ifstream f(Name.c_str(), std::ios::binary);
+    auto Buf = f.rdbuf();
    uint32_t Split = 125 * MB;
-    char* Data;
+    std::vector<uint8_t> Data;
    if (Size > Split)
-        Data = new char[Split];
+        Data.resize(Split);
    else
-        Data = new char[Size];
+        Data.resize(Size);
    SOCKET TCPSock;
    if (D)
        TCPSock = c.GetDownSock();
@@ -778,8 +855,8 @@ void TNetwork::SplitLoad(TClient& c, size_t Sent, size_t Size, bool D, const std
        size_t Diff = Size - Sent;
        if (Diff > Split) {
            f.seekg(Sent, std::ios_base::beg);
-            f.read(Data, Split);
-            if (!TCPSendRaw(c, TCPSock, Data, Split)) {
+            f.read(reinterpret_cast<char*>(Data.data()), Split);
+            if (!TCPSendRaw(c, TCPSock, reinterpret_cast<char*>(Data.data()), Split)) {
                if (c.GetStatus() > -1)
                    c.SetStatus(-1);
                break;
@@ -787,8 +864,8 @@ void TNetwork::SplitLoad(TClient& c, size_t Sent, size_t Size, bool D, const std
            Sent += Split;
        } else {
            f.seekg(Sent, std::ios_base::beg);
-            f.read(Data, Diff);
-            if (!TCPSendRaw(c, TCPSock, Data, int32_t(Diff))) {
+            f.read(reinterpret_cast<char*>(Data.data()), Diff);
+            if (!TCPSendRaw(c, TCPSock, reinterpret_cast<char*>(Data.data()), int32_t(Diff))) {
                if (c.GetStatus() > -1)
                    c.SetStatus(-1);
                break;
@@ -796,8 +873,6 @@ void TNetwork::SplitLoad(TClient& c, size_t Sent, size_t Size, bool D, const std
            Sent += Diff;
        }
    }
-    delete[] Data;
-    f.close();
 }

 bool TNetwork::TCPSendRaw(TClient& C, SOCKET socket, char* Data, int32_t Size) {
@@ -10,7 +10,6 @@ TPPSMonitor::TPPSMonitor(TServer& Server)
        Application::SetSubsystemStatus("PPSMonitor", Application::Status::ShuttingDown);
        if (mThread.joinable()) {
            beammp_debug("shutting down PPSMonitor");
-            mShutdown = true;
            mThread.join();
            beammp_debug("shut down PPSMonitor");
        }
@@ -27,7 +26,7 @@ void TPPSMonitor::operator()() {
    beammp_debug("PPSMonitor starting");
    Application::SetSubsystemStatus("PPSMonitor", Application::Status::Good);
    std::vector<std::shared_ptr<TClient>> TimedOutClients;
-    while (!mShutdown) {
+    while (!Application::IsShuttingDown()) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        int C = 0, V = 0;
        if (mServer.ClientCount() == 0) {
@@ -0,0 +1,75 @@
+#include "TPluginMonitor.h"
+
+#include "TLuaEngine.h"
+
+TPluginMonitor::TPluginMonitor(const fs::path& Path, std::shared_ptr<TLuaEngine> Engine)
+    : mEngine(Engine)
+    , mPath(Path) {
+    Application::SetSubsystemStatus("PluginMonitor", Application::Status::Starting);
+    if (!fs::exists(mPath)) {
+        fs::create_directories(mPath);
+    }
+    for (const auto& Entry : fs::recursive_directory_iterator(mPath)) {
+        // TODO: trigger an event when a subfolder file changes
+        if (Entry.is_regular_file()) {
+            mFileTimes[Entry.path().string()] = fs::last_write_time(Entry.path());
+        }
+    }
+
+    Application::RegisterShutdownHandler([this] {
+        if (mThread.joinable()) {
+            mThread.join();
+        }
+    });
+
+    Start();
+}
+
+void TPluginMonitor::operator()() {
+    RegisterThread("PluginMonitor");
+    beammp_info("PluginMonitor started");
+    Application::SetSubsystemStatus("PluginMonitor", Application::Status::Good);
+    while (!Application::IsShuttingDown()) {
+        std::vector<std::string> ToRemove;
+        for (const auto& Pair : mFileTimes) {
+            try {
+                auto CurrentTime = fs::last_write_time(Pair.first);
+                if (CurrentTime > Pair.second) {
+                    mFileTimes[Pair.first] = CurrentTime;
+                    // grandparent of the path should be Resources/Server
+                    if (fs::equivalent(fs::path(Pair.first).parent_path().parent_path(), mPath)) {
+                        beammp_infof("File \"{}\" changed, reloading", Pair.first);
+                        // is in root folder, so reload
+                        std::ifstream FileStream(Pair.first, std::ios::in | std::ios::binary);
+                        auto Size = std::filesystem::file_size(Pair.first);
+                        auto Contents = std::make_shared<std::string>();
+                        Contents->resize(Size);
+                        FileStream.read(Contents->data(), Contents->size());
+                        TLuaChunk Chunk(Contents, Pair.first, fs::path(Pair.first).parent_path().string());
+                        auto StateID = mEngine->GetStateIDForPlugin(fs::path(Pair.first).parent_path());
+                        auto Res = mEngine->EnqueueScript(StateID, Chunk);
+                        Res->WaitUntilReady();
+                        if (Res->Error) {
+                            beammp_lua_errorf("Error while hot-reloading \"{}\": {}", Pair.first, Res->ErrorMessage);
+                        } else {
+                            mEngine->ReportErrors(mEngine->TriggerLocalEvent(StateID, "onInit"));
+                            mEngine->ReportErrors(mEngine->TriggerEvent("onFileChanged", "", Pair.first));
+                        }
+                    } else {
+                        // is in subfolder, dont reload, just trigger an event
+                        beammp_debugf("File \"{}\" changed, not reloading because it's in a subdirectory. Triggering 'onFileChanged' event instead", Pair.first);
+                        mEngine->ReportErrors(mEngine->TriggerEvent("onFileChanged", "", Pair.first));
+                    }
+                }
+            } catch (const std::exception& e) {
+                ToRemove.push_back(Pair.first);
+            }
+        }
+        Application::SleepSafeSeconds(3);
+        for (const auto& File : ToRemove) {
+            mFileTimes.erase(File);
+            beammp_warnf("File \"{}\" couldn't be accessed, so it was removed from plugin hot reload monitor (probably got deleted)", File);
+        }
+    }
+    Application::SetSubsystemStatus("PluginMonitor", Application::Status::Shutdown);
+}
@@ -28,8 +28,9 @@ TResourceManager::TResourceManager() {
        }
    }

-    if (mModsLoaded)
+    if (mModsLoaded) {
        beammp_info("Loaded " + std::to_string(mModsLoaded) + " Mods");
+    }

    Application::SetSubsystemStatus("ResourceManager", Application::Status::Good);
 }
@@ -1,30 +1,14 @@
 #include "VehicleData.h"

 #include "Common.h"
-#include <regex>
 #include <utility>

-TVehicleData::TVehicleData(int ID, const std::string& Data)
+TVehicleData::TVehicleData(int ID, std::string Data)
    : mID(ID)
-    , mData(Data) {
-    try {
-        std::regex Reg(R"(^[a-zA-Z0-9_\-.]+:[a-zA-Z0-9_\-.]+:[a-zA-Z0-9_\-.]+:\d+\-\d+:(\{.+\}))", std::regex::ECMAScript);
-        std::smatch Match;
-        std::string Result;
-        if (std::regex_search(Data, Match, Reg) && Match.size() > 1) {
-            Result = Match.str(1);
-            mJson = json::parse(Result);
-        }
-    } catch (const std::exception& e) {
-        beammp_debugf("Failed to parse vehicle data for vehicle {} as json, this isn't expected: {}", ID, e.what());
-    }
+    , mData(std::move(Data)) {
    beammp_trace("vehicle " + std::to_string(mID) + " constructed");
 }

 TVehicleData::~TVehicleData() {
    beammp_trace("vehicle " + std::to_string(mID) + " destroyed");
 }
-
-const json& TVehicleData::Json() const {
-    return mJson;
-}
@@ -11,13 +11,14 @@
 #include "TLuaEngine.h"
 #include "TNetwork.h"
 #include "TPPSMonitor.h"
+#include "TPluginMonitor.h"
 #include "TResourceManager.h"
 #include "TScopedTimer.h"
 #include "TServer.h"

 #include <iostream>
 #include <thread>
-#define CPPHTTPLIB_OPENSSL_SUPPORT 1
+
 static const std::string sCommandlineArguments = R"(
 USAGE: 
    BeamMP-Server [arguments]
@@ -44,10 +45,6 @@ EXAMPLES:
        'MyWestCoastServerConfig.toml'.
 )";

-// this is provided by the build system, leave empty for source builds
-// global, yes, this is ugly, no, it cant be done another way
-TSentry Sentry {};
-
 struct MainArguments {
    int argc {};
    char** argv {};
@@ -72,7 +69,7 @@ int main(int argc, char** argv) {
        Sentry.LogException(e, _file_basename, _line);
        MainRet = -1;
    }
-    return MainRet;
+    std::exit(MainRet);
 }

 int BeamMPServerMain(MainArguments Arguments) {
@@ -137,9 +134,9 @@ int BeamMPServerMain(MainArguments Arguments) {

    TServer Server(Arguments.List);
    TConfig Config(ConfigPath);
-    TLuaEngine LuaEngine;
-    LuaEngine.SetServer(&Server);
-    Application::Console().InitializeLuaConsole(LuaEngine);
+    auto LuaEngine = std::make_shared<TLuaEngine>();
+    LuaEngine->SetServer(&Server);
+    Application::Console().InitializeLuaConsole(*LuaEngine);

    if (Config.Failed()) {
        beammp_info("Closing in 10 seconds");
@@ -159,16 +156,14 @@ int BeamMPServerMain(MainArguments Arguments) {
    TPPSMonitor PPSMonitor(Server);
    THeartbeatThread Heartbeat(ResourceManager, Server);
    TNetwork Network(Server, PPSMonitor, ResourceManager);
-    LuaEngine.SetNetwork(&Network);
+    LuaEngine->SetNetwork(&Network);
    PPSMonitor.SetNetwork(Network);
    Application::CheckForUpdates();

-    std::unique_ptr<Http::Server::THttpServerInstance> HttpServer;
+    TPluginMonitor PluginMonitor(fs::path(Application::Settings.Resource) / "Server", LuaEngine);
+
    if (Application::Settings.HTTPServerEnabled) {
-        HttpServer = std::make_unique<Http::Server::THttpServerInstance>(
-            Server,
-            Network,
-            ResourceManager);
+        Http::Server::THttpServerInstance HttpServerInstance {};
    }

    Application::SetSubsystemStatus("Main", Application::Status::Good);
@@ -0,0 +1,22 @@
+#define DOCTEST_CONFIG_IMPLEMENT
+#include <doctest/doctest.h>
+
+#include <Common.h>
+
+int main(int argc, char** argv) {
+    doctest::Context context;
+
+    // Application::InitializeConsole();
+
+    context.applyCommandLine(argc, argv);
+
+    int res = context.run(); // run
+
+    if (context.shouldExit()) // important - query flags (and --exit) rely on the user doing this
+        return res; // propagate the result of the tests
+
+    int client_stuff_return_code = 0;
+    // your program - if the testing framework is integrated in your production code
+
+    return res + client_stuff_return_code; // the result from doctest is propagated here as well
+}
@@ -1,18 +0,0 @@
-include(FetchContent)
-
-message(STATUS "Getting, checking and running vcpkg, this may take a while")
-
-FetchContent_Declare(
-  vcpkg
-  GIT_REPOSITORY    https://github.com/microsoft/vcpkg.git
-)
-
-FetchContent_GetProperties(vcpkg)
-
-if(NOT vcpkg_POPULATED)
-  FetchContent_Populate(vcpkg)
-  execute_process(COMMAND ./${vcpkg_SOURCE_DIR}/bootstrap-vcpkg.sh)
-endif()
-
-set(CMAKE_TOOLCHAIN_FILE ${vcpkg_SOURCE_DIR}/scripts/buildsystems/vcpkg.cmake
-CACHE STRING "Vcpkg toolchain file")
@@ -1,17 +0,0 @@
-{
-    "name": "beammp-server",
-    "version-string": "3.0.2",
-    "homepage": "https://beammp.com",
-    "dependencies": [
-        "sentry-native",
-        "lua",
-        "zlib",
-        "rapidjson",
-        "nlohmann-json",
-        "openssl",
-        "curl",
-        "sol2",
-        "cpp-httplib",
-        "toml11"
-    ]
-}
Author	SHA1	Message	Date
Lion Kortlepel	b209e70d62	update dlhttp	2022-07-27 09:20:21 +02:00
Lion Kortlepel	5394122d77	add /modlist endpoint, DownloadThreads config option	2022-07-26 17:57:19 +02:00
Lion Kortlepel	f48b8ff1a1	update dlhttp, make / work	2022-07-24 15:29:20 +02:00
Lion Kortlepel	de2a3795cc	update dlhttp	2022-07-24 14:19:49 +02:00
Lion Kortlepel	054016a099	remove debug print	2022-07-20 16:08:56 +02:00
Lion Kortlepel	8b57f6e35a	fix missing Lua error messages in ResultCheckThread	2022-07-20 16:07:00 +02:00
Lion Kortlepel	f21d3d0389	fix bug which caused Lua hot-reload not to report syntax errors	2022-07-20 14:56:58 +02:00
Lion Kortlepel	2ed92c4aa1	fix plugin monitor eating a whole cpu core i must have messed this up when i changed the plugin monitor behavior recently	2022-07-20 14:42:07 +02:00
Lion Kortlepel	fd7b11f436	fix event loop timing issue The event loop tries to run no faster than every 10ms. If it detects that it goes faster, it would incorrectly calculate the difference, and then wait (what I assume was) way too long or too short. Either way, now it's fixed and it correctly works, even when introducing new lua states.	2022-07-20 14:33:19 +02:00
Lion Kortlepel	6a94060970	update changelog	2022-07-14 02:08:28 +02:00
Lion Kortlepel	51ccf31373	add beammp_debugf	2022-07-14 01:38:35 +02:00
Lion Kortlepel	a2cc629153	add onFileChanged (fixes #116 )	2022-07-14 01:18:50 +02:00
Lion Kortlepel	ad414ec5c9	call onInit on hot-reload, cleanup, remove warnings onInit is now called on hot-reload, for the whole plugin. Arguably, this is not expected behavior, since only one file is being reloaded, but this is the easiest way to do it, and the entire hot-reload process is only for development purposes. Open an issue if this breaks your stuff :^)	2022-07-14 00:37:47 +02:00
Lion Kortlepel	0a8e7d8e50	add TriggerLocalEvent	2022-07-14 00:27:44 +02:00
Lion	bbd026e399	Merge pull request #114 from Mack29446/rc-v3.1.0 Add support to properly parse IPs	2022-07-13 00:02:40 +02:00
Mackenzie	04bbdff6b7	Add code from EvanMulawski	2022-07-12 22:59:41 +01:00
Lion Kortlepel	2d8ce09b2c	Merge remote-tracking branch 'origin/master' into rc-v3.1.0	2022-07-09 23:03:46 +02:00
Lion	05251efc06	Merge pull request #98 from BeamMP/rc-v3.0.2 RC v3.0.2	2022-07-09 22:55:16 +02:00
Lion Kortlepel	f8d622352f	generate toml from scratch	2022-07-09 22:42:38 +02:00
Lion Kortlepel	6c1d02a425	add fclose	2022-07-09 22:29:12 +02:00
Lion Kortlepel	38eeec39b4	another attempt to fix #105	2022-07-09 22:27:05 +02:00
Lion Kortlepel	696e080e1c	fix #105	2022-07-09 22:01:53 +02:00
Lion Kortlepel	98681254e6	update toml11	2022-07-09 21:50:23 +02:00
Lion Kortlepel	420e6c3533	roll back to an ancient version of sentry sentry-native deprecated compiling without error somewhere around one of the next version	2022-07-09 21:40:19 +02:00
Lion Kortlepel	06f8ba5a0e	update sentry-native to 0.4.18	2022-07-09 21:11:34 +02:00
Lion Kortlepel	9420d8a7a0	update changelog	2022-06-30 21:30:56 +02:00
Lion Kortlepel	dfa90da8af	check if Resources/Server directory exists, and only create it if it doesnt While this doesn't make a difference with usual setups, it does if the server path exists but is a symlink. In that case, the create_directories call fails, and the server aborts. this fixes that. :^)	2022-06-30 20:19:48 +02:00
Lion Kortlepel	6e46d5aca9	start building the `clear` command	2022-06-28 03:29:01 +02:00
Lion Kortlepel	817bd4b588	start fixing mod download	2022-06-28 03:20:42 +02:00
Lion Kortlepel	25391fa0c7	thank you toml11 maintainer for naming your header some super generic name that clashes with every single other toml library B)	2022-06-04 16:51:34 +03:00
Lion	28270072d4	Merge pull request #102 from Mack29446/master update version number in git checkout command	2022-05-30 19:16:10 +02:00
Lion Kortlepel	758d5b2c96	Revert "let's try vcpkg" This reverts commit `8d7505956d`.	2022-05-29 14:37:50 +02:00
Lion Kortlepel	1970d97ea4	Revert "Remove unneeded submodules" This reverts commit `a5153e4bc1`.	2022-05-29 14:37:41 +02:00
Lion Kortlepel	d8526f0649	TNetwork::SplitLoad: Use managed memory	2022-05-29 14:30:57 +02:00
Lion Kortlepel	0621c0bf82	rebase fixup	2022-05-26 21:13:18 +02:00
Lion Kortlepel	36547d1e9e	Move PluginMonitor out of TLuaEngine	2022-05-26 20:59:53 +02:00
Lion Kortlepel	f06f31c2a0	add moar tests!!!	2022-05-26 16:58:13 +02:00
Lion Kortlepel	46b92b4992	only run termios test if stdin is a tty	2022-05-26 16:14:05 +02:00
Lion Kortlepel	70e53c2a70	fix dependencies ubuntu's package naming is confusing me	2022-05-26 16:00:36 +02:00
Lion Kortlepel	cc35d83834	make linux workflow parallel, add runtime dependencies	2022-05-26 15:54:23 +02:00
Lion Kortlepel	b4f97a6da0	make tests executable before running :^)	2022-05-26 15:44:39 +02:00
Lion Kortlepel	3d7db6d0bc	windows me waiting for MSVC to stop making me write properly, deepls retarded code: https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fmedia.istockphoto.com%2Fphotos%2Fskeleton-reaching-for-a-window-picture-id155154794%3Fk%3D6%26m%3D155154794%26s%3D612x612%26w%3D0%26h%3DKNIrAKdhAsI1FCoMtSLXd99ZnP9MO1zZj8VkThTvwVs%3D&f=1&nofb=1	2022-05-26 15:41:52 +02:00
Lion Kortlepel	1c3b1ecc76	fix workflow test run path	2022-05-26 15:37:33 +02:00
Lion Kortlepel	303da19f48	add -t to linux workflow	2022-05-26 14:43:38 +02:00
Lion Kortlepel	c455d4855c	possibly fix workflow	2022-05-26 14:40:56 +02:00
Lion Kortlepel	8df61fe44c	add g++ to workflow	2022-05-26 13:58:29 +02:00
Lion Kortlepel	7224e90c68	add test workflow	2022-05-26 13:56:58 +02:00
Lion Kortlepel	fde5bc7fb6	remove tests from linux action	2022-05-26 13:50:50 +02:00
Lion Kortlepel	22b63220c7	add more tests to LuaAPI::FS, minor fixes to LuaAPI::FS test config file creation, too	2022-05-26 13:49:13 +02:00
Lion Kortlepel	811ace1999	fix Application::IsOutdated test case types	2022-05-26 13:36:02 +02:00
Lion Kortlepel	2cf083a7e4	run tests in github actions	2022-05-26 13:34:29 +02:00
Lion Kortlepel	28c43a51ee	add some tests for LuaAPI FS, termios	2022-05-26 13:33:08 +02:00
Lion Kortlepel	00f156cb86	start adding tests	2022-05-26 13:02:09 +02:00
Lion Kortlepel	67b8565a4d	update json	2022-05-26 12:06:36 +02:00
Lion Kortlepel	ed8d8a6419	remove unused code	2022-05-26 12:03:03 +02:00
Lion Kortlepel	895058f85f	revert sentry to 0.4.9	2022-05-26 12:01:27 +02:00
Lion Kortlepel	a0876ed58c	update submodules, remove ssl crap	2022-05-26 11:59:36 +02:00
Lion Kortlepel	4f69ca1ad0	remove ssl code @jimkoen This was removed because, as useful and as much work as this was, we can't reasonably take responsibility for this. Instead, a server like this should always be localhost only, and if it's not, it should be behind an nginx reverse proxy anyways. We're removing the config options regarding this in one of the next commits.	2022-05-26 11:54:19 +02:00
Lion Kortlepel	bc1628afeb	fix some sentry and linking related issues	2022-05-26 11:51:26 +02:00
Lion Kortlepel	019c5202ea	add tests executable	2022-05-26 11:44:20 +02:00
Lion Kortlepel	2dd181d492	gracefully shutdown on bind() failure	2022-05-26 11:19:48 +02:00
Mackenzie	58e2383b2e	update version number in git checkout command	2022-04-13 19:48:12 +01:00