Ticket #599: proxywip.patch

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

@@ -56 +56 @@
     return (this.buildProgress >= 1.0);
 };
 
+Foundation.prototype.OnVisibilityChanged = function(msg)
+{
+  if (msg.source != this.entity)
+      return;
+  var building = msg.source;
+  var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+  var cmpBuildingPosition = Engine.QueryInterface(building, IID_Position);
+  var pos = cmpPosition.GetPosition();
+  cmpBuildingPosition.JumpTo(pos.x, pos.z);
+  var rot = cmpPosition.GetRotation();
+  cmpBuildingPosition.SetYRotation(rot.y);
+  cmpBuildingPosition.SetXZRotation(rot.x, rot.z);
+  // TODO: should add a ICmpPosition::CopyFrom() instead of all this
+  
+  var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+  var cmpBuildingOwnership = Engine.QueryInterface(building, IID_Ownership);
+  cmpBuildingOwnership.SetOwner(cmpOwnership.GetOwner());
+  
+  var cmpHealth = Engine.QueryInterface(this.entity, IID_Health);
+  var cmpBuildingHealth = Engine.QueryInterface(building, IID_Health);
+  cmpBuildingHealth.SetHitpoints(cmpHealth.GetHitpoints());
+}
+
 Foundation.prototype.OnDestroy = function()
 {
     // Refund a portion of the construction cost, proportional to the amount of build progress remaining

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

@@ -21 +21 @@
     this.rallyPoints = undefined;
     this.notifications = [];
     this.renamedEntities = [];
+        this.proxiedEntities = {};
 };
 
 /*
@@ -111 +112 @@
 
 GuiInterface.prototype.GetRenamedEntities = function(player)
 {
-    return this.renamedEntities;
+        var proxied = this.proxiedEntities[player];
+        if (!proxied) proxied = [];
+        return this.renamedEntities.concat(proxied);
 };
 
 GuiInterface.prototype.ClearRenamedEntities = function(player)
 {
     this.renamedEntities = [];
+        this.proxiedEntities[player] = [];
 };
 
 GuiInterface.prototype.GetEntityState = function(player, ent)
@@ -713 +717 @@
     this.renamedEntities.push(msg);
 }
 
+GuiInterface.prototype.OnGlobalDestroy = function(msg)
+{
+  var cmpVisual = Engine.QueryInterface(msg.entity, IID_Visual);
+  if (!cmpVisual)
+    return;
+  var proxy = cmpVisual.GetProxyOwner();
+  if (proxy == INVALID_ENTITY)
+    return;
+  // FIXME: we could end up flooding the list if there are lots of proxies coming into view
+  //        at the same time, since we don't have a way of checking the target player
+  this.renamedEntities.push({"type": "EntityRenamed", "entity": msg.entity, "newentity": proxy});
+}
+
+GuiInterface.prototype.OnGlobalVisibilityChanged = function(msg)
+{
+    if (msg.source != INVALID_ENTITY)
+        this.proxiedEntities[msg.player].push({"type": "EntityRenamed", "entity": msg.source, "newentity": msg.proxy});
+}
+
+GuiInterface.prototype.GetProxiedEntities = function(player)
+{
+    return this.proxiedEntities[player];
+}
+
+GuiInterface.prototype.ClearProxiedEntities = function(player)
+{
+    this.proxiedEntities[player] = [];
+}
+
 // List the GuiInterface functions that can be safely called by GUI scripts.
 // (GUI scripts are non-deterministic and untrusted, so these functions must be
 // appropriately careful. They are called with a first argument "player", which is
@@ -742 +775 @@
     "SetPathfinderDebugOverlay": 1,
     "SetObstructionDebugOverlay": 1,
     "SetMotionDebugOverlay": 1,
-    "SetRangeDebugOverlay": 1,
+    "SetRangeDebugOverlay": 1
 };
 
 GuiInterface.prototype.ScriptCall = function(player, name, args)

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

@@ -82 +82 @@
     return { "generic": type, "specific": subtype };
 };
 
+ResourceSupply.prototype.OnVisibilityChanged = function(msg)
+{
+    if (msg.source != this.entity)
+        return;
+    var entity = msg.proxy;
+    var supply = Engine.QueryInterface(entity, IID_ResourceSupply);
+    supply.amount = this.amount;
+    var proxyPosition = Engine.QueryInterface(entity, IID_Position);
+    var position = Engine.QueryInterface(this.entity, IID_Position);
+    var pos = position.GetPosition();
+    proxyPosition.JumpTo(pos.x, pos.z);
+    var rot = position.GetRotation();
+    proxyPosition.SetYRotation(rot.y);
+    proxyPosition.SetXZRotation(rot.x, rot.z);
+    // TODO: should add a ICmpPosition::CopyFrom() instead of all this
+
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    var cmpProxyOwnership = Engine.QueryInterface(entity, IID_Ownership);
+    cmpProxyOwnership.SetOwner(cmpOwnership.GetOwner());
+}
+
 Engine.RegisterComponentType(IID_ResourceSupply, "ResourceSupply", ResourceSupply);

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

@@ -790 +790 @@
         },
 
         "GATHER": {
+            "EntityRenamed": function(msg) {
+                if (this.order.data.target == msg.entity)
+                    this.order.data.target = msg.newentity;
+            },
+
             "APPROACHING": {
                 "enter": function() {
                     this.SelectAnimation("move");
@@ -1454 +1459 @@
         rangeMan.DestroyActiveQuery(this.losRangeQuery);
 };
 
+UnitAI.prototype.OnGlobalDestroy = function(msg)
+{
+    var cmpVisual = Engine.QueryInterface(msg.entity, IID_Visual);
+    if (!cmpVisual)
+        return;
+    var proxy = cmpVisual.GetProxyOwner();
+    if (proxy == INVALID_ENTITY)
+        return;
+    this.OnGlobalEntityRenamed({entity: msg.entity, newentity: proxy});
+}
+
 // Set up a range query for all enemy units within LOS range
 // which can be attacked.
 // This should be called whenever our ownership changes.
@@ -1699 +1715 @@
     UnitFsm.ProcessMessage(this, {"type": "EntityRenamed", "entity": msg.entity, "newentity": msg.newentity});
 }
 
+UnitAI.prototype.OnGlobalVisibilityChanged = function(msg)
+{
+    if (msg.source == INVALID_ENTITY)
+        return;
+    var cmpVisual = Engine.QueryInterface(msg.proxy, IID_Visual);
+    var cmpOwner = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (cmpVisual.GetProxyPlayerTarget() == cmpOwner.GetOwner())
+        this.OnGlobalEntityRenamed({entity: msg.source, newentity: msg.proxy});
+}
+
 UnitAI.prototype.OnAttacked = function(msg)
 {
     UnitFsm.ProcessMessage(this, {"type": "Attacked", "data": msg});

source/network/NetTurnManager.cpp

@@ -32 +32 @@
 #include "ps/SavedGame.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
+#include "simulation2/system/SimContext.h"
 
 #include <sstream>
 #include <fstream>
@@ -232 +233 @@
     bool ok = m_Simulation2.ComputeStateHash(hash, quick);
     ENSURE(ok);
 
-    OsPath path = psLogDir()/"oos_dump.txt";
+    std::stringstream fname; 
+    fname << "oos_dump_" << m_Simulation2.GetSimContext().GetCurrentDisplayedPlayer() << ".txt";
+    OsPath path = psLogDir()/fname.str();
     std::ofstream file (OsString(path).c_str(), std::ofstream::out | std::ofstream::trunc);
     m_Simulation2.DumpDebugState(file);
     file.close();

source/simulation2/MessageTypes.h

@@ -23 +23 @@
 #include "simulation2/system/Message.h"
 
 #include "simulation2/helpers/Position.h"
+#include "simulation2/helpers/Player.h"
 
 #include "simulation2/components/ICmpPathfinder.h"
 
@@ -99 +100 @@
     fixed turnLength;
 };
 
+class CMessageUpdate_Visibility : public CMessage
+{
+public:
+    DEFAULT_MESSAGE_IMPL(Update_Visibility)
+
+    CMessageUpdate_Visibility()
+    {
+    }
+};
+
 /**
  * Final update phase, after all other updates.
  */
@@ -357 +368 @@
     ICmpPathfinder::Path path;
 };
 
+class CMessageVisibilityChanged : public CMessage
+{
+public:
+    DEFAULT_MESSAGE_IMPL(VisibilityChanged)
+
+    CMessageVisibilityChanged(entity_id_t source, entity_id_t proxy, player_id_t player) :
+        source(source), proxy(proxy), player(player)
+    {
+    }
+
+    CMessageVisibilityChanged() :
+        source(INVALID_ENTITY), proxy(INVALID_ENTITY), player(INVALID_PLAYER)
+    {
+    }
+
+    entity_id_t source, proxy;
+    player_id_t player;
+};
+
 #endif // INCLUDED_MESSAGETYPES

source/simulation2/Simulation2.cpp

@@ -499 +499 @@
         CMessageUpdate_MotionUnit msgUpdate(turnLengthFixed);
         componentManager.BroadcastMessage(msgUpdate);
     }
+    {
+        CMessageUpdate_Visibility msgUpdate;
+        componentManager.BroadcastMessage(msgUpdate);
+    }
     {
         CMessageUpdate_Final msgUpdate(turnLengthFixed);
         componentManager.BroadcastMessage(msgUpdate);

source/simulation2/TypeList.h

@@ -34 +34 @@
 MESSAGE(Update)
 MESSAGE(Update_MotionFormation)
 MESSAGE(Update_MotionUnit)
+MESSAGE(Update_Visibility)
 MESSAGE(Update_Final)
 MESSAGE(Interpolate) // non-deterministic (use with caution)
 MESSAGE(RenderSubmit) // non-deterministic (use with caution)
@@ -47 +48 @@
 MESSAGE(TerrainChanged)
 MESSAGE(TerritoriesChanged)
 MESSAGE(PathResult)
+MESSAGE(VisibilityChanged)
 
 // TemplateManager must come before all other (non-test) components,
 // so that it is the first to be (de)serialized

source/simulation2/components/CCmpRangeManager.cpp

@@ -18 +18 @@
 #include "precompiled.h"
 
 #include "simulation2/system/Component.h"
+#include "simulation2/Simulation2.h"
 #include "ICmpRangeManager.h"
 
 #include "simulation2/MessageTypes.h"
 #include "simulation2/components/ICmpPosition.h"
 #include "simulation2/components/ICmpTerritoryManager.h"
 #include "simulation2/components/ICmpVision.h"
+#include "simulation2/components/ICmpVisual.h"
 #include "simulation2/helpers/Render.h"
 #include "simulation2/helpers/Spatial.h"
 
@@ -34 +36 @@
 #include "ps/CLogger.h"
 #include "ps/Overlay.h"
 #include "ps/Profile.h"
+#include "ps/Game.h"
 #include "renderer/Scene.h"
 
 #define DEBUG_RANGE_MANAGER_BOUNDS 0
@@ -164 +167 @@
         componentManager.SubscribeGloballyToMessageType(MT_Destroy);
 
         componentManager.SubscribeToMessageType(MT_Update);
+        componentManager.SubscribeToMessageType(MT_Update_Visibility);
 
         componentManager.SubscribeToMessageType(MT_RenderSubmit); // for debug overlays
     }
@@ -186 +190 @@
     std::map<entity_id_t, EntityData> m_EntityData;
     SpatialSubdivision<entity_id_t> m_Subdivision; // spatial index of m_EntityData
 
+  std::set<entity_id_t> m_DirtyVisibility;
     // LOS state:
 
     std::map<player_id_t, bool> m_LosRevealAll;
@@ -413 +418 @@
             ExecuteActiveQueries();
             break;
         }
+        case MT_Update_Visibility:
+        {
+            CMessageVisibilityChanged msg;
+            for (std::set<entity_id_t>::iterator it = m_DirtyVisibility.begin(); it != m_DirtyVisibility.end(); ++it)
+            {
+                g_Game->GetSimulation2()->PostMessage(*it, msg);
+            }
+            m_DirtyVisibility.clear();
+            break;
+        }
         case MT_RenderSubmit:
         {
             const CMessageRenderSubmit& msgData = static_cast<const CMessageRenderSubmit&> (msg);
@@ -876 +891 @@
     {
         // (We can't use m_EntityData since this needs to handle LOCAL entities too)
 
+        CmpPtr<ICmpVisual> cmpVisual(GetSimContext(), ent);
+        if (!cmpVisual.null())
+        {
+          // Proxy entities for other players are never visible
+          player_id_t target = cmpVisual->GetProxyPlayerTarget();
+          if (target != INVALID_PLAYER && target != player)
+            return VIS_HIDDEN;
+        }
+
         // Entities not with positions in the world are never visible
         CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), ent);
         if (cmpPosition.null() || !cmpPosition->IsInWorld())
@@ -902 +926 @@
         if (los.IsVisible(i, j))
             return VIS_VISIBLE;
 
+        // If a proxy exists, we should never show this actor
+        if (!cmpVisual.null() && cmpVisual->GetProxyForPlayer(player) != INVALID_ENTITY)
+        {
+            return VIS_HIDDEN;
+        }
+
         // Fogged if the 'retain in fog' flag is set, and in a non-visible explored region
         if (los.IsExplored(i, j))
         {
@@ -971 +1001 @@
                     m_LosState[i+1 + j*m_TerrainVerticesPerSide] |= (LOS_EXPLORED << (2*(p-1)));
                     m_LosState[i + (j+1)*m_TerrainVerticesPerSide] |= (LOS_EXPLORED << (2*(p-1)));
                     m_LosState[i+1 + (j+1)*m_TerrainVerticesPerSide] |= (LOS_EXPLORED << (2*(p-1)));
+
+                    CFixedVector2D start(fixed::FromInt(i*CELL_SIZE), fixed::FromInt(j*CELL_SIZE));
+                    CFixedVector2D end(fixed::FromInt((i+1)*CELL_SIZE), fixed::FromInt((j+1)*CELL_SIZE));
+                    std::vector<entity_id_t> ents = m_Subdivision.GetInRange(start, end);
+                    m_DirtyVisibility.insert(ents.begin(), ents.end());
                 }
             }
         }
@@ -1025 +1060 @@
             {
                 i32 i = i0 + idx - idx0;
                 if (!LosIsOffWorld(i, j))
+                {
                     m_LosState[idx] |= ((LOS_VISIBLE | LOS_EXPLORED) << (2*(owner-1)));
+                }
             }
 
             ASSERT(counts[idx] < 65535);
             counts[idx] = (u16)(counts[idx] + 1); // ignore overflow; the player should never have 64K units
         }
+
+        CFixedVector2D start(fixed::FromInt(i0*CELL_SIZE), fixed::FromInt(j*CELL_SIZE));
+        CFixedVector2D end(fixed::FromInt(i1*CELL_SIZE), fixed::FromInt(j*CELL_SIZE));
+        std::vector<entity_id_t> ents = m_Subdivision.GetInRange(start, end);
+        m_DirtyVisibility.insert(ents.begin(), ents.end());
     }
 
     /**
@@ -1054 +1096 @@
             {
                 // (If LosIsOffWorld then this is a no-op, so don't bother doing the check)
                 m_LosState[idx] &= ~(LOS_VISIBLE << (2*(owner-1)));
-            }
+            }
         }
+
+        CFixedVector2D start(fixed::FromInt(i0*CELL_SIZE), fixed::FromInt(j*CELL_SIZE));
+        CFixedVector2D end(fixed::FromInt(i1*CELL_SIZE), fixed::FromInt(j*CELL_SIZE));
+        std::vector<entity_id_t> ents = m_Subdivision.GetInRange(start, end);
+        m_DirtyVisibility.insert(ents.begin(), ents.end());
     }
 
     /**

source/simulation2/components/CCmpUnitMotion.cpp

@@ -1311 +1311 @@
     CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
     if (cmpObstructionManager.null())
         return false;
-
     bool hasObstruction = false;
     ICmpObstructionManager::ObstructionSquare obstruction;
     CmpPtr<ICmpObstruction> cmpObstruction(GetSimContext(), target);

source/simulation2/components/CCmpVisualActor.cpp

@@ -17 +17 @@
 
 #include "precompiled.h"
 
+#include <sstream>
+
+#include "simulation2/Simulation2.h"
 #include "simulation2/system/Component.h"
 #include "ICmpVisual.h"
 
@@ -24 +27 @@
 #include "ICmpPosition.h"
 #include "ICmpRangeManager.h"
 #include "ICmpVision.h"
+#include "ICmpTemplateManager.h"
 #include "simulation2/MessageTypes.h"
 #include "simulation2/components/ICmpFootprint.h"
+#include "simulation2/serialization/SerializeTemplates.h"
 
 #include "graphics/Frustum.h"
 #include "graphics/Model.h"
@@ -37 +42 @@
 #include "maths/Matrix3D.h"
 #include "maths/Vector3D.h"
 #include "ps/CLogger.h"
+#include "ps/Game.h"
 #include "renderer/Scene.h"
+#include "lib/utf8.h"
 
 class CCmpVisualActor : public ICmpVisual
 {
@@ -48 +55 @@
         componentManager.SubscribeToMessageType(MT_Interpolate);
         componentManager.SubscribeToMessageType(MT_RenderSubmit);
         componentManager.SubscribeToMessageType(MT_OwnershipChanged);
+        componentManager.SubscribeToMessageType(MT_VisibilityChanged);
         componentManager.SubscribeGloballyToMessageType(MT_TerrainChanged);
     }
 
@@ -59 +67 @@
     fixed m_R, m_G, m_B; // shading colour
 
     ICmpRangeManager::ELosVisibility m_Visibility; // only valid between Interpolate and RenderSubmit
+    ICmpRangeManager::ELosVisibility m_LastVisibility;
+    bool m_FirstVisUpdate;
+
+    typedef std::map<player_id_t, entity_id_t> ProxyEntityMap;
+    ProxyEntityMap m_ProxyEntities;
+    entity_id_t m_ProxiedEntity;
+    player_id_t m_ProxyPlayerTarget;
+
+    int32_t m_ActorSeed;
 
     // Current animation state
     fixed m_AnimRunThreshold; // if non-zero this is the special walk/run mode
@@ -138 +155 @@
 
         m_R = m_G = m_B = fixed::FromInt(1);
 
+        m_FirstVisUpdate = true;
+        m_LastVisibility = ICmpRangeManager::VIS_VISIBLE;
+
+        m_ProxyPlayerTarget = INVALID_PLAYER;
+        m_ProxiedEntity = INVALID_ENTITY;
+
+        m_ActorSeed = GetEntityId();
+
         if (!GetSimContext().HasUnitManager())
             return; // do nothing further if graphics are disabled
 
@@ -148 +173 @@
         else
             m_ActorName = paramNode.GetChild("Actor").ToString();
 
-        std::set<CStr> selections;
-        m_Unit = GetSimContext().GetUnitManager().CreateUnit(m_ActorName, GetActorSeed(), selections);
-        if (m_Unit)
+        ResetUnitSeed(m_ActorSeed);
+        if (m_Unit)
         {
-            u32 modelFlags = 0;
-            if (paramNode.GetChild("SilhouetteDisplay").ToBool())
-                modelFlags |= MODELFLAG_SILHOUETTE_DISPLAY;
-            if (paramNode.GetChild("SilhouetteOccluder").ToBool())
-                modelFlags |= MODELFLAG_SILHOUETTE_OCCLUDER;
-
-            CModelAbstract& model = m_Unit->GetModel();
-            if (model.ToCModel())
-                model.ToCModel()->AddFlagsRec(modelFlags);
-
-            // Initialize the model's selection shape descriptor. This currently relies on the component initialization order; the 
-            // Footprint component must be initialized before this component (VisualActor) to support the ability to use the footprint
-            // shape for the selection box (instead of the default recursive bounding box). See TypeList.h for the order in
-            // which components are initialized; if for whatever reason you need to get rid of this dependency, you can always just
-            // initialize the selection shape descriptor on-demand.
-            InitSelectionShapeDescriptor(model, paramNode);
-
-            m_Unit->SetID(GetEntityId());
+          u32 modelFlags = 0;
+          if (paramNode.GetChild("SilhouetteDisplay").ToBool())
+            modelFlags |= MODELFLAG_SILHOUETTE_DISPLAY;
+          if (paramNode.GetChild("SilhouetteOccluder").ToBool())
+            modelFlags |= MODELFLAG_SILHOUETTE_OCCLUDER;
+
+          CModelAbstract& model = m_Unit->GetModel();
+          if (model.ToCModel())
+            model.ToCModel()->AddFlagsRec(modelFlags);
+
+          // Initialize the model's selection shape descriptor. This currently relies on the component initialization order; the 
+          // Footprint component must be initialized before this component (VisualActor) to support the ability to use the footprint
+          // shape for the selection box (instead of the default recursive bounding box). See TypeList.h for the order in
+          // which components are initialized; if for whatever reason you need to get rid of this dependency, you can always just
+          // initialize the selection shape descriptor on-demand.
+          InitSelectionShapeDescriptor(model, paramNode);
         }
 
         SelectAnimation("idle", false, fixed::FromInt(1), L"");
@@ -206 +228 @@
         serialize.NumberFixed_Unbounded("anim desync", m_AnimDesync);
         serialize.NumberFixed_Unbounded("anim sync repeat time", m_AnimSyncRepeatTime);
 
+        serialize.NumberI32_Unbounded("seed", m_ActorSeed);
+        //serialize.Bool("first vis update", m_FirstVisUpdate);
+        /*  serialize.NumberU8("last visibility state", *(uint8_t*)&m_LastVisibility, (uint8_t)ICmpRangeManager::VIS_HIDDEN, (uint8_t)ICmpRangeManager::VIS_VISIBLE);*/
+        serialize.NumberU32_Unbounded("proxied entity", m_ProxiedEntity);
+        serialize.NumberI32_Unbounded("proxy player target", m_ProxyPlayerTarget);
+        SerializeMap<SerializeI32_Unbounded, SerializeU32_Unbounded>()(serialize, "per-player proxy entities", m_ProxyEntities);
         // TODO: store actor variables?
     }
 
@@ -226 +254 @@
         Init(paramNode);
 
         SerializeCommon(deserialize);
-
+        
         fixed repeattime = m_AnimSyncRepeatTime; // save because SelectAnimation overwrites it
 
         if (m_AnimRunThreshold.IsZero())
@@ -246 +274 @@
 
     virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
     {
+        if (msg.GetType() == MT_VisibilityChanged)
+        {
+            const CMessageVisibilityChanged& msgData = static_cast<const CMessageVisibilityChanged&> (msg);
+            if (msgData.source == INVALID_ENTITY)
+                VisibilityChanged();
+            return;
+        }
+
         // Quick exit for running in non-graphical mode
         if (m_Unit == NULL)
             return;
@@ -456 +492 @@
 
         // TODO: should copy/reset silhouette flags
     }
+  
+    virtual entity_id_t GetProxyForPlayer(player_id_t player)
+    {
+        ProxyEntityMap::iterator result = m_ProxyEntities.find(player);
+        if (result != m_ProxyEntities.end()) {
+            return result->second;
+        }
+        return INVALID_ENTITY;
+    }
+
+    virtual entity_id_t GetProxyOwner()
+    {
+        return m_ProxiedEntity;
+    }
+
+    virtual player_id_t GetProxyPlayerTarget()
+    {
+        return m_ProxyPlayerTarget;
+    }
+
+    virtual void SetProxyData(entity_id_t entity, player_id_t player)
+    {
+        m_ProxiedEntity = entity;
+        m_ProxyPlayerTarget = player;
+    }
+
+    virtual void ResetUnitSeed(int32_t seed)
+    {
+        m_ActorSeed = seed;
+        if (!GetSimContext().HasUnitManager())
+            return;
+        if (m_Unit)
+            GetSimContext().GetUnitManager().DeleteUnit(m_Unit);
 
+        std::set<CStr> selections;
+        m_Unit = GetSimContext().GetUnitManager().CreateUnit(m_ActorName, GetActorSeed(), selections);
+        if (m_Unit)
+            m_Unit->SetID(GetEntityId());
+    }
+  
 private:
     int32_t GetActorSeed()
     {
-        return GetEntityId();
+        return m_ActorSeed;
     }
 
     /// Helper method; initializes the model selection shape descriptor from XML. Factored out for readability of @ref Init.
@@ -471 +546 @@
     void InitSelectionShapeDescriptor(CModelAbstract& model, const CParamNode& paramNode);
 
     void Update(fixed turnLength);
+    void VisibilityChanged();
     void Interpolate(float frameTime, float frameOffset);
     void RenderSubmit(SceneCollector& collector, const CFrustum& frustum, bool culling);
 };
@@ -584 +660 @@
     }
 }
 
+void CCmpVisualActor::VisibilityChanged()
+{
+  player_id_t player = GetSimContext().GetCurrentDisplayedPlayer();
+
+  CmpPtr<ICmpRangeManager> cmpRangeManager(GetSimContext(), SYSTEM_ENTITY);
+  ICmpRangeManager::ELosVisibility vis = cmpRangeManager->GetLosVisibility(GetEntityId(), player);
+
+  bool forceProxy = false;
+  if (m_FirstVisUpdate)
+  {
+    m_LastVisibility = vis;
+    if (vis == ICmpRangeManager::VIS_FOGGED)
+    {
+      forceProxy = true;
+    }
+    m_FirstVisUpdate = false;
+  }
+
+  if (vis != m_LastVisibility || forceProxy)
+  {
+    CSimulation2& simulation = *g_Game->GetSimulation2();
+    if (vis == ICmpRangeManager::VIS_FOGGED && m_ProxiedEntity == INVALID_ENTITY)
+    {
+      CmpPtr<ICmpTemplateManager> cmpTemplateManager(simulation, SYSTEM_ENTITY);
+      std::string templ = cmpTemplateManager->GetCurrentTemplateName(GetEntityId());
+      std::wstring wtempl = wstring_from_utf8(templ);
+      entity_id_t proxy = simulation.AddEntity(wtempl);
+      CmpPtr<ICmpVisual> proxyVis(simulation, proxy);
+      proxyVis->SetProxyData(GetEntityId(), player);
+      proxyVis->ResetUnitSeed(GetActorSeed());
+      m_ProxyEntities[player] = proxy;
+
+      CMessageVisibilityChanged msg(GetEntityId(), proxy, player);
+      simulation.BroadcastMessage(msg);
+    }
+    else if (vis == ICmpRangeManager::VIS_VISIBLE)
+    {
+      ProxyEntityMap::iterator it = m_ProxyEntities.find(player);
+      if (it != m_ProxyEntities.end())
+      {
+        simulation.DestroyEntity(it->second);
+        m_ProxyEntities.erase(it);
+      }
+
+      if (m_ProxiedEntity != INVALID_ENTITY)
+      {
+        CmpPtr<ICmpVisual> proxyVis(simulation, m_ProxiedEntity);
+        if (proxyVis.null())
+          simulation.DestroyEntity(GetEntityId());
+      }
+    }
+  }
+
+  m_LastVisibility = vis;
+}
+
 void CCmpVisualActor::Interpolate(float frameTime, float frameOffset)
 {
     if (m_Unit == NULL)

source/simulation2/components/ICmpVisual.cpp

@@ -28 +28 @@
 DEFINE_INTERFACE_METHOD_1("SetAnimationSyncOffset", void, ICmpVisual, SetAnimationSyncOffset, fixed)
 DEFINE_INTERFACE_METHOD_4("SetShadingColour", void, ICmpVisual, SetShadingColour, fixed, fixed, fixed, fixed)
 DEFINE_INTERFACE_METHOD_2("SetVariable", void, ICmpVisual, SetVariable, std::string, float)
+DEFINE_INTERFACE_METHOD_0("GetProxyPlayerTarget", player_id_t, ICmpVisual, GetProxyPlayerTarget)
+DEFINE_INTERFACE_METHOD_0("GetProxyOwner", entity_id_t, ICmpVisual, GetProxyOwner)
 END_INTERFACE_WRAPPER(Visual)

source/simulation2/components/ICmpVisual.h

@@ -19 +19 @@
 #define INCLUDED_ICMPVISUAL
 
 #include "simulation2/system/Interface.h"
+#include "simulation2/helpers/Player.h"
 
 #include "ps/CStr.h"
 #include "maths/BoundingBoxOriented.h"
@@ -138 +139 @@
      */
     virtual void Hotload(const VfsPath& name) = 0;
 
-    DECLARE_INTERFACE_TYPE(Visual)
+    /**
+     *
+     */
+    virtual entity_id_t GetProxyForPlayer(player_id_t player) = 0;
+
+    virtual entity_id_t GetProxyOwner() = 0;
+    virtual player_id_t GetProxyPlayerTarget() = 0;
+    virtual void SetProxyData(entity_id_t entity, player_id_t player) = 0;
+    virtual void ResetUnitSeed(int32_t seed) = 0;
+  
+    DECLARE_INTERFACE_TYPE(Visual)
 };
 
 // TODO: rename this to VisualActor, because the interface is actor-specific, maybe?

source/simulation2/scripting/MessageTypeConversions.cpp

@@ -90 +90 @@
 MESSAGE_1(Update_MotionUnit, fixed, turnLength)
 MESSAGE_1(Update_Final, fixed, turnLength)
 
+jsval CMessageUpdate_Visibility::ToJSVal(ScriptInterface& scriptInterface) const
+{
+  TOJSVAL_SETUP();
+  return OBJECT_TO_JSVAL(obj);
+}
+
+CMessage* CMessageUpdate_Visibility::FromJSVal(ScriptInterface& UNUSED(scriptInterface), jsval UNUSED(val))
+{
+  return NULL;
+}
+
 ////////////////////////////////
 
 jsval CMessageInterpolate::ToJSVal(ScriptInterface& scriptInterface) const
@@ -296 +307 @@
     return NULL;
 }
 
+////////////////////////////////
+
+jsval CMessageVisibilityChanged::ToJSVal(ScriptInterface& scriptInterface) const
+{
+  TOJSVAL_SETUP();
+  SET_MSG_PROPERTY(source);
+  SET_MSG_PROPERTY(proxy);
+  SET_MSG_PROPERTY(player);
+  return OBJECT_TO_JSVAL(obj);
+}
+
+CMessage* CMessageVisibilityChanged::FromJSVal(ScriptInterface& UNUSED(scriptInterface), jsval UNUSED(val))
+{
+  LOGWARNING(L"CMessageVisibilityChanged::FromJSVal not implemented");
+  return NULL;
+}
+
 ////////////////////////////////////////////////////////////////
 
 CMessage* CMessageFromJSVal(int mtid, ScriptInterface& scriptingInterface, jsval val)