Scripts/Vault of Archavon: Cleaned and simplified scripts, fixed Toravon's Frozen Orb summon count

Closes issue #2857.

--HG--
branch : trunk

6 files changed, 605 insertions, 750 deletions

diff --git a/src/server/scripts/Northrend/VaultOfArchavon/boss_archavon.cpp b/src/server/scripts/Northrend/VaultOfArchavon/boss_archavon.cpp
index aa8f601e756..f25025b9b5e 100644
--- a/src/server/scripts/Northrend/VaultOfArchavon/boss_archavon.cpp
+++ b/src/server/scripts/Northrend/VaultOfArchavon/boss_archavon.cpp
@@ -37,110 +37,92 @@
 //Yell
 #define SAY_LEAP "Archavon the Stone Watcher lunges for $N!" //$N should be the target
 
-#define EVENT_ROCK_SHARDS        1  //15s cd
-#define EVENT_CHOKING_CLOUD      2  //30s cd
-#define EVENT_STOMP              3  //45s cd
-#define EVENT_IMPALE             4
-#define EVENT_BERSERK            5  //300s cd
-
-//mob
-#define EVENT_ROCK_SHOWER        5  //set = 20s cd,unkown cd
-#define EVENT_SHIELD_CRUSH       6  //set = 30s cd
-#define EVENT_WHIRL              8  //set= 10s cd
+enum Events
+{
+    // Archavon
+    EVENT_ROCK_SHARDS       = 1,    // 15s cd
+    EVENT_CHOKING_CLOUD     = 2,    // 30s cd
+    EVENT_STOMP             = 3,    // 45s cd
+    EVENT_IMPALE            = 4,
+    EVENT_BERSERK           = 5,    // 300s cd
+
+    //mob
+    EVENT_ROCK_SHOWER       = 6,    // set = 20s cd,unkown cd
+    EVENT_SHIELD_CRUSH      = 7,    // set = 30s cd
+    EVENT_WHIRL             = 8,    // set= 10s cd
+};
 
 class boss_archavon : public CreatureScript
 {
-public:
-    boss_archavon() : CreatureScript("boss_archavon") { }
-
-    CreatureAI* GetAI(Creature* pCreature) const
-    {
-        return new boss_archavonAI (pCreature);
-    }
-
-    struct boss_archavonAI : public ScriptedAI
-    {
-        boss_archavonAI(Creature *c) : ScriptedAI(c)
-        {
-            pInstance = c->GetInstanceScript();
-        }
-
-        InstanceScript* pInstance;
-        EventMap events;
+    public:
+        boss_archavon() : CreatureScript("boss_archavon") { }
 
-        void Reset()
+        struct boss_archavonAI : public BossAI
         {
-            events.Reset();
-
-            if (pInstance)
-                pInstance->SetData(DATA_ARCHAVON_EVENT, NOT_STARTED);
-        }
-
-        void KilledUnit(Unit* /*Victim*/) {}
+            boss_archavonAI(Creature* creature) : BossAI(creature, DATA_ARCHAVON)
+            {
+            }
 
-        void JustDied(Unit* /*Killer*/)
-        {
-            if (pInstance)
-                pInstance->SetData(DATA_ARCHAVON_EVENT, DONE);
-        }
+            void EnterCombat(Unit * /*who*/)
+            {
+                events.ScheduleEvent(EVENT_ROCK_SHARDS, 15000);
+                events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30000);
+                events.ScheduleEvent(EVENT_STOMP, 45000);
+                events.ScheduleEvent(EVENT_BERSERK, 300000);
 
-        void EnterCombat(Unit * /*who*/)
-        {
-            DoZoneInCombat();
-            events.ScheduleEvent(EVENT_ROCK_SHARDS, 15000);
-            events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30000);
-            events.ScheduleEvent(EVENT_STOMP, 45000);
-            events.ScheduleEvent(EVENT_BERSERK, 300000);
-
-            if (pInstance)
-                pInstance->SetData(DATA_ARCHAVON_EVENT, IN_PROGRESS);
-        }
+                _EnterCombat();
+            }
 
-        // Below UpdateAI may need review/debug.
-        void UpdateAI(const uint32 diff)
-        {
-            //Return since we have no target
-            if (!UpdateVictim())
-                return;
+            // Below UpdateAI may need review/debug.
+            void UpdateAI(const uint32 diff)
+            {
+                if (!UpdateVictim())
+                    return;
 
-            events.Update(diff);
+                events.Update(diff);
 
-            if (me->HasUnitState(UNIT_STAT_CASTING))
-                return;
+                if (me->HasUnitState(UNIT_STAT_CASTING))
+                    return;
 
-            while (uint32 eventId = events.ExecuteEvent())
-            {
-                switch(eventId)
+                while (uint32 eventId = events.ExecuteEvent())
                 {
-                    case EVENT_ROCK_SHARDS:
-                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                            DoCast(pTarget, SPELL_ROCK_SHARDS);
-                        events.ScheduleEvent(EVENT_ROCK_SHARDS, 15000);
-                        return;
-                    case EVENT_CHOKING_CLOUD:
-                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                            DoCast(pTarget, SPELL_CRUSHING_LEAP, true); //10y~80y, ignore range
-                        events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30000);
-                        return;
-                    case EVENT_STOMP:
-                        DoCast(me->getVictim(), SPELL_STOMP);
-                        events.ScheduleEvent(EVENT_IMPALE, 3000);
-                        events.ScheduleEvent(EVENT_STOMP, 45000);
-                        return;
-                    case EVENT_IMPALE:
-                        DoCast(me->getVictim(), SPELL_IMPALE);
-                        return;
-                    case EVENT_BERSERK:
-                        DoCast(me, SPELL_BERSERK);
-                        DoScriptText(EMOTE_BERSERK, me);
-                        return;
+                    switch (eventId)
+                    {
+                        case EVENT_ROCK_SHARDS:
+                            if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                                DoCast(target, SPELL_ROCK_SHARDS);
+                            events.ScheduleEvent(EVENT_ROCK_SHARDS, 15000);
+                            break;
+                        case EVENT_CHOKING_CLOUD:
+                            if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                                DoCast(target, SPELL_CRUSHING_LEAP, true); //10y~80y, ignore range
+                            events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30000);
+                            break;
+                        case EVENT_STOMP:
+                            DoCastVictim(SPELL_STOMP);
+                            events.ScheduleEvent(EVENT_IMPALE, 3000);
+                            events.ScheduleEvent(EVENT_STOMP, 45000);
+                            break;
+                        case EVENT_IMPALE:
+                            DoCastVictim(SPELL_IMPALE);
+                            break;
+                        case EVENT_BERSERK:
+                            DoCast(me, SPELL_BERSERK);
+                            DoScriptText(EMOTE_BERSERK, me);
+                            break;
+                        default:
+                            break;
+                    }
                 }
+
+                DoMeleeAttackIfReady();
             }
+        };
 
-            DoMeleeAttackIfReady();
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new boss_archavonAI(creature);
         }
-    };
-
 };
 
 /*######
@@ -148,70 +130,72 @@ public:
 ######*/
 class mob_archavon_warder : public CreatureScript
 {
-public:
-    mob_archavon_warder() : CreatureScript("mob_archavon_warder") { }
+    public:
+        mob_archavon_warder() : CreatureScript("mob_archavon_warder") { }
 
-    CreatureAI* GetAI(Creature* pCreature) const
-    {
-        return new mob_archavon_warderAI(pCreature);
-    }
+        struct mob_archavon_warderAI : public ScriptedAI //npc 32353
+        {
+            mob_archavon_warderAI(Creature* creature) : ScriptedAI(creature)
+            {
+            }
 
-    struct mob_archavon_warderAI : public ScriptedAI //npc 32353
-    {
-        mob_archavon_warderAI(Creature *c) : ScriptedAI(c) {}
+            EventMap events;
 
-        EventMap events;
+            void Reset()
+            {
+                events.Reset();
+                events.ScheduleEvent(EVENT_ROCK_SHOWER, 2000);
+                events.ScheduleEvent(EVENT_SHIELD_CRUSH, 20000);
+                events.ScheduleEvent(EVENT_WHIRL, 7500);
+            }
 
-        void Reset()
-        {
-            events.Reset();
-        }
+            void EnterCombat(Unit* /*who*/)
+            {
+                DoZoneInCombat();
+            }
 
-        void EnterCombat(Unit * /*who*/)
-        {
-            DoZoneInCombat();
-            events.ScheduleEvent(EVENT_ROCK_SHOWER, 2000);
-            events.ScheduleEvent(EVENT_SHIELD_CRUSH, 20000);
-            events.ScheduleEvent(EVENT_WHIRL, 7500);
-        }
+            void UpdateAI(const uint32 diff)
+            {
+                if (!UpdateVictim())
+                    return;
 
-        void UpdateAI(const uint32 diff)
-        {
-            //Return since we have no target
-            if (!UpdateVictim())
-                return;
+                events.Update(diff);
 
-            events.Update(diff);
+                if (me->HasUnitState(UNIT_STAT_CASTING))
+                    return;
 
-            while (uint32 eventId = events.ExecuteEvent())
-            {
-                switch(eventId)
+                while (uint32 eventId = events.ExecuteEvent())
                 {
-                    case EVENT_ROCK_SHOWER:
+                    switch (eventId)
                     {
-                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                            DoCast(pTarget, SPELL_ROCK_SHOWER);
-                        events.ScheduleEvent(EVENT_ROCK_SHARDS, 6000);
-                        return;
+                        case EVENT_ROCK_SHOWER:
+                            if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                                DoCast(target, SPELL_ROCK_SHOWER);
+                            events.ScheduleEvent(EVENT_ROCK_SHARDS, 6000);
+                            break;
+                        case EVENT_SHIELD_CRUSH:
+                            DoCastVictim(SPELL_SHIELD_CRUSH);
+                            events.ScheduleEvent(EVENT_SHIELD_CRUSH, 20000);
+                            break;
+                        case EVENT_WHIRL:
+                            DoCastVictim(SPELL_WHIRL);
+                            events.ScheduleEvent(EVENT_WHIRL, 8000);
+                            break;
+                        default:
+                            break;
                     }
-                    case EVENT_SHIELD_CRUSH:
-                        DoCast(me->getVictim(), SPELL_SHIELD_CRUSH);
-                        events.ScheduleEvent(EVENT_SHIELD_CRUSH, 20000);
-                        return;
-                    case EVENT_WHIRL:
-                        DoCast(me->getVictim(), SPELL_WHIRL);
-                        events.ScheduleEvent(EVENT_WHIRL, 8000);
-                        return;
                 }
+
+                DoMeleeAttackIfReady();
             }
-            DoMeleeAttackIfReady();
-        }
-    };
+        };
 
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new mob_archavon_warderAI(creature);
+        }
 };
 
-
-
 void AddSC_boss_archavon()
 {
     new boss_archavon();
diff --git a/src/server/scripts/Northrend/VaultOfArchavon/boss_emalon.cpp b/src/server/scripts/Northrend/VaultOfArchavon/boss_emalon.cpp
index e69389938e1..e07c924a8cf 100644
--- a/src/server/scripts/Northrend/VaultOfArchavon/boss_emalon.cpp
+++ b/src/server/scripts/Northrend/VaultOfArchavon/boss_emalon.cpp
@@ -19,27 +19,35 @@
 #include "vault_of_archavon.h"
 
 //Emalon spells
+enum Spells
+{
+    SPELL_OVERCHARGE            = 64218,    // Cast every 45 sec on a random Tempest Minion
+    SPELL_BERSERK               = 26662,
+
+    SPELL_SHOCK                 = 64363,
+    SPELL_OVERCHARGED           = 64217,
+    SPELL_OVERCHARGED_BLAST     = 64219,    // Cast when Overcharged reaches 10 stacks. Mob dies after that
+};
+
+// cannot let SpellDifficulty handle it, no entries for these
 #define SPELL_CHAIN_LIGHTNING           RAID_MODE(64213, 64215)
 #define SPELL_LIGHTNING_NOVA            RAID_MODE(64216, 65279)
-#define SPELL_OVERCHARGE                64218                   //Casted every 45 sec on a random Tempest Minion
-#define SPELL_BERSERK                   26662
-
-//Tempest Minion spells
-#define SPELL_SHOCK                     64363
-#define SPELL_OVERCHARGED               64217
-#define SPELL_OVERCHARGED_BLAST         64219                   //Casted when Overcharged reaches 10 stacks. Mob dies after that
-
-//Emotes
-#define EMOTE_OVERCHARGE        -1590000
-#define EMOTE_MINION_RESPAWN    -1590001
-#define EMOTE_BERSERK           -1590002
-
-//Events
-#define EVENT_CHAIN_LIGHTNING       1
-#define EVENT_LIGHTNING_NOVA        2
-#define EVENT_OVERCHARGE            3
-#define EVENT_BERSERK               4
-#define EVENT_SHOCK                 5
+
+enum BossEmotes
+{
+    EMOTE_OVERCHARGE        = -1590000,
+    EMOTE_MINION_RESPAWN    = -1590001,
+    EMOTE_BERSERK           = -1590002,
+};
+
+enum Events
+{
+    EVENT_CHAIN_LIGHTNING   = 1,
+    EVENT_LIGHTNING_NOVA    = 2,
+    EVENT_OVERCHARGE        = 3,
+    EVENT_BERSERK           = 4,
+    EVENT_SHOCK             = 5,
+};
 
 //Creatures
 #define MOB_TEMPEST_MINION          33998
@@ -59,106 +67,107 @@ struct Position TempestMinions[MAX_TEMPEST_MINIONS] =
 ######*/
 class boss_emalon : public CreatureScript
 {
-public:
-    boss_emalon() : CreatureScript("boss_emalon") { }
-
-    CreatureAI* GetAI(Creature *_Creature) const
-    {
-        return new boss_emalonAI (_Creature);
-    }
+    public:
+        boss_emalon() : CreatureScript("boss_emalon") { }
 
-    struct boss_emalonAI : public BossAI
-    {
-        boss_emalonAI(Creature *c) : BossAI(c, DATA_EMALON_EVENT)
+        struct boss_emalonAI : public BossAI
         {
-        }
+            boss_emalonAI(Creature* creature) : BossAI(creature, DATA_EMALON)
+            {
+            }
 
-        void Reset()
-        {
-            _Reset();
+            void Reset()
+            {
+                _Reset();
 
-            for (uint8 i = 0; i < MAX_TEMPEST_MINIONS; ++i)
-                me->SummonCreature(MOB_TEMPEST_MINION, TempestMinions[i], TEMPSUMMON_CORPSE_DESPAWN, 0);
-        }
+                for (uint8 i = 0; i < MAX_TEMPEST_MINIONS; ++i)
+                    me->SummonCreature(MOB_TEMPEST_MINION, TempestMinions[i], TEMPSUMMON_CORPSE_DESPAWN, 0);
+            }
 
-        void JustSummoned(Creature *summoned)
-        {
-            BossAI::JustSummoned(summoned);
+            void JustSummoned(Creature* summoned)
+            {
+                BossAI::JustSummoned(summoned);
 
-            if (me->getVictim() && summoned->AI())
-                summoned->AI()->AttackStart(me->getVictim());
-        }
+                // AttackStart has NULL-check for victim
+                if (summoned->AI())
+                    summoned->AI()->AttackStart(me->getVictim());
+            }
 
-        void EnterCombat(Unit * who)
-        {
-            if (!summons.empty())
+            void EnterCombat(Unit* who)
             {
-                for (std::list<uint64>::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
+                if (!summons.empty())
                 {
-                    Creature *minion = Unit::GetCreature(*me, *itr);
-                    if (minion && minion->isAlive() && !minion->getVictim() && minion->AI())
-                        minion->AI()->AttackStart(who);
+                    for (std::list<uint64>::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
+                    {
+                        Creature *minion = Unit::GetCreature(*me, *itr);
+                        if (minion && minion->isAlive() && !minion->getVictim() && minion->AI())
+                            minion->AI()->AttackStart(who);
+                    }
                 }
-            }
 
-            events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 5000);
-            events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40000);
-            events.ScheduleEvent(EVENT_BERSERK, 360000);
-            events.ScheduleEvent(EVENT_OVERCHARGE, 45000);
+                events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 5000);
+                events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40000);
+                events.ScheduleEvent(EVENT_BERSERK, 360000);
+                events.ScheduleEvent(EVENT_OVERCHARGE, 45000);
 
-            _EnterCombat();
-        }
+                _EnterCombat();
+            }
 
-        void UpdateAI(const uint32 diff)
-        {
-            //Return since we have no target
-            if (!UpdateVictim())
-                return;
+            void UpdateAI(const uint32 diff)
+            {
+                if (!UpdateVictim())
+                    return;
 
-            events.Update(diff);
+                events.Update(diff);
 
-            if (me->HasUnitState(UNIT_STAT_CASTING))
-                return;
+                if (me->HasUnitState(UNIT_STAT_CASTING))
+                    return;
 
-            while (uint32 eventId = events.ExecuteEvent())
-            {
-                switch(eventId)
+                while (uint32 eventId = events.ExecuteEvent())
                 {
-                case EVENT_CHAIN_LIGHTNING:
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                        DoCast(pTarget, SPELL_CHAIN_LIGHTNING);
-                    events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 25000);
-                    break;
-                case EVENT_LIGHTNING_NOVA:
-                    DoCastAOE(SPELL_LIGHTNING_NOVA, false);
-                    events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40000);
-                    break;
-                case EVENT_OVERCHARGE:
-                    if (!summons.empty())
+                    switch (eventId)
                     {
-                        std::list<uint64>::const_iterator itr = summons.begin();
-                        std::advance(itr, urand(0, summons.size()-1));
-                        Creature *minion = Unit::GetCreature(*me, *itr);
-                        if (minion && minion->isAlive())
-                        {
-                            minion->CastSpell(me, SPELL_OVERCHARGED, true);
-                            minion->SetFullHealth();
-                            DoScriptText(EMOTE_OVERCHARGE, me);
-                            events.ScheduleEvent(EVENT_OVERCHARGE, 45000);
-                        }
+                        case EVENT_CHAIN_LIGHTNING:
+                            if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                                DoCast(target, SPELL_CHAIN_LIGHTNING);
+                            events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 25000);
+                            break;
+                        case EVENT_LIGHTNING_NOVA:
+                            DoCastAOE(SPELL_LIGHTNING_NOVA);
+                            events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40000);
+                            break;
+                        case EVENT_OVERCHARGE:
+                            if (!summons.empty())
+                            {
+                                std::list<uint64>::const_iterator itr = summons.begin();
+                                std::advance(itr, urand(0, summons.size()-1));
+                                Creature* minion = Unit::GetCreature(*me, *itr);
+                                if (minion && minion->isAlive())
+                                {
+                                    minion->CastSpell(me, SPELL_OVERCHARGED, true);
+                                    minion->SetFullHealth();
+                                    DoScriptText(EMOTE_OVERCHARGE, me);
+                                    events.ScheduleEvent(EVENT_OVERCHARGE, 45000);
+                                }
+                            }
+                            break;
+                        case EVENT_BERSERK:
+                            DoCast(me, SPELL_BERSERK);
+                            DoScriptText(EMOTE_BERSERK, me);
+                            break;
+                        default:
+                            break;
                     }
-                    break;
-                case EVENT_BERSERK:
-                    DoCast(me, SPELL_BERSERK);
-                    DoScriptText(EMOTE_BERSERK, me);
-                    break;
                 }
+
+                DoMeleeAttackIfReady();
             }
+        };
 
-            DoMeleeAttackIfReady();
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new boss_emalonAI(creature);
         }
-    };
-
 };
 
 /*######
@@ -166,109 +175,101 @@ public:
 ######*/
 class mob_tempest_minion : public CreatureScript
 {
-public:
-    mob_tempest_minion() : CreatureScript("mob_tempest_minion") { }
-
-    CreatureAI* GetAI(Creature *_Creature) const
-    {
-        return new mob_tempest_minionAI (_Creature);
-    }
+    public:
+        mob_tempest_minion() : CreatureScript("mob_tempest_minion") { }
 
-    struct mob_tempest_minionAI : public ScriptedAI
-    {
-        mob_tempest_minionAI(Creature *c) : ScriptedAI(c)
+        struct mob_tempest_minionAI : public ScriptedAI
         {
-            pInstance = c->GetInstanceScript();
-        }
-
-        InstanceScript* pInstance;
-
-        EventMap events;
-
-        uint32 uiOverchargedTimer;
-
-        void Reset()
-        {
-            events.Reset();
+            mob_tempest_minionAI(Creature* creature) : ScriptedAI(creature)
+            {
+                instance = creature->GetInstanceScript();
+            }
 
-            uiOverchargedTimer = 0;
-        }
+            void Reset()
+            {
+                events.Reset();
+                OverchargedTimer = 0;
+            }
 
-        void JustDied(Unit* /*Killer*/)
-        {
-            if (Creature *pEmalon = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_EMALON) : 0))
+            void JustDied(Unit* /*Killer*/)
             {
-                if (pEmalon->isAlive())
+                if (Creature* emalon = Unit::GetCreature(*me, instance ? instance->GetData64(DATA_EMALON) : 0))
                 {
-                    pEmalon->SummonCreature(MOB_TEMPEST_MINION, 0, 0, 0, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
-                    DoScriptText(EMOTE_MINION_RESPAWN, me);
+                    if (emalon->isAlive())
+                    {
+                        emalon->SummonCreature(MOB_TEMPEST_MINION, 0, 0, 0, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
+                        DoScriptText(EMOTE_MINION_RESPAWN, me);
+                    }
                 }
             }
-        }
-
-        void EnterCombat(Unit * who)
-        {
-            DoZoneInCombat();
-            events.ScheduleEvent(EVENT_SHOCK, 20000);
 
-            if (Creature *pEmalon = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_EMALON) : 0))
+            void EnterCombat(Unit * who)
             {
-                if (!pEmalon->getVictim() && pEmalon->AI())
-                    pEmalon->AI()->AttackStart(who);
+                DoZoneInCombat();
+                events.ScheduleEvent(EVENT_SHOCK, 20000);
+
+                if (Creature *pEmalon = Unit::GetCreature(*me, instance ? instance->GetData64(DATA_EMALON) : 0))
+                {
+                    if (!pEmalon->getVictim() && pEmalon->AI())
+                        pEmalon->AI()->AttackStart(who);
+                }
             }
-        }
 
-        void UpdateAI(const uint32 diff)
-        {
-            //Return since we have no target
-            if (!UpdateVictim())
-                return;
+            void UpdateAI(const uint32 diff)
+            {
+                //Return since we have no target
+                if (!UpdateVictim())
+                    return;
 
-            events.Update(diff);
+                events.Update(diff);
 
-            if (me->HasUnitState(UNIT_STAT_CASTING))
-                return;
+                if (me->HasUnitState(UNIT_STAT_CASTING))
+                    return;
 
-            if (Aura *overchargedAura = me->GetAura(SPELL_OVERCHARGED))
-            {
-                if (overchargedAura->GetStackAmount() < 10)
+                if (Aura const* overchargedAura = me->GetAura(SPELL_OVERCHARGED))
                 {
-                    if (uiOverchargedTimer <= diff)
+                    if (overchargedAura->GetStackAmount() < 10)
                     {
-                        DoCast(me, SPELL_OVERCHARGED);
-                        uiOverchargedTimer = 2000;
-                    } else uiOverchargedTimer -=diff;
-                }
-                else
-                {
-                    if (overchargedAura->GetStackAmount() == 10)
+                        if (OverchargedTimer <= diff)
+                        {
+                            DoCast(me, SPELL_OVERCHARGED);
+                            OverchargedTimer = 2000;
+                        }
+                        else
+                            OverchargedTimer -= diff;
+                    }
+                    else
                     {
-                        DoCast(me, SPELL_OVERCHARGED_BLAST);
-                        me->ForcedDespawn();
-                        DoScriptText(EMOTE_MINION_RESPAWN, me);
+                        if (overchargedAura->GetStackAmount() == 10)
+                        {
+                            DoCast(me, SPELL_OVERCHARGED_BLAST);
+                            me->ForcedDespawn();
+                            DoScriptText(EMOTE_MINION_RESPAWN, me);
+                        }
                     }
                 }
-            }
 
-            while (uint32 eventId = events.ExecuteEvent())
-            {
-                switch(eventId)
+                if (events.ExecuteEvent() == EVENT_SHOCK)
                 {
-                case EVENT_SHOCK:
-                    DoCast(me->getVictim(), SPELL_SHOCK);
+                    DoCastVictim(SPELL_SHOCK);
                     events.ScheduleEvent(EVENT_SHOCK, 20000);
-                    return;
                 }
+
+                DoMeleeAttackIfReady();
             }
 
-            DoMeleeAttackIfReady();
-        }
-    };
+        private:
+            InstanceScript* instance;
+            EventMap events;
+            uint32 OverchargedTimer;
+        };
 
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new mob_tempest_minionAI(creature);
+        }
 };
 
-
-
 void AddSC_boss_emalon()
 {
     new boss_emalon();
diff --git a/src/server/scripts/Northrend/VaultOfArchavon/boss_koralon.cpp b/src/server/scripts/Northrend/VaultOfArchavon/boss_koralon.cpp
index 9672d2a5718..3ad2ba3ff0e 100644
--- a/src/server/scripts/Northrend/VaultOfArchavon/boss_koralon.cpp
+++ b/src/server/scripts/Northrend/VaultOfArchavon/boss_koralon.cpp
@@ -20,135 +20,105 @@
 
 enum Events
 {
-    EVENT_NONE,
-
     // Koralon
-    EVENT_BURNING_BREATH,
-    EVENT_BURNING_FURY,
-    EVENT_FLAME_CINDER_A,
-    EVENT_METEOR_FISTS_A,
-    EVENT_METEOR_FISTS_B,
+    EVENT_BURNING_BREATH    = 1,
+    EVENT_BURNING_FURY      = 2,
+    EVENT_FLAME_CINDER_A    = 3,
+    EVENT_METEOR_FISTS_A    = 4,
+    EVENT_METEOR_FISTS_B    = 5,
 
     // Flame Warder
-    EVENT_FW_LAVA_BIRST,
-    EVENT_FW_METEOR_FISTS_A,
-    EVENT_FW_METEOR_FISTS_B,
+    EVENT_FW_LAVA_BIRST     = 6,
+    EVENT_FW_METEOR_FISTS_A = 7,
+    EVENT_FW_METEOR_FISTS_B = 8,
 };
 
 enum Spells
 {
     // Spells Koralon
     SPELL_BURNING_BREATH                        = 66665,
-    SPELL_BURNING_BREATH_H                      = 67328,
     SPELL_BURNING_FURY                          = 66721,
     SPELL_FLAME_CINDER_A                        = 66684,
-    SPELL_FLAME_CINDER_A_H                      = 67332,
     SPELL_FLAME_CINDER_B                        = 66681, // don't know the real relation to SPELL_FLAME_CINDER_A atm.
     SPELL_METEOR_FISTS_A                        = 66725,
-    SPELL_METEOR_FISTS_A_H                      = 66765,
     SPELL_METEOR_FISTS_B                        = 67333,
-    SPELL_METEOR_FISTS_B_H                      = 68161,
 
     // Spells Flame Warder
     SPELL_FW_LAVA_BIRST                         = 66813,
-    SPELL_FW_LAVA_BIRST_H                       = 67330,
     SPELL_FW_METEOR_FISTS_A                     = 66808,
-    SPELL_FW_METEOR_FISTS_A_H                   = 66809,
     SPELL_FW_METEOR_FISTS_B                     = 67331,
-    SPELL_FW_METEOR_FISTS_B_H                   = 68160,
 };
 
 class boss_koralon : public CreatureScript
 {
-public:
-    boss_koralon() : CreatureScript("boss_koralon") { }
-
-    CreatureAI* GetAI(Creature* pCreature) const
-    {
-        return new boss_koralonAI (pCreature);
-    }
+    public:
+        boss_koralon() : CreatureScript("boss_koralon") { }
 
-    struct boss_koralonAI : public ScriptedAI
-    {
-        boss_koralonAI(Creature *c) : ScriptedAI(c)
+        struct boss_koralonAI : public BossAI
         {
-            pInstance = c->GetInstanceScript();
-        }
-
-        InstanceScript *pInstance;
-        EventMap events;
-
-        void Reset()
-        {
-            events.Reset();
-
-            if (pInstance)
-                pInstance->SetData(DATA_KORALON_EVENT, NOT_STARTED);
-        }
-
-        void KilledUnit(Unit* /*Victim*/) {}
-
-        void JustDied(Unit* /*Killer*/)
-        {
-            if (pInstance)
-                pInstance->SetData(DATA_KORALON_EVENT, DONE);
-        }
-
-        void EnterCombat(Unit * /*who*/)
-        {
-            DoZoneInCombat();
+            boss_koralonAI(Creature* creature) : BossAI(creature, DATA_KORALON)
+            {
+            }
 
-            DoCast(me, SPELL_BURNING_FURY);
+            void EnterCombat(Unit* /*who*/)
+            {
+                DoCast(me, SPELL_BURNING_FURY);
 
-            events.ScheduleEvent(EVENT_BURNING_FURY, 20000);    // TODO check timer
-            events.ScheduleEvent(EVENT_BURNING_BREATH, 15000);  // 1st after 15sec, then every 45sec
-            events.ScheduleEvent(EVENT_METEOR_FISTS_A, 75000);  // 1st after 75sec, then every 45sec
-            events.ScheduleEvent(EVENT_FLAME_CINDER_A, 30000);  // TODO check timer
+                events.ScheduleEvent(EVENT_BURNING_FURY, 20000);    // TODO check timer
+                events.ScheduleEvent(EVENT_BURNING_BREATH, 15000);  // 1st after 15sec, then every 45sec
+                events.ScheduleEvent(EVENT_METEOR_FISTS_A, 75000);  // 1st after 75sec, then every 45sec
+                events.ScheduleEvent(EVENT_FLAME_CINDER_A, 30000);  // TODO check timer
 
-            if (pInstance)
-                pInstance->SetData(DATA_KORALON_EVENT, IN_PROGRESS);
-        }
+                _EnterCombat();
+            }
 
-        void UpdateAI(const uint32 diff)
-        {
-            if (!UpdateVictim())
-                return;
+            void UpdateAI(const uint32 diff)
+            {
+                if (!UpdateVictim())
+                    return;
 
-            events.Update(diff);
+                events.Update(diff);
 
-            if (me->HasUnitState(UNIT_STAT_CASTING))
-                return;
+                if (me->HasUnitState(UNIT_STAT_CASTING))
+                    return;
 
-            while (uint32 eventId = events.ExecuteEvent())
-            {
-                switch(eventId)
+                while (uint32 eventId = events.ExecuteEvent())
                 {
-                    case EVENT_BURNING_FURY:
-                        DoCast(me, SPELL_BURNING_FURY);
-                        events.ScheduleEvent(EVENT_BURNING_FURY, 20000);
-                        return;
-                    case EVENT_BURNING_BREATH:
-                        DoCast(me, RAID_MODE(SPELL_BURNING_BREATH,SPELL_BURNING_BREATH_H));
-                        events.ScheduleEvent(EVENT_BURNING_BREATH, 45000);
-                        return;
-                    case EVENT_METEOR_FISTS_A:
-                        DoCast(me, RAID_MODE(SPELL_METEOR_FISTS_A,SPELL_METEOR_FISTS_A_H));
-                        events.ScheduleEvent(EVENT_METEOR_FISTS_B, 1500);
-                        return;
-                    case EVENT_METEOR_FISTS_B:
-                        DoCast(me, RAID_MODE(SPELL_METEOR_FISTS_B,SPELL_METEOR_FISTS_B_H));
-                        events.ScheduleEvent(EVENT_METEOR_FISTS_A, 45000);
-                        return;
-                    case EVENT_FLAME_CINDER_A:
-                        DoCast(me, RAID_MODE(SPELL_FLAME_CINDER_A,SPELL_FLAME_CINDER_A_H));
-                        events.ScheduleEvent(EVENT_FLAME_CINDER_A, 30000);
-                        return;
+                    switch (eventId)
+                    {
+                        case EVENT_BURNING_FURY:
+                            DoCast(me, SPELL_BURNING_FURY);
+                            events.ScheduleEvent(EVENT_BURNING_FURY, 20000);
+                            break;
+                        case EVENT_BURNING_BREATH:
+                            DoCast(me, SPELL_BURNING_BREATH);
+                            events.ScheduleEvent(EVENT_BURNING_BREATH, 45000);
+                            break;
+                        case EVENT_METEOR_FISTS_A:
+                            DoCast(me, SPELL_METEOR_FISTS_A);
+                            events.ScheduleEvent(EVENT_METEOR_FISTS_B, 1500);
+                            break;
+                        case EVENT_METEOR_FISTS_B:
+                            DoCast(me, SPELL_METEOR_FISTS_B);
+                            events.ScheduleEvent(EVENT_METEOR_FISTS_A, 45000);
+                            break;
+                        case EVENT_FLAME_CINDER_A:
+                            DoCast(me, SPELL_FLAME_CINDER_A);
+                            events.ScheduleEvent(EVENT_FLAME_CINDER_A, 30000);
+                            break;
+                        default:
+                            break;
+                    }
                 }
+
+                DoMeleeAttackIfReady();
             }
-            DoMeleeAttackIfReady();
-        }
-    };
+        };
 
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new boss_koralonAI(creature);
+        }
 };
 
 /*######
@@ -156,65 +126,68 @@ public:
 ######*/
 class mob_flame_warder : public CreatureScript
 {
-public:
-    mob_flame_warder() : CreatureScript("mob_flame_warder") { }
-
-    CreatureAI* GetAI(Creature* pCreature) const
-    {
-        return new mob_flame_warderAI (pCreature);
-    }
-
-    struct mob_flame_warderAI : public ScriptedAI
-    {
-        mob_flame_warderAI(Creature *c) : ScriptedAI(c) {}
-
-        EventMap events;
-
-        void Reset()
-        {
-            events.Reset();
-        }
+    public:
+        mob_flame_warder() : CreatureScript("mob_flame_warder") { }
 
-        void EnterCombat(Unit * /*who*/)
+        struct mob_flame_warderAI : public ScriptedAI
         {
-            DoZoneInCombat();
+            mob_flame_warderAI(Creature* creature) : ScriptedAI(creature)
+            {
+            }
 
-            events.ScheduleEvent(EVENT_FW_LAVA_BIRST, 5000);
-            events.ScheduleEvent(EVENT_FW_METEOR_FISTS_A, 10000);
-        }
+            void Reset()
+            {
+                events.Reset();
+            }
 
-        void UpdateAI(const uint32 diff)
-        {
-            if (!UpdateVictim())
-                return;
+            void EnterCombat(Unit * /*who*/)
+            {
+                DoZoneInCombat();
 
-            events.Update(diff);
+                events.ScheduleEvent(EVENT_FW_LAVA_BIRST, 5000);
+                events.ScheduleEvent(EVENT_FW_METEOR_FISTS_A, 10000);
+            }
 
-            while (uint32 eventId = events.ExecuteEvent())
+            void UpdateAI(const uint32 diff)
             {
-                switch(eventId)
+                if (!UpdateVictim())
+                    return;
+
+                events.Update(diff);
+
+                while (uint32 eventId = events.ExecuteEvent())
                 {
-                    case EVENT_FW_LAVA_BIRST:
-                        DoCast(me->getVictim(), RAID_MODE(SPELL_FW_LAVA_BIRST,SPELL_FW_LAVA_BIRST_H));
-                        events.ScheduleEvent(EVENT_FW_LAVA_BIRST, 15000);
-                        return;
-                    case EVENT_FW_METEOR_FISTS_A:
-                        DoCast(me, RAID_MODE(SPELL_FW_METEOR_FISTS_A,SPELL_FW_METEOR_FISTS_A_H));
-                        events.ScheduleEvent(EVENT_FW_METEOR_FISTS_B, 1500);
-                        return;
-                    case EVENT_FW_METEOR_FISTS_B:
-                        DoCast(me, RAID_MODE(SPELL_FW_METEOR_FISTS_B,SPELL_FW_METEOR_FISTS_B_H));
-                        events.ScheduleEvent(EVENT_FW_METEOR_FISTS_A, 20000);
-                        return;
+                    switch (eventId)
+                    {
+                        case EVENT_FW_LAVA_BIRST:
+                            DoCastVictim(SPELL_FW_LAVA_BIRST);
+                            events.ScheduleEvent(EVENT_FW_LAVA_BIRST, 15000);
+                            break;
+                        case EVENT_FW_METEOR_FISTS_A:
+                            DoCast(me, SPELL_FW_METEOR_FISTS_A);
+                            events.ScheduleEvent(EVENT_FW_METEOR_FISTS_B, 1500);
+                            break;
+                        case EVENT_FW_METEOR_FISTS_B:
+                            DoCast(me, SPELL_FW_METEOR_FISTS_B);
+                            events.ScheduleEvent(EVENT_FW_METEOR_FISTS_A, 20000);
+                            break;
+                        default:
+                            break;
+                    }
                 }
-            }
-            DoMeleeAttackIfReady();
-        }
-    };
 
-};
+                DoMeleeAttackIfReady();
+            }
 
+        private:
+            EventMap events;
+        };
 
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new mob_flame_warderAI(creature);
+        }
+};
 
 void AddSC_boss_koralon()
 {
diff --git a/src/server/scripts/Northrend/VaultOfArchavon/boss_toravon.cpp b/src/server/scripts/Northrend/VaultOfArchavon/boss_toravon.cpp
index 83ffa1f6a21..a99f46d4be3 100644
--- a/src/server/scripts/Northrend/VaultOfArchavon/boss_toravon.cpp
+++ b/src/server/scripts/Northrend/VaultOfArchavon/boss_toravon.cpp
@@ -18,117 +18,101 @@
 #include "ScriptPCH.h"
 #include "vault_of_archavon.h"
 
-// Spells Toravon
-#define SPELL_FREEZING_GROUND   RAID_MODE(72090,72104)  // don't know cd... using 20 secs.
-#define SPELL_FROZEN_ORB        RAID_MODE(72091,72095)
-#define SPELL_WHITEOUT          RAID_MODE(72034,72096)  // Every 38 sec. cast. (after SPELL_FROZEN_ORB)
-#define SPELL_FROZEN_MALLET     71993
-
-// Spells Frost Warder
-#define SPELL_FROST_BLAST   RAID_MODE(72123,72124)      // don't know cd... using 20 secs.
-#define SPELL_FROZEN_MALLET_2 72122
-
-// Spell Frozen Orb
-#define SPELL_FROZEN_ORB_DMG    72081   // priodic dmg aura
-#define SPELL_FROZEN_ORB_AURA   72067   // make visible
-
-// Spell Frozen Orb Stalker
-#define SPELL_FROZEN_ORB_SUMMON 72093   // summon orb
+enum Spells
+{
+    // Toravon
+    SPELL_FREEZING_GROUND   = 72090,    // don't know cd... using 20 secs.
+    SPELL_FROZEN_ORB        = 72091,
+    SPELL_WHITEOUT          = 72034,    // Every 38 sec. cast. (after SPELL_FROZEN_ORB)
+    SPELL_FROZEN_MALLET     = 71993,
+
+    // Frost Warder
+    SPELL_FROST_BLAST       = 72123,    // don't know cd... using 20 secs.
+    SPELL_FROZEN_MALLET_2   = 72122,
+
+    // Frozen Orb
+    SPELL_FROZEN_ORB_DMG    = 72081,    // priodic dmg aura
+    SPELL_FROZEN_ORB_AURA   = 72067,    // make visible
+
+    // Frozen Orb Stalker
+    SPELL_FROZEN_ORB_SUMMON = 72093,    // summon orb
+};
 
 // Events boss
-#define EVENT_FREEZING_GROUND   1
-#define EVENT_FROZEN_ORB        2
-#define EVENT_WHITEOUT          3
+enum Events
+{
+    EVENT_FREEZING_GROUND   = 1,
+    EVENT_FROZEN_ORB        = 2,
+    EVENT_WHITEOUT          = 3,
 
-// Events mob
-#define EVENT_FROST_BLAST   4
+    EVENT_FROST_BLAST       = 4,
+};
 
 // Mob Frozen Orb
 #define MOB_FROZEN_ORB 38456    // 1 in 10 mode and 3 in 25 mode
 
 class boss_toravon : public CreatureScript
 {
-public:
-    boss_toravon() : CreatureScript("boss_toravon") { }
-
-    CreatureAI* GetAI(Creature* pCreature) const
-    {
-        return new boss_toravonAI (pCreature);
-    }
-
-    struct boss_toravonAI : public ScriptedAI
-    {
-        boss_toravonAI(Creature *c) : ScriptedAI(c)
-        {
-            pInstance = c->GetInstanceScript();
-        }
+    public:
+        boss_toravon() : CreatureScript("boss_toravon") { }
 
-        InstanceScript *pInstance;
-        EventMap events;
-
-        void Reset()
-        {
-            events.Reset();
-
-            if (pInstance)
-                pInstance->SetData(DATA_TORAVON_EVENT, NOT_STARTED);
-        }
-
-        void KilledUnit(Unit* /*Victim*/) {}
-
-        void JustDied(Unit* /*Killer*/)
-        {
-            if (pInstance)
-                pInstance->SetData(DATA_TORAVON_EVENT, DONE);
-        }
-
-        void EnterCombat(Unit * /*who*/)
+        struct boss_toravonAI : public BossAI
         {
-            DoZoneInCombat();
+            boss_toravonAI(Creature* creature) : BossAI(creature, DATA_TORAVON)
+            {
+            }
 
-            DoCast(me, SPELL_FROZEN_MALLET);
+            void EnterCombat(Unit* /*who*/)
+            {
+                DoCast(me, SPELL_FROZEN_MALLET);
 
-            events.ScheduleEvent(EVENT_FROZEN_ORB, 11000);
-            events.ScheduleEvent(EVENT_WHITEOUT, 13000);
-            events.ScheduleEvent(EVENT_FREEZING_GROUND, 15000);
+                events.ScheduleEvent(EVENT_FROZEN_ORB, 11000);
+                events.ScheduleEvent(EVENT_WHITEOUT, 13000);
+                events.ScheduleEvent(EVENT_FREEZING_GROUND, 15000);
 
-            if (pInstance)
-                pInstance->SetData(DATA_TORAVON_EVENT, IN_PROGRESS);
-        }
+                _EnterCombat();
+            }
 
-        void UpdateAI(const uint32 diff)
-        {
-            if (!UpdateVictim())
-                return;
+            void UpdateAI(const uint32 diff)
+            {
+                if (!UpdateVictim())
+                    return;
 
-            events.Update(diff);
+                events.Update(diff);
 
-            if (me->HasUnitState(UNIT_STAT_CASTING))
-                return;
+                if (me->HasUnitState(UNIT_STAT_CASTING))
+                    return;
 
-            while (uint32 eventId = events.ExecuteEvent())
-            {
-                switch(eventId)
+                while (uint32 eventId = events.ExecuteEvent())
                 {
-                    case EVENT_FROZEN_ORB:
-                        DoCast(me, SPELL_FROZEN_ORB);
-                        events.ScheduleEvent(EVENT_FROZEN_ORB, 38000);
-                        return;
-                    case EVENT_WHITEOUT:
-                        DoCast(me, SPELL_WHITEOUT);
-                        events.ScheduleEvent(EVENT_WHITEOUT, 38000);
-                        return;
-                    case EVENT_FREEZING_GROUND:
-                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                            DoCast(pTarget, SPELL_FREEZING_GROUND);
-                        events.ScheduleEvent(EVENT_FREEZING_GROUND, 20000);
-                        return;
+                    switch (eventId)
+                    {
+                        case EVENT_FROZEN_ORB:
+                            me->CastCustomSpell(SPELL_FROZEN_ORB, SPELLVALUE_MAX_TARGETS, 1, me);
+                            events.ScheduleEvent(EVENT_FROZEN_ORB, 38000);
+                            break;
+                        case EVENT_WHITEOUT:
+                            DoCast(me, SPELL_WHITEOUT);
+                            events.ScheduleEvent(EVENT_WHITEOUT, 38000);
+                            break;
+                        case EVENT_FREEZING_GROUND:
+                            if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 1))
+                                DoCast(target, SPELL_FREEZING_GROUND);
+                            events.ScheduleEvent(EVENT_FREEZING_GROUND, 20000);
+                            break;
+                        default:
+                            break;
+                    }
                 }
+
+                DoMeleeAttackIfReady();
             }
-            DoMeleeAttackIfReady();
-        }
-    };
+        };
 
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new boss_toravonAI(creature);
+        }
 };
 
 /*######
@@ -136,57 +120,55 @@ public:
 ######*/
 class mob_frost_warder : public CreatureScript
 {
-public:
-    mob_frost_warder() : CreatureScript("mob_frost_warder") { }
-
-    CreatureAI* GetAI(Creature* pCreature) const
-    {
-        return new mob_frost_warderAI (pCreature);
-    }
+    public:
+        mob_frost_warder() : CreatureScript("mob_frost_warder") { }
 
-    struct mob_frost_warderAI : public ScriptedAI
-    {
-        mob_frost_warderAI(Creature *c) : ScriptedAI(c) {}
+        struct mob_frost_warderAI : public ScriptedAI
+        {
+            mob_frost_warderAI(Creature* c) : ScriptedAI(c) {}
 
-        EventMap events;
+            void Reset()
+            {
+                events.Reset();
+            }
 
-        void Reset()
-        {
-            events.Reset();
-        }
+            void EnterCombat(Unit* /*who*/)
+            {
+                DoZoneInCombat();
 
-        void EnterCombat(Unit * /*who*/)
-        {
-            DoZoneInCombat();
+                DoCast(me, SPELL_FROZEN_MALLET_2);
 
-            DoCast(me, SPELL_FROZEN_MALLET_2);
+                events.ScheduleEvent(EVENT_FROST_BLAST, 5000);
+            }
 
-            events.ScheduleEvent(EVENT_FROST_BLAST, 5000);
-        }
+            void UpdateAI(const uint32 diff)
+            {
+                if (!UpdateVictim())
+                    return;
 
-        void UpdateAI(const uint32 diff)
-        {
-            if (!UpdateVictim())
-                return;
+                events.Update(diff);
 
-            events.Update(diff);
+                if (me->HasUnitState(UNIT_STAT_CASTING))
+                    return;
 
-            while (uint32 eventId = events.ExecuteEvent())
-            {
-                switch(eventId)
+                if (events.ExecuteEvent() == EVENT_FROST_BLAST)
                 {
-                    case EVENT_FROST_BLAST:
-                        DoCast(me->getVictim(), SPELL_FROST_BLAST);
-                        events.ScheduleEvent(EVENT_FROST_BLAST, 20000);
-                        return;
+                    DoCastVictim(SPELL_FROST_BLAST);
+                    events.ScheduleEvent(EVENT_FROST_BLAST, 20000);
                 }
+
+                DoMeleeAttackIfReady();
             }
-            DoMeleeAttackIfReady();
-        }
-    };
 
-};
+        private:
+            EventMap events;
+        };
 
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new mob_frost_warderAI(creature);
+        }
+};
 
 /*######
 ##  Mob Frozen Orb
@@ -196,22 +178,16 @@ class mob_frozen_orb : public CreatureScript
 public:
     mob_frozen_orb() : CreatureScript("mob_frozen_orb") { }
 
-    CreatureAI* GetAI(Creature* pCreature) const
-    {
-        return new mob_frozen_orbAI (pCreature);
-    }
-
     struct mob_frozen_orbAI : public ScriptedAI
     {
-        mob_frozen_orbAI(Creature *c) : ScriptedAI(c) {}
-
-        bool done;
-        uint32 killtimer;
+        mob_frozen_orbAI(Creature* creature) : ScriptedAI(creature)
+        {
+        }
 
         void Reset()
         {
             done = false;
-            killtimer = 60000; // if after this time there is no victim -> destroy!
+            killTimer = 60000; // if after this time there is no victim -> destroy!
         }
 
         void EnterCombat(Unit * /*who*/)
@@ -228,17 +204,25 @@ public:
                 done = true;
             }
 
-            if (killtimer <= diff)
+            if (killTimer <= diff)
             {
                 if (!UpdateVictim())
                     me->ForcedDespawn();
-                killtimer = 10000;
+                killTimer = 10000;
             }
             else
-                killtimer -= diff;
+                killTimer -= diff;
         }
+
+    private:
+        uint32 killTimer;
+        bool done;
     };
 
+    CreatureAI* GetAI(Creature* creature) const
+    {
+        return new mob_frozen_orbAI(creature);
+    }
 };
 
 /*######
@@ -246,59 +230,52 @@ public:
 ######*/
 class mob_frozen_orb_stalker : public CreatureScript
 {
-public:
-    mob_frozen_orb_stalker() : CreatureScript("mob_frozen_orb_stalker") { }
+    public:
+        mob_frozen_orb_stalker() : CreatureScript("mob_frozen_orb_stalker") { }
 
-    CreatureAI* GetAI(Creature* pCreature) const
-    {
-        return new mob_frozen_orb_stalkerAI (pCreature);
-    }
-
-    struct mob_frozen_orb_stalkerAI : public Scripted_NoMovementAI
-    {
-        mob_frozen_orb_stalkerAI(Creature* c) : Scripted_NoMovementAI(c)
+        struct mob_frozen_orb_stalkerAI : public Scripted_NoMovementAI
         {
-            c->SetVisible(false);
-            c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_DISABLE_MOVE);
-            c->SetReactState(REACT_PASSIVE);
+            mob_frozen_orb_stalkerAI(Creature* creature) : Scripted_NoMovementAI(creature)
+            {
+                c->SetVisible(false);
+                c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_DISABLE_MOVE);
+                c->SetReactState(REACT_PASSIVE);
 
-            pInstance = c->GetInstanceScript();
-            spawned = false;
-        }
+                instance = c->GetInstanceScript();
+                spawned = false;
+            }
 
-        InstanceScript *pInstance;
-        bool spawned;
+            void UpdateAI(const uint32 /*diff*/)
+            {
+                if (spawned)
+                    return;
 
-        void UpdateAI(const uint32 /*diff*/)
-        {
-            if (spawned)
-                return;
+                spawned = true;
+                Unit* toravon = me->GetCreature(*me, instance ? instance->GetData64(DATA_TORAVON) : 0);
+                if (!toravon)
+                    return;
 
-            spawned = true;
-            if (!pInstance)
-                return;
+                uint8 num_orbs = RAID_MODE(1, 3);
+                for (uint8 i = 0; i < num_orbs; ++i)
+                {
+                    Position pos;
+                    me->GetNearPoint(toravon, pos.m_positionX, pos.m_positionY, pos.m_positionZ, 0.0f, 10.0f, 0.0f);
+                    me->SetPosition(pos, true);
+                    DoCast(me, SPELL_FROZEN_ORB_SUMMON);
+                }
+            }
 
-            Unit* pToravon = me->GetCreature(*me, pInstance->GetData64(DATA_TORAVON));
-            if (!pToravon)
-                return;
+        private:
+            InstanceScript* instance;
+            bool spawned;
+        };
 
-            uint8 num_orbs = RAID_MODE(1, 3);
-            for (uint8 i=0; i<num_orbs; ++i)
-            {
-                Position pos;
-                me->GetNearPoint(pToravon, pos.m_positionX, pos.m_positionY, pos.m_positionZ, 0.0f, 10.0f, 0.0f);
-                me->SetPosition(pos, true);
-                DoCast(me, SPELL_FROZEN_ORB_SUMMON);
-            }
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new mob_frozen_orb_stalkerAI(creature);
         }
-    };
-
 };
 
-
-
-
-
 void AddSC_boss_toravon()
 {
     new boss_toravon();
diff --git a/src/server/scripts/Northrend/VaultOfArchavon/instance_vault_of_archavon.cpp b/src/server/scripts/Northrend/VaultOfArchavon/instance_vault_of_archavon.cpp
index 8f672f586a8..3de820d496d 100644
--- a/src/server/scripts/Northrend/VaultOfArchavon/instance_vault_of_archavon.cpp
+++ b/src/server/scripts/Northrend/VaultOfArchavon/instance_vault_of_archavon.cpp
@@ -18,8 +18,6 @@
 #include "ScriptPCH.h"
 #include "vault_of_archavon.h"
 
-#define ENCOUNTERS  4
-
 /* Vault of Archavon encounters:
 1 - Archavon the Stone Watcher event
 2 - Emalon the Storm Watcher event
@@ -29,135 +27,63 @@
 
 class instance_archavon : public InstanceMapScript
 {
-public:
-    instance_archavon() : InstanceMapScript("instance_archavon", 624) { }
-
-    InstanceScript* GetInstanceScript(InstanceMap* pMap) const
-    {
-        return new instance_archavon_InstanceMapScript(pMap);
-    }
-
-    struct instance_archavon_InstanceMapScript : public InstanceScript
-    {
-        instance_archavon_InstanceMapScript(Map *Map) : InstanceScript(Map) {};
-
-        uint32 uiEncounters[ENCOUNTERS];
-
-        uint64 uiArchavon;
-        uint64 uiEmalon;
-        uint64 uiKoralon;
-        uint64 uiToravon;
-
-        void Initialize()
-        {
-            uiArchavon = 0;
-            uiEmalon = 0;
-            uiKoralon = 0;
-            uiToravon = 0;
-
-            for (uint8 i = 0; i < ENCOUNTERS; i++)
-                uiEncounters[i] = NOT_STARTED;
-        }
+    public:
+        instance_archavon() : InstanceMapScript("instance_archavon", 624) { }
 
-        bool IsEncounterInProgress() const
+        struct instance_archavon_InstanceMapScript : public InstanceScript
         {
-            for (uint8 i = 0; i < ENCOUNTERS; i++)
-                if (uiEncounters[i] == IN_PROGRESS)
-                    return true;
-
-            return false;
-        }
-
-        void OnCreatureCreate(Creature* creature)
-        {
-            switch(creature->GetEntry())
+            instance_archavon_InstanceMapScript(Map* map) : InstanceScript(map)
             {
-                case CREATURE_ARCHAVON: uiArchavon  = creature->GetGUID(); break;
-                case CREATURE_EMALON:   uiEmalon    = creature->GetGUID(); break;
-                case CREATURE_KORALON:  uiKoralon   = creature->GetGUID(); break;
-                case CREATURE_TORAVON:  uiToravon   = creature->GetGUID(); break;
+                SetBossNumber(MAX_ENCOUNTER);
             }
-        }
 
-        uint32 GetData(uint32 type)
-        {
-            switch(type)
+            void Initialize()
             {
-                case DATA_ARCHAVON_EVENT:   return uiEncounters[0];
-                case DATA_EMALON_EVENT:     return uiEncounters[1];
-                case DATA_KORALON_EVENT:    return uiEncounters[2];
-                case DATA_TORAVON_EVENT:    return uiEncounters[3];
+                EmalonGUID = 0;
+                ToravonGUID = 0;
             }
-            return 0;
-        }
 
-        uint64 GetData64(uint32 identifier)
-        {
-            switch(identifier)
+            void OnCreatureCreate(Creature* creature)
             {
-                case DATA_ARCHAVON: return uiArchavon;
-                case DATA_EMALON:   return uiEmalon;
-                case DATA_KORALON:  return uiKoralon;
-                case DATA_TORAVON:  return uiToravon;
+                switch (creature->GetEntry())
+                {
+                    case CREATURE_EMALON:
+                        EmalonGUID = creature->GetGUID();
+                        break;
+                    case CREATURE_TORAVON:
+                        ToravonGUID = creature->GetGUID();
+                        break;
+                    default:
+                        break;
+                }
             }
-            return 0;
-        }
 
-        void SetData(uint32 type, uint32 data)
-        {
-            switch(type)
+            uint64 GetData64(uint32 identifier)
             {
-                case DATA_ARCHAVON_EVENT:   uiEncounters[0] = data; break;
-                case DATA_EMALON_EVENT:     uiEncounters[1] = data; break;
-                case DATA_KORALON_EVENT:    uiEncounters[2] = data; break;
-                case DATA_TORAVON_EVENT:    uiEncounters[3] = data; break;
+                switch (identifier)
+                {
+                    case DATA_EMALON:
+                        return EmalonGUID;
+                    case DATA_TORAVON:
+                        return ToravonGUID;
+                    default:
+                        break;
+                }
+
+                return 0;
             }
 
-            if (data == DONE)
-                SaveToDB();
-        }
+        private:
+            uint64 EmalonGUID;
+            uint64 ToravonGUID;
+        };
 
-        std::string GetSaveData()
+        InstanceScript* GetInstanceScript(InstanceMap* map) const
         {
-            OUT_SAVE_INST_DATA;
-            std::ostringstream stream;
-            stream << uiEncounters[0] << " " << uiEncounters[1] << " " << uiEncounters[2] << " " << uiEncounters[3];
-
-            char* out = new char[stream.str().length() + 1];
-            strcpy(out, stream.str().c_str());
-            if (out)
-            {
-                OUT_SAVE_INST_DATA_COMPLETE;
-                return out;
-            }
-
-            return NULL;
+            return new instance_archavon_InstanceMapScript(map);
         }
-
-        void Load(const char* in)
-        {
-            if (!in)
-            {
-                OUT_LOAD_INST_DATA_FAIL;
-                return;
-            }
-
-            OUT_LOAD_INST_DATA(in);
-
-            std::istringstream stream(in);
-            stream >> uiEncounters[0] >> uiEncounters[1] >> uiEncounters[2] >> uiEncounters[3];
-
-            for (uint8 i = 0; i < ENCOUNTERS; ++i)
-                if (uiEncounters[i] == IN_PROGRESS)
-                    uiEncounters[i] = NOT_STARTED;
-
-            OUT_LOAD_INST_DATA_COMPLETE;
-        }
-    };
-
 };
 
-
 void AddSC_instance_archavon()
 {
     new instance_archavon();
diff --git a/src/server/scripts/Northrend/VaultOfArchavon/vault_of_archavon.h b/src/server/scripts/Northrend/VaultOfArchavon/vault_of_archavon.h
index 1885235359e..d0c29054fc3 100644
--- a/src/server/scripts/Northrend/VaultOfArchavon/vault_of_archavon.h
+++ b/src/server/scripts/Northrend/VaultOfArchavon/vault_of_archavon.h
@@ -28,18 +28,12 @@ enum Creatures
 
 enum Data
 {
-    DATA_ARCHAVON_EVENT,
-    DATA_EMALON_EVENT,
-    DATA_KORALON_EVENT,
-    DATA_TORAVON_EVENT,
+    DATA_ARCHAVON   = 0,
+    DATA_EMALON     = 1,
+    DATA_KORALON    = 2,
+    DATA_TORAVON    = 3,
 };
 
-enum Data64
-{
-    DATA_ARCHAVON,
-    DATA_EMALON,
-    DATA_KORALON,
-    DATA_TORAVON,
-};
+#define MAX_ENCOUNTER 4
 
 #endif