src/game/ObjectAccessor.cpp

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "ObjectAccessor.h"
  20 #include "ObjectMgr.h"
  21 #include "Policies/SingletonImp.h"
  22 #include "Player.h"
  23 #include "Creature.h"
  24 #include "GameObject.h"
  25 #include "DynamicObject.h"
  26 #include "Vehicle.h"
  27 #include "WorldPacket.h"
  28 #include "Item.h"
  29 #include "Corpse.h"
  30 #include "GridNotifiers.h"
  31 #include "MapManager.h"
  32 #include "Map.h"
  33 #include "CellImpl.h"
  34 #include "GridNotifiersImpl.h"
  35 #include "Opcodes.h"
  36 #include "ObjectDefines.h"
  37 #include "MapInstanced.h"
  38 #include "World.h"
  39
  40 #include <cmath>
  41
  42 #define CLASS_LOCK MaNGOS::ClassLevelLockable<ObjectAccessor, ACE_Thread_Mutex>
  43 INSTANTIATE_SINGLETON_2(ObjectAccessor, CLASS_LOCK);
  44 INSTANTIATE_CLASS_MUTEX(ObjectAccessor, ACE_Thread_Mutex);
  45
  46 ObjectAccessor::ObjectAccessor() {}
  47 ObjectAccessor::~ObjectAccessor()
  48 {
  49     for(Player2CorpsesMapType::const_iterator itr = i_player2corpse.begin(); itr != i_player2corpse.end(); ++itr)
  50         delete itr->second;
  51 }
  52
  53 Creature*
  54 ObjectAccessor::GetCreatureOrPetOrVehicle(WorldObject const &u, uint64 guid)
  55 {
  56     if(IS_PLAYER_GUID(guid))
  57         return NULL;
  58
  59     if(IS_PET_GUID(guid))
  60         return GetPet(guid);
  61
  62     if(IS_VEHICLE_GUID(guid))
  63         return GetVehicle(guid);
  64
  65     return u.IsInWorld() ? u.GetMap()->GetCreature(guid) : NULL;
  66 }
  67
  68 Unit*
  69 ObjectAccessor::GetUnit(WorldObject const &u, uint64 guid)
  70 {
  71     if(!guid)
  72         return NULL;
  73
  74     if(IS_PLAYER_GUID(guid))
  75         return FindPlayer(guid);
  76
  77     return GetCreatureOrPetOrVehicle(u, guid);
  78 }
  79
  80 Corpse*
  81 ObjectAccessor::GetCorpse(WorldObject const &u, uint64 guid)
  82 {
  83     Corpse * ret = GetObjectInWorld(guid, (Corpse*)NULL);
  84     if(!ret)
  85         return NULL;
  86     if(ret->GetMapId() != u.GetMapId())
  87         return NULL;
  88     if(ret->GetInstanceId() != u.GetInstanceId())
  89         return NULL;
  90     return ret;
  91 }
  92
  93 Object* ObjectAccessor::GetObjectByTypeMask(WorldObject const &p, uint64 guid, uint32 typemask)
  94 {
  95     Object *obj = NULL;
  96
  97     if(typemask & TYPEMASK_PLAYER)
  98     {
  99         obj = FindPlayer(guid);
 100         if(obj)
 101             return obj;
 102     }
 103
 104     if(typemask & TYPEMASK_UNIT)
 105     {
 106         obj = GetCreatureOrPetOrVehicle(p,guid);
 107         if(obj)
 108             return obj;
 109     }
 110
 111     if(typemask & TYPEMASK_GAMEOBJECT)
 112     {
 113         obj = p.GetMap()->GetGameObject(guid);
 114         if(obj)
 115             return obj;
 116     }
 117
 118     if(typemask & TYPEMASK_DYNAMICOBJECT)
 119     {
 120         obj = p.GetMap()->GetDynamicObject(guid);
 121         if(obj)
 122             return obj;
 123     }
 124
 125     if(typemask & TYPEMASK_ITEM && p.GetTypeId() == TYPEID_PLAYER)
 126     {
 127         obj = ((Player const &)p).GetItemByGuid( guid );
 128         if(obj)
 129             return obj;
 130     }
 131
 132     return NULL;
 133 }
 134
 135 Player*
 136 ObjectAccessor::FindPlayer(uint64 guid)
 137 {
 138     Player * plr = GetObjectInWorld(guid, (Player*)NULL);
 139     if(!plr || !plr->IsInWorld())
 140         return NULL;
 141
 142     return plr;
 143 }
 144
 145 Player*
 146 ObjectAccessor::FindPlayerByName(const char *name)
 147 {
 148     //TODO: Player Guard
 149     HashMapHolder<Player>::MapType& m = HashMapHolder<Player>::GetContainer();
 150     HashMapHolder<Player>::MapType::iterator iter = m.begin();
 151     for(; iter != m.end(); ++iter)
 152         if(iter->second->IsInWorld() && ( ::strcmp(name, iter->second->GetName()) == 0 ))
 153             return iter->second;
 154     return NULL;
 155 }
 156
 157 void
 158 ObjectAccessor::SaveAllPlayers()
 159 {
 160     Guard guard(*HashMapHolder<Player*>::GetLock());
 161     HashMapHolder<Player>::MapType& m = HashMapHolder<Player>::GetContainer();
 162     HashMapHolder<Player>::MapType::iterator itr = m.begin();
 163     for(; itr != m.end(); ++itr)
 164         itr->second->SaveToDB();
 165 }
 166
 167 void
 168 ObjectAccessor::UpdateObject(Object* obj, Player* exceptPlayer)
 169 {
 170     UpdateDataMapType update_players;
 171     obj->BuildUpdate(update_players);
 172
 173     WorldPacket packet;
 174     for(UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
 175     {
 176         if(iter->first == exceptPlayer)
 177             continue;
 178
 179         iter->second.BuildPacket(&packet);
 180         iter->first->GetSession()->SendPacket(&packet);
 181         packet.clear();
 182     }
 183 }
 184
 185 void
 186 ObjectAccessor::_buildUpdateObject(Object *obj, UpdateDataMapType &update_players)
 187 {
 188     bool build_for_all = true;
 189     Player *pl = NULL;
 190     if( obj->isType(TYPEMASK_ITEM) )
 191     {
 192         Item *item = static_cast<Item *>(obj);
 193         pl = item->GetOwner();
 194         build_for_all = false;
 195     }
 196
 197     if( pl != NULL )
 198         _buildPacket(pl, obj, update_players);
 199
 200     // Capt: okey for all those fools who think its a real fix
 201     //       THIS IS A TEMP FIX
 202     if( build_for_all )
 203     {
 204         WorldObject * temp = dynamic_cast<WorldObject*>(obj);
 205
 206         //assert(dynamic_cast<WorldObject*>(obj)!=NULL);
 207         if (temp)
 208             _buildChangeObjectForPlayer(temp, update_players);
 209         else
 210             sLog.outDebug("ObjectAccessor: Ln 405 Temp bug fix");
 211     }
 212 }
 213
 214 void
 215 ObjectAccessor::_buildPacket(Player *pl, Object *obj, UpdateDataMapType &update_players)
 216 {
 217     UpdateDataMapType::iterator iter = update_players.find(pl);
 218
 219     if( iter == update_players.end() )
 220     {
 221         std::pair<UpdateDataMapType::iterator, bool> p = update_players.insert( UpdateDataValueType(pl, UpdateData()) );
 222         assert(p.second);
 223         iter = p.first;
 224     }
 225
 226     obj->BuildValuesUpdateBlockForPlayer(&iter->second, iter->first);
 227 }
 228
 229 void
 230 ObjectAccessor::_buildChangeObjectForPlayer(WorldObject *obj, UpdateDataMapType &update_players)
 231 {
 232     CellPair p = MaNGOS::ComputeCellPair(obj->GetPositionX(), obj->GetPositionY());
 233     Cell cell(p);
 234     cell.data.Part.reserved = ALL_DISTRICT;
 235     cell.SetNoCreate();
 236     WorldObjectChangeAccumulator notifier(*obj, update_players);
 237     TypeContainerVisitor<WorldObjectChangeAccumulator, WorldTypeMapContainer > player_notifier(notifier);
 238     CellLock<GridReadGuard> cell_lock(cell, p);
 239     cell_lock->Visit(cell_lock, player_notifier, *obj->GetMap());
 240 }
 241
 242 Pet*
 243 ObjectAccessor::GetPet(uint64 guid)
 244 {
 245     return GetObjectInWorld(guid, (Pet*)NULL);
 246 }
 247
 248 Vehicle*
 249 ObjectAccessor::GetVehicle(uint64 guid)
 250 {
 251     return GetObjectInWorld(guid, (Vehicle*)NULL);
 252 }
 253
 254 Corpse*
 255 ObjectAccessor::GetCorpseForPlayerGUID(uint64 guid)
 256 {
 257     Guard guard(i_corpseGuard);
 258
 259     Player2CorpsesMapType::iterator iter = i_player2corpse.find(guid);
 260     if( iter == i_player2corpse.end() ) return NULL;
 261
 262     assert(iter->second->GetType() != CORPSE_BONES);
 263
 264     return iter->second;
 265 }
 266
 267 void
 268 ObjectAccessor::RemoveCorpse(Corpse *corpse)
 269 {
 270     assert(corpse && corpse->GetType() != CORPSE_BONES);
 271
 272     Guard guard(i_corpseGuard);
 273     Player2CorpsesMapType::iterator iter = i_player2corpse.find(corpse->GetOwnerGUID());
 274     if( iter == i_player2corpse.end() )
 275         return;
 276
 277     // build mapid*cellid -> guid_set map
 278     CellPair cell_pair = MaNGOS::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
 279     uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
 280
 281     objmgr.DeleteCorpseCellData(corpse->GetMapId(), cell_id, corpse->GetOwnerGUID());
 282     corpse->RemoveFromWorld();
 283
 284     i_player2corpse.erase(iter);
 285 }
 286
 287 void
 288 ObjectAccessor::AddCorpse(Corpse *corpse)
 289 {
 290     assert(corpse && corpse->GetType() != CORPSE_BONES);
 291
 292     Guard guard(i_corpseGuard);
 293     assert(i_player2corpse.find(corpse->GetOwnerGUID()) == i_player2corpse.end());
 294     i_player2corpse[corpse->GetOwnerGUID()] = corpse;
 295
 296     // build mapid*cellid -> guid_set map
 297     CellPair cell_pair = MaNGOS::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
 298     uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
 299
 300     objmgr.AddCorpseCellData(corpse->GetMapId(), cell_id, corpse->GetOwnerGUID(), corpse->GetInstanceId());
 301 }
 302
 303 void
 304 ObjectAccessor::AddCorpsesToGrid(GridPair const& gridpair,GridType& grid,Map* map)
 305 {
 306     Guard guard(i_corpseGuard);
 307     for(Player2CorpsesMapType::iterator iter = i_player2corpse.begin(); iter != i_player2corpse.end(); ++iter)
 308         if(iter->second->GetGrid() == gridpair)
 309     {
 310         // verify, if the corpse in our instance (add only corpses which are)
 311         if (map->Instanceable())
 312         {
 313             if (iter->second->GetInstanceId() == map->GetInstanceId())
 314             {
 315                 grid.AddWorldObject(iter->second, iter->second->GetGUID());
 316             }
 317         }
 318         else
 319         {
 320             grid.AddWorldObject(iter->second, iter->second->GetGUID());
 321         }
 322     }
 323 }
 324
 325 Corpse*
 326 ObjectAccessor::ConvertCorpseForPlayer(uint64 player_guid, bool insignia)
 327 {
 328     Corpse *corpse = GetCorpseForPlayerGUID(player_guid);
 329     if(!corpse)
 330     {
 331         //in fact this function is called from several places
 332         //even when player doesn't have a corpse, not an error
 333         //sLog.outError("Try remove corpse that not in map for GUID %ul", player_guid);
 334         return NULL;
 335     }
 336
 337     DEBUG_LOG("Deleting Corpse and spawning bones.");
 338
 339     // remove corpse from player_guid -> corpse map
 340     RemoveCorpse(corpse);
 341
 342     // remove resurrectable corpse from grid object registry (loaded state checked into call)
 343     // do not load the map if it's not loaded
 344     Map *map = MapManager::Instance().FindMap(corpse->GetMapId(), corpse->GetInstanceId());
 345     if(map)
 346         map->Remove(corpse, false);
 347
 348     // remove corpse from DB
 349     corpse->DeleteFromDB();
 350
 351     Corpse *bones = NULL;
 352     // create the bones only if the map and the grid is loaded at the corpse's location
 353     // ignore bones creating option in case insignia
 354     if (map && (insignia ||
 355         (map->IsBattleGroundOrArena() ? sWorld.getConfig(CONFIG_DEATH_BONES_BG_OR_ARENA) : sWorld.getConfig(CONFIG_DEATH_BONES_WORLD))) &&
 356         !map->IsRemovalGrid(corpse->GetPositionX(), corpse->GetPositionY()))
 357     {
 358         // Create bones, don't change Corpse
 359         bones = new Corpse;
 360         bones->Create(corpse->GetGUIDLow());
 361
 362         for (int i = 3; i < CORPSE_END; ++i)                    // don't overwrite guid and object type
 363             bones->SetUInt32Value(i, corpse->GetUInt32Value(i));
 364
 365         bones->SetGrid(corpse->GetGrid());
 366         // bones->m_time = m_time;                              // don't overwrite time
 367         // bones->m_inWorld = m_inWorld;                        // don't overwrite world state
 368         // bones->m_type = m_type;                              // don't overwrite type
 369         bones->Relocate(corpse->GetPositionX(), corpse->GetPositionY(), corpse->GetPositionZ(), corpse->GetOrientation());
 370         bones->SetPhaseMask(corpse->GetPhaseMask(), false);
 371
 372         bones->SetUInt32Value(CORPSE_FIELD_FLAGS, CORPSE_FLAG_UNK2 | CORPSE_FLAG_BONES);
 373         bones->SetUInt64Value(CORPSE_FIELD_OWNER, 0);
 374
 375         for (int i = 0; i < EQUIPMENT_SLOT_END; ++i)
 376         {
 377             if(corpse->GetUInt32Value(CORPSE_FIELD_ITEM + i))
 378                 bones->SetUInt32Value(CORPSE_FIELD_ITEM + i, 0);
 379         }
 380
 381         // add bones in grid store if grid loaded where corpse placed
 382         map->Add(bones);
 383     }
 384
 385     // all references to the corpse should be removed at this point
 386     delete corpse;
 387
 388     return bones;
 389 }
 390
 391 void
 392 ObjectAccessor::Update(uint32 diff)
 393 {
 394     UpdateDataMapType update_players;
 395     {
 396         Guard guard(i_updateGuard);
 397         while(!i_objects.empty())
 398         {
 399             Object* obj = *i_objects.begin();
 400             i_objects.erase(i_objects.begin());
 401             if (!obj)
 402                 continue;
 403             _buildUpdateObject(obj, update_players);
 404             obj->ClearUpdateMask(false);
 405         }
 406     }
 407
 408     WorldPacket packet;                                     // here we allocate a std::vector with a size of 0x10000
 409     for(UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
 410     {
 411         iter->second.BuildPacket(&packet);
 412         iter->first->GetSession()->SendPacket(&packet);
 413         packet.clear();                                     // clean the string
 414     }
 415 }
 416
 417 void
 418 ObjectAccessor::WorldObjectChangeAccumulator::Visit(PlayerMapType &m)
 419 {
 420     for(PlayerMapType::iterator iter = m.begin(); iter != m.end(); ++iter)
 421         if(iter->getSource()->HaveAtClient(&i_object))
 422             ObjectAccessor::_buildPacket(iter->getSource(), &i_object, i_updateDatas);
 423 }
 424
 425 void
 426 ObjectAccessor::UpdateObjectVisibility(WorldObject *obj)
 427 {
 428     CellPair p = MaNGOS::ComputeCellPair(obj->GetPositionX(), obj->GetPositionY());
 429     Cell cell(p);
 430
 431     obj->GetMap()->UpdateObjectVisibility(obj, cell, p);
 432 }
 433
 434 void ObjectAccessor::UpdateVisibilityForPlayer( Player* player )
 435 {
 436     CellPair p = MaNGOS::ComputeCellPair(player->GetPositionX(), player->GetPositionY());
 437     Cell cell(p);
 438     Map* m = player->GetMap();
 439
 440     m->UpdatePlayerVisibility(player, cell, p);
 441     m->UpdateObjectsVisibilityFor(player, cell, p);
 442 }
 443
 444 /// Define the static member of HashMapHolder
 445
 446 template <class T> UNORDERED_MAP< uint64, T* > HashMapHolder<T>::m_objectMap;
 447 template <class T> ACE_Thread_Mutex HashMapHolder<T>::i_lock;
 448
 449 /// Global definitions for the hashmap storage
 450
 451 template class HashMapHolder<Player>;
 452 template class HashMapHolder<Pet>;
 453 template class HashMapHolder<Vehicle>;
 454 template class HashMapHolder<GameObject>;
 455 template class HashMapHolder<DynamicObject>;
 456 template class HashMapHolder<Creature>;
 457 template class HashMapHolder<Corpse>;
 458
 459 template Player* ObjectAccessor::GetObjectInWorld<Player>(uint32 mapid, float x, float y, uint64 guid, Player* /*fake*/);
 460 template Pet* ObjectAccessor::GetObjectInWorld<Pet>(uint32 mapid, float x, float y, uint64 guid, Pet* /*fake*/);
 461 template Vehicle* ObjectAccessor::GetObjectInWorld<Vehicle>(uint32 mapid, float x, float y, uint64 guid, Vehicle* /*fake*/);
 462 template Creature* ObjectAccessor::GetObjectInWorld<Creature>(uint32 mapid, float x, float y, uint64 guid, Creature* /*fake*/);
 463 template Corpse* ObjectAccessor::GetObjectInWorld<Corpse>(uint32 mapid, float x, float y, uint64 guid, Corpse* /*fake*/);
 464 template GameObject* ObjectAccessor::GetObjectInWorld<GameObject>(uint32 mapid, float x, float y, uint64 guid, GameObject* /*fake*/);
 465 template DynamicObject* ObjectAccessor::GetObjectInWorld<DynamicObject>(uint32 mapid, float x, float y, uint64 guid, DynamicObject* /*fake*/);