Ticket #1707: RangeManagerEntityMap.patch

lib/ps_stl.h

@@ +1 @@
+/* Copyright (c) 2013 Wildfire Games
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef INCLUDED_PS_STL
+#define INCLUDED_PS_STL
+
+/**
+ * @author Jorma Rebane
+ * @note Pyrogenesis STL methods
+ * @note This file contains useful and optimized methods for use with STL
+ */
+
+namespace ps 
+{
+    /**
+     * Removes the first occurrence of the specified value from the container.
+     * @param container The STL-compatible container to remove from.
+     * @param value The value to remove.
+     */
+template<class Container, class T>
+    inline void remove_first_occurrence(Container& container, const T& value)
+    {
+        if (int count = container.size())
+        {
+            T* data = &container[0];
+            for (int i = 0; i < count; ++i)
+            {
+                if (data[i] == value)
+                {
+                    container.erase(container.begin() + i);
+                    return;
+                }
+            }
+        }
+    }
+
+    /**
+     * @param container The STL-compatible container to search in.
+     * @param value The value to search for.
+     * @return TRUE if [value] exists in [container].
+     */
+template<class Container, class T>
+    inline bool exists_in(const Container& container, const T& value)
+    {
+        if (int count = container.size())
+        {
+            for (const T* data = &container[0]; count; ++data, --count)
+            {
+                if (*data == value)
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Finds a value in a container
+     * @param container The STL-compatible container to search in.
+     * @param value The value to search for.
+     * @return Pointer to the value if found, NULL if not found.
+     */
+template<class Container, class T>
+    inline T* find_in(const Container& container, const T& value)
+    {
+        if (int count = container.size())
+        {
+            for (const T* data = &container[0]; count; ++data, --count)
+            {
+                if (*data == value)
+                {
+                    return (T*)data;
+                }
+            }
+        }
+        return NULL;
+    }
+
+
+} // namespace ps
+
+#endif // INCLUDED_PS_STL
+ No newline at end of file

simulation2/components/CCmpObstructionManager.cpp

@@ -124 +124 @@
     bool m_DebugOverlayDirty;
     std::vector<SOverlayLine> m_DebugOverlayLines;
 
-    SpatialSubdivision<u32> m_UnitSubdivision;
-    SpatialSubdivision<u32> m_StaticSubdivision;
+    SpatialSubdivision m_UnitSubdivision;
+    SpatialSubdivision m_StaticSubdivision;
 
     // TODO: using std::map is a bit inefficient; is there a better way to store these?
     std::map<u32, UnitShape> m_UnitShapes;
@@ -161 +161 @@
 
         // Initialise with bogus values (these will get replaced when
         // SetBounds is called)
-        ResetSubdivisions(entity_pos_t::FromInt(1), entity_pos_t::FromInt(1));
+        ResetSubdivisions(entity_pos_t::FromInt(1024), entity_pos_t::FromInt(1024));
     }
 
     virtual void Deinit()
@@ -171 +171 @@
     template<typename S>
     void SerializeCommon(S& serialize)
     {
-        SerializeSpatialSubdivision<SerializeU32_Unbounded>()(serialize, "unit subdiv", m_UnitSubdivision);
-        SerializeSpatialSubdivision<SerializeU32_Unbounded>()(serialize, "static subdiv", m_StaticSubdivision);
+        SerializeSpatialSubdivision()(serialize, "unit subdiv", m_UnitSubdivision);
+        SerializeSpatialSubdivision()(serialize, "static subdiv", m_StaticSubdivision);
 
         SerializeMap<SerializeU32_Unbounded, SerializeUnitShape>()(serialize, "unit shapes", m_UnitShapes);
         SerializeMap<SerializeU32_Unbounded, SerializeStaticShape>()(serialize, "static shapes", m_StaticShapes);
@@ -544 +544 @@
     CFixedVector2D posMin (std::min(x0, x1) - r, std::min(z0, z1) - r);
     CFixedVector2D posMax (std::max(x0, x1) + r, std::max(z0, z1) + r);
 
-    std::vector<u32> unitShapes = m_UnitSubdivision.GetInRange(posMin, posMax);
-    for (size_t i = 0; i < unitShapes.size(); ++i)
+    SpatialQueryArray unitShapes;
+    m_UnitSubdivision.GetInRange(unitShapes, posMin, posMax);
+    for (int i = 0; i < unitShapes.size(); ++i)
     {
         std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(unitShapes[i]);
         ENSURE(it != m_UnitShapes.end());
@@ -559 +560 @@
             return true;
     }
 
-    std::vector<u32> staticShapes = m_StaticSubdivision.GetInRange(posMin, posMax);
-    for (size_t i = 0; i < staticShapes.size(); ++i)
+    SpatialQueryArray staticShapes;
+    m_StaticSubdivision.GetInRange(staticShapes, posMin, posMax);
+    for (int i = 0; i < staticShapes.size(); ++i)
     {
         std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(staticShapes[i]);
         ENSURE(it != m_StaticShapes.end());
@@ -880 +882 @@
 
     ENSURE(x0 <= x1 && z0 <= z1);
 
-    std::vector<u32> unitShapes = m_UnitSubdivision.GetInRange(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
-    for (size_t i = 0; i < unitShapes.size(); ++i)
+    SpatialQueryArray unitShapes;
+    m_UnitSubdivision.GetInRange(unitShapes, CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
+    for (int i = 0; i < unitShapes.size(); ++i)
     {
         std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(unitShapes[i]);
         ENSURE(it != m_UnitShapes.end());
@@ -901 +904 @@
         squares.push_back(s);
     }
 
-    std::vector<u32> staticShapes = m_StaticSubdivision.GetInRange(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
-    for (size_t i = 0; i < staticShapes.size(); ++i)
+    SpatialQueryArray staticShapes;
+    m_StaticSubdivision.GetInRange(staticShapes, CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
+    for (int i = 0; i < staticShapes.size(); ++i)
     {
         std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(staticShapes[i]);
         ENSURE(it != m_StaticShapes.end());

simulation2/components/CCmpRangeManager.cpp

@@ -21 +21 @@
 #include "ICmpRangeManager.h"
 
 #include "ICmpTerrain.h"
+#include "simulation2/system/EntityMap.h"
 #include "simulation2/MessageTypes.h"
 #include "simulation2/components/ICmpPosition.h"
 #include "simulation2/components/ICmpTerritoryManager.h"
@@ -37 +38 @@
 #include "ps/Overlay.h"
 #include "ps/Profile.h"
 #include "renderer/Scene.h"
+#include "lib/ps_stl.h"
 
+
 #define DEBUG_RANGE_MANAGER_BOUNDS 0
 
 /**
@@ -61 +64 @@
  * Convert an owner ID (-1 = unowned, 0 = gaia, 1..30 = players)
  * into a 32-bit mask for quick set-membership tests.
  */
-static u32 CalcOwnerMask(player_id_t owner)
+static inline u32 CalcOwnerMask(player_id_t owner)
 {
     if (owner >= -1 && owner < 31)
         return 1 << (1+owner);
@@ -72 +75 @@
 /**
  * Returns LOS mask for given player.
  */
-static u32 CalcPlayerLosMask(player_id_t player)
+static inline u32 CalcPlayerLosMask(player_id_t player)
 {
     if (player > 0 && player <= 16)
         return ICmpRangeManager::LOS_MASK << (2*(player-1));
@@ -210 +213 @@
  */
 struct EntityDistanceOrdering
 {
-    EntityDistanceOrdering(const std::map<entity_id_t, EntityData>& entities, const CFixedVector2D& source) :
+    EntityDistanceOrdering(const EntityMap<EntityData>& entities, const CFixedVector2D& source) :
         m_EntityData(entities), m_Source(source)
     {
     }
@@ -224 +227 @@
         return (vecA.CompareLength(vecB) < 0);
     }
 
-    const std::map<entity_id_t, EntityData>& m_EntityData;
+    const EntityMap<EntityData>& m_EntityData;
     CFixedVector2D m_Source;
 
 private:
@@ -271 +274 @@
     // Range query state:
     tag_t m_QueryNext; // next allocated id
     std::map<tag_t, Query> m_Queries;
-    std::map<entity_id_t, EntityData> m_EntityData;
-    SpatialSubdivision<entity_id_t> m_Subdivision; // spatial index of m_EntityData
+    EntityMap<EntityData> m_EntityData;
 
+    SpatialSubdivision m_Subdivision; // spatial index of m_EntityData
+
     // LOS state:
 
     std::map<player_id_t, bool> m_LosRevealAll;
@@ -319 +323 @@
 
         // Initialise with bogus values (these will get replaced when
         // SetBounds is called)
-        ResetSubdivisions(entity_pos_t::FromInt(1), entity_pos_t::FromInt(1));
+        ResetSubdivisions(entity_pos_t::FromInt(1024), entity_pos_t::FromInt(1024));
 
         // The whole map should be visible to Gaia by default, else e.g. animals
         // will get confused when trying to run from enemies
@@ -349 +353 @@
 
         serialize.NumberU32_Unbounded("query next", m_QueryNext);
         SerializeMap<SerializeU32_Unbounded, SerializeQuery>()(serialize, "queries", m_Queries, GetSimContext());
-        SerializeMap<SerializeU32_Unbounded, SerializeEntityData>()(serialize, "entity data", m_EntityData);
+        SerializeEntityMap<SerializeEntityData>()(serialize, "entity data", m_EntityData);
 
         SerializeMap<SerializeI32_Unbounded, SerializeBool>()(serialize, "los reveal all", m_LosRevealAll);
         serialize.Bool("los circular", m_LosCircular);
@@ -411 +415 @@
             }
 
             // Remember this entity
-            m_EntityData.insert(std::make_pair(ent, entdata));
-
+            m_EntityData.insert(ent, entdata);
             break;
         }
         case MT_PositionChanged:
@@ -420 +423 @@
             const CMessagePositionChanged& msgData = static_cast<const CMessagePositionChanged&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
+            EntityMap<EntityData>::iterator it = m_EntityData.find(ent);
 
             // Ignore if we're not already tracking this entity
             if (it == m_EntityData.end())
@@ -467 +470 @@
             const CMessageOwnershipChanged& msgData = static_cast<const CMessageOwnershipChanged&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
+            EntityMap<EntityData>::iterator it = m_EntityData.find(ent);
 
             // Ignore if we're not already tracking this entity
             if (it == m_EntityData.end())
@@ -490 +493 @@
             const CMessageDestroy& msgData = static_cast<const CMessageDestroy&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
+            EntityMap<EntityData>::iterator it = m_EntityData.find(ent);
 
             // Ignore if we're not already tracking this entity
             if (it == m_EntityData.end())
@@ -512 +515 @@
             const CMessageVisionRangeChanged& msgData = static_cast<const CMessageVisionRangeChanged&> (msg);
             entity_id_t ent = msgData.entity;
 
-            std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
+            EntityMap<EntityData>::iterator it = m_EntityData.find(ent);
 
             // Ignore if we're not already tracking this entity
             if (it == m_EntityData.end())
@@ -576 +579 @@
 
         std::vector<std::vector<u16> > oldPlayerCounts = m_LosPlayerCounts;
         std::vector<u32> oldStateRevealed = m_LosStateRevealed;
-        SpatialSubdivision<entity_id_t> oldSubdivision = m_Subdivision;
+        SpatialSubdivision oldSubdivision = m_Subdivision;
 
         ResetDerivedData(true);
 
@@ -637 +640 @@
         m_LosStateRevealed.clear();
         m_LosStateRevealed.resize(m_TerrainVerticesPerSide*m_TerrainVerticesPerSide);
 
-        for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+        for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
         {
             if (it->second.inWorld)
                 LosAdd(it->second.owner, it->second.visionRange, CFixedVector2D(it->second.x, it->second.z));
@@ -663 +666 @@
         // (TODO: find the optimal number instead of blindly guessing)
         m_Subdivision.Reset(x1, z1, entity_pos_t::FromInt(8*TERRAIN_TILE_SIZE));
 
-        for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+        for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
         {
             if (it->second.inWorld)
                 m_Subdivision.Add(it->first, CFixedVector2D(it->second.x, it->second.z));
@@ -794 +797 @@
 
         u32 ownerMask = CalcOwnerMask(player);
 
-        for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+        for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
         {
             // Check owner and add to list if it matches
             if (CalcOwnerMask(it->second.owner) & ownerMask)
@@ -822 +825 @@
         // Store a queue of all messages before sending any, so we can assume
         // no entities will move until we've finished checking all the ranges
         std::vector<std::pair<entity_id_t, CMessageRangeUpdate> > messages;
+        std::vector<entity_id_t> results;
+        std::vector<entity_id_t> added;
+        std::vector<entity_id_t> removed;
 
         for (std::map<tag_t, Query>::iterator it = m_Queries.begin(); it != m_Queries.end(); ++it)
         {
-            Query& q = it->second;
+            Query& query = it->second;
 
-            if (!q.enabled)
+            if (!query.enabled)
                 continue;
 
-            CmpPtr<ICmpPosition> cmpSourcePosition(q.source);
+            CmpPtr<ICmpPosition> cmpSourcePosition(query.source);           
             if (!cmpSourcePosition || !cmpSourcePosition->IsInWorld())
                 continue;
 
-            std::vector<entity_id_t> r;
-            r.reserve(q.lastMatch.size());
+            results.clear();
+            results.reserve(query.lastMatch.size());
+            PerformQuery(query, results);
 
-            PerformQuery(q, r);
-
             // Compute the changes vs the last match
-            std::vector<entity_id_t> added;
-            std::vector<entity_id_t> removed;
-            std::set_difference(r.begin(), r.end(), q.lastMatch.begin(), q.lastMatch.end(), std::back_inserter(added));
-            std::set_difference(q.lastMatch.begin(), q.lastMatch.end(), r.begin(), r.end(), std::back_inserter(removed));
+            added.clear();
+            removed.clear();
+            size_t resultsSize = results.size();
+            size_t lastMatchSize = query.lastMatch.size();
 
+            // check results for any new ones:
+            for (size_t i = 0; i < resultsSize; ++i)
+            {
+                entity_id_t entity = results[i];
+                if (ps::exists_in(query.lastMatch, entity) == false)
+                    added.push_back(entity); // not in last matches, so it's NEW
+            }
+            // check last matches for any missing ones:
+            for (size_t i = 0; i < lastMatchSize; ++i)
+            {
+                entity_id_t entity = query.lastMatch[i];
+                if (ps::exists_in(results, entity) == false)
+                    removed.push_back(entity); // not in results, so it's moved out of range
+            }
             if (added.empty() && removed.empty())
                 continue;
 
             // Return the 'added' list sorted by distance from the entity
             // (Don't bother sorting 'removed' because they might not even have positions or exist any more)
-            CFixedVector2D pos = cmpSourcePosition->GetPosition2D();
-            std::stable_sort(added.begin(), added.end(), EntityDistanceOrdering(m_EntityData, pos));
+            if (!added.empty())
+            {
+                CFixedVector2D pos = cmpSourcePosition->GetPosition2D();
+                std::stable_sort(&added[0], &added[0] + added.size(), EntityDistanceOrdering(m_EntityData, pos));
+            }
 
-            messages.push_back(std::make_pair(q.source.GetId(), CMessageRangeUpdate(it->first)));
-            messages.back().second.added.swap(added);
-            messages.back().second.removed.swap(removed);
-
-            it->second.lastMatch.swap(r);
+            messages.resize(messages.size() + 1);
+            std::pair<entity_id_t, CMessageRangeUpdate>& back = messages.back();
+            back.first = query.source.GetId();
+            back.second.tag = it->first;
+            back.second.added.swap(added);
+            back.second.removed.swap(removed);
+            it->second.lastMatch.swap(results);
         }
 
+        CComponentManager& cmpMgr = GetSimContext().GetComponentManager();
         for (size_t i = 0; i < messages.size(); ++i)
-            GetSimContext().GetComponentManager().PostMessage(messages[i].first, messages[i].second);
+            cmpMgr.PostMessage(messages[i].first, messages[i].second);
     }
 
     /**
@@ -905 +930 @@
         // Special case: range -1.0 means check all entities ignoring distance
         if (q.maxRange == entity_pos_t::FromInt(-1))
         {
-            for (std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+            for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
             {
                 if (!TestEntityQuery(q, it->first, it->second))
                     continue;
@@ -920 +945 @@
             CFixedVector3D pos3d = cmpSourcePosition->GetPosition()+
                 CFixedVector3D(entity_pos_t::Zero(), q.elevationBonus, entity_pos_t::Zero()) ;
             // Get a quick list of entities that are potentially in range, with a cutoff of 2*maxRange
-            std::vector<entity_id_t> ents = m_Subdivision.GetNear(pos, q.maxRange*2);
+            SpatialQueryArray ents;
+            m_Subdivision.GetNear(ents, pos, q.maxRange*2);
 
-            for (size_t i = 0; i < ents.size(); ++i)
+            for (int i = 0; i < ents.size(); ++i)
             {
-                std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.find(ents[i]);
+                EntityMap<EntityData>::const_iterator it = m_EntityData.find(ents[i]);
                 ENSURE(it != m_EntityData.end());
 
                 if (!TestEntityQuery(q, it->first, it->second))
@@ -950 +976 @@
                 }
 
                 r.push_back(it->first);
-
             }
         }
         // check a regular range (i.e. not the entire world, and not parabolic)
@@ -957 +982 @@
         else 
         {
             // Get a quick list of entities that are potentially in range
-            std::vector<entity_id_t> ents = m_Subdivision.GetNear(pos, q.maxRange);
-
-            for (size_t i = 0; i < ents.size(); ++i)
+            SpatialQueryArray ents;
+            m_Subdivision.GetNear(ents, pos, q.maxRange);
+            
+            for (int i = 0; i < ents.size(); ++i)
             {
-                std::map<entity_id_t, EntityData>::const_iterator it = m_EntityData.find(ents[i]);
+                EntityMap<EntityData>::const_iterator it = m_EntityData.find(ents[i]);
                 ENSURE(it != m_EntityData.end());
 
                 if (!TestEntityQuery(q, it->first, it->second))
@@ -980 +1006 @@
                 }
 
                 r.push_back(it->first);
-
             }
         }
     }
@@ -1135 +1160 @@
     {
         if (!m_DebugOverlayEnabled)
             return;
-        CColor enabledRingColour(0, 1, 0, 1);
-        CColor disabledRingColour(1, 0, 0, 1);
-        CColor rayColour(1, 1, 0, 0.2f);
+        static CColor disabledRingColour(1, 0, 0, 1);   // red
+        static CColor enabledRingColour(0, 1, 0, 1);    // green
+        static CColor subdivColour(0, 0, 1, 1);         // blue 
+        static CColor rayColour(1, 1, 0, 0.2f);
 
         if (m_DebugOverlayDirty)
         {
@@ -1244 +1270 @@
                 }
             }
 
+            // render subdivision grid
+            float divSize = m_Subdivision.GetDivisionSize().ToFloat();
+            int width = m_Subdivision.GetWidth();
+            int height = m_Subdivision.GetHeight();
+            for (int x = 0; x < width; ++x)
+            {
+                for (int y = 0; y < height; ++y)
+                {
+                    m_DebugOverlayLines.push_back(SOverlayLine());
+                    m_DebugOverlayLines.back().m_Color = subdivColour;
+                    
+                    float xpos = x*divSize + divSize/2;
+                    float zpos = y*divSize + divSize/2;
+                    SimRender::ConstructSquareOnGround(GetSimContext(), xpos, zpos, divSize, divSize, 0.0f,
+                        m_DebugOverlayLines.back(), false, 1.0f);
+                }
+            }
+
             m_DebugOverlayDirty = false;
         }
 
@@ -1264 +1308 @@
 
     virtual void SetEntityFlag(entity_id_t ent, std::string identifier, bool value)
     {
-        std::map<entity_id_t, EntityData>::iterator it = m_EntityData.find(ent);
+        EntityMap<EntityData>::iterator it = m_EntityData.find(ent);
 
         // We don't have this entity
         if (it == m_EntityData.end())

simulation2/helpers/Spatial.h

@@ -21 +21 @@
 #include "simulation2/serialization/SerializeTemplates.h"
 
 /**
+ * A simple fixed-size array that works similar to an std::vector
+ * but is obviously limited in its max items
+ */
+struct SpatialQueryArray
+{
+    enum { MAX_COUNT = 1024 };
+    int count;
+    uint32_t items[MAX_COUNT];
+
+    inline SpatialQueryArray() : count(0) {}
+    inline const uint32_t& operator[](int index) const { return items[index]; }
+    inline uint32_t& operator[](int index) { return items[index]; }
+    inline int size() const { return count; }
+    inline void clear() { count = 0; }
+    void make_unique() // removes any duplicate entries
+    {
+        if (count)
+            count = int(std::unique(items, items + count) - items);
+    }
+};
+
+/**
  * A very basic subdivision scheme for finding items in ranges.
  * Items are stored in lists in fixed-size divisions.
  * Items have a size (min/max values of their axis-aligned bounding box)
@@ -34 +56 @@
  *
  * (TODO: maybe an adaptive quadtree would be better than fixed sizes?)
  */
-template<typename T>
 class SpatialSubdivision
 {
+    struct SubDivisionGrid
+    {
+        std::vector<uint32_t> items;
+
+        inline void push_back(uint32_t value)
+        {
+            items.push_back(value);
+        }
+
+        inline void erase(int index)
+        {
+            // Delete by swapping with the last element then popping
+            if ((int)items.size() > 1) // but only if we have more than 1 elements
+                items[index] = items.back();
+            items.pop_back();
+        }
+
+        void copy_items(SpatialQueryArray& out)
+        {
+            if (items.empty()) 
+                return; // nothing to copy
+
+            int dsti = out.count;               // the index in [out] where to start copying
+            int count = (int)items.size();
+            if ((dsti + count) > SpatialQueryArray::MAX_COUNT)
+                count = SpatialQueryArray::MAX_COUNT - dsti; // silently fail to copy overflowing items
+            uint32_t* dst = &out.items[dsti];
+            uint32_t* src = &items[0];
+            for (int i = 0; i < count; ++i) // copy all items
+                dst[i] = src[i];
+            out.count += count;
+        }
+    };
+
+
+    entity_pos_t m_DivisionSize;
+    SubDivisionGrid* m_Divisions;
+    uint32_t m_DivisionsW;
+    uint32_t m_DivisionsH;
+
+    friend struct SerializeSubDivisionGrid;
+    friend struct SerializeSpatialSubdivision;
+
 public:
-    SpatialSubdivision() :
-        m_DivisionsW(0), m_DivisionsH(0)
+    SpatialSubdivision() : m_Divisions(NULL), m_DivisionsW(0), m_DivisionsH(0)
     {
     }
+    ~SpatialSubdivision()
+    {
+        delete[] m_Divisions;
+    }
+    SpatialSubdivision(const SpatialSubdivision& rhs)
+    {
+        m_DivisionSize = rhs.m_DivisionSize;
+        m_DivisionsW = rhs.m_DivisionsW;
+        m_DivisionsH = rhs.m_DivisionsH;
+        size_t n = m_DivisionsW * m_DivisionsH;
+        m_Divisions = new SubDivisionGrid[n];
+        for (size_t i = 0; i < n; ++i)
+            m_Divisions[i] = rhs.m_Divisions[i]; // just fall back to piecemeal copy
+    }
+    SpatialSubdivision& operator=(const SpatialSubdivision& rhs)
+    {
+        if (this != &rhs)
+        {
+            m_DivisionSize = rhs.m_DivisionSize;
+            size_t n = rhs.m_DivisionsW * rhs.m_DivisionsH;
+            if (m_DivisionsW != rhs.m_DivisionsW || m_DivisionsH != rhs.m_DivisionsH)
+                Create(n); // size changed, recreate
+            
+            m_DivisionsW = rhs.m_DivisionsW;
+            m_DivisionsH = rhs.m_DivisionsH;
+            for (size_t i = 0; i < n; ++i)
+                m_Divisions[i] = rhs.m_Divisions[i]; // just fall back to piecemeal copy
+        }
+        return *this;
+    }
 
+    inline entity_pos_t GetDivisionSize() const { return m_DivisionSize; }
+    inline uint32_t GetWidth() const { return m_DivisionsW; }
+    inline uint32_t GetHeight() const { return m_DivisionsH; }
+
+    void Create(size_t count)
+    {
+        if (m_Divisions) delete[] m_Divisions;
+        m_Divisions = new SubDivisionGrid[count];
+    }
+
     /**
      * Equivalence test (ignoring order of items within each subdivision)
      */
@@ -51 +154 @@
         if (m_DivisionSize != rhs.m_DivisionSize || m_DivisionsW != rhs.m_DivisionsW || m_DivisionsH != rhs.m_DivisionsH)
             return false;
         
-        for (u32 j = 0; j < m_DivisionsH; ++j)
+        uint32_t n = m_DivisionsH * m_DivisionsW;
+        for (uint32_t i = 0; i < n; ++i)
         {
-            for (u32 i = 0; i < m_DivisionsW; ++i)
-            {
-                std::vector<T> div1 = m_Divisions.at(i + j*m_DivisionsW);
-                std::vector<T> div2 = rhs.m_Divisions.at(i + j*m_DivisionsW);
-                std::sort(div1.begin(), div1.end());
-                std::sort(div2.begin(), div2.end());
-                if (div1 != div2)
-                    return false;
-            }
+            if (m_Divisions[i].items.size() != rhs.m_Divisions[i].items.size())
+                return false;
+
+            // don't bother optimizing this, this is only used in the TESTING SUITE
+            std::vector<uint32_t> a = m_Divisions[i].items;
+            std::vector<uint32_t> b = rhs.m_Divisions[i].items;
+            std::sort(a.begin(), a.end());
+            std::sort(b.begin(), b.end());
+            if (a != b)
+                return false;
         }
-
         return true;
     }
 
-    bool operator!=(const SpatialSubdivision& rhs)
+    inline bool operator!=(const SpatialSubdivision& rhs)
     {
         return !(*this == rhs);
     }
@@ -77 +181 @@
         m_DivisionSize = divisionSize;
         m_DivisionsW = (maxX / m_DivisionSize).ToInt_RoundToInfinity();
         m_DivisionsH = (maxZ / m_DivisionSize).ToInt_RoundToInfinity();
-        m_Divisions.clear();
-        m_Divisions.resize(m_DivisionsW * m_DivisionsH);
+
+        Create(m_DivisionsW * m_DivisionsH);
     }
 
+
     /**
      * Add an item with the given 'to' size.
      * The item must not already be present.
      */
-    void Add(T item, CFixedVector2D toMin, CFixedVector2D toMax)
+    void Add(uint32_t item, CFixedVector2D toMin, CFixedVector2D toMax)
     {
         ENSURE(toMin.X <= toMax.X && toMin.Y <= toMax.Y);
 
@@ -97 +202 @@
         {
             for (u32 i = i0; i <= i1; ++i)
             {
-                std::vector<T>& div = m_Divisions.at(i + j*m_DivisionsW);
-                div.push_back(item);
+                m_Divisions[i + j*m_DivisionsW].push_back(item);
             }
         }
     }
@@ -108 +212 @@
      * The item should already be present.
      * The size must match the size that was last used when adding the item.
      */
-    void Remove(T item, CFixedVector2D fromMin, CFixedVector2D fromMax)
+    void Remove(uint32_t item, CFixedVector2D fromMin, CFixedVector2D fromMax)
     {
         ENSURE(fromMin.X <= fromMax.X && fromMin.Y <= fromMax.Y);
 
@@ -120 +224 @@
         {
             for (u32 i = i0; i <= i1; ++i)
             {
-                std::vector<T>& div = m_Divisions.at(i + j*m_DivisionsW);
-
-                for (u32 n = 0; n < div.size(); ++n)
+                SubDivisionGrid& div = m_Divisions[i + j*m_DivisionsW];
+                int size = div.items.size();
+                for (int n = 0; n < size; ++n)
                 {
-                    if (div[n] == item)
+                    if (div.items[n] == item)
                     {
-                        // Delete by swapping with the last element then popping
-                        div[n] = div.back();
-                        div.pop_back();
+                        div.erase(n);
                         break;
                     }
                 }
@@ -139 +241 @@
     /**
      * Equivalent to Remove() then Add(), but potentially faster.
      */
-    void Move(T item, CFixedVector2D fromMin, CFixedVector2D fromMax, CFixedVector2D toMin, CFixedVector2D toMax)
+    void Move(uint32_t item, CFixedVector2D fromMin, CFixedVector2D fromMax, CFixedVector2D toMin, CFixedVector2D toMax)
     {
         // Skip the work if we're staying in the same divisions
         if (GetIndex0(fromMin) == GetIndex0(toMin) && GetIndex1(fromMax) == GetIndex1(toMax))
@@ -153 +255 @@
      * Convenience function for Add() of individual points.
      * (Note that points on a boundary may occupy multiple divisions.)
      */
-    void Add(T item, CFixedVector2D to)
+    void Add(uint32_t item, CFixedVector2D to)
     {
         Add(item, to, to);
     }
@@ -161 +263 @@
     /**
      * Convenience function for Remove() of individual points.
      */
-    void Remove(T item, CFixedVector2D from)
+    void Remove(uint32_t item, CFixedVector2D from)
     {
         Remove(item, from, from);
     }
@@ -169 +271 @@
     /**
      * Convenience function for Move() of individual points.
      */
-    void Move(T item, CFixedVector2D from, CFixedVector2D to)
+    void Move(uint32_t item, CFixedVector2D from, CFixedVector2D to)
     {
         Move(item, from, from, to, to);
     }
@@ -178 +280 @@
      * Returns a sorted list of unique items that includes all items
      * within the given axis-aligned square range.
      */
-    std::vector<T> GetInRange(CFixedVector2D posMin, CFixedVector2D posMax)
+    void GetInRange(SpatialQueryArray& out, CFixedVector2D posMin, CFixedVector2D posMax)
     {
-        std::vector<T> ret;
-
+        out.clear();
         ENSURE(posMin.X <= posMax.X && posMin.Y <= posMax.Y);
 
         u32 i0 = GetI0(posMin.X);
@@ -192 +293 @@
         {
             for (u32 i = i0; i <= i1; ++i)
             {
-                std::vector<T>& div = m_Divisions.at(i + j*m_DivisionsW);
-                ret.insert(ret.end(), div.begin(), div.end());
+                m_Divisions[i + j*m_DivisionsW].copy_items(out);
             }
         }
-
-        // Remove duplicates
-        std::sort(ret.begin(), ret.end());
-        ret.erase(std::unique(ret.begin(), ret.end()), ret.end());
-
-        return ret;
+        // some buildings span several tiles, so we need to make it unique
+        out.make_unique();
     }
 
     /**
@@ -208 +304 @@
      * Returns a sorted list of unique items that includes all items
      * within the given circular distance of the given point.
      */
-    std::vector<T> GetNear(CFixedVector2D pos, entity_pos_t range)
+    void GetNear(SpatialQueryArray& out, CFixedVector2D pos, entity_pos_t range)
     {
         // TODO: be cleverer and return a circular pattern of divisions,
         // not this square over-approximation
-
-        return GetInRange(pos - CFixedVector2D(range, range), pos + CFixedVector2D(range, range));
+        CFixedVector2D r(range, range);
+        GetInRange(out, pos - r, pos + r);
     }
 
 private:
@@ -221 +317 @@
     // (avoiding out-of-bounds accesses, and rounding correctly so that
     // points precisely between divisions are counted in both):
 
-    u32 GetI0(entity_pos_t x)
+    uint32_t GetI0(entity_pos_t x)
     {
         return Clamp((x / m_DivisionSize).ToInt_RoundToInfinity()-1, 0, (int)m_DivisionsW-1);
     }
 
-    u32 GetJ0(entity_pos_t z)
+    uint32_t GetJ0(entity_pos_t z)
     {
         return Clamp((z / m_DivisionSize).ToInt_RoundToInfinity()-1, 0, (int)m_DivisionsH-1);
     }
 
-    u32 GetI1(entity_pos_t x)
+    uint32_t GetI1(entity_pos_t x)
     {
         return Clamp((x / m_DivisionSize).ToInt_RoundToNegInfinity(), 0, (int)m_DivisionsW-1);
     }
 
-    u32 GetJ1(entity_pos_t z)
+    uint32_t GetJ1(entity_pos_t z)
     {
         return Clamp((z / m_DivisionSize).ToInt_RoundToNegInfinity(), 0, (int)m_DivisionsH-1);
     }
 
-    u32 GetIndex0(CFixedVector2D pos)
+    uint32_t GetIndex0(CFixedVector2D pos)
     {
         return GetI0(pos.X) + GetJ0(pos.Y)*m_DivisionsW;
     }
 
-    u32 GetIndex1(CFixedVector2D pos)
+    uint32_t GetIndex1(CFixedVector2D pos)
     {
         return GetI1(pos.X) + GetJ1(pos.Y)*m_DivisionsW;
     }
-
-    entity_pos_t m_DivisionSize;
-    std::vector<std::vector<T> > m_Divisions;
-    u32 m_DivisionsW;
-    u32 m_DivisionsH;
-
-    template<typename ELEM> friend struct SerializeSpatialSubdivision;
 };
 
 /**
  * Serialization helper template for SpatialSubdivision
  */
-template<typename ELEM>
 struct SerializeSpatialSubdivision
 {
-    template<typename T>
-    void operator()(ISerializer& serialize, const char* UNUSED(name), SpatialSubdivision<T>& value)
+    void operator()(ISerializer& serialize, const char* UNUSED(name), SpatialSubdivision& value)
     {
         serialize.NumberFixed_Unbounded("div size", value.m_DivisionSize);
-        SerializeVector<SerializeVector<ELEM> >()(serialize, "divs", value.m_Divisions);
         serialize.NumberU32_Unbounded("divs w", value.m_DivisionsW);
         serialize.NumberU32_Unbounded("divs h", value.m_DivisionsH);
+
+        size_t count = value.m_DivisionsH * value.m_DivisionsW;
+        for (size_t i = 0; i < count; ++i)
+            SerializeVector<SerializeU32_Unbounded>()(serialize, "subdiv items", value.m_Divisions[i].items);
     }
 
-    template<typename T>
-    void operator()(IDeserializer& serialize, const char* UNUSED(name), SpatialSubdivision<T>& value)
+    void operator()(IDeserializer& serialize, const char* UNUSED(name), SpatialSubdivision& value)
     {
         serialize.NumberFixed_Unbounded("div size", value.m_DivisionSize);
-        SerializeVector<SerializeVector<ELEM> >()(serialize, "divs", value.m_Divisions);
+        serialize.NumberU32_Unbounded("divs w", value.m_DivisionsW);
+        serialize.NumberU32_Unbounded("divs h", value.m_DivisionsH);
 
-        u32 w, h;
-        serialize.NumberU32_Unbounded("divs w", w);
-        serialize.NumberU32_Unbounded("divs h", h);
-        value.m_DivisionsW = w;
-        value.m_DivisionsH = h;
+        size_t count = value.m_DivisionsW * value.m_DivisionsH;
+        value.Create(count);
+        for (size_t i = 0; i < count; ++i)
+            SerializeVector<SerializeU32_Unbounded>()(serialize, "subdiv items", value.m_Divisions[i].items);
     }
 };
 

simulation2/MessageTypes.h

@@ -314 +314 @@
 public:
     DEFAULT_MESSAGE_IMPL(RangeUpdate)
 
-    CMessageRangeUpdate(u32 tag, const std::vector<entity_id_t>& added, const std::vector<entity_id_t>& removed) :
-        tag(tag), added(added), removed(removed)
-    {
-    }
 
+
     u32 tag;
     std::vector<entity_id_t> added;
     std::vector<entity_id_t> removed;
@@ -327 +324 @@
     // swap vectors instead of copying (to save on memory allocations),
     // so add some constructors for it:
 
-    CMessageRangeUpdate(u32 tag) :
-        tag(tag)
+    // don't init tag in empty ctor
+    CMessageRangeUpdate() 
     {
     }
-
-    CMessageRangeUpdate(const CMessageRangeUpdate& other) :
-        CMessage(), tag(other.tag), added(other.added), removed(other.removed)
+    CMessageRangeUpdate(u32 tag) : tag(tag)
     {
     }
-
+    CMessageRangeUpdate(u32 tag, const std::vector<entity_id_t>& added, const std::vector<entity_id_t>& removed)
+        : tag(tag), added(added), removed(removed)
+    {
+    }
+    CMessageRangeUpdate(const CMessageRangeUpdate& other) 
+        : CMessage(), tag(other.tag), added(other.added), removed(other.removed)
+    {
+    }
     CMessageRangeUpdate& operator=(const CMessageRangeUpdate& other)
     {
         tag = other.tag;

simulation2/system/EntityMap.h

@@ +1 @@
+/* Copyright (C) 2013 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef INCLUDED_ENTITYMAP
+#define INCLUDED_ENTITYMAP
+
+#include "Entity.h"
+
+/**
+ * A fast replacement for map<entity_id_t, T>.
+ * We make the following assumptions:
+ *  - entity id's (keys) are unique and are inserted in increasing order
+ *  - an entity id that was removed is never added again
+ *  - modifications (add / delete) are far less frequent then look-ups
+ *  - preformance for iteration is important
+ */
+template<class T> class EntityMap
+{
+private:
+    EntityMap(const EntityMap&);            // non-copyable
+    EntityMap& operator=(const EntityMap&); // non-copyable
+
+public:
+    typedef entity_id_t key_type;
+    typedef T mapped_type;
+    template<class K, class V> struct key_val {
+        typedef K first_type;
+        typedef V second_type;
+        K first;
+        V second;
+    };
+    typedef key_val<entity_id_t, T> value_type;
+
+private:
+    size_t m_BufferSize;        // number of elements in the buffer
+    size_t m_BufferCapacity;    // capacity of the buffer
+    value_type* m_Buffer;       // vector with all the mapped key-value pairs
+
+    size_t m_Count;             // number of 'valid' entity id's
+
+public:
+
+    inline EntityMap() : m_BufferSize(1), m_BufferCapacity(4096), m_Count(0)
+    {
+        // for entitymap we allocate the buffer right away
+        // with first element in buffer being the Invalid Entity
+        m_Buffer = (value_type*)malloc(sizeof(value_type) * (m_BufferCapacity + 1));
+
+        // create the first element:
+        m_Buffer[0].first = INVALID_ENTITY;
+        m_Buffer[1].first = 0xFFFFFFFF; // ensure end() always has 0xFFFFFFFF
+    }
+    inline ~EntityMap()
+    {
+        free(m_Buffer);
+    }
+
+    // Iterators
+    template<class U> struct _iter : public std::iterator<std::forward_iterator_tag, U>
+    {
+        U* val;
+        inline _iter(U* init) : val(init) {}
+        inline U& operator*() { return *val; }
+        inline U* operator->() { return val; }
+        inline _iter& operator++() // ++it
+        {
+            ++val;
+            while (val->first == INVALID_ENTITY) ++val; // skip any invalid entities
+            return *this;
+        }
+        inline _iter& operator++(int) // it++
+        {
+            U* ptr = val;
+            ++val;
+            while (val->first == INVALID_ENTITY) ++val; // skip any invalid entities
+            return ptr;
+        }
+        inline bool operator==(_iter other) { return val == other.val; }
+        inline bool operator!=(_iter other) { return val != other.val; }
+        inline operator _iter<U const>() const { return _iter<U const>(val); }
+    };
+    
+    typedef _iter<value_type> iterator;
+    typedef _iter<value_type const> const_iterator;
+
+    inline iterator begin()
+    {
+        value_type* ptr = m_Buffer + 1; // skip the first INVALID_ENTITY
+        while (ptr->first == INVALID_ENTITY) ++ptr; // skip any other invalid entities
+        return ptr;
+    }
+    inline iterator end()
+    {
+        return iterator(m_Buffer + m_BufferSize);
+    }
+    inline const_iterator begin() const
+    {
+        value_type* ptr = m_Buffer + 1; // skip the first INVALID_ENTITY
+        while (ptr->first == INVALID_ENTITY) ++ptr; // skip any other invalid entities
+        return ptr;
+    }
+    inline const_iterator end() const
+    {
+        return const_iterator(m_Buffer + m_BufferSize);
+    }
+
+    // Size
+    inline bool empty() const { return m_Count == 0; }
+    inline size_t size() const { return m_Count; }
+
+    // Modification
+    void insert(const key_type key, const mapped_type& value)
+    {
+        if (key >= m_BufferCapacity) // do we need to resize buffer?
+        {
+            do { m_BufferCapacity += 4096; } while (key >= m_BufferCapacity);
+
+            // always allocate +1 behind the scenes, because end() must have a 0xFFFFFFFF key
+            m_Buffer = (value_type*)realloc(m_Buffer, sizeof(value_type) * (m_BufferCapacity + 1));
+
+            goto fill_gaps;
+        }
+        else if (key > m_BufferSize) // weird insert far beyond the end
+        {
+fill_gaps:
+            // set all entity id's to INVALID_ENTITY inside the new range
+            for (size_t i = m_BufferSize; i <= key; ++i)
+                m_Buffer[i].first = INVALID_ENTITY;
+            m_BufferSize = key; // extend the new size
+        }
+
+        value_type& item = m_Buffer[key];
+        item.first = key;
+        if (key == m_BufferSize) // push_back
+        {
+            ++m_BufferSize; // expand
+            ++m_Count;
+            new (&item.second) mapped_type(value); // copy ctor to init
+            m_Buffer[m_BufferSize].first = 0xFFFFFFFF; // ensure end() always has 0xFFFFFFFF
+        }
+        else if(!item.first) // insert new to middle
+        {
+            ++m_Count;
+            new (&item.second) mapped_type(value); // copy ctor to init
+        }
+        else // set existing value
+        {
+            item.second = value; // overwrite existing
+        }
+    }
+    
+    void erase(iterator it)
+    {
+        value_type* ptr = it.val;
+        if (ptr->first != INVALID_ENTITY)
+        {
+            ptr->first = INVALID_ENTITY;
+            ptr->second.~T(); // call dtor
+            --m_Count;
+        }
+    }
+    void erase(const entity_id_t key)
+    {
+        if (key < m_BufferSize)
+        {
+            value_type* ptr = m_Buffer + key;
+            if (ptr->first != INVALID_ENTITY)
+            {
+                ptr->first = INVALID_ENTITY;
+                ptr->second.~T(); // call dtor
+                --m_Count;
+            }
+        }
+    }
+    inline void clear()
+    {
+        // orphan whole range
+        value_type* ptr = m_Buffer;
+        value_type* end = m_Buffer + m_BufferSize;
+        for (; ptr != end; ++ptr)
+        {
+            if (ptr->first != INVALID_ENTITY)
+            {
+                ptr->first = INVALID_ENTITY;
+                ptr->second.~T(); // call dtor
+            }
+        }
+        m_Count = 0; // no more valid entities
+    }
+
+    // Operations
+    inline iterator find(const entity_id_t key)
+    {
+        if (key < m_BufferSize) // is this key in the range of existing entitites?
+        {
+            value_type* ptr = m_Buffer + key;
+            if (ptr->first != INVALID_ENTITY)
+                return ptr;
+        }
+        return m_Buffer + m_BufferSize; // return iterator end()
+    }
+    inline const_iterator find(const entity_id_t key) const
+    {
+        if (key < m_BufferSize) // is this key in the range of existing entitites?
+        {
+            const value_type* ptr = m_Buffer + key;
+            if (ptr->first != INVALID_ENTITY)
+                return ptr;
+        }
+        return m_Buffer + m_BufferSize; // return iterator end()
+    }
+    inline size_t count(const entity_id_t key) const
+    {
+        if (key < m_BufferSize)
+        {
+            if (m_Buffer[key].first != INVALID_ENTITY)
+                return 1;
+        }
+        return 0;
+    }
+};
+
+template<class VSerializer>
+struct SerializeEntityMap
+{
+    template<class V>
+    void operator()(ISerializer& serialize, const char* UNUSED(name), EntityMap<V>& value)
+    {
+        size_t len = value.size();
+        serialize.NumberU32_Unbounded("length", (u32)len);
+        for (typename EntityMap<V>::iterator it = value.begin(); it != value.end(); ++it)
+        {
+            serialize.NumberI32_Unbounded("key", it->first);
+            VSerializer()(serialize, "value", it->second);
+        }
+    }
+
+    template<class V>
+    void operator()(IDeserializer& deserialize, const char* UNUSED(name), EntityMap<V>& value)
+    {
+        value.clear();
+        uint32_t len;
+        deserialize.NumberU32_Unbounded("length", len);
+        for (size_t i = 0; i < len; ++i)
+        {
+            entity_id_t k;
+            V v;
+            deserialize.NumberU32_Unbounded("key", k);
+            VSerializer()(deserialize, "value", v);
+            value.insert(k, v);
+        }
+    }
+};
+
+
+#endif

simulation2/system/SimContext.cpp

@@ -34 +34 @@
 
 CComponentManager& CSimContext::GetComponentManager() const
 {
-    ENSURE(m_ComponentManager);
     return *m_ComponentManager;
 }