diff --git a/src/framework/GameSystem/TypeContainer.h b/src/framework/GameSystem/TypeContainer.h
index 894027c2f..2b46ff67b 100644
--- a/src/framework/GameSystem/TypeContainer.h
+++ b/src/framework/GameSystem/TypeContainer.h
@@ -28,8 +28,114 @@
 #include <vector>
 #include "Platform/Define.h"
 #include "Utilities/TypeList.h"
+#include "Utilities/UnorderedMap.h"
 #include "GameSystem/GridRefManager.h"
 
+template<class OBJECT, class KEY_TYPE> struct ContainerUnorderedMap
+{
+    UNORDERED_MAP<KEY_TYPE, OBJECT*> _element;
+};
+template<class KEY_TYPE> struct ContainerUnorderedMap<TypeNull, KEY_TYPE>
+{
+};
+template<class H, class T, class KEY_TYPE> struct ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >
+{
+    ContainerUnorderedMap<H, KEY_TYPE> _elements;
+    ContainerUnorderedMap<T, KEY_TYPE> _TailElements;
+};
+
+template<class OBJECT_TYPES, class KEY_TYPE = OBJECT_HANDLE>
+class TypeUnorderedMapContainer
+{
+    public:
+        template<class SPECIFIC_TYPE> bool insert(KEY_TYPE handle, SPECIFIC_TYPE* obj)
+        {
+            return TypeUnorderedMapContainer::insert(i_elements, handle, obj);
+        }
+        template<class SPECIFIC_TYPE> bool erase(KEY_TYPE handle, SPECIFIC_TYPE* /*obj*/)
+        {
+            return TypeUnorderedMapContainer::erase(i_elements, handle, (SPECIFIC_TYPE*)NULL);
+        }
+        template<class SPECIFIC_TYPE> SPECIFIC_TYPE* find(KEY_TYPE hdl, SPECIFIC_TYPE* /*obj*/)
+        {
+            return TypeUnorderedMapContainer::find(i_elements, hdl, (SPECIFIC_TYPE*)NULL);
+        }
+    private:
+        ContainerUnorderedMap<OBJECT_TYPES, KEY_TYPE> i_elements;
+
+        // Helpers
+        // Insert helpers
+        template<class SPECIFIC_TYPE> static bool insert(ContainerUnorderedMap<SPECIFIC_TYPE, KEY_TYPE>& elements, KEY_TYPE handle, SPECIFIC_TYPE* obj)
+        {
+            typename UNORDERED_MAP<OBJECT_HANDLE, SPECIFIC_TYPE*>::iterator i = elements._element.find(handle);
+            if (i == elements._element.end())
+            {
+                elements._element[handle] = obj;
+                return true;
+            }
+            else
+            {
+                assert (i->second == obj && "Object with certain key already in but objects are different!");
+                return false;
+            }
+        }
+        template<class SPECIFIC_TYPE> static bool insert(ContainerUnorderedMap<TypeNull, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
+        {
+            return false;
+        }
+        template<class SPECIFIC_TYPE, class T> static bool insert(ContainerUnorderedMap<T, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
+        {
+            return false;
+        }
+        template<class SPECIFIC_TYPE, class H, class T> static bool insert(ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >& elements, KEY_TYPE handle, SPECIFIC_TYPE* obj)
+        {
+            bool ret = TypeUnorderedMapContainer::insert(elements._elements, handle, obj);
+            return ret ? ret : TypeUnorderedMapContainer::insert(elements._TailElements, handle, obj);
+        }
+        // Find helpers
+        template<class SPECIFIC_TYPE> static SPECIFIC_TYPE* find(ContainerUnorderedMap<SPECIFIC_TYPE, KEY_TYPE>& elements, KEY_TYPE hdl, SPECIFIC_TYPE* /*obj*/)
+        {
+            typename UNORDERED_MAP<OBJECT_HANDLE, SPECIFIC_TYPE*>::iterator i = elements._element.find(hdl);
+            if (i == elements._element.end())
+                return NULL;
+            else
+                return i->second;
+        }
+        template<class SPECIFIC_TYPE> static SPECIFIC_TYPE* find(ContainerUnorderedMap<TypeNull, KEY_TYPE>& /*elements*/, KEY_TYPE /*hdl*/, SPECIFIC_TYPE* /*obj*/)
+        {
+            return NULL;
+        }
+        template<class SPECIFIC_TYPE, class T> static SPECIFIC_TYPE* find(ContainerUnorderedMap<T, KEY_TYPE>& /*elements*/, KEY_TYPE /*hdl*/, SPECIFIC_TYPE* /*obj*/)
+        {
+            return NULL;
+        }
+        template<class SPECIFIC_TYPE, class H, class T> static SPECIFIC_TYPE* find(ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >& elements, KEY_TYPE hdl, SPECIFIC_TYPE* /*obj*/)
+        {
+            SPECIFIC_TYPE* ret = TypeUnorderedMapContainer::find(elements._elements, hdl, (SPECIFIC_TYPE*)NULL);
+            return ret ? ret : TypeUnorderedMapContainer::find(elements._TailElements, hdl, (SPECIFIC_TYPE*)NULL);
+        }
+        // Erase helpers
+        template<class SPECIFIC_TYPE> static bool erase(ContainerUnorderedMap<SPECIFIC_TYPE, KEY_TYPE>& elements, KEY_TYPE handle, SPECIFIC_TYPE* /*obj*/)
+        {
+            elements._element.erase(handle);
+
+            return true;
+        }
+        template<class SPECIFIC_TYPE> static bool erase(ContainerUnorderedMap<TypeNull, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
+        {
+            return false;
+        }
+        template<class SPECIFIC_TYPE, class T> static bool erase(ContainerUnorderedMap<T, KEY_TYPE>& /*elements*/, KEY_TYPE /*handle*/, SPECIFIC_TYPE* /*obj*/)
+        {
+            return false;
+        }
+        template<class SPECIFIC_TYPE, class H, class T> static bool erase(ContainerUnorderedMap< TypeList<H, T>, KEY_TYPE >& elements, KEY_TYPE handle, SPECIFIC_TYPE* /*obj*/)
+        {
+            bool ret = TypeUnorderedMapContainer::erase(elements._elements, handle, (SPECIFIC_TYPE*)NULL);
+            return ret ? ret : TypeUnorderedMapContainer::erase(elements._TailElements, handle, (SPECIFIC_TYPE*)NULL);
+        }
+};
+
 /*
  * @class ContainerMapList is a mulit-type container for map elements
  * By itself its meaningless but collaborate along with TypeContainers,
diff --git a/src/game/BattleGroundAB.cpp b/src/game/BattleGroundAB.cpp
index ad485cdb8..8a7ed49e8 100644
--- a/src/game/BattleGroundAB.cpp
+++ b/src/game/BattleGroundAB.cpp
@@ -26,6 +26,7 @@
 #include "Language.h"
 #include "Util.h"
 #include "WorldPacket.h"
+#include "MapManager.h"
 
 BattleGroundAB::BattleGroundAB()
 {
diff --git a/src/game/BattleGroundEY.cpp b/src/game/BattleGroundEY.cpp
index f3ef573f2..cab99dec5 100644
--- a/src/game/BattleGroundEY.cpp
+++ b/src/game/BattleGroundEY.cpp
@@ -26,6 +26,7 @@
 #include "Language.h"
 #include "WorldPacket.h"
 #include "Util.h"
+#include "MapManager.h"
 
 BattleGroundEY::BattleGroundEY()
 {
diff --git a/src/game/BattleGroundWS.cpp b/src/game/BattleGroundWS.cpp
index 296e79875..c4ad4efbd 100644
--- a/src/game/BattleGroundWS.cpp
+++ b/src/game/BattleGroundWS.cpp
@@ -26,6 +26,7 @@
 #include "BattleGroundMgr.h"
 #include "WorldPacket.h"
 #include "Language.h"
+#include "MapManager.h"
 
 BattleGroundWS::BattleGroundWS()
 {
diff --git a/src/game/Creature.cpp b/src/game/Creature.cpp
index b9ce2442a..fc2ab843b 100644
--- a/src/game/Creature.cpp
+++ b/src/game/Creature.cpp
@@ -141,14 +141,18 @@ Creature::~Creature()
 void Creature::AddToWorld()
 {
     ///- Register the creature for guid lookup
-    if(!IsInWorld()) ObjectAccessor::Instance().AddObject(this);
+    if(!IsInWorld())
+        GetMap()->GetObjectsStore().insert<Creature>(GetGUID(), (Creature*)this);
+
     Unit::AddToWorld();
 }
 
 void Creature::RemoveFromWorld()
 {
     ///- Remove the creature from the accessor
-    if(IsInWorld()) ObjectAccessor::Instance().RemoveObject(this);
+    if(IsInWorld())
+        GetMap()->GetObjectsStore().erase<Creature>(GetGUID(), (Creature*)NULL);
+
     Unit::RemoveFromWorld();
 }
 
diff --git a/src/game/DynamicObject.cpp b/src/game/DynamicObject.cpp
index 92db7e25b..f6bbaf742 100644
--- a/src/game/DynamicObject.cpp
+++ b/src/game/DynamicObject.cpp
@@ -41,7 +41,7 @@ void DynamicObject::AddToWorld()
 {
     ///- Register the dynamicObject for guid lookup
     if(!IsInWorld())
-        ObjectAccessor::Instance().AddObject(this);
+        GetMap()->GetObjectsStore().insert<DynamicObject>(GetGUID(), (DynamicObject*)this);
 
     Object::AddToWorld();
 }
@@ -50,7 +50,7 @@ void DynamicObject::RemoveFromWorld()
 {
     ///- Remove the dynamicObject from the accessor
     if(IsInWorld())
-        ObjectAccessor::Instance().RemoveObject(this);
+        GetMap()->GetObjectsStore().erase<DynamicObject>(GetGUID(), (DynamicObject*)NULL);
 
     Object::RemoveFromWorld();
 }
diff --git a/src/game/GameObject.cpp b/src/game/GameObject.cpp
index c7d1829a7..ac068fef3 100644
--- a/src/game/GameObject.cpp
+++ b/src/game/GameObject.cpp
@@ -60,23 +60,26 @@ GameObject::GameObject() : WorldObject()
 
 GameObject::~GameObject()
 {
-    CleanupsBeforeDelete();
 }
 
-void GameObject::CleanupsBeforeDelete()
+void GameObject::AddToWorld()
 {
-    if(m_uint32Values)                                      // field array can be not exist if GameOBject not loaded
+    ///- Register the gameobject for guid lookup
+    if(!IsInWorld())
+        GetMap()->GetObjectsStore().insert<GameObject>(GetGUID(), (GameObject*)this);
+
+    Object::AddToWorld();
+}
+
+void GameObject::RemoveFromWorld()
+{
+    ///- Remove the gameobject from the accessor
+    if(IsInWorld())
     {
-        // Possible crash at access to deleted GO in Unit::m_gameobj
+        // Remove GO from owner
         if(uint64 owner_guid = GetOwnerGUID())
         {
-            Unit* owner = NULL;
-            if(IS_PLAYER_GUID(owner_guid))
-                owner = ObjectAccessor::GetObjectInWorld(owner_guid, (Player*)NULL);
-            else
-                owner = ObjectAccessor::GetUnit(*this,owner_guid);
-
-            if(owner)
+            if (Unit* owner = IS_PLAYER_GUID(owner_guid) ? ObjectAccessor::FindPlayer(owner_guid) : GetMap()->GetCreatureOrPet(owner_guid))
                 owner->RemoveGameObject(this,false);
             else
             {
@@ -90,20 +93,10 @@ void GameObject::CleanupsBeforeDelete()
                     GetGUIDLow(), GetGOInfo()->id, m_spellId, GetGOInfo()->GetLinkedGameObjectEntry(), GUID_LOPART(owner_guid), ownerType);
             }
         }
+
+        GetMap()->GetObjectsStore().erase<GameObject>(GetGUID(), (GameObject*)NULL);
     }
-}
 
-void GameObject::AddToWorld()
-{
-    ///- Register the gameobject for guid lookup
-    if(!IsInWorld()) ObjectAccessor::Instance().AddObject(this);
-    Object::AddToWorld();
-}
-
-void GameObject::RemoveFromWorld()
-{
-    ///- Remove the gameobject from the accessor
-    if(IsInWorld()) ObjectAccessor::Instance().RemoveObject(this);
     Object::RemoveFromWorld();
 }
 
diff --git a/src/game/GameObject.h b/src/game/GameObject.h
index 06ebfa278..db0a49665 100644
--- a/src/game/GameObject.h
+++ b/src/game/GameObject.h
@@ -559,7 +559,6 @@ class MANGOS_DLL_SPEC GameObject : public WorldObject
 
         void AddToWorld();
         void RemoveFromWorld();
-        void CleanupsBeforeDelete();
 
         bool Create(uint32 guidlow, uint32 name_id, Map *map, uint32 phaseMask, float x, float y, float z, float ang, float rotation0, float rotation1, float rotation2, float rotation3, uint32 animprogress, GOState go_state);
         void Update(uint32 p_time);
diff --git a/src/game/GridDefines.h b/src/game/GridDefines.h
index 7d57814fb..ebfbf20dd 100644
--- a/src/game/GridDefines.h
+++ b/src/game/GridDefines.h
@@ -26,6 +26,7 @@
 // Forward class definitions
 class Corpse;
 class Creature;
+class Vehicle;
 class DynamicObject;
 class GameObject;
 class Pet;
@@ -57,6 +58,7 @@ class Player;
 // Creature used instead pet to simplify *::Visit templates (not required duplicate code for Creature->Pet case)
 typedef TYPELIST_3(Player, Creature/*pets*/, Corpse/*resurrectable*/)                   AllWorldObjectTypes;
 typedef TYPELIST_4(GameObject, Creature/*except pets*/, DynamicObject, Corpse/*Bones*/) AllGridObjectTypes;
+typedef TYPELIST_5(Creature, Pet, Vehicle, GameObject, DynamicObject)                   AllMapStoredObjectTypes;
 
 typedef GridRefManager<Corpse>          CorpseMapType;
 typedef GridRefManager<Creature>        CreatureMapType;
diff --git a/src/game/Map.cpp b/src/game/Map.cpp
index 52a57efaf..4abed7b57 100644
--- a/src/game/Map.cpp
+++ b/src/game/Map.cpp
@@ -56,6 +56,7 @@ struct ScriptAction
 
 Map::~Map()
 {
+    ObjectAccessor::DelinkMap(this);
     UnloadAll(true);
 
     if(!m_scriptSchedule.empty())
@@ -212,6 +213,7 @@ Map::Map(uint32 id, time_t expiry, uint32 InstanceId, uint8 SpawnMode, Map* _par
             setNGrid(NULL, idx, j);
         }
     }
+    ObjectAccessor::LinkMap(this);
 
     //lets initialize visibility distance for map
     Map::InitVisibilityDistance();
@@ -2761,19 +2763,19 @@ void Map::ScriptsProcess()
                     break;
                 }
                 case HIGHGUID_UNIT:
-                    source = HashMapHolder<Creature>::Find(step.sourceGUID);
+                    source = GetCreature(step.sourceGUID);
                     break;
                 case HIGHGUID_PET:
-                    source = HashMapHolder<Pet>::Find(step.sourceGUID);
+                    source = GetPet(step.sourceGUID);
                     break;
                 case HIGHGUID_VEHICLE:
-                    source = HashMapHolder<Vehicle>::Find(step.sourceGUID);
+                    source = GetVehicle(step.sourceGUID);
                     break;
                 case HIGHGUID_PLAYER:
                     source = HashMapHolder<Player>::Find(step.sourceGUID);
                     break;
                 case HIGHGUID_GAMEOBJECT:
-                    source = HashMapHolder<GameObject>::Find(step.sourceGUID);
+                    source = GetGameObject(step.sourceGUID);
                     break;
                 case HIGHGUID_CORPSE:
                     source = HashMapHolder<Corpse>::Find(step.sourceGUID);
@@ -2793,19 +2795,19 @@ void Map::ScriptsProcess()
             switch(GUID_HIPART(step.targetGUID))
             {
                 case HIGHGUID_UNIT:
-                    target = HashMapHolder<Creature>::Find(step.targetGUID);
+                    target = GetCreature(step.targetGUID);
                     break;
                 case HIGHGUID_PET:
-                    target = HashMapHolder<Pet>::Find(step.targetGUID);
+                    target = GetPet(step.targetGUID);
                     break;
                 case HIGHGUID_VEHICLE:
-                    target = HashMapHolder<Vehicle>::Find(step.targetGUID);
+                    target = GetVehicle(step.targetGUID);
                     break;
                 case HIGHGUID_PLAYER:                       // empty GUID case also
                     target = HashMapHolder<Player>::Find(step.targetGUID);
                     break;
                 case HIGHGUID_GAMEOBJECT:
-                    target = HashMapHolder<GameObject>::Find(step.targetGUID);
+                    target = GetGameObject(step.targetGUID);
                     break;
                 case HIGHGUID_CORPSE:
                     target = HashMapHolder<Corpse>::Find(step.targetGUID);
@@ -3381,44 +3383,35 @@ void Map::ScriptsProcess()
     return;
 }
 
-Creature*
-Map::GetCreature(uint64 guid)
+Creature* Map::GetCreature(uint64 guid)
 {
-    Creature * ret = ObjectAccessor::GetObjectInWorld(guid, (Creature*)NULL);
-    if(!ret)
-        return NULL;
-
-    if(ret->GetMapId() != GetId())
-        return NULL;
-
-    if(ret->GetInstanceId() != GetInstanceId())
-        return NULL;
-
-    return ret;
+    return m_objectsStore.find<Creature>(guid, (Creature*)NULL);
 }
 
-GameObject*
-Map::GetGameObject(uint64 guid)
+Vehicle* Map::GetVehicle(uint64 guid)
 {
-    GameObject * ret = ObjectAccessor::GetObjectInWorld(guid, (GameObject*)NULL);
-    if(!ret)
-        return NULL;
-    if(ret->GetMapId() != GetId())
-        return NULL;
-    if(ret->GetInstanceId() != GetInstanceId())
-        return NULL;
-    return ret;
+    return m_objectsStore.find<Vehicle>(guid, (Vehicle*)NULL);
 }
 
-DynamicObject*
-Map::GetDynamicObject(uint64 guid)
+Pet* Map::GetPet(uint64 guid)
 {
-    DynamicObject * ret = ObjectAccessor::GetObjectInWorld(guid, (DynamicObject*)NULL);
-    if(!ret)
-        return NULL;
-    if(ret->GetMapId() != GetId())
-        return NULL;
-    if(ret->GetInstanceId() != GetInstanceId())
-        return NULL;
-    return ret;
+    return m_objectsStore.find<Pet>(guid, (Pet*)NULL);
+}
+
+Unit* Map::GetCreatureOrPet(uint64 guid)
+{
+    if (Unit* ret = GetCreature(guid))
+        return ret;
+
+    return GetPet(guid);
+}
+
+GameObject* Map::GetGameObject(uint64 guid)
+{
+    return m_objectsStore.find<GameObject>(guid, (GameObject*)NULL);
+}
+
+DynamicObject* Map::GetDynamicObject(uint64 guid)
+{
+    return m_objectsStore.find<DynamicObject>(guid, (DynamicObject*)NULL);
 }
diff --git a/src/game/Map.h b/src/game/Map.h
index c867a31d5..a50a3e1f4 100644
--- a/src/game/Map.h
+++ b/src/game/Map.h
@@ -32,6 +32,7 @@
 #include "SharedDefines.h"
 #include "GameSystem/GridRefManager.h"
 #include "MapRefManager.h"
+#include "Utilities/TypeList.h"
 
 #include <bitset>
 #include <list>
@@ -420,8 +421,13 @@ class MANGOS_DLL_SPEC Map : public GridRefManager<NGridType>, public MaNGOS::Obj
         void RemoveFromActive(Creature* obj);
 
         Creature* GetCreature(uint64 guid);
+        Vehicle* GetVehicle(uint64 guid);
+        Pet* GetPet(uint64 guid);
+        Unit* GetCreatureOrPet(uint64 guid);
         GameObject* GetGameObject(uint64 guid);
         DynamicObject* GetDynamicObject(uint64 guid);
+
+        TypeUnorderedMapContainer<AllMapStoredObjectTypes>& GetObjectsStore() { return m_objectsStore; }
     private:
         void LoadMapAndVMap(int gx, int gy);
         void LoadVMap(int gx, int gy);
@@ -484,6 +490,7 @@ class MANGOS_DLL_SPEC Map : public GridRefManager<NGridType>, public MaNGOS::Obj
         typedef std::set<WorldObject*> ActiveNonPlayers;
         ActiveNonPlayers m_activeNonPlayers;
         ActiveNonPlayers::iterator m_activeNonPlayersIter;
+        TypeUnorderedMapContainer<AllMapStoredObjectTypes> m_objectsStore;
     private:
         time_t i_gridExpiry;
 
diff --git a/src/game/ObjectAccessor.cpp b/src/game/ObjectAccessor.cpp
index 0f1d23608..1eb61903e 100644
--- a/src/game/ObjectAccessor.cpp
+++ b/src/game/ObjectAccessor.cpp
@@ -53,16 +53,16 @@ ObjectAccessor::~ObjectAccessor()
 Creature*
 ObjectAccessor::GetCreatureOrPetOrVehicle(WorldObject const &u, uint64 guid)
 {
-    if(IS_PLAYER_GUID(guid))
+    if(IS_PLAYER_GUID(guid) || !u.IsInWorld())
         return NULL;
 
     if(IS_PET_GUID(guid))
-        return GetPet(guid);
+        return u.GetMap()->GetPet(guid);
 
     if(IS_VEHICLE_GUID(guid))
-        return GetVehicle(guid);
+        return u.GetMap()->GetVehicle(guid);
 
-    return u.IsInWorld() ? u.GetMap()->GetCreature(guid) : NULL;
+    return u.GetMap()->GetCreature(guid);
 }
 
 Unit*
@@ -97,8 +97,8 @@ WorldObject* ObjectAccessor::GetWorldObject(WorldObject const &p, uint64 guid)
         case HIGHGUID_PLAYER:       return FindPlayer(guid);
         case HIGHGUID_GAMEOBJECT:   return p.GetMap()->GetGameObject(guid);
         case HIGHGUID_UNIT:         return p.GetMap()->GetCreature(guid);
-        case HIGHGUID_PET:          return GetPet(guid);
-        case HIGHGUID_VEHICLE:      return GetVehicle(guid);
+        case HIGHGUID_PET:          return p.GetMap()->GetPet(guid);
+        case HIGHGUID_VEHICLE:      return p.GetMap()->GetVehicle(guid);
         case HIGHGUID_DYNAMICOBJECT:return p.GetMap()->GetDynamicObject(guid);
         case HIGHGUID_TRANSPORT:    return NULL;
         case HIGHGUID_CORPSE:       return GetCorpse(p,guid);
@@ -131,11 +131,11 @@ Object* ObjectAccessor::GetObjectByTypeMask(WorldObject const &p, uint64 guid, u
             break;
         case HIGHGUID_PET:
             if(typemask & TYPEMASK_UNIT)
-                return GetPet(guid);
+                return p.GetMap()->GetPet(guid);
             break;
         case HIGHGUID_VEHICLE:
             if(typemask & TYPEMASK_UNIT)
-                return GetVehicle(guid);
+                return p.GetMap()->GetVehicle(guid);
             break;
         case HIGHGUID_DYNAMICOBJECT:
             if(typemask & TYPEMASK_DYNAMICOBJECT)
@@ -416,13 +416,11 @@ template <class T> ACE_Thread_Mutex HashMapHolder<T>::i_lock;
 /// Global definitions for the hashmap storage
 
 template class HashMapHolder<Player>;
-template class HashMapHolder<Pet>;
-template class HashMapHolder<Vehicle>;
-template class HashMapHolder<GameObject>;
-template class HashMapHolder<DynamicObject>;
-template class HashMapHolder<Creature>;
 template class HashMapHolder<Corpse>;
 
+/// Define the static member of ObjectAccessor
+std::list<Map*> ObjectAccessor::i_mapList;
+
 template Player* ObjectAccessor::GetObjectInWorld<Player>(uint32 mapid, float x, float y, uint64 guid, Player* /*fake*/);
 template Pet* ObjectAccessor::GetObjectInWorld<Pet>(uint32 mapid, float x, float y, uint64 guid, Pet* /*fake*/);
 template Vehicle* ObjectAccessor::GetObjectInWorld<Vehicle>(uint32 mapid, float x, float y, uint64 guid, Vehicle* /*fake*/);
diff --git a/src/game/ObjectAccessor.h b/src/game/ObjectAccessor.h
index e77b5abeb..0de531c0d 100644
--- a/src/game/ObjectAccessor.h
+++ b/src/game/ObjectAccessor.h
@@ -32,6 +32,7 @@
 #include "Player.h"
 
 #include <set>
+#include <list>
 
 class Creature;
 class Corpse;
@@ -95,29 +96,9 @@ class MANGOS_DLL_DECL ObjectAccessor : public MaNGOS::Singleton<ObjectAccessor,
             return HashMapHolder<T>::Find(guid);
         }
 
-        static Unit* GetObjectInWorld(uint64 guid, Unit* /*fake*/)
-        {
-            if(!guid)
-                return NULL;
-
-            if (IS_PLAYER_GUID(guid))
-            {
-                Unit * u = (Unit*)HashMapHolder<Player>::Find(guid);
-                if(!u || !u->IsInWorld())
-                    return NULL;
-
-                return u;
-            }
-
-            if (IS_PET_GUID(guid))
-                return (Unit*)HashMapHolder<Pet>::Find(guid);
-
-            return (Unit*)HashMapHolder<Creature>::Find(guid);
-        }
-
         template<class T> static T* GetObjectInWorld(uint32 mapid, float x, float y, uint64 guid, T* /*fake*/)
         {
-            T* obj = HashMapHolder<T>::Find(guid);
+            T* obj = GetObjectInWorld(guid, (T*)NULL);
             if(!obj || obj->GetMapId() != mapid) return NULL;
 
             CellPair p = MaNGOS::ComputeCellPair(x,y);
@@ -201,6 +182,9 @@ class MANGOS_DLL_DECL ObjectAccessor : public MaNGOS::Singleton<ObjectAccessor,
 
         static void _buildUpdateObject(Object* obj, UpdateDataMapType &);
 
+        // TODO: This methods will need lock in MT environment
+        static void LinkMap(Map* map)   { i_mapList.push_back(map); }
+        static void DelinkMap(Map* map) { i_mapList.remove(map); }
     private:
         struct WorldObjectChangeAccumulator
         {
@@ -211,6 +195,24 @@ class MANGOS_DLL_DECL ObjectAccessor : public MaNGOS::Singleton<ObjectAccessor,
             template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
         };
 
+        // TODO: This methods will need lock in MT environment
+        // Theoreticaly multiple threads can enter and search in this method but
+        // in that case linking/delinking other map should be guarded
+        template <class OBJECT> static OBJECT* FindHelper(uint64 guid)
+        {
+            OBJECT* ret = NULL;
+            std::list<Map*>::const_iterator i = i_mapList.begin();
+            while (i != i_mapList.end() && !ret)
+            {
+                ret = (*i)->GetObjectsStore().find<OBJECT>(guid, (OBJECT*)NULL);
+                ++i;
+            }
+
+            return ret;
+        }
+
+        static std::list<Map*> i_mapList;
+
         friend struct WorldObjectChangeAccumulator;
         Player2CorpsesMapType   i_player2corpse;
 
@@ -223,6 +225,52 @@ class MANGOS_DLL_DECL ObjectAccessor : public MaNGOS::Singleton<ObjectAccessor,
         LockType i_playerGuard;
         LockType i_updateGuard;
         LockType i_corpseGuard;
-        LockType i_petGuard;
 };
+
+/// Out of class template specializations
+template <> static inline Creature* ObjectAccessor::GetObjectInWorld(uint64 guid, Creature* /*fake*/)
+{
+    return FindHelper<Creature>(guid);
+}
+
+template <> static inline GameObject* ObjectAccessor::GetObjectInWorld(uint64 guid, GameObject* /*fake*/)
+{
+    return FindHelper<GameObject>(guid);
+}
+
+template <> static inline DynamicObject* ObjectAccessor::GetObjectInWorld(uint64 guid, DynamicObject* /*fake*/)
+{
+    return FindHelper<DynamicObject>(guid);
+}
+
+template <> static inline Pet* ObjectAccessor::GetObjectInWorld(uint64 guid, Pet* /*fake*/)
+{
+    return FindHelper<Pet>(guid);
+}
+
+template <> static inline Vehicle* ObjectAccessor::GetObjectInWorld(uint64 guid, Vehicle* /*fake*/)
+{
+    return FindHelper<Vehicle>(guid);
+}
+
+template <> static inline Unit* ObjectAccessor::GetObjectInWorld(uint64 guid, Unit* /*fake*/)
+{
+    if(!guid)
+        return NULL;
+
+    if (IS_PLAYER_GUID(guid))
+    {
+        Unit * u = (Unit*)HashMapHolder<Player>::Find(guid);
+        if(!u || !u->IsInWorld())
+            return NULL;
+
+        return u;
+    }
+
+    if (IS_PET_GUID(guid))
+        return (Unit*)GetObjectInWorld<Pet>(guid, (Pet*)NULL);
+
+    return (Unit*)GetObjectInWorld<Creature>(guid, (Creature*)NULL);
+}
+
 #endif
diff --git a/src/game/Pet.cpp b/src/game/Pet.cpp
index 3581c456f..d1765c092 100644
--- a/src/game/Pet.cpp
+++ b/src/game/Pet.cpp
@@ -57,23 +57,24 @@ m_declinedname(NULL)
 
 Pet::~Pet()
 {
-    if(m_uint32Values)                                      // only for fully created Object
-        ObjectAccessor::Instance().RemoveObject(this);
-
     delete m_declinedname;
 }
 
 void Pet::AddToWorld()
 {
     ///- Register the pet for guid lookup
-    if(!IsInWorld()) ObjectAccessor::Instance().AddObject(this);
+    if(!IsInWorld())
+        GetMap()->GetObjectsStore().insert<Pet>(GetGUID(), (Pet*)this);
+
     Unit::AddToWorld();
 }
 
 void Pet::RemoveFromWorld()
 {
     ///- Remove the pet from the accessor
-    if(IsInWorld()) ObjectAccessor::Instance().RemoveObject(this);
+    if(IsInWorld())
+        GetMap()->GetObjectsStore().erase<Pet>(GetGUID(), (Pet*)NULL);
+
     ///- Don't call the function for Creature, normal mobs + totems go in a different storage
     Unit::RemoveFromWorld();
 }
diff --git a/src/game/Player.cpp b/src/game/Player.cpp
index 18c49c03e..e6fd665d1 100644
--- a/src/game/Player.cpp
+++ b/src/game/Player.cpp
@@ -18821,7 +18821,7 @@ void Player::UpdateForQuestWorldObjects()
     {
         if(IS_GAMEOBJECT_GUID(*itr))
         {
-            GameObject *obj = HashMapHolder<GameObject>::Find(*itr);
+            GameObject *obj = GetMap()->GetGameObject(*itr);
             if(obj)
                 obj->BuildValuesUpdateBlockForPlayer(&udata,this);
         }
diff --git a/src/game/Unit.cpp b/src/game/Unit.cpp
index 7e6f7f900..b28159b2b 100644
--- a/src/game/Unit.cpp
+++ b/src/game/Unit.cpp
@@ -11736,7 +11736,7 @@ void Unit::SetFeared(bool apply, uint64 const& casterGUID, uint32 spellID, uint3
                 GetMotionMaster()->Initialize();
 
             // attack caster if can
-            Unit* caster = ObjectAccessor::GetObjectInWorld(casterGUID, (Unit*)NULL);
+            Unit* caster = Unit::GetUnit(*this, casterGUID);
             if(caster && ((Creature*)this)->AI())
                 ((Creature*)this)->AI()->AttackedBy(caster);
         }
diff --git a/src/game/Vehicle.cpp b/src/game/Vehicle.cpp
index 5c5fad437..d856d3657 100644
--- a/src/game/Vehicle.cpp
+++ b/src/game/Vehicle.cpp
@@ -31,21 +31,23 @@ Vehicle::Vehicle() : Creature(), m_vehicleId(0)
 
 Vehicle::~Vehicle()
 {
-    if(m_uint32Values)                                      // only for fully created Object
-        ObjectAccessor::Instance().RemoveObject(this);
 }
 
 void Vehicle::AddToWorld()
 {
     ///- Register the vehicle for guid lookup
-    if(!IsInWorld()) ObjectAccessor::Instance().AddObject(this);
+    if(!IsInWorld())
+        GetMap()->GetObjectsStore().insert<Vehicle>(GetGUID(), (Vehicle*)this);
+
     Unit::AddToWorld();
 }
 
 void Vehicle::RemoveFromWorld()
 {
     ///- Remove the vehicle from the accessor
-    if(IsInWorld()) ObjectAccessor::Instance().RemoveObject(this);
+    if(IsInWorld())
+        GetMap()->GetObjectsStore().erase<Vehicle>(GetGUID(), (Vehicle*)NULL);
+
     ///- Don't call the function for Creature, normal mobs + totems go in a different storage
     Unit::RemoveFromWorld();
 }
diff --git a/src/shared/revision_nr.h b/src/shared/revision_nr.h
index be7649255..0b9a2b860 100644
--- a/src/shared/revision_nr.h
+++ b/src/shared/revision_nr.h
@@ -1,4 +1,4 @@
 #ifndef __REVISION_NR_H__
 #define __REVISION_NR_H__
- #define REVISION_NR "8652"
+ #define REVISION_NR "8653"
 #endif // __REVISION_NR_H__