void instance_temple_of_ahnqiraj::SetData(uint32 uiType, uint32 uiData)
{
switch (uiType)
{
case TYPE_SKERAM:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
DoUseDoorOrButton(GO_SKERAM_GATE);
break;
case TYPE_BUG_TRIO:
if (uiData == SPECIAL)
{
++m_uiBugTrioDeathCount;
if (m_uiBugTrioDeathCount == 2)
SetData(TYPE_BUG_TRIO, DONE);
// don't store any special data
break;
}
if (uiData == FAIL)
m_uiBugTrioDeathCount = 0;
m_auiEncounter[uiType] = uiData;
break;
case TYPE_SARTURA:
case TYPE_FANKRISS:
case TYPE_VISCIDUS:
case TYPE_HUHURAN:
m_auiEncounter[uiType] = uiData;
break;
case TYPE_TWINS:
// Either of the twins can set data, so return to avoid double changing
if (m_auiEncounter[uiType] == uiData)
return;
m_auiEncounter[uiType] = uiData;
DoUseDoorOrButton(GO_TWINS_ENTER_DOOR);
if (uiData == DONE)
DoUseDoorOrButton(GO_TWINS_EXIT_DOOR);
break;
case TYPE_OURO:
switch (uiData)
{
case FAIL:
// Respawn the Ouro spawner on fail
if (Creature* pSpawner = GetSingleCreatureFromStorage(NPC_OURO_SPAWNER))
pSpawner->Respawn();
// no break;
case DONE:
// Despawn the sandworm base on Done or Fail
if (GameObject* pBase = GetSingleGameObjectFromStorage(GO_SANDWORM_BASE))
pBase->SetLootState(GO_JUST_DEACTIVATED);
break;
}
m_auiEncounter[uiType] = uiData;
break;
case TYPE_CTHUN:
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_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
void instance_pit_of_saron::SetData(uint32 uiType, uint32 uiData)
{
switch (uiType)
{
case TYPE_GARFROST:
if (uiData == DONE && m_auiEncounter[TYPE_KRICK] == DONE)
DoUseDoorOrButton(GO_ICEWALL);
if (uiData == IN_PROGRESS)
SetSpecialAchievementCriteria(TYPE_ACHIEV_DOESNT_GO_ELEVEN, true);
else if (uiData == DONE)
StartNextDialogueText(NPC_GARFROST);
m_auiEncounter[uiType] = uiData;
break;
case TYPE_KRICK:
if (uiData == DONE && m_auiEncounter[TYPE_GARFROST] == DONE)
DoUseDoorOrButton(GO_ICEWALL);
if (uiData == SPECIAL)
{
// Used just to start the epilogue
StartNextDialogueText(SAY_JAINA_KRICK_1);
return;
}
m_auiEncounter[uiType] = uiData;
break;
case TYPE_TYRANNUS:
if (uiData == DONE)
StartNextDialogueText(NPC_SINDRAGOSA);
else if (uiData == SPECIAL)
{
// Used just to start the intro
StartNextDialogueText(NPC_TYRANNUS);
return;
}
m_auiEncounter[uiType] = uiData;
break;
case TYPE_AMBUSH:
if (uiData == DONE)
{
// Complete tunnel achievement
if (Creature* pTyrannus = GetSingleCreatureFromStorage(NPC_TYRANNUS))
pTyrannus->CastSpell(pTyrannus, SPELL_ACHIEVEMENT_CHECK, true);
m_uiIciclesTimer = 0;
}
m_auiEncounter[uiType] = uiData;
break;
default:
return;
}
if (uiData == DONE)
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << m_auiEncounter[0] << " " << m_auiEncounter[1] << " " << m_auiEncounter[2] << " " << m_auiEncounter[3];
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:
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_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
void instance_naxxramas::SetData(uint32 uiType, uint32 uiData)
{
switch (uiType)
{
case TYPE_ANUB_REKHAN:
m_auiEncounter[uiType] = uiData;
DoUseDoorOrButton(GO_ARAC_ANUB_DOOR);
if (uiData == DONE)
DoUseDoorOrButton(GO_ARAC_ANUB_GATE);
break;
case TYPE_FAERLINA:
DoUseDoorOrButton(GO_ARAC_FAER_WEB);
if (uiData == DONE)
{
DoUseDoorOrButton(GO_ARAC_FAER_DOOR);
DoUseDoorOrButton(GO_ARAC_MAEX_OUTER_DOOR);
}
m_auiEncounter[uiType] = uiData;
break;
case TYPE_MAEXXNA:
m_auiEncounter[uiType] = uiData;
DoUseDoorOrButton(GO_ARAC_MAEX_INNER_DOOR, uiData);
if (uiData == DONE)
{
DoUseDoorOrButton(GO_ARAC_EYE_RAMP);
DoUseDoorOrButton(GO_ARAC_EYE_BOSS);
DoRespawnGameObject(GO_ARAC_PORTAL, 30 * MINUTE);
DoToggleGameObjectFlags(GO_ARAC_PORTAL, GO_FLAG_NO_INTERACT, false);
m_uiTauntTimer = 5000;
}
break;
case TYPE_NOTH:
m_auiEncounter[uiType] = uiData;
DoUseDoorOrButton(GO_PLAG_NOTH_ENTRY_DOOR);
if (uiData == DONE)
{
DoUseDoorOrButton(GO_PLAG_NOTH_EXIT_DOOR);
DoUseDoorOrButton(GO_PLAG_HEIG_ENTRY_DOOR);
}
break;
case TYPE_HEIGAN:
m_auiEncounter[uiType] = uiData;
DoUseDoorOrButton(GO_PLAG_HEIG_ENTRY_DOOR);
if (uiData == DONE)
DoUseDoorOrButton(GO_PLAG_HEIG_EXIT_HALLWAY);
break;
case TYPE_LOATHEB:
m_auiEncounter[uiType] = uiData;
DoUseDoorOrButton(GO_PLAG_LOAT_DOOR);
if (uiData == DONE)
{
DoUseDoorOrButton(GO_PLAG_EYE_RAMP);
DoUseDoorOrButton(GO_PLAG_EYE_BOSS);
DoRespawnGameObject(GO_PLAG_PORTAL, 30 * MINUTE);
DoToggleGameObjectFlags(GO_PLAG_PORTAL, GO_FLAG_NO_INTERACT, false);
m_uiTauntTimer = 5000;
}
break;
case TYPE_RAZUVIOUS:
m_auiEncounter[uiType] = uiData;
break;
case TYPE_GOTHIK:
switch (uiData)
{
case IN_PROGRESS:
DoUseDoorOrButton(GO_MILI_GOTH_ENTRY_GATE);
DoUseDoorOrButton(GO_MILI_GOTH_COMBAT_GATE);
break;
case SPECIAL:
DoUseDoorOrButton(GO_MILI_GOTH_COMBAT_GATE);
break;
case FAIL:
if (m_auiEncounter[uiType] == IN_PROGRESS)
DoUseDoorOrButton(GO_MILI_GOTH_COMBAT_GATE);
DoUseDoorOrButton(GO_MILI_GOTH_ENTRY_GATE);
break;
case DONE:
DoUseDoorOrButton(GO_MILI_GOTH_ENTRY_GATE);
DoUseDoorOrButton(GO_MILI_GOTH_EXIT_GATE);
DoUseDoorOrButton(GO_MILI_HORSEMEN_DOOR);
m_dialogueHelper.StartNextDialogueText(NPC_THANE);
break;
}
m_auiEncounter[uiType] = uiData;
break;
case TYPE_FOUR_HORSEMEN:
// Skip if already set
if (m_auiEncounter[uiType] == uiData)
return;
if (uiData == SPECIAL)
{
++m_uiHorseMenKilled;
if (m_uiHorseMenKilled == 4)
SetData(TYPE_FOUR_HORSEMEN, DONE);
// Don't store special data
break;
}
if (uiData == FAIL)
m_uiHorseMenKilled = 0;
m_auiEncounter[uiType] = uiData;
DoUseDoorOrButton(GO_MILI_HORSEMEN_DOOR);
if (uiData == DONE)
{
// Despawn spirits
if (Creature* pSpirit = GetSingleCreatureFromStorage(NPC_SPIRIT_OF_BLAUMEUX))
pSpirit->ForcedDespawn();
if (Creature* pSpirit = GetSingleCreatureFromStorage(NPC_SPIRIT_OF_MOGRAINE))
pSpirit->ForcedDespawn();
if (Creature* pSpirit = GetSingleCreatureFromStorage(NPC_SPIRIT_OF_KORTHAZZ))
pSpirit->ForcedDespawn();
if (Creature* pSpirit = GetSingleCreatureFromStorage(NPC_SPIRIT_OF_ZELIREK))
pSpirit->ForcedDespawn();
DoUseDoorOrButton(GO_MILI_EYE_RAMP);
DoUseDoorOrButton(GO_MILI_EYE_BOSS);
DoRespawnGameObject(GO_MILI_PORTAL, 30 * MINUTE);
DoToggleGameObjectFlags(GO_MILI_PORTAL, GO_FLAG_NO_INTERACT, false);
DoRespawnGameObject(GO_CHEST_HORSEMEN_NORM, 30 * MINUTE);
m_uiTauntTimer = 5000;
}
break;
case TYPE_PATCHWERK:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
DoUseDoorOrButton(GO_CONS_PATH_EXIT_DOOR);
break;
case TYPE_GROBBULUS:
m_auiEncounter[uiType] = uiData;
break;
case TYPE_GLUTH:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
{
DoUseDoorOrButton(GO_CONS_GLUT_EXIT_DOOR);
DoUseDoorOrButton(GO_CONS_THAD_DOOR);
}
break;
case TYPE_THADDIUS:
// Only process real changes here
if (m_auiEncounter[uiType] == uiData)
return;
m_auiEncounter[uiType] = uiData;
if (uiData != SPECIAL)
DoUseDoorOrButton(GO_CONS_THAD_DOOR, uiData);
if (uiData == DONE)
{
DoUseDoorOrButton(GO_CONS_EYE_RAMP);
DoUseDoorOrButton(GO_CONS_EYE_BOSS);
DoRespawnGameObject(GO_CONS_PORTAL, 30 * MINUTE);
DoToggleGameObjectFlags(GO_CONS_PORTAL, GO_FLAG_NO_INTERACT, false);
m_uiTauntTimer = 5000;
}
break;
case TYPE_SAPPHIRON:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
{
DoUseDoorOrButton(GO_KELTHUZAD_WATERFALL_DOOR);
m_dialogueHelper.StartNextDialogueText(NPC_KELTHUZAD);
}
// Start Sapph summoning process
if (uiData == SPECIAL)
m_uiSapphSpawnTimer = 22000;
break;
case TYPE_KELTHUZAD:
m_auiEncounter[uiType] = uiData;
DoUseDoorOrButton(GO_KELTHUZAD_EXIT_DOOR);
if (uiData == NOT_STARTED)
{
if (GameObject* pWindow = GetSingleGameObjectFromStorage(GO_KELTHUZAD_WINDOW_1))
pWindow->ResetDoorOrButton();
if (GameObject* pWindow = GetSingleGameObjectFromStorage(GO_KELTHUZAD_WINDOW_2))
pWindow->ResetDoorOrButton();
if (GameObject* pWindow = GetSingleGameObjectFromStorage(GO_KELTHUZAD_WINDOW_3))
pWindow->ResetDoorOrButton();
if (GameObject* pWindow = GetSingleGameObjectFromStorage(GO_KELTHUZAD_WINDOW_4))
pWindow->ResetDoorOrButton();
}
break;
}
if (uiData == DONE || (uiData == SPECIAL && uiType == TYPE_SAPPHIRON))
{
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_arcatraz::JustDidDialogueStep(int32 iEntry)
{
Creature* pMellichar = GetSingleCreatureFromStorage(NPC_MELLICHAR);
if (!pMellichar)
return;
switch (iEntry)
{
case SPELL_TARGET_ALPHA:
pMellichar->CastSpell(pMellichar, SPELL_TARGET_ALPHA, TRIGGERED_NONE);
if (Creature* pTarget = GetSingleCreatureFromStorage(NPC_PRISON_APHPA_POD))
pMellichar->SetFacingToObject(pTarget);
SetData(TYPE_WARDEN_1, IN_PROGRESS);
break;
case YELL_MELLICHAR_RELEASE1:
pMellichar->SummonCreature(urand(0, 1) ? NPC_BLAZING_TRICKSTER : NPC_PHASE_HUNTER, aSummonPosition[0].m_fX, aSummonPosition[0].m_fY, aSummonPosition[0].m_fZ, aSummonPosition[0].m_fO, TEMPSUMMON_DEAD_DESPAWN, 0);
break;
case YELL_MELLICHAR_RELEASE2:
if (Creature* pTarget = GetSingleCreatureFromStorage(NPC_PRISON_BETA_POD))
pMellichar->SetFacingToObject(pTarget);
break;
case SPELL_TARGET_BETA:
pMellichar->CastSpell(pMellichar, SPELL_TARGET_BETA, TRIGGERED_NONE);
SetData(TYPE_WARDEN_2, IN_PROGRESS);
break;
case TYPE_WARDEN_2:
pMellichar->SummonCreature(NPC_MILLHOUSE, aSummonPosition[1].m_fX, aSummonPosition[1].m_fY, aSummonPosition[1].m_fZ, aSummonPosition[1].m_fO, TEMPSUMMON_DEAD_DESPAWN, 0);
break;
case SPELL_TARGET_DELTA:
pMellichar->CastSpell(pMellichar, SPELL_TARGET_DELTA, TRIGGERED_NONE);
if (Creature* pTarget = GetSingleCreatureFromStorage(NPC_PRISON_DELTA_POD))
pMellichar->SetFacingToObject(pTarget);
SetData(TYPE_WARDEN_3, IN_PROGRESS);
break;
case TYPE_WARDEN_3:
pMellichar->SummonCreature(urand(0, 1) ? NPC_AKKIRIS : NPC_SULFURON, aSummonPosition[2].m_fX, aSummonPosition[2].m_fY, aSummonPosition[2].m_fZ, aSummonPosition[2].m_fO, TEMPSUMMON_DEAD_DESPAWN, 0);
pMellichar->CastSpell(pMellichar, SPELL_TARGET_OMEGA, TRIGGERED_NONE);
if (Creature* pTarget = GetSingleCreatureFromStorage(NPC_PRISON_BOSS_POD))
pMellichar->SetFacingToObject(pTarget);
break;
case YELL_MELLICHAR_RELEASE4:
pMellichar->InterruptNonMeleeSpells(false);
if (Creature* pTarget = GetSingleCreatureFromStorage(NPC_PRISON_GAMMA_POD))
pMellichar->SetFacingToObject(pTarget);
break;
case SPELL_TARGET_GAMMA:
pMellichar->CastSpell(pMellichar, SPELL_TARGET_GAMMA, TRIGGERED_NONE);
if (Creature* pTarget = GetSingleCreatureFromStorage(NPC_PRISON_GAMMA_POD))
pMellichar->SetFacingToObject(pTarget);
SetData(TYPE_WARDEN_4, IN_PROGRESS);
break;
case TYPE_WARDEN_4:
pMellichar->SummonCreature(urand(0, 1) ? NPC_TW_DRAKONAAR : NPC_BL_DRAKONAAR, aSummonPosition[3].m_fX, aSummonPosition[3].m_fY, aSummonPosition[3].m_fZ, aSummonPosition[3].m_fO, TEMPSUMMON_DEAD_DESPAWN, 0);
pMellichar->CastSpell(pMellichar, SPELL_TARGET_OMEGA, TRIGGERED_NONE);
if (Creature* pTarget = GetSingleCreatureFromStorage(NPC_PRISON_BOSS_POD))
pMellichar->SetFacingToObject(pTarget);
break;
case YELL_MELLICHAR_RELEASE5:
pMellichar->InterruptNonMeleeSpells(false);
SetData(TYPE_WARDEN_5, IN_PROGRESS);
break;
case TYPE_WARDEN_5:
if (Creature* pSkyriss = pMellichar->SummonCreature(NPC_SKYRISS, aSummonPosition[4].m_fX, aSummonPosition[4].m_fY, aSummonPosition[4].m_fZ, aSummonPosition[4].m_fO, TEMPSUMMON_DEAD_DESPAWN, 0))
pSkyriss->CastSpell(pSkyriss, SPELL_SIMPLE_TELEPORT, TRIGGERED_NONE);
break;
case YELL_MELLICAR_WELCOME:
if (Creature* pSkyriss = GetSingleCreatureFromStorage(NPC_SKYRISS))
pSkyriss->CastSpell(pSkyriss, SPELL_MIND_REND, TRIGGERED_NONE);
break;
case SAY_SKYRISS_AGGRO:
// Kill Mellichar and start combat
if (Creature* pSkyriss = GetSingleCreatureFromStorage(NPC_SKYRISS))
{
pSkyriss->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PASSIVE);
pMellichar->DealDamage(pMellichar, pMellichar->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
}
DoUseDoorOrButton(GO_SEAL_SPHERE);
break;
}
}
void instance_nexus::SetData(uint32 uiType, uint32 uiData)
{
switch (uiType)
{
case TYPE_TELESTRA:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
{
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_CONTAINMENT_SPHERE_TELESTRA))
pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NO_INTERACT);
}
break;
case TYPE_ANOMALUS:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
{
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_CONTAINMENT_SPHERE_ANOMALUS))
pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NO_INTERACT);
}
break;
case TYPE_ORMOROK:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
{
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_CONTAINMENT_SPHERE_ORMOROK))
pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NO_INTERACT);
}
break;
case TYPE_KERISTRASZA:
m_auiEncounter[uiType] = uiData;
break;
default:
error_log("SD2: Instance Nexus: ERROR SetData = %u for type %u does not exist/not implemented.", uiType, uiData);
return;
}
if (m_auiEncounter[TYPE_TELESTRA] == SPECIAL && m_auiEncounter[TYPE_ANOMALUS] == SPECIAL && m_auiEncounter[TYPE_ORMOROK] == SPECIAL)
{
// release Keristrasza from her prison here
m_auiEncounter[TYPE_KERISTRASZA] = SPECIAL;
Creature* pCreature = GetSingleCreatureFromStorage(NPC_KERISTRASZA);
if (pCreature && pCreature->isAlive())
{
if (pCreature->isAlive())
{
pCreature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PASSIVE | UNIT_FLAG_OOC_NOT_ATTACKABLE);
pCreature->RemoveAurasDueToSpell(SPELL_FROZEN_PRISON);
}
}
}
if (uiData == DONE)
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << m_auiEncounter[0] << " " << m_auiEncounter[1] << " " << m_auiEncounter[2] << " " << m_auiEncounter[3];
m_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
void instance_arcatraz::SetData(uint32 uiType, uint32 uiData)
{
switch (uiType)
{
case TYPE_ENTRANCE:
case TYPE_ZEREKETH:
m_auiEncounter[uiType] = uiData;
break;
case TYPE_DALLIAH:
if (uiData == IN_PROGRESS)
{
// Soccothares taunts after Dalliah gets aggro
if (GetData(TYPE_SOCCOTHRATES) != DONE)
StartNextDialogueText(TYPE_DALLIAH);
}
if (uiData == DONE)
{
DoUseDoorOrButton(GO_CORE_SECURITY_FIELD_BETA);
// Soccothares taunts after Dalliah dies
if (GetData(TYPE_SOCCOTHRATES) != DONE)
StartNextDialogueText(TYPE_SOCCOTHRATES);
}
m_auiEncounter[uiType] = uiData;
break;
case TYPE_SOCCOTHRATES:
if (uiData == DONE)
DoUseDoorOrButton(GO_CORE_SECURITY_FIELD_ALPHA);
m_auiEncounter[uiType] = uiData;
break;
case TYPE_HARBINGERSKYRISS:
if (uiData == FAIL)
{
SetData(TYPE_WARDEN_1, NOT_STARTED);
SetData(TYPE_WARDEN_2, NOT_STARTED);
SetData(TYPE_WARDEN_3, NOT_STARTED);
SetData(TYPE_WARDEN_4, NOT_STARTED);
SetData(TYPE_WARDEN_5, NOT_STARTED);
// Reset event in 1 min
if (Creature* pMellichar = GetSingleCreatureFromStorage(NPC_MELLICHAR))
pMellichar->ForcedDespawn();
m_uiResetDelayTimer = 60000;
// Despawn all the summons manually
for (GuidList::const_iterator itr = m_lSkyrissEventMobsGuidList.begin(); itr != m_lSkyrissEventMobsGuidList.end(); ++itr)
{
if (Creature* pTemp = instance->GetCreature(*itr))
pTemp->ForcedDespawn();
}
// Reset these objects, because they doesn't reset automatically
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_POD_BETA))
pGo->ResetDoorOrButton();
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_POD_OMEGA))
pGo->ResetDoorOrButton();
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_SEAL_SPHERE))
pGo->ResetDoorOrButton();
}
if (uiData == IN_PROGRESS)
{
StartNextDialogueText(YELL_MELLICHAR_INTRO1);
DoUseDoorOrButton(GO_SEAL_SPHERE);
}
if (uiData == DONE)
{
if (Creature* pMillhouse = GetSingleCreatureFromStorage(NPC_MILLHOUSE))
DoScriptText(SAY_MILLHOUSE_COMPLETE, pMillhouse);
}
m_auiEncounter[3] = uiData;
break;
case TYPE_WARDEN_1:
if (uiData == IN_PROGRESS)
DoUseDoorOrButton(GO_POD_ALPHA);
if (uiData == DONE)
StartNextDialogueText(YELL_MELLICHAR_RELEASE2);
m_auiEncounter[uiType] = uiData;
break;
case TYPE_WARDEN_2:
if (uiData == IN_PROGRESS)
DoUseDoorOrButton(GO_POD_BETA);
if (uiData == DONE)
StartNextDialogueText(YELL_MELLICHAR_RELEASE3);
m_auiEncounter[uiType] = uiData;
break;
case TYPE_WARDEN_3:
if (uiData == IN_PROGRESS)
DoUseDoorOrButton(GO_POD_DELTA);
if (uiData == DONE)
StartNextDialogueText(YELL_MELLICHAR_RELEASE4);
m_auiEncounter[uiType] = uiData;
break;
case TYPE_WARDEN_4:
if (uiData == IN_PROGRESS)
DoUseDoorOrButton(GO_POD_GAMMA);
if (uiData == DONE)
StartNextDialogueText(YELL_MELLICHAR_RELEASE5);
m_auiEncounter[uiType] = uiData;
break;
case TYPE_WARDEN_5:
if (uiData == IN_PROGRESS)
DoUseDoorOrButton(GO_POD_OMEGA);
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_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
void instance_stratholme::Update(uint32 uiDiff)
{
if (m_uiBarthilasRunTimer)
{
if (m_uiBarthilasRunTimer <= uiDiff)
{
Creature* pBarthilas = GetSingleCreatureFromStorage(NPC_BARTHILAS);
if (pBarthilas && pBarthilas->isAlive() && !pBarthilas->isInCombat())
pBarthilas->NearTeleportTo(aStratholmeLocation[1].m_fX, aStratholmeLocation[1].m_fY, aStratholmeLocation[1].m_fZ, aStratholmeLocation[1].m_fO);
SetData(TYPE_BARTHILAS_RUN, DONE);
m_uiBarthilasRunTimer = 0;
}
else
m_uiBarthilasRunTimer -= uiDiff;
}
if (m_uiBaronRunTimer)
{
if (m_uiYellCounter == 0 && m_uiBaronRunTimer <= 10*MINUTE*IN_MILLISECONDS)
{
DoOrSimulateScriptTextForThisInstance(SAY_ANNOUNCE_RUN_10_MIN, NPC_BARON);
++m_uiYellCounter;
}
else if (m_uiYellCounter == 1 && m_uiBaronRunTimer <= 5*MINUTE*IN_MILLISECONDS)
{
DoOrSimulateScriptTextForThisInstance(SAY_ANNOUNCE_RUN_5_MIN, NPC_BARON);
++m_uiYellCounter;
}
if (m_uiBaronRunTimer <= uiDiff)
{
SetData(TYPE_BARON_RUN, FAIL);
DoOrSimulateScriptTextForThisInstance(SAY_ANNOUNCE_RUN_FAIL, NPC_BARON);
m_uiBaronRunTimer = 0;
debug_log("SD2: Instance Stratholme: Baron run event reached end. Event has state %u.", GetData(TYPE_BARON_RUN));
}
else
m_uiBaronRunTimer -= uiDiff;
}
if (m_uiMindlessSummonTimer)
{
if (m_uiMindlessCount < 30)
{
if (m_uiMindlessSummonTimer <= uiDiff)
{
if (Creature* pBaron = GetSingleCreatureFromStorage(NPC_BARON))
{
// Summon mindless skeletons and move them to random point in the center of the square
if (Creature* pTemp = pBaron->SummonCreature(NPC_MINDLESS_UNDEAD, aStratholmeLocation[4].m_fX, aStratholmeLocation[4].m_fY, aStratholmeLocation[4].m_fZ, aStratholmeLocation[4].m_fO, TEMPSUMMON_DEAD_DESPAWN, 0))
{
float fX, fY, fZ;
pBaron->GetRandomPoint(aStratholmeLocation[5].m_fX, aStratholmeLocation[5].m_fY, aStratholmeLocation[5].m_fZ, 20.0f, fX, fY, fZ);
pTemp->GetMotionMaster()->MovePoint(0, fX, fY, fZ);
m_luiUndeadGUIDs.push_back(pTemp->GetObjectGuid());
++m_uiMindlessCount;
}
}
m_uiMindlessSummonTimer = 400;
}
else
m_uiMindlessSummonTimer -= uiDiff;
}
else
m_uiMindlessSummonTimer = 0;
}
if (m_uiSlaugtherSquareTimer)
{
if (m_uiSlaugtherSquareTimer <= uiDiff)
{
// Call next Abomnations
for (GUIDSet::const_iterator itr = m_sAbomnationGUID.begin(); itr != m_sAbomnationGUID.end(); ++itr)
{
Creature* pAbom = instance->GetCreature(*itr);
// Skip killed and already walking Abomnations
if (!pAbom || !pAbom->isAlive() || pAbom->GetMotionMaster()->GetCurrentMovementGeneratorType() == POINT_MOTION_TYPE)
continue;
// Let Move to somewhere in the middle
if (!pAbom->isInCombat())
{
if (GameObject* pDoor = GetSingleGameObjectFromStorage(GO_PORT_SLAUGTHER))
{
float fX, fY, fZ;
pAbom->GetRandomPoint(pDoor->GetPositionX(), pDoor->GetPositionY(), pDoor->GetPositionZ(), 10.0f, fX, fY, fZ);
pAbom->GetMotionMaster()->MovePoint(0, fX, fY, fZ);
}
}
break;
}
// TODO - how fast are they called?
m_uiSlaugtherSquareTimer = urand(15000, 30000);
}
else
m_uiSlaugtherSquareTimer -= uiDiff;
}
}
void instance_stratholme::DoSortZiggurats()
{
if (m_luiAcolyteGUIDs.empty())
return;
std::list<Creature*> lAcolytes; // Valid pointers, only used locally
for (GUIDList::const_iterator itr = m_luiAcolyteGUIDs.begin(); itr != m_luiAcolyteGUIDs.end(); ++itr)
{
if (Creature* pAcolyte = instance->GetCreature(*itr))
lAcolytes.push_back(pAcolyte);
}
m_luiAcolyteGUIDs.clear();
if (lAcolytes.empty())
return;
if (!GetSingleCreatureFromStorage(NPC_THUZADIN_ACOLYTE, true))
{
// Sort the acolytes by height, and the one with the biggest height is the announcer (a bit outside the map)
lAcolytes.sort(sortByHeight);
m_mNpcEntryGuidStore[NPC_THUZADIN_ACOLYTE] = (*lAcolytes.begin())->GetObjectGuid();
lAcolytes.erase(lAcolytes.begin());
}
// Sort Acolytes
for (std::list<Creature*>::iterator itr = lAcolytes.begin(); itr != lAcolytes.end(); )
{
bool bAlreadyIterated = false;
for (uint8 i = 0; i < MAX_ZIGGURATS; ++i)
{
if (GameObject* pZigguratDoor = instance->GetGameObject(m_zigguratStorage[i].m_doorGuid))
{
if ((*itr)->isAlive() && (*itr)->IsWithinDistInMap(pZigguratDoor, 35.0f, false))
{
m_zigguratStorage[i].m_lZigguratAcolyteGuid.push_back((*itr)->GetObjectGuid());
itr = lAcolytes.erase(itr);
bAlreadyIterated = true;
break;
}
}
}
if (itr != lAcolytes.end() && !bAlreadyIterated)
++itr;
}
// In case some mobs have not been able to be sorted, store their GUIDs again
for (std::list<Creature*>::const_iterator itr = lAcolytes.begin(); itr != lAcolytes.end(); ++itr)
m_luiAcolyteGUIDs.push_back((*itr)->GetObjectGuid());
// Sort Crystal
for (GUIDList::iterator itr = m_luiCrystalGUIDs.begin(); itr != m_luiCrystalGUIDs.end(); )
{
Creature* pCrystal = instance->GetCreature(*itr);
if (!pCrystal)
{
itr = m_luiCrystalGUIDs.erase(itr);
continue;
}
bool bAlreadyIterated = false;
for (uint8 i = 0; i < MAX_ZIGGURATS; ++i)
{
if (GameObject* pZigguratDoor = instance->GetGameObject(m_zigguratStorage[i].m_doorGuid))
{
if (pCrystal->IsWithinDistInMap(pZigguratDoor, 50.0f, false))
{
m_zigguratStorage[i].m_crystalGuid = pCrystal->GetObjectGuid();
itr = m_luiCrystalGUIDs.erase(itr);
bAlreadyIterated = true;
break;
}
}
}
if (itr != m_luiCrystalGUIDs.end() && !bAlreadyIterated)
++itr;
}
}
void instance_stratholme::SetData(uint32 uiType, uint32 uiData)
{
// TODO: Remove the hard-coded indexes from array accessing
switch(uiType)
{
case TYPE_BARON_RUN:
switch(uiData)
{
case IN_PROGRESS:
if (m_auiEncounter[uiType] == IN_PROGRESS || m_auiEncounter[uiType] == FAIL)
break;
DoOrSimulateScriptTextForThisInstance(SAY_ANNOUNCE_RUN_START, NPC_BARON);
m_uiBaronRunTimer = 45*MINUTE*IN_MILLISECONDS;
debug_log("SD2: 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:
m_uiBaronRunTimer = 0;
break;
}
m_auiEncounter[uiType] = uiData;
break;
case TYPE_BARONESS:
case TYPE_NERUB:
case TYPE_PALLID:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
{
DoSortZiggurats();
DoUseDoorOrButton(m_zigguratStorage[uiType - TYPE_BARONESS].m_doorGuid);
}
if (uiData == SPECIAL)
StartSlaugtherSquare();
break;
case TYPE_RAMSTEIN:
if (uiData == SPECIAL)
{
if (m_auiEncounter[uiType] != SPECIAL && m_auiEncounter[uiType] != DONE)
{
m_uiSlaugtherSquareTimer = 20000; // TODO - unknown, also possible that this is not the very correct place..
DoUseDoorOrButton(GO_PORT_GAUNTLET);
}
uint32 uiCount = m_sAbomnationGUID.size();
for(GUIDSet::iterator itr = m_sAbomnationGUID.begin(); itr != m_sAbomnationGUID.end();)
{
if (Creature* pAbom = instance->GetCreature(*itr))
{
++itr;
if (!pAbom->isAlive())
--uiCount;
}
else
{
// Remove obsolete guid from set and decrement count
m_sAbomnationGUID.erase(itr++);
--uiCount;
}
}
if (!uiCount)
{
// Old Comment: a bit itchy, it should close GO_ZIGGURAT_DOOR_4 door after 10 secs, but it doesn't. skipping it for now.
// However looks like that this door is no more closed
DoUseDoorOrButton(GO_ZIGGURAT_DOOR_4);
// No more handlng of Abomnations
m_uiSlaugtherSquareTimer = 0;
if (Creature* pBaron = GetSingleCreatureFromStorage(NPC_BARON))
{
DoScriptText(SAY_ANNOUNCE_RAMSTEIN, pBaron);
if (Creature* pRamstein = pBaron->SummonCreature(NPC_RAMSTEIN, aStratholmeLocation[2].m_fX, aStratholmeLocation[2].m_fY, aStratholmeLocation[2].m_fZ, aStratholmeLocation[2].m_fO, TEMPSUMMON_DEAD_DESPAWN, 0))
pRamstein->GetMotionMaster()->MovePoint(0, aStratholmeLocation[3].m_fX, aStratholmeLocation[3].m_fY, aStratholmeLocation[3].m_fZ);
debug_log("SD2: Instance Stratholme - Slaugther event: Ramstein spawned.");
}
}
else
debug_log("SD2: Instance Stratholme - Slaugther event: %u Abomnation left to kill.", uiCount);
}
// After fail aggroing Ramstein means wipe on Ramstein, so close door again
if (uiData == IN_PROGRESS && m_auiEncounter[uiType] == FAIL)
DoUseDoorOrButton(GO_PORT_GAUNTLET);
if (uiData == DONE)
{
// Open side gate and start summoning skeletons
DoUseDoorOrButton(GO_PORT_SLAUGHTER_GATE);
// use this timer as a bool just to start summoning
m_uiMindlessSummonTimer = 500;
m_uiMindlessCount = 0;
m_luiUndeadGUIDs.clear();
// Summon 5 guards
if (Creature* pBaron = GetSingleCreatureFromStorage(NPC_BARON))
{
for(uint8 i = 0; i < 5; ++i)
{
float fX, fY, fZ;
pBaron->GetRandomPoint(aStratholmeLocation[6].m_fX, aStratholmeLocation[6].m_fY, aStratholmeLocation[6].m_fZ, 5.0f, fX, fY, fZ);
if (Creature* pTemp = pBaron->SummonCreature(NPC_BLACK_GUARD, aStratholmeLocation[6].m_fX, aStratholmeLocation[6].m_fY, aStratholmeLocation[6].m_fZ, aStratholmeLocation[6].m_fO, TEMPSUMMON_DEAD_DESPAWN, 0))
m_luiGuardGUIDs.push_back(pTemp->GetObjectGuid());
}
debug_log("SD2: Instance Stratholme - Slaugther event: Summoned 5 guards.");
}
}
// Open Door again and stop Abomnation
if (uiData == FAIL && m_auiEncounter[uiType] != FAIL)
{
DoUseDoorOrButton(GO_PORT_GAUNTLET);
m_uiSlaugtherSquareTimer = 0;
// Let already moving Abomnations stop
for (GUIDSet::const_iterator itr = m_sAbomnationGUID.begin(); itr != m_sAbomnationGUID.end(); ++itr)
{
Creature* pAbom = instance->GetCreature(*itr);
if (pAbom && pAbom->GetMotionMaster()->GetCurrentMovementGeneratorType() == POINT_MOTION_TYPE)
pAbom->GetMotionMaster()->MovementExpired();
}
}
m_auiEncounter[uiType] = uiData;
break;
case TYPE_BARON:
if (uiData == IN_PROGRESS)
{
// Reached the Baron within time-limit
if (m_auiEncounter[TYPE_BARON_RUN] == IN_PROGRESS)
SetData(TYPE_BARON_RUN, DONE);
// Close Slaughterhouse door if needed
if (m_auiEncounter[uiType] == FAIL)
DoUseDoorOrButton(GO_PORT_GAUNTLET);
}
if (uiData == DONE)
{
if (m_auiEncounter[TYPE_BARON_RUN] == DONE)
{
Map::PlayerList const& players = instance->GetPlayers();
for(Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
if (Player* pPlayer = itr->getSource())
{
if (pPlayer->HasAura(SPELL_BARON_ULTIMATUM))
pPlayer->RemoveAurasDueToSpell(SPELL_BARON_ULTIMATUM);
if (pPlayer->GetQuestStatus(QUEST_DEAD_MAN_PLEA) == QUEST_STATUS_INCOMPLETE)
pPlayer->AreaExploredOrEventHappens(QUEST_DEAD_MAN_PLEA);
}
}
// Open cage and finish rescue event
if (Creature* pYsidaT = GetSingleCreatureFromStorage(NPC_YSIDA_TRIGGER))
{
if (Creature* pYsida = pYsidaT->SummonCreature(NPC_YSIDA, pYsidaT->GetPositionX(), pYsidaT->GetPositionY(), pYsidaT->GetPositionZ(), pYsidaT->GetOrientation(), TEMPSUMMON_TIMED_DESPAWN, 1800000))
{
DoScriptText(SAY_EPILOGUE, pYsida);
pYsida->GetMotionMaster()->MovePoint(0, aStratholmeLocation[7].m_fX, aStratholmeLocation[7].m_fY, aStratholmeLocation[7].m_fZ);
}
DoUseDoorOrButton(GO_YSIDA_CAGE);
}
}
// Open Slaughterhouse door again
DoUseDoorOrButton(GO_PORT_GAUNTLET);
}
if (uiData == FAIL)
DoUseDoorOrButton(GO_PORT_GAUNTLET);
m_auiEncounter[uiType] = uiData;
break;
case TYPE_BARTHILAS_RUN:
if (uiData == IN_PROGRESS)
{
Creature* pBarthilas = GetSingleCreatureFromStorage(NPC_BARTHILAS);
if (pBarthilas && pBarthilas->isAlive() && !pBarthilas->isInCombat())
{
DoScriptText(SAY_WARN_BARON, pBarthilas);
pBarthilas->SetWalk(false);
pBarthilas->GetMotionMaster()->MovePoint(0, aStratholmeLocation[0].m_fX, aStratholmeLocation[0].m_fY, aStratholmeLocation[0].m_fZ);
m_uiBarthilasRunTimer = 8000;
}
}
m_auiEncounter[uiType] = uiData;
break;
case TYPE_BLACK_GUARDS:
// Prevent double action
if (m_auiEncounter[uiType] == uiData)
return;
// Restart after failure, close Gauntlet
if (uiData == IN_PROGRESS && m_auiEncounter[uiType] == FAIL)
DoUseDoorOrButton(GO_PORT_GAUNTLET);
// Wipe case - open gauntlet
if (uiData == FAIL)
DoUseDoorOrButton(GO_PORT_GAUNTLET);
if (uiData == DONE)
{
if (Creature* pBaron = GetSingleCreatureFromStorage(NPC_BARON))
DoScriptText(SAY_UNDEAD_DEFEAT, pBaron);
DoUseDoorOrButton(GO_ZIGGURAT_DOOR_5);
}
m_auiEncounter[uiType] = uiData;
// No need to save anything here, so return
return;
case TYPE_SH_AELMAR:
m_bIsSilverHandDead[0] = (uiData) ? true : false;
break;
case TYPE_SH_CATHELA:
m_bIsSilverHandDead[1] = (uiData) ? true : false;
break;
case TYPE_SH_GREGOR:
m_bIsSilverHandDead[2] = (uiData) ? true : false;
break;
case TYPE_SH_NEMAS:
m_bIsSilverHandDead[3] = (uiData) ? true : false;
break;
case TYPE_SH_VICAR:
m_bIsSilverHandDead[4] = (uiData) ? true : false;
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_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
void instance_blackrock_depths::SetData(uint32 uiType, uint32 uiData)
{
switch (uiType)
{
case TYPE_RING_OF_LAW:
// If finished the arena event after theldren fight
if (uiData == DONE && m_auiEncounter[0] == SPECIAL)
DoRespawnGameObject(GO_ARENA_SPOILS, HOUR);
m_auiEncounter[0] = uiData;
break;
case TYPE_VAULT:
if (uiData == SPECIAL)
{
++m_uiCofferDoorsOpened;
if (m_uiCofferDoorsOpened == MAX_RELIC_DOORS)
{
SetData(TYPE_VAULT, IN_PROGRESS);
Creature* pConstruct = NULL;
// Activate vault constructs
for (GuidSet::const_iterator itr = m_sVaultNpcGuids.begin(); itr != m_sVaultNpcGuids.end(); ++itr)
{
pConstruct = instance->GetCreature(*itr);
if (pConstruct)
pConstruct->RemoveAurasDueToSpell(SPELL_STONED);
}
if (!pConstruct)
return;
// Summon doomgrip
pConstruct->SummonCreature(NPC_WATCHER_DOOMGRIP, aVaultPositions[0], aVaultPositions[1], aVaultPositions[2], aVaultPositions[3], TEMPSUMMON_DEAD_DESPAWN, 0);
}
// No need to store in this case
return;
}
if (uiData == DONE)
DoUseDoorOrButton(GO_SECRET_DOOR);
m_auiEncounter[1] = uiData;
break;
case TYPE_BAR:
if (uiData == SPECIAL)
++m_uiBarAleCount;
else
m_auiEncounter[2] = uiData;
break;
case TYPE_TOMB_OF_SEVEN:
// Don't set the same data twice
if (uiData == m_auiEncounter[3])
break;
// Combat door
DoUseDoorOrButton(GO_TOMB_ENTER);
// Start the event
if (uiData == IN_PROGRESS)
DoCallNextDwarf();
if (uiData == FAIL)
{
// Reset dwarfes
for (uint8 i = 0; i < MAX_DWARFS; ++i)
{
if (Creature* pDwarf = GetSingleCreatureFromStorage(aTombDwarfes[i]))
{
if (!pDwarf->isAlive())
pDwarf->Respawn();
}
}
m_uiDwarfRound = 0;
m_uiDwarfFightTimer = 0;
}
if (uiData == DONE)
{
DoRespawnGameObject(GO_CHEST_SEVEN, HOUR);
DoUseDoorOrButton(GO_TOMB_EXIT);
}
m_auiEncounter[3] = uiData;
break;
case TYPE_LYCEUM:
if (uiData == DONE)
{
DoUseDoorOrButton(GO_GOLEM_ROOM_N);
DoUseDoorOrButton(GO_GOLEM_ROOM_S);
}
m_auiEncounter[4] = uiData;
break;
case TYPE_IRON_HALL:
switch (uiData)
{
case IN_PROGRESS:
DoUseDoorOrButton(GO_GOLEM_ROOM_N);
DoUseDoorOrButton(GO_GOLEM_ROOM_S);
break;
case FAIL:
DoUseDoorOrButton(GO_GOLEM_ROOM_N);
DoUseDoorOrButton(GO_GOLEM_ROOM_S);
break;
case DONE:
DoUseDoorOrButton(GO_GOLEM_ROOM_N);
DoUseDoorOrButton(GO_GOLEM_ROOM_S);
DoUseDoorOrButton(GO_THRONE_ROOM);
break;
}
m_auiEncounter[5] = uiData;
break;
case TYPE_QUEST_JAIL_BREAK:
m_auiEncounter[6] = uiData;
return;
}
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_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
