include/Client.h

@@ -56,14 +56,14 @@ public:
     ~TClient();
     TClient& operator=(const TClient&) = delete;
 
-    void AddNewCar(int Ident, const nlohmann::json& Data);
-    void SetCarData(int Ident, const nlohmann::json& Data);
+    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; }
-    nlohmann::json GetCarData(int Ident);
+    std::string GetCarData(int Ident);
     std::string GetCarPositionRaw(int Ident);
     void SetUDPAddr(const ip::udp::endpoint& Addr) { mUDPAddress = Addr; }
     void SetTCPSock(ip::tcp::socket&& CSock) { mSocket = std::move(CSock); }

include/Common.h

@@ -86,8 +86,6 @@ public:
         };
     }
 
-    static std::string GetServerCheckUrl() { return "https://check.beammp.com"; }
-
     static std::string GetBackendUrlForAuth() { return "https://auth.beammp.com"; }
     static std::string GetBackendUrlForSocketIO() { return "https://backend.beammp.com"; }
     static void CheckForUpdates();
@@ -129,7 +127,7 @@ private:
     static inline std::mutex mShutdownHandlersMutex {};
     static inline std::deque<TShutdownHandler> mShutdownHandlers {};
 
-    static inline Version mVersion { 3, 8, 4 };
+    static inline Version mVersion { 3, 8, 3 };
 };
 
 void SplitString(std::string const& str, const char delim, std::vector<std::string>& out);

include/Env.h

@@ -27,7 +27,6 @@ enum class Key {
     PROVIDER_UPDATE_MESSAGE,
     PROVIDER_DISABLE_CONFIG,
     PROVIDER_PORT_ENV,
-    PROVIDER_IP_ENV
 };
 
 std::optional<std::string> Get(Key key);

include/LuaAPI.h

@@ -36,7 +36,6 @@ namespace MP {
     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> SendNotification(int ID, const std::string& Message, const std::string& Icon, const std::string& Category);
-    std::pair<bool, std::string> ConfirmationDialog(int ID, const std::string& Title, const std::string& Body, const sol::table& buttons, const std::string& InteractionID, const bool& warning = false, const bool& reportToServer = true, const bool& reportToExtensions = true);
     std::pair<bool, std::string> RemoveVehicle(int PlayerID, int VehicleID);
     void Set(int ConfigID, sol::object NewValue);
     TLuaValue Get(int ConfigID);

include/TConsole.h

@@ -59,9 +59,6 @@ private:
     void Command_Settings(const std::string& cmd, const std::vector<std::string>& args);
     void Command_Clear(const std::string&, const std::vector<std::string>& args);
     void Command_Version(const std::string& cmd, const std::vector<std::string>& args);
-    void Command_ProtectMod(const std::string& cmd, const std::vector<std::string>& args);
-    void Command_ReloadMods(const std::string& cmd, const std::vector<std::string>& args);
-    void Command_NetTest(const std::string& cmd, const std::vector<std::string>& args);
 
     void Command_Say(const std::string& FullCommand);
     bool EnsureArgsCount(const std::vector<std::string>& args, size_t n);
@@ -80,9 +77,6 @@ private:
         { "clear", [this](const auto& a, const auto& b) { Command_Clear(a, b); } },
         { "say", [this](const auto&, const auto&) { Command_Say(""); } }, // shouldn't actually be called
         { "version", [this](const auto& a, const auto& b) { Command_Version(a, b); } },
-        { "protectmod", [this](const auto& a, const auto& b) { Command_ProtectMod(a, b); } },
-        { "reloadmods", [this](const auto& a, const auto& b) { Command_ReloadMods(a, b); } },
-        { "nettest", [this](const auto& a, const auto& b) { Command_NetTest(a, b); } },
     };
 
     std::unique_ptr<Commandline> mCommandline { nullptr };

include/TNetwork.h

@@ -45,8 +45,6 @@ public:
     void SendToAll(TClient* c, const std::vector<uint8_t>& Data, bool Self, bool Rel);
     void UpdatePlayer(TClient& Client);
 
-    TResourceManager& ResourceManager() const { return mResourceManager; }
-
 private:
     void UDPServerMain();
     void TCPServerMain();

include/TResourceManager.h

@@ -30,10 +30,10 @@ public:
     [[nodiscard]] std::string TrimmedList() const { return mTrimmedList; }
     [[nodiscard]] std::string FileSizes() const { return mFileSizes; }
     [[nodiscard]] int ModsLoaded() const { return mModsLoaded; }
-    [[nodiscard]] nlohmann::json GetMods() const { return mMods; }
+
+    [[nodiscard]] std::string NewFileList() const;
 
     void RefreshFiles();
-    void SetProtected(const std::string& ModName, bool Protected);
 
 private:
     size_t mMaxModSize = 0;

include/VehicleData.h

@@ -18,12 +18,11 @@
 
 #pragma once
 
-#include <nlohmann/json.hpp>
 #include <string>
 
 class TVehicleData final {
 public:
-    TVehicleData(int ID, nlohmann::json Data);
+    TVehicleData(int ID, std::string Data);
     ~TVehicleData();
     // We cannot delete this, since vector needs to be able to copy when it resizes.
     // Deleting this causes some wacky template errors which are hard to decipher,
@@ -33,16 +32,14 @@ public:
     [[nodiscard]] bool IsInvalid() const { return mID == -1; }
     [[nodiscard]] int ID() const { return mID; }
 
-    [[nodiscard]] nlohmann::json Data() const { return mData; }
-    [[nodiscard]] std::string DataAsPacket(const std::string& Role, const std::string& Name, int ID) const;
-
-    void SetData(const nlohmann::json& Data) { mData = Data; }
+    [[nodiscard]] std::string Data() const { return mData; }
+    void SetData(const std::string& Data) { mData = Data; }
 
     bool operator==(const TVehicleData& v) const { return mID == v.mID; }
 
 private:
     int mID { -1 };
-    nlohmann::json mData;
+    std::string mData;
 };
 
 // TODO: unused now, remove?

src/Client.cpp

@@ -57,7 +57,7 @@ int TClient::GetOpenCarID() const {
     return OpenID;
 }
 
-void TClient::AddNewCar(int Ident, const nlohmann::json& Data) {
+void TClient::AddNewCar(int Ident, const std::string& Data) {
     std::unique_lock lock(mVehicleDataMutex);
     mVehicleData.emplace_back(Ident, Data);
 }
@@ -98,7 +98,7 @@ void TClient::SetCarPosition(int Ident, const std::string& Data) {
     mVehiclePosition[size_t(Ident)] = Data;
 }
 
-nlohmann::json TClient::GetCarData(int Ident) {
+std::string TClient::GetCarData(int Ident) {
     { // lock
         std::unique_lock lock(mVehicleDataMutex);
         for (auto& v : mVehicleData) {
@@ -108,10 +108,10 @@ nlohmann::json TClient::GetCarData(int Ident) {
         }
     } // unlock
     DeleteCar(Ident);
-    return nlohmann::detail::value_t::null;
+    return "";
 }
 
-void TClient::SetCarData(int Ident, const nlohmann::json& Data) {
+void TClient::SetCarData(int Ident, const std::string& Data) {
     { // lock
         std::unique_lock lock(mVehicleDataMutex);
         for (auto& v : mVehicleData) {

src/Env.cpp

@@ -39,9 +39,6 @@ std::string_view Env::ToString(Env::Key key) {
     case Key::PROVIDER_PORT_ENV:
         return "BEAMMP_PROVIDER_PORT_ENV";
         break;
-    case Key::PROVIDER_IP_ENV:
-        return "BEAMMP_PROVIDER_IP_ENV";
-        break;
     }
     return "";
 }

src/LuaAPI.cpp

@@ -241,48 +241,6 @@ std::pair<bool, std::string> LuaAPI::MP::SendNotification(int ID, const std::str
     return Result;
 }
 
-std::pair<bool, std::string> LuaAPI::MP::ConfirmationDialog(int ID, const std::string& Title, const std::string& Body, const sol::table& buttons, const std::string& InteractionID, const bool& warning, const bool& reportToServer, const bool& reportToExtensions) {
-    std::pair<bool, std::string> Result;
-
-    const nlohmann::json PacketBody = {
-        { "title", Title },
-        { "body", Body },
-        { "buttons", nlohmann::json::parse(JsonEncode(buttons), nullptr, false) },
-        { "interactionID", InteractionID },
-        { "class", warning ? "experimental" : "" },
-        { "reportToServer", reportToServer },
-        { "reportToExtensions", reportToExtensions }
-    };
-
-    std::string Packet = "D" + PacketBody.dump();
-    if (ID == -1) {
-        Engine->Network().SendToAll(nullptr, StringToVector(Packet), true, true);
-        Result.first = true;
-    } else {
-        auto MaybeClient = GetClient(Engine->Server(), ID);
-        if (MaybeClient) {
-            auto c = MaybeClient.value().lock();
-            if (!c->IsSynced()) {
-                Result.first = false;
-                Result.second = "Player is not synced yet";
-                return Result;
-            }
-            if (!Engine->Network().Respond(*c, StringToVector(Packet), true)) {
-                beammp_errorf("Failed to send confirmation dialog to player (id {}) - did the player disconnect?", ID);
-                Result.first = false;
-                Result.second = "Failed to send packet";
-            }
-            Result.first = true;
-        } else {
-            beammp_lua_error("ConfirmationDialog invalid argument [1] invalid ID");
-            Result.first = false;
-            Result.second = "Invalid Player ID";
-        }
-        return Result;
-    }
-    return Result;
-}
-
 std::pair<bool, std::string> LuaAPI::MP::RemoveVehicle(int PID, int VID) {
     std::pair<bool, std::string> Result;
     auto MaybeClient = GetClient(Engine->Server(), PID);
@@ -293,7 +251,7 @@ std::pair<bool, std::string> LuaAPI::MP::RemoveVehicle(int PID, int VID) {
         return Result;
     }
     auto c = MaybeClient.value().lock();
-    if (c->GetCarData(VID) != nlohmann::detail::value_t::null) {
+    if (!c->GetCarData(VID).empty()) {
         std::string Destroy = "Od:" + std::to_string(PID) + "-" + std::to_string(VID);
         LuaAPI::MP::Engine->ReportErrors(LuaAPI::MP::Engine->TriggerEvent("onVehicleDeleted", "", PID, VID));
         Engine->Network().SendToAll(nullptr, StringToVector(Destroy), true, true);

src/TConfig.cpp

@@ -258,11 +258,7 @@ void TConfig::ParseFromFile(std::string_view name) {
         } else {
             TryReadValue(data, "General", StrPort, EnvStrPort, Settings::Key::General_Port);
         }
-        if (Env::Get(Env::Key::PROVIDER_IP_ENV).has_value()) {
-            TryReadValue(data, "General", StrIP, Env::Get(Env::Key::PROVIDER_IP_ENV).value(), Settings::Key::General_IP);
-        } else {
         TryReadValue(data, "General", StrIP, EnvStrIP, Settings::Key::General_IP);
-        }
         TryReadValue(data, "General", StrMaxCars, EnvStrMaxCars, Settings::Key::General_MaxCars);
         TryReadValue(data, "General", StrMaxPlayers, EnvStrMaxPlayers, Settings::Key::General_MaxPlayers);
         TryReadValue(data, "General", StrMap, EnvStrMap, Settings::Key::General_Map);
@@ -313,7 +309,6 @@ void TConfig::PrintDebug() {
     beammp_debug(std::string(StrPrivate) + ": " + std::string(Application::Settings.getAsBool(Settings::Key::General_Private) ? "true" : "false"));
     beammp_debug(std::string(StrInformationPacket) + ": " + std::string(Application::Settings.getAsBool(Settings::Key::General_InformationPacket) ? "true" : "false"));
     beammp_debug(std::string(StrPort) + ": " + std::to_string(Application::Settings.getAsInt(Settings::Key::General_Port)));
-    beammp_debug(std::string(StrIP) + ": \"" + Application::Settings.getAsString(Settings::Key::General_IP) + "\"");
     beammp_debug(std::string(StrMaxCars) + ": " + std::to_string(Application::Settings.getAsInt(Settings::Key::General_MaxCars)));
     beammp_debug(std::string(StrMaxPlayers) + ": " + std::to_string(Application::Settings.getAsInt(Settings::Key::General_MaxPlayers)));
     beammp_debug(std::string(StrMap) + ": \"" + Application::Settings.getAsString(Settings::Key::General_Map) + "\"");

src/TConsole.cpp

@@ -24,7 +24,6 @@
 #include "CustomAssert.h"
 #include "LuaAPI.h"
 #include "TLuaEngine.h"
-#include "Http.h"
 
 #include <ctime>
 #include <lua.hpp>
@@ -218,9 +217,7 @@ void TConsole::Command_Help(const std::string&, const std::vector<std::string>&
         settings [command]      sets or gets settings for the server, run `settings help` for more info
         status                  how the server is doing and what it's up to
         clear                   clears the console window
-        version                    displays the server version
-        protectmod <name> <value>  sets whether a mod is protected, value can be true or false
-        reloadmods                 reloads all mods from the Resources Client folder)";
+        version                 displays the server version)";
     Application::Console().WriteRaw("BeamMP-Server Console: " + std::string(sHelpString));
 }
 
@@ -265,56 +262,6 @@ void TConsole::Command_Version(const std::string& cmd, const std::vector<std::st
     std::string openssl_version = fmt::format("OpenSSL:  v{}.{}.{}", OPENSSL_VERSION_MAJOR, OPENSSL_VERSION_MINOR, OPENSSL_VERSION_PATCH);
     Application::Console().WriteRaw(openssl_version);
 }
-void TConsole::Command_ProtectMod(const std::string& cmd, const std::vector<std::string>& args) {
-    if (!EnsureArgsCount(args, 2)) {
-        return;
-    }
-
-    const auto& ModName = args.at(0);
-    const auto& Protect = args.at(1);
-
-    for (auto mod : mLuaEngine->Network().ResourceManager().GetMods()) {
-        if (mod["file_name"].get<std::string>() == ModName) {
-            mLuaEngine->Network().ResourceManager().SetProtected(ModName, Protect == "true");
-            Application::Console().WriteRaw("Mod " + ModName + " is now " + (Protect == "true" ? "protected" : "unprotected"));
-            return;
-        }
-    }
-
-    Application::Console().WriteRaw("Mod " + ModName + " not found.");
-}
-void TConsole::Command_ReloadMods(const std::string& cmd, const std::vector<std::string>& args) {
-    if (!EnsureArgsCount(args, 0)) {
-        return;
-    }
-
-    mLuaEngine->Network().ResourceManager().RefreshFiles();
-    Application::Console().WriteRaw("Mods reloaded.");
-}
-
-void TConsole::Command_NetTest(const std::string& cmd, const std::vector<std::string>& args) {
-    unsigned int status = 0;
-
-    std::string T = Http::GET(
-    Application::GetServerCheckUrl() + "/api/v2/beammp/" + std::to_string(Application::Settings.getAsInt(Settings::Key::General_Port)), &status
-        );
-
-    beammp_debugf("Status and response from Server Check API: {0}, {1}", status, T);
-
-    auto Doc = nlohmann::json::parse(T, nullptr, false);
-
-    if (Doc.is_discarded() || !Doc.is_object()) {
-        beammp_warn("Failed to parse Server Check API response, however the server will most likely still work correctly.");
-    } else {
-        std::string status = Doc["status"];
-        std::string details = "Response from Server Check API: " + std::string(Doc["details"]);
-        if (status == "ok") {
-            beammp_info(details);
-        } else {
-            beammp_warn(details);
-        }
-    }
-}
 
 void TConsole::Command_Kick(const std::string&, const std::vector<std::string>& args) {
     if (!EnsureArgsCount(args, 1, size_t(-1))) {

src/TLuaEngine.cpp

@@ -668,7 +668,7 @@ sol::table TLuaEngine::StateThreadData::Lua_GetPlayerVehicles(int ID) {
         sol::state_view StateView(mState);
         sol::table Result = StateView.create_table();
         for (const auto& v : VehicleData) {
-            Result[v.ID()] = v.DataAsPacket(Client->GetRoles(), Client->GetName(), Client->GetID()).substr(3);
+            Result[v.ID()] = v.Data().substr(3);
         }
         return Result;
     } else
@@ -876,12 +876,6 @@ TLuaEngine::StateThreadData::StateThreadData(const std::string& Name, TLuaStateI
             beammp_lua_error("SendNotification expects 2, 3 or 4 arguments.");
         }
     });
-    MPTable.set_function("ConfirmationDialog", sol::overload(
-        &LuaAPI::MP::ConfirmationDialog,
-        [&](const int& ID, const std::string& Title, const std::string& Body, const sol::table& Buttons, const std::string& InteractionID) {
-            LuaAPI::MP::ConfirmationDialog(ID, Title, Body, Buttons, InteractionID);
-        }
-    ));
     MPTable.set_function("GetPlayers", [&]() -> sol::table {
         return Lua_GetPlayers();
     });

src/TNetwork.cpp

@@ -786,7 +786,7 @@ void TNetwork::Parse(TClient& c, const std::vector<uint8_t>& Packet) {
     case 'S':
         if (SubCode == 'R') {
             beammp_debug("Sending Mod Info");
-            std::string ToSend = mResourceManager.GetMods().dump();
+            std::string ToSend = mResourceManager.NewFileList();
             beammp_debugf("Mod Info: {}", ToSend);
             if (!TCPSend(c, StringToVector(ToSend))) {
                 ClientKick(c, "TCP Send 'SY' failed");
@@ -808,15 +808,6 @@ void TNetwork::SendFile(TClient& c, const std::string& UnsafeName) {
         return;
     }
     auto FileName = fs::path(UnsafeName).filename().string();
-
-    for (auto mod : mResourceManager.GetMods()) {
-        if (mod["file_name"].get<std::string>() == FileName && mod["protected"] == true) {
-            beammp_warn("Client tried to access protected file " + UnsafeName);
-            c.Disconnect("Mod is protected thus cannot be downloaded");
-            return;
-        }
-    }
-
     FileName = Application::Settings.getAsString(Settings::Key::General_ResourceFolder) + "/Client/" + FileName;
 
     if (!std::filesystem::exists(FileName)) {
@@ -974,7 +965,7 @@ bool TNetwork::SyncClient(const std::weak_ptr<TClient>& c) {
                     res = false;
                     return false;
                 }
-                res = Respond(*LockedClient, StringToVector(v.DataAsPacket(client->GetRoles(), client->GetName(), client->GetID())), true, true);
+                res = Respond(*LockedClient, StringToVector(v.Data()), true, true);
             }
         }
 

src/TResourceManager.cpp

@@ -58,58 +58,22 @@ TResourceManager::TResourceManager() {
     Application::SetSubsystemStatus("ResourceManager", Application::Status::Good);
 }
 
+std::string TResourceManager::NewFileList() const {
+    return mMods.dump();
+}
 void TResourceManager::RefreshFiles() {
     mMods.clear();
     std::unique_lock Lock(mModsMutex);
 
     std::string Path = Application::Settings.getAsString(Settings::Key::General_ResourceFolder) + "/Client";
-
-    nlohmann::json modsDB;
-
-    if (std::filesystem::exists(Path + "/mods.json")) {
-        try {
-            std::ifstream stream(Path + "/mods.json");
-
-            stream >> modsDB;
-
-            stream.close();
-        } catch (const std::exception& e) {
-            beammp_errorf("Failed to load mods.json: {}", e.what());
-        }
-    }
-
     for (const auto& entry : fs::directory_iterator(Path)) {
         std::string File(entry.path().string());
 
-        if (entry.path().filename().string() == "mods.json") {
-            continue;
-        }
-
         if (entry.path().extension() != ".zip" || std::filesystem::is_directory(entry.path())) {
             beammp_warnf("'{}' is not a ZIP file and will be ignored", File);
             continue;
         }
 
-        if (modsDB.contains(entry.path().filename().string())) {
-            auto& dbEntry = modsDB[entry.path().filename().string()];
-            if (entry.last_write_time().time_since_epoch().count() > dbEntry["lastwrite"] || std::filesystem::file_size(File) != dbEntry["filesize"].get<size_t>()) {
-                beammp_infof("File '{}' has been modified, rehashing", File);
-            } else {
-                dbEntry["exists"] = true;
-
-                mMods.push_back(nlohmann::json {
-                    { "file_name", std::filesystem::path(File).filename() },
-                    { "file_size", std::filesystem::file_size(File) },
-                    { "hash_algorithm", "sha256" },
-                    { "hash", dbEntry["hash"] },
-                    { "protected", dbEntry["protected"] } });
-
-                beammp_debugf("Mod '{}' loaded from cache", File);
-
-                continue;
-            }
-        }
-
         try {
             EVP_MD_CTX* mdctx;
             const EVP_MD* md;
@@ -169,73 +133,9 @@ void TResourceManager::RefreshFiles() {
                 { "file_size", std::filesystem::file_size(File) },
                 { "hash_algorithm", "sha256" },
                 { "hash", result },
-                { "protected", false } });
-
-            modsDB[std::filesystem::path(File).filename().string()] = {
-                { "lastwrite", entry.last_write_time().time_since_epoch().count() },
-                { "hash", result },
-                { "filesize", std::filesystem::file_size(File) },
-                { "protected", false },
-                { "exists", true }
-            };
-
+            });
         } catch (const std::exception& e) {
             beammp_errorf("Sha256 hashing of '{}' failed: {}", File, e.what());
         }
     }
-
-    for (auto it = modsDB.begin(); it != modsDB.end();) {
-        if (!it.value().contains("exists")) {
-            it = modsDB.erase(it);
-        } else {
-            it.value().erase("exists");
-            ++it;
-        }
-    }
-
-    try {
-        std::ofstream stream(Path + "/mods.json");
-
-        stream << modsDB.dump(4);
-
-        stream.close();
-    } catch (std::exception& e) {
-        beammp_error("Failed to update mod DB: " + std::string(e.what()));
-    }
-}
-
-void TResourceManager::SetProtected(const std::string& ModName, bool Protected) {
-    std::unique_lock Lock(mModsMutex);
-
-    for (auto& mod : mMods) {
-        if (mod["file_name"].get<std::string>() == ModName) {
-            mod["protected"] = Protected;
-            break;
-        }
-    }
-
-    auto modsDBPath = Application::Settings.getAsString(Settings::Key::General_ResourceFolder) + "/Client/mods.json";
-
-    if (std::filesystem::exists(modsDBPath)) {
-        try {
-            nlohmann::json modsDB;
-
-            std::fstream stream(modsDBPath);
-
-            stream >> modsDB;
-
-            if (modsDB.contains(ModName)) {
-                modsDB[ModName]["protected"] = Protected;
-            }
-
-            stream.clear();
-            stream.seekp(0, std::ios::beg);
-
-            stream << modsDB.dump(4);
-
-            stream.close();
-        } catch (const std::exception& e) {
-            beammp_errorf("Failed to update mods.json: {}", e.what());
-        }
-    }
 }

src/TServer.cpp

@@ -195,18 +195,6 @@ void TServer::GlobalParser(const std::weak_ptr<TClient>& Client, std::vector<uin
 
     // V to Y
     if (Code <= 89 && Code >= 86) {
-        int PID = -1;
-        int VID = -1;
-
-        auto MaybePidVid = GetPidVid(StringPacket.substr(3).substr(0, StringPacket.substr(3).find(':', 1)));
-        if (MaybePidVid) {
-            std::tie(PID, VID) = MaybePidVid.value();
-        }
-
-        if (PID == -1 || VID == -1 || PID != LockedClient->GetID()) {
-            return;
-        }
-
         PPSMonitor.IncrementInternalPPS();
         Network.SendToAll(LockedClient.get(), Packet, false, false);
         return;
@@ -267,25 +255,11 @@ void TServer::GlobalParser(const std::weak_ptr<TClient>& Client, std::vector<uin
     case 'N':
         Network.SendToAll(LockedClient.get(), Packet, false, true);
         return;
-    case 'Z': { // position packet
+    case 'Z': // position packet
         PPSMonitor.IncrementInternalPPS();
-
-        int PID = -1;
-        int VID = -1;
-
-        auto MaybePidVid = GetPidVid(StringPacket.substr(3).substr(0, StringPacket.substr(3).find(':', 1)));
-        if (MaybePidVid) {
-            std::tie(PID, VID) = MaybePidVid.value();
-        }
-
-        if (PID == -1 || VID == -1 || PID != LockedClient->GetID()) {
-            return;
-        }
-
         Network.SendToAll(LockedClient.get(), Packet, false, false);
         HandlePosition(*LockedClient, StringPacket);
         return;
-    }
     default:
         return;
     }
@@ -354,9 +328,8 @@ void TServer::ParseVehicle(TClient& c, const std::string& Pckt, TNetwork& Networ
                 });
 
             bool SpawnConfirmed = false;
-            auto CarJsonDoc = nlohmann::json::parse(CarJson, nullptr, false);
-            if (ShouldSpawn(c, CarJson, CarID) && !ShouldntSpawn && !CarJsonDoc.is_discarded()) {
-                c.AddNewCar(CarID, CarJsonDoc);
+            if (ShouldSpawn(c, CarJson, CarID) && !ShouldntSpawn) {
+                c.AddNewCar(CarID, Packet);
                 Network.SendToAll(nullptr, StringToVector(Packet), true, true);
                 SpawnConfirmed = true;
             } else {
@@ -473,17 +446,6 @@ void TServer::ParseVehicle(TClient& c, const std::string& Pckt, TNetwork& Networ
             Data = Data.substr(Data.find('['));
             LuaAPI::MP::Engine->ReportErrors(LuaAPI::MP::Engine->TriggerEvent("onVehiclePaintChanged", "", c.GetID(), VID, Data));
             Network.SendToAll(&c, StringToVector(Packet), false, true);
-
-            auto CarData = c.GetCarData(VID);
-            if (CarData == nlohmann::detail::value_t::null)
-                return;
-
-            if (CarData.contains("vcf") && CarData.at("vcf").is_object())
-                if (CarData.at("vcf").contains("paints") && CarData.at("vcf").at("paints").is_array()) {
-                    CarData.at("vcf")["paints"] = nlohmann::json::parse(Data);
-                    c.SetCarData(VID, CarData);
-                }
-
         }
         return;
     }
@@ -499,22 +461,42 @@ void TServer::Apply(TClient& c, int VID, const std::string& pckt) {
         beammp_error("Malformed packet received, no '{' found");
         return;
     }
-
     std::string Packet = pckt.substr(FoundPos);
-    nlohmann::json VD = c.GetCarData(VID);
-    if (VD == nlohmann::detail::value_t::null) {
+    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('{'));
 
-    nlohmann::json Pack = nlohmann::json::parse(Packet, nullptr, false);
-
-    if (Pack.is_discarded()) {
+    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;
     }
 
-    c.SetCarData(VID, Pack);
+    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) {

src/VehicleData.cpp

@@ -21,7 +21,7 @@
 #include "Common.h"
 #include <utility>
 
-TVehicleData::TVehicleData(int ID, nlohmann::json Data)
+TVehicleData::TVehicleData(int ID, std::string Data)
     : mID(ID)
     , mData(std::move(Data)) {
     beammp_trace("vehicle " + std::to_string(mID) + " constructed");
@@ -30,7 +30,3 @@ TVehicleData::TVehicleData(int ID, nlohmann::json Data)
 TVehicleData::~TVehicleData() {
     beammp_trace("vehicle " + std::to_string(mID) + " destroyed");
 }
-
-std::string TVehicleData::DataAsPacket(const std::string& Role, const std::string& Name, const int ID) const {
-    return "Os:" + Role + ":" + Name + ":" + std::to_string(ID) + "-" + std::to_string(this->mID) + ":" + this->mData.dump();
-}