Ticket #1334: shared-los.patch

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

@@ -65 +65 @@
         // store player ally/enemy data as arrays
         var allies = [];
         var enemies = [];
-        for (var j = 0; j <= n; ++j)
+        for (var j = 0; j < n; ++j)
         {
             allies[j] = cmpPlayer.IsAlly(j);
             enemies[j] = cmpPlayer.IsEnemy(j);
         }
+
+        var diplomacy = [];
+        for (var k = 0; k < allies.length; ++k)
+        {
+            if (allies[k])
+                diplomacy.push(k);
+        }
+        cmpPlayer.SetAllies(diplomacy);
+
         var playerData = {
             "name": cmpPlayer.GetName(),
             "civ": cmpPlayer.GetCiv(),

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

@@ -23 +23 @@
     this.team = -1; // team number of the player, players on the same team will always have ally diplomatic status - also this is useful for team emblems, scoring, etc.
     this.state = "active"; // game state - one of "active", "defeated", "won"
     this.diplomacy = [];    // array of diplomatic stances for this player with respect to other players (including gaia and self)
+    this.allies = []; // non-sparse array of a player's allies (including self)
     this.conquestCriticalEntitiesCount = 0; // number of owned units with ConquestCritical class
     this.phase = "village";
     this.formations = [];
@@ -213 +214 @@
     this.team = team;
 };
 
+Player.prototype.GetAllies = function()
+{
+    return this.allies;
+};
+
+Player.prototype.SetAllies = function(allies)
+{
+    this.allies = allies;
+};
+
 Player.prototype.GetDiplomacy = function()
 {
     return this.diplomacy;

source/graphics/GameView.cpp

@@ -487 +487 @@
     CheckLightEnv();
 
     m->Game->CachePlayerColours();
+    m->Game->CachePlayerTeamMasks();
 }
 
 void CGameView::Render()

source/graphics/LOSTexture.cpp

@@ -178 +178 @@
     if (!cmpRangeManager)
         return;
 
-    ICmpRangeManager::CLosQuerier los (cmpRangeManager->GetLosQuerier(g_Game->GetPlayerID()));
+    u32 playerMask = g_Game->GetPlayerTeamMask(g_Game->GetPlayerID());
+    ICmpRangeManager::CLosQuerier los (cmpRangeManager->GetLosQuerier(g_Game->GetPlayerID(), playerMask));
 
     GenerateBitmap(los, &losData[0], m_MapSize, m_MapSize);
 

source/ps/Game.cpp

@@ -352 +352 @@
 
     return m_PlayerColours[player];
 }
+
+
+void CGame::CachePlayerTeamMasks()
+{
+    m_PlayerTeamMasks.clear();
+
+    CmpPtr<ICmpPlayerManager> cmpPlayerManager(*m_Simulation2, SYSTEM_ENTITY);
+    if (!cmpPlayerManager)
+        return;
+
+    CmpPtr<ICmpRangeManager> cmpRangeManager(*m_Simulation2, SYSTEM_ENTITY);
+    if (!cmpRangeManager)
+        return;
+
+    int numPlayers = cmpPlayerManager->GetNumPlayers();
+    m_PlayerTeamMasks.resize(numPlayers);
+
+    for (int i = 0; i < numPlayers; ++i)
+    {
+        CmpPtr<ICmpPlayer> cmpPlayer(*m_Simulation2, cmpPlayerManager->GetPlayerByID(i));
+        if (!cmpPlayer)
+            m_PlayerTeamMasks[i] = 0;
+        else
+            m_PlayerTeamMasks[i] = cmpRangeManager->GetLosVisibilityMask( cmpPlayer->GetAllies() );
+    }
+}
+
+
+u32 CGame::GetPlayerTeamMask(int player) const
+{
+    if (player < 0 || player >= (int)m_PlayerTeamMasks.size())
+        return 0;
+
+    return m_PlayerTeamMasks[player];
+}

source/ps/Game.h

@@ -97 +97 @@
     CColor GetPlayerColour(int player) const;
 
     /**
+     * Retrieves each player's list of allies and generates a mask that
+     * allows line-of-sight visibility to be checked against a player and
+     * all allies with one comparison.
+     */
+    void CachePlayerTeamMasks();
+
+    u32 GetPlayerTeamMask(int player) const;
+
+    /**
      * Get m_GameStarted.
      *
      * @return bool the value of m_GameStarted.
@@ -158 +167 @@
     IReplayLogger* m_ReplayLogger;
 
     std::vector<CColor> m_PlayerColours;
+    std::vector<u32> m_PlayerTeamMasks;
 
     int LoadInitialState();
     std::string m_InitialSavedState; // valid between RegisterInit and LoadInitialState

source/simulation2/components/CCmpRangeManager.cpp

@@ -32 +32 @@
 #include "lib/timer.h"
 #include "maths/FixedVector2D.h"
 #include "ps/CLogger.h"
+#include "ps/Game.h"
 #include "ps/Overlay.h"
 #include "ps/Profile.h"
 #include "renderer/Scene.h"
@@ -915 +916 @@
             return CLosQuerier(player, m_LosState, m_TerrainVerticesPerSide);
     }
 
+    virtual CLosQuerier GetLosQuerier(player_id_t player, u32 playerMask)
+    {
+        if (GetLosRevealAll(player))
+            return CLosQuerier(playerMask, m_LosStateRevealed, m_TerrainVerticesPerSide);
+        else
+            return CLosQuerier(playerMask, m_LosState, m_TerrainVerticesPerSide);
+    }
+
     virtual ELosVisibility GetLosVisibility(entity_id_t ent, player_id_t player, bool forceRetainInFog)
     {
+        return GetLosVisibility(ent, player, 0, forceRetainInFog);
+    }
+
+    virtual ELosVisibility GetLosVisibility(entity_id_t ent, player_id_t player, u32 playerMask, bool forceRetainInFog)
+    {
         // (We can't use m_EntityData since this needs to handle LOCAL entities too)
 
         // Entities not with positions in the world are never visible
@@ -939 +953 @@
         }
 
         // Visible if within a visible region
+        if (!playerMask)
+            playerMask = g_Game->GetPlayerTeamMask(player);
 
-        CLosQuerier los(player, m_LosState, m_TerrainVerticesPerSide);
+        CLosQuerier los(playerMask, m_LosState, m_TerrainVerticesPerSide);
 
         if (los.IsVisible(i, j))
             return VIS_VISIBLE;
@@ -957 +973 @@
         return VIS_HIDDEN;
     }
 
+    virtual u32 GetLosVisibilityMask(std::vector<player_id_t> players)
+    {
+        u32 playerMask = 0;
+        player_id_t player;
+
+        for (size_t i = 0; i < players.size(); i++)
+        {
+            player = players[i];
+            if (player > 0 && player <= 16)
+                playerMask |= LOS_MASK << (2*(player-1));
+            else
+                continue;
+        }
+
+        return playerMask;
+    }
+
     virtual void SetLosRevealAll(player_id_t player, bool enabled)
     {
         m_LosRevealAll[player] = enabled;

source/simulation2/components/ICmpPlayer.cpp

@@ -43 +43 @@
         return m_Script.Call<std::wstring>("GetCiv");
     }
 
+    virtual std::vector<int> GetAllies()
+    {
+        return m_Script.Call<std::vector<int> >("GetAllies");
+    }
+
     virtual CFixedVector3D GetStartingCameraPos()
     {
         return m_Script.Call<CFixedVector3D>("GetStartingCameraPos");

source/simulation2/components/ICmpPlayer.h

@@ -33 +33 @@
 public:
     virtual CColor GetColour() = 0;
     virtual std::wstring GetCiv() = 0;
+    virtual std::vector<int> GetAllies() = 0;
     virtual CFixedVector3D GetStartingCameraPos() = 0;
     virtual CFixedVector3D GetStartingCameraRot() = 0;
 

source/simulation2/components/ICmpRangeManager.h

@@ -194 +194 @@
                 m_PlayerMask = 0;
         }
 
+        CLosQuerier(u32 playerMask, const std::vector<u32>& data, ssize_t verticesPerSide) :
+            m_Data(&data[0]), m_VerticesPerSide(verticesPerSide)
+        {
+            m_PlayerMask = playerMask;
+        }
+
         const CLosQuerier& operator=(const CLosQuerier&); // not implemented
 
     public:
@@ -269 +275 @@
      * Returns a CLosQuerier for checking whether vertex positions are visible to the given player.
      */
     virtual CLosQuerier GetLosQuerier(player_id_t player) = 0;
+    virtual CLosQuerier GetLosQuerier(player_id_t player, u32 playerMask) = 0;
 
     /**
      * Returns the visibility status of the given entity, with respect to the given player.
@@ -279 +286 @@
      *  see http://trac.wildfiregames.com/ticket/958
      */
     virtual ELosVisibility GetLosVisibility(entity_id_t ent, player_id_t player, bool forceRetainInFog = false) = 0;
+    virtual u32 GetLosVisibilityMask(std::vector<player_id_t> players) = 0;
 
     /**
      * GetLosVisibility wrapped for script calls.