ObjectAccessor.cpp

Go to the documentation of this file.

/*
* This file is part of Project SkyFire https://www.projectskyfire.org.
* See LICENSE.md file for Copyright information
*/
 
#include "CellImpl.h"
#include "Corpse.h"
#include "Creature.h"
#include "DynamicObject.h"
#include "GameObject.h"
#include "GridNotifiers.h"
#include "GridNotifiersImpl.h"
#include "Item.h"
#include "Map.h"
#include "MapInstanced.h"
#include "MapManager.h"
#include "ObjectAccessor.h"
#include "ObjectDefines.h"
#include "ObjectMgr.h"
#include "ObjectAccessorLifecycle.h"
#include "Opcodes.h"
#include "Pet.h"
#include "Player.h"
#include "Vehicle.h"
#include "World.h"
#include "WorldPacket.h"
 
#include <cmath>
 
template<class T>
void HashMapHolder<T>::Insert(T* o)
{
    SF_UNIQUE_GUARD writeGuard(*GetLock());
    GetContainer()[o->GetGUID()] = o;
}
 
template<class T>
void HashMapHolder<T>::Remove(T* o)
{
    SF_UNIQUE_GUARD writeGuard(*GetLock());
    GetContainer().erase(o->GetGUID());
}
 
template<class T>
T* HashMapHolder<T>::Find(uint64 guid)
{
    SF_SHARED_GUARD readGuard(*GetLock());
    typename MapType::iterator itr = GetContainer().find(guid);
    return (itr != GetContainer().end()) ? itr->second : NULL;
}
 
template<class T>
auto HashMapHolder<T>::GetContainer()->MapType&
{
    static MapType m_objectMap;
    return m_objectMap;
}
 
template<class T>
SF_SHARED_MUTEX* HashMapHolder<T>::GetLock()
{
    static SF_SHARED_MUTEX i_lock;
    return &i_lock;
}

 
template class HashMapHolder<Player>;
template class HashMapHolder<Pet>;
template class HashMapHolder<GameObject>;
template class HashMapHolder<DynamicObject>;
template class HashMapHolder<Creature>;
template class HashMapHolder<Corpse>;
template class HashMapHolder<AreaTrigger>;
 
 
 
ObjectAccessor::ObjectAccessor() { }
 
ObjectAccessor::~ObjectAccessor() { }
 
template<class T> T* ObjectAccessor::GetObjectInWorld(uint32 mapid, float x, float y, uint64 guid, T* /*fake*/)
{
    T* obj = HashMapHolder<T>::Find(guid);
    if (!obj || obj->GetMapId() != mapid)
        return NULL;
 
    CellCoord p = Skyfire::ComputeCellCoord(x, y);
    if (!p.IsCoordValid())
    {
        SF_LOG_ERROR("misc", "ObjectAccessor::GetObjectInWorld: invalid coordinates supplied X:%f Y:%f grid cell [%u:%u]", x, y, p.x_coord, p.y_coord);
        return NULL;
    }
 
    CellCoord q = Skyfire::ComputeCellCoord(obj->GetPositionX(), obj->GetPositionY());
    if (!q.IsCoordValid())
    {
        SF_LOG_ERROR("misc", "ObjectAccessor::GetObjecInWorld: object (GUID: %u TypeId: %u) has invalid coordinates X:%f Y:%f grid cell [%u:%u]", obj->GetGUIDLow(), uint8(obj->GetTypeId()), obj->GetPositionX(), obj->GetPositionY(), q.x_coord, q.y_coord);
        return NULL;
    }
 
    int32 dx = int32(p.x_coord) - int32(q.x_coord);
    int32 dy = int32(p.y_coord) - int32(q.y_coord);
 
    if (dx > -2 && dx < 2 && dy > -2 && dy < 2)
        return obj;
    else
        return NULL;
}
 
Player* ObjectAccessor::GetObjectInWorld(uint64 guid, Player* /*typeSpecifier*/)
{
    Player* player = HashMapHolder<Player>::Find(guid);
    return player && player->IsInWorld() ? player : NULL;
}
 
WorldObject* ObjectAccessor::GetWorldObject(WorldObject const& p, uint64 guid)
{
    switch (GUID_HIPART(guid))
    {
        case HIGHGUID_PLAYER:        return GetPlayer(p, guid);
        case HIGHGUID_TRANSPORT:
        case HIGHGUID_MO_TRANSPORT:
        case HIGHGUID_GAMEOBJECT:    return GetGameObject(p, guid);
        case HIGHGUID_VEHICLE:
        case HIGHGUID_UNIT:          return GetCreature(p, guid);
        case HIGHGUID_PET:           return GetPet(p, guid);
        case HIGHGUID_DYNAMICOBJECT: return GetDynamicObject(p, guid);
        case HIGHGUID_AREATRIGGER:   return GetAreaTrigger(p, guid);
        case HIGHGUID_CORPSE:        return GetCorpse(p, guid);
        default:                     return NULL;
    }
}
 
Object* ObjectAccessor::GetObjectByTypeMask(WorldObject const& p, uint64 guid, uint32 typemask)
{
    switch (GUID_HIPART(guid))
    {
        case HIGHGUID_ITEM:
            if (typemask & TYPEMASK_ITEM && p.GetTypeId() == TypeID::TYPEID_PLAYER)
                return ((Player const&)p).GetItemByGuid(guid);
            break;
        case HIGHGUID_PLAYER:
            if (typemask & TYPEMASK_PLAYER)
                return GetPlayer(p, guid);
            break;
        case HIGHGUID_TRANSPORT:
        case HIGHGUID_MO_TRANSPORT:
        case HIGHGUID_GAMEOBJECT:
            if (typemask & TYPEMASK_GAMEOBJECT)
                return GetGameObject(p, guid);
            break;
        case HIGHGUID_UNIT:
        case HIGHGUID_VEHICLE:
            if (typemask & TYPEMASK_UNIT)
                return GetCreature(p, guid);
            break;
        case HIGHGUID_PET:
            if (typemask & TYPEMASK_UNIT)
                return GetPet(p, guid);
            break;
        case HIGHGUID_DYNAMICOBJECT:
            if (typemask & TYPEMASK_DYNAMICOBJECT)
                return GetDynamicObject(p, guid);
            break;
        case HIGHGUID_AREATRIGGER:
            if (typemask & TYPEMASK_AREATRIGGER)
                return GetAreaTrigger(p, guid);
        case HIGHGUID_CORPSE:
            break;
    }
 
    return NULL;
}
 
Corpse* ObjectAccessor::GetCorpse(WorldObject const& u, uint64 guid)
{
    return GetObjectInMap(guid, u.GetMap(), (Corpse*)NULL);
}
 
GameObject* ObjectAccessor::GetGameObject(WorldObject const& u, uint64 guid)
{
    return GetObjectInMap(guid, u.GetMap(), (GameObject*)NULL);
}
 
Transport* ObjectAccessor::GetTransport(WorldObject const& u, uint64 guid)
{
    if (GUID_HIPART(guid) != HIGHGUID_MO_TRANSPORT)
        return NULL;
 
    return u.GetMap()->GetTransport(guid);
}
 
DynamicObject* ObjectAccessor::GetDynamicObject(WorldObject const& u, uint64 guid)
{
    return GetObjectInMap(guid, u.GetMap(), (DynamicObject*)NULL);
}
 
AreaTrigger* ObjectAccessor::GetAreaTrigger(WorldObject const& u, uint64 guid)
{
    return GetObjectInMap(guid, u.GetMap(), (AreaTrigger*)NULL);
}
 
Unit* ObjectAccessor::GetUnit(WorldObject const& u, uint64 guid)
{
    return GetObjectInMap(guid, u.GetMap(), (Unit*)NULL);
}
 
Creature* ObjectAccessor::GetCreature(WorldObject const& u, uint64 guid)
{
    return GetObjectInMap(guid, u.GetMap(), (Creature*)NULL);
}
 
Pet* ObjectAccessor::GetPet(WorldObject const& u, uint64 guid)
{
    return GetObjectInMap(guid, u.GetMap(), (Pet*)NULL);
}
 
Player* ObjectAccessor::GetPlayer(WorldObject const& u, uint64 guid)
{
    return GetObjectInMap(guid, u.GetMap(), (Player*)NULL);
}
 
Creature* ObjectAccessor::GetCreatureOrPetOrVehicle(WorldObject const& u, uint64 guid)
{
    if (IS_PET_GUID(guid))
        return GetPet(u, guid);
 
    if (IS_CRE_OR_VEH_GUID(guid))
        return GetCreature(u, guid);
 
    return NULL;
}
 
Pet* ObjectAccessor::FindPet(uint64 guid)
{
    return GetObjectInWorld(guid, (Pet*)NULL);
}
 
Player* ObjectAccessor::FindPlayer(uint64 guid)
{
    return GetObjectInWorld(guid, (Player*)NULL);
}
 
Player* ObjectAccessor::FindPlayerInOrOutOfWorld(uint64 guid)
{
    return GetObjectInOrOutOfWorld(guid, (Player*)NULL);
}
 
Unit* ObjectAccessor::FindUnit(uint64 guid)
{
    return GetObjectInWorld(guid, (Unit*)NULL);
}
 
Player* ObjectAccessor::FindPlayerByName(std::string const& name)
{
    SF_SHARED_GUARD readGuard(*HashMapHolder<Player>::GetLock());
    std::string nameStr = name;
    std::transform(nameStr.begin(), nameStr.end(), nameStr.begin(), ::tolower);
    HashMapHolder<Player>::MapType const& m = GetPlayers();
    for (HashMapHolder<Player>::MapType::const_iterator iter = m.begin(); iter != m.end(); ++iter)
    {
        if (!iter->second->IsInWorld())
            continue;
        std::string currentName = iter->second->GetName();
        std::transform(currentName.begin(), currentName.end(), currentName.begin(), ::tolower);
        if (nameStr.compare(currentName) == 0)
            return iter->second;
    }
 
    return NULL;
}
 
void ObjectAccessor::SaveAllPlayers()
{
    SF_SHARED_GUARD readGuard(*HashMapHolder<Player>::GetLock());
    HashMapHolder<Player>::MapType const& m = GetPlayers();
    for (HashMapHolder<Player>::MapType::const_iterator itr = m.begin(); itr != m.end(); ++itr)
        itr->second->SaveToDB();
}
void ObjectAccessor::AddUpdateObject(Object* obj)
{
    SF_UNIQUE_GUARD writeGuard(i_objectLock);
    Skyfire::ObjectAccess::ObjectUpdateQueueAddAction const action =
        Skyfire::ObjectAccess::GetUpdateObjectQueueAddAction(i_objects.find(obj) != i_objects.end());
    if (action == Skyfire::ObjectAccess::OBJECT_UPDATE_QUEUE_ADD_INSERT)
        i_objects.insert(obj);
}
 
void ObjectAccessor::RemoveUpdateObject(Object* obj)
{
    SF_UNIQUE_GUARD writeGuard(i_objectLock);
    std::set<Object*>::iterator itr = i_objects.find(obj);
    Skyfire::ObjectAccess::ObjectUpdateQueueRemoveAction const action =
        Skyfire::ObjectAccess::GetUpdateObjectQueueRemoveAction(itr != i_objects.end());
    if (action == Skyfire::ObjectAccess::OBJECT_UPDATE_QUEUE_REMOVE_ERASE)
        i_objects.erase(itr);
}
 
Corpse* ObjectAccessor::GetCorpseForPlayerGUID(uint64 guid)
{
    SF_SHARED_GUARD readGuard(i_corpseLock);
 
    Player2CorpsesMapType::iterator iter = i_player2corpse.find(guid);
    if (iter == i_player2corpse.end())
        return NULL;
 
    ASSERT(iter->second->GetType() != CorpseType::CORPSE_BONES);
 
    return iter->second;
}
 
void ObjectAccessor::RemoveCorpse(Corpse* corpse)
{
    ASSERT(corpse && corpse->GetType() != CorpseType::CORPSE_BONES);

    if (Map* map = corpse->FindMap())
    {
        corpse->DestroyForNearbyPlayers();
        if (corpse->IsInGrid())
            map->RemoveFromMap(corpse, false);
        else
        {
            corpse->RemoveFromWorld();
            corpse->ResetMap();
        }
    }
    else
 
        corpse->RemoveFromWorld();
 
    // Critical section
    {
        SF_UNIQUE_GUARD writeGuard(i_corpseLock);
        Player2CorpsesMapType::iterator iter = i_player2corpse.find(corpse->GetOwnerGUID());
        Skyfire::ObjectAccess::ObjectCorpseOwnerRemoveAction const action =
            Skyfire::ObjectAccess::GetCorpseOwnerMappingRemoveAction(iter != i_player2corpse.end());
        if (action == Skyfire::ObjectAccess::OBJECT_CORPSE_OWNER_REMOVE_MISSING)
        {
            SF_LOG_ERROR("misc", "ObjectAccessor::RemoveCorpse: missing owner mapping for corpse %u owner %u after world removal.",
                corpse->GetGUIDLow(), GUID_LOPART(corpse->GetOwnerGUID()));
            return;
        }
 
        // build mapid*cellid -> guid_set map
        CellCoord cellCoord = Skyfire::ComputeCellCoord(corpse->GetPositionX(), corpse->GetPositionY());
        sObjectMgr->DeleteCorpseCellData(corpse->GetMapId(), cellCoord.GetId(), GUID_LOPART(corpse->GetOwnerGUID()));
 
        i_player2corpse.erase(iter);
    }
}
 
void ObjectAccessor::AddCorpse(Corpse* corpse)
{
    ASSERT(corpse && corpse->GetType() != CorpseType::CORPSE_BONES);
 
    // Critical section
    {
        SF_UNIQUE_GUARD writeGuard(i_corpseLock);
 
        Skyfire::ObjectAccess::ObjectCorpseOwnerAddAction const action =
            Skyfire::ObjectAccess::GetCorpseOwnerMappingAddAction(i_player2corpse.find(corpse->GetOwnerGUID()) != i_player2corpse.end());
        ASSERT(action == Skyfire::ObjectAccess::OBJECT_CORPSE_OWNER_ADD_INSERT);
        i_player2corpse[corpse->GetOwnerGUID()] = corpse;
 
        // build mapid*cellid -> guid_set map
        CellCoord cellCoord = Skyfire::ComputeCellCoord(corpse->GetPositionX(), corpse->GetPositionY());
        sObjectMgr->AddCorpseCellData(corpse->GetMapId(), cellCoord.GetId(), GUID_LOPART(corpse->GetOwnerGUID()), corpse->GetInstanceId());
    }
}
 
void ObjectAccessor::AddCorpsesToGrid(GridCoord const& gridpair, GridType& grid, Map* map)
{
    SF_SHARED_GUARD readGuard(i_corpseLock);
 
    for (Player2CorpsesMapType::iterator iter = i_player2corpse.begin(); iter != i_player2corpse.end(); ++iter)
    {
        // We need this check otherwise a corpose may be added to a grid twice
        if (iter->second->IsInGrid())
            continue;
 
        if (iter->second->GetGridCoord() == gridpair)
        {
            // verify, if the corpse in our instance (add only corpses which are)
            if (map->Instanceable())
            {
                if (iter->second->GetInstanceId() == map->GetInstanceId())
                    grid.AddWorldObject(iter->second);
            }
            else
                grid.AddWorldObject(iter->second);
        }
    }
}
 
Corpse* ObjectAccessor::ConvertCorpseForPlayer(uint64 player_guid, bool insignia /*=false*/)
{
    Corpse* corpse = GetCorpseForPlayerGUID(player_guid);
    if (!corpse)
    {
        //in fact this function is called from several places
        //even when player doesn't have a corpse, not an error
        return NULL;
    }
 
    SF_LOG_DEBUG("misc", "Deleting Corpse and spawned bones.");
 
    // Map can be NULL
    Map* map = corpse->FindMap();
 
    // remove corpse from player_guid -> corpse map and from current map
    RemoveCorpse(corpse);
 
    // remove corpse from DB
    SQLTransaction trans = CharacterDatabase.BeginTransaction();
    corpse->DeleteFromDB(trans);
    CharacterDatabase.CommitTransaction(trans);
 
    Corpse* bones = NULL;
    // create the bones only if the map and the grid is loaded at the corpse's location
    // ignore bones creating option in case insignia
 
    if (map && (insignia ||
        (map->IsBattlegroundOrArena() ? sWorld->GetBoolConfig(WorldBoolConfigs::CONFIG_DEATH_BONES_BG_OR_ARENA) : sWorld->GetBoolConfig(WorldBoolConfigs::CONFIG_DEATH_BONES_WORLD))) &&
        !map->IsRemovalGrid(corpse->GetPositionX(), corpse->GetPositionY()))
    {
        // Create bones, don't change Corpse
        bones = new Corpse;
        bones->Create(corpse->GetGUIDLow(), map);
 
        for (uint8 i = OBJECT_FIELD_TYPE + 1; i < CORPSE_END; ++i)                    // don't overwrite guid and object type
            bones->SetUInt32Value(i, corpse->GetUInt32Value(i));
 
        bones->SetGridCoord(corpse->GetGridCoord());
        // bones->m_time = m_time;                              // don't overwrite time
        // bones->m_type = m_type;                              // don't overwrite type
        bones->Relocate(corpse->GetPositionX(), corpse->GetPositionY(), corpse->GetPositionZ(), corpse->GetOrientation());
        bones->SetPhaseMask(corpse->GetPhaseMask(), false);
 
        bones->SetUInt32Value(CORPSE_FIELD_FLAGS, CORPSE_FLAG_UNK2 | CORPSE_FLAG_BONES);
        bones->SetUInt64Value(CORPSE_FIELD_OWNER, 0);
 
        for (uint8 i = 0; i < EQUIPMENT_SLOT_END; ++i)
        {
            if (corpse->GetUInt32Value(CORPSE_FIELD_ITEMS + i))
                bones->SetUInt32Value(CORPSE_FIELD_ITEMS + i, 0);
        }
 
        // add bones in grid store if grid loaded where corpse placed
        map->AddToMap(bones);
    }
 
    // all references to the corpse should be removed at this point
    delete corpse;
 
    return bones;
}
 
void ObjectAccessor::RemoveOldCorpses()
{
    time_t now = time(NULL);
    Player2CorpsesMapType::iterator next;
    for (Player2CorpsesMapType::iterator itr = i_player2corpse.begin(); itr != i_player2corpse.end(); itr = next)
    {
        next = itr;
        ++next;
 
        if (!itr->second->IsExpired(now))
            continue;
 
        ConvertCorpseForPlayer(itr->first);
    }
}
 
void ObjectAccessor::Update(uint32 /*diff*/)
{
    UpdateDataMapType update_players;
 
    for (;;)
    {
        Object* obj = NULL;
        {
            SF_UNIQUE_GUARD writeGuard(i_objectLock);
            Skyfire::ObjectAccess::ObjectUpdateQueueDrainAction const action =
                Skyfire::ObjectAccess::GetUpdateObjectQueueDrainAction(i_objects.empty());
            if (action == Skyfire::ObjectAccess::OBJECT_UPDATE_QUEUE_DRAIN_EMPTY)
                break;
 
            obj = *i_objects.begin();
            i_objects.erase(i_objects.begin());
        }
 
        ASSERT(Skyfire::ObjectAccess::CanBuildUpdateForQueuedObject(obj != NULL, obj && obj->IsInWorld()));
        obj->BuildUpdate(update_players);
    }
 
    WorldPacket packet;                                     // here we allocate a std::vector with a size of 0x10000
    for (UpdateDataMapType::iterator iter = update_players.begin(); iter != update_players.end(); ++iter)
    {
        iter->second.BuildPacket(&packet);
        iter->first->GetSession()->SendPacket(&packet);
        packet.clear();                                     // clean the string
    }
}
 
void ObjectAccessor::UnloadAll()
{
    SF_UNIQUE_GUARD writeGuard(i_corpseLock);
    Skyfire::ObjectAccess::ObjectCorpseStorageUnloadAction const action =
        Skyfire::ObjectAccess::GetCorpseStorageUnloadAction(i_player2corpse.empty());
    if (action == Skyfire::ObjectAccess::OBJECT_CORPSE_STORAGE_UNLOAD_EMPTY)
        return;
 
    for (Player2CorpsesMapType::const_iterator itr = i_player2corpse.begin(); itr != i_player2corpse.end(); ++itr)
    {
        itr->second->RemoveFromWorld();
        delete itr->second;
    }
 
    i_player2corpse.clear();
}

 
template <class T> UNORDERED_MAP< uint64, T* > HashMapHolder<T>::m_objectMap;
template <class T> typename SF_SHARED_MUTEX HashMapHolder<T>::i_lock;
 
 
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 Creature* ObjectAccessor::GetObjectInWorld<Creature>(uint32 mapid, float x, float y, uint64 guid, Creature* /*fake*/);
template Corpse* ObjectAccessor::GetObjectInWorld<Corpse>(uint32 mapid, float x, float y, uint64 guid, Corpse* /*fake*/);
template GameObject* ObjectAccessor::GetObjectInWorld<GameObject>(uint32 mapid, float x, float y, uint64 guid, GameObject* /*fake*/);
template DynamicObject* ObjectAccessor::GetObjectInWorld<DynamicObject>(uint32 mapid, float x, float y, uint64 guid, DynamicObject* /*fake*/);