Add player addons scores info

src/network/protocols/server_lobby.cpp

@@ -3020,9 +3020,58 @@ bool ServerLobby::handleAssets(const NetworkString& ns, STKPeer* peer) const
         return false;
     }
 
+    std::array<int, AS_TOTAL> addons_scores = {{ -1, -1, -1, -1 }};
+    size_t addon_kart = 0;
+    size_t addon_track = 0;
+    size_t addon_arena = 0;
+    size_t addon_soccer = 0;
+
+    for (auto& kart : m_addon_kts.first)
+    {
+        if (client_karts.find(kart) != client_karts.end())
+            addon_kart++;
+    }
+    for (auto& track : m_addon_kts.second)
+    {
+        if (client_tracks.find(track) != client_tracks.end())
+            addon_track++;
+    }
+    for (auto& arena : m_addon_arenas)
+    {
+        if (client_tracks.find(arena) != client_tracks.end())
+            addon_arena++;
+    }
+    for (auto& soccer : m_addon_soccers)
+    {
+        if (client_tracks.find(soccer) != client_tracks.end())
+            addon_soccer++;
+    }
+
+    if (!m_addon_kts.first.empty())
+    {
+        addons_scores[AS_KART] = int
+            ((float)addon_kart / (float)m_addon_kts.first.size() * 100.0);
+    }
+    if (!m_addon_kts.second.empty())
+    {
+        addons_scores[AS_TRACK] = int
+            ((float)addon_track / (float)m_addon_kts.second.size() * 100.0);
+    }
+    if (!m_addon_arenas.empty())
+    {
+        addons_scores[AS_ARENA] = int
+            ((float)addon_arena / (float)m_addon_arenas.size() * 100.0);
+    }
+    if (!m_addon_soccers.empty())
+    {
+        addons_scores[AS_SOCCER] = int
+            ((float)addon_soccer / (float)m_addon_soccers.size() * 100.0);
+    }
+
     // Save available karts and tracks from clients in STKPeer so if this peer
     // disconnects later in lobby it won't affect current players
     peer->setAvailableKartsTracks(client_karts, client_tracks);
+    peer->setAddonsScores(addons_scores);
     return true;
 }   // handleAssets
 
@@ -5000,6 +5049,49 @@ void ServerLobby::handleServerCommand(Event* event, STKPeer* peer) const
         peer->sendPacket(chat, true/*reliable*/);
         delete chat;
     }
+    else if (StringUtils::startsWith(cmd, "playeraddonscore"))
+    {
+        NetworkString* chat = getNetworkString();
+        chat->addUInt8(LE_CHAT);
+        chat->setSynchronous(true);
+        std::string player_name;
+        if (cmd.length() > 17)
+            player_name = cmd.substr(17);
+        std::shared_ptr<STKPeer> player_peer = STKHost::get()->findPeerByName(
+            StringUtils::utf8ToWide(player_name));
+        if (player_name.empty() || !player_peer)
+        {
+            chat->encodeString16(
+                L"Usage: /playeraddonscore [player name] (return 0-100)");
+        }
+        else
+        {
+            auto& scores = player_peer->getAddonsScores();
+            if (scores[AS_KART] == -1 && scores[AS_TRACK] == -1 &&
+                scores[AS_ARENA] == -1 && scores[AS_SOCCER] == -1)
+            {
+                chat->encodeString16(StringUtils::utf8ToWide
+                    (player_name + " has no addon"));
+            }
+            else
+            {
+                std::string msg = player_name;
+                msg += " addon:";
+                if (scores[AS_KART] != -1)
+                    msg += " kart: " + StringUtils::toString(scores[AS_KART]) + ",";
+                if (scores[AS_TRACK] != -1)
+                    msg += " track: " + StringUtils::toString(scores[AS_TRACK]) + ",";
+                if (scores[AS_ARENA] != -1)
+                    msg += " arena: " + StringUtils::toString(scores[AS_ARENA]) + ",";
+                if (scores[AS_SOCCER] != -1)
+                    msg += " soccer: " + StringUtils::toString(scores[AS_SOCCER]) + ",";
+                msg = msg.substr(0, msg.size() - 1);
+                chat->encodeString16(StringUtils::utf8ToWide(msg));
+            }
+        }
+        peer->sendPacket(chat, true/*reliable*/);
+        delete chat;
+    }
     else if (argv[0] == "serverhasaddon")
     {
         NetworkString* chat = getNetworkString();

src/network/stk_peer.cpp

@@ -37,6 +37,7 @@
 STKPeer::STKPeer(ENetPeer *enet_peer, STKHost* host, uint32_t host_id)
        : m_peer_address(enet_peer->address), m_host(host)
 {
+    m_addons_scores.fill(-1);
     // We use 0.x.x.x ip to map to IPv6 address internally
     if (m_peer_address.getIP() < 16777216)
         m_ipv6_address = getIPV6ReadableFromMappedAddress(&enet_peer->address);

src/network/stk_peer.hpp

@@ -30,6 +30,7 @@
 
 #include <enet/enet.h>
 
+#include <array>
 #include <atomic>
 #include <deque>
 #include <memory>
@@ -52,6 +53,15 @@ enum PeerDisconnectInfo : unsigned int
     PDI_KICK_HIGH_PING = 3, //!< Too high ping, kicked by server
 };   // PeerDisconnectInfo
 
+enum AddonScore : int
+{
+    AS_KART = 0,
+    AS_TRACK = 1,
+    AS_ARENA = 2,
+    AS_SOCCER = 3,
+    AS_TOTAL = 4,
+};   // AddonScore
+
 /*! \class STKPeer
  *  \brief Represents a peer.
  *  This class is used to interface the ENetPeer structure.
@@ -108,6 +118,7 @@ protected:
      *  features available in same version. */
     std::set<std::string> m_client_capabilities;
 
+    std::array<int, AS_TOTAL> m_addons_scores;
 public:
     STKPeer(ENetPeer *enet_peer, STKHost* host, uint32_t host_id);
     // ------------------------------------------------------------------------
@@ -256,6 +267,12 @@ public:
     void setPacketLoss(int loss)                 { m_packet_loss.store(loss); }
     // ------------------------------------------------------------------------
     int getPacketLoss() const                  { return m_packet_loss.load(); }
+    // ------------------------------------------------------------------------
+    const std::array<int, AS_TOTAL>& getAddonsScores() const
+                                                    { return m_addons_scores; }
+    // ------------------------------------------------------------------------
+    void setAddonsScores(const std::array<int, AS_TOTAL>& scores)
+                                                  { m_addons_scores = scores; }
 };   // STKPeer
 
 #endif // STK_PEER_HPP