boss_muru.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 "InstanceScript.h"
#include "ObjectAccessor.h"
#include "ScriptedCreature.h"
#include "SpellAuraEffects.h"
#include "SpellScript.h"
#include "sunwell_plateau.h"
 
enum Spells
{
 // Muru's spells
 SPELL_OPEN_PORTAL_PERIODIC = 45994,
 SPELL_DARKNESS_PERIODIC = 45998,
 SPELL_NEGATIVE_ENERGY_PERIODIC = 46009,
 SPELL_SUMMON_VOID_SPAWN = 46071,
 SPELL_SUMMON_BLOOD_ELVES_SCRIPT = 46050,
 SPELL_SUMMON_BLOOD_ELVES_PERIODIC = 46041,
 SPELL_OPEN_ALL_PORTALS = 46177,
 SPELL_SUMMON_ENTROPIUS = 46217,
 SPELL_ENRAGE = 26662,
 SPELL_SUMMON_DARK_FIEND_0 = 46000,
 SPELL_SUMMON_DARK_FIEND_1 = 46001,
 SPELL_SUMMON_DARK_FIEND_2 = 46002,
 SPELL_SUMMON_DARK_FIEND_3 = 46003,
 SPELL_SUMMON_DARK_FIEND_4 = 46004,
 SPELL_SUMMON_DARK_FIEND_5 = 46005,
 SPELL_SUMMON_DARK_FIEND_6 = 46006,
 SPELL_SUMMON_DARK_FIEND_7 = 46007,
 SPELL_SUMMON_BERSERKER = 46037,
 SPELL_SUMMON_BERSERKER_2 = 46040,
 SPELL_SUMMON_FURY_MAGE = 46038,
 SPELL_SUMMON_FURY_MAGE_2 = 46039,
 
 // Entropius's spells
 SPELL_ENTROPIUS_COSMETIC_SPAWN = 46223,
 SPELL_DARKNESS_E = 46269,
 SPELL_NEGATIVE_ENERGY_PERIODIC_E = 46284,
 SPELL_BLACKHOLE = 46282,
 SPELL_SUMMON_DARKFIEND_E = 46263,
 
 // Myruu's Portal Target
 SPELL_SUMMON_VOID_SENTINEL_SUMMONER = 45978,
 SPELL_SUMMON_VOID_SENTINEL_SUMMONER_VISUAL = 45989,
 SPELL_SUMMON_VOID_SENTINEL = 45988,
 SPELL_TRANSFORM_VISUAL_MISSILE = 46205,
 TRANSFORM_VISUAL_MISSILE_1 = 46208,
 TRANSFORM_VISUAL_MISSILE_2 = 46178,
 SPELL_OPEN_PORTAL = 45977,
 SPELL_OPEN_PORTAL_2 = 45976,
 
 //Dark Fiend Spells
 SPELL_DARKFIEND_DAMAGE = 45944,
 SPELL_DARKFIEND_VISUAL = 45936,
 SPELL_DARKFIEND_SKIN = 45934,
 
 // Void Sentinel's spells
 SPELL_SHADOW_PULSE_PERIODIC = 46086,
 SPELL_VOID_BLAST = 46161,
 
 //Black Hole Spells
 SPELL_BLACKHOLE_SUMMON_VISUAL = 46242,
 SPELL_BLACKHOLE_SUMMON_VISUAL_2 = 46247,
 SPELL_BLACKHOLE_PASSIVE = 46228,
 SPELL_BLACK_HOLE_VISUAL_2 = 46235
};
 
enum Phases
{
 PHASE_ONE = 1,
 PHASE_TWO = 2
};
 
enum Misc
{
 MAX_VOID_SPAWNS = 6,
 MAX_SUMMON_BLOOD_ELVES = 4,
 MAX_SUMMON_DARK_FIEND = 8
};
 
uint32 const SummonDarkFiendSpells[MAX_SUMMON_DARK_FIEND] =
{
 SPELL_SUMMON_DARK_FIEND_0,
 SPELL_SUMMON_DARK_FIEND_1,
 SPELL_SUMMON_DARK_FIEND_2,
 SPELL_SUMMON_DARK_FIEND_3,
 SPELL_SUMMON_DARK_FIEND_4,
 SPELL_SUMMON_DARK_FIEND_5,
 SPELL_SUMMON_DARK_FIEND_6,
 SPELL_SUMMON_DARK_FIEND_7
};
 
uint32 const SummonBloodElvesSpells[MAX_SUMMON_BLOOD_ELVES] =
{
 SPELL_SUMMON_BERSERKER,
 SPELL_SUMMON_BERSERKER_2,
 SPELL_SUMMON_FURY_MAGE,
 SPELL_SUMMON_FURY_MAGE_2
};
 
class VoidSpawnSummon : public BasicEvent
{
 public:
 explicit VoidSpawnSummon(Creature* owner)
 : _owner(owner)
 {
 }
 
 bool Execute(uint64 /*time*/, uint32 /*diff*/)
 {
 _owner->CastSpell(nullptr, SPELL_SUMMON_VOID_SENTINEL, true);
 return true;
 }
 
 private:
 Creature* _owner;
};
 
struct boss_entropius : public BossAI
{
 boss_entropius(Creature* creature) : BossAI(creature, DATA_MURU) { }
 
 void Reset() override
 {
 _Reset();
 DoCast(me, SPELL_ENTROPIUS_COSMETIC_SPAWN, true);
 }
 
 void ScheduleTasks() override
 {
 scheduler.Schedule(Milliseconds(2000), [this](TaskContext /*context*/)
 {
 DoResetPortals();
 DoCastAOE(SPELL_NEGATIVE_ENERGY_PERIODIC_E, true);
 });
 
 scheduler.Schedule(Seconds(15), [this](TaskContext context)
 {
 DoCastAOE(SPELL_DARKNESS_E, true);
 DoCastAOE(SPELL_BLACKHOLE, true);
 
 context.Repeat();
 });
 }
 
 void JustSummoned(Creature* summon) override
 {
 switch (summon->GetEntry())
 {
 case NPC_DARK_FIENDS:
 summon->CastSpell(summon, SPELL_DARKFIEND_VISUAL);
 break;
 case NPC_DARKNESS:
 summon->SetReactState(REACT_PASSIVE);
 summon->CastSpell(summon, SPELL_BLACKHOLE);
 summon->CastSpell(summon, SPELL_SUMMON_DARKFIEND_E, true);
 break;
 }
 summons.Summon(summon);
 }
 
 void EnterEvadeMode(EvadeReason /*why*/) override
 {
 if (Creature* muru = instance->GetCreature(DATA_MURU))
 muru->AI()->EnterEvadeMode();
 
 DoResetPortals();
 summons.DespawnAll();
 me->DespawnOrUnsummon();
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 _JustDied();
 
 if (Creature* muru = instance->GetCreature(DATA_MURU))
 muru->DisappearAndDie();
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (!UpdateVictim())
 return;
 
 scheduler.Update(diff);
 }
 
 void DoResetPortals()
 {
 std::list<Creature*> portals;
 me->GetCreatureListWithEntryInGrid(portals, NPC_MURU_PORTAL_TARGET, 100.0f);
 for (Creature* portal : portals)
 portal->RemoveAllAuras();
 }
};
 
struct boss_muru : public BossAI
{
 boss_muru(Creature* creature) : BossAI(creature, DATA_MURU)
 {
 Initialize();
 SetCombatMovement(false);
 }
 
 void Initialize()
 {
 _hasEnraged = false;
 _phase = PHASE_ONE;
 _entropiusGUID.Clear();
 }
 
 void Reset() override
 {
 _Reset();
 Initialize();
 me->SetUninteractible(false);
 me->SetVisible(true);
 }
 
 void EnterEvadeMode(EvadeReason /*why*/) override
 {
 BossAI::EnterEvadeMode();
 if (Creature* entropius = ObjectAccessor::GetCreature(*me, _entropiusGUID))
 entropius->AI()->EnterEvadeMode();
 }
 
 void ScheduleTasks() override
 {
 scheduler.Schedule(Minutes(10), [this](TaskContext /*context*/)
 {
 if (Creature* entropius = ObjectAccessor::GetCreature(*me, _entropiusGUID))
 entropius->CastSpell(entropius, SPELL_ENRAGE);
 DoCast(me, SPELL_ENRAGE);
 _hasEnraged = true;
 });
 
 scheduler.Schedule(Seconds(10), [this](TaskContext /*context*/)
 {
 DoCast(me, SPELL_SUMMON_BLOOD_ELVES_SCRIPT, true);
 DoCast(me, SPELL_SUMMON_BLOOD_ELVES_PERIODIC, true);
 });
 }
 
 void JustEngagedWith(Unit* who) override
 {
 BossAI::JustEngagedWith(who);
 DoCast(me, SPELL_OPEN_PORTAL_PERIODIC, true);
 DoCast(me, SPELL_DARKNESS_PERIODIC, true);
 DoCast(me, SPELL_NEGATIVE_ENERGY_PERIODIC, true);
 }
 
 void DamageTaken(Unit* /*done_by*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
 {
 if (damage >= me->GetHealth())
 {
 damage = me->GetHealth() - 1;
 if (_phase != PHASE_ONE)
 return;
 
 _phase = PHASE_TWO;
 me->RemoveAllAuras();
 DoCast(me, SPELL_OPEN_ALL_PORTALS, true);
 me->SetUninteractible(true);
 
 scheduler.Schedule(Seconds(6), [this](TaskContext /*context*/)
 {
 DoCast(me, SPELL_SUMMON_ENTROPIUS, true);
 });
 }
 }
 
 void JustSummoned(Creature* summon) override
 {
 if (summon->GetEntry() == NPC_ENTROPIUS)
 {
 me->SetVisible(false);
 _entropiusGUID = summon->GetGUID();
 DoZoneInCombat(summon);
 if (_hasEnraged)
 summon->CastSpell(summon, SPELL_ENRAGE, true);
 return;
 }
 BossAI::JustSummoned(summon);
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (!UpdateVictim())
 return;
 
 scheduler.Update(diff);
 }
 
private:
 ObjectGuid _entropiusGUID;
 bool _hasEnraged;
 uint8 _phase;
};
 
struct npc_muru_portal : public ScriptedAI
{
 npc_muru_portal(Creature* creature) : ScriptedAI(creature) { }
 
 void JustSummoned(Creature* summon) override
 {
 DoCast(summon, SPELL_SUMMON_VOID_SENTINEL_SUMMONER_VISUAL, true);
 
 summon->m_Events.AddEvent(new VoidSpawnSummon(summon), summon->m_Events.CalculateTime(1500ms));
 }
 
 void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
 {
 switch (spellInfo->Id)
 {
 case SPELL_OPEN_ALL_PORTALS:
 DoCastAOE(SPELL_OPEN_PORTAL, true);
 DoCastAOE(SPELL_TRANSFORM_VISUAL_MISSILE, true);
 break;
 case SPELL_OPEN_PORTAL_2:
 DoCastAOE(SPELL_OPEN_PORTAL, true);
 _scheduler.Schedule(Seconds(6), [this](TaskContext /*context*/)
 {
 DoCastAOE(SPELL_SUMMON_VOID_SENTINEL_SUMMONER, true);
 });
 break;
 default:
 break;
 }
 }
 
 void UpdateAI(uint32 diff) override
 {
 _scheduler.Update(diff);
 }
 
private:
 TaskScheduler _scheduler;
};
 
struct npc_dark_fiend : public ScriptedAI
{
 npc_dark_fiend(Creature* creature) : ScriptedAI(creature)
 {
 Initialize();
 }
 
 void Initialize()
 {
 me->SetDisplayFromModel(1);
 me->SetReactState(REACT_PASSIVE);
 DoCast(me, SPELL_DARKFIEND_SKIN, true);
 
 _scheduler.Schedule(Seconds(2), [this](TaskContext /*context*/)
 {
 me->SetReactState(REACT_AGGRESSIVE);
 me->SetUninteractible(false);
 
 if (Creature* _summoner = ObjectAccessor::GetCreature(*me, _summonerGUID))
 if (Unit* target = _summoner->AI()->SelectTarget(SelectTargetMethod::Random, 0))
 AttackStart(target);
 });
 
 _scheduler.Schedule(Seconds(3), [this](TaskContext context)
 {
 if (me->IsWithinDist(me->GetVictim(), 5.0f) && me->HasAura(SPELL_DARKFIEND_SKIN))
 {
 DoCastAOE(SPELL_DARKFIEND_DAMAGE, false);
 me->DisappearAndDie();
 }
 
 context.Repeat(Milliseconds(500));
 });
 }
 
 void IsSummonedBy(WorldObject* summoner) override
 {
 _summonerGUID = summoner->GetGUID();
 }
 
 bool CanAIAttack(Unit const* /*target*/) const override
 {
 return me->HasAura(SPELL_DARKFIEND_SKIN);
 }
 
 void UpdateAI(uint32 diff) override
 {
 _scheduler.Update(diff);
 }
 
private:
 TaskScheduler _scheduler;
 ObjectGuid _summonerGUID;
};
 
struct npc_void_sentinel : public ScriptedAI
{
 npc_void_sentinel(Creature* creature) : ScriptedAI(creature)
 {
 _instance = me->GetInstanceScript();
 }
 
 void IsSummonedBy(WorldObject* /*summoner*/) override
 {
 if (Creature* muru = _instance->GetCreature(DATA_MURU))
 muru->AI()->JustSummoned(me);
 }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 DoCast(me, SPELL_SHADOW_PULSE_PERIODIC, true);
 
 _scheduler.Schedule(Seconds(45), [this](TaskContext context)
 {
 DoCastVictim(SPELL_VOID_BLAST, false);
 
 context.Repeat();
 });
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 for (uint8 i = 0; i < MAX_VOID_SPAWNS; ++i)
 DoCastAOE(SPELL_SUMMON_VOID_SPAWN, true);
 }
 
 void UpdateAI(uint32 diff) override
 {
 _scheduler.Update(diff);
 }
 
private:
 TaskScheduler _scheduler;
 InstanceScript* _instance;
};
 
struct npc_blackhole : public ScriptedAI
{
 npc_blackhole(Creature* creature) : ScriptedAI(creature)
 {
 _instance = creature->GetInstanceScript();
 }
 
 void Reset() override
 {
 me->SetReactState(REACT_PASSIVE);
 DoCast(SPELL_BLACKHOLE_SUMMON_VISUAL);
 
 _scheduler.Schedule(Seconds(15), [this](TaskContext /*context*/)
 {
 me->DisappearAndDie();
 });
 
 _scheduler.Schedule(Seconds(1), [this](TaskContext context)
 {
 switch (context.GetRepeatCounter())
 {
 case 0:
 me->SetReactState(REACT_AGGRESSIVE);
 DoCast(SPELL_BLACKHOLE_SUMMON_VISUAL_2);
 if (Unit* victim = ObjectAccessor::GetUnit(*me, _instance->GetGuidData(DATA_PLAYER_GUID)))
 AttackStart(victim);
 context.Repeat(Milliseconds(1200));
 break;
 case 1:
 DoCast(SPELL_BLACKHOLE_SUMMON_VISUAL);
 context.Repeat(Seconds(2));
 break;
 case 2:
 DoCast(SPELL_BLACKHOLE_PASSIVE);
 DoCast(SPELL_BLACK_HOLE_VISUAL_2);
 break;
 default:
 break;
 }
 });
 }
 
 void UpdateAI(uint32 diff) override
 {
 _scheduler.Update(diff);
 }
 
private:
 TaskScheduler _scheduler;
 InstanceScript* _instance;
};
 
// 46050 - Summon Blood Elves Script
class spell_summon_blood_elves_script : public SpellScript
{
 bool Validate(SpellInfo const* /*spell*/) override
 {
 return ValidateSpellInfo(SummonBloodElvesSpells);
 }
 
 void HandleScript(SpellEffIndex /*effIndex*/)
 {
 for (uint8 i = 0; i < MAX_SUMMON_BLOOD_ELVES; ++i)
 GetCaster()->CastSpell(nullptr, SummonBloodElvesSpells[urand(0,3)], true);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_summon_blood_elves_script::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
 }
};
 
// 45996 - Darkness
class spell_muru_darkness : public SpellScript
{
 bool Validate(SpellInfo const* /*spell*/) override
 {
 return ValidateSpellInfo(SummonDarkFiendSpells);
 }
 
 void HandleAfterCast()
 {
 for (uint8 i = 0; i < MAX_SUMMON_DARK_FIEND; ++i)
 GetCaster()->CastSpell(nullptr, SummonDarkFiendSpells[i], true);
 }
 
 void Register() override
 {
 AfterCast += SpellCastFn(spell_muru_darkness::HandleAfterCast);
 }
};
 
// 45934 - Dark Fiend
class spell_dark_fiend_skin : public AuraScript
{
 void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 if (GetTargetApplication()->GetRemoveMode() != AURA_REMOVE_BY_ENEMY_SPELL)
 return;
 
 if (Creature* target = GetTarget()->ToCreature())
 {
 target->SetReactState(REACT_PASSIVE);
 target->AttackStop();
 target->StopMoving();
 target->CastSpell(target, SPELL_DARKFIEND_VISUAL, true);
 target->DespawnOrUnsummon(3s);
 }
 }
 
 void Register() override
 {
 AfterEffectRemove += AuraEffectRemoveFn(spell_dark_fiend_skin::OnRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
 }
};
 
// 46205 - Transform Visual Missile Periodic
class spell_transform_visual_missile_periodic : public AuraScript
{
 void OnPeriodic(AuraEffect const* /*aurEff*/)
 {
 GetTarget()->CastSpell(nullptr, RAND(TRANSFORM_VISUAL_MISSILE_1, TRANSFORM_VISUAL_MISSILE_2), true);
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_transform_visual_missile_periodic::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
 }
};
 
// 46041 - Summon Blood Elves Periodic
class spell_summon_blood_elves_periodic : public AuraScript
{
 void OnPeriodic(AuraEffect const* /*aurEff*/)
 {
 GetTarget()->CastSpell(nullptr, SPELL_SUMMON_BLOOD_ELVES_SCRIPT, true);
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_summon_blood_elves_periodic::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
 }
};
 
// 46284 - Negative Energy Periodic
class spell_muru_negative_energy_periodic : public AuraScript
{
 bool Validate(SpellInfo const* spellInfo) override
 {
 return ValidateSpellEffect({ { spellInfo->Id, EFFECT_0 } }) && ValidateSpellInfo({ spellInfo->GetEffect(EFFECT_0).TriggerSpell });
 }
 
 void PeriodicTick(AuraEffect const* aurEff)
 {
 PreventDefaultAction();
 
 CastSpellExtraArgs args(aurEff);
 args.AddSpellMod(SPELLVALUE_MAX_TARGETS, aurEff->GetTickNumber() / 10 + 1);
 GetTarget()->CastSpell(nullptr, aurEff->GetSpellEffectInfo().TriggerSpell, args);
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_muru_negative_energy_periodic::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
 }
};
 
void AddSC_boss_muru()
{
 RegisterSunwellPlateauCreatureAI(boss_muru);
 RegisterSunwellPlateauCreatureAI(boss_entropius);
 RegisterSunwellPlateauCreatureAI(npc_muru_portal);
 RegisterSunwellPlateauCreatureAI(npc_dark_fiend);
 RegisterSunwellPlateauCreatureAI(npc_void_sentinel);
 RegisterSunwellPlateauCreatureAI(npc_blackhole);
 RegisterSpellScript(spell_summon_blood_elves_script);
 RegisterSpellScript(spell_muru_darkness);
 RegisterSpellScript(spell_dark_fiend_skin);
 RegisterSpellScript(spell_transform_visual_missile_periodic);
 RegisterSpellScript(spell_summon_blood_elves_periodic);
 RegisterSpellScript(spell_muru_negative_energy_periodic);
}