Example #1
0
 void StartEvent()
 {
     if(pInstance)
         pInstance->SetData(TYPE_ALAR, 1);
     
     CreaturePointMove(0, waypoint[0][0], waypoint[0][1], waypoint[0][2]);
 }
Example #2
0
 void StartEvent()
 {
     if(pInstance)
         pInstance->SetData(DATA_ALAREVENT, 1);
     
     Moving = true;
     CreaturePointMove(cur_wp, waypoint[cur_wp][0], waypoint[cur_wp][1], waypoint[cur_wp][2]);
 }
Example #3
0
    void UpdateAI(const uint32 diff)
    {
        if(!m_creature->SelectHostileTarget() || !m_creature->getVictim() )
            return;

        if (MovementInform_id >= 0)
        {
            Moving = false;
            m_creature->RemoveMonsterMoveFlag(MONSTER_MOVE_FLY);
            switch (MovementInform_id)
            {
                case 0:
                case 1:
                case 2:
                case 3:
                    Platforms_Move_Timer = 30000+rand()%5000;
                    break;
                case 4:
                    DoCast(m_creature, SPELL_FLAME_QUILLS);
                    FlameQuillsDuration_Timer = 10000;
                    FlameQuills = true;
                    break;
                case 5:
                    m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                    m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                    m_creature->SetVisibility(VISIBILITY_ON);
                    DoCast(m_creature, SPELL_REBIRTH);
                    Phase2_begin = true;
                    FakeDeath = false;
                    break;
                case 6:
                    m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FIRE, false);
                    m_creature->SetFloatValue(OBJECT_FIELD_SCALE_X, DefaultSize/4.0f);
                    DoCast(m_creature->getVictim(), SPELL_DIVE_BOMB_VISUAL);
                    DiveBombCastDelay_Timer = 4000;
                    break;
                case 7:
                    m_creature->SetSpeed(MOVE_RUN, DefaultMoveSpeedRate);
                    m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                    m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                    m_creature->SetUInt32Value(UNIT_FIELD_DISPLAYID, DefaultModel);
                    m_creature->SetVisibility(VISIBILITY_OFF);  // I know, that this sequence of commands looks stupid, but without it visual effect of Rebirth 
                    m_creature->SetVisibility(VISIBILITY_ON);   // after Dive Bomb looks not perfect (Al'ar appears, and than again disappears and cast Rebirth).
                    DoCast(m_creature, SPELL_REBIRTH_2);
                    DiveBombCastDelay_Timer = 9999999;
                    FlameBuffetAfterDiveBomb = true;
                    DiveBomb_Timer = 40000+rand()%5000;
                    FlameBuffet_Timer = 5000;
                    break;
            }
            m_creature->GetMotionMaster()->Clear();
            m_creature->GetMotionMaster()->MoveIdle();
            MovementInform_id = -1;
        }
        
        if (!Phase1)
            if (Enrage_Timer < diff)
            {
                DoCast(m_creature, SPELL_ENRAGE);
                Enrage_Timer = 600000;
            }else Enrage_Timer -= diff;

        if (Moving)
        {
            return;
        }

        if (Charge)
        {
            if (ChargeDelay_Timer < diff)
            {
                if (Charge_target && Charge_target_threat && Charge_target_threat > 0 && Charge_target->isAlive() &&
                    Charge_target->GetTypeId() == TYPEID_PLAYER && Charge_target->GetMaxHealth() > 2000 && Charge_target->IsInWorld())
                {
                    m_creature->getThreatManager().modifyThreatPercent(Charge_target, -100);
                    m_creature->getThreatManager().addThreat(Charge_target, Charge_target_threat);
                }
                Charge = false;
                m_creature->SetSpeed(MOVE_RUN, DefaultMoveSpeedRate);
            }else ChargeDelay_Timer -= diff;
            return;
        }

        if (CorpseDisappear_Timer < diff)
        {
            m_creature->SetVisibility(VISIBILITY_OFF);
            m_creature->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
            m_creature->SetHealth(m_creature->GetMaxHealth());
            CreaturePointMove(5, waypoint[5][0], waypoint[5][1], waypoint[5][2]);
            CorpseDisappear_Timer = 9999999;
        }else CorpseDisappear_Timer -= diff;

        if (FakeDeath)
            return;

        if (Phase2_begin)
        {
            m_creature->GetMotionMaster()->Clear();
            m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
            MeltArmor_Timer = 60000;
            Charge_Timer = 7000;
            DiveBomb_Timer = 40000+rand()%5000;
            DiveBombCastDelay_Timer = 9999999;
            FlameBuffet_Timer = 9999999;
            FlamePatch_Timer = 30000;
            Phase2_begin = false;
            Phase1 = false;
            if(pInstance)
                pInstance->SetData(DATA_ALAREVENT, 2);
        }

        if (Phase1)
        {
            if (FlameQuills) {
                if (FlameQuillsDuration_Timer < diff)
                {
                    switch(rand()%2)
                    {
                    case 0:
                        cur_wp = 0;
                        break;
                    case 1:
                        cur_wp = 3;
                        break;
                    }
                    CreaturePointMove(cur_wp, waypoint[cur_wp][0], waypoint[cur_wp][1], waypoint[cur_wp][2]);
                    FlameQuills = false;
                }else FlameQuillsDuration_Timer -= diff;
                return;
            }
            if (Platforms_Move_Timer < diff)
            {
                Creature* Summoned = NULL;
                Summoned = m_creature->SummonCreature(CREATURE_EMBER_OF_ALAR, waypoint[cur_wp][0], waypoint[cur_wp][1], waypoint[cur_wp][2], 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
                if (Summoned)
                {
                    Unit* target = NULL;
                    target = SelectUnit(SELECT_TARGET_RANDOM, 0);
                    if (target)
                        Summoned->AI()->AttackStart(target);
                }
                if (rand()%100 <= 20)
                {
                    cur_wp = 4;
                    FlameQuills = true;
                } else
                {
                    cur_wp++;
                    if (cur_wp == 4)
                        cur_wp = 0;
                }
                CreaturePointMove(cur_wp, waypoint[cur_wp][0], waypoint[cur_wp][1], waypoint[cur_wp][2]);
            }else Platforms_Move_Timer -= diff;

            if (FlameBuffet_Timer < diff)
            {
                std::list<HostileReference*>& m_threatlist = m_creature->getThreatManager().getThreatList();
                if(!m_threatlist.empty())
                {
                    std::list<HostileReference*>::iterator i = m_threatlist.begin();
                    bool InMeleeRange = false;
                    for(i = m_threatlist.begin(); i != m_threatlist.end(); ++i)
                    {
                        Unit* pUnit = NULL;
                        pUnit = Unit::GetUnit((*m_creature), (*i)->getUnitGuid());
                        if (pUnit)
                            if (m_creature->IsWithinDistInMap(pUnit, 5))
                            {                        
                                InMeleeRange = true;
                                m_creature->getThreatManager().addThreat(pUnit, 2.0f);
                                break;
                            }else
                                m_creature->getThreatManager().modifyThreatPercent(pUnit, -100);
                    }
                    if (!InMeleeRange)
                        DoCast(m_creature, SPELL_FLAME_BUFFET);
                }
                FlameBuffet_Timer = 1500;
            }else FlameBuffet_Timer -= diff;
        } else
        {
            if (FlameBuffetAfterDiveBomb)
            {
                if (FlameBuffet_Timer < diff)
                {
                    if (m_creature->IsWithinDistInMap(m_creature->getVictim(), 5))
                    {                        
                        m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
                        FlameBuffetAfterDiveBomb = false;
                        FlameBuffet_Timer = 9999999;
                    } else
                    {
                        DoCast(m_creature, SPELL_FLAME_BUFFET);
                        FlameBuffet_Timer = 1500;
                    }
                } else FlameBuffet_Timer -= diff;
            } else
            {
                if (MeltArmor_Timer < diff)
                {
                    DoCast(m_creature->getVictim(), SPELL_MELT_ARMOR);
                    MeltArmor_Timer = 60000;
                }else MeltArmor_Timer -= diff;

                if (Charge_Timer < diff)
                {
                    Charge_target = SelectUnit(SELECT_TARGET_RANDOM, 1);
                    if (Charge_target)
                    {
                        m_creature->SetInFront(Charge_target);
                        Charge_target_threat = m_creature->getThreatManager().getThreat(Charge_target);
                        m_creature->getThreatManager().addThreat(Charge_target, 100000000.0f);
                        m_creature->SetSpeed(MOVE_RUN, DefaultMoveSpeedRate*5.0f);
                        DoCast(Charge_target, SPELL_CHARGE);
                        ChargeDelay_Timer = 2000;
                        Charge = true;
                    }
                    Charge_Timer = 30000;
                }else Charge_Timer -= diff;
            }

            if (!PrepareDiveBomb)
            {
                if (DiveBomb_Timer < diff)
                {
                    PrepareDiveBomb = true;
                    m_creature->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
                    m_creature->ApplySpellImmune(0, IMMUNITY_EFFECT,SPELL_EFFECT_ATTACK_ME, true);
                    DiveBomb_Timer2 = 1500;
                    DiveBomb_Timer = 40000+rand()%5000;
                }else DiveBomb_Timer -= diff;
            }

            if (PrepareDiveBomb)
            {
                if (DiveBomb_Timer2 < diff)
                {
                    CreaturePointMove(6, waypoint[4][0], waypoint[4][1], waypoint[4][2]);
                    PrepareDiveBomb = false;
                }else DiveBomb_Timer2 -= diff;
            }

            if (DiveBombCastDelay_Timer < diff)
            {
                m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FIRE, true);
                m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                m_creature->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
                m_creature->ApplySpellImmune(0, IMMUNITY_EFFECT,SPELL_EFFECT_ATTACK_ME, false);
                m_creature->SetDisplayId(11686);
                Unit* target = NULL;
                target = SelectUnit(SELECT_TARGET_RANDOM, 0);
                if (target) DoCast(target, SPELL_DIVE_BOMB);
                m_creature->SetFloatValue(OBJECT_FIELD_SCALE_X, DefaultSize);
                m_creature->RemoveAurasDueToSpell(SPELL_DIVE_BOMB_VISUAL);
                m_creature->SetSpeed(MOVE_RUN, DefaultMoveSpeedRate*2.0f);
                if (target)
                {
                    CreaturePointMove(7, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ());
                    Creature* Summoned = NULL;
                    for (int8 i=1; i<=2; i++)
                        {
                            Summoned = m_creature->SummonCreature(CREATURE_EMBER_OF_ALAR, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
                            if (Summoned)
                            {
                                Unit* target1 = NULL;
                                target1 = SelectUnit(SELECT_TARGET_RANDOM, 0);
                                if (target1)
                                    Summoned->AI()->AttackStart(target1);
                            }
                        }
                }
                DiveBombCastDelay_Timer = 9999999;
            }else DiveBombCastDelay_Timer -= diff;

            if (FlamePatch_Timer < diff)
            {
                Unit* target = NULL;
                target = SelectUnit(SELECT_TARGET_RANDOM, 0);
                if (target)
                {
                    Creature* Summoned = NULL;
                    Summoned = m_creature->SummonCreature(CREATURE_FLAME_PATCH_ALAR, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 120000);
                    if (Summoned)
                    {
                        Summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                        Summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                        Summoned->SetFloatValue(OBJECT_FIELD_SCALE_X, Summoned->GetFloatValue(OBJECT_FIELD_SCALE_X)*2.9f);
                        Summoned->SetDisplayId(11686);
                        Summoned->setFaction(m_creature->getFaction());
                        Summoned->SetLevel(m_creature->getLevel());
                        Summoned->CastSpell(Summoned, SPELL_FLAME_PATCH, false);
                    }
                }
                FlamePatch_Timer = 30000;
            }else FlamePatch_Timer -= diff;

        }

        DoMeleeAttackIfReady();
    }