Jump to content

  • Announcements

    • Xmat

      Pravidlo pro postování v TTT

      Do sekce Tipy, triky, tutoriály nepatří žádné dotazy.   Postujte sem vaše návody, tipy a různé další věci jež uznáte za vhodné sdělit zdejšímu osazenstvu, ale veškeré dotazy směřujte do sekce Všeobecná diskuse.
    • Replik

      Seznam návodů a důležitých témat v této sekci

      Pro lepší přehlednost jsem vytvořil tento seznam, který vás, méně zkušené, lépe provede touto sekcí. Věřím, že zde najdete, co hledáte. Vypsané jsou návody, které jsou oficiálně uznané jako návody. Běžné diskuze, které neposkytují postupy a rady zvěřejněny nejsou.   Instalace vlastního MaNGOS Serveru Díky těmto návodům budete (měli by jste být) schopni vytvořit a následně spustit váš vlastní server. Nastavení je pro verze s i bez datadisku.   Instalace MaNGOS Serveru (bez datadisku TBC) - Autor Benny Instalace MaNGOS Serveru (s datadiskem TBC) - Autor Malfik Instalace MaNGOS Serveru v prostředí Linux - Autor charlie Instalace MaNGOS Serveru v prostředí Linux - Autor kupkoid   Chyby a jejich řešení při přihlašování k serveru - Autor Cybe   Zálohování uživatelských dat   Dávkový soubor (BAT soubor) pro vytvoření SQL záloh - Autor Replik   Kompilování - tvoření vlastních release (revizí)   Tvorba kompilací pro Win32 (MangoScript) - Autor bLuma   Ostatní - těžko zařaditelné, ale neznamená to, že nejsou dobré   VIP Systém - Autor charlie Tvorba Webových stránek pro MaNGOS - Autor zahuba Tvorba teleportačních NPC (MangoScript) - Autor Replik Registrační web (původně předělaná SPORA) Funkční pro Antrix i MaNGOS - Autor Replik Nastavení a spuštění Minimanager pro MaNGOS - Autor BlackMartin Nastavení MaNGOS Website - Autor Artorius   Samozřejmě jsou zde i jiné návody, ale tyto jsou nejvíce používané, proto věřím, že vám budou nápomocné. Tuto sekci budeme upravovat podle potřeby. Pokud by jste něco nenašli nebo si nevěděli rady, hledejte na fóru a teprve potom založte vlastní topik. Pokud nějaký autor vytvoří kvalitní návod a chtěl by ho zveřejnit i v tomto seznamu, doporučuji, aby mi napsal zprávu skrze PM.   Díky a přeji hezký den na WoWResource   Replik
    • Aristo

      Příspěvky tam, kde nemají co dělat

      Dodržujte zákaz přispívání do topiků s repaky pokud si to zakladatelé nepřejí!! Opakované psaní příspěvků bude trestáno warnem.
    • Aristo

      Používání spoilerů

      Poslední dobou má většina uživatelů fora zvláštní nutkání postovat extrémně dlouhé texty nebo kódy, které zabírají v nejedenom případu i 80% obsahu celé stránky a hodně tak zvedají nepřehlednost v topiku. Chtěl bych všechny uživatele požádat, aby při postování citací, jakýchkoliv kódů, errorů, atp... delších než 30 řádků používali funkci spoileru.   Funkci vyvoláte příkazem [spoiler] text [/spoiler]   Ukázka:  
Sign in to follow this  
Followers 0
ali

[ICC] Script Bosses

By ali, in Scripting

Recommended Posts

ali    18

ali
Posted (edited)

Zdravim pridávam sem par scriptov do Icecrown Citadel ak by to nevyhovovalo môžete zmazať (nieje to moja práca)

 

rotface.cpp

 

 

 


/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

/*Comment:
Script created by Goga (TrinDev Team special for trinity-core.ru and wowjp.net) Please if you use this script contact copiryght*/

#include "ScriptedPch.h"
#include "icecrown_citadel.h"

enum Yells
{
SAY_AGGRO                  = -1666016,
SAY_DEATH                  = -1666024,
SAY_DEATH_2                = -1666025,
SAY_KILLING                = -1666022,
SAY_KILLING_2              = -1666021, 
SAY_BERSERK                = -1666023,
SAY_SLIME_SPRAY            = -1666017,
SAY_EXPLOSION              = -1666018,

};

enum Creatures
{
CREATURE_OOZE_BIG             = 36899,
CREATURE_LITTLE_OOZE          = 36897,
CREATURE_PROFFESOR_PUTRICIDE  = 36678,
};

enum RotfaceSpells
{
SPELL_OOZE_FLOOD           = 71215,
SPELL_SLIME_SPRAY          = 71213,
SPELL_MUTATED_INFECTION    = 71224,
SPELL_BERSERK              = 47008,
};

enum OozeSpells
{
SPELL_STICKY_OOZE          = 71208,
SPELL_RADIATING_OOZE       = 71212,
SPELL_UNSTABLE_OOZE        = 69558,
SPELL_UNSTABLE_EXPLOSION   = 71209,
};

Creature* pProfessor_Putricide;

struct boss_RotfaceAI : public ScriptedAI
{
   boss_RotfaceAI(Creature *pCreature) : ScriptedAI(pCreature)
   {
	m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;

uint32 m_uiOozeFloodTimer;
uint32 m_uiSlimeSprayTimer;
uint32 m_uiMutatedInfectionTimer;
   uint32 m_uiBerserkTimer;
   uint32 m_uiSummonBigTimer;
   uint32 m_uiSummonLittleTimer;

   void Reset()
   {
m_uiOozeFloodTimer = 12000+rand()%3000;
m_uiSlimeSprayTimer = 20000+rand()%2000;
m_uiMutatedInfectionTimer = 6000+rand()%4000;
   m_uiBerserkTimer = 360000;
m_uiSummonLittleTimer = 5000; // not officially ? // hack
m_uiSummonBigTimer = 15000; // not officially // hack


	if(m_pInstance)
	m_pInstance->SetData(DATA_ROTFACE_EVENT, NOT_STARTED);  
   }

   void JustDied(Unit* pKiller)
   {
       DoScriptText(SAY_DEATH, me);
       DoScriptText(SAY_DEATH_2, pProfessor_Putricide);

	if(m_pInstance)
	m_pInstance->SetData(DATA_ROTFACE_EVENT, DONE);  
   }

   void EnterCombat(Unit* who)
   {
	DoScriptText(SAY_AGGRO, me);

	if(m_pInstance)
	m_pInstance->SetData(DATA_ROTFACE_EVENT, IN_PROGRESS);  
   }

   void JustReachedHome()
   {
	if(m_pInstance)
	m_pInstance->SetData(DATA_ROTFACE_EVENT, FAIL);  
   }

   void KilledUnit(Unit *victim)
   {
       DoScriptText(SAY_KILLING, me);
       DoScriptText(SAY_KILLING_2, me);
   }

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

           if (m_uiSummonLittleTimer<= diff)  
           { 
                me->SummonCreature(36897, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 10000);

               m_uiSummonLittleTimer = 23000+rand()%4000; 
           }  
           else m_uiSummonLittleTimer -= diff;

           if (m_uiSummonBigTimer<= diff)  
           { 
                me->SummonCreature(36899, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 10000);

               m_uiSummonBigTimer = 32000+rand()%4000; 
           }  
           else m_uiSummonBigTimer -= diff;


	if (m_uiOozeFloodTimer <= diff)
	{
                 DoCast(SPELL_OOZE_FLOOD);
		m_uiOozeFloodTimer = 12000+rand()%3000;
	} else m_uiOozeFloodTimer -= diff;

	if (m_uiSlimeSprayTimer <= diff)
	{
		DoScriptText(SAY_SLIME_SPRAY, me);
                 DoCast(SPELL_SLIME_SPRAY);
		m_uiSlimeSprayTimer = 20000+rand()%2000;
	} else m_uiSlimeSprayTimer -= diff;

	if (m_uiMutatedInfectionTimer <= diff)
	{
                 DoCast(SPELL_MUTATED_INFECTION);
		m_uiMutatedInfectionTimer = 6000+rand()%4000;
	} else m_uiMutatedInfectionTimer -= diff;

	if (m_uiBerserkTimer <= diff)
	{
                 DoScriptText(SAY_BERSERK, me);
                 DoCast(SPELL_BERSERK);
		m_uiBerserkTimer = 360000;
	} else m_uiBerserkTimer -= diff;

	DoMeleeAttackIfReady();
}
};

struct npc_OozeBigAI : public ScriptedAI
{
   npc_OozeBigAI(Creature *pCreature) : ScriptedAI(pCreature)
   {
	m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;

uint32 m_uiStickyOozeTimer;
uint32 m_uiRadiatingOozeTimer;
uint32 m_uiUnstableOozeTimer;
     uint32 m_uiUnstableExplosionTimer;

   void Reset()
   {
m_uiStickyOozeTimer = 5000+rand()%3000;
m_uiRadiatingOozeTimer = 7000+rand()%2000;
     m_uiUnstableOozeTimer = 4000;
     m_uiUnstableExplosionTimer = 20000;
   }

   void EnterCombat(Unit* who)
   {
   }

   void KilledUnit(Unit *victim)
   {
   }

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

	if (m_uiStickyOozeTimer <= diff)
	{
                 DoCast(SPELL_STICKY_OOZE);
		m_uiStickyOozeTimer = 5000+rand()%3000;
	} else m_uiStickyOozeTimer -= diff;

	if (m_uiRadiatingOozeTimer <= diff)
	{
                 DoCast(SPELL_RADIATING_OOZE);
		m_uiRadiatingOozeTimer = 360000;
	} else m_uiRadiatingOozeTimer -= diff;

	if (m_uiUnstableOozeTimer <= diff)
	{
		DoCast(me, SPELL_UNSTABLE_OOZE);
		 m_uiUnstableOozeTimer = 4000;
	} else m_uiUnstableOozeTimer -= diff;

	if (m_uiUnstableExplosionTimer <= diff)
	{
                 DoCast(SPELL_UNSTABLE_EXPLOSION);
		m_uiUnstableExplosionTimer = 20000;
	} else m_uiUnstableExplosionTimer -= diff;

	DoMeleeAttackIfReady();
}
};

struct npc_OozeLittleAI : public ScriptedAI
{
   npc_OozeLittleAI(Creature *pCreature) : ScriptedAI(pCreature)
   {
	m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;

uint32 m_uiStickyOozeTimer;
uint32 m_uiRadiatingOozeTimer;

   void Reset()
   {
m_uiStickyOozeTimer = 5000+rand()%2000;
m_uiRadiatingOozeTimer = 6000+rand()%3000;
   }

   void EnterCombat(Unit* who)
   {
   }

   void KilledUnit(Unit *victim)
   {
   }

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

	if (m_uiStickyOozeTimer <= diff)
	{
		DoCast(SPELL_STICKY_OOZE);
		m_uiStickyOozeTimer = 5000+rand()%3000;
	} else m_uiStickyOozeTimer -= diff;

	if (m_uiRadiatingOozeTimer <= diff)
	{
		DoCast(SPELL_RADIATING_OOZE);
		m_uiRadiatingOozeTimer = 360000;
	} else m_uiRadiatingOozeTimer -= diff;

	DoMeleeAttackIfReady();
}
};

CreatureAI* GetAI_boss_Rotface(Creature* pCreature)
{
   return new boss_RotfaceAI(pCreature);
}

CreatureAI* GetAI_npc_OozeBig(Creature* pCreature)
{
   return new npc_OozeBigAI(pCreature);
}

CreatureAI* GetAI_npc_OozeLittle(Creature* pCreature)
{
   return new npc_OozeLittleAI(pCreature);
}

void AddSC_boss_rotface()
{
   Script* NewScript;

   NewScript = new Script;
   NewScript->Name = "boss_Rotface";
   NewScript->GetAI = &GetAI_boss_Rotface;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "npc_OozeBig";
   NewScript->GetAI = &GetAI_npc_OozeBig;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "npc_OozeLittle";
   NewScript->GetAI = &GetAI_npc_OozeLittle;
   NewScript->RegisterSelf();
}

 

 

 

 

lady_deadwhisper.cpp

 

 



/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "ScriptedPch.h"
#include "icecrown_citadel.h"

enum DeathwhisperSpells
{
SPELL_DEATH_AND_DECAY_10_NORMAL	=	72108,
   SPELL_DEATH_AND_DECAY_25_NORMAL	=	72110,
SPELL_DEATH_AND_DECAY_10_HEROIC	=	71001,
   SPELL_DEATH_AND_DECAY_25_HEROIC	=	72110,
SPELL_DOMINATE_MIND				=	71289,
SPELL_SHADOW_BOLT_10_NORMAL     =   71254,
SPELL_SHADOW_BOLT_25_NORMAL     =   72008,
SPELL_SHADOW_BOLT_10_HEROIC     =   72008,
SPELL_SHADOW_BOLT_25_HEROIC     =   72504,
SPELL_MANA_BARRIER				=	70842,
SPELL_DARK_TRANSFORMATION		=	70900,
SPELL_DARK_EMPOWEREMENT			=	70901,
SPELL_FROST_BOLT_10_NORMAL      =   71420,
SPELL_FROST_BOLT_25_NORMAL      =   72501,
SPELL_FROST_BOLT_10_HEROIC      =   72007,
SPELL_FROST_BOLT_25_HEROIC      =   72502,
SPELL_FROST_BOLT_VALLEY_10_NORMAL	=	72905,
SPELL_FROST_BOLT_VALLEY_25_NORMAL   =	72906,
SPELL_FROST_BOLT_VALLEY_10_HEROIC   =	72907,
SPELL_FROST_BOLT_VALLEY_25_HEROIC   =	72908,
SPELL_SUMMON_SHADE				=	71363,
SPELL_INSIGNIFICANCE			=	71204,
SPELL_ROOT						=	42716,
SPELL_BERSERK					=	47008,
SPELL_BLAST_10_NORMAL           =   72010,
   SPELL_BLAST_10_HEROIC           =   72012,
SPELL_BLAST_25_NORMAL           =   72010,
   SPELL_BLAST_25_HEROIC           =   72012,
SPELL_PORT_VISUAL				=	41236,
//SPELL_ANIMATED_DEAD			=	?????,
};

enum Summons
{
NPC_CULT_ADHERENT          = 37949,
   NPC_CULT_FANATIC           = 37890,
   NPC_VENGEFUL_SHADE         = 38222,
};

enum Yells
{
SAY_INTRO_1			=	-1665907,
SAY_INTRO_2			=	-1665908,
SAY_INTRO_3			=	-1665902,	
SAY_INTRO_4			=	-1665903,
SAY_INTRO_5			=	-1665904,
SAY_INTRO_6			=	-1665905,
SAY_INTRO_7			=	-1665906,
SAY_AGGRO			=	-1665909,
SAY_PHASE_2			=	-1665910,
SAY_EMPOWERMENT		=	-1665911,
SAY_TRANSFORMATION	=	-1665912,
SAY_ANIMATE_DEAD	=	-1665913,
SAY_KILL_1			=	-1665917,
SAY_KILL_2			=	-1665918,
SAY_BERSERK			=	-1665915,
SAY_DEATH			=	-1665916,	
};

#define ADD_1X -619.006
#define ADD_1Y 2158.104
#define ADD_1Z 50.848
#define ADD_2X -598.697
#define ADD_2Y 2157.767
#define ADD_2Z 50.848
#define ADD_3X -577.992
#define ADD_3Y 2156.989
#define ADD_3Z 50.848
#define ADD_4X -618.748
#define ADD_4Y 2266.648
#define ADD_4Z 50.849
#define ADD_5X -598.573
#define ADD_5Y 2266.870
#define ADD_5Z 50.849
#define ADD_6X -578.360
#define ADD_6Y 2267.210
#define ADD_6Z 50.849
#define ADD_7X -555.643
#define ADD_7Y 2211.281
#define ADD_7Z 49.476

struct NotCharmedTargetSelector : public std::unary_function<Unit *, bool> 
{
   NotCharmedTargetSelector() {}

   bool operator() (const Unit *pTarget) {
       return (!pTarget->isCharmed());
   }
};

struct Boss_Lady_DeathwisperAI : public ScriptedAI
{
Boss_Lady_DeathwisperAI(Creature *pCreature) : ScriptedAI(pCreature)
   {
	m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;

uint32 m_uiPhase;
uint32 m_uiDominateMindTimer;
uint32 m_uiSummonWaveTimer;
uint32 m_uiDeathandDecayTimer;
uint8  m_uiIntroText;
   uint32 m_uiIntroTextTimer;
uint32 m_uiFrostBoltTimer;
uint32 m_uiFrostValleyTimer;
uint32 m_uiShadowBoltTimer;
uint32 m_uiDarkEmpoweredTimer;
uint32 m_uiBerserkTimer;
   uint32 m_uiInsignificanceTimer;
uint32 m_uiShadeTimer;

   void Reset()
   {
	m_uiPhase = 1;
	m_uiSummonWaveTimer	= 60000;
	m_uiDeathandDecayTimer = 10000;
	m_uiIntroText = 0;
       m_uiIntroTextTimer = 15000;
	m_uiFrostBoltTimer = 16000;
	m_uiFrostValleyTimer = 25000;
	m_uiShadowBoltTimer = 7000;
	m_uiDarkEmpoweredTimer	= 26000;
	m_uiBerserkTimer = 600000;
	m_uiInsignificanceTimer = 5000;
	m_uiShadeTimer = 15000;

	if (m_pInstance)
           m_pInstance->SetData(DATA_DEATHWHISPER_EVENT, NOT_STARTED);
   }

   void EnterCombat(Unit* who)
   {
	DoScriptText(SAY_AGGRO, me);

	if (m_pInstance)
           m_pInstance->SetData(DATA_DEATHWHISPER_EVENT, IN_PROGRESS);
   }

void JustDied(Unit* killer)
   {  
	DoScriptText(SAY_DEATH, me);

	if (m_pInstance)
           m_pInstance->SetData(DATA_DEATHWHISPER_EVENT, DONE);
   }

void KilledUnit(Unit *victim)
   {
       DoScriptText(RAND(SAY_KILL_1,SAY_KILL_2), me);
   }

void MoveInLineOfSight(Unit* pWho)
   {
       if (me->IsWithinDistInMap(pWho, 100.0f) && m_uiIntroText == 0)
       {
           DoScriptText(SAY_INTRO_1, me);
           m_uiIntroText++;
       }
   }

void JustSummoned(Creature* pSummoned)
   {
	pSummoned->CastSpell(pSummoned, SPELL_PORT_VISUAL, false);  

       if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
           pSummoned->AI()->AttackStart(pTarget);
   }

void DamageTaken(Unit *done_by, uint32 &damage)
   {
       if (me->HasAura(SPELL_MANA_BARRIER))
       {
           me->SetHealth(me->GetHealth()+damage);
           me->SetPower(POWER_MANA, me->GetPower(POWER_MANA)>damage ? me->GetPower(POWER_MANA)-damage : 0);
       }
   }

void AdherentList(Unit* me)
{
	me->FindNearestCreature(NPC_CULT_ADHERENT, 200.0f);

       std::list<Creature*> pAdherentList;
       Trinity::AllCreaturesOfEntryInRange checker(me, NPC_CULT_ADHERENT, 200.0f);
       Trinity::CreatureListSearcher<Trinity::AllCreaturesOfEntryInRange> searcher(me, pAdherentList, checker);
       me->VisitNearbyObject(200.0f, searcher);

       if(pAdherentList.empty())
           return;

       std::list<Creature*>::iterator itr = pAdherentList.begin();
       uint32 rnd = rand()%pAdherentList.size();

       for(uint32 i = 0; i < rnd; ++i)
           ++itr;

       (*itr)->CastSpell(me, SPELL_DARK_EMPOWEREMENT, true);
}

void FanaticList(Unit* me)
{
	me->FindNearestCreature(NPC_CULT_FANATIC, 200.0f);

       std::list<Creature*> pFanaticList;
       Trinity::AllCreaturesOfEntryInRange checker(me, NPC_CULT_FANATIC, 200.0f);
       Trinity::CreatureListSearcher<Trinity::AllCreaturesOfEntryInRange> searcher(me, pFanaticList, checker);
       me->VisitNearbyObject(200.0f, searcher);

       if(pFanaticList.empty())
           return;

       std::list<Creature*>::iterator itr = pFanaticList.begin();
       uint32 rnd = rand()%pFanaticList.size();

       for(uint32 i = 0; i < rnd; ++i)
           ++itr;

       (*itr)->CastSpell(me, SPELL_DARK_EMPOWEREMENT, true);
}

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

		if (m_uiIntroTextTimer < uiDiff)
               {
                   DoScriptText(RAND(SAY_INTRO_2,SAY_INTRO_3,SAY_INTRO_4,SAY_INTRO_5,SAY_INTRO_6,SAY_INTRO_7), me);
                   m_uiIntroTextTimer = 15000;
				m_uiIntroText++;
               } 
		    else m_uiIntroTextTimer -= uiDiff;

		if (m_uiBerserkTimer < uiDiff)
           {
			DoCast(me, SPELL_BERSERK);
			DoScriptText(SAY_BERSERK, me);
			m_uiBerserkTimer = 600000;
           }
		else m_uiBerserkTimer -= uiDiff;

		if (m_uiDeathandDecayTimer < uiDiff)
           {
			Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0);
			DoCast(pTarget, RAID_MODE(SPELL_DEATH_AND_DECAY_10_NORMAL,SPELL_DEATH_AND_DECAY_25_NORMAL,SPELL_DEATH_AND_DECAY_10_HEROIC,SPELL_DEATH_AND_DECAY_25_HEROIC));
			m_uiDeathandDecayTimer = 11000;
           }
           else m_uiDeathandDecayTimer -= uiDiff;

              if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC || getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
		   {
		       if (m_uiDominateMindTimer < uiDiff)
			   {
				   Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 1, 200, true);
				   if (pTarget && !pTarget->isCharmed())
				      {
					      DoCast(pTarget, SPELL_DOMINATE_MIND);
				      }
			       m_uiDominateMindTimer = 25000;
                  }
                  else m_uiDominateMindTimer -= uiDiff;
		   }

	if (m_uiPhase == 1)
       {
		if (m_uiShadowBoltTimer < uiDiff)
           {
			Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0);
			DoCast(pTarget, RAID_MODE(SPELL_SHADOW_BOLT_10_NORMAL,SPELL_SHADOW_BOLT_25_NORMAL,SPELL_SHADOW_BOLT_10_HEROIC,SPELL_SHADOW_BOLT_25_HEROIC));
			m_uiShadowBoltTimer = 7000;
           }
		else m_uiShadowBoltTimer -= uiDiff;

		if (m_uiDarkEmpoweredTimer < uiDiff)
           {
			DoScriptText(SAY_EMPOWERMENT, me);
			switch(rand() % 2)
			{
				case 0:
					AdherentList(me);
					break;
				case 1:
					FanaticList(me);
					break;
			}
			m_uiDarkEmpoweredTimer = 26000;
           }
           else m_uiDarkEmpoweredTimer -= uiDiff;

if (getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL || getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC)
{
       if (m_uiSummonWaveTimer < uiDiff)
       {
           Unit* pSummoned= NULL;
           me->SummonCreature(NPC_CULT_FANATIC,ADD_1X,ADD_1Y,ADD_1Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
           me->SummonCreature(NPC_CULT_ADHERENT,ADD_2X,ADD_2Y,ADD_2Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
           me->SummonCreature(NPC_CULT_FANATIC,ADD_3X,ADD_3Y,ADD_3Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
		m_uiSummonWaveTimer = 60000;
       } 
	else m_uiSummonWaveTimer -= uiDiff;
}

if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
{
       if (m_uiSummonWaveTimer < uiDiff)
       {
           Unit* pSummoned= NULL;
           me->SummonCreature(NPC_CULT_FANATIC,ADD_1X,ADD_1Y,ADD_1Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
           me->SummonCreature(NPC_CULT_ADHERENT,ADD_2X,ADD_2Y,ADD_2Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
           me->SummonCreature(NPC_CULT_FANATIC,ADD_3X,ADD_3Y,ADD_3Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
		me->SummonCreature(NPC_CULT_ADHERENT,ADD_4X,ADD_4Y,ADD_4Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
           me->SummonCreature(NPC_CULT_FANATIC,ADD_5X,ADD_5Y,ADD_5Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
           me->SummonCreature(NPC_CULT_ADHERENT,ADD_6X,ADD_6Y,ADD_6Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
		me->SummonCreature(RAND(NPC_CULT_FANATIC, NPC_CULT_ADHERENT), ADD_7X,ADD_7Y,ADD_7Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
		m_uiSummonWaveTimer = 60000;
       } 
	else m_uiSummonWaveTimer -= uiDiff;
}

		if (!me->HasAura(SPELL_MANA_BARRIER))
               DoCast(me, SPELL_MANA_BARRIER);

		if (!me->HasAura(SPELL_ROOT))
               DoCast(me, SPELL_ROOT);

		if ((me->GetPower(POWER_MANA)*100 / me->GetMaxPower(POWER_MANA)) < 1)
		{
			DoScriptText(SAY_PHASE_2, me);
			DoResetThreat();
               m_uiPhase = 2;
           }
	}

	if (m_uiPhase == 2)
       {
           if (me->HasAura(SPELL_MANA_BARRIER))
               me->RemoveAurasDueToSpell(SPELL_MANA_BARRIER);

		if (me->HasAura(SPELL_ROOT))
               me->RemoveAurasDueToSpell(SPELL_ROOT);

		if (m_uiFrostBoltTimer < uiDiff)
           {
                   Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM,1);
				me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_INTERRUPT, false); 
			    DoCast(pTarget, RAID_MODE(SPELL_FROST_BOLT_10_NORMAL,SPELL_FROST_BOLT_25_NORMAL,SPELL_FROST_BOLT_10_HEROIC,SPELL_FROST_BOLT_25_HEROIC));
			    m_uiFrostBoltTimer = 16000;
		}
           else m_uiFrostBoltTimer -= uiDiff;

	if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
	{
		if (m_uiFrostValleyTimer < uiDiff)
           {
			me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_INTERRUPT, true); 
			DoCastAOE(RAID_MODE(SPELL_FROST_BOLT_VALLEY_10_NORMAL,SPELL_FROST_BOLT_VALLEY_25_NORMAL,SPELL_FROST_BOLT_VALLEY_10_HEROIC,SPELL_FROST_BOLT_VALLEY_25_HEROIC));
			m_uiFrostValleyTimer = 25000;
           }
           else m_uiFrostValleyTimer -= uiDiff;
	}

		if (m_uiInsignificanceTimer < uiDiff)
           {
                   Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM,1);
			    DoCast(pTarget, SPELL_INSIGNIFICANCE);
			    m_uiInsignificanceTimer = 5000;
           }
           else m_uiInsignificanceTimer -= uiDiff;

if (getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
{
       if (m_uiSummonWaveTimer < uiDiff)
       {
           Unit* pSummoned= NULL;
           me->SummonCreature(NPC_CULT_FANATIC,ADD_1X,ADD_1Y,ADD_1Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
           me->SummonCreature(NPC_CULT_ADHERENT,ADD_2X,ADD_2Y,ADD_2Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
           me->SummonCreature(NPC_CULT_FANATIC,ADD_3X,ADD_3Y,ADD_3Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
		m_uiSummonWaveTimer = 60000;
       } 
	else m_uiSummonWaveTimer -= uiDiff;
}

if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC)
{
       if (m_uiSummonWaveTimer < uiDiff)
       {
           Unit* pSummoned= NULL;
		me->SummonCreature(RAND(NPC_CULT_FANATIC, NPC_CULT_ADHERENT), ADD_7X,ADD_7Y,ADD_7Z,0,TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,10000);
		m_uiSummonWaveTimer = 60000;
       } 
	else m_uiSummonWaveTimer -= uiDiff;
}
              if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC || getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
		   {

		if (m_uiShadeTimer < uiDiff)
           {
               if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
		        {
			        DoCast(pTarget, SPELL_SUMMON_SHADE);
					m_uiShadeTimer = 15000;
			    }
           } 
		else m_uiShadeTimer -= uiDiff;
		   }

		DoMeleeAttackIfReady();
	}
}
};

struct npc_shadeAI : public ScriptedAI //Dont work
{
   npc_shadeAI(Creature *pCreature) : ScriptedAI(pCreature)
{
	m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;

   void Reset()
   {
       me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
       me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
	me->SetSpeed(MOVE_WALK, 1.1f, true);
   }

   void EnterCombat(Unit* who)
   {
   }

   void KilledUnit(Unit *victim)
   {
   }

 void MoveInLineOfSight(Unit *who)
    {
       if (!me->IsWithinDistInMap(who,3.0f))
       {
           Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM,0); 
		DoCast(pTarget, RAID_MODE(SPELL_BLAST_10_NORMAL,SPELL_BLAST_25_NORMAL,SPELL_BLAST_10_HEROIC,SPELL_BLAST_25_HEROIC));
		return;
       }

       ScriptedAI::MoveInLineOfSight(who);
   }

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

	DoMeleeAttackIfReady();
}
};


CreatureAI* GetAI_Boss_Lady_Deathwisper(Creature* pCreature)
{
   return new Boss_Lady_DeathwisperAI(pCreature);
}

CreatureAI* GetAI_npc_shade(Creature* pCreature)
{
   return new npc_shadeAI(pCreature);
}

void AddSC_boss_deahtwisper()
{
   Script* NewScript;

   NewScript = new Script;
   NewScript->Name = "Boss_Lady_Deathwisper";
   NewScript->GetAI = &GetAI_Boss_Lady_Deathwisper;
   NewScript->RegisterSelf();

   NewScript = new Script;
   NewScript->Name = "npc_shade";
   NewScript->GetAI = &GetAI_npc_shade;
   NewScript->RegisterSelf();
}

 

 

 

the_lich_king.cpp

 

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "ScriptedPch.h"
#include "icecrown_citadel.h"

#define GOSSIP_START_EVENT "We are ready Fordring!"

enum Yells
{
SAY_INTRO_1_KING			=	-1810001,
SAY_INTRO_2_TIRION			=	-1810002,
SAY_INTRO_3_KING			=	-1810003,
SAY_INTRO_4_TIRION			=	-1810004,
SAY_INTRO_5_KING			=	-1810005,
SAY_AGGRO_KING				=	-1810006,
SAY_REMORSELESS_WINTER		=	-1810007,
SAY_RANDOM_1				=	-1810008,
SAY_RANDOM_2				=	-1810009,
SAY_KILL_1					=	-1810010,
SAY_KILL_2					=	-1810011,
SAY_BERSERK					=	-1810012,
SAY_ENDING_1_KING			=	-1810013,
SAY_ENDING_2_KING			=	-1810014,
SAY_ENDING_3_KING			=	-1810015,
SAY_ENDING_4_KING			=	-1810016,
SAY_ENDING_5_TIRION			=	-1810017,
SAY_ENDING_6_KING			=	-1810018,
SAY_ENDING_7_KING			=	-1810019,
SAY_ENDING_8_TIRION			=	-1810020,
SAY_ENDING_9_FATHER			=	-1810021,
SAY_ENDING_10_TIRION		=	-1810022,
SAY_ENDING_11_FATHER		=	-1810023,
SAY_ENDING_12_KING			=	-1810024,
SAY_DEATH_KING				=	-1810025,	
SAY_ESCAPE_FROSTMOURNE		=	-1810026,
SAY_HARVEST_SOUL			=	-1810027,
SAY_DEVOURED_FROSTMOURNE	=	-1810028,
SAY_SUMMON_VALKYR			=	-1810029,
SAY_BROKEN_ARENA			=	-1810030,
SAY_10_PROZENT				=	-1810031, 
};

enum Creatures
{	
CREATURE_TIRION_ICC				=	38995,	
CREAUTRE_MENETHIL				=	38579,
CREATURE_FROSTMOURNE_TRIGGER	=	38584,
CREATURE_ICE_SPHERE				=	36633,
CREATURE_VALKYR					=	36609,
CREATURE_DEFILE					=	38757,
CREATURE_RAGING_SPIRIT			=	36701,
CREATURE_TRIGGER                =   30494,
};

enum Models
{
MODEL_INVISIBLE					=	11686,
};

enum LichKingSpells
{
		  /***** Phase 1 Spells *****/
SPELL_SUMMON_SHAMBLING_HORROR	=	70372,
SPELL_SUMMON_DRUDGE_GHOULS		=	70358,
SPELL_INFEST					=	70541,
SPELL_NECROTIC_PLAGUE			=	70337,
SPELL_PLAGUE_SIPHON				=	74074,

		 /***** Pre Phase Spells *****/
SPELL_REMORSELES_WINTER			=	68981,
SPELL_PAIN_AND_SUFFERING		=	72133,
SPELL_SUMMON_ICE_SPEHERE		=	69104,
SPELL_SUMMON_RAGING_SPIRIT		=	69200,

		/******* Phase 2 Spells ******/
SPELL_SUMMON_VALKYR				=	69037,
SPELL_SOUL_REAPER				=	69409,
SPELL_SUMMON_DEFILE				=	72754,

		/******* Phase 3Spells ******/
SPELL_HARVEST_SOULS				=	68980,
SPELL_HARVEST_SOUL_TELEPORT		=	71372,
SPELL_SUMMON_VILE_SPIRIT		=	70498,
N_25_SPELL_HARVEST_SOULS		=	74325,
};

enum OtherSpells
{
SPELL_QUAKE						=	72262,
SPELL_CHANNEL_KING				=	71769,
SPELL_BROKEN_FROSTMOURNE		=	72398,
SPELL_BOOM_VISUAL				=	72726,
SPELL_ICEBLOCK_TRIGGER			=	71614,
SPELL_TIRION_LIGHT				=	71797,
SPELL_FROSTMOURNE_TRIGGER		=	72405,
SPELL_SUMMON_BROKEN_FROSTMOURNE	=	72406,
SPELL_DISENGAGE					=	61508,
SPELL_FURY_OF_FROSTMOURNE		=	70063,
SPELL_REVIVE_VISUAL				=	37755,
SPELL_REVIVE					=	51918,
SPELL_CLONE_PLAYER              =	57507,
SPELL_BERSERK					=	47008,
SPELL_RAGING_SPIRIT_VISUAL	=	69198,
SPELL_DAMAGE_DEFILE				=	72743,
SPELL_SPAWN_DEFILE				=	72762,
SPELL_ICE_SPHERE_VISUAL			=	69090,
SPELL_ICE_PULSE					=	69091,
SPELL_ICE_BURST					=	69108,
};

enum DefileDamage
{
DEFILE_N_10_DAMAGE	=	3000,
DEFILE_N_25_DAMAGE	=	5000,
};

#define MOVIE_ID_ARTHAS_DEATH	14

const Position MovePosition = {461.792633, -2125.855957, 1040.860107};
const Position MoveEndingPosition = {503.156525, -2124.516602, 1040.860107};
const Position MoveTirionFrostmourne = {490.110779, -2124.989014, 1040.860352};
const Position MoveTirionAttack = {478.333466, -2124.618652, 1040.859863}; 
const Position ValkyrMoveMent = {498.004486, 2201.573486, 1046.093872};

struct Locations
{
   float x,y,z;
};

static Locations TeleportPoint[]=
{
   {959.996, 212.576, 193.843},
   {932.537, 231.813, 193.838},
   {958.675, 254.767, 193.822},
   {946.955, 201.316, 192.535},
   {944.294, 149.676, 197.551},
   {930.548, 284.888, 193.367},
   {965.997, 278.398, 195.777}
};

Creature* pLichKing;
Creature* pTirion;
Creature* pFather;
Creature* pFrostmourne;
Creature* pSafeZone;

struct boss_lich_kingAI : public ScriptedAI
{
   boss_lich_kingAI(Creature* pCreature) : ScriptedAI(pCreature), summons(me) 
   {
       m_pInstance = pCreature->GetInstanceData();
	pLichKing = me;
   }

   ScriptedInstance* m_pInstance;

bool m_bIsDeathPhase;
bool m_bIsTirionSpawned;
bool m_bIsTriggerSpawned;
bool m_bIsBerserk;
bool m_bIsSwitchPhase1;
bool m_bIsSwitchPhase2;

uint32 m_uiEndingTimer;
uint32 m_uiEndingPhase;
uint32 m_uiPhase;
uint32 m_uiTirionSpawneTimer;

/******************* Spells Phase 1 ********************/
uint32 m_uiSummonShamblingHorrorTimer;
uint32 m_uiSummonDrudgeGhoulsTimer;
uint32 m_uiInfestTimer;
uint32 m_uiNecroticPlagueTimer;
uint32 m_uiPlagueSiphonTimer;
uint32 m_uiBerserkTimer;

/******************* Spells Phase 2 ********************/
uint32 m_uiSummonValkyrTimer;
uint32 m_uiSoulReaperTimer;
uint32 m_uiDefileTimer;

/******************* Spells Phase 3 ********************/
uint32 m_uiHarvestSoulTimer;
uint32 m_uiSummonVileSpiritTimer;
uint32 m_uiFrostGramPortTimer;

/******************* Pre Phase Spells ********************/
uint32 m_uiRemorselesWinterTimer;
uint32 m_uiPainandSufferingTimer;
uint32 m_uiQuakeTimer;
uint32 m_uiIcePulsSummonTimer;
uint32 m_uiSummonSpiritTimer;
uint32 m_uiRandomSpeechTimer;

SummonList summons;

   void Reset()
   {
	me->SetReactState(REACT_PASSIVE);

	/******************* Phasen  ******************/
	m_uiPhase = 0;
	m_uiRandomSpeechTimer = urand(25*IN_MILISECONDS,35*IN_MILISECONDS); 
	m_uiBerserkTimer =	900000;

	/******************* Spells Phase 1 ********************/
	m_uiSummonShamblingHorrorTimer	= 20000;
	m_uiSummonDrudgeGhoulsTimer		= 20000;
	m_uiInfestTimer					= 30000;
	m_uiNecroticPlagueTimer			= 30000;
	m_uiPlagueSiphonTimer			= 5000;
	m_uiTirionSpawneTimer			= 5000;

	/****************** Spells Phase 1.5 & Phase 2.5 **************/
	m_uiRemorselesWinterTimer = 5000;
	m_uiQuakeTimer = 70000;
	m_uiIcePulsSummonTimer	= 10000;
	m_uiPainandSufferingTimer = urand(10*IN_MILISECONDS,11*IN_MILISECONDS);
	m_uiSummonSpiritTimer = 18000;

	/******************* Spells Phase 2 *********************/
	m_uiSummonValkyrTimer	= 20000;
	m_uiSoulReaperTimer		= 15000;
	m_uiDefileTimer			= 25000;
	m_uiInfestTimer			= 40000;

	/******************* Spells Phase 3 **********************/
	m_uiSummonVileSpiritTimer = 30000;
	m_uiHarvestSoulTimer = 70000;
	m_uiFrostGramPortTimer = 900000;

	/*********************** Other ***********************/
	m_bIsDeathPhase = false;
	m_bIsTirionSpawned = false;
	m_bIsTriggerSpawned = false;
	m_bIsBerserk = false;
	m_bIsSwitchPhase1 = false;
	m_bIsSwitchPhase2 = false;

	if(m_pInstance)
	m_pInstance->SetData(DATA_LICH_KING_EVENT, NOT_STARTED);  

	summons.DespawnAll();

	me->SetSpeed(MOVE_RUN, 1.8f);

	me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISARMED);
   }

   void EnterCombat(Unit* pWho)
   {
       DoScriptText(SAY_AGGRO_KING, me);
	m_uiPhase = 1;

	if(m_pInstance)
	m_pInstance->SetData(DATA_LICH_KING_EVENT, IN_PROGRESS);  
   }

   void JustDied(Unit* pKiller)
   {
       DoScriptText(SAY_DEATH_KING, me);

	Map::PlayerList const &PlList = me->GetMap()->GetPlayers();

	if (PlList.isEmpty())
		return;

	for (Map::PlayerList::const_iterator i = PlList.begin(); i != PlList.end(); ++i)
	{
		if (Player* pPlayer = i->getSource())
		{
			pPlayer->SendMovieStart(16);
		}
	}

	if(m_pInstance)
	m_pInstance->SetData(DATA_LICH_KING_EVENT, DONE);  
   }

   void JustReachedHome()
   {
	if(m_pInstance)
	m_pInstance->SetData(DATA_LICH_KING_EVENT, FAIL);  
   }

   void KilledUnit(Unit *victim)
   {
	if(!m_bIsDeathPhase)
       DoScriptText(RAND(SAY_KILL_1,SAY_KILL_2), me);
   }

void SummonedCreatureDespawn(Creature *summon) 
{
	summons.Despawn(summon);
}

void JustSummoned(Creature *summon) 
{
	if (summon->GetEntry() == CREATURE_ICE_SPHERE)

	if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM))
	summon->AI()->AttackStart(pTarget);
	summons.Summon(summon);
}

/************* 10% Ending Start ************/
void SetEnding()
{
	m_uiEndingTimer	= 4000;
	m_uiEndingPhase	= 1;
	EndingPhase();
}

void Phasenswitch()
{
	me->SetReactState(REACT_PASSIVE);
	me->AttackStop();
	me->GetMotionMaster()->MovePoint(0, MoveEndingPosition);
}

void KingEnding(uint32 uiTimer)
   {
       m_uiEndingTimer = uiTimer;
       ++m_uiEndingPhase;
   }

   void UpdateAI(const uint32 uiDiff)
   {
	if (m_uiTirionSpawneTimer < uiDiff && !m_bIsTirionSpawned)
	{
		me->SummonCreature(CREATURE_TIRION_ICC, 528.552002, -2124.620117, 1040.859985, 3.183670, TEMPSUMMON_CORPSE_DESPAWN, 5000);
		m_bIsTirionSpawned = true;
	}
	else m_uiTirionSpawneTimer -= uiDiff;

      if(!UpdateVictim())
           return;

	if(!m_bIsDeathPhase)
	{
		if (m_uiRandomSpeechTimer < uiDiff)
		{
		   DoScriptText(RAND(SAY_RANDOM_1,SAY_RANDOM_2), me);
		   m_uiRandomSpeechTimer = urand(30*IN_MILISECONDS,35*IN_MILISECONDS);
		}
		else m_uiRandomSpeechTimer -= uiDiff;
	}


	if (m_uiBerserkTimer < uiDiff && !m_bIsBerserk)
       {
		DoScriptText(SAY_BERSERK, me);
		DoCast(me, SPELL_BERSERK);
           m_bIsBerserk = true;
       }
       else m_uiBerserkTimer -= uiDiff;

	/******************** Start Phase 1 Spells ********************/
	if(m_uiPhase == 1)
	{
		if (m_uiInfestTimer < uiDiff)
           {
			DoCast(me, SPELL_INFEST);
               m_uiInfestTimer = 30000;
           }
           else m_uiInfestTimer -= uiDiff;

		if (m_uiPlagueSiphonTimer < uiDiff)
           {
			DoCast(me, SPELL_PLAGUE_SIPHON);
               m_uiPlagueSiphonTimer = 30000;
           }
           else m_uiPlagueSiphonTimer -= uiDiff;

		if (m_uiSummonDrudgeGhoulsTimer < uiDiff)
           {
			DoCast(me, SPELL_SUMMON_DRUDGE_GHOULS);
               m_uiSummonDrudgeGhoulsTimer = 20000;
           }
           else m_uiSummonDrudgeGhoulsTimer -= uiDiff;

		if (m_uiSummonShamblingHorrorTimer < uiDiff)
           {
			DoCast(me, SPELL_SUMMON_SHAMBLING_HORROR);
               m_uiSummonShamblingHorrorTimer = 60000;
           }
           else m_uiSummonShamblingHorrorTimer -= uiDiff;

		if (m_uiNecroticPlagueTimer < uiDiff)
           {
               if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM,0))
               DoCast(target, SPELL_NECROTIC_PLAGUE);
               m_uiNecroticPlagueTimer = 5000;
           }
           else m_uiNecroticPlagueTimer -= uiDiff;
	}

	/******************** Start Phase 1.5 Spells ********************/
	if(m_uiPhase == 2)
	{
		if (m_uiRemorselesWinterTimer < uiDiff)
           {
			DoScriptText(SAY_REMORSELESS_WINTER, me);
               DoCast(me, SPELL_REMORSELES_WINTER);
               m_uiRemorselesWinterTimer = 90000;
           }
           else m_uiRemorselesWinterTimer -= uiDiff;

		if (m_uiSummonSpiritTimer < uiDiff)
           {
			if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM,0))
               DoCast(target, SPELL_SUMMON_RAGING_SPIRIT);
			m_uiSummonSpiritTimer	= 16000;
           }
           else m_uiSummonSpiritTimer -= uiDiff;

		if (m_uiIcePulsSummonTimer < uiDiff)
           {
               DoCast(me, SPELL_SUMMON_ICE_SPEHERE);
			m_uiIcePulsSummonTimer	= 15000;
           }
           else m_uiIcePulsSummonTimer -= uiDiff;

		if (m_uiPainandSufferingTimer < uiDiff)
           {
               if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
               DoCast(target, SPELL_PAIN_AND_SUFFERING);
			m_uiPainandSufferingTimer = 2000;
           }
           else m_uiPainandSufferingTimer -= uiDiff;

		if (m_uiQuakeTimer < uiDiff)
           {
			DoScriptText(SAY_BROKEN_ARENA, me);
               DoCast(me, SPELL_QUAKE);
			me->SetReactState(REACT_AGGRESSIVE);
			me->GetMotionMaster()->Clear();
               me->GetMotionMaster()->MoveChase(me->getVictim());
			m_uiPhase = 3;

           }
           else m_uiQuakeTimer -= uiDiff;
	}

	/******************** Start Phase 2 Spells ********************/
	if(m_uiPhase == 3)
	{
		if (m_uiDefileTimer < uiDiff)
           {
               if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM,0))
               DoCast(target, SPELL_SPAWN_DEFILE);
               m_uiDefileTimer = 20000;
           }
           else m_uiDefileTimer -= uiDiff;

		if (m_uiSummonValkyrTimer < uiDiff)
           {
			DoScriptText(SAY_SUMMON_VALKYR, me);
			me->SummonCreature(CREATURE_VALKYR, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()+10, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 99999999);
               //DoCast(me, SPELL_SUMMON_VALKYR);
               m_uiSummonValkyrTimer = 20000;
           }
           else m_uiSummonValkyrTimer -= uiDiff;

		if (m_uiSoulReaperTimer < uiDiff)
           {
               DoCast(me->getVictim(), SPELL_SOUL_REAPER);
               m_uiSoulReaperTimer = 20000;
           }
           else m_uiSoulReaperTimer -= uiDiff;

		if (m_uiInfestTimer < uiDiff)
           {
			DoCast(me, SPELL_INFEST);
               m_uiInfestTimer = urand(30*IN_MILISECONDS,35*IN_MILISECONDS);
           }
           else m_uiInfestTimer -= uiDiff;
	}

	/******************** Start Phase 2.5 Spells ********************/
	if(m_uiPhase == 4)
	{
		if (m_uiRemorselesWinterTimer < uiDiff)
           {
			DoScriptText(SAY_REMORSELESS_WINTER, me);
               DoCast(me, SPELL_REMORSELES_WINTER);
               m_uiRemorselesWinterTimer = 90000;
           }
           else m_uiRemorselesWinterTimer -= uiDiff;

		if (m_uiSummonSpiritTimer < uiDiff)
           {
			if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM,0))
               DoCast(target, SPELL_SUMMON_RAGING_SPIRIT);
			m_uiSummonSpiritTimer = 16000;
           }
           else m_uiSummonSpiritTimer -= uiDiff;

		if (m_uiIcePulsSummonTimer < uiDiff)
           {
               DoCast(me, SPELL_SUMMON_ICE_SPEHERE);
			m_uiIcePulsSummonTimer	= 15000;
           }
           else m_uiIcePulsSummonTimer -= uiDiff;

		if (m_uiPainandSufferingTimer < uiDiff)
           {
               if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM,0))
               DoCast(target, SPELL_PAIN_AND_SUFFERING);
			m_uiPainandSufferingTimer = 3000;
           }
           else m_uiPainandSufferingTimer -= uiDiff;

		if (m_uiQuakeTimer < uiDiff)
           {
			DoScriptText(SAY_BROKEN_ARENA, me);
               DoCast(me, SPELL_QUAKE);
			me->SetReactState(REACT_AGGRESSIVE);
			me->GetMotionMaster()->Clear();
               me->GetMotionMaster()->MoveChase(me->getVictim());
			m_uiPhase = 5;
           }
           else m_uiQuakeTimer -= uiDiff;
	}

	/******************** Start Phase 3 Spells ********************/
		if(m_uiPhase == 5)
		{
			if (m_uiSummonVileSpiritTimer < uiDiff)
			{
				DoCast(me, SPELL_SUMMON_VILE_SPIRIT);
				m_uiSummonVileSpiritTimer = 30000;
			}
			else m_uiSummonVileSpiritTimer -= uiDiff;

			if (m_uiHarvestSoulTimer < uiDiff)
			{
				DoScriptText(SAY_HARVEST_SOUL, me);
				Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);
				DoCast(pTarget, SPELL_HARVEST_SOULS);
				m_uiHarvestSoulTimer = 70000;
			}
			else m_uiHarvestSoulTimer -= uiDiff;
		}

	   DoMeleeAttackIfReady();

    /*************** Start Ending Phase ******************/
			if (m_uiEndingTimer <= uiDiff)
				EndingPhase();
			else m_uiEndingTimer -= uiDiff;

	/************* Switch Phase 1 to 2 *************/
	if (HealthBelowPct(70) && !m_bIsSwitchPhase1)
	{
		m_uiPhase = 2;
		Phasenswitch();
		m_bIsSwitchPhase1 = true;
	}
	else /************* Switch Phase 2 to 3 **************/
	if (HealthBelowPct(40) && !m_bIsSwitchPhase2)
	{
		m_uiPhase = 4;
		m_uiRemorselesWinterTimer = 5000;
		m_uiQuakeTimer = 70000;
		m_uiIcePulsSummonTimer	= 10000;
		m_uiPainandSufferingTimer = 10000;
		m_uiSummonSpiritTimer = 18000;
		Phasenswitch();
		m_bIsSwitchPhase2 = true;
	}
	else /************* Save Trigger Spawned ************/
	if (HealthBelowPct(11) && !m_bIsTriggerSpawned)
	{
		pSafeZone = me->SummonCreature(CREATURE_TRIGGER, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN, 360000);
           pSafeZone->AI()->AttackStart(me);
		pSafeZone->SetDisplayId(MODEL_INVISIBLE);
		m_bIsTriggerSpawned = true;
	}
	else /************* Switch Phase 5 to 6 Ending Phase *************/
	if (HealthBelowPct(10) && !m_bIsDeathPhase)
	{
		m_uiPhase = 6;
		m_bIsDeathPhase = true;
		SetEnding();
	}
}
/************ 10% Ending *************/
void ReviveCinematic()
{
	Map::PlayerList const &PlList = pFather->GetMap()->GetPlayers();

	if (PlList.isEmpty())
		return;

	for (Map::PlayerList::const_iterator i = PlList.begin(); i != PlList.end(); ++i)
	{
		if (Player* pPlayer = i->getSource())
		{
			if (pPlayer && pPlayer->isDead())
			{
				pFather->CastSpell(pPlayer, 26687, true);
				pPlayer->ResurrectPlayer(100, false);
			}
		}
	}
}

void EndingPhase()
{
	if( m_uiEndingTimer )
	{
		switch(m_uiEndingPhase)
		{
			case 1: 
				me->GetMotionMaster()->MoveIdle();
				me->SetReactState(REACT_PASSIVE);
				me->AttackStop();
				me->CastStop();
				DoResetThreat();
				DoScriptText(SAY_10_PROZENT, me);
				DoCastAOE(SPELL_FURY_OF_FROSTMOURNE);
				KingEnding(5000);
				break;
			case 2:
				KingEnding(10000);
				break;
			case 3: 
				DoScriptText(SAY_ENDING_1_KING, me);
				KingEnding(24000);
				break;
			case 4: 
				DoScriptText(SAY_ENDING_2_KING, me);
				KingEnding(25000);
				break;
			case 5:
				me->GetMotionMaster()->MovePoint(0, MoveEndingPosition);
				KingEnding(4000);
				break;
			case 6: 
				DoCastAOE(SPELL_CHANNEL_KING);
				DoScriptText(SAY_ENDING_3_KING, me);
				KingEnding(26000);
				break;
			case 7: 
				DoScriptText(SAY_ENDING_4_KING, me);
				KingEnding(9000);
				break;
			case 8: 
				DoScriptText(SAY_ENDING_5_TIRION, pTirion);
				KingEnding(9000);
				break;
			case 9:
				pTirion->CastSpell(pTirion, SPELL_TIRION_LIGHT, false);
				KingEnding(5000);
				break;
			case 10:
				pTirion->RemoveAurasDueToSpell(SPELL_ICEBLOCK_TRIGGER);
				KingEnding(2000);
				break;
			case 11:
				pTirion->GetMotionMaster()->MovePoint(0, MoveTirionFrostmourne);
				KingEnding(1000);
				break;
			case 12:
				pTirion->GetMotionMaster()->MoveJump(517.482910, -2124.905762, 1040.861328, 10.0f, 15.0f); //pTirion->JumpTo(pFrostmourne, 15.0f);
				pTirion->SetUInt32Value(UNIT_NPC_EMOTESTATE, 375);
				KingEnding(1000);
				break;
			case 13:
				me->RemoveAura(SPELL_CHANNEL_KING);
				me->CastSpell(me, SPELL_BOOM_VISUAL, false);
				KingEnding(300);
				break;
			case 14:
				me->CastSpell(me, SPELL_SUMMON_BROKEN_FROSTMOURNE, false);
				KingEnding(3000);
				break;
			case 15:
				me->CastSpell(me, 73017, false);
				KingEnding(1000);
				break;
			case 16:
				DoScriptText(SAY_ENDING_6_KING, me);
				KingEnding(3000);
				break;
			case 17:
				pFrostmourne = me->SummonCreature(27880, me->GetPositionX()+2, me->GetPositionY()+2, me->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 99999999);
				pFrostmourne->CastSpell(pFrostmourne, SPELL_BROKEN_FROSTMOURNE, false);
				pFrostmourne->CastSpell(pFrostmourne, SPELL_FROSTMOURNE_TRIGGER, false);
				pFrostmourne->GetMotionMaster()->MoveChase(me);
				me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISARMED);
				//pTirion->CastSpell(pTirion, SPELL_DISENGAGE, false);
				KingEnding(2000);
				break;
			case 18:
				me->RemoveAllAuras();
				me->RemoveAura(SPELL_SUMMON_BROKEN_FROSTMOURNE);
				DoScriptText(SAY_ENDING_7_KING, me);
				me->SetUInt32Value(UNIT_NPC_EMOTESTATE, 473);
				KingEnding(5000);
				break;
			case 19:
				DoScriptText(SAY_ENDING_8_TIRION, pTirion);
				KingEnding(6000);
				break;
			case 20:
				DoScriptText(SAY_ENDING_9_FATHER, pFather);
				pFather = me->SummonCreature(CREAUTRE_MENETHIL, me->GetPositionX()+5, me->GetPositionY()+5, me->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 0);
				KingEnding(6000);
				break;
			case 21:
				DoScriptText(SAY_ENDING_11_FATHER, pFather);
				pFather->CastSpell(pFather, SPELL_REVIVE_VISUAL, false);
				ReviveCinematic();
				KingEnding(6000);
				break;
			case 22:
				DoScriptText(SAY_ENDING_10_TIRION, pTirion);
				KingEnding(5000);
				break;
			case 23:
				DoScriptText(SAY_ENDING_12_KING, me);
				//pTirion->SetReactState(REACT_AGGRESSIVE);
				//pTirion->AI()->AttackStart(me);
				//pFather->AI()->AttackStart(me);
				KingEnding(5000);
				break;
		}
	}
}
};

struct boss_TirionCitadellAI : public ScriptedAI
{
   boss_TirionCitadellAI(Creature* pCreature) : ScriptedAI(pCreature)
   {
       m_pInstance = (ScriptedInstance*)pCreature->GetInstanceData();
	pTirion = me;
   }

   ScriptedInstance* m_pInstance;

uint32 m_uiIntroTimer;
uint32 m_uiIntroPhase;

   void Reset()
   {
	m_uiIntroTimer	= 0;
	m_uiIntroPhase	= 0;

	me->SetReactState(REACT_PASSIVE);
	me->SetSpeed(MOVE_RUN, 1.8f);
	me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
   }

void StartEvent()
   {
	m_uiIntroTimer = 1000;
	m_uiIntroPhase = 1;
	Intro(); 
   }

void KingIntro(uint32 uiTimer)
   {
       m_uiIntroTimer = uiTimer;
       ++m_uiIntroPhase;
   }

/************* Intro Start Event *************/
void Intro()
{
	if( m_uiIntroTimer )
	{
		switch( m_uiIntroPhase )
		{
			case 1: 
				pLichKing->SetStandState(UNIT_STAND_STATE_STAND);
				pLichKing->AddUnitMovementFlag(MOVEMENTFLAG_WALK_MODE);
				pLichKing->SetSpeed(MOVE_WALK, 1.2f);
				pLichKing->GetMotionMaster()->MovePoint(0, MovePosition);
				me->SetUInt32Value(UNIT_NPC_EMOTESTATE, 375);
				KingIntro(3000);
				break;
			case 2: 
				pLichKing->SetUInt32Value(UNIT_NPC_EMOTESTATE, 1);
				DoScriptText(SAY_INTRO_1_KING, pLichKing);
				KingIntro(14000);
				break;
			case 3:
				pLichKing->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
				DoScriptText(SAY_INTRO_2_TIRION, me);
				KingIntro(9000);
				break;
			case 4:
				DoScriptText(SAY_INTRO_3_KING, pLichKing);
				pLichKing->SetUInt32Value(UNIT_NPC_EMOTESTATE, 392);
				KingIntro(3000);
				break;
			case 5:
				pLichKing->SetUInt32Value(UNIT_NPC_EMOTESTATE, 397);
				KingIntro(2000);
				break;
			case 6:
				pLichKing->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
				KingIntro(21000);
				break;
			case 7:
				me->SetUInt32Value(UNIT_NPC_EMOTESTATE, 397);
				DoScriptText(SAY_INTRO_4_TIRION, me);
				KingIntro(1000);
				break;
			case 8:
				me->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
				me->GetMotionMaster()->MovePoint(0, MoveTirionAttack);
				KingIntro(4000);
				break;
                       case 9:
                             pTirion->CastSpell(pLichKing, SPELL_ICEBLOCK_TRIGGER, false);
				KingIntro(2000);
				break;
			case 10:
				pLichKing->SetUInt32Value(UNIT_NPC_EMOTESTATE, 1);
				DoScriptText(SAY_INTRO_5_KING, pLichKing);
				KingIntro(12000);
				break;
			case 11:
				pLichKing->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
				pLichKing->SetReactState(REACT_AGGRESSIVE);
				KingIntro(6000);
				break;
		}
	}
}

   void UpdateAI(const uint32 uiDiff)
   {
	if (m_uiIntroTimer <= uiDiff)
               Intro();
	else m_uiIntroTimer -= uiDiff;

	if (m_pInstance && m_pInstance->GetData(DATA_LICH_KING_EVENT) == IN_PROGRESS || m_pInstance->GetData(DATA_LICH_KING_EVENT) == DONE)
	{
		me->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
	}

	if (m_pInstance && m_pInstance->GetData(DATA_LICH_KING_EVENT) == NOT_STARTED)
	{
		me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
	}
   }
};

struct mob_IcePulsAI : public ScriptedAI
{
   mob_IcePulsAI(Creature *pCreature) : ScriptedAI(pCreature) 
{
	DoCast(me, SPELL_ICE_SPHERE_VISUAL);
}

uint32 m_uiIcePulseTimer;
uint32 m_uiIceBurstCheckTimer;

void Reset()
   {
	m_uiIcePulseTimer	= 2000;
	m_uiIceBurstCheckTimer	= 2000;
   }

   void EnterCombat(Unit *who) 
{
	DoZoneInCombat();
}

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

       if (me->getVictim()->GetTypeId() != TYPEID_PLAYER) 
		return; 

		if (m_uiIcePulseTimer < uiDiff)
		{
			DoCast(me->getVictim(), SPELL_ICE_PULSE, true);
		}
		else m_uiIcePulseTimer -= uiDiff;

	if (m_uiIceBurstCheckTimer < uiDiff)
	{
		if (me->IsWithinDistInMap(me->getVictim(), 3))
           DoCast(me->getVictim(), SPELL_ICE_BURST);
		m_uiIceBurstCheckTimer = 2000;
	}
	else m_uiIceBurstCheckTimer -= uiDiff;
   }
};

struct mob_ValkyrAI : public ScriptedAI
{
   mob_ValkyrAI(Creature *pCreature) : ScriptedAI(pCreature), vehicle(me->GetVehicleKit())
{
	assert(vehicle);
}

uint32 m_uiGrabTimer;
uint32 m_uiMovementTimer;
uint32 m_uiFallPlayerTimer;

Vehicle *vehicle;

void Reset()
   {
	me->SetFlying(true);
	m_uiGrabTimer = 2000;
	m_uiMovementTimer = 3000;
	m_uiFallPlayerTimer = 10000;
   }

   void EnterCombat(Unit *who) 
{
	DoZoneInCombat();
}

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

	 if (m_uiGrabTimer < uiDiff)
        {
		if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
		{
			pTarget->EnterVehicle(vehicle);
		}
           m_uiGrabTimer = 120000;
        } 
	else m_uiGrabTimer -= uiDiff;

	if (m_uiMovementTimer < uiDiff)
       {
		me->GetMotionMaster()->MovePoint(0, ValkyrMoveMent);
		m_uiMovementTimer = 120000;
       } 
	else m_uiMovementTimer -= uiDiff;

	if (m_uiFallPlayerTimer < uiDiff)
       {
		vehicle->RemoveAllPassengers();
		m_uiFallPlayerTimer = 120000;
       } 
	else m_uiFallPlayerTimer -= uiDiff;
   }
};

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

uint32 m_uiLifeTimer;
uint32 m_uiAggroTimer;

bool m_bIsLife;
bool m_bIsAggroTimer;

void Reset()
   {
	m_uiLifeTimer = 1000;
	m_uiAggroTimer = 4000;
	m_bIsLife = false;
	m_bIsAggroTimer = false;
   }

   void EnterCombat(Unit *who) 
{
	DoZoneInCombat();
}

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

	if (m_uiLifeTimer < uiDiff && !m_bIsLife)
	{
		me->SetUInt32Value(UNIT_NPC_EMOTESTATE, 449);
		m_bIsLife = true;
	}
	else m_uiLifeTimer -= uiDiff;

	if (m_uiAggroTimer < uiDiff && !m_bIsAggroTimer)
	{
		me->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
		m_bIsAggroTimer = true;
	}
	else m_uiAggroTimer -= uiDiff;
   }
};

struct mob_DefileAI : public Scripted_NoMovementAI
{
   mob_DefileAI(Creature *pCreature) : Scripted_NoMovementAI(pCreature)
   {
       m_pInstance = pCreature->GetInstanceData();
	me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
   }

   ScriptedInstance* m_pInstance;

uint32 m_uiDefileTimer;
uint32 m_uiDefileDamageTimer;
uint32 m_uiDespawnTimer;

bool m_bIsDefile;
bool m_bIsDespawnd;

   void Reset()
{
	me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
	//me->SetReactState(REACT_PASSIVE);
	m_uiDefileTimer	= 1000;
	m_uiDefileDamageTimer = 1000;
	m_uiDespawnTimer = 60000;
	m_bIsDefile = false;
	m_bIsDespawnd = false;
}

// Hack Damage Buggt :/
   void DefileDamage()
   {
       Map* pMap = me->GetMap();
       if (pMap && pMap->IsDungeon())
       {
           Map::PlayerList const &PlayerList = pMap->GetPlayers();
           for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
           {
               if (i->getSource() && i->getSource()->GetDistance2d(me) <= 20)
               {
                   int32 damage = RAID_MODE(DEFILE_N_10_DAMAGE, DEFILE_N_25_DAMAGE);
                   me->DealDamage(i->getSource(), damage, NULL, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_SHADOW);
               }
           }
       }
   }

   void UpdateAI(const uint32 uiDiff)
   {
	if (m_uiDefileTimer < uiDiff && !m_bIsDefile)
	{
		DoCast(me, SPELL_DAMAGE_DEFILE);
		m_bIsDefile = true;
	}
	else m_uiDefileTimer -= uiDiff;

	if (m_uiDefileDamageTimer < uiDiff)
	{
		DefileDamage();
		m_uiDefileDamageTimer = 1000;
	}
	else m_uiDefileDamageTimer -= uiDiff;

	if (m_uiDespawnTimer < uiDiff && !m_bIsDespawnd)
	{
		me->SetVisibility(VISIBILITY_OFF);
		me->DealDamage(me, me->GetHealth(), NULL, DIRECT_DAMAGE,SPELL_SCHOOL_MASK_NORMAL, NULL, false);
		m_bIsDespawnd = true;
       }
	else m_uiDespawnTimer -= uiDiff;
   }
};

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

void Reset()
   {
	DoCast(me, SPELL_RAGING_SPIRIT_VISUAL);
   }

   void EnterCombat(Unit *who) 
{
	DoZoneInCombat();
}

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

CreatureAI* GetAI_mob_RagingSpirit(Creature* pCreature)
{
   return new mob_RagingSpiritAI (pCreature);
}

CreatureAI* GetAI_mob_Defile(Creature* pCreature)
{
   return new mob_DefileAI (pCreature);
}

CreatureAI* GetAI_mob_Ghoul(Creature* pCreature)
{
   return new mob_GhoulAI(pCreature);
}

CreatureAI* GetAI_mob_Valkyr(Creature* pCreature)
{
   return new mob_ValkyrAI(pCreature);
}

CreatureAI* GetAI_mob_IcePuls(Creature* pCreature)
{
   return new mob_IcePulsAI(pCreature);
}

CreatureAI* GetAI_boss_TirionCitadell(Creature* pCreature)
{
   return new boss_TirionCitadellAI(pCreature);
}

CreatureAI* GetAI_boss_lich_king(Creature* pCreature)
{
   return new boss_lich_kingAI(pCreature);
}

bool GossipHello_Tirion_ICC(Player* pPlayer, Creature* pCreature)
{
pPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_START_EVENT, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1);
pPlayer->SEND_GOSSIP_MENU(10600, pCreature->GetGUID());
   return true;
}

bool GossipSelect_Tirion_ICC(Player* pPlayer, Creature* pCreature, uint32 uiSender, uint32 uiAction)
{
   if (uiAction == GOSSIP_ACTION_INFO_DEF+1)
   {
	pCreature->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
	pPlayer->CLOSE_GOSSIP_MENU();
	((boss_TirionCitadellAI*)pCreature->AI())->StartEvent();
   }
   return true;
}

void AddSC_boss_lichking()
{
   Script* NewScript;

   NewScript = new Script;
   NewScript->Name = "boss_the_lich_king";
   NewScript->GetAI = &GetAI_boss_lich_king;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "boss_tirion_icc";
NewScript->pGossipHello = &GossipHello_Tirion_ICC;
   NewScript->pGossipSelect = &GossipSelect_Tirion_ICC;
   NewScript->GetAI = &GetAI_boss_TirionCitadell;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "mob_Ice_Puls";
   NewScript->GetAI = &GetAI_mob_IcePuls;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "mob_Valkyr";
   NewScript->GetAI = &GetAI_mob_Valkyr;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "mob_ghoul_icc";
   NewScript->GetAI = &GetAI_mob_Ghoul;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "mob_Defile";
   NewScript->GetAI = &GetAI_mob_Defile;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "mob_RagingSpirit";
   NewScript->GetAI = &GetAI_mob_RagingSpirit;
   NewScript->RegisterSelf();
}

 

 

 

sindragosa.cpp

 

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "ScriptedPch.h"
#include "icecrown_citadel.h"

const Position FlyPosition = { 4523.889160, 2486.907227, 280.249878, 3.155010};
const Position LandPosition = { 4407.439453, 2484.90541,  203.374374, 3.166791};

enum Yells
{
SAY_AGGRO				=	-1666070,
SAY_UNCHAIND_MAGIC		=	-1666071,
SAY_BLISTERING_COLD		=	-1666072,
SAY_BREATH				=	-1666073,
SAY_AIR_PHASE			=	-1666074,
SAY_PHASE_3				=	-1666075,
SAY_KILL_1				=	-1666076,
SAY_KILL_2				=	-1666077,
SAY_BERSERK				=	-1666078,
SAY_DEATH				=	-1666079,
};

enum Spells
{
SPELL_FROST_AURA_10_NORMAL		=	70084,
SPELL_FROST_AURA_25_NORMAL		=	71050,
SPELL_CLEAVE					=	19983,
SPELL_TAIL_SMASH				=	71077,
SPELL_FROST_BREATH_10_NORMAL	=	69649,
SPELL_FROST_BREATH_25_NORMAL	=	71056,
SPELL_PERMEATING_CHILL			=	70107,
SPELL_UNCHAINED_MAGIC			=	69762,
SPELL_ICY_GRIP_TRIGGER			=	70117,
SPELL_ICY_TRIP_PULL				=	70122,
SPELL_BLISTERING_COLD_10_NORMAL	=	70123,
SPELL_BLISTERING_COLD_25_NORMAL	=	71047,
SPELL_FROST_BOMB_TRIGGER		=	69846,
SPELL_FROST_BEACON				=	70126,
SPELL_ICE_TOMB					=	70157, 
SPELL_ICE_TOMB_TRIGGER			=	69675, 
SPELL_FROST_BOMB				=	71053,
SPELL_MYSTIC_BUFFED				=	70128,
SPELL_BERSERK					=	47008,
};

enum Mobs
{
NPC_ICE_TOMB	=	36980,
NPC_FROST_BOMB	=	37186,
};

enum Phase
{
   PHASE_LAND     = 1,
   PHASE_FLY      = 2, 
   PHASE_ENRAGE   = 3,  
};
/*
float IntroWays[8][3] =
{
   {-11053.37,-1794.48,149},
   {-11141.07,-1841.40,125},
   {-11187.28,-1890.23,125},
   {-11189.20,-1931.25,125},
   {-11153.76,-1948.93,125},
   {-11128.73,-1929.75,125},
   {-11140   , -1915  ,122},
   {-11163   , -1903  ,91.473}
};
*/
struct Boss_SindragosaAI : public ScriptedAI
{
Boss_SindragosaAI(Creature*pCreature) : ScriptedAI (pCreature)
   {
	 m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;

uint8 Phase;

uint32 m_uiBreathTimer;
uint32 m_uiCleaveTimer;
uint32 m_uiTailSmashTimer;
uint32 m_uiBlisteringColdTimer;
uint32 m_uiBerserkTimer;
uint32 m_uiMarkTimer;
uint32 m_uiIceBoltTriggerTimer;
uint32 FlyTimer;

   void Reset()
   {
	Phase = PHASE_LAND;

	m_uiBreathTimer = urand(5000,15000);
	m_uiTailSmashTimer = urand(10000,11000);
	m_uiBlisteringColdTimer = urand(30000,31000);
	m_uiMarkTimer = 10000;

	me->SetSpeed(MOVE_WALK, 1.5f, true);
       me->SetSpeed(MOVE_RUN, 1.5f, true);
       me->SetSpeed(MOVE_FLIGHT, 2.5f, true);

	if (m_pInstance)
           m_pInstance->SetData(DATA_SINDRAGOSA_EVENT, NOT_STARTED);
   }

void EnterCombat(Unit* who)
   {
	DoCast(me, RAID_MODE(SPELL_FROST_AURA_10_NORMAL,SPELL_FROST_AURA_25_NORMAL));

	if (m_pInstance)
           m_pInstance->SetData(DATA_SINDRAGOSA_EVENT, IN_PROGRESS);
   }

void JustDied(Unit* killer)
   {  
	DoScriptText(SAY_DEATH, me);

	if (m_pInstance)
           m_pInstance->SetData(DATA_SINDRAGOSA_EVENT, DONE);
   }

void MarkPlayer()
{
	uint32 count = RAID_MODE(1,1,1,1); 
	for (uint8 i = 1; i <= count; i++)
	{
		if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
		if (!pTarget->HasAura(SPELL_FROST_BEACON))
		DoCast(pTarget, SPELL_FROST_BEACON, true);
	}
}

void CastIceBlockTrigger()
{
	uint32 count = RAID_MODE(1,1,1,1); 
       for (uint8 i = 1; i <= count; i++)
	{
		if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
		if (pTarget->HasAura(SPELL_FROST_BEACON))
		DoCast(pTarget, SPELL_ICE_TOMB_TRIGGER, true);
	}
}

void BlisteringCold()
{
	Map* pMap = me->GetMap();
           Map::PlayerList const &PlayerList = pMap->GetPlayers();
           for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
               if (Player* i_pl = i->getSource())
                   if (i_pl->isAlive())
                       i_pl->TeleportTo(me->GetMapId(), me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(), 0, TELE_TO_NOT_LEAVE_COMBAT);
			DoCast(me, SPELL_ICY_GRIP_TRIGGER);
			DoCast(me, RAID_MODE(SPELL_BLISTERING_COLD_10_NORMAL,SPELL_BLISTERING_COLD_25_NORMAL));
}

 void TakeOff()
    {
       //me->MonsterYell(YELL_FLY_PHASE, LANG_UNIVERSAL, NULL);

       me->InterruptSpell(CURRENT_GENERIC_SPELL);
       me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
       /*me->AddUnitMovementFlag(MOVEMENTFLAG_LEVITATING);
       (*me).GetMotionMaster()->Clear(false);
       (*me).GetMotionMaster()->MovePoint(0,IntroWays[2][0],IntroWays[2][1],IntroWays[2][2]);*/

       FlyTimer = urand(45000,60000);
    }

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

if(Phase == PHASE_LAND || Phase == PHASE_ENRAGE)
{
	if (m_uiBreathTimer <= uiDiff)
       {
		DoCast(me->getVictim(), RAID_MODE(SPELL_FROST_BREATH_10_NORMAL,SPELL_FROST_BREATH_25_NORMAL));
           m_uiBreathTimer = urand(14000,20000);
       } 
	else m_uiBreathTimer -= uiDiff;

	if (m_uiCleaveTimer <= uiDiff)
       {
		DoCast(me->getVictim() , SPELL_CLEAVE);
           m_uiCleaveTimer = urand(10000,11000);
       } 
	else m_uiCleaveTimer -= uiDiff;

	if (m_uiTailSmashTimer <= uiDiff)
       {
		TakeOff();//DoCast(me, SPELL_TAIL_SMASH);
           m_uiTailSmashTimer = urand(5000,10000);
       } 
	else m_uiTailSmashTimer -= uiDiff;

	if (m_uiBlisteringColdTimer <= uiDiff)
       {
		BlisteringCold();
           m_uiBlisteringColdTimer = urand(30000,31000);
       } 
	else m_uiBlisteringColdTimer -= uiDiff;
}

if(Phase == PHASE_LAND)
{
// Todo: Flyphase
}

if(Phase == PHASE_FLY)
{	
	if (m_uiMarkTimer < uiDiff)
	{
		MarkPlayer();
		m_uiMarkTimer = 20000;
		m_uiIceBoltTriggerTimer = 5000;
	}
	else m_uiMarkTimer -= uiDiff;

	if (m_uiIceBoltTriggerTimer < uiDiff)
	{
		CastIceBlockTrigger();
		m_uiIceBoltTriggerTimer = 31000;
	}
	else m_uiIceBoltTriggerTimer -= uiDiff;
}

if(Phase == PHASE_ENRAGE)
{
}

if(Phase == PHASE_LAND || Phase == PHASE_FLY)
   {
       if((me->GetHealth()*100) / me->GetMaxHealth() < 35)
       {
		Phase = PHASE_ENRAGE;
		DoCast(me, SPELL_MYSTIC_BUFFED);
	}
}

 DoMeleeAttackIfReady();
   }
};

CreatureAI* GetAI_Boss_Sindragosa(Creature* pCreature)
{
   return new Boss_SindragosaAI(pCreature);
}

void AddSC_boss_sindragosa()
{
   Script *newscript;

   newscript = new Script;
   newscript->Name = "Boss_Sindragosa";
   newscript->GetAI = &GetAI_Boss_Sindragosa;
   newscript->RegisterSelf();
}

 

 

 

 

lord_marrowgar.cpp

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "ScriptedPch.h"
#include "icecrown_citadel.h"

enum Yells
{
SAY_ENTER_ZONE       =    -1665892,
SAY_AGGRO            =    -1665893,
SAY_BONE_STORM       =    -1665894,
SAY_BONESPIKE_1      =    -1665895,
SAY_BONESPIKE_2      =    -1665896,
SAY_BONESPIKE_3      =    -1665897,
SAY_KILL_1           =    -1665898,
SAY_KILL_2           =    -1665899,
SAY_DEATH            =    -1665900,
SAY_BERSERK          =    -1665901,
};

enum Spells
{
SPELL_SABER_SLASH_10_NORMAL	= 69055,
SPELL_SABER_SLASH_25_NORMAL = 69055,
SPELL_SABER_SLASH_10_HEROIC = 70814,
SPELL_SABER_SLASH_25_HEROIC = 70814,
SPELL_COLD_FLAME_10_NORMAL = 69146,
SPELL_COLD_FLAME_25_NORMAL = 70823,
SPELL_COLD_FLAME_10_HEROIC = 70824,
SPELL_COLD_FLAME_25_HEROIC = 70825,
SPELL_COLD_FLAME_SPAWN	   = 69138,
SPELL_BONE_SPIKE_GRAVEYARD = 69057,
SPELL_BONE_SPIKE_IMPALING  = 69065,
SPELL_BONE_STORM_CHANNEL	=	69076,
SPELL_BONE_STORM_10_NORMAL	=	69075,
SPELL_BONE_STORM_25_NORMAL	=	70835,
SPELL_BONE_STORM_10_HEROIC	=	70835,
SPELL_BONE_STORM_25_HEROIC	=	70836,
SPELL_BERSERK				=   26662,
};

enum NPC
{
CREATURE_BONE_SPIKE	=	38711,
CREATURE_COLD_FLAME	=	36672,
};


struct BoneSpikeAI : public Scripted_NoMovementAI
{
   BoneSpikeAI(Creature *pCreature) : Scripted_NoMovementAI(pCreature)
   {
       BoneSpikeGUID = 0;
   }

   uint64 BoneSpikeGUID;

   void SetPrisoner(Unit* uPrisoner)
   {
       BoneSpikeGUID = uPrisoner->GetGUID();
   }

   void Reset()
{ 
	BoneSpikeGUID = 0; 
}

   void JustDied(Unit *killer)
   {
       if (killer->GetGUID() != me->GetGUID())

       if (BoneSpikeGUID)
       {
           Unit* Bone = Unit::GetUnit((*me), BoneSpikeGUID);
           if (Bone)
               Bone->RemoveAurasDueToSpell(SPELL_BONE_SPIKE_IMPALING);
       }
   }

void KilledUnit(Unit *victim)
   {
       if (victim->GetGUID() != me->GetGUID())

       if (BoneSpikeGUID)
       {
           Unit* Bone = Unit::GetUnit((*me), BoneSpikeGUID);
           if (Bone)
               Bone->RemoveAurasDueToSpell(SPELL_BONE_SPIKE_IMPALING);
       }
   }

   void UpdateAI(const uint32 diff)
   {
  Unit* temp = Unit::GetUnit((*me),BoneSpikeGUID);
       if ((temp && temp->isAlive() && !temp->HasAura(SPELL_BONE_SPIKE_IMPALING)) || !temp)
           me->DealDamage(me, me->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
   }
};

struct Boss_Lord_MarrowgarAI : public ScriptedAI
{
   Boss_Lord_MarrowgarAI(Creature *pCreature) : ScriptedAI(pCreature)
   {
    pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* pInstance;

uint32 m_uiSaberSlashTimer;
uint32 m_uiBoneSpikeGraveyardTimer;
uint32 m_uiBoneStormChanelTimer;
uint32 m_uiBoneStormTimer;
uint32 m_uiBoneStormRemoveTimer;
uint32 m_uiColdFlameTimer;
uint32 m_uiBerserkTimer;

bool Intro;

   void Reset()
   {
	m_uiSaberSlashTimer = 6000;
	m_uiBoneSpikeGraveyardTimer	= 15000;
	m_uiColdFlameTimer	= 15000;
	m_uiBoneStormChanelTimer = 30000;
	m_uiBoneStormTimer = 1500;
	m_uiBoneStormRemoveTimer = 20000;
	m_uiBerserkTimer = 600000;

	me->SetSpeed(MOVE_RUN, 2.5f, true);
	me->SetSpeed(MOVE_WALK, 1.8f, true);

	Intro = false;

	if (pInstance)
           pInstance->SetData(DATA_MARROWGAR_EVENT, NOT_STARTED);
   }

   void EnterCombat(Unit* who)
   {
	DoScriptText(SAY_AGGRO, me);

	if (pInstance)
           pInstance->SetData(DATA_MARROWGAR_EVENT, IN_PROGRESS);
   }

void JustDied(Unit* killer)
   {  
	DoScriptText(SAY_DEATH, me);

	if (pInstance)
           pInstance->SetData(DATA_MARROWGAR_EVENT, DONE);
   }

void KilledUnit(Unit *victim)
   {
       DoScriptText(RAND(SAY_KILL_1,SAY_KILL_2), me);
   }

 void MoveInLineOfSight(Unit *who)
    {
       if (!Intro && me->IsWithinDistInMap(who,55.0f))
       {
               DoScriptText(SAY_ENTER_ZONE, me);
               Intro = true;
       }

       ScriptedAI::MoveInLineOfSight(who);
   }

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

	if (m_uiBerserkTimer <= uiDiff)
	{
		DoScriptText(SAY_BERSERK, me);
		DoCast(SPELL_BERSERK);
		m_uiBerserkTimer = 1000000;
	} 
	else m_uiBerserkTimer -= uiDiff;

			if (getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL || getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)
			{
				if (!me->HasAura(SPELL_BONE_STORM_CHANNEL))
	                {
		                if (m_uiBoneSpikeGraveyardTimer < uiDiff)
                               {
								DoScriptText(RAND(SAY_BONESPIKE_1,SAY_BONESPIKE_2,SAY_BONESPIKE_3), me);
			                    uint32 count = RAID_MODE(1,3,1,3); 
                                   for (uint8 i = 1; i <= count; i++)
                                       {
				                        Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 200, true);
				                        if (pTarget && !pTarget->HasAura(SPELL_BONE_SPIKE_IMPALING))
					                        {
						                        Creature* Bone = me->SummonCreature(CREATURE_BONE_SPIKE, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 999999);
						                        CAST_AI(BoneSpikeAI, Bone->AI())->SetPrisoner(pTarget);
						                        Bone->CastSpell(pTarget, SPELL_BONE_SPIKE_IMPALING, true);
					                        }
			                            }
			                            m_uiBoneSpikeGraveyardTimer = 15000;
						     } else m_uiBoneSpikeGraveyardTimer -= uiDiff;

		if (m_uiColdFlameTimer <= uiDiff)
			{
					me->SummonCreature(CREATURE_COLD_FLAME, me->GetPositionX()+20, me->GetPositionY()+20, me->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 8000);
					me->SummonCreature(CREATURE_COLD_FLAME, me->GetPositionX()-20, me->GetPositionY()-20, me->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 8000);
					me->SummonCreature(CREATURE_COLD_FLAME, me->GetPositionX()+20, me->GetPositionY()-20, me->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 8000);
					me->SummonCreature(CREATURE_COLD_FLAME, me->GetPositionX()-20, me->GetPositionY()+20, me->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 8000);
					m_uiColdFlameTimer = 15000;
			} 
			else m_uiColdFlameTimer -= uiDiff;
				}
			}

			if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
			{
			if (m_uiBoneSpikeGraveyardTimer < uiDiff)
			{
                   DoScriptText(RAND(SAY_BONESPIKE_1,SAY_BONESPIKE_2,SAY_BONESPIKE_3), me);
				uint32 count = RAID_MODE(1,3,1,3);
				for (uint8 i = 1; i <= count; i++)
				{
	            Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 200, true);
				if (pTarget && !pTarget->HasAura(SPELL_BONE_SPIKE_IMPALING))
				{
					Creature* Bone = me->SummonCreature(CREATURE_BONE_SPIKE, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 999999);
					CAST_AI(BoneSpikeAI, Bone->AI())->SetPrisoner(pTarget);
					Bone->CastSpell(pTarget, SPELL_BONE_SPIKE_IMPALING, true);
				}
			}
			m_uiBoneSpikeGraveyardTimer = 15000;
           } else m_uiBoneSpikeGraveyardTimer -= uiDiff;
			}

	if (!me->HasAura(SPELL_BONE_STORM_CHANNEL))
	{
		if (m_uiBoneStormChanelTimer <= uiDiff)
		{
			DoCast(SPELL_BONE_STORM_CHANNEL);
		    DoScriptText(SAY_BONE_STORM, me);
			m_uiBoneStormChanelTimer = 30000;
		}
		else m_uiBoneStormChanelTimer -= uiDiff;

	if (m_uiSaberSlashTimer <= uiDiff)
	{
           if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1))
		{
		    DoCast(RAID_MODE(SPELL_SABER_SLASH_10_NORMAL,SPELL_SABER_SLASH_25_NORMAL,SPELL_SABER_SLASH_10_HEROIC,SPELL_SABER_SLASH_10_HEROIC));
		    m_uiSaberSlashTimer = 6000;
		}
	} 
	else m_uiSaberSlashTimer -= uiDiff;

	}

	if (me->HasAura(SPELL_BONE_STORM_CHANNEL))
	{
		if (m_uiBoneStormTimer <= uiDiff)
		{
			DoCastAOE(RAID_MODE(SPELL_BONE_STORM_10_NORMAL,SPELL_BONE_STORM_25_NORMAL,SPELL_BONE_STORM_10_HEROIC,SPELL_BONE_STORM_25_HEROIC));
			m_uiBoneStormTimer = 1500;
		}
		else m_uiBoneStormTimer -= uiDiff;

		if (m_uiBoneStormRemoveTimer <= uiDiff)
		{
               me->RemoveAurasDueToSpell(SPELL_BONE_STORM_CHANNEL);
			m_uiBoneStormRemoveTimer = 20000;
		}
		else m_uiBoneStormRemoveTimer -= uiDiff;
	}

	DoMeleeAttackIfReady();
}
};

struct Cold_FlameAI : public ScriptedAI
{
Cold_FlameAI(Creature *pCreature) : ScriptedAI(pCreature)
   {
    m_pInstance = pCreature->GetInstanceData();
   }
ScriptedInstance* m_pInstance;
uint32 m_uiColdFlameTimer;
   void Reset()
   {
       float x, y, z;
       me->GetNearPoint(me, x, y, z, 1, 50, M_PI*2*rand_norm());
       me->GetMotionMaster()->MovePoint(0, x, y, z);
       me->SetVisibility(VISIBILITY_OFF);
	DoCast(me, RAID_MODE(SPELL_COLD_FLAME_10_NORMAL,SPELL_COLD_FLAME_25_NORMAL,SPELL_COLD_FLAME_10_HEROIC,SPELL_COLD_FLAME_25_HEROIC));
	me->SetReactState(REACT_PASSIVE);
	me->SetSpeed(MOVE_WALK, 1.5f, true);
	m_uiColdFlameTimer = 1000;
   }
void UpdateAI(const uint32 uiDiff)
   {
	if(m_uiColdFlameTimer <= uiDiff)
	{
		DoCast(me, RAID_MODE(SPELL_COLD_FLAME_10_NORMAL,SPELL_COLD_FLAME_25_NORMAL,SPELL_COLD_FLAME_10_HEROIC,SPELL_COLD_FLAME_25_HEROIC));
		m_uiColdFlameTimer = 1000;
	} 
	else m_uiColdFlameTimer -= uiDiff;

}
};

CreatureAI* GetAI_Cold_Flame(Creature* pCreature)
{
   return new Cold_FlameAI(pCreature);
}

CreatureAI* GetAI_Boss_Lord_Marrowgar(Creature* pCreature)
{
   return new Boss_Lord_MarrowgarAI(pCreature);
}

CreatureAI* GetAI_BoneSpike(Creature* pCreature)
{
   return new BoneSpikeAI(pCreature);
}

void AddSC_boss_marrowgar()
{
   Script* NewScript;
   NewScript = new Script;
   NewScript->Name = "Boss_Lord_Marrowgar";
   NewScript->GetAI = &GetAI_Boss_Lord_Marrowgar;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "Cold_Flame";
   NewScript->GetAI = &GetAI_Cold_Flame;
   NewScript->RegisterSelf();	

NewScript = new Script;
   NewScript->Name = "BoneSpike";
   NewScript->GetAI = &GetAI_BoneSpike;
   NewScript->RegisterSelf();	
}

 

 

 

professor_putricide.cpp

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "ScriptedPch.h"
#include "icecrown_citadel.h"

enum Yells
{
SAY_AGGRO		=	-1666025,
SAY_AIRLOCK		=	-1666026,	
SAY_PHASE_HC	=	-1666027,
SAY_TRANSFORM_1	=	-1666028,
SAY_TRANSFORM_2	=	-1666029,
SAY_KILL_1		=	-1666030,
SAY_KILL_2		=	-1666031,
SAY_BERSERK		=	-1666032,
SAY_DEATH		=	-1666033,
};

enum ProfessorSpells
{
SPELL_UNSTABLE_EXPERIMENT			=	71968,
N_SPELL_TEAR_GAS					=	71617,
N_SPELL_CREATE_CONCOTION			=	71621,
N_SPELL_GUZZLE_POTIONS				=	73122,
N_10_SPELL_MALLEABLE_GOO			=	72296,
N_25_SPELL_MALLEABLE_GOO			=	70852,
N_10_SPELL_MUTATED_STRENGTH			=	71603,
N_10_MUTATED_PLAGUE					=	72672,
};

enum OozeSpells
{
N_10_SPELL_OOZE_ERUPTION			=	70492,
N_10_SPELL_OOZE_ADHESIV				=	70447,
N_10_SPELL_CHOKING_GAS				=	71278,
N_10_SPELL_CHOKING_GAS_EXPLOSION	=	71279,
};

enum Summons
{
SUMMON_GASCLOUD			=	37562,
SUMMON_VOLATILE_OOZE	=	37697,
};

enum Achievements
{
};

#define EMOTE_UNSTABLE_EXPERIMENT "Professor Putricide begins unstable experiment!"

struct Boss_ProfessorPutricideAI : public ScriptedAI
{
   Boss_ProfessorPutricideAI(Creature *pCreature) : ScriptedAI(pCreature)
   {
	m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;

uint32 m_uiPhase;
uint32 m_uiUnstableExperimentTimer;
uint32 m_uiAddSpawnTimer;

   void Reset()
   {
	m_uiPhase = 1;
	m_uiUnstableExperimentTimer = 10000;
	m_uiAddSpawnTimer = 60000;

	if (m_pInstance)
           m_pInstance->SetData(DATA_PROFESSOR_PUTRICIDE_EVENT, NOT_STARTED);
   }

   void EnterCombat(Unit* who)
   {
	DoScriptText(SAY_AGGRO, me);

	if (m_pInstance)
           m_pInstance->SetData(DATA_PROFESSOR_PUTRICIDE_EVENT, IN_PROGRESS);
   }

void JustDied(Unit* killer)
   {  
	DoScriptText(SAY_DEATH, me);

	if (m_pInstance)
           m_pInstance->SetData(DATA_PROFESSOR_PUTRICIDE_EVENT, DONE);
   }

void KilledUnit(Unit *victim)
   {
       DoScriptText(RAND(SAY_KILL_1,SAY_KILL_2), me);
   }

void JustSummoned(Creature* pSummoned)
   {
       if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
           pSummoned->AI()->AttackStart(pTarget);
   }

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

	if (m_uiUnstableExperimentTimer < uiDiff)
       {
		DoCast(me, SPELL_UNSTABLE_EXPERIMENT);
		me->MonsterTextEmote(EMOTE_UNSTABLE_EXPERIMENT,NULL);
		m_uiUnstableExperimentTimer = 40000;
		m_uiAddSpawnTimer = 5000;
       }
	else m_uiUnstableExperimentTimer -= uiDiff;

	if (m_uiAddSpawnTimer < uiDiff)
       {
		me->SummonCreature(SUMMON_VOLATILE_OOZE, me->GetPositionX()+20, me->GetPositionY()+20, me->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 9999999);
		m_uiAddSpawnTimer = 60000;
       }
	else m_uiAddSpawnTimer -= uiDiff;

	if (m_uiPhase == 1)
       {
	}

	if (m_uiPhase == 2)
       {
	}
		DoMeleeAttackIfReady();
	}
};

struct VolatileOozeAI : public ScriptedAI
{
   VolatileOozeAI(Creature *pCreature) : ScriptedAI(pCreature) 
{
	me->ApplySpellImmune(0, IMMUNITY_ID, N_10_SPELL_OOZE_ADHESIV, true);
}

   uint64 TargetGUID;

uint32 OozeAdhesivTimer;
uint32 OozeExplosion;
uint32 MovechaseTimer;

   void EnterCombat(Unit *who) 
{
	DoZoneInCombat();
}

   void Reset()
   {
       TargetGUID = 0;
	OozeAdhesivTimer	= 1000;
	OozeExplosion		= 1000;
	MovechaseTimer		= 999999;
   }

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

       if (me->getVictim()->GetTypeId() != TYPEID_PLAYER) 
		return; 

       if (!me->getVictim()->HasAura(N_10_SPELL_OOZE_ADHESIV))
       {
		if (OozeAdhesivTimer < diff)
		{
			uint32 count = RAID_MODE(1,3,1,3);
               for (uint8 i = 1; i <= count; i++)
               {
				DoCast(me->getVictim(), N_10_SPELL_OOZE_ADHESIV, true);
				me->GetMotionMaster()->MoveChase(me->getVictim());
				OozeAdhesivTimer = 999999;
				MovechaseTimer = 10000;
			}
		}
	else OozeAdhesivTimer -= diff;
       }

	if (MovechaseTimer < diff)
	{
		me->AddThreat(me->getVictim(), 10000000.0f);
		me->GetMotionMaster()->MoveChase(me->getVictim());
		MovechaseTimer = 2000;
	}
	else MovechaseTimer -= diff;


	if (OozeAdhesivTimer < diff)
	{
		if (me->IsWithinDistInMap(me->getVictim(), 3))
           DoCast(me->getVictim(), N_10_SPELL_OOZE_ERUPTION);
		OozeAdhesivTimer = 10000;
	}
	else OozeAdhesivTimer -= diff;
   }
};

CreatureAI* GetAI_VolatileOoze(Creature* pCreature)
{
   return new VolatileOozeAI(pCreature);
}

CreatureAI* GetAI_Boss_ProfessorPutricide(Creature* pCreature)
{
   return new Boss_ProfessorPutricideAI(pCreature);
}

void AddSC_boss_professor_putricide()
{
   Script* NewScript;

   NewScript = new Script;
   NewScript->Name = "Boss_ProfessorPutricide";
   NewScript->GetAI = &GetAI_Boss_ProfessorPutricide;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "Mob_VolatileOoze";
   NewScript->GetAI = &GetAI_VolatileOoze;
   NewScript->RegisterSelf();
}

 

 

 

 

Pridávam SQL scripty Ai Text bossov a ScriptName:

 

http://filebeam.com/45e9b0ff1a31a8799a4db28cdf49e746

Edited by ali
  • Upvote 5

Share this post

Link to post
Share on other sites

ali    18

ali
Posted (edited)

festergut.cpp

 

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "ScriptedPch.h"
#include "icecrown_citadel.h"

enum Yells
{
SAY_STINKI_DIES			=	-1666004,
SAY_AGGRO				=	-1666005,
SAY_GAS_CLOUD			=	-1666006,
SAY_GAS_SPORES			=	-1666007,
SAY_PUNGENT_BLIGHT_1	=	-1666008,
SAY_PUNGENT_BLIGHT_2	=	-1666009,
SAY_KILL_1				=	-1666010,
SAY_KILL_2				=	-1666011,
SAY_BERSERK				=	-1666012,
SAY_DEATH_1				=	-1666013,
SAY_DEATH_2				=	-1666014, 
};

enum Spells
{
N_10_SPELL_PUNGENT_BLIGHT		=	69195, 
N_10_SPELL_GASTRIC_EXPLOSION	=	72227, 
SPELL_INHALE_BLIGHT				=	69165,
N_10_SPELL_VILE_GAS				=	72272,
N_10_SPELL_GASTRIC_BLOAT		=	72219,
SPELL_GAS_VISUAL_SMAL			=	69154,
SPELL_GAS_VISUAL_MIDDEL			=	69152,
SPELL_GAS_VISUAL_BIG			=	69126, 
SPELL_GAS_SPORES				=	69279,
SPELL_BERSERK					=	47008,
SPELL_INOCULATED				=	72103,
SPELL_BLIGHTED_SPORES			=	69290, 
};

struct Boss_FestergutAI : public ScriptedAI
{
   Boss_FestergutAI(Creature *pCreature) : ScriptedAI(pCreature)
   {
	m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;

uint32 m_uiPungentBlightTimer;
uint32 m_uiGastricExplosionTimer;
uint32 m_uiInhaleBlightTimer;
uint32 m_uiGasSporesTimer;
uint32 m_uiVileGasTimer;
uint32 m_uiGastricBloatTimer;
     uint32 m_uiBerserkTimer;

   void Reset()
   {
	m_uiPungentBlightTimer	= 120000;
	m_uiInhaleBlightTimer 	= 33000;
	m_uiVileGasTimer = urand(10000,15000);
	m_uiGasSporesTimer = 20000;
	m_uiGastricBloatTimer = 10000;
           m_uiBerserkTimer = 300000;

	if (m_pInstance)
           m_pInstance->SetData(DATA_FESTERGURT_EVENT, NOT_STARTED);
   }

   void EnterCombat(Unit* who)
   {
	DoScriptText(SAY_AGGRO, me);

	if (m_pInstance)
           m_pInstance->SetData(DATA_FESTERGURT_EVENT, IN_PROGRESS);
   }

void JustDied(Unit* killer)
   {  
	DoScriptText(SAY_DEATH_1, me);

	if (m_pInstance)
           m_pInstance->SetData(DATA_FESTERGURT_EVENT, DONE);
   }

void KilledUnit(Unit *victim)
   {
      DoScriptText(RAND(SAY_KILL_1,SAY_KILL_2), me);
   }

void SpellHitTarget(Unit *pTarget,const SpellEntry* spell)
   {
       switch(spell->Id)
       {
		case SPELL_GAS_SPORES:
           HandleTouchedSpells(pTarget, SPELL_BLIGHTED_SPORES);
           break;
       }
   }

void HandleTouchedSpells(Unit *pTarget, uint32 TouchedType)
   {
       switch(TouchedType)
       {
       case SPELL_GAS_SPORES:
               if (pTarget->HasAura(SPELL_BLIGHTED_SPORES))
               {
                   pTarget->CastSpell(pTarget, SPELL_INOCULATED, true);
               } else pTarget->CastSpell(pTarget, SPELL_INOCULATED, true);
			break;
	 }
   }

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

if (m_uiGastricBloatTimer < uiDiff)
{
	if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 1))
	DoCast(me->getVictim(), N_10_SPELL_GASTRIC_BLOAT);
	m_uiGastricBloatTimer = 15000;
}
else m_uiGastricBloatTimer -= uiDiff;

if(m_uiInhaleBlightTimer < uiDiff)
{
	DoCast(me, SPELL_INHALE_BLIGHT);
	m_uiInhaleBlightTimer = 33000;
}
else m_uiInhaleBlightTimer -= uiDiff;

if (m_uiVileGasTimer < uiDiff)
{
	if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
	DoCast(target, N_10_SPELL_VILE_GAS);
	m_uiVileGasTimer = 30000;
}
else m_uiVileGasTimer -= uiDiff;

if (m_uiGasSporesTimer < uiDiff)
{
	if (Unit *target = SelectUnit(SELECT_TARGET_RANDOM, 0))
	target->CastSpell(target, SPELL_GAS_SPORES, true);
	m_uiGasSporesTimer = 35000;
}
else m_uiGasSporesTimer -= uiDiff;

if (m_uiPungentBlightTimer < uiDiff)
{
	DoCastAOE(N_10_SPELL_PUNGENT_BLIGHT);
	m_uiPungentBlightTimer = 120000;
	m_uiInhaleBlightTimer = 33000;
	me->RemoveAllAuras();
}
else m_uiPungentBlightTimer -= uiDiff;

if(m_uiBerserkTimer < uiDiff)
{
	DoCast(me, SPELL_BERSERK);
	m_uiBerserkTimer = 300000;
}

DoMeleeAttackIfReady();
}
};

CreatureAI* GetAI_Boss_Festergut(Creature* pCreature)
{
   return new Boss_FestergutAI(pCreature);
}

void AddSC_boss_festergut()
{
   Script* NewScript;

   NewScript = new Script;
   NewScript->Name = "boss_Festergut";
   NewScript->GetAI = &GetAI_Boss_Festergut;
   NewScript->RegisterSelf();
}

 

 

 

 

valithria_dreamwalker.cpp

 

 

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "ScriptedPch.h"   
#include "icecrown_citadel.h"

enum Yells
{
     SAY_AGGRO                     = -1666063,  
     SAY_BELOW_25                  = -1666066,
     SAY_ABOVE_75                  = -1666065, 
     SAY_DEATH                     = -1666067, 
     SAY_PDEATH                    = -1666068, 
     SAY_END                       = -1666070,
  SAY_BERSERK                   = -1666069,
     SAY_OPEN_PORTAL               = -1666064,
};

enum ValithriaSpells 
{
     SPELL_CORRUPTION                 = 70904, 
     SPELL_DREAM_SLIP                 = 71196, 
     SPELL_RAGE                       = 71189,
};

enum AddsSpells
{
     SPELL_VOLLEY                     = 70759, 
     SPELL_COLUMN                     = 70702, 
     SPELL_MANA_VOID                  = 71085,
     SPELL_CORRUPTING                 = 70602,
     SPELL_WASTE                      = 69325, 
     SPELL_FIREBALL                   = 70754,
     SPELL_SUPRESSION                 = 70588, 
     SPELL_CORROSION                  = 70751, 
     SPELL_BURST                      = 70744, 
     SPELL_SPRAY                      = 71283,  
     SPELL_ROT                        = 72963, 
     SPELL_DREAM_STATE                = 70766, 
     SPELL_PORTAL_VISUAL              = 71304,
     SPELL_VIGOR                      = 70873, 
     SPELL_CLOUD_VISUAL               = 70876, 
};

enum creatures
{	  
     CREATURE_WORM                       = 37907, 
     CREATURE_PORTAL                     = 37945, 
     CREATURE_CLOUD                      = 37985,   
     CREATURE_VOID                       = 38068,  
     CREATURE_ABOMINATION                = 37886, 
     CREATURE_SKELETON                   = 36791, 
     CREATURE_ARCHMAGE                   = 37868, 
     CREATURE_SUPPRESSER                 = 37863, 
     CREATURE_ZOMBIE                     = 37934,  
     CREATURE_COMBAT_TRIGGER             = 38752, 
};

const Position Pos[4] =
{
   {4166.216797f, 2564.197266f, 364.873047f},
   {4240.688477f, 2405.794678f, 364.868591f},
   {4165.112305f, 2405.872559f, 364.872925f},
   {4239.579102f, 2566.753418f, 364.868439f},

};

Unit* pValithria;  
Unit* pPlayer; 
Unit* pBuff;  

Creature* combat_trigger= NULL;

struct boss_valithriaAI : public ScriptedAI
{
   boss_valithriaAI(Creature *c) : ScriptedAI(c)
   {
       m_pInstance = c->GetInstanceData(); 
   }

   ScriptedInstance* m_pInstance;

    uint32 Phase;
    uint32 m_uiPortalTimer;  
 uint32 m_uiEndTimer; 
    uint32 m_uiSummonTimer;
    uint32 m_uiEnd2Timer;  


    bool valithria;
 bool end;  
 bool ABOVEHP; 
 bool BELOWHP;

    void InitializeAI()
   {    
       Phase = 0;
       DoCast(SPELL_CORRUPTION);   
           me->SetHealth(me->GetMaxHealth()/2);  

       m_uiSummonTimer = 999999999;
	m_uiPortalTimer = 999999999; 
    valithria = false;
       end = false;
    ABOVEHP = false; 
	BELOWHP = false;

	ScriptedAI::InitializeAI();
   } 

 void MoveInLineOfSight(Unit *who)
        {
            if(!valithria && who->IsWithinDistInMap(me,40.0f))
                {
	             DoScriptText(SAY_AGGRO, me); 
                    combat_trigger = me->SummonCreature(CREATURE_COMBAT_TRIGGER,me->GetPositionX(), me->GetPositionY(),me->GetPositionZ(),0,TEMPSUMMON_CORPSE_TIMED_DESPAWN,20000);  
	             me->AddThreat(combat_trigger, 10000000.0f); 
	             combat_trigger->AddThreat(me, 10000000.0f);
                    me->AI()->AttackStart(combat_trigger);  
	             combat_trigger->AI()->AttackStart(me);
	             end = false;
	             valithria = true;  
	             ABOVEHP = false; 
	             BELOWHP = false;

	ScriptedAI::MoveInLineOfSight(who);
             }
     }

    void EnterCombat(Unit *who) 
 {
	 me->SetHealth(me->GetMaxHealth() * 0.50); 	  	      
        m_uiSummonTimer = 15000;
	 m_uiPortalTimer = 30000;  
	 Phase = 1;
 }

 	void JustSummoned(Creature* pSummoned)
           {
	        if(!pSummoned->HasAura(SPELL_PORTAL_VISUAL))
	    {
               pSummoned->AI()->AttackStart(me); 
	}
   } 

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

       if (Phase == 1)
        {
               DoStartNoMovement(me->getVictim()); 
	        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE); 
	        m_uiEndTimer = 999999999; 

if (m_uiSummonTimer <= diff) 
{
	if (getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL || getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC)
         {
             DoSummon(CREATURE_ZOMBIE, Pos[RAND(0,4)]);  
          DoSummon(CREATURE_SKELETON, Pos[RAND(0,4)]);  
          DoSummon(CREATURE_ARCHMAGE, Pos[RAND(0,4)]);  
          DoSummon(CREATURE_SUPPRESSER, Pos[RAND(0,4)]);  
          DoSummon(CREATURE_ABOMINATION, Pos[RAND(0,4)]);
	  }

	if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
         {
             DoSummon(CREATURE_ZOMBIE, Pos[RAND(0,1,2,3)]);  
          DoSummon(CREATURE_SKELETON, Pos[RAND(0,1,2,3)]);  
          DoSummon(CREATURE_ARCHMAGE, Pos[RAND(0,1,2,3)]);  
          DoSummon(CREATURE_SUPPRESSER, Pos[RAND(0,1,2,3)]);  
          DoSummon(CREATURE_ABOMINATION, Pos[RAND(0,1,2,3)]);
	  }

   m_uiSummonTimer = 20000;
} else m_uiSummonTimer -= diff;

if  (m_uiPortalTimer <= diff) 
{
	DoScriptText(SAY_OPEN_PORTAL,me);
       me->SummonCreature(CREATURE_PORTAL,me->GetPositionX()+15,me->GetPositionY()+15,me->GetPositionZ(),0, TEMPSUMMON_TIMED_DESPAWN, 15000);  
	me->SummonCreature(CREATURE_PORTAL,me->GetPositionX()+10,me->GetPositionY()+25,me->GetPositionZ(),0, TEMPSUMMON_TIMED_DESPAWN, 15000);  
	me->SummonCreature(CREATURE_PORTAL,me->GetPositionX()+15,me->GetPositionY()-25,me->GetPositionZ(),0, TEMPSUMMON_TIMED_DESPAWN, 15000);   
	m_uiPortalTimer = 30000;
} else m_uiPortalTimer -= diff;

   if(!ABOVEHP && (me->GetHealth()*100 / me->GetMaxHealth()) > 75) 
{
    DoScriptText(SAY_ABOVE_75,me); 
    ABOVEHP = true; 
}
if (!BELOWHP && (me->GetHealth()*100 / me->GetMaxHealth()) < 25) 
{
    DoScriptText(SAY_BELOW_25,me); 
    BELOWHP = true; 
}

   	if ((me->GetHealth()*100 / me->GetMaxHealth()) > 99)
	    {
		    Phase = 2; 
               me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);  
		    me->SetReactState(REACT_PASSIVE);
		    me->RemoveAurasDueToSpell(SPELL_CORRUPTION);

		end = true; 
		} 
	  }

 if (Phase == 2)

	 {
	     Phase = 3; 
	     m_uiEndTimer = 1000; 
	     m_uiEnd2Timer = 6000;
	     DoScriptText(SAY_END , me); 
	 }

    if (Phase == 3) 
 {
     if (m_uiEndTimer <= diff) 
 {
	 DoScriptText(SAY_BERSERK , me); 
     combat_trigger->CastSpell(combat_trigger,SPELL_RAGE,true,0,0,0); 
     combat_trigger->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
     m_uiEndTimer = 50000;   	  
 } else m_uiEndTimer -= diff; 

  if (m_uiEnd2Timer <= diff)
      {
          combat_trigger->ForcedDespawn(); 
          me->CastSpell(me,SPELL_DREAM_SLIP,true,0,0,0); 
          m_uiEnd2Timer = 50000; 
      } else m_uiEnd2Timer -= diff;
 }

     if (me->HasAura(SPELL_DREAM_SLIP))
  {
         me->ForcedDespawn();  
         	if (m_pInstance)
		    {
                   m_pInstance->SetData(DATA_VALITHRIA_DREAMWALKER_EVENT, DONE);  
		    } 
  }
	 }

void JustDied(Unit* killer)
       {
		DoScriptText(SAY_DEATH, me);

         	if (m_pInstance)
		    {
                   m_pInstance->SetData(DATA_VALITHRIA_DREAMWALKER_EVENT, FAIL);  
		    } 
       }
}; 

struct npc_dreamportalAI : public ScriptedAI
{
npc_dreamportalAI(Creature *c) : ScriptedAI(c){}   

uint32 m_uiSTATETimer; 

   void InitializeAI() 
{ 
	DoCast(SPELL_PORTAL_VISUAL);      
	me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
       me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);  

    	ScriptedAI::InitializeAI();
   } 

	 void MoveInLineOfSight(Unit *who)
	 { 
	 if (who->IsControlledByPlayer())
	{
  if (me->IsWithinDistInMap(who,5.0f))
           {   
		 pPlayer = who; 
            pPlayer->CastSpell(pPlayer,SPELL_DREAM_STATE,false,0,0,0);
		 pPlayer->AddUnitMovementFlag(MOVEMENTFLAG_FLY_MODE);
            pPlayer->SendMovementFlagUpdate();  
		 m_uiSTATETimer = 15000;    
		 me->ForcedDespawn();
  }  
	 }
	 } 

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

	 	 if (m_uiSTATETimer <= diff) 
		 {  
	    pPlayer->RemoveAurasDueToSpell(SPELL_DREAM_STATE);
		pPlayer->RemoveUnitMovementFlag(MOVEMENTFLAG_FLY_MODE); 
		pPlayer->SendMovementFlagUpdate();
		}else m_uiSTATETimer -= diff;   
    }
};

struct npc_skellmageAI : public ScriptedAI
{
npc_skellmageAI(Creature *c) : ScriptedAI(c)
{
       m_pInstance = c->GetInstanceData(); 
   }

   ScriptedInstance* m_pInstance;	

uint32 m_uiVOLLEYTimer; 
   uint32 m_uiCOLUMNTimer;  
uint32 m_uiVOIDTimer;

  void EnterCombat(Unit* who)
   {  
  m_uiVOLLEYTimer = 12000; 
  m_uiCOLUMNTimer = 20000; 
  m_uiVOIDTimer = 30000;

     if(m_pInstance)
	   {
              m_pInstance->SetData(DATA_VALITHRIA_DREAMWALKER_EVENT, IN_PROGRESS);  
   	   } 
  }

    void KilledUnit(Unit* victim)
        {
            DoScriptText(SAY_PDEATH, pValithria);
        }

    void Reset()
          {
              if (m_pInstance) 
               m_pInstance->SetData(DATA_VALITHRIA_DREAMWALKER_EVENT, NOT_STARTED);   
          }

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

       if (m_uiVOLLEYTimer <= diff)
	{
           if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
               DoCast(pTarget, SPELL_VOLLEY);
          m_uiVOLLEYTimer = 15000; 
	} else m_uiVOLLEYTimer -= diff;  

    if (m_uiVOIDTimer <= diff)
	{
          if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
          me->SummonCreature(CREATURE_VOID,pTarget->GetPositionX(),pTarget->GetPositionY(),pTarget->GetPositionZ(),0, TEMPSUMMON_TIMED_DESPAWN, 15000);   
          m_uiVOIDTimer = 30000; 
	} else m_uiVOIDTimer -= diff; 

       if (m_uiCOLUMNTimer <= diff)
	{
           if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
               DoCast(pTarget, SPELL_COLUMN);
          m_uiCOLUMNTimer = 20000; 
	} else m_uiCOLUMNTimer -= diff; 

     DoMeleeAttackIfReady(); 
  } 
};

struct npc_fireskellAI : public ScriptedAI
{
npc_fireskellAI(Creature *c) : ScriptedAI(c){}   

uint32 m_uiWASTETimer; 
   uint32 m_uiFIREBALLTimer;  

  void EnterCombat(Unit* who)
   {  
  m_uiWASTETimer = 20000; 
  m_uiFIREBALLTimer = 5000; 
   }

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

       if (m_uiWASTETimer <= diff)
	{
          DoCast(SPELL_WASTE);
          m_uiWASTETimer = 20000; 
	} else m_uiWASTETimer -= diff; 

       if (m_uiFIREBALLTimer <= diff)
	{
           if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
               DoCast(pTarget, SPELL_FIREBALL);
          m_uiFIREBALLTimer = 5000; 
	} else m_uiFIREBALLTimer -= diff; 

     DoMeleeAttackIfReady(); 
  }   
       void KilledUnit(Unit* victim)
   {
       DoScriptText(SAY_PDEATH, pValithria);
   }
}; 
struct npc_suppressorAI : public ScriptedAI
{
npc_suppressorAI(Creature *c) : ScriptedAI(c){}    

  uint32 m_uiCheckTimer; 


  void EnterCombat(Unit* who)
 { 
 me->SetReactState(REACT_PASSIVE);  
 m_uiCheckTimer = 2500;
 } 

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

 if (m_uiCheckTimer <= diff) 
 { 
    me->CastSpell(pValithria,SPELL_SUPRESSION,true,0,0,0);  
 m_uiCheckTimer = 100000;  
 }
 else m_uiCheckTimer -= diff; 
 }
}; 

struct npc_manavoidAI : public ScriptedAI
{
npc_manavoidAI(Creature *c) : ScriptedAI(c){}   

   void InitializeAI() 
{   
	DoCast(SPELL_MANA_VOID);
   }   
	  void EnterCombat(Unit* who)
   {   
	me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
	DoStartNoMovement(me->getVictim()); 
   }
};  
struct npc_glutabominationAI : public ScriptedAI
{
npc_glutabominationAI(Creature *c) : ScriptedAI(c){}   

uint32 m_uiSPRAYTimer;  

  void EnterCombat(Unit* who)
 { 
  m_uiSPRAYTimer = 10000; 
 } 

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

       if (m_uiSPRAYTimer <= diff)
       {
           DoCast(me->getVictim(), SPELL_SPRAY);
           m_uiSPRAYTimer = 20000;
       } else m_uiSPRAYTimer -= diff;  


	DoMeleeAttackIfReady();  
       }   

       void KilledUnit(Unit* victim)
           {
               DoScriptText(SAY_PDEATH, pValithria);
           }

      void JustDied(Unit* killer)  
   {
	me->SummonCreature(CREATURE_WORM,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(),0, TEMPSUMMON_CORPSE_DESPAWN);   	
       me->SummonCreature(CREATURE_WORM,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(),0, TEMPSUMMON_CORPSE_DESPAWN);
	me->SummonCreature(CREATURE_WORM,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(),0, TEMPSUMMON_CORPSE_DESPAWN);
	me->SummonCreature(CREATURE_WORM,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(),0, TEMPSUMMON_CORPSE_DESPAWN);
	me->SummonCreature(CREATURE_WORM,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(),0, TEMPSUMMON_CORPSE_DESPAWN);
	me->SummonCreature(CREATURE_WORM,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(),0, TEMPSUMMON_CORPSE_DESPAWN);
	me->SummonCreature(CREATURE_WORM,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(),0, TEMPSUMMON_CORPSE_DESPAWN);
	me->SummonCreature(CREATURE_WORM,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(),0, TEMPSUMMON_CORPSE_DESPAWN);
   }

}; 
struct npc_blistzombieAI : public ScriptedAI
{
npc_blistzombieAI(Creature *c) : ScriptedAI(c){}  

uint32 m_uiBURSTTimer;  
uint32 m_uiDELAYTimer;  

void EnterCombat(Unit* who) 
{ 
  m_uiBURSTTimer = 20000;  
  m_uiDELAYTimer = 99999; 
} 

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

 if (m_uiBURSTTimer <= diff)
       {
           DoCast(SPELL_BURST); 
		m_uiBURSTTimer = 20000;
           m_uiDELAYTimer = 1000;
       } else m_uiBURSTTimer -= diff;   

      if (m_uiDELAYTimer <= diff)
             {
                 me->ForcedDespawn();
                 m_uiDELAYTimer = 100000;
             } else m_uiDELAYTimer -= diff;  

	 DoMeleeAttackIfReady();  
       }  

     void KilledUnit(Unit* victim)
   {
       DoScriptText(SAY_PDEATH, pValithria);
   }
};
struct npc_dreamcloudAI : public ScriptedAI
{
npc_dreamcloudAI(Creature *c) : ScriptedAI(c){}    

uint32 SPAWN;
   uint32 m_uiDelayTimer;

void InitializeAI() 
{
    DoCast(SPELL_CLOUD_VISUAL);
    me->AddUnitMovementFlag(MOVEMENTFLAG_FLY_MODE);  
    me->SendMovementFlagUpdate();   
    me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE); 
    me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
} 

void JustRespawned() 
{ 
	 DoCast(SPELL_CLOUD_VISUAL);
     me->AddUnitMovementFlag(MOVEMENTFLAG_FLY_MODE);  
     me->SendMovementFlagUpdate();   
     me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
}
	 void MoveInLineOfSight(Unit *who)
	 {  
		 if (me->IsWithinDistInMap(who,5.0f))
                {
                  DoCast(SPELL_VIGOR);  
		          m_uiDelayTimer = 100;
		     }
	 } 

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

	if (m_uiDelayTimer <= diff) 
	{ 
	 me->ForcedDespawn(); 
	}else m_uiDelayTimer -= diff;
  }

};

CreatureAI* GetAI_boss_valithria(Creature* pCreature)
{
   return new boss_valithriaAI (pCreature);
}  

CreatureAI* GetAI_npc_dreamcloud(Creature* pCreature)
{
   return new npc_dreamcloudAI (pCreature);
}

CreatureAI* GetAI_npc_skellmage(Creature* pCreature)
{
   return new npc_skellmageAI (pCreature);
} 

CreatureAI* GetAI_npc_fireskell(Creature* pCreature)
{
   return new npc_fireskellAI (pCreature);
} 

CreatureAI* GetAI_npc_dreamportal(Creature* pCreature)
{
   return new npc_dreamportalAI (pCreature);
} 

CreatureAI* GetAI_npc_suppressor(Creature* pCreature)
{
   return new npc_suppressorAI (pCreature);
}  

CreatureAI* GetAI_npc_glutabomination(Creature* pCreature)
{
   return new npc_glutabominationAI (pCreature);
} 

CreatureAI* GetAI_npc_manavoid(Creature* pCreature)
{
   return new npc_manavoidAI (pCreature);
} 

CreatureAI* GetAI_npc_blistzombie(Creature* pCreature)
{
   return new npc_blistzombieAI (pCreature);
}

void AddSC_boss_valithria()
{
   Script *newscript;
   newscript = new Script;
   newscript->Name="boss_valithria";
   newscript->GetAI = &GetAI_boss_valithria;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_skellmage";
   newscript->GetAI = &GetAI_npc_skellmage;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_fireskell";
   newscript->GetAI = &GetAI_npc_fireskell;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_dreamportal";
   newscript->GetAI = &GetAI_npc_dreamportal;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_suppressor";
   newscript->GetAI = &GetAI_npc_suppressor;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_manavoid";
   newscript->GetAI = &GetAI_npc_manavoid;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_glutabomination";
   newscript->GetAI = &GetAI_npc_glutabomination;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_blistzombie";
   newscript->GetAI = &GetAI_npc_blistzombie;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_dreamcloud";
   newscript->GetAI = &GetAI_npc_dreamcloud;
   newscript->RegisterSelf();
}

 

 

 

 

deathbringer_saurfang.cpp

 

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "ScriptedPch.h"
#include "icecrown_citadel.h"

enum Yells
{
   SAY_AGGRO           = -1665973,
   SAY_FALLENCHAMPION  = -1665974,
   SAY_BLOODBEASTS     = -1665975,
   SAY_KILL1           = -1665976,
   SAY_KILL2           = -1665977,
   SAY_BERSERK         = -1665978,
   SAY_DEATH           = -1665979,
};

enum SaurfangSpells
{
   SPELL_BLOOD_LINK			= 72178,
SPELL_SUMMON_BLOOD_BEAST    = 72172,
SPELL_FRENZY				= 72737,
SPELL_BLOOD_NOVA_TRIGGER	= 72378,
SPELL_TASTE_OF_BLOOD		= 69634,
SPELL_CLEAVE				= 15284,
SPELL_RENDING_THROW			= 70309,
   N_10_SPELL_FALLEN_CHAMPION  = 72293,
   SPELL_BOILING_BLOOD			= 72385,
   N_10_SPELL_BLOOD_NOVA       = 72380,
N_25_SPELL_BLOOD_NOVA		= 72438,
H_10_SPELL_BLOOD_NOVA		= 72380,
H_25_SPELL_BLOOD_NOVA		= 72380,
   N_SPELL_RUNE_OF_BLOOD       = 72408,
};

Creature* pSaurfang;

enum BloodBeastSpells
{
SPELL_BLOOD_LINK_BEAST	=	72176,
SPELL_RESISTAN_SKIN		=	72723,
SPELL_SCENT_OF_BLOOD	=	72769,
};

enum Creatures
{
CREATURE_BLOOD_BEAST	=	38508,
};

float BloodBeastSpawnLocation[4][3] =
{
   {-494.024536, 2217.747314, 541.114075},
   {-493.856537, 2208.298828, 541.114075},
   {-493.966431, 2214.478760, 541.114075},
   {-493.794312, 2204.799316, 541.114075}
};

struct boss_saurfangAI : public ScriptedAI
{
   boss_saurfangAI(Creature* pCreature) : ScriptedAI(pCreature), summons(me)
   {
       m_pInstance = (ScriptedInstance*)pCreature->GetInstanceData();
	pSaurfang = me;
   }

   ScriptedInstance* m_pInstance;

uint32 m_uiFallenChampionTimer;
uint32 m_uiBoilingBloodTimer;
uint32 m_uiBloodNovaChannelTimer;
uint32 m_uiBloodNovaDamageTimer;
uint32 m_uiRuneOfBloodTimer;
uint32 m_uiSummonBloodBeastTimer;
uint32 m_uiBerserkTimer;

bool m_bIsEnrage;

SummonList summons;

   void Reset()
   {
	m_uiFallenChampionTimer = RAID_MODE(60000,30000,60000,30000);
	m_uiBoilingBloodTimer	= 15000;
	m_uiBloodNovaChannelTimer = 22000;
	m_uiBloodNovaDamageTimer = 25000;
	m_uiRuneOfBloodTimer = urand (20000,25000);
	m_uiSummonBloodBeastTimer = 40000;

	m_bIsEnrage = false;

	if (m_pInstance)
           m_pInstance->SetData(DATA_SAURFANG, NOT_STARTED);
   }

   void EnterCombat(Unit* pWho)
   {
       if (m_pInstance)
           m_pInstance->SetData(DATA_SAURFANG_EVENT, IN_PROGRESS);

       DoScriptText(SAY_AGGRO, me);
   }

   void JustDied(Unit* pKiller)
   {
       if (m_pInstance)
           m_pInstance->SetData(DATA_SAURFANG_EVENT, DONE);

       DoScriptText(SAY_DEATH, me);

   Map::PlayerList const &PlList = me->GetMap()->GetPlayers();

   if (PlList.isEmpty())
           return;

   for (Map::PlayerList::const_iterator i = PlList.begin(); i != PlList.end(); ++i)
   {
       if (Player* pPlayer = i->getSource())
       {
	    if (pPlayer && pPlayer->HasAura(72293))
               pPlayer->RemoveAurasDueToSpell(72293);
       }
}
   }

   void JustReachedHome()
   {
       if (m_pInstance)
           m_pInstance->SetData(DATA_SAURFANG_EVENT, NOT_STARTED);
   }

   void KilledUnit(Unit* pVictim)
   {
       switch(urand(0,1))
       {
           case 0: DoScriptText(SAY_KILL1, me); break;
           case 1: DoScriptText(SAY_KILL2, me); break;
       }
	me->ModifyHealth(me->GetMaxHealth() * 0.10);
	if (pVictim && pVictim->HasAura(72293))
		pVictim->RemoveAurasDueToSpell(72293);
   }

void JustSummoned(Creature *summon)
   {
	if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
       summon->AI()->AttackStart(pTarget);

	summons.Summon(summon);
   }

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

   if (!me->HasAura(SPELL_BLOOD_LINK))
		DoCast(me, SPELL_BLOOD_LINK);

	if (m_uiBoilingBloodTimer < uiDiff)
	{
		if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 1))
		DoCast(target, SPELL_BOILING_BLOOD);
		me->ModifyHealth(me->GetMaxHealth() * 0.02);
	    //me->SetPower(me->getPowerType(), 10);
		//me->ModifyPower(POWER_MANA, -mana);
		m_uiBoilingBloodTimer = 20000;
	}
	else m_uiBoilingBloodTimer -= uiDiff;

	if (m_uiBloodNovaChannelTimer < uiDiff)
	{
		DoCast(me, SPELL_BLOOD_NOVA_TRIGGER);
		m_uiBloodNovaChannelTimer = 22000;
		m_uiBloodNovaDamageTimer = 2000;
	}
	else m_uiBloodNovaChannelTimer -= uiDiff;

	if (m_uiBloodNovaDamageTimer < uiDiff)
	{
		uint32 count = RAID_MODE(1,3,1,3);
           for (uint8 i = 1; i <= count; i++)
           {
			if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
			DoCast(target, RAID_MODE(N_10_SPELL_BLOOD_NOVA,N_25_SPELL_BLOOD_NOVA,H_10_SPELL_BLOOD_NOVA,H_25_SPELL_BLOOD_NOVA));
			me->ModifyHealth(me->GetMaxHealth() * 0.02);
			m_uiBloodNovaDamageTimer = 90000;
		}
	}
	else m_uiBloodNovaDamageTimer -= uiDiff;

	if (m_uiSummonBloodBeastTimer <= uiDiff)
       {
		for (uint8 i = 0; i < RAID_MODE(1,4,1,4); ++i)
		{
			DoCast(me, SPELL_SUMMON_BLOOD_BEAST);
			me->SummonCreature(CREATURE_BLOOD_BEAST, BloodBeastSpawnLocation[i][0],BloodBeastSpawnLocation[i][1],BloodBeastSpawnLocation[i][2],BloodBeastSpawnLocation[i][3], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 20000);
			DoScriptText(SAY_BLOODBEASTS, me);
			me->ModifyHealth(me->GetMaxHealth() * 0.02);
			m_uiSummonBloodBeastTimer = 40000;
		}
       } 
	else m_uiSummonBloodBeastTimer -= uiDiff;

	if (m_uiFallenChampionTimer < uiDiff)
	{
		DoScriptText(SAY_FALLENCHAMPION, me);
		if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
		DoCast(target, N_10_SPELL_FALLEN_CHAMPION);
		me->ModifyHealth(me->GetMaxHealth() * 0.09);
		m_uiFallenChampionTimer	= RAID_MODE(60000,30000,60000,30000);
	}
	else m_uiFallenChampionTimer -= uiDiff;

	if (m_uiRuneOfBloodTimer < uiDiff)
	{
		if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
		DoCast(target, N_SPELL_RUNE_OF_BLOOD);
		me->ModifyHealth(me->GetMaxHealth() * 0.05);
		m_uiRuneOfBloodTimer = 25000;
	}
	else m_uiRuneOfBloodTimer -= uiDiff;

	if(!m_bIsEnrage && (me->GetHealth()*100) / me->GetMaxHealth() < 30)
	{
		DoCast(me, SPELL_FRENZY);
		m_bIsEnrage = true;
	}

       DoMeleeAttackIfReady();
   }
};

struct npc_bloodbeastAI : public ScriptedAI
{
   npc_bloodbeastAI(Creature* pCreature) : ScriptedAI(pCreature)
   {
       m_pInstance = (ScriptedInstance*)pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;

	uint32 m_uiSetPowerTimer;
	uint32 m_uiScentOfBloodTimer;
	uint32 m_uiResistanSkinTimer;

   void Reset()
   {
	m_uiSetPowerTimer = 2000;
	m_uiScentOfBloodTimer = 7000;
	m_uiResistanSkinTimer = 10000;
   }

   void EnterCombat(Unit* pWho)
   {
   }

   void KilledUnit(Unit* pVictim)
   { 
	if (Creature* Saurfang = me->GetCreature(*me, m_pInstance->GetData64(DATA_SAURFANG)))
       {
		Saurfang->ModifyHealth(Saurfang->GetMaxHealth() * 0.10);
	}
   }

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

   	if (m_uiSetPowerTimer <= uiDiff)
	{
		pSaurfang->ModifyPower(pSaurfang->getPowerType(), +1);
		m_uiSetPowerTimer = 2000;
	} else m_uiSetPowerTimer -= uiDiff;

if (getDifficulty() == RAID_DIFFICULTY_10MAN_HEROIC || getDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC)
      {
   	   if (m_uiScentOfBloodTimer <= uiDiff)
	       {
               DoCast(SPELL_SCENT_OF_BLOOD);
               m_uiScentOfBloodTimer = 7000;
	       } else m_uiScentOfBloodTimer -= uiDiff;
   }

	if (m_uiResistanSkinTimer <= uiDiff)
	    {
            DoCast(me, SPELL_RESISTAN_SKIN);
            m_uiResistanSkinTimer = 10000;
	    } else m_uiResistanSkinTimer -= uiDiff;

	DoMeleeAttackIfReady();
   }
};

CreatureAI* GetAI_boss_saurfang(Creature* pCreature)
{
   return new boss_saurfangAI(pCreature);
}

CreatureAI* GetAI_npc_bloodbeast(Creature* pCreature)
{
   return new npc_bloodbeastAI(pCreature);
}

void AddSC_boss_saurfang()
{
   Script* NewScript;

   NewScript = new Script;
   NewScript->Name = "boss_saurfang";
   NewScript->GetAI = &GetAI_boss_saurfang;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "npc_bloodbeast";
   NewScript->GetAI = &GetAI_npc_bloodbeast;
   NewScript->RegisterSelf();
}

 

 

 

 

lower_spire_trash.cpp

 

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "ScriptedPch.h"
#include "icecrown_citadel.h"

/***************************************SPELLS*************************************/
//Nerub'ar Broodkeeper
#define SPELL_CRYPTSCARABS                RAID_MODE(70965,70965)
#define SPELL_DARKMENDING                 RAID_MODE(71020,71020)
#define SPELL_WEBWRAP                     RAID_MODE(70980,70980)

//The Damned
#define SPELL_BONEFLURRY                  RAID_MODE(70960,70960)
#define SPELL_SHATTEREDBONES              RAID_MODE(70961,70961)

//Servant of the Throne
#define SPELL_GLACIALBLAST                 RAID_MODE(71029,71029)

//Ancient Skeletal Soldier
#define SPELL_SHIELDBASH                  RAID_MODE(70964,70964)

//Deathbound Ward
#define SPELL_DISRUPTINGSHOUT             RAID_MODE(70122,70122)
#define SPELL_SABERLASH                   RAID_MODE(70121,70121)

//Deathspeaker Attendant
#define SPELL_SHADOWBOLT                  RAID_MODE(69387,69387)
#define SPELL_SHADOWNOVA                  RAID_MODE(69355,71106)

//Deathspeaker Disciple
#define SPELL_DARKBLESSING				  RAID_MODE(69391,69391)
#define SPELL_SHADOWBOLT2                 RAID_MODE(69387,69387)
#define SPELL_SHADOWMEND                  RAID_MODE(69389,71107)

//Deathspeaker High Priest
#define SPELL_AURAOFDARKNESS              RAID_MODE(69491,69491)
#define SPELL_DARKRECKONING               RAID_MODE(69483,69483)

//Deathspeaker Servant
#define SPELL_CHAOSBOLT					  RAID_MODE(69576,71108)
#define SPELL_CONSUMINGSHADOWS            RAID_MODE(69405,69405)
#define SPELL_CURSEOFAGONY                RAID_MODE(69404,71112)

//Deathspeaker Zealot
#define SPELL_SHADOWCLEAVE                RAID_MODE(69492,69492)

//Cult Adherant
#define SPELL_CURSEOFTRPOR                RAID_MODE(71237,71237)
#define SPELL_DARKEMPOWERMENT             RAID_MODE(70901,70901)
#define SPELL_DARKMARTYDOM                RAID_MODE(70903,72498)
#define SPELL_DEATHCHILLBLAST             RAID_MODE(70594,72005)
#define SPELL_DEATHCHILLBLAST_EM          RAID_MODE(70906,72485)
#define SPELL_SHROUDOFTHEOCCULT           RAID_MODE(70768,70768)
#define COSMETIC_TELEPORT                 52096

//Cult Fanatic
#define SPELL_DARKMARTYRDOM               RAID_MODE(71236,72495)
#define SPELL_DARKTRANSFORMATION          RAID_MODE(70900,70900)
#define SPELL_NECROTICSTRIKE              RAID_MODE(70659,72490)
#define SPELL_SHADOWCLEAVE                RAID_MODE(70670,72006)
#define SPELL_VAMPIRICMIGHT               RAID_MODE(70674,70674)

//Nerub'ar Broodkeeper
#define EVENT_CRYPTSCARABS          1
#define EVENT_DARKMENDING           2
#define EVENT_WEBWRAP               3

//The Damned
#define EVENT_BONEFLURRY            4
#define EVENT_SHATTEREDBONES        5

//Servant of the Throne
#define EVENT_GLACIALBLAST          6

//Ancient Skeletal Soldier
#define EVENT_SHIELDBASH            7

//Deathbound Ward
#define EVENT_DISRUPTINGSHOUT       8
#define EVENT_SABERLASH             9

//Deathspeaker Attendant
#define EVENT_SHADOWBOLT            10
#define EVENT_SHADOWNOVA            11

//Deathspeaker Disciple
#define EVENT_SHADOWBOLT2           12
#define EVENT_DARKBLESSING          13
#define EVENT_SHADOWMEND            14

//Deathspeaker High Priest
#define EVENT_DARKRECKONING         15

//Deathspeaker Servant
#define EVENT_CHAOSBOLT             16
#define EVENT_CONSUMINGSHADOWS      17
#define EVENT_CURSEOFAGONY          18

//Deathspeaker Zealot
#define EVENT_SHADOWCLEAVE          19

//Cult Adherant
#define EVENT_CURSEOFTRPOR          20
#define EVENT_DARKEMPOWERMENT       21
#define EVENT_DARKMARTYDOM          22
#define EVENT_DEATHCHILLBLAST       23
#define EVENT_SHROUDOFTHEOCCULT     24

//Cult Fanatic
#define EVENT_DARKMARTYRDOM         25
#define EVENT_DARKTRANSFORMATION    26
#define EVENT_NECROTICSTRIKE        27
#define EVENT_SHADOWCLEAVE          28
#define EVENT_VAMPIRICMIGHT         29

struct  npc_NerubarBroodkeeperAI: public ScriptedAI
{
   npc_NerubarBroodkeeperAI(Creature *c) : ScriptedAI(c)
   {
   }
   EventMap events;

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

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

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

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

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

struct  npc_TheDamnedAI: public ScriptedAI
{
   npc_TheDamnedAI(Creature *c) : ScriptedAI(c)
   {
   }
   EventMap events;

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

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

void JustDied(Unit* who)
{
DoCastAOE(SPELL_SHATTEREDBONES);
}

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

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

       while(uint32 eventId = events.ExecuteEvent())
       {
           switch(eventId)
           {
               case EVENT_BONEFLURRY:
                   DoCast(me, SPELL_BONEFLURRY, 1);
                   events.RescheduleEvent(EVENT_BONEFLURRY, 15000);
                   return;
           }
       }
       DoMeleeAttackIfReady();
   }
};

struct  npc_ServantoftheThroneAI: public ScriptedAI
{
   npc_ServantoftheThroneAI(Creature *c) : ScriptedAI(c)
   {
   }
   EventMap events;

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

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

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

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

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

struct  npc_AncientSkeletalSoldierAI: public ScriptedAI
{
   npc_AncientSkeletalSoldierAI(Creature *c) : ScriptedAI(c)
   {
   }
   EventMap events;

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

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

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

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

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

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)
   {
       if (!UpdateVictim())
           return;

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

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

struct  npc_DeathspeakerAttedantAI: public ScriptedAI
{
   npc_DeathspeakerAttedantAI(Creature *c) : ScriptedAI(c)
   {
   }
   EventMap events;

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

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

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

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

       while(uint32 eventId = events.ExecuteEvent())
       {
           switch(eventId)
           {
               case EVENT_SHADOWBOLT:
				if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
                   DoCast(pTarget, SPELL_SHADOWBOLT);
                   events.RescheduleEvent(EVENT_SHADOWBOLT, 8000);
                   return;
               case EVENT_SHADOWNOVA:
                   DoCastAOE(SPELL_SHADOWNOVA);
                   events.RescheduleEvent(EVENT_SHADOWNOVA, 17000);
                   return;
           }
       }
       DoMeleeAttackIfReady();
   }
};

struct  npc_DeathspeakerDiscipleAI: public ScriptedAI
{
   npc_DeathspeakerDiscipleAI(Creature *c) : ScriptedAI(c)
   {
   }
   EventMap events;

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

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

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

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

       while(uint32 eventId = events.ExecuteEvent())
       {
           switch(eventId)
           {
               case EVENT_DARKBLESSING:
				if(Unit* pTarget = me->SelectNearestTarget(45))
				if(pTarget->GetHealth() == pTarget->GetHealth() * 100 / pTarget->GetMaxHealth() && pTarget->IsFriendlyTo(me))
                   DoCast(pTarget, SPELL_DARKBLESSING);
                   events.RescheduleEvent(EVENT_DARKBLESSING, 20000);
                   return;
               case EVENT_SHADOWBOLT2:
				if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
                   DoCast(pTarget, SPELL_SHADOWBOLT2);
                   events.RescheduleEvent(EVENT_SHADOWBOLT2, 8000);
                   return;
               case EVENT_SHADOWMEND:
				if(Unit* pTarget = me->SelectNearestTarget(45))
				if(pTarget->GetHealth() == pTarget->GetHealth() * 100 / pTarget->GetMaxHealth() && pTarget->IsFriendlyTo(me))
                   DoCast(pTarget, SPELL_SHADOWMEND);
                   events.RescheduleEvent(EVENT_SHADOWMEND, 25000);
                   return;
           }
       }
       DoMeleeAttackIfReady();
   }
};

struct  npc_DeathspeakerHighPriestAI: public ScriptedAI
{
   npc_DeathspeakerHighPriestAI(Creature *c) : ScriptedAI(c)
   {
   }
   EventMap events;

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

   void EnterCombat(Unit* who)
   {
   events.ScheduleEvent(EVENT_DARKRECKONING, 10000);
   DoCast(me, SPELL_AURAOFDARKNESS);
   }

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

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

       while(uint32 eventId = events.ExecuteEvent())
       {
           switch(eventId)
           {
               case EVENT_DARKRECKONING:
				if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
                   DoCast(pTarget, SPELL_DARKRECKONING);
                   events.RescheduleEvent(EVENT_DARKRECKONING, 20000);
                   return;
           }
       }
       DoMeleeAttackIfReady();
   }
};

struct  npc_DeathspeakerServantAI: public ScriptedAI
{
   npc_DeathspeakerServantAI(Creature *c) : ScriptedAI(c)
   {
   }
   EventMap events;

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

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

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

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

       while(uint32 eventId = events.ExecuteEvent())
       {
           switch(eventId)
           {
               case EVENT_CHAOSBOLT:
				if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
                   DoCast(pTarget, SPELL_CHAOSBOLT);
                   events.RescheduleEvent(EVENT_CHAOSBOLT, 15000);
                   return;
               case EVENT_CONSUMINGSHADOWS:
				if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
                   DoCast(pTarget, SPELL_CONSUMINGSHADOWS);
                   events.RescheduleEvent(EVENT_CONSUMINGSHADOWS, 13000);
                   return;
               case EVENT_CURSEOFAGONY:
				if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
                   DoCast(pTarget, SPELL_CURSEOFAGONY);
                   events.RescheduleEvent(EVENT_CURSEOFAGONY, 17000);
                   return;
           }
       }
       DoMeleeAttackIfReady();
   }
};

struct  npc_DeathspeakerZealotAI: public ScriptedAI
{
   npc_DeathspeakerZealotAI(Creature *c) : ScriptedAI(c)
   {
   }
   EventMap events;

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

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

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

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

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

struct  npc_CultAdherentAI: public ScriptedAI
{
   npc_CultAdherentAI(Creature *c) : ScriptedAI(c)
   {
   }
   EventMap events;

bool bReanimated;
bool bEmpowered;

   void Reset()
   {
       events.Reset();
	bEmpowered = false;
	bReanimated = false;
   }

   void JustSummoned(Creature* summoned)
   {
       if (Unit* target = SelectUnit(SELECT_TARGET_TOPAGGRO,0))
           summoned->AI()->AttackStart(target);

       DoCast(COSMETIC_TELEPORT);
   }

   void Aggro(Unit* pWho)
   {
       me->SetInCombatWithZone();
   }

   void EnterCombat(Unit* who)
   {
   events.ScheduleEvent(EVENT_CURSEOFTRPOR, 10000);
   events.ScheduleEvent(EVENT_DARKEMPOWERMENT, 30000);
   events.ScheduleEvent(EVENT_DEATHCHILLBLAST, 20000);
   events.ScheduleEvent(EVENT_SHROUDOFTHEOCCULT, 15000);

   DoCast(COSMETIC_TELEPORT);
   }

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

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

       while(uint32 eventId = events.ExecuteEvent())
       {
           switch(eventId)
           {
               case EVENT_CURSEOFTRPOR:
				if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
                   DoCast(pTarget, SPELL_CURSEOFTRPOR);
                   events.RescheduleEvent(EVENT_CURSEOFTRPOR, 8000);
                   return;

               case EVENT_DARKEMPOWERMENT:
                   DoCast(me, RAND(SPELL_DARKEMPOWERMENT,SPELL_DARKMARTYDOM));
                   events.RescheduleEvent(EVENT_DARKEMPOWERMENT, 9999999);
				bEmpowered = true;
                   return;

               case EVENT_DEATHCHILLBLAST:
				if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
				if (bEmpowered = false)
				{
                   DoCast(pTarget, SPELL_DEATHCHILLBLAST);
				} else {
				DoCast(pTarget, SPELL_DEATHCHILLBLAST_EM);
				}
                   events.RescheduleEvent(EVENT_DEATHCHILLBLAST, 8000);
                   return;
			case EVENT_SHROUDOFTHEOCCULT:
				DoCast(me, SPELL_SHROUDOFTHEOCCULT);
				events.RescheduleEvent(EVENT_SHROUDOFTHEOCCULT, 8000);
				return;
           }
       }
       DoMeleeAttackIfReady();
   }
};

struct  npc_CultFanaticAI: public ScriptedAI
{
   npc_CultFanaticAI(Creature *c) : ScriptedAI(c)
   {
   }
   EventMap events;

bool Martyr;
bool Transform;

   void Reset()
   {
       events.Reset();

	Martyr = false;
	Transform = false;
   }

   void Aggro(Unit* pWho)
   {
       me->SetInCombatWithZone();
   }

   void EnterCombat(Unit* who)
   {
   events.ScheduleEvent(EVENT_DARKMARTYRDOM, 45000);
   events.ScheduleEvent(EVENT_NECROTICSTRIKE, 8000);
   events.ScheduleEvent(EVENT_SHADOWCLEAVE, 8000);
   events.ScheduleEvent(EVENT_VAMPIRICMIGHT, 8000);

   DoCast(COSMETIC_TELEPORT);
   }

   void JustSummoned(Creature* summoned)
   {
       if (Unit* target = SelectUnit(SELECT_TARGET_TOPAGGRO,0))
           summoned->AI()->AttackStart(target);

       DoCast(COSMETIC_TELEPORT);
   }

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

       events.Update(diff);

       if (me->hasUnitState(UNIT_STAT_CASTING))
           return;

       while(uint32 eventId = events.ExecuteEvent())
       {
           switch(eventId)
           {
               case EVENT_DARKMARTYRDOM:
				if ((Martyr = false) && (Transform = false))
                   DoCast(me, RAND(SPELL_DARKMARTYRDOM, SPELL_DARKTRANSFORMATION));
                   events.RescheduleEvent(EVENT_DARKMARTYRDOM, 999999);
                   return;
               case EVENT_NECROTICSTRIKE:
                   DoCast(me->getVictim(), SPELL_NECROTICSTRIKE);
                   events.RescheduleEvent(EVENT_NECROTICSTRIKE, 13000);
                   return;
               case EVENT_SHADOWCLEAVE:
                   DoCast(me->getVictim(), SPELL_SHADOWCLEAVE);
                   events.RescheduleEvent(EVENT_SHADOWCLEAVE, 10000);
                   return;
               case EVENT_VAMPIRICMIGHT:
                   DoCast(me, SPELL_VAMPIRICMIGHT);
                   events.RescheduleEvent(EVENT_VAMPIRICMIGHT, 15000);
                   return;
           }
       }
       DoMeleeAttackIfReady();
   }
};

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

CreatureAI* GetAI_npc_TheDamnedAI(Creature* pCreature)
{
   return new npc_TheDamnedAI (pCreature);
}

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

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

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

/*****************************DEATHWHISPER TRASH**************************/
CreatureAI* GetAI_npc_DeathspeakerAttedantAI(Creature* pCreature)
{
   return new npc_DeathspeakerAttedantAI (pCreature);
}

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

CreatureAI* GetAI_npc_DeathspeakerHighPriestAI(Creature* pCreature)
{
   return new npc_DeathspeakerHighPriestAI (pCreature);
}

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

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

CreatureAI* GetAI_npc_CultAdherentAI(Creature* pCreature)
{
   return new npc_CultAdherentAI (pCreature);
}

CreatureAI* GetAI_npc_CultFanaticAI(Creature* pCreature)
{
   return new npc_CultFanaticAI (pCreature);
}

void AddSC_lower_spire_trash()
{
   Script *newscript;
   newscript = new Script;
   newscript->Name="npc_NerubarBroodkeeper";
   newscript->GetAI = &GetAI_npc_NerubarBroodkeeperAI;
   newscript->RegisterSelf();

newscript = new Script;
   newscript->Name="npc_TheDamned";
   newscript->GetAI = &GetAI_npc_TheDamnedAI;
   newscript->RegisterSelf();

newscript = new Script;
   newscript->Name="npc_ServantoftheThrone";
   newscript->GetAI = &GetAI_npc_ServantoftheThroneAI;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_AncientSkeletalSoldier";
   newscript->GetAI = &GetAI_npc_AncientSkeletalSoldierAI;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_DeathboundWard";
   newscript->GetAI = &GetAI_npc_DeathboundWardAI;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_DeathspeakerAttedant";
   newscript->GetAI = &GetAI_npc_DeathspeakerAttedantAI;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_DeathspeakerDisciple";
   newscript->GetAI = &GetAI_npc_DeathspeakerDiscipleAI;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_DeathspeakerHighPriest";
   newscript->GetAI = &GetAI_npc_DeathspeakerHighPriestAI;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_DeathspeakerServant";
   newscript->GetAI = &GetAI_npc_DeathspeakerServantAI;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_DeathspeakerZealot";
   newscript->GetAI = &GetAI_npc_DeathspeakerZealotAI;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_CultAdherent";
   newscript->GetAI = &GetAI_npc_CultAdherentAI;
   newscript->RegisterSelf();

   newscript = new Script;
   newscript->Name="npc_CultFanatic";
   newscript->GetAI = &GetAI_npc_CultFanaticAI;
   newscript->RegisterSelf();
}

 

 

 

 

rat_des_blutes.cpp

 

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "ScriptedPch.h"
#include "icecrown_citadel.h"

/*HACK*/
struct boss_blood_elf_ValanarAI : public ScriptedAI
{
   boss_blood_elf_ValanarAI(Creature *pCreature) : ScriptedAI(pCreature)
   {
	m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;


   void Reset()
   {

	if(m_pInstance)
	m_pInstance->SetData(DATA_BLOOD_PRINCE_COUNCIL_EVENT, NOT_STARTED);  
   }

   void JustDied(Unit* pKiller)
   {
	if(m_pInstance)
	m_pInstance->SetData(DATA_BLOOD_PRINCE_COUNCIL_EVENT, DONE);  
   }

   void EnterCombat(Unit* who)
   {
	if(m_pInstance)
	m_pInstance->SetData(DATA_BLOOD_PRINCE_COUNCIL_EVENT, IN_PROGRESS);  
   }

   void JustReachedHome()
   {
	if(m_pInstance)
	m_pInstance->SetData(DATA_BLOOD_PRINCE_COUNCIL_EVENT, FAIL);  
   }

   void KilledUnit(Unit *victim)
   {
   }

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


	DoMeleeAttackIfReady();
}
};

struct boss_blood_elf_TaldaramAI : public ScriptedAI
{
   boss_blood_elf_TaldaramAI(Creature *pCreature) : ScriptedAI(pCreature)
   {
	m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;


   void Reset()
   {
   }

   void EnterCombat(Unit* who)
   {
   }

   void KilledUnit(Unit *victim)
   {
   }

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

	DoMeleeAttackIfReady();
}
};

struct boss_blood_elf_KelesetAI : public ScriptedAI
{
   boss_blood_elf_KelesetAI(Creature *pCreature) : ScriptedAI(pCreature)
   {
	m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;


   void Reset()
   {
   }

   void EnterCombat(Unit* who)
   {
   }

   void KilledUnit(Unit *victim)
   {
   }

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

CreatureAI* GetAI_boss_blood_elf_Valanar(Creature* pCreature)
{
   return new boss_blood_elf_ValanarAI(pCreature);
}

CreatureAI* GetAI_boss_blood_elf_Taldaram(Creature* pCreature)
{
   return new boss_blood_elf_TaldaramAI(pCreature);
}

CreatureAI* GetAI_boss_blood_elf_Keleset(Creature* pCreature)
{
   return new boss_blood_elf_KelesetAI(pCreature);
}

void AddSC_boss_rat_des_blutes()
{
   Script* NewScript;

   NewScript = new Script;
   NewScript->Name = "boss_blood_elf_Valanar";
   NewScript->GetAI = &GetAI_boss_blood_elf_Valanar;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "boss_blood_elf_Taldaram";
   NewScript->GetAI = &GetAI_boss_blood_elf_Taldaram;
   NewScript->RegisterSelf();

NewScript = new Script;
   NewScript->Name = "boss_blood_elf_Keleset";
   NewScript->GetAI = &GetAI_boss_blood_elf_Keleset;
   NewScript->RegisterSelf();
}

 

 

 

 

blood_queen_lana_thel.cpp

 

 

 

/* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "ScriptedPch.h"
#include "icecrown_citadel.h"

enum Yells
{
SAY_AGGRO			=	-1666053,
SAY_VAMP_BITE_1		=	-1666054,	
SAY_VAMP_BITE_2		=	-1666055,
SAY_SWARM_SHADOWS	=	-1666056,
SAY_PACT_DARKFALLEN	=	-1666057,
SAY_MIND_CONTROLL	=	-1666058,
SAY_AIR_PHASE		=	-1666059,
SAY_BERSERK			=	-1666060,
SAY_DEATH			=	-1666061,
};

enum BloodQuennSpells
{
SPELL_SHROUD_OF_SORROW			=	72982,
SPELL_DELIRIOUS_SLASH			=	71623,
SPELL_BLOOD_MIRROR_1			=	70821,
SPELL_BLOOD_MIRROR_2			=	71510,
SPELL_VAMPIRIC_BITE				=	71726,
SPELL_PACT_OF_THE_DARKFALLEN_1	=	71340, 
SPELL_PACT_OF_THE_DARKFALLEN_2	=	71341, 
SPELL_SWARMING_SHADOWS			=	71264, // Spawn Creature 38163 need Visual Spell ID :/
SPELL_TWILIGHT_BLOODBOLT		=	71446, 
SPELL_BLOODBOLD_WHIRL			=	71772,
SPELL_BLOODBOLD_SPLASH			=	71481,
SPELL_BERSERK					=	47008,
SPELL_INCITE_TERROR				=	73070
};

enum SwarmingShadowSpells
{
SPELL_SWARMING_SHADOWS_VISUAL		=	71267, // 72890
N_10_SPELL_SWARMING_SHADOW_DAMAGE	=	71267,
N_25_SPELL_SWARMING_SHADOW_DAMAGE	=	72635,	
H_10_SPELL_SWARMING_SHADOW_DAMAGE	=	72636,
H_25_SPELL_SWARMING_SHADOW_DAMAGE	=	72637,
};

enum Creatures
{
CREATURE_SWARMING_SHADOWS	=	38163,
};

enum Achievments
{
ACHIEVMENT_ONCE_BITTEN_TWICE_SHY_10	=	4539,
ACHIEVMENT_ONCE_BITTEN_TWICE_SHY_25	=	4618,
};

const Position Phase2Position = { 4595.640137, 2769.195557, 400.137054};
const Position FlyPosition = { 4595.904785, 2769.315918, 421.838623};

struct boss_blood_queen_lanathelAI : public ScriptedAI
{
   boss_blood_queen_lanathelAI(Creature *pCreature) : ScriptedAI(pCreature)
{
       m_pInstance = pCreature->GetInstanceData();
   }

ScriptedInstance* m_pInstance;

uint32 m_uiTwilightBloodboltTimer;
uint32 m_uiPhaseTimer;
uint32 m_uiVampBiteTimer;
uint32 m_uiSwarmingShadowsTimer;
uint32 m_uiPactofDarkfallenTimer;
   uint32 m_uiPactofDarkfallenExplodeTimer;
uint32 m_uiPactofDarkfallenExplosionCount;
uint32 m_uiPhase;
uint32 m_uiBerserkTimer;		
uint32 m_uiSetHoverTimer;
uint32 m_uiLandingTimer;
uint32 m_uiFlyingFalseTimer;
uint32 m_uiBloodboldSplashTimer;

void Reset()
{
	m_uiPhaseTimer = 90000;

	m_uiTwilightBloodboltTimer = 10000;
	m_uiVampBiteTimer	= 15000;
	m_uiSwarmingShadowsTimer = 30000;
	m_uiPactofDarkfallenTimer	= 5000;
	m_uiSetHoverTimer = 90000;
	m_uiBloodboldSplashTimer = 900000;
	m_uiLandingTimer = 900000;
	m_uiFlyingFalseTimer = 900000;

	/************ Other **********/
	m_uiPhase = 1;
	m_uiBerserkTimer	= 330000;
	me->SetFlying(false);

	me->SetReactState(REACT_AGGRESSIVE);

	if (m_pInstance)
           m_pInstance->SetData(DATA_BLOOD_QUEEN_LANATHEL_EVENT, NOT_STARTED);
}

void EnterCombat(Unit *who)
{
	DoScriptText(SAY_AGGRO, me);

	if (m_pInstance)
           m_pInstance->SetData(DATA_BLOOD_QUEEN_LANATHEL_EVENT, IN_PROGRESS);
}

void KilledUnit(Unit* victim)
{
}

void JustDied(Unit* Killer)
{
	DoScriptText(SAY_DEATH, me);

	if (m_pInstance)
           m_pInstance->SetData(DATA_BLOOD_QUEEN_LANATHEL_EVENT, DONE);
}

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

	if (!me->HasAura(SPELL_SHROUD_OF_SORROW))
		DoCast(me, SPELL_SHROUD_OF_SORROW);

		if(m_uiPhase == 1)
		{

			if (m_uiPactofDarkfallenTimer <= uiDiff)
			{
//					PactFallen();

				DoScriptText(SAY_PACT_DARKFALLEN, me);
				m_uiPactofDarkfallenExplosionCount = 0;
				m_uiPactofDarkfallenExplodeTimer = 2000;
				m_uiPactofDarkfallenTimer = 25000;
			} 
			else m_uiPactofDarkfallenTimer -= uiDiff;

			if (m_uiSwarmingShadowsTimer < uiDiff)
			{
				if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
				DoCast(target, SPELL_SWARMING_SHADOWS);
				m_uiSwarmingShadowsTimer  = 30000;
			}
			else m_uiSwarmingShadowsTimer -= uiDiff;

			if (m_uiTwilightBloodboltTimer < uiDiff)
			{
				if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
				DoCast(target, SPELL_TWILIGHT_BLOODBOLT);
				m_uiTwilightBloodboltTimer  = 9000;
			}
			else m_uiTwilightBloodboltTimer -= uiDiff;

			if (m_uiVampBiteTimer < uiDiff)
			{
				DoScriptText(RAND(SAY_VAMP_BITE_1,SAY_VAMP_BITE_2), me);
				if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 1))
				DoCast(target, SPELL_VAMPIRIC_BITE);
				m_uiVampBiteTimer	= 45000+rand()%20000;
			}
			else m_uiVampBiteTimer -= uiDiff;

			if (m_uiPhaseTimer < uiDiff)
			{	
				DoScriptText(SAY_AIR_PHASE, me);
				DoCast(me, SPELL_INCITE_TERROR);
				me->GetMotionMaster()->MovePoint(0, Phase2Position);
				me->SetReactState(REACT_PASSIVE);
				me->AttackStop();
				m_uiPhase = 2;
				m_uiPhaseTimer	= 90000;
				m_uiSetHoverTimer = 5000;
				m_uiBloodboldSplashTimer = 10000;
				m_uiLandingTimer = 26000;
				m_uiFlyingFalseTimer = 30000;
			}
			else m_uiPhaseTimer -= uiDiff;
		}

	if(m_uiPhase == 2)
	{
		if (m_uiSetHoverTimer < uiDiff)
		{
			me->GetMotionMaster()->MovePoint(0, FlyPosition);
			me->SetUnitMovementFlags(MOVEMENTFLAG_JUMPING);
			me->SetFlying(true);
			m_uiSetHoverTimer	= 90000;
		}
		else m_uiSetHoverTimer -= uiDiff;

		if (m_uiBloodboldSplashTimer < uiDiff)
		{
              std::list<Unit*> pTargets;
                   SelectTargetList(pTargets, 5, SELECT_TARGET_RANDOM, 80, true);
                   for (std::list<Unit*>::const_iterator i = pTargets.begin(); i != pTargets.end(); ++i)
                       DoCast(*i, RAID_MODE(SPELL_TWILIGHT_BLOODBOLT,SPELL_TWILIGHT_BLOODBOLT));
			m_uiBloodboldSplashTimer = 2000;
		}
		else m_uiBloodboldSplashTimer -= uiDiff;

		if (m_uiLandingTimer < uiDiff)
		{
			me->GetMotionMaster()->MovePoint(0, Phase2Position);
			me->SetUnitMovementFlags(MOVEMENTFLAG_JUMPING);
			m_uiLandingTimer	= 900000;
			m_uiBloodboldSplashTimer = 900000;
		}
		else m_uiLandingTimer -= uiDiff;

		if (m_uiFlyingFalseTimer < uiDiff)
		{
			me->SetFlying(false);
			me->RemoveAllAuras();
			me->SetReactState(REACT_AGGRESSIVE);
			me->GetMotionMaster()->MoveChase(me->getVictim());
			m_uiPhase = 1;
			m_uiFlyingFalseTimer = 900000;
		}
		else m_uiFlyingFalseTimer -= uiDiff;
	}

	DoMeleeAttackIfReady();
}
};

struct npc_swarming_shadowsAI : public Scripted_NoMovementAI
{
   npc_swarming_shadowsAI(Creature *pCreature) : Scripted_NoMovementAI(pCreature)
   {
       m_pInstance = pCreature->GetInstanceData();
   }

   ScriptedInstance* m_pInstance;

uint32 m_uiSwarmingShadowTimer;

   void Reset()
   {
	me->SetReactState(REACT_PASSIVE);
	m_uiSwarmingShadowTimer = 1200;
   }
   void UpdateAI(const uint32 uiDiff)
   {
	if (!me->HasAura(SPELL_SWARMING_SHADOWS_VISUAL))
		DoCast(me, SPELL_SWARMING_SHADOWS_VISUAL);

	if (m_uiSwarmingShadowTimer < uiDiff)
	{
		DoCast(me, RAID_MODE(N_10_SPELL_SWARMING_SHADOW_DAMAGE,N_25_SPELL_SWARMING_SHADOW_DAMAGE,H_10_SPELL_SWARMING_SHADOW_DAMAGE,H_25_SPELL_SWARMING_SHADOW_DAMAGE));
		m_uiSwarmingShadowTimer	= 2000;
	}
	else m_uiSwarmingShadowTimer -= uiDiff;
   }
};

CreatureAI* GetAIboss_blood_queen_lanathelAI(Creature* pCreature)
{
   return new boss_blood_queen_lanathelAI (pCreature);
}

CreatureAI* GetAInpc_swarming_shadowsAI(Creature* pCreature)
{
   return new npc_swarming_shadowsAI (pCreature);
}

void AddSC_boss_blood_queen_lana_thel()
{
    Script *newscript;

    newscript = new Script;
    newscript->Name = "boss_blood_queen_lanathel";
    newscript->GetAI = &GetAIboss_blood_queen_lanathelAI;
    newscript->RegisterSelf();

    newscript = new Script;
    newscript->Name = "npc_swarming_shadows";
    newscript->GetAI = &GetAInpc_swarming_shadowsAI;
    newscript->RegisterSelf();
}

 

 

Edited by ali
  • Upvote 1

Share this post

Link to post
Share on other sites

ali    18

ali
Posted (edited)

Samotná Instancia:

 

 

instance_icecrown_citadel.cpp

 

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include "ScriptedPch.h"
#include "icecrown_citadel.h"

#define MAX_ENCOUNTER     12

struct instance_icecrown_citadel : public ScriptedInstance
{
   instance_icecrown_citadel(Map* pMap) : ScriptedInstance(pMap)
{
	Initialize();
};

   uint64 uiLordMarrowgar;
   uint64 uiLadyDeathwhisper;
   uint64 uiGunship;
uint64 uiDeathbringerSaurfang;
uint64 uiFestergut;
uint64 uiRotface;
uint64 uiProfessorPutricide;
uint64 uiPrinceValanar;
uint64 uiPrinceKeleseth;	
uint64 uiPrinceTaldaram;
uint64 uiBloodQueenLanathel;
uint64 uiValithriaDreamwalker;
uint64 uiSindragosa;
uint64 uiLichKing;

   uint64 uiMarrowgarDoor1;
uint64 uiMarrowgarDoor2;
uint64 uiMarrowgarDoor3;
uint64 uiFrozenThrone;
uint64 m_uiSaurfangCacheGUID;
   uint64 uiLadyDeathwisperTransporter;
   uint64 uiOratoryDoor;
   uint64 uiSaurfangDoor;
   uint64 uiOrangeMonsterDoor;
   uint64 uiGreenMonsterDoor;
   uint64 uiOrangeProffesorDoor;
   uint64 uiGreenProffesorDoor;
   uint64 uiProffesorDoor;
   uint64 uiBloodwingDoor;
   uint64 uiCrimsonHallDoor1;
   uint64 uiCrimsonHallDoor2;
   uint64 uiCrimsonHallDoor3;
   uint64 uiBloodQueenTransporter;
   uint64 uiFrostwingDoor;
   uint64 uiDragonDoor1;
   uint64 uiDragonDoor2;
   uint64 uiDragonDoor3;
   uint64 uiRoostDoor1;
   uint64 uiRoostDoor2;
   uint64 uiRoostDoor3;
   uint64 uiRoostDoor4;
   uint64 m_uiDreamwalkerCacheGUID; 
   uint64 uiSindragosaDoor1;
   uint64 uiSindragosaDoor2;
   uint64 uiIceShard1;
   uint64 uiIceShard2;
   uint64 uiIceShard3;
   uint64 uiIceShard4;
   uint64 uiFirstTp;
   uint64 uiMarrowgarTp;
   uint64 uiFlightWarTp;
   uint64 uiSaurfangTp;
   uint64 uiCitadelTp;
uint64 uiLichTp;

   uint32 auiEncounter[MAX_ENCOUNTER];

  void Initialize()
  {
       memset(&auiEncounter, 0, sizeof(auiEncounter));

       uiLordMarrowgar			= 0;
       uiLadyDeathwhisper		= 0;
       uiGunship               = 0;
	uiDeathbringerSaurfang	= 0;
	uiFestergut				= 0;
	uiRotface				= 0;
	uiProfessorPutricide	= 0;
	uiPrinceValanar			= 0;
	uiPrinceKeleseth		= 0;	
	uiPrinceTaldaram		= 0;
	uiBloodQueenLanathel	= 0;
	uiValithriaDreamwalker	= 0;
	uiSindragosa			= 0;
	uiLichKing				= 0;
	m_uiSaurfangCacheGUID   = 0;

       uiMarrowgarDoor1	= 0;
       uiMarrowgarDoor2	= 0;
	uiMarrowgarDoor3	= 0;
	uiLadyDeathwisperTransporter	=	0;
       uiOratoryDoor       = 0;
	uiSaurfangDoor      = 0;
       uiOrangeMonsterDoor = 0;
       uiGreenMonsterDoor  = 0;
       uiOrangeProffesorDoor  = 0;
       uiGreenProffesorDoor   = 0;
       uiProffesorDoor     = 0;
       uiBloodwingDoor     = 0;
       uiCrimsonHallDoor1  = 0;
       uiCrimsonHallDoor2  = 0;
       uiCrimsonHallDoor3  = 0;
       uiBloodQueenTransporter = 0;
       uiFrostwingDoor         = 0;
       uiDragonDoor1           = 0;
       uiDragonDoor2           = 0;
       uiDragonDoor3           = 0;
       uiRoostDoor1            = 0;
       uiRoostDoor2            = 0;
       uiRoostDoor3            = 0;
       uiRoostDoor4            = 0;
       uiSindragosaDoor1       = 0;
       uiSindragosaDoor2       = 0;
       uiIceShard1             = 0;
       uiIceShard2             = 0;
       uiIceShard3             = 0;
       uiIceShard4             = 0;
//      Portals
	uiFirstTp           = 0;
       uiMarrowgarTp       = 0;
       uiFlightWarTp       = 0;
       uiSaurfangTp        = 0;
       uiCitadelTp         = 0;
	uiLichTp            = 0;
   }

   bool IsEncounterInProgress() const
   {
       for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
           if (auiEncounter[i] == IN_PROGRESS) return true;

       return false;
   }

   void OnCreatureCreate(Creature* pCreature, bool add)
   {
       switch(pCreature->GetEntry())
       {
           case 36612: uiLordMarrowgar = pCreature->GetGUID(); break;
           case 36855:	uiLadyDeathwhisper = pCreature->GetGUID(); break;
		case 30343: uiGunship = pCreature->GetGUID(); break;
		case 37813:	uiDeathbringerSaurfang = pCreature->GetGUID(); break;
		case 36626: uiFestergut = pCreature->GetGUID(); break;
		case 36627: uiRotface = pCreature->GetGUID(); break;
		case 36678: uiProfessorPutricide = pCreature->GetGUID(); break;
		case 37970: uiPrinceValanar = pCreature->GetGUID(); break;
		case 37972: uiPrinceKeleseth = pCreature->GetGUID(); break;
		case 37973: uiPrinceTaldaram = pCreature->GetGUID(); break;
		case 37955: uiBloodQueenLanathel = pCreature->GetGUID(); break;
		case 36789: uiValithriaDreamwalker = pCreature->GetGUID(); break;
		case 36853: uiSindragosa = pCreature->GetGUID(); break;
		case 36597:	uiLichKing = pCreature->GetGUID(); break;
       }
   }

   void OnGameObjectCreate(GameObject* pGo, bool add)
   {
       switch (pGo->GetEntry())
       {
           case 201910:
               uiMarrowgarDoor1 = pGo->GetGUID();
			if (auiEncounter[0] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
               break;
		case 201911:
               uiMarrowgarDoor2 = pGo->GetGUID();
               if (auiEncounter[0] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
               break;
		case 201857:
			uiMarrowgarDoor3 = pGo->GetGUID();
               if (auiEncounter[0] == DONE)
                   HandleGameObject(NULL,true,pGo);
               break;
		case 201563:
               uiOratoryDoor = pGo->GetGUID();
			if (auiEncounter[1] == DONE)
                   HandleGameObject(NULL,true,pGo);
			break;
		case 202220:
			uiLadyDeathwisperTransporter = pGo->GetGUID();
			if (auiEncounter[1] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
               break;
		case 201825:
			uiSaurfangDoor = pGo->GetGUID();
			if (auiEncounter[3] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
			break;
		case 201919:
			uiBloodwingDoor = pGo->GetGUID();
			if (auiEncounter[3] == DONE)
                   HandleGameObject(NULL,true,pGo);
                       break;
		case 201920:
			uiFrostwingDoor = pGo->GetGUID();
			if (auiEncounter[3] == DONE)
                   HandleGameObject(NULL,true,pGo);
                       break;
		case 201371:
			uiOrangeMonsterDoor = pGo->GetGUID();
			if (auiEncounter[4] == DONE)
                   HandleGameObject(NULL,true,pGo);
			break;
		case 201613:
			uiOrangeProffesorDoor = pGo->GetGUID();
			if (auiEncounter[4] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
			break;
		case 201370:
			uiGreenMonsterDoor = pGo->GetGUID();
			if (auiEncounter[5] == DONE)
                   HandleGameObject(NULL,true,pGo);
			break;
		case 201614:
			uiGreenProffesorDoor = pGo->GetGUID();
			if (auiEncounter[5] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
			break;
		case 201372:
			uiProffesorDoor = pGo->GetGUID();
			if (auiEncounter[6] == DONE)
                   HandleGameObject(NULL,true,pGo);
			break;
		case 201376:
			uiCrimsonHallDoor1 = pGo->GetGUID();
			if (auiEncounter[7] == DONE)
                   HandleGameObject(NULL,true,pGo);
                       break;
		case 201377:
			uiCrimsonHallDoor2 = pGo->GetGUID();
			if (auiEncounter[7] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 201378:
			uiCrimsonHallDoor3 = pGo->GetGUID();
			if (auiEncounter[7] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 201755:
			uiBloodQueenTransporter = pGo->GetGUID();
			if (auiEncounter[8] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 201375:
			uiDragonDoor1 = pGo->GetGUID();
			if (auiEncounter[9] == DONE)
                   HandleGameObject(NULL,true,pGo);
                       break;
		case 201374:
			uiDragonDoor2 = pGo->GetGUID();
			if (auiEncounter[9] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 201379:
			uiDragonDoor3 = pGo->GetGUID();
			if (auiEncounter[9] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 201380:
			uiRoostDoor1 = pGo->GetGUID();
			if (auiEncounter[9] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 201381:
			uiRoostDoor2 = pGo->GetGUID();
			if (auiEncounter[9] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 201382:
			uiRoostDoor3 = pGo->GetGUID();
			if (auiEncounter[9] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 201383:
			uiRoostDoor4 = pGo->GetGUID();
			if (auiEncounter[9] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 201373:
			uiSindragosaDoor1 = pGo->GetGUID();
			if (auiEncounter[10] == DONE)
                   HandleGameObject(NULL,true,pGo);
                       break;
		case 201369:
			uiSindragosaDoor2 = pGo->GetGUID();
			if (auiEncounter[10] == DONE)
                   HandleGameObject(NULL,true,pGo);
                       break;
		case 202142:
			uiIceShard1 = pGo->GetGUID();
			if (auiEncounter[11] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 202141:
			uiIceShard2 = pGo->GetGUID();
			if (auiEncounter[11] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 202143:
			uiIceShard3 = pGo->GetGUID();
			if (auiEncounter[11] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 202144:
			uiIceShard4 = pGo->GetGUID();
			if (auiEncounter[11] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
                       break;
		case 202239: // 10 Normal
			m_uiSaurfangCacheGUID = pGo->GetGUID();
			break;
           case 202240: // 25 Normal
			m_uiSaurfangCacheGUID = pGo->GetGUID();
			break;
           case 202238: // 10 Heroic
			m_uiSaurfangCacheGUID = pGo->GetGUID();
			break;
           case 202241: // 25 Heroic
			m_uiSaurfangCacheGUID = pGo->GetGUID();
			break;
		case 201959: // 10 Normal
			m_uiDreamwalkerCacheGUID = pGo->GetGUID();
			break;
           case 202339: // 25 Normal
			m_uiDreamwalkerCacheGUID = pGo->GetGUID();
			break;
           case 202338: // 10 Heroic
			m_uiDreamwalkerCacheGUID = pGo->GetGUID();
			break;
           case 202340: // 25 Heroic
			m_uiDreamwalkerCacheGUID = pGo->GetGUID();
			break;
		case 202242:
               uiFirstTp = pGo->GetGUID();
			if (auiEncounter[0] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
			break;
		case 202243:
               uiMarrowgarTp = pGo->GetGUID();
			if (auiEncounter[0] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
			break;
		case 202244:
               uiFlightWarTp = pGo->GetGUID(); 
			break;
		case 202245:
               uiSaurfangTp = pGo->GetGUID();
			if (auiEncounter[1] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
			break;
		case 202235:
			uiCitadelTp = pGo->GetGUID();
			if (auiEncounter[3] == NOT_STARTED)
                   HandleGameObject(NULL,false,pGo);
			break;
		case 202223:
			uiLichTp = pGo->GetGUID();
			break;
		 }
	}

   uint64 GetData64(uint32 identifier)
   {
       switch(identifier)
       {
           case DATA_MARROWGAR:				return uiLordMarrowgar;
           case DATA_DEATHWHISPER:				return uiLadyDeathwhisper;
           case DATA_GUNSHIP_BATTLE:           return uiGunship;
		case DATA_SAURFANG:				    return uiDeathbringerSaurfang;
		case DATA_FESTERGURT:				return uiFestergut;
		case DATA_ROTFACE:				    return uiRotface;
		case DATA_PROFESSOR_PUTRICIDE:		return uiProfessorPutricide;
		case DATA_PRINCE_VALANAR_ICC:		return uiPrinceValanar;
		case DATA_PRINCE_KELESETH_ICC:		return uiPrinceKeleseth;
		case DATA_PRINCE_TALDARAM_ICC:		return uiPrinceTaldaram;
		case DATA_BLOOD_QUEEN_LANATHEL:		return uiBloodQueenLanathel;
		case DATA_VALITHRIA_DREAMWALKER:	return uiValithriaDreamwalker;
		case DATA_SINDRAGOSA:				return uiSindragosa;
		case DATA_LICH_KING:				return uiLichKing;
       }
       return 0;
   }

   void SetData(uint32 type, uint32 data)
   {
       switch(type)
	{
//////////////////////////////////////
		case DATA_MARROWGAR_EVENT:
		switch(data)
           {
		case DONE:
			HandleGameObject(uiMarrowgarDoor1,true);
			HandleGameObject(uiMarrowgarDoor2,true);
			HandleGameObject(uiMarrowgarDoor3,true);
               HandleGameObject(uiFirstTp,true);
               HandleGameObject(uiMarrowgarTp,true);
		    if (GameObject* pFirstTp = instance->GetGameObject(uiFirstTp))
		        if (pFirstTp && pFirstTp->isSpawned()) 
		        {
		            pFirstTp->RemoveFlag(GAMEOBJECT_FLAGS,GO_FLAG_INTERACT_COND);
		        }
		    if (GameObject* pMarrowgarTp = instance->GetGameObject(uiMarrowgarTp))
		        if (pMarrowgarTp && pMarrowgarTp->isSpawned()) 
		        {
		            pMarrowgarTp->RemoveFlag(GAMEOBJECT_FLAGS,GO_FLAG_INTERACT_COND);
		        }

			break;
           case NOT_STARTED:
               HandleGameObject(uiMarrowgarDoor1,false);
			HandleGameObject(uiMarrowgarDoor2,false);
			HandleGameObject(uiMarrowgarDoor3,true);
               HandleGameObject(uiFirstTp,false);
               HandleGameObject(uiMarrowgarTp,false);
			break;
		case IN_PROGRESS:
			HandleGameObject(uiMarrowgarDoor3,false);
			break;
		}
		auiEncounter[0] = data;
		break;
///////////////////////////////////////////////
		case DATA_DEATHWHISPER_EVENT:
		switch(data)
           {
		case DONE:
               HandleGameObject(uiSaurfangTp,true);
			HandleGameObject(uiLadyDeathwisperTransporter,true);
               HandleGameObject(uiFlightWarTp,true);
               HandleGameObject(uiOratoryDoor,true);
		    if (GameObject* pSaurfangTp = instance->GetGameObject(uiSaurfangTp))
		        if (pSaurfangTp && pSaurfangTp->isSpawned()) 
		        {
		            pSaurfangTp->RemoveFlag(GAMEOBJECT_FLAGS,GO_FLAG_INTERACT_COND);
		        }
		    if (GameObject* pFlightWarTp = instance->GetGameObject(uiFlightWarTp))
		        if (pFlightWarTp && pFlightWarTp->isSpawned()) 
		        {
		            pFlightWarTp->RemoveFlag(GAMEOBJECT_FLAGS,GO_FLAG_INTERACT_COND);
		        }
			break;
		case IN_PROGRESS:
	        HandleGameObject(uiOratoryDoor,false);
               HandleGameObject(uiSaurfangTp,false);
	        HandleGameObject(uiLadyDeathwisperTransporter,false);
               HandleGameObject(uiFlightWarTp,false);
			break;
           case NOT_STARTED:
               HandleGameObject(uiOratoryDoor,true);
			break;
		}
		auiEncounter[1] = data;
		break;
////////////////////////////////////////////////////
		case DATA_GUNSHIP_BATTLE_EVENT:
		switch(data)
           {
		case DONE:
               HandleGameObject(uiOratoryDoor,true);
			break;
           case NOT_STARTED:
               HandleGameObject(uiOratoryDoor,false);
			break;
		}
		auiEncounter[2] = data;
		break;
////////////////////////////////////////////////////
		case DATA_SAURFANG_EVENT:
           switch(data)
		{
		case DONE:
		    if (GameObject* pChest = instance->GetGameObject(m_uiSaurfangCacheGUID))
		        if (pChest && !pChest->isSpawned()) 
		        {
		            pChest->SetRespawnTime(pChest->GetRespawnDelay());
		        }
			    HandleGameObject(uiSaurfangDoor,true);
			    HandleGameObject(uiBloodwingDoor,true);
			    HandleGameObject(uiFrostwingDoor,true);
			    HandleGameObject(uiCitadelTp, true);
		    if (GameObject* pCitadelTp = instance->GetGameObject(uiCitadelTp))
		        if (pCitadelTp && pCitadelTp->isSpawned()) 
		        {
		            pCitadelTp->RemoveFlag(GAMEOBJECT_FLAGS,GO_FLAG_INTERACT_COND);
		        }
                       break;
           case NOT_STARTED:
              HandleGameObject(uiSaurfangDoor,false);
			    HandleGameObject(uiBloodwingDoor,false);
			    HandleGameObject(uiFrostwingDoor,false);
			break;
		case IN_PROGRESS:
               HandleGameObject(uiSaurfangDoor,false);
			    HandleGameObject(uiBloodwingDoor,false);
			    HandleGameObject(uiFrostwingDoor,false);
			break;
		}
			auiEncounter[3] = data;
			break;
/////////////////////////////////////////////////
		case DATA_FESTERGURT_EVENT:
           switch(data)
		{
		case DONE:

			    HandleGameObject(uiOrangeMonsterDoor,true);
			    HandleGameObject(uiOrangeProffesorDoor, true);
			break;
           case NOT_STARTED:
               HandleGameObject(uiOrangeMonsterDoor,true);
               HandleGameObject(uiOrangeProffesorDoor,false);
			break;
		case IN_PROGRESS:
               HandleGameObject(uiOrangeMonsterDoor,false);
			break;
		}
			auiEncounter[4] = data;
			break;
////////////////////////////////////////////////
		case DATA_ROTFACE_EVENT:
           switch(data)
		{
		case DONE:
			    HandleGameObject(uiGreenMonsterDoor,true);
			    HandleGameObject(uiGreenProffesorDoor, true);
			break;
           case NOT_STARTED:
			    HandleGameObject(uiGreenMonsterDoor,true);
			    HandleGameObject(uiGreenProffesorDoor, false);
			break;
		case IN_PROGRESS:
               HandleGameObject(uiGreenMonsterDoor,false);
			break;
		}
			auiEncounter[5] = data;
			break;
////////////////////////////////////////////////
		case DATA_PROFESSOR_PUTRICIDE_EVENT:
           switch(data)
		{
		case DONE:
			    HandleGameObject(uiProffesorDoor, true);
			break;
           case NOT_STARTED:
			    HandleGameObject(uiProffesorDoor, true);
			break;
		case IN_PROGRESS:
			    HandleGameObject(uiProffesorDoor, false);
			break;
		}
			auiEncounter[6] = data;
			break;
////////////////////////////////////////////////
		case DATA_BLOOD_PRINCE_COUNCIL_EVENT:
           switch(data)
		{
		case DONE:
			    HandleGameObject(uiCrimsonHallDoor1,true);
			    HandleGameObject(uiCrimsonHallDoor2,true);
			    HandleGameObject(uiCrimsonHallDoor3,true);
               break;
           case NOT_STARTED:
			    HandleGameObject(uiCrimsonHallDoor1,true);
			    HandleGameObject(uiCrimsonHallDoor2,false);
			    HandleGameObject(uiCrimsonHallDoor3,false);
			break;
		case IN_PROGRESS:
			    HandleGameObject(uiCrimsonHallDoor1,false);
			break;
		}
			auiEncounter[7] = data;
			break;
///////////////////////////////////////////////
		case DATA_BLOOD_QUEEN_LANATHEL_EVENT:
           switch(data)
		{
		case DONE:
			    HandleGameObject(uiBloodQueenTransporter,true);
			break;
           case NOT_STARTED:
			    HandleGameObject(uiBloodQueenTransporter,false);
			break;
		case IN_PROGRESS:
			   HandleGameObject(uiBloodQueenTransporter,false);
			break;
		}
			auiEncounter[8] = data;
			break;
//////////////////////////////////////////////
		case DATA_VALITHRIA_DREAMWALKER_EVENT:
           switch(data)
		{
		case DONE:
		    if (GameObject* pChest = instance->GetGameObject(m_uiDreamwalkerCacheGUID))
		        if (pChest && !pChest->isSpawned()) 
		        {
		            pChest->SetRespawnTime(pChest->GetRespawnDelay());
		        }
			    HandleGameObject(uiDragonDoor1,true);
			    HandleGameObject(uiDragonDoor2,true);
		    HandleGameObject(uiDragonDoor3,true);
			    HandleGameObject(uiRoostDoor1,false);
			    HandleGameObject(uiRoostDoor2,false);
		    HandleGameObject(uiRoostDoor3,false);
			    HandleGameObject(uiRoostDoor4,false);
			break;
           case NOT_STARTED:
			    HandleGameObject(uiDragonDoor1,true);
			    HandleGameObject(uiDragonDoor2,false);
			HandleGameObject(uiDragonDoor3,false);
			    HandleGameObject(uiRoostDoor1,false);
			    HandleGameObject(uiRoostDoor2,false);
		    HandleGameObject(uiRoostDoor3,false);
			    HandleGameObject(uiRoostDoor4,false);
			break;
		case IN_PROGRESS:
	if (Difficulty()  == RAID_DIFFICULTY_10MAN_NORMAL ||
	    Difficulty()  == RAID_DIFFICULTY_10MAN_HEROIC)
         {
               HandleGameObject(uiDragonDoor1,false);
			    HandleGameObject(uiRoostDoor3,true);
			    HandleGameObject(uiRoostDoor2,true);
		    HandleGameObject(uiRoostDoor1,false);
			    HandleGameObject(uiRoostDoor4,false);
			break;
	  }
               HandleGameObject(uiDragonDoor1,false);
			    HandleGameObject(uiRoostDoor1,true);
			    HandleGameObject(uiRoostDoor2,true);
		    HandleGameObject(uiRoostDoor3,true);
			    HandleGameObject(uiRoostDoor4,true);
			break;
		}
			auiEncounter[9] = data;
			break;
//////////////////////////////////////////////
		case DATA_SINDRAGOSA_EVENT:
           switch(data)
		{
		case DONE:
			    HandleGameObject(uiSindragosaDoor1,true);
			    HandleGameObject(uiSindragosaDoor2,true);
			break;
           case NOT_STARTED:
			    HandleGameObject(uiSindragosaDoor1,true);
			    HandleGameObject(uiSindragosaDoor2,true);
			break;
		case IN_PROGRESS:
			    HandleGameObject(uiSindragosaDoor1,false);
			    HandleGameObject(uiSindragosaDoor2,false);
			break;
		}
			auiEncounter[10] = data;
			break;
/////////////////////////////////////////////////
		case DATA_LICH_KING_EVENT:
           switch(data)
		{
		case DONE:
			    HandleGameObject(uiIceShard1,true);
			    HandleGameObject(uiIceShard2,true);
			    HandleGameObject(uiIceShard3,true);
			    HandleGameObject(uiIceShard4,true);
			break;
           case NOT_STARTED:
			    HandleGameObject(uiIceShard1,false);
			    HandleGameObject(uiIceShard2,false);
			    HandleGameObject(uiIceShard3,false);
			    HandleGameObject(uiIceShard4,false);
			break;
		case IN_PROGRESS:
			    HandleGameObject(uiIceShard1,false);
			    HandleGameObject(uiIceShard2,false);
			    HandleGameObject(uiIceShard3,false);
			    HandleGameObject(uiIceShard4,false);
			break;
		}
			auiEncounter[10] = data;
			break;
       }

       if (data == DONE)
       {
           SaveToDB();
       }
}

   uint32 GetData(uint32 type)
   {
       switch(type)
       {
           case DATA_MARROWGAR_EVENT:				return auiEncounter[0];
           case DATA_DEATHWHISPER_EVENT:			return auiEncounter[1];
		case DATA_GUNSHIP_BATTLE_EVENT:			return auiEncounter[2];
		case DATA_SAURFANG_EVENT:				return auiEncounter[3];
		case DATA_FESTERGURT_EVENT:				return auiEncounter[4];
		case DATA_ROTFACE_EVENT:				return auiEncounter[5];
		case DATA_PROFESSOR_PUTRICIDE_EVENT:	return auiEncounter[6];
		case DATA_BLOOD_PRINCE_COUNCIL_EVENT:	return auiEncounter[7];
		case DATA_BLOOD_QUEEN_LANATHEL_EVENT:	return auiEncounter[8];
		case DATA_VALITHRIA_DREAMWALKER_EVENT:	return auiEncounter[9];
		case DATA_SINDRAGOSA_EVENT:				return auiEncounter[10];
		case DATA_LICH_KING_EVENT:				return auiEncounter[11];
       }
       return 0;
   }

  std::string GetSaveData()
  {
	OUT_SAVE_INST_DATA;

	std::ostringstream saveStream;
	saveStream << "I C" << auiEncounter[0] << " " << auiEncounter[1] << " " << auiEncounter[2] << " " << auiEncounter[3] 
	<< " " << auiEncounter[4] << " " << auiEncounter[5] << " " << auiEncounter[6] << " " << auiEncounter[7] << " " << auiEncounter[8]
	<< " " << auiEncounter[9] << " " << auiEncounter[10] << " " << auiEncounter[11];

	OUT_SAVE_INST_DATA_COMPLETE;
	return saveStream.str();
  }

   void Load(const char* in)
   {
       if (!in)
       {
           OUT_LOAD_INST_DATA_FAIL;
           return;
       }

       OUT_LOAD_INST_DATA(in);

       char dataHead1, dataHead2;
       uint16 data0,data1,data2,data3,data4,data5,data6,data7,data8,data9,data10,data11;

       std::istringstream loadStream(in);
       loadStream >> dataHead1 >> dataHead2 >> data0 >> data1 >> data2 >> data3 >> data4 >> data5 >> data6
	>> data7 >> data8 >> data9 >> data10 >> data11;

       if (dataHead1 == 'I' && dataHead2 == 'C')
       {
           auiEncounter[0] = data0;
           auiEncounter[1] = data1;
		auiEncounter[2] = data2;
		auiEncounter[3] = data3;
		auiEncounter[4] = data4;
		auiEncounter[5] = data5;
		auiEncounter[6] = data6;
		auiEncounter[7] = data7;
		auiEncounter[8] = data8;
		auiEncounter[9] = data9;
		auiEncounter[10] = data10;
		auiEncounter[11] = data11;

           for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
               if (auiEncounter[i] == IN_PROGRESS)
                   auiEncounter[i] = NOT_STARTED;

       } else OUT_LOAD_INST_DATA_FAIL;

       OUT_LOAD_INST_DATA_COMPLETE;
   }
};

InstanceData* GetInstanceData_instance_icecrown_citadel(Map* pMap)
{
   return new instance_icecrown_citadel(pMap);
}

void AddSC_instance_icecrown_citadel()
{
   Script* pNewScript;
   pNewScript = new Script;
   pNewScript->Name = "instance_icecrown_citadel";
   pNewScript->GetInstanceData = &GetInstanceData_instance_icecrown_citadel;
   pNewScript->RegisterSelf();
}

 

 

 

 

 

icecrown_citadel.h

 

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#ifndef DEF_ICECROWN_CITADEL_H
#define DEF_ICECROWN_CITADEL_H

enum Data
{
   DATA_MARROWGAR_EVENT,
   DATA_DEATHWHISPER_EVENT,
DATA_GUNSHIP_BATTLE_EVENT,
   DATA_SAURFANG_EVENT,
DATA_FESTERGURT_EVENT,
DATA_ROTFACE_EVENT,
DATA_PROFESSOR_PUTRICIDE_EVENT, 
DATA_BLOOD_PRINCE_COUNCIL_EVENT,
DATA_BLOOD_QUEEN_LANATHEL_EVENT,
DATA_VALITHRIA_DREAMWALKER_EVENT,
DATA_SINDRAGOSA_EVENT,
DATA_LICH_KING_EVENT,
};

enum Data64
{
   DATA_MARROWGAR,
   DATA_DEATHWHISPER,
   DATA_SAURFANG,
DATA_GUNSHIP_BATTLE,
DATA_FESTERGURT,
DATA_ROTFACE,
DATA_PROFESSOR_PUTRICIDE,
DATA_PRINCE_VALANAR_ICC,
DATA_PRINCE_KELESETH_ICC,
DATA_PRINCE_TALDARAM_ICC,
DATA_BLOOD_QUEEN_LANATHEL,
DATA_VALITHRIA_DREAMWALKER,
DATA_SINDRAGOSA,
DATA_LICH_KING,
};

enum mainCreatures
{
   CREATURE_MARROWGAR               = 36612,
   CREATURE_DEATHWHISPER            = 36855,
   CREATURE_GUNSHIP                 = 30343,
   CREATURE_SAURFANG                = 37813,
CREATURE_FESTERGURT				 = 36626,
CREATURE_ROTFACE				 = 36627,
CREATURE_PROFESSOR_PUTRICIDE	 = 36678,
CREATURE_PRINCE_VALANAR_ICC		 = 37970,
CREATURE_PRINCE_KELESETH_ICC	 = 37972,
CREATURE_PRINCE_TALDARAM_ICC	 = 37973,
CREATURE_BLOOD_QUEEN_LANATHEL    = 37955,
CREATURE_VALITHRIA_DREAMWALKER	 = 36789,
CREATURE_SINDRAGOSA				 = 36853,
CREATURE_LICH_KING				 = 36597,
};

#endif

 

 

 

 

 

Teleporter:

 

icecrown_teleport.cpp

 

 

 

/*
* Copyright (C) 2009 - 2010 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

/*
Complete: 70%
Created by Lordronn
*/


#include "ScriptedPch.h"
#include "icecrown_citadel.h"

#define LIGHTS_HAMMER 70781
#define ORATORY       70856
#define RAMPART       70857
#define DEATHBRINGER  70858
#define PLAGUEWORKS   9995
#define CRIMSONHALL   9996
#define FWHALLS     9997
#define QUEEN       70861
#define LICHKING    70860

bool GoHello_icecrown_teleporter( Player *pPlayer, GameObject *pGO )
{
   ScriptedInstance *pInstance = (ScriptedInstance *) pGO->GetInstanceData();
   if(!pInstance) return true;


   pPlayer->ADD_GOSSIP_ITEM(0, "Teleport to Light's Hammer", GOSSIP_SENDER_MAIN, LIGHTS_HAMMER);
   if(pInstance->GetData(DATA_MARROWGAR_EVENT) == DONE || pPlayer->isGameMaster())
{
       pPlayer->ADD_GOSSIP_ITEM(0, "Teleport to the Oratory of the Damned", GOSSIP_SENDER_MAIN, ORATORY);
       if(pInstance->GetData(DATA_DEATHWHISPER_EVENT) == DONE || pPlayer->isGameMaster())
	{
           pPlayer->ADD_GOSSIP_ITEM(0, "Teleport to the Rampart of Skulls", GOSSIP_SENDER_MAIN, RAMPART);
           pPlayer->ADD_GOSSIP_ITEM(0, "Teleport to Deathbringer's Rise", GOSSIP_SENDER_MAIN, DEATHBRINGER);
           if(pInstance->GetData(DATA_SAURFANG_EVENT) == DONE || pPlayer->isGameMaster())
		{
                 pPlayer->ADD_GOSSIP_ITEM(0, "Teleport to the Plagueworks", GOSSIP_SENDER_MAIN, PLAGUEWORKS);
                 pPlayer->ADD_GOSSIP_ITEM(0, "Teleport to the Crimson Halls", GOSSIP_SENDER_MAIN, CRIMSONHALL);
                 pPlayer->ADD_GOSSIP_ITEM(0, "Teleport to the Frostwing Halls", GOSSIP_SENDER_MAIN, FWHALLS);
                 if(pInstance->GetData(DATA_VALITHRIA_DREAMWALKER_EVENT) == DONE || pPlayer->isGameMaster())
			  {
                        pPlayer->ADD_GOSSIP_ITEM(0, "Teleport to The Frost Queens's Lair", GOSSIP_SENDER_MAIN, QUEEN);
                        if(pInstance->GetData(DATA_SINDRAGOSA_EVENT) == DONE || pPlayer->isGameMaster())
					 { 
                           pPlayer->ADD_GOSSIP_ITEM(0, "Teleport to the Frozen Throne", GOSSIP_SENDER_MAIN, LICHKING);

					 }
			  }
		}
	}
}

   pPlayer->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGE, pGO->GetGUID());

   return true;
};


bool GOSelect_icecrown_teleporter( Player *pPlayer, GameObject *pGO, uint32 sender, uint32 action )
{
   if(sender != GOSSIP_SENDER_MAIN) return true;
   if(!pPlayer->getAttackers().empty()) return true;


   switch(action)
   {
   case LIGHTS_HAMMER:
       pPlayer->TeleportTo(631, -17.856115, 2211.640137, 30.115812, 3.12149);
       pPlayer->CLOSE_GOSSIP_MENU();
	break;

   case ORATORY:
       pPlayer->TeleportTo(631, -503.632599, 2211.219971, 62.823246, 3.139313);
       pPlayer->CLOSE_GOSSIP_MENU();
	break;

   case RAMPART:
       pPlayer->TeleportTo(631, -615.098267, 2211.509766, 199.973083, 6.26832);
       pPlayer->CLOSE_GOSSIP_MENU();
	break;

   case DEATHBRINGER:
       pPlayer->TeleportTo(631, -549.151001, 2211.463967, 539.290222, 6.275452);
       pPlayer->CLOSE_GOSSIP_MENU();
	break;

   case PLAGUEWORKS:
       pPlayer->TeleportTo(631, 4356.780273, 2863.636230, 349.337982, 1.559445);
       pPlayer->CLOSE_GOSSIP_MENU();
	break;

   case CRIMSONHALL:
       pPlayer->TeleportTo(631, 4453.248535, 2769.325684, 349.347473, 0.023817);
       pPlayer->CLOSE_GOSSIP_MENU();
	break;

   case FWHALLS:
       pPlayer->TeleportTo(631, 4356.853516, 2674.143311, 349.340118, 4.736377);
       pPlayer->CLOSE_GOSSIP_MENU();
	break;

   case QUEEN:
       pPlayer->TeleportTo(631, 4356.527344, 2402.710205, 220.462723, 4.886216);
       pPlayer->CLOSE_GOSSIP_MENU(); 
	break;

   case LICHKING:
       pPlayer->TeleportTo(631, 529.3969, -2124.879883, 1055.959961, 0.120937);
       pPlayer->CLOSE_GOSSIP_MENU(); 
	break;
   }

   return true;
}


void AddSC_icecrown_teleporter()
{
   Script *newscript;
   newscript = new Script;
   newscript->Name = "icecrown_teleporter";
   newscript->pGOHello = &GoHello_icecrown_teleporter;
   newscript->pGOSelect = &GOSelect_icecrown_teleporter;
   newscript->RegisterSelf();
}

 

 

 

 

 

 

 

Dúfam že vam to pomoholo :-)

Edited by ali
  • Upvote 3

Share this post

Link to post
Share on other sites

Wajrous    39

Wajrous
Posted

Nebylo by od věci, aby se napsalo na jaký to je patch. Některé lidi by to nenapadlo. Zkoušel jsi to?

Share this post

Link to post
Share on other sites

ali    18

ali
Posted

Nebylo by od věci, aby se napsalo na jaký to je patch. Některé lidi by to nenapadlo. Zkoušel jsi to?

 

 

Ano skušal som to a je to v poriadku skušal som to na patch 3.3.3a ale malo by to isť aj na staršom.

Share this post

Link to post
Share on other sites

Wolf Officious    1382

Wolf Officious
Posted

Ano skušal som to a je to v poriadku skušal som to na patch 3.3.3a ale malo by to isť aj na staršom.

 

No tak hlavně by to mělo jít na těch, kde je ICC, ne? :D

 

A odkud že jsi to vlastně čerpal? Nějak jsem si nevšimnul. :) Jinak pecka, až se vyhrabu z CaTaNGOSu a začnu zase dělat TC, určitě to využiju.

Share this post

Link to post
Share on other sites

ali    18

ali
Posted

No tak hlavně by to mělo jít na těch, kde je ICC, ne? :D

 

A odkud že jsi to vlastně čerpal? Nějak jsem si nevšimnul. :) Jinak pecka, až se vyhrabu z CaTaNGOSu a začnu zase dělat TC, určitě to využiju.

 

 

 

Ani neviem odkiaľ mam to dlhšie len až teraz som to našiel ale bolo to niekde myslim na bitbucket

Share this post

Link to post
Share on other sites

Wajrous    39

Wajrous
Posted

V tom případě něco z toho vyzkouším i já a děkuji, že jsi mi ušetřil pár chvil :) +rep

Share this post

Link to post
Share on other sites

Angelo    120

Angelo
Posted

Má to len jeden háčik, teleporter nemá portovať priamo k "end-wing" bossom, ale len do Upper Spire, ak by niekto chcel robiť blizz-like, tak by bolo dobré si to opraviť :o)

Share this post

Link to post
Share on other sites

overy    23

overy
Posted (edited)

hmm hustý vim odkud cerpal 

http://www.wowresource.eu/index.php?showtopic=18726

:innocent:

 

no aspon napsal ze to neni jeho prace ... ale aspon vime co jsou to za scripty :)

Edited by overy

Share this post

Link to post
Share on other sites

ali    18

ali
Posted

jenom by mě zajímalo testoval to někdo jak to jde?

 

PS: rep+ jestli to pujde

 

 

ja som to testoval ide to dobre až na Lich kinga hneď jak zabije all a nastane chvíľa kedy ich ma ten druhý revive tak padne server chcelo by to fix no ja to nezvládnem.

Share this post

Link to post
Share on other sites

killmatrixx    0

killmatrixx
Posted

jak to vlozim na server?

Když jsem to chtěl přikompilovat,tak mi to napsalo error: fatal error C1083: Cannot open precompiled header file: 'scripts.dir\Release\scripts.pch': No such file or directory nevíte co s tím?

Share this post

Link to post
Share on other sites

Wolf Officious    1382

Wolf Officious
Posted (edited)

Tohle už je docela starý, koukněte se někde na netu na novější, třeba na bolvořím bitbucketu: https://bitbucket.org/bolvor/icecrown-citadel/overview

peace :beach:

 

EDIT: Mimo jiné, už to tady jednou padlo: http://www.wowresource.eu/index.php?showtopic=18726&view=findpost&p=167906 Nevím proč se to tady musí objevovat milionkrát a stále poprvé. ;)

Edited by Wolf Officious

Share this post

Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
Sign in to follow this  
Followers 0
Go To Topic Listing Scripting
×