示例#1
0
    void UpdateAI(const uint32 diff)
    {
        if (IsIntroEvent)
        {
            if (!m_pInstance)
                return;

            if (m_pInstance->GetData(TYPE_NETHEKURSE) == IN_PROGRESS)
            {
                if (IntroEvent_Timer < diff)
                {
                    DoTauntPeons();
                }else IntroEvent_Timer -= diff;
            }
        }

        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        if (!IsMainEvent)
            return;

        if (Phase)
        {
            if (!SpinOnce)
            {
                DoCastSpellIfCan(m_creature->getVictim(),SPELL_DARK_SPIN);
                SpinOnce = true;
            }

            if (Cleave_Timer < diff)
            {
                DoCastSpellIfCan(m_creature->getVictim(), m_bIsRegularMode ? SPELL_SHADOW_CLEAVE : H_SPELL_SHADOW_SLAM);
                Cleave_Timer = urand(6000, 8500);
            }else Cleave_Timer -= diff;
        }
        else
        {
            if (ShadowFissure_Timer < diff)
            {
                if (Unit *target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0))
                    DoCastSpellIfCan(target,SPELL_SHADOW_FISSURE);
                ShadowFissure_Timer = urand(7500, 15000);
            }else ShadowFissure_Timer -= diff;

            if (DeathCoil_Timer < diff)
            {
                if (Unit *target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0))
                    DoCastSpellIfCan(target,SPELL_DEATH_COIL);
                DeathCoil_Timer = urand(15000, 20000);
            }else DeathCoil_Timer -= diff;

            if (m_creature->GetHealthPercent() <= 20.0f)
                Phase = true;

            DoMeleeAttackIfReady();
        }
    }
示例#2
0
    void UpdateAI(const uint32 diff)
    {
        if (IsIntroEvent)
        {
            if (!pInstance)
                return;

            if (pInstance->GetData(TYPE_NETHEKURSE) == IN_PROGRESS)
            {
                if (IntroEvent_Timer <= diff)
                    DoTauntPeons();
                else
                    IntroEvent_Timer -= diff;
            }
        }

        if (!UpdateVictim())
            return;

        if (!IsMainEvent)
            return;

        if (Phase)
        {
            if (!SpinOnce)
            {
                DoCast(me->getVictim(), SPELL_DARK_SPIN);
                SpinOnce = true;
            }

            if (Cleave_Timer <= diff)
            {
                DoCast(me->getVictim(), SPELL_SHADOW_CLEAVE);
                Cleave_Timer = 6000+rand()%2500;
            } else Cleave_Timer -= diff;
        }
        else
        {
            if (ShadowFissure_Timer <= diff)
            {
                if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
                    DoCast(pTarget, SPELL_SHADOW_FISSURE);
                ShadowFissure_Timer = urand(7500,15000);
            } else ShadowFissure_Timer -= diff;

            if (DeathCoil_Timer <= diff)
            {
                if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
                    DoCast(pTarget, SPELL_DEATH_COIL);
                DeathCoil_Timer = urand(15000,20000);
            } else DeathCoil_Timer -= diff;

            if ((me->GetHealth()*100) / me->GetMaxHealth() <= 20)
                Phase = true;

            DoMeleeAttackIfReady();
        }
    }
            void UpdateAI(uint32 diff) override
            {
                if (IsIntroEvent)
                {
                    if (instance->GetBossState(DATA_NETHEKURSE) == IN_PROGRESS)
                    {
                        if (IntroEvent_Timer <= diff)
                            DoTauntPeons();
                        else
                            IntroEvent_Timer -= diff;
                    }
                }

                if (!UpdateVictim())
                    return;

                if (!IsMainEvent)
                    return;

                if (Phase)
                {
                    if (!SpinOnce)
                    {
                        DoCastVictim(SPELL_DARK_SPIN);
                        SpinOnce = true;
                    }

                    if (Cleave_Timer <= diff)
                    {
                        DoCastVictim(SPELL_SHADOW_CLEAVE);
                        Cleave_Timer = 6000 + rand32() % 2500;
                    }
                    else
                        Cleave_Timer -= diff;
                }
                else
                {
                    if (ShadowFissure_Timer <= diff)
                    {
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            DoCast(target, SPELL_SHADOW_FISSURE);
                        ShadowFissure_Timer = urand(7500, 15000);
                    }
                    else
                        ShadowFissure_Timer -= diff;

                    if (DeathCoil_Timer <= diff)
                    {
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            DoCast(target, SPELL_DEATH_COIL);
                        DeathCoil_Timer = urand(15000, 20000);
                    }
                    else
                        DeathCoil_Timer -= diff;

                    if (!HealthAbovePct(20))
                        Phase = true;

                    DoMeleeAttackIfReady();
                }
            }
示例#4
0
    void UpdateAI(const uint32 uiDiff) override
    {
        if (m_bIsIntroEvent)
        {
            if (!m_pInstance)
                return;

            if (m_pInstance->GetData(TYPE_NETHEKURSE) == IN_PROGRESS)
            {
                if (m_uiIntroEventTimer < uiDiff)
                    DoTauntPeons();
                else
                    m_uiIntroEventTimer -= uiDiff;
            }
        }

        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        if (!m_bIsMainEvent)
            return;

        if (m_bPhase)
        {
            if (!m_bSpinOnce)
            {
                DoCastSpellIfCan(m_creature->getVictim(), SPELL_DARK_SPIN);
                m_bSpinOnce = true;
            }

            if (m_uiCleaveTimer < uiDiff)
            {
                DoCastSpellIfCan(m_creature->getVictim(), m_bIsRegularMode ? SPELL_SHADOW_CLEAVE : SPELL_SHADOW_SLAM_H);
                m_uiCleaveTimer = urand(6000, 8500);
            }
            else
                m_uiCleaveTimer -= uiDiff;
        }
        else
        {
            if (m_uiShadowFissureTimer < uiDiff)
            {
                if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
                    DoCastSpellIfCan(pTarget, SPELL_SHADOW_FISSURE);
                m_uiShadowFissureTimer = urand(7500, 15000);
            }
            else
                m_uiShadowFissureTimer -= uiDiff;

            if (m_uiDeathCoilTimer < uiDiff)
            {
                if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
                    DoCastSpellIfCan(pTarget, SPELL_DEATH_COIL);
                m_uiDeathCoilTimer = urand(15000, 20000);
            }
            else
                m_uiDeathCoilTimer -= uiDiff;

            if (m_creature->GetHealthPercent() <= 20.0f)
                m_bPhase = true;

            DoMeleeAttackIfReady();
        }
    }