自学教程：C++ GetBossState函数代码示例

        uint32 GetData(uint32 type)        {            switch (type)            {            case DATA_UROM_PLATAFORM:                return platformUrom;            // used by condition system            case DATA_UROM_EVENT:                return GetBossState(DATA_UROM_EVENT);            }            return 0;        }

			bool CheckRequiredBosses(uint32 bossId, Player const* player = NULL) const			{				if (player && player->isGameMaster())					return true;				switch (bossId)				{					case DATA_GENERAL_ZARITHRIAN:						if (GetBossState(DATA_BALTHARUS_THE_WARBORN) != DONE || GetBossState(DATA_SAVIANA_RAGEFIRE) != DONE)							return false;						break;					case DATA_HALION:						if (GetBossState(DATA_BALTHARUS_THE_WARBORN) != DONE || GetBossState(DATA_SAVIANA_RAGEFIRE) != DONE 							|| GetBossState(DATA_GENERAL_ZARITHRIAN) != DONE)							return false;						break;					default:						break;				}				return true;			}

 void OnCreatureCreate(Creature* creature) {     switch (creature->GetEntry())     {         case NPC_DRAKOS:             drakosGUID = creature->GetGUID();             break;         case NPC_VAROS:             varosGUID = creature->GetGUID();             if (GetBossState(DATA_DRAKOS_EVENT) == DONE)                creature->SetPhaseMask(1, true);             break;         case NPC_UROM:             uromGUID = creature->GetGUID();             if (GetBossState(DATA_VAROS_EVENT) == DONE)                 creature->SetPhaseMask(1, true);             break;         case NPC_EREGOS:             eregosGUID = creature->GetGUID();             if (GetBossState(DATA_UROM_EVENT) == DONE)                 creature->SetPhaseMask(1, true);             break;         case NPC_CENTRIFUGE_CONSTRUCT:             if (creature->isAlive())                 DoUpdateWorldState(WORLD_STATE_CENTRIFUGE_CONSTRUCT_AMOUNT, ++centrifugueConstructCounter);             break;         case NPC_BELGARISTRASZ:             belgaristraszGUID = creature->GetGUID();             if (GetBossState(DATA_DRAKOS_EVENT) == DONE)                 creature->SetWalk(true),                 creature->GetMotionMaster()->MovePoint(0, 941.453f, 1044.1f, 359.967f),                 creature->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);             break;         case NPC_ETERNOS:             eternosGUID = creature->GetGUID();             if (GetBossState(DATA_DRAKOS_EVENT) == DONE)                 creature->SetWalk(true),                 creature->GetMotionMaster()->MovePoint(0, 943.202f, 1059.35f, 359.967f),                 creature->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);             break;         case NPC_VERDISA:             verdisaGUID = creature->GetGUID();             if (GetBossState(DATA_DRAKOS_EVENT) == DONE)                 creature->SetWalk(true),                 creature->GetMotionMaster()->MovePoint(0, 949.188f, 1032.91f, 359.967f),                 creature->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);             break;         case NPC_GREATER_WHELP:             if (GetBossState(DATA_UROM_EVENT) == DONE)                 creature->SetPhaseMask(1, true);                 gwhelpList.push_back(creature->GetGUID());             break;     } }

            void OnUnitDeath(Unit* unit) override            {                Creature* creature = unit->ToCreature();                if (!creature)                    return;                if (creature->GetEntry() == NPC_GENERAL_ZARITHRIAN && GetBossState(DATA_HALION) != DONE)                {                    instance->LoadGrid(HalionControllerSpawnPos.GetPositionX(), HalionControllerSpawnPos.GetPositionY());                    if (Creature* halionController = instance->SummonCreature(NPC_HALION_CONTROLLER, HalionControllerSpawnPos))                        halionController->AI()->DoAction(ACTION_INTRO_HALION);                }            }

 void OnGameObjectCreate(GameObject* go) override {     switch (go->GetEntry())     {         case GO_ANOMALUS_CONTAINMET_SPHERE:             AnomalusContainmentSphere = go->GetGUID();             if (GetBossState(DATA_ANOMALUS) == DONE)                 go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);             break;         case GO_ORMOROKS_CONTAINMET_SPHERE:             OrmoroksContainmentSphere = go->GetGUID();             if (GetBossState(DATA_ORMOROK) == DONE)                 go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);             break;         case GO_TELESTRAS_CONTAINMET_SPHERE:             TelestrasContainmentSphere = go->GetGUID();             if (GetBossState(DATA_MAGUS_TELESTRA) == DONE)                 go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);             break;         default:             break;     } }

            void Load(char const* strIn)            {                if (!strIn)                {                    OUT_LOAD_INST_DATA_FAIL;                    return;                }                OUT_LOAD_INST_DATA(strIn);                char dataHead1, dataHead2;                std::istringstream loadStream(strIn);                loadStream >> dataHead1 >> dataHead2;                if (dataHead1 == 'U' && dataHead2 == 'U')                {                    for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)                    {                        uint32 tmpState;                        loadStream >> tmpState;                        if (tmpState == IN_PROGRESS || tmpState > SPECIAL)                            tmpState = NOT_STARTED;                        SetBossState(i, EncounterState(tmpState));                    }                    uint32 tempState;                    loadStream >> tempState;                    if (tempState == IN_PROGRESS || tempState > SPECIAL)                        tempState = NOT_STARTED;                    SetData(DATA_COLOSSUS, tempState);                    loadStream >> _algalonTimer;                    loadStream >> tempState;                    _algalonSummoned = tempState != 0;                    if (_algalonSummoned && GetBossState(BOSS_ALGALON) != DONE)                    {                        _summonAlgalon = true;                        if (_algalonTimer && _algalonTimer <= 60)                        {                            _events.ScheduleEvent(EVENT_UPDATE_ALGALON_TIMER, 60000);                            DoUpdateWorldState(WORLD_STATE_ALGALON_TIMER_ENABLED, 1);                            DoUpdateWorldState(WORLD_STATE_ALGALON_DESPAWN_TIMER, _algalonTimer);                        }                    }                }                OUT_LOAD_INST_DATA_COMPLETE;            }

 void SetData(uint32 type, uint32 data) override {     switch (type)     {         case AREATRIGGER:             if (data == AREATRIGGER_DRAGONSPIRE_HALL)             {                 if (GetBossState(DATA_DRAGONSPIRE_ROOM) != DONE)                     Events.ScheduleEvent(EVENT_DARGONSPIRE_ROOM_STORE, 1000);             }         default:             break;     } }

            bool SetBossState(uint32 type, EncounterState state) override            {                if (!InstanceScript::SetBossState(type, state))                    return false;                switch (type)                {                    case DATA_HYDROMANCER_THESPIA:                        if (state == DONE)                            if (GameObject* panel = GetGameObject(DATA_ACCESS_PANEL_HYDRO))                                panel->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);                        if (state == SPECIAL)                        {                            if (GetBossState(DATA_MEKGINEER_STEAMRIGGER) == SPECIAL)                                HandleGameObject(MainChambersDoorGUID, true);                            TC_LOG_DEBUG("scripts", "Instance Steamvault: Access panel used.");                        }                        break;                    case DATA_MEKGINEER_STEAMRIGGER:                        if (state == DONE)                            if (GameObject* panel = GetGameObject(DATA_ACCESS_PANEL_MEK))                                panel->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);                        if (state == SPECIAL)                        {                            if (GetBossState(DATA_HYDROMANCER_THESPIA) == SPECIAL)                                HandleGameObject(MainChambersDoorGUID, true);                            TC_LOG_DEBUG("scripts", "Instance Steamvault: Access panel used.");                        }                        break;                    default:                        break;                }                return true;            }

        bool SetBossState(uint32 type, EncounterState state) override        {            if (!InstanceScript::SetBossState(type, state))                return false;            switch (type)            {                case BOSS_RAZORGORE:                    HandleGameObject(RazorgoreDoorGUID, state == DONE);                    if (state == DONE)                    {                        for (GuidList::const_iterator itr = EggList.begin(); itr != EggList.end(); ++itr)                            if (GameObject* egg = instance->GetGameObject((*itr)))                                egg->SetPhaseMask(2, true);                    }                    SetData(DATA_EGG_EVENT, NOT_STARTED);                    break;                case BOSS_VAELASTRAZ:                    HandleGameObject(VaelastraszDoorGUID, state == DONE);                    break;                case BOSS_BROODLORD:                    HandleGameObject(BroodlordDoorGUID, state == DONE);                    break;                case BOSS_FIREMAW:                case BOSS_EBONROC:                case BOSS_FLAMEGOR:                    HandleGameObject(ChrommagusDoorGUID, GetBossState(BOSS_FIREMAW) == DONE && GetBossState(BOSS_EBONROC) == DONE && GetBossState(BOSS_FLAMEGOR) == DONE);                    break;                case BOSS_CHROMAGGUS:                    HandleGameObject(NefarianDoorGUID, state == DONE);                    break;                case BOSS_NEFARIAN:                    switch (state)                    {                        case NOT_STARTED:                            if (Creature* nefarian = instance->GetCreature(NefarianGUID))                                nefarian->DespawnOrUnsummon();                            break;                        case FAIL:                            _events.ScheduleEvent(EVENT_RESPAWN_NEFARIUS, 15*IN_MILLISECONDS*MINUTE);                            SetBossState(BOSS_NEFARIAN, NOT_STARTED);                            break;                        default:                            break;                    }                    break;            }            return true;        }

 void OnGameObjectCreate(GameObject* go) override {     switch (go->GetEntry())     {         case GAMEOBJECT_CORBORUS_ROCKDOOR:             corborusRockDoorGUID = go->GetGUID();             go->SetGoState(GetBossState(DATA_CORBORUS) != DONE ? GO_STATE_READY : GO_STATE_ACTIVE);             break;         case GAMEOBJECT_SLABHIDE_ROCK_WALL:             slabhideRockWallGUIDs.push_back(go->GetGUID());             break;         default:             break;     } }

            void Save()            {                OUT_SAVE_INST_DATA;                std::ostringstream saveStream;                for (uint8 i = 0; i < EncounterCount; ++i)                    saveStream << GetBossState(i) << ' ';                saveStream << TrialCounter;                SaveDataBuffer = saveStream.str();                SaveToDB();                OUT_SAVE_INST_DATA_COMPLETE;                NeedSave = false;            }

            void OnGameObjectCreate(GameObject* go) override            {                InstanceScript::OnGameObjectCreate(go);                switch (go->GetEntry())                {                    case GO_GONG_OF_BETHEKK:                        _goGongOfBethekkGUID = go->GetGUID();                        if (GetBossState(DATA_ARLOKK) == DONE)                            go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);                        else                            go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);                        break;                    default:                        break;                }            }

            bool CheckRequiredBosses(uint32 bossId, Player const* player = nullptr) const override            {                if (_SkipCheckRequiredBosses(player))                    return true;                switch (bossId)                {                    case DATA_SJONNIR:                        if (GetBossState(DATA_TRIBUNAL_OF_AGES) != DONE)                            return false;                        break;                    default:                        break;                }                return true;            }

            bool CheckRequiredBosses(uint32 bossId, Player const* player = nullptr) const override            {                if (player && player->GetSession()->HasPermission(rbac::RBAC_PERM_SKIP_CHECK_INSTANCE_REQUIRED_BOSSES))                    return true;                switch (bossId)                {                    case DATA_SJONNIR:                        if (GetBossState(DATA_TRIBUNAL_OF_AGES) != DONE)                            return false;                        break;                    default:                        break;                }                return true;            }

            void Update(uint32 diff)            {                if (GetData(TYPE_NORTHREND_BEASTS) == SNAKES_SPECIAL && NotOneButTwoJormungarsTimer)                {                    if (NotOneButTwoJormungarsTimer <= diff)                        NotOneButTwoJormungarsTimer = 0;                    else                        NotOneButTwoJormungarsTimer -= diff;                }                if (GetBossState(BOSS_CRUSADERS) == SPECIAL && ResilienceWillFixItTimer)                {                    if (ResilienceWillFixItTimer <= diff)                        ResilienceWillFixItTimer = 0;                    else                        ResilienceWillFixItTimer -= diff;                }            }

            void Update(uint32 diff) override            {                if (GetData(TYPE_NORTHREND_BEASTS) == SNAKES_SPECIAL && NotOneButTwoJormungarsTimer)                {                    if (NotOneButTwoJormungarsTimer <= diff)                        NotOneButTwoJormungarsTimer = 0;                    else                        NotOneButTwoJormungarsTimer -= diff;                }                if (GetBossState(DATA_FACTION_CRUSADERS) == IN_PROGRESS && ResilienceWillFixItTimer)                {                    if (ResilienceWillFixItTimer <= diff)                        ResilienceWillFixItTimer = 0;                    else                        ResilienceWillFixItTimer -= diff;                }            }

 void OnGameObjectCreate(GameObject* go) {     switch (go->GetEntry())     {         case GO_FORCEFIELD:             AddDoor(go, true);             break;         case GO_GONG_OF_BETHEKK:             _goGongOfBethekkGUID = go->GetGUID();             if (GetBossState(DATA_ARLOKK) == DONE)                 go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);             else                 go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);             break;         default:             break;     } }

            void ResetBossEncounter(uint8 bossId)            {                if (bossId < DATA_CYANIGOSA || bossId > DATA_ZURAMAT)                    return;                Creature* boss = GetCreature(bossId);                if (!boss)                    return;                switch (bossId)                {                    case DATA_CYANIGOSA:                        boss->DespawnOrUnsummon();                        break;                    case DATA_EREKEM:                        for (uint32 i = DATA_EREKEM_GUARD_1; i <= DATA_EREKEM_GUARD_2; ++i)                        {                            if (Creature* guard = instance->GetCreature(GetGuidData(i)))                            {                                if (guard->isDead())                                    guard->Respawn();                                if (GetBossState(bossId) == DONE)                                    UpdateKilledBoss(guard);                                guard->GetMotionMaster()->MoveTargetedHome();                                guard->SetImmuneToAll(true);                            }                        }                        /* fallthrough */                    default:                        if (boss->isDead())                        {                            // respawn and update to a placeholder npc to avoid be looted again                            boss->Respawn();                            UpdateKilledBoss(boss);                        }                        boss->GetMotionMaster()->MoveTargetedHome();                        boss->SetImmuneToAll(true);                        break;                }            }

            bool CheckRequiredBosses(uint32 bossId, Player const* player = NULL) const            {                if (!InstanceScript::CheckRequiredBosses(bossId, player))                    return false;                switch (bossId)                {                    case DATA_WILL_OF_EMPEROR:                    case DATA_ELEGON:                    case DATA_SPIRIT_KINGS:                    case DATA_GARAJAL:                    case DATA_FENG:                        if (GetBossState(bossId - 1) != DONE)                            return false;                    default:                        break;                }                return true;            }

			void OnGameObjectCreate(GameObject* gameobject)			{				switch (gameobject->GetEntry())				{					case GO_ALTAR_OF_SLAD_RAN:						_sladRanAltarGUID = gameobject->GetGUID();						gameobject->SetGoState(GetBossState(DATA_SLAD_RAN) == DONE ? GO_STATE_ACTIVE : GO_STATE_READY);						break;					case GO_ALTAR_OF_DRAKKARI:						_drakkariAltarGUID = gameobject->GetGUID();						gameobject->SetGoState(GetBossState(DATA_DRAKKARI_COLOSSUS) == DONE ? GO_STATE_ACTIVE : GO_STATE_READY);						break;					case GO_ALTAR_OF_MOORABI:						_moorabiAltarGUID = gameobject->GetGUID();						gameobject->SetGoState(GetBossState(DATA_MOORABI) == DONE ? GO_STATE_ACTIVE : GO_STATE_READY);						break;					case GO_STATUE_OF_SLAD_RAN:						_bridgeGUIDs[0] = gameobject->GetGUID();						gameobject->SetGoState(_keysInCount == 3 ? GO_STATE_ACTIVE_ALTERNATIVE : (GetBossState(DATA_SLAD_RAN) == DONE ? GO_STATE_READY : GO_STATE_ACTIVE));						break;					case GO_STATUE_OF_DRAKKARI:						_bridgeGUIDs[1] = gameobject->GetGUID();						gameobject->SetGoState(_keysInCount == 3 ? GO_STATE_ACTIVE_ALTERNATIVE : (GetBossState(DATA_DRAKKARI_COLOSSUS) == DONE ? GO_STATE_READY : GO_STATE_ACTIVE));						break;					case GO_STATUE_OF_MOORABI:						_bridgeGUIDs[2] = gameobject->GetGUID();						gameobject->SetGoState(_keysInCount == 3 ? GO_STATE_ACTIVE_ALTERNATIVE : (GetBossState(DATA_MOORABI) == DONE ? GO_STATE_READY : GO_STATE_ACTIVE));						break;					case GO_STATUE_OF_GAL_DARAH:						_bridgeGUIDs[3] = gameobject->GetGUID();						gameobject->SetGoState(_keysInCount == 3 ? GO_STATE_ACTIVE_ALTERNATIVE : GO_STATE_READY);						break;					case GO_GUNDRAK_COLLISION:						_bridgeGUIDs[4] = gameobject->GetGUID();						gameobject->SetGoState(_keysInCount == 3 ? GO_STATE_ACTIVE_ALTERNATIVE : GO_STATE_READY);						break;					case GO_GUNDRAK_BRIDGE:						_bridgeGUIDs[5] = gameobject->GetGUID();						gameobject->SetGoState(GO_STATE_READY);						break;					case GO_ECK_DOORS:					case GO_ECK_UNDERWATER_GATE:					case GO_GAL_DARAH_DOORS0:					case GO_GAL_DARAH_DOORS1:					case GO_GAL_DARAH_DOORS2:						AddDoor(gameobject, true);						break;				}			}

		bool CheckRequiredBosses(uint32 bossId, Player const* player = NULL) const		{			if (!InstanceScript::CheckRequiredBosses(bossId, player))				return false;			switch (bossId)			{			case DATA_TAYAK:			case DATA_GARALON:			case DATA_MELJARAK:			case DATA_UNSOK:			case DATA_SHEKZEER:				if (GetBossState(bossId - 1) != DONE)					return false;			default:				break;			}			return true;		}

 void OnGameObjectCreate(GameObject* go) {     switch (go->GetEntry())     {         case GO_PLATFORM:             platformGUID = go->GetGUID();             //if (GetBossState(BOSS_MALYGOS) == DONE)             //    go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_DESTROYED);             break;         case GO_EXIT_PORTAL:             exitPortalGUID = go->GetGUID();             break;         case GO_FOCUSING_IRIS_10:         case GO_FOCUSING_IRIS_25:             focusingIrisGUID = go->GetGUID();             if (GetBossState(BOSS_MALYGOS) == DONE)                 go->SetPhaseMask(2, true);             break;     } }

            void SummonMajordomoExecutus()            {                _executusSchedule = false;                if (_majordomoExecutusGUID)                    return;                if (GetBossState(BOSS_MAJORDOMO_EXECUTUS) != DONE)                {                    instance->SummonCreature(NPC_MAJORDOMO_EXECUTUS, SummonPositions[0]);                    instance->SummonCreature(NPC_FLAMEWAKER_HEALER, SummonPositions[1]);                    instance->SummonCreature(NPC_FLAMEWAKER_HEALER, SummonPositions[2]);                    instance->SummonCreature(NPC_FLAMEWAKER_HEALER, SummonPositions[3]);                    instance->SummonCreature(NPC_FLAMEWAKER_HEALER, SummonPositions[4]);                    instance->SummonCreature(NPC_FLAMEWAKER_ELITE, SummonPositions[5]);                    instance->SummonCreature(NPC_FLAMEWAKER_ELITE, SummonPositions[6]);                    instance->SummonCreature(NPC_FLAMEWAKER_ELITE, SummonPositions[7]);                    instance->SummonCreature(NPC_FLAMEWAKER_ELITE, SummonPositions[8]);                }                else if (TempSummon* summon = instance->SummonCreature(NPC_MAJORDOMO_EXECUTUS, RagnarosTelePos))                    summon->AI()->DoAction(ACTION_START_RAGNAROS_ALT);            }

 void SetData(uint32 type, uint32 data) {     switch (type)     {         case DATA_CHANNELER_COMBAT:             if (GetBossState(TYPE_MAGTHERIDON) != IN_PROGRESS)                 if (Creature* magtheridon = instance->GetCreature(_magtheridonGUID))                     magtheridon->SetInCombatWithZone();             break;         case DATA_ACTIVATE_CUBES:             for (std::set<uint64>::const_iterator itr = _cubesSet.begin(); itr != _cubesSet.end(); ++itr)                 if (GameObject* cube = instance->GetGameObject(*itr))                     cube->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);             break;         case DATA_COLLAPSE:             for (std::set<uint64>::const_iterator itr = _columnSet.begin(); itr != _columnSet.end(); ++itr)                 if (GameObject* column = instance->GetGameObject(*itr))                     column->SetGoState(GOState(data));             break;     } }

        void OnUnitDeath(Unit* unit) override        {            Creature* creature = unit->ToCreature();            if (!creature)                return;            switch (creature->GetEntry())            {                case NPC_COLDMIST_WIDOW:                case NPC_COLDMIST_STALKER:                case NPC_SHADOWBAT:                case NPC_VAMPIRIC_SHADOWBAT:                case NPC_GREATER_SHADOWBAT:                case NPC_PHASE_HOUND:                case NPC_DREADBEAST:                case NPC_SHADOWBEAST:                    if (GetBossState(DATA_OPTIONAL_BOSS) == TO_BE_DECIDED)                    {                        ++OptionalBossCount;                        if (OptionalBossCount == OPTIONAL_BOSS_REQUIRED_DEATH_COUNT)                        {                            switch (urand(NPC_HYAKISS_THE_LURKER, NPC_ROKAD_THE_RAVAGER))                            {                                case NPC_HYAKISS_THE_LURKER:                                    instance->SummonCreature(NPC_HYAKISS_THE_LURKER, OptionalSpawn[0]);                                    break;                                case NPC_SHADIKITH_THE_GLIDER:                                    instance->SummonCreature(NPC_SHADIKITH_THE_GLIDER, OptionalSpawn[1]);                                    break;                                case NPC_ROKAD_THE_RAVAGER:                                    instance->SummonCreature(NPC_ROKAD_THE_RAVAGER, OptionalSpawn[2]);                                    break;                            }                        }                    }                    break;                default:                    break;            }        }

        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;            }        }

        void Update(uint32 diff) override        {            Events.Update(diff);            while (uint32 eventId = Events.ExecuteEvent())            {                switch (eventId)                {                    case EVENT_DARGONSPIRE_ROOM_STORE:                        Dragonspireroomstore();                        Events.ScheduleEvent(EVENT_DARGONSPIRE_ROOM_CHECK, 3000);                        break;                    case EVENT_DARGONSPIRE_ROOM_CHECK:                        Dragonspireroomcheck();                        if ((GetBossState(DATA_DRAGONSPIRE_ROOM) != DONE))                            Events.ScheduleEvent(EVENT_DARGONSPIRE_ROOM_CHECK, 3000);                        break;                    default:                         break;                }            }        }

 void OnGameObjectCreate(GameObject* go) override {     switch (go->GetEntry())     {         case GO_UTGARDE_MIRROR:             UtgardeMirrorGUID = go->GetGUID();             break;         case GO_GORTOK_PALEHOOF_SPHERE:             GortokPalehoofSphereGUID = go->GetGUID();             if (GetBossState(DATA_GORTOK_PALEHOOF) == DONE)             {                 HandleGameObject(ObjectGuid::Empty, true, go);                 go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);             }             break;         case GO_SKADI_THE_RUTHLESS_DOOR:         case GO_KING_YMIRON_DOOR:             AddDoor(go, true);             break;         default:             break;     } }