Refactor server list

src/openrct2/network/ServerList.cpp

@@ -11,18 +11,122 @@
 
 #include "../Context.h"
 #include "../PlatformEnvironment.h"
+#include "../config/Config.h"
 #include "../core/FileStream.hpp"
+#include "../core/Json.hpp"
 #include "../core/Memory.hpp"
 #include "../core/Path.hpp"
 #include "../core/String.hpp"
+#include "../network/Http.h"
 #include "../platform/platform.h"
+#include "UdpSocket.h"
+#include "network.h"
+
+#include <algorithm>
+#include <numeric>
 
 using namespace OpenRCT2;
+using namespace OpenRCT2::Network;
 
-std::vector<server_entry> server_list_read()
+int32_t ServerListEntry::CompareTo(const ServerListEntry& other) const
+{
+    const auto& a = *this;
+    const auto& b = other;
+
+    // Order by favourite
+    if (a.favourite != b.favourite)
+    {
+        return a.favourite ? -1 : 1;
+    }
+
+    // Then by version
+    bool serverACompatible = a.version == network_get_version();
+    bool serverBCompatible = b.version == network_get_version();
+    if (serverACompatible != serverBCompatible)
+    {
+        return serverACompatible ? 1 : -1;
+    }
+
+    // Then by password protection
+    if (a.requiresPassword != b.requiresPassword)
+    {
+        return a.requiresPassword ? -1 : 1;
+    }
+
+    // Then by name
+    return String::Compare(a.name, b.name, true);
+}
+
+bool ServerListEntry::IsVersionValid() const
+{
+    return version.empty() || version == network_get_version();
+}
+
+std::optional<ServerListEntry> ServerListEntry::FromJson(const json_t* server)
+{
+    auto port = json_object_get(server, "port");
+    auto name = json_object_get(server, "name");
+    auto description = json_object_get(server, "description");
+    auto requiresPassword = json_object_get(server, "requiresPassword");
+    auto version = json_object_get(server, "version");
+    auto players = json_object_get(server, "players");
+    auto maxPlayers = json_object_get(server, "maxPlayers");
+    auto ip = json_object_get(server, "ip");
+    auto ip4 = json_object_get(ip, "v4");
+    auto addressIp = json_array_get(ip4, 0);
+
+    if (name == nullptr || version == nullptr)
+    {
+        log_verbose("Cowardly refusing to add server without name or version specified.");
+        return {};
+    }
+    else
+    {
+        ServerListEntry entry;
+        entry.address = String::StdFormat("%s:%d", json_string_value(addressIp), (int32_t)json_integer_value(port));
+        entry.name = (name == nullptr ? "" : json_string_value(name));
+        entry.description = (description == nullptr ? "" : json_string_value(description));
+        entry.version = json_string_value(version);
+        entry.requiresPassword = json_is_true(requiresPassword);
+        entry.players = (uint8_t)json_integer_value(players);
+        entry.maxplayers = (uint8_t)json_integer_value(maxPlayers);
+        return entry;
+    }
+}
+
+void ServerList::Sort()
+{
+    std::sort(_serverEntries.begin(), _serverEntries.end(), [](const ServerListEntry& a, const ServerListEntry& b) {
+        return a.CompareTo(b) > 0;
+    });
+}
+
+ServerListEntry& ServerList::GetServer(size_t index)
+{
+    return _serverEntries[index];
+}
+
+size_t ServerList::GetCount() const
+{
+    return _serverEntries.size();
+}
+
+void ServerList::Add(const ServerListEntry& entry)
+{
+    _serverEntries.push_back(entry);
+    Sort();
+}
+
+void ServerList::AddRange(const std::vector<ServerListEntry>& entries)
+{
+    _serverEntries.insert(_serverEntries.end(), entries.begin(), entries.end());
+    Sort();
+}
+
+std::vector<ServerListEntry> ServerList::ReadFavourites()
 {
     log_verbose("server_list_read(...)");
-    std::vector<server_entry> entries;
+    std::vector<ServerListEntry> entries;
     try
     {
         auto env = GetContext()->GetPlatformEnvironment();
@@ -33,7 +137,7 @@ std::vector<server_entry> server_list_read()
             auto numEntries = fs.ReadValue<uint32_t>();
             for (size_t i = 0; i < numEntries; i++)
             {
-                server_entry serverInfo;
+                ServerListEntry serverInfo;
                 serverInfo.address = fs.ReadStdString();
                 serverInfo.name = fs.ReadStdString();
                 serverInfo.requiresPassword = false;
@@ -49,12 +153,32 @@ std::vector<server_entry> server_list_read()
     catch (const std::exception& e)
     {
         log_error("Unable to read server list: %s", e.what());
-        entries = std::vector<server_entry>();
+        entries = std::vector<ServerListEntry>();
     }
     return entries;
 }
 
-bool server_list_write(const std::vector<server_entry>& entries)
+void ServerList::ReadAndAddFavourites()
+{
+    _serverEntries.erase(
+        std::remove_if(
+            _serverEntries.begin(), _serverEntries.end(), [](const ServerListEntry& entry) { return entry.favourite; }),
+        _serverEntries.end());
+    auto entries = ReadFavourites();
+    AddRange(entries);
+}
+
+void ServerList::WriteFavourites()
+{
+    // Save just favourite servers
+    std::vector<ServerListEntry> favouriteServers;
+    std::copy_if(
+        _serverEntries.begin(), _serverEntries.end(), std::back_inserter(favouriteServers),
+        [](const ServerListEntry& entry) { return entry.favourite; });
+    WriteFavourites(favouriteServers);
+}
+
+bool ServerList::WriteFavourites(const std::vector<ServerListEntry>& entries)
 {
     log_verbose("server_list_write(%d, 0x%p)", entries.size(), entries.data());
 
@@ -80,3 +204,131 @@ bool server_list_write(const std::vector<server_entry>& entries)
         return false;
     }
 }
+
+std::future<std::vector<ServerListEntry>> ServerList::FetchLocalServerListAsync()
+{
+    return std::async([] {
+        constexpr auto RECV_DELAY_MS = 10;
+        constexpr auto RECV_WAIT_MS = 2000;
+
+        std::vector<ServerListEntry> entries;
+        std::string msg = "Are you an OpenRCT2 server?";
+        auto udpSocket = CreateUdpSocket();
+        auto len = udpSocket->SendData("192.168.1.255", 11754, msg.data(), msg.size());
+        if (len != msg.size())
+        {
+            throw std::runtime_error("Unable to broadcast server query.");
+        }
+
+        char buffer[1024]{};
+        size_t recievedLen{};
+        std::unique_ptr<INetworkEndpoint> endpoint;
+        for (int i = 0; i < (RECV_WAIT_MS / RECV_DELAY_MS); i++)
+        {
+            auto p = udpSocket->ReceiveData(buffer, sizeof(buffer) - 1, &recievedLen, &endpoint);
+            if (p == NETWORK_READPACKET_SUCCESS)
+            {
+                auto sender = endpoint->GetHostname();
+                std::printf(">> Recieved packet from %s\n", sender.c_str());
+                auto jinfo = Json::FromString(std::string_view(buffer));
+
+                auto ip4 = json_array();
+                json_array_append_new(ip4, json_string(sender.c_str()));
+                auto ip = json_object();
+                json_object_set_new(ip, "v4", ip4);
+                json_object_set_new(jinfo, "ip", ip);
+
+                auto entry = ServerListEntry::FromJson(jinfo);
+                if (entry.has_value())
+                {
+                    entries.push_back(entry.value());
+                }
+
+                json_decref(jinfo);
+            }
+            platform_sleep(RECV_DELAY_MS);
+        }
+
+        return entries;
+    });
+}
+
+std::future<std::vector<ServerListEntry>> ServerList::FetchOnlineServerListAsync()
+{
+#ifdef DISABLE_HTTP
+    return std::async(std::launch::deferred, [] { return std::vector<ServerListEntry>(); });
+#else
+    auto p = std::make_shared<std::promise<std::vector<ServerListEntry>>>();
+    auto f = p->get_future();
+
+    std::string masterServerUrl = OPENRCT2_MASTER_SERVER_URL;
+    if (!gConfigNetwork.master_server_url.empty())
+    {
+        masterServerUrl = gConfigNetwork.master_server_url;
+    }
+
+    Http::Request request;
+    request.url = masterServerUrl;
+    request.method = Http::Method::GET;
+    request.header["Accept"] = "application/json";
+    Http::DoAsync(request, [p](Http::Response& response) -> void {
+        json_t* root{};
+        try
+        {
+            if (response.status != Http::Status::OK)
+            {
+                throw MasterServerException(STR_SERVER_LIST_NO_CONNECTION);
+            }
+
+            root = Json::FromString(response.body);
+            auto jsonStatus = json_object_get(root, "status");
+            if (!json_is_number(jsonStatus))
+            {
+                throw MasterServerException(STR_SERVER_LIST_INVALID_RESPONSE_JSON_NUMBER);
+            }
+
+            auto status = (int32_t)json_integer_value(jsonStatus);
+            if (status != 200)
+            {
+                throw MasterServerException(STR_SERVER_LIST_MASTER_SERVER_FAILED);
+            }
+
+            auto jServers = json_object_get(root, "servers");
+            if (!json_is_array(jServers))
+            {
+                throw MasterServerException(STR_SERVER_LIST_INVALID_RESPONSE_JSON_ARRAY);
+            }
+
+            std::vector<ServerListEntry> entries;
+            auto count = json_array_size(jServers);
+            for (size_t i = 0; i < count; i++)
+            {
+                auto jServer = json_array_get(jServers, i);
+                if (json_is_object(jServer))
+                {
+                    auto entry = ServerListEntry::FromJson(jServer);
+                    if (entry.has_value())
+                    {
+                        entries.push_back(entry.value());
+                    }
+                }
+            }
+
+            p->set_value(entries);
+        }
+        catch (...)
+        {
+            p->set_exception(std::current_exception());
+        }
+        json_decref(root);
+    });
+    return f;
+#endif
+}
+
+uint32_t ServerList::GetTotalPlayerCount() const
+{
+    return std::accumulate(_serverEntries.begin(), _serverEntries.end(), 0, [](uint32_t acc, const ServerListEntry& entry) {
+        return acc + entry.players;
+    });
+}