Ticket #4095: rename_CNetTurnManager_v2.patch

source/network/NetTurnManager.cpp

@@ -58 +58 @@
     return str.str();
 }
 
-CNetTurnManager::CNetTurnManager(CSimulation2& simulation, u32 defaultTurnLength, int clientId, IReplayLogger& replay) :
+CTurnManager::CTurnManager(CSimulation2& simulation, u32 defaultTurnLength, int clientId, IReplayLogger& replay) :
     m_Simulation2(simulation), m_CurrentTurn(0), m_ReadyTurn(1), m_TurnLength(defaultTurnLength), m_DeltaSimTime(0),
     m_PlayerId(-1), m_ClientId(clientId), m_HasSyncError(false), m_Replay(replay),
     m_TimeWarpNumTurns(0), m_FinalTurn(std::numeric_limits<u32>::max())
@@ -72 +72 @@
     m_QueuedCommands.resize(COMMAND_DELAY + 1);
 }
 
-void CNetTurnManager::ResetState(u32 newCurrentTurn, u32 newReadyTurn)
+void CTurnManager::ResetState(u32 newCurrentTurn, u32 newReadyTurn)
 {
     m_CurrentTurn = newCurrentTurn;
     m_ReadyTurn = newReadyTurn;
@@ -82 +82 @@
     m_QueuedCommands.resize(queuedCommandsSize);
 }
 
-void CNetTurnManager::SetPlayerID(int playerId)
+void CTurnManager::SetPlayerID(int playerId)
 {
     m_PlayerId = playerId;
 }
 
-bool CNetTurnManager::WillUpdate(float simFrameLength)
+bool CTurnManager::WillUpdate(float simFrameLength)
 {
     // Keep this in sync with the return value of Update()
 
@@ -103 +103 @@
     return true;
 }
 
-bool CNetTurnManager::Update(float simFrameLength, size_t maxTurns)
+bool CTurnManager::Update(float simFrameLength, size_t maxTurns)
 {
     if (m_CurrentTurn > m_FinalTurn)
         return false;
@@ -191 +191 @@
     return true;
 }
 
-bool CNetTurnManager::UpdateFastForward()
+bool CTurnManager::UpdateFastForward()
 {
     m_DeltaSimTime = 0;
 
@@ -229 +229 @@
     return true;
 }
 
-void CNetTurnManager::OnSyncError(u32 turn, const CStr& expectedHash, std::vector<CSyncErrorMessage::S_m_PlayerNames>& playerNames)
+void CTurnManager::OnSyncError(u32 turn, const CStr& expectedHash, std::vector<CSyncErrorMessage::S_m_PlayerNames>& playerNames)
 {
     NETTURN_LOG((L"OnSyncError(%d, %hs)\n", turn, Hexify(expectedHash).c_str()));
 
@@ -252 +252 @@
     DisplayOOSError(turn, hash, expectedHashHex, false, &playerNames, &path);
 }
 
-void CNetTurnManager::DisplayOOSError(u32 turn, const CStr& hash, const CStr& expectedHash, bool isReplay, std::vector<CSyncErrorMessage::S_m_PlayerNames>* playerNames = NULL, OsPath* path = NULL)
+void CTurnManager::DisplayOOSError(u32 turn, const CStr& hash, const CStr& expectedHash, bool isReplay, std::vector<CSyncErrorMessage::S_m_PlayerNames>* playerNames = NULL, OsPath* path = NULL)
 {
     m_HasSyncError = true;
 
@@ -277 +277 @@
         g_GUI->DisplayMessageBox(600, 350, L"Sync error", wstring_from_utf8(msg.str()));
 }
 
-void CNetTurnManager::Interpolate(float simFrameLength, float realFrameLength)
+void CTurnManager::Interpolate(float simFrameLength, float realFrameLength)
 {
     // TODO: using m_TurnLength might be a bit dodgy when length changes - maybe
     // we need to save the previous turn length?
@@ -291 +291 @@
     m_Simulation2.Interpolate(simFrameLength, offset, realFrameLength);
 }
 
-void CNetTurnManager::AddCommand(int client, int player, JS::HandleValue data, u32 turn)
+void CTurnManager::AddCommand(int client, int player, JS::HandleValue data, u32 turn)
 {
     NETTURN_LOG((L"AddCommand(client=%d player=%d turn=%d)\n", client, player, turn));
 
@@ -305 +305 @@
     m_QueuedCommands[turn - (m_CurrentTurn+1)][client].emplace_back(player, m_Simulation2.GetScriptInterface().GetContext(), data);
 }
 
-void CNetTurnManager::FinishedAllCommands(u32 turn, u32 turnLength)
+void CTurnManager::FinishedAllCommands(u32 turn, u32 turnLength)
 {
     NETTURN_LOG((L"FinishedAllCommands(%d, %d)\n", turn, turnLength));
 
@@ -314 +314 @@
     m_TurnLength = turnLength;
 }
 
-bool CNetTurnManager::TurnNeedsFullHash(u32 turn)
+bool CTurnManager::TurnNeedsFullHash(u32 turn)
 {
     // Check immediately for errors caused by e.g. inconsistent game versions
     // (The hash is computed after the first sim update, so we start at turn == 1)
@@ -330 +330 @@
     return false;
 }
 
-void CNetTurnManager::EnableTimeWarpRecording(size_t numTurns)
+void CTurnManager::EnableTimeWarpRecording(size_t numTurns)
 {
     m_TimeWarpStates.clear();
     m_TimeWarpNumTurns = numTurns;
 }
 
-void CNetTurnManager::RewindTimeWarp()
+void CTurnManager::RewindTimeWarp()
 {
     if (m_TimeWarpStates.empty())
         return;
@@ -352 +352 @@
     ResetState(0, 1);
 }
 
-void CNetTurnManager::QuickSave()
+void CTurnManager::QuickSave()
 {
     TIMER(L"QuickSave");
 
@@ -373 +373 @@
 
 }
 
-void CNetTurnManager::QuickLoad()
+void CTurnManager::QuickLoad()
 {
     TIMER(L"QuickLoad");
 
@@ -401 +401 @@
 
 
 CNetClientTurnManager::CNetClientTurnManager(CSimulation2& simulation, CNetClient& client, int clientId, IReplayLogger& replay) :
-    CNetTurnManager(simulation, DEFAULT_TURN_LENGTH_MP, clientId, replay), m_NetClient(client)
+    CTurnManager(simulation, DEFAULT_TURN_LENGTH_MP, clientId, replay), m_NetClient(client)
 {
 }
 
@@ -470 +470 @@
 }
 
 
-CNetLocalTurnManager::CNetLocalTurnManager(CSimulation2& simulation, IReplayLogger& replay) :
-    CNetTurnManager(simulation, DEFAULT_TURN_LENGTH_SP, 0, replay)
+CLocalTurnManager::CLocalTurnManager(CSimulation2& simulation, IReplayLogger& replay) :
+    CTurnManager(simulation, DEFAULT_TURN_LENGTH_SP, 0, replay)
 {
 }
 
-void CNetLocalTurnManager::PostCommand(JS::HandleValue data)
+void CLocalTurnManager::PostCommand(JS::HandleValue data)
 {
     // Add directly to the next turn, ignoring COMMAND_DELAY,
     // because we don't need to compensate for network latency
@@ -482 +482 @@
     AddCommand(m_ClientId, m_PlayerId, data, m_CurrentTurn + 1);
 }
 
-void CNetLocalTurnManager::NotifyFinishedOwnCommands(u32 turn)
+void CLocalTurnManager::NotifyFinishedOwnCommands(u32 turn)
 {
     FinishedAllCommands(turn, m_TurnLength);
 }
 
-void CNetLocalTurnManager::NotifyFinishedUpdate(u32 UNUSED(turn))
+void CLocalTurnManager::NotifyFinishedUpdate(u32 UNUSED(turn))
 {
 #if 0 // this hurts performance and is only useful for verifying log replays
     std::string hash;
@@ -499 +499 @@
 #endif
 }
 
-void CNetLocalTurnManager::OnSimulationMessage(CSimulationMessage* UNUSED(msg))
+void CLocalTurnManager::OnSimulationMessage(CSimulationMessage* UNUSED(msg))
 {
     debug_warn(L"This should never be called");
 }
 
-CNetReplayTurnManager::CNetReplayTurnManager(CSimulation2& simulation, IReplayLogger& replay) :
-    CNetLocalTurnManager(simulation, replay)
+CReplayTurnManager::CReplayTurnManager(CSimulation2& simulation, IReplayLogger& replay) :
+    CLocalTurnManager(simulation, replay)
 {
 }
 
-void CNetReplayTurnManager::StoreReplayCommand(u32 turn, int player, const std::string& command)
+void CReplayTurnManager::StoreReplayCommand(u32 turn, int player, const std::string& command)
 {
     // Using the pair we make sure that commands per turn will be processed in the correct order
     m_ReplayCommands[turn].emplace_back(player, command);
 }
 
-void CNetReplayTurnManager::StoreReplayHash(u32 turn, const std::string& hash, bool quick)
+void CReplayTurnManager::StoreReplayHash(u32 turn, const std::string& hash, bool quick)
 {
     m_ReplayHash[turn] = std::make_pair(hash, quick);
 }
 
-void CNetReplayTurnManager::StoreReplayTurnLength(u32 turn, u32 turnLength)
+void CReplayTurnManager::StoreReplayTurnLength(u32 turn, u32 turnLength)
 {
     m_ReplayTurnLengths[turn] = turnLength;
 
@@ -529 +529 @@
         m_TurnLength = m_ReplayTurnLengths[0];
 }
 
-void CNetReplayTurnManager::StoreFinalReplayTurn(u32 turn)
+void CReplayTurnManager::StoreFinalReplayTurn(u32 turn)
 {
     m_FinalTurn = turn;
 }
 
-void CNetReplayTurnManager::NotifyFinishedUpdate(u32 turn)
+void CReplayTurnManager::NotifyFinishedUpdate(u32 turn)
 {
     if (turn == 1 && m_FinalTurn == 0)
         g_GUI->SendEventToAll("ReplayFinished");
@@ -560 +560 @@
         DisplayOOSError(turn, hash, expectedHash, true);
 }
 
-void CNetReplayTurnManager::DoTurn(u32 turn)
+void CReplayTurnManager::DoTurn(u32 turn)
 {
     debug_printf("Executing turn %u of %u\n", turn, m_FinalTurn);
 

source/network/NetTurnManager.h

@@ -36 +36 @@
 class IReplayLogger;
 
 /*
- * This file deals with the logic of the network turn system. The basic idea is as in
+ * This file deals with the logic of the turn system. The basic idea is as in
  * http://www.gamasutra.com/view/feature/3094/1500_archers_on_a_288_network_.php?print=1
  *
  * Each player performs the simulation for turn N.
@@ -55 +55 @@
 /**
  * Common network turn system (used by clients and offline games).
  */
-class CNetTurnManager
+class CTurnManager
 {
-    NONCOPYABLE(CNetTurnManager);
+    NONCOPYABLE(CTurnManager);
 public:
     /**
      * Construct for a given network session ID.
      */
-    CNetTurnManager(CSimulation2& simulation, u32 defaultTurnLength, int clientId, IReplayLogger& replay);
+    CTurnManager(CSimulation2& simulation, u32 defaultTurnLength, int clientId, IReplayLogger& replay);
 
-    virtual ~CNetTurnManager() { }
+    virtual ~CTurnManager() { }
 
     void ResetState(u32 newCurrentTurn, u32 newReadyTurn);
 
@@ -205 +205 @@
 
 
 /**
- * Implementation of CNetTurnManager for network clients.
+ * Implementation of CTurnManager for network clients.
  */
-class CNetClientTurnManager : public CNetTurnManager
+class CNetClientTurnManager : public CTurnManager
 {
 public:
     CNetClientTurnManager(CSimulation2& simulation, CNetClient& client, int clientId, IReplayLogger& replay);
@@ -230 +230 @@
 };
 
 /**
- * Implementation of CNetTurnManager for offline games.
+ * Implementation of CTurnManager for offline games.
  */
-class CNetLocalTurnManager : public CNetTurnManager
+class CLocalTurnManager : public CTurnManager
 {
 public:
-    CNetLocalTurnManager(CSimulation2& simulation, IReplayLogger& replay);
+    CLocalTurnManager(CSimulation2& simulation, IReplayLogger& replay);
 
     virtual void OnSimulationMessage(CSimulationMessage* msg);
 
@@ -250 +250 @@
 
 
 /**
- * Implementation of CNetTurnManager for replay games.
+ * Implementation of CTurnManager for replay games.
  */
-class CNetReplayTurnManager : public CNetLocalTurnManager
+class CReplayTurnManager : public CLocalTurnManager
 {
 public:
-    CNetReplayTurnManager(CSimulation2& simulation, IReplayLogger& replay);
+    CReplayTurnManager(CSimulation2& simulation, IReplayLogger& replay);
 
     void StoreReplayCommand(u32 turn, int player, const std::string& command);
 

source/network/tests/test_Net.h

@@ -310 +310 @@
         wait(clients, 100);
 
         // (This SetTurnLength thing doesn't actually detect errors unless you change
-        // CNetTurnManager::TurnNeedsFullHash to always return true)
+        // CTurnManager::TurnNeedsFullHash to always return true)
 
         {
             JS::RootedValue cmd(cx);

source/ps/Game.cpp

@@ -87 +87 @@
     if (m_GameView)
         m_World->GetUnitManager().SetObjectManager(m_GameView->GetObjectManager());
 
-    m_TurnManager = new CNetLocalTurnManager(*m_Simulation2, GetReplayLogger()); // this will get replaced if we're a net server/client
+    m_TurnManager = new CLocalTurnManager(*m_Simulation2, GetReplayLogger()); // this will get replaced if we're a net server/client
 
     m_Simulation2->LoadDefaultScripts();
 }
@@ -110 +110 @@
     delete m_ReplayStream;
 }
 
-void CGame::SetTurnManager(CNetTurnManager* turnManager)
+void CGame::SetTurnManager(CTurnManager* turnManager)
 {
     if (m_TurnManager)
         delete m_TurnManager;
@@ -127 +127 @@
     ENSURE(!m_ReplayPath.empty());
     ENSURE(m_ReplayStream);
 
-    CNetReplayTurnManager* replayTurnMgr = static_cast<CNetReplayTurnManager*>(GetTurnManager());
+    CReplayTurnManager* replayTurnMgr = static_cast<CReplayTurnManager*>(GetTurnManager());
 
     u32 currentTurn = 0;
     std::string type;
@@ -175 +175 @@
     m_IsVisualReplay = true;
     ScriptInterface& scriptInterface = m_Simulation2->GetScriptInterface();
 
-    SetTurnManager(new CNetReplayTurnManager(*m_Simulation2, GetReplayLogger()));
+    SetTurnManager(new CReplayTurnManager(*m_Simulation2, GetReplayLogger()));
 
     m_ReplayPath = replayPath;
     m_ReplayStream = new std::ifstream(m_ReplayPath.c_str());

source/ps/Game.h

@@ -27 +27 @@
 class CWorld;
 class CSimulation2;
 class CGameView;
-class CNetTurnManager;
+class CTurnManager;
 class IReplayLogger;
 struct CColor;
 
@@ -77 +77 @@
      */
     player_id_t m_ViewedPlayerID;
 
-    CNetTurnManager* m_TurnManager;
+    CTurnManager* m_TurnManager;
 
 public:
     CGame(bool disableGraphics = false, bool replayLog = true);
@@ -185 +185 @@
      * Replace the current turn manager.
      * This class will take ownership of the pointer.
      */
-    void SetTurnManager(CNetTurnManager* turnManager);
+    void SetTurnManager(CTurnManager* turnManager);
 
-    CNetTurnManager* GetTurnManager() const
+    CTurnManager* GetTurnManager() const
     {   return m_TurnManager; }
 
     IReplayLogger& GetReplayLogger() const