void UpdateAI(const uint32 diff)
        {
            events.Update(diff);
            switch (events.ExecuteEvent())
            {
                case EVENT_START_INTRO:
                    me->GetMotionMaster()->MovePoint(0, MoveThronePos);
                    // Begining of intro is differents between factions as the speech sequence and timers are differents.
                    if (instance->GetData(DATA_TEAM_IN_INSTANCE) == ALLIANCE)
                        events.ScheduleEvent(EVENT_INTRO_A2_1, 0);
                    else
                        events.ScheduleEvent(EVENT_INTRO_H2_1, 0);
                    break;

            // A2 Intro Events
                case EVENT_INTRO_A2_1:
                    DoScriptText(SAY_JAINA_INTRO_3, me);
                    events.ScheduleEvent(EVENT_INTRO_A2_2, 5000);
                    break;
                case EVENT_INTRO_A2_2:
                    DoScriptText(SAY_JAINA_INTRO_4, me);
                    events.ScheduleEvent(EVENT_INTRO_A2_3, 10000);
                    break;
                case EVENT_INTRO_A2_3:
                    // TODO: she's doing some kind of spell casting emote
                    instance->HandleGameObject(instance->GetData64(DATA_FROSTMOURNE), true);
                    events.ScheduleEvent(EVENT_INTRO_A2_4, 10000);
                    break;
                case EVENT_INTRO_A2_4:
                    // spawn UTHER during speach 2
                    if (Creature* pUther = me->SummonCreature(NPC_UTHER, UtherSpawnPos, TEMPSUMMON_MANUAL_DESPAWN))
                    {
                        pUther->GetMotionMaster()->MoveIdle();
                        pUther->SetReactState(REACT_PASSIVE); // be sure he will not aggro arthas
                        uiUther = pUther->GetGUID();
                    }
                    events.ScheduleEvent(EVENT_INTRO_A2_5, 2000);
                    break;
                case EVENT_INTRO_A2_5:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_A2_1, pUther);
                    events.ScheduleEvent(EVENT_INTRO_A2_6, 3000);
                    break;
                case EVENT_INTRO_A2_6:
                    DoScriptText(SAY_JAINA_INTRO_5, me);
                    events.ScheduleEvent(EVENT_INTRO_A2_7, 6000);
                    break;
                case EVENT_INTRO_A2_7:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_A2_2, pUther);
                    events.ScheduleEvent(EVENT_INTRO_A2_8, 6500);
                    break;
                case EVENT_INTRO_A2_8:
                    DoScriptText(SAY_JAINA_INTRO_6, me);
                    events.ScheduleEvent(EVENT_INTRO_A2_9, 2000);
                    break;
                case EVENT_INTRO_A2_9:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_A2_3, pUther);
                    events.ScheduleEvent(EVENT_INTRO_A2_10, 9000);
                    break;
                case EVENT_INTRO_A2_10:
                    DoScriptText(SAY_JAINA_INTRO_7, me);
                    events.ScheduleEvent(EVENT_INTRO_A2_11, 5000);
                    break;
                case EVENT_INTRO_A2_11:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_A2_4, pUther);
                    events.ScheduleEvent(EVENT_INTRO_A2_12, 11000);
                    break;
                case EVENT_INTRO_A2_12:
                    DoScriptText(SAY_JAINA_INTRO_8, me);
                    events.ScheduleEvent(EVENT_INTRO_A2_13, 4000);
                    break;
                case EVENT_INTRO_A2_13:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_A2_5, pUther);
                    events.ScheduleEvent(EVENT_INTRO_A2_14, 12500);
                    break;
                case EVENT_INTRO_A2_14:
                    DoScriptText(SAY_JAINA_INTRO_9, me);
                    events.ScheduleEvent(EVENT_INTRO_A2_15, 10000);
                    break;
                case EVENT_INTRO_A2_15:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_A2_6, pUther);
                    events.ScheduleEvent(EVENT_INTRO_A2_16, 22000);
                    break;
                case EVENT_INTRO_A2_16:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_A2_7, pUther);
                    events.ScheduleEvent(EVENT_INTRO_A2_17, 4000);
                    break;
                case EVENT_INTRO_A2_17:
                    DoScriptText(SAY_JAINA_INTRO_10, me);
                    events.ScheduleEvent(EVENT_INTRO_A2_18, 2000);
                    break;
                case EVENT_INTRO_A2_18:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                    {
                        pUther->HandleEmoteCommand(EMOTE_ONESHOT_NO);
                        DoScriptText(SAY_UTHER_INTRO_A2_8, pUther);
                    }
                    events.ScheduleEvent(EVENT_INTRO_A2_19, 11000);
                    break;
                case EVENT_INTRO_A2_19:
                    DoScriptText(SAY_JAINA_INTRO_11, me);
                    events.ScheduleEvent(EVENT_INTRO_LK_1, 2000);
                    break;

            // H2 Intro Events
                case EVENT_INTRO_H2_1:
                    DoScriptText(SAY_SYLVANAS_INTRO_1, me);
                    events.ScheduleEvent(EVENT_INTRO_H2_2, 8000);
                    break;
                case EVENT_INTRO_H2_2:
                    DoScriptText(SAY_SYLVANAS_INTRO_2, me);
                    events.ScheduleEvent(EVENT_INTRO_H2_3, 6000);
                    break;
                case EVENT_INTRO_H2_3:
                    DoScriptText(SAY_SYLVANAS_INTRO_3, me);
                    // TODO: she's doing some kind of spell casting emote
                    events.ScheduleEvent(EVENT_INTRO_H2_4, 6000);
                    break;
                case EVENT_INTRO_H2_4:
                    // spawn UTHER during speach 2
                    if (Creature* pUther = me->SummonCreature(NPC_UTHER, UtherSpawnPos, TEMPSUMMON_MANUAL_DESPAWN))
                    {
                        pUther->GetMotionMaster()->MoveIdle();
                        pUther->SetReactState(REACT_PASSIVE); // be sure he will not aggro arthas
                        uiUther = pUther->GetGUID();
                    }
                    events.ScheduleEvent(EVENT_INTRO_H2_5, 2000);
                    break;
                case EVENT_INTRO_H2_5:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_H2_1, pUther);
                    events.ScheduleEvent(EVENT_INTRO_H2_6, 11000);
                    break;
                case EVENT_INTRO_H2_6:
                    DoScriptText(SAY_SYLVANAS_INTRO_4, me);
                    events.ScheduleEvent(EVENT_INTRO_H2_7, 3000);
                    break;
                case EVENT_INTRO_H2_7:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_H2_2, pUther);
                    events.ScheduleEvent(EVENT_INTRO_H2_8, 6000);
                    break;
                case EVENT_INTRO_H2_8:
                    DoScriptText(SAY_SYLVANAS_INTRO_5, me);
                    events.ScheduleEvent(EVENT_INTRO_H2_9, 5000);
                    break;
                case EVENT_INTRO_H2_9:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_H2_3, pUther);
                    events.ScheduleEvent(EVENT_INTRO_H2_10, 19000);
                    break;
                case EVENT_INTRO_H2_10:
                    DoScriptText(SAY_SYLVANAS_INTRO_6, me);
                    events.ScheduleEvent(EVENT_INTRO_H2_11, 1500);
                    break;
                case EVENT_INTRO_H2_11:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_H2_4, pUther);
                    events.ScheduleEvent(EVENT_INTRO_H2_12, 19500);
                    break;
                case EVENT_INTRO_H2_12:
                    DoScriptText(SAY_SYLVANAS_INTRO_7, me);
                    events.ScheduleEvent(EVENT_INTRO_H2_13, 2000);
                    break;
                case EVENT_INTRO_H2_13:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                    {
                        pUther->HandleEmoteCommand(EMOTE_ONESHOT_NO);
                        DoScriptText(SAY_UTHER_INTRO_H2_5, pUther);
                    }
                    events.ScheduleEvent(EVENT_INTRO_H2_14, 12000);
                    break;
                case EVENT_INTRO_H2_14:
                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                        DoScriptText(SAY_UTHER_INTRO_H2_6, pUther);
                    events.ScheduleEvent(EVENT_INTRO_H2_15, 8000);
                    break;
                case EVENT_INTRO_H2_15:
                    DoScriptText(SAY_SYLVANAS_INTRO_8, me);
                    events.ScheduleEvent(EVENT_INTRO_LK_1, 2000);
                    break;

            // Remaining Intro Events common for both faction
                case EVENT_INTRO_LK_1:
                    // Spawn LK in front of door, and make him move to the sword.
                    if (Creature* pLichKing = me->SummonCreature(NPC_LICH_KING_EVENT, LichKingSpawnPos, TEMPSUMMON_MANUAL_DESPAWN))
                    {
                        pLichKing->GetMotionMaster()->MovePoint(0, LichKingMoveThronePos);
                        pLichKing->SetReactState(REACT_PASSIVE);
                        uiLichKing = pLichKing->GetGUID();
                    }

                    if (Creature* pUther = me->GetCreature(*me, uiUther))
                    {
                        if (instance->GetData(DATA_TEAM_IN_INSTANCE) == ALLIANCE)
                            DoScriptText(SAY_UTHER_INTRO_A2_9, pUther);
                        else
                            DoScriptText(SAY_UTHER_INTRO_H2_7, pUther);
                    }

                    events.ScheduleEvent(EVENT_INTRO_LK_2, 11000);
                    break;

                case EVENT_INTRO_LK_2:
                     if (Creature* pLichKing = me->GetCreature(*me, uiLichKing))
                         DoScriptText(SAY_LK_INTRO_1, pLichKing);
                     events.ScheduleEvent(EVENT_INTRO_LK_3, 2000);
                     break;

                case EVENT_INTRO_LK_3:
                     // The Lich King banishes Uther to the abyss.
                     if (Creature* pUther = me->GetCreature(*me, uiUther))
                     {
                         pUther->DisappearAndDie();
                         uiUther = 0;
                     }

                     // He steps forward and removes the runeblade from the heap of skulls.

                     events.ScheduleEvent(EVENT_INTRO_LK_4, 4000);
                     break;

                case EVENT_INTRO_LK_4:
                      if (Creature* pLichKing = me->GetCreature(*me, uiLichKing))
                          DoScriptText(SAY_LK_INTRO_2, pLichKing);
                    events.ScheduleEvent(EVENT_INTRO_LK_5, 10000);
                    break;

                case EVENT_INTRO_LK_5:
                    // summon Falric and Marwyn. then go back to the door
                    if (Creature* pFalric = me->GetCreature(*me, instance->GetData64(DATA_FALRIC)))
                        pFalric->SetVisible(true);
                    if (Creature* pMarwyn = me->GetCreature(*me, instance->GetData64(DATA_MARWYN)))
                        pMarwyn->SetVisible(true);

                    if (Creature* pLichKing = me->GetCreature(*me, uiLichKing))
                    {
                        pLichKing->GetMotionMaster()->MovePoint(0, LichKingSpawnPos);
                        DoScriptText(SAY_LK_INTRO_3, pLichKing);
                    }

                    events.ScheduleEvent(EVENT_INTRO_LK_6, 8000);
                    break;

                case EVENT_INTRO_LK_6:
                    if (Creature* pFalric = me->GetCreature(*me, instance->GetData64(DATA_FALRIC)))
                        DoScriptText(SAY_FALRIC_INTRO_1, pFalric);

                    events.ScheduleEvent(EVENT_INTRO_LK_7, 2000);
                    break;

                case EVENT_INTRO_LK_7:
                    if (Creature* pMarwyn = me->GetCreature(*me, instance->GetData64(DATA_MARWYN)))
                        DoScriptText(SAY_MARWYN_INTRO_1, pMarwyn);

                    events.ScheduleEvent(EVENT_INTRO_LK_8, 2000);
                    break;

                case EVENT_INTRO_LK_8:
                    if (Creature* pFalric = me->GetCreature(*me, instance->GetData64(DATA_FALRIC)))
                        DoScriptText(SAY_FALRIC_INTRO_2, pFalric);

                    events.ScheduleEvent(EVENT_INTRO_LK_9, 5000);
                    break;

                case EVENT_INTRO_LK_9:
                    if (instance->GetData(DATA_TEAM_IN_INSTANCE) == ALLIANCE)
                        DoScriptText(SAY_JAINA_INTRO_END, me);
                    else
                        DoScriptText(SAY_SYLVANAS_INTRO_END, me);

                    me->GetMotionMaster()->MovePoint(0, LichKingSpawnPos);
                    // TODO: Loralen/Koreln shall run also
                    events.ScheduleEvent(EVENT_INTRO_END, 10000);
                    break;

                case EVENT_INTRO_END:
                    if (instance)
                        instance->SetData(DATA_WAVE_COUNT, SPECIAL);   // start first wave

                    // Loralen or Koreln disappearAndDie()
                    me->DisappearAndDie();
                    break;

                case EVENT_SKIP_INTRO:
                    // TODO: implement

                    if (Creature* pFalric = me->GetCreature(*me, instance->GetData64(DATA_FALRIC)))
                        pFalric->SetVisible(true);
                    if (Creature* pMarwyn = me->GetCreature(*me, instance->GetData64(DATA_MARWYN)))
                        pMarwyn->SetVisible(true);

                    me->GetMotionMaster()->MovePoint(0, LichKingSpawnPos);
                    // TODO: Loralen/Koreln shall run also

                    events.ScheduleEvent(EVENT_INTRO_END, 15000);
                    break;
            }
        }
        void UpdateAI(uint32 diff) override
        {
            events.Update(diff);

            switch (events.ExecuteEvent())
            {
                case EVENT_SPAWN:
                    {
                        if (Creature* Dalfors = DoSummon(NPC_CRUSADER_LORD_DALFORS, DalforsPos[0]))
                        {
                            guidDalfors = Dalfors->GetGUID();
                            Dalfors->GetMotionMaster()->MovePoint(0, DalforsPos[1]);
                        }
                        if (Creature* Priest1 = DoSummon(NPC_ARGENT_BATTLE_PRIEST, Priest1Pos[0]))
                        {
                            guidPriest[0] = Priest1->GetGUID();
                            Priest1->GetMotionMaster()->MovePoint(0, Priest1Pos[1]);
                        }
                        if (Creature* Priest2 = DoSummon(NPC_ARGENT_BATTLE_PRIEST, Priest2Pos[0]))
                        {
                            guidPriest[1] = Priest2->GetGUID();
                            Priest2->GetMotionMaster()->MovePoint(0, Priest2Pos[1]);
                        }
                        if (Creature* Priest3 = DoSummon(NPC_ARGENT_BATTLE_PRIEST, Priest3Pos[0]))
                        {
                            guidPriest[2] = Priest3->GetGUID();
                            Priest3->GetMotionMaster()->MovePoint(0, Priest3Pos[1]);
                        }
                        if (Creature* Mason1 = DoSummon(NPC_ARGENT_MASON, Mason1Pos[0]))
                        {
                            guidMason[0] = Mason1->GetGUID();
                            Mason1->GetMotionMaster()->MovePoint(0, Mason1Pos[1]);
                        }
                        if (Creature* Mason2 = DoSummon(NPC_ARGENT_MASON, Mason2Pos[0]))
                        {
                            guidMason[1] = Mason2->GetGUID();
                            Mason2->GetMotionMaster()->MovePoint(0, Mason2Pos[1]);
                        }
                        if (Creature* Mason3 = DoSummon(NPC_ARGENT_MASON, Mason3Pos[0]))
                        {
                            guidMason[2] = Mason3->GetGUID();
                            Mason3->GetMotionMaster()->MovePoint(0, Mason3Pos[1]);
                        }
                        events.ScheduleEvent(EVENT_INTRO_1, 15000);
                    }
                    break;
                case EVENT_INTRO_1:
                    {
                        if (Creature* Dalfors = ObjectAccessor::GetCreature(*me, guidDalfors))
                            Dalfors->AI()->Talk(DALFORS_SAY_PRE_1);
                        events.ScheduleEvent(EVENT_INTRO_2, 5000);
                    }
                    break;
                case EVENT_INTRO_2:
                    {
                        if (Creature* Dalfors = ObjectAccessor::GetCreature(*me, guidDalfors))
                        {
                            Dalfors->SetFacingTo(6.215f);
                            Dalfors->AI()->Talk(DALFORS_SAY_PRE_2);
                        }
                    events.ScheduleEvent(EVENT_INTRO_3, 5000);
                    }
                    break;
                case EVENT_INTRO_3:
                    {
                        if (Creature* Dalfors = ObjectAccessor::GetCreature(*me, guidDalfors))
                        {
                            Dalfors->GetMotionMaster()->MovePoint(0, DalforsPos[2]);
                            Dalfors->SetHomePosition(DalforsPos[2]);
                        }
                        if (Creature* Priest1 = ObjectAccessor::GetCreature(*me, guidPriest[0]))
                        {
                            Priest1->SetFacingTo(5.7421f);
                            Priest1->SetHomePosition(Priest1Pos[1]);
                        }
                        if (Creature* Priest2 = ObjectAccessor::GetCreature(*me, guidPriest[1]))
                        {
                            Priest2->SetFacingTo(5.7421f);
                            Priest2->SetHomePosition(Priest2Pos[1]);
                        }
                        if (Creature* Priest3 = ObjectAccessor::GetCreature(*me, guidPriest[2]))
                        {
                            Priest3->SetFacingTo(5.7421f);
                            Priest3->SetHomePosition(Priest3Pos[1]);
                        }
                        if (Creature* Mason1 = ObjectAccessor::GetCreature(*me, guidMason[0]))
                        {
                            Mason1->GetMotionMaster()->MovePoint(0, Mason1Pos[2]);
                            Mason1->SetHomePosition(Mason1Pos[2]);
                        }
                        if (Creature* Mason2 = ObjectAccessor::GetCreature(*me, guidMason[1]))
                        {
                            Mason2->GetMotionMaster()->MovePoint(0, Mason2Pos[2]);
                            Mason2->SetHomePosition(Mason2Pos[2]);
                        }
                        if (Creature* Mason3 = ObjectAccessor::GetCreature(*me, guidMason[2]))
                        {
                            Mason3->GetMotionMaster()->MovePoint(0, Mason3Pos[2]);
                            Mason3->SetHomePosition(Mason3Pos[2]);
                        }
                        events.ScheduleEvent(EVENT_START_FIGHT, 5000);
                        events.ScheduleEvent(EVENT_MASON_ACTION, 15000);
                    }
                    break;
                case EVENT_MASON_ACTION:
                    {
                        if (Creature* Mason1 = ObjectAccessor::GetCreature(*me, guidMason[0]))
                        {
                            Mason1->SetFacingTo(2.8972f);
                            Mason1->AI()->SetData(1, 1); // triggers SAI actions on npc
                        }
                        if (Creature* Mason2 = ObjectAccessor::GetCreature(*me, guidMason[1]))
                        {
                            Mason2->SetFacingTo(3.1241f);
                            Mason2->AI()->SetData(1, 1); // triggers SAI actions on npc
                        }
                        if (Creature* Mason3 = ObjectAccessor::GetCreature(*me, guidMason[2]))
                        {
                            Mason3->SetFacingTo(3.6651f);
                            Mason3->AI()->SetData(1, 1); // triggers SAI actions on npc
                        }
                    }
                    break;
                case EVENT_START_FIGHT:
                    {
                        if (Creature* LK = GetClosestCreatureWithEntry(me, NPC_LK, 100))
                            LK->AI()->Talk(LK_TALK_1);
                        if (Creature* Dalfors = ObjectAccessor::GetCreature(*me, guidDalfors))
                            Dalfors->AI()->Talk(DALFORS_SAY_START);
                        events.ScheduleEvent(EVENT_WAVE_SPAWN, 1000);
                    }
                    break;
                case EVENT_WAVE_SPAWN:
                    {
                        if (PhaseCount == 3)
                        {
                            if (Creature* LK = GetClosestCreatureWithEntry(me, NPC_LK, 100))
                                LK->AI()->Talk(LK_TALK_2);
                        }
                        else if (PhaseCount == 6)
                        {
                            if (Creature* LK = GetClosestCreatureWithEntry(me, NPC_LK, 100))
                                LK->AI()->Talk(LK_TALK_3);
                        }
                        if (Creature* tempsum = DoSummon(NPC_SCOURGE_DRUDGE, Mason3Pos[0]))
                            {
                                tempsum->SetHomePosition(DalforsPos[2]);
                                tempsum->AI()->AttackStart(GetClosestCreatureWithEntry(me, NPC_BLESSED_BANNER, 100));
                            }
                        if (urand(0, 1) == 0)
                        {
                            if (Creature* tempsum = DoSummon(NPC_HIDEOUS_PLAGEBRINGER, Mason1Pos[0]))
                            {
                                tempsum->SetHomePosition(DalforsPos[2]);
                                tempsum->AI()->AttackStart(GetClosestCreatureWithEntry(me, NPC_BLESSED_BANNER, 100));
                            }
                            if (Creature* tempsum = DoSummon(NPC_HIDEOUS_PLAGEBRINGER, Mason2Pos[0]))
                            {
                                tempsum->SetHomePosition(DalforsPos[2]);
                                tempsum->AI()->AttackStart(GetClosestCreatureWithEntry(me, NPC_BLESSED_BANNER, 100));
                            }
                        }
                        else
                        {
                            if (Creature* tempsum = DoSummon(NPC_REANIMATED_CAPTAIN, Mason1Pos[0]))
                            {
                                tempsum->SetHomePosition(DalforsPos[2]);
                                tempsum->AI()->AttackStart(GetClosestCreatureWithEntry(me, NPC_BLESSED_BANNER, 100));
                            }
                            if (Creature* tempsum = DoSummon(NPC_REANIMATED_CAPTAIN, Mason2Pos[0]))
                            {
                                tempsum->SetHomePosition(DalforsPos[2]);
                                tempsum->AI()->AttackStart(GetClosestCreatureWithEntry(me, NPC_BLESSED_BANNER, 100));
                            }
                        }

                        PhaseCount++;

                        if (PhaseCount < 8)
                            events.ScheduleEvent(EVENT_WAVE_SPAWN, urand(10000, 20000));
                        else
                            events.ScheduleEvent(EVENT_HALOF, urand(10000, 20000));
                    }
                    break;
                case EVENT_HALOF:
                    {
                        if (Creature* LK = GetClosestCreatureWithEntry(me, NPC_LK, 100))
                            LK->AI()->Talk(LK_TALK_4);
                        if (Creature* tempsum = DoSummon(NPC_SCOURGE_DRUDGE, Mason1Pos[0]))
                        {
                            tempsum->SetHomePosition(DalforsPos[2]);
                            tempsum->AI()->AttackStart(GetClosestCreatureWithEntry(me, NPC_BLESSED_BANNER, 100));
                        }
                        if (Creature* tempsum = DoSummon(NPC_SCOURGE_DRUDGE, Mason2Pos[0]))
                        {
                            tempsum->SetHomePosition(DalforsPos[2]);
                            tempsum->AI()->AttackStart(GetClosestCreatureWithEntry(me, NPC_BLESSED_BANNER, 100));
                        }
                        if (Creature* tempsum = DoSummon(NPC_HALOF_THE_DEATHBRINGER, DalforsPos[0]))
                        {
                            HalofSpawned = true;
                            guidHalof = tempsum->GetGUID();
                            tempsum->SetHomePosition(DalforsPos[2]);
                            tempsum->AI()->AttackStart(GetClosestCreatureWithEntry(me, NPC_BLESSED_BANNER, 100));
                        }
                    }
                    break;
                case EVENT_ENDED:
                    {
                        Summons.DespawnAll();
                        me->DespawnOrUnsummon();
                    }
                    break;
            }

            if (PhaseCount == 8)
                if (Creature* Halof = ObjectAccessor::GetCreature(*me, guidHalof))
                    if (Halof->isDead())
                    {
                        DoCast(me, SPELL_CRUSADERS_SPIRE_VICTORY, true);
                        Summons.DespawnEntry(NPC_HIDEOUS_PLAGEBRINGER);
                        Summons.DespawnEntry(NPC_REANIMATED_CAPTAIN);
                        Summons.DespawnEntry(NPC_SCOURGE_DRUDGE);
                        Summons.DespawnEntry(NPC_HALOF_THE_DEATHBRINGER);
                        if (Creature* Dalfors = ObjectAccessor::GetCreature(*me, guidDalfors))
                            Dalfors->AI()->Talk(DALFORS_YELL_FINISHED);
                        events.ScheduleEvent(EVENT_ENDED, 10000);
                    }
        }
        void UpdateAI(const uint32 diff)
        {
            if (!UpdateVictim())
            {
                if (phase == PHASE_FLIGHT && !me->IsInEvadeMode())
                    EnterEvadeMode();
                return;
            }

            events.Update(diff);

            if (me->IsNonMeleeSpellCasted(false))
                return;

            if (phase == PHASE_GROUND)
            {
                switch (events.ExecuteEvent())
                {
                    case EVENT_BERSERK:
                        DoScriptText(YELL_BERSERK, me);
                        DoCast(me, SPELL_BERSERK, true);
                        events.ScheduleEvent(EVENT_BERSERK, 10000);
                        break;
                    case EVENT_CLEAVE:
                        DoCast(me->getVictim(), SPELL_CLEAVE, false);
                        events.ScheduleEvent(EVENT_CLEAVE, urand(5000, 10000));
                        break;
                    case EVENT_CORROSION:
                        DoCast(me->getVictim(), SPELL_CORROSION, false);
                        events.ScheduleEvent(EVENT_CORROSION, urand(20000, 30000));
                        break;
                    case EVENT_GAS_NOVA:
                        DoCast(me, SPELL_GAS_NOVA, false);
                        events.ScheduleEvent(EVENT_GAS_NOVA, urand(20000, 25000));
                        break;
                    case EVENT_ENCAPSULATE:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150, true))
                            DoCast(target, SPELL_ENCAPSULATE_CHANNEL, false);
                        events.ScheduleEvent(EVENT_ENCAPSULATE, urand(25000, 30000));
                        break;
                    case EVENT_FLIGHT:
                        EnterPhase(PHASE_FLIGHT);
                        break;
                    default:
                        DoMeleeAttackIfReady();
                        break;
                }
            }

            if (phase == PHASE_FLIGHT)
            {
                switch (events.ExecuteEvent())
                {
                    case EVENT_BERSERK:
                        DoScriptText(YELL_BERSERK, me);
                        DoCast(me, SPELL_BERSERK, true);
                        break;
                    case EVENT_FLIGHT_SEQUENCE:
                        HandleFlightSequence();
                        break;
                    case EVENT_SUMMON_FOG:
                        {
                            float x, y, z;
                            me->GetPosition(x, y, z);
                            me->UpdateGroundPositionZ(x, y, z);
                            if (Creature* Fog = me->SummonCreature(MOB_VAPOR_TRAIL, x, y, z, 0, TEMPSUMMON_TIMED_DESPAWN, 10000))
                            {
                                Fog->RemoveAurasDueToSpell(SPELL_TRAIL_TRIGGER);
                                Fog->CastSpell(Fog, SPELL_FOG_TRIGGER, true);
                                me->CastSpell(Fog, SPELL_FOG_FORCE, true);
                            }
                        }
                        events.ScheduleEvent(EVENT_SUMMON_FOG, 1000);
                        break;
                }
            }
        }
示例#4
0
            void UpdateAI(uint32 diff)
            {
                if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_CASTING))
                    return;

                events.Update(diff);

                while (uint32 eventId = events.ExecuteEvent())
                {
                    switch (eventId)
                    {
                        case EVENT_PYROBLAST:
                            DoCastVictim(SPELL_PYROBLAST);
                            events.ScheduleEvent(EVENT_PYROBLAST, urand(3500, 4500));
                            break;

                        case EVENT_FLARECORE:
                            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
                                DoCast(target, SPELL_FLARECORE_MISSILE);
                            events.ScheduleEvent(EVENT_FLARECORE, urand(19000, 21000));
                            break;

                        case EVENT_BLINK:
                            Talk(SAY_BLINK);
                            DoCast(me, SPELL_BLINK);
                            if (Creature* blink = me->FindNearestCreature(NPC_BLINK_TARGT, 200.0f, true))
                                me->NearTeleportTo(blink->GetPositionX(), blink->GetPositionY(), blink->GetPositionZ(), blink->GetOrientation());
                            events.CancelEvent(EVENT_PYROBLAST);
                            events.CancelEvent(EVENT_FLARECORE);
                            events.ScheduleEvent(EVENT_FROST_BLADES, 1500);
                            events.ScheduleEvent(EVENT_FROSTBOLT_VOLLEY, 2000);
                            events.ScheduleEvent(EVENT_BLINK, 31500);
                            break;

                        case EVENT_FROSTBOLT_VOLLEY:
                            if(VolleyCount < 3)
                            {
                                DoCast(me, SPELL_FROSTBOLT_VOLLEY);
                                events.ScheduleEvent(EVENT_FROSTBOLT_VOLLEY, 2200);
                                VolleyCount++;
                            }
                            else
                            {
                                Talk(SAY_FROSTBOLT_VOLLEY);
                                DoCast(me, SPELL_FROSTBOLT_VOLLEY);
                                events.CancelEvent(EVENT_FROSTBOLT_VOLLEY);
                                VolleyCount = 0;
                                events.ScheduleEvent(EVENT_PYROBLAST, urand(3000, 3500));
                                events.ScheduleEvent(EVENT_FLARECORE, urand (7500, 8500));
                            }
                            break;

                        case EVENT_FROST_BLADES:
                            Talk(SAY_FROST_BLADES);
                            me->SummonCreature(NPC_FROSTBLADES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation() - 0.1f, TEMPSUMMON_TIMED_DESPAWN, 10000);
                            me->SummonCreature(NPC_FROSTBLADES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation(), TEMPSUMMON_TIMED_DESPAWN, 10000);
                            me->SummonCreature(NPC_FROSTBLADES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation() + 0.1f, TEMPSUMMON_TIMED_DESPAWN, 10000);
                            break;
                    }
                }
            }
示例#5
0
			void UpdateAI(uint32 diff)
			{
				events2.Update(diff);
				switch (events2.ExecuteEvent())
				{
					case EVENT_SHADE_GATHER_NPCS:
					{
						std::list<Creature*> ChannelerList;
						me->GetCreaturesWithEntryInRange(ChannelerList, 100.0f, NPC_ASHTONGUE_CHANNELER);
						for (std::list<Creature*>::const_iterator itr = ChannelerList.begin(); itr != ChannelerList.end(); ++itr)
							summonsChanneler.Summon(*itr);

						std::list<Creature*> SpawnerList;
						me->GetCreaturesWithEntryInRange(SpawnerList, 100.0f, NPC_CREATURE_GENERATOR_AKAMA);
						for (std::list<Creature*>::const_iterator itr = SpawnerList.begin(); itr != SpawnerList.end(); ++itr)
							summonsGenerator.Summon(*itr);

						summonsChanneler.Respawn();
						summonsGenerator.Respawn();
						ChannelersAction(ACTION_CHANNELERS_START_CHANNEL);
						
						if (Creature* akama = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_AKAMA_SHADE)))
							akama->Respawn(true);
						break;
					}
					case EVENT_SHADE_RESET_ENCOUNTER:
						me->SetVisible(true);
						summonsGenerator.Respawn();
						summonsChanneler.Respawn();
						ChannelersAction(ACTION_CHANNELERS_START_CHANNEL);

						if (Creature* akama = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_AKAMA_SHADE)))
							akama->Respawn(true);
						break;
				}

				if (!UpdateVictim())
					return;

				events.Update(diff);
				if (me->HasUnitState(UNIT_STATE_CASTING))
					return;

				switch (events.ExecuteEvent())
				{
					case EVENT_SHADE_CHECK_DISTANCE:
						if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() != POINT_MOTION_TYPE)
						{
							int32 slow = me->GetMaxNegativeAuraModifier(SPELL_AURA_MOD_DECREASE_SPEED);
							if (slow > -100)
							{
								me->SetWalk(true);
								me->GetMotionMaster()->MovePoint(POINT_START, 510.0f, 400.7993f, 112.7837f);
							}
						}
						else
						{
							int32 slow = me->GetMaxNegativeAuraModifier(SPELL_AURA_MOD_DECREASE_SPEED);
							if (slow < -100)
								me->GetMotionMaster()->Clear();
							else if (slow == 0)
							{
								summonsGenerator.DoAction(ACTION_NO_SORCERERS);
								me->SetWalk(false);
							}
						}

						if (me->IsWithinMeleeRange(me->GetVictim()))
						{
							me->SetReactState(REACT_AGGRESSIVE);
							DoResetThreat();
							me->GetVictim()->InterruptNonMeleeSpells(false);
							me->AddThreat(me->GetVictim(), 1000000.0f);
							me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC|UNIT_FLAG_IMMUNE_TO_NPC|UNIT_FLAG_NOT_SELECTABLE);
							summonsGenerator.DoAction(ACTION_STOP_SPAWNING);
							break;
						}
						events.ScheduleEvent(EVENT_SHADE_CHECK_DISTANCE, 1000);
						break;
				}

				DoMeleeAttackIfReady();
				EnterEvadeIfOutOfCombatArea();
			}
示例#6
0
        void UpdateAI(const uint32 diff)
        {
            if (phase == PHASE_INTRO)
            {
                if (!instance)
                    return;

                events.Update(diff);
                switch (events.ExecuteEvent())
                {
                case EVENT_INTRO_1:
                    DoScriptText(SAY_JAINA_INTRO_1, me);
                    events.ScheduleEvent(EVENT_INTRO_2, 8000);
                    break;

                case EVENT_INTRO_2:
                    DoScriptText(SAY_JAINA_INTRO_2, me);
                    events.ScheduleEvent(EVENT_INTRO_3, 8500);
                    break;

                case EVENT_INTRO_3:
                    DoScriptText(SAY_JAINA_INTRO_3, me);
                    events.ScheduleEvent(EVENT_INTRO_4, 8000);
                    break;

                case EVENT_INTRO_4:
                    DoScriptText(SAY_JAINA_INTRO_4, me);
                    events.ScheduleEvent(EVENT_INTRO_5, 10000);
                    break;

                case EVENT_INTRO_5:
                    DoScriptText(SAY_JAINA_INTRO_5, me);
                    events.ScheduleEvent(EVENT_INTRO_6, 8000);
                    break;

                case EVENT_INTRO_6:
                    DoScriptText(SAY_JAINA_INTRO_6, me);
                    events.ScheduleEvent(EVENT_INTRO_7, 12000);
                    break;

                case EVENT_INTRO_7:
                    DoScriptText(SAY_JAINA_INTRO_7, me);
                    events.ScheduleEvent(EVENT_INTRO_8, 8000);
                    break;

                case EVENT_INTRO_8:
                    DoScriptText(SAY_JAINA_INTRO_8, me);
                    // End of Intro
                    phase = PHASE_NORMAL;
                    break;
                }
            }

            //Return since we have no target
            if (!UpdateVictim())
                return;

            events.Update(diff);

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

            if (insanityHandled)
            {
                if (!CheckPhaseMinions())
                    return;

                insanityHandled = 0;
                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                me->SetControlled(false, UNIT_STATE_STUNNED);
                me->RemoveAurasDueToSpell(INSANITY_VISUAL);
            }

            events.Update(diff);
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;

            switch (events.GetEvent())
            {
                case EVENT_HERALD_HEALTH:
                {
                    if (insanityTimes == 0 && me->GetHealthPct() <= 66)
                    {
                        me->CastSpell(me, SPELL_INSANITY, false);
                        insanityTimes++;
                    }
                    else if (insanityTimes == 1 && me->GetHealthPct() <= 33)
                    {
                        me->CastSpell(me, SPELL_INSANITY, false);
                        insanityTimes++;
                    }

                    events.RepeatEvent(1000);
                    break;
                }
                case EVENT_HERALD_MIND_FLAY:
                {
                    me->CastSpell(me->GetVictim(), IsHeroic() ? SPELL_MIND_FLAY_H : SPELL_MIND_FLAY, false);
                    events.RepeatEvent(20000);
                    break;
                }
                case EVENT_HERALD_SHADOW:
                {
                    me->CastSpell(me->GetVictim(), IsHeroic() ? SPELL_SHADOW_BOLT_VOLLEY_H : SPELL_SHADOW_BOLT_VOLLEY, false);
                    events.RepeatEvent(5000);
                    break;
                }
                case EVENT_HERALD_SHIVER:
                {
                    if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
                        me->CastSpell(pTarget, IsHeroic() ? SPELL_SHIVER_H : SPELL_SHIVER, false);

                    events.RepeatEvent(15000);
                    break;
                }
            }

            DoMeleeAttackIfReady();
        }
示例#8
0
        void UpdateAI(uint32 diff)
        {
            m_events.Update(diff);
            while (uint32 eventId = m_events.ExecuteEvent())
            {
                switch (eventId)
                {
                case 1:
                {
                    // if (GameObject* door = ObjectAccessor::GetGameObject(*me, m_instance->GetData64(DATA_FACTORY_DOOR)))
                    // door->UseDoorOrButton();

                    

                    m_events.ScheduleEvent(1, 10000);
                    break;
                }
                }
            }

            if (!UpdateVictim())
                return;

            if (phase == 1)
            {
                if (SpellTimer <= diff)
                {
                    switch (urand(0, 1))
                    {
                    case 0:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
                            DoCast(me, SPELL_FIST_OF_FLAME);
                        Talk(SAY_FISTS_OF_FLAME);
                        break;

                    case 1:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
                            DoCast(me, SPELL_FIST_OF_FROST);
                        Talk(SAY_FISTS_OF_FROST);
                        break;
                    }

                    SpellTimer = urand(10 * IN_MILLISECONDS, 25 * IN_MILLISECONDS);
                }
                else SpellTimer -= diff;

                if (HealthBelowPct(50))
                {
                    phase = 2;
                    DoCast(me, SPELL_ARCANE_POWER);
                    Talk(SAY_ARCANE_POWER);
                }

                DoMeleeAttackIfReady();
            }
            else
            {
                if (SpellTimer <= diff)
                {
                    DoCast(me, urand(1, 2) == 1 ? SPELL_FROST_BLOSSOM : SPELL_FIRE_BLOSSOM);
                    SpellTimer = urand(10 * IN_MILLISECONDS, 25 * IN_MILLISECONDS);
                }
                else SpellTimer -= diff;
            }

            if (PhaseChangeTimer <= diff && Phase == PHASE_NORMAL)
            {
                if (PhaseChangeTimer <= diff)
                {
                    me->SetReactState(REACT_AGGRESSIVE);
                    elemental_fists = 20000;
                    blinkTimer = 12000;
                    Phase = PHASE_NORMAL;
                }
                else PhaseChangeTimer -= diff;

                if (elemental_fists <= diff && Phase == PHASE_NORMAL)
                {
                    if (elemental_fists <= diff)
                    {
                        DoCast(me, elemental_fists);
                        me->MonsterYell(SAY_FLAME, LANG_UNIVERSAL, NULL);
                        elemental_fists = 20000;
                    }
                    else elemental_fists -= diff;
                }

                if (blinkTimer <= diff && Phase == PHASE_NORMAL)
                {
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 10.0f, true))
                        DoCast(me, SPELL_BLINK);
                    blinkTimer = 12000;
                }
                else blinkTimer -= diff;

                DoMeleeAttackIfReady();
            }
        }
            void UpdateAI(const uint32 diff)
            {
                if (!UpdateVictim())
                    return;

                if (me->HasUnitState(UNIT_STATE_CASTING))
                    return;

                events.Update(diff);

                while (uint32 eventId = events.ExecuteEvent())
                {
                    switch (eventId)
                    {
                        case EVENT_BLOODY_PREY:
                            if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
                                me->CastSpell(target, SPELL_BLOODY_PREY, false);
                            events.ScheduleEvent(EVENT_BLOODY_PREY,      10000);
                            break;
                        case EVENT_CLAW_RIP:
                            if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
                                me->CastSpell(target, SPELL_CLAW_RIP, false);
                            events.ScheduleEvent(EVENT_CLAW_RIP,      15000);
                            break;
                        case EVENT_GROWL:
                            if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
                                me->CastSpell(target, SPELL_GROWL, false);
                            events.ScheduleEvent(EVENT_GROWL,      28000);
                            break;
                        case EVENT_ROAR_OF_COURAGE:
                            if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
                                me->CastSpell(target, SPELL_ROAR_OF_COURAGE, false);
                            events.ScheduleEvent(EVENT_ROAR_OF_COURAGE,      70000);
                            break;
                        case EVENT_BLOOD_CRAZED:
                            if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
                                me->CastSpell(target, SPELL_BLOOD_CRAZED, false);
                            events.ScheduleEvent(EVENT_BLOOD_CRAZED,      31000);
                            break;
                        case EVENT_BLOODTHIRST:
                            if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
                                me->CastSpell(target, SPELL_BLOODTHIRST, false);
                            events.ScheduleEvent(EVENT_BLOODTHIRST,      40000);
                            break;
                        case EVENT_CLAW_SLASH:
                            if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
                                me->CastSpell(target, SPELL_CLAW_SLASH, false);
                            events.ScheduleEvent(EVENT_CLAW_SLASH,      25000);
                            break;
                        case EVENT_FRENZY:
                            if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
                                me->CastSpell(target, SPELL_FRENZY, false);
                            events.ScheduleEvent(EVENT_FRENZY,      50000);
                            break;
                        default:
                            break;
                    }
                }

                DoMeleeAttackIfReady();
            }
        void UpdateAI(uint32 diff)
        {
            if (!UpdateVictim())
                return;

            if (me->GetVictim())
            {
                float x,y,z;
                me->GetVictim()->GetPosition(x, y, z);
                if (TSDistCheckPos.GetExactDist(x,y,z) > 100.0f || z > TSDistCheckPos.GetPositionZ()+20.0f || z < TSDistCheckPos.GetPositionZ()-20.0f)
                {
                    me->SetHealth(me->GetMaxHealth());
                    EnterEvadeMode();
                    return;
                }
            }

            events.Update(diff);

            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;

            switch(events.GetEvent())
            {
                case 0:
                    break;
                case EVENT_SPELL_FORCEFUL_SMASH:
                    if (me->IsWithinMeleeRange(me->GetVictim()))
                    {
                        me->CastSpell(me->GetVictim(), SPELL_FORCEFUL_SMASH, false);
                        events.PopEvent();
                        events.RescheduleEvent(EVENT_SPELL_UNHOLY_POWER, 1000);
                        break;
                    }
                    events.RepeatEvent(3000);
                    break;
                case EVENT_SPELL_UNHOLY_POWER:
                    Talk(SAY_SMASH);
                    Talk(EMOTE_SMASH);
                    me->CastSpell(me, SPELL_UNHOLY_POWER, false);
                    events.PopEvent();
                    events.ScheduleEvent(EVENT_SPELL_FORCEFUL_SMASH, urand(40000, 48000));
                    break;
                case EVENT_SPELL_OVERLORDS_BRAND:
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 95.0f, true))
                        me->CastSpell(target, SPELL_OVERLORDS_BRAND, false);
                    events.RepeatEvent(urand(11000,12000));
                    break;
                case EVENT_RIMEFANG_SPELL_ICY_BLAST:
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 190.0f, true))
                        if (Creature* c = pInstance->instance->GetCreature(pInstance->GetData64(DATA_RIMEFANG_GUID)))
                            c->CastSpell(target, RIMEFANG_SPELL_ICY_BLAST, false);
                    events.RepeatEvent(5000);
                    break;
                case EVENT_SPELL_MARK_OF_RIMEFANG:
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 190.0f, true))
                        if (Creature* c = pInstance->instance->GetCreature(pInstance->GetData64(DATA_RIMEFANG_GUID)))
                        {
                            Talk(SAY_MARK);
                            c->AI()->Talk(EMOTE_RIMEFANG_ICEBOLT, target);
                            c->CastSpell(target, RIMEFANG_SPELL_HOARFROST, false);
                        }
                    events.RepeatEvent(25000);
                    events.RescheduleEvent(EVENT_RIMEFANG_SPELL_ICY_BLAST, 10000);
                    break;
            }

            DoMeleeAttackIfReady();
        }
        void UpdateAI(const uint32 diff)
        {
            if (!UpdateVictim())
                return;

            if (me->GetDistance(me->GetHomePosition()) > 60.0f)
            {
                EnterEvadeMode();
                return;
            }

            events.Update(diff);

            /*if (me->GetHealthPct() <= 66 && stage == 0)
            {
                events.Reset();
                stage = 1;
                DoCast(SPELL_CHAINS_OF_WOE);
                events.ScheduleEvent(EVENT_SKULLCRACKER, 2100);
            }

            if (me->GetHealthPct() <= 33 && stage == 1)
            {
                events.Reset();
                stage = 2;
                DoCast(SPELL_CHAINS_OF_WOE);
                events.ScheduleEvent(EVENT_SKULLCRACKER, 2100);
            }*/

            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                case EVENT_WOUNDING_STRIKE:
                    DoCast(me->getVictim(), DUNGEON_MODE(SPELL_WOUNDING_STRIKE, SPELL_WOUNDING_STRIKE_H));
                    events.ScheduleEvent(EVENT_WOUNDING_STRIKE, urand(6000, 7000));
                    break;
                case EVENT_QUAKE:
                    DoCast(me, SPELL_QUAKE);
                    if (IsHeroic())
                    {
                        Map::PlayerList const& players = me->GetMap()->GetPlayers();
                        if (me->GetMap()->IsDungeon() && !players.isEmpty())
                        {
                            for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                            {
                                Player* pPlayer = itr->getSource();
                                me->SummonCreature(NPC_ANGERED_EARTH, pPlayer->GetPositionX(), pPlayer->GetPositionY(), pPlayer->GetPositionZ(),0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
                            }
                        }
                    }
                    events.ScheduleEvent(EVENT_QUAKE, urand(18000, 20000));
                    break;
                }
            }

            DoMeleeAttackIfReady();
        }
示例#12
0
        void UpdateAI(const uint32 diff)
        {
            if (phase == PHASE_OUTRO)
            {
                if (!pInstance)
                    return;

                events.Update(diff);
                switch(events.ExecuteEvent())
                {
                    case EVENT_OUTRO_1:
                    {
                        DoScriptText(SAY_KRICK_OUTRO_1, me);
                        events.ScheduleEvent(EVENT_OUTRO_2, 14000);
                        break;
                    }
                    case EVENT_OUTRO_2:
                    {
                        Creature* pNpcDialog = me->GetCreature(*me, uiNpcOutroDialog);
                        if (pNpcDialog)
                        {
                            if (pInstance->GetData(DATA_TEAM_IN_INSTANCE) == TEAM_ALLIANCE)
                                DoScriptText(SAY_JAYNA_OUTRO_2, pNpcDialog);
                            else
                                DoScriptText(SAY_SYLVANAS_OUTRO_2, pNpcDialog);
                        }
                        events.ScheduleEvent(EVENT_OUTRO_3, 8500);
                        break;
                    }
                    case EVENT_OUTRO_3:
                        DoScriptText(SAY_KRICK_OUTRO_3, me);
                        events.ScheduleEvent(EVENT_OUTRO_4, 12000);
                        break;
                    case EVENT_OUTRO_4:
                    {
                        Creature* pNpcDialog = me->GetCreature(*me, uiNpcOutroDialog);
                        if (pNpcDialog)
                        {
                            if (pInstance->GetData(DATA_TEAM_IN_INSTANCE) == TEAM_ALLIANCE)
                                DoScriptText(SAY_JAYNA_OUTRO_4, pNpcDialog);
                            else
                                DoScriptText(SAY_SYLVANAS_OUTRO_4, pNpcDialog);
                        }
                        events.ScheduleEvent(EVENT_OUTRO_5, 8000);
                        break;
                    }
                    case EVENT_OUTRO_5:
                        DoScriptText(SAY_KRICK_OUTRO_5, me);
                        events.ScheduleEvent(EVENT_OUTRO_6, 4000);
                        break;
                    case EVENT_OUTRO_6:
                        // TODO spawn Tyrannus at some distance and MovePoint near-by (flying on rimefang)
                        // store uiTyrannus
                        // Adjust timer so tyrannus has time to come
                        uiTyrannus = (pInstance ? pInstance->GetData64(DATA_TYRANNUS) : 0);
                        events.ScheduleEvent(EVENT_OUTRO_7, 1);
                        break;
                    case EVENT_OUTRO_7:
                        if (Creature *pTyrannus = me->GetCreature(*me, uiTyrannus))
                            DoScriptText(SAY_TYRANNUS_OUTRO_7, pTyrannus);
                        events.ScheduleEvent(EVENT_OUTRO_8, 7000);
                        break;
                    case EVENT_OUTRO_8:
                        DoScriptText(SAY_KRICK_OUTRO_8, me);
                        // TODO: Tyrannus starts killing Krick.
                        // there shall be some visual spell effect
                        events.ScheduleEvent(EVENT_OUTRO_9, 6000);
                        break;
                    case EVENT_OUTRO_9:
                        // tyrannus kills krick
                        me->SetStandState(UNIT_STAND_STATE_DEAD);
                        me->SetHealth(0);

                        if (Creature *pTyrannus = me->GetCreature(*me, uiTyrannus))
                            DoScriptText(SAY_TYRANNUS_OUTRO_9, pTyrannus);

                        events.ScheduleEvent(EVENT_OUTRO_10, 12000);
                        break;
                    case EVENT_OUTRO_10:
                    {
                        Creature* pNpcDialog = me->GetCreature(*me, uiNpcOutroDialog);
                        if (pNpcDialog)
                        {
                            if (pInstance->GetData(DATA_TEAM_IN_INSTANCE) == TEAM_ALLIANCE)
                                DoScriptText(SAY_JAYNA_OUTRO_10, pNpcDialog);
                            else
                                DoScriptText(SAY_SYLVANAS_OUTRO_10, pNpcDialog);
                        }

                        // End of OUTRO. for now...
                        events.ScheduleEvent(EVENT_OUTRO_END, 8000);
                        break;
                    }
                    case EVENT_OUTRO_END:
                    {
                        Creature* pNpcDialog = me->GetCreature(*me, uiNpcOutroDialog);
                        if (pNpcDialog)
                            pNpcDialog->DisappearAndDie();

                        me->DisappearAndDie();
                        break;
                    }
                }
                return;
            }
        }
示例#13
0
        void UpdateAI(const uint32 diff)
        {
            switch(phase)
            {
            case PHASE_CHAINED:
                if (!anchorGUID)
                {
                    if (Creature* anchor = me->FindNearestCreature(29521, 30))
                    {
                        anchor->AI()->SetGUID(me->GetGUID());
                        anchor->CastSpell(me, SPELL_SOUL_PRISON_CHAIN, true);
                        anchorGUID = anchor->GetGUID();
                    }
                    else
                        sLog->outError("npc_unworthy_initiateAI: unable to find anchor!");

                    float dist = 99.0f;
                    GameObject* prison = NULL;

                    for (uint8 i = 0; i < 12; ++i)
                    {
                        if (GameObject* temp_prison = me->FindNearestGameObject(acherus_soul_prison[i], 30))
                        {
                            if (me->IsWithinDist(temp_prison, dist, false))
                            {
                                dist = me->GetDistance2d(temp_prison);
                                prison = temp_prison;
                            }
                        }
                    }

                    if (prison)
                        prison->ResetDoorOrButton();
                    else
                        sLog->outError("npc_unworthy_initiateAI: unable to find prison!");
                }
                break;
            case PHASE_TO_EQUIP:
                if (wait_timer)
                {
                    if (wait_timer > diff)
                        wait_timer -= diff;
                    else
                    {
                        me->GetMotionMaster()->MovePoint(1, anchorX, anchorY, me->GetPositionZ());
                        //sLog->outDebug(LOG_FILTER_TSCR, "npc_unworthy_initiateAI: move to %f %f %f", anchorX, anchorY, me->GetPositionZ());
                        phase = PHASE_EQUIPING;
                        wait_timer = 0;
                    }
                }
                break;
            case PHASE_TO_ATTACK:
                if (wait_timer)
                {
                    if (wait_timer > diff)
                        wait_timer -= diff;
                    else
                    {
                        me->setFaction(14);
                        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
                        phase = PHASE_ATTACKING;

                        if (Player* target = Unit::GetPlayer(*me, playerGUID))
                            me->AI()->AttackStart(target);
                        wait_timer = 0;
                    }
                }
                break;
            case PHASE_ATTACKING:
                if (!UpdateVictim())
                    return;

                events.Update(diff);

                while (uint32 eventId = events.ExecuteEvent())
                {
                    switch(eventId)
                    {
                    case EVENT_ICY_TOUCH:
                        DoCast(me->getVictim(), SPELL_ICY_TOUCH);
                        events.DelayEvents(1000, GCD_CAST);
                        events.ScheduleEvent(EVENT_ICY_TOUCH, 5000, GCD_CAST);
                        break;
                    case EVENT_PLAGUE_STRIKE:
                        DoCast(me->getVictim(), SPELL_PLAGUE_STRIKE);
                        events.DelayEvents(1000, GCD_CAST);
                        events.ScheduleEvent(SPELL_PLAGUE_STRIKE, 5000, GCD_CAST);
                        break;
                    case EVENT_BLOOD_STRIKE:
                        DoCast(me->getVictim(), SPELL_BLOOD_STRIKE);
                        events.DelayEvents(1000, GCD_CAST);
                        events.ScheduleEvent(EVENT_BLOOD_STRIKE, 5000, GCD_CAST);
                        break;
                    case EVENT_DEATH_COIL:
                        DoCast(me->getVictim(), SPELL_DEATH_COIL);
                        events.DelayEvents(1000, GCD_CAST);
                        events.ScheduleEvent(EVENT_DEATH_COIL, 5000, GCD_CAST);
                        break;
                    }
                }

                DoMeleeAttackIfReady();
                break;
            default:
                break;
            }
        }
示例#14
0
            void UpdateAI(const uint32 diff)
            { 
                // Falled to water in out of platform = die
                CheckPlayersInWater();

                if (!UpdateVictim())
                    return;

                events.Update(diff);

                switch (events.ExecuteEvent())
                {
                    case EVENT_HARD_STARE:
                        if (me->getVictim())
                        {
                            DoPlaySoundToSet(me, 35334); // wound
                            DoCast(me->getVictim(),SPELL_HARD_STARE);
                        }
                        events.ScheduleEvent(EVENT_HARD_STARE, 13000);
                        break;
                    case EVENT_GAZE:
                        {
                            Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 2.0f, true);
                            if (!target)
                                if (!me->HasUnitState(UNIT_STATE_CASTING))
                                    DoCast(SPELL_GAZE);
                            events.ScheduleEvent(EVENT_GAZE, 2000);
                            break;
                        }
                    case EVENT_BERSERK:
                        events.CancelEventGroup(0); // clear all events
                        me->AI()->Talk(SAY_BERSERK);
                        DoCast(SPELL_BERSERK_KILLALL);
                        break;
                    // Spectrum phase start
                    case EVENT_LIGHT_SPECTRUM_SAY_SUMMON:
                        FogKilled = 0;
                        me->AI()->Talk(SAY_SUMMON_SPECTRUM);
                        SummonSomeCreatures(RED_FOG, 3, 10.0f); // 3 red fog
                        SummonSomeCreatures(BLUE_FOG, 1, 10.0f); // 1 blue fog
                        events.ScheduleEvent(EVENT_LIGHT_SPECTRUM, 3000);
                        break;
                    case EVENT_LIGHT_SPECTRUM:
                        me->AI()->Talk(SAY_SPECTRUM_INF);
                        SummonBeamsEye();
                        break;
                    // Spectrum phase end

                    // Disintegration Beam phase start
                    case EVENT_MAZE_TIME:
                        Maze(true);
                        events.ScheduleEvent(EVENT_MAZE_ORIENTATION, 5000);
                        events.ScheduleEvent(EVENT_MAZE_END, 47000);
                        events.ScheduleEvent(EVENT_MIND_DAGGERS, 6000);
                        SendMazeToEyes(true);
                        break;
                    case EVENT_MAZE_ORIENTATION:
                        UpdateOrientation();
                        TryKillPlayerInFront();
                        events.ScheduleEvent(EVENT_MAZE_ORIENTATION, 200);
                        break;
                    case EVENT_MAZE_END:
                        Maze(false);
                        SendMazeToEyes(false);
                        events.ScheduleEvent(EVENT_LIGHT_SPECTRUM_SAY_SUMMON, 40000);
                        break;
                    case EVENT_MIND_DAGGERS:
                        DoCast(SPELL_MIND_DAGGERS);
                        events.ScheduleEvent(EVENT_MIND_DAGGERS, 6000);
                        break;
                    // Disintegration Beam phase end
                    default:
                        break;
                }

                if (!me->HasUnitState(UNIT_STATE_CASTING))
                    DoMeleeAttackIfReady();
            }
示例#15
0
        void UpdateAI(uint32 diff)
        {
            if (me->GetVictim())
                if(!me->HasAura(RAID_MODE(SPELL_FACE_RAGE_10N, SPELL_FACE_RAGE_25N,SPELL_FACE_RAGE_10H, SPELL_FACE_RAGE_25H)) && me->GetVictim()->HasAura(SPELL_FACE_RAGE) && !me->HasAura(CRYSTAL_PRISON_EFFECT))
                {
                    if (Unit* RageTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 500.0f, true, SPELL_RAGE))
                    {
                        me->getThreatManager().resetAllAggro();
                        me->AddThreat(RageTarget, 500.0f);

                        if (me->GetDistance(RageTarget) >= 13.0f)
                            me->JumpTo(RageTarget,15);

                        me->GetMotionMaster()->MoveChase(RageTarget);
                        me->AI()->AttackStart(RageTarget);
                    }
                    me->GetVictim()->RemoveAurasDueToSpell(SPELL_FACE_RAGE);
                }

            if(GetShannox() && !me->IsInCombat())
            {
                if (me->GetDistance(GetShannox()) > 20.0f)
                    me->SetPosition(GetShannox()->GetPositionX()+5,GetShannox()->GetPositionY()-5,GetShannox()->GetPositionZ(),0);
                else
                    me->GetMotionMaster()->MoveFollow(GetShannox(), walkRagefaceDistance, walkRagefaceAngle);
            }

            events.Update(diff);

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                case EVENT_CHANGE_TARGET:
                    if (!me->GetVictim()->HasAura(SPELL_RAGE) && !me->HasAura(RAID_MODE(SPELL_FACE_RAGE_10N, SPELL_FACE_RAGE_25N,SPELL_FACE_RAGE_10H, SPELL_FACE_RAGE_25H)))
                        SelectNewTarget();

                    events.ScheduleEvent(EVENT_CHANGE_TARGET, urand(9000,15000));
                    break;

                case EVENT_FACE_RAGE:
                    if (Unit *FaceRageTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 500, true))
                    {
                        me->getThreatManager().resetAllAggro();
                        me->AddThreat(FaceRageTarget, 500.0f);

                        if (me->GetDistance(FaceRageTarget) >= 13.0f)
                            me->JumpTo(FaceRageTarget,15);

                        me->GetMotionMaster()->MoveChase(FaceRageTarget);
                        me->AI()->AttackStart(FaceRageTarget);
                        DoCast(FaceRageTarget,SPELL_FACE_RAGE);
                    }
                    events.ScheduleEvent(EVENT_FACE_RAGE, 61000);
                    break;

                case EVENT_PRISON_DOG_ATTACK_RAGEFACE:
                    if (Creature* prison = me->FindNearestCreature(NPC_CRYSTAL_PRISON, 50.0f, true))
                    {
                        int32 dmg = prison->GetMaxHealth() * 0.20;
                        me->DealDamage(prison,dmg);
                        if (prison->IsAlive())
                            events.ScheduleEvent(EVENT_PRISON_DOG_ATTACK_RAGEFACE, 1000);
                    }
                    break;

                default:
                    break;
                }
            }

            if (me->HasAura(CRYSTAL_PRISON_EFFECT) && !prisonStartAttack)
                if (me->FindNearestCreature(NPC_CRYSTAL_PRISON, 50.0f, true))
                {
                    events.ScheduleEvent(EVENT_PRISON_DOG_ATTACK_RAGEFACE, 1000);
                    prisonStartAttack = true;
                }

            if(GetShannox())
            {
                if(GetShannox()->GetHealthPct() <= 30 && frenzy == false && !me->GetMap()->IsHeroic())
                {
                    frenzy = true;
                    DoCast(me, SPELL_FRENZIED_DEVOLUTION);
                }

                if(GetShannox()->GetDistance2d(me) >= maxDistanceBetweenShannoxAndDogs && !me->HasAura(SPELL_SEPERATION_ANXIETY)) //TODO Sniff right Distance
                {
                    DoCast(me, SPELL_SEPERATION_ANXIETY);
                }

            }

            if (!UpdateVictim())
                return;

            if(Unit* victim = me->GetVictim()) // DoMeleeAttackIfReady implementation of Feeding Frenzy.
            if (me->isAttackReady() && me->IsWithinMeleeRange(victim))
            {
                me->AttackerStateUpdate(victim);
                me->resetAttackTimer();

                if (me->GetMap()->IsHeroic())
                    me->AddAura(SPELL_FEEDING_FRENZY_H, me);
            }
        }
示例#16
0
            void UpdateAI(uint32 diff)
            {
                if (!bActive)
                    return;

                if (me->HealthBelowPct(50) && !b50)
                {
                    b50 = true;
                    Talk(SAY_50);
                }
                if (me->HealthBelowPct(25) && !b25)
                {
                    b25 = true;
                    Talk(SAY_25);
                }

                events.Update(diff);

                while (uint32 eventId = events.ExecuteEvent())
                {
                    switch (eventId)
                    {
                    case EVENT_INTRO_2:
                        Talk(SAY_INTRO_2);
                        bActive = false;
                        break;
                    case EVENT_INTRO_3_2:
                        Talk(SAY_INTRO_3_2);
                        break;
                    case EVENT_PHASE_2_2:
                        Talk(SAY_PHASE_2_1);
                        break;
                    case EVENT_SUMMON_MINDLASHER:
                        if (Creature* pMindlasher = me->SummonCreature(NPC_VICIOUS_MINDLASHER, spawnPos[urand(0, 1)]))
                        {
                            pMindlasher->AddThreat(me, 1.0f);
                            pMindlasher->AI()->AttackStart(me);
                        }
                        break;
                    case EVENT_SUMMON_BEHEMOTH:
                        if (Creature* pBehemoth = me->SummonCreature(NPC_UNYIELDING_BEHEMOTH, spawnPos[urand(0, 1)]))
                        {
                            pBehemoth->AddThreat(me, 1.0f);
                            pBehemoth->AI()->AttackStart(me);
                        }
                        break;
                    case EVENT_SUMMON_SAPPER:
                        for (uint8 i = 2; i < 5; i++)
                            if (Creature* pSapper = me->SummonCreature(NPC_FACELESS_SAPPER, spawnPos[i]))
                                pSapper->CastSpell(me, SPELL_ENTANGLING_GRASP, false);
                        break;
                    case EVENT_SUMMON_BEAST:
                        if (Creature* pBeast = me->SummonCreature(NPC_BLIGHT_BEAST,
                            me->GetPositionX(),
                            me->GetPositionY(),
                            me->GetPositionZ(),
                            me->GetOrientation()))
                            if (Player* pTarget = GetRandomPlayer())
                                pBeast->AI()->AttackStart(pTarget);
                        events.ScheduleEvent(EVENT_SUMMON_BEAST, urand(15000, 24000));
                        break;
                    case EVENT_SUMMON_MURLOC:
                        for (uint8 i = 0; i < 5; i++)
                        {
                            if (Creature* pMurloc = me->SummonCreature(NPC_DEEP_MURLOC_INVADER, spawnPos[urand(0, 1)]))
                            {
                                pMurloc->AddThreat(me, 1.0f);
                                pMurloc->AI()->AttackStart(me);
                            }
                        }
                        events.ScheduleEvent(EVENT_SUMMON_MURLOC, urand(10000, 17000));
                        break;
                    case EVENT_BLIGHT_OF_OZUMAT:
                        if (Player* pTarget = GetRandomPlayer())
                            DoCast(pTarget, SPELL_BLIGHT_OF_OZUMAT_MISSILE);
                        events.ScheduleEvent(EVENT_BLIGHT_OF_OZUMAT, urand(10000, 18000));
                        break;
                    }
                }
            }         
示例#17
0
        void UpdateAI(uint32 diff)
        {
            if (!me->GetVictim()) { }

            if(GetShannox() && !me->IsInCombat())
            {
                if (me->GetDistance(GetShannox()) > 20.0f)
                    me->SetPosition(GetShannox()->GetPositionX()+5,GetShannox()->GetPositionY()-5,GetShannox()->GetPositionZ(),0);
                else
                    me->GetMotionMaster()->MoveFollow(GetShannox(), walkRiplimbDistance, walkRiplimbAngle);
            }

            events.Update(diff);

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                case EVENT_LIMB_RIP:
                    DoCastVictim(SPELL_LIMB_RIP);
                    
                    if(GetShannox() && !firstLimbRip)
                    {
                        firstLimbRip = true;
                        GetShannox()->AI()->Talk(SAY_GO_FOR_THROAT);
                        events.ScheduleEvent(EVENT_RIPLIMB_RESET_SHANNOX_YELL, 45000); // Resets Yell after 45s
                    }

                    events.ScheduleEvent(EVENT_LIMB_RIP, 12000); //TODO Find out the correct Time
                    break;

                case EVENT_TAKING_SPEAR_DELAY:
                    inTakingSpearPhase = false;
                    if (GetShannox())
                        GetShannox()->AI()->SetData(DATA_PHASE, PHASE_RIPLIMB_GOS_TO_SPEER);
                    break;

                case EVENT_RIPLIMB_RESET_SHANNOX_YELL:
                    firstLimbRip = false;
                    break;

                case EVENT_PRISON_DOG_ATTACK_RIPLIMB:
                    if (Creature* prison = me->FindNearestCreature(NPC_CRYSTAL_PRISON, 50.0f, true))
                    {
                        int32 dmg = prison->GetMaxHealth() * 0.10;
                        me->DealDamage(prison,dmg);
                        if (prison->IsAlive())
                            events.ScheduleEvent(EVENT_PRISON_DOG_ATTACK_RIPLIMB, 1000);
                    }
                    break;

                default:
                    break;
                }
            }

            if (me->HasAura(CRYSTAL_PRISON_EFFECT) && !prisonStartAttack)
                if (me->FindNearestCreature(NPC_CRYSTAL_PRISON, 50.0f, true))
                {
                    events.ScheduleEvent(EVENT_PRISON_DOG_ATTACK_RIPLIMB, 1000);
                    prisonStartAttack = true;
                }

            if(GetShannox())
            {
                if(GetShannox()->GetHealthPct() <= 30 && frenzy == false && !me->GetMap()->IsHeroic())
                {
                    frenzy = true;
                    DoCast(me, SPELL_FRENZIED_DEVOLUTION);
                }

                if(GetShannox()->GetDistance2d(me) >= maxDistanceBetweenShannoxAndDogs && !me->HasAura(SPELL_SEPERATION_ANXIETY)) //TODO Sniff right Distance
                    DoCast(me, SPELL_SEPERATION_ANXIETY);

                if (GetShannox()->AI()->GetData(DATA_PHASE) == PHASE_SPEAR_ON_THE_GROUND && !inTakingSpearPhase)
                {
                    inTakingSpearPhase = true;
                    events.ScheduleEvent(EVENT_TAKING_SPEAR_DELAY, 7500);
                }

                if (GetSpear())
                {
                    if (GetShannox()->AI()->GetData(DATA_PHASE) == PHASE_RIPLIMB_GOS_TO_SPEER && GetSpear()->GetDistance(me) <= 1)
                    {
                        GetShannox()->AI()->SetData(DATA_PHASE, PHASE_RIPLIMB_BRINGS_SPEER);
                        GetSpear()->DespawnOrUnsummon();
                        me->AddAura(SPEAR_VISIBLE_FETCH,me);

                        DoCast(me, SPELL_DOGGED_DETERMINATION);
                    }
                }
            }

            if (!UpdateVictim())
                return;

            if(Unit* victim = me->GetVictim()) // DoMeleeAttackIfReady implementation of Feeding Frenzy.
            if (me->isAttackReady() && me->IsWithinMeleeRange(victim))
            {
                me->AttackerStateUpdate(victim);
                me->resetAttackTimer();

                if (me->GetMap()->IsHeroic())
                    me->AddAura(SPELL_FEEDING_FRENZY_H, me);
            }
        }
        void UpdateAI(uint32 diff)
        {
            if (talkTimer)
            {
                talkTimer += diff;
                if (talkTimer >= 1000 && talkTimer < 10000)
                {
                    Talk(SAY_ANZU_INTRO1);
                    talkTimer = 10000;
                }
                else if (talkTimer >= 16000)
                {
                    me->SetUInt32Value(UNIT_FIELD_FLAGS, 0);
                    me->RemoveAurasDueToSpell(SPELL_SHADOWFORM);
                    Talk(SAY_ANZU_INTRO2);
                    talkTimer = 0;
                }
            }

            if (!UpdateVictim())
                return;

            events.Update(diff);
            if (me->HasUnitState(UNIT_STATE_CASTING|UNIT_STATE_STUNNED))
                return;

            switch (events.GetEvent())
            {
                case EVENT_SPELL_SCREECH:
                    me->CastSpell(me, SPELL_PARALYZING_SCREECH, false);
                    events.RepeatEvent(23000);
                    events.DelayEvents(3000);
                    break;
                case EVENT_SPELL_BOMB:
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f, true))
                        me->CastSpell(target, SPELL_SPELL_BOMB, false);
                    events.RepeatEvent(urand(16000, 24500));
                    events.DelayEvents(3000);
                    break;
                case EVENT_SPELL_CYCLONE:
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 45.0f, true))
                        me->CastSpell(target, SPELL_CYCLONE, false);
                    events.RepeatEvent(urand(22000, 27000));
                    events.DelayEvents(3000);
                    break;
                case EVENT_ANZU_HEALTH1:
                    if (me->HealthBelowPct(66))
                    {
                        SummonBroods();
                        events.PopEvent();
                        events.DelayEvents(10000);
                        return;
                    }
                    events.RepeatEvent(1000);
                    break;
                case EVENT_ANZU_HEALTH2:
                    if (me->HealthBelowPct(33))
                    {
                        SummonBroods();
                        events.PopEvent();
                        events.DelayEvents(10000);
                        return;
                    }
                    events.RepeatEvent(1000);
                    break;
            }

            DoMeleeAttackIfReady();
        }
		void UpdateAI(uint32 diff)
		{
			if (!UpdateVictim())
				return;

			events.Update(diff);

			if( me->HasUnitState(UNIT_STATE_CASTING) )
				return;

			switch( events.GetEvent() )
			{
				case 0:
					break;
				case EVENT_YELL_DEAD_1:
					Talk(YELL_DEAD_1);
					events.PopEvent();
					break;
				case EVENT_START_RESURRECTION:
					me->CastSpell(me, SPELL_SUMMON_VALKYR, true);
					events.PopEvent();
					events.RescheduleEvent(EVENT_VALKYR_BEAM, 7000);
					events.RescheduleEvent(EVENT_VALKYR_MOVE, 1);
					events.RescheduleEvent(EVENT_ANNHYLDE_YELL, 3000);
					break;
				case EVENT_VALKYR_MOVE:
					if( Creature* s = ObjectAccessor::GetCreature(*me, ValkyrGUID) )
						s->GetMotionMaster()->MovePoint(1, s->GetPositionX(), s->GetPositionY(), s->GetPositionZ()-15.0f);
					events.PopEvent();
					break;
				case EVENT_ANNHYLDE_YELL:
					if( Creature* s = ObjectAccessor::GetCreature(*me, ValkyrGUID) )
						s->AI()->Talk(YELL_ANHYLDE_2);
					events.PopEvent();
					break;
				case EVENT_VALKYR_BEAM:
					me->RemoveAura(SPELL_SUMMON_VALKYR);
					if( Creature* c = ObjectAccessor::GetCreature(*me, ValkyrGUID) )
						c->CastSpell(me, SPELL_RESURRECTION_BEAM, false);
					events.PopEvent();
					events.RescheduleEvent(EVENT_RESURRECTION_BALL, 4000);
					break;
				case EVENT_RESURRECTION_BALL:
					me->CastSpell(me, SPELL_RESURRECTION_BALL, true);
					events.PopEvent();
					events.RescheduleEvent(EVENT_RESURRECTION_HEAL, 4000);
					break;
				case EVENT_RESURRECTION_HEAL:
					me->RemoveAura(SPELL_RESURRECTION_BALL);
					me->CastSpell(me, SPELL_RESURRECTION_HEAL, true);
					FeignDeath(false);
					events.PopEvent();
					events.RescheduleEvent(EVENT_MORPH_TO_UNDEAD, 3000);
					break;
				case EVENT_MORPH_TO_UNDEAD:
					me->CastSpell(me, SPELL_INGVAR_TRANSFORM, true);
					events.PopEvent();
					events.RescheduleEvent(EVENT_START_PHASE_2, 1000);
					break;
				case EVENT_START_PHASE_2:
					if( Creature* c = ObjectAccessor::GetCreature(*me, ValkyrGUID) )
					{
						c->DespawnOrUnsummon();
						summons.DespawnAll();
					}
					events.PopEvent();
					me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
					AttackStart(me->GetVictim());
					me->GetMotionMaster()->MoveChase(me->GetVictim());
					Talk(YELL_AGGRO_2);

					// schedule Phase 2 abilities
					events.RescheduleEvent(EVENT_SPELL_ROAR, 15000);
					events.RescheduleEvent(EVENT_SPELL_CLEAVE_OR_WOE_STRIKE, 2000);
					events.RescheduleEvent(EVENT_SPELL_SMASH, 5000);
					events.RescheduleEvent(EVENT_SPELL_ENRAGE_OR_SHADOW_AXE, 10000);

					break;

				// ABILITIES HERE:
				case EVENT_UNROOT:
					me->SetControlled(false, UNIT_STATE_ROOT);
					me->DisableRotate(false);
					events.PopEvent();
					break;
				case EVENT_SPELL_ROAR:
					Talk(EMOTE_ROAR);

					me->_AddCreatureSpellCooldown(SPELL_STAGGERING_ROAR, 0);
					me->_AddCreatureSpellCooldown(SPELL_DREADFUL_ROAR, 0);

					if (me->GetDisplayId() == DISPLAYID_DEFAULT)
						me->CastSpell((Unit*)NULL, SPELL_STAGGERING_ROAR, false);
					else
						me->CastSpell((Unit*)NULL, SPELL_DREADFUL_ROAR, false);
					events.RepeatEvent(urand(15000,20000));
					break;
				case EVENT_SPELL_CLEAVE_OR_WOE_STRIKE:
					if( me->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID) == 0 )
					{
						events.RepeatEvent(3000);
						break;
					}
					if (me->GetDisplayId() == DISPLAYID_DEFAULT)
						me->CastSpell(me->GetVictim(), SPELL_CLEAVE, false);
					else
						me->CastSpell(me->GetVictim(), SPELL_WOE_STRIKE, false);
					events.RepeatEvent(urand(0,4000)+3000);
					break;
				case EVENT_SPELL_SMASH:
					if( me->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID) == 0 )
					{
						events.RepeatEvent(3000);
						break;
					}
					me->SetControlled(true, UNIT_STATE_ROOT);
					me->DisableRotate(true);
					me->SendMovementFlagUpdate();
					if (me->GetDisplayId() == DISPLAYID_DEFAULT)
						me->CastSpell((Unit*)NULL, SPELL_SMASH, false);
					else
						me->CastSpell((Unit*)NULL, SPELL_DARK_SMASH, false);
					events.RepeatEvent(urand(9000,11000));
					events.RescheduleEvent(EVENT_UNROOT, 3750);
					break;
				case EVENT_SPELL_ENRAGE_OR_SHADOW_AXE:
					if (me->GetDisplayId() == DISPLAYID_DEFAULT)
					{
						me->CastSpell(me, SPELL_ENRAGE, false);
						events.RepeatEvent(10000);
					}
					else
					{
						me->CastSpell((Unit*)NULL, SPELL_SHADOW_AXE, true);
						SetEquipmentSlots(false, EQUIP_UNEQUIP, EQUIP_NO_CHANGE, EQUIP_NO_CHANGE);
						events.RepeatEvent(35000);
						events.RescheduleEvent(EVENT_AXE_RETURN, 10000);
					}
					break;
				case EVENT_AXE_RETURN:
					if (Creature* c = ObjectAccessor::GetCreature(*me, ThrowGUID))
						c->GetMotionMaster()->MoveCharge(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()+0.5f);
					events.PopEvent();
					events.RescheduleEvent(EVENT_AXE_PICKUP, 1500);
					break;
				case EVENT_AXE_PICKUP:
					if (Creature* c = ObjectAccessor::GetCreature(*me, ThrowGUID))
					{
						c->DestroyForNearbyPlayers();
						c->DespawnOrUnsummon();
						summons.DespawnAll();
					}
					ThrowGUID = 0;
					SetEquipmentSlots(true);
					events.PopEvent();
					break;
			}

			if (!me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))
				DoMeleeAttackIfReady();
		}
        void UpdateAI(uint32 diff) override
        {
            m_events.Update(diff);

            while (uint32 eventId = m_events.ExecuteEvent())
            {
                switch (eventId)
                {
                    case EVENT_CAST_HEAD_VIDEO:
                    {
                        if (Creature* head = me->SummonCreature(NPC_SEAHORNS_HEAD, -14443.48f, 485.88f, 28.74f, 3.001957f, TEMPSUMMON_TIMED_DESPAWN, 15000))
                            m_headGUID = head->GetGUID();
                        if (Creature* npc = me->FindNearestCreature(NPC_BARON_REVILGAZ, 15.0f))
                        {
                            m_baronGUID = npc->GetGUID();
                            me->SetFacingToObject(npc);
                        }
                        m_events.ScheduleEvent(2, 3000);
                        break;
                    }
                    case 2:
                    {
                        if (Creature* head = sObjectAccessor->GetCreature(*me, m_headGUID))
                        {
                            me->HandleEmoteCommand(EMOTE_ONESHOT_KICK);
                            head->GetMotionMaster()->MoveJump(-14440.13f, 484.35f, 28.80f, 10.0f, 10.0f);
                        }
                        m_events.ScheduleEvent(3, 3000);
                        break;
                    }
                    case 3:
                    {
                        if (Creature* baron = sObjectAccessor->GetCreature(*me, m_baronGUID))
                            if (Creature* head = sObjectAccessor->GetCreature(*me, m_headGUID))
                            {
                                baron->HandleEmoteCommand(EMOTE_ONESHOT_KICK);
                                head->GetMotionMaster()->MoveJump(-14443.48f, 485.88f, 28.74f, 10.0f, 10.0f);
                            }
                        m_events.ScheduleEvent(4, 3000);
                        break;
                    }
                    case 4:
                    {
                        if (Creature* head = sObjectAccessor->GetCreature(*me, m_headGUID))
                        {
                            me->HandleEmoteCommand(EMOTE_ONESHOT_KICK);
                            head->GetMotionMaster()->MoveJump(-14440.13f, 484.35f, 28.80f, 10.0f, 10.0f);
                        }
                        m_events.ScheduleEvent(5, 3000);
                        break;
                    }
                    case 5:
                    {
                        if (Creature* baron = sObjectAccessor->GetCreature(*me, m_baronGUID))
                            if (Creature* head = sObjectAccessor->GetCreature(*me, m_headGUID))
                            {
                                baron->HandleEmoteCommand(EMOTE_ONESHOT_KICK);
                                head->GetMotionMaster()->MoveJump(-14443.48f, 485.88f, 28.74f, 10.0f, 10.0f);
                            }
                        m_events.ScheduleEvent(6, 3000);
                        break;
                    }
                    case 6:
                    {
                        Talk(1);
                        if (Creature* head = sObjectAccessor->GetCreature(*me, m_headGUID))
                            head->DespawnOrUnsummon();
                        if (Player* player = sObjectAccessor->GetPlayer(*me, m_playerGUID))
                        {
                            player->KilledMonsterCredit(2487);
                            player->CompleteQuest(QUEST_LOOKS_LIKE_A_TAUREN_PIRATE_TO_ME);
                        }
                        break;
                    }
                }
            }
        }
示例#21
0
		void UpdateAI(const uint32 diff)
		{
			if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_CASTING))
				return;

			if ((!me->HasAura(SPELL_DECIMATION_BLADE_10) && !me->HasAura(SPELL_DECIMATION_BLADE_25)) && !me->HasAura(SPELL_INFERNO_BLADE)) //set normal 2 blade equip
				SetEquipmentSlots(false, EQUIPMENT_ID_SWORD_1H, EQUIPMENT_ID_SWORD_1H, 0);

			events.Update(diff);

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

				case EVENT_BERSERK:
					DoCast(me, SPELL_BERSERK);
					break;

				case EVENT_BLAZE_OF_GLORY:
					DoCast(me->GetVictim(), SPELL_BLAZE_OF_GLORY);
					DoCast(me, SPELL_INCENDIARY_SOUL);

					events.ScheduleEvent(EVENT_BLAZE_OF_GLORY, 20000);
					break;

				case EVENT_SHARDS_OF_TORMENT:
					Talk(SAY_CRY_ANN);
					DoCast(me, SPELL_SHARDS_OF_TORMENT);

					events.ScheduleEvent(EVENT_SUMMON_SHARDS, 1000);
					break;

				case EVENT_DECIMATION_BLADE:
					Talk(SAY_DECIMATION);
					Talk(SAY_DECI_ANN);
					DoCast(me, (Is25ManRaid() ? SPELL_DECIMATION_BLADE_25 : SPELL_DECIMATION_BLADE_10));
					SetEquipmentSlots(false, EQUIPMENT_ID_SWORD_2H, 0, 0); //set one blade equip

					events.ScheduleEvent(EVENT_INFERNO_BLADE, 30000);
					break;

				case EVENT_INFERNO_BLADE:
					Talk(SAY_INFERNO);
					Talk(SAY_INFE_ANN);
					DoCast(me, SPELL_INFERNO_BLADE);
					SetEquipmentSlots(false, EQUIPMENT_ID_SWORD_2H, 0, 0); //set one blade equip

					events.ScheduleEvent(EVENT_DECIMATION_BLADE, 30000);
					break;

				case EVENT_COUNTDOWN:
					Talk(SAY_COUNTDOWN);
					CastCountDown();

					events.ScheduleEvent(EVENT_COUNTDOWN, 40000);
					break;

				case EVENT_SUMMON_SHARDS:
					std::list<Unit*> players;
					SelectTargetList(players, Is25ManRaid() ? 2 : 1, SELECT_TARGET_RANDOM, 500.0f, true);
					if (!players.empty())
						for (std::list<Unit*>::iterator itr = players.begin(); itr != players.end(); ++itr)
							DoCast(*itr, SPELL_SHARDS_OF_TORMENT_SUMMON);

					events.ScheduleEvent(EVENT_SHARDS_OF_TORMENT, 35000);
					break;
				}
			}

			DoMeleeAttackIfReady();
		}
示例#22
0
		void UpdateAI(const uint32 diff)
		{
			if(head != NULL && !IsInHeadPhase)
			{
				head->SetReactState(REACT_PASSIVE);
				head->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_DISABLE_MOVE | UNIT_FLAG_NOT_SELECTABLE);
			}else if(head == NULL)
			{
				head =  me->FindNearestCreature(NPC_MAGMAWS_HEAD,1000.0f, true);
			}

			if (!UpdateVictim())
				return;

			events.Update(diff);

			while (uint32 eventId = events.ExecuteEvent())
			{
				switch(eventId)
				{
					if(!IsInHeadPhase)
					{
				case EVENT_MAGMA_SPIT:
					// Maybe we have to cast the spell on all Players
					if(Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 200, true))
						DoCast(pTarget,SPELL_MAGMA_SPIT);
					
					events.ScheduleEvent(EVENT_MAGMA_SPIT, urand(15000,17000));
					break;

				case EVENT_LAVA_SPEW: 
					DoCastAOE(SPELL_LAVA_SPEW);

					events.ScheduleEvent(EVENT_LAVA_SPEW, urand(7000,9000));
					break;

				case EVENT_IN_RANGE_CHECK:
					DoCast(me, SPELL_MOLTEN_TANTRUM);

					events.ScheduleEvent(EVENT_IN_RANGE_CHECK, 5000);
					break;

				case EVENT_MANGLE:
					DoCastVictim(SPELL_MANGLE);

					if(head != NULL)
					{
						//me->getVictim()->EnterVehicle(head);
						head->CastSpell(head,SPELL_POINT_OF_VULNERABILITY, true);
						head->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
					}
					
					IsInHeadPhase = true;

					events.ScheduleEvent(EVENT_LEAVE_HEAD_PHASE, 10000);
					events.ScheduleEvent(EVENT_LAVA_SPEW, urand(95000,115000));
					DoCastVictim(SPELL_RIDE_VEHICLE, true);
					DoCastVictim(88287);
					break;

				case EVENT_PILLAR_OF_FLAME:
					if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 500, true))
						me->SummonCreature(NPC_PILLAR_OF_FLAME_TRIGGER,target->GetPositionX(),target->GetPositionY(),target->GetPositionZ(), 0,TEMPSUMMON_CORPSE_DESPAWN);		

					events.ScheduleEvent(EVENT_PILLAR_OF_FLAME, urand(20000,25000));
					break;

				case EVENT_BERSERK:
					DoCast(me, SPELL_BERSERK);
					break;

					}else
					{
				case EVENT_LEAVE_HEAD_PHASE:


					
					DoCastAOE(SPELL_MASSIVE_CRASH);
					CastIgnition();
					IsInHeadPhase = false;
					break;
					}
				}
			}

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

			if(ShouldSummonAdds)
			{
				// Despawns the Stalker
				DespawnCreatures(NPC_SHADOW_GALE_STALKER);
				RemoveShadowGaleDebuffFromPlayers();

				me->SetReactState(REACT_AGGRESSIVE);
				me->GetMotionMaster()->Clear();
				me->GetMotionMaster()->MoveChase(me->getVictim());

				if ((rand()%2))
					me->MonsterYell(SAY_SUMMON, LANG_UNIVERSAL, NULL);

				//Adds a visual portal effect to the Stalker
				FacelessPortalStalker->GetAI()->DoCast(FacelessPortalStalker,SPELL_TWILIGHT_PORTAL_VISUAL,true);
				events.ScheduleEvent(EVENT_REMOVE_TWILIGHT_PORTAL, 7000);

				//Summons Faceless over the Spell
				FacelessPortalStalker->GetAI()->DoCast(FacelessPortalStalker,SPELL_SPAWN_FACELESS,true);

				ShouldSummonAdds = false;

				// DBM says that the Spell has 40s CD
				events.ScheduleEvent(EVENT_SHADOW_GALE, urand(40000,44000));
			}

			events.Update(diff);

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

				case EVENT_ENFEEBLING_BLOW:
					DoCastVictim(SPELL_ENFEEBLING_BLOW);
					events.ScheduleEvent(EVENT_ENFEEBLING_BLOW, urand(19000,24000));
					break;

				case EVENT_SHADOW_GALE:
					ShadowGaleTrigger = me->SummonCreature(NPC_SHADOW_GALE_STALKER,-739.665f/*+(urand(0,20)-10)*/,-827.024f/*+(urand(0,20)-10)*/,232.412f,3.1f,TEMPSUMMON_CORPSE_DESPAWN);
					me->SetReactState(REACT_PASSIVE);
					me->GetMotionMaster()->MovePoint(POINT_ERUDAX_IS_AT_STALKER,ShadowGaleTrigger->GetPositionX(),ShadowGaleTrigger->GetPositionY(),ShadowGaleTrigger->GetPositionZ());
                    DoScriptText(SAY_GALE, me);
					break;

				case EVENT_REMOVE_TWILIGHT_PORTAL:
					//Removes Portal effect from Stalker
					FacelessPortalStalker->RemoveAllAuras();
					break;

				case EVENT_BINDING_SHADOWS:

					if (Unit* tempTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 500.0f, true))
						DoCast(tempTarget,SPELL_BINDING_SHADOWS);

					events.ScheduleEvent(EVENT_BINDING_SHADOWS, urand(12000,17000));
					break;

				default:
					break;
				}
			}

			DoMeleeAttackIfReady();
		}
        void UpdateAI(uint32 diff)
        {
            if (startPath)
            {
                me->StopMoving();
                startPath = false;
                if (WaypointPath const* i_path = sWaypointMgr->GetPath(me->GetWaypointPath()))
                {
                    Movement::PointsArray pathPoints;
                    pathPoints.push_back(G3D::Vector3(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()));
                    for (uint8 i = 0; i < i_path->size(); ++i)
                    {
                        WaypointData const* node = i_path->at(i);
                        pathPoints.push_back(G3D::Vector3(node->x, node->y, node->z));
                    }
                    me->GetMotionMaster()->MoveSplinePath(&pathPoints);
                }
            }

            if (!UpdateVictim())
                return;

            events.Update(diff);

            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;

            switch (events.GetEvent())
            {
                case 0:
                    break;
                case EVENT_ENRAGE:
                    me->CastSpell(me, SPELL_BERSERK, true);
                    events.RepeatEvent(600000);
                    break;
                case EVENT_COMMANDER_SAY_AGGRO:
                    if (Creature* commander = ObjectAccessor::GetCreature(*me, CommanderGUID))
                        commander->AI()->Talk(SAY_COMMANDER_AGGRO);
                    events.PopEvent();
                    break;
                case EVENT_EE_SAY_MOVE_OUT:
                    for (uint8 i=0; i<3; ++i)
                        if (Creature* c = ObjectAccessor::GetCreature(*me, ExpeditionEngineerGUIDs[i]))
                        {
                            if (!i)
                                c->MonsterYell(TEXT_EE_MOVE_OUT, LANG_UNIVERSAL, 0);
                            c->AI()->SetData(1, 0); // start repairing
                        }
                    events.PopEvent();
                    break;
                case EVENT_SPELL_FIREBALL:
                    if( Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 200.0f, true) )
                        me->CastSpell(pTarget, SPELL_FIREBALL, false);
                    events.RepeatEvent(4000);
                    break;
                case EVENT_SPELL_DEVOURING_FLAME:
                    if( Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 200.0f, true) )
                        me->CastSpell(pTarget, SPELL_DEVOURINGFLAME, false);
                    events.RepeatEvent(13000);
                    break;
                case EVENT_SUMMON_MOLE_MACHINES:
                    {
                        memset(cords, '\0', sizeof(cords));
                        uint8 num = RAID_MODE( urand(2,3), urand(2,4) );
                        for( int i=0; i<num; ++i )
                        {
                            // X: (550, 625) Y: (-185, -230)
                            cords[i][0] = urand(550, 625);
                            cords[i][1] = -230 + rand()%45;
                            if( GameObject* drill = me->SummonGameObject(GO_DRILL, cords[i][0], cords[i][1], 391.1f, M_PI/4, 0.0f, 0.0f, 0.0f, 0.0f, 8) )
                            {
                                //drill->SetGoAnimProgress(0);
                                //drill->SetLootState(GO_READY);
                                //drill->UseDoorOrButton(8);
                                //drill->SetGoState(GO_STATE_READY);
                                drill->SetGoState(GO_STATE_ACTIVE);
                                drill->SetGoAnimProgress(0);
                            }
                        }
                        events.RepeatEvent(45000);
                        events.RescheduleEvent(EVENT_SUMMON_ADDS, 4000);
                    }
                    break;
                case EVENT_SUMMON_ADDS:
                    for( int i=0; i<4; ++i )
                    {
                        if( !cords[i][0] )
                            break;

                        uint8 opt;
                        uint8 r = urand(1,100);
                        if( r <= 30 ) opt = 1;
                        else if( r <= 65 ) opt = 2;
                        else opt = 3;

                        for( int j=0; j<4; ++j )
                        {
                            float x = cords[i][0] + 4.0f*cos(j*M_PI/2);
                            float y = cords[i][1] + 4.0f*sin(j*M_PI/2);

                            uint32 npc_entry = 0;
                            switch( opt )
                            {
                                case 1: if( j == 1 ) npc_entry = NPC_DARK_RUNE_SENTINEL; break;
                                case 2:
                                    switch( j )
                                    {
                                        case 1: npc_entry = NPC_DARK_RUNE_WATCHER; break;
                                        case 2: npc_entry = NPC_DARK_RUNE_GUARDIAN; break;
                                    }
                                    break;
                                default: // case 3:
                                    switch( j )
                                    {
                                        case 1: npc_entry = NPC_DARK_RUNE_WATCHER; break;
                                        case 2: npc_entry = NPC_DARK_RUNE_GUARDIAN; break;
                                        case 3: npc_entry = NPC_DARK_RUNE_GUARDIAN; break;
                                    }
                                    break;
                            }

                            if( npc_entry )
                                if (Creature* c = me->SummonCreature(npc_entry, x, y, 391.1f, j*M_PI/2, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5000))
                                    DoZoneInCombat(c);

                        }
                    }
                    events.PopEvent();
                    break;
                case EVENT_WARN_DEEP_BREATH:
                    me->MonsterTextEmote(TEXT_DEEP_BREATH, 0, true);
                    me->RemoveAura(62794);
                    events.PopEvent();
                    events.ScheduleEvent(EVENT_PHASE2_FLAME_BREATH, 2500);
                    break;
                case EVENT_PHASE2_FLAME_BREATH:
                    me->CastSpell(me, S_FLAMEBREATH, true);
                    events.PopEvent();
                    events.ScheduleEvent(EVENT_FLY_UP, 2000);
                    break;
                case EVENT_FLY_UP:
                    me->SetInCombatWithZone(); // just in case
                    if (pInstance)
                        for( int i=0; i<4; ++i )
                            if( uint64 guid = pInstance->GetData64(DATA_HARPOON_FIRE_STATE_1 + i) )
                                if( Creature* hfs = ObjectAccessor::GetCreature(*me, guid) )
                                {
                                    me->SummonCreature(34188, hfs->GetPositionX(), hfs->GetPositionY(), hfs->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 22000);
                                    hfs->AI()->SetData(1, 0);
                                }

                    me->RemoveAura(SPELL_LAUNCH_CHAIN);
                    me->RemoveAura(SPELL_CHAIN_1);
                    me->RemoveAura(SPELL_CHAIN_3);
                    if (RAID_MODE(0,1))
                    {
                        me->RemoveAura(SPELL_CHAIN_2);
                        me->RemoveAura(SPELL_CHAIN_4);
                    }
                    me->CastSpell(me, SPELL_WINGBUFFET, true);
                    
                    if( (me->GetHealth()*100) / me->GetMaxHealth() < 50 ) // start phase 3
                    {
                        me->SetControlled(false, UNIT_STATE_ROOT);
                        me->DisableRotate(false);
                        DoResetThreat();
                        Unit* target = SelectTarget(SELECT_TARGET_NEAREST, 0, 0.0, true);
                        if (!target)
                            target = me->SelectNearestPlayer(200.0f);
                        if (target)
                        {
                            AttackStart(target);
                            me->GetMotionMaster()->MoveChase(target);
                        }
                        bGroundPhase = true;
                        events.PopEvent();
                        events.CancelEvent(EVENT_SPELL_FIREBALL);
                        events.CancelEvent(EVENT_SPELL_DEVOURING_FLAME);
                        events.CancelEvent(EVENT_SUMMON_MOLE_MACHINES);

                        events.ScheduleEvent(EVENT_SPELL_FLAME_BREATH, 20000);
                        events.ScheduleEvent(EVENT_SPELL_DEVOURING_FLAME_GROUND, 5000);
                        events.ScheduleEvent(EVENT_SPELL_FUSE_ARMOR, 10000);
                        events.ScheduleEvent(EVENT_SPELL_FLAME_BUFFET, 3000);

                        break;
                    }
                    else
                    {
                        ++flyTimes;
                        me->SetControlled(false, UNIT_STATE_ROOT);
                        me->DisableRotate(false);
                        me->SendMeleeAttackStop(me->GetVictim());
                        me->GetMotionMaster()->MoveIdle();
                        me->StopMoving();
                        me->SetCanFly(true);
                        me->SetDisableGravity(true);
                        me->SetHover(true);
                        me->SendMovementFlagUpdate();
                        me->GetMotionMaster()->MoveTakeoff(1, CORDS_AIR, 25.0f);
                        events.ScheduleEvent(EVENT_RESUME_FIXING, 22000);
                    }

                    events.PopEvent();
                    break;
                case EVENT_RESUME_FIXING:
                    for (uint8 i=0; i<3; ++i)
                        if (Creature* c = ObjectAccessor::GetCreature(*me, ExpeditionEngineerGUIDs[i]))
                        {
                            if (!i)
                                c->MonsterYell(TEXT_EE_FIRES_OUT, LANG_UNIVERSAL, 0);
                            c->AI()->SetData(1, 0); // start repairing
                        }
                    events.PopEvent();
                    break;
                case EVENT_SPELL_FLAME_BREATH:
                    me->CastSpell(me->GetVictim(), S_FLAMEBREATH, false);
                    events.RepeatEvent(20000);
                    break;
                case EVENT_SPELL_DEVOURING_FLAME_GROUND:
                    me->CastSpell(me->GetVictim(), SPELL_DEVOURINGFLAME, false);
                    events.RepeatEvent(13000);
                    break;
                case EVENT_SPELL_FUSE_ARMOR:
                    if (Unit* victim = me->GetVictim())
                        if (me->IsWithinMeleeRange(victim))
                        {
                            me->CastSpell(victim, SPELL_FUSEARMOR, false);
                            if (Aura* aur = victim->GetAura(SPELL_FUSEARMOR))
                                if (aur->GetStackAmount() == 5)
                                    victim->CastSpell(victim, 64774, true);
                            events.RepeatEvent(10000);
                            break;
                        }
                    events.RepeatEvent(2000);
                    break;
                case EVENT_SPELL_FLAME_BUFFET:
                    me->CastSpell(me->GetVictim(), S_FLAMEBUFFET, false);
                    events.RepeatEvent(7000);
                    break;
            }

            if (bGroundPhase)
                DoMeleeAttackIfReady();
        }
示例#25
0
			void UpdateAI(uint32 diff)
			{
				events2.Update(diff);
				switch (events2.ExecuteEvent())
				{
					case EVENT_AKAMA_START_ENCOUNTER:
						me->RemoveAura(SPELL_STEALTH);
						me->SetWalk(true);
						me->GetMotionMaster()->MovePoint(POINT_START, 517.4877f, 400.7993f, 112.7837f, false);
						events2.ScheduleEvent(EVENT_AKAMA_START_CHANNEL, 11000);
						break;
					case EVENT_AKAMA_START_CHANNEL:
						me->CastSpell(me, SPELL_AKAMA_SOUL_CHANNEL, false);
						if (Creature* shade = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_SHADE_OF_AKAMA)))
						{
							shade->AI()->AttackStart(me);
							shade->GetMotionMaster()->Clear();
							shade->AI()->DoAction(ACTION_START_ENCOUNTER);
						}
						break;
					case EVENT_AKAMA_SCENE0:
						me->SetWalk(true);
						me->GetMotionMaster()->MovePoint(POINT_CHANNEL_SOUL, 467.0f, 400.7993f, 118.537f);
						break;
					case EVENT_AKAMA_SCENE1:
						me->CastSpell(me, SPELL_AKAMA_SOUL_RETRIEVE, true);
						break;
					case EVENT_AKAMA_SCENE2:
						Talk(SAY_BROKEN_FREE_0);
						break;
					case EVENT_AKAMA_SCENE3:
						me->SummonCreatureGroup(SUMMON_GROUP_BROKENS);
						break;
					case EVENT_AKAMA_SCENE4:
						Talk(SAY_BROKEN_FREE_1);
						break;
					case EVENT_AKAMA_SCENE5:
						for (SummonList::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
							if (Creature* broken = ObjectAccessor::GetCreature(*me, *itr))
								broken->SetStandState(UNIT_STAND_STATE_KNEEL);
						Talk(SAY_BROKEN_FREE_2);
						break;
					case EVENT_AKAMA_SCENE6:
						if (Creature* broken = summons.GetCreatureWithEntry(NPC_ASHTONGUE_BROKEN))
							broken->AI()->Talk(SAY_BROKEN_S1);
						break;
					case EVENT_AKAMA_SCENE7:
						for (SummonList::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
							if (Creature* broken = ObjectAccessor::GetCreature(*me, *itr))
								broken->AI()->Talk(SAY_BROKEN_S2);
						break;
				}

				if (!UpdateVictim())
					return;

				events.Update(diff);
				if (me->HasUnitState(UNIT_STATE_CASTING))
					return;

				switch (events.ExecuteEvent())
				{
					case EVENT_SPELL_CHAIN_LIGHTNING:
						me->CastSpell(me->GetVictim(), SPELL_CHAIN_LIGHTNING, false);
						events.ScheduleEvent(EVENT_SPELL_CHAIN_LIGHTNING, urand(10000, 15000));
						break;
					case EVENT_SPELL_DESTRUCTIVE_POISON:
						me->CastSpell(me, SPELL_DESTRUCTIVE_POISON, false);
						events.ScheduleEvent(EVENT_SPELL_DESTRUCTIVE_POISON, urand(4000, 5000));
						break;
				}

				DoMeleeAttackIfReady();
			}
示例#26
0
        void UpdateAI(uint32 diff)
        {

            events.Update(diff);

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                case EVENT_CRYSTAL_TRAP_TRIGGER:

                    //Riplimb has a higher Priority than Players...

                    if(GetRiplimb() && GetRiplimb()->GetDistance(me) <= 2.0f && (!GetRiplimb()->HasAura(RAID_MODE(SPELL_WARY_10N, SPELL_WARY_25N, SPELL_WARY_10H, SPELL_WARY_25H))) && GetRiplimb()->IsAlive() && GetShannox()->AI()->GetData(DATA_PHASE) == PHASE_SHANNOX_HAS_SPEER)
                        tempTarget = GetRiplimb();
                    else if(GetRageface() && GetRageface()->GetDistance(me) <= 3.0f && !GetRageface()->HasAura(RAID_MODE(SPELL_WARY_10N, SPELL_WARY_25N, SPELL_WARY_10H, SPELL_WARY_25H)) && GetRageface()->IsAlive())
                        tempTarget = GetRageface();
                    else
                        tempTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 2.0f, true);

                    if (!tempTarget || tempTarget->HasAura(CRYSTAL_PRISON_EFFECT)) // If no Target exists try to get a new Target in 0,5s
                        events.ScheduleEvent(EVENT_CRYSTAL_TRAP_TRIGGER, 500);
                    else
                    { 
                        // Intialize Prison if tempTarget was set
                        DoCast(tempTarget,CRYSTAL_PRISON_EFFECT);
                        myPrison = me->SummonCreature(NPC_CRYSTAL_PRISON,tempTarget->GetPositionX(), tempTarget->GetPositionY(), tempTarget->GetPositionZ(),0, TEMPSUMMON_MANUAL_DESPAWN);

                        if (myPrison)
                        {
                            me->SetReactState(REACT_AGGRESSIVE);
                            myPrison->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
                        }

                        events.ScheduleEvent(EVENT_CRYSTAL_PRISON_DESPAWN, 20000);
                    }

                    break;

                case EVENT_CRYSTAL_PRISON_DESPAWN:

                    if (tempTarget)
                    {
                        myPrison->DisappearAndDie();
                        tempTarget->RemoveAurasDueToSpell(CRYSTAL_PRISON_EFFECT);
                        // Cast Spell Wary on Dogs
                        if(tempTarget->GetEntry() == NPC_RIPLIMB || tempTarget->GetEntry() == NPC_RAGEFACE)
                            tempTarget->AddAura(RAID_MODE(SPELL_WARY_10N, SPELL_WARY_25N, SPELL_WARY_10H, SPELL_WARY_25H),tempTarget);

                        me->DisappearAndDie();
                    }
                    break;
                default:
                    break;
                }
            }    

            if(myPrison && myPrison->IsDead())
            {
                myPrison->DisappearAndDie();
                tempTarget->RemoveAurasDueToSpell(CRYSTAL_PRISON_EFFECT);
                // Cast Spell Wary on Dogs
                if(tempTarget->GetEntry() == NPC_RIPLIMB || tempTarget->GetEntry() == NPC_RAGEFACE)
                    tempTarget->AddAura(RAID_MODE(SPELL_WARY_10N, SPELL_WARY_25N, SPELL_WARY_10H, SPELL_WARY_25H),tempTarget);

                me->DisappearAndDie();
            }    
        }
示例#27
0
        void UpdateAI(uint32 diff)
        {
            if (!isActive)
            {
                IntroTimer += diff;
                if (IntroTimer > 5000 && IntroTimer < 10000)
                {
                    if (SelectTargetFromPlayerList(60))
                    {
                        Talk(SAY_INTRO_1);
                        IntroTimer = 10000;
                    }
                    else
                        IntroTimer = 0;
                }

                if (IntroTimer >= 30000 && IntroTimer < 40000)
                {
                    Talk(SAY_INTRO_2);
                    IntroTimer = 40000;
                }
                if (IntroTimer >= 60000)
                {
                    isActive = true;
                    if (m_pInstance)
                        m_pInstance->SetData(TYPE_LOKEN_INTRO, 1);

                    me->SetControlled(false, UNIT_STATE_STUNNED);
                    me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);

                    if (Player* target = SelectTargetFromPlayerList(80))
                        AttackStart(target);
                }

                return;
            }

            //Return since we have no target
            if (!UpdateVictim())
                return;

            events.Update(diff);

            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;

            switch (events.GetEvent())
            {
                case EVENT_CHECK_HEALTH:
                    if (HealthBelowPct(HealthCheck))
                    {
                        LokenSpeach(true);
                        HealthCheck -= 25;
                    }

                    events.RepeatEvent(1000);
                    break;
                case EVENT_LIGHTNING_NOVA:
                    events.RepeatEvent(15000);
                    me->CastSpell(me, SPELL_LIGHTNING_NOVA_VISUAL, true);
                    me->CastSpell(me, SPELL_LIGHTNING_NOVA_THUNDERS, true);

                    events.DelayEvents(5001);
                    events.ScheduleEvent(EVENT_AURA_REMOVE, me->GetMap()->IsHeroic() ? 4000 : 5000);

                    me->CastSpell(me, me->GetMap()->IsHeroic() ? SPELL_LIGHTNING_NOVA_H : SPELL_LIGHTNING_NOVA_N, false);
                    break;
                case EVENT_SHOCKWAVE:
                    me->CastSpell(me, me->GetMap()->IsHeroic() ? SPELL_PULSING_SHOCKWAVE_H : SPELL_PULSING_SHOCKWAVE_N, false);
                    events.PopEvent();
                    break;
                case EVENT_ARC_LIGHTNING:
                    if (Unit* target = SelectTargetFromPlayerList(100, SPELL_ARC_LIGHTNING))
                        me->CastSpell(target, SPELL_ARC_LIGHTNING, false);

                    events.RepeatEvent(12000);
                    break;
                case EVENT_AURA_REMOVE:
                    me->RemoveAura(SPELL_LIGHTNING_NOVA_THUNDERS);
                    events.PopEvent();
                    break;
            }

            DoMeleeAttackIfReady();
        }
示例#28
0
        void UpdateAI(uint32 diff)
        {
            if (!me->GetVictim()) { }

            if( (!introSpeechDone) && (!me->IsInCombat()) )
            {
                introSpeechDone = true;
                Talk(SAY_INTRO_SPECH_PART_ONE);
                events.ScheduleEvent(EVENT_SHANNOX_SEC_INTRO_YELL, 6500);
                events.ScheduleEvent(EVENT_SHANNOX_RESET_INTRO_YELL, 180000); // 1:15 Min
            }

            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;

            events.Update(diff);

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                case EVENT_SUMMON_IMMOLATION_TRAP:
                    if (Unit* tempTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 500, true))
                        DoCast(tempTarget,SPELL_SUMMON_IMOLATION_TRAP);
                    events.ScheduleEvent(EVENT_SUMMON_IMMOLATION_TRAP, 10000);
                    break;

                case EVENT_BERSERK:
                    DoCast(me, SPELL_BERSERK);
                    break;

                case EVENT_SHANNOX_RESET_INTRO_YELL:
                    introSpeechDone = false;
                    break;

                case EVENT_SHANNOX_SEC_INTRO_YELL:
                    Talk(SAY_INTRO_SPECH_PART_TWO);
                    break;

                case EVENT_ARCING_SLASH:
                    if (uiPhase == PHASE_SHANNOX_HAS_SPEER)
                    {
                        DoCastVictim(RAID_MODE(SPELL_ARCTIC_SLASH_10N, SPELL_ARCTIC_SLASH_25N,SPELL_ARCTIC_SLASH_10H, SPELL_ARCTIC_SLASH_25H));
                        events.ScheduleEvent(EVENT_ARCING_SLASH, 12000);
                    }
                    else
                        events.ScheduleEvent(EVENT_ARCING_SLASH, 500);
                    break;

                case EVENT_HURL_SPEAR:
                    if (Creature* fakeSpear = me->FindNearestCreature(NPC_FAKE_SHANNOX_SPEAR, 5000.0f, true))
                    {
                        DoCast(fakeSpear,SPELL_HURL_SPEAR);
                        events.ScheduleEvent(EVENT_HURL_SPEAR_2, 1000);
                    }
                    break;

                case EVENT_HURL_SPEAR_2:
                    if (Creature* fakeSpear = me->FindNearestCreature(NPC_FAKE_SHANNOX_SPEAR, 5000.0f, true))
                    {
                        // Shifts the Event back if Shannox has not the Spear yet
                        me->LoadEquipment(0, true);

                        me->SummonCreature(NPC_SHANNOX_SPEAR,fakeSpear->GetPositionX(),fakeSpear->GetPositionY(),fakeSpear->GetPositionZ());

                        DespawnCreatures(NPC_FAKE_SHANNOX_SPEAR, 5000.0f);
                    }
                    break;

                case EVENT_DESPAWN_SPEAR:
                    me->LoadEquipment();
                    DespawnCreatures(NPC_SHANNOX_SPEAR, 5000.0f);
                    break;

                case EVENT_SUMMON_SPEAR:
                    if (GetSpear())
                        DoCast(GetSpear(),SPELL_CALL_SPEAR);

                    events.ScheduleEvent(EVENT_DESPAWN_SPEAR, 700);
                    break;

                case EVENT_HURL_SPEAR_OR_MAGMA_RUPTURE:
                    if(GetRiplimb() && GetRiplimb()->IsDead())
                    { 
                        // Cast Magma Rupture when Ripclimb is Death
                        DoCastVictim(SPELL_MAGMA_RUPTURE_SHANNOX);
                        me->LoadEquipment(0, true);
                        me->SummonCreature(NPC_SHANNOX_SPEAR,me->GetPositionX()-(std::cos(float(me->GetOrientation()))+6),me->GetPositionY()-(std::sin(float(me->GetOrientation()))+6),me->GetPositionZ());
                        events.ScheduleEvent(EVENT_SUMMON_SPEAR, 4000);
                        events.ScheduleEvent(EVENT_HURL_SPEAR_OR_MAGMA_RUPTURE, 42000);
                    }
                    else
                    {
                        // Throw Spear if Riplimb is Alive and Shannox has the Spear
                        if (uiPhase == PHASE_SHANNOX_HAS_SPEER && GetRiplimb())
                        {
                            events.ScheduleEvent(EVENT_HURL_SPEAR_OR_MAGMA_RUPTURE, 42000);

                            me->SummonCreature(NPC_FAKE_SHANNOX_SPEAR,GetRiplimb()->GetPositionX()+irand(-30,30),GetRiplimb()->GetPositionY()+irand(-30,30),GetRiplimb()->GetPositionZ());

                            if (me->FindNearestCreature(NPC_FAKE_SHANNOX_SPEAR, 5000.0f, true))
                                events.ScheduleEvent(EVENT_HURL_SPEAR, 2000);

                            uiPhase = PHASE_SPEAR_ON_THE_GROUND;
                            //DoCast(SPELL_HURL_SPEAR_DUMMY_SCRIPT);

                            Talk(SAY_BURN);
                        }
                        else
                            events.ScheduleEvent(EVENT_HURL_SPEAR_OR_MAGMA_RUPTURE, 10000);
                    }
                    break;

                case EVENT_SUMMON_CRYSTAL_PRISON:
                    if (Unit* tempTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 500, true))
                        DoCast(tempTarget,SPELL_SUMMON_CRYSTAL_PRISON);
                    events.ScheduleEvent(EVENT_SUMMON_CRYSTAL_PRISON, 25000);
                    break;

                case EVENT_RIPLIMB_RESPAWN_H:
                    if (GetRiplimb())
                    {
                        Talk(SAY_FETCH_SUPPER);
                        GetRiplimb()->Respawn();
                        DoZoneInCombat(GetRiplimb());
                    }
                    break;

                default:
                    break;
                }
            }

            if (!UpdateVictim())
                return;

            if(((GetRiplimb() && GetRiplimb()->GetDistance2d(me) >= maxDistanceBetweenShannoxAndDogs && GetRiplimb()->IsAlive()) || (GetRageface() && GetRageface()->GetDistance2d(me) >= maxDistanceBetweenShannoxAndDogs && GetRageface()->IsAlive())) && (!me->HasAura(SPELL_SEPERATION_ANXIETY)))
                DoCast(me, SPELL_SEPERATION_ANXIETY);

            if (uiPhase == PHASE_RIPLIMB_BRINGS_SPEER && GetRiplimb() && GetRiplimb()->GetDistance(me) <= 1)
            {
                uiPhase = PHASE_SHANNOX_HAS_SPEER;
                me->LoadEquipment();

                DespawnCreatures(NPC_SHANNOX_SPEAR, 5000.0f);

                if (GetRiplimb()->HasAura(SPELL_DOGGED_DETERMINATION))
                    GetRiplimb()->RemoveAura(SPELL_DOGGED_DETERMINATION);

                if (GetRiplimb()->HasAura(SPEAR_VISIBLE_FETCH))
                    GetRiplimb()->RemoveAura(SPEAR_VISIBLE_FETCH);

                GetRiplimb()->setActive(true);
                GetRiplimb()->GetMotionMaster()->MoveChase(GetRiplimb()->GetVictim());
                GetRiplimb()->AI()->AttackStart(GetRiplimb()->GetVictim());
            }
            else if (uiPhase == PHASE_RIPLIMB_GOS_TO_SPEER && GetRiplimb() && GetRiplimb()->IsAlive())
            {
                if (GetSpear() && !GetRiplimb()->HasAura(CRYSTAL_PRISON_EFFECT))
                {
                    GetRiplimb()->GetMotionMaster()->MoveIdle();
                    GetRiplimb()->GetMotionMaster()->MovePoint(0,GetSpear()->GetPositionX(),GetSpear()->GetPositionY(),GetSpear()->GetPositionZ());
                }
            }
            else if (uiPhase == PHASE_RIPLIMB_BRINGS_SPEER && GetRiplimb() && GetRiplimb()->IsAlive())
            {
                GetRiplimb()->GetMotionMaster()->MoveIdle();
                GetRiplimb()->GetMotionMaster()->MovePoint(0,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ());
            }


            DoMeleeAttackIfReady();
        }
示例#29
0
        void UpdateAI(const uint32 diff)
        {
            if (!pInstance || !UpdateVictim())
                return;

            if (IsHeroic() && me->HealthBelowPct(30) && !bShadowBreath)
            {
                bShadowBreath = true;
                if (Creature* pNefarius = me->FindNearestCreature(NPC_LORD_VICTOR_NEFARIUS_HEROIC, 200.0f))
                    pNefarius->AI()->DoAction(ACTION_SHADOW_BREATH);
            }

            events.Update(diff);

            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                /*case EVENT_HEAD_START:
                    SetGrounded(true, 0);
                    if (Creature* pMagmawhead = ObjectAccessor::GetCreature(*me, pInstance->GetData64(DATA_MAGMAW_HEAD)))
                        pMagmawhead->AI()->DoAction(ACTION_HEAD_START);
                    events.ScheduleEvent(EVENT_HEAD_END, 20000);
                    break;
                case EVENT_HEAD_END:
                    if (Creature* pMagmawhead = ObjectAccessor::GetCreature(*me, pInstance->GetData64(DATA_MAGMAW_HEAD)))
                        pMagmawhead->AI()->DoAction(ACTION_HEAD_END);
                    SetGrounded(false, 0);
                    events.ScheduleEvent(EVENT_MELEE_CHECK, 6000);
                    events.ScheduleEvent(EVENT_LAVA_SPEW, urand(3000, 7000));
                    events.ScheduleEvent(EVENT_PILLAR_OF_FLAME, urand(10000, 15000));
                    events.ScheduleEvent(EVENT_MAGMA_SPLIT, urand(15000, 20000));
                    break;*/
                case EVENT_BERSERK:
                    DoCast(me, SPELL_BERSERK);
                    break;
                case EVENT_MELEE_CHECK:
                    if (!me->IsWithinMeleeRange(me->GetVictim()))
                        DoCast(me, SPELL_MAGMA_SPLIT_2);
                    events.ScheduleEvent(EVENT_MELEE_CHECK, 1000);
                    break;
                case EVENT_MAGMA_SPLIT:
                    me->CastCustomSpell(SPELL_MAGMA_SPLIT_1, SPELLVALUE_MAX_TARGETS, RAID_MODE(3, 8, 3, 8), 0, false); 
                    events.ScheduleEvent(EVENT_MAGMA_SPLIT, urand(15000, 20000));
                    break;
                case EVENT_LAVA_SPEW:
                    DoCast (me, SPELL_LAVA_SPEW);
                    events.ScheduleEvent(EVENT_LAVA_SPEW, 22000);
                    break;
                case EVENT_PILLAR_OF_FLAME:
                    Unit* target;
                    target = SelectTarget(SELECT_TARGET_RANDOM, 1, -20.0f, true);
                    if (!target)
                        target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true);
                    if (!target)
                        break;
                    me->SummonCreature(NPC_PILLAR_OF_FLAME,
                        target->GetPositionX(),
                        target->GetPositionY(),
                        target->GetPositionZ(),
                        0.0f, TEMPSUMMON_TIMED_DESPAWN, 8000);
                    events.ScheduleEvent(EVENT_PILLAR_OF_FLAME, urand(35000, 45000));
                    break;
                case EVENT_MANGLE:
                    DoCast(me->GetVictim(), SPELL_MANGLE);
                    //events.CancelEvent(EVENT_MELEE_CHECK);
                    //events.CancelEvent(EVENT_LAVA_SPEW);
                    //events.CancelEvent(EVENT_PILLAR_OF_FLAME);
                    //events.CancelEvent(EVENT_MAGMA_SPLIT);
                    events.ScheduleEvent(EVENT_MANGLE, 95000);
                    //events.ScheduleEvent(EVENT_HEAD_START, 12000);
                    break;
                }
            }
            if (me->GetVictim())
                if (!me->GetVictim()->HasAura(SPELL_MANGLE) && !bGrounded)
                    DoMeleeAttackIfReady();
        }
示例#30
0
        void UpdateAI(const uint32 diff)
        {
            if (LamentEvent)
            {
                if (LamentEventTimer <= diff)
                {
                    DoSummon(ENTRY_HIGHBORNE_BUNNY, me, 10.0f, 3000, TEMPSUMMON_TIMED_DESPAWN);

                    LamentEventTimer = 2000;
                    if (!me->HasAura(SPELL_SYLVANAS_CAST))
                    {
                        DoScriptText(SAY_LAMENT_END, me);
                        DoScriptText(EMOTE_LAMENT_END, me);
                        LamentEvent = false;
                    }
                } else LamentEventTimer -= diff;
            }

            // World Notify Cooldown
            if (notifyCooldown >= diff)
                notifyCooldown -= diff;
            else
                notifyCooldown = 0;

            if (!UpdateVictim())
                return;

            // Defender Quest Credit
            if (!defenderCredit)
                if (me->getThreatManager().getThreatList().size() >= 5 && me->GetHealthPct() < 90.f) // Anti-Farming Conditions
                    defenderCredit = true;

            // Boss rescaling
            if (rescaleTimer <= diff)
            {
                HandleScaling();
                rescaleTimer = 10000;
            } else rescaleTimer -= diff;

            events.Update(diff);

            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                    case SPELL_BLACK_ARROW:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 45.0f, true))
                            DoCast(target, SPELL_BLACK_ARROW);
                        events.ScheduleEvent(SPELL_BLACK_ARROW, urand(15000, 25000));
                        break;
                    case SPELL_FADE:
                        DoCast(me, SPELL_FADE);
                        events.ScheduleEvent(SPELL_FADE, urand(25000, 35000));
                        break;
                    case SPELL_MULTI_SHOT:
                        DoCastVictim(SPELL_MULTI_SHOT);
                        events.ScheduleEvent(SPELL_MULTI_SHOT, urand(11000, 14000));
                        break;
                    case SPELL_SHOOT_SYLVANAS:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 30.0f, true))
                            if (me->GetDistance(target) > 5.0f)
                                DoCast(target, SPELL_SHOOT_SYLVANAS);
                        events.ScheduleEvent(SPELL_SHOOT_SYLVANAS, urand(6000, 9000));
                        break;
                    case SPELL_SUMMON_SKELETON:
                        if (Summons.size() < 7)
                            DoCast(me, SPELL_SUMMON_SKELETON);
                        events.ScheduleEvent(SPELL_SUMMON_SKELETON, urand(17000, 23000));
                        break;
                }
            }

            DoMeleeAttackIfReady();
        }