void SetData(uint32 type, uint32 data)
		{
			switch(type)
			{
				case DATA_INTRO:
					EncounterMask |= (1 << DATA_INTRO);
					AddWave1();
					break;
				case ACTION_SHOW_TRASH:
					RandomizeCompositionsAndShow();
					break;
				case DATA_FALRIC:
					if (WaveNumber)
					{
						if (data == NOT_STARTED)
							DoWipe1();
						else if (data == DONE)
						{
							NextWaveTimer = 60000;
							EncounterMask |= (1 << DATA_FALRIC);
						}
					}
					break;
				case DATA_MARWYN:
					if (WaveNumber)
					{
						if (data == NOT_STARTED)
							DoWipe1();
						else if (data == DONE)
						{
							EncounterMask |= (1 << DATA_MARWYN);
							HandleGameObject(GO_FrontDoorGUID, true);
							HandleGameObject(GO_ArthasDoorGUID, true);
							if (Creature* c = instance->GetCreature(NPC_FrostswornGeneralGUID))
							{
								c->SetVisible(true);
								c->SetReactState(REACT_AGGRESSIVE);
							}
							WaveNumber = 0;
							DoUpdateWorldState(WORLD_STATE_HOR_COUNTER, 0);

							// give quest
							Map::PlayerList const& pl = instance->GetPlayers();
							for (Map::PlayerList::const_iterator itr = pl.begin(); itr != pl.end(); ++itr)
								if (Player* p = itr->GetSource())
									p->CastSpell(p, p->GetTeamId() == TEAM_ALLIANCE ? SPELL_HOR_START_QUEST_ALLY : SPELL_HOR_START_QUEST_HORDE, true);
						}
					}
					break;
				case DATA_FROSTSWORN_GENERAL:
					EncounterMask |= (1 << DATA_FROSTSWORN_GENERAL);
					if (data == DONE)
					{
						if (Creature* c = instance->GetCreature(NPC_LichKingGUID))
							c->SetVisible(true);
						if (Creature* c = instance->GetCreature(NPC_LeaderGUID))
							c->SetVisible(true);
					}
					break;
				case ACTION_SPIRITUAL_REFLECTIONS_COPY:
					{
						uint8 i=0;
						Map::PlayerList const& pl = instance->GetPlayers();
						for (Map::PlayerList::const_iterator itr = pl.begin(); itr != pl.end(); ++itr)
							if (Player* p = itr->GetSource())
								if (p->IsAlive() && !p->IsGameMaster())
									if (Creature* c = instance->GetCreature(NPC_SpiritualReflectionGUID[i++]))
									{
										if (!c->IsAlive())
											c->Respawn();
										c->SetDisableGravity(true);
										c->SetCanFly(true);
										c->SetVisible(true);

										Item* i;
										i = p->GetWeaponForAttack(BASE_ATTACK);
										c->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, i ? i->GetEntry() : 0);
										i = p->GetWeaponForAttack(OFF_ATTACK);
										c->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 1, i ? i->GetEntry() : 0);
										i = p->GetWeaponForAttack(RANGED_ATTACK);
										c->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 2, i ? i->GetEntry() : 0);
										p->CastSpell(c, SPELL_HOR_CLONE, true);
										p->CastSpell(c, SPELL_HOR_CLONE_NAME, true);
									}
					}
					break;
				case ACTION_SPIRITUAL_REFLECTIONS_ACTIVATE:
					if (Creature* fg = instance->GetCreature(NPC_FrostswornGeneralGUID))
						for (uint8 i=0; i<5; ++i)
							if (Creature* c = instance->GetCreature(NPC_SpiritualReflectionGUID[i]))
								if (c->IsVisible())
								{
									c->SetInCombatWithZone();
									c->SetDisableGravity(false);
									c->SetCanFly(false);
									c->GetMotionMaster()->MoveJump(fg->GetPositionX(), fg->GetPositionY(), fg->GetPositionZ(), 20.0f, 10.0f);
								}
					break;
				case ACTION_SPIRITUAL_REFLECTIONS_HIDE:
					for (uint8 i=0; i<5; ++i)
						if (Creature* c = instance->GetCreature(NPC_SpiritualReflectionGUID[i]))
							c->AI()->EnterEvadeMode();
					break;
				case DATA_LK_INTRO:
					EncounterMask |= (1 << DATA_LK_INTRO);
					if (Creature* c = instance->GetCreature(NPC_LeaderGUID))
						c->AI()->DoAction(ACTION_START_INTRO);
					break;
				case ACTION_START_LK_FIGHT:
					IsDuringLKFight = true;
					DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_RETREATING_TIMED_EVENT);
					DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_RETREATING_TIMED_EVENT);
					break;
				case ACTION_STOP_LK_FIGHT:
					if (!IsDuringLKFight)
						break;
					instance->LoadGrid(LeaderEscapePos.GetPositionX(), LeaderEscapePos.GetPositionY());
					if (Creature* c = instance->GetCreature(NPC_LeaderGUID))
					{
						if (!c->IsAlive())
						{
							c->Respawn();
							if (TeamIdInInstance == TEAM_ALLIANCE)
								c->UpdateEntry(NPC_JAINA_PART2);
						}
						c->DeleteThreatList();
						c->CombatStop(true);
						c->InterruptNonMeleeSpells(true);
						c->GetMotionMaster()->Clear();
						c->GetMotionMaster()->MoveIdle();
						c->UpdatePosition(LeaderEscapePos, true);
						c->StopMovingOnCurrentPos();
						c->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_QUESTGIVER);
						c->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
						c->SetHealth(c->GetMaxHealth()/20);
						c->AI()->Reset();
						c->setActive(false);
						c->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
						c->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_NONE);
					}
					if (Creature* c = instance->GetCreature(NPC_LichKingGUID))
					{
						c->DeleteThreatList();
						c->CombatStop(true);
						c->InterruptNonMeleeSpells(true);
						c->GetMotionMaster()->Clear();
						c->GetMotionMaster()->MoveIdle();
						c->UpdatePosition(c->GetHomePosition(), true);
						c->StopMovingOnCurrentPos();
						c->RemoveAllAuras();
						c->AddAura(TeamIdInInstance == TEAM_ALLIANCE ? SPELL_JAINA_ICE_PRISON : SPELL_SYLVANAS_DARK_BINDING, c);
						c->AI()->Reset();
						c->setActive(false);
						c->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
						c->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_NONE);
						c->SetSpeed(MOVE_RUN, c->GetCreatureTemplate()->speed_run);
					}
					IsDuringLKFight = false;
					outroTimer = 0;
					outroStep = 0;
					// no break intended
				case ACTION_DELETE_ICE_WALL:
					HandleGameObject(GO_IceWallGUID, true);
					GO_IceWallGUID = 0;
					break;
				case DATA_LICH_KING:
					if (data == DONE)
					{
						instance->LoadGrid(PathWaypoints[0].GetPositionX(), PathWaypoints[0].GetPositionY());
						EncounterMask |= (1 << DATA_LICH_KING);
						if (Creature* c = instance->GetCreature(NPC_LeaderGUID))
							c->setActive(false);
						if (Creature* c = instance->GetCreature(NPC_LichKingGUID))
							c->setActive(false);
						IsDuringLKFight = false;
						outroStep = 1;
						outroTimer = 0;
					}
					break;
				case DATA_BATTERED_HILT:
					{
						if (EncounterMask & (1 << DATA_BATTERED_HILT))
							return;

						switch(data)
						{
							case 1: // talked to leader
								EncounterMask |= (1 << DATA_BATTERED_HILT);
								SaveToDB();
								break;
							case 2:
								if (BatteredHiltStatus)
									break;
								BatteredHiltStatus |= BHSF_STARTED;
								if (Creature* c = instance->GetCreature(NPC_AltarBunnyGUID))
									c->CastSpell(c, 70720, true);
								if (Creature* c = instance->GetCreature(NPC_UtherGUID))
									c->m_Events.AddEvent(new UtherBatteredHiltEvent(*c, 1), c->m_Events.CalculateTime(3000));
								break;
							case 3:
								if ((BatteredHiltStatus & BHSF_STARTED) == 0 || (BatteredHiltStatus & BHSF_THROWN))
									break;
								BatteredHiltStatus |= BHSF_THROWN;
								if (Creature* c = instance->GetCreature(NPC_UtherGUID))
								{
									c->AI()->Talk(SAY_BATTERED_HILT_LEAP);
									c->m_Events.AddEvent(new UtherBatteredHiltEvent(*c, 3), c->m_Events.CalculateTime(1500));
								}
								break;
							case 4:
								if (Creature* c = instance->GetCreature(NPC_QuelDelarGUID))
								{
									c->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
									c->SetSpeed(MOVE_RUN, 2.5f);
								}
								break;
							case 5:
								if (Creature* c = instance->GetCreature(NPC_UtherGUID))
									c->m_Events.AddEvent(new UtherBatteredHiltEvent(*c, 6), c->m_Events.CalculateTime(3000));
								break;
							case 6:
								if (Creature* c = instance->GetCreature(NPC_QuelDelarGUID))
								{
									c->SetSpeed(MOVE_RUN, c->GetCreatureTemplate()->speed_run);
									c->GetMotionMaster()->MoveLand(0, c->GetPositionX(), c->GetPositionY(), 707.70f, 7.0f);
								}
								break;
							case 7:
								if (Creature* c = instance->GetCreature(NPC_QuelDelarGUID))
								{
									c->SetReactState(REACT_AGGRESSIVE);
									c->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_IMMUNE_TO_NPC);
									c->RemoveAurasDueToSpell(70300);
								}
								break;
							case 8:
								if (Creature* c = instance->GetCreature(NPC_QuelDelarGUID))
									c->SetInCombatWithZone();
								break;
							case 9:
								EncounterMask |= (1 << DATA_BATTERED_HILT);
								BatteredHiltStatus |= BHSF_FINISHED;
								SaveToDB();
								break;
						}
					}
					return;
			}

			if (data == DONE)
				SaveToDB();
		}
        void SetData(uint32 type, uint32 data)
        {
            if (type == DATA_WAVE_COUNT && data == SPECIAL)
            {
                CloseDoor(FrontDoor);
                events.ScheduleEvent(EVENT_NEXT_WAVE, 10000);
                return;
            }

            if (WaveCount && data == NOT_STARTED)
                DoWipe();

            switch (type)
            {
                case DATA_INTRO_EVENT:
                    IntroDone = data;
                    break;
                case DATA_FALRIC_EVENT:
                    Encounter[0] = data;
                    if (data == DONE)
                        events.ScheduleEvent(EVENT_NEXT_WAVE, 60000);
                    break;
                case DATA_MARWYN_EVENT:
                    Encounter[1] = data;
                    if (data == DONE)
                    {
                        OpenDoor(FrostwornDoor);
                        OpenDoor(FrontDoor);
                    }
                    break;
                case DATA_FROSWORN_EVENT:
                    Encounter[2] = data;
                    if (data == DONE)
                    {
                        OpenDoor(ArthasDoor);
                        SetData(DATA_PHASE, 3);
                        instance->SummonCreature(BOSS_LICH_KING, OutroSpawns[0]);
                        instance->SummonCreature(NPC_JAINA_OUTRO, OutroSpawns[1]);
                    }
                    break;
                case DATA_LICHKING_EVENT:
                    Encounter[3] = data;
                    if (data == IN_PROGRESS)
                    {
                        OpenDoor(RunDoor);

                        if (instance->IsHeroic())
                            DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                    }
                    if (data == FAIL)
                    {
                        for (uint8 i = 0; i<4; i++)
                            OpenDoor(WallID[i]);

                        CloseDoor(RunDoor);

                        if (Creature* lichKing = instance->GetCreature(LichKing))
                            lichKing->DespawnOrUnsummon(10000);
                        if (Creature* lider = instance->GetCreature(Lider))
                            lider->DespawnOrUnsummon(10000);

                        DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                        DoCastSpellOnPlayers(5); // Kill all players

                        SetData(DATA_PHASE, 3);
                        instance->SummonCreature(BOSS_LICH_KING, OutroSpawns[0]);
                        instance->SummonCreature(NPC_JAINA_OUTRO, OutroSpawns[1]);
                    }
                    if (data == DONE)
                    {
                        if (GameObject* chest = instance->GetGameObject(Chest))
                            chest->SetPhaseMask(1, true);
                        if (GameObject* portal = instance->GetGameObject(uiPortal))
                            portal->SetPhaseMask(1, true);

                        /*DoCompleteAchievement(ACHIEV_HALLS_OF_REFLECTION_N);
                        if (instance->IsHeroic())
                        {
                            DoCompleteAchievement(ACHIEV_HALLS_OF_REFLECTION_H);
                            DoCastSpellOnPlayers(SPELL_ACHIEV_CHECK);
                            DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                        }*/
                    }
                    break;
                case DATA_SUMMONS:
                    if (data == 3) Summons = 0;
                    else if (data == 1) ++Summons;
                    else if (data == 0) --Summons;
                    data = NOT_STARTED;
                    break;
                case DATA_ICE_WALL_1:
                    Wall[0] = data;
                    break;
                case DATA_ICE_WALL_2:
                    Wall[1] = data;
                    break;
                case DATA_ICE_WALL_3:
                    Wall[2] = data;
                    break;
                case DATA_ICE_WALL_4:
                    Wall[3] = data;
                    break;
                case DATA_PHASE:
                    DataPhase = data;
                    break;
            }

            if (data == DONE)
                SaveToDB();
        }
        void SetData(uint32 type, uint32 data)
        {
            if (type == DATA_WAVE_COUNT && data == SPECIAL)
            {
                  bIntroDone = true;
                  CloseDoor(uiFrontDoor);
                  CloseDoor(uiRunDoor);
                  events.ScheduleEvent(EVENT_NEXT_WAVE, 9000);
                return;
            }

            if (uiWaveCount && data == NOT_STARTED)
                  DoWipe();

            switch (type)
            {
                case DATA_FALRIC_EVENT:
                    uiEncounter[0] = data;
                    if (data == DONE)
                           events.ScheduleEvent(EVENT_NEXT_WAVE, 9000);
                    if (Creature* partner = instance->GetCreature(uiPartner2))
                           partner->SetVisible(false);
                    break;
                case DATA_MARWYN_EVENT:
                    uiEncounter[1] = data;
                    if (data == DONE)
                    {
                           OpenDoor(uiFrostswornDoor);
                           OpenDoor(uiFrontDoor);
                    }
                    break;
                case DATA_FROSTSWORN_EVENT:
                    uiEncounter[2] = data;
                    if (data == DONE)
                    {     
                           OpenDoor(uiArthasDoor);
                           SetData(DATA_PHASE, 3);
                           instance->SummonCreature(NPC_LICH_KING_BOSS, OutroSpawns[0]);
                           instance->SummonCreature(NPC_SYLVANAS_PART2, OutroSpawns[1]);
                    }
                    if (Creature* partner = instance->GetCreature(uiPartner2))                    
                           partner->SetVisible(true);
                    break;
                case DATA_LICHKING_EVENT:
                    uiEncounter[3] = data;
                    if (data == IN_PROGRESS)
                    {
                           OpenDoor(uiRunDoor);
                        if (instance->IsHeroic())
                               DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                    }
                    if (data == FAIL)
                    {
                        for(uint8 i = 0; i<4; i++)
                               OpenDoor(uiWallID[i]);

                        CloseDoor(uiRunDoor);

                        if (Creature* pLichKing = instance->GetCreature(uiLichKing))
                               pLichKing->DespawnOrUnsummon(10000);
                        if (Creature* pLider = instance->GetCreature(uiLider))
                               pLider->DespawnOrUnsummon(10000);

                        DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                        DoCastSpellOnPlayers(5); // Kill all players

                        SetData(DATA_PHASE, 3);
                        instance->SummonCreature(NPC_LICH_KING_BOSS, OutroSpawns[0]);
                        instance->SummonCreature(NPC_SYLVANAS_PART2, OutroSpawns[1]);
                    }
                    if (data == DONE)
                    {
                        if (GameObject *pChest = instance->GetGameObject(uiChest))
                               pChest->SetPhaseMask(1, true);
                        if (GameObject *pPortal = instance->GetGameObject(uiPortal))
                               pPortal->SetPhaseMask(1, true);

                        //ToDo Complete Achievement ACHIEV_HALLS_OF_REFLECTION_N
                        if (instance->IsHeroic())
                        {
                        //ToDo Complete Achievement(ACHIEV_HALLS_OF_REFLECTION_H);
                               DoCastSpellOnPlayers(SPELL_ACHIEV_CHECK);
                               DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                        }
                    }
                    break;
                case DATA_WAVES_BEGIN:
                    uiWaveBegin = data;
                    break;
                 case DATA_SUMMONS:
                    if (data == 3) uiSummons = 0;
                    else if (data == 1) ++uiSummons;
                    else if (data == 0) --uiSummons;
                    data = NOT_STARTED;
                    break;
                case DATA_ICE_WALL_1:
                    uiWall[0] = data;
                    break;
                case DATA_ICE_WALL_2:
                    uiWall[1] = data;
                    break;
                case DATA_ICE_WALL_3:
                    uiWall[2] = data;
                    break;
                case DATA_ICE_WALL_4:
                    uiWall[3] = data;
                    break;
                case DATA_PHASE:
                    uiDataPhase = data;
                    break;
            }

            if (data == DONE)
                SaveToDB();
        }
        void SetData(uint32 type, uint32 data)
        {
            switch (type)
            {
                case DATA_WAVE_COUNT:
                    if (GetData(DATA_MARWYN_EVENT) == DONE)
                    {
                        WaveCnt = 0;
                        DoUpdateWorldState(WORLD_STATE_HOR_WAVE_COUNT, 0);
                        DoUpdateWorldState(WORLD_STATE_HOR, WaveCnt);
                        events.CancelEvent(EVENT_NEXT_WAVE);
                        break;
                    }
                    if (data == START_WAVES) // Start der Wellen
                    {
                        CloseDoor(FrontDoorGUID);
                        events.ScheduleEvent(EVENT_NEXT_WAVE, 0);
                        break;
                    }
                    if (data == START_NEXT_WAVE_INSTANT) // Nächste Welle sofort
                    {
                        events.RescheduleEvent(EVENT_NEXT_WAVE, 0);
                        break;
                    }
                    if (data == START_NEXT_WAVE) // Nächste Welle starten
                    {
                        events.RescheduleEvent(EVENT_NEXT_WAVE, SEKUNDEN_60);
                        break;
                    }
                    if (WaveCnt && data == START_RESET) // Wipe
                    {
                        DoWipe();
                        break;
                    }
                    break;
                case DATA_INTRO_EVENT:
                    IntroDone = data;
                    break;
                case DATA_FALRIC_EVENT:
                    Encounter[0] = data;
                    if (data == DONE)
                        events.RescheduleEvent(EVENT_NEXT_WAVE, SEKUNDEN_60);
                    break;
                case DATA_MARWYN_EVENT:
                    Encounter[1] = data;
                    if (data == DONE)
                    {
                        DoUpdateWorldState(WORLD_STATE_HOR, 0);
                        OpenDoor(FrostwornDoorGUID);
                        OpenDoor(FrontDoorGUID);
                    }
                    break;
                case DATA_FROSWORN_EVENT:
                    Encounter[2] = data;
                    if (data == DONE)
                    {
                        OpenDoor(ArthasDoorGUID);
                        SetData(DATA_PHASE, 3);
                        instance->SummonCreature(BOSS_LICH_KING, OutroSpawns[0]);
                        instance->SummonCreature(NPC_JAINA_OUTRO, OutroSpawns[1]);
                    }
                    break;
                case DATA_LICHKING_EVENT:
                    Encounter[3] = data;
                    switch(data)
                    {
                        case IN_PROGRESS:
                            OpenDoor(RunDoorGUID);
                            if (instance->IsHeroic())
                                DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                            break;
                        case FAIL:
                            for (uint8 i=0; i<4; ++i)
                                OpenDoor(WallGUID[i]);

                            CloseDoor(RunDoorGUID);

                            if (Creature * LichKing = instance->GetCreature(LichKingGUID))
                                LichKing->DespawnOrUnsummon(10000);
                            if (Creature * Leader = instance->GetCreature(LeaderGUID))
                                Leader->DespawnOrUnsummon(10000);

                            DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                            DoCastSpellOnPlayers(SPELL_SUICIDE); // Alle Spieler begehen Selbsmord!

                            SetData(DATA_PHASE, 3);
                            instance->SummonCreature(BOSS_LICH_KING, OutroSpawns[0]);
                            instance->SummonCreature(NPC_JAINA_OUTRO, OutroSpawns[1]);
                            break;
                        case DONE:
                            if (GameObject * Chest = instance->GetGameObject(ChestGUID))
                                Chest->SetPhaseMask(1, true);
                            if (GameObject * Portal = instance->GetGameObject(PortalGUID))
                                Portal->SetPhaseMask(1, true);

                            DoCompleteAchievement(ACHIEV_HALLS_OF_REFLECTION_N);

                            if (instance->IsHeroic())
                            {
                                DoCompleteAchievement(ACHIEV_HALLS_OF_REFLECTION_H);
                                DoCastSpellOnPlayers(SPELL_ACHIEV_CHECK);
                                DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                            }
                            break;
                    }
                    break;
                case DATA_SUMMONS:
                    if (data == 3)
                        Summons = 0;
                    else if (data == 1)
                        ++Summons;
                    else if (data == 0)
                        --Summons;
                    data = NOT_STARTED;
                    break;
                case DATA_ICE_WALL_1:
                    WallData[0] = data;
                    break;
                case DATA_ICE_WALL_2:
                    WallData[1] = data;
                    break;
                case DATA_ICE_WALL_3:
                    WallData[2] = data;
                    break;
                case DATA_ICE_WALL_4:
                    WallData[3] = data;
                    break;
                case DATA_PHASE:
                    PhaseData = data;
                    break;
            }

            if (data == DONE)
                SaveToDB();
        }
            void SetData(uint32 type, uint32 data)
            {
                switch (type)
                {
                    case DATA_MEATHOOK_EVENT:
                        _encounterState[0] = data;
                        break;
                    case DATA_SALRAMM_EVENT:
                        if(data == DONE)
                        {
                            DoUpdateWorldState(WORLDSTATE_WAVE_COUNT, 0);
                            if(ArthasNeedsTeleport())
                                if(Creature* arthas = instance->GetCreature(_arthasGUID))
                                    arthas->AI()->SetData(1, 0);
                        }
                        _encounterState[1] = data;
                        break;
                    case DATA_EPOCH_EVENT:
                        _encounterState[2] = data;
                        break;
                    case DATA_MAL_GANIS_EVENT:
                        _encounterState[3] = data;

                        switch (_encounterState[3])
                        {
                            case NOT_STARTED:
                                HandleGameObject(_malGanisGate2GUID, true);
                                break;
                            case IN_PROGRESS:
                                HandleGameObject(_malGanisGate2GUID, false);
                                break;
                            case DONE:
                                HandleGameObject(_exitGateGUID, true);
                                if (GameObject* go = instance->GetGameObject(_malGanisChestGUID))
								{
                                    go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
									go->SetPhaseMask(1, true);
								}
                                instance->SummonCreature(NPC_CHROMIE_3, ChromieExitSummonPos);
                                Map::PlayerList const &players = instance->GetPlayers();
                                for(Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                                    itr->getSource()->KilledMonsterCredit(31006, 0);
                                break;
                        }
                        break;
                    case DATA_INFINITE_EVENT:
                        _encounterState[4] = data;
                        switch(data)
                        {
                            case DONE:
                                DoUpdateWorldState(WORLDSTATE_TIME_GUARDIAN_SHOW, 0);
                                //DoCompleteAchievement(ACHIEVEMENT_CULLING_TIME);
                                break;
                            case FAIL:
                                DoUpdateWorldState(WORLDSTATE_TIME_GUARDIAN_SHOW, 0);
                                if(Creature* infinite = instance->GetCreature(_infiniteGUID))
                                    infinite->AI()->DoAction(0);
                                break;
                            case IN_PROGRESS:
                                DoUpdateWorldState(WORLDSTATE_TIME_GUARDIAN_SHOW, 1);
                                DoUpdateWorldState(WORLDSTATE_TIME_GUARDIAN, 25);
								timerVisible = true;
                                instance->SummonCreature(NPC_INFINITE, InfiniteSummonPos);
                                break;
                        }
                        break;
                    case DATA_ARTHAS_EVENT:
                        if(data == FAIL)
                        {
                            if(Creature* deadArthas = instance->GetCreature(_arthasGUID))
                            {
                                deadArthas->DespawnOrUnsummon(10000);
                                int index;
                                if(_artasStepUi >= 83) // Before last run
                                    index = 2;
                                else if(_artasStepUi >= 60) // Before the council
                                    index = 1;
                                else // entrance of city
                                    index = 0;

                                if(Creature* newArthas = instance->SummonCreature(NPC_ARTHAS, ArthasSpawnPositions[index]))
                                    newArthas->AI()->SetData(0, (uint32)pow(2.0f, index));
                            }
                        }
                        break;
                    case DATA_CRATE_COUNT:
                        _crateCount = data;
						DoUpdateWorldState(WORLDSTATE_CRATES_REVEALED, _crateCount);
                        if (_crateCount == 5)
                        {
                            if (Creature* bunny = instance->GetCreature(_genericBunnyGUID))
                                bunny->CastSpell(bunny, SPELL_CRATES_CREDIT, true);

							// Summon Chromie and global whisper
                            if (Creature* chromie = instance->SummonCreature(NPC_CHROMIE_2, ChromieSummonPos))
                                if (!instance->GetPlayers().isEmpty())
                                    if (Player* player = instance->GetPlayers().getFirst()->getSource())
                                        sCreatureTextMgr->SendChat(chromie, SAY_CRATES_COMPLETED, player->GetGUID(), CHAT_MSG_ADDON, LANG_ADDON, TEXT_RANGE_ZONE);

							DoUpdateWorldState(WORLDSTATE_SHOW_CRATES, 0);

							if(Creature* crier = instance->GetCreature(_lordaeronCrierGUID))
								crier->YellToZone(-1595053, LANG_UNIVERSAL, 0);
						}
                        break;
                    case DATA_TRANSFORM_CITIZENS:
                        switch(data)
                        {
                            case SPECIAL: // Respawn Zombies
                                while(!_zombiesList.empty())
                                {
                                    Creature* summon = instance->GetCreature(*_zombiesList.begin());
                                    if(!summon)
                                        _zombiesList.erase(_zombiesList.begin());
                                    else
                                    {
                                        _zombiesList.erase(_zombiesList.begin());
                                        if(TempSummon* summ = summon->ToTempSummon())
                                        {
                                            summon->DestroyForNearbyPlayers();
                                            summ->UnSummon();
                                        }
                                        else
                                            summon->DisappearAndDie();
                                    }
                                }
                            case IN_PROGRESS: // Transform Citizens
                                for(std::list<uint64>::iterator itr = _citizensList.begin(); itr != _citizensList.end(); ++itr)
                                    if(Creature* citizen = instance->GetCreature((*itr)))
                                    {
                                        if(Creature* arthas = instance->GetCreature(GetData64(DATA_ARTHAS)))
                                            if(Creature* risenZombie = arthas->SummonCreature(NPC_ZOMBIE, citizen->GetPositionX(), citizen->GetPositionY(), citizen->GetPositionZ(), citizen->GetOrientation())) //, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5000))
											{
                                                _zombiesList.push_back(risenZombie->GetGUID());
												risenZombie->SetRespawnTime(60);
												risenZombie->GetMotionMaster()->MoveRandom(10.0f);
											}
                                        citizen->SetPhaseMask(2, true);
                                    }
                                break;
                        }
                        break;
                    case DATA_ZOMBIEFEST:
                        if(!instance->IsHeroic() || GetData(DATA_ZOMBIEFEST) == DONE)
                            break;

                        switch(data)
                        {
                            case DONE:
                                //DoCompleteAchievement(ACHIEVEMENT_ZOMBIEFEST);
                                _zombieFest = data;
                                break;
                            case IN_PROGRESS:
                                _zombieFest = data;
                                break;
                            case FAIL:
                                _killedZombieCount = 0;
                                _zombieTimer = 60000;
                                _zombieFest = data;
                               DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_CREATURE, ACHIEVEMENT_ZOMBIEFEST);
                                break;
                            case SPECIAL:
                                _killedZombieCount++;
								DoUpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE, 27737, 1);
                                if(_killedZombieCount == 1)
								{
                                    SetData(DATA_ZOMBIEFEST, IN_PROGRESS);
									DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_CREATURE, ACHIEVEMENT_ZOMBIEFEST);
								}
                                else if(_killedZombieCount >= 100 && GetData(DATA_ZOMBIEFEST) == IN_PROGRESS)
                                    SetData(DATA_ZOMBIEFEST, DONE);
                                //else
                                //{
                                    //if(_killedZombieCount%10 == 0);
                                //}
                                break;
                        }
                        break;
                    case DATA_ARTHAS_STEP:
                        _artasStepUi = data;
                        return;
                    case DATA_SKIP:
                        _skipUi = data;
                }

                if (data == DONE)
                    SaveToDB();
            }
示例#6
0
        void SetData(uint32 type, uint32 data)
        {
            if (type == DATA_WIPE)
            {
                DoWipe();
                return;
            }

            if (type == DATA_WAVES_STATE && data == IN_PROGRESS)
            {
                uiWaveState = data;
                HandleGameObject(uiFrontDoor, false);
                events.CancelEvent(EVENT_NEXT_WAVE);
                events.ScheduleEvent(EVENT_NEXT_WAVE, 10000);
                return;
            }

            switch (type)
            {
                case DATA_INTRO_EVENT:
                    uiIntroDone = data;
                    break;
                case DATA_FALRIC_EVENT:
                    uiEncounter[0] = data;
                    if (data == DONE)
                    {
                        events.CancelEvent(EVENT_NEXT_WAVE);
                        events.ScheduleEvent(EVENT_NEXT_WAVE, WAVE_STD_SPAWNCYCLE);
                    }
                    break;
                case DATA_MARWYN_EVENT:
                    uiEncounter[1] = data;
                    if (data == DONE)
                    {
                        HandleGameObject(uiFrostwornDoor, true);
                        HandleGameObject(uiFrontDoor, true);
                    }
                    break;
                case DATA_FROSWORN_EVENT:
                    uiEncounter[2] = data;
                    if (data == DONE)
                    {
                        HandleGameObject(uiArthasDoor, true);
                        SetData(DATA_PHASE, 3);

                        instance->SummonCreature(NPC_LICH_KING_BOSS, OutroSpawns[0]);
                        instance->SummonCreature(uiTeamInInstance == HORDE ? NPC_SYLVANAS_PART2 : NPC_JAINA_PART2, OutroSpawns[1]);
                    }
                    break;
                case DATA_LICHKING_EVENT:
                    uiEncounter[3] = data;

                    if (data == IN_PROGRESS)
                    {
                        // Respawn all ice uiWalls on gossip select
                        for (uint8 i = 0; i<4; i++)
                            HandleGameObject(uiWallID[i], false);

                        // Open door on gossip select
                        HandleGameObject(uiRunDoor, true);
                        if (instance->IsHeroic())
                            DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                    }

                    if (data == FAIL)
                    {
                        // Open ice uiWalls on wipe (way back for alive players)
                        for (uint8 i = 0; i<4; i++)
                            HandleGameObject(uiWallID[i], true);

                        // Open door on wipe (way back for alive players)
                        HandleGameObject(uiRunDoor, true);

                        if (Creature* pLichKing = instance->GetCreature(uiLichKingEvent))
                            pLichKing->DespawnOrUnsummon(10000);

                        if (Creature* pLeader = instance->GetCreature(uiLeader))
                            pLeader->DespawnOrUnsummon(10000);

                        DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                        DoCastSpellOnPlayers(5); // Kill all players

                        SetData(DATA_PHASE, 3);
                        instance->SummonCreature(NPC_LICH_KING_BOSS, OutroSpawns[0]);
                        instance->SummonCreature(uiTeamInInstance == HORDE ? NPC_SYLVANAS_PART2 : NPC_JAINA_PART2, OutroSpawns[1]);
                    }

                    if (data == DONE)
                    {
                        // Open ice uiWalls on complete (way back for alive players)
                        for (uint8 i = 0; i<4; i++)
                            HandleGameObject(uiWallID[i], true);

                        // Open door on complete (way back for alive players)
                        HandleGameObject(uiRunDoor, true);

                        if (GameObject* pChest = instance->GetGameObject(uiChest))
                            pChest->SetPhaseMask(1, true);
                        if (GameObject* pPortal = instance->GetGameObject(uiPortal))
                            pPortal->SetPhaseMask(1, true);

                        if (!instance->IsHeroic())
                        {
                            DoCompleteAchievement(ACHIEV_HALLS_OF_REFLECTION_N);
                        }
                        else
                        {
                            DoCompleteAchievement(ACHIEV_HALLS_OF_REFLECTION_H);
                            DoCastSpellOnPlayers(SPELL_ACHIEV_CHECK);
                            DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_NOT_RETREATING_EVENT);
                        }

                    }
                    break;
                case DATA_ICE_WALL_1:
                    uiWall[0] = data;
                    if (data == IN_PROGRESS)
                    {
                        uiCurrentWall = 1;
                    }
                    break;
                case DATA_ICE_WALL_2:
                    uiWall[1] = data;
                    if (data == IN_PROGRESS)
                    {
                        uiCurrentWall = 2;
                    }
                    break;
                case DATA_ICE_WALL_3:
                    uiWall[2] = data;
                    if (data == IN_PROGRESS)
                    {
                        uiCurrentWall = 3;
                    }
                    break;
                case DATA_ICE_WALL_4:
                    uiWall[3] = data;
                    if (data == IN_PROGRESS)
                    {
                        uiCurrentWall = 4;
                    }
                    break;
                case DATA_PHASE:
                    uiDataPhase = data;
                    break;
                case DATA_CURRENT_WALL:
                    uiCurrentWall = data;
                    break;
                case DATA_WAVES_STATE:
                    uiWaveState = data;
                    break;
            }

            if (data == DONE)
                SaveToDB();
        }
        void SetData(uint32 type, uint32 data)
        {
            switch(type)
            {
				case DATA_WAVE_STATE:
                    uiWaveState = data;
                    
                    if (data == SPECIAL) // Called on first spawn
                    {
                        CloseDoor(uiFrontDoor);
                        if (!m_bIsCall)
                        {
                           m_bIsCall = true;
                           Summon();
                        }
                        events.ScheduleEvent(EVENT_NEXT_WAVE, 15000);
                     }
                     
                     if (data == IN_PROGRESS) // Called on failed wave
                    {
                        CloseDoor(uiFrontDoor);
                        if (!m_bIsCall)
                        {
                           m_bIsCall = true;
                           Summon();
                        }
                        events.ScheduleEvent(EVENT_NEXT_WAVE, 3000);
                    }

                    if (uiWaveCount && data == FAIL)
                        DoWipe();
                    break;
                case DATA_INTRO_EVENT:
                    uiIntroDone = data;
                    break;
                case DATA_FALRIC_EVENT:
                    uiEncounter[0] = data;
                    if (data == DONE)
                        events.ScheduleEvent(EVENT_NEXT_WAVE, 60000);
                    break;
                case DATA_MARWYN_EVENT:
                    uiEncounter[1] = data;
                    if (data == DONE)
                    {
                        OpenDoor(uiFrostwornDoor);
                        OpenDoor(uiFrontDoor);
                    }
                    break;
                case DATA_FROSWORN_EVENT:
                    uiEncounter[2] = data;
                    if (data == DONE)
                    {
                        OpenDoor(uiArthasDoor);
                        SetData(DATA_PHASE, 3);
                        instance->SummonCreature(BOSS_LICH_KING, OutroSpawns[0]);
                        instance->SummonCreature(NPC_JAINA_OUTRO, OutroSpawns[1]);
                    }
                    break;
                case DATA_LICHKING_EVENT:
                    uiEncounter[3] = data;
                    if(data == IN_PROGRESS)
                    {
                        OpenDoor(uiRunDoor);

                        if(instance->IsHeroic())
                            DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEVNOTRETREATINGEVENT);
                    }
                    if(data == FAIL)
                    {
                        for(uint8 i = 0; i<4; i++)
                            OpenDoor(uiWallID[i]);

                        CloseDoor(uiRunDoor);

                        if(Creature* pLichKing = instance->GetCreature(uiLichKing))
                            pLichKing->DespawnOrUnsummon(10000);
                        if(Creature* pLider = instance->GetCreature(uiLider))
                            pLider->DespawnOrUnsummon(10000);

                        DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEVNOTRETREATINGEVENT);
                        DoCastSpellOnPlayers(5); // Kill all players

                        SetData(DATA_PHASE, 3);
                        instance->SummonCreature(BOSS_LICH_KING, OutroSpawns[0]);
                        instance->SummonCreature(NPC_JAINA_OUTRO, OutroSpawns[1]);
                    }
                    if(data == DONE)
                    {
                        if(GameObject *pChest = instance->GetGameObject(uiChest))
                            pChest->SetPhaseMask(1, true);
                        if(GameObject *pPortal = instance->GetGameObject(uiPortal))
                            pPortal->SetPhaseMask(1, true);

						AchievementEntry const* AchievHoRN = sAchievementStore.LookupEntry(ACHIEVHORN);

						Map::PlayerList const &players = instance->GetPlayers();
                        for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
							itr->getSource()->CompletedAchievement(AchievHoRN);

                        if(instance->IsHeroic())
                        {
							AchievementEntry const* AchievHoRH = sAchievementStore.LookupEntry(ACHIEVHORH);
                            for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
								itr->getSource()->CompletedAchievement(AchievHoRH);
                            DoCastSpellOnPlayers(SPELL_ACHIEV_CHECK);
                            DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEVNOTRETREATINGEVENT);
                        }
                    }
                    break;
                case DATA_SUMMONS:
                    if (data == 3) uiSummons = 0;
                    else if (data == 1) ++uiSummons;
                    else if (data == 0) --uiSummons;
                    data = NOT_STARTED;
                    break;
                case DATA_ICE_WALL_1:
                    uiWall[0] = data;
                    break;
                case DATA_ICE_WALL_2:
                    uiWall[1] = data;
                    break;
                case DATA_ICE_WALL_3:
                    uiWall[2] = data;
                    break;
                case DATA_ICE_WALL_4:
                    uiWall[3] = data;
                    break;
                case DATA_PHASE:
                    uiDataPhase = data;
                    break;
            }

            if (data == DONE)
                SaveToDB();
        }