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 WorldObject* ObjectAccessor::GetWorldObject(WorldObject const &p, uint64 guid)
  94 {
  95     switch(GUID_HIPART(guid))
  96     {
  97         case HIGHGUID_PLAYER:       return FindPlayer(guid);
  98         case HIGHGUID_GAMEOBJECT:   return p.GetMap()->GetGameObject(guid);
  99         case HIGHGUID_UNIT:         return p.GetMap()->GetCreature(guid);
 100         case HIGHGUID_PET:          return GetPet(guid);
 101         case HIGHGUID_VEHICLE:      return GetVehicle(guid);
 102         case HIGHGUID_DYNAMICOBJECT:return p.GetMap()->GetDynamicObject(guid);
 103         case HIGHGUID_TRANSPORT:    return NULL;
 104         case HIGHGUID_CORPSE:       return GetCorpse(p,guid);
 105         case HIGHGUID_MO_TRANSPORT: return NULL;
 106         default: break;
 107     }
 108
 109     return NULL;
 110 }
 111
 112 Object* ObjectAccessor::GetObjectByTypeMask(WorldObject const &p, uint64 guid, uint32 typemask)
 113 {
 114     switch(GUID_HIPART(guid))
 115     {
 116         case HIGHGUID_ITEM:
 117             if(typemask & TYPEMASK_ITEM && p.GetTypeId() == TYPEID_PLAYER)
 118                 return ((Player const &)p).GetItemByGuid( guid );
 119             break;
 120         case HIGHGUID_PLAYER:
 121             if(typemask & TYPEMASK_PLAYER)
 122                 return FindPlayer(guid);
 123             break;
 124         case HIGHGUID_GAMEOBJECT:
 125             if(typemask & TYPEMASK_GAMEOBJECT)
 126                 return p.GetMap()->GetGameObject(guid);
 127             break;
 128         case HIGHGUID_UNIT:
 129             if(typemask & TYPEMASK_UNIT)
 130                 return p.GetMap()->GetCreature(guid);
 131             break;
 132         case HIGHGUID_PET:
 133             if(typemask & TYPEMASK_UNIT)
 134                 return GetPet(guid);
 135             break;
 136         case HIGHGUID_VEHICLE:
 137             if(typemask & TYPEMASK_UNIT)
 138                 return GetVehicle(guid);
 139             break;
 140         case HIGHGUID_DYNAMICOBJECT:
 141             if(typemask & TYPEMASK_DYNAMICOBJECT)
 142                 return p.GetMap()->GetDynamicObject(guid);
 143             break;
 144         case HIGHGUID_TRANSPORT:
 145         case HIGHGUID_CORPSE:
 146         case HIGHGUID_MO_TRANSPORT:
 147             break;
 148     }
 149
 150     return NULL;
 151 }
 152
 153 Player*
 154 ObjectAccessor::FindPlayer(uint64 guid)
 155 {
 156     Player * plr = GetObjectInWorld(guid, (Player*)NULL);
 157     if(!plr || !plr->IsInWorld())
 158         return NULL;
 159
 160     return plr;
 161 }
 162
 163 Player*
 164 ObjectAccessor::FindPlayerByName(const char *name)
 165 {
 166     //TODO: Player Guard
 167     HashMapHolder<Player>::MapType& m = HashMapHolder<Player>::GetContainer();
 168     HashMapHolder<Player>::MapType::iterator iter = m.begin();
 169     for(; iter != m.end(); ++iter)
 170         if(iter->second->IsInWorld() && ( ::strcmp(name, iter->second->GetName()) == 0 ))
 171             return iter->second;
 172     return NULL;
 173 }
 174
 175 void
 176 ObjectAccessor::SaveAllPlayers()
 177 {
 178     Guard guard(*HashMapHolder<Player*>::GetLock());
 179     HashMapHolder<Player>::MapType& m = HashMapHolder<Player>::GetContainer();
 180     HashMapHolder<Player>::MapType::iterator itr = m.begin();
 181     for(; itr != m.end(); ++itr)
 182         itr->second->SaveToDB();
 183 }
 184
 185 void
 186 ObjectAccessor::UpdateObject(Object* obj, Player* exceptPlayer)
 187 {
 188     UpdateDataMapType update_players;
 189     obj->BuildUpdate(update_players);
 190
 191     WorldPacket packet;
 192     for(UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
 193     {
 194         if(iter->first == exceptPlayer)
 195             continue;
 196
 197         iter->second.BuildPacket(&packet);
 198         iter->first->GetSession()->SendPacket(&packet);
 199         packet.clear();
 200     }
 201 }
 202
 203 void
 204 ObjectAccessor::_buildUpdateObject(Object *obj, UpdateDataMapType &update_players)
 205 {
 206     bool build_for_all = true;
 207     Player *pl = NULL;
 208     if( obj->isType(TYPEMASK_ITEM) )
 209     {
 210         Item *item = static_cast<Item *>(obj);
 211         pl = item->GetOwner();
 212         build_for_all = false;
 213     }
 214
 215     if( pl != NULL )
 216         _buildPacket(pl, obj, update_players);
 217
 218     // Capt: okey for all those fools who think its a real fix
 219     //       THIS IS A TEMP FIX
 220     if( build_for_all )
 221     {
 222         WorldObject * temp = dynamic_cast<WorldObject*>(obj);
 223
 224         //assert(dynamic_cast<WorldObject*>(obj)!=NULL);
 225         if (temp)
 226             _buildChangeObjectForPlayer(temp, update_players);
 227         else
 228             sLog.outDebug("ObjectAccessor: Ln 405 Temp bug fix");
 229     }
 230 }
 231
 232 void
 233 ObjectAccessor::_buildPacket(Player *pl, Object *obj, UpdateDataMapType &update_players)
 234 {
 235     UpdateDataMapType::iterator iter = update_players.find(pl);
 236
 237     if( iter == update_players.end() )
 238     {
 239         std::pair<UpdateDataMapType::iterator, bool> p = update_players.insert( UpdateDataValueType(pl, UpdateData()) );
 240         assert(p.second);
 241         iter = p.first;
 242     }
 243
 244     obj->BuildValuesUpdateBlockForPlayer(&iter->second, iter->first);
 245 }
 246
 247 void
 248 ObjectAccessor::_buildChangeObjectForPlayer(WorldObject *obj, UpdateDataMapType &update_players)
 249 {
 250     CellPair p = MaNGOS::ComputeCellPair(obj->GetPositionX(), obj->GetPositionY());
 251     Cell cell(p);
 252     cell.data.Part.reserved = ALL_DISTRICT;
 253     cell.SetNoCreate();
 254     WorldObjectChangeAccumulator notifier(*obj, update_players);
 255     TypeContainerVisitor<WorldObjectChangeAccumulator, WorldTypeMapContainer > player_notifier(notifier);
 256     CellLock<GridReadGuard> cell_lock(cell, p);
 257     cell_lock->Visit(cell_lock, player_notifier, *obj->GetMap());
 258 }
 259
 260 Pet*
 261 ObjectAccessor::GetPet(uint64 guid)
 262 {
 263     return GetObjectInWorld(guid, (Pet*)NULL);
 264 }
 265
 266 Vehicle*
 267 ObjectAccessor::GetVehicle(uint64 guid)
 268 {
 269     return GetObjectInWorld(guid, (Vehicle*)NULL);
 270 }
 271
 272 Corpse*
 273 ObjectAccessor::GetCorpseForPlayerGUID(uint64 guid)
 274 {
 275     Guard guard(i_corpseGuard);
 276
 277     Player2CorpsesMapType::iterator iter = i_player2corpse.find(guid);
 278     if( iter == i_player2corpse.end() ) return NULL;
 279
 280     assert(iter->second->GetType() != CORPSE_BONES);
 281
 282     return iter->second;
 283 }
 284
 285 void
 286 ObjectAccessor::RemoveCorpse(Corpse *corpse)
 287 {
 288     assert(corpse && corpse->GetType() != CORPSE_BONES);
 289
 290     Guard guard(i_corpseGuard);
 291     Player2CorpsesMapType::iterator iter = i_player2corpse.find(corpse->GetOwnerGUID());
 292     if( iter == i_player2corpse.end() )
 293         return;
 294
 295     // build mapid*cellid -> guid_set map
 296     CellPair cell_pair = MaNGOS::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
 297     uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
 298
 299     objmgr.DeleteCorpseCellData(corpse->GetMapId(), cell_id, corpse->GetOwnerGUID());
 300     corpse->RemoveFromWorld();
 301
 302     i_player2corpse.erase(iter);
 303 }
 304
 305 void
 306 ObjectAccessor::AddCorpse(Corpse *corpse)
 307 {
 308     assert(corpse && corpse->GetType() != CORPSE_BONES);
 309
 310     Guard guard(i_corpseGuard);
 311     assert(i_player2corpse.find(corpse->GetOwnerGUID()) == i_player2corpse.end());
 312     i_player2corpse[corpse->GetOwnerGUID()] = corpse;
 313
 314     // build mapid*cellid -> guid_set map
 315     CellPair cell_pair = MaNGOS::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
 316     uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
 317
 318     objmgr.AddCorpseCellData(corpse->GetMapId(), cell_id, corpse->GetOwnerGUID(), corpse->GetInstanceId());
 319 }
 320
 321 void
 322 ObjectAccessor::AddCorpsesToGrid(GridPair const& gridpair,GridType& grid,Map* map)
 323 {
 324     Guard guard(i_corpseGuard);
 325     for(Player2CorpsesMapType::iterator iter = i_player2corpse.begin(); iter != i_player2corpse.end(); ++iter)
 326         if(iter->second->GetGrid() == gridpair)
 327     {
 328         // verify, if the corpse in our instance (add only corpses which are)
 329         if (map->Instanceable())
 330         {
 331             if (iter->second->GetInstanceId() == map->GetInstanceId())
 332             {
 333                 grid.AddWorldObject(iter->second, iter->second->GetGUID());
 334             }
 335         }
 336         else
 337         {
 338             grid.AddWorldObject(iter->second, iter->second->GetGUID());
 339         }
 340     }
 341 }
 342
 343 Corpse*
 344 ObjectAccessor::ConvertCorpseForPlayer(uint64 player_guid, bool insignia)
 345 {
 346     Corpse *corpse = GetCorpseForPlayerGUID(player_guid);
 347     if(!corpse)
 348     {
 349         //in fact this function is called from several places
 350         //even when player doesn't have a corpse, not an error
 351         //sLog.outError("Try remove corpse that not in map for GUID %ul", player_guid);
 352         return NULL;
 353     }
 354
 355     DEBUG_LOG("Deleting Corpse and spawning bones.");
 356
 357     // remove corpse from player_guid -> corpse map
 358     RemoveCorpse(corpse);
 359
 360     // remove resurrectable corpse from grid object registry (loaded state checked into call)
 361     // do not load the map if it's not loaded
 362     Map *map = MapManager::Instance().FindMap(corpse->GetMapId(), corpse->GetInstanceId());
 363     if(map)
 364         map->Remove(corpse, false);
 365
 366     // remove corpse from DB
 367     corpse->DeleteFromDB();
 368
 369     Corpse *bones = NULL;
 370     // create the bones only if the map and the grid is loaded at the corpse's location
 371     // ignore bones creating option in case insignia
 372     if (map && (insignia ||
 373         (map->IsBattleGroundOrArena() ? sWorld.getConfig(CONFIG_DEATH_BONES_BG_OR_ARENA) : sWorld.getConfig(CONFIG_DEATH_BONES_WORLD))) &&
 374         !map->IsRemovalGrid(corpse->GetPositionX(), corpse->GetPositionY()))
 375     {
 376         // Create bones, don't change Corpse
 377         bones = new Corpse;
 378         bones->Create(corpse->GetGUIDLow());
 379
 380         for (int i = 3; i < CORPSE_END; ++i)                    // don't overwrite guid and object type
 381             bones->SetUInt32Value(i, corpse->GetUInt32Value(i));
 382
 383         bones->SetGrid(corpse->GetGrid());
 384         // bones->m_time = m_time;                              // don't overwrite time
 385         // bones->m_inWorld = m_inWorld;                        // don't overwrite world state
 386         // bones->m_type = m_type;                              // don't overwrite type
 387         bones->Relocate(corpse->GetPositionX(), corpse->GetPositionY(), corpse->GetPositionZ(), corpse->GetOrientation());
 388         bones->SetPhaseMask(corpse->GetPhaseMask(), false);
 389
 390         bones->SetUInt32Value(CORPSE_FIELD_FLAGS, CORPSE_FLAG_UNK2 | CORPSE_FLAG_BONES);
 391         bones->SetUInt64Value(CORPSE_FIELD_OWNER, 0);
 392
 393         for (int i = 0; i < EQUIPMENT_SLOT_END; ++i)
 394         {
 395             if(corpse->GetUInt32Value(CORPSE_FIELD_ITEM + i))
 396                 bones->SetUInt32Value(CORPSE_FIELD_ITEM + i, 0);
 397         }
 398
 399         // add bones in grid store if grid loaded where corpse placed
 400         map->Add(bones);
 401     }
 402
 403     // all references to the corpse should be removed at this point
 404     delete corpse;
 405
 406     return bones;
 407 }
 408
 409 void
 410 ObjectAccessor::Update(uint32 diff)
 411 {
 412     UpdateDataMapType update_players;
 413     {
 414         Guard guard(i_updateGuard);
 415         while(!i_objects.empty())
 416         {
 417             Object* obj = *i_objects.begin();
 418             i_objects.erase(i_objects.begin());
 419             if (!obj)
 420                 continue;
 421             _buildUpdateObject(obj, update_players);
 422             obj->ClearUpdateMask(false);
 423         }
 424     }
 425
 426     WorldPacket packet;                                     // here we allocate a std::vector with a size of 0x10000
 427     for(UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
 428     {
 429         iter->second.BuildPacket(&packet);
 430         iter->first->GetSession()->SendPacket(&packet);
 431         packet.clear();                                     // clean the string
 432     }
 433 }
 434
 435 void
 436 ObjectAccessor::WorldObjectChangeAccumulator::Visit(PlayerMapType &m)
 437 {
 438     for(PlayerMapType::iterator iter = m.begin(); iter != m.end(); ++iter)
 439         if(iter->getSource()->HaveAtClient(&i_object))
 440             ObjectAccessor::_buildPacket(iter->getSource(), &i_object, i_updateDatas);
 441 }
 442
 443 void
 444 ObjectAccessor::UpdateObjectVisibility(WorldObject *obj)
 445 {
 446     CellPair p = MaNGOS::ComputeCellPair(obj->GetPositionX(), obj->GetPositionY());
 447     Cell cell(p);
 448
 449     obj->GetMap()->UpdateObjectVisibility(obj, cell, p);
 450 }
 451
 452 void ObjectAccessor::UpdateVisibilityForPlayer( Player* player )
 453 {
 454     CellPair p = MaNGOS::ComputeCellPair(player->GetPositionX(), player->GetPositionY());
 455     Cell cell(p);
 456     Map* m = player->GetMap();
 457
 458     m->UpdatePlayerVisibility(player, cell, p);
 459     m->UpdateObjectsVisibilityFor(player, cell, p);
 460 }
 461
 462 /// Define the static member of HashMapHolder
 463
 464 template <class T> UNORDERED_MAP< uint64, T* > HashMapHolder<T>::m_objectMap;
 465 template <class T> ACE_Thread_Mutex HashMapHolder<T>::i_lock;
 466
 467 /// Global definitions for the hashmap storage
 468
 469 template class HashMapHolder<Player>;
 470 template class HashMapHolder<Pet>;
 471 template class HashMapHolder<Vehicle>;
 472 template class HashMapHolder<GameObject>;
 473 template class HashMapHolder<DynamicObject>;
 474 template class HashMapHolder<Creature>;
 475 template class HashMapHolder<Corpse>;
 476
 477 template Player* ObjectAccessor::GetObjectInWorld<Player>(uint32 mapid, float x, float y, uint64 guid, Player* /*fake*/);
 478 template Pet* ObjectAccessor::GetObjectInWorld<Pet>(uint32 mapid, float x, float y, uint64 guid, Pet* /*fake*/);
 479 template Vehicle* ObjectAccessor::GetObjectInWorld<Vehicle>(uint32 mapid, float x, float y, uint64 guid, Vehicle* /*fake*/);
 480 template Creature* ObjectAccessor::GetObjectInWorld<Creature>(uint32 mapid, float x, float y, uint64 guid, Creature* /*fake*/);
 481 template Corpse* ObjectAccessor::GetObjectInWorld<Corpse>(uint32 mapid, float x, float y, uint64 guid, Corpse* /*fake*/);
 482 template GameObject* ObjectAccessor::GetObjectInWorld<GameObject>(uint32 mapid, float x, float y, uint64 guid, GameObject* /*fake*/);
 483 template DynamicObject* ObjectAccessor::GetObjectInWorld<DynamicObject>(uint32 mapid, float x, float y, uint64 guid, DynamicObject* /*fake*/);