Ticket #4046: EntityMapForComponents.4.patch

source/graphics/MapWriter.cpp

@@ -326 +326 @@
 
             // This will probably need to be changed in the future, but for now we'll
             // just save all entities that have a position
-            CSimulation2::InterfaceList ents = sim.GetEntitiesWithInterface(IID_Position);
+            const CSimulation2::InterfaceList& ents = sim.GetEntitiesWithInterface(IID_Position);
             for (CSimulation2::InterfaceList::const_iterator it = ents.begin(); it != ents.end(); ++it)
             {
                 entity_id_t ent = it->first;

source/graphics/ObjectManager.cpp

@@ -29 +29 @@
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpTerrain.h"
 #include "simulation2/components/ICmpVisual.h"
+#include "simulation2/system/EntityMap.h"
 
 
 bool CObjectManager::ObjectKey::operator< (const CObjectManager::ObjectKey& a) const
@@ -197 +198 @@
             // object with all correct variations, and we don't want to waste space storing it just for the
             // rare occurrence of hotloading, so we'll tell the component (which does preserve the information)
             // to do the reloading itself
-            const CSimulation2::InterfaceListUnordered& cmps = m_Simulation.GetEntitiesWithInterfaceUnordered(IID_Visual);
-            for (CSimulation2::InterfaceListUnordered::const_iterator eit = cmps.begin(); eit != cmps.end(); ++eit)
+            const CSimulation2::InterfaceList& cmps = m_Simulation.GetEntitiesWithInterface(IID_Visual);
+            for (CSimulation2::InterfaceList::const_iterator eit = cmps.begin(); eit != cmps.end(); ++eit)
                 static_cast<ICmpVisual*>(eit->second)->Hotload(it->first);
         }
     }

source/gui/MiniMap.cpp

@@ -506 +506 @@
     const float sx = (float)m_Width / ((m_MapSize - 1) * TERRAIN_TILE_SIZE);
     const float sy = (float)m_Height / ((m_MapSize - 1) * TERRAIN_TILE_SIZE);
 
-    CSimulation2::InterfaceList ents = sim->GetEntitiesWithInterface(IID_Minimap);
+    const CSimulation2::InterfaceList& ents = sim->GetEntitiesWithInterface(IID_Minimap);
 
     if (doUpdate)
     {

source/simulation2/components/CCmpTerritoryManager.cpp

@@ -408 +408 @@
         count = 0;
 
     // Find all territory influence entities
-    CComponentManager::InterfaceList influences = GetSimContext().GetComponentManager().GetEntitiesWithInterface(IID_TerritoryInfluence);
+    const CComponentManager::InterfaceList& influences = GetSimContext().GetComponentManager().GetEntitiesWithInterface(IID_TerritoryInfluence);
 
     // Split influence entities into per-player lists, ignoring any with invalid properties
     std::map<player_id_t, std::vector<entity_id_t> > influenceEntities;

source/simulation2/helpers/Selection.cpp

@@ -151 +151 @@
     }
     else // owner == INVALID_PLAYER; Used when selecting units in Atlas or other mods that allow all kinds of selectables to be selected.
     {
-        const CSimulation2::InterfaceListUnordered& selectableEnts = simulation.GetEntitiesWithInterfaceUnordered(IID_Selectable);
-        for (CSimulation2::InterfaceListUnordered::const_iterator it = selectableEnts.begin(); it != selectableEnts.end(); ++it)
+        const CSimulation2::InterfaceList& selectableEnts = simulation.GetEntitiesWithInterface(IID_Selectable);
+        for (CSimulation2::InterfaceList::const_iterator it = selectableEnts.begin(); it != selectableEnts.end(); ++it)
         {
             if (CheckEntityVisibleAndInRect(it->second->GetEntityHandle(), cmpRangeManager, camera, sx0, sy0, sx1, sy1, owner, allowEditorSelectables))
                 hitEnts.push_back(it->first);
@@ -172 +172 @@
 
     std::vector<entity_id_t> hitEnts;
 
-    const CSimulation2::InterfaceListUnordered& ents = simulation.GetEntitiesWithInterfaceUnordered(IID_Selectable);
-    for (CSimulation2::InterfaceListUnordered::const_iterator it = ents.begin(); it != ents.end(); ++it)
+    const CSimulation2::InterfaceList& ents = simulation.GetEntitiesWithInterface(IID_Selectable);
+    for (CSimulation2::InterfaceList::const_iterator it = ents.begin(); it != ents.end(); ++it)
     {
         entity_id_t ent = it->first;
         CEntityHandle handle = it->second->GetEntityHandle();

source/simulation2/serialization/SerializeTemplates.h

@@ -164 +164 @@
     }
 };
 
-// We have to order the map before serializing to make things consistent
-template<typename KS, typename VS>
-struct SerializeUnorderedMap
-{
-    template<typename K, typename V>
-    void operator()(ISerializer& serialize, const char* name, boost::unordered_map<K, V>& value)
-    {
-        std::map<K, V> ordered_value(value.begin(), value.end());
-        SerializeMap<KS, VS>()(serialize, name, ordered_value);
-    }
-
-    template<typename K, typename V>
-    void operator()(IDeserializer& deserialize, const char* name, boost::unordered_map<K, V>& value)
-    {
-        SerializeMap<KS, VS>()(deserialize, name, value);
-    }
-};
-
 template<typename T, T max>
 struct SerializeU8_Enum
 {

source/simulation2/Simulation2.cpp

@@ -647 +647 @@
     m->m_ComponentManager.BroadcastMessage(msg);
 }
 
-CSimulation2::InterfaceList CSimulation2::GetEntitiesWithInterface(int iid)
+const CSimulation2::InterfaceList& CSimulation2::GetEntitiesWithInterface(int iid)
 {
     return m->m_ComponentManager.GetEntitiesWithInterface(iid);
 }
 
-const CSimulation2::InterfaceListUnordered& CSimulation2::GetEntitiesWithInterfaceUnordered(int iid)
-{
-    return m->m_ComponentManager.GetEntitiesWithInterfaceUnordered(iid);
-}
-
 const CSimContext& CSimulation2::GetSimContext() const
 {
     return m->m_SimContext;

source/simulation2/Simulation2.h

@@ -20 +20 @@
 
 #include "simulation2/system/CmpPtr.h"
 #include "simulation2/system/Components.h"
+#include "simulation2/system/EntityMap.h"
 #include "simulation2/helpers/SimulationCommand.h"
 #include "scriptinterface/ScriptVal.h"
 
 #include "lib/file/vfs/vfs_path.h"
 
-#include <boost/unordered_map.hpp>
-
 #include <map>
 
 class CSimulation2Impl;
@@ -202 +201 @@
     void PostMessage(entity_id_t ent, const CMessage& msg) const;
     void BroadcastMessage(const CMessage& msg) const;
 
-    typedef std::vector<std::pair<entity_id_t, IComponent*> > InterfaceList;
-    typedef boost::unordered_map<entity_id_t, IComponent*> InterfaceListUnordered;
+    typedef GlobalEntityMap<IComponent*> InterfaceList;
 
     /**
      * Returns a list of components implementing the given interface, and their
-     * associated entities, sorted by entity ID.
+     * associated entities.
      */
-    InterfaceList GetEntitiesWithInterface(int iid);
+    const InterfaceList& GetEntitiesWithInterface(int iid);
 
-    /**
-     * Returns a list of components implementing the given interface, and their
-     * associated entities, as an unordered map.
-     */
-    const InterfaceListUnordered& GetEntitiesWithInterfaceUnordered(int iid);
-
     const CSimContext& GetSimContext() const;
     ScriptInterface& GetScriptInterface() const;
 

source/simulation2/system/ComponentManager.cpp

@@ -305 +305 @@
     {
         // For every script component with this cid, we need to switch its
         // prototype from the old constructor's prototype property to the new one's
-        const std::map<entity_id_t, IComponent*>& comps = componentManager->m_ComponentsByTypeId[cid];
-        std::map<entity_id_t, IComponent*>::const_iterator eit = comps.begin();
+        const GlobalEntityMap<IComponent*>& comps = componentManager->m_ComponentsByTypeId[cid];
+        GlobalEntityMap<IComponent*>::const_iterator eit = comps.begin();
         for (; eit != comps.end(); ++eit)
         {
             JS::RootedValue instance(cx, eit->second->GetJSInstance());
@@ -405 +405 @@
     CComponentManager* componentManager = static_cast<CComponentManager*> (pCxPrivate->pCBData);
 
     std::vector<int> ret;
-    const InterfaceListUnordered& ents = componentManager->GetEntitiesWithInterfaceUnordered(iid);
-    for (InterfaceListUnordered::const_iterator it = ents.begin(); it != ents.end(); ++it)
+    const InterfaceList& ents = componentManager->GetEntitiesWithInterface(iid);
+    for (InterfaceList::const_iterator it = ents.begin(); it != ents.end(); ++it)
         if (!ENTITY_IS_LOCAL(it->first))
             ret.push_back(it->first);
     std::sort(ret.begin(), ret.end());
@@ -418 +418 @@
     CComponentManager* componentManager = static_cast<CComponentManager*> (pCxPrivate->pCBData);
 
     std::vector<IComponent*> ret;
-    InterfaceList ents = componentManager->GetEntitiesWithInterface(iid);
+    const InterfaceList& ents = componentManager->GetEntitiesWithInterface(iid);
     for (InterfaceList::const_iterator it = ents.begin(); it != ents.end(); ++it)
         ret.push_back(it->second); // TODO: maybe we should exclude local entities
     return ret;
@@ -509 +509 @@
     m_DynamicMessageSubscriptionsNonsyncByComponent.clear();
 
     // Delete all IComponents
-    std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::iterator iit = m_ComponentsByTypeId.begin();
+    std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::iterator iit = m_ComponentsByTypeId.begin();
     for (; iit != m_ComponentsByTypeId.end(); ++iit)
     {
-        std::map<entity_id_t, IComponent*>::iterator eit = iit->second.begin();
+        GlobalEntityMap<IComponent*>::iterator eit = iit->second.begin();
         for (; eit != iit->second.end(); ++eit)
         {
             eit->second->Deinit();
@@ -520 +520 @@
         }
     }
 
-    std::vector<boost::unordered_map<entity_id_t, IComponent*> >::iterator ifcit = m_ComponentsByInterface.begin();
+    std::vector<GlobalEntityMap<IComponent*> >::iterator ifcit = m_ComponentsByInterface.begin();
     for (; ifcit != m_ComponentsByInterface.end(); ++ifcit)
         ifcit->clear();
 
@@ -527 +527 @@
     m_ComponentsByTypeId.clear();
 
     // Delete all SEntityComponentCaches
-    std::map<entity_id_t, SEntityComponentCache*>::iterator ccit = m_ComponentCaches.begin();
+    GlobalEntityMap<SEntityComponentCache*>::iterator ccit = m_ComponentCaches.begin();
     for (; ccit != m_ComponentCaches.end(); ++ccit)
         free(ccit->second);
     m_ComponentCaches.clear();
@@ -750 +750 @@
 
     ENSURE((size_t)ct.iid < m_ComponentsByInterface.size());
 
-    boost::unordered_map<entity_id_t, IComponent*>& emap1 = m_ComponentsByInterface[ct.iid];
+    GlobalEntityMap<IComponent*>& emap1 = m_ComponentsByInterface[ct.iid];
     if (emap1.find(ent.GetId()) != emap1.end())
     {
         LOGERROR("Multiple components for interface %d", ct.iid);
@@ -757 +757 @@
         return NULL;
     }
 
-    std::map<entity_id_t, IComponent*>& emap2 = m_ComponentsByTypeId[cid];
+    GlobalEntityMap<IComponent*>& emap2 = m_ComponentsByTypeId[cid];
 
     // If this is a scripted component, construct the appropriate JS object first
     JS::RootedValue obj(cx);
@@ -779 +779 @@
     component->SetSimContext(m_SimContext);
 
     // Store a reference to the new component
-    emap1.insert(std::make_pair(ent.GetId(), component));
-    emap2.insert(std::make_pair(ent.GetId(), component));
+    emap1.insert(ent.GetId(), component);
+    emap2.insert(ent.GetId(), component);
     // TODO: We need to more careful about this - if an entity is constructed by a component
     // while we're iterating over all components, this will invalidate the iterators and everything
     // will break.
@@ -799 +799 @@
     // Just add it into the by-interface map, not the by-component-type map,
     // so it won't be considered for messages or deletion etc
 
-    boost::unordered_map<entity_id_t, IComponent*>& emap1 = m_ComponentsByInterface.at(iid);
+    GlobalEntityMap<IComponent*>& emap1 = m_ComponentsByInterface.at(iid);
     if (emap1.find(ent.GetId()) != emap1.end())
         debug_warn(L"Multiple components for interface");
-    emap1.insert(std::make_pair(ent.GetId(), &component));
+    emap1.insert(ent.GetId(), &component);
 
     SEntityComponentCache* cache = ent.GetComponentCache();
     ENSURE(cache != NULL && iid < (int)cache->numInterfaces && cache->interfaces[iid] == NULL);
@@ -819 +819 @@
     cache->numInterfaces = m_InterfaceIdsByName.size() + 1;
 
     ENSURE(m_ComponentCaches.find(ent) == m_ComponentCaches.end());
-    m_ComponentCaches[ent] = cache;
+    m_ComponentCaches.insert(ent, cache);
 
     return CEntityHandle(ent, cache);
 }
@@ -826 +826 @@
 
 CEntityHandle CComponentManager::LookupEntityHandle(entity_id_t ent, bool allowCreate)
 {
-    std::map<entity_id_t, SEntityComponentCache*>::iterator it;
-    it = m_ComponentCaches.find(ent);
+    GlobalEntityMap<SEntityComponentCache*>::iterator it = m_ComponentCaches.find(ent);
     if (it == m_ComponentCaches.end())
     {
         if (allowCreate)
@@ -918 +917 @@
             PostMessage(ent, msg);
 
             // Destroy the components, and remove from m_ComponentsByTypeId:
-            std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::iterator iit = m_ComponentsByTypeId.begin();
+            std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::iterator iit = m_ComponentsByTypeId.begin();
             for (; iit != m_ComponentsByTypeId.end(); ++iit)
             {
-                std::map<entity_id_t, IComponent*>::iterator eit = iit->second.find(ent);
+                GlobalEntityMap<IComponent*>::iterator eit = iit->second.find(ent);
                 if (eit != iit->second.end())
                 {
                     eit->second->Deinit();
@@ -936 +935 @@
             m_ComponentCaches.erase(ent);
 
             // Remove from m_ComponentsByInterface
-            std::vector<boost::unordered_map<entity_id_t, IComponent*> >::iterator ifcit = m_ComponentsByInterface.begin();
+            std::vector<GlobalEntityMap<IComponent*> >::iterator ifcit = m_ComponentsByInterface.begin();
             for (; ifcit != m_ComponentsByInterface.end(); ++ifcit)
             {
                 ifcit->erase(ent);
@@ -953 +952 @@
         return NULL;
     }
 
-    boost::unordered_map<entity_id_t, IComponent*>::const_iterator eit = m_ComponentsByInterface[iid].find(ent);
+    GlobalEntityMap<IComponent*>::const_iterator eit = m_ComponentsByInterface[iid].find(ent);
     if (eit == m_ComponentsByInterface[iid].end())
     {
         // This entity doesn't implement this interface
@@ -963 +962 @@
     return eit->second;
 }
 
-CComponentManager::InterfaceList CComponentManager::GetEntitiesWithInterface(InterfaceId iid) const
+static CComponentManager::InterfaceList g_EmptyEntityMap;
+const CComponentManager::InterfaceList& CComponentManager::GetEntitiesWithInterface(InterfaceId iid) const
 {
-    std::vector<std::pair<entity_id_t, IComponent*> > ret;
-
     if ((size_t)iid >= m_ComponentsByInterface.size())
     {
         // Invalid iid
-        return ret;
-    }
-
-    ret.reserve(m_ComponentsByInterface[iid].size());
-
-    boost::unordered_map<entity_id_t, IComponent*>::const_iterator it = m_ComponentsByInterface[iid].begin();
-    for (; it != m_ComponentsByInterface[iid].end(); ++it)
-        ret.push_back(*it);
-
-    std::sort(ret.begin(), ret.end()); // lexicographic pair comparison means this'll sort by entity ID
-
-    return ret;
-}
-
-static CComponentManager::InterfaceListUnordered g_EmptyEntityMap;
-const CComponentManager::InterfaceListUnordered& CComponentManager::GetEntitiesWithInterfaceUnordered(InterfaceId iid) const
-{
-    if ((size_t)iid >= m_ComponentsByInterface.size())
-    {
-        // Invalid iid
         return g_EmptyEntityMap;
     }
 
@@ -1007 +985 @@
         for (; ctit != it->second.end(); ++ctit)
         {
             // Find the component instances of this type (if any)
-            std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
+            std::map<ComponentTypeId, GlobalEntityMap< IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
             if (emap == m_ComponentsByTypeId.end())
                 continue;
 
             // Send the message to all of them
-            std::map<entity_id_t, IComponent*>::const_iterator eit = emap->second.find(ent);
+            GlobalEntityMap<IComponent*>::const_iterator eit = emap->second.find(ent);
             if (eit != emap->second.end())
                 eit->second->HandleMessage(msg, false);
         }
@@ -1032 +1010 @@
         for (; ctit != it->second.end(); ++ctit)
         {
             // Find the component instances of this type (if any)
-            std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
+            std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
             if (emap == m_ComponentsByTypeId.end())
                 continue;
 
             // Send the message to all of them
-            std::map<entity_id_t, IComponent*>::const_iterator eit = emap->second.begin();
+            GlobalEntityMap<IComponent*>::const_iterator eit = emap->second.begin();
             for (; eit != emap->second.end(); ++eit)
                 eit->second->HandleMessage(msg, false);
         }
@@ -1069 +1047 @@
             }
 
             // Find the component instances of this type (if any)
-            std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
+            std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
             if (emap == m_ComponentsByTypeId.end())
                 continue;
 
             // Send the message to all of them
-            std::map<entity_id_t, IComponent*>::const_iterator eit = emap->second.begin();
+            GlobalEntityMap<IComponent*>::const_iterator eit = emap->second.begin();
             for (; eit != emap->second.end(); ++eit)
                 eit->second->HandleMessage(msg, true);
         }

source/simulation2/system/ComponentManager.h

@@ -19 +19 @@
 #define INCLUDED_COMPONENTMANAGER
 
 #include "Entity.h"
+#include "EntityMap.h"
 #include "Components.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/helpers/Player.h"
@@ -25 +26 @@
 #include "ps/Filesystem.h"
 
 #include <boost/random/linear_congruential.hpp>
-#include <boost/unordered_map.hpp>
 
 #include <map>
 
@@ -270 +270 @@
     IComponent* QueryInterface(entity_id_t ent, InterfaceId iid) const;
 
     typedef std::pair<entity_id_t, IComponent*> InterfacePair;
-    typedef std::vector<InterfacePair> InterfaceList;
-    typedef boost::unordered_map<entity_id_t, IComponent*> InterfaceListUnordered;
+    typedef GlobalEntityMap<IComponent*> InterfaceList;
 
-    InterfaceList GetEntitiesWithInterface(InterfaceId iid) const;
-    const InterfaceListUnordered& GetEntitiesWithInterfaceUnordered(InterfaceId iid) const;
+    const InterfaceList& GetEntitiesWithInterface(InterfaceId iid) const;
 
     /**
      * Send a message, targeted at a particular entity. The message will be received by any
@@ -354 +352 @@
     // TODO: some of these should be vectors
     std::map<ComponentTypeId, ComponentType> m_ComponentTypesById;
     std::vector<CComponentManager::ComponentTypeId> m_ScriptedSystemComponents;
-    std::vector<boost::unordered_map<entity_id_t, IComponent*> > m_ComponentsByInterface; // indexed by InterfaceId
-    std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> > m_ComponentsByTypeId;
+    std::vector<GlobalEntityMap<IComponent*> > m_ComponentsByInterface; // indexed by InterfaceId
+    std::map<ComponentTypeId, GlobalEntityMap<IComponent*> > m_ComponentsByTypeId;
     std::map<MessageTypeId, std::vector<ComponentTypeId> > m_LocalMessageSubscriptions;
     std::map<MessageTypeId, std::vector<ComponentTypeId> > m_GlobalMessageSubscriptions;
     std::map<std::string, ComponentTypeId> m_ComponentTypeIdsByName;
@@ -366 +364 @@
     std::map<MessageTypeId, CDynamicSubscription> m_DynamicMessageSubscriptionsNonsync;
     std::map<IComponent*, std::set<MessageTypeId> > m_DynamicMessageSubscriptionsNonsyncByComponent;
 
-    std::map<entity_id_t, SEntityComponentCache*> m_ComponentCaches;
+    GlobalEntityMap<SEntityComponentCache*> m_ComponentCaches;
 
     // TODO: maintaining both ComponentsBy* is nasty; can we get rid of one,
     // while keeping QueryInterface and PostMessage sufficiently efficient?

source/simulation2/system/ComponentManagerSerialization.cpp

@@ -18 +18 @@
 #include "precompiled.h"
 
 #include "ComponentManager.h"
+#include "EntityMap.h"
 #include "IComponent.h"
 #include "ParamNode.h"
 
@@ -58 +59 @@
     std::map<entity_id_t, std::map<ComponentTypeId, IComponent*> > components;
     //std::map<ComponentTypeId, std::string> names;
 
-    std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator ctit = m_ComponentsByTypeId.begin();
+    std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::const_iterator ctit = m_ComponentsByTypeId.begin();
     for (; ctit != m_ComponentsByTypeId.end(); ++ctit)
     {
-        std::map<entity_id_t, IComponent*>::const_iterator eit = ctit->second.begin();
+        GlobalEntityMap<IComponent*>::const_iterator eit = ctit->second.begin();
         for (; eit != ctit->second.end(); ++eit)
         {
             components[eit->first][ctit->first] = eit->second;
@@ -109 +110 @@
     serializer.StringASCII("rng", SerializeRNG(m_RNG), 0, 32);
     serializer.NumberU32_Unbounded("next entity id", m_NextEntityId);
 
-    std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator cit = m_ComponentsByTypeId.begin();
+    std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::const_iterator cit = m_ComponentsByTypeId.begin();
     for (; cit != m_ComponentsByTypeId.end(); ++cit)
     {
         // In quick mode, only check unit positions
@@ -118 +119 @@
 
         // Only emit component types if they have a component that will be serialized
         bool needsSerialization = false;
-        for (std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
+        for (GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
         {
             // Don't serialize local entities
             if (ENTITY_IS_LOCAL(eit->first))
@@ -133 +134 @@
 
         serializer.NumberI32_Unbounded("component type id", cit->first);
 
-        for (std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
+        for (GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
         {
             // Don't serialize local entities
             if (ENTITY_IS_LOCAL(eit->first))
@@ -188 +189 @@
     serializer.StringASCII("rng", SerializeRNG(m_RNG), 0, 32);
     serializer.NumberU32_Unbounded("next entity id", m_NextEntityId);
 
-    std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator cit;
+    std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::const_iterator cit;
     
     uint32_t numSystemComponentTypes = 0;
     uint32_t numComponentTypes = 0;
@@ -199 +200 @@
     {
         // Only emit component types if they have a component that will be serialized
         bool needsSerialization = false;
-        for (std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
+        for (GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
         {
             // Don't serialize local entities, and handle SYSTEM_ENTITY separately
             if (ENTITY_IS_LOCAL(eit->first) || eit->first == SYSTEM_ENTITY)
@@ -238 +239 @@
 
         serializer.StringASCII("name", ctit->second.name, 0, 255);
 
-        std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.find(SYSTEM_ENTITY);
+        GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.find(SYSTEM_ENTITY);
         if (eit == cit->second.end())
         {
             debug_warn(L"Invalid eit"); // this should never happen
@@ -265 +266 @@
 
         // Count the components before serializing any of them
         uint32_t numComponents = 0;
-        for (std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
+        for (GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
         {
             // Don't serialize local entities or SYSTEM_ENTITY
             if (ENTITY_IS_LOCAL(eit->first) || eit->first == SYSTEM_ENTITY)
@@ -278 +279 @@
         serializer.NumberU32_Unbounded("num components", numComponents);
 
         // Serialize the components now
-        for (std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
+        for (GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
         {
             // Don't serialize local entities or SYSTEM_ENTITY
             if (ENTITY_IS_LOCAL(eit->first) || eit->first == SYSTEM_ENTITY)

source/simulation2/system/EntityMap.h

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -18 +18 @@
 #define INCLUDED_ENTITYMAP
 
 #include "Entity.h"
+#include "simulation2/serialization/ISerializer.h"
+#include "simulation2/serialization/IDeserializer.h"
 
 /**
  * A fast replacement for map<entity_id_t, T>.
@@ -28 +30 @@
  */
 template<class T> class EntityMap
 {
-private:
-    EntityMap(const EntityMap&);            // non-copyable
-    EntityMap& operator=(const EntityMap&); // non-copyable
+public:
+    EntityMap(const EntityMap&) = delete;
+    EntityMap& operator=(const EntityMap&) = delete;
+    EntityMap(EntityMap&& o)
+    {
+        m_BufferSize = o.m_BufferSize;
+        m_BufferCapacity = o.m_BufferCapacity;
+        m_Buffer = o.m_Buffer;
+        m_FirstEntityID = o.m_FirstEntityID;
+        m_Count = o.m_Count;
+        
+        o.m_Buffer = nullptr;
+    }
+    EntityMap& operator=(EntityMap&& o)
+    {
+        if (this != &o)
+        {
+            free(m_Buffer);
 
-public:
+            m_BufferSize = o.m_BufferSize;
+            m_BufferCapacity = o.m_BufferCapacity;
+            m_Buffer = o.m_Buffer;
+            m_FirstEntityID = o.m_FirstEntityID;
+            m_Count = o.m_Count;
+
+            o.m_Buffer = nullptr;
+        }
+        return *this;
+    }
     typedef entity_id_t key_type;
     typedef T mapped_type;
     template<class K, class V> struct key_val {
@@ -40 +66 @@
         typedef V second_type;
         K first;
         V second;
+        void operator=(const std::pair<K, V> o)
+        {
+            first = o.first;
+            second = o.second;
+        };
+        operator std::pair<K, V>() { return std::make_pair(first, second); };
+        operator std::pair<K, V>() const { return std::make_pair(first, second); };
     };
     typedef key_val<entity_id_t, T> value_type;
 
@@ -48 +81 @@
     size_t m_BufferCapacity;    // capacity of the buffer
     value_type* m_Buffer;       // vector with all the mapped key-value pairs
 
+    size_t m_FirstEntityID;     // real ID of the [0] in the buffer, so we can offset.
     size_t m_Count;             // number of 'valid' entity id's
 
 public:
 
-    inline EntityMap() : m_BufferSize(1), m_BufferCapacity(4096), m_Count(0)
+    inline EntityMap() : m_BufferSize(0), m_BufferCapacity(4096), m_Count(0), m_FirstEntityID(1)
     {
         // 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
+        m_Buffer[0].first = 0xFFFFFFFF; // ensure end() always has 0xFFFFFFFF
     }
+    inline EntityMap(size_t ID) : EntityMap()
+    {
+        m_FirstEntityID = ID;
+    }
+
     inline ~EntityMap()
     {
         free(m_Buffer);
@@ -97 +134 @@
 
     inline iterator begin()
     {
-        value_type* ptr = m_Buffer + 1; // skip the first INVALID_ENTITY
+        value_type* ptr = m_Buffer;
         while (ptr->first == INVALID_ENTITY) ++ptr; // skip any other invalid entities
         return ptr;
     }
@@ -107 +144 @@
     }
     inline const_iterator begin() const
     {
-        value_type* ptr = m_Buffer + 1; // skip the first INVALID_ENTITY
+        value_type* ptr = m_Buffer;
         while (ptr->first == INVALID_ENTITY) ++ptr; // skip any other invalid entities
         return ptr;
     }
@@ -121 +158 @@
     inline size_t size() const { return m_Count; }
 
     // Modification
-    void insert(const key_type key, const mapped_type& value)
+    void insert(const key_type actual_key, const mapped_type& value)
     {
+        key_type key = actual_key - m_FirstEntityID;
         if (key >= m_BufferCapacity) // do we need to resize buffer?
         {
             size_t newCapacity = m_BufferCapacity + 4096;
@@ -143 +181 @@
 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;
+                new (&m_Buffer[i].second) mapped_type();
+            }
             m_BufferSize = key; // extend the new size
         }
 
         value_type& item = m_Buffer[key];
         key_type oldKey = item.first;
-        item.first = key;
+        item.first = actual_key;
         if (key == m_BufferSize) // push_back
         {
             ++m_BufferSize; // expand
@@ -157 +198 @@
             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
         {
             if (oldKey == INVALID_ENTITY)
                 m_Count++;
-            item.second = value; // overwrite existing
+            item.second = value;
         }
     }
     
@@ -182 +218 @@
     }
     void erase(const entity_id_t key)
     {
-        if (key < m_BufferSize)
+        if (key - m_FirstEntityID < m_BufferSize)
         {
-            value_type* ptr = m_Buffer + key;
+            value_type* ptr = m_Buffer + key - m_FirstEntityID;
             if (ptr->first != INVALID_ENTITY)
             {
                 ptr->first = INVALID_ENTITY;
@@ -210 +246 @@
     }
 
     // Operations
+    inline value_type& operator[](const entity_id_t key)
+    {
+        return m_Buffer[key - m_FirstEntityID];
+    };
+    inline const value_type& operator[](const entity_id_t key) const
+    {
+        return m_Buffer[key - m_FirstEntityID];
+    };
     inline iterator find(const entity_id_t key)
     {
-        if (key < m_BufferSize) // is this key in the range of existing entitites?
+        if (key - m_FirstEntityID >= 0 && key - m_FirstEntityID < m_BufferSize) // is this key in the range of existing entitites?
         {
-            value_type* ptr = m_Buffer + key;
+            value_type* ptr = m_Buffer + key - m_FirstEntityID;
             if (ptr->first != INVALID_ENTITY)
                 return ptr;
         }
@@ -222 +266 @@
     }
     inline const_iterator find(const entity_id_t key) const
     {
-        if (key < m_BufferSize) // is this key in the range of existing entitites?
+        if (key - m_FirstEntityID >= 0 && key - m_FirstEntityID < m_BufferSize) // is this key in the range of existing entitites?
         {
-            const value_type* ptr = m_Buffer + key;
+            const value_type* ptr = m_Buffer + key - m_FirstEntityID;
             if (ptr->first != INVALID_ENTITY)
                 return ptr;
         }
@@ -232 +276 @@
     }
     inline size_t count(const entity_id_t key) const
     {
-        if (key < m_BufferSize)
+        if (key - m_FirstEntityID >= 0 && key - m_FirstEntityID < m_BufferSize)
         {
-            if (m_Buffer[key].first != INVALID_ENTITY)
+            if (m_Buffer[key - m_FirstEntityID].first != INVALID_ENTITY)
                 return 1;
         }
         return 0;
@@ -278 +322 @@
     }
 };
 
+//Implements the same interface as EntityMap but uses two internally to separate local entities
+template<class T>
+class GlobalEntityMap
+{
+public:
+    GlobalEntityMap(const GlobalEntityMap&) = delete;
+    GlobalEntityMap& operator=(const GlobalEntityMap&) = delete;
+    GlobalEntityMap(GlobalEntityMap&& o) : m_Entities(std::move(o.m_Entities)),
+                                         m_LocalEntities(std::move(o.m_LocalEntities)) {}
+    GlobalEntityMap& operator=(GlobalEntityMap&& o)
+    {
+        if (this != &o)
+        {
+            m_Entities = o.m_Entities;
+            m_LocalEntities = o.m_LocalEntities;
+        }
+        return *this;
+    }
+    
+    EntityMap<T> m_Entities;
+    EntityMap<T> m_LocalEntities;
 
+    inline GlobalEntityMap() : m_LocalEntities(ENTITY_TAGMASK) {}
+    
+    typedef typename EntityMap<T>::mapped_type mapped_type;
+    typedef typename EntityMap<T>::key_type key_type;
+    typedef typename EntityMap<T>::value_type value_type;
+
+    // iterator aware of GlobalEntityMap to jump between the two vectors
+    template<class U, class V, class W> struct _iter : public std::iterator<std::forward_iterator_tag, U>
+    {
+        U* val;
+        V* orig;
+        inline _iter(V* mapInit) : orig(mapInit), val(orig.begin()) {}
+        inline _iter(V* mapInit, U* init) : orig(mapInit), val(init) {}
+        inline _iter(V* mapInit, W& init) : orig(mapInit), val(&*init) {}
+        inline U& operator*() { return *val; }
+        inline U* operator->() { return val; }
+        inline _iter& operator++() // ++it
+        {
+            ++val;
+            while (val->first == INVALID_ENTITY) ++val;
+            auto end = &*orig->m_Entities.end();
+            auto toto = &*orig->m_LocalEntities.begin();
+            auto realtoto = &*orig->m_LocalEntities.end();
+            if (val == &*orig->m_Entities.end())
+                val = &*orig->m_LocalEntities.begin();
+            while (val->first == INVALID_ENTITY) ++val;
+            return *this;
+        }
+        inline _iter& operator++(int) // it++
+        {
+            U* ptr = val;
+            ++val;
+            while (val->first == INVALID_ENTITY) ++val; // skip any invalid entities
+            if (val == &*orig->m_Entities.end())
+                val = &*orig->m_LocalEntities.begin();
+            while (val->first == INVALID_ENTITY) ++val;
+            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, V const, W const>() const { return _iter<U const, V const, W const>(orig, val); }
+    };
+
+    typedef _iter<value_type, GlobalEntityMap, typename EntityMap<T>::iterator> iterator;
+    typedef _iter<value_type const, GlobalEntityMap const, typename EntityMap<T>::const_iterator> const_iterator;
+
+    inline iterator begin()
+    {
+        if (m_Entities.empty())
+            return iterator(this, m_LocalEntities.begin());
+        return iterator(this, m_Entities.begin());
+    }
+    inline iterator end()
+    {
+        return iterator(this, m_LocalEntities.end());
+    }
+    inline const_iterator begin() const
+    {
+        if (m_Entities.empty())
+            return const_iterator(this, m_LocalEntities.begin());
+        return const_iterator(this, m_Entities.begin());
+    }
+    inline const_iterator end() const
+    {
+        return const_iterator(this, m_LocalEntities.end());
+    }
+
+    // Size
+    inline bool empty() const { return m_Entities.empty() && m_LocalEntities.empty(); }
+    inline size_t size() const { return m_Entities.size() + m_LocalEntities.size(); }
+
+    // Modification
+    void insert(const key_type key, const mapped_type& value)
+    {
+        if (key < ENTITY_TAGMASK)
+            m_Entities.insert(key, value);
+        else
+            m_LocalEntities.insert(key, value);
+    }
+
+    void erase(iterator it)
+    {
+        if ((*it)->first < ENTITY_TAGMASK)
+            m_Entities.erase(it);
+        else
+            m_LocalEntities.erase(it);
+    }
+    void erase(const entity_id_t key)
+    {
+        if (key < ENTITY_TAGMASK)
+            m_Entities.erase(key);
+        else
+            m_LocalEntities.erase(key);
+    }
+    inline void clear()
+    {
+        m_Entities.clear();
+        m_LocalEntities.clear();
+    }
+
+    // Operations
+    inline value_type& operator[](const entity_id_t key)
+    {
+        if (key < ENTITY_TAGMASK)
+            return m_Entities[key];
+        else
+            return m_LocalEntities[key];
+    };
+    inline const value_type& operator[](const entity_id_t key) const
+    {
+        if (key < ENTITY_TAGMASK)
+            return m_Entities[key];
+        else
+            return m_LocalEntities[key];
+    };
+    inline iterator find(const entity_id_t key)
+    {
+        if (key < ENTITY_TAGMASK)
+        {
+            iterator ret(this, m_Entities.find(key));
+            if (&*ret == &*m_Entities.end())
+                return end();
+            return ret;
+        }
+        else
+            return iterator(this, m_LocalEntities.find(key));
+    }
+    inline const_iterator find(const entity_id_t key) const
+    {
+        if (key < ENTITY_TAGMASK)
+        {
+            const_iterator ret(this, m_Entities.find(key));
+            if (&*ret == &*m_Entities.end())
+                return end();
+            return ret;
+        }
+        else
+            return const_iterator(this, m_LocalEntities.find(key));
+    }
+    inline size_t count(const entity_id_t key) const
+    {
+        if (key < ENTITY_TAGMASK)
+            return m_Entities.count(key);
+        else
+            return m_LocalEntities.count(key);
+    }
+};
+
 #endif

source/simulation2/tests/test_EntityMap.h

@@ +1 @@
+/* Copyright (C) 2016 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/>.
+ */
+
+#include "lib/self_test.h"
+
+#include <array>
+#include "simulation2/system/EntityMap.h"
+
+#include <iostream>
+
+// Test the EntityMap container using the GlobalEntityMap, which uses EntityMap internally.
+class TestEntityMap : public CxxTest::TestSuite
+{
+    GlobalEntityMap<int* > map;
+    std::vector<int> verif;
+
+    void clear()
+    {
+        map.clear();
+        verif.clear();
+    }
+public:
+    void test_TestClear()
+    {
+        for (size_t i = 1; i <= 20; ++i)
+            map.insert(i, verif.data());
+        map.clear();
+        TS_ASSERT_EQUALS(map.size(), 0);
+        TS_ASSERT_EQUALS(map.begin(), map.end())
+    }
+        
+    void test_TestInsert()
+    {
+        clear();
+        // insert items in key positions and verify they are retrieved correctly
+        // I don't actually care about the values, so store pointers in the EntityMap
+        verif = std::vector<int>(20);
+        
+        for (size_t i = 1; i <= 20; ++i)
+            map.insert(i, verif.data() + i);
+
+        TS_ASSERT_EQUALS(map.size(), 20);
+
+        for (size_t i = 1; i <= 20; ++i)
+            TS_ASSERT_EQUALS(map[i].second, verif.data() + i);
+
+        map.insert(1, verif.data());
+        map.insert(5, verif.data() + 1);
+        map.insert(1500, verif.data() + 2);
+
+        TS_ASSERT_EQUALS(map[1].second, verif.data());
+        TS_ASSERT_EQUALS(map[5].second, verif.data() + 1);
+        TS_ASSERT_EQUALS(map[1500].second, verif.data() + 2);
+
+        TS_ASSERT_EQUALS(map[1].first, 1);
+        TS_ASSERT_EQUALS(map[5].first, 5);
+        TS_ASSERT_EQUALS(map[1500].first, 1500);
+
+        // check that we properly pad
+        TS_ASSERT_EQUALS(map[1300].first, INVALID_ENTITY);
+    }
+    void test_TestLargeInsert()
+    {
+        clear();
+        verif = std::vector<int>(21);
+
+        for (size_t i = 1; i <= 10; ++i)
+            map.insert(i, verif.data() + i);
+
+        for (size_t i = 11; i <= 20; ++i)
+            map.insert(i + ENTITY_TAGMASK, verif.data() + i);
+
+        TS_ASSERT_EQUALS(map.size(), 20);
+
+        for (size_t i = 1; i <= 10; ++i)
+            TS_ASSERT_EQUALS(map[i].second, verif.data() + i);
+        for (size_t i = 11; i <= 20; ++i)
+            TS_ASSERT_EQUALS(map[i + ENTITY_TAGMASK].second, verif.data() + i);
+    }
+    void test_TestIter()
+    {
+        clear();
+        
+        // verify the returned iterators
+        verif = std::vector<int>(20);
+
+        for (size_t i = 1; i < 10; i++)
+            map.insert(i, verif.data() + i-1);
+        for (size_t i = 10; i < 20; i++)
+            map.insert(i + ENTITY_TAGMASK, verif.data() + i - 1);
+
+        TS_ASSERT_EQUALS(map.begin()->second, verif.data());
+        TS_ASSERT_EQUALS(map.end()->first, 0xFFFFFFFF);
+
+        size_t i = 0;
+        auto it = map.begin();
+        for (; it != map.end(); ++it)
+        {
+            TS_ASSERT_EQUALS(it->second, verif.data() + i);
+            i++;
+        }
+        TS_ASSERT_EQUALS(i, map.size())
+    }
+    void test_TestID()
+    {
+        clear();
+        verif = std::vector<int>(20);
+
+        for (size_t i = 1; i <= 10; ++i)
+            map.insert(i, verif.data());
+
+        for (size_t i = 11; i <= 20; ++i)
+            map.insert(i + ENTITY_TAGMASK, verif.data());
+
+        TS_ASSERT_EQUALS(map.begin()->second, verif.data());
+        TS_ASSERT_EQUALS(map.end()->first, 0xFFFFFFFF);
+
+        size_t i = 1;
+        auto it = map.begin();
+        for (; it != map.end(); ++it)
+        {
+            TS_ASSERT_EQUALS(it->first, i);
+            i++;
+            if (i == 11)
+                i += ENTITY_TAGMASK;
+        }
+    }
+    void test_TestFind()
+    {
+        clear();
+        verif = std::vector<int>(20);
+
+        map.insert(5, verif.data());
+        map.insert(10, verif.data()+5);
+        map.insert(50, verif.data() + 1);
+        map.insert(ENTITY_TAGMASK + 5, verif.data()+2);
+        map.insert(ENTITY_TAGMASK + 50, verif.data()+3);
+
+        TS_ASSERT_EQUALS(map.find(5)->second, verif.data());
+        TS_ASSERT_EQUALS(map[5].second, verif.data());
+        TS_ASSERT_EQUALS(map.find(50)->second, verif.data()+1);
+        TS_ASSERT_EQUALS(map[50].second, verif.data() + 1);
+        TS_ASSERT_EQUALS(map.find(40), map.end());
+
+        TS_ASSERT_EQUALS(map.find(5 + ENTITY_TAGMASK)->second, verif.data()+2);
+        TS_ASSERT_EQUALS(map[5 + ENTITY_TAGMASK].second, verif.data() + 2);
+        TS_ASSERT_EQUALS(map.find(50 + ENTITY_TAGMASK)->second, verif.data()+3);
+        TS_ASSERT_EQUALS(map[50 + ENTITY_TAGMASK].second, verif.data() + 3);
+        TS_ASSERT_EQUALS(map.find(40 + ENTITY_TAGMASK), map.end());
+
+        TS_ASSERT_EQUALS(map.find(-5), map.end());
+    }
+
+    void test_TestErase()
+    {
+        clear();
+        verif = std::vector<int>(21);
+
+        for (size_t i = 1; i <= 10; ++i)
+            map.insert(i, verif.data() + i);
+
+        for (size_t i = 11; i <= 20; ++i)
+            map.insert(i + ENTITY_TAGMASK, verif.data() + i);
+
+        map.erase(5);
+        map.erase(6);
+        map.erase(5);
+        map.erase(5 + ENTITY_TAGMASK);
+
+        TS_ASSERT_EQUALS(map.find(5), map.end());
+        TS_ASSERT_EQUALS(map.find(6), map.end());
+        TS_ASSERT_EQUALS(map.find(5 + ENTITY_TAGMASK), map.end());
+    }
+
+    void test_TestAssign()
+    {
+        clear();
+        verif = std::vector<int>(21);
+
+        map.insert(5, verif.data());
+        map.insert(6, verif.data());
+        map.insert(150, verif.data());
+
+        map.insert(150 + ENTITY_TAGMASK, verif.data());
+
+        TS_ASSERT_EQUALS(map[5].second, verif.data());
+        map[5] = std::make_pair(8, nullptr);
+        TS_ASSERT_EQUALS(map[5].first, 8);
+        TS_ASSERT_EQUALS(map[5].second, nullptr);
+        map[5].first = 4;
+        TS_ASSERT_EQUALS(map[5].first, 4);
+
+        TS_ASSERT_EQUALS(map[150 + ENTITY_TAGMASK].second, verif.data());
+        map[150 + ENTITY_TAGMASK] = std::make_pair(8, nullptr);
+        TS_ASSERT_EQUALS(map[150 + ENTITY_TAGMASK].first, 8);
+        TS_ASSERT_EQUALS(map[150 + ENTITY_TAGMASK].second, nullptr);
+        map[150 + ENTITY_TAGMASK].first = 4;
+        TS_ASSERT_EQUALS(map[150 + ENTITY_TAGMASK].first, 4);
+
+    }};

source/tools/atlas/GameInterface/DeltaArray.h

@@ -18 +18 @@
 #ifndef INCLUDED_DELTAARRAY
 #define INCLUDED_DELTAARRAY
 
+#include <boost/unordered_map.hpp>
+
 template<typename T> class DeltaArray2D
 {
 public:

source/tools/atlas/GameInterface/Handlers/ObjectHandlers.cpp

@@ -50 +50 @@
 #include "simulation2/components/ICmpTemplateManager.h"
 #include "simulation2/components/ICmpVisual.h"
 #include "simulation2/helpers/Selection.h"
+#include "simulation2/system/EntityMap.h"
 #include "ps/XML/XMLWriter.h"
 
 namespace AtlasMessage {
@@ -1106 +1107 @@
     std::vector<entity_id_t> ids;
     player_id_t playerID = msg->player;
 
-    const CSimulation2::InterfaceListUnordered& cmps = g_Game->GetSimulation2()->GetEntitiesWithInterfaceUnordered(IID_Ownership);
-    for (CSimulation2::InterfaceListUnordered::const_iterator eit = cmps.begin(); eit != cmps.end(); ++eit)
+    const CSimulation2::InterfaceList& cmps = g_Game->GetSimulation2()->GetEntitiesWithInterface(IID_Ownership);
+    for (CSimulation2::InterfaceList::const_iterator eit = cmps.begin(); eit != cmps.end(); ++eit)
     {
         if (static_cast<ICmpOwnership*>(eit->second)->GetOwner() == playerID)
         {