Пример #1
0
            void UpdateAI(uint32 diff) override
            {
                if (Delay_Timer <= diff)
                {
                    Delay_Timer = 3500;

                    Creature* LeftHead  = ObjectAccessor::GetCreature(*me, LeftHeadGUID);
                    Creature* RightHead = ObjectAccessor::GetCreature(*me, RightHeadGUID);

                    if (!LeftHead || !RightHead)
                        return;

                    if (AggroYell)
                    {
                        RightHead->AI()->Talk(GoCombatDelay[iaggro].id);
                        AggroYell = false;
                    }

                    if (ThreatYell2)
                    {
                        Creature* source = (LeftHead->GetEntry() == ThreatDelay2[ithreat].creature ? LeftHead : RightHead);

                        source->AI()->Talk(ThreatDelay2[ithreat].id);
                        ThreatYell2 = false;
                    }

                    if (ThreatYell)
                    {
                        Creature* source = (LeftHead->GetEntry() == ThreatDelay1[ithreat].creature ? LeftHead : RightHead);

                        source->AI()->Talk(ThreatDelay1[ithreat].id);
                        ThreatYell = false;
                        ThreatYell2 = true;
                    }

                    if (KillingYell)
                    {
                        Creature* source = (LeftHead->GetEntry() == KillingDelay[ikilling].creature ? LeftHead : RightHead);

                        source->AI()->Talk(KillingDelay[ikilling].id);
                        KillingYell = false;
                    }
                } else Delay_Timer -= diff;

                if (!UpdateVictim())
                    return;

                if (BlastCount && BlastWave_Timer <= diff)
                {
                    DoCast(me, SPELL_BLAST_WAVE);
                    BlastWave_Timer = 5000;
                    ++BlastCount;

                    if (BlastCount == 3)
                        BlastCount = 0;
                }
                else
                    BlastWave_Timer -= diff;

                if (BurningMaul_Timer <= diff)
                {
                    Talk(EMOTE_ENRAGE);
                    DoCast(me, SPELL_BURNING_MAUL);
                    BurningMaul_Timer = 40000;
                    BlastWave_Timer = 16000;
                    BlastCount = 1;
                }
                else
                    BurningMaul_Timer -= diff;

                if (ResetThreat_Timer <= diff)
                {
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                    {
                        DoYellForThreat();
                        DoResetThreat();
                        me->AddThreat(target, 0.0f);
                    }
                    ResetThreat_Timer = 25000 + rand32() % 15000;
                }
                else
                    ResetThreat_Timer -= diff;

                if (Fear_Timer <= diff)
                {
                    DoCast(me, SPELL_FEAR);
                    Fear_Timer = 15000 + rand32() % 20000;
                }
                else
                    Fear_Timer -= diff;

                if (ThunderClap_Timer <= diff)
                {
                    DoCast(me, SPELL_THUNDERCLAP);
                    ThunderClap_Timer = 15000 + rand32() % 15000;
                }
                else
                    ThunderClap_Timer -= diff;

                DoMeleeAttackIfReady();
            }
    void UpdateAI(const uint32 diff)
    {
        if (Delay_Timer <= diff)
        {
            Delay_Timer = 3500;

            Unit* pLeftHead  = Unit::GetUnit(*m_creature,LeftHeadGUID);
            Unit* pRightHead = Unit::GetUnit(*m_creature,RightHeadGUID);

            if (!pLeftHead || !pRightHead)
                return;

            if (AggroYell)
            {
                DoScriptText(GoCombatDelay[iaggro].id, pRightHead);
                AggroYell = false;
            }

            if (ThreatYell2)
            {
                Unit *source = (pLeftHead->GetEntry() == ThreatDelay2[ithreat].creature ? pLeftHead : pRightHead);

                DoScriptText(ThreatDelay2[ithreat].id, source);
                ThreatYell2 = false;
            }

            if (ThreatYell)
            {
                Unit *source = (pLeftHead->GetEntry() == ThreatDelay1[ithreat].creature ? pLeftHead : pRightHead);

                DoScriptText(ThreatDelay1[ithreat].id, source);
                ThreatYell = false;
                ThreatYell2 = true;
            }

            if (KillingYell)
            {
                Unit *source = (pLeftHead->GetEntry() == KillingDelay[ikilling].creature ? pLeftHead : pRightHead);

                DoScriptText(KillingDelay[ikilling].id, source);
                KillingYell = false;
            }
        } else Delay_Timer -= diff;

        if (!UpdateVictim())
            return;

        if (BlastCount && BlastWave_Timer <= diff)
        {
            DoCast(m_creature, SPELL_BLAST_WAVE);
            BlastWave_Timer = 5000;
            ++BlastCount;

            if (BlastCount == 3)
                BlastCount = 0;
        } else BlastWave_Timer -= diff;

        if (BurningMaul_Timer <= diff)
        {
            DoScriptText(EMOTE_ENRAGE, m_creature);
            DoCast(m_creature, DUNGEON_MODE(SPELL_BURNING_MAUL, H_SPELL_BURNING_MAUL));
            BurningMaul_Timer = 40000;
            BlastWave_Timer = 16000;
            BlastCount = 1;
        } else BurningMaul_Timer -= diff;

        if (ResetThreat_Timer <= diff)
        {
            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
            {
                DoYellForThreat();
                DoResetThreat();
                m_creature->AddThreat(pTarget, 0.0f);
            }
            ResetThreat_Timer = 25000+rand()%15000;
        } else ResetThreat_Timer -= diff;

        if (Fear_Timer <= diff)
        {
            DoCast(m_creature, SPELL_FEAR);
            Fear_Timer = 15000+rand()%20000;
        } else Fear_Timer -= diff;

        if (ThunderClap_Timer <= diff)
        {
            DoCast(m_creature, SPELL_THUNDERCLAP);
            ThunderClap_Timer = 15000+rand()%15000;
        } else ThunderClap_Timer -= diff;

        DoMeleeAttackIfReady();
    }
    void UpdateAI(const uint32 uiDiff)
    {
        if (m_uiDelay_Timer < uiDiff)
        {
            m_uiDelay_Timer = 3500;

            Unit* pLeftHead  = Unit::GetUnit(*m_creature,m_uiLeftHeadGUID);
            Unit* pRightHead = Unit::GetUnit(*m_creature,m_uiRightHeadGUID);

            if (!pLeftHead || !pRightHead)
                return;

            if (m_bAggroYell)
            {
                DoScriptText(GoCombatDelay[m_iAggro].id, pRightHead);
                m_bAggroYell = false;
            }

            if (m_bThreatYell2)
            {
                Unit* pSource = (pLeftHead->GetEntry() == ThreatDelay2[m_iThreat].creature ? pLeftHead : pRightHead);

                DoScriptText(ThreatDelay2[m_iThreat].id, pSource);
                m_bThreatYell2 = false;
            }

            if (m_bThreatYell)
            {
                Unit* pSource = (pLeftHead->GetEntry() == ThreatDelay1[m_iThreat].creature ? pLeftHead : pRightHead);

                DoScriptText(ThreatDelay1[m_iThreat].id, pSource);
                m_bThreatYell = false;
                m_bThreatYell2 = true;
            }

            if (m_bKillingYell)
            {
                Unit* pSource = (pLeftHead->GetEntry() == KillingDelay[m_iKilling].creature ? pLeftHead : pRightHead);

                DoScriptText(KillingDelay[m_iKilling].id, pSource);
                m_bKillingYell = false;
            }
        }else m_uiDelay_Timer -= uiDiff;

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

        if (m_uiBlastCount && m_uiBlastWave_Timer <= uiDiff)
        {
            DoCastSpellIfCan(m_creature,SPELL_BLAST_WAVE);
            m_uiBlastWave_Timer = 5000;
            ++m_uiBlastCount;

            if (m_uiBlastCount == 3)
                m_uiBlastCount = 0;
        }else m_uiBlastWave_Timer -= uiDiff;

        if (m_uiBurningMaul_Timer < uiDiff)
        {
            DoScriptText(EMOTE_ENRAGE, m_creature);
            DoCastSpellIfCan(m_creature, m_bIsRegularMode ? SPELL_BURNING_MAUL : H_SPELL_BURNING_MAUL);
            m_uiBurningMaul_Timer = 40000;
            m_uiBlastWave_Timer = 16000;
            m_uiBlastCount = 1;
        }else m_uiBurningMaul_Timer -= uiDiff;

        if (m_uiResetThreat_Timer < uiDiff)
        {
            if (Unit *target = SelectUnit(SELECT_TARGET_RANDOM,0))
            {
                DoYellForThreat();
                DoResetThreat();
                m_creature->AddThreat(target);
            }
            m_uiResetThreat_Timer = urand(25000, 40000);
        }else m_uiResetThreat_Timer -= uiDiff;

        if (m_uiFear_Timer < uiDiff)
        {
            DoCastSpellIfCan(m_creature,SPELL_FEAR);
            m_uiFear_Timer = urand(15000, 35000);
        }else m_uiFear_Timer -= uiDiff;

        if (m_uiThunderClap_Timer < uiDiff)
        {
            DoCastSpellIfCan(m_creature,SPELL_THUNDERCLAP);
            m_uiThunderClap_Timer = urand(15000, 30000);
        }else m_uiThunderClap_Timer -= uiDiff;

        DoMeleeAttackIfReady();
    }