instance_onyxias_lair.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
/* ScriptData
SDName: Instance_Onyxias_Lair
SD%Complete: 100
SDComment:
SDCategory: Onyxia's Lair
EndScriptData */
 
#include "ScriptMgr.h"
#include "AreaBoundary.h"
#include "CellImpl.h"
#include "CreatureAI.h"
#include "GridNotifiersImpl.h"
#include "InstanceScript.h"
#include "Map.h"
#include "onyxias_lair.h"
#include "TemporarySummon.h"
#include <queue>
 
BossBoundaryData const boundaries =
{
    { DATA_ONYXIA, new CircleBoundary(Position(-34.3697f, -212.3296f), 100.0) }
};
 
DungeonEncounterData const encounters[] =
{
    { DATA_ONYXIA, {{ 1084 }} }
};
 
class instance_onyxias_lair : public InstanceMapScript
{
public:
    instance_onyxias_lair() : InstanceMapScript(OnyxiaScriptName, 249) { }
 
    InstanceScript* GetInstanceScript(InstanceMap* map) const override
    {
        return new instance_onyxias_lair_InstanceMapScript(map);
    }
 
    struct instance_onyxias_lair_InstanceMapScript : public InstanceScript
    {
        instance_onyxias_lair_InstanceMapScript(InstanceMap* map) : InstanceScript(map)
        {
            SetHeaders(DataHeader);
            SetBossNumber(EncounterCount);
            LoadBossBoundaries(boundaries);
            LoadDungeonEncounterData(encounters);
 
            onyxiaLiftoffTimer = 0;
            manyWhelpsCounter = 0;
            eruptTimer = 0;
 
            achievManyWhelpsHandleIt = false;
            achievSheDeepBreathMore = true;
        }
 
        //Eruption is a BFS graph problem
        //One map to remember all floor, one map to keep floor that still need to erupt and one queue to know what needs to be removed
 
        void OnCreatureCreate(Creature* creature) override
        {
            switch (creature->GetEntry())
            {
                case NPC_ONYXIA:
                    onyxiaGUID = creature->GetGUID();
                    break;
            }
        }
 
        void OnGameObjectCreate(GameObject* go) override
        {
            if ((go->GetGOInfo()->displayId == 4392 || go->GetGOInfo()->displayId == 4472) && go->GetGOInfo()->trap.spell == 17731)
            {
                FloorEruptionGUID[0].insert(std::make_pair(go->GetGUID(), 0));
                return;
            }
 
            switch (go->GetEntry())
            {
                case GO_WHELP_SPAWNER:
                    Position goPos = go->GetPosition();
                    if (Creature* temp = go->SummonCreature(NPC_WHELP, goPos, TEMPSUMMON_CORPSE_DESPAWN))
                    {
                        temp->AI()->DoZoneInCombat();
                        ++manyWhelpsCounter;
                    }
                    break;
            }
        }
 
        void OnGameObjectRemove(GameObject* go) override
        {
            if ((go->GetGOInfo()->displayId == 4392 || go->GetGOInfo()->displayId == 4472) && go->GetGOInfo()->trap.spell == 17731)
            {
                FloorEruptionGUID[0].erase(go->GetGUID());
                return;
            }
        }
 
        void FloorEruption(ObjectGuid floorEruptedGUID)
        {
            if (GameObject* floorEruption = instance->GetGameObject(floorEruptedGUID))
            {
                //THIS GOB IS A TRAP - What shall i do? =(
                //Cast it spell? Copyed Heigan method
                floorEruption->SendCustomAnim(floorEruption->GetGoAnimProgress());
                CastSpellExtraArgs args;
                args.OriginalCaster = onyxiaGUID;
                floorEruption->CastSpell(floorEruption, floorEruption->GetGOInfo()->trap.spell, args);
 
                //Get all immediatly nearby floors
                std::list<GameObject*> nearFloorList;
                Trinity::GameObjectInRangeCheck check(floorEruption->GetPositionX(), floorEruption->GetPositionY(), floorEruption->GetPositionZ(), 15);
                Trinity::GameObjectListSearcher<Trinity::GameObjectInRangeCheck> searcher(floorEruption, nearFloorList, check);
                Cell::VisitGridObjects(floorEruption, searcher, SIZE_OF_GRIDS);
                //remove all that are not present on FloorEruptionGUID[1] and update treeLen on each GUID
                for (std::list<GameObject*>::const_iterator itr = nearFloorList.begin(); itr != nearFloorList.end(); ++itr)
                {
                    if (((*itr)->GetGOInfo()->displayId == 4392 || (*itr)->GetGOInfo()->displayId == 4472) && (*itr)->GetGOInfo()->trap.spell == 17731)
                    {
                        ObjectGuid nearFloorGUID = (*itr)->GetGUID();
                        if (FloorEruptionGUID[1].find(nearFloorGUID) != FloorEruptionGUID[1].end() && (*FloorEruptionGUID[1].find(nearFloorGUID)).second == 0)
                        {
                            (*FloorEruptionGUID[1].find(nearFloorGUID)).second = (*FloorEruptionGUID[1].find(floorEruptedGUID)).second+1;
                            FloorEruptionGUIDQueue.push(nearFloorGUID);
                        }
                    }
                }
            }
            FloorEruptionGUID[1].erase(floorEruptedGUID);
        }
 
        bool SetBossState(uint32 type, EncounterState state) override
        {
            if (!InstanceScript::SetBossState(type, state))
                return false;
 
            switch (type)
            {
                case DATA_ONYXIA:
                    if (state == IN_PROGRESS)
                        SetBossState(DATA_SHE_DEEP_BREATH_MORE, IN_PROGRESS);
                    break;
            }
            return true;
        }
 
        void SetData(uint32 type, uint32 data) override
        {
            switch (type)
            {
                case DATA_ONYXIA_PHASE:
                    if (data == PHASE_BREATH) //Used to mark the liftoff phase
                    {
                        achievManyWhelpsHandleIt = false;
                        manyWhelpsCounter = 0;
                        onyxiaLiftoffTimer = 10000;
                    }
                    break;
                case DATA_SHE_DEEP_BREATH_MORE:
                    if (data == IN_PROGRESS)
                    {
                        achievSheDeepBreathMore = true;
                    }
                    else if (data == FAIL)
                    {
                        achievSheDeepBreathMore = false;
                    }
                    break;
            }
        }
 
        void SetGuidData(uint32 type, ObjectGuid data) override
        {
            switch (type)
            {
                case DATA_FLOOR_ERUPTION_GUID:
                    FloorEruptionGUID[1] = FloorEruptionGUID[0];
                    FloorEruptionGUIDQueue.push(data);
                    eruptTimer = 2500;
                    break;
            }
        }
 
        ObjectGuid GetGuidData(uint32 data) const override
        {
            switch (data)
            {
                case NPC_ONYXIA:
                    return onyxiaGUID;
            }
 
            return ObjectGuid::Empty;
        }
 
        void Update(uint32 diff) override
        {
            if (GetBossState(DATA_ONYXIA) == IN_PROGRESS)
            {
                if (onyxiaLiftoffTimer && onyxiaLiftoffTimer <= diff)
                {
                    onyxiaLiftoffTimer = 0;
                    if (manyWhelpsCounter >= 50)
                        achievManyWhelpsHandleIt = true;
                } else onyxiaLiftoffTimer -= diff;
            }
 
            if (!FloorEruptionGUIDQueue.empty())
            {
                if (eruptTimer <= diff)
                {
                    ObjectGuid frontGuid = FloorEruptionGUIDQueue.front();
                    std::map<ObjectGuid, uint32>::iterator itr = FloorEruptionGUID[1].find(frontGuid);
                    if (itr != FloorEruptionGUID[1].end())
                    {
                        uint32 treeHeight = itr->second;
 
                        do
                        {
                            FloorEruption(frontGuid);
                            FloorEruptionGUIDQueue.pop();
                            if (FloorEruptionGUIDQueue.empty())
                                break;
 
                            frontGuid = FloorEruptionGUIDQueue.front();
                            itr = FloorEruptionGUID[1].find(frontGuid);
                        } while (itr != FloorEruptionGUID[1].end() && itr->second == treeHeight);
                    }
 
                    eruptTimer = 1000;
                }
                else
                    eruptTimer -= diff;
            }
        }
 
        bool CheckAchievementCriteriaMeet(uint32 criteriaId, Player const* /*source*/, Unit const* /*target = nullptr*/, uint32 /*miscValue1 = 0*/) override
        {
            switch (criteriaId)
            {
                case ACHIEV_CRITERIA_MANY_WHELPS_10_PLAYER:  // Criteria for achievement 4403: Many Whelps! Handle It! (10 player) Hatch 50 eggs in 10s
                case ACHIEV_CRITERIA_MANY_WHELPS_25_PLAYER:  // Criteria for achievement 4406: Many Whelps! Handle It! (25 player) Hatch 50 eggs in 10s
                    return achievManyWhelpsHandleIt;
                case ACHIEV_CRITERIA_DEEP_BREATH_10_PLAYER:  // Criteria for achievement 4404: She Deep Breaths More (10 player) Everybody evade Deep Breath
                case ACHIEV_CRITERIA_DEEP_BREATH_25_PLAYER:  // Criteria for achievement 4407: She Deep Breaths More (25 player) Everybody evade Deep Breath
                    return achievSheDeepBreathMore;
            }
            return false;
        }
 
    protected:
        std::map<ObjectGuid, uint32> FloorEruptionGUID[2];
        std::queue<ObjectGuid> FloorEruptionGUIDQueue;
        ObjectGuid onyxiaGUID;
        uint32 onyxiaLiftoffTimer;
        uint32 manyWhelpsCounter;
        uint32 eruptTimer;
        bool   achievManyWhelpsHandleIt;
        bool   achievSheDeepBreathMore;
    };
};
 
void AddSC_instance_onyxias_lair()
{
    new instance_onyxias_lair();
}