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

        if (m_uiTwinSpikeTimer < uiDiff)
        {
            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_TWIN_SPIKE_DARK) == CAST_OK)
                m_uiTwinSpikeTimer = 10000;
        }
        else
            m_uiTwinSpikeTimer -= uiDiff;

        // heroic abilities
        if (m_pInstance && m_pInstance->IsHeroicDifficulty())
        {
            if (m_uiTouchTimer < uiDiff)
            {
                if (DoCastSpellIfCan(m_creature, SPELL_DARK_TOUCH) == CAST_OK)
                    m_uiTouchTimer = 20000;
            }
            else
                m_uiTouchTimer -= uiDiff;
        }

        DoMeleeAttackIfReady();
    }
    void Reset() override
    {
        DoCastSpellIfCan(m_creature, SPELL_VALKYR_TWINS_HITTING_YA);

        m_uiTwinSpikeTimer      = 7000;
        m_uiTouchTimer          = 10000;
        m_uiSpecialAbilityTimer = 45000;
        m_uiSummonTimer         = 25000;
        m_uiBerserkTimer        = 8 * MINUTE * IN_MILLISECONDS;

        // always start with light twin pact
        m_bIsLightTwin          = true;
        m_bIsVortex             = false;

        if (m_pInstance && m_pInstance->IsHeroicDifficulty())
            m_uiBerserkTimer    = 6 * MINUTE * IN_MILLISECONDS;
    }
Exemplo n.º 3
0
    void SpellHit(Unit* /*pCaster*/, const SpellEntry* pSpell) override
    {
        if (pSpell->Id == SPELL_SUBMERGE)
        {
            m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);

            // Extra check here, because AnubArak must be submerged by default
            if (m_Phase != PHASE_SUBMERGING)
                return;

            m_Phase = PHASE_UNDERGROUND;

            // Refresh spheres only on normal difficulty
            if (m_pInstance && !m_pInstance->IsHeroicDifficulty())
                DoRefreshSpheres();

            DoCastSpellIfCan(m_creature, SPELL_CLEAR_ALL_DEBUFFS, CAST_TRIGGERED);
            DoCastSpellIfCan(m_creature, SPELL_SUMMON_SPIKES, CAST_TRIGGERED);
            DoCastSpellIfCan(m_creature, SPELL_SUMMON_SCARAB, CAST_TRIGGERED);
        }
    }
    void UpdateAI(const uint32 uiDiff) override
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        // Call specific virtual function
        if (!UpdateCrusaderAI(uiDiff))
            return;

        if (m_uiAbilityTimer < uiDiff)
        {
            uint8 uiIndex = urand(0, m_uiMaxAbilities - 1);
            uint32 uiMinHealth = m_pAbilityArray[uiIndex].m_uiMinHealth;
            uint8 uiTargetType = m_pAbilityArray[uiIndex].m_uiTargetType;

            SelectFlags spellSelectFlag = m_pAbilityArray[uiIndex].m_selectFlag;

            // check timers and health condition
            // only cast spells that have timers expired
            // also check for health percentage for self cast spells
            if (m_uiSpellTimer[uiIndex] || (uiTargetType == TARGET_TYPE_SELF && uiMinHealth && m_creature->GetHealthPercent() > uiMinHealth))
            {
                 m_uiAbilityTimer = 2000;
                 return;
            }
            else
            {
                uint32 uiSpellId = m_pAbilityArray[uiIndex].m_uiSpellId;

                // special case for heroism / bloodlust
                if (uiSpellId == SPELL_HEROISM && m_pInstance && m_pInstance->GetPlayerTeam() == ALLIANCE)
                    uiSpellId = SPELL_BLOODLUST;

                if (CanUseSpecialAbility(uiSpellId, uiTargetType, spellSelectFlag, uiMinHealth))
                {
                    m_uiSpellTimer[uiIndex] = m_pAbilityArray[uiIndex].m_uiCooldown;
                    m_uiAbilityTimer = urand(2000, 6000);
                }
                else
                    m_uiAbilityTimer = 2000;
            }
        }
        else
            m_uiAbilityTimer -= uiDiff;

        // spell cooldown
        for (uint8 i = 0; i < m_uiMaxAbilities; ++i)
        {
            if (m_uiSpellTimer[i])
            {
                if (m_uiSpellTimer[i] <= uiDiff)
                    m_uiSpellTimer[i] = 0;
                else
                    m_uiSpellTimer[i] -= uiDiff;
            }
        }

        // Change target
        if (m_uiResetThreatTimer < uiDiff)
        {
            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 1))
            {
                DoResetThreat();
                AttackStart(pTarget);
                m_uiResetThreatTimer = urand(5000, 15000);
            }
        }
        else
            m_uiResetThreatTimer -= uiDiff;

        // CC check for PVP trinket
        if (m_uiIsCCTimer < uiDiff)
        {
            if (m_creature->isFrozen() || m_creature->hasUnitState(UNIT_STAT_CAN_NOT_REACT))
            {
                // Pvp trinket only in heroic mode
                if (m_pInstance && m_pInstance->IsHeroicDifficulty() && !m_uiTrinketCooldownTimer)
                {
                    if (DoCastSpellIfCan(m_creature, SPELL_PVP_TRINKET, CAST_TRIGGERED) == CAST_OK)
                        m_uiTrinketCooldownTimer = 120000;
                }

                SendAIEventAround(AI_EVENT_GOT_CCED, NULL, 0, CRUSADER_AIEVENT_THROW_RADIUS);
                SendAIEvent(AI_EVENT_GOT_CCED, NULL, m_creature);
                m_uiIsCCTimer = 5000;
            }
            else
                m_uiIsCCTimer = 2000;
        }
        else
            m_uiIsCCTimer -= uiDiff;

        // trinket cooldown
        if (m_uiTrinketCooldownTimer)
        {
            if (m_uiTrinketCooldownTimer <= uiDiff)
                m_uiTrinketCooldownTimer = 0;
            else
                m_uiTrinketCooldownTimer -= uiDiff;
        }

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

        if (m_bIsFuriousCharge)
        {
            if (m_uiFuriosChargeTimer < uiDiff)
            {
                switch (m_uiFuriousChargeStage)
                {
                    case 0:
                        // pick a target
                        if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0, uint32(0), SELECT_FLAG_PLAYER | SELECT_FLAG_IN_LOS))
                        {
                            DoScriptText(EMOTE_MASSIVE_CRASH, m_creature, pTarget);
                            m_creature->SummonCreature(NPC_FURIOUS_CHARGE_STALKER, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 35000);
                        }

                        // apply surge of adrenaline
                        if (m_pInstance && !m_pInstance->IsHeroicDifficulty())
                            DoApplySurgeOfAdrenaline();

                        m_uiFuriosChargeTimer = 1000;
                        break;

                    case 1:
                        // roar at target
                        if (Creature* pTarget = m_creature->GetMap()->GetCreature(m_chargeStalkerGuid))
                            DoCastSpellIfCan(pTarget, SPELL_ROAR);

                        m_uiFuriosChargeTimer = 2000;
                        break;

                    case 2:
                        // jump back and prepare to charge
                        if (Creature* pTarget = m_creature->GetMap()->GetCreature(m_chargeStalkerGuid))
                            DoCastSpellIfCan(pTarget, SPELL_JUMP_BACK);

                        m_uiFuriosChargeTimer = 2000;
                        break;

                    case 3:
                        // charge to the target
                        m_creature->SetSpeedRate(MOVE_RUN, m_fSpeedRate * 4);
                        if (Creature* pTarget = m_creature->GetMap()->GetCreature(m_chargeStalkerGuid))
                            m_creature->GetMotionMaster()->MovePoint(POINT_ID_CHARGE_END, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ());

                        m_uiFuriosChargeTimer = 99999;
                        break;
                }
                ++m_uiFuriousChargeStage;
            }
            else
                m_uiFuriosChargeTimer -= uiDiff;

            // no other actions during charge
            return;
        }

        if (m_uiMassiveCrashTimer < uiDiff)
        {
            SetCombatMovement(false);
            m_creature->InterruptNonMeleeSpells(false);
            m_creature->GetMotionMaster()->Clear();
            m_creature->GetMotionMaster()->MoveJump(aSpawnPositions[0][0], aSpawnPositions[0][1], aSpawnPositions[1][2], 2 * m_creature->GetSpeed(MOVE_RUN), 10.0f, POINT_ID_CHARGE_BEGIN);

            m_bIsFuriousCharge      = true;
            m_uiFuriousChargeStage  = 0;
            m_uiFuriosChargeTimer   = 99999;
            m_uiMassiveCrashTimer   = urand(40000, 45000);
        }
        else
            m_uiMassiveCrashTimer -= uiDiff;

        if (m_uiWhirlTimer < uiDiff)
        {
            if (DoCastSpellIfCan(m_creature, SPELL_WHIRL) == CAST_OK)
                m_uiWhirlTimer = urand(15000, 20000);
        }
        else
            m_uiWhirlTimer -= uiDiff;

        if (m_uiArticBreathTimer < uiDiff)
        {
            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_ARCTIC_BREATH) == CAST_OK)
                m_uiArticBreathTimer = urand(25000, 30000);
        }
        else
            m_uiArticBreathTimer -= uiDiff;

        if (m_uiFerociousButtTimer < uiDiff)
        {
            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_FEROCIOUS_BUTT) == CAST_OK)
                m_uiFerociousButtTimer = 15000;
        }
        else
            m_uiFerociousButtTimer -= uiDiff;

        DoMeleeAttackIfReady();
    }
Exemplo n.º 6
0
    void UpdateAI(const uint32 uiDiff) override
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        switch (m_Phase)
        {
            case PHASE_GROUND:

                // Switch to underground phase on timer
                if (m_PhaseSwitchTimer < uiDiff)
                {
                    if (DoCastSpellIfCan(m_creature, SPELL_SUBMERGE) == CAST_OK)
                    {
                        DoScriptText(SAY_SUBMERGE, m_creature);
                        DoScriptText(EMOTE_BURROW, m_creature);
                        m_PhaseSwitchTimer = 63000;
                        m_Phase = PHASE_SUBMERGING;
                        return;
                    }
                }
                else
                    m_PhaseSwitchTimer -= uiDiff;

                // Switch to phase 3 when below 30%
                if (m_creature->GetHealthPercent() <= 30.0f)
                {
                    if (DoCastSpellIfCan(m_creature, SPELL_LEECHING_SWARM) == CAST_OK)
                    {
                        DoScriptText(SAY_LEECHING_SWARM, m_creature);
                        DoScriptText(EMOTE_LEECHING_SWARM, m_creature);
                        m_Phase = PHASE_LEECHING_SWARM;
                    }
                }

                // No break - the spells are used in both phase 1 and 3
            case PHASE_LEECHING_SWARM:

                if (m_uiFreezingSlashTimer < uiDiff)
                {
                    if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_FREEZING_SLASH) == CAST_OK)
                        m_uiFreezingSlashTimer = 20000;
                }
                else
                    m_uiFreezingSlashTimer -= uiDiff;

                if (m_uiPenetratingColdTimer < uiDiff)
                {
                    if (DoCastSpellIfCan(m_creature, SPELL_PENETRATING_COLD) == CAST_OK)
                        m_uiPenetratingColdTimer = 15000;
                }
                else
                    m_uiPenetratingColdTimer -= uiDiff;

                // The Borrowers are summoned in Ground phase only on normal mode or during Ground and Swarm phase on heroic mode
                if (m_Phase == PHASE_GROUND || (m_pInstance && m_pInstance->IsHeroicDifficulty()))
                {
                    if (m_uiBurrowerSummonTimer < uiDiff)
                    {
                        // The number of targets is handled in core, based on difficulty
                        if (DoCastSpellIfCan(m_creature, SPELL_SUMMON_NERUBIAN_BURROWER) == CAST_OK)
                            m_uiBurrowerSummonTimer = 45000;
                    }
                    else
                        m_uiBurrowerSummonTimer -= uiDiff;
                }

                DoMeleeAttackIfReady();

                break;

            case PHASE_UNDERGROUND:

                // Underground phase is finished
                if (m_PhaseSwitchTimer < uiDiff)
                {
                    DoCastSpellIfCan(m_creature, SPELL_EMERGE, CAST_TRIGGERED);
                    DoCastSpellIfCan(m_creature, SPELL_TELEPORT_TO_SPIKE, CAST_TRIGGERED);
                    DoScriptText(EMOTE_EMERGE, m_creature);
                    DoDespawnPursuingSpikes();

                    m_creature->RemoveAurasDueToSpell(SPELL_SUBMERGE);
                    m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);

                    // Refresh spheres only on normal difficulty
                    if (m_pInstance && !m_pInstance->IsHeroicDifficulty())
                        DoRefreshSpheres();

                    m_PhaseSwitchTimer = 80000;
                    m_Phase = PHASE_GROUND;
                }
                else
                    m_PhaseSwitchTimer -= uiDiff;

                break;
            case PHASE_SUBMERGING:                          // Do nothing, but continue berserk timer
                break;
        }

        if (m_uiBerserkTimer)
        {
            if (m_uiBerserkTimer <= uiDiff)
            {
                if (m_Phase != PHASE_UNDERGROUND)
                {
                    if (DoCastSpellIfCan(m_creature, SPELL_BERSERK) == CAST_OK)
                    {
                        DoScriptText(SAY_BERSERK, m_creature);
                        m_uiBerserkTimer = 0;
                    }
                }
            }
            else
                m_uiBerserkTimer -= uiDiff;
        }
    }
    void UpdateAI(const uint32 uiDiff) override
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        // special ability spell
        if (m_uiSpecialAbilityTimer < uiDiff)
        {
            if (DoCastSpecialAbility())
                m_uiSpecialAbilityTimer = 45000;
        }
        else
            m_uiSpecialAbilityTimer -= uiDiff;

        if (m_uiSummonTimer < uiDiff)
        {
            DoCastSpellIfCan(m_creature, SPELL_LIGHT_BULLET_SUMMON_TRIGGER, CAST_TRIGGERED);
            DoCastSpellIfCan(m_creature, SPELL_DARK_BULLET_SUMMON_TRIGGER, CAST_TRIGGERED);
            m_uiSummonTimer = 30000;
        }
        else
            m_uiSummonTimer -= uiDiff;

        // berserk spell
        if (m_uiBerserkTimer)
        {
            if (m_uiBerserkTimer <= uiDiff)
            {
                // handle berserk for both twins
                if (DoCastSpellIfCan(m_creature, SPELL_BERSERK) == CAST_OK)
                {
                    if (m_pInstance)
                    {
                        if (Creature* pEydis = m_pInstance->GetSingleCreatureFromStorage(NPC_EYDIS))
                        {
                            pEydis->CastSpell(pEydis, SPELL_BERSERK, TRIGGERED_OLD_TRIGGERED);
                            DoScriptText(SAY_BERSERK, pEydis);
                        }
                    }

                    DoScriptText(SAY_BERSERK, m_creature);
                    m_uiBerserkTimer = 0;
                }
            }
            else
                m_uiBerserkTimer -= uiDiff;
        }

        if (m_uiTwinSpikeTimer < uiDiff)
        {
            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_TWIN_SPIKE_LIGHT) == CAST_OK)
                m_uiTwinSpikeTimer = 10000;
        }
        else
            m_uiTwinSpikeTimer -= uiDiff;

        // heroic abilities
        if (m_pInstance && m_pInstance->IsHeroicDifficulty())
        {
            if (m_uiTouchTimer < uiDiff)
            {
                if (DoCastSpellIfCan(m_creature, SPELL_LIGHT_TOUCH) == CAST_OK)
                    m_uiTouchTimer = 20000;
            }
            else
                m_uiTouchTimer -= uiDiff;
        }

        DoMeleeAttackIfReady();
    }