Ticket #9: t0009_visualreplay_v2_16707.patch

binaries/data/mods/public/gui/session/session.js

@@ -555 +555 @@
         if (battleState)
             global.music.setState(global.music.states[battleState]);
     }
 }
 
+function onReplayFinished()
+{
+    closeMenu();
+    closeOpenDialogs();
+    pauseGame();
+    var btCaptions = ["Yes", "No"];
+    var btCode = [leaveGame, resumeGame];
+    messageBox(400, 200, "The replay has finished. Do you want to quit?", "Confirmation", 0, btCaptions, btCode);
+}
+
 /**
 * updates a status bar on the GUI
 * nameOfBar: name of the bar
 * points: points to show
 * maxPoints: max points 

binaries/data/mods/public/gui/session/session.xml

@@ -20 +20 @@
 
     <action on="SimulationUpdate">
         onSimulationUpdate();
     </action>
 
+    <action on="ReplayFinished">
+        onReplayFinished();
+    </action>
+
     <action on="Press">
         this.hidden = !this.hidden;
     </action>
 
     <!-- ================================  ================================ -->

source/main.cpp

@@ -440 +440 @@
         return;
 
     // run non-visual simulation replay if requested
     if (args.Has("replay"))
     {
+        std::string replayFile = args.Get("replay");
+        if (!FileExists(OsPath(replayFile)))
+        {
+            debug_printf("ERROR: The requested replay file '%s' does not exist!\n", replayFile.c_str());
+            return;
+        }
         Paths paths(args);
         g_VFS = CreateVfs(20 * MiB);
         g_VFS->Mount(L"cache/", paths.Cache(), VFS_MOUNT_ARCHIVABLE);
         MountMods(paths, GetMods(args, INIT_MODS));
 
         {
             CReplayPlayer replay;
-            replay.Load(args.Get("replay"));
+            replay.Load(replayFile);
             replay.Replay(args.Has("serializationtest"), args.Has("ooslog"));
         }
 
         g_VFS.reset();
 
         CXeromyces::Terminate();
         return;
     }
 
+    // If visual replay file does not exist, quit before starting the renderer
+    if (args.Has("replay-visual"))
+    {
+        std::string replayFile = args.Get("replay-visual");
+        if (!FileExists(OsPath(replayFile)))
+        {
+            debug_printf("ERROR: The requested replay file '%s' does not exist!\n", replayFile.c_str());
+            return;
+        }
+    }
+
+
     // run in archive-building mode if requested
     if (args.Has("archivebuild"))
     {
         Paths paths(args);
 

source/network/NetTurnManager.cpp

@@ -29 +29 @@
 #include "ps/Profile.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/Replay.h"
 #include "ps/SavedGame.h"
 #include "scriptinterface/ScriptInterface.h"
+#include "simulation2/helpers/Player.h"
 #include "simulation2/Simulation2.h"
 
 #include <sstream>
 #include <fstream>
 #include <iomanip>
@@ -227 +228 @@
         return;
     m_HasSyncError = true;
 
     bool quick = !TurnNeedsFullHash(turn);
     std::string hash;
-    bool ok = m_Simulation2.ComputeStateHash(hash, quick);
-    ENSURE(ok);
+    ENSURE(m_Simulation2.ComputeStateHash(hash, quick));
 
     OsPath path = psLogDir()/"oos_dump.txt";
     std::ofstream file (OsString(path).c_str(), std::ofstream::out | std::ofstream::trunc);
     m_Simulation2.DumpDebugState(file);
     file.close();
 
+    hash = Hexify(hash);
+    const std::string& expectedHashHex = Hexify(expectedHash);
+
+    DisplayOOSError(turn, hash, expectedHashHex, false, &path);
+}
+
+void CNetTurnManager::DisplayOOSError(u32 turn, std::string& hash, const std::string& expectedHash, const bool isReplay, OsPath* path = NULL)
+{
     std::stringstream msg;
-    msg << "Out of sync on turn " << turn << ": expected hash " << Hexify(expectedHash) << "\n\n";
-    msg << "Current state: turn " << m_CurrentTurn << ", hash " << Hexify(hash) << "\n\n";
-    msg << "Dumping current state to " << utf8_from_wstring(path.string());
+    msg << "Out of sync on turn " << turn << ": expected hash " << expectedHash << "\n\n";
+
+    if ((expectedHash != hash) || (m_CurrentTurn != turn))
+        msg << "Current state: turn " << m_CurrentTurn << ", hash " << hash << "\n\n";
+
+    if (isReplay)
+        msg << "The current game state is different from the original game state.\n\n";
+    else
+    {
+        if (expectedHash == hash)
+            msg << "Your game state is identical to the hosts game state.\n\n";
+        else
+            msg << "Your game state is different from the hosts game state.\n\n";
+    }
+
+    if (path != NULL)
+        msg << "Dumping current state to " << utf8_from_wstring(OsPath(*path).string());
+
     if (g_GUI)
         g_GUI->DisplayMessageBox(600, 350, L"Sync error", wstring_from_utf8(msg.str()));
     else
         LOGERROR("%s", msg.str());
 }
@@ -320 +343 @@
 void CNetTurnManager::QuickSave()
 {
     TIMER(L"QuickSave");
     
     std::stringstream stream;
-    bool ok = m_Simulation2.SerializeState(stream);
-    if (!ok)
+    if (!m_Simulation2.SerializeState(stream))
     {
         LOGERROR("Failed to quicksave game");
         return;
     }
 
@@ -348 +370 @@
         LOGERROR("Cannot quickload game - no game was quicksaved");
         return;
     }
 
     std::stringstream stream(m_QuickSaveState);
-    bool ok = m_Simulation2.DeserializeState(stream);
-    if (!ok)
+    if (!m_Simulation2.DeserializeState(stream))
     {
         LOGERROR("Failed to quickload game");
         return;
     }
 
@@ -400 +421 @@
 {
     bool quick = !TurnNeedsFullHash(turn);
     std::string hash;
     {
         PROFILE3("state hash check");
-        bool ok = m_Simulation2.ComputeStateHash(hash, quick);
-        ENSURE(ok);
+        ENSURE(m_Simulation2.ComputeStateHash(hash, quick));
     }
 
     NETTURN_LOG((L"NotifyFinishedUpdate(%d, %hs)\n", turn, Hexify(hash).c_str()));
 
     m_Replay.Hash(hash, quick);
@@ -450 +470 @@
 {
 #if 0 // this hurts performance and is only useful for verifying log replays
     std::string hash;
     {
         PROFILE3("state hash check");
-        bool ok = m_Simulation2.ComputeStateHash(hash);
-        ENSURE(ok);
+        ENSURE(m_Simulation2.ComputeStateHash(hash));
     }
     m_Replay.Hash(hash);
 #endif
 }
 
 void CNetLocalTurnManager::OnSimulationMessage(CSimulationMessage* UNUSED(msg))
 {
     debug_warn(L"This should never be called");
 }
 
+CNetReplayTurnManager::CNetReplayTurnManager(CSimulation2& simulation, IReplayLogger& replay) :
+    CNetLocalTurnManager(simulation, replay)
+{
+}
+
+void CNetReplayTurnManager::StoreReplayCommand(u32 turn, int player, const std::string& command)
+{
+    m_ReplayCommands[turn][player].push_back(command);
+}
+
+void CNetReplayTurnManager::StoreReplayHash(u32 turn, const std::string& hash, bool quick)
+{
+    m_ReplayHash[turn] = std::make_pair(hash, quick);
+}
+
+void CNetReplayTurnManager::StoreReplayTurnLength(u32 turn, u32 turnLength)
+{
+    m_ReplayTurnLengths[turn] = turnLength;
+
+    // Initialize turn length
+    if (turn == 0)
+        m_TurnLength = m_ReplayTurnLengths[0];
+}
+
+void CNetReplayTurnManager::StoreFinalReplayTurn(u32 turn)
+{
+    m_FinalReplayTurn = turn;
+}
+void CNetReplayTurnManager::NotifyFinishedUpdate(u32 turn)
+{
+    if (turn > m_FinalReplayTurn)
+        return;
+
+    debug_printf("Executing turn %d of %d\n", turn, m_FinalReplayTurn);
+    DoTurn(turn);
+
+    // Compare hash, if it exists in the replay
+    if (m_ReplayHash.count(turn) == 0)
+        return;
 
+    std::string expectedHash = m_ReplayHash[turn].first;
+    bool quickHash = m_ReplayHash[turn].second;
+
+    // Compute hash
+    std::string hash;
+    ENSURE(m_Simulation2.ComputeStateHash(hash, quickHash));
+    hash = Hexify(hash);
 
+    if (hash != expectedHash)
+        DisplayOOSError(turn, hash, expectedHash, true);
+}
+
+void CNetReplayTurnManager::DoTurn(u32 turn)
+{
+    // Save turn length
+    m_TurnLength = m_ReplayTurnLengths[turn];
+
+    // Simulate commands for that turn
+    for (auto& command : m_ReplayCommands[turn])
+        for (size_t i = 0; i < command.second.size(); ++i)
+        {
+            JS::RootedValue data(m_Simulation2.GetScriptInterface().GetContext());
+            m_Simulation2.GetScriptInterface().ParseJSON(command.second[i], &data);
+            AddCommand(m_ClientId, command.first, data, m_CurrentTurn + 1);
+        }
+}
 
 CNetServerTurnManager::CNetServerTurnManager(CNetServerWorker& server) :
     m_NetServer(server), m_ReadyTurn(1), m_TurnLength(DEFAULT_TURN_LENGTH_MP)
 {
     // The first turn we will actually execute is number 2,

source/network/NetTurnManager.h

@@ -17 +17 @@
 
 #ifndef INCLUDED_NETTURNMANAGER
 #define INCLUDED_NETTURNMANAGER
 
 #include "simulation2/helpers/SimulationCommand.h"
+#include "lib/os_path.h"
 
 #include <list>
 #include <map>
+#include <vector>
 
 class CNetServerWorker;
 class CNetClient;
 class CSimulationMessage;
 class CSimulation2;
@@ -106 +108 @@
      * Called when there has been an out-of-sync error.
      */
     virtual void OnSyncError(u32 turn, const std::string& expectedHash);
 
     /**
+     * Shows a message box when an out of sync error has been detected in the session or visual replay.
+     */
+    virtual void DisplayOOSError(u32 turn, std::string& hash, const std::string& expectedHash, const bool isReplay, OsPath* path);
+
+    /**
      * Called by simulation code, to add a new command to be distributed to all clients and executed soon.
      */
     virtual void PostCommand(JS::HandleValue data) = 0;
 
     /**
@@ -187 +194 @@
     std::list<std::string> m_TimeWarpStates;
     std::string m_QuickSaveState; // TODO: should implement a proper disk-based quicksave system
     std::string m_QuickSaveMetadata;
 };
 
+
 /**
  * Implementation of CNetTurnManager for network clients.
  */
 class CNetClientTurnManager : public CNetTurnManager
 {
@@ -231 +239 @@
 
     virtual void NotifyFinishedUpdate(u32 turn);
 };
 
 
+
+/**
+ * Implementation of CNetTurnManager for replay games.
+ */
+class CNetReplayTurnManager : public CNetLocalTurnManager
+{
+public:
+    CNetReplayTurnManager(CSimulation2& simulation, IReplayLogger& replay);
+
+    void StoreReplayCommand(u32 turn, int player, const std::string& command);
+
+    void StoreReplayTurnLength(u32 turn, u32 turnLength);
+
+    void StoreReplayHash(u32 turn, const std::string& hash, bool quick);
+
+    void StoreFinalReplayTurn(u32 turn);
+
+
+protected:
+    virtual void NotifyFinishedUpdate(u32 turn);
+
+    void DoTurn(u32 turn);
+
+    // Contains the commands of every player on each turn
+    std::map<u32, std::map<int, std::vector<std::string> > > m_ReplayCommands;
+
+    // Contains the length of every turn
+    std::map<u32, u32> m_ReplayTurnLengths;
+
+    // Contains all replay hash values and weather or not the quick hash method was used
+    std::map<u32, std::pair<std::string, bool> > m_ReplayHash;
+
+    // The number of the last turn in the replay
+    u32 m_FinalReplayTurn;
+
+};
 /**
  * The server-side counterpart to CNetClientTurnManager.
  * Records the turn state of each client, and sends turn advancement messages
  * when all clients are ready.
  *

source/ps/Game.cpp

@@ -45 +45 @@
 #include "renderer/WaterManager.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpPlayer.h"
 #include "simulation2/components/ICmpPlayerManager.h"
+#include "simulation2/helpers/Player.h"
 #include "soundmanager/ISoundManager.h"
 
 #include "tools/atlas/GameInterface/GameLoop.h"
 
 extern bool g_GameRestarted;
 extern GameLoopState* g_AtlasGameLoop;
+extern void kill_mainloop(); // from main.cpp
 
 /**
  * Globally accessible pointer to the CGame object.
  **/
 CGame *g_Game=NULL;
 
 /**
  * Constructor
  *
  **/
-CGame::CGame(bool disableGraphics):
+CGame::CGame(bool disableGraphics, bool replayLog):
     m_World(new CWorld(this)),
     m_Simulation2(new CSimulation2(&m_World->GetUnitManager(), g_ScriptRuntime, m_World->GetTerrain())),
     m_GameView(disableGraphics ? NULL : new CGameView(this)),
     m_GameStarted(false),
     m_Paused(false),
     m_SimRate(1.0f),
     m_PlayerID(-1),
-    m_IsSavedGame(false)
+    m_IsSavedGame(false),
+    m_IsReplay(false),
+    m_ReplayStream(NULL)
 {
-    m_ReplayLogger = new CReplayLogger(m_Simulation2->GetScriptInterface());
     // TODO: should use CDummyReplayLogger unless activated by cmd-line arg, perhaps?
+    if (replayLog)
+        m_ReplayLogger = new CReplayLogger(m_Simulation2->GetScriptInterface());
+    else
+        m_ReplayLogger = new CDummyReplayLogger();
 
     // Need to set the CObjectManager references after various objects have
     // been initialised, so do it here rather than via the initialisers above.
     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_Simulation2->LoadDefaultScripts();
 }
+int CGame::LoadReplayData()
+{
+    ENSURE(m_IsReplay);
+    ENSURE(!m_ReplayPath.empty());
+
+    CNetReplayTurnManager* replayTurnMgr = static_cast<CNetReplayTurnManager*>(GetTurnManager());
+
+    u32 currentTurn = 0;
+    std::string type;
+    while ((*m_ReplayStream >> type).good())
+    {
+        if (type == "turn")
+        {
+            u32 turn = 0;
+            u32 turnLength = 0;
+            *m_ReplayStream >> turn >> turnLength;
+            ENSURE(turn == currentTurn);
+            replayTurnMgr->StoreReplayTurnLength(currentTurn, turnLength);
+        }
+        else if (type == "cmd")
+        {
+            player_id_t player;
+            *m_ReplayStream >> player;
+
+            std::string line;
+            std::getline(*m_ReplayStream, line);
+            replayTurnMgr->StoreReplayCommand(currentTurn, player, line);
+        }
+        else if (type == "hash" || type == "hash-quick")
+        {
+            bool quick = (type == "hash-quick");
+            std::string replayHash;
+            *m_ReplayStream >> replayHash;
+            replayTurnMgr->StoreReplayHash(currentTurn, replayHash, quick);
+        }
+        else if (type == "end")
+        {
+            currentTurn++;
+        }
+        else
+        {
+            CancelLoad(L"Failed to load replay data (unrecognized content)");
+        }
+    }
+    m_FinalReplayTurn = currentTurn;
+    replayTurnMgr->StoreFinalReplayTurn(currentTurn);
+    return 0;
+}
+bool CGame::StartReplay(const std::string& replayPath)
+{
+    m_IsReplay = true;
+    ScriptInterface& scriptInterface = m_Simulation2->GetScriptInterface();
 
+    SetTurnManager(new CNetReplayTurnManager(*m_Simulation2, GetReplayLogger()));
+
+    m_ReplayPath = replayPath;
+    m_ReplayStream = new std::ifstream(m_ReplayPath.c_str());
+
+    std::string type;
+    ENSURE((*m_ReplayStream >> type).good() && type == "start");
+
+    std::string line;
+    std::getline(*m_ReplayStream, line);
+    JS::RootedValue attribs(scriptInterface.GetContext());
+    scriptInterface.ParseJSON(line, &attribs);
+    StartGame(&attribs, "");
+
+    return true;
+}
 /**
  * Destructor
  *
  **/
 CGame::~CGame()
@@ -99 +174 @@
     delete m_TurnManager;
     delete m_GameView;
     delete m_Simulation2;
     delete m_World;
     delete m_ReplayLogger;
+    delete m_ReplayStream;
 }
 
 void CGame::SetTurnManager(CNetTurnManager* turnManager)
 {
     if (m_TurnManager)
@@ -174 +250 @@
         RegMemFun(g_Renderer.GetSingletonPtr()->GetWaterManager(), &WaterManager::LoadWaterTextures, L"LoadWaterTextures", 80);
 
     if (m_IsSavedGame)
         RegMemFun(this, &CGame::LoadInitialState, L"Loading game", 1000);
 
+    if (m_IsReplay)
+        RegMemFun(this, &CGame::LoadReplayData, L"Loading replay data", 1000);
+
     LDR_EndRegistering();
 }
 
 int CGame::LoadInitialState()
 {
@@ -261 +340 @@
 int CGame::GetPlayerID()
 {
     return m_PlayerID;
 }
 
-void CGame::SetPlayerID(int playerID)
+void CGame::SetPlayerID(player_id_t playerID)
 {
     m_PlayerID = playerID;
     if (m_TurnManager)
         m_TurnManager->SetPlayerID(m_PlayerID);
 }
 
 void CGame::StartGame(JS::MutableHandleValue attribs, const std::string& savedState)
 {
-    m_ReplayLogger->StartGame(attribs);
+    if (m_ReplayLogger != false)
+        m_ReplayLogger->StartGame(attribs);
+
     RegisterInit(attribs, savedState);
 }
 
 // TODO: doInterpolate is optional because Atlas interpolates explicitly,
 // so that it has more control over the update rate. The game might want to
@@ -308 +389 @@
         {
             {
                 PROFILE3("gui sim update");
                 g_GUI->SendEventToAll("SimulationUpdate");
             }
+             if (m_IsReplay && m_TurnManager->GetCurrentTurn() == m_FinalReplayTurn - 1)
+                 g_GUI->SendEventToAll("ReplayFinished");
 
             GetView()->GetLOSTexture().MakeDirty();
         }
         
         if (CRenderer::IsInitialised())
@@ -360 +443 @@
             m_PlayerColors[i] = cmpPlayer->GetColor();
     }
 }
 
 
-CColor CGame::GetPlayerColor(int player) const
+CColor CGame::GetPlayerColor(player_id_t player) const
 {
     if (player < 0 || player >= (int)m_PlayerColors.size())
         return BrokenColor;
 
     return m_PlayerColors[player];

source/ps/Game.h

@@ -19 +19 @@
 #define INCLUDED_GAME
 
 #include "ps/Errors.h"
 #include <vector>
 
+#include <map>
 #include "scriptinterface/ScriptVal.h"
+#include "simulation2/helpers/Player.h"
 
 class CWorld;
 class CSimulation2;
 class CGameView;
 class CNetTurnManager;
@@ -58 +60 @@
     /**
      * Timescale multiplier for simulation rate.
      **/
     float m_SimRate;
 
-    int m_PlayerID;
+    player_id_t m_PlayerID;
 
     CNetTurnManager* m_TurnManager;
 
 public:
-    CGame(bool disableGraphics = false);
+    CGame(bool disableGraphics = false, bool replayLog = true);
     ~CGame();
 
     /**
      * the game is paused and no updates will be performed if true.
      **/
     bool m_Paused;
 
     void StartGame(JS::MutableHandleValue attribs, const std::string& savedState);
     PSRETURN ReallyStartGame();
 
+    bool StartReplay(const std::string& replayPath);
+
     /**
      * Periodic heartbeat that controls the process. performs all per-frame updates.
      * Simulation update is called and game status update is called.
      *
      * @param deltaRealTime Elapsed real time since last beat/frame, in seconds.
@@ -88 +92 @@
     bool Update(const double deltaRealTime, bool doInterpolate = true);
 
     void Interpolate(float simFrameLength, float realFrameLength);
 
     int GetPlayerID();
-    void SetPlayerID(int playerID);
+    void SetPlayerID(player_id_t playerID);
 
     /**
      * Retrieving player colors from scripts is slow, so this updates an
      * internal cache of all players' colors.
      * Call this just before rendering, so it will always have the latest
      * colors.
      */
     void CachePlayerColors();
 
-    CColor GetPlayerColor(int player) const;
+    CColor GetPlayerColor(player_id_t player) const;
 
     /**
      * Get m_GameStarted.
      *
      * @return bool the value of m_GameStarted.
@@ -169 +173 @@
     std::vector<CColor> m_PlayerColors;
 
     int LoadInitialState();
     std::string m_InitialSavedState; // valid between RegisterInit and LoadInitialState
     bool m_IsSavedGame; // true if loading a saved game; false for a new game
+
+    int LoadReplayData();
+    std::string m_ReplayPath;
+    bool m_IsReplay;
+    std::istream* m_ReplayStream;
+    u32 m_FinalReplayTurn;
 };
 
 extern CGame *g_Game;
 
 #endif

source/ps/GameSetup/GameSetup.cpp

@@ -879 +879 @@
     srand(time(NULL));  // NOTE: this rand should *not* be used for simulation!
 }
 
 bool Autostart(const CmdLineArgs& args);
 
+// Returns true if and only if the user has intended to replay a file
+bool VisualReplay(const std::string replayFile);
+
 bool Init(const CmdLineArgs& args, int flags)
 {
     h_mgr_init();
 
     // Do this as soon as possible, because it chdirs
@@ -1071 +1074 @@
 
     ogl_WarnIfError();
 
     try
     {
-        if (!Autostart(args))
+        if (!VisualReplay(args.Get("replay-visual")) && !Autostart(args))
         {
             const bool setup_gui = ((flags & INIT_NO_GUI) == 0);
             // We only want to display the splash screen at startup
             shared_ptr<ScriptInterface> scriptInterface = g_GUI->GetScriptInterface();
             JSContext* cx = scriptInterface->GetContext();
@@ -1468 +1471 @@
     }
 
     return true;
 }
 
+bool VisualReplay(const std::string replayFile)
+{
+    if (!FileExists(OsPath(replayFile)))
+         return false;
+
+    g_Game = new CGame(false, false);
+    g_Game->SetPlayerID(-1);
+    g_Game->StartReplay(replayFile);
+
+    // TODO: Non progressive load can fail - need a decent way to handle this
+    LDR_NonprogressiveLoad();
+
+    PSRETURN ret = g_Game->ReallyStartGame();
+    ENSURE(ret == PSRETURN_OK);
+
+    ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
+
+    InitPs(true, L"page_session.xml", &scriptInterface, JS::UndefinedHandleValue);
+    return true;
+}
+
 void CancelLoad(const CStrW& message)
 {
     shared_ptr<ScriptInterface> pScriptInterface = g_GUI->GetActiveGUI()->GetScriptInterface();
     JSContext* cx = pScriptInterface->GetContext();
     JSAutoRequest rq(cx);

source/ps/Replay.h

@@ -54 +54 @@
  */
 class CDummyReplayLogger : public IReplayLogger
 {
 public:
     virtual void StartGame(JS::MutableHandleValue UNUSED(attribs)) { }
-    virtual void Turn(u32 UNUSED(n), u32 UNUSED(turnLength), const std::vector<SimulationCommand>& UNUSED(commands)) { }
+    virtual void Turn(u32 UNUSED(n), u32 UNUSED(turnLength), std::vector<SimulationCommand>& UNUSED(commands)) { }
     virtual void Hash(const std::string& UNUSED(hash), bool UNUSED(quick)) { }
 };
 
 /**
  * Implementation of IReplayLogger that saves data to a file in the logs directory.