Minor fixes, also make PR a LobbyProtocol for some reason

Author: kimden

src/network/protocols/playing_room.cpp

@@ -57,6 +57,7 @@
 #include "utils/hit_processor.hpp"
 #include "modes/capture_the_flag.hpp"
 #include "utils/chat_manager.hpp"
+#include "network/protocols/game_events_protocol.hpp"
 
 namespace
 {
@@ -205,7 +206,7 @@ void PlayingRoom::updateRoom(int ticks)
 {
     World* w = World::getWorld();
     bool world_started = m_play_state.load() >= WAIT_FOR_WORLD_LOADED &&
-        m_state.load() <= RACING && m_server_has_loaded_world.load();
+        m_play_state.load() <= RACING && m_server_has_loaded_world.load();
     bool all_players_in_world_disconnected = (w != NULL && world_started);
     int sec = getSettings()->getKickIdlePlayerSeconds();
     if (world_started)
@@ -243,7 +244,7 @@ void PlayingRoom::updateRoom(int ticks)
                 if (w && w->getKart(i)->hasFinishedRace())
                     continue;
                 // Don't kick in game GUI server host so he can idle in game
-                if (m_process_type == PT_CHILD && isClientServerHost(peer))
+                if (getLobby()->isChildClientServerHost(peer))
                     continue;
                 Log::info("ServerLobby", "%s %s has been idle ingame for more than"
                     " %d seconds, kick.",
@@ -282,7 +283,7 @@ void PlayingRoom::updateRoom(int ticks)
             getHitProcessor()->punishSwatterHits();
         }
     }
-    if (m_state.load() == WAITING_FOR_START_GAME) {
+    if (m_play_state.load() == WAITING_FOR_START_GAME) {
         sec = getSettings()->getKickIdleLobbyPlayerSeconds();
         auto peers = STKHost::get()->getPeers();
         for (auto peer: peers)
@@ -292,7 +293,7 @@ void PlayingRoom::updateRoom(int ticks)
                 !peer->isDisconnected() && NetworkConfig::get()->isWAN())
             {
                 // Don't kick in game GUI server host so he can idle in the lobby
-                if (m_process_type == PT_CHILD && isClientServerHost(peer))
+                if (getLobby()->isChildClientServerHost(peer))
                     continue;
                 std::string peer_name = "";
                 if (peer->hasPlayerProfiles())
@@ -306,14 +307,14 @@ void PlayingRoom::updateRoom(int ticks)
     }
 
     if (w)
-        m_game_progress = w->getGameStartedProgress();
+        setGameStartedProgress(w->getGameStartedProgress());
     else
-        m_game_progress = { std::numeric_limits<uint32_t>::max(), std::numeric_limits<uint32_t>::max() };
+        resetGameStartedProgress();
 
     if (w && w->getPhase() == World::RACE_PHASE)
-        m_playing_track = (RaceManager::get()->getTrackName());
+        storePlayingTrack(RaceManager::get()->getTrackName());
     else
-        m_playing_track = "";
+        storePlayingTrack("");
 
     // Reset server to initial state if no more connected players
     if (m_rs_state.load() == RS_WAITING)
@@ -329,7 +330,7 @@ void PlayingRoom::updateRoom(int ticks)
 
     STKHost::get()->updatePlayers();
     if (m_rs_state.load() == RS_NONE &&
-        (m_state.load() > WAITING_FOR_START_GAME/* ||
+        (m_play_state.load() > WAITING_FOR_START_GAME/* ||
         m_game_setup->isGrandPrixStarted()*/) &&
         (STKHost::get()->getPlayersInGame() == 0 ||
         all_players_in_world_disconnected))
@@ -372,7 +373,7 @@ void PlayingRoom::updateRoom(int ticks)
 
     // Reset for ranked server if in kart / track selection has only 1 player
     if (getSettings()->isRanked() &&
-        m_state.load() == SELECTING &&
+        m_play_state.load() == SELECTING &&
         STKHost::get()->getPlayersInGame() == 1)
     {
         NetworkString* back_lobby = getNetworkString(2);
@@ -391,8 +392,6 @@ void PlayingRoom::updateRoom(int ticks)
 
     switch (m_play_state.load())
     {
-    case SET_PUBLIC_ADDRESS:
-    case REGISTER_SELF_ADDRESS:
     case WAITING_FOR_START_GAME:
     case WAIT_FOR_WORLD_LOADED:
     case WAIT_FOR_RACE_STARTED:
@@ -450,9 +449,6 @@ void PlayingRoom::updateRoom(int ticks)
             m_rs_state.store(RS_ASYNC_RESET);
         }
         break;
-    case ERROR_LEAVE:
-    case EXITING:
-        break;
     }
 }   // updateRoom
 //-----------------------------------------------------------------------------
@@ -769,7 +765,6 @@ void PlayingRoom::asynchronousUpdateRoom()
 }   // asynchronousUpdateRoom
 //-----------------------------------------------------------------------------
 
-
 /** Calls the corresponding method from LobbyAssetManager
  *  whenever server is reset or game mode is changed. */
 [[deprecated("Asset managers should be separate for different rooms.")]]
@@ -780,6 +775,7 @@ void PlayingRoom::updateMapsForMode()
     );
 }   // updateMapsForMode
 //-----------------------------------------------------------------------------
+
 NetworkString* PlayingRoom::getLoadWorldMessage(
     std::vector<std::shared_ptr<NetworkPlayerProfile> >& players,
     bool live_join) const
@@ -1481,7 +1477,7 @@ void PlayingRoom::clientInGameWantsToBackLobby(Event* event)
         return;
     }
 
-    if (m_process_type == PT_CHILD && isClientServerHost(event->getPeer()))
+    if (getLobby()->isChildClientServerHost(event->getPeer()))
     {
         // For child server the remaining client cannot go on player when the
         // server owner quited the game (because the world will be deleted), so
@@ -1569,7 +1565,7 @@ void PlayingRoom::clientSelectingAssetsWantsToBackLobby(Event* event)
         return;
     }
 
-    if (m_process_type == PT_CHILD && isClientServerHost(event->getPeer()))
+    if (getLobby()->isChildClientServerHost(event->getPeerSP()))
     {
         NetworkString* back_to_lobby = getNetworkString(2);
         back_to_lobby->setSynchronous(true);

src/network/protocols/playing_room.hpp

@@ -23,6 +23,7 @@
 #include "utils/lobby_context.hpp"
 #include "network/packet_types.hpp"
 #include "network/kart_data.hpp"
+#include "network/protocols/lobby_protocol.hpp"
 
 #include <algorithm>
 #include <atomic>
@@ -38,7 +39,7 @@ class GameInfo;
 class NetworkItemManager;
 
 
-class PlayingRoom: public LobbyContextUser
+class PlayingRoom: public LobbyProtocol, public LobbyContextUser
 {
 private:
     std::atomic<ServerPlayState> m_play_state;
@@ -171,11 +172,6 @@ class PlayingRoom: public LobbyContextUser
     void addLiveJoinPlaceholder(
         std::vector<std::shared_ptr<NetworkPlayerProfile> >& players) const;
 
-    std::pair<uint32_t, uint32_t> getGameStartedProgress() const
-                                                    { return m_game_progress; }
-
-    std::string getPlayingTrack() const             { return m_playing_track; }
-
 public: // were public before and SL doesn't call them
 
     void setTimeoutFromNow(int seconds);

src/network/protocols/server_lobby.cpp

@@ -314,7 +314,7 @@ bool ServerLobby::notifyEventAsynchronous(Event* event)
         Log::info("ServerLobby", "Message of type %d received.",
                   message_type);
 
-        auto& room = getRoomForPeer(event->getPeerSP());
+        auto room = getRoomForPeer(event->getPeerSP());
 
         switch(message_type)
         {
@@ -598,7 +598,7 @@ void ServerLobby::update(int ticks)
         room->updateRoom(ticks);
 
     setGameStartedProgress(m_rooms[0]->getGameStartedProgress());
-    storePlayingTrack(m_rooms[0]->getPlayingTrack());
+    storePlayingTrack(m_rooms[0]->getPlayingTrackIdent());
 }   // update
 
 //-----------------------------------------------------------------------------
@@ -1009,7 +1009,7 @@ bool ServerLobby::handleAssetsAndAddonScores(std::shared_ptr<STKPeer> peer,
     peer->setAvailableKartsTracks(client_karts, client_maps);
     peer->setAddonsScores(addons_scores);
 
-    if (m_process_type == PT_CHILD && isClientServerHost(peer))
+    if (isChildClientServerHost(peer))
     {
         // Update child process addons list too so player can choose later
         getAssetManager()->updateAddons();

src/network/protocols/server_lobby.hpp

@@ -313,6 +313,11 @@ class ServerLobby : public LobbyProtocol, public LobbyContextUser
     bool isChildProcess()                { return m_process_type == PT_CHILD; }
 
     bool isClientServerHost(const std::shared_ptr<STKPeer>& peer);
+    bool isChildClientServerHost(const std::shared_ptr<STKPeer>& peer)
+    {
+        return isChildProcess() && isClientServerHost(peer);
+    }
+
     bool canIgnoreControllerEvents() const;
     bool isPeerInGame(const std::shared_ptr<STKPeer>& peer) const;
     bool hasAnyGameStarted() const;