void OnGameObjectCreate(GameObject* pGo, bool /*add*/) {
			switch (pGo->GetEntry()) {
			//door and object id
			case ENTRY_BELLOW_1:
				forge_bellow[0] = pGo->GetGUID();
				if (forge_event[0] != NOT_STARTED)
					HandleGameObject(NULL, true, pGo);
				break;
			case ENTRY_BELLOW_2:
				forge_bellow[1] = pGo->GetGUID();
				if (forge_event[1] != NOT_STARTED)
					HandleGameObject(NULL, true, pGo);
				break;
			case ENTRY_BELLOW_3:
				forge_bellow[2] = pGo->GetGUID();
				if (forge_event[2] != NOT_STARTED)
					HandleGameObject(NULL, true, pGo);
				break;
			case ENTRY_FORGEFIRE_1:
				forge_fire[0] = pGo->GetGUID();
				if (forge_event[0] != NOT_STARTED)
					HandleGameObject(NULL, true, pGo);
				break;
			case ENTRY_FORGEFIRE_2:
				forge_fire[1] = pGo->GetGUID();
				if (forge_event[1] != NOT_STARTED)
					HandleGameObject(NULL, true, pGo);
				break;
			case ENTRY_FORGEFIRE_3:
				forge_fire[2] = pGo->GetGUID();
				if (forge_event[2] != NOT_STARTED)
					HandleGameObject(NULL, true, pGo);
				break;
			case ENTRY_GLOWING_ANVIL_1:
				forge_anvil[0] = pGo->GetGUID();
				if (forge_event[0] != NOT_STARTED)
					HandleGameObject(NULL, true, pGo);
				break;
			case ENTRY_GLOWING_ANVIL_2:
				forge_anvil[1] = pGo->GetGUID();
				if (forge_event[1] != NOT_STARTED)
					HandleGameObject(NULL, true, pGo);
				break;
			case ENTRY_GLOWING_ANVIL_3:
				forge_anvil[2] = pGo->GetGUID();
				if (forge_event[2] != NOT_STARTED)
					HandleGameObject(NULL, true, pGo);
				break;
			case ENTRY_GIANT_PORTCULLIS_1:
				portcullis[0] = pGo->GetGUID();
				if (m_auiEncounter[2] == DONE)
					HandleGameObject(NULL, true, pGo);
				break;
			case ENTRY_GIANT_PORTCULLIS_2:
				portcullis[1] = pGo->GetGUID();
				if (m_auiEncounter[2] == DONE)
					HandleGameObject(NULL, true, pGo);
				break;
			}
		}
        void SetData(uint32 type, uint32 data)
        {
            switch (type)
            {
            case DATA_HIGHWARLORDNAJENTUSEVENT:
                if (data == DONE)
                    HandleGameObject(NajentusGate, true);
                m_auiEncounter[0] = data;
                break;
            case DATA_SUPREMUSEVENT:
                if (data == DONE)
                    HandleGameObject(NajentusGate, true);
                m_auiEncounter[1] = data;
                break;
            case DATA_SHADEOFAKAMAEVENT:
                if (data == IN_PROGRESS)
                    HandleGameObject(ShadeOfAkamaDoor, false);
                else
                    HandleGameObject(ShadeOfAkamaDoor, true);
                m_auiEncounter[2] = data;
                break;
            case DATA_TERONGOREFIENDEVENT:
                if (data == IN_PROGRESS)
                {
                    HandleGameObject(TeronDoor, false);
                    HandleGameObject(CommonDoor, false);
                }
                else
                {
                    HandleGameObject(TeronDoor, true);
                    HandleGameObject(CommonDoor, true);
                }
                m_auiEncounter[3] = data;
                break;
            case DATA_GURTOGGBLOODBOILEVENT:
                if (data == DONE)
                    HandleGameObject(GuurtogDoor, true);
                m_auiEncounter[4] = data;
                break;
            case DATA_RELIQUARYOFSOULSEVENT:
                if (data == DONE)
                    HandleGameObject(TempleDoor, true);
                m_auiEncounter[5] = data;
                break;
            case DATA_MOTHERSHAHRAZEVENT:
                if (data == DONE)
                    HandleGameObject(MotherDoor, true);
                m_auiEncounter[6] = data;
                break;
            case DATA_ILLIDARICOUNCILEVENT:
                if (data == IN_PROGRESS)
                {
                    HandleGameObject(CouncilDoor, false);
                    HandleGameObject(SimpleDoor, false);
                }
                else
                {
                    HandleGameObject(CouncilDoor, true);
                    HandleGameObject(SimpleDoor, true);
                }
                m_auiEncounter[7] = data;
                break;
            case DATA_ILLIDANSTORMRAGEEVENT:
                m_auiEncounter[8] = data;
                break;
            }

            if (m_auiEncounter[5] == DONE && m_auiEncounter[4] == DONE && m_auiEncounter[3] == DONE && m_auiEncounter[2] == DONE)
            {
                HandleGameObject(TempleDoor, true);
            }

            if (data == DONE)
            {
                OUT_SAVE_INST_DATA;

                std::ostringstream saveStream;
                saveStream << m_auiEncounter[0] << ' ' << m_auiEncounter[1] << ' '
                    << m_auiEncounter[2] << ' ' << m_auiEncounter[3] << ' ' << m_auiEncounter[4]
                << ' ' << m_auiEncounter[5] << ' ' << m_auiEncounter[6] << ' ' << m_auiEncounter[7]
                << ' ' << m_auiEncounter[8];

                str_data = saveStream.str();

                SaveToDB();
                OUT_SAVE_INST_DATA_COMPLETE;
            }
        }
Beispiel #3
0
 void OpenDoor(uint64 DoorGUID, bool open)
 {
     HandleGameObject(DoorGUID, open, NULL);
 }
 void SetData(uint32 type, uint32 data)
 {
     switch (type)
     {
         case TYPE_GELIHAST:
             encounter[0] = data;
             if (data == DONE)
                 if (GameObject* go = instance->GetGameObject(shrineOfGelihastGUID))
                     go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
             break;
         case TYPE_AKU_MAI:
             encounter[3] = data;
             if (data == DONE)
                 if (GameObject* go = instance->GetGameObject(altarOfTheDeepsGUID))
                 {
                     go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
                     go->SummonCreature(NPC_MORRIDUNE, SpawnsLocation[4], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                 }
             break;
         case DATA_FIRE:
             countFires = data;
             switch (countFires)
             {
                 case 1:
                     if (GameObject* go = instance->GetGameObject(shrine1GUID))
                     {
                         go->SummonCreature(NPC_AKU_MAI_SNAPJAW, SpawnsLocation[0], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         go->SummonCreature(NPC_AKU_MAI_SNAPJAW, SpawnsLocation[1], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         go->SummonCreature(NPC_AKU_MAI_SNAPJAW, SpawnsLocation[2], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         go->SummonCreature(NPC_AKU_MAI_SNAPJAW, SpawnsLocation[3], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                     }
                     break;
                 case 2:
                     if (GameObject* go = instance->GetGameObject(shrine1GUID))
                     {
                         for (uint8 i = 0; i < 2; ++i)
                         {
                             go->SummonCreature(NPC_MURKSHALLOW_SOFTSHELL, SpawnsLocation[0], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                             go->SummonCreature(NPC_MURKSHALLOW_SOFTSHELL, SpawnsLocation[1], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                             go->SummonCreature(NPC_MURKSHALLOW_SOFTSHELL, SpawnsLocation[2], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                             go->SummonCreature(NPC_MURKSHALLOW_SOFTSHELL, SpawnsLocation[3], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         }
                     }
                     break;
                 case 3:
                     if (GameObject* go = instance->GetGameObject(shrine1GUID))
                     {
                         go->SummonCreature(NPC_AKU_MAI_SERVANT, SpawnsLocation[1], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         go->SummonCreature(NPC_AKU_MAI_SERVANT, SpawnsLocation[2], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                     }
                     break;
                 case 4:
                     if (GameObject* go = instance->GetGameObject(shrine1GUID))
                     {
                         go->SummonCreature(NPC_BARBED_CRUSTACEAN, SpawnsLocation[0], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         go->SummonCreature(NPC_BARBED_CRUSTACEAN, SpawnsLocation[1], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         go->SummonCreature(NPC_BARBED_CRUSTACEAN, SpawnsLocation[2], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         go->SummonCreature(NPC_BARBED_CRUSTACEAN, SpawnsLocation[3], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                     }
                     break;
             }
             break;
         case DATA_EVENT:
             deathTimes = data;
             if (deathTimes == 18)
                 HandleGameObject(mainDoorGUID, true);
             break;
     }
 }
 void TombOfSevenStart()
 {
     HandleGameObject(GoTombExitGUID, false);//event started, close exit door
     HandleGameObject(GoTombEnterGUID, false);//event started, close entrance door
     SetData(TYPE_TOMB_OF_SEVEN, IN_PROGRESS);
 }
 void OnGameObjectCreate(GameObject* go)
 {
     // TODO: init state depending on encounters
     switch (go->GetEntry())
     {
         case GO_FROSTMOURNE:
             uiFrostmourne = go->GetGUID();
             go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
             HandleGameObject(0, false, go);
             break;
         case GO_FROSTMOURNE_ALTAR:
             uiFrostmourneAltar = go->GetGUID();
             go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
             HandleGameObject(0, true, go);
             break;
         case GO_FRONT_DOOR:
             uiFrontDoor = go->GetGUID();
             go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
             OpenDoor(uiFrontDoor);
             break;
         case GO_FROSTSWORN_DOOR:
             uiFrostswornDoor = go->GetGUID();
             go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
             if (uiEncounter[1] == DONE)
                    OpenDoor(uiFrostswornDoor);
             else
                 CloseDoor(uiFrostswornDoor);
             break;
         case GO_RUN_DOOR:
             uiRunDoor = go->GetGUID();                     
             break;
         case GO_ARTHAS_DOOR:
             uiArthasDoor = go->GetGUID();
             break;
         case GO_ICE_WALL_1:
             uiWallID[0] = go->GetGUID();
             break;
         case GO_ICE_WALL_2:
             uiWallID[1] = go->GetGUID();
             break;
         case GO_ICE_WALL_3:
             uiWallID[2] = go->GetGUID();
             break;
         case GO_ICE_WALL_4:
             uiWallID[3] = go->GetGUID();
             break;
         case GO_CAVE:
             uiCaveDoor = go->GetGUID();
             break;
         case GO_CAPTAIN_CHEST_1:
             go->SetPhaseMask(2, true);
             if (!instance->IsHeroic() && uiTeamInInstance == HORDE)
                    uiChest = go->GetGUID();
             break;
         case GO_CAPTAIN_CHEST_3:
             go->SetPhaseMask(2, true);
             if (instance->IsHeroic() && uiTeamInInstance == HORDE)
                    uiChest = go->GetGUID();
             break;
         case GO_CAPTAIN_CHEST_2:
             go->SetPhaseMask(2, true);
             if (!instance->IsHeroic() && uiTeamInInstance == ALLIANCE)
                    uiChest = go->GetGUID();
             break;
         case GO_CAPTAIN_CHEST_4:
             go->SetPhaseMask(2, true);
             if (instance->IsHeroic() && uiTeamInInstance == ALLIANCE)
                    uiChest = go->GetGUID();
             break;
         case GO_SKYBREAKER:
             go->SetPhaseMask(2, true);
             if (uiTeamInInstance == ALLIANCE)
                    uiGunship = go->GetGUID();
             break;
         case GO_ORGRIM_HAMMER:
             go->SetPhaseMask(2, true);
             if (uiTeamInInstance == HORDE)
                    uiGunship = go->GetGUID();
             break;
         case GO_PORTAL:
             go->SetPhaseMask(2, true);
             uiPortal = go->GetGUID();
             break;
     }
 }
Beispiel #7
0
 void OnObjectCreate(GameObject* pGo)
 {
     switch(pGo->GetEntry())
     {
         case 192518:
             uiSladRanAltar = pGo->GetGUID();
             // Make sure that they start out as unusuable
             pGo->SetFlag(GAMEOBJECT_FLAGS,GO_FLAG_UNK1);
             if (m_auiEncounter[0] == DONE)
             {
                 if (uiSladRanStatueState == GO_STATE_ACTIVE)
                     pGo->RemoveFlag(GAMEOBJECT_FLAGS,GO_FLAG_UNK1);
                 else
                 {
                     ++phase;
                     pGo->SetGoState(GO_STATE_ACTIVE);
                 }
             }
             break;
         case 192519:
             uiMoorabiAltar = pGo->GetGUID();
             // Make sure that they start out as unusuable
             pGo->SetFlag(GAMEOBJECT_FLAGS,GO_FLAG_UNK1);
             if (m_auiEncounter[0] == DONE)
             {
                 if (uiMoorabiStatueState == GO_STATE_ACTIVE)
                     pGo->RemoveFlag(GAMEOBJECT_FLAGS,GO_FLAG_UNK1);
                 else
                 {
                     ++phase;
                     pGo->SetGoState(GO_STATE_ACTIVE);
                 }
             }
             break;
         case 192520:
             uiDrakkariColossusAltar = pGo->GetGUID();
             // Make sure that they start out as unusuable
             pGo->SetFlag(GAMEOBJECT_FLAGS,GO_FLAG_UNK1);
             if (m_auiEncounter[0] == DONE)
             {
                 if (uiDrakkariColossusStatueState == GO_STATE_ACTIVE)
                     pGo->RemoveFlag(GAMEOBJECT_FLAGS,GO_FLAG_UNK1);
                 else
                 {
                     ++phase;
                     pGo->SetGoState(GO_STATE_ACTIVE);
                 }
             }
             break;
         case 192564:
             uiSladRanStatue = pGo->GetGUID();
             pGo->SetGoState(uiSladRanStatueState);
             break;
         case 192565:
             uiMoorabiStatue = pGo->GetGUID();
             pGo->SetGoState(uiMoorabiStatueState);
             break;
         case 192566:
             uiGalDarahStatue = pGo->GetGUID();
             pGo->SetGoState(uiGalDarahStatueState);
             break;
         case 192567:
             uiDrakkariColossusStatue = pGo->GetGUID();
             pGo->SetGoState(uiDrakkariColossusStatueState);
             break;
         case 192632:
             uiEckTheFerociousDoor = pGo->GetGUID();
             if (bHeroicMode && m_auiEncounter[1] == DONE)
                 HandleGameObject(NULL,true,pGo);
             break;
         case 192569:
             uiEckTheFerociousDoorBehind = pGo->GetGUID();
             if (bHeroicMode && m_auiEncounter[4] == DONE)
                 HandleGameObject(NULL,true,pGo);
         case 193208:
             uiGalDarahDoor1 = pGo->GetGUID();
             if (m_auiEncounter[3] == DONE)
                 HandleGameObject(NULL,true,pGo);
             break;
         case 193209:
             uiGalDarahDoor2 = pGo->GetGUID();
             if (m_auiEncounter[3] == DONE)
                 HandleGameObject(NULL,true,pGo);
             break;
     }
 }
    void SetData(uint32 type, uint32 data)
    {
        switch(type)
        {
        case DATA_PRINCEKELESETH_EVENT:
            if(data == DONE)
            {
                //HandleGameObject(doorname, 0);
            }
            Encounters[0] = data;
            break;
        case DATA_SKARVALD_DALRONN_EVENT:
            if(data == DONE)
            {
                //HandleGameObject(doorname, 0);
            }
            Encounters[1] = data;
            break;
        case DATA_INGVAR_EVENT:
            if(data == DONE)
            {
                //HandleGameObject(doorname, 0);
            }
            Encounters[2] = data;
            break;
        case EVENT_FORGE_1:
            if(data == NOT_STARTED)
            {
                HandleGameObject(forge_bellow[0],false);
                HandleGameObject(forge_fire[0],false);
                HandleGameObject(forge_anvil[0],false);
            }else
            {
                HandleGameObject(forge_bellow[0],true);
                HandleGameObject(forge_fire[0],true);
                HandleGameObject(forge_anvil[0],true);
            }
            break;
        case EVENT_FORGE_2:
            if(data == NOT_STARTED)
            {
                HandleGameObject(forge_bellow[1],false);
                HandleGameObject(forge_fire[1],false);
                HandleGameObject(forge_anvil[1],false);
            }else
            {
                HandleGameObject(forge_bellow[1],true);
                HandleGameObject(forge_fire[1],true);
                HandleGameObject(forge_anvil[1],true);
            }
            break;
        case EVENT_FORGE_3:
            if(data == NOT_STARTED)
            {
                HandleGameObject(forge_bellow[2],false);
                HandleGameObject(forge_fire[2],false);
                HandleGameObject(forge_anvil[2],false);
            }else
            {
                HandleGameObject(forge_bellow[2],true);
                HandleGameObject(forge_fire[2],true);
                HandleGameObject(forge_anvil[2],true);
            }
            break;
        }


        if (data == DONE)
        {
            SaveToDB();
        }
    }
Beispiel #9
0
        bool SetBossState(uint32 type, EncounterState state)
        {
            if (!InstanceScript::SetBossState(type, state))
                return false;

            if (uiEncounter[type] != DONE)
                uiEncounter[type] = state;

            if (state == DONE)
                SaveToDB();

            switch (type)
            {
            case TYPE_LEVIATHAN:
                for (std::list<uint64>::iterator i = uiLeviathanDoorGUIDList.begin(); i != uiLeviathanDoorGUIDList.end(); i++)
                {
                    if (GameObject* obj = instance->GetGameObject(*i))
                        obj->SetGoState(state == IN_PROGRESS ? GO_STATE_READY : GO_STATE_ACTIVE );
                }

                if (state == DONE)
                    HandleGameObject(uiXT002DoorGUID, true);
                break;
            case TYPE_IGNIS:
            case TYPE_RAZORSCALE:
            case TYPE_XT002:
                HandleGameObject(uiXT002DoorGUID, state != IN_PROGRESS);
                break;
            case TYPE_ASSEMBLY:
                HandleGameObject(IronCouncilEntranceGUID, state != IN_PROGRESS);
                if (state == DONE)
                    HandleGameObject(ArchivumDoorGUID, true);
                break;
            case TYPE_AURIAYA:
                break;
            case TYPE_MIMIRON:
                for (std::list<uint64>::iterator i = uiMimironDoorGUIDList.begin(); i != uiMimironDoorGUIDList.end(); i++)
                {
                    if (GameObject* obj = instance->GetGameObject(*i))
                        obj->SetGoState(state == IN_PROGRESS ? GO_STATE_READY : GO_STATE_ACTIVE );
                }
                break;
            case TYPE_VEZAX:
                if (state == DONE)
                    HandleGameObject(uiVezaxDoorGUID, true);
                break;
            case TYPE_YOGGSARON:
                if (state == IN_PROGRESS)
                    HandleGameObject(uiYoggSaronDoorGUID, false);
                else
                    HandleGameObject(uiYoggSaronDoorGUID, true);
                break;
            case TYPE_KOLOGARN:
                if (state == DONE)
                {
                    if (GameObject* go = instance->GetGameObject(uiKologarnChestGUID))
                        go->SetRespawnTime(go->GetRespawnDelay());
                    HandleGameObject(uiKologarnBridgeGUID, false);
                }
                break;
            case TYPE_HODIR:
                if (state == DONE)
                {
                    HandleGameObject(uiHodirIceDoorGUID, true);
                    HandleGameObject(uiHodirStoneDoorGUID, true);

                    if (GameObject* HodirRareCache = instance->GetGameObject(HodirRareCacheGUID))
                        if (GetData(DATA_HODIR_RARE_CHEST) == 1)
                            HodirRareCache->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
                    if (GameObject* go = instance->GetGameObject(uiHodirChestGUID))
                        go->SetRespawnTime(go->GetRespawnDelay());
                }

                HandleGameObject(uiHodirEntranceDoorGUID, state != IN_PROGRESS);
                break;
            case TYPE_THORIM:
                //if (state == DONE)
                //    if (GameObject* go = instance->GetGameObject(uiThorimChestGUID))
                //        go->SetRespawnTime(go->GetRespawnDelay());
                if (GameObject* obj = instance->GetGameObject(uiThorimDoorGUID))
                    obj->SetGoState(state == IN_PROGRESS ? GO_STATE_READY : GO_STATE_ACTIVE);
                break;
            case TYPE_FREYA:
                //if (state == DONE)
                //    if (GameObject* go = instance->GetGameObject(uiFreyaChestGUID))
                //        go->SetRespawnTime(go->GetRespawnDelay());
                break;
            case TYPE_ALGALON:
                if (state == IN_PROGRESS)
                {
                    HandleGameObject(AlgalonDoorGUID, false);     // Close Door
                    HandleGameObject(AlgalonFloorOOCGUID, true);  // Makes bridge disappear
                    HandleGameObject(AlgalonFloorCOMGUID, false); // Makes round combat floor appear
                    HandleGameObject(AlgalonBridgeGUID, true);    // Removes collision from bridge
                    HandleGameObject(AlgalonGlobeGUID,true);      // "Roomchanging"
                    HandleGameObject(AlgalonForceFieldGUID,false);// Invisible Forcefield, prevents escape
                }
                else
                {
                    HandleGameObject(AlgalonDoorGUID, true);
                    HandleGameObject(AlgalonFloorOOCGUID, false);
                    HandleGameObject(AlgalonFloorCOMGUID, true);
                    HandleGameObject(AlgalonBridgeGUID, false);
                    HandleGameObject(AlgalonGlobeGUID,false);
                    HandleGameObject(AlgalonForceFieldGUID,true);

                }
                break;
            }

            if (GetBossState(TYPE_FREYA) == DONE &&
                    GetBossState(TYPE_MIMIRON) == DONE &&
                    GetBossState(TYPE_HODIR) == DONE &&
                    GetBossState(TYPE_THORIM) == DONE)
                if (GameObject* go = instance->GetGameObject(uiWayToYoggGUID))
                    go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_LOCKED);
            return true;
        }
        void OnGameObjectCreate(GameObject * go)
        {
            // TODO: init state depending on encounters
            switch (go->GetEntry())
            {
                case GO_FROSTMOURNE:
                    FrostmourneGUID = go->GetGUID();
                    go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
                    HandleGameObject(0, false, go);
                    break;
                case GO_FROSTMOURNE_ALTAR:
                    go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
                    HandleGameObject(0, true, go);
                    break;
                case GO_FRONT_DOOR:
                    FrontDoorGUID = go->GetGUID();
                    go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
                    OpenDoor(FrontDoorGUID);
                    break;
                case GO_FROSTWORN_DOOR:
                    FrostwornDoorGUID = go->GetGUID();
                    go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);

                    if (Encounter[1] == DONE)
                        OpenDoor(FrostwornDoorGUID);
                    else
                        CloseDoor(FrostwornDoorGUID);
                    break;
                case GO_RUN_DOOR:
                    RunDoorGUID = go->GetGUID();
                    break;
                case GO_ARTHAS_DOOR:
                    ArthasDoorGUID = go->GetGUID();
                    break;
                case GO_ICE_WALL_1:
                    WallGUID[0] = go->GetGUID();
                    break;
                case GO_ICE_WALL_2:
                    WallGUID[1] = go->GetGUID();
                    break;
                case GO_ICE_WALL_3:
                    WallGUID[2] = go->GetGUID();
                    break;
                case GO_ICE_WALL_4:
                    WallGUID[3] = go->GetGUID();
                    break;
                case GO_CAVE:
                    CaveDoorGUID = go->GetGUID();
                    break;
                case GO_CAPTAIN_CHEST_1:
                    go->SetPhaseMask(2, true);
                    if (!instance->IsHeroic() && Team == HORDE)
                        ChestGUID = go->GetGUID();
                    break;
                case GO_CAPTAIN_CHEST_3:
                    go->SetPhaseMask(2, true);
                    if (instance->IsHeroic() && Team == HORDE)
                        ChestGUID = go->GetGUID();
                    break;
                case GO_CAPTAIN_CHEST_2:
                    go->SetPhaseMask(2, true);
                    if (!instance->IsHeroic() && Team == ALLIANCE)
                        ChestGUID = go->GetGUID();
                    break;
                case GO_CAPTAIN_CHEST_4:
                    go->SetPhaseMask(2, true);
                    if (instance->IsHeroic() && Team == ALLIANCE)
                        ChestGUID = go->GetGUID();
                    break;
                case GO_SKYBREAKER:
                    go->SetPhaseMask(2, true);
                    if (Team == ALLIANCE)
                        GunshipGUID = go->GetGUID();
                    break;
                case GO_ORGRIM_HAMMER:
                    go->SetPhaseMask(2, true);
                    if (Team == HORDE)
                        GunshipGUID = go->GetGUID();
                    break;
                case GO_PORTAL:
                    go->SetPhaseMask(2, true);
                    PortalGUID = go->GetGUID();
                    break;
            }
        }
    void SetData(uint32 type, uint32 data)
    {
        switch(type)
        {
            case DATA_MAKEREVENT:
                if (data == IN_PROGRESS)
                {
                    HandleGameObject(Maker1GUID, false);
                }
                else HandleGameObject(Maker1GUID, true);
                if (data == DONE)
                {
                    HandleGameObject(Maker2GUID, true);
                }
                if (Encounter[0] != DONE)
                    Encounter[0] = data;
                break;
            case DATA_BROGGOKEVENT:
                if (data == IN_PROGRESS)
                {
                    if (Creature* pBroggok = instance->GetCreature(BroggokGUID))
                        DoScriptText(SAY_BROGGOK_INTRO, pBroggok);

                    HandleGameObject(Brog1GUID, false);

                    if (BroggokEventPhase <= MAX_ORC_WAVES)
                    {
                        DoSortBroggokOrcs();
                        DoNextBroggokEventPhase();
                    }
                }
                else 
                {
                    HandleGameObject(Brog1GUID, true);
                }
                if (data == FAIL)
                {
                    if (BroggokEventPhase <= MAX_BROGGOK_WAVES)
                    {
                        for (uint8 i = 0; i < MAX_ORC_WAVES; ++i)
                        {
                            if (!BroggokEvent[i].IsCellOpened)
                                continue;

                            BroggokEvent[i].KilledOrcCount = 0;
                            for (std::set<uint64>::const_iterator itr = BroggokEvent[i].SortedOrcGuids.begin(); itr != BroggokEvent[i].SortedOrcGuids.end(); ++itr)
                            {
                                if (Creature* pOrc = instance->GetCreature(*itr))
                                {
                                    if (!pOrc->isAlive())
                                    {
                                        pOrc->Respawn();
                                        BroggokEventPhase = 0;
                                    }
                                }
                            }

                            DoUseDoorOrButton(BroggokEvent[i].CellGuid);
                            BroggokEvent[i].IsCellOpened = false;
                            if (GameObject* Lever = instance->GetGameObject(LeverGUID))
                            {
                                if (Lever)
                                    Lever->ResetDoorOrButton();
                            }
                        }
                    }
           
                }
                if (data == DONE)
                {
                    HandleGameObject(Brog2GUID, true);
                }
                if (Encounter[1] != DONE)
                    Encounter[1] = data;
                break;
            case DATA_KELIDANEVENT:
                if (data == DONE)
                {
                    HandleGameObject(Sewer1GUID, true);
                    HandleGameObject(Sewer2GUID, true);
                }
                if (Encounter[2] != DONE)
                    Encounter[2] = data;
                break;
        }

        if (data == DONE)
        {
            SaveToDB();
            OUT_SAVE_INST_DATA_COMPLETE;
        }
    }
Beispiel #12
0
        void OnGameObjectCreate(GameObject* go)
        {
            switch(go->GetEntry())
            {
                case 192518:
                    uiSladRanAltar = go->GetGUID();
                    // Make sure that they start out as unusuable
                    go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
                    if (m_auiEncounter[0] == DONE)
                    {
                        if (uiSladRanStatueState == GO_STATE_ACTIVE)
                            go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
                        else
                        {
                            ++phase;
                            go->SetGoState(GO_STATE_ACTIVE);
                        }
                    }
                    break;
                case 192519:
                    uiMoorabiAltar = go->GetGUID();
                    // Make sure that they start out as unusuable
                    go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
                    if (m_auiEncounter[0] == DONE)
                    {
                        if (uiMoorabiStatueState == GO_STATE_ACTIVE)
                            go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
                        else
                        {
                            ++phase;
                            go->SetGoState(GO_STATE_ACTIVE);
                        }
                    }
                    break;
                case 192520:
                    uiDrakkariColossusAltar = go->GetGUID();
                    // Make sure that they start out as unusuable
                    go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
                    if (m_auiEncounter[0] == DONE)
                    {
                        if (uiDrakkariColossusStatueState == GO_STATE_ACTIVE)
                            go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
                        else
                        {
                            ++phase;
                            go->SetGoState(GO_STATE_ACTIVE);
                        }
                    }
                    break;
                case 192564:
                    uiSladRanStatue = go->GetGUID();
                    go->SetGoState(uiSladRanStatueState);
                    break;
                case 192565:
                    uiMoorabiStatue = go->GetGUID();
                    go->SetGoState(uiMoorabiStatueState);
                    break;
                case 192566:
                    uiGalDarahStatue = go->GetGUID();
                    go->SetGoState(uiGalDarahStatueState);
                    break;
                case 192567:
                    uiDrakkariColossusStatue = go->GetGUID();
                    go->SetGoState(uiDrakkariColossusStatueState);
                    break;
                case 192632:
                    uiEckTheFerociousDoor = go->GetGUID();
                    if (bHeroicMode && m_auiEncounter[1] == DONE)
                        HandleGameObject(NULL, true, go);
                    break;
                case 192569:
                    uiEckTheFerociousDoorBehind = go->GetGUID();
                    if (bHeroicMode && m_auiEncounter[4] == DONE)
                        HandleGameObject(NULL, true, go);
                case 193208:
                    uiGalDarahDoor1 = go->GetGUID();
                    if (m_auiEncounter[3] == DONE)
                        HandleGameObject(NULL, true, go);
                    break;
                case 193209:
                    uiGalDarahDoor2 = go->GetGUID();
                    if (m_auiEncounter[3] == DONE)
                        HandleGameObject(NULL, true, go);
                    break;
                case 193188:
                    uiBridge = go->GetGUID();
                    go->SetGoState(uiBridgeState);
                    break;
                case 192633:
                    uiCollision = go->GetGUID();
                    go->SetGoState(uiCollisionState);

                    // Can't spawn here with SpawnGameObject because go isn't added to world yet...
                    if (uiCollisionState == GO_STATE_ACTIVE_ALTERNATIVE)
                        spawnSupport = true;
                    break;
            }
        }
    void StartBossEncounter(uint8 uiBoss, bool bForceRespawn = true)
    {
        Creature* pBoss = NULL;

        switch (uiBoss)
        {
            case BOSS_MORAGG:
                HandleGameObject(uiMoraggCell,bForceRespawn);
                if (pBoss = instance->GetCreature(uiMoragg))
                    pBoss->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                break;
            case BOSS_EREKEM:
                HandleGameObject(uiErekemCell, bForceRespawn);
                HandleGameObject(uiErekemRightGuardCell, bForceRespawn);
                HandleGameObject(uiErekemLeftGuardCell, bForceRespawn);

                if (pBoss = instance->GetCreature(uiErekem))
                    pBoss->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);

                if (Creature* pGuard1 = instance->GetCreature(uiErekemGuard[0]))
                {
                    if (bForceRespawn)
                        pGuard1->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                    else
                        pGuard1->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                }

                if (Creature* pGuard2 = instance->GetCreature(uiErekemGuard[1]))
                {
                    if (bForceRespawn)
                        pGuard2->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                    else
                        pGuard2->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                }
                break;
            case BOSS_ICHORON:
                HandleGameObject(uiIchoronCell,bForceRespawn);
                if (pBoss = instance->GetCreature(uiIchoron))
                    pBoss->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                break;
            case BOSS_LAVANTHOR:
                HandleGameObject(uiLavanthorCell,bForceRespawn);
                if (pBoss = instance->GetCreature(uiLavanthor))
                    pBoss->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                break;
            case BOSS_XEVOZZ:
                HandleGameObject(uiXevozzCell,bForceRespawn);
                if (pBoss = instance->GetCreature(uiXevozz))
                    pBoss->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                break;
            case BOSS_ZURAMAT:
                HandleGameObject(uiZuramatCell,bForceRespawn);
                if (pBoss = instance->GetCreature(uiZuramat))
                    pBoss->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                break;
        }

        if (!bForceRespawn && pBoss)
        {
            if (pBoss->isDead())
            {
                // respawn but avoid to be looted again
                pBoss->Respawn();
                pBoss->RemoveLootMode(1);
            }
            pBoss->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
            SetData(DATA_WAVE_COUNT,0);
            uiWaveCount = 0;
        }
    }
 void SetData(uint32 uiType, uint32 uiData)
 {
     switch(uiType)
     {
         case TYPE_GELIHAST:
             m_auiEncounter[0] = uiData;
             if (uiData == DONE)
                 if (GameObject* pGo = instance->GetGameObject(m_uiShrineOfGelihastGUID))
                     pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
             break;
         case TYPE_AKU_MAI:
             m_auiEncounter[3] = uiData;
             if (uiData == DONE)
                 if (GameObject* pGo = instance->GetGameObject(m_uiAltarOfTheDeepsGUID))
                 {
                     pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
                     pGo->SummonCreature(NPC_MORRIDUNE,SpawnsLocation[4], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                 }
             break;
         case DATA_FIRE:
             m_uiCountFires = uiData;
             switch (m_uiCountFires)
             {
                 case 1:
                     if (GameObject* pGO = instance->GetGameObject(m_uiShrine1GUID))
                     {
                         pGO->SummonCreature(NPC_AKU_MAI_SNAPJAW, SpawnsLocation[0], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         pGO->SummonCreature(NPC_AKU_MAI_SNAPJAW, SpawnsLocation[1], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         pGO->SummonCreature(NPC_AKU_MAI_SNAPJAW, SpawnsLocation[2], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         pGO->SummonCreature(NPC_AKU_MAI_SNAPJAW, SpawnsLocation[3], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                     }
                     break;
                 case 2:
                     if (GameObject* pGO = instance->GetGameObject(m_uiShrine1GUID))
                     {
                         for (uint8 i = 0; i < 2; ++i)
                         {
                             pGO->SummonCreature(NPC_MURKSHALLOW_SOFTSHELL, SpawnsLocation[0], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                             pGO->SummonCreature(NPC_MURKSHALLOW_SOFTSHELL, SpawnsLocation[1], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                             pGO->SummonCreature(NPC_MURKSHALLOW_SOFTSHELL, SpawnsLocation[2], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                             pGO->SummonCreature(NPC_MURKSHALLOW_SOFTSHELL, SpawnsLocation[3], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         }
                     }
                     break;
                 case 3:
                     if (GameObject* pGO = instance->GetGameObject(m_uiShrine1GUID))
                     {
                         pGO->SummonCreature(NPC_AKU_MAI_SERVANT, SpawnsLocation[1], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         pGO->SummonCreature(NPC_AKU_MAI_SERVANT, SpawnsLocation[2], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                     }
                     break;
                 case 4:
                     if (GameObject* pGO = instance->GetGameObject(m_uiShrine1GUID))
                     {
                         pGO->SummonCreature(NPC_BARBED_CRUSTACEAN, SpawnsLocation[0], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         pGO->SummonCreature(NPC_BARBED_CRUSTACEAN, SpawnsLocation[1], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         pGO->SummonCreature(NPC_BARBED_CRUSTACEAN, SpawnsLocation[2], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                         pGO->SummonCreature(NPC_BARBED_CRUSTACEAN, SpawnsLocation[3], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
                     }
                     break;
             }
             break;
         case DATA_EVENT:
             uiDeathTimes = uiData;
             if (uiDeathTimes == 18)
                 HandleGameObject(m_uiMainDoorGUID,true);
             break;
     }
 }
Beispiel #15
0
        bool SetBossState(uint32 type, EncounterState state)
        {
            if (!InstanceScript::SetBossState(type, state))
                return false;

            if (uiEncounter[type] != DONE)
                uiEncounter[type] = state;

            if (state == DONE)
                SaveToDB();

            switch (type)
            {
                case TYPE_LEVIATHAN:
                    for (std::list<uint64>::iterator i = uiLeviathanDoorGUIDList.begin(); i != uiLeviathanDoorGUIDList.end(); i++)
                    {
                        if (GameObject* obj = instance->GetGameObject(*i))
                            obj->SetGoState(state == IN_PROGRESS ? GO_STATE_READY : GO_STATE_ACTIVE );
                    }

                    if (state == DONE)
                    {
                        if (GameObject* go = instance->GetGameObject(leviathanChestGUID))
                            go->SetRespawnTime(go->GetRespawnDelay());

                        HandleGameObject(uiXT002DoorGUID, true);
                    }
                    break;
                case TYPE_IGNIS:
                case TYPE_RAZORSCALE:
                case TYPE_XT002:
                    HandleGameObject(uiXT002DoorGUID, state != IN_PROGRESS);
                    break;
                case TYPE_ASSEMBLY:
                    HandleGameObject(IronCouncilEntranceGUID, state != IN_PROGRESS);
                    if (state == DONE)
                        HandleGameObject(ArchivumDoorGUID, true);
                    break;
                case TYPE_AURIAYA:
                case TYPE_FREYA:
                    break;
                case TYPE_MIMIRON:
                    for (std::list<uint64>::iterator i = uiMimironDoorGUIDList.begin(); i != uiMimironDoorGUIDList.end(); i++)
                    {
                        if (GameObject* obj = instance->GetGameObject(*i))
                            obj->SetGoState(state == IN_PROGRESS ? GO_STATE_READY : GO_STATE_ACTIVE );
                    }
                    break;
                case TYPE_VEZAX:
                    if (state == DONE)
                        HandleGameObject(uiVezaxDoorGUID, true);
                    break;
                case TYPE_YOGGSARON:
                    if (state == IN_PROGRESS)
                        HandleGameObject(uiYoggSaronDoorGUID, false);
                    else
                        HandleGameObject(uiYoggSaronDoorGUID, true);
                        break;
                case TYPE_KOLOGARN:
                    if (state == DONE)
                    {
                        if (GameObject* go = instance->GetGameObject(uiKologarnChestGUID))
                            go->SetRespawnTime(go->GetRespawnDelay());
                        HandleGameObject(uiKologarnBridgeGUID, false);
                    }
                    break;
                case TYPE_HODIR:
                    if (state == DONE)
                    {
                        HandleGameObject(uiHodirIceDoorGUID, true);
                        HandleGameObject(uiHodirStoneDoorGUID, true);

                        if (GameObject* HodirRareCache = instance->GetGameObject(HodirRareCacheGUID))
                            if (GetData(DATA_HODIR_RARE_CHEST) == 1)
                                HodirRareCache->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
                        if (GameObject* go = instance->GetGameObject(uiHodirChestGUID))
                            go->SetRespawnTime(go->GetRespawnDelay());
                    }

                    HandleGameObject(uiHodirEntranceDoorGUID, state != IN_PROGRESS);
                    break;
                case TYPE_THORIM:
                    //if (state == DONE)
                    //    if (GameObject* go = instance->GetGameObject(uiThorimChestGUID))
                    //        go->SetRespawnTime(go->GetRespawnDelay());
                    if (GameObject* obj = instance->GetGameObject(uiThorimDoorGUID))
                        obj->SetGoState(state == IN_PROGRESS ? GO_STATE_READY : GO_STATE_ACTIVE);
                    break;
                case TYPE_ALGALON:
                    switch (state)
                    {
                        case SPECIAL:
                            if (Creature* algalon = instance->GetCreature(uiAlgalonGUID))
                            {
                                algalon->setFaction(7);
                                algalon->setActive(true);
                                algalon->SetVisible(true);
                                //DoUpdateWorldState(WORLDSTATE_ALGALON_SHOW, 1);
                                //DoUpdateWorldState(WORLDSTATE_ALGALON_TIME, 60);
                            }
                            HandleGameObject(uiAlgalonDoor1GUID, true);
                            HandleGameObject(uiAlgalonDoor2GUID, true);
                            uiAlgalonCountdown = 61;
                            SaveToDB();
                            break;
                        case NOT_STARTED:
                            HandleGameObject(uiAlgalonGlobeGUID, false);
                            HandleGameObject(uiAlgalonBridgeGUID, false);
                            HandleGameObject(uiAlgalonBridgeVisualGUID, false);
                            HandleGameObject(uiAlgalonBridgeDoorGUID, true);
                            break;
                        case IN_PROGRESS:
                            if (uiAlgalonCountdown > 60)
                            {
                                uiAlgalonCountdown = 60;
                                DoUpdateWorldState(WORLDSTATE_ALGALON_SHOW, 1);
                                DoUpdateWorldState(WORLDSTATE_ALGALON_TIME, uiAlgalonCountdown);
                                SaveToDB();
                            }
                            HandleGameObject(uiAlgalonGlobeGUID, true);
                            HandleGameObject(uiAlgalonBridgeGUID, true);
                            HandleGameObject(uiAlgalonBridgeVisualGUID, true);
                            HandleGameObject(uiAlgalonBridgeDoorGUID, false);
                            break;
                        case DONE:
                            uiAlgalonCountdown = 0;
                            DoUpdateWorldState(WORLDSTATE_ALGALON_SHOW, 0);
                            SaveToDB();
                            HandleGameObject(uiAlgalonGlobeGUID, false);
                            HandleGameObject(uiAlgalonBridgeGUID, false);
                            HandleGameObject(uiAlgalonBridgeVisualGUID, false);
                            HandleGameObject(uiAlgalonBridgeDoorGUID, true);
                            break;
                    }
                    break;
             }

             if (GetBossState(TYPE_FREYA) == DONE &&
                 GetBossState(TYPE_MIMIRON) == DONE &&
                 GetBossState(TYPE_HODIR) == DONE &&
                 GetBossState(TYPE_THORIM) == DONE)
                 if (GameObject* go = instance->GetGameObject(uiWayToYoggGUID))
                     go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_LOCKED);
             return true;
        }
        bool SetBossState(uint32 id, EncounterState state)
        {
            if (!InstanceScript::SetBossState(id, state))
                return false;

            switch (id)
            {
                case DATA_GU_CLOUDSTRIKE:
                {
                    switch (state)
                    {
                        case NOT_STARTED:
                        case FAIL:
                        {
                            HandleGameObject(cloudstikeEntranceGuid, true);
                            HandleGameObject(cloudstikeExitGuid,     false);
                            break;
                        }
                        case IN_PROGRESS:
                        {
                            HandleGameObject(cloudstikeEntranceGuid, false);
                            HandleGameObject(cloudstikeExitGuid,     false);
                            break;
                        }
                        case DONE:
                        {
                            HandleGameObject(cloudstikeEntranceGuid, true);
                            HandleGameObject(cloudstikeExitGuid,     true);
                            HandleGameObject(snowdriftEntranceGuid,  true);
                            break;
                        }
                    }
                    break;
                }
                case DATA_MASTER_SNOWDRIFT:
                {
                    switch (state)
                    {
                        case NOT_STARTED:
                        case FAIL:
                            aliveNoviceCount                    = MAX_NOVICE;
                            aliveMinibossCount                  = 2;
                            minibossPositionsGuid               = minibossPositionsGuidSave;
                            firstDefeatedNovicePositionsGuid    = firstDefeatedNovicePositionsGuidSave;
                            secondDefeatedNovicePositionsGuid   = secondDefeatedNovicePositionsGuidSave;
                            
                            HandleGameObject(snowdriftEntranceGuid, true);
                            HandleGameObject(snowdriftFirewallGuid, false);
                            HandleGameObject(snowdriftDojoDoorGuid, false);
                            HandleGameObject(snowdriftExitGuid,     false);
                            break;
                        case IN_PROGRESS:
                            HandleGameObject(snowdriftEntranceGuid, false);
                            HandleGameObject(snowdriftDojoDoorGuid, false);
                            break;
                        case DONE:
                            if (GameObject* possessions = instance->GetGameObject(snowdriftPossessionsGuid))
                                possessions->SetPhaseMask(1, true);
                            
                            HandleGameObject(snowdriftEntranceGuid, true);
                            HandleGameObject(snowdriftFirewallGuid, true);
                            HandleGameObject(snowdriftDojoDoorGuid, true);
                            HandleGameObject(snowdriftExitGuid,     true);
                            HandleGameObject(shaEntranceGuid,       true);
                            break;
                    }
                    break;
                }
                case DATA_SHA_VIOLENCE:
                {
                    switch (state)
                    {
                        case NOT_STARTED:
                        case FAIL:
                            HandleGameObject(shaEntranceGuid,   true);
                            HandleGameObject(shaExitGuid,       false);
                            break;
                        case IN_PROGRESS:
                            HandleGameObject(shaEntranceGuid,   false);
                        case DONE:
                            HandleGameObject(shaEntranceGuid,   true);
                            HandleGameObject(shaExitGuid,       true);
                            break;
                    }
                    break;
                }
                case DATA_TARAN_ZHU:
                {
                    if (state == IN_PROGRESS)
                        DoAddAuraOnPlayers(SPELL_HATE);
                    else
                    {
                        Map::PlayerList const &PlayerList = instance->GetPlayers();

                        if (!PlayerList.isEmpty())
                            for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
                                if (Player* player = i->getSource())
                                {
                                    player->RemoveAurasDueToSpell(SPELL_HATE);
                                    player->RemoveAurasDueToSpell(SPELL_HAZE_OF_HATE);
                                    player->RemoveAurasDueToSpell(SPELL_HAZE_OF_HATE_VISUAL);
                                }
                    }
                    break;
                }
                default:
                    break;
            }

            return true;
        }
Beispiel #17
0
    void SetData(uint32 type, uint32 data)
    {
        Player *player = GetPlayerInMap();

        if (!player)
        {
            debug_log("TSCR: Instance Stratholme: SetData (Type: %u Data %u) cannot find any player.", type, data);
            return;
        }

        switch(type)
        {
        case TYPE_BARON_RUN:
            switch(data)
            {
            case IN_PROGRESS:
                if (Encounter[0] == IN_PROGRESS || Encounter[0] == FAIL)
                    break;
                BaronRun_Timer = 2700000;
                debug_log("TSCR: Instance Stratholme: Baron run in progress.");
                break;
            case FAIL:
                //may add code to remove aura from players, but in theory the time should be up already and removed.
                break;
            case DONE:
                BaronRun_Timer = 0;
                break;
            }
            Encounter[0] = data;
            break;
        case TYPE_BARONESS:
            Encounter[1] = data;
            if (data == SPECIAL)
                UpdateGoState(ziggurat1GUID,0,false);
            if (data == DONE)
                StartSlaugtherSquare();
            break;
        case TYPE_NERUB:
            Encounter[2] = data;
            if (data == SPECIAL)
                UpdateGoState(ziggurat2GUID,0,false);
            if (data == DONE)
                StartSlaugtherSquare();
            break;
        case TYPE_PALLID:
            Encounter[3] = data;
            if (data == SPECIAL)
                UpdateGoState(ziggurat3GUID,0,false);
            if (data == DONE)
                StartSlaugtherSquare();
            break;
        case TYPE_RAMSTEIN:
            if (data == IN_PROGRESS)
            {
                if (Encounter[4] != IN_PROGRESS)
                    UpdateGoState(portGauntletGUID,1,false);

                uint32 count = abomnationGUID.size();
                for(std::set<uint64>::iterator i = abomnationGUID.begin(); i != abomnationGUID.end(); ++i)
                {
                    if (Unit* abom = Unit::GetUnit(*player, *i))
                    {
                        if (!abom->isAlive())
                            --count;
                    }
                }

                if (!count)
                {
                    //a bit itchy, it should close the door after 10 secs, but it doesn't. skipping it for now.
                    //UpdateGoState(ziggurat4GUID,0,true);
                    player->SummonCreature(C_RAMSTEIN,4032.84,-3390.24,119.73,4.71,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,1800000);
                    debug_log("TSCR: Instance Stratholme: Ramstein spawned.");
                } else debug_log("TSCR: Instance Stratholme: %u Abomnation left to kill.",count);
            }
            if (data == SPECIAL)
            {
                SlaugtherSquare_Timer = 300000;
                HandleGameObject(portGauntletGUID, true);
                debug_log("TSCR: Instance Stratholme: Slaugther event will continue in 5 minutes.");
            }
            if (data == DONE)
            {
                SlaugtherSquare_Timer = 10000;
                debug_log("TSCR: Instance Stratholme: Skeletons died, slaughter event will continue");
            }
            if (data == FAIL)
            {
                HandleGameObject(portGauntletGUID, true);
                data = SPECIAL;
            }
            Encounter[4] = data;
            break;
        case TYPE_BARON:
            if (data == IN_PROGRESS)
            {
                if (GetData(TYPE_BARON_RUN) == IN_PROGRESS)
                {
                    if (Unit *t = Unit::GetUnit(*player, ysidaTriggerGUID))
                        t->SummonCreature(C_YSIDA,t->GetPositionX(),t->GetPositionY(),t->GetPositionZ(),t->GetOrientation(),TEMPSUMMON_TIMED_DESPAWN,1800000);

                    if (Group *pGroup = player->GetGroup())
                    {
                        for(GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
                        {
                            Player* pGroupie = itr->getSource();
                            if (!pGroupie)
                                continue;

                            if (pGroupie->HasAura(SPELL_BARON_ULTIMATUM,0))
                                pGroupie->RemoveAurasDueToSpell(SPELL_BARON_ULTIMATUM);
                            
                            if (pGroupie->GetQuestStatus(QUEST_DEAD_MAN_PLEA) == QUEST_STATUS_INCOMPLETE)
                            {
                                pGroupie->CastedCreatureOrGO(C_YSIDA, ysidaGUID,0);
                                pGroupie->AreaExploredOrEventHappens(QUEST_DEAD_MAN_PLEA);
                            }
                        }
                    } else if (player->HasAura(SPELL_BARON_ULTIMATUM,0))
                        player->RemoveAurasDueToSpell(SPELL_BARON_ULTIMATUM);

                    if (Unit *temp = Unit::GetUnit(*player,GetData64(DATA_BARON)))
                    {
                        player->CastedCreatureOrGO(C_YSIDA, ysidaGUID,0);
                        player->AreaExploredOrEventHappens(QUEST_DEAD_MAN_PLEA);
                    }
                    SetData(TYPE_BARON_RUN,DONE);
                }
            }

            if (data == DONE)
            {
                HandleGameObject(portGauntletGUID, true);
            }
            if (Encounter[5] != DONE)
                Encounter[5] = data;
            break;
        case TYPE_SH_AELMAR:
            IsSilverHandDead[0] = (data) ? true : false;
            break;
        case TYPE_SH_CATHELA:
            IsSilverHandDead[1] = (data) ? true : false;
            break;
        case TYPE_SH_GREGOR:
            IsSilverHandDead[2] = (data) ? true : false;
            break;
        case TYPE_SH_NEMAS:
            IsSilverHandDead[3] = (data) ? true : false;
            break;
        case TYPE_SH_VICAR:
            IsSilverHandDead[4] = (data) ? true : false;
            break;
        case TYPE_GAUNTLET_MOB:
            if (data != 1)
                break;
            if (GetData(TYPE_NERUB) != DONE && std::none_of(acolyte2GUID.begin(),acolyte2GUID.end(),[this](uint64 guid)-> bool {Creature *c = GetCreature(guid) ; return c ? c->isAlive():false;}))
            {
                Creature *c = GetCreature(CrystalsGUID[1]);
                if(c && c->isAlive())
                    c->Kill(c,false);
                SetData(TYPE_NERUB,DONE);
            }
            if (GetData(TYPE_BARONESS) != DONE && std::none_of(acolyte1GUID.begin(),acolyte1GUID.end(),[this](uint64 guid)-> bool {Creature *c = GetCreature(guid) ; return c ? c->isAlive():false;}))
            {
                Creature *c = GetCreature(CrystalsGUID[0]);
                if(c && c->isAlive())
                    c->Kill(c,false);
                SetData(TYPE_BARONESS,DONE);
            }
            if (GetData(TYPE_PALLID) != DONE && std::none_of(acolyte3GUID.begin(),acolyte3GUID.end(),[this](uint64 guid)-> bool {Creature *c = GetCreature(guid) ; return c ? c->isAlive():false;}))
            {
                Creature *c = GetCreature(CrystalsGUID[2]);
                if(c && c->isAlive())
                    c->Kill(c,false);
                SetData(TYPE_PALLID,DONE);
            }
        }
    }
 void OnGameObjectCreate(GameObject* gameObject)
 {
     switch (gameObject->GetEntry())
     {
         case GO_KOLOGARN_CHEST_HERO:
         case GO_KOLOGARN_CHEST:
             KologarnChestGUID = gameObject->GetGUID();
             break;
         case GO_KOLOGARN_BRIDGE:
             KologarnBridgeGUID = gameObject->GetGUID();
             if (GetBossState(BOSS_KOLOGARN) == DONE)
                 HandleGameObject(0, false, gameObject);
             break;
         case GO_KOLOGARN_DOOR:
             KologarnDoorGUID = gameObject->GetGUID();
             break;
         case GO_THORIM_CHEST_HERO:
         case GO_THORIM_CHEST:
             ThorimChestGUID = gameObject->GetGUID();
             break;
         case GO_HODIR_RARE_CACHE_OF_WINTER_HERO:
         case GO_HODIR_RARE_CACHE_OF_WINTER:
             HodirRareCacheGUID = gameObject->GetGUID();
             break;
         case GO_HODIR_CHEST_HERO:
         case GO_HODIR_CHEST:
             HodirChestGUID = gameObject->GetGUID();
             break;
         case GO_LEVIATHAN_DOOR:
             AddDoor(gameObject, true);
             break;
         case GO_LEVIATHAN_GATE:
             LeviathanGateGUID = gameObject->GetGUID();
             if (GetBossState(BOSS_LEVIATHAN) == DONE)
                 gameObject->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
             break;
         case GO_XT_002_DOOR:
             AddDoor(gameObject, true);
             break;
         case GO_VEZAX_DOOR:
             VezaxDoorGUID = gameObject->GetGUID();
             HandleGameObject(0, false, gameObject);
             break;
         case GO_RAZOR_HARPOON_1:
             RazorHarpoonGUIDs[0] = gameObject->GetGUID();
             break;
         case GO_RAZOR_HARPOON_2:
             RazorHarpoonGUIDs[1] = gameObject->GetGUID();
             break;
         case GO_RAZOR_HARPOON_3:
             RazorHarpoonGUIDs[2] = gameObject->GetGUID();
             break;
         case GO_RAZOR_HARPOON_4:
             RazorHarpoonGUIDs[3] = gameObject->GetGUID();
             break;
         case GO_MOLE_MACHINE:
             if (GetBossState(BOSS_RAZORSCALE) == IN_PROGRESS)
                 gameObject->SetGoState(GO_STATE_ACTIVE);
         case GO_HODIR_DOOR:
             HodirDoorGUID = gameObject->GetGUID();
             break;
         case GO_HODIR_ICE_DOOR:
             HodirIceDoorGUID = gameObject->GetGUID();
             break;
         case GO_ARCHIVUM_DOOR:
             ArchivumDoorGUID = gameObject->GetGUID();
             if (GetBossState(BOSS_ASSEMBLY_OF_IRON) != DONE)
                 HandleGameObject(ArchivumDoorGUID, false);
             break;
         case GO_ALGALON_DOOR:
             uiAlgalonDoor = gameObject->GetGUID();
             HandleGameObject(0, false, gameObject);
             break;
         case GO_UNIVERSE_GLOBE:
             UniverseGlobeGUID = gameObject->GetGUID();
             HandleGameObject(0, false, gameObject);
             break;
         case GO_UNIVERSE_FLOOR_1:
             UniverseFloor1GUID = gameObject->GetGUID();
             HandleGameObject(0, false, gameObject);
             break;
         case GO_UNIVERSE_FLOOR_2:
             UniverseFloor2GUID = gameObject->GetGUID();
             HandleGameObject(0, true, gameObject);
             break;
         case GO_RUNIC_DOOR:
            uiRunicDoorGUID = gameObject->GetGUID();
            break;
         case GO_STONE_DOOR:
             uiStoneDoorGUID = gameObject->GetGUID();
             break;
         case GO_MIMIRON_ELEVATOR:
             uiMimironElevatorGUID = gameObject->GetGUID();
             break;
         case GO_MIMIRON_TRAM:
             uiMimironTramGUID = gameObject->GetGUID();
             break;
     }
 }
        void SetData(uint32 type, uint32 data)
        {
            switch (type)
            {
                case DATA_RAGEWINTERCHILLEVENT: m_auiEncounter[0] = data; break;
                case DATA_ANETHERONEVENT:
                    m_auiEncounter[1] = data;
                    break;
                case DATA_KAZROGALEVENT:        m_auiEncounter[2] = data; break;
                case DATA_AZGALOREVENT:
                    {
                        m_auiEncounter[3] = data;
                        if (data == DONE)
                        {
                            if (ArchiYell)break;
                            ArchiYell = true;

                            Creature* creature = instance->GetCreature(Azgalor);
                            if (creature)
                            {
                                Creature* unit = creature->SummonCreature(21987, creature->GetPositionX(), creature->GetPositionY(), creature->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 10000);

                                Map* map = creature->GetMap();
                                if (map->IsDungeon() && unit)
                                {
                                    unit->SetVisible(false);
                                    Map::PlayerList const &PlayerList = map->GetPlayers();
                                    if (PlayerList.isEmpty())
                                         return;

                                    for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
                                    {
                                         if (i->getSource())
                                         {
                                            WorldPacket data(SMSG_MESSAGECHAT, 200);
                                            unit->BuildMonsterChat(&data, CHAT_MSG_MONSTER_YELL, YELL_EFFORTS, 0, YELL_EFFORTS_NAME, i->getSource()->GetGUID());
                                            i->getSource()->GetSession()->SendPacket(&data);

                                            WorldPacket data2(SMSG_PLAY_SOUND, 4);
                                            data2 << 10986;
                                            i->getSource()->GetSession()->SendPacket(&data2);
                                         }
                                    }
                                }
                            }
                        }
                    }
                    break;
                case DATA_ARCHIMONDEEVENT:      m_auiEncounter[4] = data; break;
                case DATA_RESET_TRASH_COUNT:    Trash = 0;            break;

                case DATA_TRASH:
                    if (data) Trash = data;
                    else     Trash--;
                    DoUpdateWorldState(WORLD_STATE_ENEMYCOUNT, Trash);
                    break;
                case TYPE_RETREAT:
                    if (data == SPECIAL)
                    {
                        if (!m_uiAncientGemGUID.empty())
                        {
                            for (std::list<uint64>::const_iterator itr = m_uiAncientGemGUID.begin(); itr != m_uiAncientGemGUID.end(); ++itr)
                            {
                                //don't know how long it expected
                                DoRespawnGameObject(*itr, DAY);
                            }
                        }
                    }
                    break;
                case DATA_ALLIANCE_RETREAT:
                    allianceRetreat = data;
                    HandleGameObject(HordeGate, true);
                    SaveToDB();
                    break;
                case DATA_HORDE_RETREAT:
                    hordeRetreat = data;
                    HandleGameObject(ElfGate, true);
                    SaveToDB();
                    break;
                case DATA_RAIDDAMAGE:
                    RaidDamage += data;
                    if (RaidDamage >= MINRAIDDAMAGE)
                        RaidDamage = MINRAIDDAMAGE;
                    break;
                case DATA_RESET_RAIDDAMAGE:
                    RaidDamage = 0;
                    break;
            }

             sLog->outDebug(LOG_FILTER_TSCR, "TSCR: Instance Hyjal: Instance data updated for event %u (Data=%u)", type, data);

            if (data == DONE)
            {
                OUT_SAVE_INST_DATA;

                std::ostringstream saveStream;
                saveStream << m_auiEncounter[0] << ' ' << m_auiEncounter[1] << ' ' << m_auiEncounter[2] << ' '
                    << m_auiEncounter[3] << ' ' << m_auiEncounter[4]
                    << ' ' << allianceRetreat << ' ' << hordeRetreat
                    << ' ' << RaidDamage;

                str_data = saveStream.str();

                SaveToDB();
                OUT_SAVE_INST_DATA_COMPLETE;
            }

        }
            bool SetBossState(uint32 type, EncounterState state)
            {
                if (!InstanceScript::SetBossState(type, state))
                    return false;

                switch (type)
                {
                    case BOSS_LEVIATHAN:
                    case BOSS_IGNIS:
                    case BOSS_RAZORSCALE:
                    case BOSS_XT002:
                    case BOSS_AURIAYA:
                    case BOSS_MIMIRON:
                    case BOSS_FREYA:
                        break;
                    case BOSS_ASSEMBLY_OF_IRON:
                        if (state == DONE)
                            HandleGameObject(ArchivumDoorGUID, true);
                        break;
                    case BOSS_VEZAX:
                        if (state == DONE)
                        {
                            HandleGameObject(VezaxDoorGUID, true);

                            // Keeper's Images
                            if (Creature* pFreya = instance->GetCreature(uiFreyaImageGUID))
                                pFreya->SetVisible(true);
                            if (Creature* pThorim = instance->GetCreature(uiThorimImageGUID))
                                pThorim->SetVisible(true);
                            if (Creature* pMimiron = instance->GetCreature(uiMimironImageGUID))
                                pMimiron->SetVisible(true);
                            if (Creature* pHodir = instance->GetCreature(uiHodirImageGUID))
                                pHodir->SetVisible(true);
                        }
                        break;
                    case BOSS_YOGGSARON:
                        break;
                    case BOSS_KOLOGARN:
                        if (state == DONE)
                        {
                            if (GameObject* gameObject = instance->GetGameObject(KologarnChestGUID))
                            {
                                gameObject->SetRespawnTime(gameObject->GetRespawnDelay());
                                gameObject->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
                            }
                            HandleGameObject(KologarnBridgeGUID, false);
                        }
                        if (state == IN_PROGRESS)
                            HandleGameObject(KologarnDoorGUID, false);
                        else
                            HandleGameObject(KologarnDoorGUID, true);
                        break;
                    case BOSS_HODIR:
                        if (state == DONE)
                        {
                            if (GameObject* HodirRareCache = instance->GetGameObject(HodirRareCacheGUID))
                                if (GetData(DATA_HODIR_RARE_CACHE))
                                    HodirRareCache->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
                            if (GameObject* HodirChest = instance->GetGameObject(HodirChestGUID))
                                HodirChest->SetRespawnTime(HodirChest->GetRespawnDelay());
                            HandleGameObject(HodirDoorGUID, true);
                            HandleGameObject(HodirIceDoorGUID, true);
                        }
                        break;
                    case BOSS_THORIM:
                        if (state == DONE)
                            if (GameObject* gameObject = instance->GetGameObject(ThorimChestGUID))
                                gameObject->SetRespawnTime(gameObject->GetRespawnDelay());
                        break;
                    case BOSS_ALGALON:
                        if (state == IN_PROGRESS)
                            HandleGameObject(uiAlgalonDoor, false);
                        else
                            HandleGameObject(uiAlgalonDoor, true);
                        break;
                }

                return true;
            }
 void SetData(uint32 type, uint32 data)
 {
     switch (type)
     {
     case DATA_MAGTHERIDON_EVENT:
         m_auiEncounter[0] = data;
         if (data == NOT_STARTED)
             RespawnTimer = 10000;
         if (data != IN_PROGRESS)
            HandleGameObject(DoorGUID, true);
         break;
     case DATA_CHANNELER_EVENT:
         switch (data)
         {
         case NOT_STARTED: // Reset all channelers once one is reset.
             if (m_auiEncounter[1] != NOT_STARTED)
             {
                 m_auiEncounter[1] = NOT_STARTED;
                 for (std::set<uint64>::const_iterator i = ChannelerGUID.begin(); i != ChannelerGUID.end(); ++i)
                 {
                     if (Creature* Channeler = instance->GetCreature(*i))
                     {
                         if (Channeler->isAlive())
                             Channeler->AI()->EnterEvadeMode();
                         else
                             Channeler->Respawn();
                     }
                 }
                 CageTimer = 0;
                 HandleGameObject(DoorGUID, true);
             }
             break;
         case IN_PROGRESS: // Event start.
             if (m_auiEncounter[1] != IN_PROGRESS)
             {
                 m_auiEncounter[1] = IN_PROGRESS;
                 // Let all five channelers aggro.
                 for (std::set<uint64>::const_iterator i = ChannelerGUID.begin(); i != ChannelerGUID.end(); ++i)
                 {
                     Creature* Channeler = instance->GetCreature(*i);
                     if (Channeler && Channeler->isAlive())
                         Channeler->AI()->AttackStart(Channeler->SelectNearestTarget(999));
                 }
                 // Release Magtheridon after two minutes.
                 Creature* Magtheridon = instance->GetCreature(MagtheridonGUID);
                 if (Magtheridon && Magtheridon->isAlive())
                 {
                     Magtheridon->MonsterTextEmote(EMOTE_BONDS_WEAKEN, 0);
                     CageTimer = 120000;
                 }
                 HandleGameObject(DoorGUID, false);
             }
             break;
         case DONE: // Add buff and check if all channelers are dead.
             for (std::set<uint64>::const_iterator i = ChannelerGUID.begin(); i != ChannelerGUID.end(); ++i)
             {
                 Creature* Channeler = instance->GetCreature(*i);
                 if (Channeler && Channeler->isAlive())
                 {
                     //Channeler->CastSpell(Channeler, SPELL_SOUL_TRANSFER, true);
                     data = IN_PROGRESS;
                     break;
                 }
             }
             break;
         }
         m_auiEncounter[1] = data;
         break;
     case DATA_COLLAPSE:
         // true - collapse / false - reset
         for (std::set<uint64>::const_iterator i = ColumnGUID.begin(); i != ColumnGUID.end(); ++i)
             DoUseDoorOrButton(*i);
         break;
     default:
         break;
     }
 }
            void SetData(uint32 type, uint32 data)
            {
                switch (type)
                {
                    case DATA_COLOSSUS:
                        ColossusData = data;
                        if (data == 2)
                        {
                            if (Creature* Leviathan = instance->GetCreature(LeviathanGUID))
                                Leviathan->AI()->DoAction(ACTION_MOVE_TO_CENTER_POSITION);
                            if (GameObject* gameObject = instance->GetGameObject(LeviathanGateGUID))
                                gameObject->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
                            SaveToDB();
                        }
                        break;
                    case DATA_HODIR_RARE_CACHE:
                        HodirRareCacheData = data;
                        if (!HodirRareCacheData)
                        {
                            if (Creature* Hodir = instance->GetCreature(HodirGUID))
                                if (GameObject* gameObject = instance->GetGameObject(HodirRareCacheGUID))
                                    Hodir->RemoveGameObject(gameObject, false);
                        }
                        break;
                    case DATA_UNBROKEN:
                        Unbroken = bool(data);
                        break;
                    case DATA_RUNIC_DOOR:
                        if (GameObject* pRunicDoor = instance->GetGameObject(uiRunicDoorGUID))
                            pRunicDoor->SetGoState(GOState(data));
                        break;
                    case DATA_STONE_DOOR:
                        if (GameObject* pStoneDoor = instance->GetGameObject(uiStoneDoorGUID))
                            pStoneDoor->SetGoState(GOState(data));
                        break;
                    case DATA_MIMIRON_ELEVATOR:
                        if (GameObject* MimironElevator = instance->GetGameObject(uiMimironElevatorGUID))
                            MimironElevator->SetGoState(GOState(data));
                        break;
                    case DATA_CALL_TRAM:
                        if (GameObject* MimironTram = instance->GetGameObject(uiMimironTramGUID))
                        {
                            // Load Mimiron Tram (unfortunally only server side)
                            instance->LoadGrid(2307, 284.632f);

                            if (data == 0)
                                MimironTram->SetGoState(GO_STATE_READY);
                            if (data == 1)
                                MimironTram->SetGoState(GO_STATE_ACTIVE);

                            // Send movement update to players
                            if (Map* pMap = MimironTram->GetMap())
                            {
                                if (pMap->IsDungeon())
                                {
                                    Map::PlayerList const &PlayerList = pMap->GetPlayers();

                                    if (!PlayerList.isEmpty())
                                    {
                                        for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
                                        {
                                            if (i->getSource())
                                            {
                                                UpdateData data;
                                                WorldPacket pkt;
                                                MimironTram->BuildValuesUpdateBlockForPlayer(&data, i->getSource());
                                                data.BuildPacket(&pkt);
                                                i->getSource()->GetSession()->SendPacket(&pkt);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        break;
                    case DATA_ALGALON:
                        if (data == SPECIAL)
                            HandleGameObject(uiAlgalonDoor,true);
                        break;
                    case DATA_UNIVERSE_GLOBE:
                        if(data == GO_STATE_READY)
                            HandleGameObject(UniverseGlobeGUID, false);
                        if(data == GO_STATE_ACTIVE)
                            HandleGameObject(UniverseGlobeGUID, true);
                        break;
                    case DATA_UNIVERSE_FLOOR_1:
                        if(data == GO_STATE_READY)
                            HandleGameObject(UniverseFloor1GUID, false);
                        if(data == GO_STATE_ACTIVE)
                            HandleGameObject(UniverseFloor1GUID, true);
                        break;
                    case DATA_UNIVERSE_FLOOR_2:
                        if(data == GO_STATE_READY)
                            HandleGameObject(UniverseFloor2GUID, false);
                        if(data == GO_STATE_ACTIVE)
                            HandleGameObject(UniverseFloor2GUID, true);
                        break;
                    default:
                        break;
                }
            }
        void SetData(uint32 id, uint32 data)
        {
            switch (id)
            {
                case DATA_KALECGOS_EVENT:
                    {
                        if (data == NOT_STARTED || data == DONE)
                        {
                            HandleGameObject(ForceField, true);
                            HandleGameObject(KalecgosWall[0], true);
                            HandleGameObject(KalecgosWall[1], true);
                        }
                        else if (data == IN_PROGRESS)
                        {
                            HandleGameObject(ForceField, false);
                            HandleGameObject(KalecgosWall[0], false);
                            HandleGameObject(KalecgosWall[1], false);
                        }
                        m_auiEncounter[0] = data;
                    }
                    break;
                case DATA_BRUTALLUS_EVENT:     m_auiEncounter[1] = data; break;
                case DATA_FELMYST_EVENT:
                    if (data == DONE)
                        HandleGameObject(FireBarrier, true);
                    m_auiEncounter[2] = data; break;
                case DATA_EREDAR_TWINS_EVENT:  m_auiEncounter[3] = data; break;
                case DATA_MURU_EVENT:
                    switch (data)
                    {
                        case DONE:
                            HandleGameObject(MurusGate[0], true);
                            HandleGameObject(MurusGate[1], true);
                            break;
                        case IN_PROGRESS:
                            HandleGameObject(MurusGate[0], false);
                            HandleGameObject(MurusGate[1], false);
                            break;
                        case NOT_STARTED:
                            HandleGameObject(MurusGate[0], true);
                            HandleGameObject(MurusGate[1], false);
                            break;
                    }
                    m_auiEncounter[4] = data; break;
                case DATA_KILJAEDEN_EVENT:     m_auiEncounter[5] = data; break;
            }

            if (data == DONE)
                SaveToDB();
        }
Beispiel #24
0
        void StartBossEncounter(uint8 uiBoss, bool bForceRespawn = true)
        {
            Creature* boss = nullptr;

            switch (uiBoss)
            {
                case BOSS_MORAGG:
                    HandleGameObject(GetObjectGuid(DATA_MORAGG_CELL), bForceRespawn);
                    boss = GetCreature(DATA_MORAGG);
                    if (boss)
                        boss->GetMotionMaster()->MovePoint(0, BossStartMove1);
                    break;
                case BOSS_EREKEM:
                    HandleGameObject(GetObjectGuid(DATA_EREKEM_CELL), bForceRespawn);
                    HandleGameObject(GetObjectGuid(DATA_EREKEM_LEFT_GUARD_CELL), bForceRespawn);
                    HandleGameObject(GetObjectGuid(DATA_EREKEM_RIGHT_GUARD_CELL), bForceRespawn);

                    boss = GetCreature(DATA_EREKEM);
                    if (boss)
                        boss->GetMotionMaster()->MovePoint(0, BossStartMove2);

                    if (Creature* pGuard1 = instance->GetCreature(uiErekemGuard[0]))
                    {
                        if (bForceRespawn)
                        {
                            pGuard1->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_NON_ATTACKABLE);
                            pGuard1->GetMotionMaster()->MovePoint(0, BossStartMove21);
                        }
                        else
                            pGuard1->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC|UNIT_FLAG_NON_ATTACKABLE);
                    }

                    if (Creature* pGuard2 = instance->GetCreature(uiErekemGuard[1]))
                    {
                        if (bForceRespawn)
                        {
                            pGuard2->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC|UNIT_FLAG_NON_ATTACKABLE);
                            pGuard2->GetMotionMaster()->MovePoint(0, BossStartMove22);
                        }
                        else
                            pGuard2->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC|UNIT_FLAG_NON_ATTACKABLE);
                    }
                    break;
                case BOSS_ICHORON:
                    HandleGameObject(GetObjectGuid(DATA_ICHORON_CELL), bForceRespawn);
                    boss = GetCreature(DATA_ICHORON);
                    if (boss)
                        boss->GetMotionMaster()->MovePoint(0, BossStartMove3);
                    break;
                case BOSS_LAVANTHOR:
                    HandleGameObject(GetObjectGuid(DATA_LAVANTHOR_CELL), bForceRespawn);
                    boss = GetCreature(DATA_LAVANTHOR);
                    if (boss)
                        boss->GetMotionMaster()->MovePoint(0, BossStartMove4);
                    break;
                case BOSS_XEVOZZ:
                    HandleGameObject(GetObjectGuid(DATA_XEVOZZ_CELL), bForceRespawn);
                    boss = GetCreature(DATA_XEVOZZ);
                    if (boss)
                        boss->GetMotionMaster()->MovePoint(0, BossStartMove5);
                    break;
                case BOSS_ZURAMAT:
                    HandleGameObject(GetObjectGuid(DATA_ZURAMAT_CELL), bForceRespawn);
                    boss = GetCreature(DATA_ZURAMAT);
                    if (boss)
                        boss->GetMotionMaster()->MovePoint(0, BossStartMove6);
                    break;
            }

            // generic boss state changes
            if (boss)
            {
                boss->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC|UNIT_FLAG_NON_ATTACKABLE);
                boss->SetReactState(REACT_AGGRESSIVE);

                if (!bForceRespawn)
                {
                    if (boss->isDead())
                    {
                        // respawn but avoid to be looted again
                        boss->Respawn();
                        boss->RemoveLootMode(1);
                    }
                    else
                        boss->GetMotionMaster()->MoveTargetedHome();

                    boss->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC|UNIT_FLAG_NON_ATTACKABLE);
                    uiWaveCount = 0;
                }
            }
        }
        void OnGameObjectCreate(GameObject* go)
        {
            switch (go->GetEntry())
            {
            case 185483:
                NajentusGate = go->GetGUID();// Gate past Naj'entus (at the entrance to Supermoose's courtyards)
                if (m_auiEncounter[0] == DONE)
                    HandleGameObject(0, true, go);
                break;

            case 185882:
                MainTempleDoors = go->GetGUID();// Main Temple Doors - right past Supermoose (Supremus)
                if (m_auiEncounter[1] == DONE)
                    HandleGameObject(0, true, go);
                break;

            case 185478:
                ShadeOfAkamaDoor = go->GetGUID();
                break;

            case 185480:
                CommonDoor = go->GetGUID();
                if (m_auiEncounter[3] == DONE)
                    HandleGameObject(0, true, go);
                break;

            case 186153:
                TeronDoor = go->GetGUID();
                if (m_auiEncounter[3] == DONE)
                    HandleGameObject(0, true, go);
                break;

            case 185892:
                GuurtogDoor = go->GetGUID();
                if (m_auiEncounter[4] == DONE)
                    HandleGameObject(0, true, go);
                break;

            case 185479:
                TempleDoor = go->GetGUID();
                if (m_auiEncounter[5] == DONE)
                    HandleGameObject(0, true, go);
                break;

            case 185482:
                MotherDoor = go->GetGUID();
                if (m_auiEncounter[6] == DONE)
                    HandleGameObject(0, true, go);
                break;

            case 185481:
                CouncilDoor = go->GetGUID();
                if (m_auiEncounter[7] == DONE)
                    HandleGameObject(0, true, go);
                break;

            case 186152:
                SimpleDoor = go->GetGUID();
                if (m_auiEncounter[7] == DONE)
                    HandleGameObject(0, true, go);
                break;

            case 185905:
                IllidanGate = go->GetGUID(); // Gate leading to Temple Summit
                break;

            case 186261:
                IllidanDoor[0] = go->GetGUID(); // Right door at Temple Summit
                break;

            case 186262:
                IllidanDoor[1] = go->GetGUID(); // Left door at Temple Summit
                break;
            }
        }
Beispiel #26
0
        bool SetBossState(uint32 type, EncounterState state)
        {
            if (!InstanceScript::SetBossState(type, state))
                return false;

            if(uiEncounter[type] != DONE)
                uiEncounter[type] = state;
            if(state == DONE)
                SaveToDB();

            switch (type)
            {
                case TYPE_LEVIATHAN:
                    if (state == IN_PROGRESS)
                        for (uint8 uiI = 0; uiI < 7; ++uiI)
                            HandleGameObject(uiLeviathanDoor[uiI],false);
                    else
                        for (uint8 uiI = 0; uiI < 7; ++uiI)
                            HandleGameObject(uiLeviathanDoor[uiI],true);
                    break;
                case TYPE_IGNIS:
                case TYPE_RAZORSCALE:
                case TYPE_XT002:
                case TYPE_ASSEMBLY:
                case TYPE_AURIAYA:
                case TYPE_MIMIRON:
                case TYPE_VEZAX:
                    if (state == DONE)
                        HandleGameObject(uiYoggSaronDoorGUID, true);
                    break;
                case TYPE_YOGGSARON:
                if(state == IN_PROGRESS)
                    HandleGameObject(uiYoggSaronDoorGUID,false);
                else
                    HandleGameObject(uiYoggSaronDoorGUID,true);
                    break;
                case TYPE_KOLOGARN:
                    if (state == DONE)
                    {
                        if (GameObject* go = instance->GetGameObject(uiKologarnChestGUID))
                            go->SetRespawnTime(go->GetRespawnDelay());
                        HandleGameObject(uiKologarnBridgeGUID, false);
                    }
                    if (state == IN_PROGRESS)
                        HandleGameObject(uiKologarnDoorGUID, false);
                    else
                        HandleGameObject(uiKologarnDoorGUID, true);
                    break;
                case TYPE_HODIR:
                    if (state == DONE)
                        if (GameObject* go = instance->GetGameObject(uiHodirChestGUID))
                            go->SetRespawnTime(go->GetRespawnDelay());
                    break;
                case TYPE_THORIM:
                    if (state == DONE)
                        if (GameObject* go = instance->GetGameObject(uiThorimChestGUID))
                            go->SetRespawnTime(go->GetRespawnDelay());
                    break;
                case TYPE_FREYA:
                    if (state == DONE)
                        if (GameObject* go = instance->GetGameObject(uiFreyaChestGUID))
                            go->SetRespawnTime(go->GetRespawnDelay());
                    break;
             }

             return true;
        }
        void StartBossEncounter(uint8 uiBoss, bool bForceRespawn = true)
        {
            Creature* pBoss = NULL;

            switch(uiBoss)
            {
                case BOSS_MORAGG:
                    HandleGameObject(uiMoraggCell,bForceRespawn);
                    pBoss = instance->GetCreature(uiMoragg);
                    if(pBoss)
                        pBoss->GetMotionMaster()->MovePoint(0, BossStartMove1);
                    break;
                case BOSS_EREKEM:
                    HandleGameObject(uiErekemCell, bForceRespawn);
                    HandleGameObject(uiErekemRightGuardCell, bForceRespawn);
                    HandleGameObject(uiErekemLeftGuardCell, bForceRespawn);

                    pBoss = instance->GetCreature(uiErekem);

                    if(pBoss)
                        pBoss->GetMotionMaster()->MovePoint(0, BossStartMove2);

                    if(Creature* pGuard1 = instance->GetCreature(uiErekemGuard[0]))
                    {
                        if(bForceRespawn)
                            pGuard1->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                        else
                            pGuard1->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                        pGuard1->GetMotionMaster()->MovePoint(0, BossStartMove21);
                    }

                    if(Creature* pGuard2 = instance->GetCreature(uiErekemGuard[1]))
                    {
                        if(bForceRespawn)
                            pGuard2->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                        else
                            pGuard2->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                        pGuard2->GetMotionMaster()->MovePoint(0, BossStartMove22);
                    }
                    break;
                case BOSS_ICHORON:
                    HandleGameObject(uiIchoronCell,bForceRespawn);
                    pBoss = instance->GetCreature(uiIchoron);
                    if(pBoss)
                        pBoss->GetMotionMaster()->MovePoint(0, BossStartMove3);
                    break;
                case BOSS_LAVANTHOR:
                    HandleGameObject(uiLavanthorCell,bForceRespawn);
                    pBoss = instance->GetCreature(uiLavanthor);
                    if(pBoss)
                        pBoss->GetMotionMaster()->MovePoint(0, BossStartMove4);
                    break;
                case BOSS_XEVOZZ:
                    HandleGameObject(uiXevozzCell,bForceRespawn);
                    pBoss = instance->GetCreature(uiXevozz);
                    if(pBoss)
                        pBoss->GetMotionMaster()->MovePoint(0, BossStartMove5);
                    break;
                case BOSS_ZURAMAT:
                    HandleGameObject(uiZuramatCell,bForceRespawn);
                    pBoss = instance->GetCreature(uiZuramat);
                    if(pBoss)
                        pBoss->GetMotionMaster()->MovePoint(0, BossStartMove6);
                    break;
            }

            // generic boss state changes
            if(pBoss)
            {
                pBoss->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                pBoss->SetReactState(REACT_AGGRESSIVE);

                if(!bForceRespawn)
                {
                    if(pBoss->isDead())
                    {
                        // respawn but avoid to be looted again
                        pBoss->Respawn();
                        pBoss->RemoveLootMode(1);
                    }
                    pBoss->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NON_ATTACKABLE);
                    uiWaveCount = 0;
                }
            }
        }
Beispiel #28
0
 void OnGameObjectCreate(GameObject* go)
 {
     switch (go->GetEntry())
     {
         case GO_LEVIATHAN_CHEST_10:
         case GO_LEVIATHAN_CHEST_25:
             leviathanChestGUID = go->GetGUID();
             break;
         case GO_IRON_COUNCIL_ENTRANCE:
             IronCouncilEntranceGUID = go->GetGUID();
             break;
         case GO_ARCHIVUM_DOOR:
             ArchivumDoorGUID = go->GetGUID();
             HandleGameObject(0, GetBossState(TYPE_ASSEMBLY) == DONE, go);
             break;
         case GO_KOLOGARN_CHEST_HERO:
         case GO_KOLOGARN_CHEST:
             uiKologarnChestGUID = go->GetGUID();
             break;
         case GO_KOLOGARN_BRIDGE:
             uiKologarnBridgeGUID = go->GetGUID();
             HandleGameObject(0, GetBossState(TYPE_KOLOGARN) != DONE, go);
             break;
         case GO_KOLOGARN_DOOR:
             uiKologarnDoorGUID = go->GetGUID();
             break;
         case GO_THORIM_CHEST_HERO:
         case GO_THORIM_CHEST:
             uiThorimChestGUID = go->GetGUID();
             break;
         case GO_THORIM_ENCOUNTER_DOOR:
             uiThorimDoorGUID = go->GetGUID();
             break;
         case GO_THORIM_STONE_DOOR:
             uiStoneDoorGUID = go->GetGUID();
             break;
         case GO_THORIM_RUNIC_DOOR:
             uiRunicDoorGUID = go->GetGUID();
             break;
         case GO_HODIR_RARE_CACHE:
         case GO_HODIR_RARE_CACHE_HERO:
            HodirRareCacheGUID = go->GetGUID();
            break;
         case GO_HODIR_CHEST_HERO:
         case GO_HODIR_CHEST:
             uiHodirChestGUID = go->GetGUID();
             break;
         case GO_HODIR_OUT_DOOR_ICE:
             uiHodirIceDoorGUID = go->GetGUID();
             if (GetBossState(TYPE_HODIR) == DONE)
                 HandleGameObject(uiHodirIceDoorGUID, true);
             break;
         case GO_HODIR_OUT_DOOR_STONE:
             uiHodirStoneDoorGUID = go->GetGUID();
             if (GetBossState(TYPE_HODIR) == DONE)
                 HandleGameObject(uiHodirIceDoorGUID, true);
             break;
         case GO_HODIR_IN_DOOR_STONE:
             uiHodirEntranceDoorGUID = go->GetGUID();
             break;
         case GO_FREYA_CHEST_HERO:
         case GO_FREYA_CHEST:
             uiFreyaChestGUID = go->GetGUID();
             break;
         case GO_LEVIATHAN_DOOR:
             go->setActive(true);
             uiLeviathanDoorGUIDList.push_back(go->GetGUID());
             break;
         case GO_LEVIATHAN_GATE:
             uiLeviathanGateGUID = go->GetGUID();
             if (GetBossState(TYPE_LEVIATHAN) == DONE)
                 go->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
             else
                 HandleGameObject(NULL, false, go);
             break;
         case GO_XT002_DOOR:
             uiXT002DoorGUID = go->GetGUID();
             HandleGameObject(0, GetBossState(TYPE_LEVIATHAN) == DONE, go);
             break;
         case GO_MIMIRON_TRAIN:
             go->setActive(true);
             uiMimironTrainGUID = go->GetGUID();
             break;
         case GO_MIMIRON_ELEVATOR:
             go->setActive(true);
             uiMimironElevatorGUID = go->GetGUID();
             break;
         case GO_MIMIRON_DOOR_1:
         case GO_MIMIRON_DOOR_2:
         case GO_MIMIRON_DOOR_3:
             go->setActive(true);
             uiMimironDoorGUIDList.push_back(go->GetGUID());
             break;
         case GO_WAY_TO_YOGG:
             uiWayToYoggGUID = go->GetGUID();
             if (GetBossState(TYPE_FREYA) == DONE &&
                 GetBossState(TYPE_MIMIRON) == DONE &&
                 GetBossState(TYPE_HODIR) == DONE &&
                 GetBossState(TYPE_THORIM) == DONE)
                 go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_LOCKED);
             break;
         case GO_VEZAX_DOOR:
             uiVezaxDoorGUID = go->GetGUID();
             HandleGameObject(NULL, GetBossState(TYPE_VEZAX) == DONE, go);
             break;
         case GO_YOGGSARON_DOOR:
             uiYoggSaronDoorGUID = go->GetGUID();
             HandleGameObject(NULL, true, go);
             break;
         case GO_YOGGBRAIN_DOOR_1:
             uiYoggSaronBrainDoor1GUID = go->GetGUID();
             break;
         case GO_YOGGBRAIN_DOOR_2:
             uiYoggSaronBrainDoor2GUID = go->GetGUID();
             HandleGameObject(NULL, false, go);
         case GO_RAZOR_HARPOON_1:
             uiRazorHarpoonGUIDs[0] = go->GetGUID();
             break;
         case GO_RAZOR_HARPOON_2:
             uiRazorHarpoonGUIDs[1] = go->GetGUID();
             break;
         case GO_RAZOR_HARPOON_3:
             uiRazorHarpoonGUIDs[2] = go->GetGUID();
             break;
         case GO_RAZOR_HARPOON_4:
             uiRazorHarpoonGUIDs[3] = go->GetGUID();
             break;
         case GO_YOGGBRAIN_DOOR_3:
             uiYoggSaronBrainDoor3GUID = go->GetGUID();
             HandleGameObject(NULL, false, go);
             break;
         case GO_MOLE_MACHINE:
             if (GetBossState(TYPE_RAZORSCALE) == IN_PROGRESS)
                 go->SetGoState(GO_STATE_ACTIVE);
             break;
         case GO_ALGALON_PLATFORM:
             HandleGameObject(NULL, false, go);
             break;
         case GO_ALGALON_BRIDGE:
             uiAlgalonBridgeGUID = go->GetGUID();
             HandleGameObject(NULL, false, go);
             break;
         case GO_ALGALON_B_VISUAL:
             uiAlgalonBridgeVisualGUID = go->GetGUID();
             HandleGameObject(NULL, false, go);
             break;
         case GO_ALGALON_B_DOOR:
             uiAlgalonBridgeDoorGUID = go->GetGUID();
             HandleGameObject(NULL, true, go);
             break;
         case GO_ALGALON_GLOBE:
             uiAlgalonGlobeGUID = go->GetGUID();
             HandleGameObject(NULL, false, go);
             break;
         case GO_ALGALON_DOOR_1:
             uiAlgalonDoor1GUID = go->GetGUID();
             HandleGameObject(NULL, uiAlgalonCountdown < 62 ? true : false, go);
             break;
         case GO_ALGALON_DOOR_2:
             uiAlgalonDoor2GUID = go->GetGUID();
             HandleGameObject(NULL, uiAlgalonCountdown < 62 ? true : false, go);
             break;
         case GO_ALGALON_ACCESS:
             uiAlgalonAccessGUID = go->GetGUID();
             if (uiAlgalonCountdown < 62)
             {
                 go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
                 go->SetGoState(GO_STATE_ACTIVE);
             }
             break;
     }
 }
Beispiel #29
0
    void UpdateAI(const uint32 diff)
    {
        if (!pInstance)
            return;

        if (MobDeath_Timer)
        {
            if (MobDeath_Timer <= diff)
            {
                MobDeath_Timer = 2500;

                if (RingBossGUID)
                {
                    Creature *boss = Unit::GetCreature(*me,RingBossGUID);
                    if (boss && !boss->isAlive() && boss->isDead())
                    {
                        RingBossGUID = 0;
                        Event_Timer = 5000;
                        MobDeath_Timer = 0;
                        return;
                    }
                    return;
                }

                for (uint8 i = 0; i < MAX_MOB_AMOUNT; ++i)
                {
                    Creature *mob = Unit::GetCreature(*me,RingMobGUID[i]);
                    if (mob && !mob->isAlive() && mob->isDead())
                    {
                        RingMobGUID[i] = 0;
                        --MobCount;

                        //seems all are gone, so set timer to continue and discontinue this
                        if (!MobCount)
                        {
                            Event_Timer = 5000;
                            MobDeath_Timer = 0;
                        }
                    }
                }
            } else MobDeath_Timer -= diff;
        }

        if (Event_Timer)
        {
            if (Event_Timer <= diff)
            {
                switch(EventPhase)
                {
                case 0:
                    DoScriptText(SCRIPT_TEXT5, me);//1
                    HandleGameObject(DATA_ARENA4, false);
                    Start(false, false);
                    CanWalk = true;
                    Event_Timer = 0;
                    break;
                case 1:
                    CanWalk = true;
                    Event_Timer = 0;
                    break;
                case 2:
                    Event_Timer = 2000;
                    break;
                case 3:
                    HandleGameObject(DATA_ARENA1, true);
                    Event_Timer = 3000;
                    break;
                case 4:
                    CanWalk = true;
                    me->SetVisibility(VISIBILITY_OFF);
                    SummonRingMob();
                    Event_Timer = 8000;
                    break;
                case 5:
                    SummonRingMob();
                    SummonRingMob();
                    Event_Timer = 8000;
                    break;
                case 6:
                    SummonRingMob();
                    Event_Timer = 0;
                    break;
                case 7:
                    me->SetVisibility(VISIBILITY_ON);
                    HandleGameObject(DATA_ARENA1, false);
                    DoScriptText(SCRIPT_TEXT6, me);//4
                    CanWalk = true;
                    Event_Timer = 0;
                    break;
                case 8:
                    HandleGameObject(DATA_ARENA2, true);
                    Event_Timer = 5000;
                    break;
                case 9:
                    me->SetVisibility(VISIBILITY_OFF);
                    SummonRingBoss();
                    Event_Timer = 0;
                    break;
                case 10:
                    //if quest, complete
                    HandleGameObject(DATA_ARENA2, false);
                    HandleGameObject(DATA_ARENA3, true);
                    HandleGameObject(DATA_ARENA4, true);
                    CanWalk = true;
                    Event_Timer = 0;
                    break;
                }
                ++EventPhase;
            } else Event_Timer -= diff;
        }

        if (CanWalk)
            npc_escortAI::UpdateAI(diff);
       }
        void Dragonspireroomcheck()
        {
            Creature* mob = NULL;
            GameObject* rune = NULL;

            for (uint8 i = 0; i < 7; ++i)
            {
                bool _mobAlive = false;
                rune = instance->GetGameObject(go_roomrunes[i]);
                if (rune && rune->GetGoState() == GO_STATE_ACTIVE)
                {
                    for (uint8 ii = 0; ii < 5; ++ii)
                    {
                        mob = instance->GetCreature(runecreaturelist[i][ii]);
                        if (mob && mob->IsAlive())
                            _mobAlive = true;
                    }
                }

                if (!_mobAlive && rune->GetGoState() == GO_STATE_ACTIVE)
                {
                    HandleGameObject(0, false, rune);

                    switch (rune->GetEntry())
                    {
                        case GO_HALL_RUNE_1:
                            SetBossState(DATA_HALL_RUNE_1, DONE);
                            break;
                        case GO_HALL_RUNE_2:
                            SetBossState(DATA_HALL_RUNE_2, DONE);
                            break;
                        case GO_HALL_RUNE_3:
                            SetBossState(DATA_HALL_RUNE_3, DONE);
                            break;
                        case GO_HALL_RUNE_4:
                            SetBossState(DATA_HALL_RUNE_4, DONE);
                            break;
                        case GO_HALL_RUNE_5:
                            SetBossState(DATA_HALL_RUNE_5, DONE);
                            break;
                        case GO_HALL_RUNE_6:
                            SetBossState(DATA_HALL_RUNE_6, DONE);
                            break;
                        case GO_HALL_RUNE_7:
                            SetBossState(DATA_HALL_RUNE_7, DONE);
                            break;
                        default:
                            break;
                    }
                }
            }

            if (GetBossState(DATA_HALL_RUNE_1) == DONE && GetBossState(DATA_HALL_RUNE_2) == DONE && GetBossState(DATA_HALL_RUNE_3) == DONE &&
                GetBossState(DATA_HALL_RUNE_4) == DONE && GetBossState(DATA_HALL_RUNE_5) == DONE && GetBossState(DATA_HALL_RUNE_6) == DONE &&
                GetBossState(DATA_HALL_RUNE_7) == DONE)
            {
                SetBossState(DATA_DRAGONSPIRE_ROOM, DONE);
                if (GameObject* door1 = instance->GetGameObject(go_emberseerin))
                    HandleGameObject(0, true, door1);
                if (GameObject* door2 = instance->GetGameObject(go_doors))
                    HandleGameObject(0, true, door2);
            }
        }