Ticket #599: fogging_scripted.patch

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

@@ -172 +172 @@
         Engine.GetGUIObjectByName("resourceCarryingText").caption = entState.foundation.numBuilders + "    ";
         Engine.GetGUIObjectByName("resourceCarryingIcon").tooltip = sprintf(translate("Number of builders.\nTasking another to this foundation would speed construction up by %(numb)s%%"), { numb : Math.round((Math.pow((entState.foundation.numBuilders+1)/entState.foundation.numBuilders, 0.7) - 1.0)*100) });
     }
-    else if (entState.resourceSupply && (!entState.resourceSupply.killBeforeGather || !entState.hitpoints))
+    else if (entState.resourceSupply && (!entState.resourceSupply.killBeforeGather || !entState.hitpoints) && !entState.mirage)
     {
         Engine.GetGUIObjectByName("resourceCarryingIcon").hidden = false;
         Engine.GetGUIObjectByName("resourceCarryingText").hidden = false;

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/Fogging.js

@@ +1 @@
+const VIS_HIDDEN = 0;
+const VIS_FOGGED = 1;
+const VIS_VISIBLE = 2;
+
+function Fogging() {}
+
+Fogging.prototype.Schema =
+    "<a:help>Allows this entity to be replaced by mirages entities in the fog-of-war.</a:help>" +
+    "<empty/>";
+
+Fogging.prototype.Init = function()
+{
+    this.mirages = [];
+    this.seen = [];
+
+    var cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+    for (var i = 0; i < cmpPlayerManager.GetNumPlayers(); ++i)
+    {
+        this.mirages.push(INVALID_ENTITY);
+        this.seen.push(false);
+    }
+};
+
+Fogging.prototype.LoadMirage = function(player)
+{
+    var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+    var templateName = "mirage|" + cmpTemplateManager.GetCurrentTemplateName(this.entity);
+    
+    // If this is an entity without visibility (e.g. a foundation), it should be
+    // marked as seen for its owner 
+    var cmpParentOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (cmpParentOwnership && cmpParentOwnership.GetOwner() == player)
+        this.seen[player] = true;
+
+    if (!this.seen[player] || this.mirages[player] != INVALID_ENTITY)
+        return;
+
+    this.mirages[player] = Engine.AddEntity(templateName);
+    var cmpMirage = Engine.QueryInterface(this.mirages[player], IID_Mirage);
+    if (!cmpMirage)
+    {
+        error("Failed to load mirage entity for template " + templateName);
+        this.mirages[player] = INVALID_ENTITY;
+        return;
+    }
+    // Setup basic mirage properties
+    cmpMirage.SetPlayer(player);
+    cmpMirage.SetParent(this.entity);
+
+    // Copy cmpOwnership data
+    var cmpMirageOwnership = Engine.QueryInterface(this.mirages[player], IID_Ownership);
+    if (!cmpParentOwnership || !cmpMirageOwnership)
+    {
+        error("Failed to setup the ownership data of the fogged entity " + templateName);
+        return;
+    }
+    cmpMirageOwnership.SetOwner(cmpParentOwnership.GetOwner());
+
+    // Copy cmpPosition data
+    var cmpParentPosition = Engine.QueryInterface(this.entity, IID_Position);
+    var cmpMiragePosition = Engine.QueryInterface(this.mirages[player], IID_Position);
+    if (!cmpParentPosition || !cmpMiragePosition)
+    {
+        error("Failed to setup the position data of the fogged entity " + templateName);
+        return;
+    }
+    if (!cmpParentPosition.IsInWorld())
+        return;
+    var pos = cmpParentPosition.GetPosition();
+    cmpMiragePosition.JumpTo(pos.x, pos.z);
+    var rot = cmpParentPosition.GetRotation();
+    cmpMiragePosition.SetYRotation(rot.y);
+    cmpMiragePosition.SetXZRotation(rot.x, rot.z);
+
+    // Copy cmpVisualActor data
+    var cmpParentVisualActor = Engine.QueryInterface(this.entity, IID_Visual);
+    var cmpMirageVisualActor = Engine.QueryInterface(this.mirages[player], IID_Visual);
+    if (!cmpParentVisualActor || !cmpMirageVisualActor)
+    {
+        error("Failed to setup the visual data of the fogged entity " + templateName);
+        return;
+    }
+    cmpMirageVisualActor.SetActorSeed(cmpParentVisualActor.GetActorSeed());
+
+    // Store valuable information into the mirage component (especially for the GUI)
+    var cmpHealth = Engine.QueryInterface(this.entity, IID_Health);
+    if (cmpHealth)
+        cmpMirage.AddHealth(cmpHealth.GetMaxHitpoints(), cmpHealth.GetHitpoints());
+
+    var cmpResourceSupply = Engine.QueryInterface(this.entity, IID_ResourceSupply);
+    if (cmpResourceSupply)
+        cmpMirage.AddResourceSupply(cmpResourceSupply.GetMaxAmount(), cmpResourceSupply.GetCurrentAmount(), cmpResourceSupply.GetType());
+};
+
+Fogging.prototype.IsMiraged = function(player)
+{
+    if (player >= this.mirages.length)
+        return false;
+
+    return this.mirages[player] != INVALID_ENTITY;
+};
+
+Fogging.prototype.WasSeen = function(player)
+{
+    if (player >= this.seen.length)
+        return false;
+
+    return this.seen[player];
+};
+
+Fogging.prototype.OnVisibilityChanged = function(msg)
+{
+    if (msg.player >= this.mirages.length)
+        return;
+
+    if (msg.newVisibility == VIS_VISIBLE)
+    {
+        this.seen[msg.player] = true;
+
+        // Destroy mirages when we get back into LoS
+        if (this.mirages[msg.player] != INVALID_ENTITY)
+        {
+            Engine.DestroyEntity(this.mirages[msg.player]);
+            this.mirages[msg.player] = INVALID_ENTITY;
+        }
+    }
+
+    // Intermediate LoS state, meaning we must create a mirage
+    if (msg.newVisibility == VIS_FOGGED)
+        this.LoadMirage(msg.player);
+};
+
+Fogging.prototype.OnDestroy = function(msg)
+{
+    for each (var mirage in this.mirages)
+    {
+        var cmpMirage = Engine.QueryInterface(mirage, IID_Mirage);
+        if (cmpMirage)
+            cmpMirage.SetParent(INVALID_ENTITY);
+    }
+};
+
+Engine.RegisterComponentType(IID_Fogging, "Fogging", Fogging);

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

@@ -179 +179 @@
         "garrisonHolder": null,
         "gate": null,
         "guard": null,
+        "mirage": null,
         "pack": null,
         "player": -1,
         "position": null,
@@ -190 +191 @@
         "visibility": null,
     };
 
+    var cmpMirage = Engine.QueryInterface(ent, IID_Mirage);
+
     var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
     if (cmpIdentity)
     {
@@ -216 +219 @@
         ret.needsRepair = cmpHealth.IsRepairable() && (cmpHealth.GetHitpoints() < cmpHealth.GetMaxHitpoints());
         ret.needsHeal = !cmpHealth.IsUnhealable();
     }
+    if (cmpMirage && cmpMirage.Health())
+    {
+        ret.hitpoints = cmpMirage.GetHitpoints();
+        ret.maxHitpoints = cmpMirage.GetMaxHitpoints();
+    }
 
     var cmpBuilder = Engine.QueryInterface(ent, IID_Builder);
     if (cmpBuilder)
@@ -351 +359 @@
         "resourceSupply": null,
     };
 
+    var cmpMirage = Engine.QueryInterface(ent, IID_Mirage);
+    if (cmpMirage)
+        ret.mirage = true;
+
     var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 
     var cmpAttack = Engine.QueryInterface(ent, IID_Attack);
@@ -445 +457 @@
             "gatherers": cmpResourceSupply.GetGatherers()
         };
     }
+    if (cmpMirage && cmpMirage.ResourceSupply())
+    {
+        ret.resourceSupply = {
+            "max": cmpMirage.GetMaxAmount(),
+            "amount": cmpMirage.GetAmount(),
+            "type": cmpMirage.GetType()
+        };
+    }
 
     var cmpResourceGatherer = Engine.QueryInterface(ent, IID_ResourceGatherer);
     if (cmpResourceGatherer)

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

@@ -1 +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
+ * - from Foundation component when building construction is done
+ * - from Promotion component when unit is promoted
+ * - from Mirage component when a fogged entity is re-discovered
  * Data: { entity: <integer>, newentity: <integer> }
  */
 Engine.RegisterMessageType("EntityRenamed");

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

@@ +1 @@
+const VIS_HIDDEN = 0;
+const VIS_FOGGED = 1;
+const VIS_VISIBLE = 2;
+
+function Mirage() {}
+
+Mirage.prototype.Schema =
+    "<a:help>Mirage entities replace real entities in the fog-of-war.</a:help>" +
+    "<empty/>";
+
+Mirage.prototype.Init = function()
+{
+    this.player = undefined;
+    this.parent = INVALID_ENTITY;
+
+    this.health = false;
+    this.maxHitpoints = undefined;
+    this.hitpoints = undefined;
+
+    this.resourceSupply = false;
+    this.maxAmount = undefined;
+    this.amount = undefined;
+    this.type = undefined;
+};
+
+Mirage.prototype.SetParent = function(ent)
+{
+    this.parent = ent;
+};
+
+Mirage.prototype.GetPlayer = function()
+{
+    return this.player;
+};
+
+Mirage.prototype.SetPlayer = function(player)
+{
+    this.player = player;
+};
+
+//// Parent entity data
+
+////
+// Health data
+////
+Mirage.prototype.AddHealth = function(maxHitpoints, hitpoints)
+{
+    this.health = true;
+    this.maxHitpoints = maxHitpoints;
+    this.hitpoints = Math.ceil(hitpoints);
+};
+
+Mirage.prototype.Health = function()
+{
+    return this.health;
+};
+
+Mirage.prototype.GetMaxHitpoints = function()
+{
+    return this.maxHitpoints;
+};
+
+Mirage.prototype.GetHitpoints = function()
+{
+    return this.hitpoints;
+};
+
+////
+// ResourceSupply data
+////
+Mirage.prototype.AddResourceSupply = function(maxAmount, amount, type)
+{
+    this.resourceSupply = true;
+    this.maxAmount = maxAmount;
+    this.amount = amount;
+    this.type = type;
+};
+
+Mirage.prototype.ResourceSupply = function()
+{
+    return this.resourceSupply;
+};
+
+Mirage.prototype.GetMaxAmount = function()
+{
+    return this.maxAmount;
+};
+
+Mirage.prototype.GetAmount = function()
+{
+    return this.amount;
+};
+
+Mirage.prototype.GetType = function()
+{
+    return this.type;
+};
+
+////
+
+Mirage.prototype.OnVisibilityChanged = function(msg)
+{
+    if (msg.player == this.player && msg.newVisibility == VIS_VISIBLE && this.parent == INVALID_ENTITY)
+        Engine.DestroyEntity(this.entity);
+};
+
+Mirage.prototype.OnDestroy = function(msg)
+{
+    if (this.parent == INVALID_ENTITY)
+        return;
+
+    Engine.BroadcastMessage(MT_EntityRenamed, { entity: this.entity, newentity: this.parent });
+};
+
+Engine.RegisterComponentType(IID_Mirage, "Mirage", Mirage);

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

@@ -243 +243 @@
 {
     var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
 
+    var type;
     var cmpResourceSupply = Engine.QueryInterface(target, IID_ResourceSupply);
-    if (!cmpResourceSupply)
+    var cmpMirage = Engine.QueryInterface(target, IID_Mirage);
+    if (cmpResourceSupply)
+        type = cmpResourceSupply.GetType();
+    else if (cmpMirage && cmpMirage.ResourceSupply())
+        type = cmpMirage.GetType();
+    else
         return 0;
 
-    var type = cmpResourceSupply.GetType();
-
     var rates = this.GetGatherRates();
 
     var rate;
@@ -261 +265 @@
         rate = rates[type.generic] / cmpPlayer.GetCheatTimeMultiplier();
     }
 
+    if (cmpMirage)
+        return rate || 0;
+
     // Apply diminishing returns with more gatherers, for e.g. infinite farms. For most resources this has no effect. (GetDiminishingReturns will return null.)
+    // We can assume that for resources that are miraged this is the case. (else just add the diminishing returns data to the mirage data and remove the
+    // early return above)
     // Note to people looking to change <DiminishingReturns> in a template: This is a bit complicated. Basically, the lower that number is
     // the steeper diminishing returns will be. I suggest playing around with Wolfram Alpha or a graphing calculator a bit.
     // In each of the following links, replace 0.65 with the gather rate of your worker for the resource with diminishing returns and

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

@@ -1987 +1987 @@
                     // check that we can gather from the resource we're supposed to gather from.
                     var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
                     var cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
-                    if (!cmpSupply || !cmpSupply.AddGatherer(cmpOwnership.GetOwner(), this.entity))
+                    var cmpMirage = Engine.QueryInterface(this.gatheringTarget, IID_Mirage);
+                    if ((!cmpMirage || !cmpMirage.ResourceSupply()) &&
+                        (!cmpSupply || !cmpSupply.AddGatherer(cmpOwnership.GetOwner(), this.entity)))
                     {
                         // Save the current order's data in case we need it later
                         var oldType = this.order.data.type;
@@ -3896 +3898 @@
     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 +4392 @@
     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;
 
@@ -5007 +5018 @@
     // Save the resource type now, so if the resource gets destroyed
     // before we process the order then we still know what resource
     // type to look for more of
+    var type;
     var cmpResourceSupply = Engine.QueryInterface(target, IID_ResourceSupply);
-    var type = cmpResourceSupply.GetType();
+    var cmpMirage = Engine.QueryInterface(target, IID_Mirage);
+    if (cmpResourceSupply)
+        type = cmpResourceSupply.GetType();
+    else if (cmpMirage && cmpMirage.ResourceSupply())
+        type = cmpMirage.GetType();
+    else
+        error("CanGather allowed gathering from invalid entity");
 
     // Also save the target entity's template, so that if it's an animal,
     // we won't go from hunting slow safe animals to dangerous fast ones
@@ -5552 +5570 @@
 {
     if (this.IsTurret())
         return false;
-    // The target must be a valid resource supply.
+    // The target must be a valid resource supply, or the mirage of one.
     var cmpResourceSupply = Engine.QueryInterface(target, IID_ResourceSupply);
-    if (!cmpResourceSupply)
+    var cmpMirage = Engine.QueryInterface(target, IID_Mirage);
+    if (!cmpResourceSupply && !(cmpMirage && cmpMirage.ResourceSupply()) )
         return false;
 
     // Formation controllers should always respond to commands

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

@@ -980 +980 @@
             "queued": cmd.queued
         });
     }
+    
+    // Load a mirage for the owner of this new entity
+    var cmpFogging = Engine.QueryInterface(ent, IID_Fogging)
+    if (cmpFogging)
+        cmpFogging.LoadMirage(player);
 
     return ent;
 }

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("Minimap");
+    permittedComponentTypes.insert("Ownership");
+    permittedComponentTypes.insert("Position");
+    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 +443 @@
     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/CCmpRangeManager.cpp

@@ -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"
@@ -1410 +1413 @@
         {
             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;
+                }
+
+                // Real entities visibility depends on ownership
+                CmpPtr<ICmpOwnership> cmpOwnership(ent);
+                if (cmpOwnership)
+                {
+                    if (cmpOwnership->GetOwner() == player)
+                    {
+                        CmpPtr<ICmpFogging> cmpFogging(ent);
+                        if (!cmpFogging)
+                            return VIS_VISIBLE;
+                        
+                        // Fogged entities must not disappear while the mirage is not ready
+                        if (!cmpFogging->IsMiraged(player))
+                            return VIS_FOGGED;
+
+                        return VIS_HIDDEN;
+                    }
+                    else
+                    {
+                        // Fogged entities must not disappear while the mirage is not ready
+                        CmpPtr<ICmpFogging> cmpFogging(ent);
+                        if (cmpFogging && cmpFogging->WasSeen(player) && !cmpFogging->IsMiraged(player))
+                            return VIS_FOGGED;
+                        
+                        return VIS_HIDDEN;
+                    }
+                }
+                
+                return VIS_VISIBLE;
+            }
         }
 
         // Otherwise not visible

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"
+#include "simulation2/scripting/ScriptComponent.h"
+
+BEGIN_INTERFACE_WRAPPER(Fogging)
+END_INTERFACE_WRAPPER(Fogging)
+
+class CCmpFoggingScripted : public ICmpFogging
+{
+public:
+    DEFAULT_SCRIPT_WRAPPER(FoggingScripted)
+
+    virtual bool WasSeen(player_id_t player)
+    {
+        return m_Script.Call<bool> ("WasSeen", player);
+    }
+
+    virtual bool IsMiraged(player_id_t player)
+    {
+        return m_Script.Call<bool> ("IsMiraged", player);
+    }
+};
+
+REGISTER_COMPONENT_SCRIPT_WRAPPER(FoggingScripted)

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 bool WasSeen(player_id_t player) = 0;
+    virtual bool IsMiraged(player_id_t player) = 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"
+#include "simulation2/scripting/ScriptComponent.h"
+
+BEGIN_INTERFACE_WRAPPER(Mirage)
+END_INTERFACE_WRAPPER(Mirage)
+
+class CCmpMirageScripted : public ICmpMirage
+{
+public:
+    DEFAULT_SCRIPT_WRAPPER(MirageScripted)
+
+    virtual player_id_t GetPlayer()
+    {
+        return m_Script.Call<player_id_t> ("GetPlayer");
+    }
+};
+
+REGISTER_COMPONENT_SCRIPT_WRAPPER(MirageScripted)

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 player_id_t GetPlayer() = 0;
+
+    DECLARE_INTERFACE_TYPE(Mirage)
+};
+
+#endif // INCLUDED_ICMPMIRAGE

source/simulation2/TypeList.h

@@ -81 +81 @@
 INTERFACE(Decay)
 COMPONENT(Decay)
 
+INTERFACE(Fogging)
+COMPONENT(FoggingScripted)
+
 // 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, 
@@ -97 +100 @@
 INTERFACE(Minimap)
 COMPONENT(Minimap)
 
+INTERFACE(Mirage)
+COMPONENT(MirageScripted)
+
 INTERFACE(Motion)
 COMPONENT(MotionBall)
 COMPONENT(MotionScripted)