boss_occuthar.cpp

Go to the documentation of this file.

/*
* This file is part of Project SkyFire https://www.projectskyfire.org. 
* See LICENSE.md file for Copyright information
*/
 
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "Vehicle.h"
#include "SpellScript.h"
#include "SpellAuraEffects.h"
#include "baradin_hold.h"
 
enum Spells
{
    SPELL_SEARING_SHADOWS               = 96913,
    SPELL_FOCUSED_FIRE_FIRST_DAMAGE     = 97212,
    SPELL_FOCUSED_FIRE_TRIGGER          = 96872,
    SPELL_FOCUSED_FIRE_VISUAL           = 96886,
    SPELL_FOCUSED_FIRE                  = 96884,
    SPELL_EYES_OF_OCCUTHAR              = 96920,
    SPELL_GAZE_OF_OCCUTHAR              = 96942,
    SPELL_OCCUTHARS_DESTUCTION          = 96968,
    SPELL_BERSERK                       = 47008
};
 
enum Events
{
    EVENT_SEARING_SHADOWS               = 1,
    EVENT_FOCUSED_FIRE                  = 2,
    EVENT_EYES_OF_OCCUTHAR              = 3,
    EVENT_BERSERK                       = 4,
 
    EVENT_FOCUSED_FIRE_FIRST_DAMAGE     = 1
};
 
enum Misc
{
    MAX_OCCUTHAR_VEHICLE_SEATS          = 7
};
 
class boss_occuthar : public CreatureScript
{
    public:
        boss_occuthar() : CreatureScript("boss_occuthar") { }
 
        struct boss_occutharAI : public BossAI
        {
            boss_occutharAI(Creature* creature) : BossAI(creature, DATA_OCCUTHAR),
                _vehicle(me->GetVehicleKit())
            {
                ASSERT(_vehicle);
            }
 
            void EnterCombat(Unit* /*who*/) OVERRIDE
            {
                _EnterCombat();
                instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, me);
                events.ScheduleEvent(EVENT_SEARING_SHADOWS, 8 * IN_MILLISECONDS);
                events.ScheduleEvent(EVENT_FOCUSED_FIRE, 15 * IN_MILLISECONDS);
                events.ScheduleEvent(EVENT_EYES_OF_OCCUTHAR, 30 * IN_MILLISECONDS);
                events.ScheduleEvent(EVENT_BERSERK, 5 * MINUTE * IN_MILLISECONDS);
            }
 
            void EnterEvadeMode() OVERRIDE
            {
                BossAI::EnterEvadeMode();
                instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
                _DespawnAtEvade();
            }
 
            void JustDied(Unit* /*killer*/) OVERRIDE
            {
                _JustDied();
                instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
            }
 
            void JustSummoned(Creature* summon) OVERRIDE
            {
                summons.Summon(summon);
 
                if (summon->GetEntry() == NPC_FOCUS_FIRE_DUMMY)
                {
                    DoCast(summon, SPELL_FOCUSED_FIRE);
 
                    for (uint8 i = 0; i < MAX_OCCUTHAR_VEHICLE_SEATS; ++i)
                    {
                        if (Unit* vehicle = _vehicle->GetPassenger(i))
                            vehicle->CastSpell(summon, SPELL_FOCUSED_FIRE_VISUAL);
                    }
                }
            }
 
            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_SEARING_SHADOWS:
                            DoCastAOE(SPELL_SEARING_SHADOWS);
                            events.ScheduleEvent(EVENT_SEARING_SHADOWS, 25 * IN_MILLISECONDS);
                            break;
                        case EVENT_FOCUSED_FIRE:
                            DoCastAOE(SPELL_FOCUSED_FIRE_TRIGGER, true);
                            events.ScheduleEvent(EVENT_FOCUSED_FIRE, 15 * IN_MILLISECONDS);
                            break;
                        case EVENT_EYES_OF_OCCUTHAR:
                            DoCastAOE(SPELL_EYES_OF_OCCUTHAR);
                            events.RescheduleEvent(EVENT_FOCUSED_FIRE, 15 * IN_MILLISECONDS);
                            events.ScheduleEvent(EVENT_EYES_OF_OCCUTHAR, 60 * IN_MILLISECONDS);
                            break;
                        case EVENT_BERSERK:
                            DoCast(me, SPELL_BERSERK, true);
                            break;
                        default:
                            break;
                    }
                }
 
                DoMeleeAttackIfReady();
            }
 
        private:
            Vehicle* _vehicle;
        };
 
        CreatureAI* GetAI(Creature* creature) const OVERRIDE
        {
            return GetBaradinHoldAI<boss_occutharAI>(creature);
        }
};
 
class npc_eyestalk : public CreatureScript
{
    public:
        npc_eyestalk() : CreatureScript("npc_eyestalk") { }
 
        struct npc_eyestalkAI : public ScriptedAI
        {
            npc_eyestalkAI(Creature* creature) : ScriptedAI(creature),
                _instance(creature->GetInstanceScript())
            {
                _damageCount = 0;
            }
 
            void IsSummonedBy(Unit* /*summoner*/) OVERRIDE
            {
                // player is the spellcaster so register summon manually
                if (Creature* occuthar = ObjectAccessor::GetCreature(*me, _instance->GetData64(DATA_OCCUTHAR)))
                    occuthar->AI()->JustSummoned(me);
            }
 
            void Reset() OVERRIDE
            {
                _events.Reset();
                _events.ScheduleEvent(EVENT_FOCUSED_FIRE_FIRST_DAMAGE, 0);
            }
 
            void UpdateAI(uint32 diff) OVERRIDE
            {
                _events.Update(diff);
 
                if (_events.ExecuteEvent() == EVENT_FOCUSED_FIRE_FIRST_DAMAGE)
                {
                    DoCastAOE(SPELL_FOCUSED_FIRE_FIRST_DAMAGE);
                    if (++_damageCount < 2)
                        _events.ScheduleEvent(EVENT_FOCUSED_FIRE_FIRST_DAMAGE, 1 * IN_MILLISECONDS);
                }
            }
 
            void EnterEvadeMode() OVERRIDE { } // Never evade
 
        private:
            InstanceScript* _instance;
            EventMap _events;
            uint8 _damageCount;
        };
 
        CreatureAI* GetAI(Creature* creature) const OVERRIDE
        {
            return GetBaradinHoldAI<npc_eyestalkAI>(creature);
        }
};
 
class FocusedFireTargetSelector : public SF_UNARY_FUNCTION<Unit *, bool>
{
    public:
        FocusedFireTargetSelector(Creature* me, const Unit* victim) : _me(me), _victim(victim) { }
 
        bool operator() (WorldObject* target)
        {
            if (target == _victim && _me->getThreatManager().getThreatList().size() > 1)
                return true;
 
            if (target->GetTypeId() != TypeID::TYPEID_PLAYER)
                return true;
 
            return false;
        }
 
        Creature* _me;
        Unit const* _victim;
};
 
// 96872 - Focused Fire
class spell_occuthar_focused_fire : public SpellScriptLoader
{
    public:
        spell_occuthar_focused_fire() : SpellScriptLoader("spell_occuthar_focused_fire") { }
 
        class spell_occuthar_focused_fire_SpellScript : public SpellScript
        {
            PrepareSpellScript(spell_occuthar_focused_fire_SpellScript);
 
            void FilterTargets(std::list<WorldObject*>& targets)
            {
                if (targets.empty())
                    return;
 
                targets.remove_if(FocusedFireTargetSelector(GetCaster()->ToCreature(), GetCaster()->GetVictim()));
                WorldObject* target = Skyfire::Containers::SelectRandomContainerElement(targets);
                targets.clear();
                targets.push_back(target);
            }
 
            void Register() OVERRIDE
            {
                OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_occuthar_focused_fire_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
            }
        };
 
        SpellScript* GetSpellScript() const OVERRIDE
        {
            return new spell_occuthar_focused_fire_SpellScript();
        }
};
 
// ID - 96931 Eyes of Occu'thar
class spell_occuthar_eyes_of_occuthar : public SpellScriptLoader
{
    public:
        spell_occuthar_eyes_of_occuthar() : SpellScriptLoader("spell_occuthar_eyes_of_occuthar") { }
 
        class spell_occuthar_eyes_of_occuthar_SpellScript : public SpellScript
        {
            PrepareSpellScript(spell_occuthar_eyes_of_occuthar_SpellScript);
 
            bool Validate(SpellInfo const* spellInfo) OVERRIDE
            {
                if (!sSpellMgr->GetSpellInfo(spellInfo->Effects[EFFECT_0].CalcValue()))
                    return false;
                return true;
            }
 
            bool Load() OVERRIDE
            {
                return GetCaster()->GetTypeId() == TypeID::TYPEID_PLAYER;
            }
 
            void FilterTargets(std::list<WorldObject*>& targets)
            {
                if (targets.empty())
                    return;
 
                WorldObject* target = Skyfire::Containers::SelectRandomContainerElement(targets);
                targets.clear();
                targets.push_back(target);
            }
 
            void HandleScript(SpellEffIndex /*effIndex*/)
            {
                GetHitUnit()->CastSpell(GetCaster(), GetEffectValue(), true);
            }
 
            void Register() OVERRIDE
            {
                OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_occuthar_eyes_of_occuthar_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
                OnEffectHitTarget += SpellEffectFn(spell_occuthar_eyes_of_occuthar_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
            }
        };
 
        SpellScript* GetSpellScript() const OVERRIDE
        {
            return new spell_occuthar_eyes_of_occuthar_SpellScript();
        }
};
 
// ID - 96932 Eyes of Occu'thar
class spell_occuthar_eyes_of_occuthar_vehicle : public SpellScriptLoader
{
    public:
        spell_occuthar_eyes_of_occuthar_vehicle() : SpellScriptLoader("spell_occuthar_eyes_of_occuthar_vehicle") { }
 
        class spell_occuthar_eyes_of_occuthar_vehicle_SpellScript : public SpellScript
        {
            PrepareSpellScript(spell_occuthar_eyes_of_occuthar_vehicle_SpellScript);
 
            bool Load() OVERRIDE
            {
                return GetCaster()->GetInstanceScript() != NULL;
            }
 
            void HandleScript()
            {
                Position pos;
                GetHitUnit()->GetPosition(&pos);
 
                if (Creature* occuthar = ObjectAccessor::GetCreature(*GetCaster(), GetCaster()->GetInstanceScript()->GetData64(DATA_OCCUTHAR)))
                {
                    if (Creature* creature = occuthar->SummonCreature(NPC_EYE_OF_OCCUTHAR, pos))
                        creature->CastSpell(GetHitUnit(), SPELL_GAZE_OF_OCCUTHAR, false);
                }
            }
 
            void Register() OVERRIDE
            {
                AfterHit += SpellHitFn(spell_occuthar_eyes_of_occuthar_vehicle_SpellScript::HandleScript);
            }
        };
 
        SpellScript* GetSpellScript() const OVERRIDE
        {
            return new spell_occuthar_eyes_of_occuthar_vehicle_SpellScript();
        }
};
 
// 96942 / 101009 - Gaze of Occu'thar
class spell_occuthar_occuthars_destruction : public SpellScriptLoader
{
    public:
        spell_occuthar_occuthars_destruction() : SpellScriptLoader("spell_occuthar_occuthars_destruction") { }
 
        class spell_occuthar_occuthars_destruction_AuraScript : public AuraScript
        {
            PrepareAuraScript(spell_occuthar_occuthars_destruction_AuraScript);
 
            bool Load() OVERRIDE
            {
                return GetCaster() && GetCaster()->GetTypeId() == TypeID::TYPEID_UNIT;
            }
 
            void OnRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
            {
                if (Unit* caster = GetCaster())
                {
                    if (IsExpired())
                        caster->CastSpell((Unit*)NULL, SPELL_OCCUTHARS_DESTUCTION, true, NULL, aurEff);
 
                    caster->ToCreature()->DespawnOrUnsummon(500);
                }
            }
 
            void Register() OVERRIDE
            {
                OnEffectRemove += AuraEffectRemoveFn(spell_occuthar_occuthars_destruction_AuraScript::OnRemove, EFFECT_2, SPELL_AURA_PERIODIC_TRIGGER_SPELL, AURA_EFFECT_HANDLE_REAL);
            }
        };
 
        AuraScript* GetAuraScript() const OVERRIDE
        {
            return new spell_occuthar_occuthars_destruction_AuraScript();
        }
};
 
void AddSC_boss_occuthar()
{
    new boss_occuthar();
    new npc_eyestalk();
    new spell_occuthar_focused_fire();
    new spell_occuthar_eyes_of_occuthar();
    new spell_occuthar_eyes_of_occuthar_vehicle();
    new spell_occuthar_occuthars_destruction();
}