Ticket #2022: Territory_Memfrag.patch

source/simulation2/helpers/Grid.h

@@ -80 +80 @@
             memset(m_Data, 0, m_W*m_H*sizeof(T));
     }
 
-    void set(int i, int j, const T& value)
+    void set(const int i, const int j, const T& value)
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
 #endif
         m_Data[j*m_W + i] = value;
     }
+    
+    void add(const int i, const int j, T val) 
+    {
+#if GRID_BOUNDS_DEBUG
+        ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
+#endif
+        m_Data[j*m_W + i] += val;
+    }
+    void getPtr(const int i, const int j) 
+    {
+#if GRID_BOUNDS_DEBUG
+        ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
+#endif
+        return m_Data[j*m_W + i];
+    }
 
-    T& get(int i, int j) const
+    T& get(const int i, const int j) const
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
@@ -113 +128 @@
 
     enum { BucketBits = 4, BucketSize = 1 << BucketBits };
 
-    T* GetBucket(int i, int j)
+    T* GetBucket(const int i, const int j)
     {
-        size_t b = (j >> BucketBits) * m_BW + (i >> BucketBits);
+        const size_t b = (j >> BucketBits) * m_BW + (i >> BucketBits);
         if (!m_Data[b])
         {
-            m_Data[b] = new T[BucketSize*BucketSize];
+            if (m_Reserve.empty())
+            {               
+                m_Data[b] = new T[BucketSize*BucketSize];
+            }
+            else
+            {
+                m_Data[b] = m_Reserve.back();
+                m_Reserve.pop_back();
+            }
             memset(m_Data[b], 0, BucketSize*BucketSize*sizeof(T));
         }
         return m_Data[b];
@@ -134 +157 @@
 
         m_Data = new T*[m_BW*m_BH];
         memset(m_Data, 0, m_BW*m_BH*sizeof(T*));
+
     }
 
     ~SparseGrid()
     {
-        reset();
+        //reset();
+        for (size_t i = 0; i < (size_t)(m_BW*m_BH); ++i)
+            delete[] m_Data[i];
         delete[] m_Data;
     }
 
     void reset()
     {
         for (size_t i = 0; i < (size_t)(m_BW*m_BH); ++i)
-            delete[] m_Data[i];
+        {           
+            if (m_Data[i])
+            {
+                m_Reserve.push_back(m_Data[i]);
+            }
+        }
 
         memset(m_Data, 0, m_BW*m_BH*sizeof(T*));
     }
 
-    void set(int i, int j, const T& value)
+    void set(const int i, const int j, const T& value)
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
@@ -158 +189 @@
         GetBucket(i, j)[(j % BucketSize)*BucketSize + (i % BucketSize)] = value;
     }
 
-    T& get(int i, int j)
+    T& get(const int i, const int j)
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
@@ -169 +200 @@
     u16 m_W, m_H;
     u16 m_BW, m_BH;
     T** m_Data;
+    std::deque < T* > m_Reserve;
 
     size_t m_DirtyID; // if this is < the id maintained by ICmpObstructionManager then it needs to be updated
 };

source/simulation2/components/CCmpTerritoryManager.cpp

@@ -56 +56 @@
 
     TerritoryOverlay(CCmpTerritoryManager& manager);
     virtual void StartRender();
-    virtual void ProcessTile(ssize_t i, ssize_t j);
+    virtual void ProcessTile(const ssize_t i, const ssize_t j);
 };
 
 class CCmpTerritoryManager : public ICmpTerritoryManager
@@ -88 +88 @@
     // connected flag in bit 6 (TERRITORY_CONNECTED_MASK);
     // processed flag in bit 7 (TERRITORY_PROCESSED_MASK)
     Grid<u8>* m_Territories;
+    Grid<u8>* m_Territories_Data;
+    Grid<u8>* m_InfluenceGrid;
 
+    u16 m_TilesW;
+    u16 m_TilesH;
+    // For each player, store the sum of influences on each tile
+    std::vector<std::pair<player_id_t, Grid<u32>* > > playerGrids;
+
+    std::map<player_id_t, std::vector<entity_id_t> > influenceEntities;
+    std::vector<entity_id_t> rootInfluenceEntities;
+
+    std::vector<std::pair<u16, u16> > tileStack;
+
+    std::deque<Grid<u32>* > grid32Pool;
+
     // Set to true when territories change; will send a TerritoriesChanged message
     // during the Update phase
     bool m_TriggerEvent;
@@ -113 +127 @@
     virtual void Init(const CParamNode& UNUSED(paramNode))
     {
         m_Territories = NULL;
+        m_Territories_Data = NULL;
+        m_InfluenceGrid = NULL;
         m_DebugOverlay = NULL;
 //      m_DebugOverlay = new TerritoryOverlay(*this);
         m_BoundaryLinesDirty = true;
@@ -120 +136 @@
         m_EnableLineDebugOverlays = false;
         m_DirtyID = 1;
 
+        m_TilesW = 0;
+        m_TilesH = 0;
         m_AnimTime = 0.0;
 
         CParamNode externalParamNode;
@@ -134 +152 @@
 
     virtual void Deinit()
     {
-        SAFE_DELETE(m_Territories);
+        SAFE_DELETE(m_Territories_Data);
+        SAFE_DELETE(m_InfluenceGrid);
         SAFE_DELETE(m_DebugOverlay);
+        for(std::deque<Grid<u32>* >::iterator it = grid32Pool.begin(); it != grid32Pool.end(); ++it )
+            delete *it;
     }
-
+    Grid<u32>* getPooledGrid32()
+    {
+        if (grid32Pool.empty())
+        {
+            return new Grid<u32>(m_TilesW, m_TilesH);
+        }
+        Grid<u32>* ret = grid32Pool.back();
+        grid32Pool.pop_back();
+        ret->reset();
+        return ret;
+    }
+    void returnPooledGrid32(Grid<u32>* ret)
+    {
+        grid32Pool.push_back(ret);
+    }
     virtual void Serialize(ISerializer& UNUSED(serialize))
     {
         // Territory state can be recomputed as required, so we don't need to serialize any of it.
@@ -233 +268 @@
 
     void MakeDirty()
     {
-        SAFE_DELETE(m_Territories);
+        m_Territories = NULL;
         ++m_DirtyID;
         m_BoundaryLinesDirty = true;
         m_TriggerEvent = true;
@@ -256 +291 @@
      * a TerritoryInfluence component. Grid cells are 0 if no influence,
      * or 1+c if the influence have cost c (assumed between 0 and 254).
      */
-    void RasteriseInfluences(CComponentManager::InterfaceList& infls, Grid<u8>& grid);
+    void RasteriseInfluences(const CComponentManager::InterfaceList& infls, Grid<u8>& grid);
 
     std::vector<STerritoryBoundary> ComputeBoundaries();
 
@@ -279 +314 @@
 
 typedef PriorityQueueHeap<std::pair<u16, u16>, u32, std::greater<u32> > OpenQueue;
 
-static void ProcessNeighbour(u32 falloff, u16 i, u16 j, u32 pg, bool diagonal,
+static void ProcessNeighbour(const u32 falloff, const u16 i, const u16 j, const u32 pg, bool diagonal,
         Grid<u32>& grid, OpenQueue& queue, const Grid<u8>& costGrid)
 {
     u32 dg = falloff * costGrid.get(i, j);
@@ -291 +326 @@
     if (pg <= grid.get(i, j) + dg)
         return;
 
-    u32 g = pg - dg; // cost to this tile = cost to predecessor - falloff from predecessor
+    const u32 g = pg - dg; // cost to this tile = cost to predecessor - falloff from predecessor
 
     grid.set(i, j, g);
     OpenQueue::Item tile = { std::make_pair(i, j), g };
     queue.push(tile);
 }
 
-static void FloodFill(Grid<u32>& grid, Grid<u8>& costGrid, OpenQueue& openTiles, u32 falloff)
+static void FloodFill(Grid<u32>& grid, Grid<u8>& costGrid, OpenQueue& openTiles, const u32 falloff)
 {
-    u16 tilesW = grid.m_W;
-    u16 tilesH = grid.m_H;
+    const u16 tilesW = grid.m_W;
+    const u16 tilesH = grid.m_H;
 
     while (!openTiles.empty())
     {
         OpenQueue::Item tile = openTiles.pop();
 
         // Process neighbours (if they're not off the edge of the map)
-        u16 x = tile.id.first;
-        u16 z = tile.id.second;
-        if (x > 0)
+        const u16 x = tile.id.first;
+        const u16 z = tile.id.second;
             ProcessNeighbour(falloff, (u16)(x-1), z, tile.rank, false, grid, openTiles, costGrid);
-        if (x < tilesW-1)
+        if (x < tilesW-1){
             ProcessNeighbour(falloff, (u16)(x+1), z, tile.rank, false, grid, openTiles, costGrid);
-        if (z > 0)
+            ProcessNeighbour(falloff, (u16)(x+1), (u16)(z-1), tile.rank, true, grid, openTiles, costGrid);
+        }
             ProcessNeighbour(falloff, x, (u16)(z-1), tile.rank, false, grid, openTiles, costGrid);
-        if (z < tilesH-1)
+        if (z < tilesH-1){
             ProcessNeighbour(falloff, x, (u16)(z+1), tile.rank, false, grid, openTiles, costGrid);
-        if (x > 0 && z > 0)
+            ProcessNeighbour(falloff, (u16)(x-1), (u16)(z+1), tile.rank, true, grid, openTiles, costGrid);
+        }
             ProcessNeighbour(falloff, (u16)(x-1), (u16)(z-1), tile.rank, true, grid, openTiles, costGrid);
-        if (x > 0 && z < tilesH-1)
-            ProcessNeighbour(falloff, (u16)(x-1), (u16)(z+1), tile.rank, true, grid, openTiles, costGrid);
-        if (x < tilesW-1 && z > 0)
-            ProcessNeighbour(falloff, (u16)(x+1), (u16)(z-1), tile.rank, true, grid, openTiles, costGrid);
+        
         if (x < tilesW-1 && z < tilesH-1)
             ProcessNeighbour(falloff, (u16)(x+1), (u16)(z+1), tile.rank, true, grid, openTiles, costGrid);
     }
@@ -343 +376 @@
     if (!cmpTerrain->IsLoaded())
         return;
 
-    u16 tilesW = cmpTerrain->GetTilesPerSide();
-    u16 tilesH = cmpTerrain->GetTilesPerSide();
+    const u16 tilesW = cmpTerrain->GetTilesPerSide();
+    const u16 tilesH = cmpTerrain->GetTilesPerSide();
+    
+    if (!m_Territories_Data)
+    { 
+        m_TilesW = tilesW;
+        m_TilesH = tilesH;
+        m_Territories_Data = new Grid<u8>(tilesW, tilesH);
+    }
+    ENSURE(m_TilesW == tilesW);
+    ENSURE(m_TilesH == tilesH);
+    
+    const u32 gridSize = tilesH * tilesW;
 
-    m_Territories = new Grid<u8>(tilesW, tilesH);
+    m_Territories = m_Territories_Data;
+    m_Territories->reset();
 
     // Compute terrain-passability-dependent costs per tile
-    Grid<u8> influenceGrid(tilesW, tilesH);
+    if (!m_InfluenceGrid)
+        m_InfluenceGrid = new Grid<u8>(tilesW, tilesH);
+    Grid<u8>* influenceGrid = m_InfluenceGrid;
+    influenceGrid->reset();
 
     CmpPtr<ICmpPathfinder> cmpPathfinder(GetSimContext(), SYSTEM_ENTITY);
-    ICmpPathfinder::pass_class_t passClassDefault = cmpPathfinder->GetPassabilityClass("default");
-    ICmpPathfinder::pass_class_t passClassUnrestricted = cmpPathfinder->GetPassabilityClass("unrestricted");
+    const ICmpPathfinder::pass_class_t passClassDefault = cmpPathfinder->GetPassabilityClass("default");
+    const ICmpPathfinder::pass_class_t passClassUnrestricted = cmpPathfinder->GetPassabilityClass("unrestricted");
 
     const Grid<u16>& passGrid = cmpPathfinder->GetPassabilityGrid();
-    for (u16 j = 0; j < tilesH; ++j)
     {
-        for (u16 i = 0; i < tilesW; ++i)
+        u8* const __restrict inflgridData = influenceGrid->m_Data;
+        const u16* const __restrict passgridData = passGrid.m_Data;
+        for (u32 k = 0; k < gridSize; ++k)
         {
-            u16 g = passGrid.get(i, j);
+            const u16 g = passgridData[k];
             u8 cost;
             if (g & passClassUnrestricted)
                 cost = 255; // off the world; use maximum cost
@@ -368 +417 @@
                 cost = m_ImpassableCost;
             else
                 cost = 1;
-            influenceGrid.set(i, j, cost);
+            inflgridData[k] = cost;
         }
     }
 
@@ -376 +425 @@
     CComponentManager::InterfaceList influences = GetSimContext().GetComponentManager().GetEntitiesWithInterface(IID_TerritoryInfluence);
 
     // Allow influence entities to override the terrain costs
-    RasteriseInfluences(influences, influenceGrid);
+    RasteriseInfluences(influences, *influenceGrid);
 
     // Split influence entities into per-player lists, ignoring any with invalid properties
-    std::map<player_id_t, std::vector<entity_id_t> > influenceEntities;
-    std::vector<entity_id_t> rootInfluenceEntities;
-    for (CComponentManager::InterfaceList::iterator it = influences.begin(); it != influences.end(); ++it)
+    influenceEntities.clear();
+    rootInfluenceEntities.clear();
+    const CComponentManager::InterfaceList::const_iterator itiEnd = influences.end();
+    for (CComponentManager::InterfaceList::const_iterator it = influences.begin(); it != itiEnd; ++it)
     {
         // Ignore any with no weight or radius (to avoid divide-by-zero later)
         ICmpTerritoryInfluence* cmpTerritoryInfluence = static_cast<ICmpTerritoryInfluence*>(it->second);
@@ -393 +443 @@
             continue;
 
         // Ignore Gaia and unassigned
-        player_id_t owner = cmpOwnership->GetOwner();
+        const player_id_t owner = cmpOwnership->GetOwner();
         if (owner <= 0)
             continue;
 
@@ -412 +462 @@
             rootInfluenceEntities.push_back(it->first);
     }
 
-    // For each player, store the sum of influences on each tile
-    std::vector<std::pair<player_id_t, Grid<u32> > > playerGrids;
+    playerGrids.clear();
     // TODO: this is a large waste of memory; we don't really need to store
     // all the intermediate grids
 
-    for (std::map<player_id_t, std::vector<entity_id_t> >::iterator it = influenceEntities.begin(); it != influenceEntities.end(); ++it)
+
+    OpenQueue openTiles;
+    Grid<u32>* entityGrid = getPooledGrid32();
+    const std::map<player_id_t, std::vector<entity_id_t> >::iterator itieEnd = influenceEntities.end();
+    for (std::map<player_id_t, std::vector<entity_id_t> >::iterator it = influenceEntities.begin(); it != itieEnd; ++it)
     {
-        Grid<u32> playerGrid(tilesW, tilesH);
+        Grid<u32>* playerGrid = getPooledGrid32();
 
-        std::vector<entity_id_t>& ents = it->second;
-        for (std::vector<entity_id_t>::iterator eit = ents.begin(); eit != ents.end(); ++eit)
+        const std::vector<entity_id_t>& ents = it->second;
+        const std::vector<entity_id_t>::const_iterator eitEnd = ents.end();     
+        for (std::vector<entity_id_t>::const_iterator eit = ents.begin(); eit != eitEnd; ++eit)
         {
             // Compute the influence map of the current entity, then add it to the player grid
+            entityGrid->reset();
 
-            Grid<u32> entityGrid(tilesW, tilesH);
+            {
+                CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), *eit);
+                const CFixedVector2D pos = cmpPosition->GetPosition2D();
+                const u16 i = (u16)clamp((pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesW-1);
+                const u16 j = (u16)clamp((pos.Y / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesH-1);
 
-            CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), *eit);
-            CFixedVector2D pos = cmpPosition->GetPosition2D();
-            u16 i = (u16)clamp((pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesW-1);
-            u16 j = (u16)clamp((pos.Y / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesH-1);
+                CmpPtr<ICmpTerritoryInfluence> cmpTerritoryInfluence(GetSimContext(), *eit);
+                const u32 weight = cmpTerritoryInfluence->GetWeight();
+                const u32 radius = cmpTerritoryInfluence->GetRadius() / TERRAIN_TILE_SIZE;
+                const u32 falloff = weight / radius; // earlier check for GetRadius() == 0 prevents divide-by-zero
 
-            CmpPtr<ICmpTerritoryInfluence> cmpTerritoryInfluence(GetSimContext(), *eit);
-            u32 weight = cmpTerritoryInfluence->GetWeight();
-            u32 radius = cmpTerritoryInfluence->GetRadius() / TERRAIN_TILE_SIZE;
-            u32 falloff = weight / radius; // earlier check for GetRadius() == 0 prevents divide-by-zero
+                // TODO: we should have some maximum value on weight, to avoid overflow
+                // when doing all the sums
 
-            // TODO: we should have some maximum value on weight, to avoid overflow
-            // when doing all the sums
+                // Initialise the tile under the entity
+                entityGrid->set(i, j, weight);
+                OpenQueue::Item tile = { std::make_pair(i, j), weight };
+                openTiles.push(tile);
 
-            // Initialise the tile under the entity
-            entityGrid.set(i, j, weight);
-            OpenQueue openTiles;
-            OpenQueue::Item tile = { std::make_pair((u16)i, (i16)j), weight };
-            openTiles.push(tile);
-
-            // Expand influences outwards
-            FloodFill(entityGrid, influenceGrid, openTiles, falloff);
-
+                // Expand influences outwards
+                FloodFill(*entityGrid, *influenceGrid, openTiles, falloff);
+            }
             // TODO: we should do a sparse grid and only add the non-zero regions, for performance
-            for (u16 j = 0; j < entityGrid.m_H; ++j)
-                for (u16 i = 0; i < entityGrid.m_W; ++i)
-                    playerGrid.set(i, j, playerGrid.get(i, j) + entityGrid.get(i, j));
+            const u32* const __restrict eData = entityGrid->m_Data;
+            u32* const __restrict pData = playerGrid->m_Data;
+            for(u32 k = 0; k < gridSize; k++)
+                pData[k] += eData[k];
         }
 
         playerGrids.push_back(std::make_pair(it->first, playerGrid));
@@ -467 +521 @@
             u32 bestWeight = 0;
             for (size_t k = 0; k < playerGrids.size(); ++k)
             {
-                u32 w = playerGrids[k].second.get(i, j);
+                u32 w = playerGrids[k].second->get(i, j);
                 if (w > bestWeight)
                 {
-                    player_id_t id = playerGrids[k].first;
+                    const player_id_t id = playerGrids[k].first;
                     m_Territories->set(i, j, (u8)id);
                     bestWeight = w;
                 }
@@ -479 +533 @@
     }
 
     // Detect territories connected to a 'root' influence (typically a civ center)
-    // belonging to their player, and mark them with the connected flag
-    for (std::vector<entity_id_t>::iterator it = rootInfluenceEntities.begin(); it != rootInfluenceEntities.end(); ++it)
+    // belonging to their player, and mark them with the connected flag, 
+
+    Grid<u8>& grid = *m_Territories;
+    const u16 maxi = (u16)(grid.m_W-1);
+    const u16 maxj = (u16)(grid.m_H-1);
+    std::vector<entity_id_t>::const_iterator itrEnd = rootInfluenceEntities.end();
+    for (std::vector<entity_id_t>::const_iterator it = rootInfluenceEntities.begin(); it != itrEnd; ++it)
     {
         // (These components must be valid else the entities wouldn't be added to this list)
         CmpPtr<ICmpOwnership> cmpOwnership(GetSimContext(), *it);
         CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), *it);
 
-        CFixedVector2D pos = cmpPosition->GetPosition2D();
-        u16 i = (u16)clamp((pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesW-1);
-        u16 j = (u16)clamp((pos.Y / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesH-1);
+        const CFixedVector2D pos = cmpPosition->GetPosition2D();
+        const u16 i = (u16)clamp((pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesW-1);
+        const u16 j = (u16)clamp((pos.Y / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesH-1);
 
-        u8 owner = (u8)cmpOwnership->GetOwner();
+        const u8 owner = (u8)cmpOwnership->GetOwner();
 
-        if (m_Territories->get(i, j) != owner)
+        if (grid.get(i, j) != owner)
             continue;
 
         // TODO: would be nice to refactor some of the many flood fill
         // algorithms in this component
-
-        Grid<u8>& grid = *m_Territories;
-
-        u16 maxi = (u16)(grid.m_W-1);
-        u16 maxj = (u16)(grid.m_H-1);
-
-        std::vector<std::pair<u16, u16> > tileStack;
-
 #define MARK_AND_PUSH(i, j) STMT(grid.set(i, j, owner | TERRITORY_CONNECTED_MASK); tileStack.push_back(std::make_pair(i, j)); )
 
         MARK_AND_PUSH(i, j);
         while (!tileStack.empty())
         {
-            int ti = tileStack.back().first;
-            int tj = tileStack.back().second;
+            const u16 ti = tileStack.back().first;
+            const u16 tj = tileStack.back().second;
             tileStack.pop_back();
 
             if (ti > 0 && grid.get(ti-1, tj) == owner)
@@ -540 +591 @@
 /**
  * Compute the tile indexes on the grid nearest to a given point
  */
-static void NearestTile(entity_pos_t x, entity_pos_t z, u16& i, u16& j, u16 w, u16 h)
+static void NearestTile(const entity_pos_t x, const entity_pos_t z, u16& i, u16& j, const u16 w, const u16 h)
 {
     i = (u16)clamp((x / (int)TERRAIN_TILE_SIZE).ToInt_RoundToZero(), 0, w-1);
     j = (u16)clamp((z / (int)TERRAIN_TILE_SIZE).ToInt_RoundToZero(), 0, h-1);
@@ -549 +600 @@
 /**
  * Returns the position of the center of the given tile
  */
-static void TileCenter(u16 i, u16 j, entity_pos_t& x, entity_pos_t& z)
+static void TileCenter(const u16 i, const u16 j, entity_pos_t& x, entity_pos_t& z)
 {
     x = entity_pos_t::FromInt(i*(int)TERRAIN_TILE_SIZE + (int)TERRAIN_TILE_SIZE/2);
     z = entity_pos_t::FromInt(j*(int)TERRAIN_TILE_SIZE + (int)TERRAIN_TILE_SIZE/2);
@@ -558 +609 @@
 // TODO: would be nice not to duplicate those two functions from CCmpObstructionManager.cpp
 
 
-void CCmpTerritoryManager::RasteriseInfluences(CComponentManager::InterfaceList& infls, Grid<u8>& grid)
+void CCmpTerritoryManager::RasteriseInfluences(const CComponentManager::InterfaceList& infls, Grid<u8>& grid)
 {
-    for (CComponentManager::InterfaceList::iterator it = infls.begin(); it != infls.end(); ++it)
+    
+    const CComponentManager::InterfaceList::const_iterator itEnd = infls.end();
+    for (CComponentManager::InterfaceList::const_iterator it = infls.begin(); it != itEnd; ++it)
     {
         ICmpTerritoryInfluence* cmpTerritoryInfluence = static_cast<ICmpTerritoryInfluence*>(it->second);
 
-        i32 cost = cmpTerritoryInfluence->GetCost();
+        const i32 cost = cmpTerritoryInfluence->GetCost();
         if (cost == -1)
             continue;
 
@@ -576 +629 @@
         if (!cmpObstruction->GetObstructionSquare(square))
             continue;
 
-        CFixedVector2D halfSize(square.hw, square.hh);
-        CFixedVector2D halfBound = Geometry::GetHalfBoundingBox(square.u, square.v, halfSize);
+        const CFixedVector2D halfSize(square.hw, square.hh);
+        const CFixedVector2D halfBound = Geometry::GetHalfBoundingBox(square.u, square.v, halfSize);
 
         u16 i0, j0, i1, j1;
         NearestTile(square.x - halfBound.X, square.z - halfBound.Y, i0, j0, grid.m_W, grid.m_H);
@@ -691 +744 @@
         m_BoundaryLinesDirty = false;
     }
 
-    for (size_t i = 0; i < m_BoundaryLines.size(); ++i)
+    const float alpha = 0.2f + 0.8f * fabsf((float)cos(m_AnimTime * M_PI));// TODO: should let artists tweak this
+    const std::vector<SBoundaryLine>::iterator itEnd = m_BoundaryLines.end();
+    for (std::vector<SBoundaryLine>::iterator it = m_BoundaryLines.begin(); it != itEnd; ++it)
     {
-        if (!m_BoundaryLines[i].connected)
+        SBoundaryLine& boundaryline = *it;
+        if (!boundaryline.connected)
         {
-            CColor c = m_BoundaryLines[i].color;
-            c.a *= 0.2f + 0.8f * fabsf((float)cos(m_AnimTime * M_PI)); // TODO: should let artists tweak this
-            m_BoundaryLines[i].overlay.m_Color = c;
+            CColor c (boundaryline.color);
+            c.a *= alpha; 
+            boundaryline.overlay.m_Color = c;
         }
     }
 }
 
 void CCmpTerritoryManager::RenderSubmit(SceneCollector& collector)
 {
-    for (size_t i = 0; i < m_BoundaryLines.size(); ++i)
-        collector.Submit(&m_BoundaryLines[i].overlay);
-    
-    for (size_t i = 0; i < m_DebugBoundaryLineNodes.size(); ++i)
-        collector.Submit(&m_DebugBoundaryLineNodes[i]);
+    {
+        const std::vector<SBoundaryLine>::iterator itEnd = m_BoundaryLines.end();
+        for (std::vector<SBoundaryLine>::iterator it = m_BoundaryLines.begin(); 
+             it != itEnd; ++it)
+        {
+            SBoundaryLine& boundaryline = *it;
+            collector.Submit(&boundaryline.overlay);
+        }
+    }
 
+    {
+        const std::vector<SOverlayLine>::iterator itEnd = m_DebugBoundaryLineNodes.end();
+        for (std::vector<SOverlayLine>::iterator it = m_DebugBoundaryLineNodes.begin(); 
+             it != itEnd; ++it)
+        {
+            SOverlayLine& overlayLine = *it;
+            collector.Submit(&overlayLine);
+        }
+    }
 }
 
 player_id_t CCmpTerritoryManager::GetOwner(entity_pos_t x, entity_pos_t z)
 {
-    u16 i, j;
     CalculateTerritories();
     if (!m_Territories)
         return 0;
 
+    u16 i, j;
     NearestTile(x, z, i, j, m_Territories->m_W, m_Territories->m_H);
     return m_Territories->get(i, j) & TERRITORY_PLAYER_MASK;
 }
 
 bool CCmpTerritoryManager::IsConnected(entity_pos_t x, entity_pos_t z)
 {
-    u16 i, j;
     CalculateTerritories();
     if (!m_Territories)
         return false;
 
+    u16 i, j;
     NearestTile(x, z, i, j, m_Territories->m_W, m_Territories->m_H);
     return (m_Territories->get(i, j) & TERRITORY_CONNECTED_MASK) != 0;
 }
@@ -743 +812 @@
     m_TerritoryManager.CalculateTerritories();
 }
 
-void TerritoryOverlay::ProcessTile(ssize_t i, ssize_t j)
+void TerritoryOverlay::ProcessTile(const ssize_t i, const ssize_t j)
 {
     if (!m_TerritoryManager.m_Territories)
         return;
 
-    u8 id = (m_TerritoryManager.m_Territories->get((int) i, (int) j) & ICmpTerritoryManager::TERRITORY_PLAYER_MASK);
+    const u8 id = (m_TerritoryManager.m_Territories->get((int) i, (int) j) & ICmpTerritoryManager::TERRITORY_PLAYER_MASK);
 
-    float a = 0.2f;
+    const float a = 0.2f;
     switch (id)
     {
     case 0:  break;
@@ -762 +831 @@
     case 6:  RenderTile(CColor(1, 0, 1, a), false); break;
     default: RenderTile(CColor(1, 1, 1, a), false); break;
     }
-}
+}
+ No newline at end of file