Changeset 24980

Timestamp:

Mar 2, 2021, 5:44:40 PM (3 years ago)

Author:

wraitii

Message:

Decouple LOS resolution from terrain resolution

Introduce a LOS_TILE_SIZE, to replace usage of TERRITORY_TILE_SIZE in the LOS code.
This makes it possible to change the resolution of LOS/Terrain without affecting the other component.

Additional refactoring:

• LosTile has been renamed LosRegion (it's more comparable to the hierarchical pathfinder regions/spatial subdivisions)
• LosState explicitly refers to "los vertices" instead of terrain vertices.

Refs #5566

Differential Revision: ​https://code.wildfiregames.com/D3076

Location:

ps/trunk

Files:

• binaries/data/mods/public/simulation/helpers/InitGame.js (modified) (1 diff)
• source/graphics/LOSTexture.cpp (modified) (5 diffs)
• source/graphics/LOSTexture.h (modified) (1 diff)
• source/simulation2/components/CCmpProjectileManager.cpp (modified) (1 diff)
• source/simulation2/components/CCmpRallyPointRenderer.cpp (modified) (2 diffs)
• source/simulation2/components/CCmpRangeManager.cpp (modified) (43 diffs)
• source/simulation2/components/CCmpTerrain.cpp (modified) (1 diff)
• source/simulation2/components/ICmpRangeManager.cpp (modified) (1 diff)
• source/simulation2/components/ICmpRangeManager.h (modified) (3 diffs)
• source/simulation2/components/tests/test_RangeManager.h (modified) (2 diffs)
• source/simulation2/helpers/Los.h (modified) (1 diff)

ps/trunk/binaries/data/mods/public/simulation/helpers/InitGame.js

@@ -39 +39 @@
         let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
         for (let i = 1; i < settings.PlayerData.length; ++i)
-            cmpRangeManager.ExploreAllTiles(i);
+            cmpRangeManager.Explore(i);
     }
 

ps/trunk/source/graphics/LOSTexture.cpp

@@ -21 +21 @@
 
 #include "graphics/ShaderManager.h"
-#include "graphics/Terrain.h"
 #include "lib/bits.h"
 #include "lib/config2.h"
@@ -32 +31 @@
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpRangeManager.h"
-#include "simulation2/components/ICmpTerrain.h"
 #include "simulation2/helpers/Los.h"
 
 /*
 
-The LOS bitmap is computed with one value per map vertex, based on
+The LOS bitmap is computed with one value per  vertex, based on
 CCmpRangeManager's visibility information.
 
@@ -244 +242 @@
 void CLOSTexture::ConstructTexture(int unit)
 {
-    CmpPtr<ICmpTerrain> cmpTerrain(m_Simulation, SYSTEM_ENTITY);
-    if (!cmpTerrain)
+    CmpPtr<ICmp(m_Simulation, SYSTEM_ENTITY);
+    if (!cmp)
         return;
 
-    m_MapSize = cmpTerrain->GetVerticesPerSide();
+    m_MapSize = cmp->GetVerticesPerSide();
 
     m_TextureSize = (GLsizei)round_up_to_pow2(round_up((size_t)m_MapSize + g_BlurSize - 1, g_SubTextureAlignment));
@@ -295 +293 @@
         //     onto texcoord ((mapsize-0.5) / texsize, (mapsize-0.5) / texsize)  (i.e. middle of last texel)
 
-        float s = (m_MapSize-1) / (float)(m_TextureSize * (m_MapSize-1) * TERRAIN_TILE_SIZE);
+        float s = (m_MapSize-1) / (float)(m_TextureSize * (m_MapSize-1) * _TILE_SIZE);
         float t = 0.5f / m_TextureSize;
         m_TextureMatrix.SetZero();
@@ -321 +319 @@
     if (m_Texture)
     {
-        CmpPtr<ICmpTerrain> cmpTerrain(m_Simulation, SYSTEM_ENTITY);
-        if (cmpTerrain && m_MapSize != (ssize_t)cmpTerrain->GetVerticesPerSide())
+        CmpPtr<ICmp(m_Simulation, SYSTEM_ENTITY);
+        if (->GetVerticesPerSide())
             DeleteTexture();
     }

ps/trunk/source/graphics/LOSTexture.h

@@ -100 +100 @@
     CShaderTechniquePtr m_smoothShader;
 
-    ssize_t m_MapSize; // vertexes per side
+    size_t m_MapSize; // vertexes per side
     GLsizei m_TextureSize; // texels per side
 

ps/trunk/source/simulation2/components/CCmpProjectileManager.cpp

@@ -363 +363 @@
 {
     // Don't display objects outside the visible area
-    ssize_t posi = (ssize_t)(0.5f + position.X / TERRAIN_TILE_SIZE);
-    ssize_t posj = (ssize_t)(0.5f + position.Z / TERRAIN_TILE_SIZE);
+    ssize_t posi = (ssize_t)(0.5f + position.X / _TILE_SIZE);
+    ssize_t posj = (ssize_t)(0.5f + position.Z / _TILE_SIZE);
     if (!losRevealAll && !los.IsVisible(posi, posj))
         return;

ps/trunk/source/simulation2/components/CCmpRallyPointRenderer.cpp

@@ -817 +817 @@
     // a new one at the next point.
 
-    const float terrainSize = static_cast<float>(TERRAIN_TILE_SIZE);
+    const float _TILE_SIZE);
     bool lastVisible = losQuerier.IsExplored(
-        (fixed::FromFloat(m_Path[index][0].X / terrainSize)).ToInt_RoundToNearest(),
-        (fixed::FromFloat(m_Path[index][0].Y / terrainSize)).ToInt_RoundToNearest()
+        (fixed::FromFloat(m_Path[index][0].X / Size)).ToInt_RoundToNearest(),
+        (fixed::FromFloat(m_Path[index][0].Y / Size)).ToInt_RoundToNearest()
     );
     // Starting node index of the current segment
@@ -828 +828 @@
     {
         // Grab tile indices for this coord
-        int i = (fixed::FromFloat(m_Path[index][k].X / terrainSize)).ToInt_RoundToNearest();
-        int j = (fixed::FromFloat(m_Path[index][k].Y / terrainSize)).ToInt_RoundToNearest();
+        int i = (fixed::FromFloat(m_Path[index][k].X / Size)).ToInt_RoundToNearest();
+        int j = (fixed::FromFloat(m_Path[index][k].Y / Size)).ToInt_RoundToNearest();
 
         bool nodeVisible = losQuerier.IsExplored(i, j);

ps/trunk/source/simulation2/components/CCmpRangeManager.cpp

@@ -46 +46 @@
 #include "renderer/Scene.h"
 
-#define LOS_TILES_RATIO 8
 #define DEBUG_RANGE_MANAGER_BOUNDS 0
 
+
 
 /**
@@ -114 +114 @@
 
 /**
- * Test whether the visibility is dirty for a given LoS tile and a given player
+ * Test whether the visibility is dirty for a given LoS  and a given player
  */
 static inline bool IsVisibilityDirty(u16 dirty, player_id_t player)
@@ -382 +382 @@
     static const player_id_t MAX_LOS_PLAYER_ID = 16;
 
-    using LosTile = std::pair<u16, u16>;
+    using Los = std::pair<u16, u16>;
 
     std::array<bool, MAX_LOS_PLAYER_ID+2> m_LosRevealAll;
     bool m_LosCircular;
-    i32 m_TerrainVerticesPerSide;
+    i32 m_VerticesPerSide;
 
     // Cache for visibility tracking
-    i32 m_LosTilesPerSide;
+    i32 m_LossPerSide;
     bool m_GlobalVisibilityUpdate;
     std::array<bool, MAX_LOS_PLAYER_ID> m_GlobalPlayerVisibilityUpdate;
     Grid<u16> m_DirtyVisibility;
-    Grid<std::set<entity_id_t>> m_LosTiles;
+    Grid<std::set<entity_id_t>> m_Loss;
     // List of entities that must be updated, regardless of the status of their tile
     std::vector<entity_id_t> m_ModifiedEntities;
@@ -448 +448 @@
 
         m_LosCircular = false;
-        m_TerrainVerticesPerSide = 0;
+        m_VerticesPerSide = 0;
     }
 
@@ -469 +469 @@
         Serializer(serialize, "los reveal all", m_LosRevealAll);
         serialize.Bool("los circular", m_LosCircular);
-        serialize.NumberI32_Unbounded("terrain verts per side", m_TerrainVerticesPerSide);
+        serialize.NumberI32_Unbounded("VerticesPerSide);
 
         serialize.Bool("global visibility update", m_GlobalVisibilityUpdate);
@@ -476 +476 @@
         Serializer(serialize, "modified entities", m_ModifiedEntities);
 
-        // We don't serialize m_Subdivision, m_LosPlayerCounts or m_LosTiles
+        // We don't serialize m_Subdivision, m_LosPlayerCounts or m_Loss
         // since they can be recomputed from the entity data when deserializing;
         // m_LosState must be serialized since it depends on the history of exploration
@@ -571 +571 @@
                     else
                         LosMove(it->second.owner, it->second.visionRange, from, to);
-                    LosTile oldLosTile = PosToLosTilesHelper(it->second.x, it->second.z);
-                    LosTile newLosTile = PosToLosTilesHelper(msgData.x, msgData.z);
-                    if (oldLosTile != newLosTile)
+                    LossHelper(it->second.x, it->second.z);
+                    LossHelper(msgData.x, msgData.z);
+                    if (oldLos)
                     {
-                        RemoveFromTile(oldLosTile, ent);
-          ��             AddToTile(newLosTile, ent);
+                        RemoveFrom, ent);
+                        AddTo, ent);
                     }
                 }
@@ -587 +587 @@
                     else
                         LosAdd(it->second.owner, it->second.visionRange, to);
-                    AddToTile(PosToLosTilesHelper(msgData.x, msgData.z), ent);
+                    AddTosHelper(msgData.x, msgData.z), ent);
                 }
 
@@ -604 +604 @@
                     else
                         LosRemove(it->second.owner, it->second.visionRange, from);
-                    RemoveFromTile(PosToLosTilesHelper(it->second.x, it->second.z), ent);
+                    RemoveFromsHelper(it->second.x, it->second.z), ent);
                 }
 
@@ -664 +664 @@
             {
                 m_Subdivision.Remove(ent, CFixedVector2D(it->second.x, it->second.z), it->second.size);
-                RemoveFromTile(PosToLosTilesHelper(it->second.x, it->second.z), ent);
+                RemoveFromsHelper(it->second.x, it->second.z), ent);
             }
 
@@ -770 +770 @@
     }
 
-    virtual void SetBounds(entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, ssize_t vertices)
-    {
+    virtual void SetBounds(entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1)
+    {
+        // Don't support rectangular looking maps.
+        ENSURE(x1-x0 == z1-z0);
         m_WorldX0 = x0;
         m_WorldZ0 = z0;
         m_WorldX1 = x1;
         m_WorldZ1 = z1;
-        m_TerrainVerticesPerSide = (i32)vertices;
+        m_;
 
         ResetDerivedData();
@@ -793 +795 @@
         Grid<u32> oldStateRevealed = m_LosStateRevealed;
         FastSpatialSubdivision oldSubdivision = m_Subdivision;
-        Grid<std::set<entity_id_t> > oldLosTiles = m_LosTiles;
+        Grid<std::set<entity_id_t> > oldLoss;
 
         m_Deserializing = true;
@@ -827 +829 @@
         if (oldSubdivision != m_Subdivision)
             debug_warn(L"inconsistent subdivs");
-        if (oldLosTiles != m_LosTiles)
-            debug_warn(L"inconsistent los tiles");
+        if (oldLoss)
+            debug_warn(L"inconsistent los s");
     }
 
@@ -842 +844 @@
         ResetSubdivisions(m_WorldX1, m_WorldZ1);
 
-        m_LosTilesPerSide = (m_TerrainVerticesPerSide - 1)/LOS_TILES_RATIO;
+        m_Los_RATIO;
 
         for (size_t player_id = 0; player_id < m_LosPlayerCounts.size(); ++player_id)
@@ -853 +855 @@
         {
             // recalc current exploration stats.
-            for (i32 j = 0; j < m_TerrainVerticesPerSide; j++)
-                for (i32 i = 0; i < m_TerrainVerticesPerSide; i++)
+            for (i32 j = 0; j < m_VerticesPerSide; j++)
+                for (i32 i = 0; i < m_VerticesPerSide; i++)
                     if (!LosIsOffWorld(i, j))
                         for (u8 k = 1; k < MAX_LOS_PLAYER_ID+1; ++k)
                             m_ExploredVertices.at(k) += ((m_LosState.get(i, j) & ((u32)LosState::EXPLORED << (2*(k-1)))) > 0);
         } else
-            m_LosState.resize(m_TerrainVerticesPerSide, m_TerrainVerticesPerSide);
-
-        m_LosStateRevealed.resize(m_TerrainVerticesPerSide, m_TerrainVerticesPerSide);
+            m_LosState.resize(m_VerticesPerSide);
+
+        m_LosStateRevealed.resize(m_VerticesPerSide);
 
         if (!m_Deserializing)
         {
-            m_DirtyVisibility.resize(m_LosTilesPerSide, m_LosTilesPerSide);
-        }
-        ENSURE(m_DirtyVisibility.width() == m_LosTilesPerSide);
-        ENSURE(m_DirtyVisibility.height() == m_LosTilesPerSide);
-
-        m_LosTiles.resize(m_LosTilesPerSide, m_LosTilesPerSide);
+            m_DirtyVisibility.resize(m_LossPerSide);
+        }
+        ENSURE(m_DirtyVisibility.width() == m_LossPerSide);
+        ENSURE(m_DirtyVisibility.height() == m_LossPerSide);
+
+        m_LossPerSide);
 
         for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
@@ -879 +881 @@
                 else
                     LosAdd(it->second.owner, it->second.visionRange, CFixedVector2D(it->second.x, it->second.z));
-                AddToTile(PosToLosTilesHelper(it->second.x, it->second.z), it->first);
+                AddTosHelper(it->second.x, it->second.z), it->first);
 
                 if (it->second.HasFlag<FlagMasks::RevealShore>())
@@ -886 +888 @@
 
         m_TotalInworldVertices = 0;
-        for (ssize_t j = 0; j < m_TerrainVerticesPerSide; ++j)
-            for (ssize_t i = 0; i < m_TerrainVerticesPerSide; ++i)
+        for (VerticesPerSide; ++j)
+            for (VerticesPerSide; ++i)
             {
                 if (LosIsOffWorld(i,j))
@@ -1601 +1603 @@
     {
         if (GetLosRevealAll(player))
-            return CLosQuerier(0xFFFFFFFFu, m_LosStateRevealed, m_TerrainVerticesPerSide);
+            return CLosQuerier(0xFFFFFFFFu, m_LosStateRevealed, m_VerticesPerSide);
         else
-            return CLosQuerier(GetSharedLosMask(player), m_LosState, m_TerrainVerticesPerSide);
+            return CLosQuerier(GetSharedLosMask(player), m_LosState, m_VerticesPerSide);
     }
 
@@ -1628 +1630 @@
 
         CFixedVector2D pos = cmpPosition->GetPosition2D();
-        int i = (pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
-        int j = (pos.Y / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
+        int i = (pos.X / _TILE_SIZE).ToInt_RoundToNearest();
+        int j = (pos.Y / _TILE_SIZE).ToInt_RoundToNearest();
 
         // Reveal flag makes all positioned entities visible and all mirages useless
@@ -1640 +1642 @@
 
         // Get visible regions
-        CLosQuerier los(GetSharedLosMask(player), m_LosState, m_TerrainVerticesPerSide);
+        CLosQuerier los(GetSharedLosMask(player), m_LosState, m_VerticesPerSide);
 
         CmpPtr<ICmpVisibility> cmpVisibility(ent);
@@ -1734 +1736 @@
         CFixedVector2D pos = cmpPosition->GetPosition2D();
 
-        if (IsVisibilityDirty(m_DirtyVisibility[PosToLosTilesHelper(pos.X, pos.Y)], player))
+        if (IsVisibilityDirty(m_DirtyVisibility[PosToLossHelper(pos.X, pos.Y)], player))
             return ComputeLosVisibility(ent, player);
 
@@ -1755 +1757 @@
     virtual LosVisibility GetLosVisibilityPosition(entity_pos_t x, entity_pos_t z, player_id_t player) const
     {
-        int i = (x / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
-        int j = (z / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
+        int i = (x / _TILE_SIZE).ToInt_RoundToNearest();
+        int j = (z / _TILE_SIZE).ToInt_RoundToNearest();
 
         // Reveal flag makes all positioned entities visible and all mirages useless
@@ -1768 +1770 @@
 
         // Get visible regions
-        CLosQuerier los(GetSharedLosMask(player), m_LosState, m_TerrainVerticesPerSide);
+        CLosQuerier los(GetSharedLosMask(player), m_LosState, m_VerticesPerSide);
 
         if (los.IsVisible(i,j))
@@ -1777 +1779 @@
     }
 
-    LosTile PosToLosTilesHelper(u16 x, u16 z) const
-    {
-        return LosTile{ Clamp(x/LOS_TILES_RATIO, 0, m_LosTilesPerSide - 1), Clamp(z/LOS_TILES_RATIO, 0, m_LosTilesPerSide - 1) };
-    }
-
-    LosTile PosToLosTilesHelper(entity_pos_t x, entity_pos_t z) const
-    {
-        i32 i = Clamp(
-            (x/(entity_pos_t::FromInt(TERRAIN_TILE_SIZE * LOS_TILES_RATIO))).ToInt_RoundToZero(),
+    size_t GetVerticesPerSide() const
+    {
+        return m_LosVerticesPerSide;
+    }
+
+    LosRegion LosVertexToLosRegionsHelper(u16 x, u16 z) const
+    {
+        return LosRegion {
+            Clamp(x/LOS_REGION_RATIO, 0, m_LosRegionsPerSide - 1),
+            Clamp(z/LOS_REGION_RATIO, 0, m_LosRegionsPerSide - 1)
+        };
+    }
+
+    LosRegion PosToLosRegionsHelper(entity_pos_t x, entity_pos_t z) const
+    {
+        u16 i = Clamp(
+            ((x/LOS_TILE_SIZE)/LOS_REGION_RATIO).ToInt_RoundToZero(),
             0,
-            m_LosTilesPerSide - 1);
-        i32 j = Clamp(
-            (z/(entity_pos_t::FromInt(TERRAIN_TILE_SIZE * LOS_TILES_RATIO))).ToInt_RoundToZero(),
+            m_LossPerSide - 1);
+         j = Clamp(
+            ().ToInt_RoundToZero(),
             0,
-            m_LosTilesPerSide - 1);
+            m_LossPerSide - 1);
         return std::make_pair(i, j);
     }
 
-    void AddToTile(LosTile tile, entity_id_t ent)
-    {
-        m_LosTiles[tile].insert(ent);
-    }
-
-    void RemoveFromTile(LosTile tile, entity_id_t ent)
-    {
-        std::set<entity_id_t>::const_iterator tileIt = m_LosTiles[tile].find(ent);
-        if (tileIt != m_LosTiles[tile].end())
-            m_LosTiles[tile].erase(tileIt);
+    void AddTo, entity_id_t ent)
+    {
+        m_Los].insert(ent);
+    }
+
+    void RemoveFrom, entity_id_t ent)
+    {
+        std::set<entity_id_t>::const_iterator ].find(ent);
+        if (].end())
+            m_LosIt);
     }
 
@@ -1811 +1821 @@
         PROFILE("UpdateVisibilityData");
 
-        for (u16 i = 0; i < m_LosTilesPerSide; ++i)
-            for (u16 j = 0; j < m_LosTilesPerSide; ++j)
-            {
-                LosTile pos{i, j};
+        for (u16 i = 0; i < m_LossPerSide; ++i)
+            for (u16 j = 0; j < m_LossPerSide; ++j)
+            {
+                Los pos{i, j};
                 for (player_id_t player = 1; player < MAX_LOS_PLAYER_ID + 1; ++player)
                     if (IsVisibilityDirty(m_DirtyVisibility[pos], player) || m_GlobalPlayerVisibilityUpdate[player-1] == 1 || m_GlobalVisibilityUpdate)
-                        for (const entity_id_t& ent : m_LosTiles[pos])
+                        for (const entity_id_t& ent : m_Loss[pos])
                             UpdateVisibility(ent, player);
 
@@ -1937 +1947 @@
     }
 
-    void ExploreAllTiles(player_id_t p)
-    {
-        for (u16 j = 0; j < m_TerrainVerticesPerSide; ++j)
-            for (u16 i = 0; i < m_TerrainVerticesPerSide; ++i)
+    void Explore(player_id_t p)
+    {
+        for (VerticesPerSide; ++j)
+            for (VerticesPerSide; ++i)
             {
                 if (LosIsOffWorld(i,j))
@@ -1960 +1970 @@
 
         // Territory data is stored per territory-tile (typically a multiple of terrain-tiles).
-        // LOS data is stored per terrain-tile vertex.
+        // LOS data is stored per los vertex (in reality tiles too, but it's the center that matters).
+        // This scales from LOS coordinates to Territory coordinates.
+        auto scale = [](i32 coord) -> i32 {
+            return (coord * LOS_TILE_SIZE + LOS_TILE_SIZE / 2) / (ICmpTerritoryManager::NAVCELLS_PER_TERRITORY_TILE * Pathfinding::NAVCELL_SIZE_INT);
+        };
 
         // For each territory-tile, if it is owned by a valid player then update the LOS
         // for every vertex inside/around that tile, to mark them as explored.
-
-        // Currently this code doesn't support territory-tiles smaller than terrain-tiles
-        // (it will get scale==0 and break), or a non-integer multiple, so check that first
-        cassert(ICmpTerritoryManager::NAVCELLS_PER_TERRITORY_TILE >= Pathfinding::NAVCELLS_PER_TILE);
-        cassert(ICmpTerritoryManager::NAVCELLS_PER_TERRITORY_TILE % Pathfinding::NAVCELLS_PER_TILE == 0);
-
-        int scale = ICmpTerritoryManager::NAVCELLS_PER_TERRITORY_TILE / Pathfinding::NAVCELLS_PER_TILE;
-
-        ENSURE(grid.m_W*scale == m_TerrainVerticesPerSide-1 && grid.m_H*scale == m_TerrainVerticesPerSide-1);
-
-        for (u16 j = 0; j < grid.m_H; ++j)
-            for (u16 i = 0; i < grid.m_W; ++i)
-            {
-                u8 p = grid.get(i, j) & ICmpTerritoryManager::TERRITORY_PLAYER_MASK;
+        for (i32 j = 0; j < m_LosVerticesPerSide; ++j)
+            for (i32 i = 0; i < m_LosVerticesPerSide; ++i)
+            {
+                // TODO: This fetches data redundantly if the los grid is smaller than the territory grid
+                // (but it's unlikely to matter much).
+                u8 p = grid.get(scale(i), scale(j)) & ICmpTerritoryManager::TERRITORY_PLAYER_MASK;
                 if (p > 0 && p <= MAX_LOS_PLAYER_ID)
                 {
                     u32& explored = m_ExploredVertices.at(p);
-                    for (int tj = j * scale; tj <= (j+1) * scale; ++tj)
-                        for (int ti = i * scale; ti <= (i+1) * scale; ++ti)
-                        {
-                            if (LosIsOffWorld(ti, tj))
-                                continue;
-
-                            u32& losState = m_LosState.get(ti, tj);
-                            if (!(losState & ((u32)LosState::EXPLORED << (2*(p-1)))))
-                            {
-                                ++explored;
-                                losState |= ((u32)LosState::EXPLORED << (2*(p-1)));
-                            }
-                        }
+
+                    if (LosIsOffWorld(i, j))
+                        continue;
+
+                    u32& losState = m_LosState.get(i, j);
+                    if (!(losState & ((u32)LosState::EXPLORED << (2*(p-1)))))
+                    {
+                        ++explored;
+                        losState |= ((u32)LosState::EXPLORED << (2*(p-1)));
+                    }
                 }
             }
@@ -2022 +2025 @@
 
             CFixedVector2D pos = cmpPosition->GetPosition2D();
-            int i = (pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
-            int j = (pos.Y / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
-
-            CLosQuerier los(GetSharedLosMask(p), m_LosState, m_TerrainVerticesPerSide);
+            int i = (pos.X / _TILE_SIZE).ToInt_RoundToNearest();
+            int j = (pos.Y / _TILE_SIZE).ToInt_RoundToNearest();
+
+            CLosQuerier los(GetSharedLosMask(p), m_LosState, m_VerticesPerSide);
             if (!los.IsExplored(i,j) || los.IsVisible(i,j))
                 continue;
@@ -2052 +2055 @@
         CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
         const Grid<u16>& shoreGrid = cmpPathfinder->ComputeShoreGrid(true);
-        ENSURE(shoreGrid.m_W == m_TerrainVerticesPerSide-1 && shoreGrid.m_H == m_TerrainVerticesPerSide-1);
+        ENSURE(shoreGrid.m_W == m_VerticesPerSide-1);
 
         Grid<u16>& counts = m_LosPlayerCounts.at(p);
@@ -2082 +2085 @@
             // With a circular map, vertex is off-world if hypot(i - size/2, j - size/2) >= size/2:
 
-            ssize_t dist2 = (i - m_TerrainVerticesPerSide/2)*(i - m_TerrainVerticesPerSide/2)
-                    + (j - m_TerrainVerticesPerSide/2)*(j - m_TerrainVerticesPerSide/2);
-
-            ssize_t r = m_TerrainVerticesPerSide / 2 - MAP_EDGE_TILES + 1;
+            ssize_t dist2 = (i - m_VerticesPerSide/2)
+                    + (j - m_VerticesPerSide/2);
+
+            ssize_t r = m_VerticesPerSide / 2 - MAP_EDGE_TILES + 1;
                 // subtract a bit from the radius to ensure nice
                 // SoD blurring around the edges of the map
@@ -2096 +2099 @@
             // so the SoD texture blends out nicely
             return i < MAP_EDGE_TILES || j < MAP_EDGE_TILES ||
-                i >= m_TerrainVerticesPerSide - MAP_EDGE_TILES ||
-                j >= m_TerrainVerticesPerSide - MAP_EDGE_TILES;
+                i >= m_VerticesPerSide - MAP_EDGE_TILES ||
+                j >= m_VerticesPerSide - MAP_EDGE_TILES;
         }
     }
@@ -2159 +2162 @@
             return;
 
-        // Mark the LoS tiles around the updated vertex
+        // Mark the LoS s around the updated vertex
         // 1: left-up, 2: right-up, 3: left-down, 4: right-down
-        LosTile n1 = PosToLosTilesHelper(i-1, j-1);
-        LosTile n2 = PosToLosTilesHelper(i-1, j);
-        LosTile n3 = PosToLosTilesHelper(i, j-1);
-        LosTile n4 = PosToLosTilesHelper(i, j);
+        LossHelper(i-1, j-1);
+        LossHelper(i-1, j);
+        LossHelper(i, j-1);
+        LossHelper(i, j);
 
         u16 sharedDirtyVisibilityMask = m_SharedDirtyVisibilityMasks[owner];
@@ -2170 +2173 @@
         if (j > 0 && i > 0)
             m_DirtyVisibility[n1] |= sharedDirtyVisibilityMask;
-        if (n2 != n1 && j > 0 && i < m_TerrainVerticesPerSide)
+        if (n2 != n1 && j > 0 && i < m_VerticesPerSide)
             m_DirtyVisibility[n2] |= sharedDirtyVisibilityMask;
-        if (n3 != n1 && j < m_TerrainVerticesPerSide && i > 0)
+        if (n3 != n1 && j < m_VerticesPerSide && i > 0)
             m_DirtyVisibility[n3] |= sharedDirtyVisibilityMask;
-        if (n4 != n1 && j < m_TerrainVerticesPerSide && i < m_TerrainVerticesPerSide)
+        if (n4 != n1 && j < m_VerticesPerSide)
             m_DirtyVisibility[n4] |= sharedDirtyVisibilityMask;
     }
@@ -2186 +2189 @@
     void LosUpdateHelper(u8 owner, entity_pos_t visionRange, CFixedVector2D pos)
     {
-        if (m_TerrainVerticesPerSide == 0) // do nothing if not initialised yet
+        if (m_VerticesPerSide == 0) // do nothing if not initialised yet
             return;
 
@@ -2195 +2198 @@
         // Lazy initialisation of counts:
         if (counts.blank())
-            counts.resize(m_TerrainVerticesPerSide, m_TerrainVerticesPerSide);
+            counts.resize(m_VerticesPerSide);
 
         // Compute the circular region as a series of strips.
@@ -2208 +2211 @@
         // Compute top/bottom coordinates, and clamp to exclude the 1-tile border around the map
         // (so that we never render the sharp edge of the map)
-        i32 j0 = ((pos.Y - visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToInfinity();
-        i32 j1 = ((pos.Y + visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity();
+        i32 j0 = ((pos.Y - visionRange)/_TILE_SIZE).ToInt_RoundToInfinity();
+        i32 j1 = ((pos.Y + visionRange)/_TILE_SIZE).ToInt_RoundToNegInfinity();
         i32 j0clamp = std::max(j0, 1);
-        i32 j1clamp = std::min(j1, m_TerrainVerticesPerSide-2);
+        i32 j1clamp = std::min(j1, m_VerticesPerSide-2);
 
         // Translate world coordinates into fractional tile-space coordinates
-        entity_pos_t x = pos.X / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t y = pos.Y / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t r = visionRange / (int)TERRAIN_TILE_SIZE;
+        entity_pos_t x = pos.X / _TILE_SIZE;
+        entity_pos_t y = pos.Y / _TILE_SIZE;
+        entity_pos_t r = visionRange / _TILE_SIZE;
         entity_pos_t r2 = r.Square();
 
@@ -2258 +2261 @@
             // then add or remove the strip as requested
             i32 i0clamp = std::max(i0, 1);
-            i32 i1clamp = std::min(i1, m_TerrainVerticesPerSide-2);
+            i32 i1clamp = std::min(i1, m_VerticesPerSide-2);
             if (adding)
                 LosAddStripHelper(owner, i0clamp, i1clamp, j, counts);
@@ -2273 +2276 @@
     void LosUpdateHelperIncremental(u8 owner, entity_pos_t visionRange, CFixedVector2D from, CFixedVector2D to)
     {
-        if (m_TerrainVerticesPerSide == 0) // do nothing if not initialised yet
+        if (m_VerticesPerSide == 0) // do nothing if not initialised yet
             return;
 
@@ -2282 +2285 @@
         // Lazy initialisation of counts:
         if (counts.blank())
-            counts.resize(m_TerrainVerticesPerSide, m_TerrainVerticesPerSide);
+            counts.resize(m_VerticesPerSide);
 
         // See comments in LosUpdateHelper.
@@ -2291 +2294 @@
         // and only have to touch tiles that have a net change.)
 
-        i32 j0_from = ((from.Y - visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToInfinity();
-        i32 j1_from = ((from.Y + visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity();
-        i32 j0_to = ((to.Y - visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToInfinity();
-        i32 j1_to = ((to.Y + visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity();
+        i32 j0_from = ((from.Y - visionRange)/_TILE_SIZE).ToInt_RoundToInfinity();
+        i32 j1_from = ((from.Y + visionRange)/_TILE_SIZE).ToInt_RoundToNegInfinity();
+        i32 j0_to = ((to.Y - visionRange)/_TILE_SIZE).ToInt_RoundToInfinity();
+        i32 j1_to = ((to.Y + visionRange)/_TILE_SIZE).ToInt_RoundToNegInfinity();
         i32 j0clamp = std::max(std::min(j0_from, j0_to), 1);
-        i32 j1clamp = std::min(std::max(j1_from, j1_to), m_TerrainVerticesPerSide-2);
-
-        entity_pos_t x_from = from.X / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t y_from = from.Y / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t x_to = to.X / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t y_to = to.Y / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t r = visionRange / (int)TERRAIN_TILE_SIZE;
+        i32 j1clamp = std::min(std::max(j1_from, j1_to), m_VerticesPerSide-2);
+
+        entity_pos_t x_from = from.X / _TILE_SIZE;
+        entity_pos_t y_from = from.Y / _TILE_SIZE;
+        entity_pos_t x_to = to.X / _TILE_SIZE;
+        entity_pos_t y_to = to.Y / _TILE_SIZE;
+        entity_pos_t r = visionRange / _TILE_SIZE;
         entity_pos_t r2 = r.Square();
 
@@ -2360 +2363 @@
             {
                 i32 i0clamp_from = std::max(i0_from, 1);
-                i32 i1clamp_from = std::min(i1_from, m_TerrainVerticesPerSide-2);
+                i32 i1clamp_from = std::min(i1_from, m_VerticesPerSide-2);
                 i32 i0clamp_to = std::max(i0_to, 1);
-                i32 i1clamp_to = std::min(i1_to, m_TerrainVerticesPerSide-2);
+                i32 i1clamp_to = std::min(i1_to, m_VerticesPerSide-2);
 
                 // Check whether one strip is negative width,
@@ -2466 +2469 @@
         std::vector<player_id_t>::const_iterator playerIt;
 
-        for (i32 j = 0; j < m_TerrainVerticesPerSide; j++)
-            for (i32 i = 0; i < m_TerrainVerticesPerSide; i++)
+        for (i32 j = 0; j < m_VerticesPerSide; j++)
+            for (i32 i = 0; i < m_VerticesPerSide; i++)
             {
                 if (LosIsOffWorld(i, j))
@@ -2485 +2488 @@
 
 REGISTER_COMPONENT_TYPE(RangeManager)
-
-#undef LOS_TILES_RATIO
-#undef DEBUG_RANGE_MANAGER_BOUNDS

ps/trunk/source/simulation2/components/CCmpTerrain.cpp

@@ -140 +140 @@
             cmpRangeManager->SetBounds(entity_pos_t::Zero(), entity_pos_t::Zero(),
                     entity_pos_t::FromInt(tiles*(int)TERRAIN_TILE_SIZE),
-                    entity_pos_t::FromInt(tiles*(int)TERRAIN_TILE_SIZE),
-                    vertices);
+                    entity_pos_t::FromInt(tiles*(int)TERRAIN_TILE_SIZE));
         }
 

ps/trunk/source/simulation2/components/ICmpRangeManager.cpp

@@ -61 +61 @@
 DEFINE_INTERFACE_METHOD_CONST_0("GetGaiaAndNonGaiaEntities", std::vector<entity_id_t>, ICmpRangeManager, GetGaiaAndNonGaiaEntities)
 DEFINE_INTERFACE_METHOD_1("SetDebugOverlay", void, ICmpRangeManager, SetDebugOverlay, bool)
-DEFINE_INTERFACE_METHOD_1("ExploreAllTiles", void, ICmpRangeManager, ExploreAllTiles, player_id_t)
+DEFINE_INTERFACE_METHOD_1("Explore, player_id_t)
 DEFINE_INTERFACE_METHOD_0("ExploreTerritories", void, ICmpRangeManager, ExploreTerritories)
 DEFINE_INTERFACE_METHOD_2("SetLosRevealAll", void, ICmpRangeManager, SetLosRevealAll, player_id_t, bool)

ps/trunk/source/simulation2/components/ICmpRangeManager.h

@@ -107 +107 @@
      * Entities should not be outside the bounds (else efficiency will suffer).
      * @param x0,z0,x1,z1 Coordinates of the corners of the world
-     * @param vertices Number of terrain vertices per side
-     */
-    virtual void SetBounds(entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, ssize_t vertices) = 0;
+     */
+    virtual void SetBounds(entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1) = 0;
 
     /**
@@ -298 +297 @@
 
     /**
-     * Explore all tiles (but leave them in the FoW) for player p
-     */
-    virtual void ExploreAllTiles(player_id_t p) = 0;
+     * Explore  in the FoW) for player p
+     */
+    virtual void Explore(player_id_t p) = 0;
 
     /**
@@ -358 +357 @@
     virtual u8 GetUnionPercentMapExplored(const std::vector<player_id_t>& players) const = 0;
 
+
+
+
+
 
     /**

ps/trunk/source/simulation2/components/tests/test_RangeManager.h

@@ -144 +144 @@
         // in various edge cases
 
-        cmp->SetBounds(entity_pos_t::FromInt(0), entity_pos_t::FromInt(0), entity_pos_t::FromInt(512), entity_pos_t::FromInt(512), 512/TERRAIN_TILE_SIZE + 1);
+        cmp->SetBounds(entity_pos_t::FromInt(0), entity_pos_t::FromInt(0), entity_pos_t::FromInt(512), entity_pos_t::FromInt(512));
         cmp->Verify();
         { CMessageCreate msg(100); cmp->HandleMessage(msg, false); }
@@ -215 +215 @@
         test.AddMock(101, IID_Obstruction, obs2);
 
-        cmp->SetBounds(entity_pos_t::FromInt(0), entity_pos_t::FromInt(0), entity_pos_t::FromInt(512), entity_pos_t::FromInt(512), 512/TERRAIN_TILE_SIZE + 1);
+        cmp->SetBounds(entity_pos_t::FromInt(0), entity_pos_t::FromInt(0), entity_pos_t::FromInt(512), entity_pos_t::FromInt(512));
         cmp->Verify();
         { CMessageCreate msg(100); cmp->HandleMessage(msg, false); }

ps/trunk/source/simulation2/helpers/Los.h

@@ -22 +22 @@
 // since files must include "Los.h" explicitly, and that's only done in .cpp files.
 #include "Grid.h"
+
+
+
+
+
+
+
 
 enum class LosState : u8