Ticket #599: fogging.diff

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

@@ -235 +235 @@
  */
 EntitySelection.prototype.update = function()
 {
-    var changed = false;
     this.checkRenamedEntities();
+
+    var miraged = {};
+    var changed = false;
     for each (var ent in this.selected)
     {
         var entState = GetEntityState(ent);
@@ -250 +252 @@
             continue;
         }
 
+        // Manually replace newly miraged entities by their mirages
+        if (entState.fogging && entState.fogging.mirage)
+        {
+            miraged[ent] = entState.fogging.mirage;
+            continue;
+        }
+
         // Remove non-visible units (e.g. moved back into fog-of-war)
         if (entState.visibility == "hidden")
         {
@@ -264 +273 @@
             continue;
         }
     }
+
+    this.rebuildSelection(miraged);
+
     if (changed)
         this.onChange();
 };

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

@@ -164 +164 @@
         Engine.GetGUIObjectByName("resourceCarryingIcon").tooltip = sprintf(translate("Gain: %(amount)s"), { amount: getTradingTooltip(entState.trader.goods.amount) });
     }
     // And for number of workers
-    else if (entState.foundation)
+    else if (entState.foundation && !entState.mirage)
     {
         Engine.GetGUIObjectByName("resourceCarryingIcon").hidden = false;
         Engine.GetGUIObjectByName("resourceCarryingText").hidden = false;
@@ -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/gui/session/unit_actions.js

@@ -656 +656 @@
     "delete": {
         "getInfo": function(entState)
         {
+            if (entState.mirage)
+                return {
+                    "tooltip": translate("You cannot destroy this entity because it is in the fog-of-war"),
+                    "icon": "kill_small.png"
+                };
+
             return {
                 "tooltip": translate("Delete"),
                 "icon": "kill_small.png"
@@ -663 +669 @@
         },
         "execute": function(entState)
         {
+            if (entState.mirage)
+                return;
+
             var selection = g_Selection.toList();
             if (selection.length < 1)
                 return;

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;
 

new file inaries/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 player = 0; player < cmpPlayerManager.GetNumPlayers(); ++player)
+    {
+        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 cmpFoundation = Engine.QueryInterface(this.entity, IID_Foundation);
+    if (cmpFoundation)
+        cmpMirage.AddFoundation(cmpFoundation.GetBuildPercentage());
+
+    var cmpHealth = Engine.QueryInterface(this.entity, IID_Health);
+    if (cmpHealth)
+        cmpMirage.AddHealth(
+            cmpHealth.GetMaxHitpoints(), 
+            cmpHealth.GetHitpoints(), 
+            cmpHealth.IsRepairable() && (cmpHealth.GetHitpoints() < cmpHealth.GetMaxHitpoints())
+        );
+
+    var cmpResourceSupply = Engine.QueryInterface(this.entity, IID_ResourceSupply);
+    if (cmpResourceSupply)
+        cmpMirage.AddResourceSupply(
+            cmpResourceSupply.GetMaxAmount(), 
+            cmpResourceSupply.GetCurrentAmount(), 
+            cmpResourceSupply.GetType(), 
+            cmpResourceSupply.IsInfinite()
+        );
+};
+
+Fogging.prototype.IsMiraged = function(player)
+{
+    if (player >= this.mirages.length)
+        return false;
+
+    return this.mirages[player] != INVALID_ENTITY;
+};
+
+Fogging.prototype.GetMirage = function(player)
+{
+    if (player >= this.mirages.length)
+        return INVALID_ENTITY;
+
+    return this.mirages[player];
+};
+
+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 (var player = 0; player < this.mirages.length; ++player)
+    {
+        var cmpMirage = Engine.QueryInterface(this.mirages[player], IID_Mirage);
+        if (cmpMirage)
+            cmpMirage.SetParent(INVALID_ENTITY);
+    }
+};
+
+Engine.RegisterComponentType(IID_Fogging, "Fogging", Fogging);

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

@@ -175 +175 @@
         "alertRaiser": null,
         "buildEntities": null,
         "identity": null,
+        "fogging": null,
         "foundation": null,
         "garrisonHolder": null,
         "gate": null,
@@ -190 +191 @@
         "visibility": null,
     };
 
+    // Used for several components
+    var cmpMirage = Engine.QueryInterface(ent, IID_Mirage);
+
     var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
     if (cmpIdentity)
     {
@@ -216 +220 @@
         ret.needsRepair = cmpHealth.IsRepairable() && (cmpHealth.GetHitpoints() < cmpHealth.GetMaxHitpoints());
         ret.needsHeal = !cmpHealth.IsUnhealable();
     }
+    if (cmpMirage && cmpMirage.Health())
+    {
+        ret.hitpoints = cmpMirage.GetHitpoints();
+        ret.maxHitpoints = cmpMirage.GetMaxHitpoints();
+        ret.needsRepair = cmpMirage.NeedsRepair();
+    }
 
     var cmpBuilder = Engine.QueryInterface(ent, IID_Builder);
     if (cmpBuilder)
@@ -251 +261 @@
         };
     }
 
+    var cmpFogging = Engine.QueryInterface(ent, IID_Fogging);
+    if (cmpFogging)
+    {
+        if (cmpFogging.IsMiraged(player))
+            ret.fogging = {"mirage": cmpFogging.GetMirage(player)};
+        else
+            ret.fogging = {"mirage": null};
+    }
+
     var cmpFoundation = Engine.QueryInterface(ent, IID_Foundation);
     if (cmpFoundation)
     {
@@ -259 +278 @@
             "numBuilders": cmpFoundation.GetNumBuilders()
         };
     }
+    if (cmpMirage && cmpMirage.Foundation())
+    {
+        ret.foundation = {
+            "progress": cmpMirage.GetBuildPercentage()
+        };
+    }
 
     var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
     if (cmpOwnership)
@@ -342 +367 @@
         "barterMarket": null,
         "buildingAI": null,
         "healer": null,
+        "mirage": null,
         "obstruction": null,
         "turretParent":null,
         "promotion": null,
@@ -351 +377 @@
         "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 +475 @@
             "gatherers": cmpResourceSupply.GetGatherers()
         };
     }
+    if (cmpMirage && cmpMirage.ResourceSupply())
+    {
+        ret.resourceSupply = {
+            "max": cmpMirage.GetMaxAmount(),
+            "amount": cmpMirage.GetAmount(),
+            "type": cmpMirage.GetType(),
+            "isInfinite": cmpMirage.IsInfinite()
+        };
+    }
 
     var cmpResourceGatherer = Engine.QueryInterface(ent, IID_ResourceGatherer);
     if (cmpResourceGatherer)

new file inaries/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 = null;
+    this.parent = INVALID_ENTITY;
+
+    this.foundation = false;
+    this.buildPercentage = null;
+
+    this.health = false;
+    this.maxHitpoints = null;
+    this.hitpoints = null;
+    this.needsRepair = null;
+
+    this.resourceSupply = false;
+    this.maxAmount = null;
+    this.amount = null;
+    this.type = null;
+    this.isInfinite = null;
+};
+
+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
+
+// Foundation data
+
+Mirage.prototype.AddFoundation = function(buildPercentage)
+{
+    this.foundation = true;
+    this.buildPercentage = buildPercentage;
+};
+
+Mirage.prototype.Foundation = function()
+{
+    return this.foundation;
+};
+
+Mirage.prototype.GetBuildPercentage = function()
+{
+    return this.buildPercentage;
+};
+
+// Health data
+
+Mirage.prototype.AddHealth = function(maxHitpoints, hitpoints, needsRepair)
+{
+    this.health = true;
+    this.maxHitpoints = maxHitpoints;
+    this.hitpoints = Math.ceil(hitpoints);
+    this.needsRepair = needsRepair;
+};
+
+Mirage.prototype.Health = function()
+{
+    return this.health;
+};
+
+Mirage.prototype.GetMaxHitpoints = function()
+{
+    return this.maxHitpoints;
+};
+
+Mirage.prototype.GetHitpoints = function()
+{
+    return this.hitpoints;
+};
+
+Mirage.prototype.NeedsRepair = function()
+{
+    return this.needsRepair;
+};
+
+// ResourceSupply data
+
+Mirage.prototype.AddResourceSupply = function(maxAmount, amount, type, isInfinite)
+{
+    this.resourceSupply = true;
+    this.maxAmount = maxAmount;
+    this.amount = amount;
+    this.type = type;
+    this.isInfinite = isInfinite;
+};
+
+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.IsInfinite = function()
+{
+    return this.isInfinite;
+};
+
+// ============================
+
+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/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/tests/test_GuiInterface.js

@@ -398 +398 @@
         visibleClasses: ["class3", "class4"],
         selectionGroupName: "Selection Group Name",
     },
+    fogging: null,
     foundation: null,
     garrisonHolder: null,
     gate: null,
@@ -425 +426 @@
     },
     buildingAI: null,
     healer: null,
+    mirage: null,
     obstruction: null,
     turretParent: null,
     promotion: null,

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

@@ -974 +974 @@
             "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)
     {
@@ -383 +398 @@
     }
 }
 
+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
@@ -397 +446 @@
     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/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)

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"
@@ -564 +567 @@
         case MT_Update:
         {
             m_DebugOverlayDirty = true;
-            UpdateTerritoriesLos();
             ExecuteActiveQueries();
             UpdateVisibilityData();
             break;
@@ -1401 +1403 @@
                 return VIS_VISIBLE;
         }
 
+        // Mirage entities, whatever their position, are visible for one specific player
+        CmpPtr<ICmpMirage> cmpMirage(ent);
+        if (cmpMirage && cmpMirage->GetPlayer() != player)
+            return VIS_HIDDEN;
+
         // Visible if within a visible region
         CLosQuerier los(GetSharedLosMask(player), m_LosState, m_TerrainVerticesPerSide);
 
         if (los.IsVisible(i, j))
             return VIS_VISIBLE;
 
+        if (!los.IsExplored(i, j))          
+            return VIS_HIDDEN;
+            
         // Fogged if the 'retain in fog' flag is set, and in a non-visible explored region
-        if (los.IsExplored(i, j))
+        CmpPtr<ICmpVision> cmpVision(ent);
+        if (!forceRetainInFog && !(cmpVision && cmpVision->GetRetainInFog()))
+            return VIS_HIDDEN;
+
+        if (cmpMirage && cmpMirage->GetPlayer() == player)
+            return VIS_FOGGED;
+
+        CmpPtr<ICmpOwnership> cmpOwnership(ent);
+        if (!cmpOwnership)
+            return VIS_VISIBLE;
+        
+        if (cmpOwnership->GetOwner() == player)
         {
-            CmpPtr<ICmpVision> cmpVision(ent);
-            if (forceRetainInFog || (cmpVision && cmpVision->GetRetainInFog()))
+            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;
-        }
 
-        // Otherwise not visible
+            return VIS_HIDDEN;
+        }
+    
+        // 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;
     }
 
@@ -1487 +1518 @@
         EntityMap<EntityData>::iterator itEnts = m_EntityData.find(ent);
         if (itEnts == m_EntityData.end())
             return;
+
+        std::vector<u8> oldVisibilities;
+        std::vector<u8> newVisibilities;
         
-        for (player_id_t player = 1; player <= MAX_LOS_PLAYER_ID; ++player)
+        for (player_id_t player = 1; player < MAX_LOS_PLAYER_ID+1; ++player)
         {
             u8 oldVis = (itEnts->second.visibilities >> (2*(player-1))) & 0x3;
             u8 newVis = GetLosVisibility(itEnts->first, player, false);
+            
+            oldVisibilities.push_back(oldVis);
+            newVisibilities.push_back(newVis);
 
             if (oldVis != newVis)
-            {
-                CMessageVisibilityChanged msg(player, ent, oldVis, newVis);
-                GetSimContext().GetComponentManager().PostMessage(ent, msg);
                 itEnts->second.visibilities = (itEnts->second.visibilities & ~(0x3 << 2*(player-1))) | (newVis << 2*(player-1));
-            }
+        }
+
+        for (player_id_t player = 1; player < MAX_LOS_PLAYER_ID+1; ++player)
+        {
+            if (oldVisibilities[player-1] == newVisibilities[player-1])
+                continue;
+            
+            CMessageVisibilityChanged msg(player, ent, oldVisibilities[player-1], newVisibilities[player-1]);
+            GetSimContext().GetComponentManager().PostMessage(ent, msg);
         }
     }
 

new file 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/scripting/ScriptComponent.h"
+#include "simulation2/system/InterfaceScripted.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)

new file 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

new file 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/scripting/ScriptComponent.h"
+#include "simulation2/system/InterfaceScripted.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)

new file 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