bump version number (#241)

now fully replaced by github releases due to issue-based workflow

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,28 @@
+---
+name: Bug report
+about: Create a report to help us improve
+labels: bug
+assignees: ''
+
+---
+
+**Fill out general information**
+OS (windows, linux, ...):
+BeamMP-Server Version:
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Do x ...
+2. Do y ...
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Logs**
+Please attach the `Server.log` from the run in which the issue appeared, preferably with Debug turned on in the `ServerConfig.toml`.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,19 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+labels: feature
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. For example: "I'm always frustrated when ...".
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen. Also supply OS information if relevant, for example "*On Linux*, I would like to be able to...".
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context about the feature request here.

.github/workflows/linux.yml

@@ -0,0 +1,123 @@
+name: Linux
+
+on: [push]
+
+env: 
+  VCPKG_BINARY_SOURCES: "clear;x-gha,readwrite"
+  CMAKE_BUILD_TYPE: "Release"
+
+jobs:
+  debian-11-build:
+    runs-on: ubuntu-latest
+    container:
+      image: debian:11
+    steps:
+      - name: Export GitHub Actions cache environment variables
+        uses: actions/github-script@v6
+        with:
+          script: |
+            core.exportVariable('ACTIONS_CACHE_URL', process.env.ACTIONS_CACHE_URL || '');
+            core.exportVariable('ACTIONS_RUNTIME_TOKEN', process.env.ACTIONS_RUNTIME_TOKEN || '');
+
+      - name: Install git
+        run: |
+          apt-get update -y
+          apt-get install -y git
+
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+
+      - name: Git config safe directory
+        shell: bash
+        run: bash ./scripts/debian-11/1.5-git-safe.sh
+
+      - name: Install Dependencies
+        run: bash ./scripts/debian-11/1-install-deps.sh
+
+      - name: Create Build Environment
+        run: bash ./scripts/debian-11/2-configure.sh '-DCMAKE_TOOLCHAIN_FILE=./vcpkg/scripts/buildsystems/vcpkg.cmake'
+
+      - name: Build Server
+        run: bash ./scripts/debian-11/3-build.sh
+
+      - name: Archive server artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: BeamMP-Server-debian
+          path: ./bin/BeamMP-Server
+
+      - name: Archive server debug info artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: BeamMP-Server-debian.debug
+          path: ./bin/BeamMP-Server.debug
+
+      - name: Build Tests
+        run: bash ./scripts/debian-11/3-build-tests.sh
+
+      - name: Install Runtime Dependencies
+        run: bash ./scripts/debian-11/4-install-runtime-deps.sh
+
+      - name: Test
+        run: ./bin/BeamMP-Server-tests
+
+  ubuntu-22-04-build:
+    runs-on: ubuntu-latest
+    container:
+      image: ubuntu:22.04
+    steps:
+      - name: Export GitHub Actions cache environment variables
+        uses: actions/github-script@v6
+        with:
+          script: |
+            core.exportVariable('ACTIONS_CACHE_URL', process.env.ACTIONS_CACHE_URL || '');
+            core.exportVariable('ACTIONS_RUNTIME_TOKEN', process.env.ACTIONS_RUNTIME_TOKEN || '');
+
+      - name: Install git
+        run: |
+          apt-get update -y
+          apt-get install -y git
+
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+
+      - name: Git config safe directory
+        shell: bash
+        run: bash ./scripts/ubuntu-22.04/1.5-git-safe.sh
+
+      - name: Install Dependencies
+        run: bash ./scripts/ubuntu-22.04/1-install-deps.sh
+
+      - name: Setup vcpkg
+        uses: lukka/run-vcpkg@v11
+        with:
+          runVcpkgInstall: true
+
+      - name: Create Build Environment
+        run: bash ./scripts/ubuntu-22.04/2-configure.sh '-DCMAKE_TOOLCHAIN_FILE=./vcpkg/scripts/buildsystems/vcpkg.cmake'
+
+      - name: Build Server
+        run: bash ./scripts/ubuntu-22.04/3-build.sh
+
+      - name: Archive server artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: BeamMP-Server-ubuntu
+          path: ./bin/BeamMP-Server
+      
+      - name: Archive server debug info artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: BeamMP-Server-ubuntu.debug
+          path: ./bin/BeamMP-Server.debug
+
+      - name: Build Tests
+        run: bash ./scripts/ubuntu-22.04/3-build-tests.sh
+
+      - name: Install Runtime Dependencies
+        run: bash ./scripts/ubuntu-22.04/4-install-runtime-deps.sh
+
+      - name: Test
+        run: ./bin/BeamMP-Server-tests

.github/workflows/release.yml

@@ -0,0 +1,191 @@
+name: Release Create & Build
+on:
+  push:
+    # Sequence of patterns matched against refs/tags
+    tags:
+    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+
+env:
+  VCPKG_BINARY_SOURCES: "clear;x-gha,readwrite"
+  CMAKE_BUILD_TYPE: "Release"
+
+jobs:
+  create-release:
+    runs-on: ubuntu-latest
+    name: Create Release
+    outputs: 
+      upload_url: ${{ steps.create_release.outputs.upload_url }} 
+    steps:
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: ${{ github.ref }}
+          draft: false
+          prerelease: true
+          body: |
+              Files included in this release:
+              - `BeamMP-Server.exe` is the windows build. You need to install the [Visual C++ Redistributables](https://aka.ms/vs/17/release/vc_redist.x64.exe) to run this.
+              - `BeamMP-Server-debian` is a Debian 11 build, requires `liblua5.3-0`.
+              - `BeamMP-Server-ubuntu` is a Ubuntu 22.04 build, requires `liblua5.3-0`.
+
+  upload-release-files-debian-11:
+    name: Build and upload Debian 11 Release Files
+    runs-on: ubuntu-22.04
+    needs: create-release
+    container:
+      image: debian:11
+    steps:
+      - name: Export GitHub Actions cache environment variables
+        uses: actions/github-script@v6
+        with:
+          script: |
+            core.exportVariable('ACTIONS_CACHE_URL', process.env.ACTIONS_CACHE_URL || '');
+            core.exportVariable('ACTIONS_RUNTIME_TOKEN', process.env.ACTIONS_RUNTIME_TOKEN || '');
+
+      - name: Install git
+        run: |
+          apt-get update -y
+          apt-get install -y git
+
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+
+      - name: Git config safe directory
+        shell: bash
+        run: bash ./scripts/debian-11/1.5-git-safe.sh
+
+      - name: Install Dependencies
+        run: bash ./scripts/debian-11/1-install-deps.sh
+
+      - name: Setup vcpkg
+        uses: lukka/run-vcpkg@v11
+        with:
+          runVcpkgInstall: true
+
+      - name: Create Build Environment
+        run: bash ./scripts/debian-11/2-configure.sh '-DCMAKE_TOOLCHAIN_FILE=./vcpkg/scripts/buildsystems/vcpkg.cmake'
+
+      - name: Build Server
+        run: bash ./scripts/debian-11/3-build.sh
+
+      - name: Upload Release Asset
+        id: upload-release-asset 
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
+          asset_path: ./bin/BeamMP-Server
+          asset_name: BeamMP-Server-debian
+          asset_content_type: application/x-elf
+
+      - name: Upload Debug Info
+        id: upload-debug-info
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
+          asset_path: ./bin/BeamMP-Server.debug
+          asset_name: debuginfo-debian.debug
+          asset_content_type: application/x-elf
+    
+  upload-release-files-ubuntu-22-04:
+    name: Build and upload Ubuntu 22.04 Release Files
+    runs-on: ubuntu-22.04
+    needs: create-release
+    container:
+      image: ubuntu:22.04
+    steps:
+      - name: Export GitHub Actions cache environment variables
+        uses: actions/github-script@v6
+        with:
+          script: |
+            core.exportVariable('ACTIONS_CACHE_URL', process.env.ACTIONS_CACHE_URL || '');
+            core.exportVariable('ACTIONS_RUNTIME_TOKEN', process.env.ACTIONS_RUNTIME_TOKEN || '');
+
+      - name: Install git
+        run: |
+          apt-get update -y
+          apt-get install -y git
+
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+
+      - name: Git config safe directory
+        shell: bash
+        run: bash ./scripts/ubuntu-22.04/1.5-git-safe.sh
+
+      - name: Install Dependencies
+        run: bash ./scripts/ubuntu-22.04/1-install-deps.sh
+
+      - name: Create Build Environment
+        run: bash ./scripts/ubuntu-22.04/2-configure.sh '-DCMAKE_TOOLCHAIN_FILE=./vcpkg/scripts/buildsystems/vcpkg.cmake'
+
+      - name: Build Server
+        run: bash ./scripts/ubuntu-22.04/3-build.sh
+
+      - name: Upload Release Asset
+        id: upload-release-asset 
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
+          asset_path: ./bin/BeamMP-Server
+          asset_name: BeamMP-Server-ubuntu
+          asset_content_type: application/x-elf
+
+      - name: Upload Debug Info
+        id: upload-debug-info
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
+          asset_path: ./bin/BeamMP-Server.debug
+          asset_name: debuginfo-ubuntu.debug
+          asset_content_type: application/x-elf
+
+  upload-release-files-windows:
+    name: Build and upload Windows Release Files
+    runs-on: windows-latest
+    needs: create-release
+    env:
+      VCPKG_DEFAULT_TRIPLET: x64-windows-static
+    steps:
+      - name: Export GitHub Actions cache environment variables
+        uses: actions/github-script@v6
+        with:
+          script: |
+            core.exportVariable('ACTIONS_CACHE_URL', process.env.ACTIONS_CACHE_URL || '');
+            core.exportVariable('ACTIONS_RUNTIME_TOKEN', process.env.ACTIONS_RUNTIME_TOKEN || '');
+
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+
+      - name: Create Build Environment
+        shell: bash
+        run: ./scripts/windows/1-configure.sh
+
+      - name: Build Server
+        shell: bash
+        run: bash ./scripts/windows/2-build.sh
+
+      - name: Upload Release Asset
+        id: upload-release-asset 
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
+          asset_path: ./bin/Release/BeamMP-Server.exe
+          asset_name: BeamMP-Server.exe
+          asset_content_type: application/vnd.microsoft.portable-executable

.github/workflows/windows.yml

@@ -0,0 +1,43 @@
+name: Windows
+
+on: [push]
+
+env:
+  VCPKG_DEFAULT_TRIPLET: x64-windows-static
+  VCPKG_BINARY_SOURCES: "clear;x-gha,readwrite"
+  CMAKE_BUILD_TYPE: "Release"
+
+jobs:
+  windows-build:
+    runs-on: windows-latest
+    steps:
+      - name: Export GitHub Actions cache environment variables
+        uses: actions/github-script@v6
+        with:
+          script: |
+            core.exportVariable('ACTIONS_CACHE_URL', process.env.ACTIONS_CACHE_URL || '');
+            core.exportVariable('ACTIONS_RUNTIME_TOKEN', process.env.ACTIONS_RUNTIME_TOKEN || '');
+
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+
+      - name: Setup vcpkg
+        uses: lukka/run-vcpkg@v11
+        with:
+          runVcpkgInstall: true
+
+      - name: Create Build Environment
+        shell: bash
+        run: ./scripts/windows/1-configure.sh
+
+      - name: Build Server
+        shell: bash
+        run: bash ./scripts/windows/2-build.sh
+
+      - name: Archive server artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: BeamMP-Server-windows
+          path: ./bin/Release/BeamMP-Server.exe
+

.gitignore

@@ -1,5 +1,10 @@
+.idea/
+.sentry-native/
+*.orig
+*.toml
 boost_*
 Resources
+run-in-env.sh
 ## Ignore Visual Studio temporary files, build results, and
 ## files generated by popular Visual Studio add-ons.
 ##
@@ -22,16 +27,9 @@ mono_crash.*
 out/
 
 #Clion Files
-cmake-build-debug/CMakeFiles/
-cmake-build-release/CMakeFiles/
-cmake-build-debug/Resources/
-cmake-build-release/Resources/
-cmake-build-debug/*.*
-cmake-build-release/*.*
-cmake-build-debug/Makefile
-cmake-build-release/Makefile
-!cmake-build-debug/*.lib
-!cmake-build-release/*.lib
+cmake-build-debug/
+cmake-build-release/
+.idea/
 # Build results
 [Dd]ebug/
 [Dd]ebugPublic/
@@ -51,7 +49,6 @@ bld/
 .vs/
 # Uncomment if you have tasks that create the project's static files in wwwroot
 #wwwroot/
-
 # Visual Studio 2017 auto generated files
 Generated\ Files/
 
@@ -462,3 +459,23 @@ out/build/x86-Debug/.cmake/api/v1/reply/index-2020-01-28T17-35-38-0764.json
 out/build/x86-Debug/.cmake/api/v1/reply/codemodel-v2-6a61e390ef8eaf17e9f8.json
 out/build/x86-Debug/Server.cfg
 *Server.cfg*
+*.cmake
+*.make
+*.xml
+*.includecache
+cmake-build-release/include/commandline/Makefile
+*.lib
+*.cbp
+*.marks
+*.internal
+*.xml
+cmake-build-debug/include/commandline/Makefile
+*.manifest
+*.rc
+*.res
+BeamMP-Server
+*.patch
+callgrind.*
+notes/*
+compile_commands.json
+nohup.out

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "deps/commandline"]
+	path = deps/commandline
+	url = https://github.com/lionkor/commandline
+[submodule "vcpkg"]
+	path = vcpkg
+	url = https://github.com/Microsoft/vcpkg.git

.idea/.gitignore

@@ -1,2 +0,0 @@
-# Default ignored files
-/workspace.xml

.idea/.name

@@ -1 +0,0 @@
-Server

.idea/BeamNG-MP-Server.iml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module classpath="CMake" type="CPP_MODULE" version="4" />

.idea/misc.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
-  <component name="JavaScriptSettings">
-    <option name="languageLevel" value="ES6" />
-  </component>
-</project>

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/BeamNG-MP-Server.iml" filepath="$PROJECT_DIR$/.idea/BeamNG-MP-Server.iml" />
-    </modules>
-  </component>
-</project>

.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

CMakeLists.txt

@@ -1,37 +1,213 @@
-cmake_minimum_required(VERSION 3.10)
-project(Server)
-set(CMAKE_CXX_STANDARD 17)
+cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG")
+if (WIN32)
+    set(VCPKG_TARGET_TRIPLET x64-windows-static)
+endif()
 
-if (UNIX)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic -static-libstdc++")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og -g")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2 -s")
-elseif (WIN32)
-    # This might cause issues with old windows headers, but it's worth the trouble to keep the code
-    #   completely cross platform. For fixes to common issues arising from /permissive- visit:
-    #   https://docs.microsoft.com/en-us/cpp/build/reference/permissive-standards-conformance
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /permissive-")
-    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})
-    #-DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static
+include(cmake/Vcpkg.cmake) # needs to happen before project()
+
+project(
+    "BeamMP-Server" # replace this
+    VERSION 3.3.0
+)
+
+include(cmake/StandardSettings.cmake)
+include(cmake/StaticAnalyzers.cmake)
+include(cmake/Git.cmake)
+
+# below are options which should be changed
+
+### SETTINGS ###
+
+# add all headers (.h, .hpp) to this
+set(PRJ_HEADERS 
+    include/ArgsParser.h
+    include/BoostAliases.h
+    include/Client.h
+    include/Common.h
+    include/Compat.h
+    include/Cryptography.h
+    include/CustomAssert.h
+    include/Defer.h
+    include/Environment.h
+    include/Http.h
+    include/IThreaded.h
+    include/Json.h
+    include/LuaAPI.h
+    include/RWMutex.h
+    include/SignalHandling.h
+    include/TConfig.h
+    include/TConsole.h
+    include/THeartbeatThread.h
+    include/TLuaEngine.h
+    include/TLuaPlugin.h
+    include/TNetwork.h
+    include/TPluginMonitor.h
+    include/TPPSMonitor.h
+    include/TResourceManager.h
+    include/TScopedTimer.h
+    include/TServer.h
+    include/VehicleData.h
+)
+# add all source files (.cpp) to this, except the one with main()
+set(PRJ_SOURCES
+    src/ArgsParser.cpp
+    src/Client.cpp
+    src/Common.cpp
+    src/Compat.cpp
+    src/Http.cpp
+    src/LuaAPI.cpp
+    src/SignalHandling.cpp
+    src/TConfig.cpp
+    src/TConsole.cpp
+    src/THeartbeatThread.cpp
+    src/TLuaEngine.cpp
+    src/TLuaPlugin.cpp
+    src/TNetwork.cpp
+    src/TPluginMonitor.cpp
+    src/TPPSMonitor.cpp
+    src/TResourceManager.cpp
+    src/TScopedTimer.cpp
+    src/TServer.cpp
+    src/VehicleData.cpp
+)
+
+find_package(Lua REQUIRED)
+
+# set the source file containing main()
+set(PRJ_MAIN src/main.cpp)
+# set the source file containing the test's main
+set(PRJ_TEST_MAIN test/test_main.cpp)
+# set include paths not part of libraries
+set(PRJ_INCLUDE_DIRS ${LUA_INCLUDE_DIR})
+# set compile features (e.g. standard version)
+set(PRJ_COMPILE_FEATURES cxx_std_20)
+# set #defines (test enable/disable not included here)
+set(PRJ_DEFINITIONS CPPHTTPLIB_OPENSSL_SUPPORT)
+# add all libraries used by the project (WARNING: also set them in vcpkg.json!)
+set(PRJ_LIBRARIES 
+    fmt::fmt
+    doctest::doctest
+    Threads::Threads
+    commandline_static
+    toml11::toml11
+    rapidjson
+    sol2
+    httplib::httplib
+    libzip::zip
+    OpenSSL::SSL OpenSSL::Crypto
+    ${LUA_LIBRARIES}
+)
+
+# add dependency find_package calls and similar here
+find_package(fmt CONFIG REQUIRED)
+find_package(OpenSSL REQUIRED)
+find_package(doctest CONFIG REQUIRED)
+find_package(Boost REQUIRED)
+find_package(httplib CONFIG REQUIRED)
+find_package(libzip CONFIG REQUIRED)
+find_package(RapidJSON CONFIG REQUIRED)
+find_package(sol2 CONFIG REQUIRED)
+find_package(toml11 CONFIG REQUIRED)
+
+include_directories(include)
+
+# to enable multithreading and the Threads::Threads dependency
+include(FindThreads)
+
+### END SETTINGS ###
+
+# DONT change anything beyond this point unless you've read the cmake bible and 
+# swore on it not to bonk up the ci/cd pipelines with your changes.
+
+####################
+
+
+# enables compile_commands.json for clang-related tools (such as the clang LS)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# build release builds by default (if not specified otherwise)
+if(NOT DEFINED CMAKE_BUILD_TYPE)
+    message(NOTICE "No build type specified, defaulting to 'Release'")
+    set(CMAKE_BUILD_TYPE "Release")
+endif()
+
+if(UNIX)
+    # this will allow to use same _DEBUG macro available in both Linux as well as Windows - MSCV environment. Easy to put Debug specific code.
+    add_compile_options("$<$<CONFIG:DEBUG>:-D_DEBUG>")
+endif(UNIX)
+
+if (WIN32)
+    add_compile_options("-D_WIN32_WINNT=0x0601")
+endif(WIN32)
+
+
+include(cmake/CompilerWarnings.cmake)
+
+# set MT library for msvc - this is required (says documentation)
+# linux/mac/etc should simply ignore this by default.
+set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+
+set(PRJ_DEFINITIONS ${PRJ_DEFINITIONS}
+    PRJ_VERSION_MAJOR=${PROJECT_VERSION_MAJOR}
+    PRJ_VERSION_MINOR=${PROJECT_VERSION_MINOR}
+    PRJ_VERSION_PATCH=${PROJECT_VERSION_PATCH}
+)
+
+# build commandline manually for funky windows flags to carry over without a custom toolchain file
+add_library(commandline_static 
+    deps/commandline/src/impls.h
+    deps/commandline/src/windows_impl.cpp
+    deps/commandline/src/linux_impl.cpp
+    deps/commandline/src/backends/InteractiveBackend.cpp
+    deps/commandline/src/backends/InteractiveBackend.h
+    deps/commandline/src/backends/Backend.cpp
+    deps/commandline/src/backends/Backend.h
+    deps/commandline/src/commandline.h
+    deps/commandline/src/commandline.cpp
+    deps/commandline/src/backends/BufferedBackend.cpp
+    deps/commandline/src/backends/BufferedBackend.h
+)
+if (WIN32)
+    target_compile_definitions(commandline_static PRIVATE -DPLATFORM_WINDOWS=1)
+else ()
+    target_compile_definitions(commandline_static PRIVATE -DPLATFORM_LINUX=1)
 endif ()
+target_include_directories(commandline_static PUBLIC "deps/commandline/src")
+target_link_libraries(commandline_static Threads::Threads)
+# end of commandline custom build
 
-find_package(Boost 1.70.0 REQUIRED COMPONENTS system thread)
-file(GLOB source_files "src/*.cpp" "src/*/*.cpp" "include/*.h" "include/*/*.h" "include/*.hpp" "include/*/*.hpp")
-add_executable(BeamMP-Server ${source_files})
+add_executable(${PROJECT_NAME} ${PRJ_HEADERS} ${PRJ_SOURCES} ${PRJ_MAIN})
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION}
+    MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}
+    MACOSX_BUNDLE TRUE
+    WIN32_EXECUTABLE TRUE
+)
+target_include_directories(${PROJECT_NAME} PRIVATE ${PRJ_INCLUDE_DIRS})
+target_link_libraries(${PROJECT_NAME} ${PRJ_LIBRARIES})
+target_compile_features(${PROJECT_NAME} PRIVATE ${PRJ_COMPILE_FEATURES})
+target_compile_definitions(${PROJECT_NAME} PRIVATE ${PRJ_DEFINITIONS} ${PRJ_WARNINGS}
+    DOCTEST_CONFIG_DISABLE # disables all test code in the final executable
+)
 
-target_include_directories(BeamMP-Server SYSTEM PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
-find_package(Lua 5.3 REQUIRED)
-target_include_directories(BeamMP-Server SYSTEM PUBLIC ${LUA_INCLUDE_DIR} ${Boost_INCLUDE_DIRS})
+if(MSVC)
+    target_link_options(${PROJECT_NAME} PRIVATE "/SUBSYSTEM:CONSOLE")
+endif(MSVC)
+
+# setup all warnings (from cmake/CompilerWarnings.cmake)
+set_project_warnings(${PROJECT_NAME})
+
+if(${PROJECT_NAME}_ENABLE_UNIT_TESTING)
+    message(STATUS "Unit tests are enabled and will be built as '${PROJECT_NAME}-tests'")
+    add_executable(${PROJECT_NAME}-tests ${PRJ_HEADERS} ${PRJ_SOURCES} ${PRJ_TEST_MAIN})
+    target_include_directories(${PROJECT_NAME}-tests PRIVATE ${PRJ_INCLUDE_DIRS})
+    target_link_libraries(${PROJECT_NAME}-tests ${PRJ_LIBRARIES})
+    target_compile_features(${PROJECT_NAME}-tests PRIVATE ${PRJ_COMPILE_FEATURES})
+    target_compile_definitions(${PROJECT_NAME}-tests PRIVATE ${PRJ_DEFINITIONS} ${PRJ_WARNINGS})
+    set_project_warnings(${PROJECT_NAME}-tests)
+    if(MSVC)
+        target_link_options(${PROJECT_NAME}-tests PRIVATE "/SUBSYSTEM:CONSOLE")
+    endif(MSVC)
+endif()
 
-if (UNIX)
-    target_link_libraries(BeamMP-Server curl z pthread stdc++fs ${Boost_LINK_DIRS} ${LUA_LIBRARIES})
-elseif (WIN32)
-    include(FindLua)
-    find_package(CURL CONFIG REQUIRED)
-    find_package(ZLIB REQUIRED)
-    target_link_libraries(BeamMP-Server PRIVATE urlmon ws2_32 CURL::libcurl ZLIB::ZLIB ${Boost_LINK_DIRS} ${LUA_LIBRARIES})
-endif ()

CONTRIBUTING.md

@@ -0,0 +1,111 @@
+# Contributing to BeamMP-Server
+
+Unlike other parts of BeamMP, the BeamMP-Server does not have any dependency to the BeamNG.drive game. 
+
+To contribute *C++ code*, you'll need a MacOS, Linux or Windows PC, and intermediate to advanced knowledge of C++.
+For reference, you should know be reasonably comfortable with the STL, the concept of RAII, templates, and generally know how to read & write post-C++17 code. To contribute anything else, you won't need most of this (though it'd be helpful to have some vocabulary about computers).
+
+# Ways to Contribute
+
+## Bug Reports
+
+If you work with BeamMP-Server, either by simply using it, or even writing plugins for it, and you run into any issues, we definitely want to know about it. Please use [GitHub issues](https://github.com/BeamMP/BeamMP-Server/issues) and select the "Bug" template, read it, and fill it out accordingly.
+
+## Bug Fixes
+
+If you are interested in fixing bugs, check out the [GitHub issues](https://github.com/BeamMP/BeamMP-Server/issues). There, you can pick any issue that has nobody assigned to it. For example, some bugs which we definitely need some help with are marked with the "help wanted" tag.
+
+Once you picked a bug, you need to reproduce it. Start by following the instructions in the bug report, and don't be afraid to ask for more information or clarification on the issue itself.
+
+Refer to [getting started with the codebase](#getting-started-with-the-codebase) for more information on how to build the server. You can also ask on our [Discord server](https://discord.gg/beammp), or on IRC ([irc.libera.chat](https://web.libera.chat/), join `#beammp`).
+
+## Features
+
+If you want to add new features, please make an issue for it first or ask on our [Discord server](https://discord.gg/beammp), or on IRC ([irc.libera.chat](https://web.libera.chat/), join `#beammp`).
+
+You need to make sure the feature isn't being worked on by someone else, and aligns with the vision we have for the server.
+
+# Git Guidelines
+
+**Read this carefully. Failing to follow these rules results in your changes not being accepted**. This applies for outside contributors, members of the BeamMP development team ("BeamMP Developers"), project owners, maintainers, frequent contributors, and literally everyone else. **It applies to everyone**.
+
+## How to Commit
+
+Commit messages **MUST** (mandatory):
+
+- start with a **lower case action verb in present tense**, for example `add`, `fix`, `implement`, `refactor`, `remove`, `rename`. *Counter examples (these are bad): ~~`Fixed`, `fixing`, `added`, `removing`~~*.
+- not have a first line much longer than 70 characters.
+- explain briefly the changes made.
+- reference the issue by number, if there is an issue the commit addresses, like so: `#<number>`. Example: `#123`.
+
+If any of these are not followed, **your changes will not be accepted.**
+
+Commit messages **SHOULD** (optional, "nice to have"):
+
+- only address one "atomic" change.
+- have an empty second line, and the subsequent lines explaining the changes in more detail (if more detail is available).
+
+Commits may be squashed (via a Git "interactive rebase") in order to satisfy these rules, but history that is >1h old should not be rewritten if possible. Force pushes are ugly ;)
+
+## Pulling, Merging
+
+Do **NOT** pull with merge. This is the default git behavior for `git pull`, but creates ugly and unnecessary commit messages like `"merge origin/master into master"`. Instead, pull with rebase, for example via `git pull -r`. If you get conflicts, resolve them properly.
+
+The only acceptable merge commits are those which actually merge functionally different branches into each other, for example for merging one feature branch into another.
+
+## Branches
+
+### Which branch should I base my work on?
+
+Each *feature* or *bug-fix* is implemented on a new Git branch, branched off of the branch it should be based on. The `master` branch is usually stable, so we don't do development on it. It is always a safe bet to branch off of `master`, but it may be more work to merge later. Branches to base your work on are usually branches like `rc-v3.3.0`, when the latest public version is `3.2.0`, for example. These can often be found in Pull-Requests on GitHub which are tagged `Release Candidate`.
+
+## Unit tests & CI/CD
+
+We use GitHub Actions, which runs our unit-tests. PR's which fail these tests, or even fail any of our actions (which run automatically), will not be merged and require further changes until they compile, link, and all tests pass properly. If you have issues with this, feel free to ask in our [Discord server](https://discord.gg/beammp), or on IRC ([irc.libera.chat](https://web.libera.chat/), join `#beammp`)
+
+### What should I call by branch?
+
+Keep branch names **unique**, **descriptive**, and **shorter than 30 characters**. Names must be in present-tense, such as `fix-xyz`, **not** ~~`fixing-xyz`~~.
+
+We generally use *feature branches*, so we keep one branch per feature or fix.
+
+For example:
+- You want to fix issue number #123? You could call the branch `fix-123`.
+- You want to add a feature described in issue #456? You could call the branch `implement-456`.
+- You want to add a feature or fix a bug that has no issue? You should probably make an issue for it first! Or, if you're not ready for that yet, you could call it by the feature name or bug description, for example for a bug that makes cars disappear: `fix-disappearing-cars`.
+
+## Pull Requests, Code Review
+
+Once you are ready to show what you did, and get feedback on it, you open a Pull-Request on GitHub. Please make sure to pick the right branches, and a descriptive title. Mention any related issues with `#<issue number>`, for example `#123`.
+
+Make sure to explain what the PR does, what it fixes, and what needs to still be done (if anything).
+
+A BeamMP-Developer must review your code in detail, and leave a review. If this takes too long, feel free to @ a maintainer/developer, or leave another comment on the PR. It helps to say something like "Ready for review", for example.
+
+# Getting Started with the Codebase
+
+1. Look at current Pull-Requests, look at the git branches, or ask in our [Discord server](https://discord.gg/beammp), or on IRC ([irc.libera.chat](https://web.libera.chat/), join `#beammp`), in order to find out which branch you should work on to minimize conflict. See [this section on branches](#branches) for more info.
+2. Fork the repository (with that branch) on GitHub. GitHub, by default, gives you only the `master` branch when forking, so make sure you fork with other branches enabled when you want to work on a branch that isn't master (it's a checkbox when you fork).
+3. Clone the fork to your local machine.
+4. Check out the branch you want to work on (see 1.).
+5. Run `git submodule update --init --recursive`.
+6. Make a new branch for your feature or fix from the branch you are on. You can do this via `git checkout -b <branch name>`. See [this section on branches](#branches) for more info on branch naming.
+7. Install all dependencies. Those are usually listed in the `README.md` in the branch you're in, or, more reliably, in one of the files in `.github/workflows` (if you can read `yaml`).
+8. Run CMake to configure the project. You can find tutorials on this online. You will want to tell CMake to build with `CMAKE_BUILD_TYPE=Debug`, for example by passing it to CMake via the commandline switch `-DCMAKE_BUILD_TYPE=Debug`. You may also want to turn off sentry by setting `SENTRY_BACKEND=none` (for example via commandline switch `-DSENTRY_BACKEND=none`). An example invocation on Linux with GNU make would be 
+`cmake . -DCMAKE_BUILD_TYPE=Debug -DSENTRY_BACKEND=none` . 
+9. Build the `BeamMP-Server` target to build the BeamMP-Server, or the `BeamMP-Server-tests` target to build the unit-tests (does not include a working server). In the example from 8. (on Linux), you could build with  `make BeamMP-Server`, `make -j BeamMP-Server` or `cmake --build . --parallel --target BeamMP-Server` . Or, on Windows, (in Visual Studio), you would just press some big green "run" or "debug" button.
+10. When making changes, refer to [this section on how to commit properly](#how-to-commit). Not following those guidelines will result in your changes being rejected, so please take a look.
+11. Make sure to add Unit-tests with `doctest` if you build new stuff. You can find examples all over the latest version of the codebase (search for `TEST_CASE`).
+
+# Code Guidelines
+
+## Formatting
+
+1. Use `clang-format` to format your code before committig. A `.clang-format` file is provided in the root of the repository.
+2. All identifiers, type names, function names, etc. should be `PascalCase`. Type names may also have the `T` prefix, although this is not enforced (for example `TNetwork`).
+
+## Modular code
+
+Write code that is modular and testable. Generally, if you can write a good unit-test for it, it's modular. If you can't, it's not.
+
+Don't overdo it though - sometimes its okay to just write code, do the job, be done with it. You'll get feedback on this in the code review for your PR.

LICENSE

@@ -0,0 +1,2 @@
+Copyright (c) 2019-present Anonymous275 (@Anonymous-275), Lion Kortlepel (@lionkor). BeamMP-Server code is not in the public domain and is not free software. One must be granted explicit permission by the copyright holder(s) in order to modify or distribute any part of the source or binaries. Special permission to modify the source-code is implicitly granted only for the purpose of upstreaming those changes directly to github.com/BeamMP/BeamMP-Server via a GitHub pull-request.
+Commercial usage is prohibited, unless explicit permission has been granted prior to usage.

README.md

@@ -1,36 +1,90 @@
-# BeamNG-MP-Server
+# BeamMP-Server
 
-## Unix specific build instructions
+[![CMake Windows Build](https://github.com/BeamMP/BeamMP-Server/workflows/CMake%20Windows%20Build/badge.svg?branch=master)](https://github.com/BeamMP/BeamMP-Server/actions?query=workflow%3A%22CMake+Windows+Build%22)
+[![CMake Linux Build](https://github.com/BeamMP/BeamMP-Server/workflows/CMake%20Linux%20Build/badge.svg?branch=master)](https://github.com/BeamMP/BeamMP-Server/actions?query=workflow%3A%22CMake+Linux+Build%22)
 
-1. You need boost >= 1.70.0
+This is the server for the multiplayer mod **[BeamMP](https://beammp.com/)** for the game [BeamNG.drive](https://www.beamng.com/).
+The server is the point through which all clients communicate. You can write Lua mods for the server, there are detailed instructions on the [BeamMP Wiki](https://wiki.beammp.com).
 
-Check with your ditro's package manager whether it provides this. If it does, you should use that. 
+**For Linux, you __need__ the runtime dependencies, which are listed below under [Runtime Dependencies](#runtime-dependencies)**
 
+## Support + Contact
 
-If it doesnt provide it or you want to link it statically (like we do with our releases), then you have to do this:
+Feel free to ask any questions via the following channels:
+
+- **Discord**: [click for invite](https://discord.gg/beammp)
+- **BeamMP Forum**: [BeamMP Forum Support](https://forum.beammp.com/c/support/33)
+
+## Minimum Requirements
+
+These values are guesstimated and are subject to change with each release.
+
+* RAM: 50+ MiB usable (not counting OS overhead)
+* CPU: >1GHz, preferably multicore
+* OS: Windows, Linux (theoretically any POSIX)
+* GPU: None
+* HDD: 10 MiB + Mods/Plugins
+* Bandwidth: 5-10 Mb/s upload
+
+## Contributing
+
+TLDR; [Issues](https://github.com/BeamMP/BeamMP-Server/issues) with the "help wanted" or "good first issue" label or with nobody assigned.
+
+To contribute, look at the active [issues](https://github.com/BeamMP/BeamMP-Server/issues). Any issues that have the "help wanted" label or don't have anyone assigned are good tasks to take on. You can either contribute by programming or by testing and adding more info and ideas.
+
+Fork this repository, make a new branch for your feature, implement your feature or fix, and then create a pull-request here. Even incomplete features and fixes can be pull-requested.
+
+If you need support with understanding the codebase, please write us in the Discord. You'll need to be proficient in modern C++.
+
+## About Building from Source
+
+We only allow building unmodified (original) source code for public use. `master` is considered **unstable** and we will not provide technical support if such a build doesn't work, so always build from a tag. You can checkout a tag with `git checkout tags/TAGNAME`, where `TAGNAME` is the tag, for example `v3.1.0`. 
+
+## Supported Operating Systems
+
+The code itself supports (latest stable) Linux and Windows. In terms of actual build support, for now we usually only distribute Windows binaries and Linux. For any other distro or OS, you just have to find the same libraries listed in [Runtime Dependencies](#runtime-dependencies) further down the page, and it should build fine.
+
+Recommended compilers: MSVC, GCC, CLANG. 
+
+You can find precompiled binaries under [Releases](https://github.com/BeamMP/BeamMP-Server/releases/).
+
+## Build Instructions
+
+On Linux, you need some dependencies to **build** the server (on Windows, you don't):
+
+For Debian, Ubuntu and others you can find scripts that do this in `scripts/`.
 
-download the latest boost source code.
-Then, go to the downloaded directory and run
-```sh
-b2 link=static runtime-link=static threading=multi
 ```
-And then either symlink, edit CMakeLists to find it, or simply run
-```sh
-b2 link=static runtime-link=static threading=multi install
+liblua5.3-dev curl zip unzip tar cmake make git g++
 ```
-(warning: installs boost into your system, you might not want this).
 
-Then on invocation of cmake, ensure that you define `Boost_USE_STATIC_RUNTIME=ON`.
+The names of each package may change depending on your platform. See in `scripts/` or use a search engine to find out what they're called for you.
 
+You can build on **Windows, Linux** or other platforms by following these steps:
 
-2. Building
+1. Check out the repository with git: `git clone --recursive https://github.com/BeamMP/BeamMP-Server`.
+2. Go into the directory `cd BeamMP-Server`.
+3. Run CMake `cmake -S . -B bin -DCMAKE_BUILD_TYPE=Release` - this can take a few minutes and may take a lot of disk space and bandwidth.
+4. Build via `cmake --build bin --parallel -t BeamMP-Server`.
+5. Your executable can be found in `bin/`.
 
-Run cmake, and then make.
+When you make changes to the code, you only have to run step 4 again.
 
-Example:
+### Runtime Dependencies
 
-```bash
-~/src/Server $ cmake -S . -B bin -DCMAKE_BUILD_TYPE=Release
-...
-~/src/Server $ make -C bin -j 5
-```
+These are needed to *run* the server.
+
+Debian, Ubuntu and friends: `liblua5.3-0`
+
+Other Linux distros: `liblua` of *some kind*.
+
+Windows: No libraries.
+
+## Support
+The BeamMP project is supported by community donations via our [Patreon](https://www.patreon.com/BeamMP). This brings perks such as Patreon-only channels on our Discord, early access to new updates, and more server keys. 
+
+## Copyright
+
+Copyright (c) 2019-present Anonymous275 (@Anonymous-275), Lion Kortlepel (@lionkor).
+BeamMP-Server code is not in the public domain and is not free software. One must be granted explicit permission by the copyright holder(s) in order to modify or distribute any part of the source or binaries. Special permission to modify the source-code is implicitly granted only for the purpose of upstreaming those changes directly to github.com/BeamMP/BeamMP-Server via a GitHub pull-request.
+Commercial usage is prohibited, unless explicit permission has been granted prior to usage.

cmake/CompilerWarnings.cmake

@@ -0,0 +1,115 @@
+# from here:
+#
+# https://github.com/lefticus/cppbestpractices/blob/master/02-Use_the_Tools_Available.md
+# Courtesy of Jason Turner
+# License here: https://github.com/cpp-best-practices/cppbestpractices/blob/master/LICENSE
+# 
+# This version has been modified by the owners of the current respository.
+# Modifications have mostly been marked with "modified" or similar, though this is not 
+# strictly required.
+
+function(set_project_warnings project_name)
+    set(MSVC_WARNINGS
+            /W4         # Baseline reasonable warnings
+            /w14242 # 'identifier': conversion from 'type1' to 'type1', possible loss
+                            # of data
+            /w14254 # 'operator': conversion from 'type1:field_bits' to
+                            # 'type2:field_bits', possible loss of data
+            /w14263 # 'function': member function does not override any base class
+                            # virtual member function
+            /w14265 # 'classname': class has virtual functions, but destructor is not
+                            # virtual instances of this class may not be destructed correctly
+            /w14287 # 'operator': unsigned/negative constant mismatch
+            /we4289 # nonstandard extension used: 'variable': loop control variable
+                            # declared in the for-loop is used outside the for-loop scope
+            /w14296 # 'operator': expression is always 'boolean_value'
+            /w14311 # 'variable': pointer truncation from 'type1' to 'type2'
+            /w14545 # expression before comma evaluates to a function which is missing
+                            # an argument list
+            /w14546 # function call before comma missing argument list
+            /w14547 # 'operator': operator before comma has no effect; expected
+                            # operator with side-effect
+            /w14549 # 'operator': operator before comma has no effect; did you intend
+                            # 'operator'?
+            /w14555 # expression has no effect; expected expression with side- effect
+            /w14619 # pragma warning: there is no warning number 'number'
+            /w14640 # Enable warning on thread un-safe static member initialization
+            /w14826 # Conversion from 'type1' to 'type_2' is sign-extended. This may
+                            # cause unexpected runtime behavior.
+            /w14905 # wide string literal cast to 'LPSTR'
+            /w14906 # string literal cast to 'LPWSTR'
+            /w14928 # illegal copy-initialization; more than one user-defined
+                            # conversion has been implicitly applied
+            /permissive- # standards conformance mode for MSVC compiler.
+    )
+
+    set(CLANG_WARNINGS
+            -Wall
+            -Wextra    # reasonable and standard
+            -Wshadow # warn the user if a variable declaration shadows one from a
+                             # parent context
+            -Wnon-virtual-dtor # warn the user if a class with virtual functions has a
+                                                 # non-virtual destructor. This helps catch hard to
+                                                 # track down memory errors
+            -Wold-style-cast # warn for c-style casts
+            -Wcast-align         # warn for potential performance problem casts
+            -Wunused                 # warn on anything being unused
+            -Woverloaded-virtual # warn if you overload (not override) a virtual
+                                                     # function
+            -Wpedantic     # warn if non-standard C++ is used
+            -Wconversion # warn on type conversions that may lose data
+            -Wsign-conversion    # warn on sign conversions
+            -Wnull-dereference # warn if a null dereference is detected
+            -Wdouble-promotion # warn if float is implicit promoted to double
+            -Wformat=2 # warn on security issues around functions that format output
+                                 # (ie printf)
+            # modified; added more errors / warnings
+            # some have been set to be errors, but the option _WARNINGS_AS_ERRORS
+            # (see below) should still be used in strict pipelines.
+            -Werror=uninitialized
+            -Werror=float-equal
+            -Werror=write-strings
+            -Werror=strict-aliasing -fstrict-aliasing
+            -Werror=missing-declarations
+            -Werror=missing-field-initializers
+            -Werror=ctor-dtor-privacy
+            -Werror=switch-enum
+            -Wswitch-default
+            -Werror=unused-result
+            -Werror=implicit-fallthrough
+            -Werror=return-type
+            -Wmissing-include-dirs
+    )
+
+    if (${PROJECT_NAME}_WARNINGS_AS_ERRORS)
+        set(CLANG_WARNINGS ${CLANG_WARNINGS} -Werror)
+        set(MSVC_WARNINGS ${MSVC_WARNINGS} /WX)
+    endif()
+
+    set(GCC_WARNINGS
+            ${CLANG_WARNINGS}
+            -Wmisleading-indentation # warn if indentation implies blocks where blocks
+                                                             # do not exist
+            -Wduplicated-cond # warn if if / else chain has duplicated conditions
+            -Wduplicated-branches # warn if if / else branches have duplicated code
+            -Wlogical-op     # warn about logical operations being used where bitwise were
+                                         # probably wanted
+            # -Wuseless-cast # warn if you perform a cast to the same type (modified: removed)
+    )
+
+    if(MSVC)
+        set(PRJ_WARNINGS ${MSVC_WARNINGS})
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+        set(PRJ_WARNINGS ${CLANG_WARNINGS})
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        set(PRJ_WARNINGS ${GCC_WARNINGS})
+    else()
+        message(AUTHOR_WARNING "No compiler warnings set for '${CMAKE_CXX_COMPILER_ID}' compiler.")
+    endif()
+
+    target_compile_options(${project_name} PUBLIC ${PRJ_WARNINGS})
+
+    if(NOT TARGET ${project_name})
+        message(AUTHOR_WARNING "${project_name} is not a target, thus no compiler warning were added.")
+    endif()
+endfunction()

cmake/Git.cmake

@@ -0,0 +1,21 @@
+find_package(Git)
+if(${PROJECT_NAME}_CHECKOUT_GIT_SUBMODULES)
+    if(Git_FOUND)
+        message(STATUS "Git found, submodule update and init")
+        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(SEND_ERROR "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}, please checkout submodules. This may result in missing dependencies.")
+        endif()
+    else()
+        message(SEND_ERROR "git required for checking out submodules, but not found. Submodules will not be checked out - this may result in missing dependencies.")
+    endif()
+endif()
+
+if(Git_FOUND)
+
+else()
+    message(STATUS "Git not found - the version will not include a git hash.")
+    set(PRJ_GIT_HASH "unknown")
+endif()

cmake/StandardSettings.cmake

@@ -0,0 +1,44 @@
+# Modified, original version from https://github.com/filipdutescu/modern-cpp-template (Unlicense)
+
+option(${PROJECT_NAME}_WARNINGS_AS_ERRORS "Treat compiler warnings as errors." OFF)
+option(${PROJECT_NAME}_CHECKOUT_GIT_SUBMODULES "If git is found, initialize all submodules." ON)
+option(${PROJECT_NAME}_ENABLE_UNIT_TESTING "Enable unit tests for the projects (from the `test` subfolder)." ON)
+option(${PROJECT_NAME}_ENABLE_CLANG_TIDY "Enable static analysis with Clang-Tidy." OFF)
+option(${PROJECT_NAME}_ENABLE_CPPCHECK "Enable static analysis with Cppcheck." OFF)
+# TODO Implement code coverage
+# option(${PROJECT_NAME}_ENABLE_CODE_COVERAGE "Enable code coverage through GCC." OFF)
+option(${PROJECT_NAME}_ENABLE_DOXYGEN "Enable Doxygen documentation builds of source." OFF)
+
+# Generate compile_commands.json for clang based tools
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# Export all symbols when building a shared library
+if(BUILD_SHARED_LIBS)
+    set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS OFF)
+    set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+    set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
+endif()
+
+option(${PROJECT_NAME}_ENABLE_LTO "Enable Interprocedural Optimization, aka Link Time Optimization (LTO)." OFF)
+if(${PROJECT_NAME}_ENABLE_LTO)
+    include(CheckIPOSupported)
+    check_ipo_supported(RESULT result OUTPUT output)
+    if(result)
+        set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+    else()
+        message(SEND_ERROR "IPO is not supported: ${output}.")
+    endif()
+endif()
+
+option(${PROJECT_NAME}_ENABLE_CCACHE "Enable the usage of Ccache, in order to speed up rebuild times." ON)
+find_program(CCACHE_FOUND ccache)
+if(CCACHE_FOUND)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+endif()
+
+option(${PROJECT_NAME}_ENABLE_SANITIZER "Enable sanitizer to detect memory errors, undefined behavior, etc. (slows down the executable)." OFF)
+if(${PROJECT_NAME}_ENABLE_SANITIZER)
+    add_compile_options(-fsanitize=address,undefined)
+    add_link_options(-fsanitize=address,undefined)
+endif()

cmake/StaticAnalyzers.cmake

@@ -0,0 +1,20 @@
+if(${PROJECT_NAME}_ENABLE_CLANG_TIDY)
+  find_program(CLANGTIDY clang-tidy)
+  if(CLANGTIDY)
+    set(CMAKE_CXX_CLANG_TIDY ${CLANGTIDY} -extra-arg=-Wno-unknown-warning-option)
+    message("Clang-Tidy finished setting up.")
+  else()
+    message(SEND_ERROR "Clang-Tidy requested but executable not found.")
+  endif()
+endif()
+
+if(${PROJECT_NAME}_ENABLE_CPPCHECK)
+  find_program(CPPCHECK cppcheck)
+  if(CPPCHECK)
+    set(CMAKE_CXX_CPPCHECK ${CPPCHECK} --suppress=missingInclude --enable=all
+                           --inline-suppr --inconclusive)
+    message("Cppcheck finished setting up.")
+  else()
+    message(SEND_ERROR "Cppcheck requested but executable not found.")
+  endif()
+endif()

cmake/Vcpkg.cmake

@@ -0,0 +1,17 @@
+if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
+    if(NOT EXISTS ${CMAKE_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake)
+        find_package(Git)
+        if(Git_FOUND)
+            execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive vcpkg
+                            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                            RESULT_VARIABLE GIT_SUBMOD_RESULT)
+            if(NOT GIT_SUBMOD_RESULT EQUAL "0")
+                message(SEND_ERROR "Checking out vcpkg in source tree failed with ${GIT_SUBMOD_RESULT}.")
+            endif()
+        else()
+            message(FATAL_ERROR "Could not find git or vcpkg.cmake. Please either, install git and re-run cmake (or run `git submodule update --init --recursive`), or install vcpkg and add `-DCMAKE_TOOLCHAIN_FILE=<path-to-vcpkg>/scripts/buildsystems/vcpkg.cmake` to your cmake invocation. Please try again after making those changes.")
+        endif()
+    endif()
+    set(CMAKE_TOOLCHAIN_FILE ${CMAKE_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake)
+endif()
+

include/ArgsParser.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <initializer_list>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+/*
+ * Allows syntax:
+ *  --help              : long flags
+ *  --path=/home/lion   : long assignments
+ */
+class ArgsParser {
+public:
+    enum Flags : int {
+        NONE = 0,
+        REQUIRED = 1, // argument is required
+        HAS_VALUE = 2, // argument must have a value
+    };
+
+    ArgsParser() = default;
+
+    void Parse(const std::vector<std::string_view>& ArgList);
+    // prints errors if any errors occurred, in that case also returns false
+    bool Verify();
+    void RegisterArgument(std::vector<std::string>&& ArgumentNames, int Flags);
+    // pass all possible names for this argument (short, long, etc)
+    bool FoundArgument(const std::vector<std::string>& Names);
+    std::optional<std::string> GetValueOfArgument(const std::vector<std::string>& Names);
+
+private:
+    void ConsumeLongAssignment(const std::string& Arg);
+    void ConsumeLongFlag(const std::string& Arg);
+    bool IsRegistered(const std::string& Name);
+
+    struct Argument {
+        std::string Name;
+        std::optional<std::string> Value;
+    };
+
+    struct RegisteredArgument {
+        std::vector<std::string> Names;
+        int Flags;
+    };
+
+    std::vector<RegisteredArgument> mRegisteredArguments;
+    std::vector<Argument> mFoundArgs;
+};

include/BoostAliases.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <boost/asio.hpp>
+#include <boost/system/error_code.hpp>
+
+using namespace boost::asio;

include/Client.h

@@ -0,0 +1,116 @@
+#pragma once
+
+#include <chrono>
+#include <memory>
+#include <optional>
+#include <queue>
+#include <string>
+#include <unordered_set>
+
+#include "BoostAliases.h"
+#include "Common.h"
+#include "Compat.h"
+#include "VehicleData.h"
+
+class TServer;
+
+#ifdef BEAMMP_WINDOWS
+// for socklen_t
+#include <WS2tcpip.h>
+#endif // WINDOWS
+
+struct TConnection final {
+    ip::tcp::socket Socket;
+    ip::tcp::endpoint SockAddr;
+};
+
+class TClient final {
+public:
+    using TSetOfVehicleData = std::vector<TVehicleData>;
+
+    struct TVehicleDataLockPair {
+        TSetOfVehicleData* VehicleData;
+        std::unique_lock<std::mutex> Lock;
+    };
+
+    TClient(TServer& Server, ip::tcp::socket&& Socket);
+    TClient(const TClient&) = delete;
+    ~TClient();
+    TClient& operator=(const TClient&) = delete;
+
+    void AddNewCar(int Ident, const std::string& Data);
+    void SetCarData(int Ident, const std::string& Data);
+    void SetCarPosition(int Ident, const std::string& Data);
+    TVehicleDataLockPair GetAllCars();
+    void SetName(const std::string& Name) { mName = Name; }
+    void SetRoles(const std::string& Role) { mRole = Role; }
+    void SetIdentifier(const std::string& key, const std::string& value) { mIdentifiers[key] = value; }
+    std::string GetCarData(int Ident);
+    std::string GetCarPositionRaw(int Ident);
+    void SetUDPAddr(const ip::udp::endpoint& Addr) { mUDPAddress = Addr; }
+    void SetDownSock(ip::tcp::socket&& CSock) { mDownSocket = std::move(CSock); }
+    void SetTCPSock(ip::tcp::socket&& CSock) { mSocket = std::move(CSock); }
+    void Disconnect(std::string_view Reason);
+    bool IsDisconnected() const { return !mSocket.is_open(); }
+    // locks
+    void DeleteCar(int Ident);
+    [[nodiscard]] const std::unordered_map<std::string, std::string>& GetIdentifiers() const { return mIdentifiers; }
+    [[nodiscard]] const ip::udp::endpoint& GetUDPAddr() const { return mUDPAddress; }
+    [[nodiscard]] ip::udp::endpoint& GetUDPAddr() { return mUDPAddress; }
+    [[nodiscard]] ip::tcp::socket& GetDownSock() { return mDownSocket; }
+    [[nodiscard]] const ip::tcp::socket& GetDownSock() const { return mDownSocket; }
+    [[nodiscard]] ip::tcp::socket& GetTCPSock() { return mSocket; }
+    [[nodiscard]] const ip::tcp::socket& GetTCPSock() const { return mSocket; }
+    [[nodiscard]] std::string GetRoles() const { return mRole; }
+    [[nodiscard]] std::string GetName() const { return mName; }
+    void SetUnicycleID(int ID) { mUnicycleID = ID; }
+    void SetID(int ID) { mID = ID; }
+    [[nodiscard]] int GetOpenCarID() const;
+    [[nodiscard]] int GetCarCount() const;
+    void ClearCars();
+    [[nodiscard]] int GetID() const { return mID; }
+    [[nodiscard]] int GetUnicycleID() const { return mUnicycleID; }
+    [[nodiscard]] bool IsConnected() const { return mIsConnected; }
+    [[nodiscard]] bool IsSynced() const { return mIsSynced; }
+    [[nodiscard]] bool IsSyncing() const { return mIsSyncing; }
+    [[nodiscard]] bool IsGuest() const { return mIsGuest; }
+    void SetIsGuest(bool NewIsGuest) { mIsGuest = NewIsGuest; }
+    void SetIsSynced(bool NewIsSynced) { mIsSynced = NewIsSynced; }
+    void SetIsSyncing(bool NewIsSyncing) { mIsSyncing = NewIsSyncing; }
+    void EnqueuePacket(const std::vector<uint8_t>& Packet);
+    [[nodiscard]] std::queue<std::vector<uint8_t>>& MissedPacketQueue() { return mPacketsSync; }
+    [[nodiscard]] const std::queue<std::vector<uint8_t>>& MissedPacketQueue() const { return mPacketsSync; }
+    [[nodiscard]] size_t MissedPacketQueueSize() const { return mPacketsSync.size(); }
+    [[nodiscard]] std::mutex& MissedPacketQueueMutex() const { return mMissedPacketsMutex; }
+    void SetIsConnected(bool NewIsConnected) { mIsConnected = NewIsConnected; }
+    [[nodiscard]] TServer& Server() const;
+    void UpdatePingTime();
+    int SecondsSinceLastPing();
+
+private:
+    void InsertVehicle(int ID, const std::string& Data);
+
+    TServer& mServer;
+    bool mIsConnected = false;
+    bool mIsSynced = false;
+    bool mIsSyncing = false;
+    mutable std::mutex mMissedPacketsMutex;
+    std::queue<std::vector<uint8_t>> mPacketsSync;
+    std::unordered_map<std::string, std::string> mIdentifiers;
+    bool mIsGuest = false;
+    mutable std::mutex mVehicleDataMutex;
+    mutable std::mutex mVehiclePositionMutex;
+    TSetOfVehicleData mVehicleData;
+    SparseArray<std::string> mVehiclePosition;
+    std::string mName = "Unknown Client";
+    ip::tcp::socket mSocket;
+    ip::tcp::socket mDownSocket;
+    ip::udp::endpoint mUDPAddress {};
+    int mUnicycleID = -1;
+    std::string mRole;
+    std::string mDID;
+    int mID = -1;
+    std::chrono::time_point<std::chrono::high_resolution_clock> mLastPingTime;
+};
+
+std::optional<std::weak_ptr<TClient>> GetClient(class TServer& Server, int ID);

include/Client.hpp

@@ -1,85 +0,0 @@
-///
-/// Created by Anonymous275 on 5/8/2020
-///
-
-#pragma once
-#ifdef WIN32
-#include <WS2tcpip.h>
-#else
-#include <arpa/inet.h>
-#define SOCKET int
-#endif
-#include "CustomAssert.h"
-#include <string>
-#include <vector>
-#include <chrono>
-#include <set>
-#include <algorithm>
-
-struct VData{
-    int ID = -1;
-    std::string Data;
-};
-
-class Client {
-private:
-    std::set<std::unique_ptr<VData>> VehicleData; //ID and Data;
-    std::string Name = Sec("Unknown Client");
-    sockaddr_in UDPADDR;
-    std::string Role;
-    std::string DID;
-    SOCKET TCPSOCK;
-    int Status = 0;
-    int ID = -1;
-public:
-    void AddNewCar(int ident,const std::string& Data);
-    void SetCarData(int ident,const std::string&Data);
-    void SetName(const std::string& name);
-    void SetRole(const std::string& role);
-    void SetDID(const std::string& did);
-    std::string GetCarData(int ident);
-    void SetUDPAddr(sockaddr_in Addr);
-    std::set<std::unique_ptr<VData>>& GetAllCars();
-    const std::set<std::unique_ptr<VData>>& GetAllCars() const;
-    void SetTCPSock(SOCKET CSock);
-    void SetStatus(int status);
-    void DeleteCar(int ident);
-    sockaddr_in GetUDPAddr();
-    bool isConnected = false;
-    std::string GetRole();
-    std::string GetName();
-    bool isSynced = false;
-    std::string GetDID();
-    SOCKET GetTCPSock();
-    void SetID(int ID);
-    int GetOpenCarID();
-    int GetCarCount();
-    void ClearCars();
-    int GetStatus();
-    int GetID();
-};
-struct ClientInterface{
-    std::set<std::unique_ptr<Client>> Clients;
-    void RemoveClient(Client*& c){
-        Assert(c);
-        c->ClearCars();
-        auto Iter = std::find_if(Clients.begin(), Clients.end(), [&](auto& ptr) {
-            return c == ptr.get();
-        });
-        Assert(Iter != Clients.end());
-        if (Iter == Clients.end()) {
-            return;
-        }
-        Clients.erase(Iter);
-        c = nullptr;
-    }
-    void AddClient(Client*&& c){
-        Assert(c);
-        Clients.insert(std::move(std::unique_ptr<Client>(c)));
-    }
-    int Size(){
-        return int(Clients.size());
-    }
-};
-
-extern std::unique_ptr<ClientInterface> CI;

include/Common.h

@@ -0,0 +1,321 @@
+#pragma once
+
+#include <array>
+#include <atomic>
+#include <cstring>
+#include <deque>
+#include <filesystem>
+#include <fmt/format.h>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <shared_mutex>
+#include <sstream>
+#include <unordered_map>
+#include <zlib.h>
+
+#include <doctest/doctest.h>
+#include <filesystem>
+namespace fs = std::filesystem;
+
+#include "TConsole.h"
+
+struct Version {
+    uint8_t major;
+    uint8_t minor;
+    uint8_t patch;
+    Version(uint8_t major, uint8_t minor, uint8_t patch);
+    Version(const std::array<uint8_t, 3>& v);
+    std::string AsString();
+};
+
+template <typename T>
+using SparseArray = std::unordered_map<size_t, T>;
+
+// static class handling application start, shutdown, etc.
+// yes, static classes, singletons, globals are all pretty
+// bad idioms. In this case we need a central way to access
+// stuff like graceful shutdown, global settings (its in the name),
+// etc.
+class Application final {
+public:
+    // types
+    struct TSettings {
+        std::string ServerName { "BeamMP Server" };
+        std::string ServerDesc { "BeamMP Default Description" };
+        std::string ServerTags { "Freeroam" };
+        std::string Resource { "Resources" };
+        std::string MapName { "/levels/gridmap_v2/info.json" };
+        std::string Key {};
+        std::string Password{};
+        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 };
+        std::string CustomIP {};
+        bool LogChat { true };
+        bool SendErrors { true };
+        bool SendErrorsMessageEnabled { true };
+        int HTTPServerPort { 8080 };
+        std::string HTTPServerIP { "127.0.0.1" };
+        bool HTTPServerUseSSL { false };
+        bool HideUpdateMessages { false };
+        [[nodiscard]] bool HasCustomIP() const { return !CustomIP.empty(); }
+    };
+
+    using TShutdownHandler = std::function<void()>;
+
+    // methods
+    Application() = delete;
+
+    // 'Handler' is called when GracefullyShutdown is called
+    static void RegisterShutdownHandler(const TShutdownHandler& Handler);
+    // Causes all threads to finish up and exit gracefull gracefully
+    static void GracefullyShutdown();
+    static TConsole& Console() { return mConsole; }
+    static std::string ServerVersionString();
+    static const Version& ServerVersion() { return mVersion; }
+    static uint8_t ClientMajorVersion() { return 2; }
+    static std::string PPS() { return mPPS; }
+    static void SetPPS(const std::string& NewPPS) { mPPS = NewPPS; }
+
+    static TSettings Settings;
+
+    static std::vector<std::string> GetBackendUrlsInOrder() {
+        return {
+            "backend.beammp.com",
+            "backup1.beammp.com",
+            "backup2.beammp.com"
+        };
+    }
+
+    static std::string GetBackendUrlForAuth() { return "auth.beammp.com"; }
+    static std::string GetBackendUrlForSocketIO() { return "https://backend.beammp.com"; }
+    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() {
+        mConsole.InitializeCommandline();
+    }
+
+    enum class Status {
+        Starting,
+        Good,
+        Bad,
+        ShuttingDown,
+        Shutdown,
+    };
+
+    using SystemStatusMap = std::unordered_map<std::string /* system name */, Status /* status */>;
+
+    static const SystemStatusMap& GetSubsystemStatuses() {
+        std::unique_lock Lock(mSystemStatusMapMutex);
+        return mSystemStatusMap;
+    }
+
+    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 TConsole mConsole;
+    static inline std::shared_mutex mShutdownMtx {};
+    static inline bool mShutdown { false };
+    static inline std::mutex mShutdownHandlersMutex {};
+    static inline std::deque<TShutdownHandler> mShutdownHandlers {};
+
+    static inline Version mVersion { 3, 2, 1 };
+};
+
+void SplitString(std::string const& str, const char delim, std::vector<std::string>& out);
+
+std::string ThreadName(bool DebugModeOverride = false);
+void RegisterThread(const std::string& str);
+#define RegisterThreadAuto() RegisterThread(__func__)
+
+#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()")
+
+// for those times when you just need to ignore something :^)
+// explicity disables a [[nodiscard]] warning
+#define beammp_ignore(x) (void)x
+
+// 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)); \
+        } 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);
+
+#define Biggest 30000
+
+template <typename T>
+inline T Comp(const T& Data) {
+    std::array<char, Biggest> C {};
+    // obsolete
+    C.fill(0);
+    z_stream defstream;
+    defstream.zalloc = nullptr;
+    defstream.zfree = nullptr;
+    defstream.opaque = nullptr;
+    defstream.avail_in = uInt(Data.size());
+    defstream.next_in = const_cast<Bytef*>(reinterpret_cast<const Bytef*>(&Data[0]));
+    defstream.avail_out = Biggest;
+    defstream.next_out = reinterpret_cast<Bytef*>(C.data());
+    deflateInit(&defstream, Z_BEST_COMPRESSION);
+    deflate(&defstream, Z_SYNC_FLUSH);
+    deflate(&defstream, Z_FINISH);
+    deflateEnd(&defstream);
+    size_t TotalOut = defstream.total_out;
+    T Ret;
+    Ret.resize(TotalOut);
+    std::fill(Ret.begin(), Ret.end(), 0);
+    std::copy_n(C.begin(), TotalOut, Ret.begin());
+    return Ret;
+}
+
+template <typename T>
+inline T DeComp(const T& Compressed) {
+    std::array<char, Biggest> C {};
+    // not needed
+    C.fill(0);
+    z_stream infstream;
+    infstream.zalloc = nullptr;
+    infstream.zfree = nullptr;
+    infstream.opaque = nullptr;
+    infstream.avail_in = Biggest;
+    infstream.next_in = const_cast<Bytef*>(reinterpret_cast<const Bytef*>(&Compressed[0]));
+    infstream.avail_out = Biggest;
+    infstream.next_out = const_cast<Bytef*>(reinterpret_cast<const Bytef*>(C.data()));
+    inflateInit(&infstream);
+    inflate(&infstream, Z_SYNC_FLUSH);
+    inflate(&infstream, Z_FINISH);
+    inflateEnd(&infstream);
+    size_t TotalOut = infstream.total_out;
+    T Ret;
+    Ret.resize(TotalOut);
+    std::fill(Ret.begin(), Ret.end(), 0);
+    std::copy_n(C.begin(), TotalOut, Ret.begin());
+    return Ret;
+}
+
+std::string GetPlatformAgnosticErrorString();
+#define S_DSN SU_RAW

include/Compat.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Environment.h"
+
+// ======================= UNIX ========================
+
+#ifdef BEAMMP_LINUX
+#include <errno.h>
+#include <termios.h>
+#include <unistd.h>
+char _getch();
+#endif // unix
+
+// ======================= APPLE ========================
+
+#ifdef BEAMMP_APPLE
+#include <errno.h>
+#include <termios.h>
+#include <unistd.h>
+char _getch();
+#endif // unix
+
+// ======================= WINDOWS =======================
+
+#ifdef BEAMMP_WINDOWS
+#include <conio.h>
+#endif // WIN32

include/Compressor.h

@@ -1,7 +0,0 @@
-///
-/// Created by Anonymous275 on 7/24/2020
-///
-#pragma once
-#include <string>
-std::string Comp(std::string Data);
-std::string DeComp(std::string Compressed);

include/Cryptography.h

@@ -1,16 +1,11 @@
-///
-/// Created by Anonymous275 on 8/11/2020
-///
+// Copyright Anonymous275 8/11/2020
+
 #pragma once
 #include <array>
 #include <cstdarg>
-#include <cstdio>
 #include <string>
 
-#define BEGIN_NAMESPACE(x) namespace x {
-#define END_NAMESPACE }
-
-BEGIN_NAMESPACE(XorCompileTime)
+namespace Crypto {
 
 constexpr auto time = __TIME__;
 constexpr auto seed = static_cast<int>(time[7]) + static_cast<int>(time[6]) * 10 + static_cast<int>(time[4]) * 60 + static_cast<int>(time[3]) * 600 + static_cast<int>(time[1]) * 3600 + static_cast<int>(time[0]) * 36000;
@@ -54,7 +49,7 @@ struct RandomChar {
 };
 
 template <size_t N, int K, typename Char>
-struct XorString {
+struct MangleString {
 private:
     const char _key;
     std::array<Char, N + 1> _encrypted;
@@ -69,11 +64,11 @@ private:
 
 public:
     template <size_t... Is>
-    constexpr inline XorString(const Char* str, std::index_sequence<Is...>)
+    constexpr MangleString(const Char* str, std::index_sequence<Is...>)
         : _key(RandomChar<K>::value)
         , _encrypted { enc(str[Is])... } { }
 
-    inline decltype(auto) decrypt() {
+    decltype(auto) decrypt() {
         for (size_t i = 0; i < N; ++i) {
             _encrypted[i] = dec(_encrypted[i]);
         }
@@ -96,37 +91,24 @@ static auto w_printf_s = [](const char* fmt, ...) {
     va_end(args);
 };
 
-/*static auto w_sprintf = [](char* buf, const char* fmt, ...) {
-        va_list args;
-                va_start(args, fmt);
-        vsprintf(buf, fmt, args);
-                va_end(args);
-    };*/
-
-/*static auto w_sprintf_ret = [](char* buf, const char* fmt, ...) {
-        int ret;
-        va_list args;
-                va_start(args, fmt);
-        ret = vsprintf(buf, fmt, args);
-                va_end(args);
-        return ret;
-    };*/
-
-static auto w_sprintf_s = [](char* buf, size_t buf_size, const char* fmt, ...) {
+static auto w_sprintf_s = [](char* buf, size_t, const char* fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    vsnprintf(buf, buf_size, fmt, args);
+    vsprintf(buf, fmt, args);
     va_end(args);
 };
 
-static auto w_sprintf_s_ret = [](char* buf, size_t buf_size, const char* fmt, ...) {
+static auto w_sprintf_s_ret = [](char* buf, size_t, const char* fmt, ...) {
     int ret;
     va_list args;
     va_start(args, fmt);
-    ret = vsnprintf(buf, buf_size, fmt, args);
+    ret = vsprintf(buf, fmt, args);
     va_end(args);
     return ret;
 };
-#define Sec(s) [] { constexpr XorCompileTime::XorString< sizeof(s)/sizeof(char) - 1, __COUNTER__, char > expr( s, std::make_index_sequence< sizeof(s)/sizeof(char) - 1>() ); return expr; }().decrypt()
-#define SecW(s) [] { constexpr XorCompileTime::XorString< sizeof(s)/sizeof(wchar_t) - 1, __COUNTER__, wchar_t > expr( s, std::make_index_sequence< sizeof(s)/sizeof(wchar_t) - 1>() ); return expr; }().decrypt()
-END_NAMESPACE
+
+#define XOR_C(s) [] { constexpr Crypto::MangleString< sizeof(s)/sizeof(char) - 1, __COUNTER__, char > expr( s, std::make_index_sequence< sizeof(s)/sizeof(char) - 1>() ); return expr; }().decrypt()
+#define XOR_W(s) [] { constexpr Crypto::MangleString< sizeof(s)/sizeof(wchar_t) - 1, __COUNTER__, wchar_t > expr( s, std::make_index_sequence< sizeof(s)/sizeof(wchar_t) - 1>() ); return expr; }().decrypt()
+#define RAWIFY(s) XOR_C(s)
+
+}

include/Curl/Http.h

@@ -1,7 +0,0 @@
-///
-/// Created by Anonymous275 on 7/18/2020
-///
-#pragma once
-#include <string>
-std::string HttpRequest(const std::string& IP, int port);
-std::string PostHTTP(const std::string& IP, const std::string& Fields);

include/CustomAssert.h

@@ -15,7 +15,7 @@
 #include <sstream>
 #include <thread>
 
-#include "Logger.h"
+#include "Common.h"
 
 static const char* const ANSI_RESET = "\u001b[0m";
 
@@ -40,7 +40,8 @@ static const char* const ANSI_WHITE_BOLD = "\u001b[37;1m";
 static const char* const ANSI_BOLD = "\u001b[1m";
 static const char* const ANSI_UNDERLINE = "\u001b[4m";
 
-#if DEBUG
+#ifdef DEBUG
+#include <iostream>
 inline void _assert([[maybe_unused]] const char* file, [[maybe_unused]] const char* function, [[maybe_unused]] unsigned line,
     [[maybe_unused]] const char* condition_string, [[maybe_unused]] bool result) {
     if (!result) {
@@ -54,14 +55,18 @@ inline void _assert([[maybe_unused]] const char* file, [[maybe_unused]] const ch
     }
 }
 
-#define Assert(cond) _assert(__FILE__, __func__, __LINE__, #cond, (cond))
-#define AssertNotReachable() _assert(__FILE__, __func__, __LINE__, "reached unreachable code", false)
+#define beammp_assert(cond) _assert(__FILE__, __func__, __LINE__, #cond, (cond))
+#define beammp_assert_not_reachable() _assert(__FILE__, __func__, __LINE__, "reached unreachable code", false)
 #else
-// In release build, these macros turn into NOPs. The compiler will optimize these out.
-#define Assert(x) \
-    do {          \
+#define beammp_assert(cond)                                                            \
+    do {                                                                               \
+        bool result = (cond);                                                          \
+        if (!result) {                                                                 \
+            beammp_errorf("Assertion failed in '{}:{}': {}.", __func__, _line, #cond); \
+        }                                                                              \
     } while (false)
-#define AssertNotReachable() \
-    do {                     \
+#define beammp_assert_not_reachable()                                                      \
+    do {                                                                                   \
+        beammp_errorf("Assertion failed in '{}:{}': Unreachable code reached. This may result in a crash or undefined state of the program.", __func__, _line); \
     } while (false)
 #endif // DEBUG

include/Defer.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <functional>
+
+template <typename FnT>
+class Defer final {
+public:
+    Defer(FnT fn)
+        : mFunction([&fn] { (void)fn(); }) { }
+    ~Defer() {
+        if (mFunction) {
+            mFunction();
+        }
+    }
+
+private:
+    std::function<void()> mFunction;
+};

include/Environment.h

@@ -0,0 +1,17 @@
+#pragma once
+
+// one of BEAMMP_{WINDOWS,LINUX,APPLE} will be set at the end of this
+
+// clang-format off
+#if !defined(BEAMMP_WINDOWS) && !defined(BEAMMP_UNIX) && !defined(BEAMMP_APPLE)
+    #if defined(_WIN32) || defined(__CYGWIN__)
+        #define BEAMMP_WINDOWS
+    #elif defined(__linux__) || defined(__linux) || defined(linux) || defined(__unix__) || defined(__unix) || defined(unix)
+        #define BEAMMP_LINUX
+    #elif defined(__APPLE__) || defined(__MACH__)
+        #define BEAMMP_APPLE
+    #else
+        #error "This platform is not known. Please define one of the above for your OS."
+    #endif
+#endif
+// clang-format on

include/Http.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <Common.h>
+#include <IThreaded.h>
+#include <filesystem>
+#include <string>
+#include <unordered_map>
+
+#if defined(BEAMMP_LINUX)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+#include <httplib.h>
+#if defined(BEAMMP_LINUX)
+#pragma GCC diagnostic pop
+#endif
+
+namespace fs = std::filesystem;
+
+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 = {});
+namespace Status {
+    std::string ToString(int code);
+}
+const std::string ErrorString = "-1";
+
+namespace Server {
+    class THttpServerInstance {
+    public:
+        THttpServerInstance();
+
+    protected:
+        void operator()();
+
+    private:
+        std::thread mThread;
+    };
+}
+}

include/IThreaded.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <thread>
+
+// pure virtual class to be inherited from by classes which intend to be threaded
+class IThreaded {
+public:
+    IThreaded()
+        // invokes operator() on this object
+        : mThread() { }
+    virtual ~IThreaded() noexcept {
+        if (mThread.joinable()) {
+            mThread.join();
+        }
+    }
+
+    virtual void Start() final {
+        mThread = std::thread([this] { (*this)(); });
+    }
+    virtual void operator()() = 0;
+
+protected:
+    std::thread mThread;
+};

include/Json.h

@@ -0,0 +1,9 @@
+//
+// Created by anon on 4/21/21.
+//
+
+#pragma once
+#include "rapidjson/stringbuffer.h"
+#include "rapidjson/prettywriter.h"
+#include "rapidjson/document.h"
+#include "rapidjson/writer.h"

include/Logger.h

@@ -1,18 +0,0 @@
-///
-/// Created by Anonymous275 on 4/2/2020.
-///
-#pragma once
-#include "Security/Xor.h"
-#include <iostream>
-#include <mutex>
-#include <string>
-void InitLog();
-#define DebugPrintTID() DebugPrintTIDInternal(__func__, false)
-void DebugPrintTIDInternal(const std::string& func, bool overwrite = true); // prints the current thread id in debug mode, to make tracing of crashes and asserts easier
-void ConsoleOut(const std::string& msg);
-void QueueAbort();
-void except(const std::string& toPrint);
-void debug(const std::string& toPrint);
-void error(const std::string& toPrint);
-void info(const std::string& toPrint);
-void warn(const std::string& toPrint);

include/Lua/LuaSystem.hpp

@@ -1,77 +0,0 @@
-///
-/// Created by Anonymous275 on 5/20/2020
-///
-
-#pragma once
-#include <any>
-#include <filesystem>
-#include <iostream>
-#include <lua.hpp>
-#include <memory>
-#include <mutex>
-#include <set>
-#include <thread>
-#include <vector>
-
-namespace fs = std::filesystem;
-
-struct LuaArg {
-    std::vector<std::any> args;
-    void PushArgs(lua_State* State) {
-        for (std::any arg : args) {
-            if (!arg.has_value())
-                return;
-            std::string Type = arg.type().name();
-            if (Type.find("bool") != std::string::npos) {
-                lua_pushboolean(State, std::any_cast<bool>(arg));
-            }
-            if (Type.find("basic_string") != std::string::npos || Type.find("char") != std::string::npos) {
-                lua_pushstring(State, std::any_cast<std::string>(arg).c_str());
-            }
-            if (Type.find("int") != std::string::npos) {
-                lua_pushinteger(State, std::any_cast<int>(arg));
-            }
-            if (Type.find("float") != std::string::npos) {
-                lua_pushnumber(State, std::any_cast<float>(arg));
-            }
-        }
-    }
-};
-
-class Lua {
-private:
-    std::set<std::pair<std::string, std::string>> _RegisteredEvents;
-    lua_State* luaState { nullptr };
-    fs::file_time_type _LastWrote;
-    std::string _PluginName {};
-    std::string _FileName {};
-    bool _StopThread = false;
-    bool _Console = false;
-
-public:
-    void Init();
-    void RegisterEvent(const std::string& Event, const std::string& FunctionName);
-    std::string GetRegistered(const std::string& Event) const;
-    void UnRegisterEvent(const std::string& Event);
-    void SetLastWrite(fs::file_time_type time);
-    bool IsRegistered(const std::string& Event);
-    void SetPluginName(const std::string& Name);
-    void Execute(const std::string& Command);
-    void SetFileName(const std::string& Name);
-    fs::file_time_type GetLastWrite();
-    std::string GetPluginName() const;
-    std::string GetFileName() const;
-    lua_State* GetState();
-    const lua_State* GetState() const;
-    std::string GetOrigin();
-    std::mutex Lock;
-    void Reload();
-    Lua(const std::string& PluginName, const std::string& FileName, fs::file_time_type LastWrote, bool Console = false);
-    Lua(bool Console = false);
-    ~Lua();
-    void SetStopThread(bool StopThread) { _StopThread = StopThread; }
-    bool GetStopThread() const { return _StopThread; }
-};
-int CallFunction(Lua* lua, const std::string& FuncName, std::unique_ptr<LuaArg> args);
-int TriggerLuaEvent(const std::string& Event, bool local, Lua* Caller, std::unique_ptr<LuaArg> arg, bool Wait);
-extern std::set<std::unique_ptr<Lua>> PluginEngine;

include/LuaAPI.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "TLuaEngine.h"
+#include <tuple>
+
+namespace LuaAPI {
+int PanicHandler(lua_State* State);
+std::string LuaToString(const sol::object Value, size_t Indent = 1, bool QuoteStrings = false);
+void Print(sol::variadic_args);
+namespace MP {
+    extern TLuaEngine* Engine;
+
+    std::string GetOSName();
+    std::tuple<int, int, int> GetServerVersion();
+    std::pair<bool, std::string> TriggerClientEvent(int PlayerID, const std::string& EventName, const sol::object& Data);
+    std::pair<bool, std::string> TriggerClientEventJson(int PlayerID, const std::string& EventName, const sol::table& Data);
+    inline size_t GetPlayerCount() { return Engine->Server().ClientCount(); }
+    std::pair<bool, std::string> DropPlayer(int ID, std::optional<std::string> MaybeReason);
+    std::pair<bool, std::string> SendChatMessage(int ID, const std::string& Message);
+    std::pair<bool, std::string> RemoveVehicle(int PlayerID, int VehicleID);
+    void Set(int ConfigID, sol::object NewValue);
+    bool IsPlayerGuest(int ID);
+    bool IsPlayerConnected(int ID);
+    void Sleep(size_t Ms);
+    void PrintRaw(sol::variadic_args);
+    std::string JsonEncode(const sol::table& object);
+    std::string JsonDiff(const std::string& a, const std::string& b);
+    std::string JsonDiffApply(const std::string& data, const std::string& patch);
+    std::string JsonPrettify(const std::string& json);
+    std::string JsonMinify(const std::string& json);
+    std::string JsonFlatten(const std::string& json);
+    std::string JsonUnflatten(const std::string& json);
+}
+
+namespace FS {
+    std::pair<bool, std::string> CreateDirectory(const std::string& Path);
+    std::pair<bool, std::string> Remove(const std::string& Path);
+    std::pair<bool, std::string> Rename(const std::string& Path, const std::string& NewPath);
+    std::pair<bool, std::string> Copy(const std::string& Path, const std::string& NewPath);
+    std::string GetFilename(const std::string& Path);
+    std::string GetExtension(const std::string& Path);
+    std::string GetParentFolder(const std::string& Path);
+    bool Exists(const std::string& Path);
+    bool IsDirectory(const std::string& Path);
+    bool IsFile(const std::string& Path);
+    std::string ConcatPaths(sol::variadic_args Args);
+}
+}

include/Network.h

@@ -1,19 +0,0 @@
-///
-/// Created by Anonymous275 on 7/31/2020
-///
-#pragma once
-#include "Client.hpp"
-#include <string>
-void TCPServerMain();
-void UpdatePlayers();
-void OnConnect(Client* c);
-void InitClient(Client* c);
-void SyncResources(Client* c);
-[[noreturn]] void UDPServerMain();
-void OnDisconnect(Client* c, bool kicked);
-void UDPSend(Client* c, std::string Data);
-void TCPSend(Client* c, const std::string& Data);
-void SendLarge(Client* c, std::string Data);
-void GParser(Client* c, const std::string& Packet);
-void Respond(Client* c, const std::string& MSG, bool Rel);
-void SendToAll(Client* c, const std::string& Data, bool Self, bool Rel);

include/RWMutex.h

@@ -7,6 +7,7 @@
  */
 
 #include <shared_mutex>
+#include <mutex>
 
 // Use ReadLock(m) and WriteLock(m) to lock it.
 using RWMutex = std::shared_mutex;

include/Security/Enc.h

@@ -1,21 +0,0 @@
-///
-/// Created by Anonymous275 on 7/28/2020
-///
-#pragma once
-#ifdef __linux
-#define EXCEPTION_POINTERS void
-#else
-#include <WS2tcpip.h>
-#endif
-#include "Xor.h"
-#include <string>
-struct RSA {
-    int n = 0;
-    int e = 0;
-    int d = 0;
-};
-std::string RSA_E(const std::string& Data, int e, int n);
-std::string RSA_E(const std::string& Data, RSA* k);
-std::string RSA_D(const std::string& Data, RSA* k);
-int Handle(EXCEPTION_POINTERS* ep, char* Origin);
-RSA* GenKey();

include/Settings.h

@@ -1,24 +0,0 @@
-///
-/// Created by Anonymous275 on 7/28/2020
-///
-#pragma once
-#include <string>
-extern std::string ServerName;
-extern std::string ServerDesc;
-extern std::string StatReport;
-extern std::string FileSizes;
-extern std::string Resource;
-extern std::string FileList;
-extern std::string CustomIP;
-extern std::string MapName;
-extern uint64_t MaxModSize;
-extern std::string Key;
-std::string GetSVer();
-std::string GetCVer();
-extern int MaxPlayers;
-extern int ModsLoaded;
-extern bool Private;
-extern int MaxCars;
-extern bool Debug;
-extern int Port;
-extern int PPS;

include/SignalHandling.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void SetupSignalHandlers();

include/Startup.h

@@ -1,12 +0,0 @@
-///
-/// Created by Anonymous275 on 7/28/2020
-///
-#pragma once
-void InitServer(int argc, char* argv[]);
-void ConsoleInit();
-void InitConfig();
-void InitLua();
-void InitRes();
-void HBInit();
-void StatInit();
-void NetMain();

include/TConfig.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "Common.h"
+
+#include <atomic>
+#include <filesystem>
+
+#define TOML11_PRESERVE_COMMENTS_BY_DEFAULT
+#include <toml.hpp> // header-only version of TOML++
+
+namespace fs = std::filesystem;
+
+class TConfig {
+public:
+    explicit TConfig(const std::string& ConfigFileName);
+
+    [[nodiscard]] bool Failed() const { return mFailed; }
+
+    void FlushToFile();
+
+private:
+    void CreateConfigFile();
+    void ParseFromFile(std::string_view name);
+    void PrintDebug();
+    void TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, const std::string_view& Env, std::string& OutValue);
+    void TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, const std::string_view& Env, bool& OutValue);
+    void TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, const std::string_view& Env, int& OutValue);
+
+    void ParseOldFormat();
+    std::string TagsAsPrettyArray() const;
+    bool IsDefault();
+    bool mFailed { false };
+    std::string mConfigFileName;
+};

include/TConsole.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "Cryptography.h"
+#include "commandline.h"
+#include <atomic>
+#include <fstream>
+#include <functional>
+#include <mutex>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+
+class TLuaEngine;
+
+class TConsole {
+public:
+    TConsole();
+
+    // Initializes the commandline app to take over I/O
+    void InitializeCommandline();
+
+    void Write(const std::string& str);
+    void WriteRaw(const std::string& str);
+    void InitializeLuaConsole(TLuaEngine& Engine);
+    void BackupOldLog();
+    void StartLoggingToFile();
+    Commandline& Internal() { return *mCommandline; }
+
+private:
+    void RunAsCommand(const std::string& cmd, bool IgnoreNotACommand = false);
+    void ChangeToLuaConsole(const std::string& LuaStateId);
+    void ChangeToRegularConsole();
+    void HandleLuaInternalCommand(const std::string& cmd);
+
+    void Command_Lua(const std::string& cmd, const std::vector<std::string>& args);
+    void Command_Help(const std::string& cmd, const std::vector<std::string>& args);
+    void Command_Kick(const std::string& cmd, const std::vector<std::string>& args);
+    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);
+    bool EnsureArgsCount(const std::vector<std::string>& args, size_t min, size_t max);
+
+    static std::tuple<std::string, std::vector<std::string>> ParseCommand(const std::string& cmd);
+    static std::string ConcatArgs(const std::vector<std::string>& args, char space = ' ');
+
+    std::unordered_map<std::string, std::function<void(const std::string&, const std::vector<std::string>&)>> mCommandMap = {
+        { "lua", [this](const auto& a, const auto& b) { Command_Lua(a, b); } },
+        { "help", [this](const auto& a, const auto& b) { Command_Help(a, b); } },
+        { "kick", [this](const auto& a, const auto& b) { Command_Kick(a, b); } },
+        { "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
+    };
+
+    std::unique_ptr<Commandline> mCommandline { nullptr };
+    std::vector<std::string> mCachedLuaHistory;
+    std::vector<std::string> mCachedRegularHistory;
+    TLuaEngine* mLuaEngine { nullptr };
+    bool mIsLuaConsole { false };
+    bool mFirstTime { true };
+    std::string mStateId;
+    const std::string mDefaultStateId = "BEAMMP_SERVER_CONSOLE";
+    std::ofstream mLogFileStream;
+    std::mutex mLogFileStreamMtx;
+};

include/THeartbeatThread.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "Common.h"
+#include "IThreaded.h"
+#include "TResourceManager.h"
+#include "TServer.h"
+
+class THeartbeatThread : public IThreaded {
+public:
+    THeartbeatThread(TResourceManager& ResourceManager, TServer& Server);
+    //~THeartbeatThread();
+    void operator()() override;
+
+private:
+    std::string GenerateCall();
+    std::string GetPlayers();
+
+    TResourceManager& mResourceManager;
+    TServer& mServer;
+};

include/TLuaEngine.h

@@ -0,0 +1,280 @@
+#pragma once
+
+#include "TNetwork.h"
+#include "TServer.h"
+#include <any>
+#include <condition_variable>
+#include <filesystem>
+#include <initializer_list>
+#include <list>
+#include <lua.hpp>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <random>
+#include <set>
+#include <toml.hpp>
+#include <unordered_map>
+#include <vector>
+
+#define SOL_ALL_SAFETIES_ON 1
+#include <sol/sol.hpp>
+
+using TLuaStateId = std::string;
+namespace fs = std::filesystem;
+/**
+ * std::variant means, that TLuaArgTypes may be one of the Types listed as template args
+ */
+using TLuaArgTypes = std::variant<std::string, int, sol::variadic_args, bool, std::unordered_map<std::string, std::string>>;
+static constexpr size_t TLuaArgTypes_String = 0;
+static constexpr size_t TLuaArgTypes_Int = 1;
+static constexpr size_t TLuaArgTypes_VariadicArgs = 2;
+static constexpr size_t TLuaArgTypes_Bool = 3;
+static constexpr size_t TLuaArgTypes_StringStringMap = 4;
+
+class TLuaPlugin;
+
+struct TLuaResult {
+    bool Ready;
+    bool Error;
+    std::string ErrorMessage;
+    sol::object Result { sol::lua_nil };
+    TLuaStateId StateId;
+    std::string Function;
+    std::shared_ptr<std::mutex> ReadyMutex {
+        std::make_shared<std::mutex>()
+    };
+    std::shared_ptr<std::condition_variable> ReadyCondition {
+        std::make_shared<std::condition_variable>()
+    };
+
+    void MarkAsReady();
+    void WaitUntilReady();
+};
+
+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 {
+    TLuaChunk(std::shared_ptr<std::string> Content,
+        std::string FileName,
+        std::string PluginPath);
+    std::shared_ptr<std::string> Content;
+    std::string FileName;
+    std::string PluginPath;
+};
+
+class TLuaEngine : public std::enable_shared_from_this<TLuaEngine>, IThreaded {
+public:
+    enum CallStrategy : int {
+        BestEffort,
+        Precise,
+    };
+
+    struct QueuedFunction {
+        std::string FunctionName;
+        std::shared_ptr<TLuaResult> Result;
+        std::vector<TLuaArgTypes> Args;
+        std::string EventName; // optional, may be empty
+    };
+
+    TLuaEngine();
+    virtual ~TLuaEngine() noexcept {
+        beammp_debug("Lua Engine terminated");
+    }
+
+    void operator()() override;
+
+    TNetwork& Network() { return *mNetwork; }
+    TServer& Server() { return *mServer; }
+
+    void SetNetwork(TNetwork* Network) { mNetwork = Network; }
+    void SetServer(TServer* Server) { mServer = Server; }
+
+    size_t GetResultsToCheckSize() {
+        std::unique_lock Lock(mResultsToCheckMutex);
+        return mResultsToCheck.size();
+    }
+
+    size_t GetLuaStateCount() {
+        std::unique_lock Lock(mLuaStatesMutex);
+        return mLuaStates.size();
+    }
+    std::vector<std::string> GetLuaStateNames() {
+        std::vector<std::string> names {};
+        for (auto const& [stateId, _] : mLuaStates) {
+            names.push_back(stateId);
+        }
+        return names;
+    }
+    size_t GetTimedEventsCount() {
+        std::unique_lock Lock(mTimedEventsMutex);
+        return mTimedEvents.size();
+    }
+    size_t GetRegisteredEventHandlerCount() {
+        std::unique_lock Lock(mLuaEventsMutex);
+        size_t LuaEventsCount = 0;
+        for (const auto& State : mLuaEvents) {
+            for (const auto& Events : State.second) {
+                LuaEventsCount += Events.second.size();
+            }
+        }
+        return LuaEventsCount - GetLuaStateCount();
+    }
+
+    static void WaitForAll(std::vector<std::shared_ptr<TLuaResult>>& Results,
+        const std::optional<std::chrono::high_resolution_clock::duration>& Max = std::nullopt);
+    void ReportErrors(const std::vector<std::shared_ptr<TLuaResult>>& Results);
+    bool HasState(TLuaStateId StateId);
+    [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueScript(TLuaStateId StateID, const TLuaChunk& Script);
+    [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueFunctionCall(TLuaStateId StateID, const std::string& FunctionName, const std::vector<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);
+    /**
+     *
+     * @tparam ArgsT Template Arguments for the event (Metadata) todo: figure out what this means
+     * @param EventName Name of the event
+     * @param IgnoreId
+     * @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);
+        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) }... };
+
+        for (const auto& Event : mLuaEvents.at(EventName)) {
+            for (const auto& Function : Event.second) {
+                if (Event.first != IgnoreId) {
+                    Results.push_back(EnqueueFunctionCall(Event.first, Function, Arguments));
+                }
+            }
+        }
+        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);
+    sol::state_view GetStateForPlugin(const fs::path& PluginPath);
+    TLuaStateId GetStateIDForPlugin(const fs::path& PluginPath);
+    void AddResultToCheck(const std::shared_ptr<TLuaResult>& Result);
+
+    static constexpr const char* BeamMPFnNotFoundError = "BEAMMP_FN_NOT_FOUND";
+
+    std::vector<std::string> GetStateGlobalKeysForState(TLuaStateId StateId);
+    std::vector<std::string> GetStateTableKeysForState(TLuaStateId StateId, std::vector<std::string> keys);
+
+    // Debugging functions (slow)
+    std::unordered_map<std::string /*event name */, std::vector<std::string> /* handlers */> Debug_GetEventsForState(TLuaStateId StateId);
+    std::queue<std::pair<TLuaChunk, std::shared_ptr<TLuaResult>>> Debug_GetStateExecuteQueueForState(TLuaStateId StateId);
+    std::vector<QueuedFunction> Debug_GetStateFunctionQueueForState(TLuaStateId StateId);
+    std::vector<TLuaResult> Debug_GetResultsToCheckForState(TLuaStateId StateId);
+
+private:
+    void CollectAndInitPlugins();
+    void InitializePlugin(const fs::path& Folder, const TLuaPluginConfig& Config);
+    void FindAndParseConfig(const fs::path& Folder, TLuaPluginConfig& Config);
+    size_t CalculateMemoryUsage();
+
+    class StateThreadData : IThreaded {
+    public:
+        StateThreadData(const std::string& Name, TLuaStateId StateId, TLuaEngine& Engine);
+        StateThreadData(const StateThreadData&) = delete;
+        virtual ~StateThreadData() noexcept { beammp_debug("\"" + mStateId + "\" destroyed"); }
+        [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueScript(const TLuaChunk& Script);
+        [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueFunctionCall(const std::string& FunctionName, const std::vector<TLuaArgTypes>& Args);
+        [[nodiscard]] std::shared_ptr<TLuaResult> EnqueueFunctionCallFromCustomEvent(const std::string& FunctionName, const std::vector<TLuaArgTypes>& Args, const std::string& EventName, CallStrategy Strategy);
+        void RegisterEvent(const std::string& EventName, const std::string& FunctionName);
+        void AddPath(const fs::path& Path); // to be added to path and cpath
+        void operator()() override;
+        sol::state_view State() { return sol::state_view(mState); }
+
+        std::vector<std::string> GetStateGlobalKeys();
+        std::vector<std::string> GetStateTableKeys(const std::vector<std::string>& keys);
+
+        // Debug functions, slow
+        std::queue<std::pair<TLuaChunk, std::shared_ptr<TLuaResult>>> Debug_GetStateExecuteQueue();
+        std::vector<TLuaEngine::QueuedFunction> Debug_GetStateFunctionQueue();
+
+    private:
+        sol::table Lua_TriggerGlobalEvent(const std::string& EventName, sol::variadic_args EventArgs);
+        sol::table Lua_TriggerLocalEvent(const std::string& EventName, sol::variadic_args EventArgs);
+        sol::table Lua_GetPlayerIdentifiers(int ID);
+        sol::table Lua_GetPlayers();
+        std::string Lua_GetPlayerName(int ID);
+        sol::table Lua_GetPlayerVehicles(int ID);
+        std::pair<sol::table, std::string> Lua_GetPositionRaw(int PID, int VID);
+        sol::table Lua_HttpCreateConnection(const std::string& host, uint16_t port);
+        sol::table Lua_JsonDecode(const std::string& str);
+        int Lua_GetPlayerIDByName(const std::string& Name);
+        sol::table Lua_FS_ListFiles(const std::string& Path);
+        sol::table Lua_FS_ListDirectories(const std::string& Path);
+
+        std::string mName;
+        TLuaStateId mStateId;
+        lua_State* mState;
+        std::thread mThread;
+        std::queue<std::pair<TLuaChunk, std::shared_ptr<TLuaResult>>> mStateExecuteQueue;
+        std::recursive_mutex mStateExecuteQueueMutex;
+        std::vector<QueuedFunction> mStateFunctionQueue;
+        std::mutex mStateFunctionQueueMutex;
+        std::condition_variable mStateFunctionQueueCond;
+        TLuaEngine* mEngine;
+        sol::state_view mStateView { mState };
+        std::queue<fs::path> mPaths;
+        std::recursive_mutex mPathsMutex;
+        std::mt19937 mMersenneTwister;
+        std::uniform_real_distribution<double> mUniformRealDistribution01;
+    };
+
+    struct TimedEvent {
+        std::chrono::high_resolution_clock::duration Duration {};
+        std::chrono::high_resolution_clock::time_point LastCompletion {};
+        std::string EventName;
+        TLuaStateId StateId;
+        CallStrategy Strategy;
+        bool Expired();
+        void Reset();
+    };
+
+    TNetwork* mNetwork;
+    TServer* mServer;
+    const fs::path mResourceServerPath;
+    std::vector<std::shared_ptr<TLuaPlugin>> mLuaPlugins;
+    std::unordered_map<TLuaStateId, std::unique_ptr<StateThreadData>> mLuaStates;
+    std::recursive_mutex mLuaStatesMutex;
+    std::unordered_map<std::string /* event name */, std::unordered_map<TLuaStateId, std::set<std::string>>> mLuaEvents;
+    std::recursive_mutex mLuaEventsMutex;
+    std::vector<TimedEvent> mTimedEvents;
+    std::recursive_mutex mTimedEventsMutex;
+    std::list<std::shared_ptr<TLuaResult>> mResultsToCheck;
+    std::mutex mResultsToCheckMutex;
+    std::condition_variable mResultsToCheckCond;
+};
+
+// std::any TriggerLuaEvent(const std::string& Event, bool local, TLuaPlugin* Caller, std::shared_ptr<TLuaArg> arg, bool Wait);

include/TLuaPlugin.h

@@ -0,0 +1,19 @@
+#include "TLuaEngine.h"
+
+class TLuaPlugin {
+public:
+    TLuaPlugin(TLuaEngine& Engine, const TLuaPluginConfig& Config, const fs::path& MainFolder);
+    TLuaPlugin(const TLuaPlugin&) = delete;
+    TLuaPlugin& operator=(const TLuaPlugin&) = delete;
+    ~TLuaPlugin() noexcept = default;
+
+    const TLuaPluginConfig& GetConfig() const { return mConfig; }
+    fs::path GetFolder() const { return mFolder; }
+
+private:
+    TLuaPluginConfig mConfig;
+    TLuaEngine& mEngine;
+    fs::path mFolder;
+    std::string mPluginName;
+    std::unordered_map<std::string, std::shared_ptr<std::string>> mFileContents;
+};

include/TNetwork.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "BoostAliases.h"
+#include "Compat.h"
+#include "TResourceManager.h"
+#include "TServer.h"
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ip/udp.hpp>
+
+struct TConnection;
+
+class TNetwork {
+public:
+    TNetwork(TServer& Server, TPPSMonitor& PPSMonitor, TResourceManager& ResourceManager);
+
+    [[nodiscard]] bool TCPSend(TClient& c, const std::vector<uint8_t>& Data, bool IsSync = false);
+    [[nodiscard]] bool SendLarge(TClient& c, std::vector<uint8_t> Data, bool isSync = false);
+    [[nodiscard]] bool Respond(TClient& c, const std::vector<uint8_t>& MSG, bool Rel, bool isSync = false);
+    std::shared_ptr<TClient> CreateClient(ip::tcp::socket&& TCPSock);
+    std::vector<uint8_t> TCPRcv(TClient& c);
+    void ClientKick(TClient& c, const std::string& R);
+    [[nodiscard]] bool SyncClient(const std::weak_ptr<TClient>& c);
+    void Identify(TConnection&& client);
+    std::shared_ptr<TClient> Authentication(TConnection&& ClientConnection);
+    void SyncResources(TClient& c);
+    [[nodiscard]] bool UDPSend(TClient& Client, std::vector<uint8_t> Data);
+    void SendToAll(TClient* c, const std::vector<uint8_t>& Data, bool Self, bool Rel);
+    void UpdatePlayer(TClient& Client);
+
+private:
+    void UDPServerMain();
+    void TCPServerMain();
+
+    TServer& mServer;
+    TPPSMonitor& mPPSMonitor;
+    ip::udp::socket mUDPSock;
+    TResourceManager& mResourceManager;
+    std::thread mUDPThread;
+    std::thread mTCPThread;
+
+    std::vector<uint8_t> UDPRcvFromClient(ip::udp::endpoint& ClientEndpoint);
+    void HandleDownload(TConnection&& TCPSock);
+    void OnConnect(const std::weak_ptr<TClient>& c);
+    void TCPClient(const std::weak_ptr<TClient>& c);
+    void Looper(const std::weak_ptr<TClient>& c);
+    int OpenID();
+    void OnDisconnect(const std::weak_ptr<TClient>& ClientPtr);
+    void Parse(TClient& c, const std::vector<uint8_t>& Packet);
+    void SendFile(TClient& c, const std::string& Name);
+    static bool TCPSendRaw(TClient& C, ip::tcp::socket& socket, const uint8_t* Data, size_t Size);
+    static void SplitLoad(TClient& c, size_t Sent, size_t Size, bool D, const std::string& Name);
+    static const uint8_t* SendSplit(TClient& c, ip::tcp::socket& Socket, const uint8_t* DataPtr, size_t Size);
+};
+
+std::string HashPassword(const std::string& str);
+std::vector<uint8_t> StringToVector(const std::string& Str);

include/TPPSMonitor.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Common.h"
+#include "TServer.h"
+#include <optional>
+
+class TNetwork;
+
+class TPPSMonitor : public IThreaded {
+public:
+    explicit TPPSMonitor(TServer& Server);
+    virtual ~TPPSMonitor() {}
+
+    void operator()() override;
+
+    void SetInternalPPS(int NewPPS) { mInternalPPS = NewPPS; }
+    void IncrementInternalPPS() { ++mInternalPPS; }
+    [[nodiscard]] int InternalPPS() const { return mInternalPPS; }
+    void SetNetwork(TNetwork& Server) { mNetwork = std::ref(Server); }
+
+private:
+    TNetwork& Network() { return mNetwork->get(); }
+
+    TServer& mServer;
+    std::optional<std::reference_wrapper<TNetwork>> mNetwork { std::nullopt };
+    int mInternalPPS { 0 };
+};

include/TPluginMonitor.h

@@ -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;
+};

include/TResourceManager.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Common.h"
+
+class TResourceManager {
+public:
+    TResourceManager();
+
+    [[nodiscard]] size_t MaxModSize() const { return mMaxModSize; }
+    [[nodiscard]] std::string FileList() const { return mFileList; }
+    [[nodiscard]] std::string TrimmedList() const { return mTrimmedList; }
+    [[nodiscard]] std::string FileSizes() const { return mFileSizes; }
+    [[nodiscard]] int ModsLoaded() const { return mModsLoaded; }
+
+private:
+    size_t mMaxModSize = 0;
+    std::string mFileSizes;
+    std::string mFileList;
+    std::string mTrimmedList;
+    int mModsLoaded = 0;
+};

include/TScopedTimer.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <chrono>
+#include <functional>
+#include <string>
+
+class TScopedTimer {
+public:
+    TScopedTimer();
+    TScopedTimer(const std::string& Name);
+    TScopedTimer(std::function<void(size_t)> OnDestroy);
+    ~TScopedTimer();
+    auto GetElapsedTime() const {
+        auto EndTime = std::chrono::high_resolution_clock::now();
+        auto Delta = EndTime - mStartTime;
+        size_t TimeDelta = Delta / std::chrono::milliseconds(1);
+        return TimeDelta;
+    }
+
+    std::function<void(size_t /* time_ms */)> OnDestroy { nullptr };
+
+private:
+    std::chrono::high_resolution_clock::time_point mStartTime;
+    std::string Name;
+};

include/TServer.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "IThreaded.h"
+#include "RWMutex.h"
+#include "TScopedTimer.h"
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <unordered_set>
+
+#include "BoostAliases.h"
+
+class TClient;
+class TNetwork;
+class TPPSMonitor;
+
+class TServer final {
+public:
+    using TClientSet = std::unordered_set<std::shared_ptr<TClient>>;
+
+    TServer(const std::vector<std::string_view>& Arguments);
+
+    void InsertClient(const std::shared_ptr<TClient>& Ptr);
+    void RemoveClient(const std::weak_ptr<TClient>&);
+    // in Fn, return true to continue, return false to break
+    void ForEachClient(const std::function<bool(std::weak_ptr<TClient>)>& Fn);
+    size_t ClientCount() const;
+
+    static void GlobalParser(const std::weak_ptr<TClient>& Client, std::vector<uint8_t>&& Packet, TPPSMonitor& PPSMonitor, TNetwork& Network);
+    static void HandleEvent(TClient& c, const std::string& Data);
+    RWMutex& GetClientMutex() const { return mClientsMutex; }
+
+    const TScopedTimer UptimeTimer;
+
+    // asio io context
+    io_context& IoCtx() { return mIoCtx; }
+
+private:
+    io_context mIoCtx {};
+    TClientSet mClients;
+    mutable RWMutex mClientsMutex;
+    static void ParseVehicle(TClient& c, const std::string& Pckt, TNetwork& Network);
+    static bool ShouldSpawn(TClient& c, const std::string& CarJson, int ID);
+    static bool IsUnicycle(TClient& c, const std::string& CarJson);
+    static void Apply(TClient& c, int VID, const std::string& pckt);
+    static void HandlePosition(TClient& c, const std::string& Packet);
+};
+
+struct BufferView {
+    uint8_t* Data { nullptr };
+    size_t Size { 0 };
+    const uint8_t* data() const { return Data; }
+    uint8_t* data() { return Data; }
+    size_t size() const { return Size; }
+};

include/UnixCompat.h

@@ -1,38 +0,0 @@
-// Author: lionkor
-
-#pragma once
-
-// This header defines unix equivalents of common win32 functions.
-
-#ifndef WIN32
-
-#include "CustomAssert.h"
-#include <cstring>
-#include <sys/socket.h>
-#include <unistd.h>
-
-// ZeroMemory is just a {0} or a memset(addr, 0, len), and it's a macro on MSVC
-inline void ZeroMemory(void* dst, size_t len) {
-    Assert(std::memset(dst, 0, len) != nullptr);
-}
-// provides unix equivalent of closesocket call in win32
-inline void CloseSocketProper(int socket) {
-    shutdown(socket, SHUT_RDWR);
-    close(socket);
-}
-
-#ifndef __try
-#define __try
-#endif
-
-#ifndef __except
-#define __except (x) /**/
-#endif
-
-#else // win32
-
-inline void CloseSocketProper(uint64_t socket) {
-    shutdown(socket, SD_BOTH);
-    closesocket(socket);
-}
-#endif // WIN32

include/VehicleData.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <string>
+
+class TVehicleData final {
+public:
+    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,
+    // and end up making no sense, so let's just leave the copy ctor.
+    // TVehicleData(const TVehicleData&) = delete;
+
+    [[nodiscard]] bool IsInvalid() const { return mID == -1; }
+    [[nodiscard]] int ID() const { return mID; }
+
+    [[nodiscard]] std::string Data() const { return mData; }
+    void SetData(const std::string& Data) { mData = Data; }
+
+    bool operator==(const TVehicleData& v) const { return mID == v.mID; }
+
+private:
+    int mID { -1 };
+    std::string mData;
+};
+
+// TODO: unused now, remove?
+namespace std {
+template <>
+struct hash<TVehicleData> {
+    std::size_t operator()(const TVehicleData& s) const noexcept {
+        return s.ID();
+    }
+};
+}

scripts/debian-11/1-install-deps.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -ex
+
+apt-get update -y
+
+apt-get install -y liblua5.3-0 liblua5.3-dev curl zip unzip tar cmake make git g++

scripts/debian-11/1.5-git-safe.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -ex
+
+git config --global --add safe.directory $(pwd)
+git config --global --add safe.directory $(pwd)/vcpkg
+git config --global --add safe.directory $(pwd)/deps/commandline

scripts/debian-11/2-configure.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -ex
+
+cmake . -B bin $1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_FLAGS="-O3 -g -Wl,-z,norelro -Wl,--hash-style=gnu -Wl,--build-id=none -Wl,-z,noseparate-code -ffunction-sections -fdata-sections -Wl,--gc-sections" -DBeamMP-Server_ENABLE_LTO=ON

scripts/debian-11/3-build-tests.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -ex
+
+cmake --build bin --parallel -t BeamMP-Server-tests

scripts/debian-11/3-build.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -ex
+
+cmake --build bin --parallel -t BeamMP-Server
+
+objcopy --only-keep-debug bin/BeamMP-Server bin/BeamMP-Server.debug
+objcopy --add-gnu-debuglink bin/BeamMP-Server bin/BeamMP-Server.debug
+
+strip -s bin/BeamMP-Server

scripts/debian-11/4-install-runtime-deps.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+set -ex
+
+apt-get update -y
+
+apt-get install -y liblua5.3-0 curl
+

scripts/ubuntu-22.04/1-install-deps.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -ex
+
+apt-get update -y
+
+apt-get install -y liblua5.3-0 liblua5.3-dev curl zip unzip tar cmake make git g++

scripts/ubuntu-22.04/1.5-git-safe.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -ex
+
+git config --global --add safe.directory $(pwd)
+git config --global --add safe.directory $(pwd)/vcpkg
+git config --global --add safe.directory $(pwd)/deps/commandline

scripts/ubuntu-22.04/2-configure.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -ex
+
+cmake . -B bin $1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_FLAGS="-O3 -g -Wl,-z,norelro -Wl,--hash-style=gnu -Wl,--build-id=none -Wl,-z,noseparate-code -ffunction-sections -fdata-sections -Wl,--gc-sections" -DBeamMP-Server_ENABLE_LTO=ON

scripts/ubuntu-22.04/3-build-tests.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -ex
+
+cmake --build bin --parallel -t BeamMP-Server-tests

scripts/ubuntu-22.04/3-build.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -ex
+
+cmake --build bin --parallel -t BeamMP-Server
+
+objcopy --only-keep-debug bin/BeamMP-Server bin/BeamMP-Server.debug
+objcopy --add-gnu-debuglink bin/BeamMP-Server bin/BeamMP-Server.debug
+
+strip -s bin/BeamMP-Server

scripts/ubuntu-22.04/4-install-runtime-deps.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+set -ex
+
+apt-get update -y
+
+apt-get install -y liblua5.3-0 curl
+

scripts/windows/1-configure.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -ex
+
+cmake . -B bin $1 -DCMAKE_BUILD_TYPE=Release -DBeamMP-Server_ENABLE_LTO=ON -DVCPKG_TARGET_TRIPLET=x64-windows-static

scripts/windows/2-build-tests.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -ex
+
+cmake --build bin --parallel -t BeamMP-Server-tests

scripts/windows/2-build.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -ex
+
+cmake --build bin --parallel -t BeamMP-Server --config Release

src/ArgsParser.cpp

@@ -0,0 +1,170 @@
+#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) {
+        if (Arg.size() > 2 && Arg.substr(0, 2) == "--") {
+            // long arg
+            if (Arg.find("=") != Arg.npos) {
+                ConsumeLongAssignment(std::string(Arg));
+            } else {
+                ConsumeLongFlag(std::string(Arg));
+            }
+        } else {
+            beammp_errorf("Error parsing commandline arguments: Supplied argument '{}' is not a valid argument and was ignored.", Arg);
+        }
+    }
+}
+
+bool ArgsParser::Verify() {
+    bool Ok = true;
+    for (const auto& RegisteredArg : mRegisteredArguments) {
+        if (RegisteredArg.Flags & Flags::REQUIRED && !FoundArgument(RegisteredArg.Names)) {
+            beammp_errorf("Error in commandline arguments: Argument '{}' is required but wasn't found.", RegisteredArg.Names.at(0));
+            Ok = false;
+            continue;
+        } else if (FoundArgument(RegisteredArg.Names)) {
+            if (RegisteredArg.Flags & Flags::HAS_VALUE) {
+                if (!GetValueOfArgument(RegisteredArg.Names).has_value()) {
+                    beammp_error("Error in commandline arguments: Argument '" + std::string(RegisteredArg.Names.at(0)) + "' expects a value, but no value was given.");
+                    Ok = false;
+                }
+            } else if (GetValueOfArgument(RegisteredArg.Names).has_value()) {
+                beammp_error("Error in commandline arguments: Argument '" + std::string(RegisteredArg.Names.at(0)) + "' does not expect a value, but one was given.");
+                Ok = false;
+            }
+        }
+    }
+    return Ok;
+}
+
+void ArgsParser::RegisterArgument(std::vector<std::string>&& ArgumentNames, int Flags) {
+    mRegisteredArguments.push_back({ ArgumentNames, Flags });
+}
+
+bool ArgsParser::FoundArgument(const std::vector<std::string>& Names) {
+    // if any of the found args match any of the names
+    return std::any_of(mFoundArgs.begin(), mFoundArgs.end(),
+        [&Names](const Argument& Arg) -> bool {
+            // if any of the names match this arg's name
+            return std::any_of(Names.begin(), Names.end(), [&Arg](const std::string& Name) -> bool {
+                return Arg.Name == Name;
+            });
+        });
+}
+
+std::optional<std::string> ArgsParser::GetValueOfArgument(const std::vector<std::string>& Names) {
+    // finds an entry which has a name that is any of the names in 'Names'
+    auto Found = std::find_if(mFoundArgs.begin(), mFoundArgs.end(), [&Names](const Argument& Arg) -> bool {
+        return std::any_of(Names.begin(), Names.end(), [&Arg](const std::string_view& Name) -> bool {
+            return Arg.Name == Name;
+        });
+    });
+    if (Found != mFoundArgs.end()) {
+        // found
+        return Found->Value;
+    } else {
+        return std::nullopt;
+    }
+}
+
+bool ArgsParser::IsRegistered(const std::string& Name) {
+    return std::any_of(mRegisteredArguments.begin(), mRegisteredArguments.end(), [&Name](const RegisteredArgument& Arg) {
+        auto Iter = std::find(Arg.Names.begin(), Arg.Names.end(), Name);
+        return Iter != Arg.Names.end();
+    });
+}
+
+void ArgsParser::ConsumeLongAssignment(const std::string& Arg) {
+    auto Value = Arg.substr(Arg.rfind("=") + 1);
+    auto Name = Arg.substr(2, Arg.rfind("=") - 2);
+    if (!IsRegistered(Name)) {
+        beammp_warn("Argument '" + Name + "' was supplied but isn't a known argument, so it is likely being ignored.");
+    }
+    mFoundArgs.push_back({ Name, Value });
+}
+
+void ArgsParser::ConsumeLongFlag(const std::string& Arg) {
+    auto Name = Arg.substr(2, Arg.rfind("=") - 2);
+    mFoundArgs.push_back({ Name, std::nullopt });
+    if (!IsRegistered(Name)) {
+        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());
+        }
+    }
+}

src/Client.cpp

@@ -0,0 +1,153 @@
+#include "Client.h"
+
+#include "CustomAssert.h"
+#include "TServer.h"
+#include <memory>
+#include <optional>
+
+void TClient::DeleteCar(int Ident) {
+    // TODO: Send delete packets
+    std::unique_lock lock(mVehicleDataMutex);
+    auto iter = std::find_if(mVehicleData.begin(), mVehicleData.end(), [&](auto& elem) {
+        return Ident == elem.ID();
+    });
+    if (iter != mVehicleData.end()) {
+        mVehicleData.erase(iter);
+    } else {
+        beammp_debug("tried to erase a vehicle that doesn't exist (not an error)");
+    }
+}
+
+void TClient::ClearCars() {
+    std::unique_lock lock(mVehicleDataMutex);
+    mVehicleData.clear();
+}
+
+int TClient::GetOpenCarID() const {
+    int OpenID = 0;
+    bool found;
+    std::unique_lock lock(mVehicleDataMutex);
+    do {
+        found = true;
+        for (auto& v : mVehicleData) {
+            if (v.ID() == OpenID) {
+                OpenID++;
+                found = false;
+            }
+        }
+    } while (!found);
+    return OpenID;
+}
+
+void TClient::AddNewCar(int Ident, const std::string& Data) {
+    std::unique_lock lock(mVehicleDataMutex);
+    mVehicleData.emplace_back(Ident, Data);
+}
+
+TClient::TVehicleDataLockPair TClient::GetAllCars() {
+    return { &mVehicleData, std::unique_lock(mVehicleDataMutex) };
+}
+
+std::string TClient::GetCarPositionRaw(int Ident) {
+    std::unique_lock lock(mVehiclePositionMutex);
+    try {
+        return mVehiclePosition.at(size_t(Ident));
+    } catch (const std::out_of_range& oor) {
+        return "";
+    }
+    return "";
+}
+
+void TClient::Disconnect(std::string_view Reason) {
+    beammp_debugf("Disconnecting client {} for reason: {}", GetID(), Reason);
+    boost::system::error_code ec;
+    mSocket.shutdown(socket_base::shutdown_both, ec);
+    if (ec) {
+        beammp_debugf("Failed to shutdown client socket: {}", ec.message());
+    }
+    mSocket.close(ec);
+    if (ec) {
+        beammp_debugf("Failed to close client socket: {}", ec.message());
+    }
+}
+
+void TClient::SetCarPosition(int Ident, const std::string& Data) {
+    std::unique_lock lock(mVehiclePositionMutex);
+    mVehiclePosition[size_t(Ident)] = Data;
+}
+
+std::string TClient::GetCarData(int Ident) {
+    { // lock
+        std::unique_lock lock(mVehicleDataMutex);
+        for (auto& v : mVehicleData) {
+            if (v.ID() == Ident) {
+                return v.Data();
+            }
+        }
+    } // unlock
+    DeleteCar(Ident);
+    return "";
+}
+
+void TClient::SetCarData(int Ident, const std::string& Data) {
+    { // lock
+        std::unique_lock lock(mVehicleDataMutex);
+        for (auto& v : mVehicleData) {
+            if (v.ID() == Ident) {
+                v.SetData(Data);
+                return;
+            }
+        }
+    } // unlock
+    DeleteCar(Ident);
+}
+
+int TClient::GetCarCount() const {
+    return int(mVehicleData.size());
+}
+
+TServer& TClient::Server() const {
+    return mServer;
+}
+
+void TClient::EnqueuePacket(const std::vector<uint8_t>& Packet) {
+    std::unique_lock Lock(mMissedPacketsMutex);
+    mPacketsSync.push(Packet);
+}
+
+TClient::TClient(TServer& Server, ip::tcp::socket&& Socket)
+    : mServer(Server)
+    , mSocket(std::move(Socket))
+    , mDownSocket(ip::tcp::socket(Server.IoCtx()))
+    , mLastPingTime(std::chrono::high_resolution_clock::now()) {
+}
+
+TClient::~TClient() {
+    beammp_debugf("client destroyed: {} ('{}')", this->GetID(), this->GetName());
+}
+
+void TClient::UpdatePingTime() {
+    mLastPingTime = std::chrono::high_resolution_clock::now();
+}
+int TClient::SecondsSinceLastPing() {
+    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(
+        std::chrono::high_resolution_clock::now() - mLastPingTime)
+                       .count();
+    return int(seconds);
+}
+
+std::optional<std::weak_ptr<TClient>> GetClient(TServer& Server, int ID) {
+    std::optional<std::weak_ptr<TClient>> MaybeClient { std::nullopt };
+    Server.ForEachClient([&](std::weak_ptr<TClient> CPtr) -> bool {
+        ReadLock Lock(Server.GetClientMutex());
+        if (!CPtr.expired()) {
+            auto C = CPtr.lock();
+            if (C->GetID() == ID) {
+                MaybeClient = CPtr;
+                return false;
+            }
+        }
+        return true;
+    });
+    return MaybeClient;
+}

src/Common.cpp

@@ -0,0 +1,361 @@
+#include "Common.h"
+
+#include "TConsole.h"
+#include <array>
+#include <charconv>
+#include <iostream>
+#include <map>
+#include <regex>
+#include <sstream>
+#include <thread>
+
+#include "Compat.h"
+#include "CustomAssert.h"
+#include "Http.h"
+
+Application::TSettings Application::Settings = {};
+
+void Application::RegisterShutdownHandler(const TShutdownHandler& Handler) {
+    std::unique_lock Lock(mShutdownHandlersMutex);
+    if (Handler) {
+        mShutdownHandlers.push_front(Handler);
+    }
+}
+
+void Application::GracefullyShutdown() {
+    SetShutdown(true);
+    static bool AlreadyShuttingDown = false;
+    static uint8_t ShutdownAttempts = 0;
+    if (AlreadyShuttingDown) {
+        ++ShutdownAttempts;
+        // hard shutdown at 2 additional tries
+        if (ShutdownAttempts == 2) {
+            beammp_info("hard shutdown forced by multiple shutdown requests");
+            std::exit(0);
+        }
+        beammp_info("already shutting down!");
+        return;
+    } else {
+        AlreadyShuttingDown = true;
+    }
+    beammp_trace("waiting for lock release");
+    std::unique_lock Lock(mShutdownHandlersMutex);
+    beammp_info("please wait while all subsystems are shutting down...");
+    for (size_t i = 0; i < mShutdownHandlers.size(); ++i) {
+        beammp_info("Subsystem " + std::to_string(i + 1) + "/" + std::to_string(mShutdownHandlers.size()) + " shutting down");
+        mShutdownHandlers[i]();
+    }
+    // std::exit(-1);
+}
+
+std::string Application::ServerVersionString() {
+    return mVersion.AsString();
+}
+
+std::array<uint8_t, 3> Application::VersionStrToInts(const std::string& str) {
+    std::array<uint8_t, 3> Version;
+    std::stringstream ss(str);
+    for (uint8_t& i : Version) {
+        std::string Part;
+        std::getline(ss, Part, '.');
+        std::from_chars(&*Part.begin(), &*Part.begin() + Part.size(), i);
+    }
+    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;
+    } else if (Newest.major == Current.major && Newest.minor > Current.minor) {
+        return true;
+    } else if (Newest.major == Current.major && Newest.minor == Current.minor && Newest.patch > Current.patch) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+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:
+        beammp_trace("Subsystem '" + Subsystem + "': Good");
+        break;
+    case Status::Bad:
+        beammp_trace("Subsystem '" + Subsystem + "': Bad");
+        break;
+    case Status::Starting:
+        beammp_trace("Subsystem '" + Subsystem + "': Starting");
+        break;
+    case Status::ShuttingDown:
+        beammp_trace("Subsystem '" + Subsystem + "': Shutting down");
+        break;
+    case Status::Shutdown:
+        beammp_trace("Subsystem '" + Subsystem + "': Shutdown");
+        break;
+    default:
+        beammp_assert_not_reachable();
+    }
+    std::unique_lock Lock(mSystemStatusMapMutex);
+    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;
+    // checks current version against latest version
+    std::regex VersionRegex { R"(\d+\.\d+\.\d+\n*)" };
+    for (const auto& url : GetBackendUrlsInOrder()) {
+        auto Response = Http::GET(url, 443, "/v/s");
+        bool Matches = std::regex_match(Response, VersionRegex);
+        if (Matches) {
+            auto MyVersion = ServerVersion();
+            auto RemoteVersion = Version(VersionStrToInts(Response));
+            if (IsOutdated(MyVersion, RemoteVersion)) {
+                std::string RealVersionString = RemoteVersion.AsString();
+                beammp_warn(std::string(ANSI_YELLOW_BOLD) + "NEW VERSION IS OUT! Please update to the new version (v" + RealVersionString + ") of the BeamMP-Server! Download it here: https://beammp.com/! For a guide on how to update, visit: https://wiki.beammp.com/en/home/server-maintenance#updating-the-server" + std::string(ANSI_RESET));
+            } else {
+                if (FirstTime) {
+                    beammp_info("Server up-to-date!");
+                }
+            }
+            Application::SetSubsystemStatus("UpdateCheck", Application::Status::Good);
+            break;
+        } else {
+            if (FirstTime) {
+                beammp_debug("Failed to fetch version from: " + url);
+                beammp_trace("got " + Response);
+                Application::SetSubsystemStatus("UpdateCheck", Application::Status::Bad);
+            }
+        }
+    }
+    if (Application::GetSubsystemStatuses().at("UpdateCheck") == Application::Status::Bad) {
+        if (FirstTime) {
+            beammp_warn("Unable to fetch version info from backend.");
+        }
+    }
+    FirstTime = false;
+}
+
+// thread name stuff
+
+static std::map<std::thread::id, std::string> threadNameMap {};
+static std::mutex ThreadNameMapMutex {};
+
+std::string ThreadName(bool DebugModeOverride) {
+    auto Lock = std::unique_lock(ThreadNameMapMutex);
+    if (DebugModeOverride || Application::Settings.DebugModeEnabled) {
+        auto id = std::this_thread::get_id();
+        if (threadNameMap.find(id) != threadNameMap.end()) {
+            // found
+            return threadNameMap.at(id) + " ";
+        }
+    }
+    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
+    ThreadId = std::to_string(GetCurrentThreadId());
+#elif defined(BEAMMP_APPLE)
+    ThreadId = std::to_string(getpid()); // todo: research if 'getpid()' is a valid, posix compliant alternative to 'gettid()'
+#elif defined(BEAMMP_LINUX)
+    ThreadId = std::to_string(gettid());
+#endif
+    if (Application::Settings.DebugModeEnabled) {
+        std::ofstream ThreadFile(".Threads.log", std::ios::app);
+        ThreadFile << ("Thread \"" + str + "\" is TID " + ThreadId) << std::endl;
+    }
+    auto Lock = std::unique_lock(ThreadNameMapMutex);
+    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)
+    , patch(patch) { }
+
+Version::Version(const std::array<uint8_t, 3>& v)
+    : Version(v[0], v[1], v[2]) {
+}
+
+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;
+        ss << ThreadName();
+        ss << "[CHAT] ";
+        if (id != -1) {
+            ss << "(" << id << ") <" << name << "> ";
+        } else {
+            ss << name << "";
+        }
+        ss << msg;
+#ifdef DOCTEST_CONFIG_DISABLE
+        Application::Console().Write(ss.str());
+#endif
+    }
+}
+
+std::string GetPlatformAgnosticErrorString() {
+#ifdef BEAMMP_WINDOWS
+    // This will provide us with the error code and an error message, all in one.
+    int err;
+    char msgbuf[256];
+    msgbuf[0] = '\0';
+
+    err = GetLastError();
+
+    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+        nullptr,
+        err,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        msgbuf,
+        sizeof(msgbuf),
+        nullptr);
+
+    if (*msgbuf) {
+        return std::to_string(GetLastError()) + " - " + std::string(msgbuf);
+    } else {
+        return std::to_string(GetLastError());
+    }
+#elif defined(BEAMMP_LINUX) || defined(BEAMMP_APPLE)
+    return std::strerror(errno);
+#else
+    return "(no human-readable errors on this platform)";
+#endif
+}
+
+// TODO: add unit tests to SplitString
+void SplitString(const std::string& str, const char delim, std::vector<std::string>& out) {
+    size_t start;
+    size_t end = 0;
+
+    while ((start = str.find_first_not_of(delim, end)) != std::string::npos) {
+        end = str.find(delim, start);
+        out.push_back(str.substr(start, end - start));
+    }
+}

src/Compat.cpp

@@ -0,0 +1,64 @@
+#include "Compat.h"
+
+#include <cstring>
+#include <doctest/doctest.h>
+
+#ifndef WIN32
+
+static struct termios old, current;
+
+static void initTermios(int echo) {
+    tcgetattr(0, &old); /* grab old terminal i/o settings */
+    current = old; /* make new settings same as old settings */
+    current.c_lflag &= ~ICANON; /* disable buffered i/o */
+    if (echo) {
+        current.c_lflag |= ECHO; /* set echo mode */
+    } else {
+        current.c_lflag &= ~ECHO; /* set no echo mode */
+    }
+    tcsetattr(0, TCSANOW, &current); /* use these new terminal i/o settings now */
+}
+
+static 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_EQ(std::memcmp(&current.c_cc, &original.c_cc, sizeof(current.c_cc)), 0);
+        CHECK_EQ(current.c_cflag, original.c_cflag);
+        CHECK_EQ(current.c_iflag, original.c_iflag);
+        CHECK_EQ(current.c_ispeed, original.c_ispeed);
+        CHECK_EQ(current.c_lflag, original.c_lflag);
+        CHECK_EQ(current.c_line, original.c_line);
+        CHECK_EQ(current.c_oflag, original.c_oflag);
+        CHECK_EQ(current.c_ospeed, original.c_ospeed);
+    }
+}
+
+static char getch_(int echo) {
+    char ch;
+    initTermios(echo);
+    if (read(STDIN_FILENO, &ch, 1) < 0) {
+        // ignore, not much we can do
+    }
+    resetTermios();
+    return ch;
+}
+
+char _getch(void) {
+    return getch_(0);
+}
+
+#endif // !WIN32

src/Compressor.cpp

@@ -1,52 +0,0 @@
-///
-/// Created by Anonymous275 on 7/15/2020
-///
-
-#include <algorithm>
-#include <array>
-#include <iostream>
-#include <zlib.h>
-
-#define Biggest 30000
-std::string Comp(std::string Data) {
-    std::array<char, Biggest> C {};
-    // obsolete
-    C.fill(0);
-    z_stream defstream;
-    defstream.zalloc = Z_NULL;
-    defstream.zfree = Z_NULL;
-    defstream.opaque = Z_NULL;
-    defstream.avail_in = (uInt)Data.length();
-    defstream.next_in = (Bytef*)&Data[0];
-    defstream.avail_out = Biggest;
-    defstream.next_out = reinterpret_cast<Bytef*>(C.data());
-    deflateInit(&defstream, Z_BEST_COMPRESSION);
-    deflate(&defstream, Z_SYNC_FLUSH);
-    deflate(&defstream, Z_FINISH);
-    deflateEnd(&defstream);
-    size_t TO = defstream.total_out;
-    std::string Ret(TO, 0);
-    std::copy_n(C.begin(), TO, Ret.begin());
-    return Ret;
-}
-std::string DeComp(std::string Compressed) {
-    std::array<char, Biggest> C {};
-    // not needed
-    C.fill(0);
-    z_stream infstream;
-    infstream.zalloc = Z_NULL;
-    infstream.zfree = Z_NULL;
-    infstream.opaque = Z_NULL;
-    infstream.avail_in = Biggest;
-    infstream.next_in = (Bytef*)(&Compressed[0]);
-    infstream.avail_out = Biggest;
-    infstream.next_out = (Bytef*)(C.data());
-    inflateInit(&infstream);
-    inflate(&infstream, Z_SYNC_FLUSH);
-    inflate(&infstream, Z_FINISH);
-    inflateEnd(&infstream);
-    size_t TO = infstream.total_out;
-    std::string Ret(TO, 0);
-    std::copy_n(C.begin(), TO, Ret.begin());
-    return Ret;
-}

src/Console.cpp

@@ -1,238 +0,0 @@
-///
-/// Created by Anonymous275 on 10/29/2020
-///
-
-#include "Lua/LuaSystem.hpp"
-#ifdef WIN32
-#include <conio.h>
-#include <windows.h>
-#else // *nix
-typedef unsigned long DWORD, *PDWORD, *LPDWORD;
-#include <termios.h>
-#include <unistd.h>
-#endif // WIN32
-#include "Logger.h"
-#include <array>
-#include <cstring>
-#include <iostream>
-#include <mutex>
-#include <string>
-#include <thread>
-
-std::vector<std::string> QConsoleOut;
-std::string CInputBuff;
-std::mutex MLock;
-std::unique_ptr<Lua> LuaConsole;
-void HandleInput(const std::string& cmd) {
-    std::cout << std::endl;
-    if (cmd == Sec("exit")) {
-        _Exit(0);
-    } else if (cmd == Sec("clear") || cmd == Sec("cls")) {
-        // 2J is clearscreen, H is reset position to top-left
-        ConsoleOut(Sec("\x1b[2J\x1b[H"));
-    } else {
-        LuaConsole->Execute(cmd);
-    }
-}
-
-void ProcessOut() {
-    static size_t len = 2;
-    if (QConsoleOut.empty() && len == CInputBuff.length())
-        return;
-    printf("%c[2K\r", 27);
-    for (const std::string& msg : QConsoleOut)
-        if (!msg.empty())
-            std::cout << msg;
-    MLock.lock();
-    QConsoleOut.clear();
-    MLock.unlock();
-    std::cout << "> " << CInputBuff << std::flush;
-    len = CInputBuff.length();
-}
-
-void ConsoleOut(const std::string& msg) {
-    MLock.lock();
-    QConsoleOut.emplace_back(msg);
-    MLock.unlock();
-}
-
-[[noreturn]] void OutputRefresh() {
-    DebugPrintTID();
-    while (true) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
-        ProcessOut();
-    }
-}
-
-#ifndef WIN32
-
-static struct termios old, current;
-
-void initTermios(int echo) {
-    tcgetattr(0, &old); /* grab old terminal i/o settings */
-    current = old; /* make new settings same as old settings */
-    current.c_lflag &= ~ICANON; /* disable buffered i/o */
-    if (echo) {
-        current.c_lflag |= ECHO; /* set echo mode */
-    } else {
-        current.c_lflag &= ~ECHO; /* set no echo mode */
-    }
-    tcsetattr(0, TCSANOW, &current); /* use these new terminal i/o settings now */
-}
-
-void resetTermios(void) {
-    tcsetattr(0, TCSANOW, &old);
-}
-
-char getch_(int echo) {
-    char ch;
-    initTermios(echo);
-    read(STDIN_FILENO, &ch, 1);
-    resetTermios();
-    return ch;
-}
-
-char _getch(void) {
-    return getch_(0);
-}
-
-#endif // WIN32
-
-void SetupConsole() {
-#if defined(WIN32) && !defined(DEBUG)
-    DWORD outMode = 0;
-    HANDLE stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE);
-    if (stdoutHandle == INVALID_HANDLE_VALUE) {
-        error("Invalid handle");
-        std::this_thread::sleep_for(std::chrono::seconds(3));
-        _Exit(GetLastError());
-    }
-    if (!GetConsoleMode(stdoutHandle, &outMode)) {
-        error("Invalid console mode");
-        std::this_thread::sleep_for(std::chrono::seconds(3));
-        _Exit(GetLastError());
-    }
-    // Enable ANSI escape codes
-    outMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-    if (!SetConsoleMode(stdoutHandle, outMode)) {
-        error("failed to set console mode");
-        std::this_thread::sleep_for(std::chrono::seconds(3));
-        _Exit(GetLastError());
-    }
-#else
-#endif // WIN32
-}
-
-static std::vector<std::string> ConsoleHistory {};
-static size_t ConsoleHistoryReadIndex { 0 };
-
-static inline void ConsoleHistoryAdd(const std::string& cmd) {
-    ConsoleHistory.push_back(cmd);
-    ConsoleHistoryReadIndex = ConsoleHistory.size();
-}
-static std::string CompositeInput;
-static bool CompositeInputExpected { false };
-
-static void ProcessCompositeInput() {
-#ifdef WIN32
-    if (CompositeInput.size() == 1 && memcmp(CompositeInput.data(), std::array<char, 1> { 72 }.data(), 1) == 0) {
-#else // unix
-    if (CompositeInput.size() == 2 && memcmp(CompositeInput.data(), std::array<char, 2> { 91, 65 }.data(), 2) == 0) {
-#endif // WIN32
-
-        // UP ARROW
-        // info(std::to_string(ConsoleHistoryReadIndex));
-        if (!ConsoleHistory.empty()) {
-            if (ConsoleHistoryReadIndex != 0) {
-                ConsoleHistoryReadIndex -= 1;
-            }
-            CInputBuff = ConsoleHistory.at(ConsoleHistoryReadIndex);
-        }
-#ifdef WIN32
-    } else if (CompositeInput.size() == 1 && memcmp(CompositeInput.data(), std::array<char, 1> { 80 }.data(), 1) == 0) {
-#else // unix
-    } else if (CompositeInput.size() == 2 && memcmp(CompositeInput.data(), std::array<char, 2> { 91, 66 }.data(), 2) == 0) {
-#endif // WIN32
-
-        // DOWN ARROW
-        if (!ConsoleHistory.empty()) {
-            if (ConsoleHistoryReadIndex != ConsoleHistory.size() - 1) {
-                ConsoleHistoryReadIndex += 1;
-                CInputBuff = ConsoleHistory.at(ConsoleHistoryReadIndex);
-            } else {
-                CInputBuff = "";
-                ConsoleHistoryReadIndex = ConsoleHistory.size();
-            }
-        }
-    } else {
-        // not composite input, we made a mistake, so lets just add it to the buffer like usual
-        CInputBuff += CompositeInput;
-    }
-    // ensure history doesnt grow too far beyond a max
-    static constexpr size_t MaxHistory = 10;
-    if (ConsoleHistory.size() > 2 * MaxHistory) {
-        std::vector<std::string> NewHistory(ConsoleHistory.begin() + ConsoleHistory.size() - MaxHistory, ConsoleHistory.end());
-        ConsoleHistory = std::move(NewHistory);
-        ConsoleHistoryReadIndex = ConsoleHistory.size();
-    }
-}
-
-[[noreturn]] void ReadCin() {
-    DebugPrintTID();
-    while (true) {
-        int In = _getch();
-        // info(std::to_string(In));
-        if (CompositeInputExpected) {
-            CompositeInput += char(In);
-#ifdef WIN32
-            if (CompositeInput.size() == 1) {
-#else // unix
-            if (CompositeInput.size() == 2) {
-#endif // WIN32
-                CompositeInputExpected = false;
-                ProcessCompositeInput();
-            }
-            continue;
-        }
-        if (In == 13 || In == '\n') {
-            if (!CInputBuff.empty()) {
-                HandleInput(CInputBuff);
-                ConsoleHistoryAdd(CInputBuff);
-                CInputBuff.clear();
-            }
-        } else if (In == 8 || In == 127) {
-            if (!CInputBuff.empty())
-                CInputBuff.pop_back();
-        } else if (In == 4) {
-            CInputBuff = "exit";
-            HandleInput(CInputBuff);
-            CInputBuff.clear();
-        } else if (In == 12) {
-            CInputBuff = "clear";
-            HandleInput(CInputBuff);
-            CInputBuff.clear();
-#ifdef WIN32
-        } else if (In == 224) {
-#else // unix
-        } else if (In == 27) {
-#endif // WIN32
-
-            // escape char, assume stuff follows
-            CompositeInputExpected = true;
-            CompositeInput.clear();
-        } else if (!isprint(In)) {
-            // ignore
-        } else {
-            CInputBuff += char(In);
-        }
-    }
-}
-void ConsoleInit() {
-    SetupConsole();
-    LuaConsole = std::make_unique<Lua>(true);
-    printf("> ");
-    std::thread In(ReadCin);
-    In.detach();
-    std::thread Out(OutputRefresh);
-    Out.detach();
-}

src/Enc.cpp

@@ -1,132 +0,0 @@
-///
-/// Created by Anonymous275 on 7/28/2020
-///
-#include "Security/Enc.h"
-#include "CustomAssert.h"
-#include "Settings.h"
-//#include <windows.h>
-#include "Logger.h"
-#include <random>
-#include <sstream>
-#include <thread>
-
-int Rand() {
-    std::random_device r;
-    std::default_random_engine e1(r());
-    std::uniform_int_distribution<int> uniform_dist(1, 5000);
-    return uniform_dist(e1);
-}
-
-int log_power(int n, unsigned int p, int mod) {
-    int result = 1;
-    for (; p; p >>= 1u) {
-        if (p & 1u)
-            result = int((1LL * result * n) % mod);
-        n = int((1LL * n * n) % mod);
-    }
-    return result;
-}
-bool rabin_miller(int n) {
-    bool ok = true;
-    for (int i = 1; i <= 5 && ok; i++) {
-        int a = Rand() + 1;
-        int result = log_power(a, n - 1, n);
-        ok &= (result == 1);
-    }
-    return ok;
-}
-int generate_prime() {
-    int generated = Rand();
-    while (!rabin_miller(generated))
-        generated = Rand();
-    return generated;
-}
-int gcd(int a, int b) {
-    while (b) {
-        int r = a % b;
-        a = b;
-        b = r;
-    }
-    return a;
-}
-
-int generate_coprime(int n) {
-    int generated = Rand();
-    while (gcd(n, generated) != 1)
-        generated = Rand();
-    return generated;
-}
-
-std::pair<int, int> euclid_extended(int a, int b) {
-    if (!b)
-        return { 1, 0 };
-    auto result = euclid_extended(b, a % b);
-    return { result.second, result.first - (a / b) * result.second };
-}
-
-int modular_inverse(int n, int mod) {
-    int inverse = euclid_extended(n, mod).first;
-    while (inverse < 0)
-        inverse += mod;
-    return inverse;
-}
-
-RSA* GenKey() {
-    int p, q;
-    p = generate_prime();
-    q = generate_prime();
-    int n = p * q;
-    int phi = (p - 1) * (q - 1);
-    int e = generate_coprime(phi);
-    int d = modular_inverse(e, phi);
-    return new RSA { n, e, d };
-}
-
-int Enc(int value, int e, int n) {
-    return log_power(value, e, n);
-}
-
-int Dec(int value, int d, int n) {
-    return log_power(value, d, n);
-}
-
-#ifdef WIN32
-int Handle(EXCEPTION_POINTERS* ep, char* Origin) {
-    //Assert(false);
-    std::stringstream R;
-    R << Sec("Code : ") << std::hex
-      << ep->ExceptionRecord->ExceptionCode
-      << std::dec << Sec(" Origin : ") << Origin;
-    except(R.str());
-    return 1;
-}
-#else
-// stub
-int Handle(EXCEPTION_POINTERS*, char*) { return 1; }
-#endif // WIN32
-
-std::string RSA_E(const std::string& Data, RSA* k) {
-    std::stringstream stream;
-    for (const char& c : Data) {
-        stream << std::hex << Enc(uint8_t(c), k->e, k->n) << "g";
-    }
-    return stream.str();
-}
-std::string RSA_E(const std::string& Data, int e, int n) {
-    std::stringstream stream;
-    for (const char& c : Data) {
-        stream << std::hex << Enc(uint8_t(c), e, n) << "g";
-    }
-    return stream.str();
-}
-std::string RSA_D(const std::string& Data, RSA* k) {
-    std::stringstream ss(Data);
-    std::string token, ret;
-    while (std::getline(ss, token, 'g')) {
-        if (token.find_first_not_of(Sec("0123456789abcdef")) != std::string::npos)
-            return "";
-        int c = std::stoi(token, nullptr, 16);
-        ret += char(Dec(c, k->d, k->n));
-    }
-    return ret;
-}

src/Http.cpp

@@ -0,0 +1,205 @@
+#include "Http.h"
+
+#include "Client.h"
+#include "Common.h"
+#include "CustomAssert.h"
+#include "LuaAPI.h"
+
+#include <map>
+#include <nlohmann/json.hpp>
+#include <random>
+#include <stdexcept>
+
+// TODO: Add sentry error handling back
+
+using json = nlohmann::json;
+
+std::string Http::GET(const std::string& host, int port, const std::string& target, unsigned int* status) {
+    httplib::SSLClient client(host, port);
+    client.enable_server_certificate_verification(false);
+    client.set_address_family(AF_INET);
+    auto res = client.Get(target.c_str());
+    if (res) {
+        if (status) {
+            *status = res->status;
+        }
+        return res->body;
+    } else {
+        return Http::ErrorString;
+    }
+}
+
+std::string Http::POST(const std::string& host, int port, const std::string& target, const std::string& body, const std::string& ContentType, unsigned int* status, const httplib::Headers& headers) {
+    httplib::SSLClient client(host, port);
+    client.set_read_timeout(std::chrono::seconds(10));
+    beammp_assert(client.is_valid());
+    client.enable_server_certificate_verification(false);
+    client.set_address_family(AF_INET);
+    auto res = client.Post(target.c_str(), headers, body.c_str(), body.size(), ContentType.c_str());
+    if (res) {
+        if (status) {
+            *status = res->status;
+        }
+        return res->body;
+    } else {
+        beammp_debug("POST failed: " + httplib::to_string(res.error()));
+        return Http::ErrorString;
+    }
+}
+
+// RFC 2616, RFC 7231
+static std::map<size_t, const char*> Map = {
+    { -1, "Invalid Response Code" },
+    { 100, "Continue" },
+    { 101, "Switching Protocols" },
+    { 102, "Processing" },
+    { 103, "Early Hints" },
+    { 200, "OK" },
+    { 201, "Created" },
+    { 202, "Accepted" },
+    { 203, "Non-Authoritative Information" },
+    { 204, "No Content" },
+    { 205, "Reset Content" },
+    { 206, "Partial Content" },
+    { 207, "Multi-Status" },
+    { 208, "Already Reported" },
+    { 226, "IM Used" },
+    { 300, "Multiple Choices" },
+    { 301, "Moved Permanently" },
+    { 302, "Found" },
+    { 303, "See Other" },
+    { 304, "Not Modified" },
+    { 305, "Use Proxy" },
+    { 306, "(Unused)" },
+    { 307, "Temporary Redirect" },
+    { 308, "Permanent Redirect" },
+    { 400, "Bad Request" },
+    { 401, "Unauthorized" },
+    { 402, "Payment Required" },
+    { 403, "Forbidden" },
+    { 404, "Not Found" },
+    { 405, "Method Not Allowed" },
+    { 406, "Not Acceptable" },
+    { 407, "Proxy Authentication Required" },
+    { 408, "Request Timeout" },
+    { 409, "Conflict" },
+    { 410, "Gone" },
+    { 411, "Length Required" },
+    { 412, "Precondition Failed" },
+    { 413, "Payload Too Large" },
+    { 414, "URI Too Long" },
+    { 415, "Unsupported Media Type" },
+    { 416, "Range Not Satisfiable" },
+    { 417, "Expectation Failed" },
+    { 421, "Misdirected Request" },
+    { 422, "Unprocessable Entity" },
+    { 423, "Locked" },
+    { 424, "Failed Dependency" },
+    { 425, "Too Early" },
+    { 426, "Upgrade Required" },
+    { 428, "Precondition Required" },
+    { 429, "Too Many Requests" },
+    { 431, "Request Header Fields Too Large" },
+    { 451, "Unavailable For Legal Reasons" },
+    { 500, "Internal Server Error" },
+    { 501, "Not Implemented" },
+    { 502, "Bad Gateway" },
+    { 503, "Service Unavailable" },
+    { 504, "Gateway Timeout" },
+    { 505, "HTTP Version Not Supported" },
+    { 506, "Variant Also Negotiates" },
+    { 507, "Insufficient Storage" },
+    { 508, "Loop Detected" },
+    { 510, "Not Extended" },
+    { 511, "Network Authentication Required" },
+    // cloudflare status codes
+    { 520, "(CDN) Web Server Returns An Unknown Error" },
+    { 521, "(CDN) Web Server Is Down" },
+    { 522, "(CDN) Connection Timed Out" },
+    { 523, "(CDN) Origin Is Unreachable" },
+    { 524, "(CDN) A Timeout Occurred" },
+    { 525, "(CDN) SSL Handshake Failed" },
+    { 526, "(CDN) Invalid SSL Certificate" },
+    { 527, "(CDN) Railgun Listener To Origin Error" },
+    { 530, "(CDN) 1XXX Internal Error" },
+};
+
+static const char Magic[] = {
+    0x20, 0x2f, 0x5c, 0x5f,
+    0x2f, 0x5c, 0x0a, 0x28,
+    0x20, 0x6f, 0x2e, 0x6f,
+    0x20, 0x29, 0x0a, 0x20,
+    0x3e, 0x20, 0x5e, 0x20,
+    0x3c, 0x0a, 0x00
+};
+
+std::string Http::Status::ToString(int Code) {
+    if (Map.find(Code) != Map.end()) {
+        return Map.at(Code);
+    } else {
+        return std::to_string(Code);
+    }
+}
+
+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() {
+    Application::SetSubsystemStatus("HTTPServer", Application::Status::Starting);
+    mThread = std::thread(&Http::Server::THttpServerInstance::operator(), this);
+    mThread.detach();
+}
+
+void Http::Server::THttpServerInstance::operator()() try {
+    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");
+    });
+    HttpLibServerInstance->Get("/health", [](const httplib::Request&, httplib::Response& res) {
+        size_t SystemsGood = 0;
+        size_t SystemsBad = 0;
+        auto Statuses = Application::GetSubsystemStatuses();
+        for (const auto& NameStatusPair : Statuses) {
+            switch (NameStatusPair.second) {
+            case Application::Status::Starting:
+            case Application::Status::ShuttingDown:
+            case Application::Status::Shutdown:
+            case Application::Status::Good:
+                SystemsGood++;
+                break;
+            case Application::Status::Bad:
+                SystemsBad++;
+                break;
+            default:
+                beammp_assert_not_reachable();
+            }
+        }
+        res.set_content(
+            json {
+                { "ok", SystemsBad == 0 },
+            }
+                .dump(),
+            "application/json");
+        res.status = 200;
+    });
+    // magic endpoint
+    HttpLibServerInstance->Get({ 0x2f, 0x6b, 0x69, 0x74, 0x74, 0x79 }, [](const httplib::Request&, httplib::Response& res) {
+        res.set_content(std::string(Magic), "text/plain");
+    });
+    HttpLibServerInstance->set_logger([](const httplib::Request& Req, const httplib::Response& Res) {
+        beammp_debug("Http Server: " + Req.method + " " + Req.target + " -> " + std::to_string(Res.status));
+    });
+    Application::SetSubsystemStatus("HTTPServer", Application::Status::Good);
+    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.");
+    }
+} catch (const std::exception& e) {
+    beammp_error("Failed to start http server. Please ensure the http server is configured properly in the ServerConfig.toml, or turn it off if you don't need it. Error: " + std::string(e.what()));
+}

src/Init/Config.cpp

@@ -1,161 +0,0 @@
-///
-/// Created by Anonymous275 on 7/28/2020
-///
-#include "CustomAssert.h"
-#include "Logger.h"
-#include "Security/Enc.h"
-#include <fstream>
-#include <string>
-#include <thread>
-std::string ServerName;
-std::string ServerDesc;
-std::string Resource;
-std::string MapName;
-std::string Key;
-int MaxPlayers;
-bool Private;
-int MaxCars;
-bool Debug;
-int Port;
-
-void SetValues(const std::string& Line, int Index) {
-    int state = 0;
-    std::string Data;
-    bool Switch = false;
-    if (Index > 5)
-        Switch = true;
-    for (char c : Line) {
-        if (Switch) {
-            if (c == '\"')
-                state++;
-            if (state > 0 && state < 2)
-                Data += c;
-        } else {
-            if (c == ' ')
-                state++;
-            if (state > 1)
-                Data += c;
-        }
-    }
-    Data = Data.substr(1);
-    std::string::size_type sz;
-    bool FoundTrue = std::string(Data).find("true") != std::string::npos; //searches for "true"
-    switch (Index) {
-    case 1:
-        Debug = FoundTrue; //checks and sets the Debug Value
-        break;
-    case 2:
-        Private = FoundTrue; //checks and sets the Private Value
-        break;
-    case 3:
-        Port = std::stoi(Data, &sz); //sets the Port
-        break;
-    case 4:
-        MaxCars = std::stoi(Data, &sz); //sets the Max Car amount
-        break;
-    case 5:
-        MaxPlayers = std::stoi(Data, &sz); //sets the Max Amount of player
-        break;
-    case 6:
-        MapName = Data; //Map
-        break;
-    case 7:
-        ServerName = Data; //Name
-        break;
-    case 8:
-        ServerDesc = Data; //desc
-        break;
-    case 9:
-        Resource = Data; //File name
-        break;
-    case 10:
-        Key = Data; //File name
-    default:
-        break;
-    }
-}
-std::string RemoveComments(const std::string& Line) {
-    std::string Return;
-    for (char c : Line) {
-        if (c == '#')
-            break;
-        Return += c;
-    }
-    return Return;
-}
-void LoadConfig(std::ifstream& IFS) {
-    Assert(IFS.is_open());
-    std::string line;
-    int index = 1;
-    while (getline(IFS, line)) {
-        index++;
-    }
-    if (index - 1 < 11) {
-        error(Sec("Outdated/Incorrect config please remove it server will close in 5 secs"));
-        std::this_thread::sleep_for(std::chrono::seconds(3));
-        _Exit(0);
-    }
-    IFS.close();
-    IFS.open(Sec("Server.cfg"));
-    info(Sec("Config found updating values"));
-    index = 1;
-    while (getline(IFS, line)) {
-        if (line.rfind('#', 0) != 0 && line.rfind(' ', 0) != 0) { //Checks if it starts as Comment
-            std::string CleanLine = RemoveComments(line); //Cleans it from the Comments
-            SetValues(CleanLine, index); //sets the values
-            index++;
-        }
-    }
-}
-void GenerateConfig() {
-    std::ofstream FileStream;
-    FileStream.open(Sec("Server.cfg"));
-    FileStream << Sec("# This is the BeamMP Server Configuration File v0.60\n"
-                      "Debug = false # true or false to enable debug console output\n"
-                      "Private = true # Private?\n"
-                      "Port = 30814 # Port to run the server on UDP and TCP\n"
-                      "Cars = 1 # Max cars for every player\n"
-                      "MaxPlayers = 10 # Maximum Amount of Clients\n"
-                      "Map = \"/levels/gridmap/info.json\" # Default Map\n"
-                      "Name = \"BeamMP New Server\" # Server Name\n"
-                      "Desc = \"BeamMP Default Description\" # Server Description\n"
-                      "use = \"Resources\" # Resource file name\n"
-                      "AuthKey = \"\" # Auth Key");
-    FileStream.close();
-}
-void Default() {
-    info(Sec("Config not found generating default"));
-    GenerateConfig();
-    error(Sec("You are required to input the AuthKey"));
-    std::this_thread::sleep_for(std::chrono::seconds(3));
-    _Exit(0);
-}
-void DebugData() {
-    debug(std::string(Sec("Debug : ")) + (Debug ? "true" : "false"));
-    debug(std::string(Sec("Private : ")) + (Private ? "true" : "false"));
-    debug(Sec("Port : ") + std::to_string(Port));
-    debug(Sec("Max Cars : ") + std::to_string(MaxCars));
-    debug(Sec("MaxPlayers : ") + std::to_string(MaxPlayers));
-    debug(Sec("MapName : ") + MapName);
-    debug(Sec("ServerName : ") + ServerName);
-    debug(Sec("ServerDesc : ") + ServerDesc);
-    debug(Sec("File : ") + Resource);
-    debug(Sec("Key length: ") + std::to_string(Key.length()));
-}
-void InitConfig() {
-    std::ifstream IFS;
-    IFS.open(Sec("Server.cfg"));
-    if (IFS.good())
-        LoadConfig(IFS);
-    else
-        Default();
-    if (IFS.is_open())
-        IFS.close();
-    if (Key.empty()) {
-        error(Sec("No AuthKey was found"));
-        std::this_thread::sleep_for(std::chrono::seconds(3));
-        _Exit(0);
-    }
-    if (Debug)
-        DebugData();
-}

src/Init/Heartbeat.cpp

@@ -1,85 +0,0 @@
-///
-/// Created by Anonymous275 on 7/28/2020
-///
-#include "Client.hpp"
-#include "Curl/Http.h"
-#include "Logger.h"
-#include "Security/Enc.h"
-#include "Settings.h"
-#include <chrono>
-#include <future>
-#include <sstream>
-#include <thread>
-
-void WebsocketInit();
-std::string GetPlayers() {
-    std::string Return;
-    for (auto& c : CI->Clients) {
-        if (c != nullptr) {
-            Return += c->GetName() + ";";
-        }
-    }
-    return Return;
-}
-std::string GenerateCall() {
-    std::stringstream Ret;
-    Ret << "uuid=" << Key << "&players=" << CI->Size()
-        << "&maxplayers=" << MaxPlayers << "&port=" << Port
-        << "&map=" << MapName << "&private=" << (Private ? "true" : "false")
-        << "&version=" << GetSVer() << "&clientversion=" << GetCVer()
-        << "&name=" << ServerName << "&pps=" << StatReport
-        << "&modlist=" << FileList << "&modstotalsize=" << MaxModSize
-        << "&modstotal=" << ModsLoaded << "&playerslist=" << GetPlayers()
-        << "&desc=" << ServerDesc;
-    return Ret.str();
-}
-std::string RunPromise(const std::string& IP, const std::string& R) {
-    std::packaged_task<std::string()> task([&]() { return PostHTTP(IP, R); });
-    std::future<std::string> f1 = task.get_future();
-    std::thread t(std::move(task));
-    t.detach();
-    auto status = f1.wait_for(std::chrono::seconds(10));
-    if (status != std::future_status::timeout)
-        return f1.get();
-    error(Sec("Backend system Timeout please try again later"));
-    std::this_thread::sleep_for(std::chrono::seconds(3));
-    _Exit(0);
-}
-
-void Heartbeat() {
-    DebugPrintTID();
-    std::string R, T;
-    bool isAuth = false;
-    while (true) {
-        R = GenerateCall();
-        if (!CustomIP.empty())
-            R += "&ip=" + CustomIP;
-        std::string link = Sec("https://beammp.com/heartbeatv2");
-        T = RunPromise(link, R);
-        if (T.find_first_not_of(Sec("20")) != std::string::npos) {
-            //Backend system refused server startup!
-            std::this_thread::sleep_for(std::chrono::seconds(10));
-            std::string Backup = Sec("https://backup1.beammp.com/heartbeatv2");
-            T = RunPromise(Backup, R);
-            if (T.find_first_not_of(Sec("20")) != std::string::npos) {
-                error(Sec("Backend system refused server! Check your AuthKey"));
-                std::this_thread::sleep_for(std::chrono::seconds(3));
-                _Exit(-1);
-            }
-        }
-        //Server Authenticated
-        if (T.length() == 4)
-            info(Sec("Server authenticated"));
-        R.clear();
-        T.clear();
-        if (!isAuth) {
-            WebsocketInit();
-            isAuth = true;
-        }
-        std::this_thread::sleep_for(std::chrono::seconds(3));
-    }
-}
-void HBInit() {
-    std::thread HB(Heartbeat);
-    HB.detach();
-}

src/Init/Resources.cpp

@@ -1,36 +0,0 @@
-///
-/// Created by Anonymous275 on 7/28/2020
-///
-#include "Logger.h"
-#include "Security/Enc.h"
-#include "Settings.h"
-#include <algorithm>
-#include <filesystem>
-
-namespace fs = std::filesystem;
-
-uint64_t MaxModSize = 0;
-std::string FileSizes;
-std::string FileList;
-int ModsLoaded = 0;
-
-void InitRes() {
-    std::string Path = Resource + Sec("/Client");
-    if (!fs::exists(Path))
-        fs::create_directory(Path);
-    for (const auto& entry : fs::directory_iterator(Path)) {
-        auto pos = entry.path().string().find(Sec(".zip"));
-        if (pos != std::string::npos) {
-            if (entry.path().string().length() - pos == 4) {
-                FileList += entry.path().string() + ";";
-                FileSizes += std::to_string(fs::file_size(entry.path())) + ";";
-                MaxModSize += fs::file_size(entry.path());
-                ModsLoaded++;
-            }
-        }
-    }
-    std::replace(FileList.begin(), FileList.end(), '\\', '/');
-    if (ModsLoaded) {
-        info(Sec("Loaded ") + std::to_string(ModsLoaded) + Sec(" Mods"));
-    }
-}

src/Init/Startup.cpp

@@ -1,36 +0,0 @@
-///
-/// Created by Anonymous275 on 7/28/2020
-///
-#include "Client.hpp"
-#include "Logger.h"
-#include "Security/Enc.h"
-#include <algorithm>
-#include <string>
-
-std::string CustomIP;
-std::string GetSVer() {
-    static std::string r = Sec("1.0");
-    return r;
-}
-std::string GetCVer() {
-    static std::string r = Sec("1.70");
-    return r;
-}
-void Args(int argc, char* argv[]) {
-    info(Sec("BeamMP Server Running version ") + GetSVer());
-    if (argc > 1) {
-        CustomIP = argv[1];
-        size_t n = std::count(CustomIP.begin(), CustomIP.end(), '.');
-        auto p = CustomIP.find_first_not_of(Sec(".0123456789"));
-        if (p != std::string::npos || n != 3 || CustomIP.substr(0, 3) == Sec("127")) {
-            CustomIP.clear();
-            warn(Sec("IP Specified is invalid! Ignoring"));
-        } else
-            info(Sec("Server started with custom IP"));
-    }
-}
-void InitServer(int argc, char* argv[]) {
-    InitLog();
-    Args(argc, argv);
-    CI = std::make_unique<ClientInterface>();
-}

src/Lua/LuaMain.cpp

@@ -1,88 +0,0 @@
-///
-/// Created by Anonymous275 on 5/20/2020
-///
-
-#include "Logger.h"
-#include "Lua/LuaSystem.hpp"
-#include "Security/Enc.h"
-#include "Settings.h"
-#include <thread>
-
-#ifdef __linux
-// we need this for `struct stat`
-#include <sys/stat.h>
-#endif // __linux
-
-std::set<std::unique_ptr<Lua>> PluginEngine;
-bool NewFile(const std::string& Path) {
-    for (auto& Script : PluginEngine) {
-        if (Path == Script->GetFileName())
-            return false;
-    }
-    return true;
-}
-void RegisterFiles(const std::string& Path, bool HotSwap) {
-    std::string Name = Path.substr(Path.find_last_of('\\') + 1);
-    if (!HotSwap)
-        info(Sec("Loading plugin : ") + Name);
-    for (const auto& entry : fs::directory_iterator(Path)) {
-        auto pos = entry.path().string().find(Sec(".lua"));
-        if (pos != std::string::npos && entry.path().string().length() - pos == 4) {
-            if (!HotSwap || NewFile(entry.path().string())) {
-                auto FileName = entry.path().string();
-                std::unique_ptr<Lua> ScriptToInsert(new Lua(Name, FileName, fs::last_write_time(FileName)));
-                auto& Script = *ScriptToInsert;
-                PluginEngine.insert(std::move(ScriptToInsert));
-                Script.Init();
-                if (HotSwap)
-                    info(Sec("[HOTSWAP] Added : ") + Script.GetFileName().substr(Script.GetFileName().find('\\')));
-            }
-        }
-    }
-}
-void FolderList(const std::string& Path, bool HotSwap) {
-    for (const auto& entry : fs::directory_iterator(Path)) {
-        auto pos = entry.path().filename().string().find('.');
-        if (pos == std::string::npos) {
-            RegisterFiles(entry.path().string(), HotSwap);
-        }
-    }
-}
-[[noreturn]] void HotSwaps(const std::string& path) {
-    DebugPrintTID();
-    while (true) {
-        if (!PluginEngine.empty()) {
-            for (auto& Script : PluginEngine) {
-                struct stat Info { };
-                if (stat(Script->GetFileName().c_str(), &Info) != 0) {
-                    Script->SetStopThread(true);
-                    PluginEngine.erase(Script);
-                    info(Sec("[HOTSWAP] Removed : ") + Script->GetFileName().substr(Script->GetFileName().find('\\')));
-                    break;
-                }
-                if (Script->GetLastWrite() != fs::last_write_time(Script->GetFileName())) {
-                    Script->SetStopThread(true);
-                    info(Sec("[HOTSWAP] Updated : ") + Script->GetFileName().substr(Script->GetFileName().find('\\')));
-                    Script->SetLastWrite(fs::last_write_time(Script->GetFileName()));
-                    Script->Reload();
-                }
-            }
-        }
-        FolderList(path, true);
-        std::this_thread::sleep_for(std::chrono::seconds(2));
-    }
-}
-
-void InitLua() {
-    if (!fs::exists(Resource)) {
-        fs::create_directory(Resource);
-    }
-    std::string Path = Resource + Sec("/Server");
-    if (!fs::exists(Path)) {
-        fs::create_directory(Path);
-    }
-    FolderList(Path, false);
-    std::thread t1(HotSwaps, Path);
-    t1.detach();
-    info(Sec("Lua system online"));
-}

src/Lua/LuaSystem.cpp

@@ -1,668 +0,0 @@
-///
-/// Created by Anonymous275 on 5/19/2020
-///
-
-#include "Lua/LuaSystem.hpp"
-#include "Client.hpp"
-#include "Logger.h"
-#include "Network.h"
-#include "Security/Enc.h"
-#include "Settings.h"
-#include "UnixCompat.h"
-#include <future>
-#include <iostream>
-#include <optional>
-#include <utility>
-
-std::unique_ptr<LuaArg> CreateArg(lua_State* L, int T, int S) {
-    if (S > T)
-        return nullptr;
-    std::unique_ptr<LuaArg> temp(new LuaArg);
-    for (int C = S; C <= T; C++) {
-        if (lua_isstring(L, C)) {
-            temp->args.emplace_back(std::string(lua_tostring(L, C)));
-        } else if (lua_isinteger(L, C)) {
-            temp->args.emplace_back(int(lua_tointeger(L, C)));
-        } else if (lua_isboolean(L, C)) {
-            temp->args.emplace_back(bool(lua_toboolean(L, C)));
-        } else if (lua_isnumber(L, C)) {
-            temp->args.emplace_back(float(lua_tonumber(L, C)));
-        }
-    }
-    return temp;
-}
-void ClearStack(lua_State* L) {
-    lua_settop(L, 0);
-}
-std::optional<std::reference_wrapper<Lua>> GetScript(lua_State* L) {
-    for (auto& Script : PluginEngine) {
-        if (Script->GetState() == L)
-            return *Script;
-    }
-    return std::nullopt;
-}
-void SendError(lua_State* L, const std::string& msg) {
-    Assert(L);
-    auto MaybeS = GetScript(L);
-    std::string a;
-    if (!MaybeS.has_value()) {
-        a = Sec("_Console");
-    } else {
-        Lua& S = MaybeS.value();
-        a = fs::path(S.GetFileName()).filename().string();
-    }
-    warn(a + Sec(" | Incorrect Call of ") + msg);
-}
-int Trigger(Lua* lua, const std::string& R, std::unique_ptr<LuaArg> arg) {
-    std::lock_guard<std::mutex> lockGuard(lua->Lock);
-    std::packaged_task<int(std::unique_ptr<LuaArg>)> task([lua, R](std::unique_ptr<LuaArg> arg) { return CallFunction(lua, R, std::move(arg)); });
-    std::future<int> f1 = task.get_future();
-    std::thread t(std::move(task), std::move(arg));
-    t.detach();
-    auto status = f1.wait_for(std::chrono::seconds(5));
-    if (status != std::future_status::timeout)
-        return f1.get();
-    SendError(lua->GetState(), R + " took too long to respond");
-    return 0;
-}
-int FutureWait(Lua* lua, const std::string& R, std::unique_ptr<LuaArg> arg, bool Wait) {
-    Assert(lua);
-    std::packaged_task<int(std::unique_ptr<LuaArg>)> task([lua, R](std::unique_ptr<LuaArg> arg) { return Trigger(lua, R, std::move(arg)); });
-    std::future<int> f1 = task.get_future();
-    std::thread t(std::move(task), std::move(arg));
-    t.detach();
-    int T = 0;
-    if (Wait)
-        T = 6;
-    auto status = f1.wait_for(std::chrono::seconds(T));
-    if (status != std::future_status::timeout)
-        return f1.get();
-    return 0;
-}
-int TriggerLuaEvent(const std::string& Event, bool local, Lua* Caller, std::unique_ptr<LuaArg> arg, bool Wait) {
-    int R = 0;
-    for (auto& Script : PluginEngine) {
-        if (Script->IsRegistered(Event)) {
-            if (local) {
-                if (Script->GetPluginName() == Caller->GetPluginName()) {
-                    R += FutureWait(Script.get(), Script->GetRegistered(Event), std::move(arg), Wait);
-                }
-            } else
-                R += FutureWait(Script.get(), Script->GetRegistered(Event), std::move(arg), Wait);
-        }
-    }
-    return R;
-}
-bool ConsoleCheck(lua_State* L, int r) {
-    if (r != LUA_OK) {
-        std::string msg = lua_tostring(L, -1);
-        warn(Sec("_Console | ") + msg);
-        return false;
-    }
-    return true;
-}
-bool CheckLua(lua_State* L, int r) {
-    if (r != LUA_OK) {
-        std::string msg = lua_tostring(L, -1);
-        auto MaybeS = GetScript(L);
-        if (MaybeS.has_value()) {
-            Lua& S = MaybeS.value();
-            std::string a = fs::path(S.GetFileName()).filename().string();
-            warn(a + " | " + msg);
-            return false;
-        }
-        // What the fuck, what do we do?!
-        AssertNotReachable();
-    }
-    return true;
-}
-
-int lua_RegisterEvent(lua_State* L) {
-    int Args = lua_gettop(L);
-    auto MaybeScript = GetScript(L);
-    Assert(MaybeScript.has_value());
-    Lua& Script = MaybeScript.value();
-    if (Args == 2 && lua_isstring(L, 1) && lua_isstring(L, 2)) {
-        Script.RegisterEvent(lua_tostring(L, 1), lua_tostring(L, 2));
-    } else
-        SendError(L, Sec("RegisterEvent invalid argument count expected 2 got ") + std::to_string(Args));
-    return 0;
-}
-int lua_TriggerEventL(lua_State* L) {
-    int Args = lua_gettop(L);
-    auto MaybeScript = GetScript(L);
-    Assert(MaybeScript.has_value());
-    Lua& Script = MaybeScript.value();
-    if (Args > 0) {
-        if (lua_isstring(L, 1)) {
-            TriggerLuaEvent(lua_tostring(L, 1), true, &Script, CreateArg(L, Args, 2), false);
-        } else
-            SendError(L, Sec("TriggerLocalEvent wrong argument [1] need string"));
-    } else {
-        SendError(L, Sec("TriggerLocalEvent not enough arguments expected 1 got 0"));
-    }
-    return 0;
-}
-
-int lua_TriggerEventG(lua_State* L) {
-    int Args = lua_gettop(L);
-    auto MaybeScript = GetScript(L);
-    Assert(MaybeScript.has_value());
-    Lua& Script = MaybeScript.value();
-    if (Args > 0) {
-        if (lua_isstring(L, 1)) {
-            TriggerLuaEvent(lua_tostring(L, 1), false, &Script, CreateArg(L, Args, 2), false);
-        } else
-            SendError(L, Sec("TriggerGlobalEvent wrong argument [1] need string"));
-    } else
-        SendError(L, Sec("TriggerGlobalEvent not enough arguments"));
-    return 0;
-}
-
-char* ThreadOrigin(Lua* lua) {
-    std::string T = "Thread in " + fs::path(lua->GetFileName()).filename().string();
-    char* Data = new char[T.size() + 1];
-    ZeroMemory(Data, T.size() + 1);
-    memcpy(Data, T.c_str(), T.size());
-    return Data;
-}
-void SafeExecution(Lua* lua, const std::string& FuncName) {
-    lua_State* luaState = lua->GetState();
-    lua_getglobal(luaState, FuncName.c_str());
-    if (lua_isfunction(luaState, -1)) {
-        char* Origin = ThreadOrigin(lua);
-#ifdef WIN32
-        __try {
-            int R = lua_pcall(luaState, 0, 0, 0);
-            CheckLua(luaState, R);
-        } __except (Handle(GetExceptionInformation(), Origin)) {
-        }
-#else // unix
-        int R = lua_pcall(luaState, 0, 0, 0);
-        CheckLua(luaState, R);
-#endif // WIN32
-        delete[] Origin;
-    }
-    ClearStack(luaState);
-}
-
-void ExecuteAsync(Lua* lua, const std::string& FuncName) {
-    std::lock_guard<std::mutex> lockGuard(lua->Lock);
-    SafeExecution(lua, FuncName);
-}
-void CallAsync(Lua* lua, const std::string& Func, int U) {
-    DebugPrintTID();
-    lua->SetStopThread(false);
-    int D = 1000 / U;
-    while (!lua->GetStopThread()) {
-        ExecuteAsync(lua, Func);
-        std::this_thread::sleep_for(std::chrono::milliseconds(D));
-    }
-}
-int lua_StopThread(lua_State* L) {
-    auto MaybeScript = GetScript(L);
-    Assert(MaybeScript.has_value());
-    // ugly, but whatever, this is safe as fuck
-    MaybeScript.value().get().SetStopThread(true);
-    return 0;
-}
-int lua_CreateThread(lua_State* L) {
-    int Args = lua_gettop(L);
-    if (Args > 1) {
-        if (lua_isstring(L, 1)) {
-            std::string STR = lua_tostring(L, 1);
-            if (lua_isinteger(L, 2) || lua_isnumber(L, 2)) {
-                int U = int(lua_tointeger(L, 2));
-                if (U > 0 && U < 501) {
-                    auto MaybeScript = GetScript(L);
-                    Assert(MaybeScript.has_value());
-                    Lua& Script = MaybeScript.value();
-                    std::thread t1(CallAsync, &Script, STR, U);
-                    t1.detach();
-                } else
-                    SendError(L, Sec("CreateThread wrong argument [2] number must be between 1 and 500"));
-            } else
-                SendError(L, Sec("CreateThread wrong argument [2] need number"));
-        } else
-            SendError(L, Sec("CreateThread wrong argument [1] need string"));
-    } else
-        SendError(L, Sec("CreateThread not enough arguments"));
-    return 0;
-}
-int lua_Sleep(lua_State* L) {
-    if (lua_isnumber(L, 1)) {
-        int t = int(lua_tonumber(L, 1));
-        std::this_thread::sleep_for(std::chrono::milliseconds(t));
-    } else {
-        SendError(L, Sec("Sleep not enough arguments"));
-        return 0;
-    }
-    return 1;
-}
-Client* GetClient(int ID) {
-    for (auto& c : CI->Clients) {
-        if (c != nullptr && c->GetID() == ID) {
-            return c.get();
-        }
-    }
-    return nullptr;
-}
-int lua_isConnected(lua_State* L) {
-    if (lua_isnumber(L, 1)) {
-        int ID = int(lua_tonumber(L, 1));
-        Client* c = GetClient(ID);
-        if (c != nullptr)
-            lua_pushboolean(L, c->isConnected);
-        else
-            return 0;
-    } else {
-        SendError(L, Sec("isConnected not enough arguments"));
-        return 0;
-    }
-    return 1;
-}
-int lua_GetPlayerName(lua_State* L) {
-    if (lua_isnumber(L, 1)) {
-        int ID = int(lua_tonumber(L, 1));
-        Client* c = GetClient(ID);
-        if (c != nullptr)
-            lua_pushstring(L, c->GetName().c_str());
-        else
-            return 0;
-    } else {
-        SendError(L, Sec("GetPlayerName not enough arguments"));
-        return 0;
-    }
-    return 1;
-}
-int lua_GetPlayerCount(lua_State* L) {
-    lua_pushinteger(L, CI->Size());
-    return 1;
-}
-int lua_GetDID(lua_State* L) {
-    if (lua_isnumber(L, 1)) {
-        int ID = int(lua_tonumber(L, 1));
-        Client* c = GetClient(ID);
-        if (c != nullptr)
-            lua_pushstring(L, c->GetDID().c_str());
-        else
-            return 0;
-    } else {
-        SendError(L, Sec("GetDID not enough arguments"));
-        return 0;
-    }
-    return 1;
-}
-int lua_GetAllPlayers(lua_State* L) {
-    lua_newtable(L);
-    int i = 1;
-    for (auto& c : CI->Clients) {
-        if (c == nullptr)
-            continue;
-        lua_pushinteger(L, c->GetID());
-        lua_pushstring(L, c->GetName().c_str());
-        lua_settable(L, -3);
-        i++;
-    }
-    if (CI->Clients.empty())
-        return 0;
-    return 1;
-}
-int lua_GetCars(lua_State* L) {
-    if (lua_isnumber(L, 1)) {
-        int ID = int(lua_tonumber(L, 1));
-        Client* c = GetClient(ID);
-        if (c != nullptr) {
-            int i = 1;
-            for (auto& v : c->GetAllCars()) {
-                if (v != nullptr) {
-                    lua_pushinteger(L, v->ID);
-                    lua_pushstring(L, v->Data.substr(3).c_str());
-                    lua_settable(L, -3);
-                    i++;
-                }
-            }
-            if (c->GetAllCars().empty())
-                return 0;
-        } else
-            return 0;
-    } else {
-        SendError(L, Sec("GetPlayerVehicles not enough arguments"));
-        return 0;
-    }
-    return 1;
-}
-int lua_dropPlayer(lua_State* L) {
-    int Args = lua_gettop(L);
-    if (lua_isnumber(L, 1)) {
-        int ID = int(lua_tonumber(L, 1));
-        Client* c = GetClient(ID);
-        if (c == nullptr)
-            return 0;
-        if (c->GetRole() == Sec("MDEV"))
-            return 0;
-        std::string Reason;
-        if (Args > 1 && lua_isstring(L, 2)) {
-            Reason = std::string(Sec(" Reason : ")) + lua_tostring(L, 2);
-        }
-        Respond(c, "C:Server:You have been Kicked from the server! " + Reason, true);
-        c->SetStatus(-2);
-        info(Sec("Closing socket due to kick"));
-        CloseSocketProper(c->GetTCPSock());
-
-    } else
-        SendError(L, Sec("DropPlayer not enough arguments"));
-    return 0;
-}
-int lua_sendChat(lua_State* L) {
-    if (lua_isinteger(L, 1) || lua_isnumber(L, 1)) {
-        if (lua_isstring(L, 2)) {
-            int ID = int(lua_tointeger(L, 1));
-            if (ID == -1) {
-                std::string Packet = "C:Server: " + std::string(lua_tostring(L, 2));
-                SendToAll(nullptr, Packet, true, true);
-            } else {
-                Client* c = GetClient(ID);
-                if (c != nullptr) {
-                    if (!c->isSynced)
-                        return 0;
-                    std::string Packet = "C:Server: " + std::string(lua_tostring(L, 2));
-                    Respond(c, Packet, true);
-                } else
-                    SendError(L, Sec("SendChatMessage invalid argument [1] invalid ID"));
-            }
-        } else
-            SendError(L, Sec("SendChatMessage invalid argument [2] expected string"));
-    } else
-        SendError(L, Sec("SendChatMessage invalid argument [1] expected number"));
-    return 0;
-}
-int lua_RemoveVehicle(lua_State* L) {
-    int Args = lua_gettop(L);
-    if (Args != 2) {
-        SendError(L, Sec("RemoveVehicle invalid argument count expected 2 got ") + std::to_string(Args));
-        return 0;
-    }
-    if ((lua_isinteger(L, 1) || lua_isnumber(L, 1)) && (lua_isinteger(L, 2) || lua_isnumber(L, 2))) {
-        int PID = int(lua_tointeger(L, 1));
-        int VID = int(lua_tointeger(L, 2));
-        Client* c = GetClient(PID);
-        if (c == nullptr) {
-            SendError(L, Sec("RemoveVehicle invalid Player ID"));
-            return 0;
-        }
-        if (c->GetRole() == "MDEV")
-            return 0;
-        if (!c->GetCarData(VID).empty()) {
-            std::string Destroy = "Od:" + std::to_string(PID) + "-" + std::to_string(VID);
-            SendToAll(nullptr, Destroy, true, true);
-            c->DeleteCar(VID);
-        }
-    } else
-        SendError(L, Sec("RemoveVehicle invalid argument expected number"));
-    return 0;
-}
-int lua_HWID(lua_State* L) {
-    lua_pushinteger(L, -1);
-    return 1;
-}
-int lua_RemoteEvent(lua_State* L) {
-    int Args = lua_gettop(L);
-    if (Args != 3) {
-        SendError(L, Sec("TriggerClientEvent invalid argument count expected 3 got ") + std::to_string(Args));
-        return 0;
-    }
-    if (!lua_isnumber(L, 1)) {
-        SendError(L, Sec("TriggerClientEvent invalid argument [1] expected number"));
-        return 0;
-    }
-    if (!lua_isstring(L, 2)) {
-        SendError(L, Sec("TriggerClientEvent invalid argument [2] expected string"));
-        return 0;
-    }
-    if (!lua_isstring(L, 3)) {
-        SendError(L, Sec("TriggerClientEvent invalid argument [3] expected string"));
-        return 0;
-    }
-    int ID = int(lua_tointeger(L, 1));
-    std::string Packet = "E:" + std::string(lua_tostring(L, 2)) + ":" + std::string(lua_tostring(L, 3));
-    if (ID == -1)
-        SendToAll(nullptr, Packet, true, true);
-    else {
-        Client* c = GetClient(ID);
-        if (c == nullptr) {
-            SendError(L, Sec("TriggerClientEvent invalid Player ID"));
-            return 0;
-        }
-        Respond(c, Packet, true);
-    }
-    return 0;
-}
-int lua_ServerExit(lua_State*) {
-    _Exit(0);
-}
-int lua_Set(lua_State* L) {
-    int Args = lua_gettop(L);
-    if (Args != 2) {
-        SendError(L, Sec("set invalid argument count expected 2 got ") + std::to_string(Args));
-        return 0;
-    }
-    if (!lua_isnumber(L, 1)) {
-        SendError(L, Sec("set invalid argument [1] expected number"));
-        return 0;
-    }
-    auto MaybeSrc = GetScript(L);
-    std::string Name;
-    if (!MaybeSrc.has_value()) {
-        Name = Sec("_Console");
-    } else {
-        Name = MaybeSrc.value().get().GetPluginName();
-    }
-    int C = int(lua_tointeger(L, 1));
-    switch (C) {
-    case 0: //debug
-        if (lua_isboolean(L, 2)) {
-            Debug = lua_toboolean(L, 2);
-            info(Name + Sec(" | Debug -> ") + (Debug ? "true" : "false"));
-        } else
-            SendError(L, Sec("set invalid argument [2] expected boolean for ID : 0"));
-        break;
-    case 1: //private
-        if (lua_isboolean(L, 2)) {
-            Private = lua_toboolean(L, 2);
-            info(Name + Sec(" | Private -> ") + (Private ? "true" : "false"));
-        } else
-            SendError(L, Sec("set invalid argument [2] expected boolean for ID : 1"));
-        break;
-    case 2: //max cars
-        if (lua_isnumber(L, 2)) {
-            MaxCars = int(lua_tointeger(L, 2));
-            info(Name + Sec(" | MaxCars -> ") + std::to_string(MaxCars));
-        } else
-            SendError(L, Sec("set invalid argument [2] expected number for ID : 2"));
-        break;
-    case 3: //max players
-        if (lua_isnumber(L, 2)) {
-            MaxPlayers = int(lua_tointeger(L, 2));
-            info(Name + Sec(" | MaxPlayers -> ") + std::to_string(MaxPlayers));
-        } else
-            SendError(L, Sec("set invalid argument [2] expected number for ID : 3"));
-        break;
-    case 4: //Map
-        if (lua_isstring(L, 2)) {
-            MapName = lua_tostring(L, 2);
-            info(Name + Sec(" | MapName -> ") + MapName);
-        } else
-            SendError(L, Sec("set invalid argument [2] expected string for ID : 4"));
-        break;
-    case 5: //Name
-        if (lua_isstring(L, 2)) {
-            ServerName = lua_tostring(L, 2);
-            info(Name + Sec(" | ServerName -> ") + ServerName);
-        } else
-            SendError(L, Sec("set invalid argument [2] expected string for ID : 5"));
-        break;
-    case 6: //Desc
-        if (lua_isstring(L, 2)) {
-            ServerDesc = lua_tostring(L, 2);
-            info(Name + Sec(" | ServerDesc -> ") + ServerDesc);
-        } else
-            SendError(L, Sec("set invalid argument [2] expected string for ID : 6"));
-        break;
-    default:
-        warn(Sec("Invalid config ID : ") + std::to_string(C));
-        break;
-    }
-
-    return 0;
-}
-extern "C" {
-int lua_Print(lua_State* L) {
-    int Arg = lua_gettop(L);
-    for (int i = 1; i <= Arg; i++) {
-        auto str = lua_tostring(L, i);
-        if (str != nullptr) {
-            ConsoleOut(str + std::string(Sec("\n")));
-        } else {
-            ConsoleOut(Sec("nil\n"));
-        }
-    }
-    return 0;
-}
-}
-
-Lua::Lua(const std::string& PluginName, const std::string& FileName, fs::file_time_type LastWrote, bool Console)
-    : luaState(luaL_newstate()) {
-    Assert(luaState);
-    if (!PluginName.empty()) {
-        SetPluginName(PluginName);
-    }
-    if (!FileName.empty()) {
-        SetFileName(FileName);
-    }
-    SetLastWrite(LastWrote);
-    _Console = Console;
-}
-
-Lua::Lua(bool Console)
-    : luaState(luaL_newstate()) {
-    _Console = Console;
-}
-
-void Lua::Execute(const std::string& Command) {
-    if (ConsoleCheck(luaState, luaL_dostring(luaState, Command.c_str()))) {
-        lua_settop(luaState, 0);
-    }
-}
-void Lua::Reload() {
-    if (CheckLua(luaState, luaL_dofile(luaState, _FileName.c_str()))) {
-        CallFunction(this, Sec("onInit"), nullptr);
-    }
-}
-std::string Lua::GetOrigin() {
-    return fs::path(GetFileName()).filename().string();
-}
-
-int CallFunction(Lua* lua, const std::string& FuncName, std::unique_ptr<LuaArg> Arg) {
-    lua_State* luaState = lua->GetState();
-    lua_getglobal(luaState, FuncName.c_str());
-    if (lua_isfunction(luaState, -1)) {
-        int Size = 0;
-        if (Arg != nullptr) {
-            Size = int(Arg->args.size());
-            Arg->PushArgs(luaState);
-        }
-        std::string Origin = lua->GetOrigin();
-        int R = lua_pcall(luaState, Size, 1, 0);
-        if (CheckLua(luaState, R)) {
-            if (lua_isnumber(luaState, -1)) {
-                return int(lua_tointeger(luaState, -1));
-            }
-        }
-    }
-    ClearStack(luaState);
-    return 0;
-}
-void Lua::SetPluginName(const std::string& Name) {
-    _PluginName = Name;
-}
-void Lua::SetFileName(const std::string& Name) {
-    _FileName = Name;
-}
-void Lua::Init() {
-    Assert(luaState);
-    luaL_openlibs(luaState);
-    lua_register(luaState, "TriggerGlobalEvent", lua_TriggerEventG);
-    lua_register(luaState, "TriggerLocalEvent", lua_TriggerEventL);
-    lua_register(luaState, "TriggerClientEvent", lua_RemoteEvent);
-    lua_register(luaState, "GetPlayerCount", lua_GetPlayerCount);
-    lua_register(luaState, "isPlayerConnected", lua_isConnected);
-    lua_register(luaState, "RegisterEvent", lua_RegisterEvent);
-    lua_register(luaState, "GetPlayerName", lua_GetPlayerName);
-    lua_register(luaState, "RemoveVehicle", lua_RemoveVehicle);
-    lua_register(luaState, "GetPlayerDiscordID", lua_GetDID);
-    lua_register(luaState, "GetPlayerVehicles", lua_GetCars);
-    lua_register(luaState, "CreateThread", lua_CreateThread);
-    lua_register(luaState, "SendChatMessage", lua_sendChat);
-    lua_register(luaState, "GetPlayers", lua_GetAllPlayers);
-    lua_register(luaState, "StopThread", lua_StopThread);
-    lua_register(luaState, "DropPlayer", lua_dropPlayer);
-    lua_register(luaState, "GetPlayerHWID", lua_HWID);
-    lua_register(luaState, "exit", lua_ServerExit);
-    lua_register(luaState, "Sleep", lua_Sleep);
-    lua_register(luaState, "print", lua_Print);
-    lua_register(luaState, "Set", lua_Set);
-    if (!_Console)
-        Reload();
-}
-
-void Lua::RegisterEvent(const std::string& Event, const std::string& FunctionName) {
-    _RegisteredEvents.insert(std::make_pair(Event, FunctionName));
-}
-void Lua::UnRegisterEvent(const std::string& Event) {
-    for (const std::pair<std::string, std::string>& a : _RegisteredEvents) {
-        if (a.first == Event) {
-            _RegisteredEvents.erase(a);
-            break;
-        }
-    }
-}
-bool Lua::IsRegistered(const std::string& Event) {
-    for (const std::pair<std::string, std::string>& a : _RegisteredEvents) {
-        if (a.first == Event)
-            return true;
-    }
-    return false;
-}
-std::string Lua::GetRegistered(const std::string& Event) const {
-    for (const std::pair<std::string, std::string>& a : _RegisteredEvents) {
-        if (a.first == Event)
-            return a.second;
-    }
-    return "";
-}
-std::string Lua::GetFileName() const {
-    return _FileName;
-}
-std::string Lua::GetPluginName() const {
-    return _PluginName;
-}
-lua_State* Lua::GetState() {
-    return luaState;
-}
-
-const lua_State* Lua::GetState() const {
-    return luaState;
-}
-
-void Lua::SetLastWrite(fs::file_time_type time) {
-    _LastWrote = time;
-}
-fs::file_time_type Lua::GetLastWrite() {
-    return _LastWrote;
-}
-
-Lua::~Lua() {
-    info("closing lua state");
-    lua_close(luaState);
-}

src/LuaAPI.cpp

@@ -0,0 +1,680 @@
+#include "LuaAPI.h"
+#include "Client.h"
+#include "Common.h"
+#include "CustomAssert.h"
+#include "TLuaEngine.h"
+
+#include <nlohmann/json.hpp>
+
+#define SOL_ALL_SAFETIES_ON 1
+#include <sol/sol.hpp>
+
+std::string LuaAPI::LuaToString(const sol::object Value, size_t Indent, bool QuoteStrings) {
+    if (Indent > 80) {
+        return "[[possible recursion, refusing to keep printing]]";
+    }
+    switch (Value.get_type()) {
+    case sol::type::userdata: {
+        std::stringstream ss;
+        ss << "[[userdata: " << Value.as<sol::userdata>().pointer() << "]]";
+        return ss.str();
+    }
+    case sol::type::thread: {
+        std::stringstream ss;
+        ss << "[[thread: " << Value.as<sol::thread>().pointer() << "]] {"
+           << "\n";
+        for (size_t i = 0; i < Indent; ++i) {
+            ss << "\t";
+        }
+        ss << "status: " << std::to_string(int(Value.as<sol::thread>().status())) << "\n}";
+        return ss.str();
+    }
+    case sol::type::lightuserdata: {
+        std::stringstream ss;
+        ss << "[[lightuserdata: " << Value.as<sol::lightuserdata>().pointer() << "]]";
+        return ss.str();
+    }
+    case sol::type::string:
+        if (QuoteStrings) {
+            return "\"" + Value.as<std::string>() + "\"";
+        } else {
+            return Value.as<std::string>();
+        }
+    case sol::type::number: {
+        std::stringstream ss;
+        ss << Value.as<float>();
+        return ss.str();
+    }
+    case sol::type::lua_nil:
+    case sol::type::none:
+        return "<nil>";
+    case sol::type::boolean:
+        return Value.as<bool>() ? "true" : "false";
+    case sol::type::table: {
+        std::stringstream Result;
+        auto Table = Value.as<sol::table>();
+        Result << "[[table: " << Table.pointer() << "]]: {";
+        if (!Table.empty()) {
+            for (const auto& Entry : Table) {
+                Result << "\n";
+                for (size_t i = 0; i < Indent; ++i) {
+                    Result << "\t";
+                }
+                Result << LuaToString(Entry.first, Indent + 1) << ": " << LuaToString(Entry.second, Indent + 1, true) << ",";
+            }
+            Result << "\n";
+        }
+        for (size_t i = 0; i < Indent - 1; ++i) {
+            Result << "\t";
+        }
+        Result << "}";
+        return Result.str();
+    }
+    case sol::type::function: {
+        std::stringstream ss;
+        ss << "[[function: " << Value.as<sol::function>().pointer() << "]]";
+        return ss.str();
+    }
+    case sol::type::poly:
+        return "<poly>";
+    default:
+        return "<unprintable type>";
+    }
+}
+
+std::string LuaAPI::MP::GetOSName() {
+#if WIN32
+    return "Windows";
+#elif __linux
+    return "Linux";
+#else
+    return "Other";
+#endif
+}
+
+std::tuple<int, int, int> LuaAPI::MP::GetServerVersion() {
+    return { Application::ServerVersion().major, Application::ServerVersion().minor, Application::ServerVersion().patch };
+}
+
+void LuaAPI::Print(sol::variadic_args Args) {
+    std::string ToPrint = "";
+    for (const auto& Arg : Args) {
+        ToPrint += LuaToString(static_cast<const sol::object>(Arg));
+        ToPrint += "\t";
+    }
+    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 std::pair<bool, std::string> InternalTriggerClientEvent(int PlayerID, const std::string& EventName, const std::string& Data) {
+    std::string Packet = "E:" + EventName + ":" + Data;
+    if (PlayerID == -1) {
+        LuaAPI::MP::Engine->Network().SendToAll(nullptr, StringToVector(Packet), true, true);
+        return { true, "" };
+    } else {
+        auto MaybeClient = GetClient(LuaAPI::MP::Engine->Server(), PlayerID);
+        if (!MaybeClient || MaybeClient.value().expired()) {
+            beammp_lua_errorf("TriggerClientEvent invalid Player ID '{}'", PlayerID);
+            return { false, "Invalid Player ID" };
+        }
+        auto c = MaybeClient.value().lock();
+        if (!LuaAPI::MP::Engine->Network().Respond(*c, StringToVector(Packet), true)) {
+            beammp_lua_errorf("Respond failed, dropping client {}", PlayerID);
+            LuaAPI::MP::Engine->Network().ClientKick(*c, "Disconnected after failing to receive packets");
+            return { false, "Respond failed, dropping client" };
+        }
+        return { true, "" };
+    }
+}
+
+std::pair<bool, std::string> LuaAPI::MP::TriggerClientEvent(int PlayerID, const std::string& EventName, const sol::object& DataObj) {
+    std::string Data = DataObj.as<std::string>();
+    return InternalTriggerClientEvent(PlayerID, EventName, Data);
+}
+
+std::pair<bool, std::string> LuaAPI::MP::DropPlayer(int ID, std::optional<std::string> MaybeReason) {
+    auto MaybeClient = GetClient(Engine->Server(), ID);
+    if (!MaybeClient || MaybeClient.value().expired()) {
+        beammp_lua_errorf("Tried to drop client with id {}, who doesn't exist", ID);
+        return { false, "Player does not exist" };
+    }
+    auto c = MaybeClient.value().lock();
+    LuaAPI::MP::Engine->Network().ClientKick(*c, MaybeReason.value_or("No reason"));
+    return { true, "" };
+}
+
+std::pair<bool, std::string> LuaAPI::MP::SendChatMessage(int ID, const std::string& Message) {
+    std::pair<bool, std::string> Result;
+    std::string Packet = "C:Server: " + Message;
+    if (ID == -1) {
+        LogChatMessage("<Server> (to everyone) ", -1, Message);
+        Engine->Network().SendToAll(nullptr, StringToVector(Packet), true, true);
+        Result.first = true;
+    } else {
+        auto MaybeClient = GetClient(Engine->Server(), ID);
+        if (MaybeClient && !MaybeClient.value().expired()) {
+            auto c = MaybeClient.value().lock();
+            if (!c->IsSynced()) {
+                Result.first = false;
+                Result.second = "Player still syncing data";
+                return Result;
+            }
+            LogChatMessage("<Server> (to \"" + c->GetName() + "\")", -1, Message);
+            if (!Engine->Network().Respond(*c, StringToVector(Packet), true)) {
+                beammp_errorf("Failed to send chat message back to sender (id {}) - did the sender disconnect?", ID);
+                // TODO: should we return an error here?
+            }
+            Result.first = true;
+        } else {
+            beammp_lua_error("SendChatMessage invalid argument [1] invalid ID");
+            Result.first = false;
+            Result.second = "Invalid Player ID";
+        }
+        return Result;
+    }
+    return Result;
+}
+
+std::pair<bool, std::string> LuaAPI::MP::RemoveVehicle(int PID, int VID) {
+    std::pair<bool, std::string> Result;
+    auto MaybeClient = GetClient(Engine->Server(), PID);
+    if (!MaybeClient || MaybeClient.value().expired()) {
+        beammp_lua_error("RemoveVehicle invalid Player ID");
+        Result.first = false;
+        Result.second = "Invalid Player ID";
+        return Result;
+    }
+    auto c = MaybeClient.value().lock();
+    if (!c->GetCarData(VID).empty()) {
+        std::string Destroy = "Od:" + std::to_string(PID) + "-" + std::to_string(VID);
+        Engine->Network().SendToAll(nullptr, StringToVector(Destroy), true, true);
+        c->DeleteCar(VID);
+        Result.first = true;
+    } else {
+        Result.first = false;
+        Result.second = "Vehicle does not exist";
+    }
+    return Result;
+}
+
+void LuaAPI::MP::Set(int ConfigID, sol::object NewValue) {
+    switch (ConfigID) {
+    case 0: // debug
+        if (NewValue.is<bool>()) {
+            Application::Settings.DebugModeEnabled = NewValue.as<bool>();
+            beammp_info(std::string("Set `Debug` to ") + (Application::Settings.DebugModeEnabled ? "true" : "false"));
+        } 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 {
+            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 {
+            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 {
+            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 {
+            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 {
+            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 {
+            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.");
+        break;
+    }
+}
+
+void LuaAPI::MP::Sleep(size_t Ms) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(Ms));
+}
+
+bool LuaAPI::MP::IsPlayerConnected(int ID) {
+    auto MaybeClient = GetClient(Engine->Server(), ID);
+    if (MaybeClient && !MaybeClient.value().expired()) {
+        return MaybeClient.value().lock()->IsConnected();
+    } else {
+        return false;
+    }
+}
+
+bool LuaAPI::MP::IsPlayerGuest(int ID) {
+    auto MaybeClient = GetClient(Engine->Server(), ID);
+    if (MaybeClient && !MaybeClient.value().expired()) {
+        return MaybeClient.value().lock()->IsGuest();
+    } else {
+        return false;
+    }
+}
+
+void LuaAPI::MP::PrintRaw(sol::variadic_args Args) {
+    std::string ToPrint = "";
+    for (const auto& Arg : 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) {
+    beammp_lua_error("PANIC: " + sol::stack::get<std::string>(State, 1));
+    return 0;
+}
+
+template <typename FnT, typename... ArgsT>
+static std::pair<bool, std::string> FSWrapper(FnT Fn, ArgsT&&... Args) {
+    std::error_code errc;
+    std::pair<bool, std::string> Result;
+    Fn(std::forward<ArgsT>(Args)..., errc);
+    Result.first = errc == std::error_code {};
+    if (!Result.first) {
+        Result.second = errc.message();
+    }
+    return Result;
+}
+
+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(Path, errc);
+    Result.first = errc == std::error_code {};
+    if (!Result.first) {
+        Result.second = errc.message();
+    }
+    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;
+    fs::remove(fs::relative(Path), errc);
+    Result.first = errc == std::error_code {};
+    if (!Result.first) {
+        Result.second = errc.message();
+    }
+    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(Path, NewPath, errc);
+    Result.first = errc == std::error_code {};
+    if (!Result.first) {
+        Result.second = errc.message();
+    }
+    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(Path, NewPath, fs::copy_options::recursive, errc);
+    Result.first = errc == std::error_code {};
+    if (!Result.first) {
+        Result.second = errc.message();
+    }
+    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(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) {
+        auto Obj = Args[i];
+        if (!Obj.is<std::string>()) {
+            beammp_lua_error("FS.Concat called with non-string argument");
+            return "";
+        }
+        Path += Obj.as<std::string>();
+        if (i < Args.size() - 1 && !Path.empty()) {
+            Path += fs::path::preferred_separator;
+        }
+    }
+    auto Result = Path.lexically_normal().string();
+    return Result;
+}
+
+static void JsonEncodeRecursive(nlohmann::json& json, const sol::object& left, const sol::object& right, bool is_array, size_t depth = 0) {
+    if (depth > 100) {
+        beammp_lua_error("json serialize will not go deeper than 100 nested tables, internal references assumed, aborted this path");
+        return;
+    }
+    std::string key {};
+    switch (left.get_type()) {
+    case sol::type::lua_nil:
+    case sol::type::none:
+    case sol::type::poly:
+    case sol::type::boolean:
+    case sol::type::lightuserdata:
+    case sol::type::userdata:
+    case sol::type::thread:
+    case sol::type::function:
+    case sol::type::table:
+        beammp_lua_error("JsonEncode: left side of table field is unexpected type");
+        return;
+    case sol::type::string:
+        key = left.as<std::string>();
+        break;
+    case sol::type::number:
+        key = std::to_string(left.as<double>());
+        break;
+    default:
+        beammp_assert_not_reachable();
+    }
+    nlohmann::json value;
+    switch (right.get_type()) {
+    case sol::type::lua_nil:
+    case sol::type::none:
+        return;
+    case sol::type::poly:
+        beammp_lua_warn("unsure what to do with poly type in JsonEncode, ignoring");
+        return;
+    case sol::type::boolean:
+        value = right.as<bool>();
+        break;
+    case sol::type::lightuserdata:
+        beammp_lua_warn("unsure what to do with lightuserdata in JsonEncode, ignoring");
+        return;
+    case sol::type::userdata:
+        beammp_lua_warn("unsure what to do with userdata in JsonEncode, ignoring");
+        return;
+    case sol::type::thread:
+        beammp_lua_warn("unsure what to do with thread in JsonEncode, ignoring");
+        return;
+    case sol::type::string:
+        value = right.as<std::string>();
+        break;
+    case sol::type::number:
+        value = right.as<double>();
+        break;
+    case sol::type::function:
+        beammp_lua_warn("unsure what to do with function in JsonEncode, ignoring");
+        return;
+    case sol::type::table: {
+        bool local_is_array = true;
+        for (const auto& pair : right.as<sol::table>()) {
+            if (pair.first.get_type() != sol::type::number) {
+                local_is_array = false;
+            }
+        }
+        for (const auto& pair : right.as<sol::table>()) {
+            JsonEncodeRecursive(value, pair.first, pair.second, local_is_array, depth + 1);
+        }
+        break;
+    }
+    default:
+        beammp_assert_not_reachable();
+    }
+    if (is_array) {
+        json.push_back(value);
+    } else {
+        json[key] = value;
+    }
+}
+
+std::string LuaAPI::MP::JsonEncode(const sol::table& object) {
+    nlohmann::json json;
+    // table
+    bool is_array = true;
+    for (const auto& pair : object.as<sol::table>()) {
+        if (pair.first.get_type() != sol::type::number) {
+            is_array = false;
+        }
+    }
+    for (const auto& entry : object) {
+        JsonEncodeRecursive(json, entry.first, entry.second, is_array);
+    }
+    return json.dump();
+}
+
+std::string LuaAPI::MP::JsonDiff(const std::string& a, const std::string& b) {
+    if (!nlohmann::json::accept(a)) {
+        beammp_lua_error("JsonDiff first argument is not valid json: `" + a + "`");
+        return "";
+    }
+    if (!nlohmann::json::accept(b)) {
+        beammp_lua_error("JsonDiff second argument is not valid json: `" + b + "`");
+        return "";
+    }
+    auto a_json = nlohmann::json::parse(a);
+    auto b_json = nlohmann::json::parse(b);
+    return nlohmann::json::diff(a_json, b_json).dump();
+}
+
+std::string LuaAPI::MP::JsonDiffApply(const std::string& data, const std::string& patch) {
+    if (!nlohmann::json::accept(data)) {
+        beammp_lua_error("JsonDiffApply first argument is not valid json: `" + data + "`");
+        return "";
+    }
+    if (!nlohmann::json::accept(patch)) {
+        beammp_lua_error("JsonDiffApply second argument is not valid json: `" + patch + "`");
+        return "";
+    }
+    auto a_json = nlohmann::json::parse(data);
+    auto b_json = nlohmann::json::parse(patch);
+    a_json.patch(b_json);
+    return a_json.dump();
+}
+
+std::string LuaAPI::MP::JsonPrettify(const std::string& json) {
+    if (!nlohmann::json::accept(json)) {
+        beammp_lua_error("JsonPrettify argument is not valid json: `" + json + "`");
+        return "";
+    }
+    return nlohmann::json::parse(json).dump(4);
+}
+
+std::string LuaAPI::MP::JsonMinify(const std::string& json) {
+    if (!nlohmann::json::accept(json)) {
+        beammp_lua_error("JsonMinify argument is not valid json: `" + json + "`");
+        return "";
+    }
+    return nlohmann::json::parse(json).dump(-1);
+}
+
+std::string LuaAPI::MP::JsonFlatten(const std::string& json) {
+    if (!nlohmann::json::accept(json)) {
+        beammp_lua_error("JsonFlatten argument is not valid json: `" + json + "`");
+        return "";
+    }
+    return nlohmann::json::parse(json).flatten().dump(-1);
+}
+
+std::string LuaAPI::MP::JsonUnflatten(const std::string& json) {
+    if (!nlohmann::json::accept(json)) {
+        beammp_lua_error("JsonUnflatten argument is not valid json: `" + json + "`");
+        return "";
+    }
+    return nlohmann::json::parse(json).unflatten().dump(-1);
+}
+
+std::pair<bool, std::string> LuaAPI::MP::TriggerClientEventJson(int PlayerID, const std::string& EventName, const sol::table& Data) {
+    return InternalTriggerClientEvent(PlayerID, EventName, JsonEncode(Data));
+}

src/Network/Auth.cpp

@@ -1,318 +0,0 @@
-///
-/// Created by Anonymous275 on 7/31/2020
-///
-#include "Curl/Http.h"
-#include "Logger.h"
-#include "Network.h"
-#include "Security/Enc.h"
-#include "Settings.h"
-#include "UnixCompat.h"
-#include <algorithm>
-#include <atomic>
-#include <cstring>
-#include <sstream>
-#include <string>
-#include <thread>
-
-bool Send(SOCKET TCPSock, std::string Data) {
-#ifdef WIN32
-    int BytesSent;
-    int len = static_cast<int>(Data.size());
-#else
-    int64_t BytesSent;
-    size_t len = Data.size();
-#endif // WIN32
-    BytesSent = send(TCPSock, Data.c_str(), len, 0);
-    Data.clear();
-    if (BytesSent <= 0) {
-#ifndef WIN32
-        error(__func__ + std::string(" ") + strerror(errno));
-#else
-        error(__func__ + std::string(" ") + std::to_string(WSAGetLastError()));
-#endif // WIN32
-        return false;
-    }
-    return true;
-}
-std::string Rcv(SOCKET TCPSock) {
-    uint32_t RealSize;
-#ifdef WIN32
-    int64_t BytesRcv = recv(TCPSock, reinterpret_cast<char*>(&RealSize), sizeof(RealSize), 0);
-#else
-    int64_t BytesRcv = recv(TCPSock, reinterpret_cast<void*>(&RealSize), sizeof(RealSize), 0);
-#endif
-    if (BytesRcv != sizeof(RealSize)) {
-        error(std::string(Sec("invalid packet: expected 4, got ")) + std::to_string(BytesRcv));
-        return "";
-    }
-    // RealSize is big-endian, so we convert it to host endianness
-    RealSize = ntohl(RealSize);
-    debug(std::string("got ") + std::to_string(RealSize) + " as size");
-    if (RealSize > 7000) {
-        error(Sec("Larger than allowed TCP packet received"));
-        return "";
-    }
-    char buf[7000];
-    std::fill_n(buf, 7000, 0);
-    BytesRcv = recv(TCPSock, buf, RealSize, 0);
-    if (BytesRcv != RealSize) {
-        debug("expected " + std::to_string(RealSize) + " bytes, got " + std::to_string(BytesRcv) + " instead");
-    }
-    if (BytesRcv <= 0)
-        return "";
-    return std::string(buf);
-}
-std::string GetRole(const std::string& DID) {
-    if (!DID.empty()) {
-        std::string a = HttpRequest(Sec("https://beammp.com/entitlement?did=") + DID, 443);
-        std::string b = HttpRequest(Sec("https://backup1.beammp.com/entitlement?did=") + DID, 443);
-        if (!a.empty() || !b.empty()) {
-            if (a != b)
-                a = b;
-            auto pos = a.find('"');
-            if (pos != std::string::npos) {
-                return a.substr(pos + 1, a.find('"', pos + 1) - 2);
-            } else if (a == "[]")
-                return Sec("Member");
-        }
-    }
-    return "";
-}
-void Check(SOCKET TCPSock, std::shared_ptr<std::atomic_bool> ok) {
-    DebugPrintTID();
-    size_t accum = 0;
-    while (!*ok) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        accum += 100;
-        if (accum >= 5000) {
-            error(Sec("Identification timed out (Check accum)"));
-            CloseSocketProper(TCPSock);
-            return;
-        }
-    }
-}
-int Max() {
-    int M = MaxPlayers;
-    for (auto& c : CI->Clients) {
-        if (c != nullptr) {
-            if (c->GetRole() == Sec("MDEV"))
-                M++;
-        }
-    }
-    return M;
-}
-void CreateClient(SOCKET TCPSock, const std::string& Name, const std::string& DID, const std::string& Role) {
-    auto* c = new Client;
-    c->SetTCPSock(TCPSock);
-    c->SetName(Name);
-    c->SetRole(Role);
-    c->SetDID(DID);
-    Client& Client = *c;
-    CI->AddClient(std::move(c));
-    InitClient(&Client);
-}
-std::pair<int, int> Parse(const std::string& msg) {
-    std::stringstream ss(msg);
-    std::string t;
-    std::pair<int, int> a = { 0, 0 }; //N then E
-    while (std::getline(ss, t, 'g')) {
-        if (t.find_first_not_of(Sec("0123456789abcdef")) != std::string::npos)
-            return a;
-        if (a.first == 0) {
-            a.first = std::stoi(t, nullptr, 16);
-        } else if (a.second == 0) {
-            a.second = std::stoi(t, nullptr, 16);
-        } else
-            return a;
-    }
-    return { 0, 0 };
-}
-std::string GenerateM(RSA* key) {
-    std::stringstream stream;
-    stream << std::hex << key->n << "g" << key->e << "g" << RSA_E(Sec("IDC"), key);
-    return stream.str();
-}
-
-void Identification(SOCKET TCPSock, RSA* Skey) {
-    DebugPrintTID();
-    Assert(Skey);
-    std::shared_ptr<std::atomic_bool> ok = std::make_shared<std::atomic_bool>(false);
-    std::thread Timeout(Check, TCPSock, ok);
-    Timeout.detach();
-    std::string Name, DID, Role;
-    if (!Send(TCPSock, GenerateM(Skey))) {
-        error("died on " + std::string(__func__) + ":" + std::to_string(__LINE__));
-        CloseSocketProper(TCPSock);
-        return;
-    }
-    std::string msg = Rcv(TCPSock);
-    auto Keys = Parse(msg);
-    if (!Send(TCPSock, RSA_E("HC", Keys.second, Keys.first))) {
-        error("died on " + std::string(__func__) + ":" + std::to_string(__LINE__));
-        CloseSocketProper(TCPSock);
-        return;
-    }
-
-    std::string Res = Rcv(TCPSock);
-    std::string Ver = Rcv(TCPSock);
-    *ok = true;
-    Ver = RSA_D(Ver, Skey);
-    if (Ver.size() > 3 && Ver.substr(0, 2) == Sec("VC")) {
-        Ver = Ver.substr(2);
-        if (Ver.length() > 4 || Ver != GetCVer()) {
-            error("died on " + std::string(__func__) + ":" + std::to_string(__LINE__));
-            CloseSocketProper(TCPSock);
-            return;
-        }
-    } else {
-        error("died on " + std::string(__func__) + ":" + std::to_string(__LINE__));
-        CloseSocketProper(TCPSock);
-        return;
-    }
-    Res = RSA_D(Res, Skey);
-    if (Res.size() < 3 || Res.substr(0, 2) != Sec("NR")) {
-        error("died on " + std::string(__func__) + ":" + std::to_string(__LINE__));
-        CloseSocketProper(TCPSock);
-        return;
-    }
-    if (Res.find(':') == std::string::npos) {
-        error("died on " + std::string(__func__) + ":" + std::to_string(__LINE__));
-        CloseSocketProper(TCPSock);
-        return;
-    }
-    Name = Res.substr(2, Res.find(':') - 2);
-    DID = Res.substr(Res.find(':') + 1);
-    Role = GetRole(DID);
-    if (Role.empty() || Role.find(Sec("Error")) != std::string::npos) {
-        error("died on " + std::string(__func__) + ":" + std::to_string(__LINE__));
-        CloseSocketProper(TCPSock);
-        return;
-    }
-    // DebugPrintTIDInternal(std::string("Client(") + Name + ")");
-    debug(Sec("Name -> ") + Name + Sec(", Role -> ") + Role + Sec(", ID -> ") + DID);
-    for (auto& c : CI->Clients) {
-        if (c != nullptr) {
-            if (c->GetDID() == DID) {
-                error("died on " + std::string(__func__) + ":" + std::to_string(__LINE__));
-                CloseSocketProper(c->GetTCPSock());
-                c->SetStatus(-2);
-                break;
-            }
-        }
-    }
-    if (Role == Sec("MDEV") || CI->Size() < Max()) {
-        debug("Identification success");
-        CreateClient(TCPSock, Name, DID, Role);
-    } else {
-        error("died on " + std::string(__func__) + ":" + std::to_string(__LINE__));
-        CloseSocketProper(TCPSock);
-    }
-}
-void Identify(SOCKET TCPSock) {
-    RSA* Skey = GenKey();
-    // this disgusting ifdef stuff is needed because for some
-    // reason MSVC defines __try and __except and libg++ defines
-    // __try and __catch so its all a big mess if we leave this in or undefine
-    // the macros
-    /*#ifdef WIN32
-    __try{
-#endif // WIN32*/
-    Identification(TCPSock, Skey);
-    /*#ifdef WIN32
-    }__except(1){
-        if(TCPSock != -1){
-            error("died on " + std::string(__func__) + ":" + std::to_string(__LINE__));
-            CloseSocketProper(TCPSock);
-        }
-    }
-#endif // WIN32*/
-
-    delete Skey;
-}
-
-void TCPServerMain() {
-    DebugPrintTID();
-#ifdef WIN32
-    WSADATA wsaData;
-    if (WSAStartup(514, &wsaData)) {
-        error(Sec("Can't start Winsock!"));
-        return;
-    }
-    SOCKET client, Listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    sockaddr_in addr {};
-    addr.sin_addr.S_un.S_addr = ADDR_ANY;
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(Port);
-    if (bind(Listener, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
-        error(Sec("Can't bind socket! ") + std::to_string(WSAGetLastError()));
-        std::this_thread::sleep_for(std::chrono::seconds(5));
-        _Exit(-1);
-    }
-    if (Listener == -1) {
-        error(Sec("Invalid listening socket"));
-        return;
-    }
-    if (listen(Listener, SOMAXCONN)) {
-        error(Sec("listener failed ") + std::to_string(GetLastError()));
-        return;
-    }
-    info(Sec("Vehicle event network online"));
-    do {
-        try {
-            client = accept(Listener, nullptr, nullptr);
-            if (client == -1) {
-                warn(Sec("Got an invalid client socket on connect! Skipping..."));
-                continue;
-            }
-            std::thread ID(Identify, client);
-            ID.detach();
-        } catch (const std::exception& e) {
-            error(Sec("fatal: ") + std::string(e.what()));
-        }
-    } while (client);
-
-    CloseSocketProper(client);
-    WSACleanup();
-#else // unix
-    // wondering why we need slightly different implementations of this?
-    // ask ms.
-    SOCKET client = -1, Listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    int optval = 1;
-    setsockopt(Listener, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval));
-    // TODO: check optval or return value idk
-    sockaddr_in addr {};
-    addr.sin_addr.s_addr = INADDR_ANY;
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(uint16_t(Port));
-    if (bind(Listener, (sockaddr*)&addr, sizeof(addr)) != 0) {
-        error(Sec("Can't bind socket! ") + std::string(strerror(errno)));
-        std::this_thread::sleep_for(std::chrono::seconds(5));
-        _Exit(-1);
-    }
-    if (Listener == -1) {
-        error(Sec("Invalid listening socket"));
-        return;
-    }
-    if (listen(Listener, SOMAXCONN)) {
-        error(Sec("listener failed ") + std::string(strerror(errno)));
-        return;
-    }
-    info(Sec("Vehicle event network online"));
-    do {
-        try {
-            client = accept(Listener, nullptr, nullptr);
-            if (client == -1) {
-                warn(Sec("Got an invalid client socket on connect! Skipping..."));
-                continue;
-            }
-            std::thread ID(Identify, client);
-            ID.detach();
-        } catch (const std::exception& e) {
-            error(Sec("fatal: ") + std::string(e.what()));
-        }
-    } while (client);
-
-    debug("all ok, arrived at " + std::string(__func__) + ":" + std::to_string(__LINE__));
-    CloseSocketProper(client);
-#endif // WIN32
-}

src/Network/Client.cpp

@@ -1,105 +0,0 @@
-///
-/// Created by Anonymous275 on 5/8/2020
-///
-#include "Client.hpp"
-
-std::string Client::GetName() {
-    return Name;
-}
-void Client::SetName(const std::string& name) {
-    Name = name;
-}
-void Client::SetDID(const std::string& did) {
-    DID = did;
-}
-std::string Client::GetDID() {
-    return DID;
-}
-void Client::SetRole(const std::string& role) {
-    Role = role;
-}
-std::string Client::GetRole() {
-    return Role;
-}
-int Client::GetID() {
-    return ID;
-}
-void Client::SetID(int id) {
-    ID = id;
-}
-void Client::SetStatus(int state) {
-    Status = state;
-}
-int Client::GetStatus() {
-    return Status;
-}
-void Client::SetUDPAddr(sockaddr_in Addr) {
-    UDPADDR = Addr;
-}
-sockaddr_in Client::GetUDPAddr() {
-    return UDPADDR;
-}
-void Client::SetTCPSock(SOCKET CSock) {
-    TCPSOCK = CSock;
-}
-SOCKET Client::GetTCPSock() {
-    return TCPSOCK;
-}
-void Client::DeleteCar(int ident) {
-    for (auto& v : VehicleData) {
-        if (v != nullptr && v->ID == ident) {
-            VehicleData.erase(v);
-            break;
-        }
-    }
-}
-void Client::ClearCars() {
-    VehicleData.clear();
-}
-int Client::GetOpenCarID() {
-    int OpenID = 0;
-    bool found;
-    do {
-        found = true;
-        for (auto& v : VehicleData) {
-            if (v != nullptr && v->ID == OpenID) {
-                OpenID++;
-                found = false;
-            }
-        }
-    } while (!found);
-    return OpenID;
-}
-void Client::AddNewCar(int ident, const std::string& Data) {
-    VehicleData.insert(std::unique_ptr<VData>(new VData { ident, Data }));
-}
-
-std::set<std::unique_ptr<VData>>& Client::GetAllCars() {
-    return VehicleData;
-}
-
-const std::set<std::unique_ptr<VData>>& Client::GetAllCars() const {
-    return VehicleData;
-}
-
-std::string Client::GetCarData(int ident) {
-    for (auto& v : VehicleData) {
-        if (v != nullptr && v->ID == ident) {
-            return v->Data;
-        }
-    }
-    DeleteCar(ident);
-    return "";
-}
-void Client::SetCarData(int ident, const std::string& Data) {
-    for (auto& v : VehicleData) {
-        if (v != nullptr && v->ID == ident) {
-            v->Data = Data;
-            return;
-        }
-    }
-    DeleteCar(ident);
-}
-int Client::GetCarCount() {
-    return int(VehicleData.size());
-}

src/Network/GParser.cpp

@@ -1,248 +0,0 @@
-///
-/// Created by Anonymous275 on 8/1/2020
-///
-#include "Client.hpp"
-#include "Logger.h"
-#include "Lua/LuaSystem.hpp"
-#include "Network.h"
-#include "Security/Enc.h"
-#include "Settings.h"
-#include "UnixCompat.h"
-#include <memory>
-#include <sstream>
-
-int FC(const std::string& s, const std::string& p, int n) {
-    auto i = s.find(p);
-    int j;
-    for (j = 1; j < n && i != std::string::npos; ++j) {
-        i = s.find(p, i + 1);
-    }
-    if (j == n)
-        return int(i);
-    else
-        return -1;
-}
-void Apply(Client* c, int VID, const std::string& pckt) {
-    Assert(c);
-    std::string Packet = pckt;
-    std::string VD = c->GetCarData(VID);
-    Packet = Packet.substr(FC(Packet, ",", 2) + 1);
-    Packet = VD.substr(0, FC(VD, ",", 2) + 1) + Packet.substr(0, Packet.find_last_of('"') + 1) + VD.substr(FC(VD, ",\"", 7));
-    c->SetCarData(VID, Packet);
-}
-
-void VehicleParser(Client* c, const std::string& Pckt) {
-    Assert(c);
-    if (c == nullptr || Pckt.length() < 4)
-        return;
-    std::string Packet = Pckt;
-    char Code = Packet.at(1);
-    int PID = -1;
-    int VID = -1;
-    std::string Data = Packet.substr(3), pid, vid;
-    switch (Code) { //Spawned Destroyed Switched/Moved NotFound Reset
-    case 's':
-#ifdef DEBUG
-        debug(std::string(Sec("got 'Os' packet: '")) + Packet + Sec("' (") + std::to_string(Packet.size()) + Sec(")"));
-#endif
-        if (Data.at(0) == '0') {
-            int CarID = c->GetOpenCarID();
-            debug(c->GetName() + Sec(" created a car with ID ") + std::to_string(CarID));
-            Packet = "Os:" + c->GetRole() + ":" + c->GetName() + ":" + std::to_string(c->GetID()) + "-" + std::to_string(CarID) + Packet.substr(4);
-            if (c->GetCarCount() >= MaxCars || TriggerLuaEvent(Sec("onVehicleSpawn"), false, nullptr, std::make_unique<LuaArg>(LuaArg { { c->GetID(), CarID, Packet.substr(3) } }), true)) {
-                Respond(c, Packet, true);
-                std::string Destroy = "Od:" + std::to_string(c->GetID()) + "-" + std::to_string(CarID);
-                Respond(c, Destroy, true);
-                debug(c->GetName() + Sec(" (force : car limit/lua) removed ID ") + std::to_string(CarID));
-            } else {
-                c->AddNewCar(CarID, Packet);
-                SendToAll(nullptr, Packet, true, true);
-            }
-        }
-        return;
-    case 'c':
-#ifdef DEBUG
-        debug(std::string(Sec("got 'Oc' packet: '")) + Packet + Sec("' (") + std::to_string(Packet.size()) + Sec(")"));
-#endif
-        pid = Data.substr(0, Data.find('-'));
-        vid = Data.substr(Data.find('-') + 1, Data.find(':', 1) - Data.find('-') - 1);
-        if (pid.find_first_not_of("0123456789") == std::string::npos && vid.find_first_not_of("0123456789") == std::string::npos) {
-            PID = stoi(pid);
-            VID = stoi(vid);
-        }
-        if (PID != -1 && VID != -1 && PID == c->GetID()) {
-            if (!TriggerLuaEvent(Sec("onVehicleEdited"), false, nullptr,
-                    std::unique_ptr<LuaArg>(new LuaArg { { c->GetID(), VID, Packet.substr(3) } }),
-                    true)) {
-                SendToAll(c, Packet, false, true);
-                Apply(c, VID, Packet);
-            } else {
-                std::string Destroy = "Od:" + std::to_string(c->GetID()) + "-" + std::to_string(VID);
-                Respond(c, Destroy, true);
-                c->DeleteCar(VID);
-            }
-        }
-        return;
-    case 'd':
-#ifdef DEBUG
-        debug(std::string(Sec("got 'Od' packet: '")) + Packet + Sec("' (") + std::to_string(Packet.size()) + Sec(")"));
-#endif
-        pid = Data.substr(0, Data.find('-'));
-        vid = Data.substr(Data.find('-') + 1);
-        if (pid.find_first_not_of("0123456789") == std::string::npos && vid.find_first_not_of("0123456789") == std::string::npos) {
-            PID = stoi(pid);
-            VID = stoi(vid);
-        }
-        if (PID != -1 && VID != -1 && PID == c->GetID()) {
-            SendToAll(nullptr, Packet, true, true);
-            TriggerLuaEvent(Sec("onVehicleDeleted"), false, nullptr,
-                std::unique_ptr<LuaArg>(new LuaArg { { c->GetID(), VID } }), false);
-            c->DeleteCar(VID);
-            debug(c->GetName() + Sec(" deleted car with ID ") + std::to_string(VID));
-        }
-        return;
-    case 'r':
-#ifdef DEBUG
-        debug(std::string(Sec("got 'Or' packet: '")) + Packet + Sec("' (") + std::to_string(Packet.size()) + Sec(")"));
-#endif
-        SendToAll(c, Packet, false, true);
-        return;
-    default:
-#ifdef DEBUG
-        warn(std::string(Sec("possibly not implemented: '") + Packet + Sec("' (") + std::to_string(Packet.size()) + Sec(")")));
-#endif // DEBUG
-        return;
-    }
-}
-void SyncClient(Client* c) {
-    Assert(c);
-    if (c->isSynced)
-        return;
-    c->isSynced = true;
-    std::this_thread::sleep_for(std::chrono::seconds(1));
-    Respond(c, Sec("Sn") + c->GetName(), true);
-    SendToAll(c, Sec("JWelcome ") + c->GetName() + "!", false, true);
-    TriggerLuaEvent(Sec("onPlayerJoin"), false, nullptr, std::unique_ptr<LuaArg>(new LuaArg { { c->GetID() } }), false);
-    for (auto& client : CI->Clients) {
-        if (client != nullptr) {
-            if (client.get() != c) {
-                for (auto& v : client->GetAllCars()) {
-                    if (v != nullptr) {
-                        if(c->GetStatus() < 0)return;
-                        Respond(c, v->Data, true);
-                        std::this_thread::sleep_for(std::chrono::seconds(2));
-                    }
-                }
-            }
-        }
-    }
-    info(c->GetName() + Sec(" is now synced!"));
-}
-void ParseVeh(Client* c, const std::string& Packet) {
-    Assert(c);
-#ifdef WIN32
-    __try {
-        VehicleParser(c, Packet);
-    } __except (Handle(GetExceptionInformation(), Sec("Vehicle Handler"))) { }
-#else // unix
-    VehicleParser(c, Packet);
-#endif // WIN32
-}
-
-void HandleEvent(Client* c, const std::string& Data) {
-    Assert(c);
-    std::stringstream ss(Data);
-    std::string t, Name;
-    int a = 0;
-    while (std::getline(ss, t, ':')) {
-        switch (a) {
-        case 1:
-            Name = t;
-            break;
-        case 2:
-            TriggerLuaEvent(Name, false, nullptr, std::unique_ptr<LuaArg>(new LuaArg { { c->GetID(), t } }), false);
-            break;
-        default:
-            break;
-        }
-        if (a == 2)
-            break;
-        a++;
-    }
-}
-
-void GlobalParser(Client* c, const std::string& Pack) {
-    Assert(c);
-    if (Pack.empty() || c == nullptr)
-        return;
-    std::string Packet = Pack.substr(0, strlen(Pack.c_str()));
-    std::string pct;
-    char Code = Packet.at(0);
-
-    //V to Z
-    if (Code <= 90 && Code >= 86) {
-        PPS++;
-        SendToAll(c, Packet, false, false);
-        return;
-    }
-    switch (Code) {
-    case 'P': // initial connection
-#ifdef DEBUG
-        debug(std::string(Sec("got 'P' packet: '")) + Pack + Sec("' (") + std::to_string(Packet.size()) + Sec(")"));
-#endif
-        Respond(c, Sec("P") + std::to_string(c->GetID()), true);
-        SyncClient(c);
-        return;
-    case 'p':
-        Respond(c, Sec("p"), false);
-        UpdatePlayers();
-        return;
-    case 'O':
-        if (Packet.length() > 1000) {
-            debug(Sec("Received data from: ") + c->GetName() + Sec(" Size: ") + std::to_string(Packet.length()));
-        }
-        ParseVeh(c, Packet);
-        return;
-    case 'J':
-#ifdef DEBUG
-        debug(std::string(Sec("got 'J' packet: '")) + Pack + Sec("' (") + std::to_string(Packet.size()) + Sec(")"));
-#endif
-        SendToAll(c, Packet, false, true);
-        return;
-    case 'C':
-#ifdef DEBUG
-        debug(std::string(Sec("got 'C' packet: '")) + Pack + Sec("' (") + std::to_string(Packet.size()) + Sec(")"));
-#endif
-        if (Packet.length() < 4 || Packet.find(':', 3) == std::string::npos)
-            break;
-        if (TriggerLuaEvent(Sec("onChatMessage"), false, nullptr,
-                std::unique_ptr<LuaArg>(new LuaArg {
-                    { c->GetID(), c->GetName(), Packet.substr(Packet.find(':', 3) + 1) } }),
-                true))
-            break;
-        SendToAll(nullptr, Packet, true, true);
-        return;
-    case 'E':
-#ifdef DEBUG
-        debug(std::string(Sec("got 'E' packet: '")) + Pack + Sec("' (") + std::to_string(Packet.size()) + Sec(")"));
-#endif
-        HandleEvent(c, Packet);
-        return;
-    default:
-        return;
-    }
-}
-
-void GParser(Client* c, const std::string& Packet) {
-    Assert(c);
-    if (Packet.find("Zp") != std::string::npos && Packet.size() > 500) {
-        abort();
-    }
-#ifdef WIN32
-    __try {
-        GlobalParser(c, Packet);
-    } __except (Handle(GetExceptionInformation(), Sec("Global Handler"))) { }
-#else
-    GlobalParser(c, Packet);
-#endif // WIN32
-}

src/Network/Http.cpp

@@ -1,52 +0,0 @@
-///
-/// Created by Anonymous275 on 4/9/2020
-///
-
-#include "CustomAssert.h"
-#include <curl/curl.h>
-#include <iostream>
-static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
-    ((std::string*)userp)->append((char*)contents, size * nmemb);
-    return size * nmemb;
-}
-std::string HttpRequest(const std::string& IP, int port) {
-    CURL* curl;
-    CURLcode res;
-    std::string readBuffer;
-    curl = curl_easy_init();
-    Assert(curl);
-    if (curl) {
-        curl_easy_setopt(curl, CURLOPT_URL, IP.c_str());
-        curl_easy_setopt(curl, CURLOPT_PORT, port);
-        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
-        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
-        res = curl_easy_perform(curl);
-        curl_easy_cleanup(curl);
-        if (res != CURLE_OK)
-            return "-1";
-    }
-    return readBuffer;
-}
-
-std::string PostHTTP(const std::string& IP, const std::string& Fields) {
-    CURL* curl;
-    CURLcode res;
-    std::string readBuffer;
-    curl = curl_easy_init();
-    Assert(curl);
-    if (curl) {
-        curl_easy_setopt(curl, CURLOPT_URL, IP.c_str());
-        /*curl_easy_setopt(curl, CURLOPT_URL, "https://95.216.35.232/heartbeatv2");
-        curl_easy_setopt(curl, CURLOPT_PORT, 3600);*/
-        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, Fields.size());
-        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, Fields.c_str());
-        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
-        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
-        curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
-        res = curl_easy_perform(curl);
-        curl_easy_cleanup(curl);
-        if (res != CURLE_OK)
-            return "-1";
-    }
-    return readBuffer;
-}

src/Network/InitClient.cpp

@@ -1,101 +0,0 @@
-///
-/// Created by Anonymous275 on 8/1/2020
-///
-#include "Client.hpp"
-#include "Logger.h"
-#include "Lua/LuaSystem.hpp"
-#include "Network.h"
-#include "Security/Enc.h"
-#include "Settings.h"
-int OpenID() {
-    int ID = 0;
-    bool found;
-    do {
-        found = true;
-        for (auto& c : CI->Clients) {
-            if (c != nullptr) {
-                if (c->GetID() == ID) {
-                    found = false;
-                    ID++;
-                }
-            }
-        }
-    } while (!found);
-    return ID;
-}
-void Respond(Client* c, const std::string& MSG, bool Rel) {
-    Assert(c);
-    char C = MSG.at(0);
-    if (Rel || C == 'W' || C == 'Y' || C == 'V' || C == 'E') {
-        if (C == 'O' || C == 'T' || MSG.length() > 1000) {
-            SendLarge(c, MSG);
-        } else {
-            TCPSend(c, MSG);
-        }
-    } else {
-        UDPSend(c, MSG);
-    }
-}
-void SendToAll(Client* c, const std::string& Data, bool Self, bool Rel) {
-    if (!Self)
-        Assert(c);
-    char C = Data.at(0);
-    for (auto& client : CI->Clients) {
-        if (client != nullptr) {
-            if (Self || client.get() != c) {
-                if (client->isSynced) {
-                    if (Rel || C == 'W' || C == 'Y' || C == 'V' || C == 'E') {
-                        if (C == 'O' || C == 'T' || Data.length() > 1000)
-                            SendLarge(client.get(), Data);
-                        else
-                            TCPSend(client.get(), Data);
-                    } else
-                        UDPSend(client.get(), Data);
-                }
-            }
-        }
-    }
-}
-void UpdatePlayers() {
-    std::string Packet = Sec("Ss") + std::to_string(CI->Size()) + "/" + std::to_string(MaxPlayers) + ":";
-    for (auto& c : CI->Clients) {
-        if (c != nullptr)
-            Packet += c->GetName() + ",";
-    }
-    Packet = Packet.substr(0, Packet.length() - 1);
-    SendToAll(nullptr, Packet, true, true);
-}
-void OnDisconnect(Client* c, bool kicked) {
-
-    Assert(c);
-    info(c->GetName() + Sec(" Connection Terminated"));
-    if (c == nullptr)
-        return;
-    std::string Packet;
-    for (auto& v : c->GetAllCars()) {
-        if (v != nullptr) {
-            Packet = "Od:" + std::to_string(c->GetID()) + "-" + std::to_string(v->ID);
-            SendToAll(c, Packet, false, true);
-        }
-    }
-    if (kicked)
-        Packet = Sec("L") + c->GetName() + Sec(" was kicked!");
-    Packet = Sec("L") + c->GetName() + Sec(" Left the server!");
-    SendToAll(c, Packet, false, true);
-    Packet.clear();
-    TriggerLuaEvent(Sec("onPlayerDisconnect"), false, nullptr, std::unique_ptr<LuaArg>(new LuaArg { { c->GetID() } }), false);
-    CI->RemoveClient(c); ///Removes the Client from existence
-}
-void OnConnect(Client* c) {
-    Assert(c);
-    info(Sec("Client connected"));
-    c->SetID(OpenID());
-    info(Sec("Assigned ID ") + std::to_string(c->GetID()) + Sec(" to ") + c->GetName());
-    TriggerLuaEvent(Sec("onPlayerConnecting"), false, nullptr, std::unique_ptr<LuaArg>(new LuaArg { { c->GetID() } }), false);
-    SyncResources(c);
-    if (c->GetStatus() < 0)
-        return;
-    Respond(c, "M" + MapName, true); //Send the Map on connect
-    info(c->GetName() + Sec(" : Connected"));
-    TriggerLuaEvent(Sec("onPlayerJoining"), false, nullptr, std::unique_ptr<LuaArg>(new LuaArg { { c->GetID() } }), false);
-}

src/Network/NetMain.cpp

@@ -1,9 +0,0 @@
-#include "Network.h"
-#include <memory>
-#include <thread>
-std::unique_ptr<ClientInterface> CI;
-void NetMain() {
-    std::thread TCP(TCPServerMain);
-    TCP.detach();
-    UDPServerMain();
-}

src/Network/StatMonitor.cpp

@@ -1,44 +0,0 @@
-///
-/// Created by Anonymous275 on 6/18/2020
-///
-#include "Client.hpp"
-#include "Security/Enc.h"
-#include <iostream>
-#include <string>
-#include <thread>
-std::string StatReport;
-int PPS = 0;
-void Monitor() {
-    int R, C = 0, V = 0;
-    if (CI->Clients.empty()) {
-        StatReport = "-";
-        return;
-    }
-    for (auto& c : CI->Clients) {
-        if (c != nullptr && c->GetCarCount() > 0) {
-            C++;
-            V += c->GetCarCount();
-        }
-    }
-    if (C == 0 || PPS == 0) {
-        StatReport = "-";
-    } else {
-        R = (PPS / C) / V;
-        StatReport = std::to_string(R);
-    }
-    PPS = 0;
-}
-
-[[noreturn]] void Stat() {
-    DebugPrintTID();
-    while (true) {
-        Monitor();
-        std::this_thread::sleep_for(std::chrono::seconds(1));
-    }
-}
-
-void StatInit() {
-    StatReport = "-";
-    std::thread Init(Stat);
-    Init.detach();
-}

src/Network/Sync.cpp

@@ -1,139 +0,0 @@
-///
-/// Created by Anonymous275 on 8/1/2020
-///
-#include "Client.hpp"
-#include "Logger.h"
-#include "Security/Enc.h"
-#include "Settings.h"
-#include "UnixCompat.h"
-#include <fstream>
-
-#ifdef __linux
-// we need this for `struct stat`
-#include <sys/stat.h>
-#endif // __linux
-
-void STCPSend(Client* c, std::string Data) {
-    Assert(c);
-    if (c == nullptr)
-        return;
-#ifdef WIN32
-    int BytesSent;
-    int len = static_cast<int>(Data.size());
-#else
-    int64_t BytesSent;
-    size_t len = Data.size();
-#endif // WIN32
-    BytesSent = send(c->GetTCPSock(), Data.c_str(), len, 0);
-    Data.clear();
-    if (BytesSent == 0) {
-        if (c->GetStatus() > -1)
-            c->SetStatus(-1);
-    } else if (BytesSent < 0) {
-        if (c->GetStatus() > -1)
-            c->SetStatus(-1);
-        info(Sec("Closing socket, BytesSent < 0"));
-        CloseSocketProper(c->GetTCPSock());
-    }
-}
-void SendFile(Client* c, const std::string& Name) {
-    Assert(c);
-    info(c->GetName() + Sec(" requesting : ") + Name.substr(Name.find_last_of('/')));
-    struct stat Info { };
-    if (stat(Name.c_str(), &Info) != 0) {
-        STCPSend(c, Sec("Cannot Open"));
-        return;
-    }
-    std::ifstream f(Name.c_str(), std::ios::binary);
-    f.seekg(0, std::ios_base::end);
-    std::streampos fileSize = f.tellg();
-    size_t Size = size_t(fileSize);
-    size_t Sent = 0;
-    size_t Diff;
-    int64_t Split = 64000;
-    while (c->GetStatus() > -1 && Sent < Size) {
-        Diff = Size - Sent;
-        if (Diff > size_t(Split)) {
-            std::string Data(size_t(Split), 0);
-            f.seekg(int64_t(Sent), std::ios_base::beg);
-            f.read(&Data[0], Split);
-            STCPSend(c, Data);
-            Sent += size_t(Split);
-        } else {
-            std::string Data(Diff, 0);
-            f.seekg(int64_t(Sent), std::ios_base::beg);
-            f.read(&Data[0], int64_t(Diff));
-            STCPSend(c, Data);
-            Sent += Diff;
-        }
-    }
-    f.close();
-}
-
-void Parse(Client* c, const std::string& Packet) {
-    Assert(c);
-    if (c == nullptr || Packet.empty())
-        return;
-    char Code = Packet.at(0), SubCode = 0;
-    if (Packet.length() > 1)
-        SubCode = Packet.at(1);
-    switch (Code) {
-    case 'f':
-        SendFile(c, Packet.substr(1));
-        return;
-    case 'S':
-        if (SubCode == 'R') {
-            debug(Sec("Sending Mod Info"));
-            std::string ToSend = FileList + FileSizes;
-            if (ToSend.empty())
-                ToSend = "-";
-            STCPSend(c, ToSend);
-        }
-        return;
-    default:
-        return;
-    }
-}
-
-bool STCPRecv(Client* c) {
-    Assert(c);
-    if (c == nullptr)
-        return false;
-#define len 200
-    char buf[len];
-    ZeroMemory(buf, len);
-    int64_t BytesRcv = recv(c->GetTCPSock(), buf, len, 0);
-#undef len
-    if (BytesRcv == 0) {
-        if (c->GetStatus() > -1)
-            c->SetStatus(-1);
-        info(Sec("Closing socket in STCP receive, BytesRcv == 0"));
-        CloseSocketProper(c->GetTCPSock());
-        return false;
-    } else if (BytesRcv < 0) {
-        if (c->GetStatus() > -1)
-            c->SetStatus(-1);
-        info(Sec("Closing socket in STCP receive, BytesRcv < 0"));
-        CloseSocketProper(c->GetTCPSock());
-        return false;
-    }
-    if (strcmp(buf, "Done") == 0)
-        return false;
-    std::string Ret(buf, size_t(BytesRcv));
-    Parse(c, Ret);
-    return true;
-}
-
-void SyncResources(Client* c) {
-    Assert(c);
-    if (c == nullptr)
-        return;
-    try {
-        STCPSend(c, Sec("WS"));
-        while (c->GetStatus() > -1 && STCPRecv(c))
-            ;
-    } catch (std::exception& e) {
-        except(Sec("Exception! : ") + std::string(e.what()));
-        c->SetStatus(-1);
-    }
-}

src/Network/TCPHandler.cpp

@@ -1,137 +0,0 @@
-///
-/// Created by Anonymous275 on 8/1/2020
-///
-#include "Compressor.h"
-#include "Logger.h"
-#include "Network.h"
-#include "Security/Enc.h"
-#include "UnixCompat.h"
-#include <thread>
-
-void TCPSend(Client* c, const std::string& Data) {
-    Assert(c);
-    if (c == nullptr)
-        return;
-    // Size is BIG ENDIAN now, use only for header!
-    //auto Size = htonl(int32_t(Data.size()));
-    ///TODO : BIG ENDIAN for other OS
-    int32_t Size, Sent, Temp;
-    std::string Send(4, 0);
-    Size = int32_t(Data.size());
-    memcpy(&Send[0], &Size, sizeof(Size));
-    Send += Data;
-    Sent = 0;
-    Size += 4;
-    do {
-        Temp = send(c->GetTCPSock(), &Send[Sent], Size - Sent, 0);
-        if (Temp == 0) {
-            if (c->GetStatus() > -1)
-                c->SetStatus(-1);
-            return;
-        } else if (Temp < 0) {
-            if (c->GetStatus() > -1)
-                c->SetStatus(-1);
-            // info(Sec("Closing socket, Temp < 0"));
-            CloseSocketProper(c->GetTCPSock());
-            return;
-        }
-        Sent += Temp;
-    } while (Sent < Size);
-}
-
-bool CheckBytes(Client* c, int32_t BytesRcv) {
-    Assert(c);
-    if (BytesRcv == 0) {
-        debug(Sec("(TCP) Connection closing..."));
-        if (c->GetStatus() > -1)
-            c->SetStatus(-1);
-        return false;
-    } else if (BytesRcv < 0) {
-#ifdef WIN32
-        debug(Sec("(TCP) recv failed with error: ") + std::to_string(WSAGetLastError()));
-#else // unix
-        debug(Sec("(TCP) recv failed with error: ") + std::string(strerror(errno)));
-#endif // WIN32
-        if (c->GetStatus() > -1)
-            c->SetStatus(-1);
-        info(Sec("Closing socket in CheckBytes, BytesRcv < 0"));
-        CloseSocketProper(c->GetTCPSock());
-        return false;
-    }
-    return true;
-}
-
-void TCPRcv(Client* c) {
-    Assert(c);
-    int32_t Header, BytesRcv = 0, Temp;
-    if (c == nullptr || c->GetStatus() < 0)
-        return;
-
-    std::vector<char> Data(sizeof(Header));
-    do {
-        Temp = recv(c->GetTCPSock(), &Data[BytesRcv], 4 - BytesRcv, 0);
-        if (!CheckBytes(c, Temp)) {
-#ifdef DEBUG
-            error(std::string(__func__) + Sec(": failed on CheckBytes in while(BytesRcv < 4)"));
-#endif // DEBUG
-            return;
-        }
-        BytesRcv += Temp;
-    } while (size_t(BytesRcv) < sizeof(Header));
-    memcpy(&Header, &Data[0], sizeof(Header));
-
-#ifdef DEBUG
-    //debug(std::string(__func__) + Sec(": expecting ") + std::to_string(Header) + Sec(" bytes."));
-#endif // DEBUG
-    if (!CheckBytes(c, BytesRcv)) {
-#ifdef DEBUG
-        error(std::string(__func__) + Sec(": failed on CheckBytes"));
-#endif // DEBUG
-        return;
-    }
-    Data.resize(Header);
-    BytesRcv = 0;
-    do {
-        Temp = recv(c->GetTCPSock(), &Data[BytesRcv], Header - BytesRcv, 0);
-        if (!CheckBytes(c, Temp)) {
-#ifdef DEBUG
-            error(std::string(__func__) + Sec(": failed on CheckBytes in while(BytesRcv < Header)"));
-#endif // DEBUG
-
-            return;
-        }
-#ifdef DEBUG
-        //debug(std::string(__func__) + Sec(": Temp: ") + std::to_string(Temp) + Sec(", BytesRcv: ") + std::to_string(BytesRcv));
-#endif // DEBUG
-        BytesRcv += Temp;
-    } while (BytesRcv < Header);
-#ifdef DEBUG
-    //debug(std::string(__func__) + Sec(": finished recv with Temp: ") + std::to_string(Temp) + Sec(", BytesRcv: ") + std::to_string(BytesRcv));
-#endif // DEBUG
-    std::string Ret(Data.data(), Header);
-
-    if (Ret.substr(0, 4) == "ABG:") {
-        Ret = DeComp(Ret.substr(4));
-    }
-#ifdef DEBUG
-    //debug("Parsing from " + c->GetName() + " -> " +std::to_string(Ret.size()));
-#endif
-    GParser(c, Ret);
-}
-
-void TCPClient(Client* c) {
-    DebugPrintTIDInternal(Sec("Client(") + c->GetName() + Sec(")"), true);
-    Assert(c);
-    if (c->GetTCPSock() == -1) {
-        CI->RemoveClient(c);
-        return;
-    }
-    OnConnect(c);
-    while (c->GetStatus() > -1)
-        TCPRcv(c);
-    OnDisconnect(c, c->GetStatus() == -2);
-}
-void InitClient(Client* c) {
-    std::thread NewClient(TCPClient, c);
-    NewClient.detach();
-}