GameObject.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 "Battleground.h"
#include "CellImpl.h"
#include "CreatureAISelector.h"
#include "DynamicTree.h"
#include "GameObjectAI.h"
#include "GameObjectModel.h"
#include "GameObjectTransportTiming.h"
#include "GridNotifiersImpl.h"
#include "Group.h"
#include "GroupMgr.h"
#include "ObjectMgr.h"
#include "OutdoorPvPMgr.h"
#include "Player.h"
#include "PoolMgr.h"
#include "ScriptMgr.h"
#include "SpellMgr.h"
#include "Transport.h"
#include "UpdateFieldFlags.h"
#include "World.h"
#include <G3D/Quat.h>
 
GameObject::GameObject() : WorldObject(false), MapObject(),
m_model(NULL), m_goValue(), m_AI(NULL)
{
    m_objectType |= TYPEMASK_GAMEOBJECT;
    m_objectTypeId = TypeID::TYPEID_GAMEOBJECT;
 
    m_updateFlag = (UPDATEFLAG_STATIONARY_POSITION | UPDATEFLAG_ROTATION);
 
    m_valuesCount = GAMEOBJECT_END;
    m_respawnTime = 0;
    m_respawnDelayTime = 300;
    m_lootState = LootState::GO_NOT_READY;
    m_spawnedByDefault = true;
    m_usetimes = 0;
    m_spellId = 0;
    m_cooldownTime = 0;
    m_goInfo = NULL;
    m_ritualOwner = NULL;
    m_goData = NULL;
 
    m_DBTableGuid = 0;
    m_rotation = 0;
 
    m_lootRecipient = 0;
    m_lootRecipientGroup = 0;
    m_groupLootTimer = 0;
    lootingGroupLowGUID = 0;
 
    ResetLootMode(); // restore default loot mode
    m_stationaryPosition.Relocate(0.0f, 0.0f, 0.0f, 0.0f);
}
 
GameObject::~GameObject()
{
    delete m_AI;
    delete m_model;
    //if (m_uint32Values)                                      // field array can be not exist if GameOBject not loaded
    //    CleanupsBeforeDelete();
}
 
bool GameObject::AIM_Initialize()
{
    if (m_AI)
        delete m_AI;
 
    m_AI = FactorySelector::SelectGameObjectAI(this);
 
    if (!m_AI)
        return false;
 
    m_AI->InitializeAI();
    return true;
}
 
std::string GameObject::GetAIName() const
{
    if (GameObjectTemplate const* got = sObjectMgr->GetGameObjectTemplate(GetEntry()))
        return got->AIName;
 
    return "";
}
 
void GameObject::CleanupsBeforeDelete(bool /*finalCleanup*/)
{
    if (IsInWorld())
        RemoveFromWorld();
 
    if (m_uint32Values)                                      // field array can be not exist if GameOBject not loaded
        RemoveFromOwner();
 
    if (GetTransport() && !ToTransport())
    {
        GetTransport()->RemovePassenger(this);
        SetTransport(NULL);
        m_movementInfo.transport.Reset();
    }
}
 
void GameObject::RemoveFromOwner()
{
    uint64 ownerGUID = GetOwnerGUID();
    if (!ownerGUID)
        return;
 
    if (Unit* owner = ObjectAccessor::GetUnit(*this, ownerGUID))
    {
        owner->RemoveGameObject(this, false);
        ASSERT(!GetOwnerGUID());
        return;
    }
 
    const char* ownerType = "creature";
    if (IS_PLAYER_GUID(ownerGUID))
        ownerType = "player";
    else if (IS_PET_GUID(ownerGUID))
        ownerType = "pet";
 
    SF_LOG_FATAL("misc", "Removed GameObject (GUID: %u Entry: %u SpellId: %u LinkedGO: %u) that just lost any reference to the owner (GUID: %u Type: '%s') GO list",
        GetGUIDLow(), GetGOInfo()->entry, m_spellId, GetGOInfo()->GetLinkedGameObjectEntry(), GUID_LOPART(ownerGUID), ownerType);
    SetOwnerGUID(0);
}
 
void GameObject::AddToWorld()
{
    if (!IsInWorld())
    {
        if (m_zoneScript)
            m_zoneScript->OnGameObjectCreate(this);
 
        sObjectAccessor->AddObject(this);
 
        // The state can be changed after GameObject::Create but before GameObject::AddToWorld
        bool toggledState = GetGoType() == GAMEOBJECT_TYPE_CHEST ? getLootState() == LootState::GO_READY : (GetGoState() == GOState::GO_STATE_READY || IsTransport());
        if (m_model)
            GetMap()->InsertGameObjectModel(*m_model);
 
        EnableCollision(toggledState);
        WorldObject::AddToWorld();
    }
}
 
void GameObject::RemoveFromWorld()
{
    if (IsInWorld())
    {
        if (m_zoneScript)
            m_zoneScript->OnGameObjectRemove(this);
 
        RemoveFromOwner();
        if (m_model)
            if (GetMap()->ContainsGameObjectModel(*m_model))
                GetMap()->RemoveGameObjectModel(*m_model);
        WorldObject::RemoveFromWorld();
        sObjectAccessor->RemoveObject(this);
    }
}
 
bool GameObject::Create(uint32 guidlow, uint32 name_id, Map* map, float x, float y, float z, float ang, float rotation0, float rotation1, float rotation2, float rotation3, uint32 animprogress, GOState go_state, uint32 artKit)
{
    ASSERT(map);
    SetMap(map);
 
    Relocate(x, y, z, ang);
    m_stationaryPosition.Relocate(x, y, z, ang);
    if (!IsPositionValid())
    {
        SF_LOG_ERROR("misc", "Gameobject (GUID: %u Entry: %u) not created. Suggested coordinates isn't valid (X: %f Y: %f)", guidlow, name_id, x, y);
        return false;
    }
 
    SetZoneScript();
    if (m_zoneScript)
    {
        name_id = m_zoneScript->GetGameObjectEntry(guidlow, name_id);
        if (!name_id)
            return false;
    }
 
    GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(name_id);
    if (!goinfo)
    {
        SF_LOG_ERROR("sql.sql", "Gameobject (GUID: %u Entry: %u) not created: non-existing entry in `gameobject_template`. Map: %u (X: %f Y: %f Z: %f)", guidlow, name_id, map->GetId(), x, y, z);
        return false;
    }
 
    HighGuid guidHigh = HIGHGUID_GAMEOBJECT;
    if (goinfo->type == GAMEOBJECT_TYPE_TRANSPORT)
    {
        m_updateFlag |= UPDATEFLAG_TRANSPORT;
        guidHigh = HIGHGUID_TRANSPORT;
    }
 
    Object::_Create(guidlow, goinfo->entry, guidHigh);
 
    m_goInfo = goinfo;
 
    if (goinfo->type >= MAX_GAMEOBJECT_TYPE)
    {
        SF_LOG_ERROR("sql.sql", "Gameobject (GUID: %u Entry: %u) not created: non-existing GO type '%u' in `gameobject_template`. It will crash client if created.", guidlow, name_id, goinfo->type);
        return false;
    }
 
    SetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 0, rotation0);
    SetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 1, rotation1);
 
    UpdateRotationFields(rotation2, rotation3);              // GAMEOBJECT_FACING, GAMEOBJECT_ROTATION, GAMEOBJECT_FIELD_PARENT_ROTATION+2/3
 
    SetObjectScale(goinfo->size);
 
    SetUInt32Value(GAMEOBJECT_FIELD_FACTION_TEMPLATE, goinfo->faction);
    SetUInt32Value(GAMEOBJECT_FIELD_FLAGS, goinfo->flags);
 
    SetEntry(goinfo->entry);
 
    // set name for logs usage, doesn't affect anything ingame
    SetName(goinfo->name);
 
    SetDisplayId(goinfo->displayId);
 
    m_model = CreateModel();
    // GAMEOBJECT_FIELD_STATE_SPELL_VISUAL_ID, index at 0, 1, 2 and 3
    SetGoType(GameobjectTypes(goinfo->type));
    SetGoState(go_state);
    SetGoArtKit(artKit);
 
    SetGoHealth(0xFF);
 
    switch (goinfo->type)
    {
        case GAMEOBJECT_TYPE_FISHINGHOLE:
            SetGoAnimProgress(animprogress);
            m_goValue.FishingHole.MaxOpens = std::rand() % GetGOInfo()->fishinghole.maxSuccessOpens + GetGOInfo()->fishinghole.minSuccessOpens;
            break;
        case GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING:
            m_goValue.Building.Health = goinfo->building.intactNumHits + goinfo->building.damagedNumHits;
            m_goValue.Building.MaxHealth = m_goValue.Building.Health;
            SetGoAnimProgress(255);
            SetUInt32Value(GAMEOBJECT_FIELD_PARENT_ROTATION, m_goInfo->building.destructibleData);
            break;
        case GAMEOBJECT_TYPE_TRANSPORT:
        {
            InitializeLegacyTransport();
            GOState const initialTransportState = GOState(Skyfire::GameObjects::GetInitialLegacyTransportState(
                goinfo->transport.startOpen != 0, !m_transportPauseTimes.empty()));
            SetByteValue(GAMEOBJECT_FIELD_PERCENT_HEALTH, 0, GetGOStateValue(initialTransportState));
            SetLegacyTransportStopped(!m_transportPauseTimes.empty());
            SetGoAnimProgress(animprogress);
            break;
        }
        case GAMEOBJECT_TYPE_FISHINGNODE:
            SetGoAnimProgress(0);
            break;
        case GAMEOBJECT_TYPE_TRAP:
            if (GetGOInfo()->trap.stealthed)
            {
                m_stealth.AddFlag(STEALTH_TRAP);
                m_stealth.AddValue(STEALTH_TRAP, 70);
            }
 
            if (GetGOInfo()->trap.invisible)
            {
                m_invisibility.AddFlag(INVISIBILITY_TRAP);
                m_invisibility.AddValue(INVISIBILITY_TRAP, 300);
            }
            break;
        default:
            SetGoAnimProgress(animprogress);
            break;
    }
    LastUsedScriptID = GetGOInfo()->ScriptId;
    AIM_Initialize();
 
    // Initialize loot duplicate count depending on raid difficulty
    if (map->Is25ManRaid())
        loot.maxDuplicates = 3;
 
    return true;
}
 
void GameObject::Update(uint32 diff)
{
    if (AI())
        AI()->UpdateAI(diff);
    else if (!AIM_Initialize())
        SF_LOG_ERROR("misc", "Could not initialize GameObjectAI");
 
    if (GetGoType() == GAMEOBJECT_TYPE_TRANSPORT)
        UpdateLegacyTransportPathProgress();
 
    switch (m_lootState)
    {
        case LootState::GO_NOT_READY:
        {
            switch (GetGoType())
            {
                case GAMEOBJECT_TYPE_TRAP:
                {
                    // Arming Time for GAMEOBJECT_TYPE_TRAP (6)
                    GameObjectTemplate const* goInfo = GetGOInfo();
                    // Bombs
                    if (goInfo->trap.type == 2)
                        m_cooldownTime = time(NULL) + 10;   // Hardcoded tooltip value
                    else if (Unit* owner = GetOwner())
                    {
                        if (owner->IsInCombat())
                            m_cooldownTime = time(NULL) + goInfo->trap.startDelay;
                    }
                    m_lootState = LootState::GO_READY;
                    break;
                }
                /* TODO: Fix movement in unloaded grid - currently GO will just disappear
                case GAMEOBJECT_TYPE_TRANSPORT:
                {
                    if (!m_goValue.Transport.AnimationInfo)
                        break;
 
                    if (GetGoState() == GO_STATE_READY)
                    {
                        m_goValue.Transport.PathProgress += diff;
                        uint32 timer = m_goValue.Transport.PathProgress % m_goValue.Transport.AnimationInfo->TotalTime;
                        TransportAnimationEntry const* node = m_goValue.Transport.AnimationInfo->GetAnimNode(timer);
                        if (node && m_goValue.Transport.CurrentSeg != node->TimeSeg)
                        {
                            m_goValue.Transport.CurrentSeg = node->TimeSeg;
 
                            G3D::Quat rotation = m_goValue.Transport.AnimationInfo->GetAnimRotation(timer);
                            G3D::Vector3 pos = rotation.toRotationMatrix()
                                             * G3D::Matrix3::fromEulerAnglesZYX(GetOrientation(), 0.0f, 0.0f)
                                             * G3D::Vector3(node->X, node->Y, node->Z);
 
                            pos += G3D::Vector3(GetStationaryX(), GetStationaryY(), GetStationaryZ());
 
                            G3D::Vector3 src(GetPositionX(), GetPositionY(), GetPositionZ());
 
                            sLog->outInfo("misc", "Src: %s Dest: %s", src.toString().c_str(), pos.toString().c_str());
 
                            GetMap()->GameObjectRelocation(this, pos.x, pos.y, pos.z, GetOrientation());
                        }
                    }
                    break;
                }
                */
                case GAMEOBJECT_TYPE_FISHINGNODE:
                {
                    // fishing code (bobber ready)
                    if (time(NULL) > m_respawnTime - FISHING_BOBBER_READY_TIME)
                    {
                        // splash bobber (bobber ready now)
                        Unit* caster = GetOwner();
                        if (caster && caster->GetTypeId() == TypeID::TYPEID_PLAYER)
                        {
                            SetGoState(GOState::GO_STATE_ACTIVE);
                            SetUInt32Value(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_NODESPAWN);
 
                            UpdateData udata(caster->GetMapId());
                            WorldPacket packet;
                            BuildValuesUpdateBlockForPlayer(&udata, caster->ToPlayer());
                            udata.BuildPacket(&packet);
                            caster->ToPlayer()->SendDirectMessage(&packet);
 
                            SendCustomAnim(GetGoAnimProgress());
                        }
 
                        m_lootState = LootState::GO_READY;                 // can be successfully open with some chance
                    }
                    return;
                }
                default:
                    m_lootState = LootState::GO_READY;                         // for other GOis same switched without delay to GO_READY
                    break;
            }
            // NO BREAK for switch (m_lootState)
        }
        case LootState::GO_READY:
        {
            if (m_respawnTime > 0)                          // timer on
            {
                time_t now = time(NULL);
                if (m_respawnTime <= now)            // timer expired
                {
                    uint64 dbtableHighGuid = MAKE_NEW_GUID(m_DBTableGuid, GetEntry(), HIGHGUID_GAMEOBJECT);
                    time_t linkedRespawntime = GetMap()->GetLinkedRespawnTime(dbtableHighGuid);
                    if (linkedRespawntime)             // Can't respawn, the master is dead
                    {
                        uint64 targetGuid = sObjectMgr->GetLinkedRespawnGuid(dbtableHighGuid);
                        if (targetGuid == dbtableHighGuid) // if linking self, never respawn (check delayed to next day)
                            SetRespawnTime(DAY);
                        else
                            m_respawnTime = (now > linkedRespawntime ? now : linkedRespawntime) + std::rand() % MINUTE + 5; // else copy time from master and add a little
                        SaveRespawnTime(); // also save to DB immediately
                        return;
                    }
 
                    m_respawnTime = 0;
                    m_SkillupList.clear();
                    m_usetimes = 0;
 
                    switch (GetGoType())
                    {
                        case GAMEOBJECT_TYPE_FISHINGNODE:   //  can't fish now
                        {
                            Unit* caster = GetOwner();
                            if (caster && caster->GetTypeId() == TypeID::TYPEID_PLAYER)
                            {
                                caster->ToPlayer()->RemoveGameObject(this, false);
 
                                WorldPacket data(SMSG_FISH_ESCAPED, 0);
                                caster->ToPlayer()->SendDirectMessage(&data);
                            }
                            // can be delete
                            m_lootState = LootState::GO_JUST_DEACTIVATED;
                            return;
                        }
                        case GAMEOBJECT_TYPE_DOOR:
                        case GAMEOBJECT_TYPE_BUTTON:
                            //we need to open doors if they are closed (add there another condition if this code breaks some usage, but it need to be here for battlegrounds)
                            if (GetGoState() != GOState::GO_STATE_READY)
                                ResetDoorOrButton();
                            break;
                        case GAMEOBJECT_TYPE_FISHINGHOLE:
                            // Initialize a new max fish count on respawn
                            m_goValue.FishingHole.MaxOpens = std::rand() % GetGOInfo()->fishinghole.maxSuccessOpens + GetGOInfo()->fishinghole.minSuccessOpens;
                            break;
                        default:
                            break;
                    }
 
                    if (!m_spawnedByDefault)        // despawn timer
                    {
                        // can be despawned or destroyed
                        SetLootState(LootState::GO_JUST_DEACTIVATED);
                        return;
                    }
                    // respawn timer
                    uint32 poolid = GetDBTableGUIDLow() ? sPoolMgr->IsPartOfAPool<GameObject>(GetDBTableGUIDLow()) : 0;
                    if (poolid)
                        sPoolMgr->UpdatePool<GameObject>(poolid, GetDBTableGUIDLow());
                    else
                        GetMap()->AddToMap(this);
                }
            }
 
            if (isSpawned())
            {
                // traps can have time and can not have
                GameObjectTemplate const* goInfo = GetGOInfo();
                if (goInfo->type == GAMEOBJECT_TYPE_TRAP)
                {
                    if (m_cooldownTime >= time(NULL))
                        return;
 
                    // Type 2 - Bomb (will go away after casting it's spell)
                    if (goInfo->trap.type == 2)
                    {
                        if (goInfo->trap.spellId)
                            CastSpell(NULL, goInfo->trap.spellId);  // FIXME: null target won't work for target type 1
                        SetLootState(LootState::GO_JUST_DEACTIVATED);
                        break;
                    }
                    // Type 0 and 1 - trap (type 0 will not get removed after casting a spell)
                    Unit* owner = GetOwner();
                    Unit* ok = NULL;                            // pointer to appropriate target if found any
 
                    bool IsBattlegroundTrap = false;
                    //FIXME: this is activation radius (in different casting radius that must be selected from spell data)
                    float radius = (float)(goInfo->trap.radius) / 3 * 2; 
                    if (!radius)
                    {
                        if (goInfo->trap.cooldown != 3)            // cast in other case (at some triggering/linked go/etc explicit call)
                            return;
                        else
                        {
                            if (m_respawnTime > 0)
                                break;
 
                            radius = (float)goInfo->trap.cooldown;       // battlegrounds gameobjects has data2 == 0 && data5 == 3
                            IsBattlegroundTrap = true;
 
                            if (!radius)
                                return;
                        }
                    }
 
                    // Note: this hack with search required until GO casting not implemented
                    // search unfriendly creature
                    if (owner && goInfo->trap.autoCloseTime != -1) // hunter trap; -1 = environmental (campfire)
                    {
                        Skyfire::AnyUnfriendlyNoTotemUnitInObjectRangeCheck checker(this, owner, radius);
                        Skyfire::UnitSearcher<Skyfire::AnyUnfriendlyNoTotemUnitInObjectRangeCheck> searcher(this, ok, checker);
                        VisitNearbyGridObject(radius, searcher);
                        if (!ok) VisitNearbyWorldObject(radius, searcher);
                    }
                    else                                        // environmental trap
                    {
                        // environmental damage spells already have around enemies targeting but this not help in case not existed GO casting support
                        // affect only players
                        Player* player = NULL;
                        Skyfire::AnyPlayerInObjectRangeCheck checker(this, radius);
                        Skyfire::PlayerSearcher<Skyfire::AnyPlayerInObjectRangeCheck> searcher(this, player, checker);
                        VisitNearbyWorldObject(radius, searcher);
                        ok = player;
                    }
 
                    if (ok)
                    {
                        // some traps do not have spell but should be triggered
                        if (goInfo->trap.spellId)
                            CastSpell(ok, goInfo->trap.spellId);
 
                        m_cooldownTime = time(NULL) + (goInfo->trap.cooldown ? goInfo->trap.cooldown : uint32(4));   // template or 4 seconds
 
                        if (goInfo->trap.type == 1)
                            SetLootState(LootState::GO_JUST_DEACTIVATED);
 
                        if (IsBattlegroundTrap && ok->GetTypeId() == TypeID::TYPEID_PLAYER)
                        {
                            //Battleground gameobjects case
                            if (ok->ToPlayer()->InBattleground())
                                if (Battleground* bg = ok->ToPlayer()->GetBattleground())
                                    bg->HandleTriggerBuff(GetGUID());
                        }
                    }
                }
                else if (uint32 max_charges = goInfo->GetCharges())
                {
                    if (m_usetimes >= max_charges)
                    {
                        m_usetimes = 0;
                        SetLootState(LootState::GO_JUST_DEACTIVATED);      // can be despawned or destroyed
                    }
                }
            }
 
            break;
        }
        case LootState::GO_ACTIVATED:
        {
            switch (GetGoType())
            {
                case GAMEOBJECT_TYPE_DOOR:
                case GAMEOBJECT_TYPE_BUTTON:
                    if (GetGOInfo()->GetAutoCloseTime() && (m_cooldownTime < time(NULL)))
                        ResetDoorOrButton();
                    break;
                case GAMEOBJECT_TYPE_GOOBER:
                    if (m_cooldownTime < time(NULL))
                    {
                        RemoveFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_IN_USE);
 
                        SetLootState(LootState::GO_JUST_DEACTIVATED);
                        m_cooldownTime = 0;
                    }
                    break;
                case GAMEOBJECT_TYPE_CHEST:
                    if (m_groupLootTimer)
                    {
                        if (m_groupLootTimer <= diff)
                        {
                            Group* group = sGroupMgr->GetGroupByGUID(lootingGroupLowGUID);
                            if (group)
                                group->EndRoll(&loot);
                            m_groupLootTimer = 0;
                            lootingGroupLowGUID = 0;
                        }
                        else m_groupLootTimer -= diff;
                    }
                default:
                    break;
            }
            break;
        }
        case LootState::GO_JUST_DEACTIVATED:
        {
            //if Gameobject should cast spell, then this, but some GOs (type = 10) should be destroyed
            if (GetGoType() == GAMEOBJECT_TYPE_GOOBER)
            {
                uint32 spellId = GetGOInfo()->goober.spellId;
 
                if (spellId)
                {
                    for (std::set<uint64>::const_iterator it = m_unique_users.begin(); it != m_unique_users.end(); ++it)
                        // m_unique_users can contain only player GUIDs
                        if (Player* owner = ObjectAccessor::GetPlayer(*this, *it))
                            owner->CastSpell(owner, spellId, false);
 
                    m_unique_users.clear();
                    m_usetimes = 0;
                }
 
                SetGoState(GOState::GO_STATE_READY);
 
                //any return here in case battleground traps
                if (GetGOInfo()->flags & GO_FLAG_NODESPAWN)
                    return;
            }
 
            loot.clear();

            if (GetSpellId() || GetOwnerGUID())
            {
                SetRespawnTime(0);
                Delete();
                return;
            }
 
            SetLootState(LootState::GO_READY);
 
            //burning flags in some battlegrounds, if you find better condition, just add it
            if (GetGOInfo()->IsDespawnAtAction() || GetGoAnimProgress() > 0)
            {
                SendObjectDeSpawnAnim(GetGUID());
                //reset flags
                SetUInt32Value(GAMEOBJECT_FIELD_FLAGS, GetGOInfo()->flags);
            }
 
            if (!m_respawnDelayTime)
                return;
 
            if (!m_spawnedByDefault)
            {
                m_respawnTime = 0;
                UpdateObjectVisibility();
                return;
            }
 
            m_respawnTime = time(NULL) + m_respawnDelayTime;
 
            // if option not set then object will be saved at grid unload
            if (sWorld->GetBoolConfig(WorldBoolConfigs::CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY))
                SaveRespawnTime();
 
            UpdateObjectVisibility();
 
            break;
        }
    }
    sScriptMgr->OnGameObjectUpdate(this, diff);
}
 
void GameObject::Refresh()
{
    // not refresh despawned not casted GO (despawned casted GO destroyed in all cases anyway)
    if (m_respawnTime > 0 && m_spawnedByDefault)
        return;
 
    if (isSpawned())
        GetMap()->AddToMap(this);
}
 
void GameObject::AddUniqueUse(Player* player)
{
    AddUse();
    m_unique_users.insert(player->GetGUID());
}
 
void GameObject::Delete()
{
    SetLootState(LootState::GO_NOT_READY);
    RemoveFromOwner();
 
    SendObjectDeSpawnAnim(GetGUID());
 
    SetGoState(GOState::GO_STATE_READY);
    SetUInt32Value(GAMEOBJECT_FIELD_FLAGS, GetGOInfo()->flags);
 
    uint32 poolid = GetDBTableGUIDLow() ? sPoolMgr->IsPartOfAPool<GameObject>(GetDBTableGUIDLow()) : 0;
    if (poolid)
        sPoolMgr->UpdatePool<GameObject>(poolid, GetDBTableGUIDLow());
    else
        AddObjectToRemoveList();
}
 
void GameObject::getFishLoot(Loot* fishloot, Player* loot_owner)
{
    fishloot->clear();
 
    uint32 zone, subzone;
    GetZoneAndAreaId(zone, subzone);
 
    // if subzone loot exist use it
    if (!fishloot->FillLoot(subzone, LootTemplates_Fishing, loot_owner, true, true))
        // else use zone loot (must exist in like case)
        fishloot->FillLoot(zone, LootTemplates_Fishing, loot_owner, true);
}
 
void GameObject::SaveToDB()
{
    // this should only be used when the gameobject has already been loaded
    // preferably after adding to map, because mapid may not be valid otherwise
    GameObjectData const* data = sObjectMgr->GetGOData(m_DBTableGuid);
    if (!data)
    {
        SF_LOG_ERROR("misc", "GameObject::SaveToDB failed, cannot get gameobject data!");
        return;
    }
 
    SaveToDB(GetMapId(), data->spawnMask);
}
 
void GameObject::SaveToDB(uint32 mapid, uint32 spawnMask)
{
    const GameObjectTemplate* goI = GetGOInfo();
 
    if (!goI)
        return;
 
    if (!m_DBTableGuid)
        m_DBTableGuid = GetGUIDLow();
    // update in loaded data (changing data only in this place)
    GameObjectData& data = sObjectMgr->NewGOData(m_DBTableGuid);
 
    // data->guid = guid must not be updated at save
    data.id = GetEntry();
    data.mapid = mapid;
    data.posX = GetPositionX();
    data.posY = GetPositionY();
    data.posZ = GetPositionZ();
    data.orientation = GetOrientation();
    data.rotation0 = GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 0);
    data.rotation1 = GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 1);
    data.rotation2 = GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 2);
    data.rotation3 = GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 3);
    data.spawntimesecs = m_spawnedByDefault ? m_respawnDelayTime : -(int32)m_respawnDelayTime;
    data.animprogress = GetGoAnimProgress();
    data.go_state = GetGoState();
    data.spawnMask = spawnMask;
    data.artKit = GetGoArtKit();
 
    // Update in DB
    SQLTransaction trans = WorldDatabase.BeginTransaction();
 
    uint8 index = 0;
 
    PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_GAMEOBJECT);
    stmt->setUInt32(0, m_DBTableGuid);
    trans->Append(stmt);
 
    stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_GAMEOBJECT);
    stmt->setUInt32(index++, m_DBTableGuid);
    stmt->setUInt32(index++, GetEntry());
    stmt->setUInt16(index++, uint16(mapid));
    stmt->setUInt32(index++, spawnMask);
    stmt->setFloat(index++, GetPositionX());
    stmt->setFloat(index++, GetPositionY());
    stmt->setFloat(index++, GetPositionZ());
    stmt->setFloat(index++, GetOrientation());
    stmt->setFloat(index++, GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION));
    stmt->setFloat(index++, GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 1));
    stmt->setFloat(index++, GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 2));
    stmt->setFloat(index++, GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 3));
    stmt->setInt32(index++, int32(m_respawnDelayTime));
    stmt->setUInt8(index++, GetGoAnimProgress());
    stmt->setUInt8(index++, uint8(GetGoState()));
    trans->Append(stmt);
 
    WorldDatabase.CommitTransaction(trans);
}
 
bool GameObject::LoadGameObjectFromDB(uint32 guid, Map* map, bool addToMap)
{
    GameObjectData const* data = sObjectMgr->GetGOData(guid);
 
    if (!data)
    {
        SF_LOG_ERROR("sql.sql", "Gameobject (GUID: %u) not found in table `gameobject`, can't load. ", guid);
        return false;
    }
 
    uint32 entry = data->id;
    //uint32 map_id = data->mapid;                          // already used before call
    float x = data->posX;
    float y = data->posY;
    float z = data->posZ;
    float ang = data->orientation;
 
    float rotation0 = data->rotation0;
    float rotation1 = data->rotation1;
    float rotation2 = data->rotation2;
    float rotation3 = data->rotation3;
 
    uint32 animprogress = data->animprogress;
    GOState go_state = data->go_state;
    uint32 artKit = data->artKit;
 
    m_DBTableGuid = guid;
    if (map->GetInstanceId() != 0) guid = sObjectMgr->GenerateLowGuid(HIGHGUID_GAMEOBJECT);
 
    if (!Create(guid, entry, map, x, y, z, ang, rotation0, rotation1, rotation2, rotation3, animprogress, go_state, artKit))
        return false;
 
    // unset flag 0x04 for questgiver objects if they have it. no idea why they have it.
    if ((GetGOInfo()->type == GAMEOBJECT_TYPE_QUESTGIVER) && (GetGOInfo()->flags & GO_FLAG_INTERACT_COND))
        RemoveFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_INTERACT_COND);
 
    if (data->phaseid)
        SetPhased(data->phaseid, false, true);
 
    if (data->phaseGroup)
    {
        for (auto ph : GetPhasesForGroup(data->phaseGroup))
            SetPhased(ph, false, true);
    }
 
    if (data->spawntimesecs >= 0)
    {
        m_spawnedByDefault = true;
 
        if (!GetGOInfo()->GetDespawnPossibility() && !GetGOInfo()->IsDespawnAtAction())
        {
            SetFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_NODESPAWN);
            m_respawnDelayTime = 0;
            m_respawnTime = 0;
        }
        else
        {
            m_respawnDelayTime = data->spawntimesecs;
            m_respawnTime = GetMap()->GetGORespawnTime(m_DBTableGuid);
 
            // ready to respawn
            if (m_respawnTime && m_respawnTime <= time(NULL))
            {
                m_respawnTime = 0;
                GetMap()->RemoveGORespawnTime(m_DBTableGuid);
            }
        }
    }
    else
    {
        m_spawnedByDefault = false;
        m_respawnDelayTime = -data->spawntimesecs;
        m_respawnTime = 0;
    }
 
    m_goData = data;
 
    if (addToMap && !GetMap()->AddToMap(this))
        return false;
 
    return true;
}
 
void GameObject::DeleteFromDB()
{
    GetMap()->RemoveGORespawnTime(m_DBTableGuid);
    sObjectMgr->DeleteGOData(m_DBTableGuid);
 
    PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_GAMEOBJECT);
 
    stmt->setUInt32(0, m_DBTableGuid);
 
    WorldDatabase.Execute(stmt);
 
    stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_EVENT_GAMEOBJECT);
 
    stmt->setUInt32(0, m_DBTableGuid);
 
    WorldDatabase.Execute(stmt);
}
 
GameObject* GameObject::GetGameObject(WorldObject& object, uint64 guid)
{
    return object.GetMap()->GetGameObject(guid);
}
 
/*********************************************************/
/***                    QUEST SYSTEM                   ***/
/*********************************************************/
bool GameObject::hasQuest(uint32 quest_id) const
{
    QuestRelationBounds qr = sObjectMgr->GetGOQuestRelationBounds(GetEntry());
    for (QuestRelations::const_iterator itr = qr.first; itr != qr.second; ++itr)
    {
        if (itr->second == quest_id)
            return true;
    }
    return false;
}
 
bool GameObject::hasInvolvedQuest(uint32 quest_id) const
{
    QuestRelationBounds qir = sObjectMgr->GetGOQuestInvolvedRelationBounds(GetEntry());
    for (QuestRelations::const_iterator itr = qir.first; itr != qir.second; ++itr)
    {
        if (itr->second == quest_id)
            return true;
    }
    return false;
}
 
bool GameObject::IsTransport() const
{
    // If something is marked as a transport, don't transmit an out of range packet for it.
    GameObjectTemplate const* gInfo = GetGOInfo();
    if (!gInfo)
        return false;
 
    return gInfo->type == GAMEOBJECT_TYPE_TRANSPORT || gInfo->type == GAMEOBJECT_TYPE_MO_TRANSPORT;
}
 
// is Dynamic transport = non-stop Transport
bool GameObject::IsDynTransport() const
{
    // If something is marked as a transport, don't transmit an out of range packet for it.
    GameObjectTemplate const* gInfo = GetGOInfo();
    if (!gInfo)
        return false;
 
    return gInfo->type == GAMEOBJECT_TYPE_MO_TRANSPORT || (gInfo->type == GAMEOBJECT_TYPE_TRANSPORT && !gInfo->transport.pause);
}
 
uint32 GameObject::GetTransportPeriod() const
{
    if (GetGoType() == GAMEOBJECT_TYPE_TRANSPORT && m_goValue.Transport.AnimationInfo)
        return m_goValue.Transport.AnimationInfo->TotalTime;
 
    return GetUInt32Value(GAMEOBJECT_FIELD_LEVEL);
}
 
void GameObject::SetTransportPathProgress(uint32 pathProgress)
{
    m_goValue.Transport.HoldingAtProgress = false;
    m_goValue.Transport.PathProgress = Skyfire::GameObjects::GetTransportDynamicPathProgress(
        GetGoType(), GetTransportPeriod(), pathProgress);
    MarkLegacyTransportPathProgressChanged();
}
 
std::vector<uint32> const* GameObject::GetPauseTimes() const
{
    if (GetGoType() == GAMEOBJECT_TYPE_TRANSPORT && !m_transportPauseTimes.empty())
        return &m_transportPauseTimes;
 
    return NULL;
}
 
void GameObject::InitializeLegacyTransport()
{
    m_goValue.Transport.AnimationInfo = sTransportMgr->GetTransportAnimInfo(GetGOInfo()->entry);
    m_goValue.Transport.CurrentSeg = 0;
    m_goValue.Transport.PathProgress = 0;
    m_goValue.Transport.WaitingAtPathStart = false;
    m_goValue.Transport.HoldingAtProgress = false;
    m_goValue.Transport.HoldProgress = 0;
    m_goValue.Transport.StateChangeEndTime = 0;
 
    m_transportPauseTimes.clear();
 
    uint32 const period = GetTransportPeriod();
    if (GetGOInfo()->transport.pause && period)
        m_transportPauseTimes.push_back(Skyfire::GameObjects::ClampLegacyTransportPathProgress(GetGOInfo()->transport.pause, period));
 
    if (!m_transportPauseTimes.empty() && GetGOInfo()->transport.startOpen)
        m_goValue.Transport.PathProgress = m_transportPauseTimes.front();
    else
        m_goValue.Transport.PathProgress = Skyfire::GameObjects::GetInitialLegacyTransportPathProgress(
            !m_transportPauseTimes.empty(), period, getMSTime());
 
    uint32 const now = getMSTime();
    m_goValue.Transport.WaitingAtPathStart = !m_transportPauseTimes.empty() && !GetGOInfo()->transport.startOpen;
    m_goValue.Transport.StateChangeTime = now;
    m_goValue.Transport.StateChangeEndTime = now;
    m_goValue.Transport.StateChangeProgress = m_goValue.Transport.PathProgress;
    SetUInt32Value(GAMEOBJECT_FIELD_LEVEL, now);
    MarkLegacyTransportPathProgressChanged();
}
 
void GameObject::UpdateLegacyTransportPathProgress()
{
    uint32 const period = GetTransportPeriod();
    if (!period)
        return;
 
    uint32 newProgress = m_goValue.Transport.PathProgress;
    bool updateStoppedFlag = false;
    bool stopped = false;
    if (m_goValue.Transport.HoldingAtProgress)
    {
        newProgress = m_goValue.Transport.HoldProgress;
        updateStoppedFlag = true;
        stopped = true;
    }
    else if (m_transportPauseTimes.empty())
        newProgress = Skyfire::GameObjects::WrapTransportPathProgress(getMSTime(), period);
    else
    {
        uint32 const targetProgress = GetLegacyTransportTargetProgress(GetGoState());
        uint32 const stopTime = m_goValue.Transport.StateChangeEndTime;
        uint32 const now = getMSTime();
 
        if (stopTime > now)
        {
            uint32 const travelTime = stopTime - m_goValue.Transport.StateChangeTime;
            uint32 const elapsedTime = now - m_goValue.Transport.StateChangeTime;
            newProgress = Skyfire::GameObjects::InterpolateLegacyTransportPathProgress(
                m_goValue.Transport.StateChangeProgress, targetProgress, period, elapsedTime, travelTime,
                HasFlag(OBJECT_FIELD_DYNAMIC_FLAGS, GO_DYNFLAG_LO_INVERTED_MOVEMENT));
        }
        else
        {
            newProgress = targetProgress;
            stopped = true;
        }
 
        updateStoppedFlag = true;
    }
 
    if (updateStoppedFlag)
        SetLegacyTransportStopped(stopped);
 
    if (newProgress == m_goValue.Transport.PathProgress)
        return;
 
    m_goValue.Transport.PathProgress = newProgress;
    // Legacy transport movement is client-side from DBC path data; only notify progress changes here.
    MarkLegacyTransportPathProgressChanged();
}
 
void GameObject::HandleLegacyTransportStateChange(GOState oldState, GOState newState)
{
    if (GetGoType() != GAMEOBJECT_TYPE_TRANSPORT || m_transportPauseTimes.empty())
        return;
 
    if (newState != GOState::GO_STATE_TRANSPORT_ACTIVE && newState != GOState::GO_STATE_TRANSPORT_STOPPED)
        return;
 
    uint32 const period = GetTransportPeriod();
    if (!period)
        return;
 
    UpdateLegacyTransportPathProgress();
 
    m_goValue.Transport.HoldingAtProgress = false;
    if (newState == GOState::GO_STATE_TRANSPORT_STOPPED && m_goValue.Transport.WaitingAtPathStart)
        m_goValue.Transport.WaitingAtPathStart = false;
 
    uint32 const targetProgress = GetLegacyTransportTargetProgress(newState);
    uint32 const now = getMSTime();
    uint32 const travelTime = Skyfire::GameObjects::GetLegacyTransportTransitionTime(
        m_goValue.Transport.PathProgress, targetProgress);
 
    m_goValue.Transport.StateChangeTime = now;
    m_goValue.Transport.StateChangeProgress = m_goValue.Transport.PathProgress;
    m_goValue.Transport.StateChangeEndTime = now + travelTime;
    SetUInt32Value(GAMEOBJECT_FIELD_LEVEL, m_goValue.Transport.StateChangeEndTime);
 
    if (int32(oldState) < int32(GOState::GO_STATE_TRANSPORT_ACTIVE) || oldState == newState)
    {
        if (m_goValue.Transport.PathProgress > targetProgress)
            SetFlag(OBJECT_FIELD_DYNAMIC_FLAGS, GO_DYNFLAG_LO_INVERTED_MOVEMENT);
        else
            RemoveFlag(OBJECT_FIELD_DYNAMIC_FLAGS, GO_DYNFLAG_LO_INVERTED_MOVEMENT);
    }
    else
    {
        int32 const stopFrameCount = int32(m_transportPauseTimes.size());
        int32 newToOldStateDelta = int32(newState) - int32(oldState);
        if (newToOldStateDelta < 0)
            newToOldStateDelta += stopFrameCount + 1;
 
        int32 oldToNewStateDelta = int32(oldState) - int32(newState);
        if (oldToNewStateDelta < 0)
            oldToNewStateDelta += stopFrameCount + 1;
 
        bool const isAtStartOfPath = m_goValue.Transport.StateChangeProgress == 0;
        if (oldToNewStateDelta < newToOldStateDelta && !isAtStartOfPath)
            SetFlag(OBJECT_FIELD_DYNAMIC_FLAGS, GO_DYNFLAG_LO_INVERTED_MOVEMENT);
        else
            RemoveFlag(OBJECT_FIELD_DYNAMIC_FLAGS, GO_DYNFLAG_LO_INVERTED_MOVEMENT);
    }
 
    SetLegacyTransportStopped(travelTime == 0);
 
    if (oldState != newState)
        MarkLegacyTransportPathProgressChanged();
}
 
void GameObject::SetLegacyTransportTravelTime(uint32 travelTime)
{
    if (GetGoType() != GAMEOBJECT_TYPE_TRANSPORT || m_transportPauseTimes.empty())
        return;
 
    uint32 const now = getMSTime();
    m_goValue.Transport.HoldingAtProgress = false;
    m_goValue.Transport.WaitingAtPathStart = false;
    m_goValue.Transport.StateChangeTime = now;
    m_goValue.Transport.StateChangeProgress = m_goValue.Transport.PathProgress;
    m_goValue.Transport.StateChangeEndTime = now + travelTime;
    SetUInt32Value(GAMEOBJECT_FIELD_LEVEL, m_goValue.Transport.StateChangeEndTime);
    SetLegacyTransportStopped(travelTime == 0);
    MarkLegacyTransportPathProgressChanged();
}
 
void GameObject::StartLegacyTransportToFirstStop(uint32 travelTime)
{
    if (GetGoType() != GAMEOBJECT_TYPE_TRANSPORT || m_transportPauseTimes.empty())
        return;
 
    uint32 const now = getMSTime();
    uint32 const targetProgress = m_transportPauseTimes.front();
 
    m_goValue.Transport.HoldingAtProgress = false;
    m_goValue.Transport.WaitingAtPathStart = false;
    m_goValue.Transport.StateChangeTime = now;
    m_goValue.Transport.StateChangeProgress = m_goValue.Transport.PathProgress;
    m_goValue.Transport.StateChangeEndTime = now + travelTime;
    SetUInt32Value(GAMEOBJECT_FIELD_LEVEL, m_goValue.Transport.StateChangeEndTime);
    SetByteValue(GAMEOBJECT_FIELD_PERCENT_HEALTH, 0, GetGOStateValue(GOState::GO_STATE_TRANSPORT_STOPPED));
 
    if (m_goValue.Transport.PathProgress > targetProgress)
        SetFlag(OBJECT_FIELD_DYNAMIC_FLAGS, GO_DYNFLAG_LO_INVERTED_MOVEMENT);
    else
        RemoveFlag(OBJECT_FIELD_DYNAMIC_FLAGS, GO_DYNFLAG_LO_INVERTED_MOVEMENT);
 
    SetLegacyTransportStopped(travelTime == 0);
    MarkLegacyTransportPathProgressChanged();
}
 
void GameObject::StopLegacyTransportAtInitialStop()
{
    if (GetGoType() != GAMEOBJECT_TYPE_TRANSPORT || m_transportPauseTimes.empty())
        return;
 
    uint32 initialProgress = 0;
    bool waitingAtPathStart = !GetGOInfo()->transport.startOpen;
    if (GetGOInfo()->transport.startOpen)
        initialProgress = m_transportPauseTimes.front();
 
    uint32 const now = getMSTime();
    m_goValue.Transport.PathProgress = initialProgress;
    m_goValue.Transport.StateChangeTime = now;
    m_goValue.Transport.StateChangeProgress = initialProgress;
    m_goValue.Transport.StateChangeEndTime = now;
    m_goValue.Transport.HoldProgress = initialProgress;
    m_goValue.Transport.HoldingAtProgress = true;
    m_goValue.Transport.WaitingAtPathStart = waitingAtPathStart;
    SetUInt32Value(GAMEOBJECT_FIELD_LEVEL, now);
    SetByteValue(GAMEOBJECT_FIELD_PERCENT_HEALTH, 0, GetGOStateValue(GOState::GO_STATE_TRANSPORT_STOPPED));
    RemoveFlag(OBJECT_FIELD_DYNAMIC_FLAGS, GO_DYNFLAG_LO_INVERTED_MOVEMENT);
    SetLegacyTransportStopped(true);
    MarkLegacyTransportPathProgressChanged();
}
 
void GameObject::StopLegacyTransportAtCurrentProgress()
{
    if (GetGoType() != GAMEOBJECT_TYPE_TRANSPORT || m_transportPauseTimes.empty())
        return;
 
    UpdateLegacyTransportPathProgress();
 
    uint32 const now = getMSTime();
    m_goValue.Transport.StateChangeTime = now;
    m_goValue.Transport.StateChangeProgress = m_goValue.Transport.PathProgress;
    m_goValue.Transport.StateChangeEndTime = now;
    m_goValue.Transport.HoldProgress = m_goValue.Transport.PathProgress;
    m_goValue.Transport.HoldingAtProgress = true;
    m_goValue.Transport.WaitingAtPathStart = false;
    SetByteValue(GAMEOBJECT_FIELD_PERCENT_HEALTH, 0, GetGOStateValue(GOState::GO_STATE_TRANSPORT_STOPPED));
    SetUInt32Value(GAMEOBJECT_FIELD_LEVEL, now);
    SetLegacyTransportStopped(true);
    MarkLegacyTransportPathProgressChanged();
}
 
void GameObject::SetLegacyTransportStopped(bool stopped)
{
    uint32 const dynamicFlags = GetUInt32Value(OBJECT_FIELD_DYNAMIC_FLAGS);
    uint32 const updatedFlags = Skyfire::GameObjects::SetLegacyTransportStoppedFlag(dynamicFlags, stopped);
 
    if (dynamicFlags != updatedFlags)
        SetUInt32Value(OBJECT_FIELD_DYNAMIC_FLAGS, updatedFlags);
}
 
void GameObject::MarkLegacyTransportPathProgressChanged()
{
    UpdateUInt32Value(OBJECT_FIELD_DYNAMIC_FLAGS, GetUInt32Value(OBJECT_FIELD_DYNAMIC_FLAGS));
 
    if (IsInWorld() && !m_objectUpdated)
    {
        sObjectAccessor->AddUpdateObject(this);
        m_objectUpdated = true;
    }
}
 
uint32 GameObject::GetLegacyTransportTargetProgress(GOState state) const
{
    if (state == GOState::GO_STATE_TRANSPORT_STOPPED && !m_transportPauseTimes.empty())
    {
        if (m_goValue.Transport.WaitingAtPathStart)
            return 0;
 
        return m_transportPauseTimes.front();
    }
 
    return 0;
}
 
bool GameObject::IsDestructibleBuilding() const
{
    GameObjectTemplate const* gInfo = GetGOInfo();
    if (!gInfo)
        return false;
 
    return gInfo->type == GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING;
}
 
Unit* GameObject::GetOwner() const
{
    return ObjectAccessor::GetUnit(*this, GetOwnerGUID());
}
 
void GameObject::SaveRespawnTime()
{
    if (m_goData && m_goData->dbData && m_respawnTime > time(NULL) && m_spawnedByDefault)
        GetMap()->SaveGORespawnTime(m_DBTableGuid, m_respawnTime);
}
 
bool GameObject::IsAlwaysVisibleFor(WorldObject const* seer) const
{
    if (WorldObject::IsAlwaysVisibleFor(seer))
        return true;
 
    if (IsTransport() || IsDestructibleBuilding())
        return true;
 
    if (!seer)
        return false;
 
    // Always seen by owner and friendly units
    if (uint64 guid = GetOwnerGUID())
    {
        if (seer->GetGUID() == guid)
            return true;
 
        Unit* owner = GetOwner();
        if (owner && seer->isType(TYPEMASK_UNIT) && owner->IsFriendlyTo(((Unit*)seer)))
            return true;
    }
 
    return false;
}
 
bool GameObject::IsInvisibleDueToDespawn() const
{
    if (WorldObject::IsInvisibleDueToDespawn())
        return true;
 
    // Despawned
    if (!isSpawned())
        return true;
 
    return false;
}
 
void GameObject::Respawn()
{
    if (m_spawnedByDefault && m_respawnTime > 0)
    {
        m_respawnTime = time(NULL);
        GetMap()->RemoveGORespawnTime(m_DBTableGuid);
    }
}
 
bool GameObject::ActivateToQuest(Player* target) const
{
    if (target->HasQuestForGO(GetEntry()))
        return true;
 
    if (!sObjectMgr->IsGameObjectForQuests(GetEntry()))
        return false;
 
    switch (GetGoType())
    {
        // scan GO chest with loot including quest items
        case GAMEOBJECT_TYPE_CHEST:
        {
            if (LootTemplates_Gameobject.HaveQuestLootForPlayer(GetGOInfo()->GetLootId(), target))
            {
                if (Battleground const* bg = target->GetBattleground())
                    return bg->CanActivateGO(GetEntry(), target->GetTeam());
                return true;
            }
            break;
        }
        case GAMEOBJECT_TYPE_GENERIC:
        {
            if (GetGOInfo()->_generic.questID == -1 || target->GetQuestStatus(GetGOInfo()->_generic.questID) == QUEST_STATUS_INCOMPLETE)
                return true;
            break;
        }
        case GAMEOBJECT_TYPE_GOOBER:
        {
            if (GetGOInfo()->goober.questId == -1 || target->GetQuestStatus(GetGOInfo()->goober.questId) == QUEST_STATUS_INCOMPLETE)
                return true;
            break;
        }
        default:
            break;
    }
 
    return false;
}
 
void GameObject::TriggeringLinkedGameObject(uint32 trapEntry, Unit* target)
{
    GameObjectTemplate const* trapInfo = sObjectMgr->GetGameObjectTemplate(trapEntry);
    if (!trapInfo || trapInfo->type != GAMEOBJECT_TYPE_TRAP)
        return;
 
    SpellInfo const* trapSpell = sSpellMgr->GetSpellInfo(trapInfo->trap.spellId);
    if (!trapSpell)                                          // checked at load already
        return;
 
    float range = float(target->GetSpellMaxRangeForTarget(GetOwner(), trapSpell));
 
    // search nearest linked GO
    GameObject* trapGO = NULL;
    {
        // using original GO distance
        CellCoord p(Skyfire::ComputeCellCoord(GetPositionX(), GetPositionY()));
        Cell cell(p);
 
        Skyfire::NearestGameObjectEntryInObjectRangeCheck go_check(*target, trapEntry, range);
        Skyfire::GameObjectLastSearcher<Skyfire::NearestGameObjectEntryInObjectRangeCheck> checker(this, trapGO, go_check);
 
        TypeContainerVisitor<Skyfire::GameObjectLastSearcher<Skyfire::NearestGameObjectEntryInObjectRangeCheck>, GridTypeMapContainer > object_checker(checker);
        cell.Visit(p, object_checker, *GetMap(), *target, range);
    }
 
    // found correct GO
    if (trapGO)
        trapGO->CastSpell(target, trapInfo->trap.spellId);
}
 
GameObject* GameObject::LookupFishingHoleAround(float range)
{
    GameObject* ok = NULL;
 
    CellCoord p(Skyfire::ComputeCellCoord(GetPositionX(), GetPositionY()));
    Cell cell(p);
    Skyfire::NearestGameObjectFishingHole u_check(*this, range);
    Skyfire::GameObjectSearcher<Skyfire::NearestGameObjectFishingHole> checker(this, ok, u_check);
 
    TypeContainerVisitor<Skyfire::GameObjectSearcher<Skyfire::NearestGameObjectFishingHole>, GridTypeMapContainer > grid_object_checker(checker);
    cell.Visit(p, grid_object_checker, *GetMap(), *this, range);
 
    return ok;
}
 
void GameObject::ResetDoorOrButton()
{
    if (m_lootState == LootState::GO_READY || m_lootState == LootState::GO_JUST_DEACTIVATED)
        return;
 
    SwitchDoorOrButton(false);
    SetLootState(LootState::GO_JUST_DEACTIVATED);
    m_cooldownTime = 0;
}
 
void GameObject::UseDoorOrButton(uint32 time_to_restore, bool alternative /* = false */, Unit* user /*=NULL*/)
{
    if (m_lootState != LootState::GO_READY)
        return;
 
    if (!time_to_restore)
        time_to_restore = GetGOInfo()->GetAutoCloseTime();
 
    SwitchDoorOrButton(true, alternative);
    SetLootState(LootState::GO_ACTIVATED, user);
 
    m_cooldownTime = time(NULL) + time_to_restore;
}
 
void GameObject::SetGoArtKit(uint8 kit)
{
    SetByteValue(GAMEOBJECT_FIELD_STATE_SPELL_VISUAL_ID, 1, kit);
    GameObjectData* data = const_cast<GameObjectData*>(sObjectMgr->GetGOData(m_DBTableGuid));
    if (data)
        data->artKit = kit;
}
 
void GameObject::SetGoArtKit(uint8 artkit, GameObject* go, uint32 lowguid)
{
    const GameObjectData* data = NULL;
    if (go)
    {
        go->SetGoArtKit(artkit);
        data = go->GetGOData();
    }
    else if (lowguid)
        data = sObjectMgr->GetGOData(lowguid);
 
    if (data)
        const_cast<GameObjectData*>(data)->artKit = artkit;
}
 
void GameObject::SwitchDoorOrButton(bool activate, bool alternative /* = false */)
{
    if (activate)
        SetFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_IN_USE);
    else
        RemoveFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_IN_USE);
 
    if (GetGoState() == GOState::GO_STATE_READY)                      //if closed -> open
        SetGoState(alternative ? GOState::GO_STATE_ACTIVE_ALTERNATIVE : GOState::GO_STATE_ACTIVE);
    else                                                    //if open -> close
        SetGoState(GOState::GO_STATE_READY);
}
 
void GameObject::Use(Unit* user)
{
    // we cannot use go with not selectable flags
    if (HasFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_NOT_SELECTABLE))
        return;
 
    // by default spell caster is user
    Unit* spellCaster = user;
    uint32 spellId = 0;
    bool triggered = false;
 
    if (Player* playerUser = user->ToPlayer())
    {
        if (playerUser->OnArchaeologyFindUsed(this))
            return;
 
        if (sScriptMgr->OnGossipHello(playerUser, this))
            return;
 
        if (AI()->GossipHello(playerUser))
            return;
    }
 
    // If cooldown data present in template
    if (uint32 cooldown = GetGOInfo()->GetCooldown())
    {
        if (m_cooldownTime > sWorld->GetGameTime())
            return;
 
        m_cooldownTime = sWorld->GetGameTime() + cooldown;
    }
 
    switch (GetGoType())
    {
        case GAMEOBJECT_TYPE_DOOR:                          //0
        case GAMEOBJECT_TYPE_BUTTON:                        //1
            //doors/buttons never really despawn, only reset to default state/flags
            UseDoorOrButton(0, false, user);
            return;
        case GAMEOBJECT_TYPE_QUESTGIVER:                    //2
        {
            if (user->GetTypeId() != TypeID::TYPEID_PLAYER)
                return;
 
            Player* player = user->ToPlayer();
 
            player->PrepareGossipMenu(this, GetGOInfo()->questgiver.gossipID, true);
            player->SendPreparedGossip(this);
            return;
        }
        case GAMEOBJECT_TYPE_CHEST:                         //3
        {
            if (user->GetTypeId() != TypeID::TYPEID_PLAYER)
                return;
 
            // Archaeology finds are handled at the start of Use(); remaining chests open as loot.
            user->ToPlayer()->SendLoot(GetGUID(), LootType::LOOT_CORPSE);
            return;
        }
        case GAMEOBJECT_TYPE_TRAP:                          //6
        {
            GameObjectTemplate const* goInfo = GetGOInfo();
            if (goInfo->trap.spellId)
                CastSpell(user, goInfo->trap.spellId);
 
            m_cooldownTime = time(NULL) + (goInfo->trap.cooldown ? goInfo->trap.cooldown : uint32(4));   // template or 4 seconds
 
            if (goInfo->trap.type == 1)         // Deactivate after trigger
                SetLootState(LootState::GO_JUST_DEACTIVATED);
 
            return;
        }
        //Sitting: Wooden bench, chairs enzz
        case GAMEOBJECT_TYPE_CHAIR:                         //7
        {
            GameObjectTemplate const* info = GetGOInfo();
            if (!info)
                return;
 
            if (user->GetTypeId() != TypeID::TYPEID_PLAYER)
                return;
 
            if (ChairListSlots.empty())        // this is called once at first chair use to make list of available slots
            {
                if (info->chair.slots > 0)     // sometimes chairs in DB have error in fields and we dont know number of slots
                    for (uint32 i = 0; i < info->chair.slots; ++i)
                        ChairListSlots[i] = 0; // Last user of current slot set to 0 (none sit here yet)
                else
                    ChairListSlots[0] = 0;     // error in DB, make one default slot
            }
 
            Player* player = user->ToPlayer();
 
            // a chair may have n slots. we have to calculate their positions and teleport the player to the nearest one
 
            float lowestDist = DEFAULT_VISIBILITY_DISTANCE;
 
            uint32 nearest_slot = 0;
            float x_lowest = GetPositionX();
            float y_lowest = GetPositionY();
 
            // the object orientation + 1/2 pi
            // every slot will be on that straight line
            float orthogonalOrientation = GetOrientation() + M_PI * 0.5f;
            // find nearest slot
            bool found_free_slot = false;
            for (ChairSlotAndUser::iterator itr = ChairListSlots.begin(); itr != ChairListSlots.end(); ++itr)
            {
                // the distance between this slot and the center of the go - imagine a 1D space
                float relativeDistance = (info->size * itr->first) - (info->size * (info->chair.slots - 1) / 2.0f);
 
                float x_i = GetPositionX() + relativeDistance * std::cos(orthogonalOrientation);
                float y_i = GetPositionY() + relativeDistance * std::sin(orthogonalOrientation);
 
                if (itr->second)
                {
                    if (Player* ChairUser = ObjectAccessor::FindPlayer(itr->second))
                    {
                        if (ChairUser->IsSitState() && ChairUser->getStandState() != UNIT_STAND_STATE_SIT && ChairUser->GetExactDist2d(x_i, y_i) < 0.1f)
                            continue;        // This seat is already occupied by ChairUser. NOTE: Not sure if the ChairUser->getStandState() != UNIT_STAND_STATE_SIT check is required.
                        else
                            itr->second = 0; // This seat is unoccupied.
                    }
                    else
                        itr->second = 0;     // The seat may of had an occupant, but they're offline.
                }
 
                found_free_slot = true;
 
                // calculate the distance between the player and this slot
                float thisDistance = player->GetDistance2d(x_i, y_i);
 
                if (thisDistance <= lowestDist)
                {
                    nearest_slot = itr->first;
                    lowestDist = thisDistance;
                    x_lowest = x_i;
                    y_lowest = y_i;
                }
            }
 
            if (found_free_slot)
            {
                ChairSlotAndUser::iterator itr = ChairListSlots.find(nearest_slot);
                if (itr != ChairListSlots.end())
                {
                    itr->second = player->GetGUID(); //this slot in now used by player
                    player->TeleportTo(GetMapId(), x_lowest, y_lowest, GetPositionZ(), GetOrientation(), TELE_TO_NOT_LEAVE_TRANSPORT | TELE_TO_NOT_LEAVE_COMBAT | TELE_TO_NOT_UNSUMMON_PET);
                    player->SetStandState(UNIT_STAND_STATE_SIT_LOW_CHAIR + info->chair.height);
                    return;
                }
            }
 
            return;
        }
        //big gun, its a spell/aura
        case GAMEOBJECT_TYPE_GOOBER:                        //10
        {
            GameObjectTemplate const* info = GetGOInfo();
 
            if (user->GetTypeId() == TypeID::TYPEID_PLAYER)
            {
                Player* player = user->ToPlayer();
 
                if (info->goober.pageId)                    // show page...
                {
                    player->GetSession()->SendPageText(GetObjectGUID());
                }
                else if (info->goober.gossipID)
                {
                    player->PrepareGossipMenu(this, info->goober.gossipID);
                    player->SendPreparedGossip(this);
                }
 
                if (info->goober.eventId)
                {
                    SF_LOG_DEBUG("maps.script", "Goober ScriptStart id %u for GO entry %u (GUID %u).", info->goober.eventId, GetEntry(), GetDBTableGUIDLow());
                    GetMap()->ScriptsStart(sEventScripts, info->goober.eventId, player, this);
                    EventInform(info->goober.eventId);
                }
 
                // possible quest objective for active quests
                if (info->goober.questId && sObjectMgr->GetQuestTemplate(info->goober.questId))
                {
                    //Quest require to be active for GO using
                    if (player->GetQuestStatus(info->goober.questId) != QUEST_STATUS_INCOMPLETE)
                        break;
                }
 
                if (Battleground* bg = player->GetBattleground())
                    bg->EventPlayerUsedGO(player, this);
 
                player->KillCreditGO(info->entry, GetGUID());
            }
 
            if (uint32 trapEntry = info->goober.linkedTrapId)
                TriggeringLinkedGameObject(trapEntry, user);
 
            SetFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_IN_USE);
            SetLootState(LootState::GO_ACTIVATED, user);
 
            // this appear to be ok, however others exist in addition to this that should have custom (ex: 190510, 188692, 187389)
            if (info->goober.customAnim)
                SendCustomAnim(GetGoAnimProgress());
            else
                SetGoState(GOState::GO_STATE_ACTIVE);
 
            m_cooldownTime = time(NULL) + info->GetAutoCloseTime();
 
            // cast this spell later if provided
            spellId = info->goober.spellId;
            spellCaster = NULL;
 
            break;
        }
        case GAMEOBJECT_TYPE_CAMERA:                        //13
        {
            GameObjectTemplate const* info = GetGOInfo();
            if (!info)
                return;
 
            if (user->GetTypeId() != TypeID::TYPEID_PLAYER)
                return;
 
            Player* player = user->ToPlayer();
 
            if (info->camera.cinematicId)
                player->SendCinematicStart(info->camera.cinematicId);
 
            if (info->camera.eventID)
                GetMap()->ScriptsStart(sEventScripts, info->camera.eventID, player, this);
 
            return;
        }
        //fishing bobber
        case GAMEOBJECT_TYPE_FISHINGNODE:                   //17
        {
            Player* player = user->ToPlayer();
            if (!player)
                return;
 
            if (player->GetGUID() != GetOwnerGUID())
                return;
 
            switch (getLootState())
            {
                case LootState::GO_READY:                              // ready for loot
                {
                    uint32 zone, subzone;
                    GetZoneAndAreaId(zone, subzone);
 
                    int32 zone_skill = sObjectMgr->GetFishingBaseSkillLevel(subzone);
                    if (!zone_skill)
                        zone_skill = sObjectMgr->GetFishingBaseSkillLevel(zone);
 
                    //provide error, no fishable zone or area should be 0
                    if (!zone_skill)
                        SF_LOG_ERROR("sql.sql", "Fishable areaId %u are not properly defined in `skill_fishing_base_level`.", subzone);
 
                    int32 skill = player->GetSkillValue(SKILL_FISHING);
 
                    int32 chance;
                    if (skill < zone_skill)
                    {
                        chance = int32(pow((double)skill / zone_skill, 2) * 100);
                        if (chance < 1)
                            chance = 1;
                    }
                    else
                        chance = 100;
 
                    int32 roll = std::rand() % 100 + 1;
 
                    SF_LOG_DEBUG("misc", "Fishing check (skill: %i zone min skill: %i chance %i roll: %i", skill, zone_skill, chance, roll);
 
                    // but you will likely cause junk in areas that require a high fishing skill (not yet implemented)
                    if (chance >= roll)
                    {
                        player->UpdateFishingSkill();

                        // prevent removing GO at spell cancel
                        RemoveFromOwner();
                        SetOwnerGUID(player->GetGUID());

                        GameObject* ok = LookupFishingHoleAround(20.0f + CONTACT_DISTANCE);
                        if (ok)
                        {
                            ok->Use(player);
                            SetLootState(LootState::GO_JUST_DEACTIVATED);
                        }
                        else
                            player->SendLoot(GetGUID(), LootType::LOOT_FISHING);
                    }
                    else
                        m_respawnTime = time(NULL);
 
                    break;
                }
                case LootState::GO_JUST_DEACTIVATED:                   // nothing to do, will be deleted at next update
                    break;
                default:
                {
                    SetLootState(LootState::GO_JUST_DEACTIVATED);
 
                    WorldPacket data(SMSG_FISH_NOT_HOOKED, 0);
                    player->SendDirectMessage(&data);
                    break;
                }
            }
 
            player->FinishSpell(CURRENT_CHANNELED_SPELL);
            return;
        }
 
        case GAMEOBJECT_TYPE_SUMMONING_RITUAL:              //18
        {
            if (user->GetTypeId() != TypeID::TYPEID_PLAYER)
                return;
 
            Player* player = user->ToPlayer();
 
            Unit* owner = GetOwner();
 
            GameObjectTemplate const* info = GetGOInfo();
 
            // ritual owner is set for GO's without owner (not summoned)
            if (!m_ritualOwner && !owner)
                m_ritualOwner = player;
 
            if (owner)
            {
                if (owner->GetTypeId() != TypeID::TYPEID_PLAYER)
                    return;
 
                // accept only use by player from same group as owner, excluding owner itself (unique use already added in spell effect)
                if (player == owner->ToPlayer() || (info->summoningRitual.castersGrouped && !player->IsInSameRaidWith(owner->ToPlayer())))
                    return;
 
                // expect owner to already be channeling, so if not...
                if (!owner->GetCurrentSpell(CURRENT_CHANNELED_SPELL))
                    return;
 
                // in case summoning ritual caster is GO creator
                spellCaster = owner;
            }
            else
            {
                if (player != m_ritualOwner && (info->summoningRitual.castersGrouped && !player->IsInSameRaidWith(m_ritualOwner)))
                    return;
 
                spellCaster = player;
            }
 
            AddUniqueUse(player);
 
            if (info->summoningRitual.animSpell)
            {
                player->CastSpell(player, info->summoningRitual.animSpell, true);
 
                // for this case, summoningRitual.spellId is always triggered
                triggered = true;
            }
 
            // full amount unique participants including original summoner
            if (GetUniqueUseCount() == info->summoningRitual.reqParticipants)
            {
                if (m_ritualOwner)
                    spellCaster = m_ritualOwner;
 
                spellId = info->summoningRitual.spellId;
 
                if (spellId == 62330)                       // GO store nonexistent spell, replace by expected
                {
                    // spell have reagent and mana cost but it not expected use its
                    // it triggered spell in fact casted at currently channeled GO
                    spellId = 61993;
                    triggered = true;
                }
 
                // Cast casterTargetSpell at a random GO user
                // on the current DB there is only one gameobject that uses this (Ritual of Doom)
                // and its required target number is 1 (outter for loop will run once)
                if (info->summoningRitual.casterTargetSpell && info->summoningRitual.casterTargetSpell != 1) // No idea why this field is a bool in some cases
                    for (uint32 i = 0; i < info->summoningRitual.casterTargetSpellTargets; i++)
                        // m_unique_users can contain only player GUIDs
                        if (Player* target = ObjectAccessor::GetPlayer(*this, Skyfire::Containers::SelectRandomContainerElement(m_unique_users)))
                            spellCaster->CastSpell(target, info->summoningRitual.casterTargetSpell, true);
 
                // finish owners spell
                if (owner)
                    owner->FinishSpell(CURRENT_CHANNELED_SPELL);
 
                // can be deleted now, if
                if (!info->summoningRitual.ritualPersistent)
                    SetLootState(LootState::GO_JUST_DEACTIVATED);
                else
                {
                    // reset ritual for this GO
                    m_ritualOwner = NULL;
                    m_unique_users.clear();
                    m_usetimes = 0;
                }
            }
            else
                return;
 
            // go to end function to spell casting
            break;
        }
        case GAMEOBJECT_TYPE_SPELLCASTER:                   //22
        {
            GameObjectTemplate const* info = GetGOInfo();
            if (!info)
                return;
 
            if (info->spellcaster.partyOnly)
            {
                Unit* caster = GetOwner();
                if (!caster || caster->GetTypeId() != TypeID::TYPEID_PLAYER)
                    return;
 
                if (user->GetTypeId() != TypeID::TYPEID_PLAYER || !user->ToPlayer()->IsInSameRaidWith(caster->ToPlayer()))
                    return;
            }
 
            user->RemoveAurasByType(SPELL_AURA_MOUNTED);
            spellId = info->spellcaster.spellId;
 
            AddUse();
            break;
        }
        case GAMEOBJECT_TYPE_MEETINGSTONE:                  //23
        {
            GameObjectTemplate const* info = GetGOInfo();
 
            if (user->GetTypeId() != TypeID::TYPEID_PLAYER)
                return;
 
            Player* player = user->ToPlayer();
 
            Player* targetPlayer = ObjectAccessor::FindPlayer(player->GetTarget());
 
            // accept only use by player from same raid as caster, except caster itself
            if (!targetPlayer || targetPlayer == player || !targetPlayer->IsInSameRaidWith(player))
                return;
 
            //required lvl checks!
            uint8 level = player->getLevel();
            if (level < info->meetingstone.minLevel)
                return;
            level = targetPlayer->getLevel();
            if (level < info->meetingstone.minLevel)
                return;
 
            if (info->entry == 194097)
                spellId = 61994;                            // Ritual of Summoning
            else
                spellId = 59782;                            // Summoning Stone Effect
 
            break;
        }
 
        case GAMEOBJECT_TYPE_FLAGSTAND:                     // 24
        {
            if (user->GetTypeId() != TypeID::TYPEID_PLAYER)
                return;
 
            Player* player = user->ToPlayer();
 
            if (player->CanUseBattlegroundObject(this))
            {
                // in battleground check
                Battleground* bg = player->GetBattleground();
                if (!bg)
                    return;
 
                if (player->GetVehicle())
                    return;
 
                player->RemoveAurasByType(SPELL_AURA_MOD_STEALTH);
                player->RemoveAurasByType(SPELL_AURA_MOD_INVISIBILITY);
                // BG flag click
                // AB:
                // 15001
                // 15002
                // 15003
                // 15004
                // 15005
                bg->EventPlayerClickedOnFlag(player, this);
                return;                                     //we don;t need to delete flag ... it is despawned!
            }
            break;
        }
 
        case GAMEOBJECT_TYPE_FISHINGHOLE:                   // 25
        {
            if (user->GetTypeId() != TypeID::TYPEID_PLAYER)
                return;
 
            Player* player = user->ToPlayer();
 
            player->SendLoot(GetGUID(), LootType::LOOT_FISHINGHOLE);
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT, GetGOInfo()->entry);
            return;
        }
 
        case GAMEOBJECT_TYPE_FLAGDROP:                      // 26
        {
            if (user->GetTypeId() != TypeID::TYPEID_PLAYER)
                return;
 
            Player* player = user->ToPlayer();
 
            if (player->CanUseBattlegroundObject(this))
            {
                // in battleground check
                Battleground* bg = player->GetBattleground();
                if (!bg)
                    return;
 
                if (player->GetVehicle())
                    return;
 
                player->RemoveAurasByType(SPELL_AURA_MOD_STEALTH);
                player->RemoveAurasByType(SPELL_AURA_MOD_INVISIBILITY);
                // BG flag dropped
                // WS:
                // 179785 - Silverwing Flag
                // 179786 - Warsong Flag
                // EotS:
                // 184142 - Netherstorm Flag
                GameObjectTemplate const* info = GetGOInfo();
                if (info)
                {
                    switch (info->entry)
                    {
                        case 179785:                        // Silverwing Flag
                        case 179786:                        // Warsong Flag
                            if (bg->GetTypeID(true) == BattlegroundTypeId::BATTLEGROUND_WS)
                                bg->EventPlayerClickedOnFlag(player, this);
                            else
                                if (bg->GetTypeID(true) == BattlegroundTypeId::BATTLEGROUND_TP)
                                    bg->EventPlayerClickedOnFlag(player, this);
                            break;
                        case 184142:                        // Netherstorm Flag
                            if (bg->GetTypeID(true) == BattlegroundTypeId::BATTLEGROUND_EY)
                                bg->EventPlayerClickedOnFlag(player, this);
                            break;
                    }
                }
                //this cause to call return, all flags must be deleted here!!
                spellId = 0;
                Delete();
            }
            break;
        }
        case GAMEOBJECT_TYPE_BARBER_CHAIR:                  //32
        {
            GameObjectTemplate const* info = GetGOInfo();
            if (!info)
                return;
 
            if (user->GetTypeId() != TypeID::TYPEID_PLAYER)
                return;
 
            Player* player = user->ToPlayer();
 
            // fallback, will always work
            player->TeleportTo(GetMapId(), GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation(), TELE_TO_NOT_LEAVE_TRANSPORT | TELE_TO_NOT_LEAVE_COMBAT | TELE_TO_NOT_UNSUMMON_PET);
 
            WorldPacket data(SMSG_ENABLE_BARBER_SHOP, 0);
            player->SendDirectMessage(&data);
 
            player->SetStandState(UNIT_STAND_STATE_SIT_LOW_CHAIR + info->barberChair.chairheight);
            return;
        }
        default:
            if (GetGoType() >= MAX_GAMEOBJECT_TYPE)
                SF_LOG_ERROR("misc", "GameObject::Use(): unit (type: %u, guid: %u, name: %s) tries to use object (guid: %u, entry: %u, name: %s) of unknown type (%u)",
                    uint8(user->GetTypeId()), user->GetGUIDLow(), user->GetName().c_str(), GetGUIDLow(), GetEntry(), GetGOInfo()->name.c_str(), GetGoType());
            break;
    }
 
    if (!spellId)
        return;
 
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    if (!spellInfo)
    {
        if (user->GetTypeId() != TypeID::TYPEID_PLAYER || !sOutdoorPvPMgr->HandleCustomSpell(user->ToPlayer(), spellId, this))
            SF_LOG_ERROR("misc", "WORLD: unknown spell id %u at use action for gameobject (Entry: %u GoType: %u)", spellId, GetEntry(), GetGoType());
        else
            SF_LOG_DEBUG("outdoorpvp", "WORLD: %u non-dbc spell was handled by OutdoorPvP", spellId);
        return;
    }
 
    if (spellCaster)
        spellCaster->CastSpell(user, spellInfo, triggered);
    else
        CastSpell(user, spellId);
}
 
void GameObject::CastSpell(Unit* target, uint32 spellId)
{
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    if (!spellInfo)
        return;
 
    bool self = false;
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (spellInfo->Effects[i].TargetA.GetTarget() == TARGET_UNIT_CASTER)
        {
            self = true;
            break;
        }
    }
 
    if (self)
    {
        if (target)
            target->CastSpell(target, spellInfo, true);
        return;
    }
 
    //summon world trigger
    Creature* trigger = SummonTrigger(GetPositionX(), GetPositionY(), GetPositionZ(), 0, spellInfo->CalcCastTime() + 100);
    if (!trigger)
        return;
 
    if (Unit* owner = GetOwner())
    {
        trigger->setFaction(owner->getFaction());
        // needed for GO casts for proper target validation checks
        trigger->SetOwnerGUID(owner->GetGUID());
        trigger->CastSpell(target ? target : trigger, spellInfo, true, 0, 0, owner->GetGUID());
    }
    else
    {
        trigger->setFaction(14);
        // Set owner guid for target if no owner available - needed by trigger auras
        // - trigger gets despawned and there's no caster avalible (see AuraEffect::TriggerSpell())
        trigger->CastSpell(target ? target : trigger, spellInfo, true, 0, 0, target ? target->GetGUID() : 0);
    }
}
 
void GameObject::SendCustomAnim(uint32 anim)
{
    ObjectGuid Guid = GetGUID();
    WorldPacket data(SMSG_GAMEOBJECT_CUSTOM_ANIM, 8 + 4);
 
    data.WriteBit(Guid[4]);
    data.WriteBit(Guid[7]);
    data.WriteBit(Guid[1]);
    data.WriteBit(Guid[0]);
    data.WriteBit(Guid[5]);
    data.WriteBit(Guid[3]);
    data.WriteBit(Guid[2]);
    data.WriteBit(0); //unk
    data.WriteBit(Guid[6]);
    data.FlushBits();
 
    data << uint32(anim);
    data.WriteByteSeq(Guid[5]);
    data.WriteByteSeq(Guid[6]);
    data.WriteByteSeq(Guid[7]);
    data.WriteByteSeq(Guid[3]);
    data.WriteByteSeq(Guid[4]);
    data.WriteByteSeq(Guid[0]);
    data.WriteByteSeq(Guid[2]);
    data.WriteByteSeq(Guid[1]);
 
    SendMessageToSet(&data, true);
}
 
bool GameObject::IsInRange(float x, float y, float z, float radius) const
{
    GameObjectDisplayInfoEntry const* info = sGameObjectDisplayInfoStore.LookupEntry(m_goInfo->displayId);
    if (!info)
        return IsWithinDist3d(x, y, z, radius);
 
    float sinA = std::sin(GetOrientation());
    float cosA = std::cos(GetOrientation());
    float dx = x - GetPositionX();
    float dy = y - GetPositionY();
    float dz = z - GetPositionZ();
    float dist = sqrt(dx * dx + dy * dy);
    if (G3D::fuzzyEq(dist, 0.0f))
        return true;
 
    float sinB = dx / dist;
    float cosB = dy / dist;
    dx = dist * (cosA * cosB + sinA * sinB);
    dy = dist * (cosA * sinB - sinA * cosB);
    return dx < info->maxX + radius && dx > info->minX - radius
        && dy < info->maxY + radius && dy > info->minY - radius
        && dz < info->maxZ + radius && dz > info->minZ - radius;
}
 
void GameObject::EventInform(uint32 eventId)
{
    if (!eventId)
        return;
 
    if (AI())
        AI()->EventInform(eventId);
 
    if (m_zoneScript)
        m_zoneScript->ProcessEvent(this, eventId);
}
 
// overwrite WorldObject function for proper name localization
std::string const& GameObject::GetNameForLocaleIdx(LocaleConstant loc_idx) const
{
    if (loc_idx != DEFAULT_LOCALE)
    {
        uint8 uloc_idx = uint8(loc_idx);
        if (GameObjectLocale const* cl = sObjectMgr->GetGameObjectLocale(GetEntry()))
            if (cl->Name.size() > uloc_idx && !cl->Name[uloc_idx].empty())
                return cl->Name[uloc_idx];
    }
 
    return GetName();
}
 
void GameObject::UpdateWorldRotationField()
{
    static double const atan_pow = atan(pow(2.0f, -20.0f));
 
    double f_rot1 = std::sin(GetOrientation() / 2.0f);
    double f_rot2 = std::cos(GetOrientation() / 2.0f);
 
    int64 i_rot1 = int64(f_rot1 / atan_pow * (f_rot2 >= 0 ? 1.0f : -1.0f));
    int64 rotation = (i_rot1 << 43 >> 43) & 0x00000000001FFFFF;
 
    //float f_rot2 = std::sin(0.0f / 2.0f);
    //int64 i_rot2 = f_rot2 / atan(pow(2.0f, -20.0f));
    //rotation |= (((i_rot2 << 22) >> 32) >> 11) & 0x000003FFFFE00000;
 
    //float f_rot3 = std::sin(0.0f / 2.0f);
    //int64 i_rot3 = f_rot3 / atan(pow(2.0f, -21.0f));
    //rotation |= (i_rot3 >> 42) & 0x7FFFFC0000000000;
 
    m_rotation = rotation;
}
 
void GameObject::UpdateRotationFields(float rotation2 /*=0.0f*/, float rotation3 /*=0.0f*/)
{
    UpdateWorldRotationField();
 
    if (rotation2 == 0.0f && rotation3 == 0.0f)
    {
        double f_rot1 = std::sin(GetOrientation() / 2.0f);
        double f_rot2 = std::cos(GetOrientation() / 2.0f);
 
        rotation2 = (float)f_rot1;
        rotation3 = (float)f_rot2;
    }
 
    SetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 2, rotation2);
    SetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 3, rotation3);
}
 
void GameObject::ModifyHealth(int32 change, Unit* attackerOrHealer /*= NULL*/, uint32 spellId /*= 0*/)
{
    if (!m_goValue.Building.MaxHealth || !change)
        return;
 
    // prevent double destructions of the same object
    if (change < 0 && !m_goValue.Building.Health)
        return;
 
    if (int32(m_goValue.Building.Health) + change <= 0)
        m_goValue.Building.Health = 0;
    else if (int32(m_goValue.Building.Health) + change >= int32(m_goValue.Building.MaxHealth))
        m_goValue.Building.Health = m_goValue.Building.MaxHealth;
    else
        m_goValue.Building.Health += change;
 
    // Set the health bar, value = 255 * healthPct;
    SetGoAnimProgress(m_goValue.Building.Health * 255 / m_goValue.Building.MaxHealth);
 
    Player* player = attackerOrHealer->GetCharmerOrOwnerPlayerOrPlayerItself();
 
    // dealing damage, send packet
    if (player)
    {
        ObjectGuid playerGUID = player->GetGUID();
        ObjectGuid vehicleGUID = attackerOrHealer->GetGUID();
        ObjectGuid objectGUID = GetGUID();
 
        WorldPacket data(SMSG_DESTRUCTIBLE_BUILDING_DAMAGE, 8 + 8 + 8 + 4 + 4);
        data.WriteGuidMask(vehicleGUID, 2);
        data.WriteGuidMask(objectGUID, 2);
        data.WriteGuidMask(playerGUID, 7);
        data.WriteGuidMask(objectGUID, 4);
        data.WriteGuidMask(playerGUID, 3, 5);
        data.WriteGuidMask(objectGUID, 0);
        data.WriteGuidMask(playerGUID, 2, 6);
        data.WriteGuidMask(vehicleGUID, 4);
        data.WriteGuidMask(objectGUID, 5);
        data.WriteGuidMask(playerGUID, 0, 1);
        data.WriteGuidMask(objectGUID, 1);
        data.WriteGuidMask(vehicleGUID, 0, 3, 6);
        data.WriteGuidMask(objectGUID, 7);
        data.WriteGuidMask(vehicleGUID, 7, 5);
        data.WriteGuidMask(objectGUID, 6);
        data.WriteGuidMask(playerGUID, 4);
        data.WriteGuidMask(vehicleGUID, 1);
        data.WriteGuidMask(objectGUID, 3);
 
        data.WriteGuidBytes(vehicleGUID, 2);
        data << uint32(spellId);
        data.WriteGuidBytes(playerGUID, 5, 6);
        data.WriteGuidBytes(objectGUID, 7);
        data.WriteGuidBytes(playerGUID, 1);
        data.WriteGuidBytes(objectGUID, 1);
        data.WriteGuidBytes(playerGUID, 2);
        data.WriteGuidBytes(vehicleGUID, 7, 5);
        data.WriteGuidBytes(objectGUID, 0, 2, 6);
        data.WriteGuidBytes(vehicleGUID, 1, 6);
        data << int32(-change);                    // change  < 0 triggers SPELL_BUILDING_HEAL combat log event
                                                   // change >= 0 triggers SPELL_BUILDING_DAMAGE event
        data.WriteGuidBytes(objectGUID, 5);
        data.WriteGuidBytes(playerGUID, 0);
        data.WriteGuidBytes(vehicleGUID, 0);
        data.WriteGuidBytes(playerGUID, 7, 4);
        data.WriteGuidBytes(objectGUID, 3);
        data.WriteGuidBytes(vehicleGUID, 3);
        data.WriteGuidBytes(objectGUID, 4);
        data.WriteGuidBytes(vehicleGUID, 4);
        data.WriteGuidBytes(playerGUID, 3);
 
        player->SendDirectMessage(&data);
    }
 
    GameObjectDestructibleState newState = GetDestructibleState();
 
    if (!m_goValue.Building.Health)
        newState = GO_DESTRUCTIBLE_DESTROYED;
    else if (m_goValue.Building.Health <= GetGOInfo()->building.damagedNumHits)
        newState = GO_DESTRUCTIBLE_DAMAGED;
    else if (m_goValue.Building.Health == m_goValue.Building.MaxHealth)
        newState = GO_DESTRUCTIBLE_INTACT;
 
    if (newState == GetDestructibleState())
        return;
 
    SetDestructibleState(newState, player, false);
}
 
void GameObject::SetDestructibleState(GameObjectDestructibleState state, Player* eventInvoker /*= NULL*/, bool setHealth /*= false*/)
{
    // the user calling this must know he is already operating on destructible gameobject
    ASSERT(GetGoType() == GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING);
 
    switch (state)
    {
        case GO_DESTRUCTIBLE_INTACT:
            RemoveFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_DAMAGED | GO_FLAG_DESTROYED);
            SetDisplayId(m_goInfo->displayId);
            if (setHealth)
            {
                m_goValue.Building.Health = m_goValue.Building.MaxHealth;
                SetGoAnimProgress(255);
            }
            EnableCollision(true);
            break;
        case GO_DESTRUCTIBLE_DAMAGED:
        {
            EventInform(m_goInfo->building.damagedEvent);
            sScriptMgr->OnGameObjectDamaged(this, eventInvoker);
            if (eventInvoker)
                if (Battleground* bg = eventInvoker->GetBattleground())
                    bg->EventPlayerDamagedGO(eventInvoker, this, m_goInfo->building.damagedEvent);
 
            RemoveFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_DESTROYED);
            SetFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_DAMAGED);
 
            uint32 modelId = m_goInfo->building.damagedDisplayId;
            if (DestructibleModelDataEntry const* modelData = sDestructibleModelDataStore.LookupEntry(m_goInfo->building.destructibleData))
                if (modelData->DamagedDisplayId)
                    modelId = modelData->DamagedDisplayId;
            SetDisplayId(modelId);
 
            if (setHealth)
            {
                m_goValue.Building.Health = m_goInfo->building.damagedNumHits;
                uint32 maxHealth = m_goValue.Building.MaxHealth;
                // in this case current health is 0 anyway so just prevent crashing here
                if (!maxHealth)
                    maxHealth = 1;
                SetGoAnimProgress(m_goValue.Building.Health * 255 / maxHealth);
            }
            break;
        }
        case GO_DESTRUCTIBLE_DESTROYED:
        {
            sScriptMgr->OnGameObjectDestroyed(this, eventInvoker);
            EventInform(m_goInfo->building.destroyedEvent);
            if (eventInvoker)
            {
                if (Battleground* bg = eventInvoker->GetBattleground())
                {
                    bg->EventPlayerDamagedGO(eventInvoker, this, m_goInfo->building.destroyedEvent);
                    bg->DestroyGate(eventInvoker, this);
                }
            }
 
            RemoveFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_DAMAGED);
            SetFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_DESTROYED);
 
            uint32 modelId = m_goInfo->building.destroyedDisplayId;
            if (DestructibleModelDataEntry const* modelData = sDestructibleModelDataStore.LookupEntry(m_goInfo->building.destructibleData))
                if (modelData->DestroyedDisplayId)
                    modelId = modelData->DestroyedDisplayId;
            SetDisplayId(modelId);
 
            if (setHealth)
            {
                m_goValue.Building.Health = 0;
                SetGoAnimProgress(0);
            }
            EnableCollision(false);
            break;
        }
        case GO_DESTRUCTIBLE_REBUILDING:
        {
            EventInform(m_goInfo->building.rebuildingEvent);
            RemoveFlag(GAMEOBJECT_FIELD_FLAGS, GO_FLAG_DAMAGED | GO_FLAG_DESTROYED);
 
            uint32 modelId = m_goInfo->displayId;
            if (DestructibleModelDataEntry const* modelData = sDestructibleModelDataStore.LookupEntry(m_goInfo->building.destructibleData))
                if (modelData->RebuildingDisplayId)
                    modelId = modelData->RebuildingDisplayId;
            SetDisplayId(modelId);
 
            // restores to full health
            if (setHealth)
            {
                m_goValue.Building.Health = m_goValue.Building.MaxHealth;
                SetGoAnimProgress(255);
            }
            EnableCollision(true);
            break;
        }
    }
}
 
void GameObject::SetLootState(LootState state, Unit* unit)
{
    m_lootState = state;
    AI()->OnStateChanged(uint32(state), unit);
    sScriptMgr->OnGameObjectLootStateChanged(this, uint32(state), unit);
    if (m_model)
    {
        bool collision = false;
        // Use the current go state
        if ((GetGoState() != GOState::GO_STATE_READY && (state == LootState::GO_ACTIVATED || state == LootState::GO_JUST_DEACTIVATED)) || state == LootState::GO_READY)
            collision = !collision;
 
        EnableCollision(collision);
    }
}
 
void GameObject::SetGoState(GOState state)
{
    GOState const oldState = GetGoState();
    SetByteValue(GAMEOBJECT_FIELD_PERCENT_HEALTH, 0, GetGOStateValue(state));
    HandleLegacyTransportStateChange(oldState, state);
    sScriptMgr->OnGameObjectStateChanged(this, uint32(state));
    if (m_model && !IsTransport())
    {
        if (!IsInWorld())
            return;
 
        // startOpen determines whether we are going to add or remove the LoS on activation
        bool collision = false;
        if (state == GOState::GO_STATE_READY)
            collision = !collision;
 
        EnableCollision(collision);
    }
}
 
void GameObject::SetDisplayId(uint32 displayid)
{
    SetUInt32Value(GAMEOBJECT_FIELD_DISPLAY_ID, displayid);
    UpdateModel();
}
 
void GameObject::SetPhaseMask(uint32 newPhaseMask, bool update)
{
    WorldObject::SetPhaseMask(newPhaseMask, update);
    if (m_model && m_model->isEnabled())
        EnableCollision(true);
}
bool GameObject::SetPhased(uint32 id, bool update, bool apply)
{
    bool res = WorldObject::SetPhased(id, update, apply);
    if (m_model && m_model->isEnabled())
        EnableCollision(true);
    return res;
}
void GameObject::EnableCollision(bool enable)
{
    if (!m_model)
        return;
 
    /*if (enable && !GetMap()->ContainsGameObjectModel(*m_model))
        GetMap()->InsertGameObjectModel(*m_model);*/
 
    m_model->enable(enable ? GetPhaseMask() : 0);
}
 
void GameObject::UpdateModel()
{
    if (!IsInWorld())
        return;
    if (m_model)
        if (GetMap()->ContainsGameObjectModel(*m_model))
            GetMap()->RemoveGameObjectModel(*m_model);
    delete m_model;
    m_model = CreateModel();
    if (m_model)
        GetMap()->InsertGameObjectModel(*m_model);
}
 
Player* GameObject::GetLootRecipient() const
{
    if (!m_lootRecipient)
        return NULL;
    return ObjectAccessor::FindPlayer(m_lootRecipient);
}
 
Group* GameObject::GetLootRecipientGroup() const
{
    if (!m_lootRecipientGroup)
        return NULL;
    return sGroupMgr->GetGroupByGUID(m_lootRecipientGroup);
}
 
void GameObject::SetLootRecipient(Unit* unit)
{
    // set the player whose group should receive the right
    // to loot the creature after it dies
    // should be set to NULL after the loot disappears
 
    if (!unit)
    {
        m_lootRecipient = 0;
        m_lootRecipientGroup = 0;
        return;
    }
 
    if (unit->GetTypeId() != TypeID::TYPEID_PLAYER && !unit->IsVehicle())
        return;
 
    Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself();
    if (!player)                                             // normal creature, no player involved
        return;
 
    m_lootRecipient = player->GetGUID();
    if (Group* group = player->GetGroup())
        m_lootRecipientGroup = group->GetLowGUID();
}
 
bool GameObject::IsLootAllowedFor(Player const* player) const
{
    if (!m_lootRecipient && !m_lootRecipientGroup)
        return true;
 
    if (player->GetGUID() == m_lootRecipient)
        return true;
 
    Group const* playerGroup = player->GetGroup();
    if (!playerGroup || playerGroup != GetLootRecipientGroup()) // if we dont have a group we arent the recipient
        return false;                                           // if go doesnt have group bound it means it was solo killed by someone else
 
    return true;
}
 
void GameObject::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* target) const
{
    if (!target)
        return;
 
    bool forcedFlags = GetGoType() == GAMEOBJECT_TYPE_CHEST && GetGOInfo()->chest.groupLootRules && HasLootRecipient();
    bool targetIsGM = target->IsGameMaster();
 
    ByteBuffer fieldBuffer;
 
    UpdateMask updateMask;
    updateMask.SetCount(m_valuesCount);
 
    uint32* flags = GameObjectUpdateFieldFlags;
    uint32 visibleFlag = UF_FLAG_PUBLIC | UF_FLAG_VIEWER_DEPENDENT;
    if (GetOwnerGUID() == target->GetGUID())
        visibleFlag |= UF_FLAG_OWNER;
 
    for (uint16 index = 0; index < m_valuesCount; ++index)
    {
        bool const forceTransportDynamicFlags =
            updateType != UPDATETYPE_VALUES &&
            index == OBJECT_FIELD_DYNAMIC_FLAGS &&
            IsTransport() &&
            GetTransportPeriod() != 0;
 
        if ((m_fieldNotifyFlags & flags[index] ||
            ((updateType == UPDATETYPE_VALUES ? _changesMask.GetBit(index) : m_uint32Values[index]) && (flags[index] & visibleFlag)) ||
            forceTransportDynamicFlags ||
            (index == GAMEOBJECT_FIELD_FLAGS && forcedFlags)))
        {
            updateMask.SetBit(index);
 
            if (index == OBJECT_FIELD_DYNAMIC_FLAGS)
            {
                uint16 dynFlags = 0;
                int16 pathProgress = -1;
                switch (GetGoType())
                {
                    case GAMEOBJECT_TYPE_CHEST:
                    case GAMEOBJECT_TYPE_GOOBER:
                        if (ActivateToQuest(target))
                            dynFlags |= GO_DYNFLAG_LO_ACTIVATE | GO_DYNFLAG_LO_SPARKLE;
                        else if (targetIsGM)
                            dynFlags |= GO_DYNFLAG_LO_ACTIVATE;
                        break;
                    case GAMEOBJECT_TYPE_GENERIC:
                        if (ActivateToQuest(target))
                            dynFlags |= GO_DYNFLAG_LO_SPARKLE;
                        break;
                    case GAMEOBJECT_TYPE_TRANSPORT:
                    case GAMEOBJECT_TYPE_MO_TRANSPORT:
                    {
                        dynFlags = uint16(GetUInt32Value(OBJECT_FIELD_DYNAMIC_FLAGS) & 0xFFFF);
 
                        uint32 const transportPeriod = GetTransportPeriod();
                        if (Skyfire::GameObjects::UsesControlledTransportProgress(GetGoType(), transportPeriod) && transportPeriod)
                        {
                            uint32 const transportProgress = Skyfire::GameObjects::GetTransportDynamicPathProgress(
                                GetGoType(), transportPeriod, m_goValue.Transport.PathProgress);
                            pathProgress = int16(float(transportProgress) / float(transportPeriod) * 65535.0f);
                        }
                        break;
                    }
                    default:
                        break;
                }
 
                fieldBuffer << uint16(dynFlags);
                fieldBuffer << int16(pathProgress);
            }
            else if (index == GAMEOBJECT_FIELD_FLAGS)
            {
                uint32 flags = m_uint32Values[GAMEOBJECT_FIELD_FLAGS];
                if (GetGoType() == GAMEOBJECT_TYPE_CHEST)
                    if (GetGOInfo()->chest.groupLootRules && !IsLootAllowedFor(target))
                        flags |= GO_FLAG_LOCKED | GO_FLAG_NOT_SELECTABLE;
 
                fieldBuffer << flags;
            }
            else
                fieldBuffer << m_uint32Values[index];                // other cases
        }
    }
 
    *data << uint8(updateMask.GetBlockCount());
    updateMask.AppendToPacket(data);
    data->append(fieldBuffer);
    *data << uint8(0);
}
 
void GameObject::GetRespawnPosition(float& x, float& y, float& z, float* ori /* = NULL*/) const
{
    if (m_DBTableGuid)
    {
        if (GameObjectData const* data = sObjectMgr->GetGOData(GetDBTableGUIDLow()))
        {
            x = data->posX;
            y = data->posY;
            z = data->posZ;
            if (ori)
                *ori = data->orientation;
            return;
        }
    }
 
    x = GetPositionX();
    y = GetPositionY();
    z = GetPositionZ();
    if (ori)
        *ori = GetOrientation();
}
 
void GameObject::UpdateModelPosition()
{
    if (!m_model)
        return;
 
    if (GetMap()->ContainsGameObjectModel(*m_model))
    {
        GetMap()->RemoveGameObjectModel(*m_model);
        m_model->Relocate();
        GetMap()->InsertGameObjectModel(*m_model);
    }
}
uint32 GameObject::GetGOStateValue(GOState state)
{
    switch (state)
    {
        case GOState::GO_STATE_ACTIVE:
            return 0;
            break;
        case GOState::GO_STATE_READY:
            return 1;
            break;
        case GOState::GO_STATE_ACTIVE_ALTERNATIVE:
            return 2;
            break;
        case GOState::GO_STATE_TRANSPORT_ACTIVE:
            return 24;
            break;
        case GOState::GO_STATE_TRANSPORT_STOPPED:
            return 25;
            break;
        default:
            return 0;
            break;
    }
}
 
class GameObjectModelOwnerImpl : public GameObjectModelOwnerBase
{
public:
    explicit GameObjectModelOwnerImpl(GameObject const* owner) : _owner(owner) { }
 
    bool isSpawned() const OVERRIDE { return _owner->isSpawned(); }
    uint32 GetDisplayId() const OVERRIDE { return _owner->GetDisplayId(); }
    uint32 GetPhaseMask() const OVERRIDE { return _owner->GetPhaseMask(); }
    G3D::Vector3 GetPosition() const OVERRIDE { return G3D::Vector3(_owner->GetPositionX(), _owner->GetPositionY(), _owner->GetPositionZ()); }
    float GetOrientation() const OVERRIDE { return _owner->GetOrientation(); }
    float GetScale() const OVERRIDE { return _owner->GetObjectScale(); }
    void DebugVisualizeCorner(G3D::Vector3 const& corner) const OVERRIDE { _owner->SummonCreature(1, corner.x, corner.y, corner.z, 0, TempSummonType::TEMPSUMMON_MANUAL_DESPAWN); }
 
private:
    GameObject const* _owner;
};
 
GameObjectModel* GameObject::CreateModel()
{
    return GameObjectModel::Create(std::make_unique<GameObjectModelOwnerImpl>(this), sWorld->GetDataPath());
}