boss_northrend_beasts.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 "Map.h"
#include "MotionMaster.h"
#include "ObjectAccessor.h"
#include "Player.h"
#include "ScriptedCreature.h"
#include "SpellAuraEffects.h"
#include "SpellScript.h"
#include "TemporarySummon.h"
#include "trial_of_the_crusader.h"
#include "Vehicle.h"
 
enum Yells
{
    // Gormok
    EMOTE_SNOBOLLED         = 0,
 
    // Acidmaw & Dreadscale
    EMOTE_ENRAGE            = 0,
    SAY_SPECIAL             = 1,
 
    // Icehowl
    EMOTE_TRAMPLE_ROAR     = 0,
    EMOTE_TRAMPLE_FAIL     = 1,
    EMOTE_TRAMPLE_ENRAGE   = 2
};
 
enum Model
{
    MODEL_ACIDMAW_STATIONARY     = 29815,
    MODEL_ACIDMAW_MOBILE         = 29816,
    MODEL_DREADSCALE_STATIONARY  = 26935,
    MODEL_DREADSCALE_MOBILE      = 24564
};
 
enum BossSpells
{
    // Gormok
    SPELL_IMPALE                = 66331,
    SPELL_STAGGERING_STOMP      = 66330,
    SPELL_TANKING_GORMOK        = 66415, // No idea what it does (SERVERSIDE spell)
 
    // Snobold
    SPELL_RISING_ANGER          = 66636,
    SPELL_SNOBOLLED             = 66406,
    SPELL_BATTER                = 66408,
    SPELL_FIRE_BOMB             = 66313,
    SPELL_HEAD_CRACK            = 66407,
    SPELL_JUMP_TO_HAND          = 66342,
    SPELL_RIDE_PLAYER           = 66245,
    SPELL_FIRE_BOMB_AURA        = 66318,
 
    // Acidmaw & Dreadscale Generic
    SPELL_SWEEP                 = 66794,
    SUMMON_SLIME_POOL           = 66883,
    SPELL_EMERGE                = 66947,
    SPELL_SUBMERGE              = 66948,
    SPELL_SUBMERGE_2            = 66936,
    SPELL_ENRAGE                = 68335,
    SPELL_GROUND_VISUAL_0       = 66969,
    SPELL_GROUND_VISUAL_1       = 68302,
    SPELL_HATE_TO_ZERO          = 63984,
    // Acidmaw
    SPELL_ACID_SPIT             = 66880,
    SPELL_PARALYTIC_SPRAY       = 66901,
    SPELL_PARALYTIC_BITE        = 66824,
    SPELL_ACID_SPEW             = 66818,
    SPELL_PARALYSIS             = 66830,
    SPELL_PARALYTIC_TOXIN       = 66823,
    // Dreadscale
    SPELL_BURNING_BITE          = 66879,
    SPELL_MOLTEN_SPEW           = 66821,
    SPELL_FIRE_SPIT             = 66796,
    SPELL_BURNING_SPRAY         = 66902,
    SPELL_BURNING_BILE          = 66869,
 
    // Slime Pool
    SPELL_SLIME_POOL_EFFECT     = 66882,
    SPELL_PACIFY_SELF           = 19951,
 
    // Icehowl
    SPELL_FEROCIOUS_BUTT        = 66770,
    SPELL_MASSIVE_CRASH         = 66683,
    SPELL_WHIRL                 = 67345,
    SPELL_ARCTIC_BREATH         = 66688,
    SPELL_TRAMPLE               = 66734,
    SPELL_FROTHING_RAGE         = 66759,
    SPELL_STAGGERED_DAZE        = 66758,
    SPELL_FURIOUS_CHARGE_SUMMON = 66729,
    SPELL_ROAR                  = 66736,
    SPELL_JUMP_BACK             = 66733,
    SPELL_SURGE_OF_ADRENALINE   = 68667,
    SPELL_BERSERK               = 26662
};
 
enum MyActions
{
    ACTION_ENABLE_FIRE_BOMB = 1,
    ACTION_DISABLE_FIRE_BOMB,
    ACTION_ACTIVE_SNOBOLD,
    ACTION_ENRAGE,
    ACTION_TRAMPLE_FAIL,
    ACTION_GORMOK_DEAD,
    ACTION_JORMUNGARS_DEAD
};
 
enum Events
{
    // Gormok
    EVENT_ENGAGE = 1,
    EVENT_IMPALE,
    EVENT_STAGGERING_STOMP,
    EVENT_THROW,
 
    // Snobold
    EVENT_FIRE_BOMB,
    EVENT_BATTER,
    EVENT_HEAD_CRACK,
    EVENT_SNOBOLLED,
    EVENT_CHECK_MOUNT,
 
    // Beasts Combat Stalker
    EVENT_BERSERK,
    EVENT_START_ICEHOWL,
    EVENT_START_JORGMUNGARS,
 
    // Acidmaw & Dreadscale
    EVENT_BITE,
    EVENT_SPEW,
    EVENT_SLIME_POOL,
    EVENT_SPRAY,
    EVENT_SWEEP,
    EVENT_SUBMERGE,
    EVENT_EMERGE,
    EVENT_SUMMON_ACIDMAW,
 
    // Icehowl
    EVENT_FEROCIOUS_BUTT,
    EVENT_MASSIVE_CRASH,
    EVENT_WHIRL,
    EVENT_ARCTIC_BREATH,
    EVENT_SELECT_CHARGE_TARGET,
    EVENT_ROAR_EMOTE,
    EVENT_ICEHOWL_ROAR,
    EVENT_JUMP_BACK,
    EVENT_TRAMPLE
};
 
enum Phases
{
    PHASE_EVENT = 1,
    PHASE_COMBAT,
    PHASE_MOBILE,
    PHASE_STATIONARY,
    PHASE_SUBMERGED,
    PHASE_CHARGE
};
 
enum NorthrendBeastsPoint
{
    POINT_INITIAL_MOVEMENT = 1,
    POINT_MIDDLE,
    POINT_ICEHOWL_CHARGE
};
 
enum Misc
{
    DATA_NEW_TARGET         = 1,
    GORMOK_HAND_SEAT        = 4,
    MAX_SNOBOLDS            = 4,
    SPLINE_INITIAL_MOVEMENT = 1
};
 
Position const CombatStalkerPosition = { 563.8941f, 137.3333f, 405.8467f };
 
class SnobolledTargetSelector
{
public:
    SnobolledTargetSelector() { }
 
    bool operator()(Unit* unit) const
    {
        return unit->GetTypeId() == TYPEID_PLAYER && !unit->HasAura(SPELL_RIDE_PLAYER) && !unit->HasAura(SPELL_SNOBOLLED);
    }
};
 
struct boss_northrend_beastsAI : public BossAI
{
    boss_northrend_beastsAI(Creature* creature, uint32 bossId) : BossAI(creature, bossId)
    {
        SetBoundary(instance->GetBossBoundary(DATA_NORTHREND_BEASTS));
    }
 
    void Reset() override
    {
        events.Reset();
        events.SetPhase(PHASE_EVENT);
        summons.DespawnAll();
        me->SetReactState(REACT_PASSIVE);
        HandleInitialMovement();
    }
 
    void HandleInitialMovement()
    {
        switch (me->GetEntry())
        {
            case NPC_GORMOK:
            case NPC_DREADSCALE:
                me->GetMotionMaster()->MoveAlongSplineChain(POINT_INITIAL_MOVEMENT, SPLINE_INITIAL_MOVEMENT, false);
                break;
            case NPC_ICEHOWL:
                me->GetMotionMaster()->MoveAlongSplineChain(POINT_INITIAL_MOVEMENT, SPLINE_INITIAL_MOVEMENT, true);
                break;
            default:
                break;
        }
    }
 
    void HandleWithHeroicEvents()
    {
        if (Creature* combatStalker = instance->GetCreature(DATA_BEASTS_COMBAT_STALKER))
        {
            if (me->GetEntry() == NPC_GORMOK)
                combatStalker->AI()->DoAction(ACTION_START_JORMUNGARS);
            else if (me->GetEntry() == NPC_DREADSCALE)
                combatStalker->AI()->DoAction(ACTION_START_ICEHOWL);
        }
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        me->setActive(true);
        ScheduleTasks();
        HandleInstanceProgress();
        instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, me);
        if (IsHeroic())
            HandleWithHeroicEvents();
    }
 
    void HandleInstanceProgress()
    {
        switch (me->GetEntry())
        {
            case NPC_GORMOK:
                instance->SetData(TYPE_NORTHREND_BEASTS, GORMOK_IN_PROGRESS);
                break;
            case NPC_ACIDMAW:
            case NPC_DREADSCALE:
                if (instance->GetData(TYPE_NORTHREND_BEASTS) != SNAKES_IN_PROGRESS)
                    instance->SetData(TYPE_NORTHREND_BEASTS, SNAKES_IN_PROGRESS);
                break;
            case NPC_ICEHOWL:
                instance->SetData(TYPE_NORTHREND_BEASTS, ICEHOWL_IN_PROGRESS);
                break;
            default:
                break;
        }
    }
 
    void EnterEvadeMode(EvadeReason why) override
    {
        ScriptedAI::EnterEvadeMode(why);
        instance->SetData(DATA_DESPAWN_SNOBOLDS, 0);
        instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
        // prevent losing 2 attempts at once on heroics
        if (instance->GetData(TYPE_NORTHREND_BEASTS) != FAIL)
            instance->SetData(TYPE_NORTHREND_BEASTS, FAIL);
        if (Creature* combatStalker = instance->GetCreature(DATA_BEASTS_COMBAT_STALKER))
            combatStalker->DespawnOrUnsummon();
        summons.DespawnAll();
        me->DespawnOrUnsummon();
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
        if (me->GetEntry() == NPC_GORMOK)
        {
            instance->SetData(TYPE_NORTHREND_BEASTS, GORMOK_DONE);
            if (Creature* combatStalker = instance->GetCreature(DATA_BEASTS_COMBAT_STALKER))
                combatStalker->AI()->DoAction(ACTION_GORMOK_DEAD);
        }
        else
            instance->SetData(TYPE_NORTHREND_BEASTS, ICEHOWL_DONE);
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim() && !events.IsInPhase(PHASE_EVENT))
            return;
 
        events.Update(diff);
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        while (uint32 eventId = events.ExecuteEvent())
        {
            ExecuteEvent(eventId);
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
};
 
struct boss_gormok : public boss_northrend_beastsAI
{
    boss_gormok(Creature* creature) : boss_northrend_beastsAI(creature, DATA_GORMOK_THE_IMPALER) { }
 
    void ScheduleTasks() override
    {
        events.ScheduleEvent(EVENT_IMPALE, 10s);
        events.ScheduleEvent(EVENT_STAGGERING_STOMP, 15s);
        events.ScheduleEvent(EVENT_THROW, 20s);
    }
 
    void PassengerBoarded(Unit* who, int8 seatId, bool apply) override
    {
        if (apply && seatId == GORMOK_HAND_SEAT)
            who->CastSpell(who, SPELL_RISING_ANGER, true);
    }
 
    void MovementInform(uint32 type, uint32 pointId) override
    {
        if (type == SPLINE_CHAIN_MOTION_TYPE && pointId == POINT_INITIAL_MOVEMENT)
            events.ScheduleEvent(EVENT_ENGAGE, 7s);
    }
 
    void ExecuteEvent(uint32 eventId) override
    {
        switch (eventId)
        {
            case EVENT_ENGAGE:
                instance->DoUseDoorOrButton(instance->GetGuidData(DATA_MAIN_GATE));
                me->SetImmuneToPC(false);
                me->SetReactState(REACT_AGGRESSIVE);
                // Npc that should keep raid in combat while boss change
                if (Creature* combatStalker = me->SummonCreature(NPC_BEASTS_COMBAT_STALKER, CombatStalkerPosition))
                    DoZoneInCombat(combatStalker);
                DoZoneInCombat();
                events.SetPhase(PHASE_COMBAT);
                DoCastSelf(SPELL_TANKING_GORMOK, true);
                break;
            case EVENT_IMPALE:
                DoCastVictim(SPELL_IMPALE);
                events.Repeat(10s);
                break;
            case EVENT_STAGGERING_STOMP:
                DoCastVictim(SPELL_STAGGERING_STOMP);
                events.Repeat(22s);
                break;
            case EVENT_THROW:
                for (uint8 i = 0; i < MAX_SNOBOLDS; ++i)
                {
                    if (Unit* snobold = me->GetVehicleKit()->GetPassenger(i))
                    {
                        snobold->ExitVehicle();
                        snobold->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
                        snobold->SetUninteractible(false);
                        snobold->GetAI()->DoAction(ACTION_DISABLE_FIRE_BOMB);
                        snobold->CastSpell(me, SPELL_JUMP_TO_HAND, true);
                        break;
                    }
                }
                events.Repeat(20s);
                break;
            default:
                break;
        }
    }
};
 
struct npc_snobold_vassal : public ScriptedAI
{
    npc_snobold_vassal(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()), _mountedOnPlayer(false), _gormokDead(false)
    {
        _instance->SetData(DATA_SNOBOLD_COUNT, INCREASE);
        SetCombatMovement(false);
    }
 
    bool CanAIAttack(Unit const* who) const override
    {
        if (_mountedOnPlayer && who->GetGUID() != _targetGUID)
            return false;
 
        return ScriptedAI::CanAIAttack(who);
    }
 
    void AttackStart(Unit* victim) override
    {
        Creature* gormok = _instance->GetCreature(DATA_GORMOK_THE_IMPALER);
        if (!_mountedOnPlayer && (!gormok || !gormok->IsAlive()))
            AttackStartCaster(victim, 30.0f);
        else
            ScriptedAI::AttackStart(victim);
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        _events.ScheduleEvent(EVENT_CHECK_MOUNT, 3s);
        _events.ScheduleEvent(EVENT_FIRE_BOMB, 12s, 25s);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        _instance->SetData(DATA_SNOBOLD_COUNT, DECREASE);
    }
 
    void DoAction(int32 action) override
    {
        switch (action)
        {
            case ACTION_ENABLE_FIRE_BOMB:
                _events.ScheduleEvent(EVENT_FIRE_BOMB, 12s, 25s);
                break;
            case ACTION_DISABLE_FIRE_BOMB:
                _events.CancelEvent(EVENT_FIRE_BOMB);
                break;
            case ACTION_ACTIVE_SNOBOLD:
                _mountedOnPlayer = true;
                me->SetCanMelee(true);
                break;
            default:
                break;
        }
    }
 
    void SetGUID(ObjectGuid const& guid, int32 id) override
    {
        if (id == DATA_NEW_TARGET)
            if (Unit* target = ObjectAccessor::GetPlayer(*me, guid))
            {
                _targetGUID = guid;
                AttackStart(target);
                _events.ScheduleEvent(EVENT_BATTER, 5s);
                _events.ScheduleEvent(EVENT_SNOBOLLED, 1s);
                _events.ScheduleEvent(EVENT_HEAD_CRACK, 1s);
            }
    }
 
    void MountOnBoss()
    {
        Unit* gormok = _instance->GetCreature(DATA_GORMOK_THE_IMPALER);
        if (gormok && gormok->IsAlive())
        {
            me->AttackStop();
            me->SetCanMelee(false);
            _targetGUID.Clear();
            _mountedOnPlayer = false;
            _events.CancelEvent(EVENT_BATTER);
            _events.CancelEvent(EVENT_HEAD_CRACK);
 
            for (uint8 i = 0; i < MAX_SNOBOLDS; i++)
            {
                if (!gormok->GetVehicleKit()->GetPassenger(i))
                {
                    me->EnterVehicle(gormok, i);
                    DoAction(ACTION_ENABLE_FIRE_BOMB);
                    break;
                }
            }
        }
        else
        {
            me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
            me->SetUninteractible(false);
            _events.CancelEvent(EVENT_CHECK_MOUNT);
            _events.CancelEvent(EVENT_FIRE_BOMB);
            me->AttackStop();
            me->SetCanMelee(true);
            SetCombatMovement(true);
            _gormokDead = true;
            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true))
            {
                AttackStart(target);
                me->GetMotionMaster()->MoveChase(target);
                _events.ScheduleEvent(EVENT_BATTER, 5s);
                _events.ScheduleEvent(EVENT_HEAD_CRACK, 1s);
            }
        }
    }
 
    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_FIRE_BOMB:
                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true))
                        me->CastSpell(target, SPELL_FIRE_BOMB);
                    _events.Repeat(20s, 30s);
                    break;
                case EVENT_HEAD_CRACK:
                    if (Unit* target = me->GetVehicleBase())
                        DoCast(target, SPELL_HEAD_CRACK);
                    else
                        DoCastVictim(SPELL_HEAD_CRACK);
                    _events.Repeat(30s);
                    break;
                case EVENT_BATTER:
                    if (Unit* target = me->GetVehicleBase())
                        DoCast(target, SPELL_BATTER);
                    else
                        DoCastVictim(SPELL_BATTER);
                    _events.Repeat(10s, 15s);
                    break;
                case EVENT_SNOBOLLED:
                    DoCastSelf(SPELL_SNOBOLLED);
                    break;
                case EVENT_CHECK_MOUNT:
                    if (!me->GetVehicleBase())
                        MountOnBoss();
                    _events.Repeat(3s);
                    break;
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
 
private:
    EventMap _events;
    InstanceScript* _instance;
    ObjectGuid _targetGUID;
    bool _mountedOnPlayer;
    bool _gormokDead;
};
 
struct npc_fire_bomb : public ScriptedAI
{
    npc_fire_bomb(Creature* creature) : ScriptedAI(creature) { }
 
    void Reset() override
    {
        DoCastSelf(SPELL_FIRE_BOMB_AURA);
    }
};
 
struct npc_beasts_combat_stalker : public ScriptedAI
{
    npc_beasts_combat_stalker(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
    void Reset() override
    {
        me->SetReactState(REACT_PASSIVE);
        _events.ScheduleEvent(EVENT_BERSERK, IsHeroic() ? 9min : 15min);
    }
 
    void DoAction(int32 action) override
    {
        switch (action)
        {
            case ACTION_START_JORMUNGARS:
                _events.ScheduleEvent(EVENT_START_JORGMUNGARS, 2min + 30s);
                break;
            case ACTION_GORMOK_DEAD:
                _events.CancelEvent(EVENT_START_JORGMUNGARS);
                break;
            case ACTION_START_ICEHOWL:
                _events.ScheduleEvent(EVENT_START_ICEHOWL, 2min + 30s);
                break;
            case ACTION_JORMUNGARS_DEAD:
                _events.CancelEvent(EVENT_START_ICEHOWL);
                break;
            default:
                break;
        }
    }
 
    void UpdateAI(uint32 diff) override
    {
        _events.Update(diff);
 
        while (uint32 eventId = _events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_BERSERK:
                    if (Creature* gormok = _instance->GetCreature(DATA_GORMOK_THE_IMPALER))
                        gormok->CastSpell(gormok, SPELL_BERSERK, true);
 
                    if (Creature* dreadscale = _instance->GetCreature(DATA_DREADSCALE))
                        dreadscale->CastSpell(dreadscale, SPELL_BERSERK, true);
 
                    if (Creature* acidmaw = _instance->GetCreature(DATA_ACIDMAW))
                        acidmaw->CastSpell(acidmaw, SPELL_BERSERK, true);
 
                    if (Creature* icehowl = _instance->GetCreature(DATA_ICEHOWL))
                        icehowl->CastSpell(icehowl, SPELL_BERSERK, true);
                    break;
                case EVENT_START_JORGMUNGARS:
                    if (Creature* tirion = _instance->GetCreature(DATA_FORDRING))
                        tirion->AI()->DoAction(ACTION_START_JORMUNGARS);
                    break;
                case EVENT_START_ICEHOWL:
                    if (Creature* tirion = _instance->GetCreature(DATA_FORDRING))
                        tirion->AI()->DoAction(ACTION_START_ICEHOWL);
                    break;
                default:
                    break;
            }
        }
    }
 
private:
    EventMap _events;
    InstanceScript* _instance;
};
 
struct boss_jormungarAI : public boss_northrend_beastsAI
{
    boss_jormungarAI(Creature* creature, uint32 bossId) : boss_northrend_beastsAI(creature, bossId)
    {
        Initialize();
    }
 
    void Initialize()
    {
        otherWormEntry = 0;
        modelStationary = 0;
        modelMobile = 0;
        biteSpell = 0;
        spewSpell = 0;
        spitSpell = 0;
        spraySpell = 0;
        wasMobile = false;
    }
 
    void Reset() override
    {
        Initialize();
        boss_northrend_beastsAI::Reset();
        me->SetCanMelee(true);
    }
 
    void JustSummoned(Creature* summoned) override
    {
        if (summoned->GetEntry() == NPC_ACIDMAW)
            BossAI::JustSummoned(summoned);
        else
            summons.Summon(summoned);
    }
 
    void ScheduleTasks() override
    {
        if (events.IsInPhase(PHASE_STATIONARY))
        {
            events.ScheduleEvent(EVENT_SPRAY, me->GetEntry() == NPC_DREADSCALE ? 17s : 9s, 0, PHASE_STATIONARY);
            events.ScheduleEvent(EVENT_SWEEP, 16s, 0, PHASE_STATIONARY);
        }
        else
        {
            events.ScheduleEvent(EVENT_BITE, 5s, 0, PHASE_MOBILE);
            events.ScheduleEvent(EVENT_SPEW, 10s, 0, PHASE_MOBILE);
            events.ScheduleEvent(EVENT_SLIME_POOL, 14s, 0, PHASE_MOBILE);
        }
 
        events.ScheduleEvent(EVENT_SUBMERGE, 45s);
    }
 
    uint32 GetOtherWormData(uint32 wormEntry)
    {
        return wormEntry == NPC_ACIDMAW ? DATA_ACIDMAW : DATA_DREADSCALE;
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        if (Creature* otherWorm = instance->GetCreature(GetOtherWormData(otherWormEntry)))
        {
            if (!otherWorm->IsAlive())
            {
                instance->SetData(TYPE_NORTHREND_BEASTS, SNAKES_DONE);
                me->DespawnOrUnsummon();
                otherWorm->DespawnOrUnsummon();
                if (Creature* combatStalker = instance->GetCreature(DATA_BEASTS_COMBAT_STALKER))
                    combatStalker->AI()->DoAction(ACTION_JORMUNGARS_DEAD);
            }
            else
            {
                instance->SetData(TYPE_NORTHREND_BEASTS, SNAKES_SPECIAL);
                otherWorm->AI()->DoAction(ACTION_ENRAGE);
            }
        }
        instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
    }
 
    void DoAction(int32 action) override
    {
        if (action == ACTION_ENRAGE)
        {
            DoCastSelf(SPELL_ENRAGE, true);
            Talk(EMOTE_ENRAGE);
            if (events.IsInPhase(PHASE_SUBMERGED))
                events.RescheduleEvent(EVENT_EMERGE, 1ms);
        }
    }
 
    void Submerge()
    {
        me->SetReactState(REACT_PASSIVE);
        me->AttackStop();
        me->HandleEmoteCommand(EMOTE_ONESHOT_SUBMERGE);
 
        if (wasMobile)
        {
            DoCastSelf(SPELL_SUBMERGE);
            me->SetSpeedRate(MOVE_RUN, 8.0f);
            DoCastSelf(SPELL_GROUND_VISUAL_0, true);
            events.SetPhase(PHASE_SUBMERGED);
            events.ScheduleEvent(EVENT_EMERGE, 5s, 0, PHASE_SUBMERGED);
        }
        else
        {
            DoCastSelf(SPELL_SUBMERGE_2);
            me->RemoveAurasDueToSpell(SPELL_GROUND_VISUAL_1);
            me->SetSpeedRate(MOVE_RUN, 1.1111f);
            DoCastSelf(SPELL_GROUND_VISUAL_0, true);
            events.SetPhase(PHASE_SUBMERGED);
            me->SetControlled(false, UNIT_STATE_ROOT);
            events.ScheduleEvent(EVENT_EMERGE, 6s, 0, PHASE_SUBMERGED);
        }
 
        me->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
        me->SetUninteractible(true);
        me->SetCanMelee(false);
        me->GetMotionMaster()->MovePoint(0, ToCCommonLoc[1].GetPositionX() + frand(-40.0f, 40.0f), ToCCommonLoc[1].GetPositionY() + frand(-40.0f, 40.0f), ToCCommonLoc[1].GetPositionZ() + me->GetCollisionHeight());
    }
 
    void Emerge()
    {
        me->UpdateSpeed(MOVE_RUN);
        uint32 submergeSpell = wasMobile ? SPELL_SUBMERGE : SPELL_SUBMERGE_2;
        me->RemoveAurasDueToSpell(submergeSpell);
        me->RemoveAurasDueToSpell(SPELL_GROUND_VISUAL_0);
        DoCastSelf(SPELL_EMERGE);
        DoCastAOE(SPELL_HATE_TO_ZERO, true);
        me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
        me->SetUninteractible(false);
        me->SetReactState(REACT_AGGRESSIVE);
        if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
            AttackStart(target);
 
        // if the worm was mobile before submerging, make him stationary now
        if (wasMobile)
        {
            me->SetControlled(true, UNIT_STATE_ROOT);
            me->SetDisplayId(modelStationary);
            me->SetCanMelee(false);
            DoCastSelf(SPELL_GROUND_VISUAL_1, true);
            events.SetPhase(PHASE_STATIONARY);
        }
        else
        {
            if (Unit* target = me->GetVictim())
                me->GetMotionMaster()->MoveChase(target);
            me->SetDisplayId(modelMobile);
            me->SetCanMelee(true);
            events.SetPhase(PHASE_MOBILE);
        }
        wasMobile = !wasMobile;
        ScheduleTasks();
    }
 
    void ExecuteEvent(uint32 eventId) override
    {
        switch (eventId)
        {
            case EVENT_ENGAGE:
                if (me->GetEntry() == NPC_DREADSCALE)
                {
                    instance->DoCloseDoorOrButton(instance->GetGuidData(DATA_MAIN_GATE));
                    me->SetImmuneToPC(false);
                    me->SetCanMelee(true);
                    events.SetPhase(PHASE_MOBILE);
                    me->SetReactState(REACT_AGGRESSIVE);
                    DoZoneInCombat();
                    events.ScheduleEvent(EVENT_SUMMON_ACIDMAW, 1ms);
                }
                else
                {
                    me->SetReactState(REACT_AGGRESSIVE);
                    DoZoneInCombat();
                }
                break;
            case EVENT_EMERGE:
                Emerge();
                break;
            case EVENT_SUBMERGE:
                Submerge();
                break;
            case EVENT_BITE:
                DoCastVictim(biteSpell);
                events.Repeat(15s);
                break;
            case EVENT_SPEW:
                DoCastAOE(spewSpell);
                events.Repeat(21s);
                break;
            case EVENT_SLIME_POOL:
                DoCastSelf(SUMMON_SLIME_POOL);
                events.Repeat(12s);
                break;
            case EVENT_SUMMON_ACIDMAW:
                me->SummonCreature(NPC_ACIDMAW, ToCCommonLoc[9]);
                break;
            case EVENT_SPRAY:
                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 1, 0.0f, true))
                    DoCast(target, spraySpell);
                events.Repeat(21s);
                break;
            case EVENT_SWEEP:
                DoCastAOE(SPELL_SWEEP);
                events.Repeat(17s);
                break;
            default:
                break;
        }
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim() && !events.IsInPhase(PHASE_EVENT))
            return;
 
        events.Update(diff);
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        while (uint32 eventId = events.ExecuteEvent())
        {
            ExecuteEvent(eventId);
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
 
        if (!events.IsInPhase(PHASE_MOBILE))
            DoCastVictim(spitSpell);
    }
 
    protected:
        uint32 otherWormEntry;
        uint32 modelStationary;
        uint32 modelMobile;
        uint32 biteSpell;
        uint32 spewSpell;
        uint32 spitSpell;
        uint32 spraySpell;
        bool wasMobile;
};
 
struct boss_dreadscale : public boss_jormungarAI
{
    boss_dreadscale(Creature* creature) : boss_jormungarAI(creature, DATA_DREADSCALE) { }
 
    void Reset() override
    {
        boss_northrend_beastsAI::Reset();
        biteSpell = SPELL_BURNING_BITE;
        spewSpell = SPELL_MOLTEN_SPEW;
        spitSpell = SPELL_FIRE_SPIT;
        spraySpell = SPELL_BURNING_SPRAY;
        modelStationary = MODEL_DREADSCALE_STATIONARY;
        modelMobile = MODEL_DREADSCALE_MOBILE;
        otherWormEntry = NPC_ACIDMAW;
        wasMobile = true;
    }
 
    void MovementInform(uint32 type, uint32 pointId) override
    {
        if (type == SPLINE_CHAIN_MOTION_TYPE && pointId == POINT_INITIAL_MOVEMENT)
            events.ScheduleEvent(EVENT_ENGAGE, 3s);
    }
};
 
struct boss_acidmaw : public boss_jormungarAI
{
    boss_acidmaw(Creature* creature) : boss_jormungarAI(creature, DATA_ACIDMAW) { }
 
    void Reset() override
    {
        boss_northrend_beastsAI::Reset();
        biteSpell = SPELL_PARALYTIC_BITE;
        spewSpell = SPELL_ACID_SPEW;
        spitSpell = SPELL_ACID_SPIT;
        spraySpell = SPELL_PARALYTIC_SPRAY;
        modelStationary = MODEL_ACIDMAW_STATIONARY;
        modelMobile = MODEL_ACIDMAW_MOBILE;
        otherWormEntry = NPC_DREADSCALE;
        events.SetPhase(PHASE_STATIONARY);
        wasMobile = false;
        me->SetControlled(true, UNIT_STATE_ROOT);
        DoCastSelf(SPELL_GROUND_VISUAL_1, true);
        events.ScheduleEvent(EVENT_ENGAGE, 3s);
    }
};
 
struct npc_jormungars_slime_pool : public ScriptedAI
{
    npc_jormungars_slime_pool(Creature* creature) : ScriptedAI(creature) { }
 
    void Reset() override
    {
        me->m_Events.AddEventAtOffset([this]()
        {
            DoCastSelf(SPELL_SLIME_POOL_EFFECT, true);
            DoCastSelf(SPELL_PACIFY_SELF, true);
        }, 1s);
    }
};
 
struct boss_icehowl : public boss_northrend_beastsAI
{
    boss_icehowl(Creature* creature) : boss_northrend_beastsAI(creature, DATA_ICEHOWL) { }
 
    void ScheduleTasks() override
    {
        events.ScheduleEvent(EVENT_FEROCIOUS_BUTT, 8s, 0, PHASE_COMBAT);
        events.ScheduleEvent(EVENT_ARCTIC_BREATH, 20s, 0, PHASE_COMBAT);
        events.ScheduleEvent(EVENT_WHIRL, 15s, 0, PHASE_COMBAT);
        events.ScheduleEvent(EVENT_MASSIVE_CRASH, 35s, 0, PHASE_COMBAT);
    }
 
    void RescheduleTasks()
    {
        events.ScheduleEvent(EVENT_FEROCIOUS_BUTT, 8s, 0, PHASE_COMBAT);
        events.ScheduleEvent(EVENT_ARCTIC_BREATH, 20s, 0, PHASE_COMBAT);
        events.ScheduleEvent(EVENT_WHIRL, 15s, 0, PHASE_COMBAT);
        events.ScheduleEvent(EVENT_MASSIVE_CRASH, 45s, 0, PHASE_COMBAT);
    }
 
    void MovementInform(uint32 type, uint32 pointId) override
    {
        if (type != POINT_MOTION_TYPE && type != EFFECT_MOTION_TYPE && type != SPLINE_CHAIN_MOTION_TYPE)
            return;
 
        switch (pointId)
        {
            case POINT_INITIAL_MOVEMENT:
                events.ScheduleEvent(EVENT_ENGAGE, 3s);
                break;
            case POINT_MIDDLE:
                DoCastSelf(SPELL_MASSIVE_CRASH);
                events.ScheduleEvent(EVENT_SELECT_CHARGE_TARGET, 4s);
                break;
            case POINT_ICEHOWL_CHARGE:
                events.Reset();
                events.SetPhase(PHASE_COMBAT);
                RescheduleTasks();
                me->SetReactState(REACT_AGGRESSIVE);
                DoCastSelf(SPELL_TRAMPLE);
                break;
            default:
                break;
        }
    }
 
    void DoAction(int32 action) override
    {
        if (action == ACTION_ENRAGE)
        {
            DoCastSelf(SPELL_FROTHING_RAGE, true);
            Talk(EMOTE_TRAMPLE_ENRAGE);
        }
        else if (action == ACTION_TRAMPLE_FAIL)
        {
            DoCastSelf(SPELL_STAGGERED_DAZE, true);
            Talk(EMOTE_TRAMPLE_FAIL);
            events.DelayEvents(15s);
        }
    }
 
    void ExecuteEvent(uint32 eventId) override
    {
        switch (eventId)
        {
            case EVENT_ENGAGE:
                instance->DoCloseDoorOrButton(instance->GetGuidData(DATA_MAIN_GATE));
                me->SetImmuneToPC(false);
                events.SetPhase(PHASE_COMBAT);
                me->SetReactState(REACT_AGGRESSIVE);
                DoZoneInCombat();
                break;
            case EVENT_MASSIVE_CRASH:
                me->SetReactState(REACT_PASSIVE);
                me->AttackStop();
                events.SetPhase(PHASE_CHARGE);
                me->GetMotionMaster()->MoveJump(POINT_MIDDLE, ToCCommonLoc[1], 50.0f, 2.0f);
                break;
            case EVENT_SELECT_CHARGE_TARGET:
                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true))
                {
                    DoCast(target, SPELL_FURIOUS_CHARGE_SUMMON, true);
                    me->SetTarget(target->GetGUID());
                    Talk(EMOTE_TRAMPLE_ROAR, target);
                    events.ScheduleEvent(EVENT_ICEHOWL_ROAR, 1s);
                }
                break;
            case EVENT_ICEHOWL_ROAR:
                if (Creature* stalker = instance->GetCreature(DATA_FURIOUS_CHARGE))
                    DoCast(stalker, SPELL_ROAR);
                events.ScheduleEvent(EVENT_JUMP_BACK, 3s, 0, PHASE_CHARGE);
                break;
            case EVENT_JUMP_BACK:
                if (Creature* stalker = instance->GetCreature(DATA_FURIOUS_CHARGE))
                    DoCast(stalker, SPELL_JUMP_BACK);
                events.ScheduleEvent(EVENT_TRAMPLE, 2s, 0, PHASE_CHARGE);
                break;
            case EVENT_TRAMPLE:
                if (Creature* stalker = instance->GetCreature(DATA_FURIOUS_CHARGE))
                    me->GetMotionMaster()->MoveCharge(stalker->GetPositionX(), stalker->GetPositionY(), stalker->GetPositionZ(), 42.0f, POINT_ICEHOWL_CHARGE);
                me->SetTarget(ObjectGuid::Empty);
                break;
            case EVENT_FEROCIOUS_BUTT:
                DoCastVictim(SPELL_FEROCIOUS_BUTT);
                events.Repeat(20s);
                break;
            case EVENT_ARCTIC_BREATH:
                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true))
                    DoCast(target, SPELL_ARCTIC_BREATH);
                events.Repeat(24s);
                break;
            case EVENT_WHIRL:
                DoCastSelf(SPELL_WHIRL);
                events.Repeat(16s);
                break;
            default:
                break;
        }
    }
};
 
// 66342 - Jump to Hand
class spell_gormok_jump_to_hand : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_RIDE_PLAYER });
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        Unit* caster = GetCaster();
        if (!caster || caster->GetEntry() != NPC_SNOBOLD_VASSAL)
            return;
 
        if (Creature* gormok = GetTarget()->ToCreature())
            if (Unit* target = gormok->AI()->SelectTarget(SelectTargetMethod::Random, 0, SnobolledTargetSelector()))
            {
                gormok->AI()->Talk(EMOTE_SNOBOLLED);
                caster->GetAI()->DoAction(ACTION_ACTIVE_SNOBOLD);
                caster->CastSpell(target, SPELL_RIDE_PLAYER, true);
            }
    }
 
    void Register() override
    {
        AfterEffectRemove += AuraEffectRemoveFn(spell_gormok_jump_to_hand::OnRemove, EFFECT_0, SPELL_AURA_CONTROL_VEHICLE, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 66245 - Ride Vehicle
class spell_gormok_ride_player : public AuraScript
{
    void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        Unit* target = GetTarget();
        if (target->GetTypeId() != TYPEID_PLAYER || !target->IsInWorld())
            return;
 
        if (Unit *caster = GetCaster())
            if (caster->IsAIEnabled())
                caster->GetAI()->SetGUID(target->GetGUID(), DATA_NEW_TARGET);
    }
 
    void Register() override
    {
        OnEffectApply += AuraEffectApplyFn(spell_gormok_ride_player::OnApply, EFFECT_0, SPELL_AURA_CONTROL_VEHICLE, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 66406 - Snobolled!
class spell_gormok_snobolled : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_RIDE_PLAYER });
    }
 
    void OnPeriodic(AuraEffect const* /*aurEff*/)
    {
        if (!GetTarget()->HasAura(SPELL_RIDE_PLAYER))
            Remove();
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_gormok_snobolled::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
    }
};
 
// 66823, 67618, 67619, 67620 - Paralytic Toxin
class spell_jormungars_paralytic_toxin : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_PARALYSIS });
    }
 
    void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        Unit* caster = GetCaster();
        if (caster && caster->GetEntry() == NPC_ACIDMAW)
            if (Creature* acidmaw = caster->ToCreature())
                acidmaw->AI()->Talk(SAY_SPECIAL, GetTarget());
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        GetTarget()->RemoveAurasDueToSpell(SPELL_PARALYSIS);
    }
 
    void CalculateAmount(AuraEffect const* aurEff, SpellEffectValue& amount, bool& canBeRecalculated)
    {
        if (!canBeRecalculated)
            amount = aurEff->GetAmount();
 
        canBeRecalculated = false;
    }
 
    void HandleDummy(AuraEffect const* /*aurEff*/)
    {
        if (AuraEffect* slowEff = GetEffect(EFFECT_0))
        {
            SpellEffectValue newAmount = slowEff->GetAmount() - 10;
            if (newAmount < -100)
                newAmount = -100;
            slowEff->ChangeAmount(newAmount);
 
            if (newAmount == -100 && !GetTarget()->HasAura(SPELL_PARALYSIS))
                GetTarget()->CastSpell(GetTarget(), SPELL_PARALYSIS, CastSpellExtraArgs(slowEff).SetOriginalCaster(GetCasterGUID()));
        }
    }
 
    void Register() override
    {
        AfterEffectApply += AuraEffectApplyFn(spell_jormungars_paralytic_toxin::OnApply, EFFECT_0, SPELL_AURA_MOD_DECREASE_SPEED, AURA_EFFECT_HANDLE_REAL);
        AfterEffectRemove += AuraEffectRemoveFn(spell_jormungars_paralytic_toxin::OnRemove, EFFECT_0, SPELL_AURA_MOD_DECREASE_SPEED, AURA_EFFECT_HANDLE_REAL);
        DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_jormungars_paralytic_toxin::CalculateAmount, EFFECT_0, SPELL_AURA_MOD_DECREASE_SPEED);
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_jormungars_paralytic_toxin::HandleDummy, EFFECT_2, SPELL_AURA_PERIODIC_DUMMY);
    }
};
 
// 66870, 67621, 67622, 67623 - Burning Bile
class spell_jormungars_burning_bile : public SpellScript
{
    void HandleScriptEffect(SpellEffIndex effIndex)
    {
        PreventHitDefaultEffect(effIndex);
        GetHitUnit()->RemoveAurasByType(SPELL_AURA_MOD_DECREASE_SPEED);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_jormungars_burning_bile::HandleScriptEffect, EFFECT_1, SPELL_EFFECT_SCRIPT_EFFECT);
    }
};
 
// 66882 - Slime Pool
class spell_jormungars_slime_pool : 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();
 
        float const radius = ((aurEff->GetTickNumber() / 60.f) * 0.9f + 0.1f) * 2.f / 3.f;
        CastSpellExtraArgs args(aurEff);
        args.AddSpellMod(SPELLVALUE_RADIUS_MOD, radius);
        GetTarget()->CastSpell(nullptr, aurEff->GetSpellEffectInfo().TriggerSpell, args);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_jormungars_slime_pool::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
    }
};
 
/* 66869 - Burning Bile
   66823 - Paralytic Toxin */
class spell_jormungars_snakes_spray : public SpellScript
{
public:
    spell_jormungars_snakes_spray(uint32 spellId) : SpellScript(), _spellId(spellId) { }
 
private:
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ _spellId });
    }
 
    void HandleScript(SpellEffIndex /*effIndex*/)
    {
        GetCaster()->CastSpell(GetHitUnit(), _spellId, true);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_jormungars_snakes_spray::HandleScript, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
    }
 
    uint32 _spellId;
};
 
// 66830 - Paralysis
class spell_jormungars_paralysis : public AuraScript
{
    void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        if (Unit* caster = GetCaster())
            if (InstanceScript* instance = caster->GetInstanceScript())
                if (instance->GetBossState(DATA_NORTHREND_BEASTS) == IN_PROGRESS)
                    return;
 
        Remove();
    }
 
    void Register() override
    {
        AfterEffectApply += AuraEffectApplyFn(spell_jormungars_paralysis::OnApply, EFFECT_0, SPELL_AURA_MOD_STUN, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 66688 - Arctic Breath
class spell_icehowl_arctic_breath : public SpellScript
{
    bool Validate(SpellInfo const* spellInfo) override
    {
        return ValidateSpellEffect({ { spellInfo->Id, EFFECT_0 } }) && ValidateSpellInfo({ static_cast<uint32>(spellInfo->GetEffect(EFFECT_0).CalcValueAsInt()) });
    }
 
    void HandleScriptEffect(SpellEffIndex /*effIndex*/)
    {
        uint32 spellId = GetEffectInfo().CalcValueAsInt();
        GetCaster()->CastSpell(GetHitUnit(), spellId, true);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_icehowl_arctic_breath::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
    }
};
 
// 66734 - Trample
class spell_icehowl_trample : public SpellScript
{
    void CheckTargets(std::list<WorldObject*>& targets)
    {
        Creature* caster = GetCaster()->ToCreature();
        if (!caster || !caster->IsAIEnabled())
            return;
 
        if (targets.empty())
            caster->AI()->DoAction(ACTION_TRAMPLE_FAIL);
        else
            caster->AI()->DoAction(ACTION_ENRAGE);
    }
 
    void Register() override
    {
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_icehowl_trample::CheckTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
    }
};
 
// 66683 - Massive Crash
class spell_icehowl_massive_crash : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_SURGE_OF_ADRENALINE });
    }
 
    void HandleSpeed(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        if (Player* target = GetTarget()->ToPlayer())
            if (target->GetMap()->IsHeroic())
                target->CastSpell(target, SPELL_SURGE_OF_ADRENALINE, true);
    }
 
    void Register() override
    {
        AfterEffectRemove += AuraEffectRemoveFn(spell_icehowl_massive_crash::HandleSpeed, EFFECT_2, SPELL_AURA_MOD_STUN, AURA_EFFECT_HANDLE_REAL);
    }
};
 
void AddSC_boss_northrend_beasts()
{
    RegisterTrialOfTheCrusaderCreatureAI(boss_gormok);
    RegisterTrialOfTheCrusaderCreatureAI(npc_snobold_vassal);
    RegisterTrialOfTheCrusaderCreatureAI(npc_beasts_combat_stalker);
    RegisterTrialOfTheCrusaderCreatureAI(boss_acidmaw);
    RegisterTrialOfTheCrusaderCreatureAI(boss_dreadscale);
    RegisterTrialOfTheCrusaderCreatureAI(npc_jormungars_slime_pool);
    RegisterTrialOfTheCrusaderCreatureAI(boss_icehowl);
    RegisterTrialOfTheCrusaderCreatureAI(npc_fire_bomb);
 
    RegisterSpellScript(spell_gormok_jump_to_hand);
    RegisterSpellScript(spell_gormok_ride_player);
    RegisterSpellScript(spell_gormok_snobolled);
    RegisterSpellScript(spell_jormungars_paralytic_toxin);
    RegisterSpellScript(spell_jormungars_burning_bile);
    RegisterSpellScript(spell_jormungars_slime_pool);
    RegisterSpellScriptWithArgs(spell_jormungars_snakes_spray, "spell_jormungars_burning_spray", SPELL_BURNING_BILE);
    RegisterSpellScriptWithArgs(spell_jormungars_snakes_spray, "spell_jormungars_paralytic_spray", SPELL_PARALYTIC_TOXIN);
    RegisterSpellScript(spell_jormungars_paralysis);
    RegisterSpellScript(spell_icehowl_arctic_breath);
    RegisterSpellScript(spell_icehowl_trample);
    RegisterSpellScript(spell_icehowl_massive_crash);
}