void UpdateAI(const uint32 diff)
        {
            //Return since we have no target
            if (!UpdateVictim())
                return;

            if (bIsWaitingToAppear)
            {
                me->StopMoving();
                me->AttackStop();
                if (uiIsWaitingToAppearTimer <= diff)
                {
                    me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                    bIsWaitingToAppear = false;
                } else uiIsWaitingToAppearTimer -= diff;
                return;
            }

            if ((Phase == 1) ||(Phase == 3))
            {
                if (bFireMagusDead && bFrostMagusDead && bArcaneMagusDead)
                {
                    for (uint8 n = 0; n < 3; ++n)
                        time[n] = 0;
                    me->GetMotionMaster()->Clear();
                    me->SetPosition(CenterOfRoom.GetPositionX(), CenterOfRoom.GetPositionY(), CenterOfRoom.GetPositionZ(), CenterOfRoom.GetOrientation());
                    DoCast(me, SPELL_TELESTRA_BACK);
                    me->SetVisible(true);
                    if (Phase == 1)
                        Phase = 2;
                    if (Phase == 3)
                        Phase = 4;
                    uiFireMagusGUID = 0;
                    uiFrostMagusGUID = 0;
                    uiArcaneMagusGUID = 0;
                    bIsWaitingToAppear = true;
                    uiIsWaitingToAppearTimer = 4*IN_MILLISECONDS;
                    Talk(SAY_MERGE);
                }
                else
                    return;
            }

            if ((Phase == 0) && HealthBelowPct(50))
            {
                Phase = 1;
                me->CastStop();
                me->RemoveAllAuras();
                me->SetVisible(false);
                me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                uiFireMagusGUID = SplitPersonality(MOB_FIRE_MAGUS);
                uiFrostMagusGUID = SplitPersonality(MOB_FROST_MAGUS);
                uiArcaneMagusGUID = SplitPersonality(MOB_ARCANE_MAGUS);
                bFireMagusDead = false;
                bFrostMagusDead = false;
                bArcaneMagusDead = false;
                Talk(SAY_SPLIT);
                return;
            }

            if (IsHeroic() && (Phase == 2) && HealthBelowPct(10))
            {
                Phase = 3;
                me->CastStop();
                me->RemoveAllAuras();
                me->SetVisible(false);
                me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                uiFireMagusGUID = SplitPersonality(MOB_FIRE_MAGUS);
                uiFrostMagusGUID = SplitPersonality(MOB_FROST_MAGUS);
                uiArcaneMagusGUID = SplitPersonality(MOB_ARCANE_MAGUS);
                bFireMagusDead = false;
                bFrostMagusDead = false;
                bArcaneMagusDead = false;
                Talk(SAY_SPLIT);
                return;
            }

            if (uiCooldown)
            {
                if (uiCooldown <= diff)
                    uiCooldown = 0;
                else
                {
                    uiCooldown -= diff;
                    return;
                }
            }

            if (uiIceNovaTimer <= diff)
            {
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                {
                    DoCast(target, SPELL_ICE_NOVA, false);
                    uiCooldown = 1500;
                }
                uiIceNovaTimer = 15*IN_MILLISECONDS;
            } else uiIceNovaTimer -= diff;

            if (uiGravityWellTimer <= diff)
            {
                if (Unit* target = me->GetVictim())
                {
                    DoCast(target, SPELL_GRAVITY_WELL);
                    uiCooldown = 6*IN_MILLISECONDS;
                }
                uiGravityWellTimer = 15*IN_MILLISECONDS;
            } else uiGravityWellTimer -= diff;

            if (uiFireBombTimer <= diff)
            {
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                {
                    DoCast(target, SPELL_FIREBOMB, false);
                    uiCooldown = 2*IN_MILLISECONDS;
                }
                uiFireBombTimer = 2*IN_MILLISECONDS;
            } else uiFireBombTimer -=diff;

            DoMeleeAttackIfReady();
        }
    void UpdateAI(const uint32 diff)
    {
        //Return since we have no target
        if (!UpdateVictim())
            return;

        if (bIsWaitingToAppear)
        {
            me->StopMoving();
            me->AttackStop();
            if (uiIsWaitingToAppearTimer <= diff)
            {
                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                bIsWaitingToAppear = false;
            } else uiIsWaitingToAppearTimer -= diff;
            return;
        }

        if ((Phase == 1) ||(Phase == 3))
        {
            if (bIsAchievementTimerRunning)
                uiAchievementTimer += diff;
            if (bFireMagusDead && bFrostMagusDead && bArcaneMagusDead)
            {
                if (uiAchievementTimer <= ACHIEV_TIMER)
                    uiAchievementProgress +=1;
                me->GetMotionMaster()->Clear();
                me->GetMap()->CreatureRelocation(me, CenterOfRoom.GetPositionX(), CenterOfRoom.GetPositionY(), CenterOfRoom.GetPositionZ(), CenterOfRoom.GetOrientation());
                DoCast(me, SPELL_TELESTRA_BACK);
                me->SetVisibility(VISIBILITY_ON);
                if (Phase == 1)
                    Phase = 2;
                if (Phase == 3)
                    Phase = 4;
                uiFireMagusGUID = 0;
                uiFrostMagusGUID = 0;
                uiArcaneMagusGUID = 0;
                bIsWaitingToAppear = true;
                uiIsWaitingToAppearTimer = 4*IN_MILISECONDS;
                DoScriptText(SAY_MERGE, me);
                bIsAchievementTimerRunning = false;
                uiAchievementTimer = 0;
            }
            else
                return;
        }

        if ((Phase == 0) && HealthBelowPct(50))
        {
            Phase = 1;
            me->CastStop();
            me->RemoveAllAuras();
            me->SetVisibility(VISIBILITY_OFF);
            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
            uiFireMagusGUID = SplitPersonality(MOB_FIRE_MAGUS);
            uiFrostMagusGUID = SplitPersonality(MOB_FROST_MAGUS);
            uiArcaneMagusGUID = SplitPersonality(MOB_ARCANE_MAGUS);
            bFireMagusDead = false;
            bFrostMagusDead = false;
            bArcaneMagusDead = false;
            DoScriptText(RAND(SAY_SPLIT_1,SAY_SPLIT_2), me);
            return;
        }

        if (IsHeroic() && (Phase == 2) && HealthBelowPct(10))
        {
            Phase = 3;
            me->CastStop();
            me->RemoveAllAuras();
            me->SetVisibility(VISIBILITY_OFF);
            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
            uiFireMagusGUID = SplitPersonality(MOB_FIRE_MAGUS);
            uiFrostMagusGUID = SplitPersonality(MOB_FROST_MAGUS);
            uiArcaneMagusGUID = SplitPersonality(MOB_ARCANE_MAGUS);
            bFireMagusDead = false;
            bFrostMagusDead = false;
            bArcaneMagusDead = false;
            DoScriptText(RAND(SAY_SPLIT_1,SAY_SPLIT_2), me);
            return;
        }

        if (uiCooldown)
        {
            if (uiCooldown <= diff)
                uiCooldown = 0;
            else
            {
                uiCooldown -= diff;
                return;
            }
        }

        if (uiIceNovaTimer <= diff)
        {
            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
            {
                DoCast(pTarget, SPELL_ICE_NOVA, false);
                uiCooldown = 1.5*IN_MILISECONDS;
            }
            uiIceNovaTimer = 15*IN_MILISECONDS;
        } else uiIceNovaTimer -= diff;

        if (uiGravityWellTimer <= diff)
        {
            if (Unit *pTarget = me->getVictim())
            {
                DoCast(pTarget, SPELL_GRAVITY_WELL);
                uiCooldown = 6*IN_MILISECONDS;
            }
            uiGravityWellTimer = 15*IN_MILISECONDS;
        } else uiGravityWellTimer -= diff;

        if (uiFireBombTimer <= diff)
        {
            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
            {
                DoCast(pTarget, SPELL_FIREBOMB, false);
                uiCooldown = 2*IN_MILISECONDS;
            }
            uiFireBombTimer = 2*IN_MILISECONDS;
        } else uiFireBombTimer -=diff;

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

        if (AppearDelay)
        {
            m_creature->StopMoving();
            m_creature->AttackStop();
            if (AppearDelay_Timer <= diff)
            {
                m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                AppearDelay = false;
            } else AppearDelay_Timer -= diff;
            return;
        }

        if ((Phase == 1)||(Phase == 3))
        {
            Unit* FireMagus;
            Unit* FrostMagus;
            Unit* ArcaneMagus;
            if (FireMagusGUID)
                FireMagus = m_creature->GetMap()->GetUnit(FireMagusGUID);
            if (FrostMagusGUID)
                FrostMagus = m_creature->GetMap()->GetUnit(FrostMagusGUID);
            if (ArcaneMagusGUID)
                ArcaneMagus = m_creature->GetMap()->GetUnit(ArcaneMagusGUID);
            if (FireMagus && FireMagus->isDead())
            {
                FireMagusDead = true;
                if (!AchievementTimerRunning)
                    AchievementTimerRunning = true;
            }
            if (FrostMagus && FrostMagus->isDead())
            {
                FrostMagusDead = true;
                if (!AchievementTimerRunning)
                    AchievementTimerRunning = true;
            }
            if (ArcaneMagus && ArcaneMagus->isDead())
            {
                ArcaneMagusDead = true;
                if (!AchievementTimerRunning)
                    AchievementTimerRunning = true;
            }
            if (AchievementTimerRunning)
                AchievementTimer += diff;
            if (FireMagusDead && FrostMagusDead && ArcaneMagusDead)
            {
                if (AchievementTimer <= ACHIEV_TIMER)
                    AchievementProgress +=1;
                m_creature->GetMotionMaster()->Clear();
                m_creature->GetMap()->CreatureRelocation(m_creature, CenterOfRoom[0][0], CenterOfRoom[0][1], CenterOfRoom[0][2], CenterOfRoom[0][3]);
                DoCast(m_creature, SPELL_TELESTRA_BACK);
                m_creature->SetVisibility(VISIBILITY_ON);
                if (Phase == 1)
                    Phase = 2;
                if (Phase == 3)
                    Phase = 4;
                FireMagusGUID = 0;
                FrostMagusGUID = 0;
                ArcaneMagusGUID = 0;
                AppearDelay = true;
                AppearDelay_Timer = 4000;
                DoScriptText(SAY_MERGE, m_creature);
                AchievementTimerRunning = false;
                AchievementTimer = 0;
            }else
                return;
        }

        if ((Phase == 0) && (m_creature->GetHealth() <= (m_creature->GetMaxHealth() * 0.5)))
        {
            Phase = 1;
            m_creature->CastStop();
            m_creature->RemoveAllAuras();
            m_creature->SetVisibility(VISIBILITY_OFF);
            m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
            FireMagusGUID = SplitPersonality(MOB_FIRE_MAGUS);
            FrostMagusGUID = SplitPersonality(MOB_FROST_MAGUS);
            ArcaneMagusGUID = SplitPersonality(MOB_ARCANE_MAGUS);
            FireMagusDead = false;
            FrostMagusDead = false;
            ArcaneMagusDead = false;
            DoScriptText(urand(SAY_SPLIT_1,SAY_SPLIT_2), m_creature);
            return;
        }

        if (!m_bIsRegularMode && (Phase == 2) && (m_creature->GetHealth() <= (m_creature->GetMaxHealth() * 0.1)))
        {
            Phase = 3;
            m_creature->CastStop();
            m_creature->RemoveAllAuras();
            m_creature->SetVisibility(VISIBILITY_OFF);
            m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
            FireMagusGUID = SplitPersonality(MOB_FIRE_MAGUS);
            FrostMagusGUID = SplitPersonality(MOB_FROST_MAGUS);
            ArcaneMagusGUID = SplitPersonality(MOB_ARCANE_MAGUS);
            FireMagusDead = false;
            FrostMagusDead = false;
            ArcaneMagusDead = false;
            DoScriptText(urand(SAY_SPLIT_1,SAY_SPLIT_2), m_creature);
            return;
        }

        if (Cooldown)
        {
            if (Cooldown <= diff)
                Cooldown = 0;
            else
            {
                Cooldown -= diff;
                return;
            }
        }

        if (SPELL_ICE_NOVA_Timer <= diff)
        {
            if (Unit *pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
            {
				DoCast(pTarget, m_bIsRegularMode ? SPELL_ICE_NOVA_N : SPELL_ICE_NOVA_H);
                Cooldown = 1500;
            }
            SPELL_ICE_NOVA_Timer = 15000;
        } else SPELL_ICE_NOVA_Timer -=diff;

        if (SPELL_GRAVITY_WELL_Timer <= diff)
        {
            if (Unit *pTarget = m_creature->getVictim())
            {
                DoCast(pTarget, SPELL_GRAVITY_WELL);
                Cooldown = 6000;
            }
            SPELL_GRAVITY_WELL_Timer = 15000;
        } else SPELL_GRAVITY_WELL_Timer -=diff;

        if (SPELL_FIREBOMB_Timer <= diff)
        {
            if (Unit *pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
            {
				DoCast(pTarget, m_bIsRegularMode ? SPELL_FIREBOMB_N : SPELL_FIREBOMB_H);
                Cooldown = 2000;
            }
            SPELL_FIREBOMB_Timer = 2000;
        } else SPELL_FIREBOMB_Timer -=diff;

        DoMeleeAttackIfReady();
    }
Esempio n. 4
0
    void UpdateAI(const uint32 uiDiff)
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        if (m_bAppearDelay)
        {
            m_creature->StopMoving();
            m_creature->AttackStop();

            if (m_uiAppearDelayTimer <= uiDiff)
            {
                m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                m_bAppearDelay = false;
            }
            else
                m_uiAppearDelayTimer -= uiDiff;

            return;
        }

        if ((m_uiPhase == 1) || (m_uiPhase == 3))
        {
            Unit* pFireMagus;
            Unit* pFrostMagus;
            Unit* pArcaneMagus;

            if (!m_pFireMagusGuid.IsEmpty())
                pFireMagus = m_creature->GetMap()->GetUnit(m_pFireMagusGuid);

            if (!m_pFrostMagusGuid.IsEmpty())
                pFrostMagus = m_creature->GetMap()->GetUnit(m_pFrostMagusGuid);

            if (!m_pArcaneMagusGuid.IsEmpty())
                pArcaneMagus = m_creature->GetMap()->GetUnit(m_pArcaneMagusGuid);

            if (pFireMagus && pFireMagus->isDead())
            {
                m_bFireMagusDead = true;
                if (!m_bIsAchievementTimerRunning)
                    m_bIsAchievementTimerRunning = true;
            }

            if (pFrostMagus && pFrostMagus->isDead())
            {
                m_bFrostMagusDead = true;
                if (!m_bIsAchievementTimerRunning)
                    m_bIsAchievementTimerRunning = true;
            }

            if (pArcaneMagus && pArcaneMagus->isDead())
            {
                m_bArcaneMagusDead = true;
                if (!m_bIsAchievementTimerRunning)
                    m_bIsAchievementTimerRunning = true;
            }

            if (m_bIsAchievementTimerRunning)
                m_uiAchievementTimer += uiDiff;

            if (m_bFireMagusDead && m_bFrostMagusDead && m_bArcaneMagusDead)
            {
                if (m_uiAchievementTimer <= ACHIEV_TIMER)
                    m_uiAchievementProgress +=1;

                m_creature->GetMotionMaster()->Clear();
                m_creature->GetMap()->CreatureRelocation(m_creature, CenterOfRoom[0][0], CenterOfRoom[0][1], CenterOfRoom[0][2], CenterOfRoom[0][3]);
                DoCast(m_creature, SPELL_TELESTRA_BACK);
                DoScriptText(SAY_MERGE, m_creature);
                m_creature->SetVisibility(VISIBILITY_ON);

                if (m_uiPhase == 1)
                    m_uiPhase = 2;
                else if (m_uiPhase == 3)
                    m_uiPhase = 4;

                m_bAppearDelay = true;
                m_bIsAchievementTimerRunning = false;
                m_uiAppearDelayTimer = 4*IN_MILLISECONDS;
                m_uiAchievementTimer = 0;
                m_pFireMagusGuid.Clear();
                m_pFrostMagusGuid.Clear();
                m_pArcaneMagusGuid.Clear();
            }
            else
                return;
        }

        if (((m_uiPhase == 0) && (m_creature->GetHealth() <= (m_creature->GetMaxHealth() * 0.5)))
           || (!m_bIsRegularMode && (m_uiPhase == 2) && (m_creature->GetHealth() <= (m_creature->GetMaxHealth() * 0.1))))
        {
            DoScriptText(urand(SAY_SPLIT_1,SAY_SPLIT_2), m_creature);
            m_creature->CastStop();
            m_creature->RemoveAllAuras();
            m_creature->SetVisibility(VISIBILITY_OFF);
            m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);

            m_bFireMagusDead = false;
            m_bFrostMagusDead = false;
            m_bArcaneMagusDead = false;
            m_uiPhase++;
            m_pFireMagusGuid = SplitPersonality(NPC_FIRE_MAGUS);
            m_pFrostMagusGuid = SplitPersonality(NPC_FROST_MAGUS);
            m_pArcaneMagusGuid = SplitPersonality(NPC_ARCANE_MAGUS);
            return;
        }

        if (m_uiCooldownTimer)
        {
            if (m_uiCooldownTimer <= uiDiff)
                m_uiCooldownTimer = 0;
            else
            {
                m_uiCooldownTimer -= uiDiff;
                return;
            }
        }

        if (m_uiIceNovaTimer <= uiDiff)
        {
            if (Unit *pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
            {
                DoCast(pTarget, m_bIsRegularMode ? SPELL_ICE_NOVA_N : SPELL_ICE_NOVA_H);
                m_uiCooldownTimer = 1.5*IN_MILLISECONDS;
            }
            m_uiIceNovaTimer = 15*IN_MILLISECONDS;
        }
        else
            m_uiIceNovaTimer -= uiDiff;

        if (m_uiGravityWellTimer <= uiDiff)
        {
            if (Unit *pTarget = m_creature->getVictim())
            {
                DoCast(pTarget, SPELL_GRAVITY_WELL);
                m_uiCooldownTimer = 6*IN_MILLISECONDS;
            }
            m_uiGravityWellTimer = 15*IN_MILLISECONDS;
        }
        else
            m_uiGravityWellTimer -= uiDiff;

        if (m_uiFirebombTimer <= uiDiff)
        {
            if (Unit *pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
            {
                DoCast(pTarget, m_bIsRegularMode ? SPELL_FIREBOMB_N : SPELL_FIREBOMB_H);
                m_uiCooldownTimer = 2*IN_MILLISECONDS;
            }
            m_uiFirebombTimer = 2*IN_MILLISECONDS;
        }
        else
            m_uiFirebombTimer -= uiDiff;

        DoMeleeAttackIfReady();
    }