Bgames
Olá visitante! Seja bem vindo ao nosso fórum!

Para você ter total acesso ao nosso fórum é preciso que você se cadastre.

Cadastre-se Aqui!


PARA VER LINKS E IMAGENS É PRECISO SE REGISTRAR!

Icecrown_trash

Ver o tópico anterior Ver o tópico seguinte Ir em baixo

Icecrown_trash

Mensagem por grimgravy em Qua 18 Set 2013 - 21:11

Esse script, Foi feito pra as correções dos mobs da Estance de Icecrown citadel.
  
1) Lembrando, o Script só é pra Servidor Blizzlike
2) O script é Atualizado 
3) pra adicionar-lo só Apenas em Servidores Copilado na Pasta Custom 

Script de CPP
Código:
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#include "ScriptPCH.h"

enum TrashSpells
{
   //Quest Spell
   SPELL_SOUL_FEAST_ALL = 71203,

   //----------LOWER SPIRE----------//
   //Nerub'ar Broodkeeper
   SPELL_CRYPTSCARABS = 70965,
   SPELL_DARKMENDING = 71020,
   SPELL_WEBWRAP = 70980,

   //Servant of the Throne
   SPELL_GLACIALBLAST = 71029,

   //Ancient Skeletal Soldier
   SPELL_SHIELDBASH = 70964,

   //Deathbound Ward
   SPELL_DISRUPTINGSHOUT = 71022,
   SPELL_SABERLASH = 71021,

   //Deathspeaker Attendant
   SPELL_SHADOWBOLT = 69387,
   SPELL_SHADOWNOVA_10N = 69355,
   SPELL_SHADOWNOVA_25N = 71106,

   //Deathspeaker Disciple
   SPELL_DARKBLESSING = 69391,
   SPELL_SHADOWBOLT2 = 69387,
   SPELL_SHADOWMEND_10N = 69389,
   SPELL_SHADOWMEND_25N = 71107,

   //Deathspeaker High Priest
   SPELL_AURAOFDARKNESS = 69491,
   SPELL_DARKRECKONING = 69483,
   SPELL_DARKRECKONING_EFFECT = 69482,

   //Deathspeaker Servant
   SPELL_CHAOSBOLT_10N = 69576,
   SPELL_CHAOSBOLT_25N = 71108,
   SPELL_CONSUMINGSHADOWS = 69405,
   SPELL_CURSEOFAGONY_10N = 69404,
   SPELL_CURSEOFAGONY_25N = 71112,

   //Deathspeaker Zealot
   SPELL_SHADOWCLEAVE = 69492,

   //----------UPPER SPIRE----------//
   //Valkyr Herald
   SPELL_SEVERED_ESSENCE_10N = 71906,
   SPELL_SEVERED_ESSENCE_25N = 71942,

   //----------PLAGUE WORKS----------//
   //Blighted Abomination
   SPELL_CLEAVE = 40504,
   SPELL_PLAGUE_CLOUD = 71150,
   SPELL_SCOURGE_HOOK = 71140,

   //Vengeful Fleshreaper
   SPELL_LEAPING_FACE_MAUL = 71164,
   SPELL_DEVOUR_HUMANOID = 71164,

   //Plague Scientist
   SPELL_PLAGUE_BLAST = 73079,
   SPELL_PLAGUE_STREAM = 69871,
   SPELL_COMBOBULATING_SPRAY = 71103,

   //Pustulating Horror
   SPELL_BLIGHT_BOMB = 71088,
   SPELL_BUBBLING_PUS_10N = 71089,
   SPELL_BUBBLING_PUS_25N = 71090,

   //Decaying Colossus
   SPELL_MASSIVE_STOMP_10N = 71114,
   SPELL_MASSIVE_STOMP_25N = 71115,

   //----------SANCTUARY OF BLOOD----------//
   //Darkfallen Archmage
   SPELL_AMPLIFY_MAGIC_10N = 70408,
   SPELL_AMPLIFY_MAGIC_25N = 72336,
   SPELL_BLAST_WAVE_10N = 70407,
   SPELL_BLAST_WAVE_25N = 71151,
   SPELL_FIREBALL_10N = 70409,
   SPELL_FIREBALL_25N = 71153,
   SPELL_POLYMORPH_SPIDER = 70410,
   SPELL_SIPHON_ESSENCE = 70299,

   //Darkfallen Blood Knight
   SPELL_VAMPIRIC_AURA = 71736,
   SPELL_UNHOLY_STRIKE = 70437,
   SPELL_BLOOD_MIRROR_DAMAGE = 70445,
   SPELL_BLOOD_MIRROR_BUFF = 70451,
   SPELL_BLOOD_MIRROR_DUMMY = 70450,

   //Darkfallen Noble
   SPELL_CHAINS_OF_SHADOW = 70645,
   SPELL_SHADOW_BOLT_10N = 72960,
   SPELL_SHADOW_BOLT_25N = 72961,

   //Vampiric Fiend
   SPELL_DISEASE_CLOUD = 41290,
   SPELL_LEECHING_ROT = 70671,

   //Darkfallen Advisor
   SPELL_LICH_SLAP_10N = 72057,
   SPELL_LICH_SLAP_25N = 72421,
   SPELL_SHROUD_OF_PROTECTION = 72065,
   SPELL_SHROUD_OF_SPELL_WARDING = 72066,

   //Darkfallen Commander
   SPELL_VAMPIRE_RUSH_10N = 70449,
   SPELL_VAMPIRE_RUSH_25N = 71155,
   SPELL_BATTLE_SHOUT = 70750,

   //Darkfallen Lieutenant
   SPELL_VAMPIRIC_CURSE = 70423,
   SPELL_REND_FLESH_10N = 70435,
   SPELL_REND_FLESH_25N = 71154,

   //Darkfallen Tactician
   SPELL_SHADOWSTEP = 70431,
   SPELL_BLOOD_SAP = 70432,

   //----------FROST WING----------//
   //Ymirjar Deathbringer
   SPELL_BANISH = 71298,
   SPELL_DEATHS_EMBRACE_10N = 71299,
   SPELL_DEATHS_EMBRACE_25N = 71300,
   SPELL_SHADOW_BOLT_YMIRJAR_10N = 71296,
   SPELL_SHADOW_BOLT_YMIRJAR_25N = 71297,
   SPELL_SUMMON_YMIRJAR = 71303,

   //Ymirjar Frostbinder
   SPELL_ARCTIC_CHILL = 71270,
   SPELL_FROZEN_ORB = 71274,
   SPELL_TWISTED_WINDS = 71306,
   SPELL_SPIRIT_STREAM = 69929,

   //Ymirjar Battle-Maiden
   SPELL_ADRENALINE_RUSH = 71258,
   SPELL_BARBARIC_STRIKE = 71257,

   //Ymirjar Huntress
   SPELL_ICE_TRAP = 71249,
   SPELL_RAPID_SHOT = 71251,
   SPELL_SHOOT = 71253,
   SPELL_VOLLEY = 71252,
   SPELL_SUMMON_WARHAWK = 71705,

   //Ymirjar Warlord
   SPELL_WHIRLWIND = 41056,
};

enum TrashEvents
{
   //Nerub'ar Broodkeeper
   EVENT_CRYPTSCARABS = 1,
   EVENT_DARKMENDING = 2,
   EVENT_WEBWRAP = 3,

   //The Damned
   EVENT_BONEFLURRY = 4,
   EVENT_SHATTEREDBONES = 5,

   //Servant of the Throne
   EVENT_GLACIALBLAST = 6,

   //Ancient Skeletal Soldier
   EVENT_SHIELDBASH = 7,

   //Deathbound Ward
   EVENT_DISRUPTINGSHOUT = 8,
   EVENT_SABERLASH = 9,

   //Deathspeaker Attendant
   EVENT_SHADOWBOLT = 10,
   EVENT_SHADOWNOVA = 11,

   //Deathspeaker Disciple
   EVENT_SHADOWBOLT2 = 12,
   EVENT_DARKBLESSING = 13,
   EVENT_SHADOWMEND = 14,

   //Deathspeaker High Priest
   EVENT_DARKRECKONING = 15,
   EVENT_DARKRECKONING_EFFECT = 16,

   //Deathspeaker Servant
   EVENT_CHAOSBOLT = 17,
   EVENT_CONSUMINGSHADOWS = 18,
   EVENT_CURSEOFAGONY = 19,

   //Deathspeaker Zealot
   EVENT_SHADOWCLEAVE = 20,
};

//----------LOWER SPIRE----------//
class npc_NerubarBroodkeeper : public CreatureScript
{
public:
   npc_NerubarBroodkeeper() : CreatureScript("npc_NerubarBroodkeeper") { }
   struct npc_NerubarBroodkeeperAI : public ScriptedAI
   {
      npc_NerubarBroodkeeperAI(Creature *c) : ScriptedAI(c)
      {
      }
      EventMap events;

      void Reset()
      {
         events.Reset();
      }

      void EnterCombat(Unit* who) override
      {
         events.ScheduleEvent(EVENT_CRYPTSCARABS, 10000);
         events.ScheduleEvent(EVENT_DARKMENDING, 17800);
         events.ScheduleEvent(EVENT_WEBWRAP, 12000);
      }

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

         events.Update(diff);

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

         while (uint32 eventId = events.ExecuteEvent())
         {
            switch (eventId)
            {
            case EVENT_CRYPTSCARABS:
               if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
                  DoCast(pTarget, SPELL_CRYPTSCARABS);
               events.RescheduleEvent(EVENT_CRYPTSCARABS, 12000);
               break;
            case EVENT_DARKMENDING:
               DoCast(me, SPELL_DARKMENDING);
               events.RescheduleEvent(EVENT_DARKMENDING, 17800);
               break;
            case EVENT_WEBWRAP:
               if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
                  DoCast(pTarget, SPELL_WEBWRAP);

               events.RescheduleEvent(EVENT_WEBWRAP, 15000);
               break;
            }
         }
         DoMeleeAttackIfReady();
      }
   };

   CreatureAI* GetAI(Creature* pCreature) const
   {
      return new npc_NerubarBroodkeeperAI(pCreature);
   }
};

class npc_ServantoftheThrone : public CreatureScript
{
public:
   npc_ServantoftheThrone() : CreatureScript("npc_ServantoftheThrone") { }
   struct npc_ServantoftheThroneAI : public ScriptedAI
   {
      npc_ServantoftheThroneAI(Creature *c) : ScriptedAI(c)
      {
      }
      EventMap events;

      void Reset() override
      {
         events.Reset();
      }

      void EnterCombat(Unit* who) override
      {
         events.ScheduleEvent(EVENT_GLACIALBLAST, 13000);
      }

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

         events.Update(diff);

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

         while (uint32 eventId = events.ExecuteEvent())
         {
            switch (eventId)
            {
            case EVENT_GLACIALBLAST:
               DoCastAOE(SPELL_GLACIALBLAST);
               events.RescheduleEvent(EVENT_GLACIALBLAST, 8000);
               break;
            }
         }
         DoMeleeAttackIfReady();
      }
   };

   CreatureAI* GetAI(Creature* pCreature) const
   {
      return new npc_ServantoftheThroneAI(pCreature);
   }
};

class npc_AncientSkeletalSoldier : public CreatureScript
{
public:
   npc_AncientSkeletalSoldier() : CreatureScript("npc_AncientSkeletalSoldier") { }
   struct npc_AncientSkeletalSoldierAI : public ScriptedAI
   {
      npc_AncientSkeletalSoldierAI(Creature *c) : ScriptedAI(c)
      {
      }
      EventMap events;

      void Reset() override
      {
         events.Reset();
      }

      void EnterCombat(Unit* who) override
      {
         events.ScheduleEvent(EVENT_SHIELDBASH, 8000);
      }

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

         events.Update(diff);

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

         while (uint32 eventId = events.ExecuteEvent())
         {
            switch (eventId)
            {
            case EVENT_SHIELDBASH:
               DoCast(me->GetVictim(), SPELL_SHIELDBASH);
               events.RescheduleEvent(EVENT_SHIELDBASH, 8000);
               break;
            }
         }
         DoMeleeAttackIfReady();
      }
   };

   CreatureAI* GetAI(Creature* pCreature) const
   {
      return new npc_AncientSkeletalSoldierAI(pCreature);
   }
};

class npc_DeathboundWard : public CreatureScript
{
public:
   npc_DeathboundWard() : CreatureScript("npc_DeathboundWard") { }
   struct npc_DeathboundWardAI : public ScriptedAI
   {
      npc_DeathboundWardAI(Creature *c) : ScriptedAI(c)
      {
      }
      EventMap events;

      void Reset()
      {
         events.Reset();
      }

      void EnterCombat(Unit* who)
      {
         events.ScheduleEvent(EVENT_DISRUPTINGSHOUT, 8000);
         events.ScheduleEvent(EVENT_SABERLASH, 8000);
      }

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

         events.Update(diff);

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

         while (uint32 eventId = events.ExecuteEvent())
         {
            switch (eventId)
            {
            case EVENT_DISRUPTINGSHOUT:
               DoCast(me, SPELL_DISRUPTINGSHOUT);
               events.RescheduleEvent(EVENT_DISRUPTINGSHOUT, 8000);
               break;
            case EVENT_SABERLASH:
               DoCast(me->GetVictim(), SPELL_SABERLASH, true);
               events.RescheduleEvent(EVENT_SABERLASH, 8000);
               break;
            }
         }
         DoMeleeAttackIfReady();
      }
   };

   CreatureAI* GetAI(Creature* pCreature) const
   {
      return new npc_DeathboundWardAI(pCreature);
   }
};

class npc_DeathspeakerAttedant : public CreatureScript
{
public:
   npc_DeathspeakerAttedant() : CreatureScript("npc_DeathspeakerAttedant") { }
   struct npc_DeathspeakerAttedantAI : public ScriptedAI
   {
      npc_DeathspeakerAttedantAI(Creature *c) : ScriptedAI(c)
      {
      }
      EventMap events;

      void Reset() override
      {
         events.Reset();
      }

      void EnterCombat(Unit* who) override
      {
         events.ScheduleEvent(EVENT_SHADOWBOLT, 8000);
         events.ScheduleEvent(EVENT_SHADOWNOVA, 23000);
      }

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

         events.Update(diff);

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

         while (uint32 eventId = events.ExecuteEvent())
         {
            switch (eventId)
            {
            case EVENT_SHADOWBOLT:
               if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
                  DoCast(pTarget, SPELL_SHADOWBOLT);

               events.RescheduleEvent(EVENT_SHADOWBOLT, 8000);
               break;
            case EVENT_SHADOWNOVA:
               DoCastAOE(RAID_MODE(SPELL_SHADOWNOVA_10N, SPELL_SHADOWNOVA_25N, SPELL_SHADOWNOVA_10N, SPELL_SHADOWNOVA_25N));
               events.RescheduleEvent(EVENT_SHADOWNOVA, 17000);
               break;
            }
         }
         DoMeleeAttackIfReady();
      }
   };

   CreatureAI* GetAI(Creature* pCreature) const
   {
      return new npc_DeathspeakerAttedantAI(pCreature);
   }
};

class npc_DeathspeakerDisciple : public CreatureScript
{
public:
   npc_DeathspeakerDisciple() : CreatureScript("npc_DeathspeakerDisciple") { }
   struct npc_DeathspeakerDiscipleAI : public ScriptedAI
   {
      npc_DeathspeakerDiscipleAI(Creature *c) : ScriptedAI(c)
      {
      }
      EventMap events;

      void Reset() override
      {
         events.Reset();
      }

      void EnterCombat(Unit* who) override
      {
         events.ScheduleEvent(EVENT_SHADOWBOLT2, 8000);
         events.ScheduleEvent(EVENT_DARKBLESSING, urand(15000, 25000));
         events.ScheduleEvent(EVENT_SHADOWMEND, urand(10000, 20000));
      }

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

         events.Update(diff);

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

         while (uint32 eventId = events.ExecuteEvent())
         {
            switch (eventId)
            {
            case EVENT_DARKBLESSING:
               if (Unit* pTarget = DoSelectLowestHpFriendly(30.0f, 1))
                  DoCast(pTarget, SPELL_DARKBLESSING);

               events.RescheduleEvent(EVENT_DARKBLESSING, 20000);
               break;
            case EVENT_SHADOWBOLT2:
               if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
                  DoCast(pTarget, SPELL_SHADOWBOLT2);

               events.RescheduleEvent(EVENT_SHADOWBOLT2, 8000);
               break;
            case EVENT_SHADOWMEND:
               if (Unit* pTarget = DoSelectLowestHpFriendly(40.0f, 1))
                  DoCast(pTarget, RAID_MODE(SPELL_SHADOWMEND_10N, SPELL_SHADOWMEND_25N, SPELL_SHADOWMEND_10N, SPELL_SHADOWMEND_25N));

               events.RescheduleEvent(EVENT_SHADOWMEND, 25000);
               break;
            }
         }
         DoMeleeAttackIfReady();
      }
   };

   CreatureAI* GetAI(Creature* pCreature) const
   {
      return new npc_DeathspeakerDiscipleAI(pCreature);
   }
};

class npc_DeathspeakerServant : public CreatureScript
{
public:
   npc_DeathspeakerServant() : CreatureScript("npc_DeathspeakerServant") { }
   struct npc_DeathspeakerServantAI : public ScriptedAI
   {
      npc_DeathspeakerServantAI(Creature *c) : ScriptedAI(c)
      {
      }
      EventMap events;

      void Reset() override
      {
         events.Reset();
      }

      void EnterCombat(Unit* who) override
      {
         events.ScheduleEvent(EVENT_CHAOSBOLT, 15000);
         events.ScheduleEvent(EVENT_CONSUMINGSHADOWS, 13000);
         events.ScheduleEvent(EVENT_CURSEOFAGONY, 10000);
      }

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

         events.Update(diff);

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

         while (uint32 eventId = events.ExecuteEvent())
         {
            switch (eventId)
            {
            case EVENT_CHAOSBOLT:
               if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
                  DoCast(pTarget, RAID_MODE(SPELL_CHAOSBOLT_10N, SPELL_CHAOSBOLT_25N, SPELL_CHAOSBOLT_10N, SPELL_CHAOSBOLT_25N));

               events.RescheduleEvent(EVENT_CHAOSBOLT, 15000);
               break;
            case EVENT_CONSUMINGSHADOWS:
               if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
                  DoCast(pTarget, SPELL_CONSUMINGSHADOWS);

               events.RescheduleEvent(EVENT_CONSUMINGSHADOWS, 13000);
               break;
            case EVENT_CURSEOFAGONY:
               if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
                  DoCast(pTarget, RAID_MODE(SPELL_CURSEOFAGONY_10N, SPELL_CURSEOFAGONY_25N, SPELL_CURSEOFAGONY_10N, SPELL_CURSEOFAGONY_25N));

               events.RescheduleEvent(EVENT_CURSEOFAGONY, 17000);
               break;
            }
         }
         DoMeleeAttackIfReady();
      }
   };

   CreatureAI* GetAI(Creature* pCreature) const
   {
      return new npc_DeathspeakerServantAI(pCreature);
   }
};

class npc_DeathspeakerZealot : public CreatureScript
{
public:
   npc_DeathspeakerZealot() : CreatureScript("npc_DeathspeakerZealot") { }
   struct npc_DeathspeakerZealotAI : public ScriptedAI
   {
      npc_DeathspeakerZealotAI(Creature *c) : ScriptedAI(c)
      {
      }
      EventMap events;

      void Reset() override
      {
         events.Reset();
      }

      void EnterCombat(Unit* who) override
      {
         events.ScheduleEvent(EVENT_SHADOWCLEAVE, 8000);
      }

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

         events.Update(diff);

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

         while (uint32 eventId = events.ExecuteEvent())
         {
            switch (eventId)
            {
            case EVENT_SHADOWCLEAVE:
               DoCast(me->GetVictim(), SPELL_SHADOWCLEAVE);
               events.RescheduleEvent(EVENT_SHADOWCLEAVE, 8000);
               break;
            }
         }
         DoMeleeAttackIfReady();
      }
   };

   CreatureAI* GetAI(Creature* pCreature) const
   {
      return new npc_DeathspeakerZealotAI(pCreature);
   }
};

class npc_valkyr_herald : public CreatureScript
{
public:
   npc_valkyr_herald() : CreatureScript("npc_valkyr_herald") { }

   struct npc_valkyr_heraldAI : public ScriptedAI
   {
      npc_valkyr_heraldAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiESSENCE_Timer;

      void Reset() override
      {
         m_uiESSENCE_Timer = 1000;
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiESSENCE_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), RAID_MODE(SPELL_SEVERED_ESSENCE_10N, SPELL_SEVERED_ESSENCE_25N, SPELL_SEVERED_ESSENCE_10N, SPELL_SEVERED_ESSENCE_25N));
            m_uiESSENCE_Timer = urand(2000, 8000);
         }
         else
            m_uiESSENCE_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_valkyr_heraldAI(creature);
   }
};

class npc_blighted_abomination : public CreatureScript
{
public:
   npc_blighted_abomination() : CreatureScript("npc_blighted_abomination") { }

   struct npc_blighted_abominationAI : public ScriptedAI
   {
      npc_blighted_abominationAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiCLOUD_Timer;
      uint32 m_uiCLEAVE_Timer;
      uint32 m_uiHOOK_Timer;

      void JustDied(Unit* killer)
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void Reset() override
      {
         m_uiCLOUD_Timer = 10000;
         m_uiCLEAVE_Timer = 4000;
         m_uiHOOK_Timer = 5000;
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiCLOUD_Timer <= uiDiff)
         {
            DoCastAOE(SPELL_PLAGUE_CLOUD);
            m_uiCLOUD_Timer = 20000;
         }
         else
            m_uiCLOUD_Timer -= uiDiff;

         if (m_uiHOOK_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_SCOURGE_HOOK);

            m_uiHOOK_Timer = urand(12000, 20000);
         }
         else
            m_uiHOOK_Timer -= uiDiff;

         if (m_uiCLEAVE_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), SPELL_CLEAVE);

            m_uiCLEAVE_Timer = 6000;
         }
         else
            m_uiCLEAVE_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_blighted_abominationAI(creature);
   }
};

class npc_vengeful_fleshreapert : public CreatureScript
{
public:
   npc_vengeful_fleshreapert() : CreatureScript("npc_vengeful_fleshreapert") { }

   struct npc_vengeful_fleshreapertAI : public ScriptedAI
   {
      npc_vengeful_fleshreapertAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiJUMP_Timer;
      uint32 m_uiDEVOUR_Timer;

      void Reset() override
      {
         m_uiJUMP_Timer = urand(3000, 20000);
         m_uiDEVOUR_Timer = urand(3000, 5000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiJUMP_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_LEAPING_FACE_MAUL);

            m_uiJUMP_Timer = urand(20000, 40000);
         }
         else
            m_uiJUMP_Timer -= uiDiff;

         if (m_uiDEVOUR_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_DEVOUR_HUMANOID);

            m_uiDEVOUR_Timer = urand(5000, 8000);
         }
         else
            m_uiDEVOUR_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_vengeful_fleshreapertAI(creature);
   }
};

class npc_plague_scientist : public CreatureScript
{
public:
   npc_plague_scientist() : CreatureScript("npc_plague_scientist") { }

   struct npc_plague_scientistAI : public ScriptedAI
   {
      npc_plague_scientistAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiBLAST_Timer;
      uint32 m_uiSTREAM_Timer;
      uint32 m_uiSTREAM_OUT_Timer;
      uint32 m_uiSPRAY_Timer;

      void Reset() override
      {
         m_uiBLAST_Timer = 2000;
         m_uiSTREAM_Timer = urand(8000, 12000);
         m_uiSTREAM_OUT_Timer = 24000;
         m_uiSPRAY_Timer = urand(5000, 8000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiSTREAM_Timer <= uiDiff)
         {
            if (m_uiSTREAM_OUT_Timer > uiDiff)
            {
               if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                  DoCast(target, SPELL_PLAGUE_STREAM);
               // maximo 24 segs para que deje de castear
               m_uiSTREAM_OUT_Timer -= uiDiff;
            }
            else
            {
               me->CastStop(SPELL_PLAGUE_STREAM);
               // se repite de entre 15 a 20 segs
               m_uiSTREAM_OUT_Timer = urand(15000, 20000);
            }
         }
         else
            m_uiSTREAM_Timer -= uiDiff;

         if (m_uiSPRAY_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_COMBOBULATING_SPRAY);
            // cada 8 a 12 segs se repite
            m_uiSPRAY_Timer = urand(8000, 12000);
         }
         else
            m_uiSPRAY_Timer -= uiDiff;

         if (m_uiBLAST_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), SPELL_PLAGUE_BLAST);
            m_uiBLAST_Timer = urand(2000, 3000);
         }
         else
            m_uiBLAST_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_plague_scientistAI(creature);
   }
};

class npc_pustulating_horror : public CreatureScript
{
public:
   npc_pustulating_horror() : CreatureScript("npc_pustulating_horror") { }

   struct npc_pustulating_horrorAI : public ScriptedAI
   {
      npc_pustulating_horrorAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiPUS_Timer;

      void Reset() override
      {
         m_uiPUS_Timer = 2000;
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (HealthBelowPct(15))
         {
            DoCastAOE(SPELL_BLIGHT_BOMB);
            m_uiPUS_Timer = 5000;
         }

         if (m_uiPUS_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_NEAREST, 0))
               DoCast(target, RAID_MODE(SPELL_BUBBLING_PUS_10N, SPELL_BUBBLING_PUS_25N, SPELL_BUBBLING_PUS_10N, SPELL_BUBBLING_PUS_25N));
            if (HealthAbovePct(15))
               m_uiPUS_Timer = urand(15000, 25000);
         }
         else
            m_uiPUS_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_pustulating_horrorAI(creature);
   }
};

class npc_decaying_colossus : public CreatureScript
{
public:
   npc_decaying_colossus() : CreatureScript("npc_decaying_colossus") { }

   struct npc_decaying_colossusAI : public ScriptedAI
   {
      npc_decaying_colossusAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiSTOMP_Timer;

      void Reset()
      {
         m_uiSTOMP_Timer = 5000;
      }

      void JustDied(Unit* killer)
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff)
      {
         if (!UpdateVictim())
            return;

         if (m_uiSTOMP_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), RAID_MODE(SPELL_MASSIVE_STOMP_10N, SPELL_MASSIVE_STOMP_25N, SPELL_MASSIVE_STOMP_10N, SPELL_MASSIVE_STOMP_25N));
            m_uiSTOMP_Timer = urand(15000, 25000);
         }
         else
            m_uiSTOMP_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_decaying_colossusAI(creature);
   }
};

class npc_darkfallen_archmage : public CreatureScript
{
public:
   npc_darkfallen_archmage() : CreatureScript("npc_darkfallen_archmage") { }

   struct npc_darkfallen_archmageAI : public ScriptedAI
   {
      npc_darkfallen_archmageAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiAMPLIFY_Timer;
      uint32 m_uiBLAST_Timer;
      uint32 m_uiFIREBALL_Timer;
      uint32 m_uiPOLYMORPH_Timer;

      void Reset() override
      {
         m_uiAMPLIFY_Timer = urand(10000, 15000);
         m_uiBLAST_Timer = urand(8000, 10000);
         m_uiFIREBALL_Timer = 2000;
         m_uiPOLYMORPH_Timer = urand(9000, 12000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiAMPLIFY_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), RAID_MODE(SPELL_AMPLIFY_MAGIC_10N, SPELL_AMPLIFY_MAGIC_25N, SPELL_AMPLIFY_MAGIC_10N, SPELL_AMPLIFY_MAGIC_25N));
            m_uiAMPLIFY_Timer = urand(15000, 20000);
         }
         else
            m_uiAMPLIFY_Timer -= uiDiff;

         if (m_uiPOLYMORPH_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_POLYMORPH_SPIDER);

            m_uiPOLYMORPH_Timer = urand(15000, 18000);
         }
         else
            m_uiPOLYMORPH_Timer -= uiDiff;

         if (m_uiFIREBALL_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), RAID_MODE(SPELL_FIREBALL_10N, SPELL_FIREBALL_25N, SPELL_FIREBALL_10N, SPELL_FIREBALL_25N));
            m_uiFIREBALL_Timer = urand(3000, 4000);
         }
         else
            m_uiFIREBALL_Timer -= uiDiff;

         if (m_uiBLAST_Timer <= uiDiff)
         {
            DoCastAOE(RAID_MODE(SPELL_BLAST_WAVE_10N, SPELL_BLAST_WAVE_25N, SPELL_BLAST_WAVE_10N, SPELL_BLAST_WAVE_25N));
            m_uiBLAST_Timer = urand(10000, 20000);
         }
         else
            m_uiBLAST_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_darkfallen_archmageAI(creature);
   }
};

class npc_darkfallen_blood_knight : public CreatureScript
{
public:
   npc_darkfallen_blood_knight() : CreatureScript("npc_darkfallen_blood_knight") { }

   struct npc_darkfallen_blood_knightAI : public ScriptedAI
   {
      npc_darkfallen_blood_knightAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiAURA_Timer;
      uint32 m_uiSTRIKE_Timer;
      uint32 m_uiMIRROR_Timer;

      void Reset() override
      {
         m_uiAURA_Timer = urand(12000, 15000);
         m_uiSTRIKE_Timer = urand(2000, 3000);
         m_uiMIRROR_Timer = urand(4000, 5000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiSTRIKE_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), SPELL_UNHOLY_STRIKE);
            m_uiSTRIKE_Timer = urand(3000, 4000);
         }
         else
            m_uiSTRIKE_Timer -= uiDiff;

         if (m_uiAURA_Timer <= uiDiff)
         {
            DoCast(me, SPELL_VAMPIRIC_AURA);
            m_uiAURA_Timer = urand(12000, 15000);
         }
         else
            m_uiAURA_Timer -= uiDiff;

         if (m_uiMIRROR_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
            {
               DoCast(me->GetVictim(), SPELL_BLOOD_MIRROR_DUMMY);
               me->GetVictim()->CastSpell(target, SPELL_BLOOD_MIRROR_DAMAGE, true);
               me->CastSpell(me->GetVictim(), SPELL_BLOOD_MIRROR_BUFF, true);
               m_uiMIRROR_Timer = urand(32000, 37000);
            }
         }
         else
            m_uiMIRROR_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_darkfallen_blood_knightAI(creature);
   }
};

enum Noblemisc
{
   NPC_VAMPIRIC_FIEND = 37901,
};
class npc_darkfallen_noble : public CreatureScript
{
public:
   npc_darkfallen_noble() : CreatureScript("npc_darkfallen_noble") { }

   struct npc_darkfallen_nobleAI : public ScriptedAI
   {
      npc_darkfallen_nobleAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiCHAINS_Timer;
      uint32 m_uiBOLT_Timer;
      uint32 m_uiFIEND_Timer;

      void Reset() override
      {
         m_uiCHAINS_Timer = urand(2000, 4000);
         m_uiBOLT_Timer = urand(3000, 5000);
         m_uiFIEND_Timer = 15000;
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiBOLT_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), RAID_MODE(SPELL_SHADOW_BOLT_10N, SPELL_SHADOW_BOLT_25N, SPELL_SHADOW_BOLT_10N, SPELL_SHADOW_BOLT_25N));
            m_uiBOLT_Timer = urand(4000, 5000);
         }
         else
            m_uiBOLT_Timer -= uiDiff;

         if (m_uiCHAINS_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_CHAINS_OF_SHADOW);

            m_uiCHAINS_Timer = urand(20000, 25000);
         }
         else
            m_uiCHAINS_Timer -= uiDiff;

         if (m_uiFIEND_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               if (me->SummonCreature(NPC_VAMPIRIC_FIEND, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ()))
                  m_uiFIEND_Timer = 60000;
         }
         else
            m_uiFIEND_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_darkfallen_nobleAI(creature);
   }
};

class npc_vampiric_fiend : public CreatureScript
{
public:
   npc_vampiric_fiend() : CreatureScript("npc_vampiric_fiend") { }

   struct npc_vampiric_fiendAI : public ScriptedAI
   {
      npc_vampiric_fiendAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiLEECHING_Timer;

      void Reset() override
      {
         m_uiLEECHING_Timer = 10000;
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void EnterCombat(Unit* /*target*/) override
      {
         DoCast(me, SPELL_DISEASE_CLOUD);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiLEECHING_Timer <= uiDiff)
         {
            DoCastAOE(SPELL_LEECHING_ROT);
            me->ForceValuesUpdateAtIndex(3000);
            m_uiLEECHING_Timer = 10000;
         }
         else
            m_uiLEECHING_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_vampiric_fiendAI(creature);
   }
};

class npc_darkfallen_advisor : public CreatureScript
{
public:
   npc_darkfallen_advisor() : CreatureScript("npc_darkfallen_advisor") { }

   struct npc_darkfallen_advisorAI : public ScriptedAI
   {
      npc_darkfallen_advisorAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiLICH_Timer;
      uint32 m_uiPROTECTION_Timer;

      void Reset() override
      {
         m_uiLICH_Timer = urand(2000, 5000);
         m_uiPROTECTION_Timer = urand(10000, 15000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiLICH_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), RAID_MODE(SPELL_LICH_SLAP_10N, SPELL_LICH_SLAP_25N, SPELL_LICH_SLAP_10N, SPELL_LICH_SLAP_25N));
            m_uiLICH_Timer = 10000;
         }
         else
            m_uiLICH_Timer -= uiDiff;

         if (m_uiPROTECTION_Timer <= uiDiff)
         {
            if (Unit* target = urand(0, 1) ? SelectTarget(SELECT_TARGET_RANDOM, 0) : DoSelectLowestHpFriendly(40.0f))
            {
               DoCast(target, SPELL_SHROUD_OF_PROTECTION);
               DoCast(target, SPELL_SHROUD_OF_SPELL_WARDING);
               m_uiPROTECTION_Timer = urand(15000, 20000);
            }
         }
         else
            m_uiPROTECTION_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_darkfallen_advisorAI(creature);
   }
};

class npc_darkfallen_commander : public CreatureScript
{
public:
   npc_darkfallen_commander() : CreatureScript("npc_darkfallen_commander") { }

   struct npc_darkfallen_commanderAI : public ScriptedAI
   {
      npc_darkfallen_commanderAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiRUSH_Timer;
      uint32 m_uiSHOUT_Timer;

      void Reset() override
      {
         m_uiRUSH_Timer = urand(4000, 8000);
         m_uiSHOUT_Timer = urand(8000, 10000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiSHOUT_Timer <= uiDiff)
         {
            DoCast(me, SPELL_BATTLE_SHOUT);
            m_uiSHOUT_Timer = urand(15000, 20000);
         }
         else
            m_uiSHOUT_Timer -= uiDiff;

         if (m_uiRUSH_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, RAID_MODE(SPELL_VAMPIRE_RUSH_10N, SPELL_VAMPIRE_RUSH_25N, SPELL_VAMPIRE_RUSH_10N, SPELL_VAMPIRE_RUSH_25N));

            m_uiRUSH_Timer = urand(10000, 15000);
         }
         else
            m_uiRUSH_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_darkfallen_commanderAI(creature);
   }
};

class npc_darkfallen_lieutenant : public CreatureScript
{
public:
   npc_darkfallen_lieutenant() : CreatureScript("npc_darkfallen_lieutenant") { }

   struct npc_darkfallen_lieutenantAI : public ScriptedAI
   {
      npc_darkfallen_lieutenantAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiREND_Timer;
      uint32 m_uiCURSE_Timer;

      void Reset() override
      {
         m_uiREND_Timer = urand(1000, 2000);
         m_uiCURSE_Timer = urand(8000, 15000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiREND_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), RAID_MODE(SPELL_REND_FLESH_10N, SPELL_REND_FLESH_25N, SPELL_REND_FLESH_10N, SPELL_REND_FLESH_25N));
            m_uiREND_Timer = 25000;
         }
         else
            m_uiREND_Timer -= uiDiff;

         if (m_uiCURSE_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_VAMPIRIC_CURSE);

            m_uiCURSE_Timer = urand(10000, 20000);
         }
         else
            m_uiCURSE_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_darkfallen_lieutenantAI(creature);
   }
};

class npc_darkfallen_tactician : public CreatureScript
{
public:
   npc_darkfallen_tactician() : CreatureScript("npc_darkfallen_tactician") { }

   struct npc_darkfallen_tacticianAI : public ScriptedAI
   {
      npc_darkfallen_tacticianAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiSHADOWSTEP_Timer;
      uint32 m_uiSAP_Timer;
      uint32 m_uiSTRIKE_Timer;

      void Reset() override
      {
         m_uiSHADOWSTEP_Timer = urand(1000, 2000);
         m_uiSAP_Timer = urand(5000, 15000);
         m_uiSTRIKE_Timer = urand(2000, 3000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiSTRIKE_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), SPELL_UNHOLY_STRIKE);
            m_uiSTRIKE_Timer = 6000;
         }
         else
            m_uiSTRIKE_Timer -= uiDiff;

         if (m_uiSAP_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_BLOOD_SAP);

            m_uiSAP_Timer = urand(15000, 25000);
         }
         else
            m_uiSAP_Timer -= uiDiff;

         if (m_uiSHADOWSTEP_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_SHADOWSTEP);

            m_uiSHADOWSTEP_Timer = urand(15000, 20000);
         }
         else
            m_uiSHADOWSTEP_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_darkfallen_tacticianAI(creature);
   }
};

class npc_ymirjar_deathbringer : public CreatureScript
{
public:
   npc_ymirjar_deathbringer() : CreatureScript("npc_ymirjar_deathbringer") { }

   struct npc_ymirjar_deathbringerAI : public ScriptedAI
   {
      npc_ymirjar_deathbringerAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiBANISH_Timer;
      uint32 m_uiEMBRACE_Timer;
      uint32 m_uiBOLT_Timer;

      void Reset() override
      {
         m_uiBANISH_Timer = urand(5000, 10000);
         m_uiEMBRACE_Timer = urand(10000, 15000);
         m_uiBOLT_Timer = urand(1000, 2000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiEMBRACE_Timer <= uiDiff)
         {
            DoCast(me, RAID_MODE(SPELL_DEATHS_EMBRACE_10N, SPELL_DEATHS_EMBRACE_25N, SPELL_DEATHS_EMBRACE_10N, SPELL_DEATHS_EMBRACE_25N));
            m_uiEMBRACE_Timer = urand(15000, 25000);
         }
         else
            m_uiEMBRACE_Timer -= uiDiff;

         if (m_uiBANISH_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_BANISH);

            m_uiBANISH_Timer = urand(15000, 25000);
         }
         else
            m_uiBANISH_Timer -= uiDiff;

         if (m_uiBOLT_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), RAID_MODE(SPELL_SHADOW_BOLT_YMIRJAR_10N, SPELL_SHADOW_BOLT_YMIRJAR_25N, SPELL_SHADOW_BOLT_YMIRJAR_10N, SPELL_SHADOW_BOLT_YMIRJAR_25N));
            m_uiBOLT_Timer = 2000;
         }
         else
            m_uiBOLT_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_ymirjar_deathbringerAI(creature);
   }
};

class npc_ymirjar_frostbinder : public CreatureScript
{
public:
   npc_ymirjar_frostbinder() : CreatureScript("npc_ymirjar_frostbinder") { }

   struct npc_ymirjar_frostbinderAI : public ScriptedAI
   {
      npc_ymirjar_frostbinderAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiORB_Timer;

      void Reset()
      {
         m_uiORB_Timer = 1000;
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiORB_Timer <= uiDiff)
         {
            DoCastAOE(SPELL_FROZEN_ORB);
            m_uiORB_Timer = urand(3000, 5000);
         }
         else
            m_uiORB_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_ymirjar_frostbinderAI(creature);
   }
};

class npc_ymirjar_battlemaiden : public CreatureScript
{
public:
   npc_ymirjar_battlemaiden() : CreatureScript("npc_ymirjar_battlemaiden") { }

   struct npc_ymirjar_battlemaidenAI : public ScriptedAI
   {
      npc_ymirjar_battlemaidenAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiRUSH_Timer;
      uint32 m_uiSTRIKE_Timer;

      void Reset() override
      {
         m_uiRUSH_Timer = urand(10000, 15000);
         m_uiSTRIKE_Timer = urand(1000, 5000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiSTRIKE_Timer <= uiDiff)
         {
            DoCast(me->GetVictim(), SPELL_BARBARIC_STRIKE);
            m_uiSTRIKE_Timer = urand(2000, 3000);
         }
         else
            m_uiSTRIKE_Timer -= uiDiff;

         if (m_uiRUSH_Timer <= uiDiff)
         {
            DoCast(me, SPELL_ADRENALINE_RUSH);
            m_uiRUSH_Timer = urand(15000, 25000);
         }
         else
            m_uiRUSH_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_ymirjar_battlemaidenAI(creature);
   }
};

class npc_ymirjar_huntress : public CreatureScript
{
public:
   npc_ymirjar_huntress() : CreatureScript("npc_ymirjar_huntress") { }

   struct npc_ymirjar_huntressAI : public ScriptedAI
   {
      npc_ymirjar_huntressAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiTRAP_Timer;
      uint32 m_uiRSHOT_Timer;
      uint32 m_uiSHOT_Timer;
      uint32 m_uiVOLLEY_Timer;

      void Reset()
      {
         m_uiTRAP_Timer = urand(5000, 15000);
         m_uiRSHOT_Timer = urand(10000, 15000);
         m_uiSHOT_Timer = urand(1000, 2000);
         m_uiVOLLEY_Timer = urand(5000, 15000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void EnterCombat(Unit* /*target*/) override
      {
         if (Is25ManRaid())
            DoCast(SPELL_SUMMON_WARHAWK);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiRSHOT_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_RAPID_SHOT);

            m_uiRSHOT_Timer = urand(15000, 25000);
         }
         else
            m_uiRSHOT_Timer -= uiDiff;

         if (m_uiVOLLEY_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_VOLLEY);

            m_uiVOLLEY_Timer = urand(10000, 15000);
         }
         else
            m_uiVOLLEY_Timer -= uiDiff;

         if (m_uiTRAP_Timer <= uiDiff)
         {
            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_ICE_TRAP);

            m_uiTRAP_Timer = urand(30000, 35000);
         }
         else
            m_uiTRAP_Timer -= uiDiff;

         if (me->isAttackReady())
         {
            if (me->IsWithinMeleeRange(me->GetVictim()))
               DoMeleeAttackIfReady();
            else if (m_uiSHOT_Timer <= uiDiff)
            {
               DoCast(me->GetVictim(), SPELL_SHOOT);
               m_uiSHOT_Timer = 1000;
            }
            else
               m_uiSHOT_Timer -= uiDiff;
         }
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_ymirjar_huntressAI(creature);
   }
};

class npc_ymirjar_warlord : public CreatureScript
{
public:
   npc_ymirjar_warlord() : CreatureScript("npc_ymirjar_warlord") { }

   struct npc_ymirjar_warlordAI : public ScriptedAI
   {
      npc_ymirjar_warlordAI(Creature* pCreature) : ScriptedAI(pCreature) {}

      uint32 m_uiWHIRLWIND_Timer;

      void Reset() override
      {
         m_uiWHIRLWIND_Timer = urand(5000, 15000);
      }

      void JustDied(Unit* killer) override
      {
         DoCast(me, SPELL_SOUL_FEAST_ALL);
      }

      void UpdateAI(const uint32 uiDiff) override
      {
         if (!UpdateVictim())
            return;

         if (m_uiWHIRLWIND_Timer <= uiDiff)
         {
            DoCastAOE(SPELL_WHIRLWIND);
            m_uiWHIRLWIND_Timer = urand(12000, 20000);
         }
         else
            m_uiWHIRLWIND_Timer -= uiDiff;

         DoMeleeAttackIfReady();
      }
   };

   CreatureAI *GetAI(Creature *creature) const
   {
      return new npc_ymirjar_warlordAI(creature);
   }
};

void AddSC_icc_trash()
{
   new npc_NerubarBroodkeeper();
   new npc_ServantoftheThrone();
   new npc_AncientSkeletalSoldier();
   new npc_DeathboundWard();
   new npc_DeathspeakerAttedant();
   new npc_DeathspeakerDisciple();
   new npc_DeathspeakerServant();
   new npc_DeathspeakerZealot();
   new npc_valkyr_herald();
   new npc_blighted_abomination();
   new npc_vengeful_fleshreapert();
   new npc_plague_scientist();
   new npc_pustulating_horror();
   new npc_decaying_colossus();
   new npc_darkfallen_archmage();
   new npc_darkfallen_blood_knight();
   new npc_darkfallen_noble();
   new npc_vampiric_fiend();
   new npc_darkfallen_advisor();
   new npc_darkfallen_commander();
   new npc_darkfallen_lieutenant();
   new npc_darkfallen_tactician();
   new npc_ymirjar_deathbringer();
   new npc_ymirjar_frostbinder();
   new npc_ymirjar_battlemaiden();
   new npc_ymirjar_huntress();
   new npc_ymirjar_warlord();
}

SQL
Código:
UPDATE creature_template SET AIName = "" WHERE entry IN (36725, 36724, 37012, 37007, 36811, 36807, 36805, 36808, 37098, 37022, 37038, 37023, 10404, 36880, 37664, 37595, 37663, 37901, 37571, 37662, 37665, 37666, 38125, 37127, 37132, 37134, 37133);
UPDATE `creature_template` SET `ScriptName` = 'npc_NerubarBroodkeeper' WHERE `entry` = 36725;
UPDATE `creature_template` SET `ScriptName` = 'npc_ServantoftheThrone' WHERE `entry` = 36724;
UPDATE `creature_template` SET `ScriptName` = 'npc_AncientSkeletalSoldier' WHERE `entry` = 37012;
UPDATE `creature_template` SET `ScriptName` = 'npc_DeathboundWard' WHERE `entry` = 37007;
UPDATE `creature_template` SET `ScriptName` = 'npc_DeathspeakerAttedant' WHERE `entry` = 36811;
UPDATE `creature_template` SET `ScriptName` = 'npc_DeathspeakerDisciple' WHERE `entry` = 36807;
UPDATE `creature_template` SET `ScriptName` = 'npc_DeathspeakerServant' WHERE `entry` = 36805;
UPDATE `creature_template` SET `ScriptName` = 'npc_DeathspeakerZealot' WHERE `entry` = 36808;
UPDATE creature_template SET scriptname = "npc_valkyr_herald" WHERE entry = 37098;
UPDATE creature_template SET scriptname = "npc_blighted_abomination" WHERE entry = 37022;
UPDATE creature_template SET scriptname = "npc_vengeful_fleshreapert" WHERE entry = 37038;
UPDATE creature_template SET scriptname = "npc_plague_scientist" WHERE entry = 37023;
UPDATE creature_template SET scriptname = "npc_pustulating_horror" WHERE entry = 10404;
UPDATE creature_template SET scriptname = "npc_decaying_colossus" WHERE entry = 36880;
UPDATE creature_template SET scriptname = "npc_darkfallen_archmage" WHERE entry = 37664;
UPDATE creature_template SET scriptname = "npc_darkfallen_blood_knight" WHERE entry = 37595;
UPDATE creature_template SET scriptname = "npc_darkfallen_noble" WHERE entry = 37663;
UPDATE creature_template SET scriptname = "npc_vampiric_fiend" WHERE entry = 37901;
UPDATE creature_template SET scriptname = "npc_darkfallen_advisor" WHERE entry = 37571;
UPDATE creature_template SET scriptname = "npc_darkfallen_commander" WHERE entry = 37662;
UPDATE creature_template SET scriptname = "npc_darkfallen_lieutenant" WHERE entry = 37665;
UPDATE creature_template SET scriptname = "npc_darkfallen_tactician" WHERE entry = 37666;
UPDATE creature_template SET scriptname = "npc_ymirjar_deathbringer" WHERE entry = 38125;
UPDATE creature_template SET scriptname = "npc_ymirjar_frostbinder" WHERE entry = 37127;
UPDATE creature_template SET scriptname = "npc_ymirjar_battlemaiden" WHERE entry = 37132;
UPDATE creature_template SET scriptname = "npc_ymirjar_huntress" WHERE entry = 37134;
UPDATE creature_template SET scriptname = "npc_ymirjar_warlord" WHERE entry = 37133;


Última edição por grimgravy em Dom 2 Nov 2014 - 19:51, editado 8 vez(es)

grimgravy


Mensagens : 106
Pontos : 219

Ver perfil do usuário http://www.youtube.com/watch?v=V9teI6t13yg&list=PL1FD324993A

Voltar ao Topo Ir em baixo

Re: Icecrown_trash

Mensagem por Aquilla em Qua 18 Set 2013 - 21:30

coloque o que o script c++ faz por favor. assim fica mais fácil a compreensão de quem quiser utiliza-lo.

Aquilla


Mensagens : 1305
Pontos : 16155

Ver perfil do usuário http://www.google.com.br

Voltar ao Topo Ir em baixo

Re: Icecrown_trash

Mensagem por WoWCore em Qui 19 Set 2013 - 10:58

Pelo código me parece ser um bom script, assim que tiver tempo vou testar.
Valeu por compartilhar e não esquece dos créditos

WoWCore


Mensagens : 619
Pontos : 2179
Evolução : 5


Ver perfil do usuário http://www.mthsena.info

Voltar ao Topo Ir em baixo

Re: Icecrown_trash

Mensagem por Conteúdo patrocinado Hoje à(s) 23:25


Conteúdo patrocinado


Voltar ao Topo Ir em baixo

Ver o tópico anterior Ver o tópico seguinte Voltar ao Topo


 
Permissão deste fórum:
Você não pode responder aos tópicos neste fórum