Put temporary teams in a separate unit utils/team_utils.*

Also remove unused code and fix inconsistent indexation inside temporary teams

Author: kimden

src/network/network_player_profile.cpp

@@ -20,8 +20,6 @@
 #include "network/network_config.hpp"
 #include "network/stk_host.hpp"
 
-float NetworkPlayerProfile::m_team_color[20] = {1.00, 0.05, 0.16, 0.33, 0.66, 0.78, 0.46, 0.94, 0.58, 0.00};
-
 // ----------------------------------------------------------------------------
 /** Returns true if this player is local, i.e. running on this computer. This
  *  is done by comparing the host id of this player with the host id of this

src/network/network_player_profile.hpp

@@ -23,6 +23,7 @@
 #define HEADER_NETWORK_PLAYER_PROFILE
 
 #include "network/kart_data.hpp"
+#include "utils/team_utils.hpp"
 #include "utils/types.hpp"
 
 #include "irrString.h"
@@ -75,8 +76,6 @@ class NetworkPlayerProfile
 
     int m_temporary_team;
 
-    static float m_team_color[20];
-
     KartData m_kart_data;
 public:
     // ------------------------------------------------------------------------
@@ -97,7 +96,7 @@ class NetworkPlayerProfile
         m_handicap.store((HandicapLevel)0);
         m_local_player_id       = 0;
         m_team.store(team);
-        m_temporary_team        = -1;
+        m_temporary_team        = 0;
         resetGrandPrixData();
     }
     // ------------------------------------------------------------------------
@@ -117,7 +116,7 @@ class NetworkPlayerProfile
         m_local_player_id       = local_player_id;
         m_team.store(team);
         m_country_code          = country_code;
-        m_temporary_team        = -1;
+        m_temporary_team        = 0;
         resetGrandPrixData();
     }
     // ------------------------------------------------------------------------
@@ -151,9 +150,9 @@ class NetworkPlayerProfile
     // ------------------------------------------------------------------------
     float getDefaultKartColor() const
     {
-        if (m_temporary_team == -1)
+        if (m_temporary_team == 0)
             return m_default_kart_color;
-        return m_team_color[m_temporary_team];
+        return TeamUtils::getTeamByIndex(m_temporary_team).getColor();
     }
     // ------------------------------------------------------------------------
     uint32_t getOnlineId() const                        { return m_online_id; }

src/network/protocols/command_manager.cpp

@@ -2739,15 +2739,15 @@ void CommandManager::process_swapteams(Context& context)
     std::map<int, int> permutation_map_int;
     for (char c: argv[1])
     {
-        std::string type(1, c);
         // todo remove that link to first char, it is awful
-        if (m_lobby->m_team_name_to_index.count(type) == 0)
+        // on the other hand, I'd better have roygbpcms than r,o,y,g,b,words
+        // so let it stay like that for now
+        std::string type(1, c);
+        int index = TeamUtils::getIndexByCode(type);
+        if (index == 0)
             continue;
-        int index = m_lobby->m_team_name_to_index[type];
-        char c1 = m_lobby->m_team_default_names[index][0];
-        if (m_lobby->m_team_name_to_index.count(type)) {
-            permutation_map[c1] = 0;
-        }
+        char c1 = TeamUtils::getTeamByIndex(index).getPrimaryCode()[0];
+        permutation_map[c1] = 0;
     }
     std::string permutation;
     for (auto& p: permutation_map)
@@ -2769,8 +2769,8 @@ void CommandManager::process_swapteams(Context& context)
     }
     for (auto& p: permutation_map)
     {
-        int from = m_lobby->m_team_name_to_index[std::string(1, p.first)];
-        int to = m_lobby->m_team_name_to_index[std::string(1, p.second)];
+        int from = TeamUtils::getIndexByCode(std::string(1, p.first));
+        int to = TeamUtils::getIndexByCode(std::string(1, p.second));
         permutation_map_int[from] = to;
     }
     m_lobby->shuffleTemporaryTeams(permutation_map_int);
@@ -2812,20 +2812,21 @@ void CommandManager::process_randomteams(Context& context)
             continue;
         players_number += p->getPlayerProfiles().size();
         for (auto& profile : p->getPlayerProfiles())
-            profile->setTemporaryTeam(-1);
+            profile->setTemporaryTeam(0);
     }
     if (players_number == 0) {
         std::string msg = "No one can play!";
         m_lobby->sendStringToPeer(msg, peer);
         return;
     }
     int teams_number = -1;
+    int max_number_of_teams = TeamUtils::getNumberOfTeams();
     if (argv.size() < 2 || !StringUtils::parseString(argv[1], &teams_number)
-        || teams_number < 1 || teams_number > 9)
+        || teams_number < 1 || teams_number > max_number_of_teams)
     {
         teams_number = (int)round(sqrt(players_number));
-        if (teams_number > 9)
-            teams_number = 9;
+        if (teams_number > max_number_of_teams)
+            teams_number = max_number_of_teams;
         if (players_number > 1 && teams_number <= 1)
             teams_number = 2;
     }
@@ -2834,7 +2835,7 @@ void CommandManager::process_randomteams(Context& context)
             "Created %d teams for %d players", teams_number, players_number);
     std::vector<int> available_colors;
     std::vector<int> profile_colors;
-    for (int i = 1; i <= 9; ++i)
+    for (int i = 1; i <= max_number_of_teams; ++i)
         available_colors.push_back(i);
 
     std::random_device rd;
@@ -2856,7 +2857,7 @@ void CommandManager::process_randomteams(Context& context)
             continue;
         for (auto& profile : p->getPlayerProfiles()) {
             std::string name = StringUtils::wideToUtf8(profile->getName());
-            std::string color = m_lobby->m_team_default_names[profile_colors.back()];
+            std::string color = TeamUtils::getTeamByIndex(profile_colors.back()).getPrimaryCode();
             m_lobby->setTemporaryTeam(name, color);
             if (profile_colors.size() > 1) // prevent crash just in case
                 profile_colors.pop_back();

src/network/protocols/command_manager.hpp

@@ -42,6 +42,7 @@
 #include "network/protocols/command_permissions.hpp"
 #include "utils/enum_extended_reader.hpp"
 #include "utils/set_typo_fixer.hpp"
+#include "utils/team_utils.hpp"
 
 class ServerLobby;
 class Event;

src/network/protocols/server_lobby.cpp

@@ -216,51 +216,8 @@ ServerLobby::ServerLobby() : LobbyProtocol()
         ((std::string) ServerConfig::m_help);
 
     m_command_manager = CommandManager(nullptr);
-
-    m_team_name_to_index = {
-           {"red", 1}, {"r", 1},
-        {"orange", 2}, {"o", 2},
-        {"yellow", 3}, {"y", 3},
-         {"green", 4}, {"g", 4},
-          {"blue", 5}, {"b", 5},
-        {"purple", 6}, {"p", 6},
-        {"violet", 6}, {"v", 6},
-          {"cyan", 7}, {"c", 7},
-       {"magenta", 8}, {"m", 8},
-          {"pink", 8},
-           {"sky", 9}, {"s", 9}
-    };
-
-    m_team_default_names = {"none", "red", "orange", "yellow", "green", "blue", "purple", "cyan", "magenta", "sky"};
-
-    m_team_index_to_icon = {
-        {1, StringUtils::utf32ToUtf8({0x1f7e5})},
-        {2, StringUtils::utf32ToUtf8({0x1f7e7})},
-        {3, StringUtils::utf32ToUtf8({0x1f7e8})},
-        {4, StringUtils::utf32ToUtf8({0x1f7e9})},
-        {5, StringUtils::utf32ToUtf8({0x1f7e6})},
-        {6, StringUtils::utf32ToUtf8({0x1f7ea})},
-        {7, StringUtils::utf32ToUtf8({0x1f5fd})},
-        {8, StringUtils::utf32ToUtf8({0x1f338})},
-        {9, StringUtils::utf32ToUtf8({0x2604})}
-    };
-
-    m_team_name = {"No Team",
-        StringUtils::utf32ToUtf8({0x1f7e5}) + "Red",
-        StringUtils::utf32ToUtf8({0x1f7e7}) + "Orange",
-        StringUtils::utf32ToUtf8({0x1f7e8}) + "Yellow",
-        StringUtils::utf32ToUtf8({0x1f7e9}) + "Green",
-        StringUtils::utf32ToUtf8({0x1f7e6}) + "Blue",
-        StringUtils::utf32ToUtf8({0x1f7ea}) + "Purple",
-        StringUtils::utf32ToUtf8({0x1f5fd}) + "Cyan",
-        StringUtils::utf32ToUtf8({0x1f338}) + "Magenta",
-        StringUtils::utf32ToUtf8({ 0x2604}) + "Sky"
-    };
-
     m_shuffle_gp = ServerConfig::m_shuffle_gp;
-
     m_current_max_players_in_game.store(ServerConfig::m_max_players_in_game);
-
     m_consent_on_replays = false;
 
     m_fixed_lap = ServerConfig::m_fixed_lap_count;
@@ -4644,7 +4601,7 @@ void ServerLobby::handleUnencryptedConnection(std::shared_ptr<STKPeer> peer,
         auto it2 = m_team_for_player.find(username);
         if (it2 != m_team_for_player.end())
         {
-            player->setTemporaryTeam(it2->second - 1);
+            player->setTemporaryTeam(it2->second);
         }
         peer->addPlayer(player);
     }
@@ -4964,8 +4921,8 @@ void ServerLobby::updatePlayerList(bool update_when_reset_server)
             prefix = "[" + prefix + "] ";
         }
         int team = profile->getTemporaryTeam();
-        if (team != -1) {
-            prefix = m_team_index_to_icon[team + 1] + " " + prefix;
+        if (team != 0) {
+            prefix = TeamUtils::getTeamByIndex(team).getEmoji() + " " + prefix;
         }
 
         profile_name = StringUtils::utf8ToWide(prefix) + profile_name;
@@ -7146,36 +7103,6 @@ void ServerLobby::initCategories()
             }
         }
     }
-    /*
-    Temporary team indexing:
-    network_player_profile.hpp: -1 for none, [0..5] for teams
-    server config: (-1 for none,) [0..5] for teams
-    server lobby command: 0 for none, [1..6] for teams
-    m_team_for_player: 0 for none, [1..6] for teams
-    Sorry for the confusion.
-    */
-    // change categories according to the teams
-    for (const auto& who: m_team_for_player)
-    {
-        int idx = who.second;
-        std::string player = who.first;
-        for (const auto& pair: m_team_name_to_index)
-        {
-            if (pair.second < 0)
-            {
-                if (pair.second == -idx)
-                {
-                    m_player_categories[pair.first].insert(player);
-                    m_categories_for_player[player].insert(pair.first);
-                }
-                else
-                {
-                    m_player_categories[pair.first].erase(player);
-                    m_categories_for_player[player].erase(pair.first);
-                }
-            }
-        }
-    }
 }   // initCategories
 //-----------------------------------------------------------------------------
 void ServerLobby::initTournamentPlayers()
@@ -7527,7 +7454,7 @@ std::string ServerLobby::getGrandPrixStandings(bool showIndividual, bool showTea
             for (unsigned i = 0; i < results2.size(); i++)
             {
                 response << (i + 1) << ". ";
-                response << "  " << m_team_name[results2[i].second];
+                response << "  " << TeamUtils::getTeamByIndex(results2[i].second).getNameWithEmoji();
                 response << "  " << results2[i].first.score;
                 response << "  " << "(" << StringUtils::timeToString(results2[i].first.time) << ")";
                 response << "\n";
@@ -8165,8 +8092,7 @@ bool ServerLobby::isSoccerGoalTarget() const
 // This should be moved later to another unit.
 void ServerLobby::setTemporaryTeam(const std::string& username, std::string& arg)
 {
-    auto it = m_team_name_to_index.find(arg);
-    int index = (it == m_team_name_to_index.end() ? 0 : it->second);
+    int index = TeamUtils::getIndexByCode(arg);
     m_team_for_player[username] = index;
     irr::core::stringw wide_player_name = StringUtils::utf8ToWide(username);
     std::shared_ptr<STKPeer> player_peer = STKHost::get()->findPeerByName(
@@ -8177,7 +8103,7 @@ void ServerLobby::setTemporaryTeam(const std::string& username, std::string& arg
         {
             if (profile->getName() == wide_player_name)
             {
-                profile->setTemporaryTeam(index - 1);
+                profile->setTemporaryTeam(index);
                 break;
             }
         }
@@ -8192,7 +8118,7 @@ void ServerLobby::clearTemporaryTeams()
 
     for (auto& peer : STKHost::get()->getPeers())
         for (auto& profile : peer->getPlayerProfiles())
-            profile->setTemporaryTeam(-1);
+            profile->setTemporaryTeam(0);
 }   // clearTemporaryTeams
 //-----------------------------------------------------------------------------
 
@@ -8209,9 +8135,9 @@ void ServerLobby::shuffleTemporaryTeams(const std::map<int, int>& permutation)
     {
         for (auto &profile: peer->getPlayerProfiles())
         {
-            auto it = permutation.find(profile->getTemporaryTeam() + 1);
+            auto it = permutation.find(profile->getTemporaryTeam());
             if (it != permutation.end())
-                profile->setTemporaryTeam(it->second - 1);
+                profile->setTemporaryTeam(it->second);
         }
     }
     auto old_scores = m_gp_team_scores;

src/network/protocols/server_lobby.hpp

@@ -21,9 +21,10 @@
 
 #include "network/protocols/lobby_protocol.hpp"
 #include "utils/cpp2011.hpp"
+#include "utils/kart_elimination.hpp"
+#include "utils/team_utils.hpp"
 #include "utils/time.hpp"
 #include "utils/track_filter.hpp"
-#include "utils/kart_elimination.hpp"
 #include "karts/controller/player_controller.hpp"
 #include "network/protocols/command_manager.hpp"
 
@@ -369,8 +370,6 @@ class ServerLobby : public LobbyProtocol
 
     std::map<int, GPScore> m_gp_team_scores;
 
-    std::vector<std::string> m_team_name;
-
     int m_tournament_game;
 
     int m_fixed_lap;
@@ -392,12 +391,6 @@ class ServerLobby : public LobbyProtocol
     bool m_allowed_to_start;
 
     bool m_consent_on_replays;
-    
-    std::map<std::string, int> m_team_name_to_index;
-
-    std::vector<std::string> m_team_default_names;
-
-    std::map<int, std::string> m_team_index_to_icon;
 
     bool m_shuffle_gp;