Ticket #958: territory_fow_building-09122011.patch

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

@@ -118 +118 @@
         return false;   // Fail
     }
     
+    // Check whether it's in a visible region or explored but inside player's territory
+    var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    if (!cmpRangeManager)
+    {
+        return false;   // Fail
+    }
+    var losState = cmpRangeManager.GetLosState(this.entity, player);
+    if (losState != "visible" && !(losState == "explored" && isOwn))
+    {
+        return false;   // Fail
+    }
+    
     // Check special requirements
     if (this.template.Category == "Dock")
     {

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

@@ -471 +471 @@
             pos.SetYRotation(cmd.angle);
         }
 
-        // Check whether it's in a visible region
-        var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
-        var visible = (cmpRangeManager && cmpRangeManager.GetLosVisibility(ent, player) == "visible");
-        var validPlacement = false;
+        // Check whether it's obstructed by other entities or invalid terrain
+        var cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
+        if (!cmpBuildRestrictions)
+            error("cmpBuildRestrictions not defined");
         
-        if (visible)
-        {   // Check whether it's obstructed by other entities or invalid terrain
-            var cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
-            if (!cmpBuildRestrictions)
-                error("cmpBuildRestrictions not defined");
-            
-            validPlacement = (cmpBuildRestrictions && cmpBuildRestrictions.CheckPlacement(player));
-        }
-
-        var ok = (visible && validPlacement);
+        var validPlacement = (cmpBuildRestrictions && cmpBuildRestrictions.CheckPlacement(player));
         
         // Set it to a red shade if this is an invalid location
         var cmpVisual = Engine.QueryInterface(ent, IID_Visual);
         if (cmpVisual)
         {
-            if (!ok)
+            if (!validPlacement)
                 cmpVisual.SetShadingColour(1.4, 0.4, 0.4, 1);
             else
                 cmpVisual.SetShadingColour(1, 1, 1, 1);
         }
 
-        return ok;
+        return validPlacement;
     }
 
     return false;

binaries/data/mods/public/simulation/helpers/Commands.js

@@ -168 +168 @@
                 Engine.DestroyEntity(ent);
                 break;
             }
-
-            // Check whether it's in a visible region
-            var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
-            var visible = (cmpRangeManager.GetLosVisibility(ent, player) == "visible");
-            if (!visible)
-            {
-                // TODO: report error to player (the building site was not visible)
-                print("Building site was not visible\n");
-
-                Engine.DestroyEntity(ent);
-                break;
-            }
         }
         
         var cmpCost = Engine.QueryInterface(ent, IID_Cost);

source/simulation2/components/CCmpRangeManager.cpp

@@ -866 +866 @@
         return VIS_HIDDEN;
     }
 
+    virtual ELosState GetLosState(entity_id_t ent, player_id_t player)
+    {
+        // (We can't use m_EntityData since this needs to handle LOCAL entities too)
+
+        // Entities not with positions in the world are never visible
+        CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), ent);
+        if (cmpPosition.null() || !cmpPosition->IsInWorld())
+            return LOS_UNEXPLORED;
+
+        CFixedVector2D pos = cmpPosition->GetPosition2D();
+
+        int i = (pos.X / (int)CELL_SIZE).ToInt_RoundToNearest();
+        int j = (pos.Y / (int)CELL_SIZE).ToInt_RoundToNearest();
+
+        // Reveal flag makes all positioned entities visible
+        if (GetLosRevealAll(player))
+        {
+            if (LosIsOffWorld(i, j))
+                return LOS_UNEXPLORED;
+            else
+                return LOS_VISIBLE;
+        }
+
+        CLosQuerier los(player, m_LosState, m_TerrainVerticesPerSide);
+
+        if (los.IsVisible(i, j))
+            return LOS_VISIBLE;
+        else if (los.IsExplored(i, j))
+            return LOS_EXPLORED;
+
+        // Otherwise unexplored
+        return LOS_UNEXPLORED;
+    }
+
     virtual void SetLosRevealAll(player_id_t player, bool enabled)
     {
         m_LosRevealAll[player] = enabled;

source/simulation2/components/ICmpRangeManager.cpp

@@ -33 +33 @@
     }
 }
 
+std::string ICmpRangeManager::GetLosState_wrapper(entity_id_t ent, int player)
+{
+    ELosState state = GetLosState(ent, player);
+    switch (state)
+    {
+    case LOS_UNEXPLORED: return "unexplored";
+    case LOS_EXPLORED: return "explored";
+    case LOS_VISIBLE: return "visible";
+    default: return "error"; // should never happen
+    }
+}
+
 BEGIN_INTERFACE_WRAPPER(RangeManager)
 DEFINE_INTERFACE_METHOD_5("ExecuteQuery", std::vector<entity_id_t>, ICmpRangeManager, ExecuteQuery, entity_id_t, entity_pos_t, entity_pos_t, std::vector<int>, int)
 DEFINE_INTERFACE_METHOD_5("CreateActiveQuery", ICmpRangeManager::tag_t, ICmpRangeManager, CreateActiveQuery, entity_id_t, entity_pos_t, entity_pos_t, std::vector<int>, int)
@@ -44 +56 @@
 DEFINE_INTERFACE_METHOD_1("SetDebugOverlay", void, ICmpRangeManager, SetDebugOverlay, bool)
 DEFINE_INTERFACE_METHOD_2("SetLosRevealAll", void, ICmpRangeManager, SetLosRevealAll, player_id_t, bool)
 DEFINE_INTERFACE_METHOD_2("GetLosVisibility", std::string, ICmpRangeManager, GetLosVisibility_wrapper, entity_id_t, player_id_t)
+DEFINE_INTERFACE_METHOD_2("GetLosState", std::string, ICmpRangeManager, GetLosState_wrapper, entity_id_t, player_id_t)
 DEFINE_INTERFACE_METHOD_1("SetLosCircular", void, ICmpRangeManager, SetLosCircular, bool)
 DEFINE_INTERFACE_METHOD_0("GetLosCircular", bool, ICmpRangeManager, GetLosCircular)
 DEFINE_INTERFACE_METHOD_1("GetPercentMapExplored", i32, ICmpRangeManager, GetPercentMapExplored, player_id_t)

source/simulation2/components/ICmpRangeManager.h

@@ -270 +270 @@
     std::string GetLosVisibility_wrapper(entity_id_t ent, player_id_t player);
 
     /**
+     * Returns the LOS state of the given entity, with respect to the given player.
+     * Returns LOS_UNEXPLORED if the entity doesn't exist or is not in the world.
+     * This respects the GetLosRevealAll flag.
+     * (Note this is subtly different than GetLosVisibility, which considers rendering concepts).
+     */
+    virtual ELosState GetLosState(entity_id_t ent, player_id_t player) = 0;
+
+    /**
+     * GetLosState wrapped for script calls.
+     * Returns "unexplored", "explored" or "visible".
+     */
+    std::string GetLosState_wrapper(entity_id_t ent, player_id_t player);
+
+    /**
      * Set whether the whole map should be made visible to the given player.
      * If player is -1, the map will be made visible to all players.
      */