boss_kalecgos.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 "GameObject.h"
#include "GameObjectAI.h"
#include "InstanceScript.h"
#include "MotionMaster.h"
#include "Player.h"
#include "ScriptedCreature.h"
#include "SpellAuraEffects.h"
#include "SpellScript.h"
#include "sunwell_plateau.h"
#include "TemporarySummon.h"
 
enum Yells
{
 SAY_SATH_AGGRO = 0,
 SAY_SATH_SLAY = 1,
 SAY_SATH_DEATH = 2,
 SAY_SATH_SPELL1 = 3,
 SAY_SATH_SPELL2 = 4,
 
 SAY_EVIL_AGGRO = 0,
 SAY_EVIL_SLAY = 1,
 SAY_OUTRO_1 = 2,
 SAY_OUTRO_2 = 3,
 EMOTE_ENRAGE = 4,
 SAY_ARCANE_BUFFET = 6,
 
 SAY_GOOD_NEAR_DEATH_0 = 0,
 SAY_GOOD_NEAR_DEATH_1 = 1,
 SAY_GOOD_NEAR_DEATH_2 = 2,
 SAY_GOOD_DEATH = 3
};
 
enum Spells
{
 SPELL_SPECTRAL_BLAST = 44869,
 SPELL_ARCANE_BUFFET = 45018,
 SPELL_FROST_BREATH = 44799,
 SPELL_TAIL_LASH = 45122,
 SPELL_WILD_MAGIC_1 = 45001,
 SPELL_WILD_MAGIC_2 = 45002,
 SPELL_WILD_MAGIC_3 = 45004,
 SPELL_WILD_MAGIC_4 = 45006,
 SPELL_WILD_MAGIC_5 = 45010,
 SPELL_WILD_MAGIC_6 = 44978,
 SPELL_BANISH = 136466, // Changed in MoP - Patch 5.3 for solo player.
 SPELL_ENRAGE = 44807,
 SPELL_DEMONIC_VISUAL = 44800,
 SPELL_CORRUPTION_STRIKE = 45029,
 SPELL_AGONY_CURSE = 45032,
 SPELL_SHADOW_BOLT = 45031,
 SPELL_TAP_CHECK = 46732,
 SPELL_TAP_CHECK_DAMAGE = 46733,
 SPELL_AGONY_CURSE_VISUAL_1 = 45083,
 SPELL_AGONY_CURSE_VISUAL_2 = 45084,
 SPELL_AGONY_CURSE_VISUAL_3 = 45085,
 SPELL_AGONY_CURSE_ALLY = 45034,
 SPELL_HEROIC_STRIKE = 45026,
 SPELL_REVITALIZE = 45027,
 SPELL_SPECTRAL_BLAST_EFFECT = 44866,
 SPELL_SPECTRAL_BLAST_VISUAL = 46648,
 SPELL_SPECTRAL_REALM_TRIGGER = 44811,
 SPELL_SPECTRAL_REALM_TELEPORT = 46019,
 SPELL_SPECTRAL_REALM_AURA = 46021,
 SPELL_SPECTRAL_REALM_2 = 44845,
 SPELL_SPECTRAL_REALM_REACTION = 44852,
 SPELL_SPECTRAL_EXHAUSTION = 44867,
 SPELL_TELEPORT_BACK = 46020
};
 
enum KalecgosEvents
{
 EVENT_ARCANE_BUFFET = 1,
 EVENT_FROST_BREATH,
 EVENT_WILD_MAGIC,
 EVENT_TAIL_LASH,
 EVENT_SPECTRAL_BLAST,
 EVENT_CHECK_TIMER,
 EVENT_OUTRO_START,
 EVENT_OUTRO_1,
 EVENT_OUTRO_2,
 EVENT_OUTRO_3,
 EVENT_REVITALIZE,
 EVENT_HEROIC_STRIKE,
 EVENT_SHADOWBOLT,
 EVENT_AGONY_CURSE,
 EVENT_CORRUPTION_STRIKE
};
 
enum SWPActions
{
 ACTION_START_OUTRO = 1,
 ACTION_ENRAGE
};
 
enum KalecSayPhases
{
 PHASE_SAY_ONE = 1,
 PHASE_SAY_TWO,
 PHASE_SAY_THREE,
 PHASE_SAY_FOUR,
 PHASE_OUTRO
};
 
enum KalecgosPoints
{
 POINT_OUTRO_1 = 0,
 POINT_OUTRO_2
};
 
Position const KalecgosSummonPos = { 1709.094f, 927.5035f, -74.28364f, 2.932153f };
Position const FlyPos[2] =
{
 { 1704.18f, 927.999f, 57.888f },
 { 1614.355f, 846.9694f, 119.0971f }
};
 
uint32 const WildMagicSpells[6] =
{
 SPELL_WILD_MAGIC_1,
 SPELL_WILD_MAGIC_2,
 SPELL_WILD_MAGIC_3,
 SPELL_WILD_MAGIC_4,
 SPELL_WILD_MAGIC_5,
 SPELL_WILD_MAGIC_6
};
 
struct boss_kalecgos : public BossAI
{
 boss_kalecgos(Creature* creature) : BossAI(creature, DATA_KALECGOS), _isEnraged(false), _isBanished(false) { }
 
 void Reset() override
 {
 _isEnraged = false;
 _isBanished = false;
 _Reset();
 events.ScheduleEvent(EVENT_ARCANE_BUFFET, 8s);
 events.ScheduleEvent(EVENT_FROST_BREATH, 15s);
 events.ScheduleEvent(EVENT_WILD_MAGIC, 10s);
 events.ScheduleEvent(EVENT_TAIL_LASH, 25s);
 events.ScheduleEvent(EVENT_SPECTRAL_BLAST, 20s, 25s);
 events.ScheduleEvent(EVENT_CHECK_TIMER, 1s);
 }
 
 void EnterEvadeMode(EvadeReason /*why*/) override
 {
 if (events.IsInPhase(PHASE_OUTRO) || me->HasAura(SPELL_BANISH))
 return;
 
 _EnterEvadeMode();
 instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
 instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_SPECTRAL_REALM_AURA, true, true);
 summons.DespawnAll();
 DespawnPortals();
 
 if (Creature* sathrovar = instance->GetCreature(DATA_SATHROVARR))
 _DespawnAtEvade(Seconds(10), sathrovar);
 
 _DespawnAtEvade(Seconds(10));
 }
 
 void DespawnPortals()
 {
 std::vector<GameObject*> portals;
 me->GetGameObjectListWithEntryInGrid(portals, GO_SPECTRAL_RIFT);
 for (GameObject* portal : portals)
 portal->Delete();
 }
 
 void DoAction(int32 action) override
 {
 switch (action)
 {
 case ACTION_START_OUTRO:
 events.ScheduleEvent(EVENT_OUTRO_START, 1s);
 break;
 case ACTION_ENRAGE:
 _isEnraged = true;
 Talk(EMOTE_ENRAGE);
 DoCastSelf(SPELL_ENRAGE, true);
 break;
 default:
 break;
 }
 }
 
 void DamageTaken(Unit* who, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
 {
 if (damage >= me->GetHealth() && (!who || who->GetGUID() != me->GetGUID()))
 damage = 0;
 }
 
 void JustEngagedWith(Unit* who) override
 {
 instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, me);
 Talk(SAY_EVIL_AGGRO);
 BossAI::JustEngagedWith(who);
 
 if (Creature* kalecgosHuman = me->SummonCreature(NPC_KALECGOS_HUMAN, KalecgosSummonPos, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 1s))
 if (Creature* sathrovar = instance->GetCreature(DATA_SATHROVARR))
 {
 sathrovar->SetInCombatWith(kalecgosHuman);
 kalecgosHuman->SetInCombatWith(sathrovar);
 }
 }
 
 void KilledUnit(Unit* who) override
 {
 if (who->GetTypeId() == TYPEID_PLAYER && roll_chance_i(50))
 Talk(SAY_EVIL_SLAY);
 }
 
 void MovementInform(uint32 type, uint32 id) override
 {
 if (type != POINT_MOTION_TYPE)
 return;
 
 switch (id)
 {
 case POINT_OUTRO_1:
 Talk(SAY_OUTRO_1);
 events.ScheduleEvent(EVENT_OUTRO_3, Seconds(9));
 break;
 case POINT_OUTRO_2:
 me->SetVisible(false);
 DespawnPortals();
 me->KillSelf();
 break;
 default:
 break;
 }
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (!UpdateVictim() && !events.IsInPhase(PHASE_OUTRO))
 return;
 
 events.Update(diff);
 
 if (me->HasUnitState(UNIT_STATE_CASTING))
 return;
 
 while (uint32 eventId = events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_ARCANE_BUFFET:
 if (roll_chance_i(20))
 Talk(SAY_ARCANE_BUFFET);
 DoCastAOE(SPELL_ARCANE_BUFFET);
 events.Repeat(Seconds(8));
 break;
 case EVENT_FROST_BREATH:
 DoCastAOE(SPELL_FROST_BREATH);
 events.Repeat(Seconds(15));
 break;
 case EVENT_TAIL_LASH:
 DoCastAOE(SPELL_TAIL_LASH);
 events.Repeat(Seconds(15));
 break;
 case EVENT_WILD_MAGIC:
 DoCastAOE(WildMagicSpells[urand(0, 5)], true);
 events.Repeat(Seconds(20));
 break;
 case EVENT_SPECTRAL_BLAST:
 DoCastAOE(SPELL_SPECTRAL_BLAST, true);
 events.Repeat(Seconds(20), Seconds(25));
 break;
 case EVENT_CHECK_TIMER:
 if (!_isEnraged && HealthBelowPct(10))
 DoAction(ACTION_ENRAGE);
 
 if (HealthBelowPct(1))
 {
 if (Creature* sathrovarr = instance->GetCreature(DATA_SATHROVARR))
 {
 if (sathrovarr->HasAura(SPELL_BANISH))
 {
 sathrovarr->CastSpell(sathrovarr, SPELL_TAP_CHECK, true);
 break;
 }
 }
 if (_isBanished)
 break;
 
 _isBanished = true;
 DoCastSelf(SPELL_BANISH, true);
 events.Reset();
 }
 events.Repeat(Seconds(1));
 break;
 case EVENT_OUTRO_START:
 events.Reset();
 events.SetPhase(PHASE_OUTRO);
 me->SetRegenerateHealth(false);
 me->SetReactState(REACT_PASSIVE);
 me->InterruptNonMeleeSpells(true);
 me->RemoveAllAttackers();
 me->AttackStop();
 me->SetFaction(FACTION_FRIENDLY);
 me->RemoveAllAuras();
 instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
 events.ScheduleEvent(EVENT_OUTRO_1, Seconds(3));
 break;
 case EVENT_OUTRO_1:
 me->SetDisableGravity(true);
 me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
 events.ScheduleEvent(EVENT_OUTRO_2, Seconds(3));
 break;
 case EVENT_OUTRO_2:
 me->GetMotionMaster()->MovePoint(POINT_OUTRO_1, FlyPos[0]);
 break;
 case EVENT_OUTRO_3:
 Talk(SAY_OUTRO_2);
 me->GetMotionMaster()->MovePoint(POINT_OUTRO_2, FlyPos[1], false);
 break;
 default:
 break;
 }
 
 if (me->HasUnitState(UNIT_STATE_CASTING))
 return;
 }
 }
 
private:
 bool _isEnraged;
 bool _isBanished;
};
 
struct boss_kalecgos_human : public ScriptedAI
{
 boss_kalecgos_human(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
 void Reset() override
 {
 _events.Reset();
 _events.SetPhase(PHASE_SAY_ONE);
 
 if (Creature* sath = _instance->GetCreature(DATA_SATHROVARR))
 _sathGUID = sath->GetGUID();
 
 _events.ScheduleEvent(EVENT_REVITALIZE, 5s);
 _events.ScheduleEvent(EVENT_HEROIC_STRIKE, 3s);
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 Talk(SAY_GOOD_DEATH);
 }
 
 void DamageTaken(Unit* who, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
 {
 if (!who || who->GetGUID() != _sathGUID)
 damage = 0;
 
 if (HealthBelowPct(75) && _events.IsInPhase(PHASE_SAY_ONE))
 {
 Talk(SAY_GOOD_NEAR_DEATH_0);
 _events.SetPhase(PHASE_SAY_TWO);
 }
 else if (HealthBelowPct(50) && _events.IsInPhase(PHASE_SAY_TWO))
 {
 _events.SetPhase(PHASE_SAY_THREE);
 Talk(SAY_GOOD_NEAR_DEATH_1);
 }
 else if (HealthBelowPct(10) && _events.IsInPhase(PHASE_SAY_THREE))
 {
 _events.SetPhase(PHASE_SAY_FOUR);
 Talk(SAY_GOOD_NEAR_DEATH_2);
 }
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (!UpdateVictim())
 return;
 
 _events.Update(diff);
 
 if (me->HasUnitState(UNIT_STATE_CASTING))
 return;
 
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_REVITALIZE:
 DoCastSelf(SPELL_REVITALIZE);
 _events.Repeat(Seconds(5));
 break;
 case EVENT_HEROIC_STRIKE:
 DoCastVictim(SPELL_HEROIC_STRIKE);
 _events.Repeat(Seconds(2));
 break;
 default:
 break;
 }
 
 if (me->HasUnitState(UNIT_STATE_CASTING))
 return;
 }
 }
 
private:
 InstanceScript* _instance;
 EventMap _events;
 ObjectGuid _sathGUID;
};
 
class CurseAgonySelector : NonTankTargetSelector
{
public:
 CurseAgonySelector(Unit* source) : NonTankTargetSelector(source, true) { }
 
 bool operator()(WorldObject* target) const
 {
 if (Unit* unitTarget = target->ToUnit())
 return !NonTankTargetSelector::operator()(unitTarget)
 && !unitTarget->HasAura(SPELL_AGONY_CURSE)
 && !unitTarget->HasAura(SPELL_AGONY_CURSE_ALLY)
 && unitTarget->HasAura(SPELL_SPECTRAL_REALM_AURA);
 return false;
 }
};
 
struct boss_sathrovarr : public BossAI
{
 boss_sathrovarr(Creature* creature) : BossAI(creature, DATA_KALECGOS), _isEnraged(false), _isBanished(false) { }
 
 void Reset() override
 {
 _isEnraged = false;
 _isBanished = false;
 _Reset();
 events.ScheduleEvent(EVENT_SHADOWBOLT, 7s, 10s);
 events.ScheduleEvent(EVENT_AGONY_CURSE, 20s);
 events.ScheduleEvent(EVENT_CORRUPTION_STRIKE, 13s);
 events.ScheduleEvent(EVENT_CHECK_TIMER, 1s);
 }
 
 void JustEngagedWith(Unit* who) override
 {
 BossAI::JustEngagedWith(who);
 Talk(SAY_SATH_AGGRO);
 }
 
 void EnterEvadeMode(EvadeReason why) override
 {
 if (Creature* kalecgos = instance->GetCreature(DATA_KALECGOS_DRAGON))
 kalecgos->AI()->EnterEvadeMode(why);
 }
 
 void SpellHit(WorldObject* caster, SpellInfo const* spellInfo) override
 {
 Unit* unitCaster = caster->ToUnit();
 if (!unitCaster)
 return;
 
 if (spellInfo->Id == SPELL_TAP_CHECK_DAMAGE)
 {
 DoCastSelf(SPELL_TELEPORT_BACK, true);
 Unit::Kill(unitCaster, me);
 }
 }
 
 void DamageTaken(Unit* who, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
 {
 if (damage >= me->GetHealth() && (!who || who->GetGUID() != me->GetGUID()))
 damage = 0;
 }
 
 void KilledUnit(Unit* target) override
 {
 if (target->GetTypeId() == TYPEID_PLAYER)
 Talk(SAY_SATH_SLAY);
 else if (Creature* kalecgosHuman = instance->GetCreature(DATA_KALECGOS_HUMAN))
 {
 if (kalecgosHuman->GetGUID() == target->GetGUID())
 EnterEvadeMode(EvadeReason::Other);
 }
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 _JustDied();
 Talk(SAY_SATH_DEATH);
 instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_SPECTRAL_REALM_AURA, true, true);
 if (Creature* kalecgos = instance->GetCreature(DATA_KALECGOS_DRAGON))
 kalecgos->AI()->DoAction(ACTION_START_OUTRO);
 }
 
 void ExecuteEvent(uint32 eventId) override
 {
 switch (eventId)
 {
 case EVENT_SHADOWBOLT:
 if (roll_chance_i(20))
 Talk(SAY_SATH_SPELL1);
 DoCastAOE(SPELL_SHADOW_BOLT);
 events.Repeat(Seconds(7), Seconds(10));
 break;
 case EVENT_AGONY_CURSE:
 {
 CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
 args.AddSpellMod(SPELLVALUE_MAX_TARGETS, 1);
 if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, CurseAgonySelector(me)))
 DoCast(target, SPELL_AGONY_CURSE, args);
 else
 DoCastVictim(SPELL_AGONY_CURSE, args);
 events.Repeat(Seconds(20));
 break;
 }
 case EVENT_CORRUPTION_STRIKE:
 if (roll_chance_i(20))
 Talk(SAY_SATH_SPELL2);
 DoCastVictim(SPELL_CORRUPTION_STRIKE);
 events.Repeat(Seconds(13));
 break;
 case EVENT_CHECK_TIMER:
 {
 if (HealthBelowPct(10) && !_isEnraged)
 {
 _isEnraged = true;
 if (Creature* kalecgos = instance->GetCreature(DATA_KALECGOS_DRAGON))
 kalecgos->AI()->DoAction(ACTION_ENRAGE);
 }
 
 if (HealthBelowPct(1))
 {
 if (Creature* kalecgos = instance->GetCreature(DATA_KALECGOS_DRAGON))
 {
 if (kalecgos->HasAura(SPELL_BANISH))
 {
 DoCastSelf(SPELL_TAP_CHECK, true);
 break;
 }
 }
 if (_isBanished)
 break;
 
 _isBanished = true;
 DoCastSelf(SPELL_BANISH, true);
 }
 events.Repeat(Seconds(1));
 break;
 }
 default:
 break;
 }
 }
 
private:
 bool _isEnraged;
 bool _isBanished;
};
 
class go_kalecgos_spectral_rift : public GameObjectScript
{
 public:
 go_kalecgos_spectral_rift() : GameObjectScript("go_kalecgos_spectral_rift") { }
 
 struct go_kalecgos_spectral_riftAI : public GameObjectAI
 {
 go_kalecgos_spectral_riftAI(GameObject* go) : GameObjectAI(go) { }
 
 bool OnGossipHello(Player* player) override
 {
 if (!player->HasAura(SPELL_SPECTRAL_EXHAUSTION))
 player->CastSpell(player, SPELL_SPECTRAL_REALM_TRIGGER, true);
 return true;
 }
 };
 
 GameObjectAI* GetAI(GameObject* go) const override
 {
 return GetSunwellPlateauAI<go_kalecgos_spectral_riftAI>(go);
 }
};
 
// 46732 - Tap Check
class spell_kalecgos_tap_check : public SpellScript
{
 bool Validate(SpellInfo const* spellInfo) override
 {
 return ValidateSpellEffect({ { spellInfo->Id, EFFECT_0 } }) && ValidateSpellInfo({ uint32(spellInfo->GetEffect(EFFECT_0).CalcValue()) });
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 GetHitUnit()->CastSpell(GetCaster(), GetEffectInfo().CalcValue(), true);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_kalecgos_tap_check::HandleDummy, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
 }
};
 
class SpectralBlastSelector : NonTankTargetSelector
{
 public:
 SpectralBlastSelector(Unit* source) : NonTankTargetSelector(source, true) { }
 
 bool operator()(WorldObject* target) const
 {
 if (Unit* unitTarget = target->ToUnit())
 return !NonTankTargetSelector::operator()(unitTarget)
 && !unitTarget->HasAura(SPELL_SPECTRAL_EXHAUSTION)
 && !unitTarget->HasAura(SPELL_SPECTRAL_REALM_AURA);
 return false;
 }
};
 
// 44869 - Spectral Blast
class spell_kalecgos_spectral_blast : public SpellScript
{
 bool Validate(SpellInfo const* /*spell*/) override
 {
 return ValidateSpellInfo(
 {
 SPELL_SPECTRAL_BLAST_EFFECT,
 SPELL_SPECTRAL_BLAST_VISUAL,
 SPELL_SPECTRAL_REALM_TRIGGER
 });
 }
 
 void FilterTargets(std::list<WorldObject*>& targets)
 {
 targets.remove_if(SpectralBlastSelector(GetCaster()));
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 Unit* caster = GetCaster();
 Unit* target = GetHitUnit();
 
 target->CastSpell(target, SPELL_SPECTRAL_BLAST_EFFECT, true);
 caster->CastSpell(target, SPELL_SPECTRAL_BLAST_VISUAL, true);
 caster->CastSpell(target, SPELL_SPECTRAL_REALM_TRIGGER, true);
 }
 
 void Register() override
 {
 OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_kalecgos_spectral_blast::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
 OnEffectHitTarget += SpellEffectFn(spell_kalecgos_spectral_blast::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
 }
};
 
// 44811 - Spectral Realm
class spell_kalecgos_spectral_realm_trigger : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo(
 {
 SPELL_SPECTRAL_REALM_TELEPORT,
 SPELL_SPECTRAL_REALM_AURA,
 SPELL_SPECTRAL_REALM_2,
 SPELL_SPECTRAL_REALM_REACTION
 });
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 Unit* target = GetHitUnit();
 target->CastSpell(target, SPELL_SPECTRAL_REALM_TELEPORT, true);
 target->CastSpell(target, SPELL_SPECTRAL_REALM_AURA, true);
 target->CastSpell(target, SPELL_SPECTRAL_REALM_2, true);
 target->CastSpell(target, SPELL_SPECTRAL_REALM_REACTION, true);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_kalecgos_spectral_realm_trigger::HandleDummy, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
 }
};
 
// 46021 - Spectral Realm
class spell_kalecgos_spectral_realm_aura : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo(
 {
 SPELL_SPECTRAL_REALM_REACTION,
 SPELL_TELEPORT_BACK,
 SPELL_SPECTRAL_EXHAUSTION
 });
 }
 
 void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 Unit* target = GetTarget();
 target->RemoveAurasDueToSpell(SPELL_SPECTRAL_REALM_REACTION);
 target->CastSpell(target, SPELL_TELEPORT_BACK, true);
 target->CastSpell(target, SPELL_SPECTRAL_EXHAUSTION, true);
 }
 
 void Register() override
 {
 AfterEffectRemove += AuraEffectRemoveFn(spell_kalecgos_spectral_realm_aura::OnRemove, EFFECT_0, SPELL_AURA_MOD_INVISIBILITY_DETECT, AURA_EFFECT_HANDLE_REAL);
 }
};
 
// 45032, 45034 - Curse of Boundless Agony
class spell_kalecgos_curse_of_boundless_agony : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo(
 {
 SPELL_AGONY_CURSE_VISUAL_1,
 SPELL_AGONY_CURSE_VISUAL_2,
 SPELL_AGONY_CURSE_VISUAL_3,
 SPELL_AGONY_CURSE_ALLY
 });
 }
 
 void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 if (InstanceScript* instance = GetTarget()->GetInstanceScript())
 if (instance->GetBossState(DATA_KALECGOS) == IN_PROGRESS)
 return;
 
 Remove(AURA_REMOVE_BY_CANCEL);
 }
 
 void OnPeriodic(AuraEffect const* aurEff)
 {
 if (aurEff->GetTickNumber() <= 5)
 GetTarget()->CastSpell(GetTarget(), SPELL_AGONY_CURSE_VISUAL_1, true);
 else if (aurEff->GetTickNumber() <= 10)
 GetTarget()->CastSpell(GetTarget(), SPELL_AGONY_CURSE_VISUAL_2, true);
 else
 GetTarget()->CastSpell(GetTarget(), SPELL_AGONY_CURSE_VISUAL_3, true);
 }
 
 void HandleEffectPeriodicUpdate(AuraEffect* aurEff)
 {
 if (aurEff->GetTickNumber() > 1 && aurEff->GetTickNumber() % 5 == 1)
 aurEff->SetAmount(aurEff->GetAmount() * 2);
 }
 
 void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_CANCEL)
 return;
 
 CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
 args.AddSpellMod(SPELLVALUE_MAX_TARGETS, 1);
 GetTarget()->CastSpell(GetTarget(), SPELL_AGONY_CURSE_ALLY, args);
 }
 
 void Register() override
 {
 AfterEffectApply += AuraEffectApplyFn(spell_kalecgos_curse_of_boundless_agony::OnApply, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE, AURA_EFFECT_HANDLE_REAL);
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_kalecgos_curse_of_boundless_agony::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
 OnEffectUpdatePeriodic += AuraEffectUpdatePeriodicFn(spell_kalecgos_curse_of_boundless_agony::HandleEffectPeriodicUpdate, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
 AfterEffectRemove += AuraEffectRemoveFn(spell_kalecgos_curse_of_boundless_agony::OnRemove, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE, AURA_EFFECT_HANDLE_REAL);
 }
};
 
void AddSC_boss_kalecgos()
{
 RegisterSunwellPlateauCreatureAI(boss_kalecgos);
 RegisterSunwellPlateauCreatureAI(boss_sathrovarr);
 RegisterSunwellPlateauCreatureAI(boss_kalecgos_human);
 new go_kalecgos_spectral_rift();
 RegisterSpellScript(spell_kalecgos_tap_check);
 RegisterSpellScript(spell_kalecgos_spectral_blast);
 RegisterSpellScript(spell_kalecgos_spectral_realm_trigger);
 RegisterSpellScript(spell_kalecgos_spectral_realm_aura);
 RegisterSpellScript(spell_kalecgos_curse_of_boundless_agony);
}