Exemple #1
0
        void UpdateAI(const uint32 Diff)
        {
            if (!UpdateVictim())
                return;

            if (_SummonBorerTimer <= Diff)
            {
                instance->DoSendNotifyToInstance("INSTANCE MESSAGE: Rock Borer are spawned"); // Notification Spawn des adds
                b_BORROW = 1;
                DoCast(me,SPELL_BURROW);
                SummonRockBorer();
                _SummonBorerTimer = 30000;
                b_BorrowTimer = 9000;
            }
            else
            {
                _SummonBorerTimer -= Diff;
                b_BorrowTimer -= Diff;
            }
            if (b_BorrowTimer <= Diff)
                b_BORROW = 0;

            if (_CrystalTimer <= Diff)
            {
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
                    if (!IsHeroic())
                        DoCast(target,SPELL_CRYSTAL_BARRAGE);
                    else
                        DoCast(target,SPELL_CRYSTAL_BARRAGE_H);

                    _CrystalTimer = 11000;
            }
            else
                _CrystalTimer -= Diff;

            if (_DampeningTimer <= Diff)
            {
                if (!IsHeroic())
                    DoCast(SPELL_DAMPENING_WAVE);
                else
                    DoCast(SPELL_DAMPENING_WAVE_H);

                _DampeningTimer = 20000;
            }
            else
                _DampeningTimer -= Diff;

            if (b_BORROW == 0)

            DoMeleeAttackIfReady();
        }
        void Reset()
        {
            BellowingRoarTimer = 30000;
            CharredEarthTimer = 15000;
            DistractingAshTimer = 20000;
            SmolderingBreathTimer = 10000;
            TailSweepTimer = 12000;
            RainofBonesTimer = 10000;
            SmokingBlastTimer = 20000;
            FireballBarrageTimer = 13000;
            SearingCindersTimer = 14000;

            Phase = 1;
            FlyCount = 0;
            MovePhase = 0;
            Movement = false;
            Flying = false;

            me->SetSpeed(MOVE_RUN, 2.0f);
            me->SetDisableGravity(true);
            me->SetWalk(false);
            me->setActive(true);

            if (instance)
            {
                if (instance->GetData(TYPE_NIGHTBANE) == DONE || instance->GetData(TYPE_NIGHTBANE) == IN_PROGRESS)
                    me->DisappearAndDie();
                else
                    instance->SetData(TYPE_NIGHTBANE, NOT_STARTED);
            }

            HandleTerraceDoors(true);
            me->SetReactState(REACT_PASSIVE);

            if (!Intro)
            {
                me->SetHomePosition(IntroWay[7][0], IntroWay[7][1], IntroWay[7][2], 0);
                me->GetMotionMaster()->MoveTargetedHome();
            }
            else
                instance->DoSendNotifyToInstance(EMOTE_SUMMON);
        }
Exemple #3
0
        void UpdateAI(const uint32 diff)
        {
            if (!UpdateVictim() || me->HasUnitState(UNIT_STAT_CASTING))
                return;

            if(me->GetHealthPct() < 20 && phase == 1)
            {
                phase = 2;

                DoCast(me, SPELL_MORTALITY);
                DoCastAOE(SPELL_MORTALITY_RAID_DEBUFF);
				instance->DoSendNotifyToInstance("INSTANCE MESSAGE: Chimaeron's Frenzy"); // Notification de la Mortalite

                events.CancelEvent(EVENT_MASSACRE);
                events.CancelEvent(EVENT_BREAK);
                events.CancelEvent(EVENT_CAUSTIC_SLIME);
            }

            events.Update(diff);
            //_DoAggroPulse(diff);

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {

                case EVENT_MASSACRE:
                    DoCast(SPELL_MASSACRE);
                    DoCast(me,SPELL_FEUD);
					instance->DoSendNotifyToInstance("INSTANCE MESSAGE: Chimaeron's Massacre"); // Notification du Massacre

                    if(urand(0,2) == 0)
                        if(Creature* bile_o_tron = ObjectAccessor::GetCreature(*me,instance->GetData64(NPC_BILE_O_TRON)))
                        {
                            bile_o_tron->AI()->DoAction(ACTION_BILE_O_TRON_SYSTEM_FAILURE);
                            events.ScheduleEvent(EVENT_MASSACRE, 45000);
                        }else
                            events.ScheduleEvent(EVENT_MASSACRE, 27000);

                    DoCast(me,SPELL_FEUD);
                    break;

                case EVENT_DOUBLE_ATTACK:
                    DoCastVictim(SPELL_DOUBLE_ATTACK);
                    events.ScheduleEvent(EVENT_DOUBLE_ATTACK, urand(13000,15000));
                    break;

                case EVENT_CAUSTIC_SLIME:
				    SelectTargetList(playerList, RAID_MODE(TARGETS_10,TARGETS_25,TARGETS_10,TARGETS_25), SELECT_TARGET_RANDOM,1,100,true);
					for (std::list<Unit*>::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
                    {
                        Unit *pTemp = (*itr);
                        me->CastSpell(pTemp, SPELL_CAUSTIC_SLIME, true);
                    }
                    events.ScheduleEvent(EVENT_CAUSTIC_SLIME, urand(10000,12000));
                    break;

                case EVENT_BREAK:
                    DoCastVictim(SPELL_BREAK);
                    events.ScheduleEvent(EVENT_BREAK, 14000);
                    break;

                default:
                    break;
                }
            }		

            DoMeleeAttackIfReady();
        }
        void UpdateAI(const uint32 diff)
        {
            if (!UpdateVictim() || me->HasUnitState(UNIT_STAT_CASTING))
                return;

            if(me->GetHealthPct() < 20 && phase == 1)
            {
                phase = 2;

                DoCast(me, SPELL_MORTALITY);
                DoCastAOE(SPELL_MORTALITY_RAID_DEBUFF);
				instance->DoSendNotifyToInstance("Mensaje de estancia: Chimaeron se enfurece!"); // Notification de la Mortalite

                events.CancelEvent(EVENT_MASSACRE);
                events.CancelEvent(EVENT_BREAK);
                events.CancelEvent(EVENT_CAUSTIC_SLIME);
				events.CancelEvent(EVENT_ENEMISTAD);
            }

            events.Update(diff);
            //_DoAggroPulse(diff);

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {

                case EVENT_MASSACRE:
                    DoCast(SPELL_MASSACRE);
                    //DoCast(me,SPELL_FEUD);
					//instance->DoSendNotifyToInstance("INSTANCE MESSAGE: Chimaeron's Massacre"); // Notification du Massacre

                    if(urand(0,2) == 0)
                        if(Creature* bile_o_tron = ObjectAccessor::GetCreature(*me,instance->GetData64(NPC_BILE_O_TRON)))
                        {
                            bile_o_tron->AI()->DoAction(ACTION_BILE_O_TRON_SYSTEM_FAILURE);
                            events.ScheduleEvent(EVENT_MASSACRE, 45000);
                        }else
                            events.ScheduleEvent(EVENT_MASSACRE, 27000);

                    //DoCast(me,SPELL_FEUD);
                    break;

                case EVENT_DOUBLE_ATTACK:
                    DoCastVictim(SPELL_DOUBLE_ATTACK);
                    events.ScheduleEvent(EVENT_DOUBLE_ATTACK, urand(13000,15000));
                    break;

                case EVENT_CAUSTIC_SLIME:
				    SelectTargetList(playerList, RAID_MODE(TARGETS_10,TARGETS_25,TARGETS_10,TARGETS_25), SELECT_TARGET_RANDOM,1,100,true);
					for (std::list<Unit*>::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
                    {
                        Unit *pTemp = (*itr);
                        me->CastSpell(pTemp, SPELL_CAUSTIC_SLIME, true);
                    }
                    events.ScheduleEvent(EVENT_CAUSTIC_SLIME, urand(10000,12000));
                    break;

                case EVENT_BREAK:
                    DoCastVictim(SPELL_BREAK);
                    events.ScheduleEvent(EVENT_BREAK, 14000);
                    break;
               
			    case EVENT_ENEMISTAD:
					events.ScheduleEvent(EVENT_SAY_CABEZA1_1, 1250);
				    instance->DoSendNotifyToInstance("Nefarian: Cimaeron te ordeno que dejes de pelearte contigo mismo, maldito experimento!");
				    DoCast(me,SPELL_ENEMISTAD);
					break;

			    case EVENT_SAY_CABEZA1_1:
				    me->MonsterYell(SAY_CABEZA1_1, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA2_1, 1250);
					break;
					
			    case EVENT_SAY_CABEZA2_1:
				    me->MonsterYell(SAY_CABEZA2_1, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA3_1, 1250);
					break;
					
			    case EVENT_SAY_CABEZA3_1:
				    me->MonsterYell(SAY_CABEZA3_1, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA2_2, 1250);
					break;
										
			    case EVENT_SAY_CABEZA2_2:
				    me->MonsterYell(SAY_CABEZA2_2, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA1_2, 1250);
					break;
										
			    case EVENT_SAY_CABEZA1_2:
				    me->MonsterYell(SAY_CABEZA1_2, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA3_2, 1250);
					break;
										
			    case EVENT_SAY_CABEZA3_2:
				    me->MonsterYell(SAY_CABEZA3_2, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA1_3, 1250);
					break;
										
			    case EVENT_SAY_CABEZA1_3:
				    me->MonsterYell(SAY_CABEZA1_3, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA2_3, 1250);
					break;
										
			    case EVENT_SAY_CABEZA2_3:
				    me->MonsterYell(SAY_CABEZA2_3, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA1_4, 1250);
					break;
										
			    case EVENT_SAY_CABEZA1_4:
				    me->MonsterYell(SAY_CABEZA1_4, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA3_3, 1250);
					break;
					
			    case EVENT_SAY_CABEZA3_3:
				    me->MonsterYell(SAY_CABEZA3_3, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA2_4, 1250);
					break;		
									
			    case EVENT_SAY_CABEZA2_4:
				    me->MonsterYell(SAY_CABEZA2_4, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA1_5, 1250);
					break;	
									
			    case EVENT_SAY_CABEZA1_5:
				    me->MonsterYell(SAY_CABEZA1_5, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA3_4, 1250);
					break;	
									
			    case EVENT_SAY_CABEZA3_4:
				    me->MonsterYell(SAY_CABEZA3_4, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA2_5, 1250);
					break;	
									
			    case EVENT_SAY_CABEZA2_5:
				    me->MonsterYell(SAY_CABEZA2_5, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA1_6, 1250);
					break;	
									
			    case EVENT_SAY_CABEZA1_6:
				    me->MonsterYell(SAY_CABEZA1_6, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA2_6, 1250);
					break;	
									
			    case EVENT_SAY_CABEZA2_6:
				    me->MonsterYell(SAY_CABEZA2_6, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA3_1, 1250);
					break;	
									
			    case EVENT_SAY_CABEZA1_7:
				    me->MonsterYell(SAY_CABEZA1_7, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA2_7, 1250);
					break;	
															
			    case EVENT_SAY_CABEZA2_7:
				    me->MonsterYell(SAY_CABEZA2_7, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA3_5, 1250);
					break;	
															
			    case EVENT_SAY_CABEZA3_5:
				    me->MonsterYell(SAY_CABEZA3_5, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA1_8, 1250);
					break;	
															
			    case EVENT_SAY_CABEZA1_8:
				    me->MonsterYell(SAY_CABEZA1_8, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA2_8, 1250);
					break;	
															
			    case EVENT_SAY_CABEZA2_8:
				    me->MonsterYell(SAY_CABEZA2_8, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA3_6, 1250);
					break;	
			    case EVENT_SAY_CABEZA3_6:
				    me->MonsterYell(SAY_CABEZA3_6, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA1_9, 1250);
					break;	
					
			    case EVENT_SAY_CABEZA1_9:
				    me->MonsterYell(SAY_CABEZA1_9, 0, 0);
					events.ScheduleEvent(EVENT_SAY_CABEZA2_9, 1250);
					break;	
					
			    case EVENT_SAY_CABEZA2_9:
				    me->MonsterYell(SAY_CABEZA2_9, 0, 0);
					break;	
					
                default:
                    break;
                }
            }		

            DoMeleeAttackIfReady();
        }