Ticket #3215: t3215_fix_observer_statusbars_v3.patch

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

@@ -159 +159 @@
     else if (placementSupport.mode === "wall")
     {
         if (placementSupport.wallSet && placementSupport.position)
         {
             // Fetch an updated list of snapping candidate entities
-            placementSupport.wallSnapEntities = Engine.PickSimilarFriendlyEntities(
+            placementSupport.wallSnapEntities = Engine.PickSimilarPlayerEntities(
                 placementSupport.wallSet.templates.tower,
                 placementSupport.wallSnapEntitiesIncludeOffscreen,
                 true, // require exact template match
                 true  // include foundations
             );
@@ -549 +549 @@
         switch (ev.type)
         {
         case "mousemotion":
             var rect = updateBandbox(bandbox, ev, false);
 
-            var ents = Engine.PickFriendlyEntitiesInRect(rect[0], rect[1], rect[2], rect[3], Engine.GetPlayerID());
+            var ents = Engine.PickPlayerEntitiesInRect(rect[0], rect[1], rect[2], rect[3], Engine.GetPlayerID());
             var preferredEntities = getPreferredEntities(ents);
             g_Selection.setHighlightList(preferredEntities);
 
             return false;
 
@@ -561 +561 @@
             if (ev.button == SDL_BUTTON_LEFT)
             {
                 var rect = updateBandbox(bandbox, ev, true);
 
                 // Get list of entities limited to preferred entities
-                var ents = getPreferredEntities(Engine.PickFriendlyEntitiesInRect(rect[0], rect[1], rect[2], rect[3], Engine.GetPlayerID()));
+                var ents = getPreferredEntities(Engine.PickPlayerEntitiesInRect(rect[0], rect[1], rect[2], rect[3], Engine.GetPlayerID()));
 
                 // Remove the bandbox hover highlighting
                 g_Selection.setHighlightList([]);
 
                 // Update the list of selected units
@@ -1043 +1043 @@
                         // Select units matching exact template name (same rank)
                         templateToMatch = GetEntityState(selectedEntity).template;
                     }
 
                     // TODO: Should we handle "control all units" here as well?
-                    ents = Engine.PickSimilarFriendlyEntities(templateToMatch, showOffscreen, matchRank, false);
+                    ents = Engine.PickSimilarPlayerEntities(templateToMatch, showOffscreen, matchRank, false);
                 }
                 else
                 {
                     // It's single click right now but it may become double or triple click
                     doubleClicked = false;

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

@@ -820 +820 @@
 
 // Toggles the display of status bars for all of the player's entities.
 function recalculateStatusBarDisplay()
 {
     if (g_ShowAllStatusBars)
-        var entities = Engine.PickFriendlyEntitiesOnScreen(Engine.GetPlayerID());
+        var entities = g_IsObserver ? Engine.PickNonGaiaEntitiesOnScreen() : Engine.PickPlayerEntitiesOnScreen(Engine.GetPlayerID());
     else
     {
         var selected = g_Selection.toList();
         for each (var ent in g_Selection.highlighted)
             selected.push(ent);
-
+        
         // Remove selected entities from the 'all entities' array, to avoid disabling their status bars.
-        var entities = Engine.GuiInterfaceCall("GetPlayerEntities").filter(
-                function(idx) { return (selected.indexOf(idx) == -1); }
-        );
+        var entities = Engine.GuiInterfaceCall(g_IsObserver ? "GetNonGaiaEntities" : "GetPlayerEntities").filter(idx => selected.indexOf(idx) == -1);
     }
 
     Engine.GuiInterfaceCall("SetStatusBars", { "entities": entities, "enabled": g_ShowAllStatusBars });
 }
-
 // Update the additional list of entities to be highlighted.
 function updateAdditionalHighlight()
 {
     var entsAdd = [];    // list of entities units to be highlighted
     var entsRemove = [];

binaries/data/mods/public/simulation/components/GuiInterface.js

@@ -891 +891 @@
 {
     var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
     return cmpRangeManager.GetEntitiesByPlayer(player);
 };
 
+GuiInterface.prototype.GetNonGaiaEntities = function()
+{
+    var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    return cmpRangeManager.GetNonGaiaEntities();
+};
+
 /**
  * Displays the rally points of a given list of entities (carried in cmd.entities).
  * 
  * The 'cmd' object may carry its own x/z coordinate pair indicating the location where the rally point should 
  * be rendered, in order to support instantaneously rendering a rally point marker at a specified location 
@@ -1883 +1889 @@
 
     "SetSelectionHighlight": 1,
     "GetAllBuildableEntities": 1,
     "SetStatusBars": 1,
     "GetPlayerEntities": 1,
+    "GetNonGaiaEntities": 1,
     "DisplayRallyPoint": 1,
     "SetBuildingPlacementPreview": 1,
     "SetWallPlacementPreview": 1,
     "GetFoundationSnapData": 1,
     "PlaySound": 1,

source/gui/scripting/ScriptFunctions.cpp

@@ -59 +59 @@
 #include "renderer/scripting/JSInterface_Renderer.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpAIManager.h"
 #include "simulation2/components/ICmpCommandQueue.h"
 #include "simulation2/components/ICmpGuiInterface.h"
+#include "simulation2/components/ICmpPlayerManager.h"
 #include "simulation2/components/ICmpRangeManager.h"
 #include "simulation2/components/ICmpSelectable.h"
 #include "simulation2/components/ICmpTemplateManager.h"
 #include "simulation2/helpers/Selection.h"
 #include "soundmanager/SoundManager.h"
@@ -151 +152 @@
 entity_id_t PickEntityAtPoint(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int x, int y)
 {
     return EntitySelection::PickEntityAtPoint(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), x, y, g_Game->GetPlayerID(), false);
 }
 
-std::vector<entity_id_t> PickFriendlyEntitiesInRect(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int x0, int y0, int x1, int y1, int player)
+std::vector<entity_id_t> PickPlayerEntitiesInRect(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> PickFriendlyEntitiesOnScreen(ScriptInterface::CxPrivate* pCxPrivate, int player)
+std::vector<entity_id_t> PickPlayerEntitiesOnScreen(ScriptInterface::CxPrivate* pCxPrivate, int player)
 {
-    return PickFriendlyEntitiesInRect(pCxPrivate, 0, 0, g_xres, g_yres, player);
+    return PickPlayerEntitiesInRect(pCxPrivate, 0, 0, g_xres, g_yres, player);
 }
 
-std::vector<entity_id_t> PickSimilarFriendlyEntities(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::string templateName, bool includeOffScreen, bool matchRank, bool allowFoundations)
+std::vector<entity_id_t> PickNonGaiaEntitiesOnScreen(ScriptInterface::CxPrivate* pCxPrivate)
+{
+    std::vector<entity_id_t> entities;
+
+    CmpPtr<ICmpPlayerManager> cmpPlayerManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
+
+    if (!cmpPlayerManager)
+        return entities;
+
+    i32 numPlayers = cmpPlayerManager->GetNumPlayers();
+    for (i32 player = 1; player < numPlayers; ++player)
+    {
+        std::vector<entity_id_t> ents = PickPlayerEntitiesOnScreen(pCxPrivate, player);
+        entities.insert(entities.end(), ents.begin(), ents.end());
+    }
+    return entities;
+}
+
+std::vector<entity_id_t> PickSimilarPlayerEntities(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);
 }
 
 CFixedVector3D GetTerrainAtScreenPoint(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int x, int y)
@@ -942 +961 @@
     scriptInterface.RegisterFunction<JS::Value, std::wstring, JS::HandleValue, &GuiInterfaceCall>("GuiInterfaceCall");
     scriptInterface.RegisterFunction<void, JS::HandleValue, &PostNetworkCommand>("PostNetworkCommand");
 
     // Entity picking
     scriptInterface.RegisterFunction<entity_id_t, int, int, &PickEntityAtPoint>("PickEntityAtPoint");
-    scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, int, int, int, &PickFriendlyEntitiesInRect>("PickFriendlyEntitiesInRect");
-    scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, &PickFriendlyEntitiesOnScreen>("PickFriendlyEntitiesOnScreen");
-    scriptInterface.RegisterFunction<std::vector<entity_id_t>, std::string, bool, bool, bool, &PickSimilarFriendlyEntities>("PickSimilarFriendlyEntities");
+    scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, int, int, int, &PickPlayerEntitiesInRect>("PickPlayerEntitiesInRect");
+    scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, &PickPlayerEntitiesOnScreen>("PickPlayerEntitiesOnScreen");
+    scriptInterface.RegisterFunction<std::vector<entity_id_t>, &PickNonGaiaEntitiesOnScreen>("PickNonGaiaEntitiesOnScreen");
+    scriptInterface.RegisterFunction<std::vector<entity_id_t>, std::string, bool, bool, bool, &PickSimilarPlayerEntities>("PickSimilarPlayerEntities");
     scriptInterface.RegisterFunction<CFixedVector3D, int, int, &GetTerrainAtScreenPoint>("GetTerrainAtScreenPoint");
 
     // Network / game setup functions
     scriptInterface.RegisterFunction<void, &StartNetworkGame>("StartNetworkGame");
     scriptInterface.RegisterFunction<void, JS::HandleValue, int, &StartGame>("StartGame");

source/simulation2/components/CCmpRangeManager.cpp

@@ -905 +905 @@
         }
 
         return entities;
     }
 
+    virtual std::vector<entity_id_t> GetNonGaiaEntities()
+    {
+        // Compute ownership mask for all players except gaia as in CalcOwnerMask
+        u32 ownerMask = ((1 << MAX_LOS_PLAYER_ID) - 1) << 1;
+
+        // Get the list of entities
+        std::vector<entity_id_t> entities;
+        for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+        {
+            // Check owner and add to list if it matches
+            if (CalcOwnerMask(it->second.owner) & ownerMask)
+                entities.push_back(it->first);
+        }
+
+        return entities;
+    }
+
     virtual void SetDebugOverlay(bool enabled)
     {
         m_DebugOverlayEnabled = enabled;
         m_DebugOverlayDirty = true;
         if (!enabled)

source/simulation2/components/ICmpRangeManager.cpp

@@ -43 +43 @@
 DEFINE_INTERFACE_METHOD_1("DisableActiveQuery", void, ICmpRangeManager, DisableActiveQuery, ICmpRangeManager::tag_t)
 DEFINE_INTERFACE_METHOD_1("ResetActiveQuery", std::vector<entity_id_t>, ICmpRangeManager, ResetActiveQuery, ICmpRangeManager::tag_t)
 DEFINE_INTERFACE_METHOD_3("SetEntityFlag", void, ICmpRangeManager, SetEntityFlag, entity_id_t, std::string, bool)
 DEFINE_INTERFACE_METHOD_1("GetEntityFlagMask", u8, ICmpRangeManager, GetEntityFlagMask, std::string)
 DEFINE_INTERFACE_METHOD_1("GetEntitiesByPlayer", std::vector<entity_id_t>, ICmpRangeManager, GetEntitiesByPlayer, player_id_t)
+DEFINE_INTERFACE_METHOD_0("GetNonGaiaEntities", std::vector<entity_id_t>, ICmpRangeManager, GetNonGaiaEntities)
 DEFINE_INTERFACE_METHOD_1("SetDebugOverlay", void, ICmpRangeManager, SetDebugOverlay, bool)
 DEFINE_INTERFACE_METHOD_1("ExploreAllTiles", void, ICmpRangeManager, ExploreAllTiles, player_id_t)
 DEFINE_INTERFACE_METHOD_0("ExploreTerritories", void, ICmpRangeManager, ExploreTerritories)
 DEFINE_INTERFACE_METHOD_2("SetLosRevealAll", void, ICmpRangeManager, SetLosRevealAll, player_id_t, bool)
 DEFINE_INTERFACE_METHOD_1("GetLosRevealAll", bool, ICmpRangeManager, GetLosRevealAll, player_id_t)

source/simulation2/components/ICmpRangeManager.h

@@ -177 +177 @@
      * @return list of entities matching the query, ordered by increasing distance from the source entity.
      */
     virtual std::vector<entity_id_t> ResetActiveQuery(tag_t tag) = 0;
 
     /**
-     * Returns list of all entities for specific player.
+     * Returns a list of all entities for specific player.
      * (This is on this interface because it shares a lot of the implementation.
      * Maybe it should be extended to be more like ExecuteQuery without
      * the range parameter.)
      */
     virtual std::vector<entity_id_t> GetEntitiesByPlayer(player_id_t player) = 0;
 
     /**
+     * Returns a list of all entities of all players except gaia.
+     */
+    virtual std::vector<entity_id_t> GetNonGaiaEntities() = 0;
+
+    /**
      * Toggle the rendering of debug info.
      */
     virtual void SetDebugOverlay(bool enabled) = 0;
 
     /**

source/simulation2/helpers/Selection.cpp

@@ -142 +142 @@
 
     if (owner != INVALID_PLAYER)
     {
         CComponentManager& componentManager = simulation.GetSimContext().GetComponentManager();
         std::vector<entity_id_t> ents = cmpRangeManager->GetEntitiesByPlayer(owner);
-        for (std::vector<entity_id_t>::iterator it = ents.begin(); it != ents.end(); ++it)
+        for (const entity_id_t& ent : ents)
         {
-            if (CheckEntityVisibleAndInRect(componentManager.LookupEntityHandle(*it), cmpRangeManager, camera, sx0, sy0, sx1, sy1, owner, allowEditorSelectables))
-                hitEnts.push_back(*it);
+            if (CheckEntityVisibleAndInRect(componentManager.LookupEntityHandle(ent), cmpRangeManager, camera, sx0, sy0, sx1, sy1, owner, allowEditorSelectables))
+                hitEnts.push_back(ent);
         }
     }
     else // owner == INVALID_PLAYER; Used when selecting units in Atlas or other mods that allow all kinds of selectables to be selected.
     {
         const CSimulation2::InterfaceListUnordered& selectableEnts = simulation.GetEntitiesWithInterfaceUnordered(IID_Selectable);
@@ -161 +161 @@
     }
 
     return hitEnts;
 }
 
+std::vector<entity_id_t> EntitySelection::PickNonGaiaEntitiesInRect(CSimulation2& simulation, const CCamera& camera, int sx0, int sy0, int sx1, int sy1, bool allowEditorSelectables)
+{
+    PROFILE2("PickNonGaiaEntitiesInRect");
+    // Make sure sx0 <= sx1, and sy0 <= sy1
+    if (sx0 > sx1)
+        std::swap(sx0, sx1);
+    if (sy0 > sy1)
+        std::swap(sy0, sy1);
+
+    CmpPtr<ICmpRangeManager> cmpRangeManager(simulation, SYSTEM_ENTITY);
+    ENSURE(cmpRangeManager);
+
+    std::vector<entity_id_t> hitEnts;
+
+    CComponentManager& componentManager = simulation.GetSimContext().GetComponentManager();
+
+    std::vector<entity_id_t> ents = cmpRangeManager->GetNonGaiaEntities();
+    for (const entity_id_t& ent : ents)
+    {
+        CmpPtr<ICmpOwnership> cmpOwnership(simulation.GetSimContext(), ent);
+        if (CheckEntityVisibleAndInRect(componentManager.LookupEntityHandle(ent), cmpRangeManager, camera, sx0, sy0, sx1, sy1, cmpOwnership->GetOwner(), allowEditorSelectables))
+            hitEnts.push_back(ent);
+    }
+
+    return hitEnts;
+}
+
 std::vector<entity_id_t> EntitySelection::PickSimilarEntities(CSimulation2& simulation, const CCamera& camera, 
     const std::string& templateName, player_id_t owner, bool includeOffScreen, bool matchRank,
     bool allowEditorSelectables, bool allowFoundations)
 {
     PROFILE2("PickSimilarEntities");

source/simulation2/helpers/Selection.h

@@ -63 +63 @@
  * @return unordered list of selected entities.
  */
 std::vector<entity_id_t> PickEntitiesInRect(CSimulation2& simulation, const CCamera& camera, int sx0, int sy0, int sx1, int sy1, player_id_t owner, bool allowEditorSelectables);
 
 /**
+ * Finds all selectable entities within the given screen coordinate rectangle,
+ * belonging to any player.
+ *
+ * @param camera use this view to convert screen to world coordinates.
+ * @param sx0,sy0,sx1,sy1 diagonally opposite corners of the rectangle in 2D screen coordinates.
+ * @param owner player whose entities we are selecting. Ownership is ignored if
+ *  INVALID_PLAYER is used.
+ * @param allowEditorSelectables if true, all entities with the ICmpSelectable interface
+ *  will be selected (including decorative actors), else only those selectable ingame.
+ *
+ * @return unordered list of selected entities.
+ */
+std::vector<entity_id_t> PickNonGaiaEntitiesInRect(CSimulation2& simulation, const CCamera& camera, int sx0, int sy0, int sx1, int sy1, bool allowEditorSelectables);
+
+/**
  * Finds all entities with the given entity template name, belonging to the given player.
  * 
  * @param camera use this view to convert screen to world coordinates.
  * @param templateName the name of the template to match, or the selection group name
  *  for similar matching.