コード例 #1
0
ファイル: zone_darkshore.cpp プロジェクト: Caydan/DeathCore
        void WaypointReached(uint32 i)
        {
            Player* player = GetPlayerForEscort();

            if (!player)
                return;

            switch (i)
            {
                case 0:
//                    DoScriptText(SAY_REM_START, me, player);
                    break;
                case 5:
//                    DoScriptText(SAY_REM_RAMP1_1, me, player);
                    break;
                case 6:
                    DoSpawnCreature(NPC_GRAVEL_SCOUT, -10.0f, 5.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
                    DoSpawnCreature(NPC_GRAVEL_BONE, -10.0f, 7.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
                    break;
                case 9:
//                    DoScriptText(SAY_REM_RAMP1_2, me, player);
                    break;
                case 14:
//                    DoScriptText(SAY_REM_BOOK, me, player);
                    break;
                case 15:
//                    DoScriptText(SAY_REM_TENT1_1, me, player);
                    break;
                case 16:
                    DoSpawnCreature(NPC_GRAVEL_SCOUT, -10.0f, 5.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
                    DoSpawnCreature(NPC_GRAVEL_BONE, -10.0f, 7.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
                    break;
                case 17:
//                    DoScriptText(SAY_REM_TENT1_2, me, player);
                    break;
                case 26:
//                    DoScriptText(SAY_REM_MOSS, me, player);
                    break;
                case 27:
//                    DoScriptText(EMOTE_REM_MOSS, me, player);
                    break;
                case 28:
//                    DoScriptText(SAY_REM_MOSS_PROGRESS, me, player);
                    break;
                case 29:
                    DoSpawnCreature(NPC_GRAVEL_SCOUT, -15.0f, 3.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
                    DoSpawnCreature(NPC_GRAVEL_BONE, -15.0f, 5.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
                    DoSpawnCreature(NPC_GRAVEL_GEO, -15.0f, 7.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
                    break;
                case 31:
//                    DoScriptText(SAY_REM_PROGRESS, me, player);
                    break;
                case 41:
//                    DoScriptText(SAY_REM_REMEMBER, me, player);
                    break;
                case 42:
//                    DoScriptText(EMOTE_REM_END, me, player);
                    player->GroupEventHappens(QUEST_ABSENT_MINDED_PT2, me);
                    break;
            }
        }
コード例 #2
0
ファイル: boss_noxxion.cpp プロジェクト: Naios/MythCore
 void SummonAdds(Unit* victim)
 {
     if(Creature* Add = DoSpawnCreature(13456, float(irand(-7, 7)), float(irand(-7, 7)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 90000))
         Add->AI()->AttackStart(victim);
 }
コード例 #3
0
        void UpdateAI(const uint32 diff)
        {
            if (!UpdateVictim())
                return;
            if (uiPhaseTimer <= diff)
            {
                switch (Phase)
                {
                case CASTING_FLAME_SPHERES:
                {
                    Creature* pSpheres[3];

                    //DoCast(me, SPELL_FLAME_SPHERE_SUMMON_1);
                    pSpheres[0] = DoSpawnCreature(CREATURE_FLAME_SPHERE, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
                    Unit *pSphereTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
                    if (pSphereTarget && pSpheres[0])
                    {
                        float angle, x, y;
                        angle = pSpheres[0]->GetAngle(pSphereTarget);
                        x = pSpheres[0]->GetPositionX() + DATA_SPHERE_DISTANCE * cos(angle);
                        y = pSpheres[0]->GetPositionY() + DATA_SPHERE_DISTANCE * sin(angle);
                        pSpheres[0]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[0]->GetPositionZ());
                    }
                    if (IsHeroic())
                    {
                        //DoCast(me, H_SPELL_FLAME_SPHERE_SUMMON_1);
                        pSpheres[1] = DoSpawnCreature(H_CREATURE_FLAME_SPHERE_1, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
                        //DoCast(me, H_SPELL_FLAME_SPHERE_SUMMON_2);
                        pSpheres[2] = DoSpawnCreature(H_CREATURE_FLAME_SPHERE_2, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
                        if (pSphereTarget && pSpheres[1] && pSpheres[2])
                        {
                            float angle, x, y;
                            angle = pSpheres[1]->GetAngle(pSphereTarget) + DATA_SPHERE_ANGLE_OFFSET;
                            x = pSpheres[1]->GetPositionX() + DATA_SPHERE_DISTANCE/2 * cos(angle);
                            y = pSpheres[1]->GetPositionY() + DATA_SPHERE_DISTANCE/2 * sin(angle);
                            pSpheres[1]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[1]->GetPositionZ());
                            angle = pSpheres[2]->GetAngle(pSphereTarget) - DATA_SPHERE_ANGLE_OFFSET;
                            x = pSpheres[2]->GetPositionX() + DATA_SPHERE_DISTANCE/2 * cos(angle);
                            y = pSpheres[2]->GetPositionY() + DATA_SPHERE_DISTANCE/2 * sin(angle);
                            pSpheres[2]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[2]->GetPositionZ());
                        }
                    }

                    Phase = NORMAL;
                    uiPhaseTimer = 0;
                    break;
                }
                case JUST_VANISHED:
                    if (Unit *pEmbraceTarget = GetEmbraceTarget())
                    {
                        me->GetMotionMaster()->Clear();
                        me->SetSpeed(MOVE_WALK, 2.0f, true);
                        me->GetMotionMaster()->MoveChase(pEmbraceTarget);
                    }
                    Phase = VANISHED;
                    uiPhaseTimer = 1300;
                    break;
                case VANISHED:
                    if (Unit *pEmbraceTarget = GetEmbraceTarget())
                        DoCast(pEmbraceTarget, SPELL_EMBRACE_OF_THE_VAMPYR);
                    me->GetMotionMaster()->Clear();
                    me->SetSpeed(MOVE_WALK, 1.0f, true);
                    me->GetMotionMaster()->MoveChase(me->getVictim());
                    Phase = FEEDING;
                    uiPhaseTimer = 20*IN_MILLISECONDS;
                    break;
                case FEEDING:
                    Phase = NORMAL;
                    uiPhaseTimer = 0;
                    uiEmbraceTarget = 0;
                    break;
                case NORMAL:
                    if (uiBloodthirstTimer <= diff)
                    {
                        DoCast(me->getVictim(), SPELL_BLOODTHIRST);
                        uiBloodthirstTimer = 10*IN_MILLISECONDS;
                    } else uiBloodthirstTimer -= diff;

                    if (uiFlamesphereTimer <= diff)
                    {
                        DoCast(me, SPELL_CONJURE_FLAME_SPHERE);
                        Phase = CASTING_FLAME_SPHERES;
                        uiPhaseTimer = 3*IN_MILLISECONDS + diff;
                        uiFlamesphereTimer = 15*IN_MILLISECONDS;
                    } else uiFlamesphereTimer -= diff;

                    if (uiVanishTimer <= diff)
                    {
                        //Count alive players
                        Unit *pTarget = NULL;
                        std::list<HostileReference *> t_list = me->getThreatManager().getThreatList();
                        std::vector<Unit *> target_list;
                        for (std::list<HostileReference *>::const_iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
                        {
                            pTarget = Unit::GetUnit(*me, (*itr)->getUnitGuid());
                            // exclude pets & totems
                            if (pTarget && pTarget->GetTypeId() == TYPEID_PLAYER && pTarget->isAlive())
                                target_list.push_back(pTarget);
                            pTarget = NULL;
                        }
                        //He only vanishes if there are 3 or more alive players
                        if (target_list.size() > 2)
                        {
                            DoScriptText(RAND(SAY_VANISH_1, SAY_VANISH_2), me);
                            DoCast(me, SPELL_VANISH);
                            Phase = JUST_VANISHED;
                            uiPhaseTimer = 500;
                            if (Unit* pEmbraceTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
                                uiEmbraceTarget = pEmbraceTarget->GetGUID();
                        }
                        uiVanishTimer = urand(25*IN_MILLISECONDS, 35*IN_MILLISECONDS);
                    } else uiVanishTimer -= diff;

                    DoMeleeAttackIfReady();
                    break;
                }
            } else uiPhaseTimer -= diff;
        }
コード例 #4
0
    void UpdateAI(const uint32 diff)
    {
        if (!CanDoSomething())
            return;

        switch(Phase)
        {
            case 0:
            {
                // *Heroic mode only:
                if (m_bIsHeroic)
                {
                    if (PyroblastTimer < diff)
                    {
                        me->InterruptSpell(CURRENT_CHANNELED_SPELL);
                        me->InterruptSpell(CURRENT_GENERIC_SPELL);
                        DoCastMe( SPELL_SHOCK_BARRIER, true);
                        DoCastVictim( SPELL_PYROBLAST);
                        PyroblastTimer = 60000;
                    }else PyroblastTimer -= diff;
                }

                if (FireballTimer < diff)
                {
                    DoCastVictim( m_bIsHeroic ? SPELL_FIREBALL_HEROIC : SPELL_FIREBALL_NORMAL);
                    FireballTimer = urand(2000, 6000);
                }else FireballTimer -= diff;

                if (PhoenixTimer < diff)
                {

                    Unit* target = NULL;
                    target = SelectUnit(SELECT_TARGET_RANDOM,1);

                    uint32 random = urand(1, 2);
                    float x = KaelLocations[random][0];
                    float y = KaelLocations[random][1];

                    Creature* Phoenix = me->SummonCreature(CREATURE_PHOENIX, x, y, LOCATION_Z, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 60000);
                    if (Phoenix)
                    {
                        Phoenix->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
                        SetThreatList(Phoenix);
                        Phoenix->AI()->AttackStart(target);
                    }

                    DoScriptText(SAY_PHOENIX, me);

                    PhoenixTimer = 60000;
                }else PhoenixTimer -= diff;

                if (FlameStrikeTimer < diff)
                {
                    if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
                    {
                        if (me->IsNonMeleeSpellCasted(false))
                            me->InterruptNonMeleeSpells(false);

                        DoCast(pTarget, SPELL_FLAME_STRIKE);
                        DoScriptText(SAY_FLAMESTRIKE, me);
                    }
                    FlameStrikeTimer = urand(15000, 25000);
                }else FlameStrikeTimer -= diff;

                // Below 50%
                if (me->GetMaxHealth() * 0.5 > me->GetHealth())
                {
                    me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_INTERRUPT_CAST, true);
                    me->StopMoving();
                    me->GetMotionMaster()->Clear();
                    me->GetMotionMaster()->MoveIdle();
                    GravityLapseTimer = 0;
                    GravityLapsePhase = 0;
                    Phase = 1;
                }

                DoMeleeAttackIfReady();
            }
            break;

            case 1:
            {
                if (GravityLapseTimer < diff)
                {
                    switch(GravityLapsePhase)
                    {
                        case 0:
                            if (FirstGravityLapse)          // Different yells at 50%, and at every following Gravity Lapse
                            {
                                DoScriptText(SAY_GRAVITY_LAPSE, me);
                                FirstGravityLapse = false;

                                if (pInstance)
                                {
                                    if (GameObject* pKaelLeft = pInstance->instance->GetGameObject(pInstance->GetData64(DATA_KAEL_STATUE_LEFT)))
                                        pKaelLeft->SetGoState(GO_STATE_ACTIVE);

                                    if (GameObject* pKaelRight = pInstance->instance->GetGameObject(pInstance->GetData64(DATA_KAEL_STATUE_RIGHT)))
                                        pKaelRight->SetGoState(GO_STATE_ACTIVE);
                                }
                            }
                            else
                            {
                                DoScriptText(SAY_RECAST_GRAVITY, me);
                            }

                            DoCastMe( SPELL_GRAVITY_LAPSE_INITIAL);
                            GravityLapseTimer = 2000 + diff;// Don't interrupt the visual spell
                            GravityLapsePhase = 1;
                            break;

                        case 1:
                            TeleportPlayersToSelf();
                            GravityLapseTimer = 1000;
                            GravityLapsePhase = 2;
                            break;

                        case 2:
                            CastGravityLapseKnockUp();
                            GravityLapseTimer = 1000;
                            GravityLapsePhase = 3;
                            break;

                        case 3:
                            CastGravityLapseFly();
                            GravityLapseTimer = 30000;
                            GravityLapsePhase = 4;


                            for(uint8 i = 0; i < 3; ++i)
                            {
                                Unit* target = NULL;
                                target = SelectUnit(SELECT_TARGET_RANDOM,0);

                                Creature* Orb = DoSpawnCreature(CREATURE_ARCANE_SPHERE, 5, 5, 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 30000);
                                if (Orb && target)
                                {
                                    //SetThreatList(Orb);
                                    Orb->AddThreat(target, 1.0f);
                                    Orb->AI()->AttackStart(target);
                                }

                            }

                            DoCastMe( SPELL_GRAVITY_LAPSE_CHANNEL);
                            break;

                        case 4:
                            me->InterruptNonMeleeSpells(false);
                            DoScriptText(SAY_TIRED, me);
                            DoCastMe( SPELL_POWER_FEEDBACK);
                            RemoveGravityLapse();
                            GravityLapseTimer = 10000;
                            GravityLapsePhase = 0;
                            break;
                    }
                }else GravityLapseTimer -= diff;
            }
            break;
        }
    }
コード例 #5
0
        void UpdateAI(const uint32 diff)
        {
            //Return since we have no target
            if (me->HasAura(AURA_BANISH) || !UpdateVictim())
            {
                if (BanishTimer <= diff)
                {
                    CheckBanish();//no need to check every update tick
                    BanishTimer = 1000;
                } else BanishTimer -= diff;
                return;
            }
            if (me->HasAura(SPELL_WHIRLWIND))
            {
                if (Whirlwind_Timer <= diff)
                {
                    Unit* newTarget = SelectTarget(SELECT_TARGET_RANDOM, 0);
                    if (newTarget)
                    {
                        DoResetThreat();
                        me->GetMotionMaster()->Clear();
                        me->GetMotionMaster()->MovePoint(0, newTarget->GetPositionX(), newTarget->GetPositionY(), newTarget->GetPositionZ());
                    }
                    Whirlwind_Timer = 2000;
                } else Whirlwind_Timer -= diff;
            }

            // reseting after changing forms and after ending whirlwind
            if (NeedThreatReset && !me->HasAura(SPELL_WHIRLWIND))
            {
                // when changing forms seting timers (or when ending whirlwind - to avoid adding new variable i use Whirlwind_Timer to countdown 2s while whirlwinding)
                if (DemonForm)
                    InnerDemons_Timer = 30000;
                else
                    Whirlwind_Timer =  15000;

                NeedThreatReset = false;
                DoResetThreat();
                me->GetMotionMaster()->Clear();
                me->GetMotionMaster()->MoveChase(me->getVictim());
            }

            //Enrage_Timer (10 min)
            if (Berserk_Timer < diff && !EnrageUsed)
            {
                me->InterruptNonMeleeSpells(false);
                DoCast(me, SPELL_BERSERK);
                EnrageUsed = true;
            } else Berserk_Timer -= diff;

            if (!DemonForm)
            {
                //Whirldind Timer
                if (!me->HasAura(SPELL_WHIRLWIND))
                {
                    if (Whirlwind_Timer <= diff)
                    {
                        DoCast(me, SPELL_WHIRLWIND);
                        // while whirlwinding this variable is used to countdown target's change
                        Whirlwind_Timer = 2000;
                        NeedThreatReset = true;
                    } else Whirlwind_Timer -= diff;
                }
                //Switch_Timer

                if (!IsFinalForm)
                {
                    if (SwitchToDemon_Timer <= diff)
                    {
                        //switch to demon form
                        me->RemoveAurasDueToSpell(SPELL_WHIRLWIND, 0);
                        me->SetDisplayId(MODEL_DEMON);
                        DoScriptText(SAY_SWITCH_TO_DEMON, me);
                        me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID  , 0);
                        me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID+1, 0);
                        DemonForm = true;
                        NeedThreatReset = true;
                        SwitchToDemon_Timer = 45000;
                    } else SwitchToDemon_Timer -= diff;
                }
                DoMeleeAttackIfReady();
            }
            else
            {
                //ChaosBlast_Timer
                if (!me->getVictim())
                    return;
                if (me->IsWithinDist(me->getVictim(), 30))
                    me->StopMoving();
                if (ChaosBlast_Timer <= diff)
                {
                    // will cast only when in range of spell
                    if (me->IsWithinDist(me->getVictim(), 30))
                    {
                        //DoCast(me->getVictim(), SPELL_CHAOS_BLAST, true);
                        int damage = 100;
                        me->CastCustomSpell(me->getVictim(), SPELL_CHAOS_BLAST, &damage, NULL, NULL, false, NULL, NULL, me->GetGUID());
                    }
                    ChaosBlast_Timer = 3000;
                } else ChaosBlast_Timer -= diff;
                //Summon Inner Demon
                if (InnerDemons_Timer <= diff)
                {
                    std::list<HostileReference*>& ThreatList = me->getThreatManager().getThreatList();
                    std::vector<Unit*> TargetList;
                    for (std::list<HostileReference*>::const_iterator itr = ThreatList.begin(); itr != ThreatList.end(); ++itr)
                    {
                        Unit* tempTarget = Unit::GetUnit(*me, (*itr)->getUnitGuid());
                        if (tempTarget && tempTarget->GetTypeId() == TYPEID_PLAYER && tempTarget->GetGUID() != me->getVictim()->GetGUID() && TargetList.size()<5)
                            TargetList.push_back(tempTarget);
                    }
                    //SpellInfo* spell = GET_SPELL(SPELL_INSIDIOUS_WHISPER);
                    for (std::vector<Unit*>::const_iterator itr = TargetList.begin(); itr != TargetList.end(); ++itr)
                    {
                        if ((*itr) && (*itr)->isAlive())
                        {
                            Creature* demon = me->SummonCreature(INNER_DEMON_ID, (*itr)->GetPositionX()+10, (*itr)->GetPositionY()+10, (*itr)->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
                            if (demon)
                            {
                                demon->AI()->AttackStart((*itr));
                                demon->AI()->SetGUID((*itr)->GetGUID(), INNER_DEMON_VICTIM);

                                (*itr)->AddAura(SPELL_INSIDIOUS_WHISPER, *itr);

                                if (InnerDemon_Count > 4)
                                    InnerDemon_Count = 0;

                                //Safe storing of creatures
                                InnderDemon[InnerDemon_Count] = demon->GetGUID();

                                //Update demon count
                                ++InnerDemon_Count;
                            }
                        }
                    }
                    DoScriptText(SAY_INNER_DEMONS, me);

                    InnerDemons_Timer = 999999;
                } else InnerDemons_Timer -= diff;

                //Switch_Timer
                if (SwitchToHuman_Timer <= diff)
                {
                    //switch to nightelf form
                    me->SetDisplayId(MODEL_NIGHTELF);
                    me->LoadEquipment(me->GetEquipmentId());

                    CastConsumingMadness();
                    DespawnDemon();

                    DemonForm = false;
                    NeedThreatReset = true;

                    SwitchToHuman_Timer = 60000;
                } else SwitchToHuman_Timer -= diff;
            }

            if (!IsFinalForm && HealthBelowPct(15))
            {
                //at this point he divides himself in two parts
                CastConsumingMadness();
                DespawnDemon();
                Creature* Copy = NULL;
                Copy = DoSpawnCreature(DEMON_FORM, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 6000);
                if (Copy)
                 {
                     Demon = Copy->GetGUID();
                    if (me->getVictim())
                        Copy->AI()->AttackStart(me->getVictim());
                }
                //set nightelf final form
                IsFinalForm = true;
                DemonForm = false;

                DoScriptText(SAY_FINAL_FORM, me);
                me->SetDisplayId(MODEL_NIGHTELF);
                me->LoadEquipment(me->GetEquipmentId());
            }
        }
コード例 #6
0
        void UpdateAI(uint32 diff) override
        {
            //Only if not incombat check if the event is started
            if (!me->IsInCombat() && instance->GetData(DATA_KARATHRESSEVENT))
            {
                if (Unit* target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_KARATHRESSEVENT_STARTER)))
                    AttackStart(target);
            }

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

            //someone evaded!
            if (!instance->GetData(DATA_KARATHRESSEVENT))
            {
                EnterEvadeMode();
                return;
            }

            //LeechingThrow_Timer
            if (LeechingThrow_Timer <= diff)
            {
                DoCastVictim(SPELL_LEECHING_THROW);
                LeechingThrow_Timer = 20000;
            } else LeechingThrow_Timer -= diff;

            //Multishot_Timer
            if (Multishot_Timer <= diff)
            {
                DoCastVictim(SPELL_MULTISHOT);
                Multishot_Timer = 20000;
            } else Multishot_Timer -= diff;

            //TheBeastWithin_Timer
            if (TheBeastWithin_Timer <= diff)
            {
                DoCast(me, SPELL_THE_BEAST_WITHIN);

                Creature* Pet = ObjectAccessor::GetCreature(*me, SummonedPet);
                if (Pet && Pet->IsAlive())
                    Pet->CastSpell(Pet, SPELL_PET_ENRAGE, true);

                TheBeastWithin_Timer = 30000;
            } else TheBeastWithin_Timer -= diff;

            //Pet_Timer
            if (Pet_Timer < diff && pet == false)
            {
                pet = true;
                //uint32 spell_id;
                uint32 pet_id;
                if (!urand(0, 1))
                {
                    //spell_id = SPELL_SUMMON_FATHOM_LURKER;
                    pet_id = CREATURE_FATHOM_LURKER;
                }
                else
                {
                    //spell_id = SPELL_SUMMON_FATHOM_SPOREBAT;
                    pet_id = CREATURE_FATHOM_SPOREBAT;
                }
                //DoCast(me, spell_id, true);
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                {
                    if (Creature* Pet = DoSpawnCreature(pet_id, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000))
                    {
                        Pet->AI()->AttackStart(target);
                        SummonedPet = Pet->GetGUID();
                    }
                }
            } else Pet_Timer -= diff;

            DoMeleeAttackIfReady();
        }
コード例 #7
0
        void UpdateAI(uint32 diff)
        {
            //Return since we have no target
            if (!UpdateVictim())
                return;

            switch (Phase)
            {
                case 0:
                {
                    // *Heroic mode only:
                    if (IsHeroic())
                    {
                        if (PyroblastTimer <= diff)
                        {
                            me->InterruptSpell(CURRENT_CHANNELED_SPELL);
                            me->InterruptSpell(CURRENT_GENERIC_SPELL);
                            DoCast(me, SPELL_SHOCK_BARRIER, true);
                            DoCast(me->getVictim(), SPELL_PYROBLAST);
                            PyroblastTimer = 60000;
                        } else PyroblastTimer -= diff;
                    }

                    if (FireballTimer <= diff)
                    {
                        DoCast(me->getVictim(), SPELL_FIREBALL_NORMAL);
                        FireballTimer = urand(2000, 6000);
                    } else FireballTimer -= diff;

                    if (PhoenixTimer <= diff)
                    {
                        Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);

                        uint8 random = urand(1, 2);
                        float x = KaelLocations[random][0];
                        float y = KaelLocations[random][1];

                        Creature* Phoenix = me->SummonCreature(CREATURE_PHOENIX, x, y, LOCATION_Z, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 60000);
                        if (Phoenix)
                        {
                            Phoenix->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
                            SetThreatList(Phoenix);
                            Phoenix->AI()->AttackStart(target);
                        }

                        Talk(SAY_PHOENIX);

                        PhoenixTimer = 60000;
                    } else PhoenixTimer -= diff;

                    if (FlameStrikeTimer <= diff)
                    {
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
                        {
                            me->InterruptSpell(CURRENT_CHANNELED_SPELL);
                            me->InterruptSpell(CURRENT_GENERIC_SPELL);
                            DoCast(target, SPELL_FLAMESTRIKE3, true);
                            Talk(SAY_FLAMESTRIKE);
                        }
                        FlameStrikeTimer = urand(15000, 25000);
                    } else FlameStrikeTimer -= diff;

                    // Below 50%
                    if (HealthBelowPct(50))
                    {
                        me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_INTERRUPT_CAST, true);
                        me->StopMoving();
                        me->GetMotionMaster()->Clear();
                        me->GetMotionMaster()->MoveIdle();
                        GravityLapseTimer = 0;
                        GravityLapsePhase = 0;
                        Phase = 1;
                    }

                    DoMeleeAttackIfReady();
                }
                break;

                case 1:
                {
                    if (GravityLapseTimer <= diff)
                    {
                        switch (GravityLapsePhase)
                        {
                            case 0:
                                if (FirstGravityLapse)          // Different yells at 50%, and at every following Gravity Lapse
                                {
                                    Talk(SAY_GRAVITY_LAPSE);
                                    FirstGravityLapse = false;

                                    if (instance)
                                        instance->SetData(DATA_KAELTHAS_STATUES, 1);
                                }
                                else
                                    Talk(SAY_RECAST_GRAVITY);

                                DoCast(me, SPELL_GRAVITY_LAPSE_INITIAL);
                                GravityLapseTimer = 2000 + diff;// Don't interrupt the visual spell
                                GravityLapsePhase = 1;
                                break;

                            case 1:
                                TeleportPlayersToSelf();
                                GravityLapseTimer = 1000;
                                GravityLapsePhase = 2;
                                break;

                            case 2:
                                CastGravityLapseKnockUp();
                                GravityLapseTimer = 1000;
                                GravityLapsePhase = 3;
                                break;

                            case 3:
                                CastGravityLapseFly();
                                GravityLapseTimer = 30000;
                                GravityLapsePhase = 4;

                                for (uint8 i = 0; i < 3; ++i)
                                {
                                    Unit* target = NULL;
                                    target = SelectTarget(SELECT_TARGET_RANDOM, 0);

                                    Creature* Orb = DoSpawnCreature(CREATURE_ARCANE_SPHERE, 5, 5, 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 30000);
                                    if (Orb && target)
                                    {
                                        Orb->SetSpeed(MOVE_RUN, 0.5f);
                                        Orb->AddThreat(target, 1000000.0f);
                                        Orb->AI()->AttackStart(target);
                                    }
                                }

                                DoCast(me, SPELL_GRAVITY_LAPSE_CHANNEL);
                                break;

                            case 4:
                                me->InterruptNonMeleeSpells(false);
                                Talk(SAY_TIRED);
                                DoCast(me, SPELL_POWER_FEEDBACK);
                                RemoveGravityLapse();
                                GravityLapseTimer = 10000;
                                GravityLapsePhase = 0;
                                break;
                        }
                    } else GravityLapseTimer -= diff;
                }
                break;
            }
        }
コード例 #8
0
		void SummonHounds(Unit* pVictim) {
			if (Creature *Hound = DoSpawnCreature(19207, float(irand(-9, 9)), float(irand(-9, 9)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 300000))
				Hound->AI()->AttackStart(pVictim);
		}
コード例 #9
0
 void SummonMedics(Unit* victim)
 {
     if (Creature* SummonedMedic = DoSpawnCreature(8894, float(irand(-9, 9)), float(irand(-9, 9)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 120000))
         SummonedMedic->AI()->AttackStart(victim);
 }
コード例 #10
0
ファイル: BossMaximus.cpp プロジェクト: AwkwardDev/255
		//Stay up to date
        void UpdateAI(const uint32 diff)
        {
			//Channel on Twilight Portal
		    if (ChannelTwilight_Timer <= diff)
			{
			    if (!IsChanneling)
                {
                    DoCast(me, SPELL_TWILIGHT_CHANNEL);
                    IsChanneling = true;
                }
			} else ChannelTwilight_Timer -= diff;             	
		
            if (!UpdateVictim())
                return;

            if (me->HealthBelowPct(20) && !BelowTwentyPercent && !Enraged)
                BelowTwentyPercent = true;

			//When enraged:
            if (Enrage_Timer < diff && !Enraged)
            {
                me->GetMotionMaster()->Clear(false);
                me->GetMotionMaster()->MoveIdle();
                me->RemoveAllAuras(); 
                me->MonsterTextEmote(EMOTE_FAIL, 0, true);
                Enraged = true;
            } else Enrage_Timer -= diff;

            if (Enraged)
            {
                DoCast(me, SPELL_BERSERK);

				//Finger of Death timer
                if (FingerOfDeath_Timer <= diff)
                {
                    if (Unit *Target = SelectTarget (SELECT_TARGET_RANDOM, 0))
			        DoCast (Target, SPELL_FINGER_OF_DEATH);
                    FingerOfDeath_Timer = 1000;
                } else FingerOfDeath_Timer -= diff;
                return; 
			}

			//When below 20% health:
            if (BelowTwentyPercent && !Enraged)
            {
                if (!HasProtected)
                {
                    me->RemoveAllAuras(); 
	                DoCast (me, SPELL_HIGH_SECURITY_SHADOW_PRISON);

                    me->MonsterTextEmote(EMOTE_WIN, 0, true);
                    HasProtected = true;
                }

				//Summon Wisp timer
                if (SummonWisp_Timer <= diff)
                {
                    DoSpawnCreature(NPC_ANCIENT_WISP, float(rand()%40), float(rand()%40), 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
					SummonWisp_Timer = 2500;
                    ++WispCount;
                } else SummonWisp_Timer -= diff;

                if (WispCount >= 10)
                    me->DealDamage(me, me->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);		    		
				   return;
			}

		        //Aura of Dread Timer
		        if (AuraOfDread_Timer <= diff)
		        {
			        DoCast (me->getVictim(), SPELL_AURA_OF_DREAD);
			        AuraOfDread_Timer = 2500;
		        } else AuraOfDread_Timer -= diff;

		        //Sunder Armor Timer
		        if (SunderArmor_Timer <= diff)
		        {
			        DoCast (me->getVictim(), SPELL_SUNDER_ARMOR);
			        SunderArmor_Timer = 15000;
                } else SunderArmor_Timer -= diff;

		        //Burning Fists Timer
			    if (BurningFists_Timer <= diff)
		        {
			        DoCast (me->getVictim(), SPELL_BURNING_FISTS);
			        BurningFists_Timer = 25001;
                } else BurningFists_Timer -= diff;

		    	//Unholy Power Timer
		     	if (UnholyPower_Timer <= diff)
		        {
		        	DoCast (me->getVictim(), SPELL_UNHOLY_POWER);
		        	UnholyPower_Timer = 25000;
		            me->MonsterTextEmote(EMOTE_STRENGTH, 0, true);
                } else UnholyPower_Timer -= diff;

		        //Pain and Suffering Timer
		        if (PainAndSuffering_Timer <= diff)
		        {
                    if (Unit *Target = SelectTarget (SELECT_TARGET_RANDOM, 0))
			        DoCast (Target, SPELL_PAIN_AND_SUFFERING);
			        PainAndSuffering_Timer = urand(10000, 17500);
		        } else PainAndSuffering_Timer -= diff;
 
			    //Fiery Combustion Timer
		        if (FieryCombustion_Timer <= diff)
		        {
                    if (Unit *Target = SelectTarget (SELECT_TARGET_RANDOM, 0))
			        DoCast (Target, SPELL_FIERY_COMBUSTION);
			        FieryCombustion_Timer = urand(12500, 20000);      
		        } else FieryCombustion_Timer -= diff;			

            DoMeleeAttackIfReady();
        }
コード例 #11
0
 void SummonAdds(Unit* victim)
 {
     if (Creature* SummonedAdd = DoSpawnCreature(8901, float(irand(-14, 14)), float(irand(-14, 14)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 120000))
         SummonedAdd->AI()->AttackStart(victim);
 }
コード例 #12
0
    void UpdateAI(const uint32 diff)
    {
        if (!beam)
        {
            SummonBeams();
            beam=true;
        }
        //Return since we have no target
        if (!UpdateVictim())
            return;

        // corrupted form
        if (CorruptedForm)
        {
            //MarkOfCorruption_Timer
            if (MarkOfCorruption_Timer <= diff)
            {
                if (MarkOfCorruption_Count <= 5)
                {
                    uint32 mark_spell;

                    switch (MarkOfCorruption_Count)
                    {
                        case 0: mark_spell = SPELL_MARK_OF_CORRUPTION1; break;
                        case 1: mark_spell = SPELL_MARK_OF_CORRUPTION2; break;
                        case 2: mark_spell = SPELL_MARK_OF_CORRUPTION3; break;
                        case 3: mark_spell = SPELL_MARK_OF_CORRUPTION4; break;
                        case 4: mark_spell = SPELL_MARK_OF_CORRUPTION5; break;
                        case 5: mark_spell = SPELL_MARK_OF_CORRUPTION6; break;
                    }

                    DoCast(m_creature->getVictim(), mark_spell);

                    if (MarkOfCorruption_Count < 5)
                        ++MarkOfCorruption_Count;
                }

                MarkOfCorruption_Timer = 15000;
            } else MarkOfCorruption_Timer -= diff;

            //VileSludge_Timer
            if (VileSludge_Timer <= diff)
            {
                Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
                if (pTarget)
                    DoCast(pTarget, SPELL_VILE_SLUDGE);

                VileSludge_Timer = 15000;
            } else VileSludge_Timer -= diff;

            //PosCheck_Timer
            if (PosCheck_Timer <= diff)
            {
                if (m_creature->IsWithinDist2d(HYDROSS_X, HYDROSS_Y, SWITCH_RADIUS))
                {
                    // switch to clean form
                    m_creature->SetDisplayId(MODEL_CLEAN);
                    CorruptedForm = false;
                    MarkOfHydross_Count = 0;

                    DoScriptText(SAY_SWITCH_TO_CLEAN, m_creature);
                    DoResetThreat();
                    SummonBeams();

                    // spawn 4 adds
                    DoSpawnCreature(ENTRY_PURE_SPAWN, SPAWN_X_DIFF1, SPAWN_Y_DIFF1, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
                    DoSpawnCreature(ENTRY_PURE_SPAWN, SPAWN_X_DIFF2, SPAWN_Y_DIFF2, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
                    DoSpawnCreature(ENTRY_PURE_SPAWN, SPAWN_X_DIFF3, SPAWN_Y_DIFF3, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
                    DoSpawnCreature(ENTRY_PURE_SPAWN, SPAWN_X_DIFF4, SPAWN_Y_DIFF4, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);

                    m_creature->SetMeleeDamageSchool(SPELL_SCHOOL_FROST);
                    m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FROST, true);
                    m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_NATURE, false);
                }

                PosCheck_Timer = 2500;
            } else PosCheck_Timer -=diff;
        }
        // clean form
        else
        {
            //MarkOfHydross_Timer
            if (MarkOfHydross_Timer <= diff)
            {
                if (MarkOfHydross_Count <= 5)
                {
                    uint32 mark_spell;

                    switch(MarkOfHydross_Count)
                    {
                        case 0:  mark_spell = SPELL_MARK_OF_HYDROSS1; break;
                        case 1:  mark_spell = SPELL_MARK_OF_HYDROSS2; break;
                        case 2:  mark_spell = SPELL_MARK_OF_HYDROSS3; break;
                        case 3:  mark_spell = SPELL_MARK_OF_HYDROSS4; break;
                        case 4:  mark_spell = SPELL_MARK_OF_HYDROSS5; break;
                        case 5:  mark_spell = SPELL_MARK_OF_HYDROSS6; break;
                    }

                    DoCast(m_creature->getVictim(), mark_spell);

                    if (MarkOfHydross_Count < 5)
                        ++MarkOfHydross_Count;
                }

                MarkOfHydross_Timer = 15000;
            } else MarkOfHydross_Timer -= diff;

            //WaterTomb_Timer
            if (WaterTomb_Timer <= diff)
            {
                Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
                if (pTarget)
                    DoCast(pTarget, SPELL_WATER_TOMB);

                WaterTomb_Timer = 7000;
            } else WaterTomb_Timer -= diff;

            //PosCheck_Timer
            if (PosCheck_Timer <= diff)
            {
                if (!m_creature->IsWithinDist2d(HYDROSS_X, HYDROSS_Y, SWITCH_RADIUS))
                {
                    // switch to corrupted form
                    m_creature->SetDisplayId(MODEL_CORRUPT);
                    MarkOfCorruption_Count = 0;
                    CorruptedForm = true;

                    DoScriptText(SAY_SWITCH_TO_CORRUPT, m_creature);
                    DoResetThreat();
                    DeSummonBeams();

                    // spawn 4 adds
                    DoSpawnCreature(ENTRY_TAINTED_SPAWN, SPAWN_X_DIFF1, SPAWN_Y_DIFF1, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
                    DoSpawnCreature(ENTRY_TAINTED_SPAWN, SPAWN_X_DIFF2, SPAWN_Y_DIFF2, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
                    DoSpawnCreature(ENTRY_TAINTED_SPAWN, SPAWN_X_DIFF3, SPAWN_Y_DIFF3, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
                    DoSpawnCreature(ENTRY_TAINTED_SPAWN, SPAWN_X_DIFF4, SPAWN_Y_DIFF4, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);

                    m_creature->SetMeleeDamageSchool(SPELL_SCHOOL_NATURE);
                    m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_NATURE, true);
                    m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FROST, false);
                }

                PosCheck_Timer = 2500;
            } else PosCheck_Timer -=diff;
        }

        //EnrageTimer
        if (EnrageTimer <= diff)
        {
            DoCast(m_creature, SPELL_ENRAGE);
            EnrageTimer = 60000;
        } else EnrageTimer -= diff;

        DoMeleeAttackIfReady();
    }
コード例 #13
0
ファイル: boss_hexlord.cpp プロジェクト: Angmon/TrinityCore
            void UpdateAI(uint32 diff)
            {
                if (!UpdateVictim())
                    return;

                if (ResetTimer <= diff)
                {
                    if (me->IsWithinDist3d(119.223f, 1035.45f, 29.4481f, 10))
                    {
                        EnterEvadeMode();
                        return;
                    }
                    ResetTimer = 5000;
                } else ResetTimer -= diff;

                if (CheckAddState_Timer <= diff)
                {
                    for (uint8 i = 0; i < 4; ++i)
                        if (Creature* temp = Unit::GetCreature(*me, AddGUID[i]))
                            if (temp->IsAlive() && !temp->GetVictim())
                                temp->AI()->AttackStart(me->GetVictim());

                    CheckAddState_Timer = 5000;
                } else CheckAddState_Timer -= diff;

                if (DrainPower_Timer <= diff)
                {
                    DoCast(me, SPELL_DRAIN_POWER, true);
                    me->MonsterYell(YELL_DRAIN_POWER, LANG_UNIVERSAL, 0);
                    DoPlaySoundToSet(me, SOUND_YELL_DRAIN_POWER);
                    DrainPower_Timer = urand(40000, 55000);    // must cast in 60 sec, or buff/debuff will disappear
                } else DrainPower_Timer -= diff;

                if (SpiritBolts_Timer <= diff)
                {
                    if (DrainPower_Timer < 12000)    // channel 10 sec
                        SpiritBolts_Timer = 13000;   // cast drain power first
                    else
                    {
                        DoCast(me, SPELL_SPIRIT_BOLTS, false);
                        me->MonsterYell(YELL_SPIRIT_BOLTS, LANG_UNIVERSAL, 0);
                        DoPlaySoundToSet(me, SOUND_YELL_SPIRIT_BOLTS);
                        SpiritBolts_Timer = 40000;
                        SiphonSoul_Timer = 10000;    // ready to drain
                        PlayerAbility_Timer = 99999;
                    }
                } else SpiritBolts_Timer -= diff;

                if (SiphonSoul_Timer <= diff)
                {
                    Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 70, true);
                    Unit* trigger = DoSpawnCreature(MOB_TEMP_TRIGGER, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN, 30000);
                    if (!target || !trigger)
                    {
                        EnterEvadeMode();
                        return;
                    }
                    else
                    {
                        trigger->SetDisplayId(11686);
                        trigger->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                        trigger->CastSpell(target, SPELL_SIPHON_SOUL, true);
                        trigger->GetMotionMaster()->MoveChase(me);

                        //DoCast(target, SPELL_SIPHON_SOUL, true);
                        //me->SetUInt64Value(UNIT_FIELD_CHANNEL_OBJECT, target->GetGUID());
                        //me->SetUInt32Value(UNIT_CHANNEL_SPELL, SPELL_SIPHON_SOUL);

                        PlayerGUID = target->GetGUID();
                        PlayerAbility_Timer = urand(8000, 10000);
                        PlayerClass = target->getClass() - 1;

                        if (PlayerClass == CLASS_DRUID-1)
                            PlayerClass = CLASS_DRUID;
                        else if (PlayerClass == CLASS_PRIEST-1 && target->HasSpell(15473))
                            PlayerClass = CLASS_PRIEST; // shadow priest

                        SiphonSoul_Timer = 99999;   // buff lasts 30 sec
                    }
                } else SiphonSoul_Timer -= diff;

                if (PlayerAbility_Timer <= diff)
                {
                    //Unit* target = Unit::GetUnit(*me, PlayerGUID);
                    //if (target && target->IsAlive())
                    //{
                        UseAbility();
                        PlayerAbility_Timer = urand(8000, 10000);
                    //}
                } else PlayerAbility_Timer -= diff;

                DoMeleeAttackIfReady();
            }
コード例 #14
0
 void JustDied(Unit*)
 {
     DoScriptText(SAY_DEATH, me);
     //When Exarch Maladar is defeated D'ore appear.
     DoSpawnCreature(19412,0,0,0,0, TEMPSUMMON_TIMED_DESPAWN, 600000);
 }
コード例 #15
0
ファイル: boss_kormok.cpp プロジェクト: LORDofDOOM/MMOTBC
 void SummonMinions(Unit* victim)
 {
     if (Creature *SummonedMinion = DoSpawnCreature(16119, irand(-7,7), irand(-7,7), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 120000))
         SummonedMinion->AI()->AttackStart(victim);
 }
コード例 #16
0
 void SummonSpirits(Unit* victim)
 {
     if (Creature *Spirit = DoSpawnCreature(9178, RAND(irand(0,-9),irand(0,9)), RAND(irand(0,-9),irand(0,9)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 60000))
         Spirit->AI()->AttackStart(victim);
 }
コード例 #17
0
ファイル: boss_kormok.cpp プロジェクト: LORDofDOOM/MMOTBC
 void SummonMages(Unit* victim)
 {
     if (Creature *SummonedMage = DoSpawnCreature(16120, irand(-9,9), irand(-9,9), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 120000))
         SummonedMage->AI()->AttackStart(victim);
 }
コード例 #18
0
 void RaiseUndeadScarab(Unit* victim)
 {
     if (Creature* pUndeadScarab = DoSpawnCreature(10876, float(irand(-9, 9)), float(irand(-9, 9)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 180000))
         if (pUndeadScarab->AI())
             pUndeadScarab->AI()->AttackStart(victim);
 }
コード例 #19
0
 void SummonIllusions(Unit* victim)
 {
     if (Creature *Illusion = DoSpawnCreature(11439, irand(-9,9), irand(-9,9), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 60000))
         Illusion->AI()->AttackStart(victim);
 }
コード例 #20
0
        void UpdateAI(const uint32 diff)
        {
            if (!me->isInCombat())
            {
                if (instance)
                {
                    // Do not let the raid skip straight to Archimonde. Visible and hostile ONLY if Azagalor is finished.
                    if ((instance->GetData(DATA_AZGALOREVENT) < DONE) && (me->IsVisible() || (me->getFaction() != 35)))
                    {
                        me->SetVisible(false);
                        me->setFaction(35);
                    }
                    else if ((instance->GetData(DATA_AZGALOREVENT) >= DONE) && (!me->IsVisible() || (me->getFaction() == 35)))
                    {
                        me->setFaction(1720);
                        me->SetVisible(true);
                    }
                }

                if (DrainNordrassilTimer <= diff)
                {
                    if (!IsChanneling)
                    {
                        Creature* temp = me->SummonCreature(CREATURE_CHANNEL_TARGET, NordrassilLoc, TEMPSUMMON_TIMED_DESPAWN, 1200000);

                        if (temp)
                            WorldTreeGUID = temp->GetGUID();

                        if (Unit* Nordrassil = Unit::GetUnit(*me, WorldTreeGUID))
                        {
                            Nordrassil->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                            Nordrassil->SetDisplayId(11686);
                            DoCast(Nordrassil, SPELL_DRAIN_WORLD_TREE);
                            IsChanneling = true;
                        }
                    }

                    if (Unit* Nordrassil = Unit::GetUnit(*me, WorldTreeGUID))
                    {
                        Nordrassil->CastSpell(me, SPELL_DRAIN_WORLD_TREE_2, true);
                        DrainNordrassilTimer = 1000;
                    }
                } else DrainNordrassilTimer -= diff;
            }

            if (!UpdateVictim())
                return;

            if (me->HealthBelowPct(10) && !BelowTenPercent && !Enraged)
				// Evita que salgan add y que tire el dedo de la muerte para que se puedan sacar el logro.
                //BelowTenPercent = true;

            if (!Enraged)
            {
                if (EnrageTimer <= diff)
                {
                    if (HealthAbovePct(10))
                    {
                        me->GetMotionMaster()->Clear(false);
                        me->GetMotionMaster()->MoveIdle();
                        Enraged = true;
                        Talk(SAY_ENRAGE);
                    }
                } else EnrageTimer -= diff;

                if (CheckDistanceTimer <= diff)
                {
                    // To simplify the check, we simply summon a Creature in the location and then check how far we are from the creature
                    Creature* Check = me->SummonCreature(CREATURE_CHANNEL_TARGET, NordrassilLoc, TEMPSUMMON_TIMED_DESPAWN, 2000);
                    if (Check)
                    {
                        Check->SetVisible(false);

                        if (me->IsWithinDistInMap(Check, 75))
                        {
                            me->GetMotionMaster()->Clear(false);
                            me->GetMotionMaster()->MoveIdle();
                            Enraged = true;
                            Talk(SAY_ENRAGE);
                        }
                    }
                    CheckDistanceTimer = 5000;
                } else CheckDistanceTimer -= diff;
            }

            if (BelowTenPercent)
            {
                if (!HasProtected)
                {
                    me->GetMotionMaster()->Clear(false);
                    me->GetMotionMaster()->MoveIdle();

                    //all members of raid must get this buff
                    DoCastVictim(SPELL_PROTECTION_OF_ELUNE, true);
                    HasProtected = true;
                    Enraged = true;
                }

                if (SummonWispTimer <= diff)
                {
                    DoSpawnCreature(CREATURE_ANCIENT_WISP, float(rand()%40), float(rand()%40), 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
                    SummonWispTimer = 1500;
                    ++WispCount;
                } else SummonWispTimer -= diff;

                if (WispCount >= 30)
                    me->DealDamage(me, me->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
            }

            if (Enraged)
            {
                if (HandOfDeathTimer <= diff)
                {
                    DoCast(me->getVictim(), SPELL_HAND_OF_DEATH);
                    HandOfDeathTimer = 2000;
                } else HandOfDeathTimer -= diff;
                return;                                         // Don't do anything after this point.
            }

            if (SoulChargeCount)
            {
                if (SoulChargeTimer <= diff)
                    UnleashSoulCharge();
                else SoulChargeTimer -= diff;
            }

            if (GripOfTheLegionTimer <= diff)
            {
                DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0), SPELL_GRIP_OF_THE_LEGION);
                GripOfTheLegionTimer = urand(5000, 25000);
            } else GripOfTheLegionTimer -= diff;

            if (AirBurstTimer <= diff)
            {
                Talk(SAY_AIR_BURST);
                DoCast(SelectTarget(SELECT_TARGET_RANDOM, 1), SPELL_AIR_BURST);//not on tank
                AirBurstTimer = urand(25000, 40000);
            } else AirBurstTimer -= diff;

            if (FearTimer <= diff)
            {
                DoCast(me->getVictim(), SPELL_FEAR);
                FearTimer = 42000;
            } else FearTimer -= diff;

            if (DoomfireTimer <= diff)
            {
                Talk(SAY_DOOMFIRE);
                Unit* temp = SelectTarget(SELECT_TARGET_RANDOM, 1);
                if (!temp)
                    temp = me->getVictim();

                //replace with spell cast 31903 once implicitTarget 73 implemented
                SummonDoomfire(temp);

                //supposedly three doomfire can be up at the same time
                DoomfireTimer = 20000;
            } else DoomfireTimer -= diff;

            if (MeleeRangeCheckTimer <= diff)
            {
                if (CanUseFingerOfDeath())
                {
                    DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0), SPELL_FINGER_OF_DEATH);
                    MeleeRangeCheckTimer = 1000;
                }

                MeleeRangeCheckTimer = 5000;
            } else MeleeRangeCheckTimer -= diff;

            DoMeleeAttackIfReady();
        }
コード例 #21
0
ファイル: boss_noxxion.cpp プロジェクト: xiaofeng2009/TC2
 void SummonAdds(Unit* pVictim)
 {
     if (Creature *Add = DoSpawnCreature(13456, RAND(irand(0,-7),irand(0,7)), RAND(irand(0,-7),irand(0,7)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 90000))
         Add->AI()->AttackStart(pVictim);
 }
コード例 #22
0
        void UpdateAI(const uint32 diff)
        {
            if (!Phase)
                return;

            if (me->getThreatManager().getThreatList().empty()) // Reset if event is begun and we don't have a threatlist
            {
                EnterEvadeMode();
                return;
            }

            Creature* Essence = NULL;
            if (EssenceGUID)
            {
                Essence = Unit::GetCreature(*me, EssenceGUID);
                if (!Essence)
                {
                    EnterEvadeMode();
                    return;
                }
            }

            if (Timer <= diff)
            {
                switch(Counter)
                {
                case 0:
                    me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_READY2H);  // I R ANNNGRRRY!
                    DoStartNoMovement(me);
                    Timer = 3000;
                    break;
                case 1:
                    Timer = 2800;
                    me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_SUBMERGE);  // Release the cube
                    DoCast(me, SPELL_SUBMERGE);
                    DoStartNoMovement(me);
                    break;
                case 2:
                    Timer = 5000;
                    if (Creature* Summon = DoSpawnCreature(23417+Phase, 0, 0, 0, 0, TEMPSUMMON_DEAD_DESPAWN, 0))
                    {
                        me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_SUBMERGED);  // Ribs: open
                        Summon->AI()->AttackStart(SelectUnit(SELECT_TARGET_TOPAGGRO, 0));
                        EssenceGUID = Summon->GetGUID();
                        DoStartNoMovement(me);
                    } else EnterEvadeMode();
                    break;
                case 3:
                    Timer = 1000;
                    if (Phase == 3)
                    {
                        if (!Essence->isAlive())
                            DoCast(me, 7, true);
                        else return;
                    }
                    else
                    {
                        if (Essence->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))
                        {
                            MergeThreatList(Essence);
                            Essence->RemoveAllAuras();
                            Essence->DeleteThreatList();
                            Essence->GetMotionMaster()->MoveFollow(me, 0.0f, 0.0f);
                        } else return;
                    }
                    break;
                case 4:
                    Timer = 1500;
                    if (Essence->IsWithinDistInMap(me, 10))
                    {
                        Essence->SetUInt32Value(UNIT_NPC_EMOTESTATE, 374); //rotate and disappear
                        Timer = 2000;
                        me->RemoveAurasDueToSpell(SPELL_SUBMERGE);
                    }
                    else
                    {
                        MergeThreatList(Essence);
                        Essence->RemoveAllAuras();
                        Essence->DeleteThreatList();
                        Essence->GetMotionMaster()->MoveFollow(me, 0, 0);
                        return;
                    }
                    break;
                case 5:
                    if (Phase == 1)
                    {
                        DoScriptText(SUFF_SAY_AFTER, Essence);
                    }
                    else
                    {
                        DoScriptText(DESI_SAY_AFTER, Essence);
                    }
                    Essence->ForcedDespawn();
                    me->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
                    EssenceGUID = 0;
                    SoulCount = 0;
                    SoulDeathCount = 0;
                    Timer = 3000;
                    break;
                case 6:
                    if (SoulCount < NUMBER_ENSLAVED_SOUL)
                    {
                        if (SummonSoul())
                            ++SoulCount;
                        Timer = 500;
                        return;
                    }
                    break;
                case 7:
                    if (SoulDeathCount >= SoulCount)
                    {
                        Counter = 1;
                        ++Phase;
                        Timer = 5000;
                    }
                    return;
                default:
                    break;
                }
                ++Counter;
            } else Timer -= diff;
        }
コード例 #23
0
    void UpdateAI(const uint32 diff)
    {
        if (!UpdateVictim())
            return;

        //always decrease BerserkTimer
        if (BerserkTimer < diff)
        {
            //if evocate, then break evocate
            if (Evocating)
            {
                if (m_creature->HasAura(SPELL_EVOCATION))
                    m_creature->RemoveAurasDueToSpell(SPELL_EVOCATION);

                Evocating = false;
            }

            //may not be correct SAY (generic hard enrage)
            DoScriptText(SAY_ENRAGE, m_creature);

            m_creature->InterruptNonMeleeSpells(true);
            DoCast(m_creature, SPELL_BERSERK);

            //don't know if he's supposed to do summon/evocate after hard enrage (probably not)
            Enraged = true;
        }else BerserkTimer -= diff;

        if (Evocating)
        {
            //not supposed to do anything while evocate
            if (m_creature->HasAura(SPELL_EVOCATION))
                return;
            else
                Evocating = false;
        }

        if (!Enraged)
        {
            if (AddTimer < diff)
            {
                //Summon Astral Flare
                Creature* AstralFlare = DoSpawnCreature(17096, rand()%37, rand()%37, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
                Unit* target = NULL;
                target = SelectUnit(SELECT_TARGET_RANDOM, 0);

                if (AstralFlare && target)
                {
                    AstralFlare->CastSpell(AstralFlare, SPELL_ASTRAL_FLARE_PASSIVE, false);
                    AstralFlare->AI()->AttackStart(target);
                }

                //Reduce Mana by 10% of max health
                if (int32 mana = m_creature->GetMaxPower(POWER_MANA))
                {
                    mana /= 10;
                    m_creature->ModifyPower(POWER_MANA, -mana);

                    //if this get's us below 10%, then we evocate (the 10th should be summoned now)
                    if (m_creature->GetPower(POWER_MANA)*100 / m_creature->GetMaxPower(POWER_MANA) < 10)
                    {
                        DoScriptText(SAY_EVOCATE, m_creature);
                        m_creature->InterruptNonMeleeSpells(false);
                        DoCast(m_creature, SPELL_EVOCATION);
                        Evocating = true;
                        //no AddTimer cooldown, this will make first flare appear instantly after evocate end, like expected
                        return;
                    }
                    else
                    {
                        if(urand(0,1) == 0)
                        {
                            DoScriptText(RAND(SAY_SUMMON1,SAY_SUMMON2), m_creature);
                        }
                    }
                }

                AddTimer = 10000;
            }else AddTimer -= diff;

            if (m_creature->GetHealth()*100 / m_creature->GetMaxHealth() <= 15)
            {
                Enraged = true;
                DoCast(m_creature, SPELL_ENRAGE);
                DoScriptText(SAY_ENRAGE, m_creature);
            }
        }

        if (HatefulBoltTimer < diff)
        {
            if (Enraged)
                HatefulBoltTimer = 7000;
            else
                HatefulBoltTimer = 15000;

            if (Unit* target = SelectUnit(SELECT_TARGET_TOPAGGRO, 1))
                DoCast(target, SPELL_HATEFUL_BOLT);

        }else HatefulBoltTimer -= diff;

        DoMeleeAttackIfReady();
    }
コード例 #24
0
        void UpdateAI(const uint32 diff)
        {
            if (!me->isInCombat()) // sometimes isincombat but !incombat, faction bug?
                return;

            if (Berserk_Timer <= diff)
            {
                DoCast(me, SPELL_BERSERK, true);
                Berserk_Timer = 60000;
            }
            else
                Berserk_Timer -= diff;

            if (ForceMove)
            {
                if (ForceTimer <= diff)
                {
                    me->GetMotionMaster()->MovePoint(0, waypoint[cur_wp][0], waypoint[cur_wp][1], waypoint[cur_wp][2]);
                    ForceTimer = 5000;
                }
                else
                    ForceTimer -= diff;
            }
            if (WaitEvent)
            {
                if (WaitTimer)
                {
                    if (WaitTimer <= diff)
                    {
                        if (AfterMoving)
                        {
                            me->GetMotionMaster()->MoveIdle();
                            AfterMoving = false;
                        }

                        switch(WaitEvent)
                        {
                        case WE_PLATFORM:
                            Platforms_Move_Timer = 30000+rand()%5000;
                            break;
                        case WE_QUILL:
                            DoCast(me, SPELL_FLAME_QUILLS, true);
                            Platforms_Move_Timer = 1;
                            WaitTimer = 10000;
                            WaitEvent = WE_DUMMY;
                            return;
                        case WE_DIE:
                            ForceMove = false;
                            me->SetUInt32Value(UNIT_FIELD_BYTES_1, UNIT_STAND_STATE_DEAD);
                            WaitTimer = 5000;
                            WaitEvent = WE_REVIVE;
                            return;
                        case WE_REVIVE:
                            me->SetUInt32Value(UNIT_FIELD_BYTES_1, UNIT_STAND_STATE_STAND);
                            me->SetFullHealth();
                            me->SetSpeed(MOVE_RUN, DefaultMoveSpeedRate);
                            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                            DoZoneInCombat();
                            DoCast(me, SPELL_REBIRTH, true);
                            MeltArmor_Timer = 60000;
                            Charge_Timer = 7000;
                            DiveBomb_Timer = 40000+rand()%5000;
                            FlamePatch_Timer = 30000;
                            Phase1 = false;
                            break;
                        case WE_METEOR:
                            me->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FIRE, false);
                            DoCast(me, SPELL_DIVE_BOMB_VISUAL, false);
                            WaitEvent = WE_DIVE;
                            WaitTimer = 4000;
                            return;
                        case WE_DIVE:
                            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
                            {
                                me->RemoveAurasDueToSpell(SPELL_DIVE_BOMB_VISUAL);
                                DoCast(pTarget, SPELL_DIVE_BOMB, true);
                                float dist = 3.0f;
                                if (me->IsWithinDist3d(pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 5.0f))
                                    dist = 5.0f;
                                WaitTimer = 1000 + uint32(floor(dist / 80 * 1000.0f));
                                me->GetMap()->CreatureRelocation(me, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 0.0f);
                                me->StopMoving();
                                WaitEvent = WE_LAND;
                            }
                            else
                            {
                                EnterEvadeMode();
                                return;
                            }
                        case WE_LAND:
                            WaitEvent = WE_SUMMON;
                            WaitTimer = 2000;
                            return;
                        case WE_SUMMON:
                            for (uint8 i = 0; i < 2; ++i)
                                DoSpawnCreature(CREATURE_EMBER_OF_ALAR, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
                            me->SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, 10);
                            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                            me->SetDisplayId(me->GetNativeDisplayId());
                            DoCast(me, SPELL_REBIRTH_2, true);
                            break;
                        case WE_DUMMY:
                        default:
                            break;
                        }

                        WaitEvent = WE_NONE;
                        WaitTimer = 0;
                    }
                    else
                        WaitTimer -= diff;
                }
                return;
            }

            if (Phase1)
            {
                if (me->getThreatManager().getThreatList().empty())
                {
                    EnterEvadeMode();
                    return;
                }

                if (Platforms_Move_Timer <= diff)
                {
                    if (cur_wp == 4)
                    {
                        cur_wp = 0;
                        WaitEvent = WE_PLATFORM;
                    }
                    else
                    {
                        if (urand(0, 4)) // next platform
                        {
                            DoSpawnCreature(CREATURE_EMBER_OF_ALAR, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
                            if (cur_wp == 3)
                                cur_wp = 0;
                            else
                                ++cur_wp;
                            WaitEvent = WE_PLATFORM;
                        }
                        else // flame quill
                        {
                            cur_wp = 4;
                            WaitEvent = WE_QUILL;
                        }
                    }
                    ForceMove = true;
                    ForceTimer = 5000;
                    me->GetMotionMaster()->MovePoint(0, waypoint[cur_wp][0], waypoint[cur_wp][1], waypoint[cur_wp][2]);
                    WaitTimer = 0;
                    return;
                }
                else
                    Platforms_Move_Timer -= diff;
            }
            else
            {
                if (Charge_Timer <= diff)
                {
                    Unit *pTarget= SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true);
                    if (pTarget)
                        DoCast(pTarget, SPELL_CHARGE);
                    Charge_Timer = 30000;
                }
                else
                    Charge_Timer -= diff;

                if (MeltArmor_Timer <= diff)
                {
                    DoCast(me->getVictim(), SPELL_MELT_ARMOR);
                    MeltArmor_Timer = 60000;
                }
                else
                    MeltArmor_Timer -= diff;

                if (DiveBomb_Timer <= diff)
                {
                    me->AttackStop();
                    me->GetMotionMaster()->MovePoint(6, waypoint[4][0], waypoint[4][1], waypoint[4][2]);
                    me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                    me->SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, 50);
                    WaitEvent = WE_METEOR;
                    WaitTimer = 0;
                    DiveBomb_Timer = 40000+rand()%5000;
                    return;
                }
                else
                    DiveBomb_Timer -= diff;

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

            DoMeleeAttackIfReady();
        }
コード例 #25
0
        void ExecuteEvent(uint32 eventId) override
        {
            switch (eventId)
            {
                case EVENT_HAND_OF_DEATH:
                    DoCastAOE(SPELL_HAND_OF_DEATH);
                    events.ScheduleEvent(EVENT_HAND_OF_DEATH, 2000);
                    break;
                case EVENT_UNLEASH_SOUL_CHARGE:
                    _chargeSpell = 0;
                    _unleashSpell = 0;
                    me->InterruptNonMeleeSpells(false);
                    switch (urand(0, 2))
                    {
                        case 0:
                            _chargeSpell = SPELL_SOUL_CHARGE_RED;
                            _unleashSpell = SPELL_UNLEASH_SOUL_RED;
                            break;
                        case 1:
                            _chargeSpell = SPELL_SOUL_CHARGE_YELLOW;
                            _unleashSpell = SPELL_UNLEASH_SOUL_YELLOW;
                            break;
                        case 2:
                            _chargeSpell = SPELL_SOUL_CHARGE_GREEN;
                            _unleashSpell = SPELL_UNLEASH_SOUL_GREEN;
                            break;
                    }

                    if (me->HasAura(_chargeSpell))
                    {
                        me->RemoveAuraFromStack(_chargeSpell);
                        DoCastVictim(_unleashSpell);
                        SoulChargeCount--;
                        events.ScheduleEvent(EVENT_UNLEASH_SOUL_CHARGE, urand(2000, 30000));
                    }
                    break;
                case EVENT_FINGER_OF_DEATH:
                    if (!SelectTarget(SELECT_TARGET_RANDOM, 0, 5.0f)) // Checks if there are no targets in melee range
                    {
                        DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0), SPELL_FINGER_OF_DEATH);
                        events.ScheduleEvent(EVENT_FINGER_OF_DEATH, 1000);
                    }
                    else
                        events.ScheduleEvent(EVENT_FINGER_OF_DEATH, 5000);
                    break;
                case EVENT_GRIP_OF_THE_LEGION:
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                        DoCast(target, SPELL_GRIP_OF_THE_LEGION);
                    events.ScheduleEvent(EVENT_GRIP_OF_THE_LEGION, urand(5000, 25000));
                    break;
                case EVENT_AIR_BURST:
                    Talk(SAY_AIR_BURST);
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1))
                        DoCast(target, SPELL_AIR_BURST); //not on tank
                    events.ScheduleEvent(EVENT_AIR_BURST, urand(25000, 40000));
                    break;
                case EVENT_FEAR:
                    DoCastAOE(SPELL_FEAR);
                    events.ScheduleEvent(EVENT_FEAR, 42000);
                    break;
                case EVENT_DOOMFIRE:
                    Talk(SAY_DOOMFIRE);
                    if (Unit* temp = SelectTarget(SELECT_TARGET_RANDOM, 1))
                        SummonDoomfire(temp);
                    else
                        SummonDoomfire(me->GetVictim());
                    events.ScheduleEvent(EVENT_DOOMFIRE, 20000);
                    break;
                case EVENT_DISTANCE_CHECK:
                    if (Creature* channelTrigger = instance->GetCreature(DATA_CHANNEL_TARGET))
                        if (me->IsWithinDistInMap(channelTrigger, 75.0f))
                            DoAction(ACTION_ENRAGE);
                    events.ScheduleEvent(EVENT_DISTANCE_CHECK, 5000);
                    break;
                case EVENT_SUMMON_WHISP:
                    DoSpawnCreature(NPC_ANCIENT_WISP, float(rand32() % 40), float(rand32() % 40), 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
                    ++WispCount;
                    if (WispCount >= 30)
                        me->DealDamage(me, me->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
                    events.ScheduleEvent(EVENT_SUMMON_WHISP, 1500);
                    break;
                default:
                    break;
            }
        }
コード例 #26
0
ファイル: boss_archimonde.cpp プロジェクト: Bearq/scriptdev2
    void UpdateAI(const uint32 diff)
    {
        if (!m_creature->isInCombat())
        {
            if (m_pInstance)
            {
                // Do not let the raid skip straight to Archimonde. Visible and hostile ONLY if Azagalor is finished.
                if ((m_pInstance->GetData(TYPE_AZGALOR) < DONE) && ((m_creature->GetVisibility() != VISIBILITY_OFF) || (m_creature->getFaction() != 35)))
                {
                    m_creature->SetVisibility(VISIBILITY_OFF);
                    m_creature->setFaction(35);
                }
                else if ((m_pInstance->GetData(TYPE_AZGALOR) >= DONE) && ((m_creature->GetVisibility() != VISIBILITY_ON) || (m_creature->getFaction() == 35)))
                {
                    m_creature->setFaction(1720);
                    m_creature->SetVisibility(VISIBILITY_ON);
                }
            }

            if (DrainNordrassilTimer < diff)
            {
                if (!IsChanneling)
                {
                    Creature *temp = m_creature->SummonCreature(CREATURE_CHANNEL_TARGET, NORDRASSIL_X, NORDRASSIL_Y, NORDRASSIL_Z, 0.0f, TEMPSUMMON_TIMED_DESPAWN, 1200000);

                    if (temp)
                        m_worldTreeGuid = temp->GetObjectGuid();

                    if (Creature *Nordrassil = m_creature->GetMap()->GetCreature(m_worldTreeGuid))
                    {
                        Nordrassil->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                        Nordrassil->SetDisplayId(11686);
                        DoCastSpellIfCan(Nordrassil, SPELL_DRAIN_WORLD_TREE);
                        IsChanneling = true;
                    }
                }

                if (Creature *Nordrassil = m_creature->GetMap()->GetCreature(m_worldTreeGuid))
                {
                    Nordrassil->CastSpell(m_creature, SPELL_DRAIN_WORLD_TREE_2, true);
                    DrainNordrassilTimer = 1000;
                }
            }else DrainNordrassilTimer -= diff;
        }

        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        if (m_creature->GetHealthPercent() < 10.0f && !BelowTenPercent && !Enraged)
            BelowTenPercent = true;

        if (!Enraged)
        {
            if (EnrageTimer < diff)
            {
                if (m_creature->GetHealthPercent() > 10.0f)
                {
                    m_creature->GetMotionMaster()->Clear(false);
                    m_creature->GetMotionMaster()->MoveIdle();
                    Enraged = true;
                    DoScriptText(SAY_ENRAGE, m_creature);
                }
            }else EnrageTimer -= diff;

            if (CheckDistanceTimer < diff)
            {
                // To simplify the check, we simply summon a creature in the location and then check how far we are from the creature
                Creature* Check = m_creature->SummonCreature(CREATURE_CHANNEL_TARGET, NORDRASSIL_X, NORDRASSIL_Y, NORDRASSIL_Z, 0, TEMPSUMMON_TIMED_DESPAWN, 2000);
                if (Check)
                {
                    Check->SetVisibility(VISIBILITY_OFF);

                    if (m_creature->IsWithinDistInMap(Check, 75))
                    {
                        m_creature->GetMotionMaster()->Clear(false);
                        m_creature->GetMotionMaster()->MoveIdle();
                        Enraged = true;
                        DoScriptText(SAY_ENRAGE, m_creature);
                    }
                }
                CheckDistanceTimer = 5000;
            }else CheckDistanceTimer -= diff;
        }

        if (BelowTenPercent)
        {
            if (!HasProtected)
            {
                m_creature->GetMotionMaster()->Clear(false);
                m_creature->GetMotionMaster()->MoveIdle();

                //all members of raid must get this buff
                DoCastSpellIfCan(m_creature->getVictim(), SPELL_PROTECTION_OF_ELUNE);
                HasProtected = true;
                Enraged = true;
            }

            if (SummonWispTimer < diff)
            {
                DoSpawnCreature(CREATURE_ANCIENT_WISP, rand()%40, rand()%40, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
                SummonWispTimer = 1500;
                ++WispCount;
            }else SummonWispTimer -= diff;

            if (WispCount >= 30)
                m_creature->DealDamage(m_creature, m_creature->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
        }

        if (Enraged)
        {
            if (HandOfDeathTimer < diff)
            {
                DoCastSpellIfCan(m_creature->getVictim(), SPELL_HAND_OF_DEATH);
                HandOfDeathTimer = 2000;
            }else HandOfDeathTimer -= diff;
            return;                                         // Don't do anything after this point.
        }

        if (GripOfTheLegionTimer < diff)
        {
            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
                DoCastSpellIfCan(pTarget, SPELL_GRIP_OF_THE_LEGION);

            GripOfTheLegionTimer = urand(5000, 25000);
        }else GripOfTheLegionTimer -= diff;

        if (AirBurstTimer < diff)
        {
            if (!urand(0, 1))
                DoScriptText(SAY_AIR_BURST1, m_creature);
            else
                DoScriptText(SAY_AIR_BURST2, m_creature);

            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 1))
            DoCastSpellIfCan(pTarget, SPELL_AIR_BURST);
            AirBurstTimer = urand(25000, 40000);
        }else AirBurstTimer -= diff;

        if (FearTimer < diff)
        {
            DoCastSpellIfCan(m_creature->getVictim(), SPELL_FEAR);
            FearTimer = 42000;
        }else FearTimer -= diff;

        if (DoomfireTimer < diff)
        {
            if (!urand(0, 1))
                DoScriptText(SAY_DOOMFIRE1, m_creature);
            else
                DoScriptText(SAY_DOOMFIRE2, m_creature);

            Unit *temp = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 1);
            if (!temp)
                temp = m_creature->getVictim();

            //replace with spell cast 31903 once implicitTarget 73 implemented
            SummonDoomfire(temp);

            //supposedly three doomfire can be up at the same time
            DoomfireTimer = 20000;
        }else DoomfireTimer -= diff;

        if (MeleeRangeCheckTimer < diff)
        {
            if (CanUseFingerOfDeath())
            {
                if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
                DoCastSpellIfCan(pTarget, SPELL_FINGER_OF_DEATH);

                MeleeRangeCheckTimer = 1000;
            }

            MeleeRangeCheckTimer = 5000;
        }else MeleeRangeCheckTimer -= diff;

        DoMeleeAttackIfReady();
    }
コード例 #27
0
    void UpdateAI(const uint32 diff)
    {
        //Only if not incombat check if the event is started
        if (!me->isInCombat() && pInstance && pInstance->GetData(DATA_KARATHRESSEVENT))
        {
            Unit *pTarget = Unit::GetUnit((*me), pInstance->GetData64(DATA_KARATHRESSEVENT_STARTER));

            if (pTarget)
            {
                AttackStart(pTarget);
            }
        }

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

        //someone evaded!
        if (pInstance && !pInstance->GetData(DATA_KARATHRESSEVENT))
        {
            EnterEvadeMode();
            return;
        }

        //LeechingThrow_Timer
        if (LeechingThrow_Timer <= diff)
        {
            DoCast(me->getVictim(), SPELL_LEECHING_THROW);
            LeechingThrow_Timer = 20000;
        } else LeechingThrow_Timer -= diff;

        //Multishot_Timer
        if (Multishot_Timer <= diff)
        {
            DoCast(me->getVictim(), SPELL_MULTISHOT);
            Multishot_Timer = 20000;
        } else Multishot_Timer -= diff;

        //TheBeastWithin_Timer
        if (TheBeastWithin_Timer <= diff)
        {
            DoCast(me, SPELL_THE_BEAST_WITHIN);
            Creature *Pet = Unit::GetCreature(*me, SummonedPet);
            if (Pet && Pet->isAlive())
            {
                Pet->CastSpell(Pet, SPELL_PET_ENRAGE, true);
            }
            TheBeastWithin_Timer = 30000;
        } else TheBeastWithin_Timer -= diff;

        //Pet_Timer
        if (Pet_Timer <= diff && pet == false)
        {
            pet = true;
            //uint32 spell_id;
            uint32 pet_id = rand()%2;
            switch(pet_id)
            {
            case 0:
                //spell_id = SPELL_SUMMON_FATHOM_LURKER;
                pet_id = CREATURE_FATHOM_LURKER;
                break;
            case 1:
                //spell_id = SPELL_SUMMON_FATHOM_SPOREBAT;
                pet_id = CREATURE_FATHOM_SPOREBAT;
                break;
            }
            //DoCast(me, spell_id, true);
            Creature *Pet = DoSpawnCreature(pet_id,0,0,0,0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
            Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0);
            if (Pet && pTarget)
            {
                Pet->AI()->AttackStart(pTarget);
                SummonedPet = Pet->GetGUID();
            }
        } else Pet_Timer -= diff;

        DoMeleeAttackIfReady();
    }