Beispiel #1
0
void instance_dire_maul::SetData(uint32 uiType, uint32 uiData)
{
    switch (uiType)
    {
            // East
        case TYPE_ZEVRIM:
            if (uiData == DONE)
            {
                // Update Old Ironbark so he can open the conservatory door
                if (Creature* pIronbark = GetSingleCreatureFromStorage(NPC_OLD_IRONBARK))
                {
                    DoScriptText(SAY_IRONBARK_REDEEM, pIronbark);
                    pIronbark->UpdateEntry(NPC_IRONBARK_REDEEMED);
                }
            }
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_IRONBARK:
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_ALZZIN:                                   // This Encounter is expected to be handled within Acid (reason handling at 50% hp)
            if (uiData == DONE)
            {
                if (!m_bWallDestroyed)
                {
                    DoUseDoorOrButton(GO_CRUMBLE_WALL);
                    m_bWallDestroyed = true;
                }

                DoUseDoorOrButton(GO_CORRUPT_VINE);

                if (!m_lFelvineShardGUIDs.empty())
                {
                    for (GuidList::const_iterator itr = m_lFelvineShardGUIDs.begin(); itr != m_lFelvineShardGUIDs.end(); ++itr)
                    {
                        DoRespawnGameObject(*itr);
                    }
                }
            }
            else if (uiData == SPECIAL && !m_bWallDestroyed)
            {
                DoUseDoorOrButton(GO_CRUMBLE_WALL);
                m_bWallDestroyed = true;
            }
            m_auiEncounter[uiType] = uiData;
            break;

            // West
        case TYPE_WARPWOOD:
            if (uiData == DONE)
            {
                DoUseDoorOrButton(GO_WARPWOOD_DOOR);
            }
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_IMMOLTHAR:
            if (uiData == DONE)
            {
                if (Creature* pPrince = GetSingleCreatureFromStorage(NPC_PRINCE_TORTHELDRIN))
                {
                    DoScriptText(SAY_FREE_IMMOLTHAR, pPrince);
                    pPrince->SetFactionTemporary(FACTION_HOSTILE, TEMPFACTION_RESTORE_RESPAWN | TEMPFACTION_TOGGLE_OOC_NOT_ATTACK);
                    // Despawn Chest-Aura
                    if (GameObject* pChestAura = GetSingleGameObjectFromStorage(GO_PRINCES_CHEST_AURA))
                    {
                        pChestAura->Use(pPrince);
                    }
                }
            }
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_PRINCE:
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_PYLON_1:
        case TYPE_PYLON_2:
        case TYPE_PYLON_3:
        case TYPE_PYLON_4:
        case TYPE_PYLON_5:
            m_auiEncounter[uiType] = uiData;
            if (uiData == DONE)
            {
                DoUseDoorOrButton(m_aCrystalGeneratorGuid[uiType - TYPE_PYLON_1]);
                if (CheckAllGeneratorsDestroyed())
                {
                    ProcessForceFieldOpening();
                }
            }
            break;

            // North
        case TYPE_KING_GORDOK:
            m_auiEncounter[uiType] = uiData;
            if (uiData == DONE)
            {
                // Apply Aura to players in the map
                Map::PlayerList const& players = instance->GetPlayers();
                for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                {
                    if (Player* pPlayer = itr->getSource())
                    {
                        pPlayer->CastSpell(pPlayer, SPELL_KING_OF_GORDOK, true);
                    }
                }
            }
            break;
        case TYPE_MOLDAR:
        case TYPE_FENGUS:
        case TYPE_SLIPKIK:
        case TYPE_KROMCRUSH:
            m_auiEncounter[uiType] = uiData;
            break;
    }

    if (uiData == 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] << " "
                      << m_auiEncounter[9] << " " << m_auiEncounter[10] << " " << m_auiEncounter[11] << " "
                      << m_auiEncounter[12] << " " << m_auiEncounter[13] << " " << m_auiEncounter[14] << " "
                      << m_auiEncounter[15];

        m_strInstData = saveStream.str();

        SaveToDB();
        OUT_SAVE_INST_DATA_COMPLETE;
    }
}
void instance_dire_maul::SetData(uint32 uiType, uint32 uiData)
{
    switch (uiType)
    {
        // East
        case TYPE_ZEVRIM:
            if (uiData == DONE)
            {
                // Update Old Ironbark so he can open the conservatory door
                if (Creature* pIronbark = GetSingleCreatureFromStorage(NPC_OLD_IRONBARK))
                {
                    DoScriptText(SAY_IRONBARK_REDEEM, pIronbark);
                    pIronbark->UpdateEntry(NPC_IRONBARK_REDEEMED);
                }
            }
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_IRONBARK:
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_ALZZIN:                                   // This Encounter is expected to be handled within Acid (reason handling at 50% hp)
            if (uiData == DONE)
            {
                if (!m_bWallDestroyed)
                {
                    DoUseDoorOrButton(GO_CRUMBLE_WALL);
                    m_bWallDestroyed = true;
                }

                DoUseDoorOrButton(GO_CORRUPT_VINE);

                if (!m_lFelvineShardGUIDs.empty())
                {
                    for (GuidList::const_iterator itr = m_lFelvineShardGUIDs.begin(); itr != m_lFelvineShardGUIDs.end(); ++itr)
                        DoRespawnGameObject(*itr);
                }
            }
            else if (uiData == SPECIAL && !m_bWallDestroyed)
            {
                DoUseDoorOrButton(GO_CRUMBLE_WALL);
                m_bWallDestroyed = true;
            }
            m_auiEncounter[uiType] = uiData;
            break;

        // West
        case TYPE_WARPWOOD:
            if (uiData == DONE)
                DoUseDoorOrButton(GO_WARPWOOD_DOOR);
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_IMMOLTHAR:
            if (uiData == DONE)
            {
                if (Creature* pPrince = GetSingleCreatureFromStorage(NPC_PRINCE_TORTHELDRIN))
                {
                    DoScriptText(SAY_FREE_IMMOLTHAR, pPrince);
                    pPrince->SetFactionTemporary(FACTION_HOSTILE, TEMPFACTION_RESTORE_RESPAWN | TEMPFACTION_TOGGLE_IMMUNE_TO_PLAYER);
                    // Despawn Chest-Aura
                    if (GameObject* pChestAura = GetSingleGameObjectFromStorage(GO_PRINCES_CHEST_AURA))
                        pChestAura->Use(pPrince);
                }
            }
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_PRINCE:
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_DREADSTEED:
            // start timer
            if (uiData == IN_PROGRESS)
                m_uiDreadsteedEventTimer = 390000;
            else if (uiData == SPECIAL)
            {
                // set animation for next stage
                if (GameObject* pCircle = GetSingleGameObjectFromStorage(GO_WARLOCK_RITUAL_CIRCLE))
                    pCircle->SetGoState(GO_STATE_ACTIVE);

                // despawn the controller; Inform the attackers to teleport
                if (Creature* pDummy = GetSingleCreatureFromStorage(NPC_WARLOCK_DUMMY_INFERNAL))
                {
                    pDummy->AI()->SendAIEventAround(AI_EVENT_CUSTOM_EVENTAI_A, pDummy, 4000, 100.0f);
                    pDummy->ForcedDespawn(5000);
                }

                // despawn side portals
                for (GuidList::const_iterator itr = m_lDreadsteedPortalsGUIDs.begin(); itr != m_lDreadsteedPortalsGUIDs.end(); ++itr)
                {
                    if (GameObject* pGo = instance->GetGameObject(*itr))
                        pGo->SetLootState(GO_JUST_DEACTIVATED);
                }
            }
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_PYLON_1:
        case TYPE_PYLON_2:
        case TYPE_PYLON_3:
        case TYPE_PYLON_4:
        case TYPE_PYLON_5:
            m_auiEncounter[uiType] = uiData;
            if (uiData == DONE)
            {
                DoUseDoorOrButton(m_aCrystalGeneratorGuid[uiType - TYPE_PYLON_1]);
                if (CheckAllGeneratorsDestroyed())
                    ProcessForceFieldOpening();
            }
            break;

        // North
        case TYPE_KING_GORDOK:
            m_auiEncounter[uiType] = uiData;
            if (uiData == DONE)
            {
                // change faction to certian ogres
                if (Creature* pOgre = GetSingleCreatureFromStorage(NPC_CAPTAIN_KROMCRUSH))
                {
                    if (pOgre->isAlive())
                    {
                        pOgre->SetFactionTemporary(FACTION_FRIENDLY, TEMPFACTION_RESTORE_RESPAWN);

                        // only evade if required
                        if (pOgre->getVictim())
                            pOgre->AI()->EnterEvadeMode();
                    }
                }

                if (Creature* pOgre = GetSingleCreatureFromStorage(NPC_CHORUSH))
                {
                    // Chorush evades and yells on king death (if alive)
                    if (pOgre->isAlive())
                    {
                        DoScriptText(SAY_CHORUSH_KING_DEAD, pOgre);
                        pOgre->SetFactionTemporary(FACTION_FRIENDLY, TEMPFACTION_RESTORE_RESPAWN);
                        pOgre->AI()->EnterEvadeMode();
                    }

                    // start WP movement for Mizzle; event handled by movement and gossip dbscripts
                    if (Creature* pMizzle = pOgre->SummonCreature(NPC_MIZZLE_THE_CRAFTY, afMizzleSpawnLoc[0], afMizzleSpawnLoc[1], afMizzleSpawnLoc[2], afMizzleSpawnLoc[3], TEMPSPAWN_DEAD_DESPAWN, 0, true))
                    {
                        pMizzle->SetWalk(false);
                        pMizzle->GetMotionMaster()->MoveWaypoint();
                    }
                }
            }
            break;
        case TYPE_MOLDAR:
        case TYPE_FENGUS:
        case TYPE_SLIPKIK:
        case TYPE_KROMCRUSH:
        case TYPE_CHORUSH:
        case TYPE_STOMPER_KREEG:
            m_auiEncounter[uiType] = uiData;
            break;
    }

    if (uiData == 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] << " "
                      << m_auiEncounter[9] << " " << m_auiEncounter[10] << " " << m_auiEncounter[11] << " "
                      << m_auiEncounter[12] << " " << m_auiEncounter[13] << " " << m_auiEncounter[14] << " "
                      << m_auiEncounter[15] << " " << m_auiEncounter[16] << " " << m_auiEncounter[17] << " "
                      << m_auiEncounter[18];

        m_strInstData = saveStream.str();

        SaveToDB();
        OUT_SAVE_INST_DATA_COMPLETE;
    }
}
void instance_dire_maul::SetData(uint32 uiType, uint32 uiData)
{
    switch(uiType)
    {
        // East
        case TYPE_ZEVRIM:
            if (uiData == DONE)
            {
                // Update Old Ironbark so he can open the conservatory door
                if (Creature* pIronbark = instance->GetCreature(m_uiOldIronbarkGUID))
                {
                    DoScriptText(SAY_IRONBARK_REDEEM, pIronbark);
					pIronbark->setFaction(FACTION_FREUNDLICH);
					pIronbark->SetDisplayId(1461);
                }
            }
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_IRONBARK:
            if (uiData == DONE)
            {
				DoUseDoorOrButton(m_uiConservatoryDoorGUID);
            }
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_ALZZIN:                                   // This Encounter is expected to be handled within Acid (reason handling at 50% hp)
            if (uiData == DONE)
            {
                if (!m_bWallDestroyed)
                {
                    DoUseDoorOrButton(m_uiCrumbleWallGUID);
                    m_bWallDestroyed = true;
                }

                DoUseDoorOrButton(m_uiCorruptVineGUID);

                if (!m_lFelvineShardGUIDs.empty())
                {
                    for(GUIDList::const_iterator itr = m_lFelvineShardGUIDs.begin(); itr != m_lFelvineShardGUIDs.end(); ++itr)
                        DoRespawnGameObject(*itr);
                }
            }
            else if (uiData == SPECIAL && !m_bWallDestroyed)
            {
                DoUseDoorOrButton(m_uiCrumbleWallGUID);
                m_bWallDestroyed = true;
            }
            m_auiEncounter[uiType] = uiData;
            break;

        // West
        case TYPE_IMMOLTHAR:
            if (uiData == DONE)
            {
                if (Creature* pPrince = instance->GetCreature(m_uiPrinceTortheldrinGUID))
                {
                    DoScriptText(SAY_FREE_IMMOLTHAR, pPrince);
                    pPrince->setFaction(FACTION_HOSTILE);
					pPrince->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                    // Despawn Chest-Aura
                    if (GameObject* pChestAura = instance->GetGameObject(m_uiPrincesChestAuraGUID))
                        pChestAura->Use(pPrince);
                }
            }
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_PRINCE:
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_PYLON_1:
        case TYPE_PYLON_2:
        case TYPE_PYLON_3:
        case TYPE_PYLON_4:
        case TYPE_PYLON_5:
            m_auiEncounter[uiType] = uiData;
            if (uiData == DONE)
            {
                DoUseDoorOrButton(m_auiCrystalGeneratorGUID[uiType - TYPE_PYLON_1]);
                if (CheckAllGeneratorsDestroyed())
                    ProcessForceFieldOpening();
            }
            break;

        // North
        case TYPE_KING_GORDOK:
            m_auiEncounter[uiType] = uiData;
            if (uiData == DONE)
            {
				StartTrue = true;
				/*
                // Apply Aura to players in the map
                Map::PlayerList const& players = instance->GetPlayers();
                for(Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                {
                    if (Player* pPlayer = itr->getSource())
                        pPlayer->CastSpell(pPlayer, SPELL_KING_OF_GORDOK, true);
                }*/
            }
            break;

		case TYPE_KNOT_CHEST:
			{
				m_auiEncounter[uiType] = uiData;
			}
			break;

		case TYPE_GORDOK_CHEST:
			m_auiEncounter[uiType] = uiData;
			break;

		default:
			{
				if(uiType < MAX_ENCOUNTER) {
					m_auiEncounter[uiType] = uiData;
				}
			}
			break;
    }

    if (uiData == DONE)
    {
        OUT_SAVE_INST_DATA;

        std::ostringstream saveStream;
		for(uint32 i = 0; i < MAX_ENCOUNTER; ++i)
			saveStream << m_auiEncounter[i] << " ";

        m_strInstData = saveStream.str();

        SaveToDB();
        OUT_SAVE_INST_DATA_COMPLETE;
    }
}
Beispiel #4
0
void instance_dire_maul::SetData(uint32 uiType, uint32 uiData)
{
    switch(uiType)
    {
        // East
        case TYPE_PUSILLIN:
            m_auiEncounter[0] = uiData;
            break;
        case TYPE_ZEVRIM_THORNHOOF:
            m_auiEncounter[1] = uiData;
            if (uiData == DONE)
				if (Creature* pIronbark = GetSingleCreatureFromStorage(NPC_OLD_IRONBARK))
                {
                    pIronbark->UpdateEntry(NPC_IRONBARK_THE_REDEEMED);
                    pIronbark->AIM_Initialize();
                    DoScriptText(SAY_REDEEMED, pIronbark);
                }
            break;
        case TYPE_IRONBARK_THE_REDEEMED:
            m_auiEncounter[2] = uiData;
            if (uiData == DONE)
                HandleGameObject(GO_CONSERVATORY_DOOR, true);
            break;
        case TYPE_ALZZIN_THE_WILDSHAPER:
            m_auiEncounter[3] = uiData;
            switch(uiData)
            {
                case NOT_STARTED:
                    HandleGameObject(GO_CRUMBLE_WALL, false);

                    for(GUIDList::iterator itr = m_uiAlzzinsMinionGUID.begin(); itr != m_uiAlzzinsMinionGUID.end(); ++itr)
                    {
                        if (Creature* pMinion = instance->GetCreature(*itr))
                            pMinion->Respawn();
                    }
                    break;
                case DONE:														//Not sure why but boss stopped doing crumble wall when it dies so I had to remove SPECIAL case.
                    HandleGameObject(GO_CORRUPTED_CRYSTAL_VINE, true);
                    for(GUIDList::iterator itr = m_uiShardGUID.begin(); itr != m_uiShardGUID.end(); ++itr)
					{ DoRespawnGameObject(*itr, HOUR);}
                /*    break;
                case SPECIAL:*/
                    HandleGameObject(GO_CRUMBLE_WALL, true);

                    if (Creature* pAlzzin = GetSingleCreatureFromStorage(NPC_ALZZINS_THE_WILDSHAPER))
                    {
                        for(GUIDList::iterator itr = m_uiAlzzinsMinionGUID.begin(); itr != m_uiAlzzinsMinionGUID.end(); ++itr)
                        {
                            if (Creature* pMinion = instance->GetCreature(*itr))
                                pMinion->AI()->AttackStart(pAlzzin->getVictim());
                        }
                    }
                    break;
            }
            break;
        case TYPE_ISALIEN:
            m_auiEncounter[4] = uiData;
            break;
        // North
        case TYPE_STOMPER_KREEG:
            m_auiEncounter[5] = uiData;
            break;
        case TYPE_GUARD_MOLDAR:
            m_auiEncounter[6] = uiData;
            break;
        case TYPE_GUARD_FENGUS:
            m_auiEncounter[7] = uiData;
            break;
        case TYPE_GUARD_SLIPKIK:
            m_auiEncounter[8] = uiData;
            break;
        case TYPE_CAPTAIN_KROMCRUSH:
            m_auiEncounter[9] = uiData;
            break;
        case TYPE_CHORUSH_THE_OBSERVER:
            m_auiEncounter[10] = uiData;
            break;
        case TYPE_KING_GORDOK:
            m_auiEncounter[11] = uiData;
            if (uiData == DONE)
            {
                Creature* pChorush = GetSingleCreatureFromStorage(NPC_CHORUSH_THE_OBSERVER);
                if (pChorush && pChorush->isAlive() && m_auiEncounter[10] != DONE)
                {
                    pChorush->setFaction(FACTION_FRIENDLY);
                    pChorush->InterruptNonMeleeSpells(false);
                    pChorush->AI()->ResetToHome();

                    if (Creature* pMizzle = pChorush->SummonCreature(NPC_MIZZLE_THE_CRAFTY, 731.14f, 481.14f, 28.18f, 0.016f, TEMPSUMMON_DEAD_DESPAWN, 10000))
                    {
                        pMizzle->setFaction(FACTION_FRIENDLY);	
						// He should be running from spawn and then walk at point 0, can't get it to work. Walk all the way for now
                        pMizzle->GetMotionMaster()->MovePoint(0, 818.92f, 481.95f, 37.32f);
                        CreatureCreatePos pos(pMizzle->GetMap(), 818.92f, 481.95f, 37.32f, 4.32f);
                        pMizzle->SetSummonPoint(pos);
                    }
                }
            }
            break;
        case TYPE_TRIBUTE_RUN:
            m_auiEncounter[12] = uiData;
            if (uiData == DONE)
            {
                // Set Gordok friendly (spell 22799 seems to be buggy)
                for(GUIDList::iterator itr = m_uiGordokGUID.begin(); itr != m_uiGordokGUID.end(); ++itr)
                {
                    if (Creature* pGordok = instance->GetCreature(*itr))
                    {
                        pGordok->setFaction(FACTION_FRIENDLY);

                        // Return Captain Krom'crush back
                        if (pGordok->GetEntry() == NPC_CAPTAIN_KROMCRUSH && pGordok->isAlive())
                        {
                            pGordok->SetVisibility(VISIBILITY_ON);
                            pGordok->GetMotionMaster()->MoveTargetedHome();
                        }
                    }
                }

                uint32 uiCount = 0;
                ObjectGuid uiTributeGUID = ObjectGuid();

                for(uint8 i = 5; i <= 10; ++i)
                    if (m_auiEncounter[i] != DONE)
                        ++uiCount;

                for(GUIDList::iterator itr = m_uiGordokTributeGUID.begin(); itr != m_uiGordokTributeGUID.end(); ++itr)
                {
                    if (GameObject* pTribute = instance->GetGameObject(*itr))
                        if (pTribute->GetEntry() == aTribute[uiCount])
                        {
							uiTributeGUID = pTribute->GetObjectGuid();
                            break;
                        }
                }

                if (uiTributeGUID)
                    DoRespawnGameObject(uiTributeGUID, HOUR);
            }
            break;
        case TYPE_KNOT_THIMBLEJACK:
            m_auiEncounter[13] = uiData;
            if (uiData == DONE)
                DoRespawnGameObject(GO_KNOT_THIMBLEJACK_CACHE, HOUR);
            break;
        // West
        case TYPE_TENDRIS_WARPWOOD:
            m_auiEncounter[14] = uiData;
            if (uiData == IN_PROGRESS)
                CallProtectors();
            if (uiData == DONE)
            {
                if (Creature* pTendris = GetSingleCreatureFromStorage(NPC_TENDRIS_WARPWOOD))
                    pTendris->SummonCreature(NPC_ANCIENT_EQUINE_SPIRIT, 9.18f, 491.05f, -23.29f, 4.89f, TEMPSUMMON_DEAD_DESPAWN, 0);
            }
            break;
    /*    case TYPE_BARRIER:
            m_auiEncounter[15] = uiData;
            if (uiData == IN_PROGRESS)
            {
                --m_uiPylonCount;

                if (!m_uiPylonCount)
                    SetData(TYPE_BARRIER, DONE);
                else
                    debug_log("SD0: Instance Dire Maul: %u pylons left to activate.", m_uiPylonCount);
            }*/
            
        case TYPE_IMMOLTHAR:
            m_auiEncounter[15] = uiData;
            if (uiData == DONE)
            {
				
                if (Creature* pPrince = GetSingleCreatureFromStorage(NPC_PRINCE_TORTHELDRIN))
				{
					pPrince->setFaction(pPrince->GetCreatureInfo()->faction_A);	
					if (!bYell1 && pPrince)
						{
							DoScriptText(SAY_KILL_IMMOLTHAR, pPrince);					//TODO: still does the text twice.
							bYell1 = true;
						}
				}
			}

            break;
        case TYPE_PRINCE_TORTHELDRIN:
            m_auiEncounter[16] = uiData;
            if (uiData == DONE)
                DoRespawnGameObject(GO_THE_PRINCES_CHEST, HOUR);
            break;
		case TYPE_PYLON_1:
        case TYPE_PYLON_2:
        case TYPE_PYLON_3:
        case TYPE_PYLON_4:
        case TYPE_PYLON_5:
            m_auiEncounter[uiType] = uiData;
            if (uiData == DONE)
            {
               DoUseDoorOrButton(m_aCrystalGeneratorGuid[uiType - TYPE_PYLON_1]);
                if (CheckAllGeneratorsDestroyed())
                {
                    ProcessForceFieldOpening();
                }
                /*if (Creature* pImmolthar = GetSingleCreatureFromStorage(NPC_IMMOLTHAR))
                    pImmolthar->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE + UNIT_FLAG_NOT_SELECTABLE);*/			//Unused since barrier case is removed
            }
            break;
    }
        
    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] << " "
	<< m_auiEncounter[9] << " " << m_auiEncounter[10] << " " << m_auiEncounter[11] << " "
	<< m_auiEncounter[12] << " " << m_auiEncounter[13] << " " << m_auiEncounter[14] << " "
	<< m_auiEncounter[15] << " " << m_auiEncounter[16] << " " << m_auiEncounter[17];

    strInstData = saveStream.str();

    SaveToDB();
    OUT_SAVE_INST_DATA_COMPLETE;
}
void instance_dire_maul::SetData(uint32 uiType, uint32 uiData)
{
    switch(uiType)
    {
        // East
        case TYPE_ALZZIN:                                   // This Encounter is expected to be handled within Acid (reason handling at 50% hp)
            if (uiData == DONE)
            {
                if (!m_bWallDestroyed)
                {
                    DoUseDoorOrButton(m_uiCrumbleWallGUID);
                    m_bWallDestroyed = true;
                }

                DoUseDoorOrButton(m_uiCorruptVineGUID);

                if (!m_lFelvineShardGUIDs.empty())
                {
                    for(std::list<uint64>::iterator i = m_lFelvineShardGUIDs.begin(); i != m_lFelvineShardGUIDs.end(); ++i)
                        DoRespawnGameObject(*i);
                }
            }
            else if (uiData == SPECIAL && !m_bWallDestroyed)
            {
                DoUseDoorOrButton(m_uiCrumbleWallGUID);
                m_bWallDestroyed = true;
            }
            m_auiEncounter[uiType] = uiData;
            break;

        // West
        case TYPE_IMMOLTHAR:
            if (uiData == DONE)
            {
                if (Creature* pPrince = instance->GetCreature(m_uiPrinceTortheldrinGUID))
                {
                    DoScriptText(SAY_FREE_IMMOLTHAR, pPrince);
                    pPrince->setFaction(FACTION_HOSTILE);
                    // Despawn Chest-Aura
                    if (GameObject* pChestAura = instance->GetGameObject(m_uiPrincesChestAuraGUID))
                        pChestAura->Use(pPrince);
                }
            }
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_PRINCE:
            m_auiEncounter[uiType] = uiData;
            break;
        case TYPE_PYLON_1:
        case TYPE_PYLON_2:
        case TYPE_PYLON_3:
        case TYPE_PYLON_4:
        case TYPE_PYLON_5:
            m_auiEncounter[uiType] = uiData;
            if (uiData == DONE)
            {
                DoUseDoorOrButton(m_auiCrystalGeneratorGUID[uiType - TYPE_PYLON_1]);
                if (CheckAllGeneratorsDestroyed())
                    ProcessForceFieldOpening();
            }
            break;

        // North
        case TYPE_KING_GORDOK:
            m_auiEncounter[uiType] = uiData;
            if (uiData == DONE)
            {
                // Apply Aura to players in the map
                Map::PlayerList const& players = instance->GetPlayers();
                for(Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                {
                    if (Player* pPlayer = itr->getSource())
                        pPlayer->CastSpell(pPlayer, SPELL_KING_OF_GORDOK, true);
                }
            }
            break;
    }

    if (uiData >= 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];

        m_strInstData = saveStream.str();

        SaveToDB();
        OUT_SAVE_INST_DATA_COMPLETE;
    }
}