Esempio n. 1
0
    void UpdateAI(const uint32 diff)
    {
        if (!UpdateVictim())
            return;

        events.Update(diff);

        while (uint32 eventId = events.ExecuteEvent())
        {
            switch(eventId)
            {
                case EVENT_BERSERK:
                    DoCast(me, SPELL_BERSERK, true);
                    break;
                case EVENT_FLAME:
                    DoCast(me, SPELL_MOLTEN_PUNCH);
                    events.DelayEvents(1500, GCD_CAST);
                    events.ScheduleEvent(EVENT_FLAME, 20000, GCD_CAST);
                    break;
                case EVENT_HATEFUL_STRIKE:
                    if (Unit *pTarget = CalculateHatefulStrikeTarget())
                        DoCast(pTarget, SPELL_HATEFUL_STRIKE);
                    events.DelayEvents(1000, GCD_CAST);
                    events.ScheduleEvent(EVENT_HATEFUL_STRIKE, 5000, GCD_CAST, PHASE_STRIKE);
                    break;
                case EVENT_SWITCH_TARGET:
                    if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true))
                    {
                        DoResetThreat();
                        me->AddThreat(pTarget, 5000000.0f);
                        DoScriptText(EMOTE_NEW_TARGET, me);
                    }
                    events.ScheduleEvent(EVENT_SWITCH_TARGET, 10000, 0, PHASE_CHASE);
                    break;
                case EVENT_VOLCANO:
                {
                    Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 999, true);
                    if (!pTarget) pTarget = me->getVictim();
                    if (pTarget)
                    {
                        //DoCast(pTarget, SPELL_VOLCANIC_SUMMON);//movement bugged
                        me->SummonCreature(CREATURE_VOLCANO,pTarget->GetPositionX(),pTarget->GetPositionY(),pTarget->GetPositionZ(),0,TEMPSUMMON_TIMED_DESPAWN,30000);
                        DoScriptText(EMOTE_GROUND_CRACK, me);
                        events.DelayEvents(1500, GCD_CAST);
                    }
                    events.ScheduleEvent(EVENT_VOLCANO, 10000, GCD_CAST, PHASE_CHASE);
                    return;
                }
                case EVENT_SWITCH_PHASE:
                    ChangePhase();
                    break;
            }
        }

        DoMeleeAttackIfReady();
    }
Esempio n. 2
0
 void ExecuteEvent(uint32 eventId) override
 {
     switch (eventId)
     {
         case EVENT_BERSERK:
             DoCast(me, SPELL_BERSERK, true);
             break;
         case EVENT_FLAME:
             DoCast(me, SPELL_MOLTEN_PUNCH);
             events.DelayEvents(1500, GCD_CAST);
             events.ScheduleEvent(EVENT_FLAME, 20000, GCD_CAST);
             break;
         case EVENT_HATEFUL_STRIKE:
             if (Unit* target = CalculateHatefulStrikeTarget())
                 DoCast(target, SPELL_HATEFUL_STRIKE);
             events.DelayEvents(1000, GCD_CAST);
             events.ScheduleEvent(EVENT_HATEFUL_STRIKE, 5000, GCD_CAST, PHASE_STRIKE);
             break;
         case EVENT_SWITCH_TARGET:
             if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true))
             {
                 DoResetThreat();
                 me->AddThreat(target, 5000000.0f);
                 Talk(EMOTE_NEW_TARGET);
             }
             events.ScheduleEvent(EVENT_SWITCH_TARGET, 10000, 0, PHASE_CHASE);
             break;
         case EVENT_VOLCANO:
             if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 999, true))
             {
                 //DoCast(target, SPELL_VOLCANIC_SUMMON);//movement bugged
                 me->SummonCreature(NPC_SUPREMUS_VOLCANO, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 30000);
                 Talk(EMOTE_GROUND_CRACK);
                 events.DelayEvents(1500, GCD_CAST);
             }
             events.ScheduleEvent(EVENT_VOLCANO, 10000, GCD_CAST, PHASE_CHASE);
             return;
         case EVENT_SWITCH_PHASE:
             ChangePhase();
             break;
         default:
             break;
     }
 }
Esempio n. 3
0
 void ExecuteEvent(uint32 eventId) override
 {
     switch (eventId)
     {
         case EVENT_BERSERK:
             DoCastSelf(SPELL_BERSERK, true);
             break;
         case EVENT_FLAME:
             DoCast(SPELL_MOLTEN_PUNCH);
             events.Repeat(Seconds(15), Seconds(20));
             break;
         case EVENT_HATEFUL_STRIKE:
             if (Unit* target = CalculateHatefulStrikeTarget())
                 DoCast(target, SPELL_HATEFUL_STRIKE);
             events.Repeat(Seconds(5));
             break;
         case EVENT_SWITCH_TARGET:
             if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100.0f, true))
             {
                 DoResetThreat();
                 me->AddThreat(target, 1000000.0f);
                 DoCast(target, SPELL_CHARGE);
                 Talk(EMOTE_NEW_TARGET);
             }
             events.Repeat(Seconds(10));
             break;
         case EVENT_VOLCANO:
             DoCastAOE(SPELL_VOLCANIC_SUMMON, true);
             Talk(EMOTE_GROUND_CRACK);
             events.Repeat(Seconds(10));
             break;
         case EVENT_SWITCH_PHASE:
             ChangePhase();
             break;
         default:
             break;
     }
 }
Esempio n. 4
0
    void UpdateAI(const uint32 diff)
    {
        if (!UpdateVictim())
            return;

        if(!m_creature->HasAura(SPELL_BERSERK, 0))
        {
            if(BerserkTimer < diff)
                DoCast(m_creature, SPELL_BERSERK);
            else BerserkTimer -= diff;
        }

        if(SummonFlameTimer < diff)
        {
            DoCast(m_creature, SPELL_MOLTEN_PUNCH);
            SummonFlameTimer = 10000;
        }else SummonFlameTimer -= diff;

        if(Phase1)
        {
            if(HatefulStrikeTimer < diff)
            {
                if(Unit* target = CalculateHatefulStrikeTarget())
                {
                    DoCast(target, SPELL_HATEFUL_STRIKE);
                    HatefulStrikeTimer = 5000;
                }
            }else HatefulStrikeTimer -= diff;
        }

        if(!Phase1)
        {
            if(SwitchTargetTimer < diff)
            {
                if(Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 1, 100, true))
                {
                    if(m_creature->GetDistance2d(m_creature->getVictim()) < 40)
                        m_creature->CastSpell(m_creature->getVictim(),SPELL_CHARGE,false);

                    DoResetThreat();
                    m_creature->AddThreat(target, 5000000.0f);
                    DoScriptText(EMOTE_NEW_TARGET, m_creature);
                    SwitchTargetTimer = 10000;
                }
            }else SwitchTargetTimer -= diff;

            if(SummonVolcanoTimer < diff)
            {
                if(Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0, 999, true))
                {
                    DoCast(target, SPELL_VOLCANIC_SUMMON);
                    DoScriptText(EMOTE_GROUND_CRACK, m_creature);
                    SummonVolcanoTimer = 10000;
                }
            }else SummonVolcanoTimer -= diff;
        }

        if(PhaseSwitchTimer < diff)
        {
            if(!Phase1)
            {
                Phase1 = true;
                DoResetThreat();
                PhaseSwitchTimer = 60000;
                m_creature->SetSpeed(MOVE_RUN, 1.2f);
                DoZoneInCombat();
                m_creature->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
                m_creature->ApplySpellImmune(0, IMMUNITY_EFFECT,SPELL_EFFECT_ATTACK_ME, false);
            }
            else
            {
                Phase1 = false;
                DoResetThreat();
                SwitchTargetTimer = 10000;
                SummonVolcanoTimer = 2000;
                PhaseSwitchTimer = 60000;
                m_creature->SetSpeed(MOVE_RUN, 0.9f);
                DoZoneInCombat();
                m_creature->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
                m_creature->ApplySpellImmune(0, IMMUNITY_EFFECT,SPELL_EFFECT_ATTACK_ME, true);
            }
        }else PhaseSwitchTimer -= diff;

        DoMeleeAttackIfReady();
    }