Ticket #599: fogging+optimization.patch

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

@@ -335 +335 @@
 
     var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 
+    // Entities that are hidden and miraged are considered visible
+    var cmpFogging = Engine.QueryInterface(target, IID_Fogging);
+    if (cmpFogging && cmpFogging.IsMiraged(cmpOwnership.GetOwner()))
+        return true;
+
     if (cmpRangeManager.GetLosVisibility(target, cmpOwnership.GetOwner(), false) == "hidden")
         return false;
 

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

@@ -102 +102 @@
         if (!cmpRangeManager || !cmpOwnership)
             return result; // Fail
 
+        var cmpFogging = Engine.QueryInterface(this.entity, IID_Fogging);
         var explored = (cmpRangeManager.GetLosVisibility(this.entity, cmpOwnership.GetOwner(), true) != "hidden");
-        if (!explored)
+        if (!explored && !(cmpFogging && cmpFogging.IsMiraged(cmpOwnership.GetOwner())))
         {
             result.message = markForTranslation("%(name)s cannot be built in unexplored area");
             return result; // Fail

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

@@ -175 +175 @@
         "garrisonHolder": null,
         "gate": null,
         "guard": null,
+        "mirage": null,
         "pack": null,
         "player": -1,
         "position": null,
@@ -303 +304 @@
         };
     }
 
+    var cmpMirage = Engine.QueryInterface(ent, IID_Mirage);
+    if (cmpMirage)
+    {
+        ret.mirage = {
+            "parent": cmpMirage.GetParent(),
+        };
+    }
+
     var cmpGate = Engine.QueryInterface(ent, IID_Gate);
     if (cmpGate)
     {

binaries/data/mods/public/simulation/components/interfaces/Messages.js

@@ -1 @@
-/**
- * Broadcast message 
- * sent when one entity is changed to other:
- * from Foundation component when building constuction is done
- * and from Promotion component when unit is promoted
- * Data: { entity: <integer>, newentity: <integer> }
- */
-Engine.RegisterMessageType("EntityRenamed");
-
 Engine.RegisterMessageType("DiplomacyChanged");

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

@@ -3896 +3896 @@
     if (cmpFormation)
         return true;
 
+    var cmpMirage = Engine.QueryInterface(ent, IID_Mirage);
+    if (cmpMirage)
+        return true;
+
     var cmpHealth = Engine.QueryInterface(ent, IID_Health);
     if (!cmpHealth)
         return false;
@@ -4386 +4390 @@
     if (!cmpRangeManager)
         return false;
 
+    // Entities that are hidden and miraged are considered visible
+    var cmpFogging = Engine.QueryInterface(target, IID_Fogging);
+    if (cmpFogging && cmpFogging.IsMiraged(cmpOwnership.GetOwner()))
+        return true;
+
     if (cmpRangeManager.GetLosVisibility(target, cmpOwnership.GetOwner(), false) == "hidden")
         return false;
 

binaries/data/mods/public/simulation/templates/template_gaia.xml

@@ -1 +1 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_entity_quasi">
+  <Fogging/>
   <Identity>
     <Civ>gaia</Civ>
     <GenericName>Gaia</GenericName>

binaries/data/mods/public/simulation/templates/template_structure.xml

@@ -37 +37 @@
     <SinkRate>3.0</SinkRate>
     <SinkAccel>9.8</SinkAccel>
   </Decay>
+  <Fogging/>
   <Health>
     <DeathType>corpse</DeathType>
     <RegenRate>0</RegenRate>

source/ps/TemplateLoader.cpp

@@ -80 +80 @@
         return true;
     }
 
+    // Handle special case "mirage|foo"
+    if (templateName.find("mirage|") == 0)
+    {
+        // Load the base entity template, if it wasn't already loaded
+        std::string baseName = templateName.substr(7);
+        if (!LoadTemplateFile(baseName, depth+1))
+        {
+            LOGERROR(L"Failed to load entity template '%hs'", baseName.c_str());
+            return false;
+        }
+        // Copy a subset to the requested template
+        CopyMirageSubset(m_TemplateFileData[templateName], m_TemplateFileData[baseName]);
+        return true;
+    }
+
     // Handle special case "foundation|foo"
     if (templateName.find("foundation|") == 0)
     {
@@ -380 +395 @@
     }
 }
 
+void CTemplateLoader::CopyMirageSubset(CParamNode& out, const CParamNode& in)
+{
+    // Currently used for mirage entities replacing real ones in fog-of-war
+
+    std::set<std::string> permittedComponentTypes;
+    permittedComponentTypes.insert("Footprint");
+    permittedComponentTypes.insert("Health");
+    permittedComponentTypes.insert("Minimap");
+    permittedComponentTypes.insert("Ownership");
+    permittedComponentTypes.insert("Position");
+    permittedComponentTypes.insert("ResourceSupply");
+    permittedComponentTypes.insert("Selectable");
+    permittedComponentTypes.insert("VisualActor");
+
+    CParamNode::LoadXMLString(out, "<Entity/>");
+    out.CopyFilteredChildrenOfChild(in, "Entity", permittedComponentTypes);
+
+    // Select a subset of identity data. We don't want to have, for example, a CC mirage
+    // that has also the CC class and then prevents construction of other CCs
+    std::set<std::string> identitySubset;
+    identitySubset.insert("Civ");
+    identitySubset.insert("GenericName");
+    identitySubset.insert("SpecificName");
+    identitySubset.insert("Tooltip");
+    identitySubset.insert("History");
+    identitySubset.insert("Icon");
+    CParamNode identity;
+    CParamNode::LoadXMLString(identity, "<Identity/>");
+    identity.CopyFilteredChildrenOfChild(in.GetChild("Entity"), "Identity", identitySubset);
+    CParamNode::LoadXMLString(out, ("<Entity>"+utf8_from_wstring(identity.ToXML())+"</Entity>").c_str());
+
+    // Set the entity as mirage entity
+    CParamNode::LoadXMLString(out, "<Entity><Mirage/></Entity>");
+    CParamNode::LoadXMLString(out, "<Entity><Vision><Range>0</Range><RetainInFog>true</RetainInFog><AlwaysVisible>false</AlwaysVisible></Vision></Entity>");
+}
+
 void CTemplateLoader::CopyFoundationSubset(CParamNode& out, const CParamNode& in)
 {
     // TODO: this is all kind of yucky and hard-coded; it'd be nice to have a more generic
@@ -394 +445 @@
     permittedComponentTypes.insert("Obstruction");
     permittedComponentTypes.insert("Selectable");
     permittedComponentTypes.insert("Footprint");
+    permittedComponentTypes.insert("Fogging");
     permittedComponentTypes.insert("Armour");
     permittedComponentTypes.insert("Health");
     permittedComponentTypes.insert("StatusBars");

source/ps/TemplateLoader.h

@@ -79 +79 @@
     void CopyPreviewSubset(CParamNode& out, const CParamNode& in, bool corpse);
 
     /** 
+     * Copy the components of an entity template necessary for a fogged "mirage"
+     * entity (position, actor) into a new entity template
+     */
+    void CopyMirageSubset(CParamNode& out, const CParamNode& in);
+
+    /** 
      * Copy the components of an entity template necessary for a construction foundation
      * (position, actor, armour, health, etc) into a new entity template
      */

source/simulation2/components/CCmpFogging.cpp

@@ +1 @@
+/* Copyright (C) 2014 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "simulation2/system/Component.h"
+#include "simulation2/MessageTypes.h"
+#include "ICmpFogging.h"
+
+#include "lib/utf8.h"
+
+#include "ICmpOwnership.h"
+#include "ICmpPlayerManager.h"
+#include "ICmpRangeManager.h"
+#include "ICmpTemplateManager.h"
+#include "ICmpVisual.h"
+
+#include "ICmpMirage.h"
+#include "ICmpPosition.h"
+
+class CCmpFogging : public ICmpFogging
+{
+public:
+    static void ClassInit(CComponentManager& componentManager)
+    {
+        componentManager.SubscribeToMessageType(MT_VisibilityChanged);
+        componentManager.SubscribeToMessageType(MT_Destroy);
+    }
+
+    DEFAULT_COMPONENT_ALLOCATOR(Fogging)
+
+    static std::string GetSchema()
+    {
+        return "<a:help>Allows this entity to be replaced by mirages entities in the fog-of-war.</a:help>"
+            "<empty/>";
+    }
+
+    virtual void Init(const CParamNode& UNUSED(paramNode))
+    {
+        CmpPtr<ICmpPlayerManager> cmpPlayerManager(GetSystemEntity());
+        size_t numPlayers = cmpPlayerManager->GetNumPlayers();
+
+        for (size_t i = 0; i < numPlayers; ++i)
+        {
+            m_Mirages.push_back(INVALID_ENTITY);
+            m_Miraged.push_back(false);
+        }
+    }
+
+    virtual void Deinit()
+    {
+    }
+
+    template<typename S>
+    void SerializeCommon(S& serialize)
+    {
+        SerializeVector<SerializeU32_Unbounded>()(serialize, "mirages", m_Mirages);
+        SerializeVector<SerializeBool>()(serialize, "enable mirages", m_Miraged);
+    }
+
+    virtual void Serialize(ISerializer& serialize)
+    {
+        SerializeCommon(serialize);
+    }
+
+    virtual void Deserialize(const CParamNode& UNUSED(paramNode), IDeserializer& deserialize)
+    {
+        SerializeCommon(deserialize);
+    }
+
+    virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
+    {
+        switch (msg.GetType())
+        {
+        case MT_VisibilityChanged:
+        {
+            const CMessageVisibilityChanged& msgData = static_cast<const CMessageVisibilityChanged&> (msg);
+            UpdateMirage(msgData.player);
+            break;
+        }
+        case MT_Destroy:
+            for (std::vector<entity_id_t>::iterator it = m_Mirages.begin(); it < m_Mirages.end(); ++it)
+            {
+                CmpPtr<ICmpMirage> cmpMirage(GetSimContext(), *it);
+                if (cmpMirage)
+                    cmpMirage->SetParent(INVALID_ENTITY);
+            }
+            break;
+        }
+    }
+
+    virtual void UpdateMirage(player_id_t player)
+    {
+        CComponentManager& componentManager = GetSimContext().GetComponentManager();
+        CmpPtr<ICmpRangeManager> cmpRangeManager(GetSystemEntity());
+        CmpPtr<ICmpTemplateManager> cmpTemplateManager(GetSystemEntity());
+        
+        std::string templateName = "mirage|" + cmpTemplateManager->GetCurrentTemplateName(GetEntityId());
+        
+        ICmpRangeManager::ELosVisibility visibility = cmpRangeManager->GetLosVisibility(GetEntityHandle(), player);
+
+        // Nothing to update
+        if (visibility == ICmpRangeManager::VIS_FOGGED)
+            return;
+            
+        // Destroy mirages when we get back into LoS
+        if (visibility == ICmpRangeManager::VIS_VISIBLE)
+        {
+            if (m_Mirages[player] != INVALID_ENTITY)
+            {
+                componentManager.DestroyComponentsSoon(m_Mirages[player]);
+                m_Mirages[player] = INVALID_ENTITY;
+            }
+            return;
+        }
+            
+        // Else, we are hidden and we should consider miraging
+
+        if (!m_Miraged[player] || m_Mirages[player] != INVALID_ENTITY)
+            return;
+                
+        m_Mirages[player] = componentManager.AllocateNewEntity();
+        componentManager.AddEntity(wstring_from_utf8(templateName), m_Mirages[player]);
+
+        CmpPtr<ICmpMirage> cmpMirage(GetSimContext(), m_Mirages[player]);
+        if (!cmpMirage)
+        {
+            LOGERROR(L"Failed to load mirage entity for template %hs", templateName.c_str());
+            m_Mirages[player] = INVALID_ENTITY;
+            return;
+        }
+
+        // Setup basic mirage properties
+        cmpMirage->SetPlayer(player);
+        cmpMirage->SetParent(GetEntityId());
+
+        // Copy cmpOwnership data
+        CmpPtr<ICmpOwnership> cmpParentOwnership(GetEntityHandle());
+        if (!cmpParentOwnership)
+        {
+            LOGERROR(L"Failed to access the ownership data of the fogged entity %hs", templateName.c_str());
+            return;
+        }
+        CmpPtr<ICmpOwnership> cmpMirageOwnership(GetSimContext(), m_Mirages[player]);
+        if (!cmpMirageOwnership)
+        {
+            LOGERROR(L"No valid Ownership in template %hs", templateName.c_str());
+            return;
+        }
+        player_id_t parentOwner = cmpParentOwnership->GetOwner();
+        cmpMirageOwnership->SetOwner(parentOwner);
+
+        // Copy cmpPosition data
+        CmpPtr<ICmpPosition> cmpParentPosition(GetEntityHandle());
+        if (!cmpParentPosition)
+        {
+            LOGERROR(L"Failed to access the position data of the fogged entity %hs", templateName.c_str());
+            return;
+        }
+        CmpPtr<ICmpPosition> cmpMiragePosition(GetSimContext(), m_Mirages[player]);
+        if (!cmpMiragePosition)
+        {
+            LOGERROR(L"No valid Position component in template %hs", templateName.c_str());
+            return;
+        }
+        // The entity may not have been moved in-world yet, if we are e.g. placing a new building
+        if (!cmpParentPosition->IsInWorld())
+            return;
+        CFixedVector3D pos = cmpParentPosition->GetPosition();
+        cmpMiragePosition->JumpTo(pos.X, pos.Z);
+        CFixedVector3D rot = cmpParentPosition->GetRotation();
+        cmpMiragePosition->SetXZRotation(rot.X, rot.Z);
+        cmpMiragePosition->SetYRotation(rot.Y);
+
+        // Copy cmpVisualActor data
+        CmpPtr<ICmpVisual> cmpParentVisualActor(GetEntityHandle());
+        if (!cmpParentVisualActor)
+        {
+            LOGERROR(L"Failed to access the visual actor of the fogged entity %hs", templateName.c_str());
+            return;
+        }
+        CmpPtr<ICmpVisual> cmpMirageVisualActor(GetSimContext(), m_Mirages[player]);
+        if (!cmpMirageVisualActor)
+        {
+            LOGERROR(L"No valid Visual actor in template %hs", templateName.c_str());
+            return;
+        }
+        u32 parentSeed = cmpParentVisualActor->GetActorSeed();
+        cmpMirageVisualActor->SetActorSeed(parentSeed);
+    }
+
+    virtual bool IsMiraged(player_id_t player)
+    {
+        if (player > m_Miraged.size())
+        {
+            LOGERROR(L"Tried to query miraging info for invalid player");
+            return false;
+        }
+        
+        return m_Miraged[player];
+    }
+
+    virtual void SetMiraged(player_id_t player, bool enable)
+    {
+        if (player > m_Miraged.size())
+        {
+            LOGERROR(L"Tried to enable/disable a mirage for invalid player");
+            return;
+        }
+        
+        m_Miraged[player] = enable;
+    }
+
+private:
+    /// Vector of mirages, one for each player
+    std::vector<entity_id_t> m_Mirages;
+
+    /// For each player, remember if the entity must be mirage'd
+    /// (i.e. has already been seen) or not.
+    std::vector<bool> m_Miraged;
+};
+
+REGISTER_COMPONENT_TYPE(Fogging)

source/simulation2/components/CCmpMirage.cpp

@@ +1 @@
+/* Copyright (C) 2014 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "simulation2/system/Component.h"
+#include "simulation2/MessageTypes.h"
+#include "ICmpMirage.h"
+#include "ICmpRangeManager.h"
+
+class CCmpMirage : public ICmpMirage
+{
+public:
+    static void ClassInit(CComponentManager& componentManager)
+    {
+        componentManager.SubscribeToMessageType(MT_VisibilityChanged);
+        componentManager.SubscribeToMessageType(MT_Destroy);
+    }
+
+    DEFAULT_COMPONENT_ALLOCATOR(Mirage)
+
+    static std::string GetSchema()
+    {
+        return "<a:help>Mirage entities replace real entities in the fog-of-war.</a:help>"
+            "<empty/>";
+    }
+
+    virtual void Init(const CParamNode& UNUSED(paramNode))
+    {
+    }
+
+    virtual void Deinit()
+    {
+    }
+
+    template<typename S>
+    void SerializeCommon(S& serialize)
+    {
+        serialize.NumberI32_Unbounded("player", m_Player);
+        serialize.NumberU32_Unbounded("parent", m_Parent);
+    }
+
+    virtual void Serialize(ISerializer& serialize)
+    {
+        SerializeCommon(serialize);
+    }
+
+    virtual void Deserialize(const CParamNode& UNUSED(paramNode), IDeserializer& deserialize)
+    {
+        SerializeCommon(deserialize);
+    }
+
+    virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
+    {
+        switch (msg.GetType())
+        {
+        case MT_VisibilityChanged:
+        {
+            const CMessageVisibilityChanged& msgData = static_cast<const CMessageVisibilityChanged&> (msg);
+            if (msgData.player == m_Player 
+                && msgData.newVisibility == ICmpRangeManager::VIS_VISIBLE 
+                && m_Parent == INVALID_ENTITY)
+                GetSimContext().GetComponentManager().DestroyComponentsSoon(GetEntityId());
+            break;
+        }
+        case MT_Destroy:
+        {
+            if (GetParent() == INVALID_ENTITY)
+                break;
+                
+            CMessageEntityRenamed msg(GetEntityId(), GetParent());
+            GetSimContext().GetComponentManager().BroadcastMessage(msg);
+            break;
+        }
+        }
+    }
+
+    virtual void SetPlayer(player_id_t player)
+    {
+        m_Player = player;
+    }
+
+    virtual player_id_t GetPlayer()
+    {
+        return m_Player;
+    }
+
+    virtual void SetParent(entity_id_t ent)
+    {
+        m_Parent = ent;
+    }
+
+    virtual entity_id_t GetParent()
+    {
+        return m_Parent;
+    }
+
+private:
+    player_id_t m_Player;
+    entity_id_t m_Parent;
+};
+
+REGISTER_COMPONENT_TYPE(Mirage)

source/simulation2/components/CCmpRangeManager.cpp

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2014 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -23 +23 @@
 #include "ICmpTerrain.h"
 #include "simulation2/system/EntityMap.h"
 #include "simulation2/MessageTypes.h"
+#include "simulation2/components/ICmpFogging.h"
+#include "simulation2/components/ICmpMirage.h"
+#include "simulation2/components/ICmpOwnership.h"
 #include "simulation2/components/ICmpPosition.h"
 #include "simulation2/components/ICmpTerritoryManager.h"
 #include "simulation2/components/ICmpVision.h"
@@ -39 +42 @@
 #include "renderer/Scene.h"
 #include "lib/ps_stl.h"
 
-
+#define LOS_TILES_RATIO 8
 #define DEBUG_RANGE_MANAGER_BOUNDS 0
 
 /**
@@ -138 +141 @@
     EntityData() : retainInFog(0), owner(-1), inWorld(0), flags(1) { }
     entity_pos_t x, z;
     entity_pos_t visionRange;
+    u32 visibilities; // 2-bit visibility, per player
     u8 retainInFog; // boolean
     i8 owner;
     u8 inWorld; // boolean
@@ -144 +148 @@
     u8 flags; // See GetEntityFlagMask
 };
 
-cassert(sizeof(EntityData) == 16);
+cassert(sizeof(EntityData) == 20);
 
 /**
  * Serialization helper template for Query
@@ -197 +201 @@
         serialize.NumberFixed_Unbounded("z", value.z);
         serialize.NumberFixed_Unbounded("vision", value.visionRange);
         serialize.NumberU8("retain in fog", value.retainInFog, 0, 1);
+        serialize.NumberU32_Unbounded("visibilities", value.visibilities);
         serialize.NumberI8_Unbounded("owner", value.owner);
         serialize.NumberU8("in world", value.inWorld, 0, 1);
         serialize.NumberU8_Unbounded("flags", value.flags);
@@ -283 +288 @@
     bool m_LosCircular;
     i32 m_TerrainVerticesPerSide;
     size_t m_TerritoriesDirtyID;
+    
+    // Cache for visibility tracking (not serialized)
+    i32 m_LosTilesPerSide;
+    bool* m_DirtyVisibility;
+    std::vector<std::set<entity_id_t>> m_LosTiles;
+    // List of entities that must be updated, regardless of the status of their tile
+    std::vector<entity_id_t> m_ModifiedEntities;
 
     // Counts of units seeing vertex, per vertex, per player (starting with player 0).
     // Use u16 to avoid overflows when we have very large (but not infeasibly large) numbers
@@ -332 +344 @@
         m_LosCircular = false;
         m_TerrainVerticesPerSide = 0;
 
+        m_DirtyVisibility = NULL;
+
         m_TerritoriesDirtyID = 0;
     }
 
     virtual void Deinit()
     {
+        delete[] m_DirtyVisibility;
     }
 
     template<typename S>
@@ -355 +370 @@
         serialize.Bool("los circular", m_LosCircular);
         serialize.NumberI32_Unbounded("terrain verts per side", m_TerrainVerticesPerSide);
 
-        // We don't serialize m_Subdivision or m_LosPlayerCounts
+        SerializeVector<SerializeU32_Unbounded>()(serialize, "modified entities", m_ModifiedEntities);
+
+        // We don't serialize m_Subdivision, m_LosPlayerCounts or m_LosTiles
         // since they can be recomputed from the entity data when deserializing;
         // m_LosState must be serialized since it depends on the history of exploration
 
@@ -432 +449 @@
                     CFixedVector2D to(msgData.x, msgData.z);
                     m_Subdivision.Move(ent, from, to);
                     LosMove(it->second.owner, it->second.visionRange, from, to);
+                    i32 oldLosTile = PosToLosTilesHelper(it->second.x, it->second.z);
+                    i32 newLosTile = PosToLosTilesHelper(msgData.x, msgData.z);
+                    if (oldLosTile != newLosTile)
+                    {
+                        RemoveFromTile(oldLosTile, ent);
+                        AddToTile(newLosTile, ent);
+                    }
                 }
                 else
                 {
@@ -438 +462 @@
                     CFixedVector2D to(msgData.x, msgData.z);
                     m_Subdivision.Add(ent, to);
                     LosAdd(it->second.owner, it->second.visionRange, to);
+                    AddToTile(PosToLosTilesHelper(msgData.x, msgData.z), ent);
                 }
 
                 it->second.inWorld = 1;
@@ -451 +476 @@
                     CFixedVector2D from(it->second.x, it->second.z);
                     m_Subdivision.Remove(ent, from);
                     LosRemove(it->second.owner, it->second.visionRange, from);
+                    RemoveFromTile(PosToLosTilesHelper(it->second.x, it->second.z), ent);
                 }
 
                 it->second.inWorld = 0;
@@ -458 +484 @@
                 it->second.z = entity_pos_t::Zero();
             }
 
+            m_ModifiedEntities.push_back(ent);
+
             break;
         }
         case MT_OwnershipChanged:
@@ -495 +523 @@
                 break;
 
             if (it->second.inWorld)
+            {
                 m_Subdivision.Remove(ent, CFixedVector2D(it->second.x, it->second.z));
+                RemoveFromTile(PosToLosTilesHelper(it->second.x, it->second.z), ent);
+            }
 
             // This will be called after Ownership's OnDestroy, so ownership will be set
             // to -1 already and we don't have to do a LosRemove here
@@ -539 +570 @@
         case MT_Update:
         {
             m_DebugOverlayDirty = true;
+            UpdateVisibilityData();
             UpdateTerritoriesLos();
             ExecuteActiveQueries();
             break;
@@ -559 +591 @@
         m_WorldX1 = x1;
         m_WorldZ1 = z1;
         m_TerrainVerticesPerSide = (i32)vertices;
+        
+        m_LosTilesPerSide = (m_TerrainVerticesPerSide - 1)/LOS_TILES_RATIO;
 
         ResetDerivedData(false);
     }
@@ -639 +673 @@
         }
         m_LosStateRevealed.clear();
         m_LosStateRevealed.resize(m_TerrainVerticesPerSide*m_TerrainVerticesPerSide);
+        
+        delete[] m_DirtyVisibility;
+        m_DirtyVisibility = new bool[m_LosTilesPerSide*m_LosTilesPerSide]();
+        m_LosTiles.clear();
+        m_LosTiles.resize(m_LosTilesPerSide*m_LosTilesPerSide);
 
         for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
         {
             if (it->second.inWorld)
+            {
                 LosAdd(it->second.owner, it->second.visionRange, CFixedVector2D(it->second.x, it->second.z));
+                AddToTile(PosToLosTilesHelper(it->second.x, it->second.z), it->first);
+            }
         }
 
         m_TotalInworldVertices = 0;
@@ -1364 +1406 @@
         CLosQuerier los(GetSharedLosMask(player), m_LosState, m_TerrainVerticesPerSide);
 
         if (los.IsVisible(i, j))
+        {
+            // If we see an entity, we should mirage it as soon as it falls into fog-of-war
+            CmpPtr<ICmpFogging> cmpFogging(ent);
+            if (cmpFogging)
+                cmpFogging->SetMiraged(player, true);
+            
             return VIS_VISIBLE;
+        }
 
         // Fogged if the 'retain in fog' flag is set, and in a non-visible explored region
         if (los.IsExplored(i, j))
@@ -1371 +1420 @@
         {
             CmpPtr<ICmpVision> cmpVision(ent);
             if (forceRetainInFog || (cmpVision && cmpVision->GetRetainInFog()))
-                return VIS_FOGGED;
+            {
+                // Mirage entities are visible for one specific player
+                CmpPtr<ICmpMirage> cmpMirage(ent);
+                if (cmpMirage)
+                {
+                    if (cmpMirage->GetPlayer() == player)
+                        return VIS_FOGGED;
+                    else
+                        return VIS_HIDDEN;
+                }
+
+                // Normal entities should be visible only for their owner
+                CmpPtr<ICmpOwnership> cmpOwnership(ent);
+                if (cmpOwnership)
+                {
+                    if (cmpOwnership->GetOwner() == player)
+                        return VIS_FOGGED;
+                    else
+                        return VIS_HIDDEN;
+                }
+                
+                return VIS_VISIBLE;
+            }
         }
 
         // Otherwise not visible
@@ -1384 +1455 @@
         return GetLosVisibility(handle, player, forceRetainInFog);
     }
 
+    i32 PosToLosTilesHelper(entity_pos_t x, entity_pos_t z)
+    {
+        i32 i = Clamp(
+            (x/(entity_pos_t::FromInt(TERRAIN_TILE_SIZE * LOS_TILES_RATIO))).ToInt_RoundToZero(),
+            0,
+            m_LosTilesPerSide - 1);
+        i32 j = Clamp(
+            (z/(entity_pos_t::FromInt(TERRAIN_TILE_SIZE * LOS_TILES_RATIO))).ToInt_RoundToZero(),
+            0,
+            m_LosTilesPerSide - 1);
+        return j*m_LosTilesPerSide + i;
+    }
 
+    void AddToTile(i32 tile, entity_id_t ent)
+    {
+        m_LosTiles[tile].insert(ent);
+    }
+
+    void RemoveFromTile(i32 tile, entity_id_t ent)
+    {
+        for (std::set<entity_id_t>::iterator tileIt = m_LosTiles[tile].begin();
+            tileIt != m_LosTiles[tile].end();
+            ++tileIt)
+        {
+            if (*tileIt == ent)
+            {
+                m_LosTiles[tile].erase(tileIt);
+                return;
+            }
+        }
+    }
+
+    void UpdateVisibilityData()
+    {
+        PROFILE("UpdateVisibilityData");
+        
+        for (i32 n = 0; n < m_LosTilesPerSide*m_LosTilesPerSide; ++n)
+        {
+            if (m_DirtyVisibility[n])
+            {
+                for (std::set<entity_id_t>::iterator it = m_LosTiles[n].begin();
+                    it != m_LosTiles[n].end();
+                    ++it)
+                {
+                    UpdateVisibility(*it);
+                }
+                m_DirtyVisibility[n] = false;
+            }
+        }
+
+        for (std::vector<entity_id_t>::iterator it = m_ModifiedEntities.begin(); it != m_ModifiedEntities.end(); ++it)
+        {
+            UpdateVisibility(*it);
+        }
+        m_ModifiedEntities.clear();
+    }
+
+    void UpdateVisibility(entity_id_t ent)
+    {
+        EntityMap<EntityData>::iterator itEnts = m_EntityData.find(ent);
+        if (itEnts == m_EntityData.end())
+            return;
+        
+        for (player_id_t player = 1; player <= MAX_LOS_PLAYER_ID; ++player)
+        {
+            u8 oldVis = (itEnts->second.visibilities >> (2*player)) & 0x3;
+            u8 newVis = GetLosVisibility(itEnts->first, player, false);
+
+            if (oldVis != newVis)
+            {
+                CMessageVisibilityChanged msg(player, ent, oldVis, newVis);
+                GetSimContext().GetComponentManager().PostMessage(ent, msg);
+                itEnts->second.visibilities = (itEnts->second.visibilities & ~(0x3 << 2*player)) | (newVis << 2*player);
+            }
+        }
+    }
+
     virtual void SetLosRevealAll(player_id_t player, bool enabled)
     {
         if (player == -1)
@@ -1532 +1679 @@
                     explored += !(m_LosState[idx] & (LOS_EXPLORED << (2*(owner-1))));
                     m_LosState[idx] |= ((LOS_VISIBLE | LOS_EXPLORED) << (2*(owner-1)));
                 }
+                m_DirtyVisibility[(j/LOS_TILES_RATIO)*m_LosTilesPerSide + i/LOS_TILES_RATIO] = true;
             }
 
             ASSERT(counts[idx] < 65535);
@@ -1559 +1707 @@
             {
                 // (If LosIsOffWorld then this is a no-op, so don't bother doing the check)
                 m_LosState[idx] &= ~(LOS_VISIBLE << (2*(owner-1)));
+
+                i32 i = i0 + idx - idx0;
+                m_DirtyVisibility[(j/LOS_TILES_RATIO)*m_LosTilesPerSide + i/LOS_TILES_RATIO] = true;
             }
         }
     }

source/simulation2/components/CCmpUnitRenderer.cpp

@@ -391 +391 @@
         CmpPtr<ICmpVision> cmpVision(unit.entity);
         if (cmpVision && cmpVision->GetAlwaysVisible())
             unit.visibility = ICmpRangeManager::VIS_VISIBLE;
+
+        // Uncomment the following two lines to prevent the models from popping into existence
+        // near the LOS boundary. Is rather resource intensive.
+        //else if (cmpVision && cmpVision->GetRetainInFog())
+        //  unit.visibility = ICmpRangeManager::VIS_VISIBLE;
+
         else
         {
             CmpPtr<ICmpRangeManager> cmpRangeManager(GetSystemEntity());
-            // Uncomment the following lines to prevent the models from popping into existence
-            // near the LOS boundary. Is rather resource intensive.
-            //if (cmpVision->GetRetainInFog())
-            //  unit.visibility = ICmpRangeManager::VIS_VISIBLE;
-            //else
-                unit.visibility = cmpRangeManager->GetLosVisibility(unit.entity,
-                    GetSimContext().GetCurrentDisplayedPlayer());
+            unit.visibility = cmpRangeManager->GetLosVisibility(unit.entity, 
+                GetSimContext().GetCurrentDisplayedPlayer());
         }
     }
     else

source/simulation2/components/CCmpVisualActor.cpp

@@ -532 +532 @@
     void ReloadActor();
 
     void Update(fixed turnLength);
-    void UpdateVisibility();
 };
 
 REGISTER_COMPONENT_TYPE(VisualActor)

source/simulation2/components/ICmpFogging.cpp

@@ +1 @@
+/* Copyright (C) 2014 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "ICmpFogging.h"
+
+#include "simulation2/system/InterfaceScripted.h"
+
+BEGIN_INTERFACE_WRAPPER(Fogging)
+DEFINE_INTERFACE_METHOD_1("UpdateMirage", void, ICmpFogging, UpdateMirage, player_id_t)
+DEFINE_INTERFACE_METHOD_1("IsMiraged", bool, ICmpFogging, IsMiraged, player_id_t)
+DEFINE_INTERFACE_METHOD_2("SetMiraged", void, ICmpFogging, SetMiraged, player_id_t, bool)
+END_INTERFACE_WRAPPER(Fogging)

source/simulation2/components/ICmpFogging.h

@@ +1 @@
+/* Copyright (C) 2014 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_ICMPFOGGING
+#define INCLUDED_ICMPFOGGING
+
+#include "simulation2/system/Interface.h"
+
+#include "simulation2/helpers/Player.h"
+
+
+/**
+ * Handles the fogging of out-of-sight enemy entities, by creating mirage
+ * entities.
+ * This allows hiding changes, especially destruction status or health.
+ */
+class ICmpFogging : public IComponent
+{
+public:
+    virtual void UpdateMirage(player_id_t player) = 0;
+    virtual bool IsMiraged(player_id_t player) = 0;
+    virtual void SetMiraged(player_id_t player, bool enable) = 0;
+    DECLARE_INTERFACE_TYPE(Fogging)
+};
+
+#endif // INCLUDED_ICMPFOGGING

source/simulation2/components/ICmpMirage.cpp

@@ +1 @@
+/* Copyright (C) 2014 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "ICmpMirage.h"
+
+#include "simulation2/system/InterfaceScripted.h"
+
+BEGIN_INTERFACE_WRAPPER(Mirage)
+DEFINE_INTERFACE_METHOD_1("SetPlayer", void, ICmpMirage, SetPlayer, player_id_t)
+DEFINE_INTERFACE_METHOD_0("GetPlayer", player_id_t, ICmpMirage, GetPlayer)
+DEFINE_INTERFACE_METHOD_1("SetParent", void, ICmpMirage, SetParent, entity_id_t)
+DEFINE_INTERFACE_METHOD_0("GetParent", entity_id_t, ICmpMirage, GetParent)
+END_INTERFACE_WRAPPER(Mirage)

source/simulation2/components/ICmpMirage.h

@@ +1 @@
+/* Copyright (C) 2014 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_ICMPMIRAGE
+#define INCLUDED_ICMPMIRAGE
+
+#include "simulation2/system/Interface.h"
+
+#include "simulation2/helpers/Player.h"
+
+/**
+ * Component allowing mirage entities to communicate with their parent entity.
+ * See ICmpFogging.
+ */
+class ICmpMirage : public IComponent
+{
+public:
+    virtual void SetPlayer(player_id_t player) = 0;
+    virtual player_id_t GetPlayer() = 0;
+    virtual void SetParent(entity_id_t ent) = 0;
+    virtual entity_id_t GetParent() = 0;
+    DECLARE_INTERFACE_TYPE(Mirage)
+};
+
+#endif // INCLUDED_ICMPMIRAGE

source/simulation2/components/ICmpRangeManager.cpp

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2014 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify

source/simulation2/components/ICmpRangeManager.h

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2014 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -216 +216 @@
 
     enum ELosVisibility
     {
-        VIS_HIDDEN,
-        VIS_FOGGED,
-        VIS_VISIBLE
+        VIS_HIDDEN = 0,
+        VIS_FOGGED = 1,
+        VIS_VISIBLE = 2
     };
 
     /**

source/simulation2/MessageTypes.h

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2014 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -241 +241 @@
     entity_id_t entity;
 };
 
+/**
+ * This is sent when one entity is changed to other: from Foundation component when building 
+ * constuction is done, from Promotion component, from Fogging component etc.
+ */
+class CMessageEntityRenamed : public CMessage
+{
+public:
+    DEFAULT_MESSAGE_IMPL(EntityRenamed)
+
+    CMessageEntityRenamed(entity_id_t entity, entity_id_t newentity) :
+        entity(entity), newentity(newentity)
+    {
+    }
+
+    entity_id_t entity;
+    entity_id_t newentity;
+};
+
 class CMessageOwnershipChanged : public CMessage
 {
 public:
@@ -362 +380 @@
 };
 
 /**
+ * Sent, at most once per turn, when the visibility of an entity changed
+ */
+class CMessageVisibilityChanged : public CMessage
+{
+public:
+    DEFAULT_MESSAGE_IMPL(VisibilityChanged)
+
+    CMessageVisibilityChanged(player_id_t player, entity_id_t ent, int oldVisibility, int newVisibility) :
+        player(player), ent(ent), oldVisibility(oldVisibility), newVisibility(newVisibility)
+    {
+    }
+
+    player_id_t player;
+    entity_id_t ent;
+    int oldVisibility;
+    int newVisibility;
+};
+
+/**
  * Sent when ObstructionManager's view of the shape of the world has changed
  * (changing the TILE_OUTOFBOUNDS tiles returned by Rasterise).
  */

source/simulation2/scripting/MessageTypeConversions.cpp

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2014 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -194 +194 @@
 
 ////////////////////////////////
 
+jsval CMessageEntityRenamed::ToJSVal(ScriptInterface& scriptInterface) const
+{
+    TOJSVAL_SETUP();
+    SET_MSG_PROPERTY(entity);
+    SET_MSG_PROPERTY(newentity);
+    return OBJECT_TO_JSVAL(obj);
+}
+
+CMessage* CMessageEntityRenamed::FromJSVal(ScriptInterface& scriptInterface, jsval val)
+{
+    FROMJSVAL_SETUP();
+    GET_MSG_PROPERTY(entity_id_t, entity);
+    GET_MSG_PROPERTY(entity_id_t, newentity);
+    return new CMessageEntityRenamed(entity, newentity);
+}
+
+////////////////////////////////
+
 jsval CMessageOwnershipChanged::ToJSVal(ScriptInterface& scriptInterface) const
 {
     TOJSVAL_SETUP();
@@ -310 +328 @@
 
 ////////////////////////////////
 
+jsval CMessageVisibilityChanged::ToJSVal(ScriptInterface& scriptInterface) const
+{
+    TOJSVAL_SETUP();
+    SET_MSG_PROPERTY(player);
+    SET_MSG_PROPERTY(ent);
+    SET_MSG_PROPERTY(oldVisibility);
+    SET_MSG_PROPERTY(newVisibility);
+    return OBJECT_TO_JSVAL(obj);
+}
+
+CMessage* CMessageVisibilityChanged::FromJSVal(ScriptInterface& scriptInterface, jsval val)
+{
+    FROMJSVAL_SETUP();
+    GET_MSG_PROPERTY(player_id_t, player);
+    GET_MSG_PROPERTY(entity_id_t, ent);
+    GET_MSG_PROPERTY(int, oldVisibility);
+    GET_MSG_PROPERTY(int, newVisibility);
+    return new CMessageVisibilityChanged(player, ent, oldVisibility, newVisibility);
+}
+
+////////////////////////////////
+
 jsval CMessageWaterChanged::ToJSVal(ScriptInterface& scriptInterface) const
 {
     TOJSVAL_SETUP();

source/simulation2/TypeList.h

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2014 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -41 +41 @@
 MESSAGE(Deserialized) // non-deterministic (use with caution)
 MESSAGE(Create)
 MESSAGE(Destroy)
+MESSAGE(EntityRenamed)
 MESSAGE(OwnershipChanged)
 MESSAGE(PositionChanged)
 MESSAGE(InterpolatedPositionChanged)
@@ -48 +49 @@
 MESSAGE(MotionChanged)
 MESSAGE(RangeUpdate)
 MESSAGE(TerrainChanged)
+MESSAGE(VisibilityChanged)
 MESSAGE(WaterChanged)
 MESSAGE(ObstructionMapShapeChanged)
 MESSAGE(TerritoriesChanged)
@@ -80 +82 @@
 INTERFACE(Decay)
 COMPONENT(Decay)
 
+INTERFACE(Fogging)
+COMPONENT(Fogging)
+
 // Note: The VisualActor component relies on this component being initialized before itself, in order to support using
 // an entity's footprint shape for the selection boxes. This dependency is not strictly necessary, but it does avoid
 // some extra plumbing code to set up on-demand initialization. If you find yourself forced to break this dependency, 
@@ -96 +101 @@
 INTERFACE(Minimap)
 COMPONENT(Minimap)
 
+INTERFACE(Mirage)
+COMPONENT(Mirage)
+
 INTERFACE(Motion)
 COMPONENT(MotionBall)
 COMPONENT(MotionScripted)