Ticket #9: visualreplay-WIP-r14723.patch

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

@@ -298 +298 @@
 }
 
 // Updates middle entity Selection Details Panel
-function updateSelectionDetails()
+function updateSelectionDetails(replay)
 {
     var supplementalDetailsPanel = Engine.GetGUIObjectByName("supplementalSelectionDetails");
     var detailsPanel = Engine.GetGUIObjectByName("selectionDetails");
@@ -340 +340 @@
     commandsPanel.hidden = false;
 
     // Fill out commands panel for specific unit selected (or first unit of primary group)
-    updateUnitCommands(entState, supplementalDetailsPanel, commandsPanel, selection);
+    updateUnitCommands(entState, supplementalDetailsPanel, commandsPanel, selection, replay);
 }

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

@@ -779 +779 @@
                         trainNum = buildingsCountToTrainFullBatch * fullBatchSize + remainderBatch;
                         button_disableable = !Engine.HotkeyIsPressed("selection.remove");
                     }
-                    Engine.GetGUIObjectByName("unit"+guiName+"Count["+i+"]").caption = (batchTrainingCount > 0) ? batchTrainingCount : "";
+                    var batchOverlayText = Engine.GetGUIObjectByName("unit" + guiName + "Count[" + i + "]");
+                    if (batchOverlayText)
+                        batchOverlayText.caption = (batchTrainingCount > 0) ? batchTrainingCount : "";
                 }
 
                 // Walls have no cost defined.
@@ -1001 +1003 @@
  * @param commandsPanel Reference to the "commandsPanel" GUI Object
  * @param selection Array of currently selected entity IDs.
  */
-function updateUnitCommands(entState, supplementalDetailsPanel, commandsPanel, selection)
+function updateUnitCommands(entState, supplementalDetailsPanel, commandsPanel, selection, replay)
 {
     // Panels that are active
     var usedPanels = {};
@@ -1014 +1016 @@
     var simState = GetSimState();
     var playerState = simState.players[player];
 
-    if (entState.player == player || g_DevSettings.controlAll)
+    if (replay || entState.player == player || g_DevSettings.controlAll)
     {
         if (selection.length > 1)
             setupUnitPanel(SELECTION, usedPanels, entState, playerState, g_Selection.groups.getTemplateNames(),
                 function (entType, rightPressed) { changePrimarySelectionGroup(entType, rightPressed); } );
 
-        var commands = getEntityCommandsList(entState);
-        if (commands.length)
-            setupUnitPanel(COMMAND, usedPanels, entState, playerState, commands,
-                function (item) { performCommand(entState.id, item.name); } );
+    if (!replay)
+    {
+          var commands = getEntityCommandsList(entState);
+          if (commands.length)
+              setupUnitPanel(COMMAND, usedPanels, entState, playerState, commands,
+                  function (item) { performCommand(entState.id, item.name); } );
+        }
 
         if (entState.garrisonHolder)
         {
@@ -1236 +1241 @@
         var panel = Engine.GetGUIObjectByName("unit" + panelName + "Panel");
         if (usedPanels[panelName])
             panel.hidden = false;
-        else
+        else if (panel)
             panel.hidden = true;
     }
 }
@@ -1245 +1250 @@
 function hideUnitCommands()
 {
     for each (var panelName in g_unitPanels)
-        Engine.GetGUIObjectByName("unit" + panelName + "Panel").hidden = true;
+    {
+        var panel = Engine.GetGUIObjectByName("unit" + panelName + "Panel");
+        if (panel)
+            panel.hidden = true;
+    }
 }
 
 // Get all of the available entities which can be trained by the selected entities

source/gui/scripting/ScriptFunctions.cpp

@@ -153 +153 @@
     return EntitySelection::PickEntitiesAtPoint(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), x, y, g_Game->GetPlayerID(), false, range);
 }
 
+std::vector<entity_id_t> PickEntitiesInRect(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int x0, int y0, int x1, int y1)
+{
+    return EntitySelection::PickEntitiesInRect(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), x0, y0, x1, y1, INVALID_PLAYER, false);
+}
+
 std::vector<entity_id_t> PickFriendlyEntitiesInRect(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int x0, int y0, int x1, int y1, int player)
 {
     return EntitySelection::PickEntitiesInRect(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), x0, y0, x1, y1, player, false);
 }
 
+std::vector<entity_id_t> PickEntitiesOnScreen(ScriptInterface::CxPrivate* pCxPrivate)
+{
+    return PickEntitiesInRect(pCxPrivate, 0, 0, g_xres, g_yres);
+}
+
 std::vector<entity_id_t> PickFriendlyEntitiesOnScreen(ScriptInterface::CxPrivate* pCxPrivate, int player)
 {
     return PickFriendlyEntitiesInRect(pCxPrivate, 0, 0, g_xres, g_yres, player);
 }
 
+std::vector<entity_id_t> PickSimilarEntities(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string templateName, bool includeOffScreen, bool matchRank, bool allowFoundations)
+{
+    return EntitySelection::PickSimilarEntities(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), templateName, INVALID_PLAYER, includeOffScreen, matchRank, false, allowFoundations);
+}
+
 std::vector<entity_id_t> PickSimilarFriendlyEntities(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string templateName, bool includeOffScreen, bool matchRank, bool allowFoundations)
 {
     return EntitySelection::PickSimilarEntities(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), templateName, g_Game->GetPlayerID(), includeOffScreen, matchRank, false, allowFoundations);
@@ -810 +825 @@
 
     // Entity picking
     scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, int, &PickEntitiesAtPoint>("PickEntitiesAtPoint");
+    scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, int, int, &PickEntitiesInRect>("PickEntitiesInRect");
     scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, int, int, int, &PickFriendlyEntitiesInRect>("PickFriendlyEntitiesInRect");
+    scriptInterface.RegisterFunction<std::vector<entity_id_t>, &PickEntitiesOnScreen>("PickEntitiesOnScreen");
     scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, &PickFriendlyEntitiesOnScreen>("PickFriendlyEntitiesOnScreen");
+    scriptInterface.RegisterFunction<std::vector<entity_id_t>, std::string, bool, bool, bool, &PickSimilarEntities>("PickSimilarEntities");
     scriptInterface.RegisterFunction<std::vector<entity_id_t>, std::string, bool, bool, bool, &PickSimilarFriendlyEntities>("PickSimilarFriendlyEntities");
     scriptInterface.RegisterFunction<CFixedVector3D, int, int, &GetTerrainAtScreenPoint>("GetTerrainAtScreenPoint");
 

source/network/NetTurnManager.cpp

@@ -38 +38 @@
 #include <iomanip>
 
 static const int DEFAULT_TURN_LENGTH_MP = 500;
-static const int DEFAULT_TURN_LENGTH_SP = 200;
+static const int DEFAULT_TURN_LENGTH_SP = 500;
 
 static const int COMMAND_DELAY = 2;
 
@@ -464 +464 @@
 
 
 
+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::NotifyFinishedUpdate(u32 turn)
+{
+    DoTurn(turn);
+}
+
+void CNetReplayTurnManager::DoTurn(u32 turn)
+{
+    std::map<int, std::vector<std::string> > playerCommands = m_ReplayCommands[turn];
+    std::map<int, std::vector<std::string> >::iterator it;
+    for (it = playerCommands.begin(); it != playerCommands.end(); ++it)
+    {
+        int player = it->first;
+        for (size_t i = 0; i < it->second.size(); ++i)
+        {
+            CScriptValRooted data = m_Simulation2.GetScriptInterface().ParseJSON(it->second[i]);
+            AddCommand(m_ClientId, player, data, m_CurrentTurn + 1);
+        }
+    }
+}
+
+
+
+
 CNetServerTurnManager::CNetServerTurnManager(CNetServerWorker& server) :
     m_NetServer(server), m_ReadyTurn(1), m_TurnLength(DEFAULT_TURN_LENGTH_MP)
 {

source/network/NetTurnManager.h

@@ -22 +22 @@
 
 #include <list>
 #include <map>
+#include <vector>
 
 class CNetServerWorker;
 class CNetClient;
@@ -227 +228 @@
     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);
+
+protected:
+    virtual void NotifyFinishedUpdate(u32 turn);
+
+    void DoTurn(u32 turn);
+
+    std::map<u32, std::map<int, std::vector<std::string> > > m_ReplayCommands;
+};
+
+
 /**
  * The server-side counterpart to CNetClientTurnManager.
  * Records the turn state of each client, and sends turn advancement messages

source/ps/Game.cpp

@@ -62 +62 @@
  * 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)),
@@ -70 +70 @@
     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.
@@ -100 +105 @@
     delete m_Simulation2;
     delete m_World;
     delete m_ReplayLogger;
+    delete m_ReplayStream;
 }
 
 void CGame::SetTurnManager(CNetTurnManager* turnManager)
@@ -170 +176 @@
     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();
 }
 
@@ -193 +202 @@
     return 0;
 }
 
+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);
+        }
+        else if (type == "cmd")
+        {
+            int player;
+            *m_ReplayStream >> player;
+
+            std::string line;
+            std::getline(*m_ReplayStream, line);
+            replayTurnMgr->StoreReplayCommand(currentTurn, player, line);
+        }
+        else if (type == "hash" || type == "hash-quick")
+        {
+            // Ignored for now
+            std::string replayHash;
+            *m_ReplayStream >> replayHash;
+        }
+        else if (type == "end")
+        {
+            currentTurn++;
+        }
+        else
+        {
+            CancelLoad(L"Failed to load replay data (unrecognized content)");
+        }
+    }
+    m_FinalReplayTurn = currentTurn + 1;
+
+    return 0;
+}
+
+void CGame::StartReplay(const std::string& replayPath)
+{
+    m_IsReplay = true;
+
+    SetTurnManager(new CNetReplayTurnManager(*m_Simulation2, GetReplayLogger()));
+
+    m_ReplayPath = replayPath;
+    m_ReplayStream = new std::ifstream(m_ReplayPath.c_str());
+    ENSURE(m_ReplayStream->good());
+
+    std::string type;
+    ENSURE((*m_ReplayStream >> type).good() && type == "start");
+
+    std::string line;
+    std::getline(*m_ReplayStream, line);
+    CScriptValRooted attribs = m_Simulation2->GetScriptInterface().ParseJSON(line);
+    StartGame(attribs, "");
+}
+
 /**
  * Game initialization has been completed. Set game started flag and start the session.
  *
@@ -306 +381 @@
                 g_GUI->SendEventToAll("SimulationUpdate");
             }
 
+            if (m_IsReplay && m_TurnManager->GetCurrentTurn() == m_FinalReplayTurn)
+                g_GUI->SendEventToAll("ReplayFinished");
+
             GetView()->GetLOSTexture().MakeDirty();
         }
         

source/ps/Game.h

@@ -19 +19 @@
 #define INCLUDED_GAME
 
 #include "ps/Errors.h"
+#include <map>
 #include <vector>
 
 #include "scriptinterface/ScriptVal.h"
@@ -65 +66 @@
     CNetTurnManager* m_TurnManager;
 
 public:
-    CGame(bool disableGraphics = false);
+    CGame(bool disableGraphics = false, bool replayLog = true);
     ~CGame();
 
     /**
@@ -76 +77 @@
     void StartGame(const CScriptValRooted& attribs, const std::string& savedState);
     PSRETURN ReallyStartGame();
 
+    void 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.
@@ -171 +174 @@
     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;

source/ps/GameSetup/GameSetup.cpp

@@ -843 +843 @@
 }
 
 bool Autostart(const CmdLineArgs& args);
+bool VisualReplay(const CmdLineArgs& args);
 
 void Init(const CmdLineArgs& args, int flags)
 {
@@ -1012 +1013 @@
 
     try
     {
-        if (!Autostart(args))
+        if (!VisualReplay(args) && !Autostart(args))
         {
             const bool setup_gui = ((flags & INIT_NO_GUI) == 0);
             // We only want to display the splash screen at startup
@@ -1054 +1055 @@
     g_DoRenderCursor = RenderingState;
 }
 
+bool VisualReplay(const CmdLineArgs& args)
+{
+    CStr replayPath = args.Get("replay-visual");
+    if (!replayPath.empty())
+    {
+        g_Game = new CGame(false, false);
+        
+        g_Game->SetPlayerID(1);
+        g_Game->StartReplay(replayPath);
+
+        // TODO: Non progressive load can fail - need a decent way to handle this
+        LDR_NonprogressiveLoad();
+
+        PSRETURN ret = g_Game->ReallyStartGame();
+        ENSURE(ret == PSRETURN_OK);
+
+        InitPs(true, L"page_replay.xml", g_GUI->GetScriptInterface().get(), JSVAL_VOID);
+        return true;
+    }
+
+    return false;
+}
+
 bool Autostart(const CmdLineArgs& args)
 {
     /*

source/ps/Replay.cpp

@@ -129 +129 @@
     g_ProfileViewer.AddRootTable(g_ScriptStatsTable);
     g_ScriptRuntime = ScriptInterface::CreateRuntime(128 * 1024 * 1024);
 
-    CGame game(true);
+    CGame game(true, false);
     g_Game = &game;
 
     // Need some stuff for terrain movement costs:

source/simulation2/helpers/Selection.cpp

@@ -212 +212 @@
 
         // Ignore entities hidden by LOS (or otherwise hidden, e.g. when not IsInWorld)
         // In this case, the checking is done to avoid selecting garrisoned units
-        if (cmpRangeManager->GetLosVisibility(handle, owner) == ICmpRangeManager::VIS_HIDDEN)
+        if (owner != INVALID_PLAYER && cmpRangeManager->GetLosVisibility(handle, owner) == ICmpRangeManager::VIS_HIDDEN)
             continue;
 
         // Ignore entities not owned by 'owner'