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 "Corpse.h"
  27 #include "WorldSession.h"
  28 #include "WorldPacket.h"
  29 #include "Item.h"
  30 #include "Corpse.h"
  31 #include "GridNotifiers.h"
  32 #include "MapManager.h"
  33 #include "Map.h"
  34 #include "CellImpl.h"
  35 #include "GridNotifiersImpl.h"
  36 #include "Opcodes.h"
  37 #include "ObjectDefines.h"
  38 #include "MapInstanced.h"
  39 #include "World.h"
  40
  41 #include <cmath>
  42
  43 #define CLASS_LOCK MaNGOS::ClassLevelLockable<ObjectAccessor, ZThread::FastMutex>
  44 INSTANTIATE_SINGLETON_2(ObjectAccessor, CLASS_LOCK);
  45 INSTANTIATE_CLASS_MUTEX(ObjectAccessor, ZThread::FastMutex);
  46
  47 ObjectAccessor::ObjectAccessor() {}
  48 ObjectAccessor::~ObjectAccessor() {}
  49
  50 Creature*
  51 ObjectAccessor::GetNPCIfCanInteractWith(Player const &player, uint64 guid, uint32 npcflagmask)
  52 {
  53     // unit checks
  54     if (!guid)
  55         return NULL;
  56
  57     // exist
  58     Creature *unit = GetCreature(player, guid);
  59     if (!unit)
  60         return NULL;
  61
  62     // player check
  63     if(!player.CanInteractWithNPCs(!unit->isSpiritService()))
  64         return NULL;
  65
  66     // appropriate npc type
  67     if(npcflagmask && !unit->HasFlag( UNIT_NPC_FLAGS, npcflagmask ))
  68         return NULL;
  69
  70     // alive or spirit healer
  71     if(!unit->isAlive() && (!unit->isSpiritService() || player.isAlive() ))
  72         return NULL;
  73
  74     // not allow interaction under control
  75     if(unit->GetCharmerOrOwnerGUID())
  76         return NULL;
  77
  78     // not enemy
  79     if( unit->IsHostileTo(&player))
  80         return NULL;
  81
  82     // not unfriendly
  83     FactionTemplateEntry const* factionTemplate = sFactionTemplateStore.LookupEntry(unit->getFaction());
  84     if(factionTemplate)
  85     {
  86         FactionEntry const* faction = sFactionStore.LookupEntry(factionTemplate->faction);
  87         if( faction->reputationListID >= 0 && player.GetReputationRank(faction) <= REP_UNFRIENDLY)
  88             return NULL;
  89     }
  90
  91     // not too far
  92     if(!unit->IsWithinDistInMap(&player,INTERACTION_DISTANCE))
  93         return NULL;
  94
  95     return unit;
  96 }
  97
  98 Creature*
  99 ObjectAccessor::GetCreatureOrPetOrVehicle(WorldObject const &u, uint64 guid)
 100 {
 101     if(Creature *unit = GetPet(guid))
 102         return unit;
 103
 104     if(Creature *unit = GetVehicle(guid))
 105         return unit;
 106
 107     return GetCreature(u, guid);
 108 }
 109
 110 Creature*
 111 ObjectAccessor::GetCreature(WorldObject const &u, uint64 guid)
 112 {
 113     Creature * ret = GetObjectInWorld(guid, (Creature*)NULL);
 114     if(!ret)
 115         return NULL;
 116
 117     if(ret->GetMapId() != u.GetMapId())
 118         return NULL;
 119
 120     if(ret->GetInstanceId() != u.GetInstanceId())
 121         return NULL;
 122
 123     return ret;
 124 }
 125
 126 Unit*
 127 ObjectAccessor::GetUnit(WorldObject const &u, uint64 guid)
 128 {
 129     if(!guid)
 130         return NULL;
 131
 132     if(IS_PLAYER_GUID(guid))
 133         return FindPlayer(guid);
 134
 135     return GetCreatureOrPetOrVehicle(u, guid);
 136 }
 137
 138 Corpse*
 139 ObjectAccessor::GetCorpse(WorldObject const &u, uint64 guid)
 140 {
 141     Corpse * ret = GetObjectInWorld(guid, (Corpse*)NULL);
 142     if(!ret)
 143         return NULL;
 144     if(ret->GetMapId() != u.GetMapId())
 145         return NULL;
 146     if(ret->GetInstanceId() != u.GetInstanceId())
 147         return NULL;
 148     return ret;
 149 }
 150
 151 Object* ObjectAccessor::GetObjectByTypeMask(WorldObject const &p, uint64 guid, uint32 typemask)
 152 {
 153     Object *obj = NULL;
 154
 155     if(typemask & TYPEMASK_PLAYER)
 156     {
 157         obj = FindPlayer(guid);
 158         if(obj) return obj;
 159     }
 160
 161     if(typemask & TYPEMASK_UNIT)
 162     {
 163         obj = GetCreatureOrPetOrVehicle(p,guid);
 164         if(obj) return obj;
 165     }
 166
 167     if(typemask & TYPEMASK_GAMEOBJECT)
 168     {
 169         obj = GetGameObject(p,guid);
 170         if(obj) return obj;
 171     }
 172
 173     if(typemask & TYPEMASK_DYNAMICOBJECT)
 174     {
 175         obj = GetDynamicObject(p,guid);
 176         if(obj) return obj;
 177     }
 178
 179     if(typemask & TYPEMASK_ITEM && p.GetTypeId() == TYPEID_PLAYER)
 180     {
 181         obj = ((Player const &)p).GetItemByGuid( guid );
 182         if(obj) return obj;
 183     }
 184
 185     return NULL;
 186 }
 187
 188 GameObject*
 189 ObjectAccessor::GetGameObject(WorldObject const &u, uint64 guid)
 190 {
 191     GameObject * ret = GetObjectInWorld(guid, (GameObject*)NULL);
 192     if(!ret)
 193         return NULL;
 194     if(ret->GetMapId() != u.GetMapId())
 195         return NULL;
 196     if(ret->GetInstanceId() != u.GetInstanceId())
 197         return NULL;
 198     return ret;
 199 }
 200
 201 DynamicObject*
 202 ObjectAccessor::GetDynamicObject(WorldObject const &u, uint64 guid)
 203 {
 204     DynamicObject * ret = GetObjectInWorld(guid, (DynamicObject*)NULL);
 205     if(!ret)
 206         return NULL;
 207     if(ret->GetMapId() != u.GetMapId())
 208         return NULL;
 209     if(ret->GetInstanceId() != u.GetInstanceId())
 210         return NULL;
 211     return ret;
 212 }
 213
 214 Player*
 215 ObjectAccessor::FindPlayer(uint64 guid)
 216 {
 217     return GetObjectInWorld(guid, (Player*)NULL);
 218 }
 219
 220 Player*
 221 ObjectAccessor::FindPlayerByName(const char *name)
 222 {
 223     //TODO: Player Guard
 224     HashMapHolder<Player>::MapType& m = HashMapHolder<Player>::GetContainer();
 225     HashMapHolder<Player>::MapType::iterator iter = m.begin();
 226     for(; iter != m.end(); ++iter)
 227         if( ::strcmp(name, iter->second->GetName()) == 0 )
 228             return iter->second;
 229     return NULL;
 230 }
 231
 232 void
 233 ObjectAccessor::SaveAllPlayers()
 234 {
 235     Guard guard(*HashMapHolder<Player*>::GetLock());
 236     HashMapHolder<Player>::MapType& m = HashMapHolder<Player>::GetContainer();
 237     HashMapHolder<Player>::MapType::iterator itr = m.begin();
 238     for(; itr != m.end(); ++itr)
 239         itr->second->SaveToDB();
 240 }
 241
 242 void
 243 ObjectAccessor::UpdateObject(Object* obj, Player* exceptPlayer)
 244 {
 245     UpdateDataMapType update_players;
 246     obj->BuildUpdate(update_players);
 247
 248     WorldPacket packet;
 249     for(UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
 250     {
 251         if(iter->first == exceptPlayer)
 252             continue;
 253
 254         iter->second.BuildPacket(&packet);
 255         iter->first->GetSession()->SendPacket(&packet);
 256         packet.clear();
 257     }
 258 }
 259
 260 void
 261 ObjectAccessor::_buildUpdateObject(Object *obj, UpdateDataMapType &update_players)
 262 {
 263     bool build_for_all = true;
 264     Player *pl = NULL;
 265     if( obj->isType(TYPEMASK_ITEM) )
 266     {
 267         Item *item = static_cast<Item *>(obj);
 268         pl = item->GetOwner();
 269         build_for_all = false;
 270     }
 271
 272     if( pl != NULL )
 273         _buildPacket(pl, obj, update_players);
 274
 275     // Capt: okey for all those fools who think its a real fix
 276     //       THIS IS A TEMP FIX
 277     if( build_for_all )
 278     {
 279         WorldObject * temp = dynamic_cast<WorldObject*>(obj);
 280
 281         //assert(dynamic_cast<WorldObject*>(obj)!=NULL);
 282         if (temp)
 283             _buildChangeObjectForPlayer(temp, update_players);
 284         else
 285             sLog.outDebug("ObjectAccessor: Ln 405 Temp bug fix");
 286     }
 287 }
 288
 289 void
 290 ObjectAccessor::_buildPacket(Player *pl, Object *obj, UpdateDataMapType &update_players)
 291 {
 292     UpdateDataMapType::iterator iter = update_players.find(pl);
 293
 294     if( iter == update_players.end() )
 295     {
 296         std::pair<UpdateDataMapType::iterator, bool> p = update_players.insert( UpdateDataValueType(pl, UpdateData()) );
 297         assert(p.second);
 298         iter = p.first;
 299     }
 300
 301     obj->BuildValuesUpdateBlockForPlayer(&iter->second, iter->first);
 302 }
 303
 304 void
 305 ObjectAccessor::_buildChangeObjectForPlayer(WorldObject *obj, UpdateDataMapType &update_players)
 306 {
 307     CellPair p = MaNGOS::ComputeCellPair(obj->GetPositionX(), obj->GetPositionY());
 308     Cell cell(p);
 309     cell.data.Part.reserved = ALL_DISTRICT;
 310     cell.SetNoCreate();
 311     WorldObjectChangeAccumulator notifier(*obj, update_players);
 312     TypeContainerVisitor<WorldObjectChangeAccumulator, WorldTypeMapContainer > player_notifier(notifier);
 313     CellLock<GridReadGuard> cell_lock(cell, p);
 314     cell_lock->Visit(cell_lock, player_notifier, *obj->GetMap());
 315 }
 316
 317 Pet*
 318 ObjectAccessor::GetPet(uint64 guid)
 319 {
 320     return GetObjectInWorld(guid, (Pet*)NULL);
 321 }
 322
 323 Vehicle*
 324 ObjectAccessor::GetVehicle(uint64 guid)
 325 {
 326     return GetObjectInWorld(guid, (Vehicle*)NULL);
 327 }
 328
 329 Corpse*
 330 ObjectAccessor::GetCorpseForPlayerGUID(uint64 guid)
 331 {
 332     Guard guard(i_corpseGuard);
 333
 334     Player2CorpsesMapType::iterator iter = i_player2corpse.find(guid);
 335     if( iter == i_player2corpse.end() ) return NULL;
 336
 337     assert(iter->second->GetType() != CORPSE_BONES);
 338
 339     return iter->second;
 340 }
 341
 342 void
 343 ObjectAccessor::RemoveCorpse(Corpse *corpse)
 344 {
 345     assert(corpse && corpse->GetType() != CORPSE_BONES);
 346
 347     Guard guard(i_corpseGuard);
 348     Player2CorpsesMapType::iterator iter = i_player2corpse.find(corpse->GetOwnerGUID());
 349     if( iter == i_player2corpse.end() )
 350         return;
 351
 352     // build mapid*cellid -> guid_set map
 353     CellPair cell_pair = MaNGOS::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
 354     uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
 355
 356     objmgr.DeleteCorpseCellData(corpse->GetMapId(),cell_id,corpse->GetOwnerGUID());
 357     corpse->RemoveFromWorld();
 358
 359     i_player2corpse.erase(iter);
 360 }
 361
 362 void
 363 ObjectAccessor::AddCorpse(Corpse *corpse)
 364 {
 365     assert(corpse && corpse->GetType() != CORPSE_BONES);
 366
 367     Guard guard(i_corpseGuard);
 368     assert(i_player2corpse.find(corpse->GetOwnerGUID()) == i_player2corpse.end());
 369     i_player2corpse[corpse->GetOwnerGUID()] = corpse;
 370
 371     // build mapid*cellid -> guid_set map
 372     CellPair cell_pair = MaNGOS::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
 373     uint32 cell_id = (cell_pair.y_coord*TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
 374
 375     objmgr.AddCorpseCellData(corpse->GetMapId(),cell_id,corpse->GetOwnerGUID(),corpse->GetInstanceId());
 376 }
 377
 378 void
 379 ObjectAccessor::AddCorpsesToGrid(GridPair const& gridpair,GridType& grid,Map* map)
 380 {
 381     Guard guard(i_corpseGuard);
 382     for(Player2CorpsesMapType::iterator iter = i_player2corpse.begin(); iter != i_player2corpse.end(); ++iter)
 383         if(iter->second->GetGrid()==gridpair)
 384     {
 385         // verify, if the corpse in our instance (add only corpses which are)
 386         if (map->Instanceable())
 387         {
 388             if (iter->second->GetInstanceId() == map->GetInstanceId())
 389             {
 390                 grid.AddWorldObject(iter->second,iter->second->GetGUID());
 391             }
 392         }
 393         else
 394         {
 395             grid.AddWorldObject(iter->second,iter->second->GetGUID());
 396         }
 397     }
 398 }
 399
 400 Corpse*
 401 ObjectAccessor::ConvertCorpseForPlayer(uint64 player_guid, bool insignia)
 402 {
 403     Corpse *corpse = GetCorpseForPlayerGUID(player_guid);
 404     if(!corpse)
 405     {
 406         //in fact this function is called from several places
 407         //even when player doesn't have a corpse, not an error
 408         //sLog.outError("ERROR: Try remove corpse that not in map for GUID %ul", player_guid);
 409         return NULL;
 410     }
 411
 412     DEBUG_LOG("Deleting Corpse and spawning bones.\n");
 413
 414     // remove corpse from player_guid -> corpse map
 415     RemoveCorpse(corpse);
 416
 417     // remove resurrectble corpse from grid object registry (loaded state checked into call)
 418     // do not load the map if it's not loaded
 419     Map *map = MapManager::Instance().FindMap(corpse->GetMapId(), corpse->GetInstanceId());
 420     if(map) map->Remove(corpse,false);
 421
 422     // remove corpse from DB
 423     corpse->DeleteFromDB();
 424
 425     Corpse *bones = NULL;
 426     // create the bones only if the map and the grid is loaded at the corpse's location
 427     // ignore bones creating option in case insignia
 428     if (map && (insignia ||
 429         (map->IsBattleGroundOrArena() ? sWorld.getConfig(CONFIG_DEATH_BONES_BG_OR_ARENA) : sWorld.getConfig(CONFIG_DEATH_BONES_WORLD))) &&
 430         !map->IsRemovalGrid(corpse->GetPositionX(), corpse->GetPositionY()))
 431     {
 432         // Create bones, don't change Corpse
 433         bones = new Corpse;
 434         bones->Create(corpse->GetGUIDLow());
 435
 436         for (int i = 3; i < CORPSE_END; i++)                    // don't overwrite guid and object type
 437             bones->SetUInt32Value(i, corpse->GetUInt32Value(i));
 438
 439         bones->SetGrid(corpse->GetGrid());
 440         // bones->m_time = m_time;                              // don't overwrite time
 441         // bones->m_inWorld = m_inWorld;                        // don't overwrite world state
 442         // bones->m_type = m_type;                              // don't overwrite type
 443         bones->Relocate(corpse->GetPositionX(), corpse->GetPositionY(), corpse->GetPositionZ(), corpse->GetOrientation());
 444         bones->SetMapId(corpse->GetMapId());
 445         bones->SetInstanceId(corpse->GetInstanceId());
 446         bones->SetPhaseMask(corpse->GetPhaseMask(),false);
 447
 448         bones->SetUInt32Value(CORPSE_FIELD_FLAGS, CORPSE_FLAG_UNK2 | CORPSE_FLAG_BONES);
 449         bones->SetUInt64Value(CORPSE_FIELD_OWNER, 0);
 450
 451         for (int i = 0; i < EQUIPMENT_SLOT_END; i++)
 452         {
 453             if(corpse->GetUInt32Value(CORPSE_FIELD_ITEM + i))
 454                 bones->SetUInt32Value(CORPSE_FIELD_ITEM + i, 0);
 455         }
 456
 457         // add bones in grid store if grid loaded where corpse placed
 458         map->Add(bones);
 459     }
 460
 461     // all references to the corpse should be removed at this point
 462     delete corpse;
 463
 464     return bones;
 465 }
 466
 467 void
 468 ObjectAccessor::Update(uint32 diff)
 469 {
 470     UpdateDataMapType update_players;
 471     {
 472         Guard guard(i_updateGuard);
 473         while(!i_objects.empty())
 474         {
 475             Object* obj = *i_objects.begin();
 476             i_objects.erase(i_objects.begin());
 477             if (!obj)
 478                 continue;
 479             _buildUpdateObject(obj, update_players);
 480             obj->ClearUpdateMask(false);
 481         }
 482     }
 483
 484     WorldPacket packet;                                     // here we allocate a std::vector with a size of 0x10000
 485     for(UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
 486     {
 487         iter->second.BuildPacket(&packet);
 488         iter->first->GetSession()->SendPacket(&packet);
 489         packet.clear();                                     // clean the string
 490     }
 491 }
 492
 493 void
 494 ObjectAccessor::UpdatePlayers(uint32 diff)
 495 {
 496     HashMapHolder<Player>::MapType& playerMap = HashMapHolder<Player>::GetContainer();
 497     for(HashMapHolder<Player>::MapType::iterator iter = playerMap.begin(); iter != playerMap.end(); ++iter)
 498         if(iter->second->IsInWorld())
 499             iter->second->Update(diff);
 500 }
 501
 502 void
 503 ObjectAccessor::WorldObjectChangeAccumulator::Visit(PlayerMapType &m)
 504 {
 505     for(PlayerMapType::iterator iter = m.begin(); iter != m.end(); ++iter)
 506         if(iter->getSource()->HaveAtClient(&i_object))
 507             ObjectAccessor::_buildPacket(iter->getSource(), &i_object, i_updateDatas);
 508 }
 509
 510 void
 511 ObjectAccessor::UpdateObjectVisibility(WorldObject *obj)
 512 {
 513     CellPair p = MaNGOS::ComputeCellPair(obj->GetPositionX(), obj->GetPositionY());
 514     Cell cell(p);
 515
 516     obj->GetMap()->UpdateObjectVisibility(obj,cell,p);
 517 }
 518
 519 void ObjectAccessor::UpdateVisibilityForPlayer( Player* player )
 520 {
 521     CellPair p = MaNGOS::ComputeCellPair(player->GetPositionX(), player->GetPositionY());
 522     Cell cell(p);
 523     Map* m = player->GetMap();
 524
 525     m->UpdatePlayerVisibility(player,cell,p);
 526     m->UpdateObjectsVisibilityFor(player,cell,p);
 527 }
 528
 529 /// Define the static member of HashMapHolder
 530
 531 template <class T> UNORDERED_MAP< uint64, T* > HashMapHolder<T>::m_objectMap;
 532 template <class T> ZThread::FastMutex HashMapHolder<T>::i_lock;
 533
 534 /// Global definitions for the hashmap storage
 535
 536 template class HashMapHolder<Player>;
 537 template class HashMapHolder<Pet>;
 538 template class HashMapHolder<Vehicle>;
 539 template class HashMapHolder<GameObject>;
 540 template class HashMapHolder<DynamicObject>;
 541 template class HashMapHolder<Creature>;
 542 template class HashMapHolder<Corpse>;
 543
 544 template Player* ObjectAccessor::GetObjectInWorld<Player>(uint32 mapid, float x, float y, uint64 guid, Player* /*fake*/);
 545 template Pet* ObjectAccessor::GetObjectInWorld<Pet>(uint32 mapid, float x, float y, uint64 guid, Pet* /*fake*/);
 546 template Vehicle* ObjectAccessor::GetObjectInWorld<Vehicle>(uint32 mapid, float x, float y, uint64 guid, Vehicle* /*fake*/);
 547 template Creature* ObjectAccessor::GetObjectInWorld<Creature>(uint32 mapid, float x, float y, uint64 guid, Creature* /*fake*/);
 548 template Corpse* ObjectAccessor::GetObjectInWorld<Corpse>(uint32 mapid, float x, float y, uint64 guid, Corpse* /*fake*/);
 549 template GameObject* ObjectAccessor::GetObjectInWorld<GameObject>(uint32 mapid, float x, float y, uint64 guid, GameObject* /*fake*/);
 550 template DynamicObject* ObjectAccessor::GetObjectInWorld<DynamicObject>(uint32 mapid, float x, float y, uint64 guid, DynamicObject* /*fake*/);