Exemple #1
0
 void doBeacon(bool command = false)
 {
     if (command)
     {
          for(uint8 i = 0; i < getSpellData(SPELL_BEACON); ++i)
          {
             if (Unit* pTarget = doSelectRandomPlayer(SPELL_BEACON, false, 100.0f))
             {
                 if (doCast(SPELL_BEACON, pTarget) == CAST_OK)
                     marked[i] = pTarget;
                 else marked[i] = NULL;
             }
          }
          conflagated = true;
     }
     else
     {
          m_creature->InterruptNonMeleeSpells(true);
          for(uint8 i = 0; i < getSpellData(SPELL_BEACON); ++i)
          {
             if (marked[i])
                 doCast(SPELL_CONFLAGATION_2, marked[i]);
             marked[i] = NULL;
          }
          doCast(SPELL_CONFLAGATION_1);
          conflagated = false;
     }
 }
    void doSearchSpored()
    {
         Unit* searched = doSelectRandomPlayer(SPELL_SPORE_AURA_1, true, 80.0f);

         if (!searched) return;

         bool exist = false;

         for(uint8 i = 0; i < MAX_SPORE_TARGETS; ++i)
             if (spored[i])
                if (spored[i] = searched)
                {
                    exist = true;
                    break;
                }

         if (exist) return;

         for(uint8 i = 0; i < MAX_SPORE_TARGETS; ++i)
             if (!spored[i])
             {
                 spored[i] = searched;
                 break;
             }
    }
Exemple #3
0
    void UpdateAI(const uint32 diff)
    {

    if(!pInstance) return;

    if (!pet)
    {
        if (Creature* pGuard = m_creature->GetMap()->GetCreature(pInstance->GetData64(NPC_PRECIOUS)))
            if (!pGuard->isAlive())
            {
                 pet = true;
                 if (pInstance->GetData(TYPE_PRECIOUS) == NOT_STARTED)
                 {
                     DoScriptText(-1631228,m_creature);
                     pInstance->SetData(TYPE_PRECIOUS,DONE);
                 }
            }
    }

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

        if (nexttick)
              {
                  doCast(SPELL_OOZE_FLOOD_1);
                  DoScriptText(-1631227,m_creature);
                  nexttick = false;
              };

        if (timedQuery(SPELL_OOZE_FLOOD_1, diff))
              {
                   uint8 i = urand(0,3);
                   if (Unit* pTemp = doSummon(NPC_OOZE_STALKER,SpawnLoc[i].x, SpawnLoc[i].y, SpawnLoc[i].z, TEMPSUMMON_TIMED_DESPAWN, 15000))
                   {
                       doCast(SPELL_OOZE_FLOOD, pTemp);
                       nexttick = true;
                   }
              };

        if (timedQuery(SPELL_SLIME_SPRAY, diff))
            if (doSummon(NPC_OOZE_SPRAY_STALKER))
                doCast(SPELL_SLIME_SPRAY);

        if (timedQuery(SPELL_MUTATED_INFECTION, diff))
        {
            for(uint8 i = 0; i < getSpellData(SPELL_MUTATED_INFECTION); ++i)
                if (Unit* pTarget = doSelectRandomPlayer(SPELL_MUTATED_INFECTION_AURA, false, 60.0f))
                     doCast(SPELL_MUTATED_INFECTION, pTarget);
            DoScriptText(-1631226,m_creature);
        }

        if (timedQuery(SPELL_BERSERK, diff))
        {
            doCast(SPELL_BERSERK);
            DoScriptText(-1631225,m_creature);
        };

        DoMeleeAttackIfReady();
    }
    void Aggro(Unit *who)
    {
        if(!pInstance) return;
        pInstance->SetData(TYPE_LANATHEL, IN_PROGRESS);

        doCast(SPELL_SHROUD_OF_SORROW);

        DoScriptText(-1631321,m_creature,who);

        if (Unit* pTarget = doSelectRandomPlayer(SPELL_BLOOD_MIRROR_MARK, false, 100.0f))
        {
            if (doCast(SPELL_BLOOD_MIRROR_MARK,pTarget) == CAST_OK)
            {
                if (Unit* pTarget1 = doSelectRandomPlayer(SPELL_BLOOD_MIRROR_MARK, false, 100.0f))
                    pTarget->CastSpell(pTarget1,getSpellWithDifficulty(SPELL_BLOOD_MIRROR), true);
            };
        };

    }
    void Aggro(Unit *pWho) 
    {
        if (!pInstance) return;
        if (!pWho || pWho->GetTypeId() != TYPEID_PLAYER) 
            return;

        pInstance->SetData(TYPE_PUTRICIDE, IN_PROGRESS);
        DoScriptText(-1631249,m_creature, pWho);

        if (Unit* pTarget = doSelectRandomPlayer(SPELL_SHADOWS_EDGE, true, 100.0f))
            doAura(SHADOW_INFUSION_AURA,pTarget);
    }
    void JustSummoned(Creature* summoned)
    {
        if(!pInstance || !summoned) return;

        if ( summoned->GetEntry() == NPC_VOLATILE_OOZE
             || summoned->GetEntry() == NPC_GAS_CLOUD)
              if (Unit* pTarget = doSelectRandomPlayer())
                 {
                     summoned->SetInCombatWith(pTarget);
                     summoned->AddThreat(pTarget, 100.0f);
                 }

    }
    void Aggro(Unit* pWho)
    {
        if (!victimGUID && pWho && pWho->GetTypeId() == TYPEID_PLAYER)
        {
             if (pWho->HasAura(SPELL_ICY_TOMB))
             {
                 victimGUID = pWho->GetObjectGuid();
                 m_creature->SetInCombatWith(pWho);
             }
             else if (Unit* pTarget = doSelectRandomPlayer(SPELL_ICY_TOMB,true,3.0f))
             {
                 victimGUID = pTarget->GetObjectGuid();
                 m_creature->SetInCombatWith(pTarget);
             }

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

        switch(getStage())
        {
            case 0: 
                    if (timedQuery(SPELL_BONE_STRIKE, diff))
                        if (Unit* pTarget = doSelectRandomPlayer(SPELL_BONE_STRIKE_IMPALE, false, 60.0f))
                            if (doCast(SPELL_BONE_STRIKE, pTarget) == CAST_OK)
                            {
                                doSummonSpike(pTarget);
                                switch (urand(0,1)) {
                                                   case 0:
                                                   DoScriptText(-1631003,m_creature,pTarget);
                                                   break;
                                                   case 1:
                                                   DoScriptText(-1631004,m_creature,pTarget);
                                                   break;
                                                   case 2:
                                                   DoScriptText(-1631005,m_creature,pTarget);
                                                   break;
                                                   };

                            };

                    if (timedQuery(SPELL_BONE_STORM, diff)) setStage(1);

                    if (timedQuery(SPELL_CALL_COLD_FLAME, diff))
                    {
                        if (urand(0,1)) doCast(SPELL_CALL_COLD_FLAME);
                            else  doCast(SPELL_CALL_COLD_FLAME_1);

                        if (m_creature->GetHealthPercent() <= 30.0f)
                        {
                            if (urand(0,1)) doCast(SPELL_CALL_COLD_FLAME);
                                else  doCast(SPELL_CALL_COLD_FLAME_1);
                        }
                    }

                    timedCast(SPELL_SABER_LASH, diff);

                    DoMeleeAttackIfReady();

                    break;
            case 1:
                    m_creature->InterruptNonMeleeSpells(true);
                    doCast(SPELL_BONE_STORM);
                    setStage(2);
                    DoScriptText(-1631002,m_creature);
                    DoResetThreat();
                    m_creature->RemoveSplineFlag(SPLINEFLAG_WALKMODE);
                    m_creature->SetSpeedRate(MOVE_RUN, 3);
                    m_creature->SetSpeedRate(MOVE_WALK, 3);
                    break;
            case 2:
                    if (!m_creature->IsNonMeleeSpellCasted(false)) setStage(3);
                    break;
            case 3:
                    if (isHeroic())
                        if (timedQuery(SPELL_BONE_STRIKE, diff, true))
                            if (Unit* pTarget = doSelectRandomPlayer(SPELL_BONE_STRIKE_IMPALE, false, 60.0f))
                                doSummonSpike(pTarget);

                    if (timedQuery(SPELL_CALL_COLD_FLAME, diff, true)
                        && m_creature->IsWithinDistInMap(m_creature->getVictim(),2.0f))
                    {
                        pInstance->SetData(DATA_DIRECTION, (uint32)(1000*2.0f*M_PI_F*((float)urand(1,16)/16.0f)));
//                        if (urand(0,1)) doCast(SPELL_CALL_COLD_FLAME);
//                            else  doCast(SPELL_CALL_COLD_FLAME_1);
                        float fPosX, fPosY, fPosZ;
                        m_creature->GetPosition(fPosX, fPosY, fPosZ);
                        doSummon(NPC_COLD_FLAME, fPosX, fPosY, fPosZ);
                        DoResetThreat();
                        if (Unit* pTarget = doSelectRandomPlayerAtRange(60.0f))
                            AttackStart(pTarget);
                    }
                    if (!hasAura(SPELL_BONE_STORM_STRIKE, m_creature) && !hasAura(SPELL_BONE_STORM, m_creature)) setStage(4);
                    break;
            case 4:
                    pInstance->SetData(DATA_DIRECTION, 0);
                    m_creature->SetSpeedRate(MOVE_RUN, 1);
                    m_creature->SetSpeedRate(MOVE_WALK, 1);
//                    m_creature->AddSplineFlag(SPLINEFLAG_WALKMODE);
                    setStage(0);
                    break;
            default:
                    break;
            }

        if (timedQuery(SPELL_BERSERK, diff))
            {
                doCast(SPELL_BERSERK);
                DoScriptText(-1631008,m_creature);
            }


    }
    void UpdateAI(const uint32 diff)
    {
        if (pInstance->GetData(TYPE_EVENT_NPC) == NPC_PROFESSOR_PUTRICIDE)
        {
            UpdateTimer = pInstance->GetData(TYPE_EVENT_TIMER);
            if (UpdateTimer <= diff)
            {
            debug_log("EventMGR: creature %u received signal %u ",m_creature->GetEntry(),pInstance->GetData(TYPE_EVENT));
            switch (pInstance->GetData(TYPE_EVENT))
                {
                case 500:
                          m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                          m_creature->NearTeleportTo(SpawnLoc[1].x, SpawnLoc[1].y, SpawnLoc[1].z, SpawnLoc[1].o);
                          DoScriptText(-1631201, m_creature);
                          UpdateTimer = 60000;
                          pInstance->SetData(TYPE_EVENT,510);
                          break;
                case 510:
                          UpdateTimer = 5000;
                          if (pInstance->GetData(TYPE_FESTERGUT) == DONE)
                              pInstance->SetData(TYPE_EVENT,550);
                          if (pInstance->GetData(TYPE_FESTERGUT) == FAIL)
                              pInstance->SetData(TYPE_EVENT,630);
                          break;
                case 550:
                          DoScriptText(-1631202, m_creature);
                          UpdateTimer = 10000;
                          pInstance->SetData(TYPE_EVENT,630);
                          break;
                case 600:
                          m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                          m_creature->NearTeleportTo(SpawnLoc[2].x, SpawnLoc[2].y, SpawnLoc[2].z, SpawnLoc[2].o);
                          DoScriptText(-1631220, m_creature);
                          UpdateTimer = 60000;
                          pInstance->SetData(TYPE_EVENT,610);
                          break;
                case 610:
                          UpdateTimer = 5000;
                          if (pInstance->GetData(TYPE_ROTFACE) == DONE)
                              pInstance->SetData(TYPE_EVENT,620);
                          if (pInstance->GetData(TYPE_ROTFACE) == FAIL)
                              pInstance->SetData(TYPE_EVENT,630);
                          break;
                case 620:
                          DoScriptText(-1631202, m_creature);
                          UpdateTimer = 10000;
                          pInstance->SetData(TYPE_EVENT,630);
                          break;
                case 630:
                          m_creature->NearTeleportTo(SpawnLoc[0].x, SpawnLoc[0].y, SpawnLoc[0].z, SpawnLoc[0].o);
                          m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                          UpdateTimer = 2000;
                          pInstance->SetData(TYPE_EVENT,690);
                          break;
                default:
                          break;
                }
             } else UpdateTimer -= diff;
             pInstance->SetData(TYPE_EVENT_TIMER, UpdateTimer);
        }

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

        switch(stage)
        {
            case 0: 

                if (timedQuery(SPELL_UNSTABLE_EXPERIMENT, diff))
                    CallOoze();

                timedCast(SPELL_OOZE_THROW, diff);

                if (timedQuery(SPELL_MALLEABLE_GOO, diff))
                {
                    doCast(SPELL_MALLEABLE_GOO);
                }

                DoMeleeAttackIfReady();

                if (m_creature->GetHealthPercent() < 80.0f ) stage = 1;

                break;
            case 1: 
                m_creature->InterruptNonMeleeSpells(true);
                m_creature->AttackStop();
                SetCombatMovement(false);
                doCast(SPELL_TEAR_GAS_1);
                DoScriptText(-1631245,m_creature);
                StartMovement(0);
                stage = 2;
                break;
            case 2:
                if (movementstarted) return;
                doCast(SPELL_CREATE_CONCOCTION);
                stage = 3;
                break;
            case 3:
                if (m_creature->IsNonMeleeSpellCasted(true,false,false) ||
                    !doSelectRandomPlayer(SPELL_TEAR_GAS_1, false)) return;
                DoScriptText(-1631246,m_creature);
                m_creature->SetDisplayId(VIEW_2);
                m_creature->GetMotionMaster()->Clear();
                m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
                SetCombatMovement(true);
                stage = 4;
                break;
            case 4:
                if (timedQuery(SPELL_UNSTABLE_EXPERIMENT, diff))
                    CallOoze();

                if (timedQuery(SPELL_THROW_BOTTLE_1, diff))
                    switch(urand(0,2))
                {
                    case 0:
                        doCast(SPELL_THROW_BOTTLE_1);
                        break;
                    case 1:
                        doCast(SPELL_THROW_BOTTLE_2);
                        break;
                    case 2:
                        doCast(SPELL_THROW_BOTTLE_3);
                        break;
                    default: break;
                }

                timedCast(SPELL_OOZE_THROW, diff);

                timedCast(SPELL_MALLEABLE_GOO, diff);

                if (timedQuery(SPELL_MALLEABLE_GOO, diff))
                {
                    doCast(SPELL_MALLEABLE_GOO);
                }

                if (m_creature->GetDisplayId() != VIEW_2)
                    m_creature->SetDisplayId(VIEW_2);

                DoMeleeAttackIfReady();

                if (m_creature->GetHealthPercent() < 35.0f ) stage = 5;

                break;
            case 5:
                    m_creature->InterruptNonMeleeSpells(true);
                    m_creature->AttackStop();
                    SetCombatMovement(false);
                    doCast(SPELL_TEAR_GAS_1);
                    DoScriptText(-1631245,m_creature);
                    StartMovement(0);
                    stage = 6;
                    break;
            case 6:
                    if (movementstarted) return;
                    doCast(SPELL_GUZZLE_POTIONS);
                    stage = 7;
                    break;
            case 7:
                    if (m_creature->IsNonMeleeSpellCasted(true,false,false)) return;
                    if (m_creature->GetDisplayId() != VIEW_3)
                        m_creature->SetDisplayId(VIEW_3);
                    if (!doSelectRandomPlayer(SPELL_TEAR_GAS_1, false)) return;
                    DoScriptText(-1631247,m_creature);
                    m_creature->SetDisplayId(VIEW_3);
                    doCast(SPELL_MUTATED_STRENGTH);
                    m_creature->GetMotionMaster()->Clear();
                    m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
                    SetCombatMovement(true);
                    stage = 8;
                    break;
            case 8:
                    timedCast(SPELL_MUTATED_PLAGUE, diff);
                    if (m_creature->GetDisplayId() != VIEW_3)
                        m_creature->SetDisplayId(VIEW_3);
                    DoMeleeAttackIfReady();

                    break;
            default:
                    break;
            }

        if (timedQuery(SPELL_BERSERK, diff))
        {
            doCast(SPELL_BERSERK);
            DoScriptText(-1631244,m_creature);
        }
    }
Exemple #10
0
    void UpdateAI(const uint32 uiDiff)
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        if (m_creature->GetHealth() > m_pInstance->GetData(DATA_HEALTH_FJOLA) &&
                                      m_pInstance->GetData(DATA_HEALTH_FJOLA) != 0)
                m_creature->SetHealth(m_pInstance->GetData(DATA_HEALTH_FJOLA));

        switch (stage)
        {
        case 0:
            timedCast(SPELL_TWIN_SPIKE_H, uiDiff);

            if (timedQuery(SPELL_DARK_TOUCH, uiDiff))
            {
                if (currentDifficulty == RAID_DIFFICULTY_25MAN_HEROIC || RAID_DIFFICULTY_10MAN_HEROIC)
                    if (Unit* pTarget = doSelectRandomPlayer(SPELL_DARK_ESSENCE, false, 50.0f))
                        doCast(SPELL_DARK_TOUCH, pTarget);
                doCast(NPC_UNLEASHED_DARK);
            }
            if (m_pInstance->GetData(DATA_CASTING_VALKYRS) == SPELL_NONE )
            {
                if (timedQuery(SPELL_DARK_VORTEX, uiDiff))
                {
                    m_pInstance->SetData(DATA_CASTING_VALKYRS, SPELL_DARK_VORTEX);
                    DoScriptText(-1713540,m_creature);
                    stage = 1;
                    break;
                }
                if (timedQuery(SPELL_TWIN_PACT_H, uiDiff)
                    && m_creature->GetHealthPercent() <= 50.0f)
                {
                    m_creature->InterruptNonMeleeSpells(true);
                    doCast(SPELL_SHIELD_DARK);
                    m_pInstance->SetData(DATA_CASTING_VALKYRS, SPELL_TWIN_PACT_H);
                    DoScriptText(-1713539,m_creature);
                    stage = 3;
                    break;
                }
            }
            if (m_pInstance->GetData(DATA_CASTING_VALKYRS) == SPELL_TWIN_PACT_L)
                if (!m_creature->HasAura(SPELL_TWIN_POWER)) 
                    doCast(SPELL_TWIN_POWER);
            break;
        case 1:
            doCast(SPELL_DARK_VORTEX);
            stage = 2;
            break;
        case 2:
            if (!m_creature->HasAura(SPELL_DARK_VORTEX)
                && timedQuery(SPELL_SHIELD_DARK, uiDiff)) 
            {
                m_pInstance->SetData(DATA_CASTING_VALKYRS, SPELL_NONE);
                stage = 0;
            }
            break;
        case 3:
            doCast(SPELL_TWIN_PACT_H);
            stage = 4;
            break;
        case 4:
            if (!m_creature->HasAura(SPELL_SHIELD_DARK)
                && timedQuery(SPELL_SHIELD_DARK, uiDiff)) 
            {
                m_pInstance->SetData(DATA_CASTING_VALKYRS, SPELL_NONE);
                stage = 0;
            };
        default:
            break;
        }

        timedCast(SPELL_BERSERK, uiDiff);

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

        if (!m_creature->HasAura(SPELL_BLOOD_POWER))
            doCast(SPELL_BLOOD_POWER);

        switch (stage)
        {
            case 0:
                    if (m_creature->GetHealthPercent() <= 30.0f) stage = 1;
                    break;

            case 1: 
                        doCast(SPELL_FRENZY);
                        stage = 2;
                        DoScriptText(-1631101,m_creature);
                    break;

            case 2:
                    break;

            default:
                    break;
        }

            if (timedQuery(SPELL_MARK, diff))
            {
                if (Unit* pTarget = doSelectRandomPlayer(SPELL_MARK,false,120.0f))
                   if (doCast(SPELL_MARK, pTarget) == CAST_OK) 
                       doBloodPower();
            }

            if (timedCast(SPELL_BLOOD_NOVA, diff) == CAST_OK) doBloodPower();

            if (timedCast(SPELL_BOILING_BLOOD, diff) == CAST_OK) doBloodPower();

            if (timedCast(SPELL_RUNE_OF_BLOOD, diff) == CAST_OK) doBloodPower();

            if (timedQuery(SPELL_CALL_BLOOD_BEASTS, diff))
                    {
                        if (currentDifficulty == RAID_DIFFICULTY_25MAN_NORMAL
                            || currentDifficulty == RAID_DIFFICULTY_25MAN_HEROIC) beasts = 4;
                            else beasts = 2;

                        DoScriptText(-1631102,m_creature);
                     };

                     if (beasts > 0)
                        if (doCast(SPELL_CALL_BLOOD_BEASTS) == CAST_OK)
                           {
                               doBloodPower();
                               --beasts;
                           };

        if (timedQuery(SPELL_BERSERK, diff)){
                 doCast(SPELL_BERSERK);
                 DoScriptText(-1631108,m_creature);
                 };

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

        switch(getStage())
        {
            case 0: // Bone Slice and single Coldflames phase
            {
                if (timedQuery(SPELL_BONE_SPIKE, diff))
                {
                    if (Unit* pTarget = doSelectRandomPlayer(SPELL_BONE_SPIKE_IMPALE, false, 60.0f, isHeroic()))
                    {
                        doCast(pTarget, SPELL_BONE_SPIKE);
                        DoSummonSpike(pTarget);
                        DoScriptText(-1631003 - urand(0,2), m_creature, pTarget);
                    }
                }

                if (timedQuery(SPELL_BONE_STORM, diff))
                    setStage(1);

                if (timedQuery(SPELL_CALL_COLD_FLAME, diff))
                    doCast(SPELL_CALL_COLD_FLAME);

                if (m_uiSliceTimer <= 1000)
                {
                    if (m_uiSliceTimer <= diff)
                    {
                        doCast(SPELL_BONE_SLICE, m_creature->getVictim());
                        m_uiSliceTimer = 1000;
                    }
                    else
                        m_uiSliceTimer -= diff;
                }
                else
                    m_uiSliceTimer -= diff;

                DoMeleeAttackIfReady();
                break;
            }
            case 1: // Bone Storm initialization phase
            {
                m_creature->InterruptNonMeleeSpells(true);
                doCast(SPELL_BONE_STORM);
                DoScriptText(-1631002,m_creature);
                SetCombatMovement(false);
                m_creature->GetMotionMaster()->Clear();
                m_creature->SetSpeedRate(MOVE_RUN, 3);
                // initial X Coldflames are in Marrowgar's place
                m_creature->GetPosition(targetPosX, targetPosY, targetPosZ);
                setStage(2);
                break;
            }
            case 2: // Bone Storm waiting to end casting the spell
            {
                if (!m_creature->IsNonMeleeSpellCasted(false))
                    setStage(3);
                break;
            }
            case 3: // Whirling in Bone Storm and casting Cold Flames
            {
                if (isHeroic())
                {
                    if (timedQuery(SPELL_BONE_SPIKE, diff))
                    {
                        if (Unit* pTarget = doSelectRandomPlayer(SPELL_BONE_SPIKE_IMPALE, false, 60.0f, isHeroic()))
                        {
                            doCast(pTarget, SPELL_BONE_SPIKE);
                            DoSummonSpike(pTarget);
                            DoScriptText(-1631003 - urand(0,2), m_creature, pTarget);
                        }
                    }
                }

                if (m_creature->GetDistance2d(targetPosX, targetPosY) < 5.0f)
                {
                    if (!m_bIsColdFlameXCast)
                    {
                        
                        float myPosX, myPosY, myPosZ;

                        m_creature->GetPosition(myPosX, myPosY, myPosZ);

                        m_pInstance->SetData(DATA_DIRECTION, (uint32)(1000*2.0f*M_PI_F*((float)urand(1,16)/16.0f)));
                        doCast(SPELL_CALL_COLD_FLAME);
                        doSummon(NPC_COLD_FLAME, myPosX, myPosY, myPosZ);

                        if (++m_uiColdFlameCounter >= 4 + isHeroic())
                        {
                            doRemove(SPELL_BONE_STORM_STRIKE);
                            doRemove(SPELL_BONE_STORM);
                        }
                        m_bIsColdFlameXCast = true;
                    }

                    if (m_uiBoneStormChargeTimer <= diff)
                    {
                        if (Unit* pTarget = doSelectRandomPlayerAtRange(60.0f))
                        {
                            pTarget->GetPosition(targetPosX, targetPosY, targetPosZ);
                            m_creature->GetMotionMaster()->MovePoint(0, targetPosX, targetPosY, targetPosZ);
                            m_bIsColdFlameXCast = false;
                            m_uiBoneStormChargeTimer = 3000;
                        }
                    }
                    else
                        m_uiBoneStormChargeTimer -= diff;
                }

                if (!hasAura(SPELL_BONE_STORM_STRIKE, m_creature) && !hasAura(SPELL_BONE_STORM, m_creature))
                    setStage(4);

                break;
            }
            case 4:
            {
                m_pInstance->SetData(DATA_DIRECTION, 0);
                m_creature->SetSpeedRate(MOVE_RUN, 1);
                m_uiColdFlameCounter = 0;
                SetCombatMovement(true);
                m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
                m_uiSliceTimer = 10000;
                setStage(0);
                break;
            }
            default:
                break;
        }

        if (timedQuery(SPELL_BERSERK, diff))
        {
            doCast(SPELL_BERSERK);
            DoScriptText(-1631008, m_creature);
        }
    }
CanCastResult BSWScriptedAI::_BSWSpellSelector(uint8 m_uiSpellIdx, Unit* pTarget)
{

    SpellTable* pSpell = &m_BossSpell[m_uiSpellIdx];

    Unit* pSummon = NULL;

        debug_log("BSW: Casting spell number %u type %u",pSpell->m_uiSpellEntry[currentDifficulty], pSpell->m_CastTarget);

        switch (pSpell->m_CastTarget) {

            case DO_NOTHING: 
                   return CAST_OK;

            case CAST_ON_SELF:
                   if (!pSpell->m_IsBugged) return _DoCastSpellIfCan(m_creature, pSpell->m_uiSpellEntry[currentDifficulty]);
                   else return _BSWDoCast(m_uiSpellIdx, m_creature);
                   break;

            case CAST_ON_SUMMONS:
                   if (!pTarget) return CAST_FAIL_OTHER;
                   else return _DoCastSpellIfCan(pTarget, pSpell->m_uiSpellEntry[currentDifficulty]);
                   break;

            case CAST_ON_VICTIM:
                   pTarget = m_creature->getVictim();
                   return _BSWCastOnTarget(pTarget, m_uiSpellIdx);
                   break;

            case CAST_ON_RANDOM:
                   pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0);
                   return _BSWCastOnTarget(pTarget, m_uiSpellIdx);
                   break;

            case CAST_ON_BOTTOMAGGRO:
                   pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_BOTTOMAGGRO,0);
                   return _BSWCastOnTarget(pTarget, m_uiSpellIdx);
                   break;

            case CAST_ON_TARGET:
                   return _BSWCastOnTarget(pTarget, m_uiSpellIdx);
                   break;

            case APPLY_AURA_SELF:
                       if (_doAura(m_uiSpellIdx, m_creature, EFFECT_INDEX_0))
                           return CAST_OK;
                       else return CAST_FAIL_OTHER;
                   break;

            case APPLY_AURA_TARGET:
                   if (!pTarget || !pTarget->IsInMap(m_creature)) return CAST_FAIL_OTHER;
                       if (_doAura(m_uiSpellIdx, pTarget, EFFECT_INDEX_0))
                           return CAST_OK;
                       else return CAST_FAIL_OTHER;
                   break;

            case SUMMON_NORMAL:
                   pSummon = _doSummon(m_uiSpellIdx, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5000);
                   if (pSummon) return CAST_OK;
                          else return CAST_FAIL_OTHER;
                   break;

            case SUMMON_TEMP:
                   pSummon = _doSummon(m_uiSpellIdx, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,
                                        urand(pSpell->m_uiSpellTimerMin[currentDifficulty],pSpell->m_uiSpellTimerMax[currentDifficulty]));
                   if (pSummon) return CAST_OK;
                          else return CAST_FAIL_OTHER;
                   break;

            case SUMMON_INSTANT:
                   pSummon = _doSummon(m_uiSpellIdx, TEMPSUMMON_MANUAL_DESPAWN,0);
                   if (pSummon) return CAST_OK;
                          else return CAST_FAIL_OTHER;
                   break;

            case CAST_ON_ALLPLAYERS:
            {
                    CanCastResult res1 = CAST_FAIL_OTHER;
                    Map::PlayerList const& pPlayers = pMap->GetPlayers();
                    for (Map::PlayerList::const_iterator itr = pPlayers.begin(); itr != pPlayers.end(); ++itr)
                    {
                        pTarget = itr->getSource();
                        if (pTarget && pTarget->isAlive() && pTarget->IsWithinDistInMap(m_creature, pSpell->LocData.x))
                           {
                               if (!pSpell->m_IsBugged) 
                                   {
                                       res1 = _DoCastSpellIfCan(pTarget, pSpell->m_uiSpellEntry[currentDifficulty]);
                                   }
                                   else 
                                   {
                                       _BSWDoCast(m_uiSpellIdx, pTarget);
                                       res1 = CAST_OK;
                                   };
                           };
                           return res1;
                     }
                   break;
            }

            case CAST_ON_FRENDLY:
                   pTarget = doSelectLowHPFriendly(pSpell->LocData.x);
                   return _BSWCastOnTarget(pTarget, m_uiSpellIdx);
                   break;

            case CAST_ON_FRENDLY_LOWHP:
                   pTarget = doSelectLowHPFriendly(pSpell->LocData.x);
                   return _BSWCastOnTarget(pTarget, m_uiSpellIdx);
                   break;

            case CAST_ON_RANDOM_POINT:
                   if (!pTarget) pTarget = m_creature;
                   if (pSpell->LocData.z <= 1.0f) {
                         float fPosX, fPosY, fPosZ;
                         if (!pTarget->IsPositionValid() || !pTarget->IsInMap(m_creature))
                            {
                                if (pTarget->GetTypeId() == TYPEID_PLAYER)
                                     error_log("BSW: CAST_ON_RANDOM_POINT FAILED: player has invalid position. SpellID is %u",pSpell->m_uiSpellEntry[currentDifficulty]);
                                else error_log("BSW: CAST_ON_RANDOM_POINT FAILED: creature has invalid position. SpellID is %u",pSpell->m_uiSpellEntry[currentDifficulty]);
                                return CAST_FAIL_OTHER;
                            }
                         pTarget->GetPosition(fPosX, fPosY, fPosZ);
                         pTarget->GetRandomPoint(fPosX, fPosY, fPosZ, urand((uint32)pSpell->LocData.x, (uint32)pSpell->LocData.y), fPosX, fPosY, fPosZ);
                                if ((int)fPosZ == 0)
                                {
                                    error_log("BSW: CAST_ON_RANDOM_POINT FAILED: Positon Z is NULL. Strange bug");
                                    return CAST_FAIL_OTHER;
                                 }
                         if (SpellEntry const *spell = (SpellEntry *)GetSpellStore()->LookupEntry(pSpell->m_uiSpellEntry[currentDifficulty]))
                           if (SpellRangeEntry const *pSpellRange = GetSpellRangeStore()->LookupEntry(spell->rangeIndex))
                              if (m_creature->GetDistance(fPosX, fPosY, fPosZ) <= pSpellRange->maxRange)
                                 {
                                     m_creature->CastSpell(fPosX, fPosY, fPosZ, pSpell->m_uiSpellEntry[currentDifficulty], false);
                                     return CAST_OK;
                                 };
                                 return CAST_FAIL_TOO_FAR;
                         } else  return CAST_FAIL_OTHER;
                   break;

            case CAST_ON_RANDOM_PLAYER:
                   if ( pSpell->LocData.x < 1 ) pTarget = doSelectRandomPlayer();
                       else pTarget = doSelectRandomPlayerAtRange((float)pSpell->LocData.x);
                   if (pTarget && pTarget->IsInMap(m_creature)) return _BSWCastOnTarget(pTarget, m_uiSpellIdx);
                       else return CAST_FAIL_OTHER;
                   break;

            case APPLY_AURA_ALLPLAYERS:
                   {
                       Map::PlayerList const& pPlayers = pMap->GetPlayers();
                       for (Map::PlayerList::const_iterator itr = pPlayers.begin(); itr != pPlayers.end(); ++itr)
                       {
                           pTarget = itr->getSource();
                           if (pTarget && pTarget->isAlive() && pTarget->IsWithinDistInMap(m_creature, pSpell->LocData.x))
                               _doAura(m_uiSpellIdx, pTarget, EFFECT_INDEX_0);
                       }
                   return CAST_OK;
                   }
                   break;

            case SPELLTABLEPARM_NUMBER:
            default:
                   return CAST_FAIL_OTHER;
                   break;
            };

    error_log("BSW: FAILED casting spell number %u type %u - type not exists",pSpell->m_uiSpellEntry[currentDifficulty], pSpell->m_CastTarget);

    return CAST_FAIL_OTHER;
};