Пример #1
0
    void UpdateAI(const uint32 uiDiff) override
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        if(m_uiCheckTimer < uiDiff)
        {
            CheckVehicle();
            m_uiCheckTimer = 2000;
        } else m_uiCheckTimer -= uiDiff;

        if(m_uiDragonAttackTimer <= uiDiff)
        {
           DoCast(m_creature, SPELL_SUMMON_BEAM, true);
           m_uiDragonAttackTimer = 25000;
           m_uiDragonMoveTimer = 16000;
           uint8 uiText = urand(0, 2);
           switch (uiText)
           {
              case 0: DoScriptText(SAY_CALL_CAPTAIN_1, m_creature); break;
              case 1: DoScriptText(SAY_CALL_CAPTAIN_2, m_creature); break;
              case 2: DoScriptText(SAY_CALL_CAPTAIN_3, m_creature); break;
           }
        } else m_uiDragonAttackTimer -= uiDiff;

        if(m_uiDragonMoveTimer <= uiDiff)
        {
           if(m_pInstance)
              if(Creature* Dragon = m_pInstance->instance->GetCreature(m_uiAzureDrakeGUID))
              {
                 Dragon->GetMotionMaster()->MovementExpired(false);
                 Dragon->GetMotionMaster()->Clear(false);
                 Dragon->GetMotionMaster()->MovePoint(0, (m_creature->GetPositionX()-45)+rand()%90, (m_creature->GetPositionY()-45)+rand()%90, m_creature->GetPositionZ() + 30.0f);
              }
           m_uiDragonMoveTimer = 25000;
        } else m_uiDragonMoveTimer -= uiDiff;

        if(!m_bIsCastChain)
        {
           if(m_uiOrbCast <= uiDiff)
           {
              m_uiOrbCast = 1000;
              m_bIsCastChain = true;
              SelectFourOrb();
              m_uiCoreTimer = 5000;
           } else m_uiOrbCast -= uiDiff;
        }
        else
        {
           if(m_uiCoreTimer <= uiDiff)
           {
              m_uiCoreTimer = 5000;
              m_bIsCastChain = false;
              CastEnergy();
              m_uiOrbCast = 1000;
           } else m_uiCoreTimer -= uiDiff;
        }

        DoMeleeAttackIfReady();
    }
Пример #2
0
    void UpdateAI(const uint32 uiDiff) override
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        if(!m_bIsTeleported)
        {
           if(m_uiFrostBombTimer < uiDiff)
           {
               m_creature->CastSpell(m_creature->getVictim(), SPELL_FROSTBOMB, false);
               m_uiFrostBombTimer = urand(5000, 7000);
           } else m_uiFrostBombTimer -= uiDiff;

           if(m_uiLiveBombTimer < uiDiff)
           {
               if(Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
                  DoCast(pTarget, m_bIsRegularMode ? SPELL_TIME_BOMB : SPELL_TIME_BOMB_2);
               m_uiLiveBombTimer = urand(15000, 25000);
           } else m_uiLiveBombTimer -= uiDiff;

           if(m_uiTeleportTimer < uiDiff)
           {
               DoCast(m_creature, SPELL_TELEPORT);
               m_uiTeleportTimer = 31500;
           } else m_uiTeleportTimer -= uiDiff;

           if(m_uiCheckTimer < uiDiff)
           {
               CheckVehicle();
               m_uiCheckTimer = 2000;
           } else m_uiCheckTimer -= uiDiff;

           if(m_uiRelocateTimer < uiDiff)
           {
               m_bIsTeleported = true;
               m_creature->SetLevitate(true);
               m_creature->GetMotionMaster()->Clear(false);
               m_creature->GetMotionMaster()->MoveIdle();
               m_creature->StopMoving();
               TeleportBoss(Teleport[4].x,Teleport[4].y,Teleport[4].z,Teleport[4].o);
               m_uiRelocateTimer = 31500;
           } else m_uiRelocateTimer -= uiDiff;

           DoMeleeAttackIfReady();
        }
        else
        {
           if(m_uiArcaneExplodeTimer < uiDiff)
           {
               DoScriptText(urand(0,1) ? SAY_EXPLOSION_1 : SAY_EXPLOSION_2, m_creature);
               DoCast(m_creature, SPELL_EMPOWERED_ARCANE_EXPLOSION);
               m_uiArcaneExplodeTimer = 32000;
           } else m_uiArcaneExplodeTimer -= uiDiff;

           if(m_uiBackTimer < uiDiff)
           {
               TeleportBoss((m_creature->getVictim())->GetPositionX(),(m_creature->getVictim())->GetPositionY(),(m_creature->getVictim())->GetPositionZ(),(m_creature->getVictim())->GetOrientation());
               m_creature->SetLevitate(false);
               if(m_creature->getVictim())
                  m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
               m_uiBackTimer = 9000;
               m_bIsTeleported = false;
               m_uiArcaneExplodeTimer = 1000;
           } else m_uiBackTimer -= uiDiff;
        }
    }
Пример #3
0
    void UpdateAI(const uint32 uiDiff)
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        if (m_uiCheckTimer < uiDiff)
        {
            CheckVehicle();
            m_uiCheckTimer = 2000;
        }
        else
            m_uiCheckTimer -= uiDiff;

        if (m_uiDragonAttackTimer < uiDiff)
        {
            if (DoCastSpellIfCan(m_creature, SPELL_CALL_AZURE_RING_CAPTAIN) == CAST_OK)
            {
                m_uiDragonAttackTimer = 25000;
                uint8 uiText = urand(0, 2);
                switch (uiText)
                {
                    case 0: DoScriptText(SAY_AIRSTRIKE_1, m_creature); break;
                    case 1: DoScriptText(SAY_AIRSTRIKE_2, m_creature); break;
                    case 2: DoScriptText(SAY_AIRSTRIKE_3, m_creature); break;
                }
            }
        }
        else
            m_uiDragonAttackTimer -= uiDiff;

        if (m_uiAmplifyMagicTimer < uiDiff)
        {
            if  (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0, m_bIsRegularMode ? SPELL_CALL_AMPLIFY_MAGIC : SPELL_CALL_AMPLIFY_MAGIC_H, SELECT_FLAG_PLAYER))
            {
                if (DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_CALL_AMPLIFY_MAGIC : SPELL_CALL_AMPLIFY_MAGIC_H) == CAST_OK)
                {
                    m_uiAmplifyMagicTimer = urand(7000, 12000);
                }
            }
        }
        else
            m_uiAmplifyMagicTimer -= uiDiff;


        if(!m_bIsCastChain)
        {
            if(m_uiCoreTimer < uiDiff)
            {
                if (Creature* pCore = m_pInstance->GetFarestVaromOrb())
                {
                    m_creature->SetTargetGuid(pCore->GetTargetGuid());
                    m_creature->SetInFront(pCore);
                    if (DoCastSpellIfCan(pCore, SPELL_ENERGIZE_CORES_SHOW) == CAST_OK)
                    {
                        m_Core = pCore->GetObjectGuid();
                        m_uiCoreTimer = 5000;
                        m_bIsCastChain = true;
                    }
                }
            }
            else
                m_uiCoreTimer -= uiDiff;
        }
        else
        {
            if(m_uiCoreTimer < uiDiff)
            {
                if (Creature* pCore = m_creature->GetMap()->GetCreature(m_Core))
                {
                    m_creature->SetTargetGuid(pCore->GetTargetGuid());
                    m_creature->SetInFront(pCore);
                    if (DoCastSpellIfCan(pCore, m_bIsRegularMode ? SPELL_ENERGIZE_CORES : SPELL_ENERGIZE_CORES_H) == CAST_OK)
                    {
                        m_bIsCastChain = false;
                        m_uiCoreTimer = 5000;
                    }
                }
            }
            else
                m_uiCoreTimer -= uiDiff;
        }

        DoMeleeAttackIfReady();
    }