add readline, start working on a new console sink

marked non-implemented stuff with an exception

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "vcpkg"]
 	path = vcpkg
 	url = https://github.com/Microsoft/vcpkg.git
+[submodule "deps/BeamMP-Protocol"]
+	path = deps/BeamMP-Protocol
+	url = https://github.com/BeamMP/BeamMP-Protocol

CMakeLists.txt

@@ -15,6 +15,8 @@ include(cmake/StandardSettings.cmake)
 include(cmake/StaticAnalyzers.cmake)
 include(cmake/Git.cmake)
 
+add_subdirectory(deps/BeamMP-Protocol)
+
 # below are options which should be changed
 
 ### SETTINGS ###
@@ -23,7 +25,6 @@ include(cmake/Git.cmake)
 set(PRJ_HEADERS 
     include/ArgsParser.h
     include/BoostAliases.h
-    include/Client.h
     include/Common.h
     include/Compat.h
     include/Cryptography.h
@@ -41,19 +42,15 @@ set(PRJ_HEADERS
     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
     include/Env.h
+    include/Network.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
@@ -64,14 +61,11 @@ set(PRJ_SOURCES
     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
     src/Env.cpp
+    src/Network.cpp
 )
 
 find_package(Lua REQUIRED)
@@ -98,19 +92,25 @@ set(PRJ_LIBRARIES
     httplib::httplib
     libzip::zip
     OpenSSL::SSL OpenSSL::Crypto
+    protocol
     ${LUA_LIBRARIES}
+    zstd::libzstd_static
+    Boost::thread
+    glm::glm
 )
 
 # 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(Boost REQUIRED COMPONENTS thread)
 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)
+find_package(zstd CONFIG REQUIRED)
+find_package(glm CONFIG REQUIRED)
 
 include_directories(include)
 

cmake/CompilerWarnings.cmake

@@ -71,9 +71,8 @@ function(set_project_warnings project_name)
             -Werror=write-strings
             -Werror=strict-aliasing -fstrict-aliasing
             -Werror=missing-declarations
-            -Werror=missing-field-initializers
             -Werror=ctor-dtor-privacy
-            -Werror=switch-enum
+            -Wno-missing-field-initializers
             -Wswitch-default
             -Werror=unused-result
             -Werror=implicit-fallthrough

include/Client.h

@@ -1,116 +0,0 @@
-#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/Common.h

@@ -265,57 +265,5 @@ void RegisterThread(const std::string& str);
 
 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/IThreaded.h

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

include/LuaAPI.h

@@ -14,7 +14,7 @@ namespace MP {
     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(); }
+    inline size_t GetPlayerCount() { return Engine->Network()->authenticated_client_count(); }
     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);

include/Network.h

@@ -0,0 +1,250 @@
+#pragma once
+
+#include "Common.h"
+#include "Packet.h"
+#include "State.h"
+#include "Sync.h"
+#include "Transport.h"
+#include "Util.h"
+#include <boost/asio.hpp>
+#include <boost/asio/execution_context.hpp>
+#include <boost/asio/thread_pool.hpp>
+#include <boost/thread/scoped_thread.hpp>
+#include <boost/thread/synchronized_value.hpp>
+#include <cstdint>
+#include <filesystem>
+#include <glm/detail/qualifier.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+#include <memory>
+#include <mutex>
+#include <nlohmann/json.hpp>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+using ClientID = uint32_t;
+using VehicleID = uint16_t;
+
+using namespace boost::asio;
+
+struct Client : std::enable_shared_from_this<Client> {
+    using StrandPtr = std::shared_ptr<boost::asio::strand<ip::tcp::socket::executor_type>>;
+    using Ptr = std::shared_ptr<Client>;
+
+    ClientID id;
+    Sync<bmp::State> state { bmp::State::None };
+
+    Sync<std::string> name;
+    Sync<std::string> role;
+    Sync<bool> is_guest;
+    Sync<std::unordered_map<std::string /* identifier */, std::string /* value */>> identifiers;
+    /// Writes the packet to the TCP stream. Blocks all other writes.
+    void tcp_write(bmp::Packet& packet);
+    /// Writes the specified to the TCP stream without a header or any metadata - use in
+    /// conjunction with something else. Blocks other writes.
+    void tcp_write_file_raw(const std::filesystem::path& path);
+
+    /// Ensures no client is ever created as a non-shared-ptr, so that enable_shared_from_this works.
+    static Client::Ptr make_ptr(ClientID new_id, class Network& network, ip::tcp::socket&& tcp_socket);
+    ~Client();
+
+    ip::tcp::socket& tcp_socket() { return m_tcp_socket; }
+
+    void start_tcp();
+
+    /// Used to associate the udp socket with this client.
+    /// This isn't very secure and still allows spoofing of the UDP connection (technically),
+    /// but better than simply using the ID like the old protocol.
+    const uint64_t udp_magic;
+
+    const ip::udp::endpoint& udp_endpoint() const { return m_udp_endpoint; }
+    void set_udp_endpoint(const ip::udp::endpoint& ep) { m_udp_endpoint = ep; }
+
+private:
+    /// Ctor must be private to ensure all clients are constructed as shared_ptr to enable_shared_from_this.
+    Client(ClientID id, class Network& network, ip::tcp::socket&& tcp_socket);
+    /// Call this when the client seems to have timed out. Will send a ping and set a flag.
+    /// Returns true if try-again, false if the connection was closed.
+    [[nodiscard]] bool handle_timeout();
+    bool m_timed_out { false };
+
+    /// Timeout used for typical tcp reads.
+    boost::posix_time::milliseconds m_read_timeout { 5000 };
+    /// Timeout used for typical tcp writes. Specified in milliseconds per byte.
+    /// For example, 10 mbit/s works out to 1250 B/ms, so a value of 1250 here would
+    /// cause clients with >10 mbit/s download speed to usually not time out.
+    /// This is done because a write is considered completed when all data is written,
+    /// and worst-case this could mean that we're limited by their download speed.
+    /// We're setting it to 50, which will drop clients who are below a download speed + ping
+    /// combination of 0.4 mbit/s.
+    double m_write_byte_timeout { 0.01 };
+    /// Timeout used for mod download tcp writes.
+    /// This is typically orders of magnitude larger
+    /// to allow for slow downloads.
+    boost::posix_time::milliseconds m_download_write_timeout { 60000 };
+
+    std::mutex m_tcp_read_mtx;
+    std::mutex m_tcp_write_mtx;
+    std::mutex m_udp_read_mtx;
+
+    ip::tcp::socket m_tcp_socket;
+
+    boost::scoped_thread<> m_tcp_thread;
+
+    std::vector<uint8_t> m_header { bmp::Header::SERIALIZED_SIZE };
+    bmp::Packet m_packet {};
+
+    ip::udp::endpoint m_udp_endpoint;
+
+    class Network& m_network;
+
+    StrandPtr m_tcp_strand;
+};
+
+struct Vehicle {
+    using Ptr = std::shared_ptr<Vehicle>;
+    Sync<ClientID> owner;
+    Sync<std::vector<uint8_t>> data;
+
+    Vehicle(std::span<uint8_t> raw_data)
+        : data(std::vector<uint8_t>(raw_data.begin(), raw_data.end())) {
+        reset_status(data.get());
+    }
+
+    /// Resets all status fields to zero and reads any statuses present in the data into the fields.
+    void reset_status(std::span<const uint8_t> status_data);
+
+    struct Status {
+        glm::vec3 rvel {};
+        glm::vec4 rot {};
+        glm::vec3 vel {};
+        glm::vec3 pos {};
+        float time {};
+    };
+
+    Status get_status();
+
+    void update_status(std::span<const uint8_t> raw_packet);
+
+    const std::vector<uint8_t>& get_raw_status() const { return m_status_data; }
+
+private:
+    std::recursive_mutex m_mtx;
+
+    /// Holds pos, rvel, vel, etc. raw, updated every time
+    /// such a packet arrives.
+    std::vector<uint8_t> m_status_data;
+
+    /// Parses the status_data on request sets needs_refresh = false.
+    void refresh_cache(std::unique_lock<std::recursive_mutex>& lock);
+
+    bool m_needs_refresh = false;
+    glm::vec3 m_rvel {};
+    glm::vec4 m_rot {};
+    glm::vec3 m_vel {};
+    glm::vec3 m_pos {};
+    float m_time {};
+};
+
+class Network {
+public:
+    Network();
+    ~Network();
+
+    friend Client;
+
+    void disconnect(ClientID id, const std::string& msg);
+
+    void send_to(ClientID id, bmp::Packet& packet);
+
+    /// Returns a map of <id, client> containing only clients which are
+    /// fully connected, i.e. who have mods downloaded and everything spawned in.
+    /// If you're unsure which to use, use this one.
+    std::unordered_map<ClientID, Client::Ptr> playing_clients() const;
+    /// Returns a map of <id, client> containing only clients who are authenticated.
+    std::unordered_map<ClientID, Client::Ptr> authenticated_clients() const;
+    /// Returns all clients, including non-authenticated clients. Use only for debugging,
+    /// information, stats, status.
+    std::unordered_map<ClientID, Client::Ptr> all_clients() const;
+
+    std::optional<Client::Ptr> get_client(ClientID id, bmp::State min_state) const;
+
+    std::unordered_map<VehicleID, Vehicle::Ptr> get_vehicles_owned_by(ClientID id);
+
+    std::optional<Vehicle::Ptr> get_vehicle(VehicleID id);
+
+    /// Builds the SessionSetup.PlayersInfo json which contains all player info and all vehicles.
+    nlohmann::json build_players_info();
+
+    size_t authenticated_client_count() const;
+
+    size_t clients_in_state_count(bmp::State state) const;
+
+    size_t guest_count() const;
+
+    size_t vehicle_count() const;
+
+    /// Creates a Playing state packet from uncompressed data.
+    bmp::Packet make_playing_packet(bmp::Purpose purpose, ClientID from_id, VehicleID veh_id, const std::vector<uint8_t>& data);
+
+    /// Sends a <System> or <Server> chat message to all or only one client(s).
+    void send_system_chat_message(const std::string& msg, ClientID to = 0xffffffff);
+
+    /// To be called by accept() async handler once an accept() is completed.
+    void accept();
+
+    /// Gets the async i/o context of the network - can be used to "schedule" tasks on it.
+    boost::asio::thread_pool& context() {
+        return m_threadpool;
+    }
+
+private:
+    void handle_packet(ClientID id, const bmp::Packet& packet);
+
+    /// Reads a packet from the given UDP socket, returning the client's endpoint as an out-argument.
+    bmp::Packet udp_read(ip::udp::endpoint& out_ep);
+    /// Sends a packet to the specified UDP endpoint via the UDP socket.
+    void udp_write(bmp::Packet& packet, const ip::udp::endpoint& ep);
+
+    void udp_read_main();
+    void tcp_listen_main();
+
+    /// Handles all packets which are allowed during the Identification state.
+    void handle_identification(ClientID id, const bmp::Packet& packet, std::shared_ptr<Client>& client);
+    /// Handles all packets which are allowed during the Authentication state.
+    void handle_authentication(ClientID id, const bmp::Packet& packet, std::shared_ptr<Client>& client);
+    /// Handles all packets which are allowed during the ModDownload state.
+    void handle_mod_download(ClientID id, const bmp::Packet& packet, std::shared_ptr<Client>& client);
+    /// Handles all packets which are allowed during the SessionSetup state.
+    void handle_session_setup(ClientID id, const bmp::Packet& packet, std::shared_ptr<Client>& client);
+    /// Handles all packets which are allowed during the Playing state.
+    void handle_playing(ClientID id, const bmp::Packet& packet, std::shared_ptr<Client>& client);
+
+    /// On failure, throws an exception with the error for the client.
+    static void authenticate_user(const std::string& public_key, std::shared_ptr<Client>& client);
+
+    /// Called by accept() once completed (completion handler).
+    void handle_accept(const boost::system::error_code& ec);
+
+    Sync<std::unordered_map<ClientID, Client::Ptr>> m_clients {};
+    Sync<std::unordered_map<VehicleID, Vehicle::Ptr>> m_vehicles {};
+    Sync<std::unordered_map<uint64_t, ClientID>> m_client_magics {};
+    Sync<std::unordered_map<ip::udp::endpoint, ClientID>> m_udp_endpoints {};
+
+    ClientID new_client_id();
+    VehicleID new_vehicle_id();
+
+    thread_pool m_threadpool { std::thread::hardware_concurrency() };
+    Sync<bool> m_shutdown { false };
+
+    ip::udp::socket m_udp_socket { m_threadpool };
+
+    ip::tcp::socket m_tcp_listener { m_threadpool };
+    ip::tcp::acceptor m_tcp_acceptor { m_threadpool };
+    /// This socket gets accepted into, and is then moved.
+    ip::tcp::socket m_temp_socket { m_threadpool };
+
+    boost::scoped_thread<> m_tcp_listen_thread;
+    boost::scoped_thread<> m_udp_read_thread;
+};

include/Sync.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <boost/thread/synchronized_value.hpp>
+#include <mutex>
+
+/// This header provides convenience aliases for synchronization primitives.
+
+template<typename T>
+using Sync = boost::synchronized_value<T, std::recursive_mutex>;
+

include/TConsole.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Cryptography.h"
+#include "TScopedTimer.h"
 #include "commandline.h"
 #include <atomic>
 #include <fstream>
@@ -10,6 +11,30 @@
 #include <tuple>
 #include <unordered_map>
 #include <vector>
+#include <boost/container/deque.hpp>
+#include <boost/thread/scoped_thread.hpp>
+#include <boost/thread/synchronized_value.hpp>
+#include <memory>
+#include <optional>
+#include <span>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/sinks/sink.h>
+#include <string>
+#include <string_view>
+
+class TConsole;
+
+class ConsoleSink : public spdlog::sinks::base_sink<spdlog::details::null_mutex> {
+public:
+    ConsoleSink(TConsole& console);
+
+private:
+    void sink_it_(const spdlog::details::log_msg& msg) override;
+    void flush_() override;
+
+    TConsole* m_console;
+};
 
 class TLuaEngine;
 
@@ -69,4 +94,5 @@ private:
     const std::string mDefaultStateId = "BEAMMP_SERVER_CONSOLE";
     std::ofstream mLogFileStream;
     std::mutex mLogFileStreamMtx;
+    TScopedTimer mUptimeTimer{};
 };

include/THeartbeatThread.h

@@ -2,12 +2,11 @@
 
 #include "Common.h"
 #include "IThreaded.h"
-#include "TResourceManager.h"
-#include "TServer.h"
+#include "Network.h"
 
 class THeartbeatThread : public IThreaded {
 public:
-    THeartbeatThread(TResourceManager& ResourceManager, TServer& Server);
+    THeartbeatThread(std::shared_ptr<Network> network);
     //~THeartbeatThread();
     void operator()() override;
 
@@ -15,6 +14,5 @@ private:
     std::string GenerateCall();
     std::string GetPlayers();
 
-    TResourceManager& mResourceManager;
-    TServer& mServer;
+    std::shared_ptr<Network> m_network;
 };

include/TLuaEngine.h

@@ -1,8 +1,10 @@
 #pragma once
 
-#include "TNetwork.h"
-#include "TServer.h"
+#include "Common.h"
+#include "IThreaded.h"
+#include "Network.h"
 #include <any>
+#include <boost/thread/scoped_thread.hpp>
 #include <condition_variable>
 #include <filesystem>
 #include <initializer_list>
@@ -68,7 +70,7 @@ struct TLuaChunk {
     std::string PluginPath;
 };
 
-class TLuaEngine : public std::enable_shared_from_this<TLuaEngine>, IThreaded {
+class TLuaEngine : public std::enable_shared_from_this<TLuaEngine> {
 public:
     enum CallStrategy : int {
         BestEffort,
@@ -87,13 +89,11 @@ public:
         beammp_debug("Lua Engine terminated");
     }
 
-    void operator()() override;
+    void Start();
 
-    TNetwork& Network() { return *mNetwork; }
-    TServer& Server() { return *mServer; }
+    std::shared_ptr<::Network> Network() { return mNetwork; }
 
-    void SetNetwork(TNetwork* Network) { mNetwork = Network; }
-    void SetServer(TServer* Server) { mServer = Server; }
+    void SetNetwork(const std::shared_ptr<::Network>& network) { mNetwork = network; }
 
     size_t GetResultsToCheckSize() {
         std::unique_lock Lock(mResultsToCheckMutex);
@@ -201,7 +201,7 @@ private:
     void FindAndParseConfig(const fs::path& Folder, TLuaPluginConfig& Config);
     size_t CalculateMemoryUsage();
 
-    class StateThreadData : IThreaded {
+    class StateThreadData {
     public:
         StateThreadData(const std::string& Name, TLuaStateId StateId, TLuaEngine& Engine);
         StateThreadData(const StateThreadData&) = delete;
@@ -211,7 +211,7 @@ private:
         [[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;
+        void Start();
         sol::state_view State() { return sol::state_view(mState); }
 
         std::vector<std::string> GetStateGlobalKeys();
@@ -221,6 +221,8 @@ private:
         std::queue<std::pair<TLuaChunk, std::shared_ptr<TLuaResult>>> Debug_GetStateExecuteQueue();
         std::vector<TLuaEngine::QueuedFunction> Debug_GetStateFunctionQueue();
 
+        sol::table Lua_JsonDecode(const std::string& str);
+
     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);
@@ -228,9 +230,8 @@ private:
         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);
+        std::pair<sol::table, std::string> Lua_GetVehicleStatus(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);
@@ -238,7 +239,6 @@ private:
         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;
@@ -250,6 +250,7 @@ private:
         std::recursive_mutex mPathsMutex;
         std::mt19937 mMersenneTwister;
         std::uniform_real_distribution<double> mUniformRealDistribution01;
+        boost::scoped_thread<> mThread;
     };
 
     struct TimedEvent {
@@ -262,8 +263,7 @@ private:
         void Reset();
     };
 
-    TNetwork* mNetwork;
-    TServer* mServer;
+    std::shared_ptr<::Network> mNetwork;
     const fs::path mResourceServerPath;
     std::vector<std::shared_ptr<TLuaPlugin>> mLuaPlugins;
     std::unordered_map<TLuaStateId, std::unique_ptr<StateThreadData>> mLuaStates;
@@ -275,6 +275,7 @@ private:
     std::list<std::shared_ptr<TLuaResult>> mResultsToCheck;
     std::mutex mResultsToCheckMutex;
     std::condition_variable mResultsToCheckCond;
+    boost::scoped_thread<> mThread;
 };
 
 // std::any TriggerLuaEvent(const std::string& Event, bool local, TLuaPlugin* Caller, std::shared_ptr<TLuaArg> arg, bool Wait);

include/TNetwork.h

@@ -1,56 +0,0 @@
-#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

@@ -1,27 +0,0 @@
-#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/TResourceManager.h

@@ -1,21 +0,0 @@
-#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/TServer.h

@@ -1,55 +0,0 @@
-#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;
-
-    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);
-    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; }
-};

src/Client.cpp

@@ -1,155 +0,0 @@
-#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) {
-        beammp_debugf("Failed to get vehicle position for {}: {}", Ident, oor.what());
-        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;
-            }
-        } else {
-            beammp_debugf("Found an expired client while looking for id {}", ID);
-        }
-        return true;
-    });
-    return MaybeClient;
-}

src/Http.cpp

@@ -1,6 +1,5 @@
 #include "Http.h"
 
-#include "Client.h"
 #include "Common.h"
 #include "CustomAssert.h"
 #include "LuaAPI.h"
@@ -15,7 +14,7 @@
 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);
+    static thread_local httplib::SSLClient client(host, port);
     client.enable_server_certificate_verification(false);
     client.set_address_family(AF_INET);
     auto res = client.Get(target.c_str());
@@ -30,7 +29,7 @@ std::string Http::GET(const std::string& host, int port, const std::string& targ
 }
 
 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);
+    static thread_local httplib::SSLClient client(host, port);
     client.set_read_timeout(std::chrono::seconds(10));
     beammp_assert(client.is_valid());
     client.enable_server_certificate_verification(false);
@@ -181,7 +180,7 @@ void Http::Server::THttpServerInstance::operator()() try {
             }
         }
         res.set_content(
-            json {
+            nlohmann::json {
                 { "ok", SystemsBad == 0 },
             }
                 .dump(),

src/LuaAPI.cpp

@@ -1,5 +1,4 @@
 #include "LuaAPI.h"
-#include "Client.h"
 #include "Common.h"
 #include "CustomAssert.h"
 #include "TLuaEngine.h"
@@ -114,24 +113,26 @@ TEST_CASE("LuaAPI::MP::GetServerVersion") {
 }
 
 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, "" };
-    }
+    throw std::runtime_error(fmt::format("NOT IMPLEMENTED: {}", __func__));
+    /*
+        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) {
+                beammp_lua_errorf("TriggerClientEvent invalid Player ID '{}'", PlayerID);
+                return { false, "Invalid Player ID" };
+            }
+            auto c = MaybeClient.value();
+            if (!LuaAPI::MP::Engine->Network().Respond(*c, StringToVector(Packet), true)) {
+                beammp_lua_errorf("Respond failed, dropping client {}", PlayerID);
+                LuaAPI::MP::Engine->Network().Disconnect(*c);
+                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) {
@@ -140,17 +141,22 @@ std::pair<bool, std::string> LuaAPI::MP::TriggerClientEvent(int PlayerID, const
 }
 
 std::pair<bool, std::string> LuaAPI::MP::DropPlayer(int ID, std::optional<std::string> MaybeReason) {
+    throw std::runtime_error(fmt::format("NOT IMPLEMENTED: {}", __func__));
+    /*
     auto MaybeClient = GetClient(Engine->Server(), ID);
-    if (!MaybeClient || MaybeClient.value().expired()) {
+    if (!MaybeClient) {
         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();
+    auto c = MaybeClient.value();
     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) {
+    throw std::runtime_error(fmt::format("NOT IMPLEMENTED: {}", __func__));
+    /*
     std::pair<bool, std::string> Result;
     std::string Packet = "C:Server: " + Message;
     if (ID == -1) {
@@ -159,17 +165,18 @@ std::pair<bool, std::string> LuaAPI::MP::SendChatMessage(int ID, const std::stri
         Result.first = true;
     } else {
         auto MaybeClient = GetClient(Engine->Server(), ID);
-        if (MaybeClient && !MaybeClient.value().expired()) {
-            auto c = MaybeClient.value().lock();
-            if (!c->IsSynced()) {
+        if (MaybeClient) {
+            auto c = MaybeClient.value();
+            if (!c->IsSynced) {
                 Result.first = false;
                 Result.second = "Player still syncing data";
                 return Result;
             }
-            LogChatMessage("<Server> (to \"" + c->GetName() + "\")", -1, Message);
+            LogChatMessage("<Server> (to \"" + c->Name.get() + "\")", -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?
+                beammp_infof("Disconnecting client {} for failure to receive a chat message (TCP disconnect)", c->Name.get());
+                Engine->Network().Disconnect(c);
             }
             Result.first = true;
         } else {
@@ -180,18 +187,21 @@ std::pair<bool, std::string> LuaAPI::MP::SendChatMessage(int ID, const std::stri
         return Result;
     }
     return Result;
+    */
 }
 
 std::pair<bool, std::string> LuaAPI::MP::RemoveVehicle(int PID, int VID) {
+    throw std::runtime_error(fmt::format("NOT IMPLEMENTED: {}", __func__));
+    /*
     std::pair<bool, std::string> Result;
     auto MaybeClient = GetClient(Engine->Server(), PID);
-    if (!MaybeClient || MaybeClient.value().expired()) {
+    if (!MaybeClient) {
         beammp_lua_error("RemoveVehicle invalid Player ID");
         Result.first = false;
         Result.second = "Invalid Player ID";
         return Result;
     }
-    auto c = MaybeClient.value().lock();
+    auto c = MaybeClient.value();
     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);
@@ -202,6 +212,7 @@ std::pair<bool, std::string> LuaAPI::MP::RemoveVehicle(int PID, int VID) {
         Result.second = "Vehicle does not exist";
     }
     return Result;
+    */
 }
 
 void LuaAPI::MP::Set(int ConfigID, sol::object NewValue) {
@@ -273,21 +284,26 @@ void LuaAPI::MP::Sleep(size_t Ms) {
 }
 
 bool LuaAPI::MP::IsPlayerConnected(int ID) {
+    throw std::runtime_error(fmt::format("NOT IMPLEMENTED: {}", __func__));
+    /*
     auto MaybeClient = GetClient(Engine->Server(), ID);
-    if (MaybeClient && !MaybeClient.value().expired()) {
-        return MaybeClient.value().lock()->IsConnected();
+    if (MaybeClient) {
+        return MaybeClient.value()->IsConnected.get();
     } else {
         return false;
-    }
+    }*/
 }
 
 bool LuaAPI::MP::IsPlayerGuest(int ID) {
+    throw std::runtime_error(fmt::format("NOT IMPLEMENTED: {}", __func__));
+    /*
     auto MaybeClient = GetClient(Engine->Server(), ID);
-    if (MaybeClient && !MaybeClient.value().expired()) {
-        return MaybeClient.value().lock()->IsGuest();
+    if (MaybeClient) {
+        return MaybeClient.value()->IsGuest.get();
     } else {
         return false;
     }
+    */
 }
 
 void LuaAPI::MP::PrintRaw(sol::variadic_args Args) {

src/TConsole.cpp

@@ -2,7 +2,6 @@
 #include "Common.h"
 #include "Compat.h"
 
-#include "Client.h"
 #include "CustomAssert.h"
 #include "LuaAPI.h"
 #include "TLuaEngine.h"
@@ -266,17 +265,15 @@ void TConsole::Command_Kick(const std::string&, const std::vector<std::string>&
         std::for_each(Name2.begin(), Name2.end(), [](char& c) { c = char(std::tolower(char(c))); });
         return StringStartsWith(Name1, Name2) || StringStartsWith(Name2, Name1);
     };
-    mLuaEngine->Server().ForEachClient([&](std::weak_ptr<TClient> Client) -> bool {
-        if (!Client.expired()) {
-            auto locked = Client.lock();
-            if (NameCompare(locked->GetName(), Name)) {
-                mLuaEngine->Network().ClientKick(*locked, Reason);
+    throw std::runtime_error(fmt::format("NOT IMPLEMENTED: {}", __func__));
+    /*mLuaEngine->Server().ForEachClient([&](const std::shared_ptr<TClient>& Client) -> bool {
+            if (NameCompare(Client->Name.get(), Name)) {
+                mLuaEngine->Network().ClientKick(*Client, Reason);
                 Kicked = true;
                 return false;
             }
-        }
         return true;
-    });
+    });*/
     if (!Kicked) {
         Application::Console().WriteRaw("Error: No player with name matching '" + Name + "' was found.");
     } else {
@@ -359,23 +356,24 @@ void TConsole::Command_List(const std::string&, const std::vector<std::string>&
     if (!EnsureArgsCount(args, 0)) {
         return;
     }
+    // Implement once running
+    throw std::runtime_error(fmt::format("NOT IMPLEMENTED: {}", __func__));
+    /*
     if (mLuaEngine->Server().ClientCount() == 0) {
         Application::Console().WriteRaw("No players online.");
     } else {
         std::stringstream ss;
         ss << std::left << std::setw(25) << "Name" << std::setw(6) << "ID" << std::setw(6) << "Cars" << std::endl;
-        mLuaEngine->Server().ForEachClient([&](std::weak_ptr<TClient> Client) -> bool {
-            if (!Client.expired()) {
-                auto locked = Client.lock();
-                ss << std::left << std::setw(25) << locked->GetName()
-                   << std::setw(6) << locked->GetID()
-                   << std::setw(6) << locked->GetCarCount() << "\n";
-            }
+        mLuaEngine->Server().ForEachClient([&](const std::shared_ptr<TClient>& Client) -> bool {
+            ss << std::left << std::setw(25) << Client->Name.get()
+               << std::setw(6) << Client->ID.get()
+               << std::setw(6) << Client->GetCarCount() << "\n";
             return true;
         });
         auto Str = ss.str();
         Application::Console().WriteRaw(Str.substr(0, Str.size() - 1));
     }
+*/
 }
 
 void TConsole::Command_Status(const std::string&, const std::vector<std::string>& args) {
@@ -384,29 +382,6 @@ void TConsole::Command_Status(const std::string&, const std::vector<std::string>
     }
     std::stringstream Status;
 
-    size_t CarCount = 0;
-    size_t ConnectedCount = 0;
-    size_t GuestCount = 0;
-    size_t SyncedCount = 0;
-    size_t SyncingCount = 0;
-    size_t MissedPacketQueueSum = 0;
-    int LargestSecondsSinceLastPing = 0;
-    mLuaEngine->Server().ForEachClient([&](std::weak_ptr<TClient> Client) -> bool {
-        if (!Client.expired()) {
-            auto Locked = Client.lock();
-            CarCount += Locked->GetCarCount();
-            ConnectedCount += Locked->IsConnected() ? 1 : 0;
-            GuestCount += Locked->IsGuest() ? 1 : 0;
-            SyncedCount += Locked->IsSynced() ? 1 : 0;
-            SyncingCount += Locked->IsSyncing() ? 1 : 0;
-            MissedPacketQueueSum += Locked->MissedPacketQueueSize();
-            if (Locked->SecondsSinceLastPing() < LargestSecondsSinceLastPing) {
-                LargestSecondsSinceLastPing = Locked->SecondsSinceLastPing();
-            }
-        }
-        return true;
-    });
-
     size_t SystemsStarting = 0;
     size_t SystemsGood = 0;
     size_t SystemsBad = 0;
@@ -451,15 +426,21 @@ void TConsole::Command_Status(const std::string&, const std::vector<std::string>
     SystemsShuttingDownList = SystemsShuttingDownList.substr(0, SystemsShuttingDownList.size() - 2);
     SystemsShutdownList = SystemsShutdownList.substr(0, SystemsShutdownList.size() - 2);
 
-    auto ElapsedTime = mLuaEngine->Server().UptimeTimer.GetElapsedTime();
+    auto ElapsedTime = mUptimeTimer.GetElapsedTime();
+
+    auto network = mLuaEngine->Network();
+    auto clients = network->all_clients();
 
     Status << "BeamMP-Server Status:\n"
-           << "\tTotal Players:             " << mLuaEngine->Server().ClientCount() << "\n"
-           << "\tSyncing Players:           " << SyncingCount << "\n"
-           << "\tSynced Players:            " << SyncedCount << "\n"
-           << "\tConnected Players:         " << ConnectedCount << "\n"
-           << "\tGuests:                    " << GuestCount << "\n"
-           << "\tCars:                      " << CarCount << "\n"
+           << "\tTotal Players:             " << clients.size() << "\n"
+           << "\tPlayers identifying:       " << network->clients_in_state_count(bmp::State::Identification) << "\n"
+           << "\tPlayers authenticating:    " << network->clients_in_state_count(bmp::State::Authentication) << "\n"
+           << "\tPlayers downloading mods:  " << network->clients_in_state_count(bmp::State::ModDownload) << "\n"
+           << "\tPlayers spawning in:       " << network->clients_in_state_count(bmp::State::SessionSetup) << "\n"
+           << "\tPlayers playing:           " << network->clients_in_state_count(bmp::State::Playing) << "\n"
+           << "\tPlayers leaving:           " << network->clients_in_state_count(bmp::State::Leaving) << "\n"
+           << "\tGuests:                    " << network->guest_count() << "\n"
+           << "\tVehicles:                  " << network->vehicle_count() << "\n"
            << "\tUptime:                    " << ElapsedTime << "ms (~" << size_t(double(ElapsedTime) / 1000.0 / 60.0 / 60.0) << "h) \n"
            << "\tLua:\n"
            << "\t\tQueued results to check:     " << mLuaEngine->GetResultsToCheckSize() << "\n"

src/THeartbeatThread.cpp

@@ -1,8 +1,7 @@
 #include "THeartbeatThread.h"
 
-#include "Client.h"
 #include "Http.h"
-//#include "SocketIO.h"
+// #include "SocketIO.h"
 #include <rapidjson/document.h>
 #include <rapidjson/rapidjson.h>
 #include <sstream>
@@ -121,7 +120,7 @@ std::string THeartbeatThread::GenerateCall() {
     std::stringstream Ret;
 
     Ret << "uuid=" << Application::Settings.Key
-        << "&players=" << mServer.ClientCount()
+        << "&players=" << m_network->authenticated_client_count()
         << "&maxplayers=" << Application::Settings.MaxPlayers
         << "&port=" << Application::Settings.Port
         << "&map=" << Application::Settings.MapName
@@ -130,17 +129,16 @@ std::string THeartbeatThread::GenerateCall() {
         << "&clientversion=" << std::to_string(Application::ClientMajorVersion()) + ".0" // FIXME: Wtf.
         << "&name=" << Application::Settings.ServerName
         << "&tags=" << Application::Settings.ServerTags
-        << "&modlist=" << mResourceManager.TrimmedList()
-        << "&modstotalsize=" << mResourceManager.MaxModSize()
-        << "&modstotal=" << mResourceManager.ModsLoaded()
+        << "&modlist=" << "-"//mResourceManager.TrimmedList()
+        << "&modstotalsize=" << 0 //mResourceManager.MaxModSize()
+        << "&modstotal=" << 0 // mResourceManager.ModsLoaded()
         << "&playerslist=" << GetPlayers()
         << "&desc=" << Application::Settings.ServerDesc
         << "&pass=" << (Application::Settings.Password.empty() ? "false" : "true");
     return Ret.str();
 }
-THeartbeatThread::THeartbeatThread(TResourceManager& ResourceManager, TServer& Server)
-    : mResourceManager(ResourceManager)
-    , mServer(Server) {
+THeartbeatThread::THeartbeatThread(std::shared_ptr<Network> network)
+    : m_network(std::move(network)) {
     Application::SetSubsystemStatus("Heartbeat", Application::Status::Starting);
     Application::RegisterShutdownHandler([&] {
         Application::SetSubsystemStatus("Heartbeat", Application::Status::ShuttingDown);
@@ -152,15 +150,10 @@ THeartbeatThread::THeartbeatThread(TResourceManager& ResourceManager, TServer& S
     Start();
 }
 std::string THeartbeatThread::GetPlayers() {
-    std::string Return;
-    mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
-        ReadLock Lock(mServer.GetClientMutex());
-        if (!ClientPtr.expired()) {
-            Return += ClientPtr.lock()->GetName() + ";";
-        }
-        return true;
-    });
-    return Return;
+    std::string players;
+    for (const auto& [id, client] : m_network->authenticated_clients()) {
+        players += client->name.get() + ";";
+    }
+    return players;
 }
-/*THeartbeatThread::~THeartbeatThread() {
-}*/
+

src/TLuaEngine.cpp

@@ -1,5 +1,4 @@
 #include "TLuaEngine.h"
-#include "Client.h"
 #include "CustomAssert.h"
 #include "Http.h"
 #include "LuaAPI.h"
@@ -32,7 +31,7 @@ TLuaEngine::TLuaEngine()
         }
         Application::SetSubsystemStatus("LuaEngine", Application::Status::Shutdown);
     });
-    IThreaded::Start();
+    mThread = boost::scoped_thread<>(&TLuaEngine::Start, this);
 }
 
 TEST_CASE("TLuaEngine ctor & dtor") {
@@ -41,7 +40,7 @@ TEST_CASE("TLuaEngine ctor & dtor") {
     Application::GracefullyShutdown();
 }
 
-void TLuaEngine::operator()() {
+void TLuaEngine::Start() {
     RegisterThread("LuaEngine");
     Application::SetSubsystemStatus("LuaEngine", Application::Status::Good);
     // lua engine main thread
@@ -479,14 +478,14 @@ sol::table TLuaEngine::StateThreadData::Lua_TriggerLocalEvent(const std::string&
 }
 
 sol::table TLuaEngine::StateThreadData::Lua_GetPlayerIdentifiers(int ID) {
-    auto MaybeClient = GetClient(mEngine->Server(), ID);
-    if (MaybeClient && !MaybeClient.value().expired()) {
-        auto IDs = MaybeClient.value().lock()->GetIdentifiers();
-        if (IDs.empty()) {
+    auto MaybeClient = mEngine->Network()->get_client(ClientID(ID), bmp::State::Authentication);
+    if (MaybeClient) {
+        auto IDs = MaybeClient.value()->identifiers.synchronize();
+        if (IDs->empty()) {
             return sol::lua_nil;
         }
         sol::table Result = mStateView.create_table();
-        for (const auto& Pair : IDs) {
+        for (const auto& Pair : *IDs) {
             Result[Pair.first] = Pair.second;
         }
         return Result;
@@ -496,30 +495,22 @@ sol::table TLuaEngine::StateThreadData::Lua_GetPlayerIdentifiers(int ID) {
 }
 
 sol::table TLuaEngine::StateThreadData::Lua_GetPlayers() {
-    sol::table Result = mStateView.create_table();
-    mEngine->Server().ForEachClient([&](std::weak_ptr<TClient> Client) -> bool {
-        if (!Client.expired()) {
-            auto locked = Client.lock();
-            Result[locked->GetID()] = locked->GetName();
-        }
-        return true;
-    });
-    return Result;
+    sol::table result = mStateView.create_table();
+    auto clients = mEngine->Network()->authenticated_clients();
+    for (const auto& [id, client] : clients) {
+        result[client->id] = client->name.get();
+    }
+    return result;
 }
 
 int TLuaEngine::StateThreadData::Lua_GetPlayerIDByName(const std::string& Name) {
-    int Id = -1;
-    mEngine->mServer->ForEachClient([&Id, &Name](std::weak_ptr<TClient> Client) -> bool {
-        if (!Client.expired()) {
-            auto locked = Client.lock();
-            if (locked->GetName() == Name) {
-                Id = locked->GetID();
-                return false;
-            }
+    auto clients = mEngine->Network()->authenticated_clients();
+    for (const auto& [id, client] : clients) {
+        if (client->name.get() == Name) {
+            return int(client->id);
         }
-        return true;
-    });
-    return Id;
+    }
+    return -1;
 }
 
 sol::table TLuaEngine::StateThreadData::Lua_FS_ListFiles(const std::string& Path) {
@@ -549,60 +540,51 @@ sol::table TLuaEngine::StateThreadData::Lua_FS_ListDirectories(const std::string
 }
 
 std::string TLuaEngine::StateThreadData::Lua_GetPlayerName(int ID) {
-    auto MaybeClient = GetClient(mEngine->Server(), ID);
-    if (MaybeClient && !MaybeClient.value().expired()) {
-        return MaybeClient.value().lock()->GetName();
+    auto maybe_client = mEngine->Network()->get_client(ClientID(ID), bmp::State::Authentication);
+    if (maybe_client) {
+        return maybe_client.value()->name.get();
     } else {
         return "";
     }
 }
 
 sol::table TLuaEngine::StateThreadData::Lua_GetPlayerVehicles(int ID) {
-    auto MaybeClient = GetClient(mEngine->Server(), ID);
-    if (MaybeClient && !MaybeClient.value().expired()) {
-        auto Client = MaybeClient.value().lock();
-        TClient::TSetOfVehicleData VehicleData;
-        { // Vehicle Data Lock Scope
-            auto LockedData = Client->GetAllCars();
-            VehicleData = *LockedData.VehicleData;
-        } // End Vehicle Data Lock Scope
-        if (VehicleData.empty()) {
-            return sol::lua_nil;
-        }
-        sol::state_view StateView(mState);
-        sol::table Result = StateView.create_table();
-        for (const auto& v : VehicleData) {
-            Result[v.ID()] = v.Data().substr(3);
-        }
-        return Result;
-    } else
+    auto vehicles = mEngine->Network()->get_vehicles_owned_by(ClientID(ID));
+    if (vehicles.empty()) {
         return sol::lua_nil;
+    }
+    sol::state_view state_view(mState);
+    sol::table result = state_view.create_table();
+    for (const auto& [vid, vehicle] : vehicles) {
+        result[vid] = vehicle->data.get();
+    }
+    return result;
 }
 
-std::pair<sol::table, std::string> TLuaEngine::StateThreadData::Lua_GetPositionRaw(int PID, int VID) {
-    std::pair<sol::table, std::string> Result;
-    auto MaybeClient = GetClient(mEngine->Server(), PID);
-    if (MaybeClient && !MaybeClient.value().expired()) {
-        auto Client = MaybeClient.value().lock();
-        std::string VehiclePos = Client->GetCarPositionRaw(VID);
-
-        if (VehiclePos.empty()) {
-            // return std::make_tuple(sol::lua_nil, sol::make_object(StateView, "Vehicle not found"));
-            Result.second = "Vehicle not found";
-            return Result;
-        }
-
-        sol::table t = Lua_JsonDecode(VehiclePos);
-        if (t == sol::lua_nil) {
-            Result.second = "Packet decode failed";
-        }
-        // return std::make_tuple(Result, sol::make_object(StateView, sol::lua_nil));
-        Result.first = t;
-        return Result;
+std::pair<sol::table, std::string> TLuaEngine::StateThreadData::Lua_GetVehicleStatus(int VID) {
+    auto maybe_vehicle = mEngine->Network()->get_vehicle(VehicleID(VID));
+    if (maybe_vehicle) {
+        sol::state_view state_view(mState);
+        sol::table result = state_view.create_table();
+        auto veh = maybe_vehicle.value();
+        auto status = veh->get_status();
+        result["pos"]["x"] = status.pos.x;
+        result["pos"]["y"] = status.pos.y;
+        result["pos"]["z"] = status.pos.z;
+        result["vel"]["x"] = status.vel.x;
+        result["vel"]["y"] = status.vel.y;
+        result["vel"]["z"] = status.vel.z;
+        result["rvel"]["x"] = status.rvel.x;
+        result["rvel"]["y"] = status.rvel.y;
+        result["rvel"]["z"] = status.rvel.z;
+        result["rot"]["x"] = status.rot.x;
+        result["rot"]["y"] = status.rot.y;
+        result["rot"]["z"] = status.rot.z;
+        result["rot"]["w"] = status.rot.w;
+        result["time"] = status.time;
+        return { result, "" };
     } else {
-        // return std::make_tuple(sol::lua_nil, sol::make_object(StateView, "Client expired"));
-        Result.second = "No such player";
-        return Result;
+        return { sol::lua_nil, fmt::format("Vehicle {} not found", VID) };
     }
 }
 
@@ -764,8 +746,8 @@ TLuaEngine::StateThreadData::StateThreadData(const std::string& Name, TLuaStateI
     MPTable.set_function("GetPlayerVehicles", [&](int ID) -> sol::table {
         return Lua_GetPlayerVehicles(ID);
     });
-    MPTable.set_function("GetPositionRaw", [&](int PID, int VID) -> std::pair<sol::table, std::string> {
-        return Lua_GetPositionRaw(PID, VID);
+    MPTable.set_function("GetVehicleStatus", [&](int VID) -> std::pair<sol::table, std::string> {
+        return Lua_GetVehicleStatus(VID);
     });
     MPTable.set_function("SendChatMessage", &LuaAPI::MP::SendChatMessage);
     MPTable.set_function("GetPlayers", [&]() -> sol::table {
@@ -866,7 +848,7 @@ TLuaEngine::StateThreadData::StateThreadData(const std::string& Name, TLuaStateI
     FSTable.set_function("ListDirectories", [this](const std::string& Path) {
         return Lua_FS_ListDirectories(Path);
     });
-    Start();
+    mThread = boost::scoped_thread<>(&StateThreadData::Start, this);
 }
 
 std::shared_ptr<TLuaResult> TLuaEngine::StateThreadData::EnqueueScript(const TLuaChunk& Script) {
@@ -912,7 +894,7 @@ void TLuaEngine::StateThreadData::RegisterEvent(const std::string& EventName, co
     mEngine->RegisterEvent(EventName, mStateId, FunctionName);
 }
 
-void TLuaEngine::StateThreadData::operator()() {
+void TLuaEngine::StateThreadData::Start() {
     RegisterThread("Lua:" + mStateId);
     while (!Application::IsShuttingDown()) {
         { // StateExecuteQueue Scope
@@ -1083,7 +1065,7 @@ void TLuaResult::MarkAsReady() {
 void TLuaResult::WaitUntilReady() {
     std::unique_lock readyLock(*this->ReadyMutex);
     // wait if not ready yet
-    if(!this->Ready)
+    if (!this->Ready)
         this->ReadyCondition->wait(readyLock);
 }
 

src/TNetwork.cpp

@@ -1,999 +0,0 @@
-#include "TNetwork.h"
-#include "Client.h"
-#include "Common.h"
-#include "LuaAPI.h"
-#include "TLuaEngine.h"
-#include "nlohmann/json.hpp"
-#include <CustomAssert.h>
-#include <Http.h>
-#include <array>
-#include <boost/asio/ip/address.hpp>
-#include <boost/asio/ip/address_v4.hpp>
-#include <cstring>
-
-typedef boost::asio::detail::socket_option::integer<SOL_SOCKET, SO_RCVTIMEO> rcv_timeout_option;
-
-std::vector<uint8_t> StringToVector(const std::string& Str) {
-    return std::vector<uint8_t>(Str.data(), Str.data() + Str.size());
-}
-
-static void CompressProperly(std::vector<uint8_t>& Data) {
-    constexpr std::string_view ABG = "ABG:";
-    auto CombinedData = std::vector<uint8_t>(ABG.begin(), ABG.end());
-    auto CompData = Comp(Data);
-    CombinedData.resize(ABG.size() + CompData.size());
-    std::copy(CompData.begin(), CompData.end(), CombinedData.begin() + ABG.size());
-    Data = CombinedData;
-}
-
-TNetwork::TNetwork(TServer& Server, TPPSMonitor& PPSMonitor, TResourceManager& ResourceManager)
-    : mServer(Server)
-    , mPPSMonitor(PPSMonitor)
-    , mUDPSock(Server.IoCtx())
-    , mResourceManager(ResourceManager) {
-    Application::SetSubsystemStatus("TCPNetwork", Application::Status::Starting);
-    Application::SetSubsystemStatus("UDPNetwork", Application::Status::Starting);
-    Application::RegisterShutdownHandler([&] {
-        beammp_debug("Kicking all players due to shutdown");
-        Server.ForEachClient([&](std::weak_ptr<TClient> client) -> bool {
-            if (!client.expired()) {
-                ClientKick(*client.lock(), "Server shutdown");
-            }
-            return true;
-        });
-    });
-    Application::RegisterShutdownHandler([&] {
-        Application::SetSubsystemStatus("UDPNetwork", Application::Status::ShuttingDown);
-        if (mUDPThread.joinable()) {
-            mUDPThread.detach();
-        }
-        Application::SetSubsystemStatus("UDPNetwork", Application::Status::Shutdown);
-    });
-    Application::RegisterShutdownHandler([&] {
-        Application::SetSubsystemStatus("TCPNetwork", Application::Status::ShuttingDown);
-        if (mTCPThread.joinable()) {
-            mTCPThread.detach();
-        }
-        Application::SetSubsystemStatus("TCPNetwork", Application::Status::Shutdown);
-    });
-    mTCPThread = std::thread(&TNetwork::TCPServerMain, this);
-    mUDPThread = std::thread(&TNetwork::UDPServerMain, this);
-}
-
-void TNetwork::UDPServerMain() {
-    RegisterThread("UDPServer");
-    ip::udp::endpoint UdpListenEndpoint(ip::address::from_string("0.0.0.0"), Application::Settings.Port);
-    boost::system::error_code ec;
-    mUDPSock.open(UdpListenEndpoint.protocol(), ec);
-    if (ec) {
-        beammp_error("open() failed: " + ec.message());
-        std::this_thread::sleep_for(std::chrono::seconds(5));
-        Application::GracefullyShutdown();
-    }
-    mUDPSock.bind(UdpListenEndpoint, ec);
-    if (ec) {
-        beammp_error("bind() failed: " + ec.message());
-        std::this_thread::sleep_for(std::chrono::seconds(5));
-        Application::GracefullyShutdown();
-    }
-    Application::SetSubsystemStatus("UDPNetwork", Application::Status::Good);
-    beammp_info(("Vehicle data network online on port ") + std::to_string(Application::Settings.Port) + (" with a Max of ")
-        + std::to_string(Application::Settings.MaxPlayers) + (" Clients"));
-    while (!Application::IsShuttingDown()) {
-        try {
-            ip::udp::endpoint client {};
-            std::vector<uint8_t> Data = UDPRcvFromClient(client); // Receives any data from Socket
-            auto Pos = std::find(Data.begin(), Data.end(), ':');
-            if (Data.empty() || Pos > Data.begin() + 2)
-                continue;
-            uint8_t ID = uint8_t(Data.at(0)) - 1;
-            mServer.ForEachClient([&](std::weak_ptr<TClient> ClientPtr) -> bool {
-                std::shared_ptr<TClient> Client;
-                {
-                    ReadLock Lock(mServer.GetClientMutex());
-                    if (!ClientPtr.expired()) {
-                        Client = ClientPtr.lock();
-                    } else
-                        return true;
-                }
-
-                if (Client->GetID() == ID) {
-                    Client->SetUDPAddr(client);
-                    Client->SetIsConnected(true);
-                    Data.erase(Data.begin(), Data.begin() + 2);
-                    mServer.GlobalParser(ClientPtr, std::move(Data), mPPSMonitor, *this);
-                }
-
-                return true;
-            });
-        } catch (const std::exception& e) {
-            beammp_error(("fatal: ") + std::string(e.what()));
-        }
-    }
-}
-
-void TNetwork::TCPServerMain() {
-    RegisterThread("TCPServer");
-
-    ip::tcp::endpoint ListenEp(ip::address::from_string("0.0.0.0"), Application::Settings.Port);
-    ip::tcp::socket Listener(mServer.IoCtx());
-    boost::system::error_code ec;
-    Listener.open(ListenEp.protocol(), ec);
-    if (ec) {
-        beammp_errorf("Failed to open socket: {}", ec.message());
-        return;
-    }
-    socket_base::linger LingerOpt {};
-    LingerOpt.enabled(false);
-    Listener.set_option(LingerOpt, ec);
-    if (ec) {
-        beammp_errorf("Failed to set up listening socket to not linger / reuse address. "
-                      "This may cause the socket to refuse to bind(). Error: {}",
-            ec.message());
-    }
-
-    ip::tcp::acceptor Acceptor(mServer.IoCtx(), ListenEp);
-    Acceptor.listen(socket_base::max_listen_connections, ec);
-    if (ec) {
-        beammp_errorf("listen() failed, which is needed for the server to operate. "
-                      "Shutting down. Error: {}",
-            ec.message());
-        Application::GracefullyShutdown();
-    }
-    Application::SetSubsystemStatus("TCPNetwork", Application::Status::Good);
-    beammp_info("Vehicle event network online");
-    do {
-        try {
-            if (Application::IsShuttingDown()) {
-                beammp_debug("shutdown during TCP wait for accept loop");
-                break;
-            }
-            ip::tcp::endpoint ClientEp;
-            ip::tcp::socket ClientSocket = Acceptor.accept(ClientEp, ec);
-            if (ec) {
-                beammp_errorf("failed to accept: {}", ec.message());
-            }
-            TConnection Conn { std::move(ClientSocket), ClientEp };
-            std::thread ID(&TNetwork::Identify, this, std::move(Conn));
-            ID.detach(); // TODO: Add to a queue and attempt to join periodically
-        } catch (const std::exception& e) {
-            beammp_error("fatal: " + std::string(e.what()));
-        }
-    } while (!Application::IsShuttingDown());
-}
-
-#undef GetObject // Fixes Windows
-
-#include "Json.h"
-namespace json = rapidjson;
-
-void TNetwork::Identify(TConnection&& RawConnection) {
-    RegisterThreadAuto();
-    char Code;
-
-    boost::system::error_code ec;
-    read(RawConnection.Socket, buffer(&Code, 1), ec);
-    if (ec) {
-        // TODO: is this right?!
-        RawConnection.Socket.shutdown(socket_base::shutdown_both, ec);
-        return;
-    }
-    std::shared_ptr<TClient> Client { nullptr };
-    try {
-        if (Code == 'C') {
-            Client = Authentication(std::move(RawConnection));
-        } else if (Code == 'D') {
-            HandleDownload(std::move(RawConnection));
-        } else if (Code == 'P') {
-            boost::system::error_code ec;
-            write(RawConnection.Socket, buffer("P"), ec);
-            return;
-        } else {
-            beammp_errorf("Invalid code got in Identify: '{}'", Code);
-        }
-    } catch(const std::exception& e) {
-        beammp_errorf("Error during handling of code {} - client left in invalid state, closing socket", Code);
-        boost::system::error_code ec;
-        RawConnection.Socket.shutdown(socket_base::shutdown_both, ec);
-        if (ec) {
-            beammp_debugf("Failed to shutdown client socket: {}", ec.message());
-        }
-        RawConnection.Socket.close(ec);
-        if (ec) {
-            beammp_debugf("Failed to close client socket: {}", ec.message());
-        }
-    }
-}
-
-void TNetwork::HandleDownload(TConnection&& Conn) {
-    char D;
-    boost::system::error_code ec;
-    read(Conn.Socket, buffer(&D, 1), ec);
-    if (ec) {
-        Conn.Socket.shutdown(socket_base::shutdown_both, ec);
-        // ignore ec
-        return;
-    }
-    auto ID = uint8_t(D);
-    mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
-        ReadLock Lock(mServer.GetClientMutex());
-        if (!ClientPtr.expired()) {
-            auto c = ClientPtr.lock();
-            if (c->GetID() == ID) {
-                c->SetDownSock(std::move(Conn.Socket));
-            }
-        }
-        return true;
-    });
-}
-
-std::string HashPassword(const std::string& str) {
-    std::stringstream ret;
-    unsigned char* hash = SHA256(reinterpret_cast<const unsigned char*>(str.c_str()), str.length(), nullptr);
-    for (int i = 0; i < 32; i++) {
-        ret << std::hex << static_cast<int>(hash[i]);
-    }
-    return ret.str();
-}
-
-std::shared_ptr<TClient> TNetwork::Authentication(TConnection&& RawConnection) {
-    auto Client = CreateClient(std::move(RawConnection.Socket));
-    Client->SetIdentifier("ip", RawConnection.SockAddr.address().to_string());
-    beammp_tracef("This thread is ip {}", RawConnection.SockAddr.address().to_string());
-
-    beammp_info("Identifying new ClientConnection...");
-
-    auto Data = TCPRcv(*Client);
-
-    constexpr std::string_view VC = "VC";
-    if (Data.size() > 3 && std::equal(Data.begin(), Data.begin() + VC.size(), VC.begin(), VC.end())) {
-        std::string ClientVersionStr(reinterpret_cast<const char*>(Data.data() + 2), Data.size() - 2);
-        Version ClientVersion = Application::VersionStrToInts(ClientVersionStr + ".0");
-        if (ClientVersion.major != Application::ClientMajorVersion()) {
-            beammp_errorf("Client tried to connect with version '{}', but only versions '{}.x.x' is allowed",
-                ClientVersion.AsString(), Application::ClientMajorVersion());
-            ClientKick(*Client, "Outdated Version!");
-            return nullptr;
-        }
-    } else {
-        ClientKick(*Client, fmt::format("Invalid version header: '{}' ({})", std::string(reinterpret_cast<const char*>(Data.data()), Data.size()), Data.size()));
-        return nullptr;
-    }
-
-    if (!TCPSend(*Client, StringToVector("A"))) { //changed to A for Accepted version
-        // TODO: handle
-    }
-
-    Data = TCPRcv(*Client);
-
-    if (Data.size() > 50) {
-        ClientKick(*Client, "Invalid Key (too long)!");
-        return nullptr;
-    }
-
-    std::string key(reinterpret_cast<const char*>(Data.data()), Data.size());
-
-    nlohmann::json AuthReq{};
-    std::string AuthResStr{};
-    try {
-        AuthReq = nlohmann::json {
-            { "key", key }
-        };
-
-        auto Target = "/pkToUser";
-        unsigned int ResponseCode = 0;
-        AuthResStr = Http::POST(Application::GetBackendUrlForAuth(), 443, Target, AuthReq.dump(), "application/json", &ResponseCode);
-
-    } catch (const std::exception& e) {
-        beammp_debugf("Invalid json sent by client, kicking: {}", e.what());
-        ClientKick(*Client, "Invalid Key (invalid UTF8 string)!");
-        return nullptr;
-    }
-
-    try {
-        nlohmann::json AuthRes = nlohmann::json::parse(AuthResStr);
-
-        if (AuthRes["username"].is_string() && AuthRes["roles"].is_string()
-            && AuthRes["guest"].is_boolean() && AuthRes["identifiers"].is_array()) {
-
-            Client->SetName(AuthRes["username"]);
-            Client->SetRoles(AuthRes["roles"]);
-            Client->SetIsGuest(AuthRes["guest"]);
-            for (const auto& ID : AuthRes["identifiers"]) {
-                auto Raw = std::string(ID);
-                auto SepIndex = Raw.find(':');
-                Client->SetIdentifier(Raw.substr(0, SepIndex), Raw.substr(SepIndex + 1));
-            }
-        } else {
-            beammp_error("Invalid authentication data received from authentication backend");
-            ClientKick(*Client, "Invalid authentication data!");
-            return nullptr;
-        }
-    } catch (const std::exception& e) {
-        beammp_errorf("Client sent invalid key. Error was: {}", e.what());
-        // TODO: we should really clarify that this was a backend response or parsing error
-        ClientKick(*Client, "Invalid key! Please restart your game.");
-        return nullptr;
-    }
-
-    if(!Application::Settings.Password.empty()) { // ask password
-        if(!TCPSend(*Client, StringToVector("S"))) {
-            // TODO: handle
-        }
-        beammp_info("Waiting for password");
-        Data = TCPRcv(*Client);
-        std::string Pass = std::string(reinterpret_cast<const char*>(Data.data()), Data.size());
-        if(Pass != HashPassword(Application::Settings.Password)) {
-            beammp_debug(Client->GetName() + " attempted to connect with a wrong password");
-            ClientKick(*Client, "Wrong password!");
-            return {};
-        } else {
-            beammp_debug(Client->GetName() + " used the correct password");
-        }
-    }
-
-    beammp_debug("Name -> " + Client->GetName() + ", Guest -> " + std::to_string(Client->IsGuest()) + ", Roles -> " + Client->GetRoles());
-    mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
-        std::shared_ptr<TClient> Cl;
-        {
-            ReadLock Lock(mServer.GetClientMutex());
-            if (!ClientPtr.expired()) {
-                Cl = ClientPtr.lock();
-            } else
-                return true;
-        }
-        if (Cl->GetName() == Client->GetName() && Cl->IsGuest() == Client->IsGuest()) {
-            Cl->Disconnect("Stale Client (not a real player)");
-            return false;
-        }
-
-        return true;
-    });
-
-    auto Futures = LuaAPI::MP::Engine->TriggerEvent("onPlayerAuth", "", Client->GetName(), Client->GetRoles(), Client->IsGuest(), Client->GetIdentifiers());
-    TLuaEngine::WaitForAll(Futures);
-    bool NotAllowed = std::any_of(Futures.begin(), Futures.end(),
-        [](const std::shared_ptr<TLuaResult>& Result) {
-            return !Result->Error && Result->Result.is<int>() && bool(Result->Result.as<int>());
-        });
-    std::string Reason;
-    bool NotAllowedWithReason = std::any_of(Futures.begin(), Futures.end(),
-        [&Reason](const std::shared_ptr<TLuaResult>& Result) -> bool {
-            if (!Result->Error && Result->Result.is<std::string>()) {
-                Reason = Result->Result.as<std::string>();
-                return true;
-            }
-            return false;
-        });
-
-    if (NotAllowed) {
-        ClientKick(*Client, "you are not allowed on the server!");
-        return {};
-    } else if (NotAllowedWithReason) {
-        ClientKick(*Client, Reason);
-        return {};
-    }
-
-    if (mServer.ClientCount() < size_t(Application::Settings.MaxPlayers)) {
-        beammp_info("Identification success");
-        mServer.InsertClient(Client);
-        TCPClient(Client);
-    } else {
-        ClientKick(*Client, "Server full!");
-    }
-
-    return Client;
-}
-
-std::shared_ptr<TClient> TNetwork::CreateClient(ip::tcp::socket&& TCPSock) {
-    auto c = std::make_shared<TClient>(mServer, std::move(TCPSock));
-    return c;
-}
-
-bool TNetwork::TCPSend(TClient& c, const std::vector<uint8_t>& Data, bool IsSync) {
-    if (!IsSync) {
-        if (c.IsSyncing()) {
-            if (!Data.empty()) {
-                if (Data.at(0) == 'O' || Data.at(0) == 'A' || Data.at(0) == 'C' || Data.at(0) == 'E') {
-                    c.EnqueuePacket(Data);
-                }
-            }
-            return true;
-        }
-    }
-
-    auto& Sock = c.GetTCPSock();
-
-    /*
-     * our TCP protocol sends a header of 4 bytes, followed by the data.
-     *
-     *  [][][][][][]...[]
-     *  ^------^^---...-^
-     *    size    data
-     */
-
-    const auto Size = int32_t(Data.size());
-    std::vector<uint8_t> ToSend;
-    ToSend.resize(Data.size() + sizeof(Size));
-    std::memcpy(ToSend.data(), &Size, sizeof(Size));
-    std::memcpy(ToSend.data() + sizeof(Size), Data.data(), Data.size());
-    boost::system::error_code ec;
-    write(Sock, buffer(ToSend), ec);
-    if (ec) {
-        beammp_debugf("write(): {}", ec.message());
-        c.Disconnect("write() failed");
-        return false;
-    }
-    c.UpdatePingTime();
-    return true;
-}
-
-std::vector<uint8_t> TNetwork::TCPRcv(TClient& c) {
-    if (c.IsDisconnected()) {
-        beammp_error("Client disconnected, cancelling TCPRcv");
-        return {};
-    }
-
-    int32_t Header {};
-    auto& Sock = c.GetTCPSock();
-
-    boost::system::error_code ec;
-    std::array<uint8_t, sizeof(Header)> HeaderData;
-    read(Sock, buffer(HeaderData), ec);
-    if (ec) {
-        // TODO: handle this case (read failed)
-        beammp_debugf("TCPRcv: Reading header failed: {}", ec.message());
-        return {};
-    }
-    Header = *reinterpret_cast<int32_t*>(HeaderData.data());
-
-    if (Header < 0) {
-        ClientKick(c, "Invalid packet - header negative");
-        beammp_errorf("Client {} send negative TCP header, ignoring packet", c.GetID());
-        return {};
-    }
-
-    std::vector<uint8_t> Data;
-    // TODO: This is arbitrary, this needs to be handled another way
-    if (Header < int32_t(100 * MB)) {
-        Data.resize(Header);
-    } else {
-        ClientKick(c, "Header size limit exceeded");
-        beammp_warn("Client " + c.GetName() + " (" + std::to_string(c.GetID()) + ") sent header of >100MB - assuming malicious intent and disconnecting the client.");
-        return {};
-    }
-    auto N = read(Sock, buffer(Data), ec);
-    if (ec) {
-        // TODO: handle this case properly
-        beammp_debugf("TCPRcv: Reading data failed: {}", ec.message());
-        return {};
-    }
-
-    if (N != Header) {
-        beammp_errorf("Expected to read {} bytes, instead got {}", Header, N);
-    }
-
-    constexpr std::string_view ABG = "ABG:";
-    if (Data.size() >= ABG.size() && std::equal(Data.begin(), Data.begin() + ABG.size(), ABG.begin(), ABG.end())) {
-        Data.erase(Data.begin(), Data.begin() + ABG.size());
-        return DeComp(Data);
-    } else {
-        return Data;
-    }
-}
-
-void TNetwork::ClientKick(TClient& c, const std::string& R) {
-    beammp_info("Client kicked: " + R);
-    if (!TCPSend(c, StringToVector("K" + R))) {
-        beammp_debugf("tried to kick player '{}' (id {}), but was already disconnected", c.GetName(), c.GetID());
-    }
-    c.Disconnect("Kicked");
-}
-
-void TNetwork::Looper(const std::weak_ptr<TClient>& c) {
-    RegisterThreadAuto();
-    while (!c.expired()) {
-        auto Client = c.lock();
-        if (Client->IsDisconnected()) {
-            beammp_debug("client is disconnected, breaking client loop");
-            break;
-        }
-        if (!Client->IsSyncing() && Client->IsSynced() && Client->MissedPacketQueueSize() != 0) {
-            // debug("sending " + std::to_string(Client->MissedPacketQueueSize()) + " queued packets");
-            while (Client->MissedPacketQueueSize() > 0) {
-                std::vector<uint8_t> QData {};
-                { // locked context
-                    std::unique_lock lock(Client->MissedPacketQueueMutex());
-                    if (Client->MissedPacketQueueSize() <= 0) {
-                        break;
-                    }
-                    QData = Client->MissedPacketQueue().front();
-                    Client->MissedPacketQueue().pop();
-                } // end locked context
-                // beammp_debug("sending a missed packet: " + QData);
-                if (!TCPSend(*Client, QData, true)) {
-                    Client->Disconnect("Failed to TCPSend while clearing the missed packet queue");
-                    std::unique_lock lock(Client->MissedPacketQueueMutex());
-                    while (!Client->MissedPacketQueue().empty()) {
-                        Client->MissedPacketQueue().pop();
-                    }
-                    break;
-                }
-            }
-        } else {
-            std::this_thread::sleep_for(std::chrono::milliseconds(1));
-        }
-    }
-}
-
-void TNetwork::TCPClient(const std::weak_ptr<TClient>& c) {
-    // TODO: the c.expired() might cause issues here, remove if you end up here with your debugger
-    if (c.expired() || !c.lock()->GetTCPSock().is_open()) {
-        mServer.RemoveClient(c);
-        return;
-    }
-    OnConnect(c);
-    RegisterThread("(" + std::to_string(c.lock()->GetID()) + ") \"" + c.lock()->GetName() + "\"");
-
-    std::thread QueueSync(&TNetwork::Looper, this, c);
-
-    while (true) {
-        if (c.expired())
-            break;
-        auto Client = c.lock();
-        if (Client->IsDisconnected()) {
-            beammp_debug("client status < 0, breaking client loop");
-            break;
-        }
-
-        auto res = TCPRcv(*Client);
-        if (res.empty()) {
-            beammp_debug("TCPRcv empty");
-            Client->Disconnect("TCPRcv failed");
-            break;
-        }
-        mServer.GlobalParser(c, std::move(res), mPPSMonitor, *this);
-    }
-
-    if (QueueSync.joinable())
-        QueueSync.join();
-
-    if (!c.expired()) {
-        auto Client = c.lock();
-        OnDisconnect(c);
-    } else {
-        beammp_warn("client expired in TCPClient, should never happen");
-    }
-}
-
-void TNetwork::UpdatePlayer(TClient& Client) {
-    std::string Packet = ("Ss") + std::to_string(mServer.ClientCount()) + "/" + std::to_string(Application::Settings.MaxPlayers) + ":";
-    mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
-        ReadLock Lock(mServer.GetClientMutex());
-        if (!ClientPtr.expired()) {
-            auto c = ClientPtr.lock();
-            Packet += c->GetName() + ",";
-        }
-        return true;
-    });
-    Packet = Packet.substr(0, Packet.length() - 1);
-    Client.EnqueuePacket(StringToVector(Packet));
-    //(void)Respond(Client, Packet, true);
-}
-
-void TNetwork::OnDisconnect(const std::weak_ptr<TClient>& ClientPtr) {
-    std::shared_ptr<TClient> LockedClientPtr { nullptr };
-    try {
-        LockedClientPtr = ClientPtr.lock();
-    } catch (const std::exception&) {
-        beammp_warn("Client expired in OnDisconnect, this is unexpected");
-        return;
-    }
-    beammp_assert(LockedClientPtr != nullptr);
-    TClient& c = *LockedClientPtr;
-    beammp_info(c.GetName() + (" Connection Terminated"));
-    std::string Packet;
-    TClient::TSetOfVehicleData VehicleData;
-    { // Vehicle Data Lock Scope
-        auto LockedData = c.GetAllCars();
-        VehicleData = *LockedData.VehicleData;
-    } // End Vehicle Data Lock Scope
-    for (auto& v : VehicleData) {
-        Packet = "Od:" + std::to_string(c.GetID()) + "-" + std::to_string(v.ID());
-        SendToAll(&c, StringToVector(Packet), false, true);
-    }
-    Packet = ("L") + c.GetName() + (" left the server!");
-    SendToAll(&c, StringToVector(Packet), false, true);
-    Packet.clear();
-    auto Futures = LuaAPI::MP::Engine->TriggerEvent("onPlayerDisconnect", "", c.GetID());
-    LuaAPI::MP::Engine->WaitForAll(Futures);
-    c.Disconnect("Already Disconnected (OnDisconnect)");
-    mServer.RemoveClient(ClientPtr);
-}
-
-int TNetwork::OpenID() {
-    int ID = 0;
-    bool found;
-    do {
-        found = true;
-        mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
-            ReadLock Lock(mServer.GetClientMutex());
-            if (!ClientPtr.expired()) {
-                auto c = ClientPtr.lock();
-                if (c->GetID() == ID) {
-                    found = false;
-                    ID++;
-                }
-            }
-            return true;
-        });
-    } while (!found);
-    return ID;
-}
-
-void TNetwork::OnConnect(const std::weak_ptr<TClient>& c) {
-    beammp_assert(!c.expired());
-    beammp_info("Client connected");
-    auto LockedClient = c.lock();
-    LockedClient->SetID(OpenID());
-    beammp_info("Assigned ID " + std::to_string(LockedClient->GetID()) + " to " + LockedClient->GetName());
-    LuaAPI::MP::Engine->ReportErrors(LuaAPI::MP::Engine->TriggerEvent("onPlayerConnecting", "", LockedClient->GetID()));
-    SyncResources(*LockedClient);
-    if (LockedClient->IsDisconnected())
-        return;
-    (void)Respond(*LockedClient, StringToVector("M" + Application::Settings.MapName), true); // Send the Map on connect
-    beammp_info(LockedClient->GetName() + " : Connected");
-    LuaAPI::MP::Engine->ReportErrors(LuaAPI::MP::Engine->TriggerEvent("onPlayerJoining", "", LockedClient->GetID()));
-}
-
-void TNetwork::SyncResources(TClient& c) {
-    if (!TCPSend(c, StringToVector("P" + std::to_string(c.GetID())))) {
-        // TODO handle
-    }
-    std::vector<uint8_t> Data;
-    while (!c.IsDisconnected()) {
-        Data = TCPRcv(c);
-        if (Data.empty()) {
-            break;
-        }
-        constexpr std::string_view Done = "Done";
-        if (std::equal(Data.begin(), Data.end(), Done.begin(), Done.end()))
-            break;
-        Parse(c, Data);
-    }
-}
-
-void TNetwork::Parse(TClient& c, const std::vector<uint8_t>& Packet) {
-    if (Packet.empty())
-        return;
-    char Code = Packet.at(0), SubCode = 0;
-    if (Packet.size() > 1)
-        SubCode = Packet.at(1);
-    switch (Code) {
-    case 'f':
-        SendFile(c, std::string(reinterpret_cast<const char*>(Packet.data() + 1), Packet.size() - 1));
-        return;
-    case 'S':
-        if (SubCode == 'R') {
-            beammp_debug("Sending Mod Info");
-            std::string ToSend = mResourceManager.FileList() + mResourceManager.FileSizes();
-            if (ToSend.empty())
-                ToSend = "-";
-            if (!TCPSend(c, StringToVector(ToSend))) {
-                // TODO: error
-            }
-        }
-        return;
-    default:
-        return;
-    }
-}
-
-void TNetwork::SendFile(TClient& c, const std::string& UnsafeName) {
-    beammp_info(c.GetName() + " requesting : " + UnsafeName.substr(UnsafeName.find_last_of('/')));
-
-    if (!fs::path(UnsafeName).has_filename()) {
-        if (!TCPSend(c, StringToVector("CO"))) {
-            // TODO: handle
-        }
-        beammp_warn("File " + UnsafeName + " is not a file!");
-        return;
-    }
-    auto FileName = fs::path(UnsafeName).filename().string();
-    FileName = Application::Settings.Resource + "/Client/" + FileName;
-
-    if (!std::filesystem::exists(FileName)) {
-        if (!TCPSend(c, StringToVector("CO"))) {
-            // TODO: handle
-        }
-        beammp_warn("File " + UnsafeName + " could not be accessed!");
-        return;
-    }
-
-    if (!TCPSend(c, StringToVector("AG"))) {
-        // TODO: handle
-    }
-
-    /// Wait for connections
-    int T = 0;
-    while (!c.GetDownSock().is_open() && T < 50) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        T++;
-    }
-
-    if (!c.GetDownSock().is_open()) {
-        beammp_error("Client doesn't have a download socket!");
-        if (!c.IsDisconnected())
-            c.Disconnect("Missing download socket");
-        return;
-    }
-
-    size_t Size = size_t(std::filesystem::file_size(FileName)), MSize = Size / 2;
-
-    std::thread SplitThreads[2] {
-        std::thread([&] {
-            RegisterThread("SplitLoad_0");
-            SplitLoad(c, 0, MSize, false, FileName);
-        }),
-        std::thread([&] {
-            RegisterThread("SplitLoad_1");
-            SplitLoad(c, MSize, Size, true, FileName);
-        })
-    };
-
-    for (auto& SplitThread : SplitThreads) {
-        if (SplitThread.joinable()) {
-            SplitThread.join();
-        }
-    }
-}
-
-static std::pair<size_t /* count */, size_t /* last chunk */> SplitIntoChunks(size_t FullSize, size_t ChunkSize) {
-    if (FullSize < ChunkSize) {
-        return { 0, FullSize };
-    }
-    size_t Count = FullSize / (FullSize / ChunkSize);
-    size_t LastChunkSize = FullSize - (Count * ChunkSize);
-    return { Count, LastChunkSize };
-}
-
-TEST_CASE("SplitIntoChunks") {
-    size_t FullSize;
-    size_t ChunkSize;
-    SUBCASE("Normal case") {
-        FullSize = 1234567;
-        ChunkSize = 1234;
-    }
-    SUBCASE("Zero original size") {
-        FullSize = 0;
-        ChunkSize = 100;
-    }
-    SUBCASE("Equal full size and chunk size") {
-        FullSize = 125;
-        ChunkSize = 125;
-    }
-    SUBCASE("Even split") {
-        FullSize = 10000;
-        ChunkSize = 100;
-    }
-    SUBCASE("Odd split") {
-        FullSize = 13;
-        ChunkSize = 2;
-    }
-    SUBCASE("Large sizes") {
-        FullSize = 10 * GB;
-        ChunkSize = 125 * MB;
-    }
-    auto [Count, LastSize] = SplitIntoChunks(FullSize, ChunkSize);
-    CHECK((Count * ChunkSize) + LastSize == FullSize);
-}
-
-const uint8_t* /* end ptr */ TNetwork::SendSplit(TClient& c, ip::tcp::socket& Socket, const uint8_t* DataPtr, size_t Size) {
-    if (TCPSendRaw(c, Socket, DataPtr, Size)) {
-        return DataPtr + Size;
-    } else {
-        return nullptr;
-    }
-}
-
-void TNetwork::SplitLoad(TClient& c, size_t Sent, size_t Size, bool D, const std::string& Name) {
-    std::ifstream f(Name.c_str(), std::ios::binary);
-    uint32_t Split = 125 * MB;
-    std::vector<uint8_t> Data;
-    if (Size > Split)
-        Data.resize(Split);
-    else
-        Data.resize(Size);
-    ip::tcp::socket* TCPSock { nullptr };
-    if (D)
-        TCPSock = &c.GetDownSock();
-    else
-        TCPSock = &c.GetTCPSock();
-    while (!c.IsDisconnected() && Sent < Size) {
-        size_t Diff = Size - Sent;
-        if (Diff > Split) {
-            f.seekg(Sent, std::ios_base::beg);
-            f.read(reinterpret_cast<char*>(Data.data()), Split);
-            if (!TCPSendRaw(c, *TCPSock, Data.data(), Split)) {
-                if (!c.IsDisconnected())
-                    c.Disconnect("TCPSendRaw failed in mod download (1)");
-                break;
-            }
-            Sent += Split;
-        } else {
-            f.seekg(Sent, std::ios_base::beg);
-            f.read(reinterpret_cast<char*>(Data.data()), Diff);
-            if (!TCPSendRaw(c, *TCPSock, Data.data(), int32_t(Diff))) {
-                if (!c.IsDisconnected())
-                    c.Disconnect("TCPSendRaw failed in mod download (2)");
-                break;
-            }
-            Sent += Diff;
-        }
-    }
-}
-
-bool TNetwork::TCPSendRaw(TClient& C, ip::tcp::socket& socket, const uint8_t* Data, size_t Size) {
-    boost::system::error_code ec;
-    write(socket, buffer(Data, Size), ec);
-    if (ec) {
-        beammp_errorf("Failed to send raw data to client: {}", ec.message());
-        return false;
-    }
-    C.UpdatePingTime();
-    return true;
-}
-
-bool TNetwork::SendLarge(TClient& c, std::vector<uint8_t> Data, bool isSync) {
-    if (Data.size() > 400) {
-        CompressProperly(Data);
-    }
-    return TCPSend(c, Data, isSync);
-}
-
-bool TNetwork::Respond(TClient& c, const std::vector<uint8_t>& MSG, bool Rel, bool isSync) {
-    char C = MSG.at(0);
-    if (Rel || C == 'W' || C == 'Y' || C == 'V' || C == 'E') {
-        if (C == 'O' || C == 'T' || MSG.size() > 1000) {
-            return SendLarge(c, MSG, isSync);
-        } else {
-            return TCPSend(c, MSG, isSync);
-        }
-    } else {
-        return UDPSend(c, MSG);
-    }
-}
-
-bool TNetwork::SyncClient(const std::weak_ptr<TClient>& c) {
-    if (c.expired()) {
-        return false;
-    }
-    auto LockedClient = c.lock();
-    if (LockedClient->IsSynced())
-        return true;
-    // Syncing, later set isSynced
-    // after syncing is done, we apply all packets they missed
-    if (!Respond(*LockedClient, StringToVector("Sn" + LockedClient->GetName()), true)) {
-        return false;
-    }
-    // ignore error
-    (void)SendToAll(LockedClient.get(), StringToVector("JWelcome " + LockedClient->GetName() + "!"), false, true);
-
-    LuaAPI::MP::Engine->ReportErrors(LuaAPI::MP::Engine->TriggerEvent("onPlayerJoin", "", LockedClient->GetID()));
-    LockedClient->SetIsSyncing(true);
-    bool Return = false;
-    bool res = true;
-    mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
-        std::shared_ptr<TClient> client;
-        {
-            ReadLock Lock(mServer.GetClientMutex());
-            if (!ClientPtr.expired()) {
-                client = ClientPtr.lock();
-            } else
-                return true;
-        }
-        TClient::TSetOfVehicleData VehicleData;
-        { // Vehicle Data Lock Scope
-            auto LockedData = client->GetAllCars();
-            VehicleData = *LockedData.VehicleData;
-        } // End Vehicle Data Lock Scope
-        if (client != LockedClient) {
-            for (auto& v : VehicleData) {
-                if (LockedClient->IsDisconnected()) {
-                    Return = true;
-                    res = false;
-                    return false;
-                }
-                res = Respond(*LockedClient, StringToVector(v.Data()), true, true);
-            }
-        }
-
-        return true;
-    });
-    LockedClient->SetIsSyncing(false);
-    if (Return) {
-        return res;
-    }
-    LockedClient->SetIsSynced(true);
-    beammp_info(LockedClient->GetName() + (" is now synced!"));
-    return true;
-}
-
-void TNetwork::SendToAll(TClient* c, const std::vector<uint8_t>& Data, bool Self, bool Rel) {
-    if (!Self)
-        beammp_assert(c);
-    char C = Data.at(0);
-    bool ret = true;
-    mServer.ForEachClient([&](std::weak_ptr<TClient> ClientPtr) -> bool {
-        std::shared_ptr<TClient> Client;
-        try {
-            ReadLock Lock(mServer.GetClientMutex());
-            Client = ClientPtr.lock();
-        } catch (const std::exception&) {
-            // continue
-            beammp_warn("Client expired, shouldn't happen - if a client disconnected recently, you can ignore this");
-            return true;
-        }
-        if (Self || Client.get() != c) {
-            if (Client->IsSynced() || Client->IsSyncing()) {
-                if (Rel || C == 'W' || C == 'Y' || C == 'V' || C == 'E') {
-                    if (C == 'O' || C == 'T' || Data.size() > 1000) {
-                        if (Data.size() > 400) {
-                            auto CompressedData = Data;
-                            CompressProperly(CompressedData);
-                            Client->EnqueuePacket(CompressedData);
-                        } else {
-                            Client->EnqueuePacket(Data);
-                        }
-                        // ret = SendLarge(*Client, Data);
-                    } else {
-                        Client->EnqueuePacket(Data);
-                        // ret = TCPSend(*Client, Data);
-                    }
-                } else {
-                    ret = UDPSend(*Client, Data);
-                }
-            }
-        }
-        return true;
-    });
-    if (!ret) {
-        // TODO: handle
-    }
-    return;
-}
-
-bool TNetwork::UDPSend(TClient& Client, std::vector<uint8_t> Data) {
-    if (!Client.IsConnected() || Client.IsDisconnected()) {
-        // this can happen if we try to send a packet to a client that is either
-        // 1. not yet fully connected, or
-        // 2. disconnected and not yet fully removed
-        // this is fine can can be ignored :^)
-        return true;
-    }
-    const auto Addr = Client.GetUDPAddr();
-    if (Data.size() > 400) {
-        CompressProperly(Data);
-    }
-    boost::system::error_code ec;
-    mUDPSock.send_to(buffer(Data), Addr, 0, ec);
-    if (ec) {
-        beammp_debugf("UDP sendto() failed: {}", ec.message());
-        if (!Client.IsDisconnected())
-            Client.Disconnect("UDP send failed");
-        return false;
-    }
-    return true;
-}
-
-std::vector<uint8_t> TNetwork::UDPRcvFromClient(ip::udp::endpoint& ClientEndpoint) {
-    std::array<char, 1024> Ret {};
-    boost::system::error_code ec;
-    const auto Rcv = mUDPSock.receive_from(mutable_buffer(Ret.data(), Ret.size()), ClientEndpoint, 0, ec);
-    if (ec) {
-        beammp_errorf("UDP recvfrom() failed: {}", ec.message());
-        return {};
-    }
-    beammp_assert(Rcv <= Ret.size());
-    return std::vector<uint8_t>(Ret.begin(), Ret.begin() + Rcv);
-}

src/TPPSMonitor.cpp

@@ -1,69 +0,0 @@
-#include "TPPSMonitor.h"
-#include "Client.h"
-#include "TNetwork.h"
-
-TPPSMonitor::TPPSMonitor(TServer& Server)
-    : mServer(Server) {
-    Application::SetSubsystemStatus("PPSMonitor", Application::Status::Starting);
-    Application::SetPPS("-");
-    Application::RegisterShutdownHandler([&] {
-        Application::SetSubsystemStatus("PPSMonitor", Application::Status::ShuttingDown);
-        if (mThread.joinable()) {
-            beammp_debug("shutting down PPSMonitor");
-            mThread.join();
-            beammp_debug("shut down PPSMonitor");
-        }
-        Application::SetSubsystemStatus("PPSMonitor", Application::Status::Shutdown);
-    });
-    Start();
-}
-void TPPSMonitor::operator()() {
-    RegisterThread("PPSMonitor");
-    while (!mNetwork) {
-        // hard(-ish) spin
-        std::this_thread::yield();
-    }
-    beammp_debug("PPSMonitor starting");
-    Application::SetSubsystemStatus("PPSMonitor", Application::Status::Good);
-    std::vector<std::shared_ptr<TClient>> TimedOutClients;
-    while (!Application::IsShuttingDown()) {
-        std::this_thread::sleep_for(std::chrono::seconds(1));
-        int C = 0, V = 0;
-        if (mServer.ClientCount() == 0) {
-            Application::SetPPS("-");
-            continue;
-        }
-        mServer.ForEachClient([&](const std::weak_ptr<TClient>& ClientPtr) -> bool {
-            std::shared_ptr<TClient> c;
-            {
-                ReadLock Lock(mServer.GetClientMutex());
-                if (!ClientPtr.expired()) {
-                    c = ClientPtr.lock();
-                } else
-                    return true;
-            }
-            if (c->GetCarCount() > 0) {
-                C++;
-                V += c->GetCarCount();
-            }
-            // kick on "no ping"
-            if (c->SecondsSinceLastPing() > (20 * 60)) {
-                beammp_debug("client " + std::string("(") + std::to_string(c->GetID()) + ")" + c->GetName() + " timing out: " + std::to_string(c->SecondsSinceLastPing()) + ", pps: " + Application::PPS());
-                TimedOutClients.push_back(c);
-            }
-
-            return true;
-        });
-        for (auto& ClientToKick : TimedOutClients) {
-            Network().ClientKick(*ClientToKick, "Timeout (no ping for way too long)");
-        }
-        TimedOutClients.clear();
-        if (C == 0 || mInternalPPS == 0) {
-            Application::SetPPS("-");
-        } else {
-            int R = (mInternalPPS / C) / V;
-            Application::SetPPS(std::to_string(R));
-        }
-        mInternalPPS = 0;
-    }
-}

src/TResourceManager.cpp

@@ -1,36 +0,0 @@
-#include "TResourceManager.h"
-
-#include <algorithm>
-#include <filesystem>
-
-namespace fs = std::filesystem;
-
-TResourceManager::TResourceManager() {
-    Application::SetSubsystemStatus("ResourceManager", Application::Status::Starting);
-    std::string Path = Application::Settings.Resource + "/Client";
-    if (!fs::exists(Path))
-        fs::create_directories(Path);
-    for (const auto& entry : fs::directory_iterator(Path)) {
-        std::string File(entry.path().string());
-        if (auto pos = File.find(".zip"); pos != std::string::npos) {
-            if (File.length() - pos == 4) {
-                std::replace(File.begin(), File.end(), '\\', '/');
-                mFileList += File + ';';
-                if (auto i = File.find_last_of('/'); i != std::string::npos) {
-                    ++i;
-                    File = File.substr(i, pos - i);
-                }
-                mTrimmedList += "/" + fs::path(File).filename().string() + ';';
-                mFileSizes += std::to_string(size_t(fs::file_size(entry.path()))) + ';';
-                mMaxModSize += size_t(fs::file_size(entry.path()));
-                mModsLoaded++;
-            }
-        }
-    }
-
-    if (mModsLoaded) {
-        beammp_info("Loaded " + std::to_string(mModsLoaded) + " Mods");
-    }
-
-    Application::SetSubsystemStatus("ResourceManager", Application::Status::Good);
-}

src/TServer.cpp

@@ -1,510 +0,0 @@
-#include "TServer.h"
-#include "Client.h"
-#include "Common.h"
-#include "CustomAssert.h"
-#include "TNetwork.h"
-#include "TPPSMonitor.h"
-#include <TLuaPlugin.h>
-#include <algorithm>
-#include <any>
-#include <optional>
-#include <sstream>
-
-#include <nlohmann/json.hpp>
-
-#include "LuaAPI.h"
-
-#undef GetObject // Fixes Windows
-
-#include "Json.h"
-
-static std::optional<std::pair<int, int>> GetPidVid(const std::string& str) {
-    auto IDSep = str.find('-');
-    std::string pid = str.substr(0, IDSep);
-    std::string vid = str.substr(IDSep + 1);
-
-    if (pid.find_first_not_of("0123456789") == std::string::npos && vid.find_first_not_of("0123456789") == std::string::npos) {
-        try {
-            int PID = stoi(pid);
-            int VID = stoi(vid);
-            return { { PID, VID } };
-        } catch (const std::exception&) {
-            return std::nullopt;
-        }
-    }
-    return std::nullopt;
-}
-
-TEST_CASE("GetPidVid") {
-    SUBCASE("Valid singledigit") {
-        const auto MaybePidVid = GetPidVid("0-1");
-        CHECK(MaybePidVid);
-        auto [pid, vid] = MaybePidVid.value();
-
-        CHECK_EQ(pid, 0);
-        CHECK_EQ(vid, 1);
-    }
-    SUBCASE("Valid doubledigit") {
-        const auto MaybePidVid = GetPidVid("10-12");
-        CHECK(MaybePidVid);
-        auto [pid, vid] = MaybePidVid.value();
-
-        CHECK_EQ(pid, 10);
-        CHECK_EQ(vid, 12);
-    }
-    SUBCASE("Valid doubledigit 2") {
-        const auto MaybePidVid = GetPidVid("10-2");
-        CHECK(MaybePidVid);
-        auto [pid, vid] = MaybePidVid.value();
-
-        CHECK_EQ(pid, 10);
-        CHECK_EQ(vid, 2);
-    }
-    SUBCASE("Valid doubledigit 3") {
-        const auto MaybePidVid = GetPidVid("33-23");
-        CHECK(MaybePidVid);
-        auto [pid, vid] = MaybePidVid.value();
-
-        CHECK_EQ(pid, 33);
-        CHECK_EQ(vid, 23);
-    }
-    SUBCASE("Valid doubledigit 4") {
-        const auto MaybePidVid = GetPidVid("3-23");
-        CHECK(MaybePidVid);
-        auto [pid, vid] = MaybePidVid.value();
-
-        CHECK_EQ(pid, 3);
-        CHECK_EQ(vid, 23);
-    }
-    SUBCASE("Empty string") {
-        const auto MaybePidVid = GetPidVid("");
-        CHECK(!MaybePidVid);
-    }
-    SUBCASE("Invalid separator") {
-        const auto MaybePidVid = GetPidVid("0x0");
-        CHECK(!MaybePidVid);
-    }
-    SUBCASE("Missing pid") {
-        const auto MaybePidVid = GetPidVid("-0");
-        CHECK(!MaybePidVid);
-    }
-    SUBCASE("Missing vid") {
-        const auto MaybePidVid = GetPidVid("0-");
-        CHECK(!MaybePidVid);
-    }
-    SUBCASE("Invalid pid") {
-        const auto MaybePidVid = GetPidVid("x-0");
-        CHECK(!MaybePidVid);
-    }
-    SUBCASE("Invalid vid") {
-        const auto MaybePidVid = GetPidVid("0-x");
-        CHECK(!MaybePidVid);
-    }
-}
-
-TServer::TServer(const std::vector<std::string_view>& Arguments) {
-    beammp_info("BeamMP Server v" + Application::ServerVersionString());
-    Application::SetSubsystemStatus("Server", Application::Status::Starting);
-    if (Arguments.size() > 1) {
-        Application::Settings.CustomIP = Arguments[0];
-        size_t n = std::count(Application::Settings.CustomIP.begin(), Application::Settings.CustomIP.end(), '.');
-        auto p = Application::Settings.CustomIP.find_first_not_of(".0123456789");
-        if (p != std::string::npos || n != 3 || Application::Settings.CustomIP.substr(0, 3) == "127") {
-            Application::Settings.CustomIP.clear();
-            beammp_warn("IP Specified is invalid! Ignoring");
-        } else {
-            beammp_info("server started with custom IP");
-        }
-    }
-    Application::SetSubsystemStatus("Server", Application::Status::Good);
-}
-
-void TServer::RemoveClient(const std::weak_ptr<TClient>& WeakClientPtr) {
-    std::shared_ptr<TClient> LockedClientPtr { nullptr };
-    try {
-        LockedClientPtr = WeakClientPtr.lock();
-    } catch (const std::exception&) {
-        // silently fail, as there's nothing to do
-        return;
-    }
-    beammp_assert(LockedClientPtr != nullptr);
-    TClient& Client = *LockedClientPtr;
-    beammp_debug("removing client " + Client.GetName() + " (" + std::to_string(ClientCount()) + ")");
-    // TODO: Send delete packets for all cars
-    Client.ClearCars();
-    WriteLock Lock(mClientsMutex);
-    mClients.erase(WeakClientPtr.lock());
-}
-
-void TServer::ForEachClient(const std::function<bool(std::weak_ptr<TClient>)>& Fn) {
-    decltype(mClients) Clients;
-    {
-        ReadLock lock(mClientsMutex);
-        Clients = mClients;
-    }
-    for (auto& Client : Clients) {
-        if (!Fn(Client)) {
-            break;
-        }
-    }
-}
-
-size_t TServer::ClientCount() const {
-    ReadLock Lock(mClientsMutex);
-    return mClients.size();
-}
-
-void TServer::GlobalParser(const std::weak_ptr<TClient>& Client, std::vector<uint8_t>&& Packet, TPPSMonitor& PPSMonitor, TNetwork& Network) {
-    constexpr std::string_view ABG = "ABG:";
-    if (Packet.size() >= ABG.size() && std::equal(Packet.begin(), Packet.begin() + ABG.size(), ABG.begin(), ABG.end())) {
-        Packet.erase(Packet.begin(), Packet.begin() + ABG.size());
-        Packet = DeComp(Packet);
-    }
-    if (Packet.empty()) {
-        return;
-    }
-
-    if (Client.expired()) {
-        return;
-    }
-    auto LockedClient = Client.lock();
-
-    std::any Res;
-    char Code = Packet.at(0);
-
-    std::string StringPacket(reinterpret_cast<const char*>(Packet.data()), Packet.size());
-
-    // V to Y
-    if (Code <= 89 && Code >= 86) {
-        PPSMonitor.IncrementInternalPPS();
-        Network.SendToAll(LockedClient.get(), Packet, false, false);
-        return;
-    }
-    switch (Code) {
-    case 'H': // initial connection
-        if (!Network.SyncClient(Client)) {
-            // TODO handle
-        }
-        return;
-    case 'p':
-        if (!Network.Respond(*LockedClient, StringToVector("p"), false)) {
-            // failed to send
-            LockedClient->Disconnect("Failed to send ping");
-        } else {
-            Network.UpdatePlayer(*LockedClient);
-        }
-        return;
-    case 'O':
-        if (Packet.size() > 1000) {
-            beammp_debug(("Received data from: ") + LockedClient->GetName() + (" Size: ") + std::to_string(Packet.size()));
-        }
-        ParseVehicle(*LockedClient, StringPacket, Network);
-        return;
-    case 'C': {
-        if (Packet.size() < 4 || std::find(Packet.begin() + 3, Packet.end(), ':') == Packet.end())
-            break;
-        const auto PacketAsString = std::string(reinterpret_cast<const char*>(Packet.data()), Packet.size());
-        std::string Message = "";
-        const auto ColonPos = PacketAsString.find(':', 3);
-        if (ColonPos != std::string::npos && ColonPos + 2 < PacketAsString.size()) {
-            Message = PacketAsString.substr(ColonPos + 2);
-        }
-        if (Message.empty()) {
-            beammp_debugf("Empty chat message received from '{}' ({}), ignoring it", LockedClient->GetName(), LockedClient->GetID());
-            return;
-        }
-        auto Futures = LuaAPI::MP::Engine->TriggerEvent("onChatMessage", "", LockedClient->GetID(), LockedClient->GetName(), Message);
-        TLuaEngine::WaitForAll(Futures);
-        LogChatMessage(LockedClient->GetName(), LockedClient->GetID(), PacketAsString.substr(PacketAsString.find(':', 3) + 1));
-        if (std::any_of(Futures.begin(), Futures.end(),
-                [](const std::shared_ptr<TLuaResult>& Elem) {
-                    return !Elem->Error
-                        && Elem->Result.is<int>()
-                        && bool(Elem->Result.as<int>());
-                })) {
-            break;
-        }
-        std::string SanitizedPacket = fmt::format("C:{}: {}", LockedClient->GetName(), Message);
-        Network.SendToAll(nullptr, StringToVector(SanitizedPacket), true, true);
-        return;
-    }
-    case 'E':
-        HandleEvent(*LockedClient, StringPacket);
-        return;
-    case 'N':
-        beammp_trace("got 'N' packet (" + std::to_string(Packet.size()) + ")");
-        Network.SendToAll(LockedClient.get(), Packet, false, true);
-        return;
-    case 'Z': // position packet
-        PPSMonitor.IncrementInternalPPS();
-        Network.SendToAll(LockedClient.get(), Packet, false, false);
-        HandlePosition(*LockedClient, StringPacket);
-        return;
-    default:
-        return;
-    }
-}
-
-void TServer::HandleEvent(TClient& c, const std::string& RawData) {
-    // E:Name:Data
-    // Data is allowed to have ':'
-    if (RawData.size() < 2) {
-        beammp_debugf("Client '{}' ({}) tried to send an empty event, ignoring", c.GetName(), c.GetID());
-        return;
-    }
-    auto NameDataSep = RawData.find(':', 2);
-    if (NameDataSep == std::string::npos) {
-        beammp_warn("received event in invalid format (missing ':'), got: '" + RawData + "'");
-    }
-    std::string Name = RawData.substr(2, NameDataSep - 2);
-    std::string Data = RawData.substr(NameDataSep + 1);
-    LuaAPI::MP::Engine->ReportErrors(LuaAPI::MP::Engine->TriggerEvent(Name, "", c.GetID(), Data));
-}
-
-bool TServer::IsUnicycle(TClient& c, const std::string& CarJson) {
-    try {
-        auto Car = nlohmann::json::parse(CarJson);
-        const std::string jbm = "jbm";
-        if (Car.contains(jbm) && Car[jbm].is_string() && Car[jbm] == "unicycle") {
-            return true;
-        }
-    } catch (const std::exception& e) {
-        beammp_warn("Failed to parse vehicle data as json for client " + std::to_string(c.GetID()) + ": '" + CarJson + "'.");
-    }
-    return false;
-}
-
-bool TServer::ShouldSpawn(TClient& c, const std::string& CarJson, int ID) {
-    if (IsUnicycle(c, CarJson) && c.GetUnicycleID() < 0) {
-        c.SetUnicycleID(ID);
-        return true;
-    } else {
-        return c.GetCarCount() < Application::Settings.MaxCars;
-    }
-}
-
-void TServer::ParseVehicle(TClient& c, const std::string& Pckt, TNetwork& Network) {
-    if (Pckt.length() < 6)
-        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':
-        beammp_tracef("got 'Os' packet: '{}' ({})", Packet, Packet.size());
-        if (Data.at(0) == '0') {
-            int CarID = c.GetOpenCarID();
-            beammp_debugf("'{}' created a car with ID {}", c.GetName(), CarID);
-
-            std::string CarJson = Packet.substr(5);
-            Packet = "Os:" + c.GetRoles() + ":" + c.GetName() + ":" + std::to_string(c.GetID()) + "-" + std::to_string(CarID) + ":" + CarJson;
-            auto Futures = LuaAPI::MP::Engine->TriggerEvent("onVehicleSpawn", "", c.GetID(), CarID, Packet.substr(3));
-            TLuaEngine::WaitForAll(Futures);
-            bool ShouldntSpawn = std::any_of(Futures.begin(), Futures.end(),
-                [](const std::shared_ptr<TLuaResult>& Result) {
-                    return !Result->Error && Result->Result.is<int>() && Result->Result.as<int>() != 0;
-                });
-
-            if (ShouldSpawn(c, CarJson, CarID) && !ShouldntSpawn) {
-                c.AddNewCar(CarID, Packet);
-                Network.SendToAll(nullptr, StringToVector(Packet), true, true);
-            } else {
-                if (!Network.Respond(c, StringToVector(Packet), true)) {
-                    // TODO: handle
-                }
-                std::string Destroy = "Od:" + std::to_string(c.GetID()) + "-" + std::to_string(CarID);
-                if (!Network.Respond(c, StringToVector(Destroy), true)) {
-                    // TODO: handle
-                }
-                beammp_debugf("{} (force : car limit/lua) removed ID {}", c.GetName(), CarID);
-            }
-        }
-        return;
-    case 'c': {
-        beammp_trace(std::string(("got 'Oc' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
-        auto MaybePidVid = GetPidVid(Data.substr(0, Data.find(':', 1)));
-        if (MaybePidVid) {
-            std::tie(PID, VID) = MaybePidVid.value();
-        }
-        if (PID != -1 && VID != -1 && PID == c.GetID()) {
-            auto Futures = LuaAPI::MP::Engine->TriggerEvent("onVehicleEdited", "", c.GetID(), VID, Packet.substr(3));
-            TLuaEngine::WaitForAll(Futures);
-            bool ShouldntAllow = std::any_of(Futures.begin(), Futures.end(),
-                [](const std::shared_ptr<TLuaResult>& Result) {
-                    return !Result->Error && Result->Result.is<int>() && Result->Result.as<int>() != 0;
-                });
-
-            auto FoundPos = Packet.find('{');
-            FoundPos = FoundPos == std::string::npos ? 0 : FoundPos; // attempt at sanitizing this
-            if ((c.GetUnicycleID() != VID || IsUnicycle(c, Packet.substr(FoundPos)))
-                && !ShouldntAllow) {
-                Network.SendToAll(&c, StringToVector(Packet), false, true);
-                Apply(c, VID, Packet);
-            } else {
-                if (c.GetUnicycleID() == VID) {
-                    c.SetUnicycleID(-1);
-                }
-                std::string Destroy = "Od:" + std::to_string(c.GetID()) + "-" + std::to_string(VID);
-                Network.SendToAll(nullptr, StringToVector(Destroy), true, true);
-                c.DeleteCar(VID);
-            }
-        }
-        return;
-    }
-    case 'd': {
-        beammp_trace(std::string(("got 'Od' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
-        auto MaybePidVid = GetPidVid(Data.substr(0, Data.find(':', 1)));
-        if (MaybePidVid) {
-            std::tie(PID, VID) = MaybePidVid.value();
-        }
-        if (PID != -1 && VID != -1 && PID == c.GetID()) {
-            if (c.GetUnicycleID() == VID) {
-                c.SetUnicycleID(-1);
-            }
-            Network.SendToAll(nullptr, StringToVector(Packet), true, true);
-            // TODO: should this trigger on all vehicle deletions?
-            LuaAPI::MP::Engine->ReportErrors(LuaAPI::MP::Engine->TriggerEvent("onVehicleDeleted", "", c.GetID(), VID));
-            c.DeleteCar(VID);
-            beammp_debug(c.GetName() + (" deleted car with ID ") + std::to_string(VID));
-        }
-        return;
-    }
-    case 'r': {
-        beammp_trace(std::string(("got 'Or' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
-        auto MaybePidVid = GetPidVid(Data.substr(0, Data.find(':', 1)));
-        if (MaybePidVid) {
-            std::tie(PID, VID) = MaybePidVid.value();
-        }
-
-        if (PID != -1 && VID != -1 && PID == c.GetID()) {
-            Data = Data.substr(Data.find('{'));
-            LuaAPI::MP::Engine->ReportErrors(LuaAPI::MP::Engine->TriggerEvent("onVehicleReset", "", c.GetID(), VID, Data));
-            Network.SendToAll(&c, StringToVector(Packet), false, true);
-        }
-        return;
-    }
-    case 't':
-        beammp_trace(std::string(("got 'Ot' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
-        Network.SendToAll(&c, StringToVector(Packet), false, true);
-        return;
-    case 'm':
-        Network.SendToAll(&c, StringToVector(Packet), true, true);
-        return;
-    default:
-        beammp_trace(std::string(("possibly not implemented: '") + Packet + ("' (") + std::to_string(Packet.size()) + (")")));
-        return;
-    }
-}
-
-void TServer::Apply(TClient& c, int VID, const std::string& pckt) {
-    auto FoundPos = pckt.find('{');
-    if (FoundPos == std::string::npos) {
-        beammp_error("Malformed packet received, no '{' found");
-        return;
-    }
-    std::string Packet = pckt.substr(FoundPos);
-    std::string VD = c.GetCarData(VID);
-    if (VD.empty()) {
-        beammp_error("Tried to apply change to vehicle that does not exist");
-        return;
-    }
-    std::string Header = VD.substr(0, VD.find('{'));
-
-    FoundPos = VD.find('{');
-    if (FoundPos == std::string::npos) {
-        return;
-    }
-    VD = VD.substr(FoundPos);
-    rapidjson::Document Veh, Pack;
-    Veh.Parse(VD.c_str());
-    if (Veh.HasParseError()) {
-        beammp_error("Could not get vehicle config!");
-        return;
-    }
-    Pack.Parse(Packet.c_str());
-    if (Pack.HasParseError() || Pack.IsNull()) {
-        beammp_error("Could not get active vehicle config!");
-        return;
-    }
-
-    for (auto& M : Pack.GetObject()) {
-        if (Veh[M.name].IsNull()) {
-            Veh.AddMember(M.name, M.value, Veh.GetAllocator());
-        } else {
-            Veh[M.name] = Pack[M.name];
-        }
-    }
-    rapidjson::StringBuffer Buffer;
-    rapidjson::Writer<rapidjson::StringBuffer> writer(Buffer);
-    Veh.Accept(writer);
-    c.SetCarData(VID, Header + Buffer.GetString());
-}
-
-void TServer::InsertClient(const std::shared_ptr<TClient>& NewClient) {
-    beammp_debug("inserting client (" + std::to_string(ClientCount()) + ")");
-    WriteLock Lock(mClientsMutex); // TODO why is there 30+ threads locked here
-    (void)mClients.insert(NewClient);
-}
-
-struct PidVidData {
-    int PID;
-    int VID;
-    std::string Data;
-};
-
-static std::optional<PidVidData> ParsePositionPacket(const std::string& Packet) {
-    if (Packet.size() < 3) {
-        // invalid packet
-        return std::nullopt;
-    }
-    // Zp:PID-VID:DATA
-    std::string withoutCode = Packet.substr(3);
-
-    // parse veh ID
-    if (auto DataBeginPos = withoutCode.find('{'); DataBeginPos != std::string::npos && DataBeginPos != 0) {
-        // separator is :{, so position of { minus one
-        auto PidVidOnly = withoutCode.substr(0, DataBeginPos - 1);
-        auto MaybePidVid = GetPidVid(PidVidOnly);
-        if (MaybePidVid) {
-            int PID = -1;
-            int VID = -1;
-            // FIXME: check that the VID and PID are valid, so that we don't waste memory
-            std::tie(PID, VID) = MaybePidVid.value();
-
-            std::string Data = withoutCode.substr(DataBeginPos);
-            return PidVidData {
-                .PID = PID,
-                .VID = VID,
-                .Data = Data,
-            };
-        } else {
-            // invalid packet
-            return std::nullopt;
-        }
-    }
-    // invalid packet
-    return std::nullopt;
-}
-
-TEST_CASE("ParsePositionPacket") {
-    const auto TestData = R"({"tim":10.428000331623,"vel":[-2.4171722121385e-05,-9.7184734153252e-06,-7.6420763232237e-06],"rot":[-0.0001296154171915,0.0031575385950029,0.98994906610295,0.14138903660382],"rvel":[5.3640324636461e-05,-9.9824529946024e-05,5.1664064641372e-05],"pos":[-0.27281248907838,-0.20515357944633,0.49695488960431],"ping":0.032999999821186})";
-    SUBCASE("All the pids and vids") {
-        for (int pid = 0; pid < 100; ++pid) {
-            for (int vid = 0; vid < 100; ++vid) {
-                std::optional<PidVidData> MaybeRes = ParsePositionPacket(fmt::format("Zp:{}-{}:{}", pid, vid, TestData));
-                CHECK(MaybeRes.has_value());
-                CHECK_EQ(MaybeRes.value().PID, pid);
-                CHECK_EQ(MaybeRes.value().VID, vid);
-                CHECK_EQ(MaybeRes.value().Data, TestData);
-            }
-        }
-    }
-}
-
-void TServer::HandlePosition(TClient& c, const std::string& Packet) {
-    if (auto Parsed = ParsePositionPacket(Packet); Parsed.has_value()) {
-        c.SetCarPosition(Parsed.value().VID, Parsed.value().Data);
-    }
-}

src/main.cpp

@@ -6,13 +6,13 @@
 #include "TConfig.h"
 #include "THeartbeatThread.h"
 #include "TLuaEngine.h"
-#include "TNetwork.h"
-#include "TPPSMonitor.h"
 #include "TPluginMonitor.h"
-#include "TResourceManager.h"
-#include "TServer.h"
 
+#include <cstdlib>
 #include <iostream>
+#include <spdlog/sinks/rotating_file_sink.h>
+#include <spdlog/sinks/stdout_color_sinks.h>
+#include <spdlog/spdlog.h>
 #include <thread>
 
 static const std::string sCommandlineArguments = R"(
@@ -67,6 +67,31 @@ int main(int argc, char** argv) {
     std::exit(MainRet);
 }
 
+static std::shared_ptr<spdlog::logger> default_logger;
+
+static void setup_logger() {
+    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+    console_sink->set_pattern("[%H:%M:%S] [%^%l%$] %v");
+    if (Application::Settings.DebugModeEnabled) {
+        console_sink->set_level(spdlog::level::debug);
+    } else {
+        console_sink->set_level(spdlog::level::info);
+    }
+
+    auto file_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>("Launcher.log", 1024 * 1024, 3, true);
+    file_sink->set_level(spdlog::level::trace);
+    file_sink->set_pattern("[%H:%M:%S.%e] [%t] [%l] %v");
+
+    default_logger = std::make_shared<spdlog::logger>(spdlog::logger("default", { console_sink, file_sink }));
+
+    default_logger->set_level(spdlog::level::trace);
+    default_logger->flush_on(spdlog::level::trace);
+
+    spdlog::set_default_logger(default_logger);
+
+    spdlog::debug("Logger initialized");
+}
+
 int BeamMPServerMain(MainArguments Arguments) {
     setlocale(LC_ALL, "C");
     ArgsParser Parser;
@@ -87,14 +112,18 @@ int BeamMPServerMain(MainArguments Arguments) {
         return 0;
     }
 
+    // badly seed C's rng - this is only because rand() is used here and there for unimportant stuff
+    std::srand(std::time(0));
+
     std::string ConfigPath = "ServerConfig.toml";
     if (Parser.FoundArgument({ "config" })) {
         auto MaybeConfigPath = Parser.GetValueOfArgument({ "config" });
         if (MaybeConfigPath.has_value()) {
             ConfigPath = MaybeConfigPath.value();
-            beammp_info("Custom config requested via commandline arguments: '" + ConfigPath + "'");
+            // beammp_info("Custom config requested via commandline arguments: '" + ConfigPath + "'");
         }
     }
+    setup_logger();
     if (Parser.FoundArgument({ "working-directory" })) {
         auto MaybeWorkingDirectory = Parser.GetValueOfArgument({ "working-directory" });
         if (MaybeWorkingDirectory.has_value()) {
@@ -106,7 +135,7 @@ int BeamMPServerMain(MainArguments Arguments) {
             }
         }
     }
-    
+
     TConfig Config(ConfigPath);
 
     if (Config.Failed()) {
@@ -135,21 +164,15 @@ int BeamMPServerMain(MainArguments Arguments) {
         TLuaEngine::WaitForAll(Futures, std::chrono::seconds(5));
     });
 
-    TServer Server(Arguments.List);
-
     auto LuaEngine = std::make_shared<TLuaEngine>();
-    LuaEngine->SetServer(&Server);
     Application::Console().InitializeLuaConsole(*LuaEngine);
 
     RegisterThread("Main");
 
     beammp_trace("Running in debug mode on a debug build");
-    TResourceManager ResourceManager;
-    TPPSMonitor PPSMonitor(Server);
-    THeartbeatThread Heartbeat(ResourceManager, Server);
-    TNetwork Network(Server, PPSMonitor, ResourceManager);
-    LuaEngine->SetNetwork(&Network);
-    PPSMonitor.SetNetwork(Network);
+    std::shared_ptr<Network> network = std::make_shared<Network>();
+    THeartbeatThread Heartbeat(network);
+    LuaEngine->SetNetwork(network);
     Application::CheckForUpdates();
 
     TPluginMonitor PluginMonitor(fs::path(Application::Settings.Resource) / "Server", LuaEngine);

vcpkg.json

@@ -6,14 +6,19 @@
     "boost-spirit",
     "boost-uuid",
     "boost-variant",
+    "boost-iostreams",
     "cpp-httplib",
     "doctest",
     "fmt",
-    "libzip",
     "nlohmann-json",
     "openssl",
     "rapidjson",
     "sol2",
-    "toml11"
+    "toml11",
+    "zstd",
+    "glm",
+    "libzip",
+    "spdlog",
+    "readline"
   ]
 }