boss_ingvar_the_plunderer.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/>.
 */
 
/* ScriptData
SDName: Boss_Ingvar_The_Plunderer
SD%Complete: 95
SDComment: Blizzlike Timers (just shadow axe summon needs a new timer)
SDCategory: Utgarde Keep
EndScriptData */
 
#include "ScriptMgr.h"
#include "InstanceScript.h"
#include "MotionMaster.h"
#include "ObjectAccessor.h"
#include "ScriptedCreature.h"
#include "SpellScript.h"
#include "utgarde_keep.h"
 
enum Yells
{
    // Ingvar (Human/Undead)
    SAY_AGGRO                   = 0,
    SAY_SLAY                    = 1,
    SAY_DEATH                   = 2,
 
    // Annhylde The Caller
    YELL_RESURRECT              = 0
};
 
enum Events
{
    EVENT_CLEAVE = 1,
    EVENT_SMASH,
    EVENT_STAGGERING_ROAR,
    EVENT_ENRAGE,
 
    EVENT_DARK_SMASH,
    EVENT_DREADFUL_ROAR,
    EVENT_WOE_STRIKE,
    EVENT_SHADOW_AXE,
    EVENT_JUST_TRANSFORMED,
    EVENT_SUMMON_BANSHEE,
 
    EVENT_RESURRECT_1,
    EVENT_RESURRECT_2
};
 
enum Phases
{
    PHASE_HUMAN = 1,
    PHASE_UNDEAD,
    PHASE_EVENT
};
 
enum Spells
{
    // Ingvar Spells human form
    SPELL_CLEAVE                                = 42724,
    SPELL_SMASH                                 = 42669,
    SPELL_STAGGERING_ROAR                       = 42708,
    SPELL_ENRAGE                                = 42705,
 
    SPELL_INGVAR_FEIGN_DEATH                    = 42795,
    SPELL_SUMMON_BANSHEE                        = 42912,
    SPELL_SCOURG_RESURRECTION                   = 42863, // Spawn resurrect effect around Ingvar
 
    // Ingvar Spells undead form
    SPELL_DARK_SMASH                            = 42723,
    SPELL_DREADFUL_ROAR                         = 42729,
    SPELL_WOE_STRIKE                            = 42730,
    SPELL_WOE_STRIKE_EFFECT                     = 42739,
 
    SPELL_SHADOW_AXE_SUMMON                     = 42748,
    SPELL_SHADOW_AXE_PERIODIC_DAMAGE            = 42750,
 
    // Spells for Annhylde
    SPELL_SCOURG_RESURRECTION_HEAL              = 42704, // Heal Max + DummyAura
    SPELL_SCOURG_RESURRECTION_BEAM              = 42857, // Channeling Beam of Annhylde
    SPELL_SCOURG_RESURRECTION_DUMMY             = 42862, // Some Emote Dummy?
    SPELL_INGVAR_TRANSFORM                      = 42796
};
 
enum Misc
{
    ACTION_START_PHASE_2
};
 
struct boss_ingvar_the_plunderer : public BossAI
{
    boss_ingvar_the_plunderer(Creature* creature) : BossAI(creature, DATA_INGVAR) { }
 
    void Reset() override
    {
        if (me->GetEntry() != NPC_INGVAR)
            me->UpdateEntry(NPC_INGVAR);
        me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
        me->SetImmuneToPC(false);
        me->SetUninteractible(false);
 
        _Reset();
    }
 
    void DamageTaken(Unit* /*doneBy*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (damage >= me->GetHealth() && events.IsInPhase(PHASE_HUMAN))
        {
            events.SetPhase(PHASE_EVENT);
            events.ScheduleEvent(EVENT_SUMMON_BANSHEE, 3s, 0, PHASE_EVENT);
 
            me->RemoveAllAuras();
            me->StopMoving();
            DoCast(me, SPELL_INGVAR_FEIGN_DEATH, true);
 
            me->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
            me->SetImmuneToPC(true, true);
            me->SetUninteractible(true);
 
            Talk(SAY_DEATH);
        }
 
        if (events.IsInPhase(PHASE_EVENT))
            damage = 0;
    }
 
    void DoAction(int32 actionId) override
    {
        if (actionId == ACTION_START_PHASE_2)
            StartZombiePhase();
    }
 
    void StartZombiePhase()
    {
        me->RemoveAura(SPELL_INGVAR_FEIGN_DEATH);
        DoCast(me, SPELL_INGVAR_TRANSFORM, true);
        me->UpdateEntry(NPC_INGVAR_UNDEAD);
        events.ScheduleEvent(EVENT_JUST_TRANSFORMED, 500ms, 0, PHASE_EVENT);
    }
 
    void JustEngagedWith(Unit* who) override
    {
        if (events.IsInPhase(PHASE_EVENT) || events.IsInPhase(PHASE_UNDEAD)) // ingvar gets multiple JustEngagedWith calls
            return;
        BossAI::JustEngagedWith(who);
 
        Talk(SAY_AGGRO);
        events.SetPhase(PHASE_HUMAN);
        events.ScheduleEvent(EVENT_CLEAVE, 6s, 12s, 0, PHASE_HUMAN);
        events.ScheduleEvent(EVENT_STAGGERING_ROAR, 18s, 21s, 0, PHASE_HUMAN);
        events.ScheduleEvent(EVENT_ENRAGE, 7s, 14s, 0, PHASE_HUMAN);
        events.ScheduleEvent(EVENT_SMASH, 12s, 17s, 0, PHASE_HUMAN);
    }
 
    void AttackStart(Unit* who) override
    {
        if (events.IsInPhase(PHASE_EVENT)) // prevent ingvar from beginning to attack/chase during transition
            return;
        BossAI::AttackStart(who);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        _JustDied();
        Talk(SAY_DEATH);
    }
 
    void ScheduleSecondPhase()
    {
        events.SetPhase(PHASE_UNDEAD);
        events.ScheduleEvent(EVENT_DARK_SMASH, 14s, 18s, 0, PHASE_UNDEAD);
        events.ScheduleEvent(EVENT_DREADFUL_ROAR, 0ms, 0, PHASE_UNDEAD);
        events.ScheduleEvent(EVENT_WOE_STRIKE, 10s, 14s, 0, PHASE_UNDEAD);
        events.ScheduleEvent(EVENT_SHADOW_AXE, 30s, 0, PHASE_UNDEAD);
    }
 
    void KilledUnit(Unit* who) override
    {
        if (who->GetTypeId() == TYPEID_PLAYER)
            Talk(SAY_SLAY);
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!events.IsInPhase(PHASE_EVENT) && !UpdateVictim())
            return;
 
        events.Update(diff);
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        while (uint32 eventId = events.ExecuteEvent())
        {
            switch (eventId)
            {
                // PHASE ONE
                case EVENT_CLEAVE:
                    DoCastVictim(SPELL_CLEAVE);
                    events.ScheduleEvent(EVENT_CLEAVE, 6s, 12s, 0, PHASE_HUMAN);
                    break;
                case EVENT_STAGGERING_ROAR:
                    DoCast(me, SPELL_STAGGERING_ROAR);
                    events.ScheduleEvent(EVENT_STAGGERING_ROAR, 18s, 22s, 0, PHASE_HUMAN);
                    break;
                case EVENT_ENRAGE:
                    DoCast(me, SPELL_ENRAGE);
                    events.ScheduleEvent(EVENT_ENRAGE, 7s, 14s, 0, PHASE_HUMAN);
                    break;
                case EVENT_SMASH:
                    DoCastAOE(SPELL_SMASH);
                    events.ScheduleEvent(EVENT_SMASH, 12s, 16s, 0, PHASE_HUMAN);
                    break;
                case EVENT_JUST_TRANSFORMED:
                    me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
                    me->SetImmuneToPC(false);
                    me->SetUninteractible(false);
                    ScheduleSecondPhase();
                    Talk(SAY_AGGRO);
                    DoZoneInCombat();
                    return;
                case EVENT_SUMMON_BANSHEE:
                    DoCast(me, SPELL_SUMMON_BANSHEE);
                    return;
                // PHASE TWO
                case EVENT_DARK_SMASH:
                    DoCastVictim(SPELL_DARK_SMASH);
                    events.ScheduleEvent(EVENT_DARK_SMASH, 12s, 16s, 0, PHASE_UNDEAD);
                    break;
                case EVENT_DREADFUL_ROAR:
                    DoCast(me, SPELL_DREADFUL_ROAR);
                    events.ScheduleEvent(EVENT_DREADFUL_ROAR, 18s, 22s, 0, PHASE_UNDEAD);
                    break;
                case EVENT_WOE_STRIKE:
                    DoCastVictim(SPELL_WOE_STRIKE);
                    events.ScheduleEvent(EVENT_WOE_STRIKE, 10s, 14s, 0, PHASE_UNDEAD);
                    break;
                case EVENT_SHADOW_AXE:
                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 1, 0.0f, true))
                        DoCast(target, SPELL_SHADOW_AXE_SUMMON);
                    events.ScheduleEvent(EVENT_SHADOW_AXE, 30s, 0, PHASE_UNDEAD);
                    break;
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
};
 
struct npc_annhylde_the_caller : public ScriptedAI
{
    npc_annhylde_the_caller(Creature* creature) : ScriptedAI(creature)
    {
        x = 0.f;
        y = 0.f;
        z = 0.f;
        _instance = creature->GetInstanceScript();
    }
 
    void Reset() override
    {
        _events.Reset();
 
        me->GetPosition(x, y, z);
        me->GetMotionMaster()->MovePoint(1, x, y, z - 15.0f);
    }
 
    void MovementInform(uint32 type, uint32 id) override
    {
        if (type != POINT_MOTION_TYPE)
            return;
 
        switch (id)
        {
            case 1:
                Talk(YELL_RESURRECT);
                if (Creature* ingvar = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_INGVAR)))
                {
                    ingvar->RemoveAura(SPELL_SUMMON_BANSHEE);
                    ingvar->CastSpell(ingvar, SPELL_SCOURG_RESURRECTION_DUMMY, true);
                    DoCast(ingvar, SPELL_SCOURG_RESURRECTION_BEAM);
                }
                _events.ScheduleEvent(EVENT_RESURRECT_1, 8s);
                break;
            case 2:
                me->DespawnOrUnsummon();
                break;
            default:
                break;
        }
    }
 
    void AttackStart(Unit* /*who*/) override { }
    void MoveInLineOfSight(Unit* /*who*/) override { }
    void JustEngagedWith(Unit* /*who*/) override { }
 
    void UpdateAI(uint32 diff) override
    {
        _events.Update(diff);
 
        while (uint32 eventId = _events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_RESURRECT_1:
                    if (Creature* ingvar = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_INGVAR)))
                    {
                        ingvar->RemoveAura(SPELL_INGVAR_FEIGN_DEATH);
                        ingvar->CastSpell(ingvar, SPELL_SCOURG_RESURRECTION_HEAL, false);
                    }
                    _events.ScheduleEvent(EVENT_RESURRECT_2, 3s);
                    break;
                case EVENT_RESURRECT_2:
                    if (Creature* ingvar = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_INGVAR)))
                    {
                        ingvar->RemoveAurasDueToSpell(SPELL_SCOURG_RESURRECTION_DUMMY);
                        ingvar->AI()->DoAction(ACTION_START_PHASE_2);
                    }
 
                    me->GetMotionMaster()->MovePoint(2, x, y, z + 15.0f);
                    break;
                default:
                    break;
            }
        }
    }
 
private:
    InstanceScript* _instance;
    EventMap _events;
    float x, y, z;
};
 
struct npc_ingvar_throw_dummy : public ScriptedAI
{
    npc_ingvar_throw_dummy(Creature* creature) : ScriptedAI(creature) { }
 
    void Reset() override
    {
        if (Creature* target = me->FindNearestCreature(NPC_THROW_TARGET, 200.0f))
        {
            float x, y, z;
            target->GetPosition(x, y, z);
            me->GetMotionMaster()->MoveCharge(x, y, z);
            target->DespawnOrUnsummon();
        }
        else
            me->DespawnOrUnsummon();
    }
 
    void MovementInform(uint32 type, uint32 id) override
    {
        if (type == EFFECT_MOTION_TYPE && id == EVENT_CHARGE)
        {
            me->CastSpell(me, SPELL_SHADOW_AXE_PERIODIC_DAMAGE, true);
            me->DespawnOrUnsummon(10s);
        }
    }
};
 
// 42912 - Summon Banshee
class spell_ingvar_summon_banshee : public SpellScript
{
    void SetDest(SpellDestination& dest)
    {
        dest.RelocateOffset({ 0.0f, 0.0f, 30.0f, 0.0f });
    }
 
    void Register() override
    {
        OnDestinationTargetSelect += SpellDestinationTargetSelectFn(spell_ingvar_summon_banshee::SetDest, EFFECT_0, TARGET_DEST_CASTER_BACK);
    }
};
 
// 42730, 59735 - Woe Strike
class spell_ingvar_woe_strike : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_WOE_STRIKE_EFFECT });
    }
 
    bool CheckProc(ProcEventInfo& eventInfo)
    {
        HealInfo* healInfo = eventInfo.GetHealInfo();
        if (!healInfo || !healInfo->GetHeal())
            return false;
 
        return true;
    }
 
    void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
    {
        PreventDefaultAction();
        GetTarget()->CastSpell(eventInfo.GetActor(), SPELL_WOE_STRIKE_EFFECT, aurEff);
    }
 
    void Register() override
    {
        DoCheckProc += AuraCheckProcFn(spell_ingvar_woe_strike::CheckProc);
        OnEffectProc += AuraEffectProcFn(spell_ingvar_woe_strike::HandleProc, EFFECT_1, SPELL_AURA_PROC_TRIGGER_SPELL);
    }
};
 
void AddSC_boss_ingvar_the_plunderer()
{
    RegisterUtgardeKeepCreatureAI(boss_ingvar_the_plunderer);
    RegisterUtgardeKeepCreatureAI(npc_annhylde_the_caller);
    RegisterUtgardeKeepCreatureAI(npc_ingvar_throw_dummy);
    RegisterSpellScript(spell_ingvar_summon_banshee);
    RegisterSpellScript(spell_ingvar_woe_strike);
}