boss_algalon_the_observer.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "ScriptMgr.h"
#include "Containers.h"
#include "DB2Stores.h"
#include "GameObject.h"
#include "GameObjectAI.h"
#include "InstanceScript.h"
#include "Map.h"
#include "MotionMaster.h"
#include "MoveSplineInit.h"
#include "PassiveAI.h"
#include "Player.h"
#include "ScriptedCreature.h"
#include "SpellInfo.h"
#include "SpellScript.h"
#include "TemporarySummon.h"
#include "ulduar.h"
 
enum Texts
{
 SAY_BRANN_ALGALON_INTRO_1 = 0,
 SAY_BRANN_ALGALON_INTRO_2 = 1,
 SAY_BRANN_ALGALON_OUTRO = 2,
 
 SAY_ALGALON_INTRO_1 = 0,
 SAY_ALGALON_INTRO_2 = 1,
 SAY_ALGALON_INTRO_3 = 2,
 SAY_ALGALON_START_TIMER = 3,
 SAY_ALGALON_AGGRO = 4,
 SAY_ALGALON_COLLAPSING_STAR = 5,
 EMOTE_ALGALON_COLLAPSING_STAR = 6,
 SAY_ALGALON_BIG_BANG = 7,
 EMOTE_ALGALON_BIG_BANG = 8,
 SAY_ALGALON_ASCEND = 9,
 EMOTE_ALGALON_COSMIC_SMASH = 10,
 SAY_ALGALON_PHASE_TWO = 11,
 SAY_ALGALON_OUTRO_1 = 12,
 SAY_ALGALON_OUTRO_2 = 13,
 SAY_ALGALON_OUTRO_3 = 14,
 SAY_ALGALON_OUTRO_4 = 15,
 SAY_ALGALON_OUTRO_5 = 16,
 SAY_ALGALON_DESPAWN_1 = 17,
 SAY_ALGALON_DESPAWN_2 = 18,
 SAY_ALGALON_DESPAWN_3 = 19,
 SAY_ALGALON_KILL = 20,
 
 // Direct Sound
 ENGAGE_MUSIC_ID = 15878
};
 
enum Spells
{
 // Algalon the Observer
 SPELL_ARRIVAL = 64997,
 SPELL_RIDE_THE_LIGHTNING = 64986,
 SPELL_SUMMON_AZEROTH = 64994,
 SPELL_REORIGINATION = 64996,
 SPELL_SUPERMASSIVE_FAIL = 65311,
 SPELL_QUANTUM_STRIKE = 64395,
 SPELL_PHASE_PUNCH = 64412,
 SPELL_BIG_BANG = 64443,
 SPELL_ASCEND_TO_THE_HEAVENS = 64487,
 SPELL_COSMIC_SMASH = 62301,
 SPELL_COSMIC_SMASH_TRIGGERED = 62304,
 SPELL_COSMIC_SMASH_VISUAL_STATE = 62300,
 SPELL_SELF_STUN = 65256,
 SPELL_KILL_CREDIT = 65184,
 SPELL_TELEPORT = 62940,
 
 // Algalon Stalker
 SPELL_TRIGGER_3_ADDS = 62266, // Triggers Living Constellation
 
 // Living Constellation
 SPELL_ARCANE_BARRAGE = 64599,
 SPELL_DESPAWN_BLACK_HOLE = 64391,
 
 // Collapsing Star
 SPELL_COLLAPSE = 62018,
 SPELL_BLACK_HOLE_SPAWN_VISUAL = 62003,
 SPELL_SUMMON_BLACK_HOLE = 62189,
 
 // Black Hole
 SPELL_BLACK_HOLE_TRIGGER = 62185,
 SPELL_CONSTELLATION_PHASE_TRIGGER = 65508,
 SPELL_CONSTELLATION_PHASE_EFFECT = 65509,
 SPELL_BLACK_HOLE_EXPLOSION = 64122,
 SPELL_SUMMON_VOID_ZONE_VISUAL = 64470,
 SPELL_VOID_ZONE_VISUAL = 64469,
 SPELL_BLACK_HOLE_CREDIT = 65312,
 SPELL_BLACK_HOLE_DOT = 62169,
 
 // Worm Hole
 SPELL_WORM_HOLE_TRIGGER = 65251,
 SPELL_SUMMON_UNLEASHED_DARK_MATTER = 64450
};
 
uint32 const PhasePunchAlphaId[5] = {64435, 64434, 64428, 64421, 64417};
 
enum Events
{
 // Celestial Planetarium Access
 EVENT_DESPAWN_CONSOLE = 1,
 
 // Brann Bronzebeard
 EVENT_BRANN_MOVE_INTRO,
 EVENT_BRANN_SAY_INTRO_1,
 EVENT_SUMMON_ALGALON,
 EVENT_BRANN_OUTRO_1,
 EVENT_BRANN_OUTRO_2,
 
 // Algalon the Observer
 EVENT_INTRO_1,
 EVENT_INTRO_2,
 EVENT_SUMMON_AZEROTH,
 EVENT_INTRO_3,
 EVENT_INTRO_FINISH,
 EVENT_START_COMBAT,
 EVENT_INTRO_TIMER_DONE,
 EVENT_QUANTUM_STRIKE,
 EVENT_PHASE_PUNCH,
 EVENT_SUMMON_COLLAPSING_STAR,
 EVENT_BIG_BANG,
 EVENT_RESUME_UPDATING,
 EVENT_ASCEND_TO_THE_HEAVENS,
 EVENT_EVADE,
 EVENT_COSMIC_SMASH,
 EVENT_UNLOCK_YELL,
 EVENT_OUTRO_START,
 EVENT_OUTRO_1,
 EVENT_OUTRO_2,
 EVENT_OUTRO_3,
 EVENT_OUTRO_4,
 EVENT_OUTRO_5,
 EVENT_OUTRO_6,
 EVENT_OUTRO_7,
 EVENT_OUTRO_8,
 EVENT_OUTRO_9,
 EVENT_OUTRO_10,
 EVENT_OUTRO_11,
 
 // Living Constellation
 EVENT_ARCANE_BARRAGE
};
 
enum Actions
{
 ACTION_START_INTRO = 0,
 ACTION_ACTIVATE_STAR,
 ACTION_BIG_BANG,
 ACTION_ASCEND,
 ACTION_OUTRO,
 ACTION_INTRO_2,
};
 
enum EncounterPhases
{
 PHASE_NORMAL = 0,
 PHASE_ROLE_PLAY,
 PHASE_BIG_BANG
};
 
enum AchievmentInfo
{
 EVENT_ID_SUPERMASSIVE_START = 21697,
 DATA_HAS_FED_ON_TEARS = 30043005
};
 
enum AlgalonSplineMovements
{
 SPLINE_INITIAL_MOVE = 1,
 SPLINE_ALGALON_ROOM = 2,
 SPLINE_OUTRO_1 = 3,
 SPLINE_OUTRO_2 = 4,
 SPLINE_DESPAWN_INTRO_1 = 5
};
 
enum AlgalonMovePoints
{
 POINT_INITIAL_MOVE = 1,
 POINT_ALGALON_ROOM,
 POINT_DESPAWN,
 POINT_ALGALON_OUTRO
};
 
#define LIVING_CONSTELLATION_COUNT 11
Position const ConstellationPos[LIVING_CONSTELLATION_COUNT] =
{
 {1625.208f, -267.2771f, 446.4296f, 5.044002f},
 {1658.279f, -262.5490f, 441.9073f, 4.188790f},
 {1678.677f, -276.3280f, 427.7531f, 3.979351f},
 {1593.389f, -299.4325f, 432.4636f, 6.073746f},
 {1685.613f, -300.1219f, 443.2366f, 3.385939f},
 {1591.706f, -263.8201f, 441.4153f, 5.253441f},
 {1668.317f, -324.7676f, 457.9394f, 3.211406f},
 {1592.242f, -325.5323f, 446.9508f, 0.226893f},
 {1635.821f, -363.3442f, 424.3459f, 1.466077f},
 {1672.188f, -357.2484f, 436.7337f, 2.338741f},
 {1615.800f, -348.0065f, 442.9586f, 1.134464f}
};
 
#define COLLAPSING_STAR_COUNT 4
Position const CollapsingStarPos[COLLAPSING_STAR_COUNT] =
{
 {1649.438f, -319.8127f, 418.3941f, 1.082104f},
 {1647.005f, -288.6790f, 417.3955f, 3.490659f},
 {1622.451f, -321.1563f, 417.6188f, 4.677482f},
 {1615.060f, -291.6816f, 417.7796f, 3.490659f}
};
 
Position const BrannIntroSpawnPos = { 1677.363f, -162.3514f, 427.332f, 3.191144f };
Position const AlgalonSummonPos = { 1632.531f, -304.8516f, 450.1123f, 1.530165f };
Position const AlgalonLandPos = { 1632.668f, -302.7656f, 417.3211f, 1.530165f };
Position const AlgalonOutroPos = {1633.64f, -317.78f, 417.3211f, 0.0f};
Position const BrannOutroPos = { 1631.989f, -221.5439f, 418.4091f, 4.714909f };
 
class ActivateLivingConstellation : public BasicEvent
{
 public:
 ActivateLivingConstellation(Unit* owner) : _owner(owner), _instance(owner->GetInstanceScript()) { }
 
 bool Execute(uint64 execTime, uint32 /*diff*/) override
 {
 if (!_instance || _instance->GetBossState(DATA_ALGALON) != IN_PROGRESS)
 return true; // delete event
 
 _owner->CastSpell(nullptr, SPELL_TRIGGER_3_ADDS, TRIGGERED_FULL_MASK);
 _owner->m_Events.AddEvent(this, Milliseconds(execTime) + randtime(45s, 50s));
 return false;
 }
 
 private:
 Unit* _owner;
 InstanceScript* _instance;
};
 
class CosmicSmashDamageEvent : public BasicEvent
{
 public:
 CosmicSmashDamageEvent(Unit* caster) : _caster(caster) { }
 
 bool Execute(uint64 /*execTime*/, uint32 /*diff*/) override
 {
 _caster->CastSpell(nullptr, SPELL_COSMIC_SMASH_TRIGGERED, TRIGGERED_FULL_MASK);
 return true;
 }
 
 private:
 Unit* _caster;
};
 
class SummonUnleashedDarkMatter : public BasicEvent
{
 public:
 SummonUnleashedDarkMatter(Unit* caster) : _caster(caster) { }
 
 bool Execute(uint64 execTime, uint32 /*diff*/) override
 {
 _caster->CastSpell(nullptr, SPELL_SUMMON_UNLEASHED_DARK_MATTER, TRIGGERED_FULL_MASK);
 _caster->m_Events.AddEvent(this, Milliseconds(execTime) + 30s);
 return false;
 }
 
 private:
 Unit* _caster;
};
 
struct boss_algalon_the_observer : public BossAI
{
 boss_algalon_the_observer(Creature* creature) : BossAI(creature, DATA_ALGALON)
 {
 Initialize();
 _firstPull = true;
 _fedOnTears = false;
 }
 
 void Initialize()
 {
 _phaseTwo = false;
 _fightWon = false;
 _hasYelled = false;
 }
 
 void Reset() override
 {
 _Reset();
 me->SetReactState(REACT_PASSIVE);
 Initialize();
 }
 
 void DoAction(int32 action) override
 {
 switch (action)
 {
 case ACTION_START_INTRO:
 {
 me->SetUnitFlag2(UNIT_FLAG2_DONT_FADE_IN);
 me->SetDisableGravity(true);
 DoCastSelf(SPELL_ARRIVAL, true);
 DoCastSelf(SPELL_RIDE_THE_LIGHTNING, true);
 me->SetHomePosition(AlgalonLandPos);
 
 std::function<void(Movement::MoveSplineInit&)> initializer = [](Movement::MoveSplineInit& init)
 {
 init.MoveTo(AlgalonLandPos.GetPositionX(), AlgalonLandPos.GetPositionY(), AlgalonLandPos.GetPositionZ(), false);
 init.SetOrientationFixed(true);
 };
 me->GetMotionMaster()->LaunchMoveSpline(std::move(initializer), 0, MOTION_PRIORITY_NORMAL, POINT_MOTION_TYPE);
 
 events.Reset();
 events.SetPhase(PHASE_ROLE_PLAY);
 events.ScheduleEvent(EVENT_INTRO_1, 3s + 500ms, 0, PHASE_ROLE_PLAY);
 break;
 }
 case ACTION_ASCEND:
 events.SetPhase(PHASE_BIG_BANG);
 events.CancelEvent(EVENT_RESUME_UPDATING);
 events.ScheduleEvent(EVENT_ASCEND_TO_THE_HEAVENS, 1s + 500ms);
 break;
 case ACTION_INIT_ALGALON:
 _firstPull = false;
 me->SetImmuneToPC(false);
 break;
 default:
 break;
 }
 }
 
 uint32 GetData(uint32 type) const override
 {
 return type == DATA_HAS_FED_ON_TEARS ? _fedOnTears : 1;
 }
 
 void JustEngagedWith(Unit* who) override
 {
 Milliseconds introDelay = 0ms;
 me->SetUninteractible(true);
 me->SetImmuneToNPC(true);
 events.Reset();
 events.SetPhase(PHASE_ROLE_PLAY);
 
 if (!_firstPull)
 {
 Talk(SAY_ALGALON_AGGRO);
 me->PlayDirectMusic(ENGAGE_MUSIC_ID);
 BossAI::JustEngagedWith(who);
 introDelay = 8s;
 }
 else
 {
 _firstPull = false;
 Talk(SAY_ALGALON_START_TIMER);
 me->InterruptNonMeleeSpells(false);
 me->setActive(true);
 me->SetFarVisible(true);
 DoZoneInCombat();
 introDelay = 26500ms;
 summons.DespawnEntry(NPC_AZEROTH);
 events.ScheduleEvent(EVENT_START_COMBAT, 16s);
 }
 
 events.ScheduleEvent(EVENT_INTRO_TIMER_DONE, introDelay);
 events.ScheduleEvent(EVENT_QUANTUM_STRIKE, 3500ms + introDelay);
 events.ScheduleEvent(EVENT_PHASE_PUNCH, 15500ms + introDelay);
 events.ScheduleEvent(EVENT_SUMMON_COLLAPSING_STAR, 18s + introDelay);
 events.ScheduleEvent(EVENT_BIG_BANG, 90s + introDelay);
 events.ScheduleEvent(EVENT_ASCEND_TO_THE_HEAVENS, 360s + introDelay);
 events.ScheduleEvent(EVENT_COSMIC_SMASH, 25s + introDelay);
 
 std::list<Creature*> stalkers;
 me->GetCreatureListWithEntryInGrid(stalkers, NPC_ALGALON_STALKER, 200.0f);
 for (std::list<Creature*>::iterator itr = stalkers.begin(); itr != stalkers.end(); ++itr)
 (*itr)->m_Events.KillAllEvents(true);
 }
 
 void MovementInform(uint32 movementType, uint32 pointId) override
 {
 if (movementType != POINT_MOTION_TYPE)
 return;
 
 if (pointId == POINT_ALGALON_OUTRO)
 {
 me->SetFacingTo(1.605703f);
 events.ScheduleEvent(EVENT_OUTRO_3, 1s);
 }
 }
 
 void JustSummoned(Creature* summon) override
 {
 summons.Summon(summon);
 switch (summon->GetEntry())
 {
 case NPC_COLLAPSING_STAR:
 summon->SetReactState(REACT_PASSIVE);
 summon->GetMotionMaster()->MoveRandom(20.0f);
 summon->CastSpell(summon, SPELL_COLLAPSE, TRIGGERED_FULL_MASK);
 break;
 case NPC_ALGALON_VOID_ZONE_VISUAL_STALKER:
 summon->CastSpell(summon, SPELL_VOID_ZONE_VISUAL, TRIGGERED_FULL_MASK);
 break;
 case NPC_ALGALON_STALKER_ASTEROID_TARGET_01:
 summon->CastSpell(summon, SPELL_COSMIC_SMASH_VISUAL_STATE, TRIGGERED_FULL_MASK);
 break;
 case NPC_ALGALON_STALKER_ASTEROID_TARGET_02:
 summon->m_Events.AddEventAtOffset(new CosmicSmashDamageEvent(summon), 3s + 250ms);
 break;
 case NPC_WORM_HOLE:
 summon->SetReactState(REACT_PASSIVE);
 summon->CastSpell(summon, SPELL_WORM_HOLE_TRIGGER, TRIGGERED_FULL_MASK);
 summon->CastSpell(summon, SPELL_SUMMON_VOID_ZONE_VISUAL, TRIGGERED_FULL_MASK);
 break;
 case NPC_UNLEASHED_DARK_MATTER:
 DoZoneInCombat(summon);
 break;
 default:
 break;
 }
 }
 
 void EnterEvadeMode(EvadeReason why) override
 {
 instance->SetBossState(DATA_ALGALON, FAIL);
 BossAI::EnterEvadeMode(why);
 me->SetImmuneToPC(false);
 me->SetSheath(SHEATH_STATE_UNARMED);
 }
 
 void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
 {
 if (_fightWon)
 {
 damage = 0;
 return;
 }
 
 if (!_phaseTwo && me->HealthBelowPctDamaged(20, damage))
 {
 _phaseTwo = true;
 Talk(SAY_ALGALON_PHASE_TWO);
 summons.DespawnEntry(NPC_LIVING_CONSTELLATION);
 summons.DespawnEntry(NPC_COLLAPSING_STAR);
 summons.DespawnEntry(NPC_BLACK_HOLE);
 summons.DespawnEntry(NPC_ALGALON_VOID_ZONE_VISUAL_STALKER);
 events.CancelEvent(EVENT_SUMMON_COLLAPSING_STAR);
 std::list<Creature*> stalkers;
 me->GetCreatureListWithEntryInGrid(stalkers, NPC_ALGALON_STALKER, 200.0f);
 for (std::list<Creature*>::iterator itr = stalkers.begin(); itr != stalkers.end(); ++itr)
 (*itr)->m_Events.KillAllEvents(true);
 for (uint8 i = 0; i < COLLAPSING_STAR_COUNT; ++i)
 if (Creature* wormHole = DoSummon(NPC_WORM_HOLE, CollapsingStarPos[i], 0s, TEMPSUMMON_MANUAL_DESPAWN))
 wormHole->m_Events.AddEventAtOffset(new SummonUnleashedDarkMatter(wormHole), i >= 2 ? 8s : 6s);
 }
 else if ((int32(me->GetHealth()) - int32(damage)) < CalculatePct<int32>(int32(me->GetMaxHealth()), 2.5f) && !_fightWon)
 {
 _fightWon = true;
 damage = 0;
 events.SetPhase(PHASE_ROLE_PLAY);
 me->SetReactState(REACT_PASSIVE);
 me->AttackStop();
 me->SetUninteractible(true);
 DoCastSelf(SPELL_SELF_STUN);
 events.Reset();
 summons.DespawnAll();
 events.ScheduleEvent(EVENT_OUTRO_START, 1s + 500ms);
 events.ScheduleEvent(EVENT_OUTRO_1, 7s);
 }
 }
 
 void KilledUnit(Unit* victim) override
 {
 if (victim->GetTypeId() == TYPEID_PLAYER)
 {
 _fedOnTears = true;
 if (!_hasYelled)
 {
 _hasYelled = true;
 events.ScheduleEvent(EVENT_UNLOCK_YELL, 1s);
 Talk(SAY_ALGALON_KILL);
 }
 }
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (!(events.IsInPhase(PHASE_ROLE_PLAY) || events.IsInPhase(PHASE_BIG_BANG) || _fightWon) && !UpdateVictim())
 return;
 
 events.Update(diff);
 
 if (!events.IsInPhase(PHASE_ROLE_PLAY))
 if (me->HasUnitState(UNIT_STATE_CASTING))
 return;
 
 while (uint32 eventId = events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_INTRO_1:
 me->RemoveAurasDueToSpell(SPELL_RIDE_THE_LIGHTNING);
 Talk(SAY_ALGALON_INTRO_1);
 events.ScheduleEvent(EVENT_SUMMON_AZEROTH, 6s, 0, PHASE_ROLE_PLAY);
 break;
 case EVENT_SUMMON_AZEROTH:
 DoCastAOE(SPELL_SUMMON_AZEROTH, true);
 if (Creature* azeroth = instance->GetCreature(DATA_AZEROTH))
 if (TempSummon* summon = azeroth->ToTempSummon())
 summon->SetTempSummonType(TEMPSUMMON_MANUAL_DESPAWN);
 events.ScheduleEvent(EVENT_INTRO_2, 4s, 0, PHASE_ROLE_PLAY);
 break;
 case EVENT_INTRO_2:
 me->SetDisableGravity(false);
 Talk(SAY_ALGALON_INTRO_2);
 DoCastAOE(SPELL_REORIGINATION, true);
 events.ScheduleEvent(EVENT_INTRO_3, 8s + 500ms, 0, PHASE_ROLE_PLAY);
 break;
 case EVENT_INTRO_3:
 Talk(SAY_ALGALON_INTRO_3);
 events.ScheduleEvent(EVENT_INTRO_FINISH, 11s + 500ms, 0, PHASE_ROLE_PLAY);
 break;
 case EVENT_INTRO_FINISH:
 events.Reset();
 me->SetImmuneToPC(false);
 if (Creature* brann = instance->GetCreature(DATA_BRANN_BRONZEBEARD_ALG))
 brann->AI()->DoAction(ACTION_INTRO_2);
 break;
 case EVENT_START_COMBAT:
 Talk(SAY_ALGALON_AGGRO);
 me->PlayDirectMusic(ENGAGE_MUSIC_ID);
 instance->SetBossState(DATA_ALGALON, IN_PROGRESS);
 break;
 case EVENT_INTRO_TIMER_DONE:
 {
 events.SetPhase(PHASE_NORMAL);
 me->SetSheath(SHEATH_STATE_MELEE);
 me->SetUninteractible(false);
 me->SetImmuneToNPC(false);
 me->SetReactState(REACT_DEFENSIVE);
 DoCastAOE(SPELL_SUPERMASSIVE_FAIL, true);
 if (!me->GetThreatManager().IsThreatListEmpty())
 AttackStart(me->GetThreatManager().GetCurrentVictim());
 for (uint8 i = 0; i < LIVING_CONSTELLATION_COUNT; ++i)
 if (Creature* summon = DoSummon(NPC_LIVING_CONSTELLATION, ConstellationPos[i], 0s, TEMPSUMMON_DEAD_DESPAWN))
 summon->SetReactState(REACT_PASSIVE);
 
 std::list<Creature*> stalkers;
 me->GetCreatureListWithEntryInGrid(stalkers, NPC_ALGALON_STALKER, 200.0f);
 if (!stalkers.empty())
 {
 Unit* stalker = Trinity::Containers::SelectRandomContainerElement(stalkers);
 stalker->m_Events.AddEventAtOffset(new ActivateLivingConstellation(stalker), 45s, 50s);
 }
 break;
 }
 case EVENT_QUANTUM_STRIKE:
 DoCastVictim(SPELL_QUANTUM_STRIKE);
 events.Repeat(3s, 5s);
 break;
 case EVENT_PHASE_PUNCH:
 DoCastVictim(SPELL_PHASE_PUNCH);
 events.Repeat(15s + 500ms);
 break;
 case EVENT_SUMMON_COLLAPSING_STAR:
 Talk(SAY_ALGALON_COLLAPSING_STAR);
 Talk(EMOTE_ALGALON_COLLAPSING_STAR);
 for (uint8 i = 0; i < COLLAPSING_STAR_COUNT; ++i)
 me->SummonCreature(NPC_COLLAPSING_STAR, CollapsingStarPos[i], TEMPSUMMON_CORPSE_DESPAWN);
 events.Repeat(1min);
 break;
 case EVENT_BIG_BANG:
 {
 Talk(SAY_ALGALON_BIG_BANG);
 Talk(EMOTE_ALGALON_BIG_BANG);
 events.SetPhase(PHASE_BIG_BANG);
 std::list<Creature*> constellations;
 me->GetCreatureListWithEntryInGrid(constellations, NPC_LIVING_CONSTELLATION, 200.0f);
 for (std::list<Creature*>::iterator itr = constellations.begin(); itr != constellations.end(); ++itr)
 (*itr)->AI()->DoAction(ACTION_BIG_BANG);
 DoCastAOE(SPELL_BIG_BANG);
 events.Repeat(1min + 30s + 500ms);
 events.ScheduleEvent(EVENT_RESUME_UPDATING, 9s + 500ms);
 break;
 }
 case EVENT_RESUME_UPDATING:
 events.SetPhase(PHASE_NORMAL);
 break;
 case EVENT_ASCEND_TO_THE_HEAVENS:
 Talk(SAY_ALGALON_ASCEND);
 DoCastAOE(SPELL_ASCEND_TO_THE_HEAVENS);
 events.ScheduleEvent(EVENT_EVADE, 2s + 500ms);
 break;
 case EVENT_EVADE:
 EnterEvadeMode(EvadeReason::Other);
 break;
 case EVENT_COSMIC_SMASH:
 Talk(EMOTE_ALGALON_COSMIC_SMASH);
 DoCastAOE(SPELL_COSMIC_SMASH);
 events.Repeat(25s + 500ms);
 break;
 case EVENT_UNLOCK_YELL:
 _hasYelled = false;
 break;
 case EVENT_OUTRO_START:
 instance->SetBossState(DATA_ALGALON, DONE);
 break;
 case EVENT_OUTRO_1:
 me->RemoveAllAuras();
 ResetThreatList();
 me->SetFaction(FACTION_FRIENDLY);
 me->SetUnitFlag(UNIT_FLAG_RENAME);
 events.ScheduleEvent(EVENT_OUTRO_2, 2s);
 break;
 case EVENT_OUTRO_2:
 me->SetRegenerateHealth(false);
 me->CombatStop();
 me->GetMotionMaster()->MovePoint(POINT_ALGALON_OUTRO, AlgalonOutroPos);
 break;
 case EVENT_OUTRO_3:
 DoCastAOE(SPELL_KILL_CREDIT);
 events.ScheduleEvent(EVENT_OUTRO_4, 1s + 400ms);
 events.ScheduleEvent(EVENT_OUTRO_5, 4s + 500ms);
 break;
 case EVENT_OUTRO_4:
 DoCastAOE(SPELL_SUPERMASSIVE_FAIL);
 me->SetUninteractible(false);
 break;
 case EVENT_OUTRO_5:
 if (Creature* brann = me->SummonCreature(NPC_BRANN_BRONZBEARD_ALG, BrannOutroPos))
 brann->AI()->DoAction(ACTION_OUTRO);
 events.ScheduleEvent(EVENT_OUTRO_6, 10s);
 break;
 case EVENT_OUTRO_6:
 Talk(SAY_ALGALON_OUTRO_1);
 me->SetStandState(UNIT_STAND_STATE_KNEEL);
 events.ScheduleEvent(EVENT_OUTRO_7, 39s);
 break;
 case EVENT_OUTRO_7:
 Talk(SAY_ALGALON_OUTRO_2);
 events.ScheduleEvent(EVENT_OUTRO_8, 18s);
 break;
 case EVENT_OUTRO_8:
 Talk(SAY_ALGALON_OUTRO_3);
 events.ScheduleEvent(EVENT_OUTRO_9, 12s);
 break;
 case EVENT_OUTRO_9:
 Talk(SAY_ALGALON_OUTRO_4);
 events.ScheduleEvent(EVENT_OUTRO_10, 24s);
 break;
 case EVENT_OUTRO_10:
 Talk(SAY_ALGALON_OUTRO_5);
 events.ScheduleEvent(EVENT_OUTRO_11, 15s);
 break;
 case EVENT_OUTRO_11:
 me->SetStandState(UNIT_STAND_STATE_STAND);
 DoCastSelf(SPELL_TELEPORT);
 me->DespawnOrUnsummon(1s + 200ms);
 break;
 default:
 break;
 }
 
 if (me->HasUnitState(UNIT_STATE_CASTING) && !events.IsInPhase(PHASE_ROLE_PLAY))
 return;
 }
 }
 
private:
 bool _firstPull;
 bool _fedOnTears;
 bool _phaseTwo;
 bool _fightWon;
 bool _hasYelled;
};
 
struct npc_living_constellation : public CreatureAI
{
 npc_living_constellation(Creature* creature) : CreatureAI(creature), _instance(creature->GetInstanceScript())
 {
 Initialize();
 }
 
 void Initialize()
 {
 _isActive = false;
 }
 
 void Reset() override
 {
 _events.Reset();
 _events.ScheduleEvent(EVENT_ARCANE_BARRAGE, 2s + 500ms);
 Initialize();
 }
 
 uint32 GetData(uint32 /*type*/) const override
 {
 return _isActive ? 1 : 0;
 }
 
 void DoAction(int32 action) override
 {
 switch (action)
 {
 case ACTION_ACTIVATE_STAR:
 if (Creature* algalon = _instance->GetCreature(DATA_ALGALON))
 {
 if (Unit* target = algalon->AI()->SelectTarget(SelectTargetMethod::Random, 0, NonTankTargetSelector(algalon)))
 {
 me->SetReactState(REACT_AGGRESSIVE);
 me->SetUninteractible(false);
 AttackStart(target);
 DoZoneInCombat();
 _isActive = true;
 }
 }
 break;
 case ACTION_BIG_BANG:
 _events.SetPhase(PHASE_BIG_BANG);
 _events.DelayEvents(9s + 500ms);
 _events.ScheduleEvent(EVENT_RESUME_UPDATING, 9s + 500ms);
 break;
 default:
 break;
 }
 }
 
 void SpellHit(WorldObject* caster, SpellInfo const* spellInfo) override
 {
 Creature* creatureCaster = caster->ToCreature();
 if (!creatureCaster)
 return;
 
 if (spellInfo->Id != SPELL_CONSTELLATION_PHASE_EFFECT)
 return;
 
 _instance->TriggerGameEvent(EVENT_ID_SUPERMASSIVE_START);
 creatureCaster->CastSpell(nullptr, SPELL_BLACK_HOLE_CREDIT, TRIGGERED_FULL_MASK);
 DoCast(creatureCaster, SPELL_DESPAWN_BLACK_HOLE, TRIGGERED_FULL_MASK);
 me->DespawnOrUnsummon(500ms);
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (!(_events.IsInPhase(PHASE_ROLE_PLAY) || _events.IsInPhase(PHASE_BIG_BANG)) && !UpdateVictim())
 return;
 
 _events.Update(diff);
 
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_ARCANE_BARRAGE:
 {
 DoCastAOE(SPELL_ARCANE_BARRAGE, { SPELLVALUE_MAX_TARGETS, 1 });
 me->ClearUnitState(UNIT_STATE_CASTING);
 _events.Repeat(4s, 5s);
 break;
 }
 case EVENT_RESUME_UPDATING:
 _events.SetPhase(PHASE_NORMAL);
 break;
 }
 }
 }
 
private:
 EventMap _events;
 bool _isActive;
 InstanceScript* _instance;
};
 
struct npc_black_hole : public ScriptedAI
{
 npc_black_hole(Creature* creature) : ScriptedAI(creature), _summons(creature) { }
 
 void Reset() override
 {
 me->SetReactState(REACT_PASSIVE);
 DoCastAOE(SPELL_BLACK_HOLE_TRIGGER, TRIGGERED_FULL_MASK);
 DoCastSelf(SPELL_CONSTELLATION_PHASE_TRIGGER, TRIGGERED_FULL_MASK);
 DoCastAOE(SPELL_BLACK_HOLE_EXPLOSION, TRIGGERED_FULL_MASK);
 DoCastSelf(SPELL_SUMMON_VOID_ZONE_VISUAL, TRIGGERED_FULL_MASK);
 }
 
 void JustSummoned(Creature* summon) override
 {
 _summons.Summon(summon);
 }
 
 void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
 {
 if (spellInfo->Id == SPELL_DESPAWN_BLACK_HOLE)
 {
 _summons.DespawnAll();
 me->DespawnOrUnsummon(1ms);
 }
 }
 
 void EnterEvadeMode(EvadeReason /*why*/) override { }
 
private:
 SummonList _summons;
};
 
struct npc_collapsing_star : public PassiveAI
{
 npc_collapsing_star(Creature* creature) : PassiveAI(creature), _dying(false), _instance(creature->GetInstanceScript()) { }
 
 void JustSummoned(Creature* summon) override
 {
 if (summon->GetEntry() != NPC_BLACK_HOLE)
 return;
 
 if (Creature* algalon = _instance->GetCreature(DATA_ALGALON))
 algalon->AI()->JustSummoned(summon);
 
 me->DespawnOrUnsummon(1ms);
 }
 
 void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
 {
 if (_dying)
 {
 damage = 0;
 return;
 }
 
 if (damage >= me->GetHealth())
 {
 _dying = true;
 damage = 0;
 DoCastSelf(SPELL_BLACK_HOLE_SPAWN_VISUAL, true);
 DoCastSelf(SPELL_SUMMON_BLACK_HOLE, true);
 }
 }
 
private:
 bool _dying;
 InstanceScript* _instance;
};
 
struct npc_brann_bronzebeard_algalon : public CreatureAI
{
 npc_brann_bronzebeard_algalon(Creature* creature) : CreatureAI(creature) { }
 
 void DoAction(int32 action) override
 {
 switch (action)
 {
 case ACTION_START_INTRO:
 _events.Reset();
 me->GetMotionMaster()->MoveAlongSplineChain(POINT_INITIAL_MOVE, SPLINE_INITIAL_MOVE, false);
 break;
 case ACTION_OUTRO:
 me->GetMotionMaster()->MoveAlongSplineChain(0, SPLINE_OUTRO_1, false);
 _events.ScheduleEvent(EVENT_BRANN_OUTRO_1, 1min + 32s + 200ms);
 _events.ScheduleEvent(EVENT_BRANN_OUTRO_2, 2min);
 break;
 case ACTION_INTRO_2:
 Talk(SAY_BRANN_ALGALON_INTRO_2);
 me->GetMotionMaster()->MoveAlongSplineChain(POINT_DESPAWN, SPLINE_DESPAWN_INTRO_1, true);
 break;
 default:
 break;
 }
 }
 
 void MovementInform(uint32 type, uint32 pointId) override
 {
 if (type != POINT_MOTION_TYPE && type != SPLINE_CHAIN_MOTION_TYPE)
 return;
 
 switch (pointId)
 {
 case POINT_INITIAL_MOVE:
 _events.ScheduleEvent(EVENT_BRANN_MOVE_INTRO, 4s);
 break;
 case POINT_ALGALON_ROOM:
 me->SetFacingTo(4.714909f);
 _events.ScheduleEvent(EVENT_BRANN_SAY_INTRO_1, 500ms);
 break;
 case POINT_DESPAWN:
 me->DespawnOrUnsummon();
 break;
 default:
 break;
 }
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (_events.Empty())
 return;
 
 _events.Update(diff);
 
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_BRANN_MOVE_INTRO:
 me->GetMotionMaster()->MoveAlongSplineChain(POINT_ALGALON_ROOM, SPLINE_ALGALON_ROOM, true);
 break;
 case EVENT_BRANN_SAY_INTRO_1:
 Talk(SAY_BRANN_ALGALON_INTRO_1);
 _events.ScheduleEvent(EVENT_SUMMON_ALGALON, 8s + 300ms);
 break;
 case EVENT_SUMMON_ALGALON:
 if (Creature* algalon = me->GetMap()->SummonCreature(NPC_ALGALON, AlgalonSummonPos))
 algalon->AI()->DoAction(ACTION_START_INTRO);
 break;
 case EVENT_BRANN_OUTRO_1:
 Talk(SAY_BRANN_ALGALON_OUTRO);
 break;
 case EVENT_BRANN_OUTRO_2:
 me->GetMotionMaster()->MoveAlongSplineChain(POINT_DESPAWN, SPLINE_OUTRO_2, false);
 break;
 default:
 break;
 }
 }
 }
 
private:
 EventMap _events;
};
 
struct go_celestial_planetarium_access : public GameObjectAI
{
 go_celestial_planetarium_access(GameObject* go) : GameObjectAI(go), _instance(go->GetInstanceScript()) { }
 
 bool OnReportUse(Player* player) override
 {
 if (me->HasFlag(GO_FLAG_IN_USE))
 return true;
 
 bool hasKey = true;
 if (LockEntry const* lock = sLockStore.LookupEntry(me->GetGOInfo()->GetLockId()))
 {
 hasKey = false;
 for (uint8 i = 0; i < MAX_LOCK_CASE; ++i)
 {
 if (!lock->Index[i])
 continue;
 
 if (player->HasItemCount(lock->Index[i]))
 {
 hasKey = true;
 break;
 }
 }
 }
 
 if (!hasKey)
 return false;
 
 // Start Algalon event
 me->SetFlag(GO_FLAG_IN_USE);
 _events.ScheduleEvent(EVENT_DESPAWN_CONSOLE, 5s);
 if (Creature* brann = me->SummonCreature(NPC_BRANN_BRONZBEARD_ALG, BrannIntroSpawnPos))
 brann->AI()->DoAction(ACTION_START_INTRO);
 
 _instance->SetData(DATA_ALGALON_SUMMON_STATE, 1);
 if (GameObject* sigil = _instance->GetGameObject(DATA_SIGILDOOR_01))
 sigil->SetGoState(GO_STATE_ACTIVE);
 
 if (GameObject* sigil = _instance->GetGameObject(DATA_SIGILDOOR_02))
 sigil->SetGoState(GO_STATE_ACTIVE);
 
 return false;
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (_events.Empty())
 return;
 
 _events.Update(diff);
 
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_DESPAWN_CONSOLE:
 me->Delete();
 break;
 default:
 break;
 }
 }
 }
 
private:
 EventMap _events;
 InstanceScript* _instance;
};
 
// 64412 - Phase Punch
class spell_algalon_phase_punch : public AuraScript
{
 void HandlePeriodic(AuraEffect const* /*aurEff*/)
 {
 PreventDefaultAction();
 if (GetStackAmount() != 1)
 GetTarget()->RemoveAurasDueToSpell(PhasePunchAlphaId[GetStackAmount() - 2]);
 GetTarget()->CastSpell(GetTarget(), PhasePunchAlphaId[GetStackAmount() - 1], TRIGGERED_FULL_MASK);
 if (GetStackAmount() == 5)
 Remove(AURA_REMOVE_BY_DEFAULT);
 }
 
 void OnRemove(AuraEffect const*, AuraEffectHandleModes)
 {
 if (GetStackAmount() != 5)
 GetTarget()->RemoveAurasDueToSpell(PhasePunchAlphaId[GetStackAmount() - 1]);
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_algalon_phase_punch::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
 OnEffectRemove += AuraEffectRemoveFn(spell_algalon_phase_punch::OnRemove, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL);
 }
};
 
// 65508 - Constellation Phase Trigger
class spell_algalon_phase_constellation : public AuraScript
{
 bool Validate(SpellInfo const* spellInfo) override
 {
 return ValidateSpellEffect({ { spellInfo->Id, EFFECT_0 } }) && ValidateSpellInfo({ spellInfo->GetEffect(EFFECT_0).TriggerSpell });
 }
 
 void HandlePeriodic(AuraEffect const* aurEff)
 {
 PreventDefaultAction();
 CastSpellExtraArgs args(aurEff);
 args.AddSpellMod(SPELLVALUE_MAX_TARGETS, 1);
 // Phase Effect should only 1 target. Avoid 1 black hole despawn multiple Living Constellation
 GetTarget()->CastSpell(nullptr, GetSpellInfo()->GetEffect(EFFECT_0).TriggerSpell, args);
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_algalon_phase_constellation::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
 }
};
 
// 62266 - Trigger 3 Adds
class spell_algalon_trigger_3_adds : public SpellScript
{
 void SelectTarget(std::list<WorldObject*>& targets)
 {
 // Remove Living Constellation already actived
 targets.remove_if([](WorldObject* target) -> bool
 {
 return target->ToUnit() && target->ToUnit()->GetAI() && target->ToUnit()->GetAI()->GetData(0);
 });
 }
 
 void HandleDummy(SpellEffIndex effIndex)
 {
 PreventHitDefaultEffect(effIndex);
 if (Creature* target = GetHitCreature())
 target->AI()->DoAction(ACTION_ACTIVATE_STAR);
 }
 
 void Register() override
 {
 OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_algalon_trigger_3_adds::SelectTarget, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
 OnEffectHitTarget += SpellEffectFn(spell_algalon_trigger_3_adds::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
 }
};
 
// 62018 - Collapse
class spell_algalon_collapse : public AuraScript
{
 void HandlePeriodic(AuraEffect const* /*aurEff*/)
 {
 PreventDefaultAction();
 Unit::DealDamage(GetTarget(), GetTarget(), GetTarget()->CountPctFromMaxHealth(1), nullptr, NODAMAGE);
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_algalon_collapse::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
 }
};
 
// 64443, 64584 - Big Bang
class spell_algalon_big_bang : public SpellScript
{
 bool Load() override
 {
 _targetCount = 0;
 return GetCaster()->GetTypeId() == TYPEID_UNIT;
 }
 
 void CountTargets(std::list<WorldObject*>& targets)
 {
 _targetCount = targets.size();
 }
 
 void CheckTargets()
 {
 if (!_targetCount)
 GetCaster()->GetAI()->DoAction(ACTION_ASCEND);
 }
 
 void Register() override
 {
 OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_algalon_big_bang::CountTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
 AfterCast += SpellCastFn(spell_algalon_big_bang::CheckTargets);
 }
private:
 uint32 _targetCount = 0;
};
 
// 64445 - Remove Player from Phase
class spell_algalon_remove_phase : public AuraScript
{
 void HandlePeriodic(AuraEffect const* /*aurEff*/)
 {
 PreventDefaultAction();
 GetTarget()->RemoveAurasByType(SPELL_AURA_PHASE);
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_algalon_remove_phase::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
 }
};
 
// 62295 - Cosmic Smash
class spell_algalon_cosmic_smash : public SpellScript
{
 void ModDestHeight(SpellDestination& dest)
 {
 // Meteor should spawn below the platform
 Position const offset = { 0.0f, 0.0f, -36.1325f, 0.0f };
 dest.RelocateOffset(offset);
 }
 
 void Register() override
 {
 OnDestinationTargetSelect += SpellDestinationTargetSelectFn(spell_algalon_cosmic_smash::ModDestHeight, EFFECT_0, TARGET_DEST_CASTER_SUMMON);
 }
};
 
// 62311, 64596 - Cosmic Smash
class spell_algalon_cosmic_smash_damage : public SpellScript
{
 void RecalculateDamage()
 {
 if (!GetExplTargetDest() || !GetHitUnit())
 return;
 
 float distance = GetHitUnit()->GetDistance2d(GetExplTargetDest()->GetPositionX(), GetExplTargetDest()->GetPositionY());
 if (distance > 6.0f)
 SetHitDamage(int32(float(GetHitDamage()) / distance) * 2);
 }
 
 void Register() override
 {
 OnHit += SpellHitFn(spell_algalon_cosmic_smash_damage::RecalculateDamage);
 }
};
 
// 62168 - Black Hole (Phase Shifts)
// 65250 - Worm Hole (Phase Shifts)
// 64417 - Phase Punch (Phase Shifts)
class spell_algalon_black_hole_phase_shifts : public AuraScript
{
 bool Load() override
 {
 return GetUnitOwner()->GetTypeId() == TYPEID_PLAYER;
 }
 
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_BLACK_HOLE_DOT });
 }
 
 void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_BLACK_HOLE_DOT, true);
 }
 
 void Register() override
 {
 OnEffectApply += AuraEffectApplyFn(spell_algalon_black_hole_phase_shifts::HandleEffectApply, EFFECT_0, SPELL_AURA_PHASE, AURA_EFFECT_HANDLE_REAL);
 }
};
 
void AddSC_boss_algalon_the_observer()
{
 RegisterUlduarCreatureAI(boss_algalon_the_observer);
 RegisterUlduarCreatureAI(npc_living_constellation);
 RegisterUlduarCreatureAI(npc_black_hole);
 RegisterUlduarCreatureAI(npc_collapsing_star);
 RegisterUlduarCreatureAI(npc_brann_bronzebeard_algalon);
 RegisterGameObjectAI(go_celestial_planetarium_access);
 RegisterSpellScript(spell_algalon_phase_punch);
 RegisterSpellScript(spell_algalon_phase_constellation);
 RegisterSpellScript(spell_algalon_trigger_3_adds);
 RegisterSpellScript(spell_algalon_collapse);
 RegisterSpellScript(spell_algalon_big_bang);
 RegisterSpellScript(spell_algalon_remove_phase);
 RegisterSpellScript(spell_algalon_cosmic_smash);
 RegisterSpellScript(spell_algalon_cosmic_smash_damage);
 RegisterSpellScript(spell_algalon_black_hole_phase_shifts);
}