Ticket #599: fogging.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)
     {
@@ -319 +334 @@
     }
 }
 
+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
@@ -333 +384 @@
     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

@@ -76 +76 @@
     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 "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_Update);
+        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()
+    {
+    }
+
+    virtual void Serialize(ISerializer& serialize)
+    {
+        serialize.NumberU32_Unbounded("num players", m_Mirages.size());
+
+        for (size_t i = 0; i < m_Mirages.size(); ++i)
+        {
+            serialize.NumberU32_Unbounded("mirage entity id", m_Mirages[i]);
+            serialize.Bool("miraging enabled", m_Miraged[i]);
+        }
+    }
+
+    virtual void Deserialize(const CParamNode& UNUSED(paramNode), IDeserializer& deserialize)
+    {
+        uint32_t numPlayers;
+        deserialize.NumberU32_Unbounded("num players", numPlayers);
+
+        entity_id_t ent;
+        bool enabled;
+        for (size_t i = 0; i < numPlayers; ++i)
+        {
+            deserialize.NumberU32_Unbounded("mirage entity id", ent);
+            m_Mirages.push_back(ent);
+            
+            deserialize.Bool("miraging enabled", enabled);
+            m_Miraged.push_back(enabled);
+        }
+    }
+
+    virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
+    {
+        switch (msg.GetType())
+        {
+        case MT_Update:
+            UpdateMirages();
+            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 UpdateMirages()
+    {
+        CComponentManager& componentManager = GetSimContext().GetComponentManager();
+        CmpPtr<ICmpRangeManager> cmpRangeManager(GetSystemEntity());
+        CmpPtr<ICmpTemplateManager> cmpTemplateManager(GetSystemEntity());
+        
+        std::string templateName = "mirage|" + cmpTemplateManager->GetCurrentTemplateName(GetEntityId());
+        
+        for (size_t player = 0; player < m_Mirages.size(); ++player)
+        {
+            ICmpRangeManager::ELosVisibility visibility = cmpRangeManager->GetLosVisibility(GetEntityHandle(), player);
+
+            // Nothing to update
+            if (visibility == ICmpRangeManager::VIS_FOGGED)
+                continue;
+            
+            // 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;
+                }
+                continue;
+            }
+            
+            // Else, we are hidden and we should consider miraging
+            if (!m_Miraged[player] || m_Mirages[player] != INVALID_ENTITY)
+                continue;
+                
+            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;
+                continue;
+            }
+
+            // 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());
+                continue;
+            }
+            CmpPtr<ICmpOwnership> cmpMirageOwnership(GetSimContext(), m_Mirages[player]);
+            if (!cmpMirageOwnership)
+            {
+                LOGERROR(L"No valid Ownership in template %hs", templateName.c_str());
+                continue;
+            }
+            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());
+                continue;
+            }
+            CmpPtr<ICmpPosition> cmpMiragePosition(GetSimContext(), m_Mirages[player]);
+            if (!cmpMiragePosition)
+            {
+                LOGERROR(L"No valid Position component in template %hs", templateName.c_str());
+                continue;
+            }
+            // The entity may not have been moved in-world yet, if we are e.g. placing a new building
+            if (!cmpParentPosition->IsInWorld())
+                continue;
+            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());
+                continue;
+            }
+            CmpPtr<ICmpVisual> cmpMirageVisualActor(GetSimContext(), m_Mirages[player]);
+            if (!cmpMirageVisualActor)
+            {
+                LOGERROR(L"No valid Visual actor in template %hs", templateName.c_str());
+                continue;
+            }
+            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_Update);
+        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_Update:
+        {
+            CmpPtr<ICmpRangeManager> cmpRangeManager(GetSystemEntity());
+            ICmpRangeManager::ELosVisibility visibility = cmpRangeManager->GetLosVisibility(GetEntityHandle(), m_Player);
+            if (visibility == 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"
@@ -1364 +1367 @@
         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 +1381 @@
         {
             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

source/simulation2/components/CCmpUnitRenderer.cpp

@@ -374 +374 @@
         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_0("UpdateMirages", void, ICmpFogging, UpdateMirages)
+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 UpdateMirages() = 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/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:

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();

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)
@@ -80 +81 @@
 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 +100 @@
 INTERFACE(Minimap)
 COMPONENT(Minimap)
 
+INTERFACE(Mirage)
+COMPONENT(Mirage)
+
 INTERFACE(Motion)
 COMPONENT(MotionBall)
 COMPONENT(MotionScripted)