void DamageTaken(Unit* /*attacker*/, uint32& damage) override
        {
            if (me->HealthBelowPctDamaged(90, damage) && !_summon90)
            {
                SythSummoning();
                _summon90 = true;
            }

            if (me->HealthBelowPctDamaged(50, damage) && !_summon50)
            {
                SythSummoning();
                _summon50 = true;
            }

            if (me->HealthBelowPctDamaged(10, damage) && !_summon10)
            {
                SythSummoning();
                _summon10 = true;
            }
        }
Esempio n. 2
0
    void UpdateAI(const uint32 diff)
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        if (m_creature->GetHealthPercent() < 90.0f && !summon90)
        {
            SythSummoning();
            summon90 = true;
        }

        if (m_creature->GetHealthPercent() < 50.0f && !summon50)
        {
            SythSummoning();
            summon50 = true;
        }

        if (m_creature->GetHealthPercent() < 10.0f && !summon10)
        {
            SythSummoning();
            summon10 = true;
        }

        if (flameshock_timer < diff)
        {
            if (Unit *target = SelectUnit(SELECT_TARGET_RANDOM,0))
                DoCastSpellIfCan(target, SPELL_FLAME_SHOCK);

            flameshock_timer = urand(10000, 15000);
        } else flameshock_timer -= diff;

        if (arcaneshock_timer < diff)
        {
            if (Unit *target = SelectUnit(SELECT_TARGET_RANDOM,0))
                DoCastSpellIfCan(target,SPELL_ARCANE_SHOCK);

            arcaneshock_timer = urand(10000, 15000);
        } else arcaneshock_timer -= diff;

        if (frostshock_timer < diff)
        {
            if (Unit *target = SelectUnit(SELECT_TARGET_RANDOM,0))
                DoCastSpellIfCan(target,SPELL_FROST_SHOCK);

            frostshock_timer = urand(10000, 15000);
        } else frostshock_timer -= diff;

        if (shadowshock_timer < diff)
        {
            if (Unit *target = SelectUnit(SELECT_TARGET_RANDOM,0))
                DoCastSpellIfCan(target,SPELL_SHADOW_SHOCK);

            shadowshock_timer = urand(10000, 15000);
        } else shadowshock_timer -= diff;

        if (chainlightning_timer < diff)
        {
            if (Unit *target = SelectUnit(SELECT_TARGET_RANDOM,0))
                DoCastSpellIfCan(target,SPELL_CHAIN_LIGHTNING);

            chainlightning_timer = 25000;
        } else chainlightning_timer -= diff;

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

        if (((m_creature->GetHealth()*100) / m_creature->GetMaxHealth() < 90) && !summon90)
        {
            SythSummoning();
            summon90 = true;
        }

        if (((m_creature->GetHealth()*100) / m_creature->GetMaxHealth() < 50) && !summon50)
        {
            SythSummoning();
            summon50 = true;
        }

        if (((m_creature->GetHealth()*100) / m_creature->GetMaxHealth() < 10) && !summon10)
        {
            SythSummoning();
            summon10 = true;
        }

        if (flameshock_timer <= diff)
        {
            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
                DoCast(pTarget, SPELL_FLAME_SHOCK);

            flameshock_timer = 10000 + rand()%5000;
        } else flameshock_timer -= diff;

        if (arcaneshock_timer <= diff)
        {
            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
                DoCast(pTarget, SPELL_ARCANE_SHOCK);

            arcaneshock_timer = 10000 + rand()%5000;
        } else arcaneshock_timer -= diff;

        if (frostshock_timer <= diff)
        {
            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
                DoCast(pTarget, SPELL_FROST_SHOCK);

            frostshock_timer = 10000 + rand()%5000;
        } else frostshock_timer -= diff;

        if (shadowshock_timer <= diff)
        {
            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
                DoCast(pTarget, SPELL_SHADOW_SHOCK);

            shadowshock_timer = 10000 + rand()%5000;
        } else shadowshock_timer -= diff;

        if (chainlightning_timer <= diff)
        {
            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
                DoCast(pTarget, SPELL_CHAIN_LIGHTNING);

            chainlightning_timer = 25000;
        } else chainlightning_timer -= diff;

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

            if (HealthBelowPct(90) && !summon90)
            {
                SythSummoning();
                summon90 = true;
            }

            if (HealthBelowPct(50) && !summon50)
            {
                SythSummoning();
                summon50 = true;
            }

            if (HealthBelowPct(10) && !summon10)
            {
                SythSummoning();
                summon10 = true;
            }

            if (flameshock_timer <= diff)
            {
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                    DoCast(target, SPELL_FLAME_SHOCK);

                flameshock_timer = urand(10000, 15000);
            } else flameshock_timer -= diff;

            if (arcaneshock_timer <= diff)
            {
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                    DoCast(target, SPELL_ARCANE_SHOCK);

                arcaneshock_timer = urand(10000, 15000);
            } else arcaneshock_timer -= diff;

            if (frostshock_timer <= diff)
            {
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                    DoCast(target, SPELL_FROST_SHOCK);

                frostshock_timer = urand(10000, 15000);
            } else frostshock_timer -= diff;

            if (shadowshock_timer <= diff)
            {
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                    DoCast(target, SPELL_SHADOW_SHOCK);

                shadowshock_timer = urand(10000, 15000);
            } else shadowshock_timer -= diff;

            if (chainlightning_timer <= diff)
            {
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                    DoCast(target, SPELL_CHAIN_LIGHTNING);

                chainlightning_timer = 25000;
            } else chainlightning_timer -= diff;

            DoMeleeAttackIfReady();
        }
    void UpdateAI(const uint32 uiDiff) override
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        // Summon elementals at 90%, 50% and 10% health
        if (m_creature->GetHealthPercent() < m_fHpCheck)
        {
            SythSummoning();
            m_fHpCheck -= 40.0f;
        }

        if (m_uiFlameshockTimer < uiDiff)
        {
            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
            {
                if (DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_FLAME_SHOCK : SPELL_FLAME_SHOCK_H) == CAST_OK)
                    m_uiFlameshockTimer = m_bIsRegularMode ? urand(13000, 28000) : urand(11000, 20000);
            }
        }
        else
            m_uiFlameshockTimer -= uiDiff;

        if (m_uiArcaneshockTimer < uiDiff)
        {
            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
            {
                if (DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_ARCANE_SHOCK : SPELL_ARCANE_SHOCK_H) == CAST_OK)
                    m_uiArcaneshockTimer = m_bIsRegularMode ? urand(13000, 28000) : urand(11000, 20000);
            }
        }
        else
            m_uiArcaneshockTimer -= uiDiff;

        if (m_uiFrostshockTimer < uiDiff)
        {
            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
            {
                if (DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_FROST_SHOCK : SPELL_FROST_SHOCK_H) == CAST_OK)
                    m_uiFrostshockTimer = m_bIsRegularMode ? urand(13000, 28000) : urand(11000, 20000);
            }
        }
        else
            m_uiFrostshockTimer -= uiDiff;

        if (m_uiShadowshockTimer < uiDiff)
        {
            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
            {
                if (DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_SHADOW_SHOCK : SPELL_SHADOW_SHOCK_H) == CAST_OK)
                    m_uiShadowshockTimer = m_bIsRegularMode ? urand(13000, 28000) : urand(11000, 20000);
            }
        }
        else
            m_uiShadowshockTimer -= uiDiff;

        if (m_uiChainlightningTimer < uiDiff)
        {
            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
            {
                if (DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_CHAIN_LIGHTNING : SPELL_CHAIN_LIGHTNING_H) == CAST_OK)
                    m_uiChainlightningTimer = m_bIsRegularMode ? urand(14000, 26000) : urand(13000, 19000);
            }
        }
        else
            m_uiChainlightningTimer -= uiDiff;

        DoMeleeAttackIfReady();
    }
        void UpdateAI(uint32 const diff) 
        {
            if (!UpdateVictim())
                return;

            events.Update(diff);

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                    case EVENT_FLAME_SHOCK:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            DoCast(target, SPELL_FLAME_SHOCK);
                        events.ScheduleEvent(EVENT_FLAME_SHOCK, urand(10000, 15000));
                        break;
                    case EVENT_ARCANE_SHOCK:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            DoCast(target, SPELL_ARCANE_SHOCK);
                        events.ScheduleEvent(EVENT_ARCANE_SHOCK, urand(10000, 15000));
                        break;
                    case EVENT_FROST_SHOCK:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            DoCast(target, SPELL_FROST_SHOCK);
                        events.ScheduleEvent(EVENT_FROST_SHOCK, urand(10000, 15000));
                        break;
                    case EVENT_SHADOW_SHOCK:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            DoCast(target, SPELL_SHADOW_SHOCK);
                        events.ScheduleEvent(EVENT_SHADOW_SHOCK, urand(10000, 15000));
                        break;
                    case EVENT_CHAIN_LIGHTNING:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            DoCast(target, SPELL_CHAIN_LIGHTNING);
                        events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 25000);
                        break;
                    default:
                        break;
                }
            }

            if (HealthBelowPct(90) && !summon90)
            {
                SythSummoning();
                summon90 = true;
            }

            if (HealthBelowPct(50) && !summon50)
            {
                SythSummoning();
                summon50 = true;
            }

            if (HealthBelowPct(10) && !summon10)
            {
                SythSummoning();
                summon10 = true;
            }

            DoMeleeAttackIfReady();
        }