Ticket #3215: t3215_fix_observer_statusbars_v4.patch

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

@@ -156 +156 @@
             return true;
         }
     }
     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
             );
             
             return Engine.GuiInterfaceCall("SetWallPlacementPreview", {
                 "wallSet": placementSupport.wallSet,
@@ -546 +546 @@
     {
     case INPUT_BANDBOXING:
         var bandbox = Engine.GetGUIObjectByName("bandbox");
         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;
 
         case "mousebuttonup":
             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
                 if (Engine.HotkeyIsPressed("selection.add"))
                 {
                     g_Selection.addList(ents);
@@ -1040 +1040 @@
                     else
                     {
                         // Double click has already occurred, so this is a triple click.
                         // 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;
                     doubleClickTimer = now.getTime();
                     prevClickedEntity = selectedEntity;
 

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

@@ -792 +792 @@
     for (var i = numButtons; i < 10; ++i)
         Engine.GetGUIObjectByName("researchStartedButton[" + i + "]").hidden = true;
 }
 
 // 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 = [];
     var highlighted = g_Selection.toList();
     for each (var ent in g_Selection.highlighted)
         highlighted.push(ent);

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

@@ -896 +896 @@
 };
 
 GuiInterface.prototype.GetPlayerEntities = function(player)
 {
     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 
  * instead of incurring a delay while PostNetworkCommand processes the set-rallypoint command (see input.js).
  * If cmd doesn't carry a custom location, then the position to render the marker at will be read from the 
  * RallyPoint component.
@@ -1894 +1900 @@
     "IsFormationSelected": 1,
     "GetFormationInfoFromTemplate": 1,
     "IsStanceSelected": 1,
 
     "SetSelectionHighlight": 1,
     "GetAllBuildableEntities": 1,
     "SetStatusBars": 1,
     "GetPlayerEntities": 1,
+    "GetNonGaiaEntities": 1,
     "DisplayRallyPoint": 1,
     "SetBuildingPlacementPreview": 1,
     "SetWallPlacementPreview": 1,
     "GetFoundationSnapData": 1,
     "PlaySound": 1,
     "FindIdleUnits": 1,
     "GetTradingRouteGain": 1,
     "GetTradingDetails": 1,

source/gui/scripting/ScriptFunctions.cpp

@@ -56 +56 @@
 #include "ps/scripting/JSInterface_Console.h"
 #include "ps/scripting/JSInterface_Mod.h"
 #include "ps/scripting/JSInterface_VFS.h"
 #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"
 #include "soundmanager/scripting/JSInterface_Sound.h"
 #include "tools/atlas/GameInterface/GameLoop.h"
 
@@ -148 +149 @@
     cmpCommandQueue->PostNetworkCommand(cmd2);
 }
 
 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)
+{
+    return PickPlayerEntitiesInRect(pCxPrivate, 0, 0, g_xres, g_yres, NON_GAIA_PLAYERS);
+}
+
+std::vector<entity_id_t> PickSimilarPlayerEntities(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), CStr 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)
 {
     CVector3D pos = g_Game->GetView()->GetCamera()->GetWorldCoordinates(x, y, true);
     return CFixedVector3D(fixed::FromFloat(pos.X), fixed::FromFloat(pos.Y), fixed::FromFloat(pos.Z));
@@ -939 +945 @@
     scriptInterface.RegisterFunction<JS::Value, CStr, &GetGUIObjectByName>("GetGUIObjectByName");
 
     // Simulation<->GUI interface functions:
     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>, CStr, 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");
     scriptInterface.RegisterFunction<void, &Script_EndGame>("EndGame");
     scriptInterface.RegisterFunction<void, std::wstring, &StartNetworkHost>("StartNetworkHost");
     scriptInterface.RegisterFunction<void, std::wstring, std::string, &StartNetworkJoin>("StartNetworkJoin");

source/simulation2/components/CCmpRangeManager.cpp

@@ -889 +889 @@
 
         return r;
     }
 
     virtual std::vector<entity_id_t> GetEntitiesByPlayer(player_id_t player)
     {
         std::vector<entity_id_t> entities;
 
-        u32 ownerMask = CalcOwnerMask(player);
-
-        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);
-        }
+        for (const EntityMap<EntityData>::key_val<unsigned int, EntityData>& entityData : m_EntityData)
+            if ((player == NON_GAIA_PLAYERS && entityData.second.owner != 0) || entityData.second.owner == player)
+                entities.emplace_back(entityData.first);
 
         return entities;
     }
 
+    virtual std::vector<entity_id_t> GetNonGaiaEntities()
+    {
+        return GetEntitiesByPlayer(NON_GAIA_PLAYERS);
+    }
+
     virtual void SetDebugOverlay(bool enabled)
     {
         m_DebugOverlayEnabled = enabled;
         m_DebugOverlayDirty = true;
         if (!enabled)
             m_DebugOverlayLines.clear();
     }
 

source/simulation2/components/ICmpRangeManager.cpp

@@ -40 +40 @@
 DEFINE_INTERFACE_METHOD_7("CreateActiveParabolicQuery", ICmpRangeManager::tag_t, ICmpRangeManager, CreateActiveParabolicQuery, entity_id_t, entity_pos_t, entity_pos_t, entity_pos_t, std::vector<int>, int, u8)
 DEFINE_INTERFACE_METHOD_1("DestroyActiveQuery", void, ICmpRangeManager, DestroyActiveQuery, ICmpRangeManager::tag_t)
 DEFINE_INTERFACE_METHOD_1("EnableActiveQuery", void, ICmpRangeManager, EnableActiveQuery, ICmpRangeManager::tag_t)
 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)
 DEFINE_INTERFACE_METHOD_5("GetElevationAdaptedRange", entity_pos_t, ICmpRangeManager, GetElevationAdaptedRange, CFixedVector3D, CFixedVector3D, entity_pos_t, entity_pos_t, entity_pos_t)
 DEFINE_INTERFACE_METHOD_2("ActivateScriptedVisibility", void, ICmpRangeManager, ActivateScriptedVisibility, entity_id_t, bool)
 DEFINE_INTERFACE_METHOD_2("GetLosVisibility", std::string, ICmpRangeManager, GetLosVisibility_wrapper, entity_id_t, player_id_t)

source/simulation2/components/ICmpRangeManager.h

@@ -174 +174 @@
      * The next RangeUpdate message will say who has entered/left since this call,
      * so you won't miss any notifications.
      * @param tag identifier of query.
      * @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. Also see GetEntitiesByPlayer.
+     */
+    virtual std::vector<entity_id_t> GetNonGaiaEntities() = 0;
+
+    /**
      * Toggle the rendering of debug info.
      */
     virtual void SetDebugOverlay(bool enabled) = 0;
 
     /**
      * Returns the mask for the specified identifier.
      */
     virtual u8 GetEntityFlagMask(std::string identifier) = 0;

source/simulation2/helpers/Player.h

@@ -19 +19 @@
 #define INCLUDED_PLAYER
 
 /**
  * valid player IDs are non-negative (see ICmpOwnership)
  */
 typedef int32_t player_id_t;
 
 static const player_id_t INVALID_PLAYER = -1;
+static const player_id_t NON_GAIA_PLAYERS = -2;
 
 #endif // INCLUDED_PLAYER

source/simulation2/helpers/Selection.cpp

@@ -93 +93 @@
 static bool CheckEntityVisibleAndInRect(CEntityHandle handle, CmpPtr<ICmpRangeManager> cmpRangeManager, const CCamera& camera, int sx0, int sy0, int sx1, int sy1, player_id_t owner, bool allowEditorSelectables)
 {
     // Check if this entity is only selectable in Atlas
     CmpPtr<ICmpSelectable> cmpSelectable(handle);
     if (!cmpSelectable || (!allowEditorSelectables && cmpSelectable->IsEditorOnly()))
         return false;
 
     // Ignore entities hidden by LOS (or otherwise hidden, e.g. when not IsInWorld)
-    if (cmpRangeManager->GetLosVisibility(handle, owner) == ICmpRangeManager::VIS_HIDDEN)
+    if (owner != NON_GAIA_PLAYERS && cmpRangeManager->GetLosVisibility(handle, owner) == ICmpRangeManager::VIS_HIDDEN)
         return false;
 
     // Find the current interpolated model position.
     // (We just use the centre position and not the whole bounding box, because maybe
     // that's better for users trying to select objects in busy areas)
 
     CmpPtr<ICmpVisual> cmpVisual(handle);
     if (!cmpVisual)
@@ -118 +118 @@
     // Compare screen-space coordinates
     float x, y;
     camera.GetScreenCoordinates(position, x, y);
     int ix = (int)x;
     int iy = (int)y;
     return sx0 <= ix && ix <= sx1 && sy0 <= iy && iy <= sy1;
 }
 
+/**
+ * Returns all entities visible in the given screen area and owned by the given player.
+ * If allowEditorSelectables is true, then all selectable entities, including decoratives will be returned.
+ */
 std::vector<entity_id_t> EntitySelection::PickEntitiesInRect(CSimulation2& simulation, const CCamera& camera, int sx0, int sy0, int sx1, int sy1, player_id_t owner, bool allowEditorSelectables)
 {
     PROFILE2("PickEntitiesInRect");
+
     // 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;
-
-    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)
-        {
-            if (CheckEntityVisibleAndInRect(componentManager.LookupEntityHandle(*it), cmpRangeManager, camera, sx0, sy0, sx1, sy1, owner, allowEditorSelectables))
-                hitEnts.push_back(*it);
-        }
-    }
-    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);
-        for (CSimulation2::InterfaceListUnordered::const_iterator it = selectableEnts.begin(); it != selectableEnts.end(); ++it)
-        {
-            if (CheckEntityVisibleAndInRect(it->second->GetEntityHandle(), cmpRangeManager, camera, sx0, sy0, sx1, sy1, owner, allowEditorSelectables))
-                hitEnts.push_back(it->first);
-        }
-    }
+    if (owner == INVALID_PLAYER)
+        // Get all selectable entities (including decoratives), used by Atlas
+        for (const std::pair<const unsigned int, IComponent*>& component : simulation.GetEntitiesWithInterfaceUnordered(IID_Selectable))
+            hitEnts.emplace_back(component.first);
+    else
+        hitEnts = (owner == NON_GAIA_PLAYERS) ? cmpRangeManager->GetNonGaiaEntities() : cmpRangeManager->GetEntitiesByPlayer(owner);
+
+    // Remove all entities invisible or not in the given rectangle
+    CComponentManager& componentManager = simulation.GetSimContext().GetComponentManager();
+    hitEnts.erase(std::remove_if(hitEnts.begin(), hitEnts.end(),
+        [&](const entity_id_t& ent)
+            { return !CheckEntityVisibleAndInRect(componentManager.LookupEntityHandle(ent), cmpRangeManager, camera, sx0, sy0, sx1, sy1, owner, allowEditorSelectables); }
+    ), hitEnts.end());
 
     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)
 {