void SetData(uint32 uiType, uint32 uiData)
{
switch(uiType)
{
case TYPE_QUEST:
m_auiEncounter[0] = uiData;
break;
case TYPE_CRATES_COUNT:
m_uiCratesCount = m_uiCratesCount + uiData;
if(m_uiCratesCount == 5)
{
m_auiEncounter[0] = DONE;
ChromiWhispers();
}
DoUpdateWorldState(WORLD_STATE_COS_CRATE_COUNT, m_uiCratesCount);
break;
case TYPE_INTRO:
m_auiEncounter[1] = uiData;
break;
case TYPE_PHASE:
m_auiEncounter[2] = uiData;
break;
case TYPE_ENCOUNTER:
m_auiEncounter[3] = uiData;
break;
case TYPE_WING:
m_auiEncounter[4] = uiData;
break;
case TYPE_BONUS:
m_auiEncounter[5] = uiData;
if(uiData == IN_PROGRESS)
{
if(Creature* Corruptor = GetSingleCreatureFromStorage(NPC_INFINITE_CORRUPTOR))
Corruptor->SetPhaseMask(1, true);
DoUpdateWorldState(WORLD_STATE_COS_TIME_ON, 1);
DoUpdateWorldState(WORLD_STATE_COS_TIME_COUNT, 25);
}
break;
case TYPE_MALGANIS:
m_auiEncounter[6] = uiData;
if (uiData == DONE)
{
DoRespawnGameObject(m_uiMalChestGUID, 30*MINUTE);
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_MALGANIS_CHEST))
pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_MALGANIS_CHEST_H))
pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
if (Creature* pChromi2 = GetSingleCreatureFromStorage(NPC_CHROMI02))
pChromi2->SetVisibility(VISIBILITY_OFF);
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_EXIT))
pGo->SetGoState(GO_STATE_ACTIVE);
}
break;
case TYPE_ZOMBIEFEST:
{
if(!m_bZombiefestInProgress)
m_bZombiefestInProgress = true;
}
}
}
void SetData(uint32 uiType, uint32 uiData)
{
if (uiType == TYPE_OMEN)
{
switch (uiData)
{
case NOT_STARTED:
// Count another rocket cluster launched
m_uiRocketsCounter++;
if (m_uiRocketsCounter < MAX_ROCKETS)
{
// 25% chance of spawning Minions of Omen (guessed), only if not already spawned (encounter is set to FAIL in that case)
if (GetData(TYPE_OMEN) == NOT_STARTED && urand(0, 1) < 1)
SetData(TYPE_OMEN, SPECIAL); // This will notify the GO to summon Omen's minions
}
// Set the event in motion and notify the GO to summon Omen
else if (GetData(TYPE_OMEN) != IN_PROGRESS && GetData(TYPE_OMEN) != DONE) // Check that Omen is not already spawned and event is reset
SetData(TYPE_OMEN, IN_PROGRESS);
return; // Don't store NOT_STARTED data unless explicitly told so: we use it to count rockets
case SPECIAL:
if (GameObject* pRocketCluster = GetSingleGameObjectFromStorage(GO_ROCKET_CLUSTER))
{
for (uint8 i = POS_IDX_MINION_OMEN_START ; i <= POS_IDX_MINION_OMEN_STOP ; i++)
pRocketCluster->SummonCreature(NPC_MINION_OMEN, aSpawnLocations[i][0], aSpawnLocations[i][1], aSpawnLocations[i][2], aSpawnLocations[i][3], TEMPSPAWN_TIMED_OOC_OR_DEAD_DESPAWN, 15 * MINUTE * IN_MILLISECONDS);
}
break;
case IN_PROGRESS:
if (GameObject* pRocketCluster = GetSingleGameObjectFromStorage(GO_ROCKET_CLUSTER))
{
if (Creature* pOmen = pRocketCluster->SummonCreature(NPC_OMEN, aSpawnLocations[POS_IDX_OMEN_SPAWN][0], aSpawnLocations[POS_IDX_OMEN_SPAWN][1], aSpawnLocations[POS_IDX_OMEN_SPAWN][2], aSpawnLocations[POS_IDX_OMEN_SPAWN][3], TEMPSPAWN_TIMED_OOC_OR_DEAD_DESPAWN, 15 * MINUTE * IN_MILLISECONDS))
{
// Moving him to the lake bank
pOmen->SetWalk(true);
pOmen->GetMotionMaster()->MovePoint(1, aSpawnLocations[POS_IDX_OMEN_MOVE][0], aSpawnLocations[POS_IDX_OMEN_MOVE][1], aSpawnLocations[POS_IDX_OMEN_MOVE][2]);
m_uiOmenResetTimer = 15 * MINUTE * IN_MILLISECONDS; // Reset after 15 minutes if not engaged or defeated
}
}
break;
case DONE:
m_uiOmenMoonlightTimer = 5 * IN_MILLISECONDS; // Timer before casting the end quest spell
m_uiOmenResetTimer = 5 * MINUTE * IN_MILLISECONDS; // Prevent another summoning of Omen for 5 minutes (based on spell duration)
break;
}
}
else if (uiType == TYPE_HIVE)
{
if (uiData == IN_PROGRESS)
m_uiDronesTimer = 5 * MINUTE * IN_MILLISECONDS;
}
m_encounter[uiType] = uiData;
}
void instance_razorfen_downs::OnCreatureDeath(Creature* pCreature)
{
// Only use this function if gong event is in progress
if (GetData(TYPE_TUTEN_KASH) != IN_PROGRESS)
return;
switch (pCreature->GetEntry())
{
case NPC_TOMB_FIEND:
case NPC_TOMB_REAVER:
m_lSpawnedMobsList.remove(pCreature->GetObjectGuid());
// No more wave-mobs around, enable the gong for the next wave
if (m_lSpawnedMobsList.empty())
{
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_GONG))
{
pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NO_INTERACT);
// Workaround - GO need to be respawned - requires core fix, GO shouldn't despawn in the first place
pGo->Respawn();
}
}
break;
case NPC_TUTEN_KASH:
SetData(TYPE_TUTEN_KASH, DONE);
break;
}
}
// Right is right side from gothik (eastern)
bool instance_naxxramas::IsInRightSideGothArea(Unit* pUnit)
{
if (GameObject* pCombatGate = GetSingleGameObjectFromStorage(GO_MILI_GOTH_COMBAT_GATE))
return (pCombatGate->GetPositionY() >= pUnit->GetPositionY());
error_log("SSC: left/right side check, Gothik combat area failed.");
return true;
}
// Used in order to unlock the door to Vezax
void instance_ulduar::DoOpenMadnessDoorIfCan()
{
if (m_auiEncounter[TYPE_MIMIRON] == DONE && m_auiEncounter[TYPE_HODIR] == DONE && m_auiEncounter[TYPE_THORIM] == DONE && m_auiEncounter[TYPE_FREYA] == DONE)
{
if (GameObject* pDoor = GetSingleGameObjectFromStorage(GO_ANCIENT_GATE))
pDoor->SetGoState(GO_STATE_ACTIVE);
}
}
void instance_molten_core::SetData(uint32 uiType, uint32 uiData)
{
switch (uiType)
{
case TYPE_LUCIFRON:
m_auiEncounter[uiType] = uiData;
break;
case TYPE_MAGMADAR:
case TYPE_GEHENNAS:
case TYPE_GARR:
case TYPE_SHAZZRAH:
case TYPE_GEDDON:
case TYPE_GOLEMAGG:
case TYPE_SULFURON:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
{
for (auto m_aMoltenCoreRune : m_aMoltenCoreRunes)
{
if (m_aMoltenCoreRune.m_uiType == uiType)
{
if (GameObject* pGo = GetSingleGameObjectFromStorage(m_aMoltenCoreRune.m_uiFlamesCircleEntry))
pGo->SetLootState(GO_JUST_DEACTIVATED);
break;
}
}
}
break;
case TYPE_MAJORDOMO:
m_auiEncounter[uiType] = uiData;
if (uiData == DONE)
DoRespawnGameObject(GO_CACHE_OF_THE_FIRE_LORD, HOUR);
break;
case TYPE_RAGNAROS:
m_auiEncounter[uiType] = uiData;
break;
}
// Check if Majordomo can be summoned
if (uiData == SPECIAL)
DoSpawnMajordomoIfCan(false);
if (uiData == DONE || uiData == SPECIAL)
{
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_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
void instance_gundrak::DoAltarVisualEffect(uint8 uiType)
{
// Sort the lists if not yet done
if (!m_luiStalkerGUIDs.empty())
{
float fHeight = 10.0f; // A bit higher than the altar is needed
if (GameObject* pCollusAltar = GetSingleGameObjectFromStorage(GO_ALTAR_OF_COLOSSUS))
fHeight += pCollusAltar->GetPositionZ();
std::list<Creature*> lStalkerTargets, lStalkerCasters;
for (GuidList::const_iterator itr = m_luiStalkerGUIDs.begin(); itr != m_luiStalkerGUIDs.end(); ++itr)
{
if (Creature* pStalker = instance->GetCreature(*itr))
{
if (pStalker->GetPositionZ() > fHeight)
lStalkerTargets.push_back(pStalker);
else
lStalkerCasters.push_back(pStalker);
}
}
m_luiStalkerGUIDs.clear();
lStalkerTargets.sort(sortFromEastToWest);
lStalkerCasters.sort(sortFromEastToWest);
for (std::list<Creature*>::const_iterator itr = lStalkerTargets.begin(); itr != lStalkerTargets.end(); ++itr)
m_vStalkerTargetGuids.push_back((*itr)->GetObjectGuid());
for (std::list<Creature*>::const_iterator itr = lStalkerCasters.begin(); itr != lStalkerCasters.end(); ++itr)
m_vStalkerCasterGuids.push_back((*itr)->GetObjectGuid());
}
// Verify that the DB has enough trigger spawned
if (m_vStalkerTargetGuids.size() < 3 || m_vStalkerCasterGuids.size() < 3)
return;
// Get the Index from the bosses
uint8 uiIndex = 0;
switch (uiType)
{
case TYPE_SLADRAN: uiIndex = 0; break;
case TYPE_COLOSSUS: uiIndex = 1; break;
case TYPE_MOORABI: uiIndex = 2; break;
default:
return;
}
Creature* pTarget = instance->GetCreature(m_vStalkerTargetGuids[uiIndex]);
Creature* pCaster = instance->GetCreature(m_vStalkerCasterGuids[uiIndex]);
if (!pTarget || !pCaster)
return;
uint32 auiFireBeamSpells[3] = {SPELL_BEAM_SNAKE, SPELL_BEAM_ELEMENTAL, SPELL_BEAM_MAMMOTH};
// Cast from Caster to Target
pCaster->CastSpell(pTarget, auiFireBeamSpells[uiIndex], TRIGGERED_NONE);
}
void instance_blackwing_lair::SetData64(uint32 uiData, uint64 uiGuid)
{
if (uiData == DATA_DRAGON_EGG)
{
if (GameObject* pEgg = instance->GetGameObject(ObjectGuid(uiGuid)))
m_lUsedEggsGuids.push_back(pEgg->GetObjectGuid());
// If all eggs are destroyed, then allow Razorgore to be attacked
if (m_lUsedEggsGuids.size() == m_lDragonEggsGuids.size())
{
SetData(TYPE_RAZORGORE, SPECIAL);
if (GameObject* Orb = GetSingleGameObjectFromStorage(GO_ORB_OF_DOMINATION))
Orb->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NO_INTERACT);
if (Creature* pTrigger = GetSingleCreatureFromStorage(NPC_NEFARIANS_TROOPS))
{
DoScriptText(EMOTE_ORB_SHUT_OFF, pTrigger);
DoScriptText(EMOTE_TROOPS_FLEE, pTrigger);
}
for (GuidList::const_iterator itr = m_lDefendersGuids.begin(); itr != m_lDefendersGuids.end(); ++itr)
{
if (Creature* pDefender = instance->GetCreature(*itr))
{
pDefender->SetFlag(UNIT_NPC_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_PASSIVE);
pDefender->setFaction(35);
pDefender->DeleteThreatList();
pDefender->CombatStop();
pDefender->SetCanAttackPlayer(false);
pDefender->AI()->EnterEvadeMode();
pDefender->ForcedDespawn(15000);
}
}
if (Creature* pRazorgore = GetSingleCreatureFromStorage(NPC_RAZORGORE))
{
pRazorgore->SetHealthPercent(100.0f);
if (Unit* pController = pRazorgore->GetCharmerOrOwner())
{
pController->CastStop();
pController->RemoveAurasDueToSpell(SPELL_MIND_EXHAUSTION);
pController->RemoveAurasDueToSpell(SPELL_USE_DRAGON_ORB);
pRazorgore->RemoveAurasDueToSpell(SPELL_USE_DRAGON_ORB);
pRazorgore->AI()->AttackStart(pController);
pRazorgore->TauntApply(pController);
pRazorgore->SetFloatValue(OBJECT_FIELD_SCALE_X, 2.20f);
}
}
m_lDefendersGuids.clear();
}
else
debug_log("BWL: Black Dragon Eggs left to destroy: %u", m_lDragonEggsGuids.size());
}
}
void instance_ulduar::CloseDoor(uint32 uiEntry)
{
if(!uiEntry)
return;
GameObject* pGo = GetSingleGameObjectFromStorage(uiEntry);
if(pGo)
pGo->SetGoState(GO_STATE_READY);
}
void instance_sethekk_halls::FinishAnzuIntro()
{
Creature* target = GetSingleCreatureFromStorage(NPC_INVIS_RAVEN_GOD_TARGET, true);
target->SummonCreature(NPC_ANZU, -89.20406f, 287.9736f, 26.5665f, 3.001966f, TEMPSPAWN_MANUAL_DESPAWN, 0);
static_cast<TemporarySpawn*>(target)->UnSummon();
GuidVector casterVector;
GetCreatureGuidVectorFromStorage(NPC_INVIS_RAVEN_GOD_CASTER, casterVector);
for (ObjectGuid guid : casterVector)
if (Creature* caster = instance->GetCreature(guid))
static_cast<TemporarySpawn*>(caster)->UnSummon();
Creature* portal = GetSingleCreatureFromStorage(NPC_INVIS_RAVEN_GOD_PORTAL, true);
static_cast<TemporarySpawn*>(portal)->UnSummon();
GameObject* ravensClaw = GetSingleGameObjectFromStorage(GO_RAVENS_CLAW);
ravensClaw->SetRespawnTime(7 * DAY);
ravensClaw->SetLootState(GO_JUST_DEACTIVATED);
GameObject* moonstone = GetSingleGameObjectFromStorage(GO_MOONSTONE);
moonstone->SetLootState(GO_JUST_DEACTIVATED);
GameObject* testRift = GetSingleGameObjectFromStorage(GO_TEST_RIFT);
testRift->SetLootState(GO_JUST_DEACTIVATED);
}
void instance_maraudon::SetData(uint32 type, uint32 data)
{
if (type == TYPE_NOXXION)
{
// Do nothing if we are receiving the same data
if (m_encounter[TYPE_NOXXION] == data)
return;
m_encounter[type] = data;
switch (data)
{
// If Noxxion encounter is done or spewer attacked, stop spewing larvas
case DONE:
// Destroy the corruption spewer near Noxxion
if (GameObject* go = GetSingleGameObjectFromStorage(GO_CORRUPTION_SPEWER))
go->SetLootState(GO_ACTIVATED);
// no break, the special part is also executed
case SPECIAL:
m_spewLarvaTimer = 0;
// Destroy the larva spewer if not already done
if (GameObject* go = GetSingleGameObjectFromStorage(GO_LARVA_SPEWER))
{
if (go->getLootState() != GO_ACTIVATED)
go->SetLootState(GO_ACTIVATED);
}
}
}
if (data == DONE)
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << m_encounter[0];
m_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
void instance_icecrown_citadel::Update(uint32 uiDiff)
{
DialogueUpdate(uiDiff);
if (m_uiPutricideValveTimer)
{
if (m_uiPutricideValveTimer <= uiDiff)
{
// Open the pathway to Putricide when the timer expires
DoUseDoorOrButton(GO_SCIENTIST_DOOR_COLLISION);
if (GameObject* pDoor = GetSingleGameObjectFromStorage(GO_SCIENTIST_DOOR_GREEN))
pDoor->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
if (GameObject* pDoor = GetSingleGameObjectFromStorage(GO_SCIENTIST_DOOR_ORANGE))
pDoor->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
m_uiPutricideValveTimer = 0;
}
else
m_uiPutricideValveTimer -= uiDiff;
}
}
void instance_the_eye::SetData(uint32 uiType, uint32 uiData)
{
switch (uiType)
{
case TYPE_ALAR:
case TYPE_SOLARIAN:
case TYPE_VOIDREAVER:
m_auiEncounter[uiType] = uiData;
break;
case TYPE_KAELTHAS:
// Don't set the same data twice
if (m_auiEncounter[uiType] == uiData)
break;
DoUseDoorOrButton(GO_ARCANE_DOOR_HORIZ_3);
DoUseDoorOrButton(GO_ARCANE_DOOR_HORIZ_4);
if (uiData == FAIL)
{
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_KAEL_STATUE_LEFT))
pGo->ResetDoorOrButton();
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_KAEL_STATUE_RIGHT))
pGo->ResetDoorOrButton();
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_BRIDGE_WINDOW))
pGo->ResetDoorOrButton();
// Respawn or reset the advisors
for (uint8 i = 0; i < MAX_ADVISORS; ++i)
{
if (Creature* pTemp = GetSingleCreatureFromStorage(aAdvisors[i]))
{
if (!pTemp->isAlive())
pTemp->Respawn();
else
pTemp->AI()->EnterEvadeMode();
}
}
}
m_auiEncounter[uiType] = uiData;
break;
}
}
void instance_deadmines::Update(uint32 uiDiff)
{
if (m_uiIronDoorTimer)
{
if (m_uiIronDoorTimer <= uiDiff)
{
if (Creature* pMrSmite = GetSingleCreatureFromStorage(NPC_MR_SMITE))
{
switch(m_uiDoorStep)
{
case 0:
DoScriptText(INST_SAY_ALARM1,pMrSmite);
m_uiIronDoorTimer = 2000;
++m_uiDoorStep;
break;
case 1:
{
if (GameObject* pDoor = GetSingleGameObjectFromStorage(GO_IRON_CLAD_DOOR))
{
// should be static spawns, fetch the closest ones at the pier
if (Creature* pi1 = GetClosestCreatureWithEntry(pDoor, NPC_PIRATE, 40.0f))
{
pi1->RemoveSplineFlag(SPLINEFLAG_WALKMODE);
pi1->GetMotionMaster()->MovePoint(0, pDoor->GetPositionX(), pDoor->GetPositionY(), pDoor->GetPositionZ());
}
if (Creature* pi2 = GetClosestCreatureWithEntry(pDoor, NPC_SQUALLSHAPER, 40.0f))
{
pi2->RemoveSplineFlag(SPLINEFLAG_WALKMODE);
pi2->GetMotionMaster()->MovePoint(0, pDoor->GetPositionX(), pDoor->GetPositionY(), pDoor->GetPositionZ());
}
}
++m_uiDoorStep;
m_uiIronDoorTimer = 10000;
break;
}
case 2:
DoScriptText(INST_SAY_ALARM2,pMrSmite);
m_uiDoorStep = 0;
m_uiIronDoorTimer = 0;
debug_log("SD2: Instance Deadmines: Iron door event reached end.");
break;
}
}
else
m_uiIronDoorTimer = 0;
}
else
m_uiIronDoorTimer -= uiDiff;
}
}
void instance_deadmines::Update(uint32 uiDiff)
{
if (m_uiIronDoorTimer)
{
if (m_uiIronDoorTimer <= uiDiff)
{
switch (m_uiDoorStep)
{
case 0:
DoUseDoorOrButton(GO_IRON_CLAD_DOOR, 0, true);
if (Creature* pMrSmite = GetSingleCreatureFromStorage(NPC_MR_SMITE))
{
DoScriptText(INST_SAY_ALARM1, pMrSmite);
}
if (GameObject* pDoor = GetSingleGameObjectFromStorage(GO_IRON_CLAD_DOOR))
{
// should be static spawns, fetch the closest ones at the pier
if (Creature* pi1 = GetClosestCreatureWithEntry(pDoor, NPC_PIRATE, 40.0f))
{
pi1->SetWalk(false);
pi1->GetMotionMaster()->MovePoint(0, pDoor->GetPositionX(), pDoor->GetPositionY(), pDoor->GetPositionZ());
}
if (Creature* pi2 = GetClosestCreatureWithEntry(pDoor, NPC_SQUALLSHAPER, 40.0f))
{
pi2->SetWalk(false);
pi2->GetMotionMaster()->MovePoint(0, pDoor->GetPositionX(), pDoor->GetPositionY(), pDoor->GetPositionZ());
}
}
++m_uiDoorStep;
m_uiIronDoorTimer = 15000;
break;
case 1:
if (Creature* pMrSmite = GetSingleCreatureFromStorage(NPC_MR_SMITE))
{
DoScriptText(INST_SAY_ALARM2, pMrSmite);
}
m_uiDoorStep = 0;
m_uiIronDoorTimer = 0;
break;
}
}
else
{
m_uiIronDoorTimer -= uiDiff;
}
}
}
void instance_sethekk_halls::StartAnzuIntro(Player* player)
{
Creature* target = player->SummonCreature(NPC_INVIS_RAVEN_GOD_TARGET, -87.08602f, 287.8433f, 28.386f, 3.455752f, TEMPSPAWN_MANUAL_DESPAWN, 0, true);
target->CastSpell(nullptr, SPELL_PURPLE_BANISH_STATE, TRIGGERED_NONE);
Creature* portal = player->SummonCreature(NPC_INVIS_RAVEN_GOD_PORTAL, -87.28478f, 287.6349f, 27.17761f, 0.5759587f, TEMPSPAWN_MANUAL_DESPAWN, 0, true);
portal->CastSpell(nullptr, SPELL_OTHERWORLDLY_PORTAL, TRIGGERED_NONE);
for (uint32 i = 0; i < TRIGGER_COUNT; ++i)
{
Creature* caster = player->SummonCreature(NPC_INVIS_RAVEN_GOD_CASTER, triggerPositions[i][0], triggerPositions[i][1], triggerPositions[i][2], triggerPositions[i][3], TEMPSPAWN_MANUAL_DESPAWN, 0, true);
caster->CastSpell(nullptr, SPELL_RAVEN_GOD_SUMMON_BEAMS, TRIGGERED_NONE);
}
GameObject* moonstone = GetSingleGameObjectFromStorage(GO_MOONSTONE);
moonstone->SetLootState(GO_READY);
moonstone->SetRespawnTime(2 * MINUTE * IN_MILLISECONDS);
moonstone->Refresh();
GameObject* testRift = GetSingleGameObjectFromStorage(GO_TEST_RIFT);
testRift->SetLootState(GO_READY);
testRift->SetRespawnTime(2 * MINUTE * IN_MILLISECONDS);
testRift->Refresh();
m_anzuTimer = 6000;
m_anzuStage = 0;
}
void instance_halls_of_lightning::SetData(uint32 uiType, uint32 uiData)
{
switch (uiType)
{
case TYPE_BJARNGRIM:
if (uiData == SPECIAL)
m_bLightningStruck = true;
else if (uiData == FAIL)
m_bLightningStruck = false;
m_auiEncounter[uiType] = uiData;
break;
case TYPE_VOLKHAN:
if (uiData == DONE)
DoUseDoorOrButton(GO_VOLKHAN_DOOR);
else if (uiData == IN_PROGRESS)
m_bIsShatterResistant = true;
else if (uiData == SPECIAL)
m_bIsShatterResistant = false;
m_auiEncounter[uiType] = uiData;
break;
case TYPE_IONAR:
if (uiData == DONE)
DoUseDoorOrButton(GO_IONAR_DOOR);
m_auiEncounter[uiType] = uiData;
break;
case TYPE_LOKEN:
if (uiData == IN_PROGRESS)
DoStartTimedAchievement(ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE, ACHIEV_START_LOKEN_ID);
else if (uiData == DONE)
{
// Appears to be type 5 GO with animation. Need to figure out how this work, code below only placeholder
if (GameObject* pGlobe = GetSingleGameObjectFromStorage(GO_LOKEN_THRONE))
pGlobe->SetGoState(GO_STATE_ACTIVE);
}
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_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
void instance_baradin_hold::SetData(uint32 uiType, uint32 uiData)
{
switch (uiType)
{
case TYPE_ARGALOTH:
m_auiEncounter[uiType] = uiData;
if (GameObject* go = GetSingleGameObjectFromStorage(GO_DOOR_ARGALOTH))
go->SetGoState(uiData == IN_PROGRESS ? GO_STATE_READY : GO_STATE_ACTIVE);
break;
case TYPE_OCCUTHAR:
m_auiEncounter[uiType] = uiData;
if (GameObject* go = GetSingleGameObjectFromStorage(GO_DOOR_OCCUTHAR))
go->SetGoState(uiData == IN_PROGRESS ? GO_STATE_READY : GO_STATE_ACTIVE);
break;
case TYPE_ALIZABAL:
m_auiEncounter[uiType] = uiData;
if (GameObject* go = GetSingleGameObjectFromStorage(GO_DOOR_ALIZABAL))
go->SetGoState(uiData == IN_PROGRESS ? GO_STATE_READY : GO_STATE_ACTIVE);
break;
default:
return;
}
if (uiData == DONE)
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << m_auiEncounter[0] << " " << m_auiEncounter[1] << " " << m_auiEncounter[2];
m_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
void instance_blackwing_lair::OnObjectUse(GameObject* pGo)
{
switch(pGo->GetEntry())
{
case GO_CHROMAGGUS_LEVER:
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_PORTCULLIS_CHROMAGGUS))
{
pGo->SetGoState(GO_STATE_ACTIVE);
m_uiChromaggusPullTimer = 2000;
}
break;
default:
break;
}
}
void SetData(uint32 uiType, uint32 uiData)
{
switch(uiType)
{
case TYPE_MALYGOS:
{
if (uiData == NOT_STARTED)
{
if (GameObject* pFocusingIris = GetSingleGameObjectFromStorage(m_uiFocusingIrisActualEntry))
{
pFocusingIris->SetGoState(GO_STATE_READY);
pFocusingIris->SetPhaseMask(1, true);
}
if (GameObject* pExitPortal = GetSingleGameObjectFromStorage(GO_EXIT_PORTAL))
pExitPortal->SetPhaseMask(1, true);
if (GameObject* pPlatform = GetSingleGameObjectFromStorage(GO_PLATFORM))
pPlatform->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_DESTROYED);
}
if (uiData == IN_PROGRESS)
{
if (GameObject* pFocusingIris = GetSingleGameObjectFromStorage(m_uiFocusingIrisActualEntry))
pFocusingIris->SetPhaseMask(2, true);
if (GameObject* pExitPortal = GetSingleGameObjectFromStorage(GO_EXIT_PORTAL))
pExitPortal->SetPhaseMask(2, true);
}
if (uiData == DONE)
{
if (GameObject* pExitPortal = GetSingleGameObjectFromStorage(GO_EXIT_PORTAL))
pExitPortal->SetPhaseMask(1, true);
DoRespawnGameObject(m_uiGiftActualGuid, HOUR*IN_MILLISECONDS);
DoRespawnGameObject(m_uiHeartActualGuid, HOUR*IN_MILLISECONDS);
//hack to make loot accessible
if (GameObject* pPlatform = GetSingleGameObjectFromStorage(GO_PLATFORM))
{
pPlatform->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_DESTROYED);
pPlatform->Respawn();
}
}
m_auiEncounter[0] = uiData;
break;
}
}
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << m_auiEncounter[0];
strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
void instance_maraudon::Update(uint32 uiDiff)
{
// Nicely spew a larva that will go toward Noxxion (pathing is handled by DB)
if (m_spewLarvaTimer)
{
if (m_spewLarvaTimer <= uiDiff)
{
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_LARVA_SPEWER))
pGo->SummonCreature(NPC_SPEWED_LARVA, spawnLocation.m_fX, spawnLocation.m_fY, spawnLocation.m_fZ, spawnLocation.m_fO, TEMPSPAWN_TIMED_DESPAWN, 10 * MINUTE * IN_MILLISECONDS); // Despawn is handled by DBScript we just want to avoid an infinite number of larvas near Noxxion
m_spewLarvaTimer = 1 * MINUTE * IN_MILLISECONDS;
}
else
m_spewLarvaTimer -= uiDiff;
}
}
void SetData(uint32 uiType, uint32 uiData)
{
switch(uiType)
{
case TYPE_KRIKTHIR:
m_auiEncounter[0] = uiData;
if (uiData == DONE)
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_DOOR_KRIKTHIR))
pGo->SetGoState(GO_STATE_ACTIVE);
break;
case TYPE_HADRONOX:
m_auiEncounter[1] = uiData;
break;
case TYPE_ANUBARAK:
m_auiEncounter[2] = uiData;
if (uiData == DONE || uiData == NOT_STARTED)
{
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_DOOR_ANUBARAK_1))
pGo->SetGoState(GO_STATE_ACTIVE);
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_DOOR_ANUBARAK_2))
pGo->SetGoState(GO_STATE_ACTIVE);
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_DOOR_ANUBARAK_3))
pGo->SetGoState(GO_STATE_ACTIVE);
}
if (uiData == IN_PROGRESS)
{
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_DOOR_ANUBARAK_1))
pGo->SetGoState(GO_STATE_READY);
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_DOOR_ANUBARAK_2))
pGo->SetGoState(GO_STATE_READY);
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_DOOR_ANUBARAK_3))
pGo->SetGoState(GO_STATE_READY);
}
break;
}
if (uiData == DONE)
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << m_auiEncounter[0] << " " << m_auiEncounter[1] << " " << m_auiEncounter[2];
strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
void instance_deadmines::SetData(uint32 uiType, uint32 uiData)
{
switch(uiType)
{
case TYPE_RHAHKZOR:
{
if (uiData == DONE)
DoUseDoorOrButton(GO_FACTORY_DOOR);
m_auiEncounter[1] = uiData;
break;
}
case TYPE_SNEED:
{
if (uiData == DONE)
DoUseDoorOrButton(GO_MAST_ROOM_DOOR);
m_auiEncounter[2] = uiData;
break;
}
case TYPE_GILNID:
{
if (uiData == DONE)
DoUseDoorOrButton(GO_FOUNDRY_DOOR);
m_auiEncounter[3] = uiData;
break;
}
case TYPE_DEFIAS_ENDDOOR:
{
if (uiData == IN_PROGRESS)
{
if (GameObject* pGo = GetSingleGameObjectFromStorage(GO_IRON_CLAD_DOOR))
{
pGo->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
m_uiIronDoorTimer = 3000;
}
}
m_auiEncounter[0] = uiData;
break;
}
}
}
void instance_blackrock_spire::DoSendNextFlamewreathWave()
{
GameObject* pSummoner = GetSingleGameObjectFromStorage(GO_FATHER_FLAME);
if (!pSummoner)
return;
// TODO - The npcs would move nicer if they had DB waypoints, so i suggest to change their default movement to DB waypoints, and random movement when they reached their goal
if (m_uiFlamewreathWaveCount < 6) // Send two adds (6 waves, then boss)
{
Creature* pSummoned = NULL;
for (uint8 i = 0; i < 2; ++i)
{
float fX, fY, fZ;
pSummoner->GetRandomPoint(rookeryEventSpawnPos[0], rookeryEventSpawnPos[1], rookeryEventSpawnPos[2], 2.5f, fX, fY, fZ);
// Summon Rookery Hatchers in first wave, else random
if (pSummoned = pSummoner->SummonCreature(urand(0, 1) && m_uiFlamewreathWaveCount ? NPC_ROOKERY_GUARDIAN : NPC_ROOKERY_HATCHER,
fX, fY, fZ, 0.0, TEMPSUMMON_TIMED_OOC_OR_DEAD_DESPAWN, 300000))
{
pSummoner->GetContactPoint(pSummoned, fX, fY, fZ);
pSummoned->GetMotionMaster()->MovePoint(1, fX, fY, pSummoner->GetPositionZ());
}
}
if (pSummoned && m_uiFlamewreathWaveCount == 0)
DoScriptText(SAY_ROOKERY_EVENT_START, pSummoned);
if (m_uiFlamewreathWaveCount < 4)
m_uiFlamewreathEventTimer = 30000;
else if (m_uiFlamewreathWaveCount < 6)
m_uiFlamewreathEventTimer = 40000;
else
m_uiFlamewreathEventTimer = 10000;
++m_uiFlamewreathWaveCount;
}
else // Send Flamewreath
{
if (Creature* pSolakar = pSummoner->SummonCreature(NPC_SOLAKAR_FLAMEWREATH, rookeryEventSpawnPos[0], rookeryEventSpawnPos[1], rookeryEventSpawnPos[2], 0.0f, TEMPSUMMON_TIMED_OOC_OR_DEAD_DESPAWN, HOUR * IN_MILLISECONDS))
pSolakar->GetMotionMaster()->MovePoint(1, pSummoner->GetPositionX(), pSummoner->GetPositionY(), pSummoner->GetPositionZ());
SetData(TYPE_FLAMEWREATH, SPECIAL);
m_uiFlamewreathEventTimer = 0;
}
}
void instance_icecrown_spire::OpenAllDoors()
{
if (m_auiEncounter[1] == DONE)
{
DoOpenDoor(GO_ICEWALL_1);
DoOpenDoor(GO_ICEWALL_2);
DoOpenDoor(GO_MARROWGAR_DOOR);
DoOpenDoor(GO_ORATORY_DOOR);
};
if (m_auiEncounter[2] == DONE)
{
if (GameObject* pGO = GetSingleGameObjectFromStorage(GO_DEATHWHISPER_ELEVATOR))
{
pGO->SetUInt32Value(GAMEOBJECT_LEVEL, 0);
pGO->SetGoState(GO_STATE_READY);
}
};
if (m_auiEncounter[4] == DONE)
{
//DoOpenDoor(GO_SAURFANG_DOOR);
DoOpenDoor(GO_BLOODWING_DOOR);
DoOpenDoor(GO_FROSTWING_DOOR);
};
if (m_auiEncounter[5] == DONE)
DoOpenDoor(GO_SCIENTIST_DOOR_ORANGE);
if (m_auiEncounter[6] == DONE)
DoOpenDoor(GO_SCIENTIST_DOOR_GREEN);
if (m_auiEncounter[6] == DONE && m_auiEncounter[5] == DONE)
DoOpenDoor(GO_SCIENTIST_DOOR_COLLISION);
if (m_auiEncounter[8] == DONE)
{
DoOpenDoor(GO_COUNCIL_DOOR_1);
DoOpenDoor(GO_COUNCIL_DOOR_2);
};
if (m_auiEncounter[10] == DONE)
{
DoOpenDoor(GO_GREEN_DRAGON_DOOR_2);
DoOpenDoor(GO_SINDRAGOSA_DOOR_1);
DoOpenDoor(GO_SINDRAGOSA_DOOR_2);
};
}
void instance_sethekk_halls::SetData(uint32 uiType, uint32 uiData)
{
switch (uiType)
{
case TYPE_SYTH:
m_auiEncounter[uiType] = uiData;
break;
case TYPE_ANZU:
m_auiEncounter[uiType] = uiData;
// Respawn the Raven's Claw if event fails
if (uiData == FAIL)
{
if (GameObject* pClaw = GetSingleGameObjectFromStorage(GO_RAVENS_CLAW))
pClaw->Respawn();
}
break;
case TYPE_IKISS:
if (uiData == DONE)
{
DoUseDoorOrButton(GO_IKISS_DOOR, DAY);
DoToggleGameObjectFlags(GO_IKISS_CHEST, GO_FLAG_NO_INTERACT | GO_FLAG_INTERACT_COND, false);
}
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_strInstData = saveStream.str();
SaveToDB();
OUT_SAVE_INST_DATA_COMPLETE;
}
}
void instance_eye_of_eternity::JustDidDialogueStep(int32 iEntry)
{
switch (iEntry)
{
case SPELL_ALEXSTRASZAS_GIFT_BEAM:
if (Creature* pAlextrasza = GetSingleCreatureFromStorage(NPC_ALEXSTRASZA))
pAlextrasza->CastSpell(pAlextrasza, SPELL_ALEXSTRASZAS_GIFT_BEAM, TRIGGERED_NONE);
break;
case NPC_ALEXSTRASZAS_GIFT:
if (Creature* pGift = GetSingleCreatureFromStorage(NPC_ALEXSTRASZAS_GIFT))
pGift->CastSpell(pGift, SPELL_ALEXSTRASZAS_GIFT_VISUAL, TRIGGERED_NONE);
DoRespawnGameObject(instance->IsRegularDifficulty() ? GO_ALEXSTRASZAS_GIFT : GO_ALEXSTRASZAS_GIFT_H, 30 * MINUTE);
break;
case GO_PLATFORM:
// ToDo: respawn the portal
if (GameObject* pPlatform = GetSingleGameObjectFromStorage(GO_PLATFORM))
pPlatform->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK_11);
// Spawn the Heart of Malygos
DoRespawnGameObject(instance->IsRegularDifficulty() ? GO_HEART_OF_MAGIC : GO_HEART_OF_MAGIC_H, 30 * MINUTE);
break;
}
}
void instance_blackwing_lair::OnCreatureDeath(Creature* pCreature)
{
if (pCreature->GetEntry() == NPC_GRETHOK_THE_CONTROLLER)
{
if (GameObject* Orb = GetSingleGameObjectFromStorage(GO_ORB_OF_DOMINATION))
Orb->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NO_INTERACT);
m_uiGrethokManager = true;
}
switch (pCreature->GetEntry())
{
case NPC_BLACKWING_LEGIONNAIRE:
case NPC_BLACKWING_MAGE:
--m_uiOrcSummoned;
break;
case NPC_DEATH_TALON_DRAGONSPAWN:
--m_uiDragonkinSummoned;
break;
case NPC_BLUE_DRAGON:
case NPC_BRONZE_DRAGON:
case NPC_RED_DRAGON:
case NPC_GREEN_DRAGON:
pCreature->SetRespawnTime(20);
pCreature->SaveRespawnTime();
break;
case NPC_DRAGONKIN_LASH:
case NPC_PRIEST_LASH:
pCreature->SetRespawnTime(1200);
pCreature->SaveRespawnTime();
break;
case NPC_BLACKWING_GUARDSMAN:
m_uiGuardsmanManager = true;
break;
}
void instance_eye_of_eternity::SetData(uint32 uiType, uint32 uiData)
{
if (uiType != TYPE_MALYGOS)
return;
m_uiEncounter = uiData;
if (uiData == IN_PROGRESS)
{
// ToDo: Despawn the exit portal
DoStartTimedAchievement(ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE, ACHIEV_START_MALYGOS_ID);
}
else if (uiData == FAIL)
{
// ToDo: respawn the focus iris and the portal
if (GameObject* pPlatform = GetSingleGameObjectFromStorage(GO_PLATFORM))
pPlatform->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK_11);
}
else if (uiData == DONE)
StartNextDialogueText(NPC_ALEXSTRASZA);
// Currently no reason to save anything
}
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;
}
}
