boss_priestess_delrissa.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_Priestess_Delrissa
SD%Complete: 65
SDComment: No Heroic support yet. Needs further testing. Several scripts for pets disabled, not seem to require any special script.
SDCategory: Magister's Terrace
EndScriptData */
 
#include "ScriptMgr.h"
#include "magisters_terrace.h"
#include "InstanceScript.h"
#include "ObjectAccessor.h"
#include "ScriptedCreature.h"
#include "TemporarySummon.h"
 
struct Speech
{
    int32 id;
};
 
static Speech LackeyDeath[]=
{
    {1},
    {2},
    {3},
    {4},
};
 
static Speech PlayerDeath[]=
{
    {5},
    {6},
    {7},
    {8},
    {9},
};
 
enum DelrissaTexts
{
    SAY_AGGRO                   = 0,
    SAY_DEATH                   = 10
};
 
enum DelrissaSpells
{
    SPELL_DISPEL_MAGIC          = 27609,
    SPELL_FLASH_HEAL            = 17843,
    SPELL_SW_PAIN_NORMAL        = 14032,
    SPELL_SW_PAIN_HEROIC        = 15654,
    SPELL_SHIELD                = 44291,
    SPELL_RENEW_NORMAL          = 44174,
    SPELL_RENEW_HEROIC          = 46192
};
 
enum DelrissaMisc
{
    MAX_ACTIVE_LACKEY           = 4
};
 
const float fOrientation = 4.98f;
const float fZLocation = -19.921f;
 
float LackeyLocations[4][2]=
{
    {123.77f, 17.6007f},
    {131.731f, 15.0827f},
    {121.563f, 15.6213f},
    {129.988f, 17.2355f},
};
 
const uint32 m_auiAddEntries[] =
{
    24557,                                                  //Kagani Nightstrike
    24558,                                                  //Elris Duskhallow
    24554,                                                  //Eramas Brightblaze
    24561,                                                  //Yazzaj
    24559,                                                  //Warlord Salaris
    24555,                                                  //Garaxxas
    24553,                                                  //Apoko
    24556,                                                  //Zelfan
};
 
// 24560 - Priestess Delrissa
struct boss_priestess_delrissa : public ScriptedAI
{
    boss_priestess_delrissa(Creature* creature) : ScriptedAI(creature)
    {
        Initialize();
        instance = creature->GetInstanceScript();
        LackeyEntryList.clear();
    }
 
    void Initialize()
    {
        PlayersKilled = 0;
 
        HealTimer = 15000;
        RenewTimer = 10000;
        ShieldTimer = 2000;
        SWPainTimer = 5000;
        DispelTimer = 7500;
        ResetTimer = 5000;
    }
 
    InstanceScript* instance;
 
    std::vector<uint32> LackeyEntryList;
    ObjectGuid m_auiLackeyGUID[MAX_ACTIVE_LACKEY];
 
    uint8 PlayersKilled;
 
    uint32 HealTimer;
    uint32 RenewTimer;
    uint32 ShieldTimer;
    uint32 SWPainTimer;
    uint32 DispelTimer;
    uint32 ResetTimer;
 
    void Reset() override
    {
        Initialize();
 
        InitializeLackeys();
    }
 
    //this mean she at some point evaded
    void JustReachedHome() override
    {
        instance->SetBossState(DATA_PRIESTESS_DELRISSA, FAIL);
    }
 
    void JustEngagedWith(Unit* who) override
    {
        Talk(SAY_AGGRO);
 
        for (uint8 i = 0; i < MAX_ACTIVE_LACKEY; ++i)
            if (Unit* pAdd = ObjectAccessor::GetUnit(*me, m_auiLackeyGUID[i]))
                if (!pAdd->IsEngaged())
                    AddThreat(who, 0.0f, pAdd);
 
        instance->SetBossState(DATA_PRIESTESS_DELRISSA, IN_PROGRESS);
    }
 
    void InitializeLackeys()
    {
        //can be called if Creature are dead, so avoid
        if (!me->IsAlive())
            return;
 
        uint8 j = 0;
 
        //it's empty, so first time
        if (LackeyEntryList.empty())
        {
            //pre-allocate size for speed
            LackeyEntryList.resize((sizeof(m_auiAddEntries) / sizeof(uint32)));
 
            //fill vector array with entries from Creature array
            for (uint8 i = 0; i < LackeyEntryList.size(); ++i)
                LackeyEntryList[i] = m_auiAddEntries[i];
 
            //remove random entries
            while (LackeyEntryList.size() > MAX_ACTIVE_LACKEY)
                LackeyEntryList.erase(LackeyEntryList.begin() + rand32() % LackeyEntryList.size());
 
            //summon all the remaining in vector
            for (std::vector<uint32>::const_iterator itr = LackeyEntryList.begin(); itr != LackeyEntryList.end(); ++itr)
            {
                if (Creature* pAdd = me->SummonCreature((*itr), LackeyLocations[j][0], LackeyLocations[j][1], fZLocation, fOrientation, TEMPSUMMON_CORPSE_DESPAWN))
                    m_auiLackeyGUID[j] = pAdd->GetGUID();
 
                ++j;
            }
        }
        else
        {
            for (std::vector<uint32>::const_iterator itr = LackeyEntryList.begin(); itr != LackeyEntryList.end(); ++itr)
            {
                Unit* pAdd = ObjectAccessor::GetUnit(*me, m_auiLackeyGUID[j]);
 
                //object already removed, not exist
                if (!pAdd)
                {
                    pAdd = me->SummonCreature((*itr), LackeyLocations[j][0], LackeyLocations[j][1], fZLocation, fOrientation, TEMPSUMMON_CORPSE_DESPAWN);
                    if (pAdd)
                        m_auiLackeyGUID[j] = pAdd->GetGUID();
                }
                ++j;
            }
        }
    }
 
    void KilledUnit(Unit* victim) override
    {
        if (victim->GetTypeId() != TYPEID_PLAYER)
            return;
 
        Talk(PlayerDeath[PlayersKilled].id);
 
        if (PlayersKilled < 4)
            ++PlayersKilled;
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        Talk(SAY_DEATH);
 
        if (instance->GetData(DATA_DELRISSA_DEATH_COUNT) == MAX_ACTIVE_LACKEY)
            instance->SetBossState(DATA_PRIESTESS_DELRISSA, DONE);
        else
            me->RemoveDynamicFlag(UNIT_DYNFLAG_LOOTABLE);
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        if (ResetTimer <= diff)
        {
            float x, y, z, o;
            me->GetHomePosition(x, y, z, o);
            if (me->GetPositionZ() >= z+10)
            {
                EnterEvadeMode();
                return;
            }
            ResetTimer = 5000;
        } else ResetTimer -= diff;
 
        if (HealTimer <= diff)
        {
            uint32 health = me->GetHealth();
            Unit* target = me;
            for (uint8 i = 0; i < MAX_ACTIVE_LACKEY; ++i)
            {
                if (Unit* pAdd = ObjectAccessor::GetUnit(*me, m_auiLackeyGUID[i]))
                {
                    if (pAdd->IsAlive() && pAdd->GetHealth() < health)
                        target = pAdd;
                }
            }
 
            DoCast(target, SPELL_FLASH_HEAL);
            HealTimer = 15000;
        } else HealTimer -= diff;
 
        if (RenewTimer <= diff)
        {
            Unit* target = me;
 
            if (urand(0, 1))
                if (Unit* pAdd = ObjectAccessor::GetUnit(*me, m_auiLackeyGUID[rand32() % MAX_ACTIVE_LACKEY]))
                    if (pAdd->IsAlive())
                        target = pAdd;
 
            DoCast(target, SPELL_RENEW_NORMAL);
            RenewTimer = 5000;
        } else RenewTimer -= diff;
 
        if (ShieldTimer <= diff)
        {
            Unit* target = me;
 
            if (urand(0, 1))
                if (Unit* pAdd = ObjectAccessor::GetUnit(*me, m_auiLackeyGUID[rand32() % MAX_ACTIVE_LACKEY]))
                    if (pAdd->IsAlive() && !pAdd->HasAura(SPELL_SHIELD))
                        target = pAdd;
 
            DoCast(target, SPELL_SHIELD);
            ShieldTimer = 7500;
        } else ShieldTimer -= diff;
 
        if (DispelTimer <= diff)
        {
            Unit* target = nullptr;
 
            if (urand(0, 1))
                target = SelectTarget(SelectTargetMethod::Random, 0, 100, true);
            else
            {
                if (urand(0, 1))
                    target = me;
                else
                    if (Unit* pAdd = ObjectAccessor::GetUnit(*me, m_auiLackeyGUID[rand32() % MAX_ACTIVE_LACKEY]))
                        if (pAdd->IsAlive())
                            target = pAdd;
            }
 
            if (target)
                DoCast(target, SPELL_DISPEL_MAGIC);
 
            DispelTimer = 12000;
        } else DispelTimer -= diff;
 
        if (SWPainTimer <= diff)
        {
            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 100, true))
                DoCast(target, SPELL_SW_PAIN_NORMAL);
 
            SWPainTimer = 10000;
        } else SWPainTimer -= diff;
    }
};
 
enum LackeySpells
{
    SPELL_HEALING_POTION    = 15503
};
 
struct boss_priestess_lackey_commonAI : public ScriptedAI
{
    boss_priestess_lackey_commonAI(Creature* creature) : ScriptedAI(creature)
    {
        Initialize();
        instance = creature->GetInstanceScript();
    }
 
    void Initialize()
    {
        UsedPotion = false;
 
        // These guys does not follow normal threat system rules
        // For later development, some alternative threat system should be made
        // We do not know what this system is based upon, but one theory is class (healers=high threat, dps=medium, etc)
        // We reset their threat frequently as an alternative until such a system exist
        ResetThreatTimer = urand(5000, 20000);
    }
 
    InstanceScript* instance;
 
    ObjectGuid m_auiLackeyGUIDs[MAX_ACTIVE_LACKEY];
    uint32 ResetThreatTimer;
 
    bool UsedPotion;
 
    void Reset() override
    {
        Initialize();
        AcquireGUIDs();
 
        // in case she is not alive and Reset was for some reason called, respawn her (most likely party wipe after killing her)
        if (Creature* delrissa = instance->GetCreature(DATA_PRIESTESS_DELRISSA))
        {
            if (!delrissa->IsAlive())
                delrissa->Respawn();
        }
    }
 
    void JustEngagedWith(Unit* who) override
    {
        if (!who)
            return;
 
        for (uint8 i = 0; i < MAX_ACTIVE_LACKEY; ++i)
            if (Unit* pAdd = ObjectAccessor::GetUnit(*me, m_auiLackeyGUIDs[i]))
                if (!pAdd->IsEngaged() && pAdd != me)
                    AddThreat(who, 0.0f, pAdd);
 
        if (Creature* delrissa = instance->GetCreature(DATA_PRIESTESS_DELRISSA))
            if (delrissa->IsAlive() && !delrissa->IsEngaged())
                AddThreat(who, 0.0f, delrissa);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        Creature* delrissa = instance->GetCreature(DATA_PRIESTESS_DELRISSA);
        uint32 uiLackeyDeathCount = instance->GetData(DATA_DELRISSA_DEATH_COUNT);
 
        if (!delrissa)
            return;
 
        //should delrissa really yell if dead?
        delrissa->AI()->Talk(LackeyDeath[uiLackeyDeathCount].id);
 
        instance->SetData(DATA_DELRISSA_DEATH_COUNT, SPECIAL);
 
        //increase local var, since we now may have four dead
        ++uiLackeyDeathCount;
 
        if (uiLackeyDeathCount == MAX_ACTIVE_LACKEY)
        {
            //time to make her lootable and complete event if she died before lackeys
            if (!delrissa->IsAlive())
            {
                delrissa->SetDynamicFlag(UNIT_DYNFLAG_LOOTABLE);
 
                instance->SetBossState(DATA_PRIESTESS_DELRISSA, DONE);
            }
        }
    }
 
    void KilledUnit(Unit* victim) override
    {
        if (Creature* delrissa = instance->GetCreature(DATA_PRIESTESS_DELRISSA))
            delrissa->AI()->KilledUnit(victim);
    }
 
    void AcquireGUIDs()
    {
        if (Creature* delrissa = instance->GetCreature(DATA_PRIESTESS_DELRISSA))
        {
            for (uint8 i = 0; i < MAX_ACTIVE_LACKEY; ++i)
                m_auiLackeyGUIDs[i] = ENSURE_AI(boss_priestess_delrissa, delrissa->AI())->m_auiLackeyGUID[i];
        }
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UsedPotion && HealthBelowPct(25))
        {
            DoCast(me, SPELL_HEALING_POTION);
            UsedPotion = true;
        }
 
        if (ResetThreatTimer <= diff)
        {
            ResetThreatList();
            ResetThreatTimer = urand(5000, 20000);
        } else ResetThreatTimer -= diff;
    }
};
 
enum RogueSpells
{
    SPELL_KIDNEY_SHOT       = 27615,
    SPELL_GOUGE             = 12540,
    SPELL_KICK              = 27613,
    SPELL_VANISH            = 44290,
    SPELL_BACKSTAB          = 15657,
    SPELL_EVISCERATE        = 27611
};
 
// 24557 - Kagani Nightstrike (Rogue)
struct boss_kagani_nightstrike : public boss_priestess_lackey_commonAI
{
    boss_kagani_nightstrike(Creature* creature) : boss_priestess_lackey_commonAI(creature)
    {
        Initialize();
    }
 
    void Initialize()
    {
        Gouge_Timer = 5500;
        Kick_Timer = 7000;
        Vanish_Timer = 2000;
        Eviscerate_Timer = 6000;
        Wait_Timer = 5000;
        InVanish = false;
    }
 
    uint32 Gouge_Timer;
    uint32 Kick_Timer;
    uint32 Vanish_Timer;
    uint32 Eviscerate_Timer;
    uint32 Wait_Timer;
    bool InVanish;
 
    void Reset() override
    {
        Initialize();
        me->SetVisible(true);
        me->SetCanMelee(true);
 
        boss_priestess_lackey_commonAI::Reset();
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        boss_priestess_lackey_commonAI::UpdateAI(diff);
        me->SetCanMelee(true);
 
        if (Vanish_Timer <= diff)
        {
            DoCast(me, SPELL_VANISH);
 
            Unit* unit = SelectTarget(SelectTargetMethod::Random, 0);
 
            ResetThreatList();
 
            if (unit)
                AddThreat(unit, 1000.0f);
 
            InVanish = true;
            me->SetCanMelee(false);
            Vanish_Timer = 30000;
            Wait_Timer = 10000;
        } else Vanish_Timer -= diff;
 
        if (InVanish)
        {
            if (Wait_Timer <= diff)
            {
                DoCastVictim(SPELL_BACKSTAB, true);
                DoCastVictim(SPELL_KIDNEY_SHOT, true);
                me->SetVisible(true);       // ...? Hacklike
                InVanish = false;
                me->SetCanMelee(true);
            } else Wait_Timer -= diff;
        }
 
        if (Gouge_Timer <= diff)
        {
            DoCastVictim(SPELL_GOUGE);
            Gouge_Timer = 5500;
        } else Gouge_Timer -= diff;
 
        if (Kick_Timer <= diff)
        {
            DoCastVictim(SPELL_KICK);
            Kick_Timer = 7000;
        } else Kick_Timer -= diff;
 
        if (Eviscerate_Timer <= diff)
        {
            DoCastVictim(SPELL_EVISCERATE);
            Eviscerate_Timer = 4000;
        } else Eviscerate_Timer -= diff;
    }
};
 
enum WarlockSpells
{
    SPELL_IMMOLATE              = 44267,
    SPELL_SHADOW_BOLT           = 12471,
    SPELL_SEED_OF_CORRUPTION    = 44141,
    SPELL_CURSE_OF_AGONY        = 14875,
    SPELL_FEAR                  = 38595,
    SPELL_IMP_FIREBALL          = 44164,
    SPELL_SUMMON_IMP            = 44163
};
 
// 24558 - Ellrys Duskhallow (Warlock)
struct boss_ellris_duskhallow : public boss_priestess_lackey_commonAI
{
    boss_ellris_duskhallow(Creature* creature) : boss_priestess_lackey_commonAI(creature)
    {
        Initialize();
    }
 
    void Initialize()
    {
        Immolate_Timer = 6000;
        Shadow_Bolt_Timer = 3000;
        Seed_of_Corruption_Timer = 2000;
        Curse_of_Agony_Timer = 1000;
        Fear_Timer = 10000;
    }
 
    uint32 Immolate_Timer;
    uint32 Shadow_Bolt_Timer;
    uint32 Seed_of_Corruption_Timer;
    uint32 Curse_of_Agony_Timer;
    uint32 Fear_Timer;
 
    void Reset() override
    {
        Initialize();
 
        boss_priestess_lackey_commonAI::Reset();
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        DoCast(me, SPELL_SUMMON_IMP);
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        boss_priestess_lackey_commonAI::UpdateAI(diff);
 
        if (Immolate_Timer <= diff)
        {
            DoCastVictim(SPELL_IMMOLATE);
            Immolate_Timer = 6000;
        } else Immolate_Timer -= diff;
 
        if (Shadow_Bolt_Timer <= diff)
        {
            DoCastVictim(SPELL_SHADOW_BOLT);
            Shadow_Bolt_Timer = 5000;
        } else Shadow_Bolt_Timer -= diff;
 
        if (Seed_of_Corruption_Timer <= diff)
        {
            if (Unit* unit = SelectTarget(SelectTargetMethod::Random, 0))
                DoCast(unit, SPELL_SEED_OF_CORRUPTION);
 
            Seed_of_Corruption_Timer = 10000;
        } else Seed_of_Corruption_Timer -= diff;
 
        if (Curse_of_Agony_Timer <= diff)
        {
            if (Unit* unit = SelectTarget(SelectTargetMethod::Random, 0))
                DoCast(unit, SPELL_CURSE_OF_AGONY);
 
            Curse_of_Agony_Timer = 13000;
        } else Curse_of_Agony_Timer -= diff;
 
        if (Fear_Timer <= diff)
        {
            if (Unit* unit = SelectTarget(SelectTargetMethod::Random, 0))
                DoCast(unit, SPELL_FEAR);
 
            Fear_Timer = 10000;
        } else Fear_Timer -= diff;
    }
};
 
enum MonkSpells
{
    SPELL_KNOCKDOWN     = 11428,
    SPELL_SNAP_KICK     = 46182
};
 
// 24554 - Eramas Brightblaze (Monk)
struct boss_eramas_brightblaze : public boss_priestess_lackey_commonAI
{
    boss_eramas_brightblaze(Creature* creature) : boss_priestess_lackey_commonAI(creature)
    {
        Initialize();
    }
 
    void Initialize()
    {
        Knockdown_Timer = 6000;
        Snap_Kick_Timer = 4500;
    }
 
    uint32 Knockdown_Timer;
    uint32 Snap_Kick_Timer;
 
    void Reset() override
    {
        Initialize();
 
        boss_priestess_lackey_commonAI::Reset();
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        boss_priestess_lackey_commonAI::UpdateAI(diff);
 
        if (Knockdown_Timer <= diff)
        {
            DoCastVictim(SPELL_KNOCKDOWN);
            Knockdown_Timer = 6000;
        } else Knockdown_Timer -= diff;
 
        if (Snap_Kick_Timer <= diff)
        {
            DoCastVictim(SPELL_SNAP_KICK);
            Snap_Kick_Timer  = 4500;
        } else Snap_Kick_Timer -= diff;
    }
};
 
enum MageSpells
{
    SPELL_POLYMORPH         = 13323,
    SPELL_ICE_BLOCK         = 27619,
    SPELL_BLIZZARD          = 44178,
    SPELL_ICE_LANCE         = 46194,
    SPELL_CONE_OF_COLD      = 38384,
    SPELL_FROSTBOLT         = 15043,
    SPELL_BLINK             = 14514
};
 
// 24561 - Yazzai (Mage)
struct boss_yazzai : public boss_priestess_lackey_commonAI
{
    boss_yazzai(Creature* creature) : boss_priestess_lackey_commonAI(creature)
    {
        Initialize();
    }
 
    void Initialize()
    {
        HasIceBlocked = false;
 
        Polymorph_Timer = 1000;
        Ice_Block_Timer = 20000;
        Wait_Timer = 10000;
        Blizzard_Timer = 8000;
        Ice_Lance_Timer = 12000;
        Cone_of_Cold_Timer = 10000;
        Frostbolt_Timer = 3000;
        Blink_Timer = 8000;
    }
 
    bool HasIceBlocked;
 
    uint32 Polymorph_Timer;
    uint32 Ice_Block_Timer;
    uint32 Wait_Timer;
    uint32 Blizzard_Timer;
    uint32 Ice_Lance_Timer;
    uint32 Cone_of_Cold_Timer;
    uint32 Frostbolt_Timer;
    uint32 Blink_Timer;
 
    void Reset() override
    {
        Initialize();
 
        boss_priestess_lackey_commonAI::Reset();
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        boss_priestess_lackey_commonAI::UpdateAI(diff);
 
        if (Polymorph_Timer <= diff)
        {
            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
            {
                DoCast(target, SPELL_POLYMORPH);
                Polymorph_Timer = 20000;
            }
        } else Polymorph_Timer -= diff;
 
        if (HealthBelowPct(35) && !HasIceBlocked)
        {
            DoCast(me, SPELL_ICE_BLOCK);
            HasIceBlocked = true;
        }
 
        if (Blizzard_Timer <= diff)
        {
            if (Unit* unit = SelectTarget(SelectTargetMethod::Random, 0))
                DoCast(unit, SPELL_BLIZZARD);
 
            Blizzard_Timer = 8000;
        } else Blizzard_Timer -= diff;
 
        if (Ice_Lance_Timer <= diff)
        {
            DoCastVictim(SPELL_ICE_LANCE);
            Ice_Lance_Timer = 12000;
        } else Ice_Lance_Timer -= diff;
 
        if (Cone_of_Cold_Timer <= diff)
        {
            DoCastVictim(SPELL_CONE_OF_COLD);
            Cone_of_Cold_Timer = 10000;
        } else Cone_of_Cold_Timer -= diff;
 
        if (Frostbolt_Timer <= diff)
        {
            DoCastVictim(SPELL_FROSTBOLT);
            Frostbolt_Timer = 8000;
        } else Frostbolt_Timer -= diff;
 
        if (Blink_Timer <= diff)
        {
            bool InMeleeRange = false;
            for (auto const& pair : me->GetCombatManager().GetPvECombatRefs())
            {
                if (pair.second->GetOther(me)->IsWithinMeleeRange(me))
                {
                    InMeleeRange = true;
                    break;
                }
            }
 
            //if anybody is in melee range than escape by blink
            if (InMeleeRange)
                DoCast(me, SPELL_BLINK);
 
            Blink_Timer = 8000;
        } else Blink_Timer -= diff;
    }
};
 
enum WarriorSpells
{
    SPELL_INTERCEPT_STUN        = 27577,
    SPELL_DISARM                = 27581,
    SPELL_PIERCING_HOWL         = 23600,
    SPELL_FRIGHTENING_SHOUT     = 19134,
    SPELL_HAMSTRING             = 27584,
    SPELL_BATTLE_SHOUT          = 27578,
    SPELL_MORTAL_STRIKE         = 44268
};
 
// 24559 - Warlord Salaris (Warrior)
struct boss_warlord_salaris : public boss_priestess_lackey_commonAI
{
    boss_warlord_salaris(Creature* creature) : boss_priestess_lackey_commonAI(creature)
    {
        Initialize();
    }
 
    void Initialize()
    {
        Intercept_Stun_Timer = 500;
        Disarm_Timer = 6000;
        Piercing_Howl_Timer = 10000;
        Frightening_Shout_Timer = 18000;
        Hamstring_Timer = 4500;
        Mortal_Strike_Timer = 8000;
    }
 
    uint32 Intercept_Stun_Timer;
    uint32 Disarm_Timer;
    uint32 Piercing_Howl_Timer;
    uint32 Frightening_Shout_Timer;
    uint32 Hamstring_Timer;
    uint32 Mortal_Strike_Timer;
 
    void Reset() override
    {
        Initialize();
 
        boss_priestess_lackey_commonAI::Reset();
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        DoCast(me, SPELL_BATTLE_SHOUT);
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        boss_priestess_lackey_commonAI::UpdateAI(diff);
 
        if (Intercept_Stun_Timer <= diff)
        {
            bool InMeleeRange = false;
            for (auto const& pair : me->GetCombatManager().GetPvECombatRefs())
            {
                if (pair.second->GetOther(me)->IsWithinMeleeRange(me))
                {
                    InMeleeRange = true;
                    break;
                }
            }
 
            //if nobody is in melee range than try to use Intercept
            if (!InMeleeRange)
            {
                if (Unit* unit = SelectTarget(SelectTargetMethod::Random, 0))
                    DoCast(unit, SPELL_INTERCEPT_STUN);
            }
 
            Intercept_Stun_Timer = 10000;
        } else Intercept_Stun_Timer -= diff;
 
        if (Disarm_Timer <= diff)
        {
            DoCastVictim(SPELL_DISARM);
            Disarm_Timer = 6000;
        } else Disarm_Timer -= diff;
 
        if (Hamstring_Timer <= diff)
        {
            DoCastVictim(SPELL_HAMSTRING);
            Hamstring_Timer = 4500;
        } else Hamstring_Timer -= diff;
 
        if (Mortal_Strike_Timer <= diff)
        {
            DoCastVictim(SPELL_MORTAL_STRIKE);
            Mortal_Strike_Timer = 4500;
        } else Mortal_Strike_Timer -= diff;
 
        if (Piercing_Howl_Timer <= diff)
        {
            DoCastVictim(SPELL_PIERCING_HOWL);
            Piercing_Howl_Timer = 10000;
        } else Piercing_Howl_Timer -= diff;
 
        if (Frightening_Shout_Timer <= diff)
        {
            DoCastVictim(SPELL_FRIGHTENING_SHOUT);
            Frightening_Shout_Timer = 18000;
        } else Frightening_Shout_Timer -= diff;
    }
};
 
enum HunterSpells
{
    SPELL_AIMED_SHOT            = 44271,
    SPELL_SHOOT                 = 15620,
    SPELL_CONCUSSIVE_SHOT       = 27634,
    SPELL_MULTI_SHOT            = 31942,
    SPELL_WING_CLIP             = 44286,
    SPELL_FREEZING_TRAP         = 44136,
 
    NPC_SLIVER                  = 24552
};
 
// 24555 - Garaxxas (Hunter)
struct boss_garaxxas : public boss_priestess_lackey_commonAI
{
    boss_garaxxas(Creature* creature) : boss_priestess_lackey_commonAI(creature)
    {
        Initialize();
    }
 
    void Initialize()
    {
        Aimed_Shot_Timer = 6000;
        Shoot_Timer = 2500;
        Concussive_Shot_Timer = 8000;
        Multi_Shot_Timer = 10000;
        Wing_Clip_Timer = 4000;
        Freezing_Trap_Timer = 15000;
    }
 
    ObjectGuid m_uiPetGUID;
 
    uint32 Aimed_Shot_Timer;
    uint32 Shoot_Timer;
    uint32 Concussive_Shot_Timer;
    uint32 Multi_Shot_Timer;
    uint32 Wing_Clip_Timer;
    uint32 Freezing_Trap_Timer;
 
    void Reset() override
    {
        Initialize();
 
        Unit* pPet = ObjectAccessor::GetUnit(*me, m_uiPetGUID);
        if (!pPet)
            me->SummonCreature(NPC_SLIVER, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_CORPSE_DESPAWN);
 
        boss_priestess_lackey_commonAI::Reset();
    }
 
    void JustSummoned(Creature* summoned) override
    {
        m_uiPetGUID = summoned->GetGUID();
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        boss_priestess_lackey_commonAI::UpdateAI(diff);
 
        if (me->IsWithinDistInMap(me->GetVictim(), ATTACK_DISTANCE))
        {
            if (Wing_Clip_Timer <= diff)
            {
                DoCastVictim(SPELL_WING_CLIP);
                Wing_Clip_Timer = 4000;
            } else Wing_Clip_Timer -= diff;
 
            if (Freezing_Trap_Timer <= diff)
            {
                //attempt find go summoned from spell (cast by me)
                GameObject* go = me->GetGameObject(SPELL_FREEZING_TRAP);
 
                //if we have a go, we need to wait (only one trap at a time)
                if (go)
                    Freezing_Trap_Timer = 2500;
                else
                {
                    //if go does not exist, then we can cast
                    DoCastVictim(SPELL_FREEZING_TRAP);
                    Freezing_Trap_Timer = 15000;
                }
            } else Freezing_Trap_Timer -= diff;
        }
        else
        {
            if (Concussive_Shot_Timer <= diff)
            {
                DoCastVictim(SPELL_CONCUSSIVE_SHOT);
                Concussive_Shot_Timer = 8000;
            } else Concussive_Shot_Timer -= diff;
 
            if (Multi_Shot_Timer <= diff)
            {
                DoCastVictim(SPELL_MULTI_SHOT);
                Multi_Shot_Timer = 10000;
            } else Multi_Shot_Timer -= diff;
 
            if (Aimed_Shot_Timer <= diff)
            {
                DoCastVictim(SPELL_AIMED_SHOT);
                Aimed_Shot_Timer = 6000;
            } else Aimed_Shot_Timer -= diff;
 
            if (Shoot_Timer <= diff)
            {
                DoCastVictim(SPELL_SHOOT);
                Shoot_Timer = 2500;
            } else Shoot_Timer -= diff;
        }
    }
};
 
enum ShamanSpells
{
    SPELL_WINDFURY_TOTEM        = 27621,
    SPELL_WAR_STOMP             = 46026,
    SPELL_PURGE                 = 27626,
    SPELL_LESSER_HEALING_WAVE   = 44256,
    SPELL_FROST_SHOCK           = 21401,
    SPELL_FIRE_NOVA_TOTEM       = 44257,
    SPELL_EARTHBIND_TOTEM       = 15786
};
 
// 24553 - Apoko (Shaman)
struct boss_apoko : public boss_priestess_lackey_commonAI
{
    boss_apoko(Creature* creature) : boss_priestess_lackey_commonAI(creature)
    {
        Initialize();
    }
 
    void Initialize()
    {
        Totem_Timer = 2000;
        Totem_Amount = 1;
        War_Stomp_Timer = 10000;
        Purge_Timer = 8000;
        Healing_Wave_Timer = 5000;
        Frost_Shock_Timer = 7000;
    }
 
    uint32 Totem_Timer;
    uint8  Totem_Amount;
    uint32 War_Stomp_Timer;
    uint32 Purge_Timer;
    uint32 Healing_Wave_Timer;
    uint32 Frost_Shock_Timer;
 
    void Reset() override
    {
        Initialize();
 
        boss_priestess_lackey_commonAI::Reset();
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        boss_priestess_lackey_commonAI::UpdateAI(diff);
 
        if (Totem_Timer <= diff)
        {
            DoCast(me, RAND(SPELL_WINDFURY_TOTEM, SPELL_FIRE_NOVA_TOTEM, SPELL_EARTHBIND_TOTEM));
            ++Totem_Amount;
            Totem_Timer = Totem_Amount*2000;
        } else Totem_Timer -= diff;
 
        if (War_Stomp_Timer <= diff)
        {
            DoCast(me, SPELL_WAR_STOMP);
            War_Stomp_Timer = 10000;
        } else War_Stomp_Timer -= diff;
 
        if (Purge_Timer <= diff)
        {
            if (Unit* unit = SelectTarget(SelectTargetMethod::Random, 0))
                DoCast(unit, SPELL_PURGE);
 
            Purge_Timer = 15000;
        } else Purge_Timer -= diff;
 
        if (Frost_Shock_Timer <= diff)
        {
            DoCastVictim(SPELL_FROST_SHOCK);
            Frost_Shock_Timer = 7000;
        } else Frost_Shock_Timer -= diff;
 
        if (Healing_Wave_Timer <= diff)
        {
            DoCast(me, SPELL_LESSER_HEALING_WAVE);
            Healing_Wave_Timer = 5000;
        } else Healing_Wave_Timer -= diff;
    }
};
 
enum EngineerSpells
{
    SPELL_GOBLIN_DRAGON_GUN     = 44272,
    SPELL_ROCKET_LAUNCH         = 44137,
    SPELL_RECOMBOBULATE         = 44274,
    SPELL_HIGH_EXPLOSIVE_SHEEP  = 44276,
    SPELL_FEL_IRON_BOMB         = 46024,
    SPELL_SHEEP_EXPLOSION       = 44279
};
 
// 24556 - Zelfan (Engineer)
struct boss_zelfan : public boss_priestess_lackey_commonAI
{
    boss_zelfan(Creature* creature) : boss_priestess_lackey_commonAI(creature)
    {
        Initialize();
    }
 
    void Initialize()
    {
        Goblin_Dragon_Gun_Timer = 20000;
        Rocket_Launch_Timer = 7000;
        Recombobulate_Timer = 4000;
        High_Explosive_Sheep_Timer = 10000;
        Fel_Iron_Bomb_Timer = 15000;
    }
 
    uint32 Goblin_Dragon_Gun_Timer;
    uint32 Rocket_Launch_Timer;
    uint32 Recombobulate_Timer;
    uint32 High_Explosive_Sheep_Timer;
    uint32 Fel_Iron_Bomb_Timer;
 
    void Reset() override
    {
        Initialize();
 
        boss_priestess_lackey_commonAI::Reset();
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        boss_priestess_lackey_commonAI::UpdateAI(diff);
 
        if (Goblin_Dragon_Gun_Timer <= diff)
        {
            DoCastVictim(SPELL_GOBLIN_DRAGON_GUN);
            Goblin_Dragon_Gun_Timer = 10000;
        } else Goblin_Dragon_Gun_Timer -= diff;
 
        if (Rocket_Launch_Timer <= diff)
        {
            DoCastVictim(SPELL_ROCKET_LAUNCH);
            Rocket_Launch_Timer = 9000;
        } else Rocket_Launch_Timer -= diff;
 
        if (Fel_Iron_Bomb_Timer <= diff)
        {
            DoCastVictim(SPELL_FEL_IRON_BOMB);
            Fel_Iron_Bomb_Timer = 15000;
        } else Fel_Iron_Bomb_Timer -= diff;
 
        if (Recombobulate_Timer <= diff)
        {
            for (uint8 i = 0; i < MAX_ACTIVE_LACKEY; ++i)
            {
                if (Unit* pAdd = ObjectAccessor::GetUnit(*me, m_auiLackeyGUIDs[i]))
                {
                    if (pAdd->IsPolymorphed())
                    {
                        DoCast(pAdd, SPELL_RECOMBOBULATE);
                        break;
                    }
                }
            }
            Recombobulate_Timer = 2000;
        } else Recombobulate_Timer -= diff;
 
        if (High_Explosive_Sheep_Timer <= diff)
        {
            DoCast(me, SPELL_HIGH_EXPLOSIVE_SHEEP);
            High_Explosive_Sheep_Timer = 65000;
        } else High_Explosive_Sheep_Timer -= diff;
    }
};
 
void AddSC_boss_priestess_delrissa()
{
    RegisterMagistersTerraceCreatureAI(boss_priestess_delrissa);
    RegisterMagistersTerraceCreatureAI(boss_kagani_nightstrike);
    RegisterMagistersTerraceCreatureAI(boss_ellris_duskhallow);
    RegisterMagistersTerraceCreatureAI(boss_eramas_brightblaze);
    RegisterMagistersTerraceCreatureAI(boss_yazzai);
    RegisterMagistersTerraceCreatureAI(boss_warlord_salaris);
    RegisterMagistersTerraceCreatureAI(boss_garaxxas);
    RegisterMagistersTerraceCreatureAI(boss_apoko);
    RegisterMagistersTerraceCreatureAI(boss_zelfan);
}