Convert Ahnkahet, Azjol-Nerub, Drak'tharon Keep, and Forge of Souls to the new format.

--HG--
branch : trunk

19 files changed, 4032 insertions, 3976 deletions

diff --git a/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_anubarak.cpp b/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_anubarak.cpp
index 65c649c4225..76ffba26391 100644
--- a/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_anubarak.cpp
+++ b/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_anubarak.cpp
@@ -86,274 +86,275 @@ const Position SpawnPointGuardian[2] =
     { 550.188660, 324.264557, 237.7412 },
 };
 
-struct boss_anub_arakAI : public ScriptedAI
+class boss_anub_arak : public CreatureScript
 {
-    boss_anub_arakAI(Creature *c) : ScriptedAI(c), lSummons(me)
-    {
-        pInstance = c->GetInstanceData();
-    }
+public:
+    boss_anub_arak() : CreatureScript("boss_anub_arak") { }
 
-    ScriptedInstance *pInstance;
-
-    bool bChanneling;
-    bool bGuardianSummoned;
-    bool bVenomancerSummoned;
-    bool bDatterSummoned;
-    uint8 uiPhase;
-    uint32 uiUndergroundPhase;
-    uint32 uiCarrionBeetlesTimer;
-    uint32 uiLeechingSwarmTimer;
-    uint32 uiPoundTimer;
-    uint32 uiSubmergeTimer;
-    uint32 uiUndergroundTimer;
-    uint32 uiVenomancerTimer;
-    uint32 uiDatterTimer;
-    
-    uint32 uiImpaleTimer;
-    uint32 uiImpalePhase;
-    uint64 uiImpaleTarget;
-    
-    SummonList lSummons;
-
-    void Reset()
+    struct boss_anub_arakAI : public ScriptedAI
     {
-        uiCarrionBeetlesTimer = 8*IN_MILLISECONDS;
-        uiLeechingSwarmTimer = 20*IN_MILLISECONDS;
-        uiImpaleTimer = 9*IN_MILLISECONDS;
-        uiPoundTimer = 15*IN_MILLISECONDS;
-
-        uiPhase = PHASE_MELEE;
-        uiUndergroundPhase = 0;
-        bChanneling = false;
-        uiImpalePhase = IMPALE_PHASE_TARGET;
-
-        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
-        me->RemoveAura(SPELL_SUBMERGE);
-
-        lSummons.DespawnAll();
-       
-        if (pInstance)
+        boss_anub_arakAI(Creature *c) : ScriptedAI(c), lSummons(me)
         {
-            pInstance->SetData(DATA_ANUBARAK_EVENT, NOT_STARTED);
-            pInstance->DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_TIMED_START_EVENT);
+            pInstance = c->GetInstanceData();
         }
-    }
 
-    Creature* DoSummonImpaleTarget(Unit *pTarget)
-    {
-        Position targetPos;
-        pTarget->GetPosition(&targetPos);
-
-        if (TempSummon* pImpaleTarget = me->SummonCreature(CREATURE_IMPALE_TARGET, targetPos, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 6*IN_MILLISECONDS))
+        ScriptedInstance *pInstance;
+
+        bool bChanneling;
+        bool bGuardianSummoned;
+        bool bVenomancerSummoned;
+        bool bDatterSummoned;
+        uint8 uiPhase;
+        uint32 uiUndergroundPhase;
+        uint32 uiCarrionBeetlesTimer;
+        uint32 uiLeechingSwarmTimer;
+        uint32 uiPoundTimer;
+        uint32 uiSubmergeTimer;
+        uint32 uiUndergroundTimer;
+        uint32 uiVenomancerTimer;
+        uint32 uiDatterTimer;
+        
+        uint32 uiImpaleTimer;
+        uint32 uiImpalePhase;
+        uint64 uiImpaleTarget;
+        
+        SummonList lSummons;
+
+        void Reset()
         {
-            uiImpaleTarget = pImpaleTarget->GetGUID();
-            pImpaleTarget->SetReactState(REACT_PASSIVE);
-            pImpaleTarget->SetDisplayId(DISPLAY_INVISIBLE);
-            pImpaleTarget->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE|UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
-            return pImpaleTarget;
+            uiCarrionBeetlesTimer = 8*IN_MILLISECONDS;
+            uiLeechingSwarmTimer = 20*IN_MILLISECONDS;
+            uiImpaleTimer = 9*IN_MILLISECONDS;
+            uiPoundTimer = 15*IN_MILLISECONDS;
+
+            uiPhase = PHASE_MELEE;
+            uiUndergroundPhase = 0;
+            bChanneling = false;
+            uiImpalePhase = IMPALE_PHASE_TARGET;
+
+            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
+            me->RemoveAura(SPELL_SUBMERGE);
+
+            lSummons.DespawnAll();
+           
+            if (pInstance)
+            {
+                pInstance->SetData(DATA_ANUBARAK_EVENT, NOT_STARTED);
+                pInstance->DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_TIMED_START_EVENT);
+            }
         }
 
-        return NULL;
-    }
+        Creature* DoSummonImpaleTarget(Unit *pTarget)
+        {
+            Position targetPos;
+            pTarget->GetPosition(&targetPos);
 
-    void EnterCombat(Unit * /*pWho*/)
-    {
-        DoScriptText(SAY_AGGRO, me);
-        if (pInstance)
+            if (TempSummon* pImpaleTarget = me->SummonCreature(CREATURE_IMPALE_TARGET, targetPos, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 6*IN_MILLISECONDS))
+            {
+                uiImpaleTarget = pImpaleTarget->GetGUID();
+                pImpaleTarget->SetReactState(REACT_PASSIVE);
+                pImpaleTarget->SetDisplayId(DISPLAY_INVISIBLE);
+                pImpaleTarget->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE|UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
+                return pImpaleTarget;
+            }
+
+            return NULL;
+        }
+
+        void EnterCombat(Unit * /*pWho*/)
         {
-            pInstance->SetData(DATA_ANUBARAK_EVENT, IN_PROGRESS);
-            pInstance->DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_TIMED_START_EVENT);
+            DoScriptText(SAY_AGGRO, me);
+            if (pInstance)
+            {
+                pInstance->SetData(DATA_ANUBARAK_EVENT, IN_PROGRESS);
+                pInstance->DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_TIMED_START_EVENT);
+            }
         }
-    }
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
+        void UpdateAI(const uint32 diff)
+        {
+            if (!UpdateVictim())
+                return;
 
-        switch (uiPhase)
-        {       
-        case PHASE_UNDERGROUND:
-            if (uiImpaleTimer <= diff)
-            {
-                switch(uiImpalePhase)
-                {                    
-                case IMPALE_PHASE_TARGET:
-                    if (Unit *target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true)) 
-                    {
-                        if (Creature *pImpaleTarget = DoSummonImpaleTarget(target))
-                            pImpaleTarget->CastSpell(pImpaleTarget, SPELL_IMPALE_SHAKEGROUND, true);
-                        uiImpaleTimer = 3*IN_MILLISECONDS;
-                        uiImpalePhase = IMPALE_PHASE_ATTACK;
-                    }
-                    break;
-                case IMPALE_PHASE_ATTACK:
-                    if (Creature* pImpaleTarget = Unit::GetCreature(*me, uiImpaleTarget))
-                    {
-                        pImpaleTarget->CastSpell(pImpaleTarget, SPELL_IMPALE_SPIKE, false);
-                        pImpaleTarget->RemoveAurasDueToSpell(SPELL_IMPALE_SHAKEGROUND);
+            switch (uiPhase)
+            {       
+            case PHASE_UNDERGROUND:
+                if (uiImpaleTimer <= diff)
+                {
+                    switch(uiImpalePhase)
+                    {                    
+                    case IMPALE_PHASE_TARGET:
+                        if (Unit *target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true)) 
+                        {
+                            if (Creature *pImpaleTarget = DoSummonImpaleTarget(target))
+                                pImpaleTarget->CastSpell(pImpaleTarget, SPELL_IMPALE_SHAKEGROUND, true);
+                            uiImpaleTimer = 3*IN_MILLISECONDS;
+                            uiImpalePhase = IMPALE_PHASE_ATTACK;
+                        }
+                        break;
+                    case IMPALE_PHASE_ATTACK:
+                        if (Creature* pImpaleTarget = Unit::GetCreature(*me, uiImpaleTarget))
+                        {
+                            pImpaleTarget->CastSpell(pImpaleTarget, SPELL_IMPALE_SPIKE, false);
+                            pImpaleTarget->RemoveAurasDueToSpell(SPELL_IMPALE_SHAKEGROUND);
+                        }
+                        uiImpalePhase = IMPALE_PHASE_DMG;
+                        uiImpaleTimer = 1*IN_MILLISECONDS;
+                        break;
+                    case IMPALE_PHASE_DMG:
+                        if (Creature* pImpaleTarget = Unit::GetCreature(*me, uiImpaleTarget))
+                            me->CastSpell(pImpaleTarget, DUNGEON_MODE(SPELL_IMPALE_DMG, SPELL_IMPALE_DMG_H), true);
+                        uiImpalePhase = IMPALE_PHASE_TARGET;
+                        uiImpaleTimer = 9*IN_MILLISECONDS;
+                        break;
                     }
-                    uiImpalePhase = IMPALE_PHASE_DMG;
-                    uiImpaleTimer = 1*IN_MILLISECONDS;
-                    break;
-                case IMPALE_PHASE_DMG:
-                    if (Creature* pImpaleTarget = Unit::GetCreature(*me, uiImpaleTarget))
-                        me->CastSpell(pImpaleTarget, DUNGEON_MODE(SPELL_IMPALE_DMG, SPELL_IMPALE_DMG_H), true);
-                    uiImpalePhase = IMPALE_PHASE_TARGET;
-                    uiImpaleTimer = 9*IN_MILLISECONDS;
-                    break;
-                }
-            } else uiImpaleTimer -= diff;
+                } else uiImpaleTimer -= diff;
 
-            if (!bGuardianSummoned)
-            {
-                for (uint8 i = 0; i < 2; ++i)
+                if (!bGuardianSummoned)
                 {
-                    if (Creature *Guardian = me->SummonCreature(CREATURE_GUARDIAN,SpawnPointGuardian[i],TEMPSUMMON_CORPSE_DESPAWN,0))
+                    for (uint8 i = 0; i < 2; ++i)
                     {
-                        Guardian->AddThreat(me->getVictim(), 0.0f);
-                        DoZoneInCombat(Guardian);
+                        if (Creature *Guardian = me->SummonCreature(CREATURE_GUARDIAN,SpawnPointGuardian[i],TEMPSUMMON_CORPSE_DESPAWN,0))
+                        {
+                            Guardian->AddThreat(me->getVictim(), 0.0f);
+                            DoZoneInCombat(Guardian);
+                        }
                     }
+                    bGuardianSummoned = true;
                 }
-                bGuardianSummoned = true;
-            }
 
-            if (!bVenomancerSummoned)
-            {
-                if (uiVenomancerTimer <= diff)
+                if (!bVenomancerSummoned)
                 {
-                    if (uiUndergroundPhase > 1)
+                    if (uiVenomancerTimer <= diff)
                     {
-                        for (uint8 i = 0; i < 2; ++i)
+                        if (uiUndergroundPhase > 1)
                         {
-                            if (Creature *Venomancer = me->SummonCreature(CREATURE_VENOMANCER,SpawnPoint[i],TEMPSUMMON_CORPSE_DESPAWN,0))
+                            for (uint8 i = 0; i < 2; ++i)
                             {
-                                Venomancer->AddThreat(me->getVictim(), 0.0f);
-                                DoZoneInCombat(Venomancer);
+                                if (Creature *Venomancer = me->SummonCreature(CREATURE_VENOMANCER,SpawnPoint[i],TEMPSUMMON_CORPSE_DESPAWN,0))
+                                {
+                                    Venomancer->AddThreat(me->getVictim(), 0.0f);
+                                    DoZoneInCombat(Venomancer);
+                                }
                             }
+                            bVenomancerSummoned = true;
                         }
-                        bVenomancerSummoned = true;
-                    }
-                } else uiVenomancerTimer -= diff;
-            }
+                    } else uiVenomancerTimer -= diff;
+                }
 
-            if (!bDatterSummoned)
-            {
-                if (uiDatterTimer <= diff)
+                if (!bDatterSummoned)
                 {
-                    if (uiUndergroundPhase > 2)
+                    if (uiDatterTimer <= diff)
                     {
-                        for (uint8 i = 0; i < 2; ++i)
+                        if (uiUndergroundPhase > 2)
                         {
-                            if (Creature *Datter = me->SummonCreature(CREATURE_DATTER,SpawnPoint[i],TEMPSUMMON_CORPSE_DESPAWN,0))
+                            for (uint8 i = 0; i < 2; ++i)
                             {
-                                Datter->AddThreat(me->getVictim(), 0.0f);
-                                DoZoneInCombat(Datter);
+                                if (Creature *Datter = me->SummonCreature(CREATURE_DATTER,SpawnPoint[i],TEMPSUMMON_CORPSE_DESPAWN,0))
+                                {
+                                    Datter->AddThreat(me->getVictim(), 0.0f);
+                                    DoZoneInCombat(Datter);
+                                }
                             }
+                            bDatterSummoned = true;
                         }
-                        bDatterSummoned = true;
-                    }
-                } else uiDatterTimer -= diff;
-            }
-
-            if (uiUndergroundTimer <= diff)
-            {
-                me->RemoveAura(SPELL_SUBMERGE);
-                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
-                uiPhase = PHASE_MELEE;
-            } else uiUndergroundTimer -= diff;
-            break;
-
-        case PHASE_MELEE:
-            if (((uiUndergroundPhase == 0 && HealthBelowPct(75))
-                || (uiUndergroundPhase == 1 && HealthBelowPct(50))
-                || (uiUndergroundPhase == 2 && HealthBelowPct(25)))
-                && !me->hasUnitState(UNIT_STAT_CASTING))
-            {
-                bGuardianSummoned = false;
-                bVenomancerSummoned = false;
-                bDatterSummoned = false;
+                    } else uiDatterTimer -= diff;
+                }
 
-                uiUndergroundTimer = 40*IN_MILLISECONDS;
-                uiVenomancerTimer = 25*IN_MILLISECONDS;
-                uiDatterTimer = 32*IN_MILLISECONDS;
+                if (uiUndergroundTimer <= diff)
+                {
+                    me->RemoveAura(SPELL_SUBMERGE);
+                    me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
+                    uiPhase = PHASE_MELEE;
+                } else uiUndergroundTimer -= diff;
+                break;
+
+            case PHASE_MELEE:
+                if (((uiUndergroundPhase == 0 && HealthBelowPct(75))
+                    || (uiUndergroundPhase == 1 && HealthBelowPct(50))
+                    || (uiUndergroundPhase == 2 && HealthBelowPct(25)))
+                    && !me->hasUnitState(UNIT_STAT_CASTING))
+                {
+                    bGuardianSummoned = false;
+                    bVenomancerSummoned = false;
+                    bDatterSummoned = false;
 
-                uiImpalePhase = 0;
-                uiImpaleTimer = 9*IN_MILLISECONDS;
+                    uiUndergroundTimer = 40*IN_MILLISECONDS;
+                    uiVenomancerTimer = 25*IN_MILLISECONDS;
+                    uiDatterTimer = 32*IN_MILLISECONDS;
 
-                DoCast(me, SPELL_SUBMERGE, false);
-                me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
-                
-                uiPhase = PHASE_UNDERGROUND;
-                ++uiUndergroundPhase;
-            }
+                    uiImpalePhase = 0;
+                    uiImpaleTimer = 9*IN_MILLISECONDS;
 
-            if (bChanneling == true)
-            {
-                for (uint8 i = 0; i < 8; ++i)
-                DoCast(me->getVictim(), SPELL_SUMMON_CARRION_BEETLES, true);
-                bChanneling = false;
-            }
-            else if (uiCarrionBeetlesTimer <= diff)
-            {
-                bChanneling = true;
-                DoCastVictim(SPELL_CARRION_BEETLES);
-                uiCarrionBeetlesTimer = 25*IN_MILLISECONDS;
-            } else uiCarrionBeetlesTimer -= diff;
-            
-            if (uiLeechingSwarmTimer <= diff)
-            {
-                DoCast(me, SPELL_LEECHING_SWARM, true);
-                uiLeechingSwarmTimer = 19*IN_MILLISECONDS;
-            } else uiLeechingSwarmTimer -= diff;
+                    DoCast(me, SPELL_SUBMERGE, false);
+                    me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
+                    
+                    uiPhase = PHASE_UNDERGROUND;
+                    ++uiUndergroundPhase;
+                }
 
-            if (uiPoundTimer <= diff)
-            {
-                if (Unit *target = me->getVictim())
+                if (bChanneling == true)
                 {
-                    if (Creature *pImpaleTarget = DoSummonImpaleTarget(target))
-                        me->CastSpell(pImpaleTarget, DUNGEON_MODE(SPELL_POUND, SPELL_POUND_H), false);
+                    for (uint8 i = 0; i < 8; ++i)
+                    DoCast(me->getVictim(), SPELL_SUMMON_CARRION_BEETLES, true);
+                    bChanneling = false;
                 }
-                uiPoundTimer = 16.5*IN_MILLISECONDS;
-            } else uiPoundTimer -= diff;
+                else if (uiCarrionBeetlesTimer <= diff)
+                {
+                    bChanneling = true;
+                    DoCastVictim(SPELL_CARRION_BEETLES);
+                    uiCarrionBeetlesTimer = 25*IN_MILLISECONDS;
+                } else uiCarrionBeetlesTimer -= diff;
+                
+                if (uiLeechingSwarmTimer <= diff)
+                {
+                    DoCast(me, SPELL_LEECHING_SWARM, true);
+                    uiLeechingSwarmTimer = 19*IN_MILLISECONDS;
+                } else uiLeechingSwarmTimer -= diff;
 
-            DoMeleeAttackIfReady();
-            break;
+                if (uiPoundTimer <= diff)
+                {
+                    if (Unit *target = me->getVictim())
+                    {
+                        if (Creature *pImpaleTarget = DoSummonImpaleTarget(target))
+                            me->CastSpell(pImpaleTarget, DUNGEON_MODE(SPELL_POUND, SPELL_POUND_H), false);
+                    }
+                    uiPoundTimer = 16.5*IN_MILLISECONDS;
+                } else uiPoundTimer -= diff;
+
+                DoMeleeAttackIfReady();
+                break;
+            }
+        }
+        
+        void JustDied(Unit * /*pKiller*/)
+        {
+            DoScriptText(SAY_DEATH, me);
+            lSummons.DespawnAll();
+            if (pInstance)
+                pInstance->SetData(DATA_ANUBARAK_EVENT, DONE);
         }
-    }
-    
-    void JustDied(Unit * /*pKiller*/)
-    {
-        DoScriptText(SAY_DEATH, me);
-        lSummons.DespawnAll();
-        if (pInstance)
-            pInstance->SetData(DATA_ANUBARAK_EVENT, DONE);
-    }
 
-    void KilledUnit(Unit *pVictim)
-    {
-        if (pVictim == me)
-            return;
-        DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2,SAY_SLAY_3), me);
-    }
+        void KilledUnit(Unit *pVictim)
+        {
+            if (pVictim == me)
+                return;
+            DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2,SAY_SLAY_3), me);
+        }
+
+        void JustSummoned(Creature* summon)
+        {
+            lSummons.Summon(summon);
+        }
+    };
 
-    void JustSummoned(Creature* summon)
+    CreatureAI *GetAI(Creature *creature) const
     {
-        lSummons.Summon(summon);
+        return new boss_anub_arakAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_anub_arak(Creature *pCreature)
-{
-    return new boss_anub_arakAI (pCreature);
-}
-
 void AddSC_boss_anub_arak()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_anub_arak";
-    newscript->GetAI = &GetAI_boss_anub_arak;
-    newscript->RegisterSelf();
+    new boss_anub_arak;
 }
diff --git a/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_hadronox.cpp b/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_hadronox.cpp
index 7b8a81013be..bd83605cb80 100644
--- a/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_hadronox.cpp
+++ b/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_hadronox.cpp
@@ -44,162 +44,162 @@ enum Spells
     H_SPELL_WEB_GRAB                              = 59421
 };
 
-struct boss_hadronoxAI : public ScriptedAI
+class boss_hadronox : public CreatureScript
 {
-    boss_hadronoxAI(Creature* c) : ScriptedAI(c)
-    {
-        pInstance = c->GetInstanceData();
-        fMaxDistance = 50.0f;
-        bFirstTime = true;
-    }
-
-    ScriptedInstance* pInstance;
-
-    uint32 uiAcidTimer;
-    uint32 uiLeechTimer;
-    uint32 uiPierceTimer;
-    uint32 uiGrabTimer;
-    uint32 uiDoorsTimer;
-    uint32 uiCheckDistanceTimer;
-
-    bool bFirstTime;
-
-    float fMaxDistance;
-
-    void Reset()
-    {
-        me->SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, 9.0f);
-        me->SetFloatValue(UNIT_FIELD_COMBATREACH, 9.0f);
-
-        uiAcidTimer = urand(10*IN_MILLISECONDS,14*IN_MILLISECONDS);
-        uiLeechTimer = urand(3*IN_MILLISECONDS,9*IN_MILLISECONDS);
-        uiPierceTimer = urand(1*IN_MILLISECONDS,3*IN_MILLISECONDS);
-        uiGrabTimer = urand(15*IN_MILLISECONDS,19*IN_MILLISECONDS);
-        uiDoorsTimer = urand(20*IN_MILLISECONDS,30*IN_MILLISECONDS);
-        uiCheckDistanceTimer = 2*IN_MILLISECONDS;
-
-        if (pInstance && (pInstance->GetData(DATA_HADRONOX_EVENT) != DONE && !bFirstTime))
-            pInstance->SetData(DATA_HADRONOX_EVENT, FAIL);
+public:
+    boss_hadronox() : CreatureScript("boss_hadronox") { }
 
-        bFirstTime = false;
-    }
-
-    //when Hadronox kills any enemy (that includes a party member) she will regain 10% of her HP if the target had Leech Poison on
-    void KilledUnit(Unit* Victim)
+    struct boss_hadronoxAI : public ScriptedAI
     {
-        // not sure if this aura check is correct, I think it is though
-        if (!Victim || !Victim->HasAura(DUNGEON_MODE(SPELL_LEECH_POISON, H_SPELL_LEECH_POISON)) || !me->isAlive())
-            return;
+        boss_hadronoxAI(Creature* c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+            fMaxDistance = 50.0f;
+            bFirstTime = true;
+        }
 
-        uint32 health = me->GetMaxHealth()/10;
+        ScriptedInstance* pInstance;
 
-        if ((me->GetHealth()+health) >= me->GetMaxHealth())
-            me->SetHealth(me->GetMaxHealth());
-        else
-            me->SetHealth(me->GetHealth()+health);
-    }
+        uint32 uiAcidTimer;
+        uint32 uiLeechTimer;
+        uint32 uiPierceTimer;
+        uint32 uiGrabTimer;
+        uint32 uiDoorsTimer;
+        uint32 uiCheckDistanceTimer;
 
-    void JustDied(Unit* /*Killer*/)
-    {
-        if (pInstance)
-            pInstance->SetData(DATA_HADRONOX_EVENT, DONE);
-    }
+        bool bFirstTime;
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        if (pInstance)
-            pInstance->SetData(DATA_HADRONOX_EVENT, IN_PROGRESS);
-        me->SetInCombatWithZone();
-    }
+        float fMaxDistance;
 
-    void CheckDistance(float dist, const uint32 uiDiff)
-    {
-        if (!me->isInCombat())
-            return;
-
-        float x=0.0f, y=0.0f, z=0.0f;
-        me->GetRespawnCoord(x,y,z);
-
-        if (uiCheckDistanceTimer <= uiDiff)
-            uiCheckDistanceTimer = 5*IN_MILLISECONDS;
-        else
+        void Reset()
         {
-            uiCheckDistanceTimer -= uiDiff;
-            return;
-        }
-        if (me->IsInEvadeMode() || !me->getVictim())
-            return;
-        if (me->GetDistance(x,y,z) > dist)
-            EnterEvadeMode();
-    }
+            me->SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, 9.0f);
+            me->SetFloatValue(UNIT_FIELD_COMBATREACH, 9.0f);
 
-    void UpdateAI(const uint32 diff)
-    {
-        //Return since we have no target
-        if (!UpdateVictim()) return;
+            uiAcidTimer = urand(10*IN_MILLISECONDS,14*IN_MILLISECONDS);
+            uiLeechTimer = urand(3*IN_MILLISECONDS,9*IN_MILLISECONDS);
+            uiPierceTimer = urand(1*IN_MILLISECONDS,3*IN_MILLISECONDS);
+            uiGrabTimer = urand(15*IN_MILLISECONDS,19*IN_MILLISECONDS);
+            uiDoorsTimer = urand(20*IN_MILLISECONDS,30*IN_MILLISECONDS);
+            uiCheckDistanceTimer = 2*IN_MILLISECONDS;
 
-        // Without he comes up through the air to players on the bridge after krikthir if players crossing this bridge!
-        CheckDistance(fMaxDistance, diff);
+            if (pInstance && (pInstance->GetData(DATA_HADRONOX_EVENT) != DONE && !bFirstTime))
+                pInstance->SetData(DATA_HADRONOX_EVENT, FAIL);
 
-        if (me->HasAura(SPELL_WEB_FRONT_DOORS) || me->HasAura(SPELL_WEB_SIDE_DOORS))
-        {
-            if (IsCombatMovement())
-                SetCombatMovement(false);
+            bFirstTime = false;
         }
-        else if (!IsCombatMovement())
-            SetCombatMovement(true);
 
-        if (uiPierceTimer <= diff)
+        //when Hadronox kills any enemy (that includes a party member) she will regain 10% of her HP if the target had Leech Poison on
+        void KilledUnit(Unit* Victim)
         {
-            DoCast(me->getVictim(), SPELL_PIERCE_ARMOR);
-            uiPierceTimer = 8*IN_MILLISECONDS;
-        } else uiPierceTimer -= diff;
+            // not sure if this aura check is correct, I think it is though
+            if (!Victim || !Victim->HasAura(DUNGEON_MODE(SPELL_LEECH_POISON, H_SPELL_LEECH_POISON)) || !me->isAlive())
+                return;
 
-        if (uiAcidTimer <= diff)
-        {
-            if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                DoCast(pTarget, SPELL_ACID_CLOUD);
+            uint32 health = me->GetMaxHealth()/10;
 
-            uiAcidTimer = urand(20*IN_MILLISECONDS,30*IN_MILLISECONDS);
-        } else uiAcidTimer -= diff;
+            if ((me->GetHealth()+health) >= me->GetMaxHealth())
+                me->SetHealth(me->GetMaxHealth());
+            else
+                me->SetHealth(me->GetHealth()+health);
+        }
 
-        if (uiLeechTimer <= diff)
+        void JustDied(Unit* /*Killer*/)
         {
-            if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                DoCast(pTarget, SPELL_LEECH_POISON);
-
-            uiLeechTimer = urand(11*IN_MILLISECONDS,14*IN_MILLISECONDS);
-        } else uiLeechTimer -= diff;
+            if (pInstance)
+                pInstance->SetData(DATA_HADRONOX_EVENT, DONE);
+        }
 
-        if (uiGrabTimer <= diff)
+        void EnterCombat(Unit* /*who*/)
         {
-            if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0)) // Draws all players (and attacking Mobs) to itself.
-                DoCast(pTarget, SPELL_WEB_GRAB);
+            if (pInstance)
+                pInstance->SetData(DATA_HADRONOX_EVENT, IN_PROGRESS);
+            me->SetInCombatWithZone();
+        }
 
-            uiGrabTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
-        } else uiGrabTimer -= diff;
+        void CheckDistance(float dist, const uint32 uiDiff)
+        {
+            if (!me->isInCombat())
+                return;
+
+            float x=0.0f, y=0.0f, z=0.0f;
+            me->GetRespawnCoord(x,y,z);
+
+            if (uiCheckDistanceTimer <= uiDiff)
+                uiCheckDistanceTimer = 5*IN_MILLISECONDS;
+            else
+            {
+                uiCheckDistanceTimer -= uiDiff;
+                return;
+            }
+            if (me->IsInEvadeMode() || !me->getVictim())
+                return;
+            if (me->GetDistance(x,y,z) > dist)
+                EnterEvadeMode();
+        }
 
-        if (uiDoorsTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            //DoCast(me, RAND(SPELL_WEB_FRONT_DOORS, SPELL_WEB_SIDE_DOORS));
-            uiDoorsTimer = urand(30*IN_MILLISECONDS,60*IN_MILLISECONDS);
-        } else uiDoorsTimer -= diff;
+            //Return since we have no target
+            if (!UpdateVictim()) return;
+
+            // Without he comes up through the air to players on the bridge after krikthir if players crossing this bridge!
+            CheckDistance(fMaxDistance, diff);
+
+            if (me->HasAura(SPELL_WEB_FRONT_DOORS) || me->HasAura(SPELL_WEB_SIDE_DOORS))
+            {
+                if (IsCombatMovement())
+                    SetCombatMovement(false);
+            }
+            else if (!IsCombatMovement())
+                SetCombatMovement(true);
+
+            if (uiPierceTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_PIERCE_ARMOR);
+                uiPierceTimer = 8*IN_MILLISECONDS;
+            } else uiPierceTimer -= diff;
+
+            if (uiAcidTimer <= diff)
+            {
+                if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                    DoCast(pTarget, SPELL_ACID_CLOUD);
+
+                uiAcidTimer = urand(20*IN_MILLISECONDS,30*IN_MILLISECONDS);
+            } else uiAcidTimer -= diff;
+
+            if (uiLeechTimer <= diff)
+            {
+                if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                    DoCast(pTarget, SPELL_LEECH_POISON);
+
+                uiLeechTimer = urand(11*IN_MILLISECONDS,14*IN_MILLISECONDS);
+            } else uiLeechTimer -= diff;
+
+            if (uiGrabTimer <= diff)
+            {
+                if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0)) // Draws all players (and attacking Mobs) to itself.
+                    DoCast(pTarget, SPELL_WEB_GRAB);
+
+                uiGrabTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
+            } else uiGrabTimer -= diff;
+
+            if (uiDoorsTimer <= diff)
+            {
+                uiDoorsTimer = urand(30*IN_MILLISECONDS,60*IN_MILLISECONDS);
+            } else uiDoorsTimer -= diff;
+
+            DoMeleeAttackIfReady();
+        }
+    };
 
-        DoMeleeAttackIfReady();
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new boss_hadronoxAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_hadronox(Creature* pCreature)
-{
-    return new boss_hadronoxAI (pCreature);
-}
-
 void AddSC_boss_hadronox()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_hadronox";
-    newscript->GetAI = &GetAI_boss_hadronox;
-    newscript->RegisterSelf();
+    new boss_hadronox;
 }
diff --git a/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_krikthir_the_gatewatcher.cpp b/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_krikthir_the_gatewatcher.cpp
index 9680863acad..183721ba62c 100644
--- a/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_krikthir_the_gatewatcher.cpp
+++ b/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_krikthir_the_gatewatcher.cpp
@@ -91,462 +91,475 @@ const Position SpawnPoint[] =
     { 504.01,  637.693, 777.479, 0.506145 },
     { 552.625, 706.408, 777.177, 3.4383   }
 };
-struct boss_krik_thirAI : public ScriptedAI
-{
-    boss_krik_thirAI(Creature *c) : ScriptedAI(c)
-    {
-        pInstance = c->GetInstanceData();
-    }
-
-    ScriptedInstance* pInstance;
 
-    uint32 uiMindFlayTimer;
-    uint32 uiCurseFatigueTimer;
-    uint32 uiSummonTimer;
+class boss_krik_thir : public CreatureScript
+{
+public:
+    boss_krik_thir() : CreatureScript("boss_krik_thir") { }
 
-    void Reset()
+    struct boss_krik_thirAI : public ScriptedAI
     {
-        uiMindFlayTimer = 15*IN_MILLISECONDS;
-        uiCurseFatigueTimer = 12*IN_MILLISECONDS;
+        boss_krik_thirAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-        if (pInstance)
-            pInstance->SetData(DATA_KRIKTHIR_THE_GATEWATCHER_EVENT, NOT_STARTED);
-    }
+        ScriptedInstance* pInstance;
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        DoScriptText(SAY_AGGRO, me);
-        Summon();
-        uiSummonTimer = 15*IN_MILLISECONDS;
+        uint32 uiMindFlayTimer;
+        uint32 uiCurseFatigueTimer;
+        uint32 uiSummonTimer;
 
-        if (pInstance)
-            pInstance->SetData(DATA_KRIKTHIR_THE_GATEWATCHER_EVENT, IN_PROGRESS);
-    }
-
-    void Summon()
-    {
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[0],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[0],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[1],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[1],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[2],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[2],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[3],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[3],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_INFECTIOR,SpawnPoint[4],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[4],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_INFECTIOR,SpawnPoint[5],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[5],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_INFECTIOR,SpawnPoint[6],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[6],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[7],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-            me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[7],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
-    }
+        void Reset()
+        {
+            uiMindFlayTimer = 15*IN_MILLISECONDS;
+            uiCurseFatigueTimer = 12*IN_MILLISECONDS;
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
+            if (pInstance)
+                pInstance->SetData(DATA_KRIKTHIR_THE_GATEWATCHER_EVENT, NOT_STARTED);
+        }
 
-        if (uiSummonTimer <= diff)
+        void EnterCombat(Unit* /*who*/)
         {
+            DoScriptText(SAY_AGGRO, me);
             Summon();
             uiSummonTimer = 15*IN_MILLISECONDS;
-        } else uiSummonTimer -= diff;
 
-        if (uiMindFlayTimer <= diff)
-        {
-                DoCast(me->getVictim(), SPELL_MIND_FLAY);
-                uiMindFlayTimer = 15*IN_MILLISECONDS;
-            } else uiMindFlayTimer -= diff;
+            if (pInstance)
+                pInstance->SetData(DATA_KRIKTHIR_THE_GATEWATCHER_EVENT, IN_PROGRESS);
+        }
 
-        if (uiCurseFatigueTimer <= diff)
+        void Summon()
         {
-            //WowWiki say "Curse of Fatigue-Kirk'thir will cast Curse of Fatigue on 2-3 targets periodically."
-            Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
-            Unit *pTarget_1 = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[0],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[0],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[1],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[1],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[2],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[2],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[3],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[3],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_INFECTIOR,SpawnPoint[4],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[4],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_INFECTIOR,SpawnPoint[5],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[5],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_INFECTIOR,SpawnPoint[6],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[6],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[7],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+                me->SummonCreature(MOB_SKITTERING_SWARMER,SpawnPoint[7],TEMPSUMMON_TIMED_DESPAWN,25*IN_MILLISECONDS);
+        }
+
+        void UpdateAI(const uint32 diff)
+        {
+            if (!UpdateVictim())
+                return;
 
-            DoCast(pTarget, SPELL_CURSE_OF_FATIGUE);
-            DoCast(pTarget_1, SPELL_CURSE_OF_FATIGUE);
+            if (uiSummonTimer <= diff)
+            {
+                Summon();
+                uiSummonTimer = 15*IN_MILLISECONDS;
+            } else uiSummonTimer -= diff;
 
-            uiCurseFatigueTimer = 10*IN_MILLISECONDS;
-        } else uiCurseFatigueTimer -= diff;
+            if (uiMindFlayTimer <= diff)
+            {
+                    DoCast(me->getVictim(), SPELL_MIND_FLAY);
+                    uiMindFlayTimer = 15*IN_MILLISECONDS;
+                } else uiMindFlayTimer -= diff;
 
-        if (!me->HasAura(SPELL_FRENZY) && HealthBelowPct(10))
-            DoCast(me, SPELL_FRENZY, true);
+            if (uiCurseFatigueTimer <= diff)
+            {
+                //WowWiki say "Curse of Fatigue-Kirk'thir will cast Curse of Fatigue on 2-3 targets periodically."
+                Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
+                Unit *pTarget_1 = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true);
 
-        DoMeleeAttackIfReady();
-    }
-    void JustDied(Unit* /*killer*/)
-    {
-        DoScriptText(SAY_DEATH, me);
+                DoCast(pTarget, SPELL_CURSE_OF_FATIGUE);
+                DoCast(pTarget_1, SPELL_CURSE_OF_FATIGUE);
 
-        if (!pInstance)
-            return;
+                uiCurseFatigueTimer = 10*IN_MILLISECONDS;
+            } else uiCurseFatigueTimer -= diff;
 
-        pInstance->SetData(DATA_KRIKTHIR_THE_GATEWATCHER_EVENT, DONE);
-        //Achievement: Watch him die
-        Creature *pAdd = Unit::GetCreature(*me, pInstance->GetData64(DATA_WATCHER_GASHRA));
-        if (!pAdd || !pAdd->isAlive())
-            return;
+            if (!me->HasAura(SPELL_FRENZY) && HealthBelowPct(10))
+                DoCast(me, SPELL_FRENZY, true);
 
-        pAdd = Unit::GetCreature(*me, pInstance->GetData64(DATA_WATCHER_SILTHIK));
-        if (!pAdd || !pAdd->isAlive())
-            return;
+            DoMeleeAttackIfReady();
+        }
+        void JustDied(Unit* /*killer*/)
+        {
+            DoScriptText(SAY_DEATH, me);
 
-        pAdd = Unit::GetCreature(*me, pInstance->GetData64(DATA_WATCHER_NARJIL));
-        if (!pAdd || !pAdd->isAlive())
-            return;
+            if (!pInstance)
+                return;
 
-        pInstance->DoCompleteAchievement(ACHIEV_WATH_HIM_DIE);
-    }
+            pInstance->SetData(DATA_KRIKTHIR_THE_GATEWATCHER_EVENT, DONE);
+            //Achievement: Watch him die
+            Creature *pAdd = Unit::GetCreature(*me, pInstance->GetData64(DATA_WATCHER_GASHRA));
+            if (!pAdd || !pAdd->isAlive())
+                return;
 
-    void KilledUnit(Unit * victim)
-    {
-        if (victim == me)
-            return;
+            pAdd = Unit::GetCreature(*me, pInstance->GetData64(DATA_WATCHER_SILTHIK));
+            if (!pAdd || !pAdd->isAlive())
+                return;
 
-        DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2), me);
-    }
+            pAdd = Unit::GetCreature(*me, pInstance->GetData64(DATA_WATCHER_NARJIL));
+            if (!pAdd || !pAdd->isAlive())
+                return;
+
+            pInstance->DoCompleteAchievement(ACHIEV_WATH_HIM_DIE);
+        }
+
+        void KilledUnit(Unit * victim)
+        {
+            if (victim == me)
+                return;
+
+            DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2), me);
+        }
+
+        void JustSummoned(Creature* summoned)
+        {
+            summoned->GetMotionMaster()->MovePoint(0,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ());
+        }
+    };
 
-    void JustSummoned(Creature* summoned)
+    CreatureAI *GetAI(Creature *creature) const
     {
-        summoned->GetMotionMaster()->MovePoint(0,me->GetPositionX(),me->GetPositionY(),me->GetPositionZ());
+        return new boss_krik_thirAI(creature);
     }
 };
 
-struct npc_skittering_infectorAI : public ScriptedAI
+class npc_skittering_infector : public CreatureScript
 {
-    npc_skittering_infectorAI(Creature *c) : ScriptedAI(c) {}
+public:
+    npc_skittering_infector() : CreatureScript("npc_skittering_infector") { }
 
-    void JustDied(Unit* /*killer*/)
+    struct npc_skittering_infectorAI : public ScriptedAI
     {
-        //The spell is not working propperly
-        DoCast(me->getVictim(),SPELL_ACID_SPLASH, true);
-    }
+        npc_skittering_infectorAI(Creature *c) : ScriptedAI(c) {}
+
+        void JustDied(Unit* /*killer*/)
+        {
+            //The spell is not working propperly
+            DoCast(me->getVictim(),SPELL_ACID_SPLASH, true);
+        }
+    };
 
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new npc_skittering_infectorAI(creature);
+    }
 };
 
-struct npc_anub_ar_skirmisherAI : public ScriptedAI
+class npc_anub_ar_skirmisher : public CreatureScript
 {
-    npc_anub_ar_skirmisherAI(Creature *c) : ScriptedAI(c) {}
+public:
+    npc_anub_ar_skirmisher() : CreatureScript("npc_anub_ar_skirmisher") { }
 
-    uint32 uiChargeTimer;
-    uint32 uiBackstabTimer;
-
-    void Reset()
+    struct npc_anub_ar_skirmisherAI : public ScriptedAI
     {
-        uiChargeTimer   = 11*IN_MILLISECONDS;
-        uiBackstabTimer = 7*IN_MILLISECONDS;
-    }
+        npc_anub_ar_skirmisherAI(Creature *c) : ScriptedAI(c) {}
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
+        uint32 uiChargeTimer;
+        uint32 uiBackstabTimer;
 
-        if (uiChargeTimer <= diff)
+        void Reset()
         {
-            if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-            {
-                DoResetThreat();
-                me->AddThreat(pTarget,1.0f);
-                DoCast(pTarget, SPELL_CHARGE, true);
-            }
-            uiChargeTimer = 15*IN_MILLISECONDS;
-        } else uiChargeTimer -= diff;
-
-        if (uiBackstabTimer <= diff)
+            uiChargeTimer   = 11*IN_MILLISECONDS;
+            uiBackstabTimer = 7*IN_MILLISECONDS;
+        }
+
+        void UpdateAI(const uint32 diff)
         {
-            DoCast(me->getVictim(), SPELL_BACKSTAB);
-            uiBackstabTimer = 12*IN_MILLISECONDS;
-        } else uiBackstabTimer -= diff;
+            if (!UpdateVictim())
+                return;
+
+            if (uiChargeTimer <= diff)
+            {
+                if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                {
+                    DoResetThreat();
+                    me->AddThreat(pTarget,1.0f);
+                    DoCast(pTarget, SPELL_CHARGE, true);
+                }
+                uiChargeTimer = 15*IN_MILLISECONDS;
+            } else uiChargeTimer -= diff;
+
+            if (uiBackstabTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_BACKSTAB);
+                uiBackstabTimer = 12*IN_MILLISECONDS;
+            } else uiBackstabTimer -= diff;
+
+            DoMeleeAttackIfReady();
 
-        DoMeleeAttackIfReady();
+        }
+    };
 
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new npc_anub_ar_skirmisherAI(creature);
     }
 };
 
-struct npc_anub_ar_shadowcasterAI : public ScriptedAI
+class npc_anub_ar_shadowcaster : public CreatureScript
 {
-    npc_anub_ar_shadowcasterAI(Creature *c) : ScriptedAI(c) {}
-
-    uint32 uiShadowBoltTimer;
-    uint32 uiShadowNovaTimer;
+public:
+    npc_anub_ar_shadowcaster() : CreatureScript("npc_anub_ar_shadowcaster") { }
 
-    void Reset()
+    struct npc_anub_ar_shadowcasterAI : public ScriptedAI
     {
-        uiShadowBoltTimer = 6*IN_MILLISECONDS;
-        uiShadowNovaTimer = 15*IN_MILLISECONDS;
-    }
+        npc_anub_ar_shadowcasterAI(Creature *c) : ScriptedAI(c) {}
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
+        uint32 uiShadowBoltTimer;
+        uint32 uiShadowNovaTimer;
 
-        if (uiShadowBoltTimer <= diff)
+        void Reset()
         {
-            if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                 DoCast(pTarget, SPELL_SHADOW_BOLT, true);
-            uiShadowBoltTimer = 15*IN_MILLISECONDS;
-        } else uiShadowBoltTimer -= diff;
+            uiShadowBoltTimer = 6*IN_MILLISECONDS;
+            uiShadowNovaTimer = 15*IN_MILLISECONDS;
+        }
 
-        if (uiShadowNovaTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            DoCast(me->getVictim(), SPELL_SHADOW_NOVA, true);
-            uiShadowNovaTimer = 17*IN_MILLISECONDS;
-        } else uiShadowNovaTimer -= diff;
+            if (!UpdateVictim())
+                return;
 
-        DoMeleeAttackIfReady();
-    }
-};
+            if (uiShadowBoltTimer <= diff)
+            {
+                if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                     DoCast(pTarget, SPELL_SHADOW_BOLT, true);
+                uiShadowBoltTimer = 15*IN_MILLISECONDS;
+            } else uiShadowBoltTimer -= diff;
 
-struct npc_anub_ar_warriorAI : public ScriptedAI
-{
-    npc_anub_ar_warriorAI(Creature *c) : ScriptedAI(c){}
+            if (uiShadowNovaTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_SHADOW_NOVA, true);
+                uiShadowNovaTimer = 17*IN_MILLISECONDS;
+            } else uiShadowNovaTimer -= diff;
 
-    uint32 uiCleaveTimer;
-    uint32 uiStrikeTimer;
+            DoMeleeAttackIfReady();
+        }
+    };
 
-    void Reset()
+    CreatureAI *GetAI(Creature *creature) const
     {
-        uiCleaveTimer = 11*IN_MILLISECONDS;
-        uiStrikeTimer = 6*IN_MILLISECONDS;
+        return new npc_anub_ar_shadowcasterAI(creature);
     }
+};
+
+class npc_anub_ar_warrior : public CreatureScript
+{
+public:
+    npc_anub_ar_warrior() : CreatureScript("npc_anub_ar_warrior") { }
 
-    void UpdateAI(const uint32 diff)
+    struct npc_anub_ar_warriorAI : public ScriptedAI
     {
-        if (!UpdateVictim())
-            return;
+        npc_anub_ar_warriorAI(Creature *c) : ScriptedAI(c){}
 
-        if (uiStrikeTimer <= diff)
+        uint32 uiCleaveTimer;
+        uint32 uiStrikeTimer;
+
+        void Reset()
         {
-            DoCast(me->getVictim(), SPELL_STRIKE, true);
-            uiStrikeTimer = 15*IN_MILLISECONDS;
-        } else uiStrikeTimer -= diff;
+            uiCleaveTimer = 11*IN_MILLISECONDS;
+            uiStrikeTimer = 6*IN_MILLISECONDS;
+        }
 
-        if (uiCleaveTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            DoCast(me->getVictim(), SPELL_CLEAVE, true);
-            uiCleaveTimer = 17*IN_MILLISECONDS;
-        } else uiCleaveTimer -= diff;
+            if (!UpdateVictim())
+                return;
 
-        DoMeleeAttackIfReady();
+            if (uiStrikeTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_STRIKE, true);
+                uiStrikeTimer = 15*IN_MILLISECONDS;
+            } else uiStrikeTimer -= diff;
 
-    }
+            if (uiCleaveTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_CLEAVE, true);
+                uiCleaveTimer = 17*IN_MILLISECONDS;
+            } else uiCleaveTimer -= diff;
+
+            DoMeleeAttackIfReady();
+        }
+    };
 
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new npc_anub_ar_warriorAI(creature);
+    }
 };
 
-struct npc_watcher_gashraAI : public ScriptedAI
+class npc_watcher_gashra : public CreatureScript
 {
-    npc_watcher_gashraAI(Creature *c) : ScriptedAI(c) {}
+public:
+    npc_watcher_gashra() : CreatureScript("npc_watcher_gashra") { }
 
-    uint32 uiWebWrapTimer;
-    uint32 uiInfectedBiteTimer;
-
-    void Reset()
+    struct npc_watcher_gashraAI : public ScriptedAI
     {
-        uiWebWrapTimer      = 11*IN_MILLISECONDS;
-        uiInfectedBiteTimer = 4*IN_MILLISECONDS;
-    }
+        npc_watcher_gashraAI(Creature *c) : ScriptedAI(c) {}
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        DoCast(me, SPELL_ENRAGE, true);
-    }
+        uint32 uiWebWrapTimer;
+        uint32 uiInfectedBiteTimer;
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
+        void Reset()
+        {
+            uiWebWrapTimer      = 11*IN_MILLISECONDS;
+            uiInfectedBiteTimer = 4*IN_MILLISECONDS;
+        }
 
-        if (uiWebWrapTimer <= diff)
+        void EnterCombat(Unit* /*who*/)
         {
-            if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                DoCast(pTarget, SPELL_WEB_WRAP, true);
-            uiWebWrapTimer = 17*IN_MILLISECONDS;
-        } else uiWebWrapTimer -= diff;
+            DoCast(me, SPELL_ENRAGE, true);
+        }
 
-        if (uiInfectedBiteTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            DoCast(me->getVictim(), SPELL_INFECTED_BITE, true);
-            uiInfectedBiteTimer = 15*IN_MILLISECONDS;
-        } else uiInfectedBiteTimer -= diff;
+            if (!UpdateVictim())
+                return;
 
-        DoMeleeAttackIfReady();
-    }
-};
+            if (uiWebWrapTimer <= diff)
+            {
+                if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                    DoCast(pTarget, SPELL_WEB_WRAP, true);
+                uiWebWrapTimer = 17*IN_MILLISECONDS;
+            } else uiWebWrapTimer -= diff;
 
-struct npc_watcher_narjilAI : public ScriptedAI
-{
-    npc_watcher_narjilAI(Creature *c) : ScriptedAI(c) {}
+            if (uiInfectedBiteTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_INFECTED_BITE, true);
+                uiInfectedBiteTimer = 15*IN_MILLISECONDS;
+            } else uiInfectedBiteTimer -= diff;
 
-    uint32 uiWebWrapTimer;
-    uint32 uiInfectedBiteTimer;
-    uint32 uiBindingWebsTimer;
+            DoMeleeAttackIfReady();
+        }
+    };
 
-    void Reset()
+    CreatureAI *GetAI(Creature *creature) const
     {
-        uiWebWrapTimer      = 11*IN_MILLISECONDS;
-        uiInfectedBiteTimer = 4*IN_MILLISECONDS;
-        uiBindingWebsTimer = 17*IN_MILLISECONDS;
+        return new npc_watcher_gashraAI(creature);
     }
+};
+
+class npc_watcher_narjil : public CreatureScript
+{
+public:
+    npc_watcher_narjil() : CreatureScript("npc_watcher_narjil") { }
 
-    void UpdateAI(const uint32 diff)
+    struct npc_watcher_narjilAI : public ScriptedAI
     {
-        if (!UpdateVictim())
-            return;
+        npc_watcher_narjilAI(Creature *c) : ScriptedAI(c) {}
 
-        if (uiWebWrapTimer <= diff)
-        {
-            if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                DoCast(pTarget, SPELL_WEB_WRAP, true);
-            uiWebWrapTimer = 15*IN_MILLISECONDS;
-        } else uiWebWrapTimer -= diff;
+        uint32 uiWebWrapTimer;
+        uint32 uiInfectedBiteTimer;
+        uint32 uiBindingWebsTimer;
 
-        if (uiInfectedBiteTimer <= diff)
+        void Reset()
         {
-            DoCast(me->getVictim(), SPELL_INFECTED_BITE, true);
-            uiInfectedBiteTimer = 11*IN_MILLISECONDS;
-        } else uiInfectedBiteTimer -= diff;
+            uiWebWrapTimer      = 11*IN_MILLISECONDS;
+            uiInfectedBiteTimer = 4*IN_MILLISECONDS;
+            uiBindingWebsTimer = 17*IN_MILLISECONDS;
+        }
 
-        if (uiBindingWebsTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            DoCast(me->getVictim(), SPELL_BLINDING_WEBS, true);
-            uiBindingWebsTimer = 17*IN_MILLISECONDS;
-        } else uiBindingWebsTimer -= diff;
+            if (!UpdateVictim())
+                return;
 
-        DoMeleeAttackIfReady();
-    }
-};
+            if (uiWebWrapTimer <= diff)
+            {
+                if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                    DoCast(pTarget, SPELL_WEB_WRAP, true);
+                uiWebWrapTimer = 15*IN_MILLISECONDS;
+            } else uiWebWrapTimer -= diff;
 
-struct npc_watcher_silthikAI : public ScriptedAI
-{
-    npc_watcher_silthikAI(Creature *c) : ScriptedAI(c) {}
+            if (uiInfectedBiteTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_INFECTED_BITE, true);
+                uiInfectedBiteTimer = 11*IN_MILLISECONDS;
+            } else uiInfectedBiteTimer -= diff;
 
-    uint32 uiWebWrapTimer;
-    uint32 uiInfectedBiteTimer;
-    uint32 uiPoisonSprayTimer;
+            if (uiBindingWebsTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_BLINDING_WEBS, true);
+                uiBindingWebsTimer = 17*IN_MILLISECONDS;
+            } else uiBindingWebsTimer -= diff;
 
-    void Reset()
+            DoMeleeAttackIfReady();
+        }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
     {
-        uiWebWrapTimer      = 11*IN_MILLISECONDS;
-        uiInfectedBiteTimer = 4*IN_MILLISECONDS;
-        uiPoisonSprayTimer  = 15*IN_MILLISECONDS;
+        return new npc_watcher_narjilAI(creature);
     }
+};
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
+class npc_watcher_silthik : public CreatureScript
+{
+public:
+    npc_watcher_silthik() : CreatureScript("npc_watcher_silthik") { }
 
-        if (uiWebWrapTimer <= diff)
-        {
-            if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                DoCast(pTarget, SPELL_WEB_WRAP, true);
+    struct npc_watcher_silthikAI : public ScriptedAI
+    {
+        npc_watcher_silthikAI(Creature *c) : ScriptedAI(c) {}
 
-            uiWebWrapTimer = 15*IN_MILLISECONDS;
-        } else uiWebWrapTimer -= diff;
+        uint32 uiWebWrapTimer;
+        uint32 uiInfectedBiteTimer;
+        uint32 uiPoisonSprayTimer;
 
-        if (uiInfectedBiteTimer <= diff)
+        void Reset()
         {
-            DoCast(me->getVictim(), SPELL_INFECTED_BITE, true);
-            uiInfectedBiteTimer = 15*IN_MILLISECONDS;
-        } else uiInfectedBiteTimer -= diff;
+            uiWebWrapTimer      = 11*IN_MILLISECONDS;
+            uiInfectedBiteTimer = 4*IN_MILLISECONDS;
+            uiPoisonSprayTimer  = 15*IN_MILLISECONDS;
+        }
 
-        if (uiPoisonSprayTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            DoCast(me->getVictim(), SPELL_POSION_SPRAY, true);
-            uiPoisonSprayTimer = 17*IN_MILLISECONDS;
-        } else uiPoisonSprayTimer -= diff;
-
-        DoMeleeAttackIfReady();
+            if (!UpdateVictim())
+                return;
 
-    }
-};
-
-CreatureAI* GetAI_boss_krik_thir(Creature* pCreature)
-{
-    return new boss_krik_thirAI (pCreature);
-}
-
-CreatureAI* GetAI_npc_anub_ar_skirmisher (Creature* pCreature)
-{
-    return new npc_anub_ar_skirmisherAI (pCreature);
-}
+            if (uiWebWrapTimer <= diff)
+            {
+                if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                    DoCast(pTarget, SPELL_WEB_WRAP, true);
 
-CreatureAI* GetAI_npc_skittering_infector (Creature* pCreature)
-{
-    return new npc_skittering_infectorAI (pCreature);
-}
+                uiWebWrapTimer = 15*IN_MILLISECONDS;
+            } else uiWebWrapTimer -= diff;
 
-CreatureAI* GetAI_npc_anub_ar_shadowcaster (Creature* pCreature)
-{
-    return new npc_anub_ar_shadowcasterAI (pCreature);
-}
+            if (uiInfectedBiteTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_INFECTED_BITE, true);
+                uiInfectedBiteTimer = 15*IN_MILLISECONDS;
+            } else uiInfectedBiteTimer -= diff;
 
-CreatureAI* GetAI_npc_anub_ar_warrior (Creature* pCreature)
-{
-    return new npc_anub_ar_warriorAI (pCreature);
-}
+            if (uiPoisonSprayTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_POSION_SPRAY, true);
+                uiPoisonSprayTimer = 17*IN_MILLISECONDS;
+            } else uiPoisonSprayTimer -= diff;
 
-CreatureAI* GetAI_npc_watcher_gashra (Creature* pCreature)
-{
-    return new npc_watcher_gashraAI (pCreature);
-}
+            DoMeleeAttackIfReady();
 
-CreatureAI* GetAI_npc_watcher_narjil (Creature* pCreature)
-{
-    return new npc_watcher_narjilAI (pCreature);
-}
+        }
+    };
 
-CreatureAI* GetAI_npc_watcher_silthik (Creature* pCreature)
-{
-    return new npc_watcher_silthikAI (pCreature);
-}
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new npc_watcher_silthikAI(creature);
+    }
+};
 
 void AddSC_boss_krik_thir()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_krik_thir";
-    newscript->GetAI = &GetAI_boss_krik_thir;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "npc_skittering_infector";
-    newscript->GetAI = &GetAI_npc_skittering_infector;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "npc_anub_ar_skirmisher";
-    newscript->GetAI = &GetAI_npc_anub_ar_skirmisher;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "npc_anub_ar_shadowcaster";
-    newscript->GetAI = &GetAI_npc_anub_ar_shadowcaster;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "npc_watcher_gashra";
-    newscript->GetAI = &GetAI_npc_watcher_gashra;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "npc_anub_ar_warrior";
-    newscript->GetAI = &GetAI_npc_anub_ar_warrior;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "npc_watcher_silthik";
-    newscript->GetAI = &GetAI_npc_watcher_silthik;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "npc_watcher_narjil";
-    newscript->GetAI = &GetAI_npc_watcher_narjil;
-    newscript->RegisterSelf();
+    new boss_krik_thir;
+    new npc_skittering_infector;
+    new npc_anub_ar_skirmisher;
+    new npc_anub_ar_shadowcaster;
+    new npc_watcher_gashra;
+    new npc_anub_ar_warrior;
+    new npc_watcher_silthik;
+    new npc_watcher_narjil;
 }
diff --git a/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/instance_azjol_nerub.cpp b/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/instance_azjol_nerub.cpp
index 90f96b21af3..a845d609b61 100644
--- a/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/instance_azjol_nerub.cpp
+++ b/src/server/scripts/Northrend/AzjolNerub/AzjolNerub/instance_azjol_nerub.cpp
@@ -26,189 +26,191 @@
 2 - Anub'arak
 */
 
-struct instance_azjol_nerub : public ScriptedInstance
+class instance_azjol_nerub : public InstanceMapScript
 {
-    instance_azjol_nerub(Map* pMap) : ScriptedInstance(pMap) {Initialize();};
-
-    uint64 uiKrikthir;
-    uint64 uiHadronox;
-    uint64 uiAnubarak;
-    uint64 uiWatcherGashra;
-    uint64 uiWatcherSilthik;
-    uint64 uiWatcherNarjil;
-    uint64 uiAnubarakDoor[3];
-
-    uint64 uiKrikthirDoor;
-
-    uint32 auiEncounter[MAX_ENCOUNTER];
-
-   void Initialize()
-   {
-        memset(&auiEncounter, 0, sizeof(auiEncounter));
-        memset(&uiAnubarakDoor, 0, sizeof(uiAnubarakDoor));
-
-        uiKrikthir = 0;
-        uiHadronox = 0;
-        uiAnubarak = 0;
-        uiWatcherGashra = 0;
-        uiWatcherSilthik = 0;
-        uiWatcherNarjil = 0;
-        uiKrikthirDoor = 0;
-    }
+public:
+    instance_azjol_nerub() : InstanceMapScript("instance_azjol_nerub") { }
 
-    bool IsEncounterInProgress() const
+    struct instance_azjol_nerub_ScriptedInstance : public ScriptedInstance
     {
-        for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-            if (auiEncounter[i] == IN_PROGRESS) return true;
-
-        return false;
-    }
+        instance_azjol_nerub_ScriptedInstance(Map* pMap) : ScriptedInstance(pMap) {Initialize();};
+
+        uint64 uiKrikthir;
+        uint64 uiHadronox;
+        uint64 uiAnubarak;
+        uint64 uiWatcherGashra;
+        uint64 uiWatcherSilthik;
+        uint64 uiWatcherNarjil;
+        uint64 uiAnubarakDoor[3];
+
+        uint64 uiKrikthirDoor;
+
+        uint32 auiEncounter[MAX_ENCOUNTER];
+
+       void Initialize()
+       {
+            memset(&auiEncounter, 0, sizeof(auiEncounter));
+            memset(&uiAnubarakDoor, 0, sizeof(uiAnubarakDoor));
+
+            uiKrikthir = 0;
+            uiHadronox = 0;
+            uiAnubarak = 0;
+            uiWatcherGashra = 0;
+            uiWatcherSilthik = 0;
+            uiWatcherNarjil = 0;
+            uiKrikthirDoor = 0;
+        }
 
-    void OnCreatureCreate(Creature* pCreature, bool /*add*/)
-    {
-        switch(pCreature->GetEntry())
+        bool IsEncounterInProgress() const
         {
-            case 28684:    uiKrikthir = pCreature->GetGUID();        break;
-            case 28921:    uiHadronox = pCreature->GetGUID();        break;
-            case 29120:    uiAnubarak = pCreature->GetGUID();        break;
-            case 28730:    uiWatcherGashra = pCreature->GetGUID();   break;
-            case 28731:    uiWatcherSilthik = pCreature->GetGUID();  break;
-            case 28729:    uiWatcherNarjil = pCreature->GetGUID();   break;
+            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
+                if (auiEncounter[i] == IN_PROGRESS) return true;
+
+            return false;
         }
-    }
 
-    void OnGameObjectCreate(GameObject* pGo, bool /*add*/)
-    {
-        switch (pGo->GetEntry())
+        void OnCreatureCreate(Creature* pCreature, bool /*add*/)
         {
-            case 192395:
-                uiKrikthirDoor = pGo->GetGUID();
-                if (auiEncounter[0] == DONE)
-                    HandleGameObject(NULL,true,pGo);
-                break;
-            case 192396:
-                uiAnubarakDoor[0] = pGo->GetGUID();
-                break;
-            case 192397:
-                uiAnubarakDoor[1] = pGo->GetGUID();
-                break;
-            case 192398:
-                uiAnubarakDoor[2] = pGo->GetGUID();
-                break;
+            switch(pCreature->GetEntry())
+            {
+                case 28684:    uiKrikthir = pCreature->GetGUID();        break;
+                case 28921:    uiHadronox = pCreature->GetGUID();        break;
+                case 29120:    uiAnubarak = pCreature->GetGUID();        break;
+                case 28730:    uiWatcherGashra = pCreature->GetGUID();   break;
+                case 28731:    uiWatcherSilthik = pCreature->GetGUID();  break;
+                case 28729:    uiWatcherNarjil = pCreature->GetGUID();   break;
+            }
         }
-    }
 
-
-    uint64 GetData64(uint32 identifier)
-    {
-        switch(identifier)
+        void OnGameObjectCreate(GameObject* pGo, bool /*add*/)
         {
-            case DATA_KRIKTHIR_THE_GATEWATCHER:     return uiKrikthir;
-            case DATA_HADRONOX:                     return uiHadronox;
-            case DATA_ANUBARAK:                     return uiAnubarak;
-            case DATA_WATCHER_GASHRA:               return uiWatcherGashra;
-            case DATA_WATCHER_SILTHIK:              return uiWatcherSilthik;
-            case DATA_WATCHER_NARJIL:               return uiWatcherNarjil;
+            switch (pGo->GetEntry())
+            {
+                case 192395:
+                    uiKrikthirDoor = pGo->GetGUID();
+                    if (auiEncounter[0] == DONE)
+                        HandleGameObject(NULL,true,pGo);
+                    break;
+                case 192396:
+                    uiAnubarakDoor[0] = pGo->GetGUID();
+                    break;
+                case 192397:
+                    uiAnubarakDoor[1] = pGo->GetGUID();
+                    break;
+                case 192398:
+                    uiAnubarakDoor[2] = pGo->GetGUID();
+                    break;
+            }
         }
 
-        return 0;
-    }
 
-    void SetData(uint32 type, uint32 data)
-    {
-        switch(type)
+        uint64 GetData64(uint32 identifier)
         {
-        case DATA_KRIKTHIR_THE_GATEWATCHER_EVENT:
-            auiEncounter[0] = data;
-            if (data == DONE)
-                HandleGameObject(uiKrikthirDoor,true);
-            break;
-        case DATA_HADRONOX_EVENT:
-            auiEncounter[1] = data;
-            break;
-        case DATA_ANUBARAK_EVENT:
-            auiEncounter[2] = data;
-            if (data == IN_PROGRESS)
-                for (uint8 i = 0; i < 3; ++i)
-                    HandleGameObject(uiAnubarakDoor[i], false);
-            else if (data == NOT_STARTED || data == DONE) 
-                for (uint8 i = 0; i < 3; ++i)
-                    HandleGameObject(uiAnubarakDoor[i], true);
-            break;
+            switch(identifier)
+            {
+                case DATA_KRIKTHIR_THE_GATEWATCHER:     return uiKrikthir;
+                case DATA_HADRONOX:                     return uiHadronox;
+                case DATA_ANUBARAK:                     return uiAnubarak;
+                case DATA_WATCHER_GASHRA:               return uiWatcherGashra;
+                case DATA_WATCHER_SILTHIK:              return uiWatcherSilthik;
+                case DATA_WATCHER_NARJIL:               return uiWatcherNarjil;
+            }
+
+            return 0;
         }
 
-        if (data == DONE)
+        void SetData(uint32 type, uint32 data)
         {
-            SaveToDB();
+            switch(type)
+            {
+            case DATA_KRIKTHIR_THE_GATEWATCHER_EVENT:
+                auiEncounter[0] = data;
+                if (data == DONE)
+                    HandleGameObject(uiKrikthirDoor,true);
+                break;
+            case DATA_HADRONOX_EVENT:
+                auiEncounter[1] = data;
+                break;
+            case DATA_ANUBARAK_EVENT:
+                auiEncounter[2] = data;
+                if (data == IN_PROGRESS)
+                    for (uint8 i = 0; i < 3; ++i)
+                        HandleGameObject(uiAnubarakDoor[i], false);
+                else if (data == NOT_STARTED || data == DONE) 
+                    for (uint8 i = 0; i < 3; ++i)
+                        HandleGameObject(uiAnubarakDoor[i], true);
+                break;
+            }
+
+            if (data == DONE)
+            {
+                SaveToDB();
+            }
         }
-    }
 
-    uint32 GetData(uint32 type)
-    {
-        switch(type)
+        uint32 GetData(uint32 type)
         {
-            case DATA_KRIKTHIR_THE_GATEWATCHER_EVENT:   return auiEncounter[0];
-            case DATA_HADRONOX_EVENT:                   return auiEncounter[1];
-            case DATA_ANUBARAK_EVENT:                   return auiEncounter[2];
+            switch(type)
+            {
+                case DATA_KRIKTHIR_THE_GATEWATCHER_EVENT:   return auiEncounter[0];
+                case DATA_HADRONOX_EVENT:                   return auiEncounter[1];
+                case DATA_ANUBARAK_EVENT:                   return auiEncounter[2];
+            }
+
+            return 0;
         }
 
-        return 0;
-    }
-
-   std::string GetSaveData()
-    {
-        OUT_SAVE_INST_DATA;
+       std::string GetSaveData()
+        {
+            OUT_SAVE_INST_DATA;
 
-        std::ostringstream saveStream;
-        saveStream << "A N " << auiEncounter[0] << " " << auiEncounter[1] << " "
-            << auiEncounter[2];
+            std::ostringstream saveStream;
+            saveStream << "A N " << auiEncounter[0] << " " << auiEncounter[1] << " "
+                << auiEncounter[2];
 
-        OUT_SAVE_INST_DATA_COMPLETE;
-        return saveStream.str();
-    }
+            OUT_SAVE_INST_DATA_COMPLETE;
+            return saveStream.str();
+        }
 
-    void Load(const char* in)
-    {
-        if (!in)
+        void Load(const char* in)
         {
-            OUT_LOAD_INST_DATA_FAIL;
-            return;
-        }
+            if (!in)
+            {
+                OUT_LOAD_INST_DATA_FAIL;
+                return;
+            }
 
-        OUT_LOAD_INST_DATA(in);
+            OUT_LOAD_INST_DATA(in);
 
-        char dataHead1, dataHead2;
-        uint16 data0,data1,data2;
+            char dataHead1, dataHead2;
+            uint16 data0,data1,data2;
 
-        std::istringstream loadStream(in);
-        loadStream >> dataHead1 >> dataHead2 >> data0 >> data1 >> data2;
+            std::istringstream loadStream(in);
+            loadStream >> dataHead1 >> dataHead2 >> data0 >> data1 >> data2;
 
-        if (dataHead1 == 'A' && dataHead2 == 'N')
-        {
-            auiEncounter[0] = data0;
-            auiEncounter[1] = data1;
-            auiEncounter[2] = data2;
+            if (dataHead1 == 'A' && dataHead2 == 'N')
+            {
+                auiEncounter[0] = data0;
+                auiEncounter[1] = data1;
+                auiEncounter[2] = data2;
 
-            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-                if (auiEncounter[i] == IN_PROGRESS)
-                    auiEncounter[i] = NOT_STARTED;
+                for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
+                    if (auiEncounter[i] == IN_PROGRESS)
+                        auiEncounter[i] = NOT_STARTED;
+
+            } else OUT_LOAD_INST_DATA_FAIL;
 
-        } else OUT_LOAD_INST_DATA_FAIL;
+            OUT_LOAD_INST_DATA_COMPLETE;
+        }
+    };
 
-        OUT_LOAD_INST_DATA_COMPLETE;
+    InstanceData* GetInstanceData(InstanceMap *map) const
+    {
+        return new instance_azjol_nerub_ScriptedInstance(map);
     }
 };
 
-InstanceData* GetInstanceData_instance_azjol_nerub(Map* pMap)
-{
-   return new instance_azjol_nerub(pMap);
-}
-
 void AddSC_instance_azjol_nerub()
 {
-   Script *newscript;
-   newscript = new Script;
-   newscript->Name = "instance_azjol_nerub";
-   newscript->GetInstanceData = &GetInstanceData_instance_azjol_nerub;
-   newscript->RegisterSelf();
+   new instance_azjol_nerub;
 }
diff --git a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_amanitar.cpp b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_amanitar.cpp
index ee5dc6b297f..1bf1fcdfdf0 100644
--- a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_amanitar.cpp
+++ b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_amanitar.cpp
@@ -41,185 +41,188 @@ enum Creatures
     NPC_POISONOUS_MUSHROOM                        = 30435
 };
 
-struct boss_amanitarAI : public ScriptedAI
+class boss_amanitar : public CreatureScript
 {
-    boss_amanitarAI(Creature *c) : ScriptedAI(c)
+public:
+    boss_amanitar() : CreatureScript("boss_amanitar") { }
+
+    struct boss_amanitarAI : public ScriptedAI
     {
-        pInstance = c->GetInstanceData();
-        bFirstTime = true;
-    }
+        boss_amanitarAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+            bFirstTime = true;
+        }
 
-    ScriptedInstance* pInstance;
+        ScriptedInstance* pInstance;
 
-    uint32 uiRootTimer;
-    uint32 uiBashTimer;
-    uint32 uiBoltTimer;
-    uint32 uiSpawnTimer;
+        uint32 uiRootTimer;
+        uint32 uiBashTimer;
+        uint32 uiBoltTimer;
+        uint32 uiSpawnTimer;
 
-    bool bFirstTime;
+        bool bFirstTime;
 
-    void Reset()
-    {
-        uiRootTimer = urand(5*IN_MILLISECONDS,9*IN_MILLISECONDS);
-        uiBashTimer = urand(10*IN_MILLISECONDS,14*IN_MILLISECONDS);
-        uiBoltTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
-        uiSpawnTimer = 0;
+        void Reset()
+        {
+            uiRootTimer = urand(5*IN_MILLISECONDS,9*IN_MILLISECONDS);
+            uiBashTimer = urand(10*IN_MILLISECONDS,14*IN_MILLISECONDS);
+            uiBoltTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
+            uiSpawnTimer = 0;
 
-        me->SetMeleeDamageSchool(SPELL_SCHOOL_NATURE);
-        me->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_NATURE, true);
+            me->SetMeleeDamageSchool(SPELL_SCHOOL_NATURE);
+            me->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_NATURE, true);
 
-        if (pInstance)
-        {
-            pInstance->DoRemoveAurasDueToSpellOnPlayers(SPELL_MINI);
-            if (!bFirstTime)
-                pInstance->SetData(DATA_AMANITAR_EVENT, FAIL);
-            else
-                bFirstTime = false;
+            if (pInstance)
+            {
+                pInstance->DoRemoveAurasDueToSpellOnPlayers(SPELL_MINI);
+                if (!bFirstTime)
+                    pInstance->SetData(DATA_AMANITAR_EVENT, FAIL);
+                else
+                    bFirstTime = false;
+            }
         }
-    }
 
-    void JustDied(Unit * /*Killer*/)
-    {
-        if (pInstance)
+        void JustDied(Unit * /*Killer*/)
         {
-            pInstance->SetData(DATA_AMANITAR_EVENT, DONE);
-            pInstance->DoRemoveAurasDueToSpellOnPlayers(SPELL_MINI);
+            if (pInstance)
+            {
+                pInstance->SetData(DATA_AMANITAR_EVENT, DONE);
+                pInstance->DoRemoveAurasDueToSpellOnPlayers(SPELL_MINI);
+            }
         }
-    }
 
-    void EnterCombat(Unit * /*who*/)
-    {
-        if (pInstance)
-            pInstance->SetData(DATA_AMANITAR_EVENT, IN_PROGRESS);
+        void EnterCombat(Unit * /*who*/)
+        {
+            if (pInstance)
+                pInstance->SetData(DATA_AMANITAR_EVENT, IN_PROGRESS);
 
-        DoCast(me, SPELL_MINI, false);
-    }
+            DoCast(me, SPELL_MINI, false);
+        }
 
-    void SpawnAdds()
-    {
-        for (uint8 i = 0; i < 30; ++i)
+        void SpawnAdds()
         {
-            Unit* victim = SelectUnit(SELECT_TARGET_RANDOM, 0);
-
-            if (victim)
+            for (uint8 i = 0; i < 30; ++i)
             {
-                Position pos;
-                victim->GetPosition(&pos);
-                me->GetRandomNearPosition(pos, float(urand(5,80)));
-                me->SummonCreature(NPC_POISONOUS_MUSHROOM, pos, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 30*IN_MILLISECONDS);
-                me->GetRandomNearPosition(pos, float(urand(5,80)));
-                me->SummonCreature(NPC_HEALTHY_MUSHROOM, pos, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 30*IN_MILLISECONDS);
+                Unit* victim = SelectUnit(SELECT_TARGET_RANDOM, 0);
+
+                if (victim)
+                {
+                    Position pos;
+                    victim->GetPosition(&pos);
+                    me->GetRandomNearPosition(pos, float(urand(5,80)));
+                    me->SummonCreature(NPC_POISONOUS_MUSHROOM, pos, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 30*IN_MILLISECONDS);
+                    me->GetRandomNearPosition(pos, float(urand(5,80)));
+                    me->SummonCreature(NPC_HEALTHY_MUSHROOM, pos, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 30*IN_MILLISECONDS);
+                }
             }
         }
-    }
 
-    void UpdateAI(const uint32 diff)
-    {
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
-
-        if (uiSpawnTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            SpawnAdds();
-            uiSpawnTimer = urand(35*IN_MILLISECONDS,40*IN_MILLISECONDS);
-        } else uiSpawnTimer -= diff;
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
 
-        if (uiRootTimer <= diff)
-        {
-            if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                DoCast(pTarget, SPELL_ENTANGLING_ROOTS);
-            uiRootTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
-        } else uiRootTimer -= diff;
+            if (uiSpawnTimer <= diff)
+            {
+                SpawnAdds();
+                uiSpawnTimer = urand(35*IN_MILLISECONDS,40*IN_MILLISECONDS);
+            } else uiSpawnTimer -= diff;
 
-        if (uiBashTimer <= diff)
-        {
-            DoCastVictim(SPELL_BASH);
-            uiBashTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
-        } else uiBashTimer -= diff;
+            if (uiRootTimer <= diff)
+            {
+                if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                    DoCast(pTarget, SPELL_ENTANGLING_ROOTS);
+                uiRootTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
+            } else uiRootTimer -= diff;
 
-        if (uiBoltTimer <= diff)
-        {
-            if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                DoCast(pTarget, SPELL_VENOM_BOLT_VOLLEY);
-            uiBoltTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
-        } else uiBoltTimer -= diff;
+            if (uiBashTimer <= diff)
+            {
+                DoCastVictim(SPELL_BASH);
+                uiBashTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
+            } else uiBashTimer -= diff;
+
+            if (uiBoltTimer <= diff)
+            {
+                if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                    DoCast(pTarget, SPELL_VENOM_BOLT_VOLLEY);
+                uiBoltTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
+            } else uiBoltTimer -= diff;
 
-        DoMeleeAttackIfReady();
+            DoMeleeAttackIfReady();
+        }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new boss_amanitarAI(creature);
     }
 };
 
-struct mob_amanitar_mushroomsAI : public Scripted_NoMovementAI
+class mob_amanitar_mushrooms : public CreatureScript
 {
-    mob_amanitar_mushroomsAI(Creature* c) : Scripted_NoMovementAI(c) {}
-
-    uint32 uiAuraTimer;
-    uint32 uiDeathTimer;
+public:
+    mob_amanitar_mushrooms() : CreatureScript("mob_amanitar_mushrooms") { }
 
-    void Reset()
+    struct mob_amanitar_mushroomsAI : public Scripted_NoMovementAI
     {
-        DoCast(me, SPELL_PUTRID_MUSHROOM, true); // Hack, to make the mushrooms visible, can't find orig. spell...
+        mob_amanitar_mushroomsAI(Creature* c) : Scripted_NoMovementAI(c) {}
 
-        if (me->GetEntry() == NPC_POISONOUS_MUSHROOM)
-            DoCast(me, SPELL_POISONOUS_MUSHROOM_VISUAL_AURA, true);
+        uint32 uiAuraTimer;
+        uint32 uiDeathTimer;
 
-        uiAuraTimer = 0;
-        uiDeathTimer = 30*IN_MILLISECONDS;
-    }
+        void Reset()
+        {
+            DoCast(me, SPELL_PUTRID_MUSHROOM, true); // Hack, to make the mushrooms visible, can't find orig. spell...
 
-    void JustDied(Unit *killer)
-    {
-        if (!killer)
-            return;
+            if (me->GetEntry() == NPC_POISONOUS_MUSHROOM)
+                DoCast(me, SPELL_POISONOUS_MUSHROOM_VISUAL_AURA, true);
 
-        if (me->GetEntry() == NPC_HEALTHY_MUSHROOM && killer->GetTypeId() == TYPEID_PLAYER)
+            uiAuraTimer = 0;
+            uiDeathTimer = 30*IN_MILLISECONDS;
+        }
+
+        void JustDied(Unit *killer)
         {
-            me->InterruptNonMeleeSpells(false);
-            DoCast(killer, SPELL_HEALTHY_MUSHROOM_POTENT_FUNGUS, false);
+            if (!killer)
+                return;
+
+            if (me->GetEntry() == NPC_HEALTHY_MUSHROOM && killer->GetTypeId() == TYPEID_PLAYER)
+            {
+                me->InterruptNonMeleeSpells(false);
+                DoCast(killer, SPELL_HEALTHY_MUSHROOM_POTENT_FUNGUS, false);
+            }
         }
-    }
 
-    void EnterCombat(Unit * /*who*/) {}
-    void AttackStart(Unit * /*victim*/) {}
+        void EnterCombat(Unit * /*who*/) {}
+        void AttackStart(Unit * /*victim*/) {}
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (me->GetEntry() == NPC_POISONOUS_MUSHROOM)
+        void UpdateAI(const uint32 diff)
         {
-            if (uiAuraTimer <= diff)
+            if (me->GetEntry() == NPC_POISONOUS_MUSHROOM)
             {
-                DoCast(me, SPELL_POISONOUS_MUSHROOM_VISUAL_AREA, true);
-                DoCast(me, SPELL_POISONOUS_MUSHROOM_POISON_CLOUD, false);
-                uiAuraTimer = 7*IN_MILLISECONDS;
-            } else uiAuraTimer -= diff;
+                if (uiAuraTimer <= diff)
+                {
+                    DoCast(me, SPELL_POISONOUS_MUSHROOM_VISUAL_AREA, true);
+                    DoCast(me, SPELL_POISONOUS_MUSHROOM_POISON_CLOUD, false);
+                    uiAuraTimer = 7*IN_MILLISECONDS;
+                } else uiAuraTimer -= diff;
+            }
+            if (uiDeathTimer <= diff)
+                me->DisappearAndDie();
+            else uiDeathTimer -= diff;
         }
-        if (uiDeathTimer <= diff)
-            me->DisappearAndDie();
-        else uiDeathTimer -= diff;
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_amanitar_mushroomsAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_amanitar(Creature* pCreature)
-{
-    return new boss_amanitarAI (pCreature);
-}
-
-CreatureAI* GetAI_mob_amanitar_mushrooms(Creature *pCreature)
-{
-    return new mob_amanitar_mushroomsAI (pCreature);
-}
-
 void AddSC_boss_amanitar()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_amanitar";
-    newscript->GetAI = &GetAI_boss_amanitar;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "mob_amanitar_mushrooms";
-    newscript->GetAI = &GetAI_mob_amanitar_mushrooms;
-    newscript->RegisterSelf();
+    new boss_amanitar;
+    new mob_amanitar_mushrooms;
 }
diff --git a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_elder_nadox.cpp b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_elder_nadox.cpp
index 05c868708f2..c9259da2298 100644
--- a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_elder_nadox.cpp
+++ b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_elder_nadox.cpp
@@ -55,228 +55,233 @@ enum Creatures
 
 #define EMOTE_HATCHES                       "An Ahn'kahar Guardian hatches!"
 
-struct boss_elder_nadoxAI : public ScriptedAI
+class boss_elder_nadox : public CreatureScript
 {
-    boss_elder_nadoxAI(Creature *c) : ScriptedAI(c)
-    {
-        pInstance = c->GetInstanceData();
-    }
-
-    uint32 uiPlagueTimer;
-    uint32 uiRagueTimer;
+public:
+    boss_elder_nadox() : CreatureScript("boss_elder_nadox") { }
 
-    uint32 uiSwarmerSpawnTimer;
-    uint32 uiGuardSpawnTimer;
-    uint32 uiEnragueTimer;
+    struct boss_elder_nadoxAI : public ScriptedAI
+    {
+        boss_elder_nadoxAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-    bool bGuardSpawned;
+        uint32 uiPlagueTimer;
+        uint32 uiRagueTimer;
 
-    ScriptedInstance *pInstance;
+        uint32 uiSwarmerSpawnTimer;
+        uint32 uiGuardSpawnTimer;
+        uint32 uiEnragueTimer;
 
-    void Reset()
-    {
-        uiPlagueTimer = 13*IN_MILLISECONDS;
-        uiRagueTimer = 20*IN_MILLISECONDS;
+        bool bGuardSpawned;
 
-        uiSwarmerSpawnTimer = 10*IN_MILLISECONDS;
-        uiGuardSpawnTimer = 25*IN_MILLISECONDS;
+        ScriptedInstance *pInstance;
 
-        uiEnragueTimer = 5*IN_MILLISECONDS;
+        void Reset()
+        {
+            uiPlagueTimer = 13*IN_MILLISECONDS;
+            uiRagueTimer = 20*IN_MILLISECONDS;
 
-        DeadAhnkaharGuardian = false;
-        bGuardSpawned = false;
+            uiSwarmerSpawnTimer = 10*IN_MILLISECONDS;
+            uiGuardSpawnTimer = 25*IN_MILLISECONDS;
 
-        if (pInstance)
-            pInstance->SetData(DATA_ELDER_NADOX_EVENT, NOT_STARTED);
-    }
+            uiEnragueTimer = 5*IN_MILLISECONDS;
 
-    void EnterCombat(Unit * /*who*/)
-    {
-        DoScriptText(SAY_DEATH,me);
+            DeadAhnkaharGuardian = false;
+            bGuardSpawned = false;
 
-        if (pInstance)
-            pInstance->SetData(DATA_ELDER_NADOX_EVENT, IN_PROGRESS);
-    }
+            if (pInstance)
+                pInstance->SetData(DATA_ELDER_NADOX_EVENT, NOT_STARTED);
+        }
 
-    void KilledUnit(Unit * /*victim*/)
-    {
-        DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2,SAY_SLAY_3), me);
-    }
+        void EnterCombat(Unit * /*who*/)
+        {
+            DoScriptText(SAY_DEATH,me);
 
-    void JustDied(Unit* /*killer*/)
-    {
-        DoScriptText(SAY_SLAY_3,me); //SAY_SLAY_3 on death?
+            if (pInstance)
+                pInstance->SetData(DATA_ELDER_NADOX_EVENT, IN_PROGRESS);
+        }
 
-        if (pInstance)
+        void KilledUnit(Unit * /*victim*/)
         {
-            pInstance->SetData(DATA_ELDER_NADOX_EVENT, DONE);
-            if (IsHeroic() && !DeadAhnkaharGuardian)
-                pInstance->DoCompleteAchievement(ACHIEV_RESPECT_YOUR_ELDERS);
+            DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2,SAY_SLAY_3), me);
         }
-    }
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
+        void JustDied(Unit* /*killer*/)
+        {
+            DoScriptText(SAY_SLAY_3,me); //SAY_SLAY_3 on death?
+
+            if (pInstance)
+            {
+                pInstance->SetData(DATA_ELDER_NADOX_EVENT, DONE);
+                if (IsHeroic() && !DeadAhnkaharGuardian)
+                    pInstance->DoCompleteAchievement(ACHIEV_RESPECT_YOUR_ELDERS);
+            }
+        }
 
-        if (uiPlagueTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            DoCast(me->getVictim(), SPELL_BROOD_PLAGUE);
-            uiPlagueTimer = 15*IN_MILLISECONDS;
-        } else uiPlagueTimer -= diff;
+            if (!UpdateVictim())
+                return;
 
-        if (IsHeroic())
-            if (uiRagueTimer <= diff)
+            if (uiPlagueTimer <= diff)
             {
-                if (Creature *pSwarmer = me->FindNearestCreature(MOB_AHNKAHAR_SWARMER, 35))
+                DoCast(me->getVictim(), SPELL_BROOD_PLAGUE);
+                uiPlagueTimer = 15*IN_MILLISECONDS;
+            } else uiPlagueTimer -= diff;
+
+            if (IsHeroic())
+                if (uiRagueTimer <= diff)
                 {
-                    DoCast(pSwarmer, H_SPELL_BROOD_RAGE, true);
-                    uiRagueTimer = 15*IN_MILLISECONDS;
-                }
-            } else uiRagueTimer -= diff;
+                    if (Creature *pSwarmer = me->FindNearestCreature(MOB_AHNKAHAR_SWARMER, 35))
+                    {
+                        DoCast(pSwarmer, H_SPELL_BROOD_RAGE, true);
+                        uiRagueTimer = 15*IN_MILLISECONDS;
+                    }
+                } else uiRagueTimer -= diff;
+
+            if (uiSwarmerSpawnTimer <= diff)
+            {
+                DoCast(me, SPELL_SUMMON_SWARMERS, true);
+                DoCast(me, SPELL_SUMMON_SWARMERS);
+                if (urand(1,3) == 3) // 33% chance of dialog
+                    DoScriptText(RAND(SAY_EGG_SAC_1,SAY_EGG_SAC_2), me);
 
-        if (uiSwarmerSpawnTimer <= diff)
-        {
-            DoCast(me, SPELL_SUMMON_SWARMERS, true);
-            DoCast(me, SPELL_SUMMON_SWARMERS);
-            if (urand(1,3) == 3) // 33% chance of dialog
-                DoScriptText(RAND(SAY_EGG_SAC_1,SAY_EGG_SAC_2), me);
+                uiSwarmerSpawnTimer = 10*IN_MILLISECONDS;
+            } else uiSwarmerSpawnTimer -= diff;
 
-            uiSwarmerSpawnTimer = 10*IN_MILLISECONDS;
-        } else uiSwarmerSpawnTimer -= diff;
+            if (!bGuardSpawned && uiGuardSpawnTimer <= diff)
+            {
+                me->MonsterTextEmote(EMOTE_HATCHES,me->GetGUID(),true);
+                DoCast(me, SPELL_SUMMON_SWARM_GUARD);
+                bGuardSpawned = true;
+            } else uiGuardSpawnTimer -= diff;
 
-        if (!bGuardSpawned && uiGuardSpawnTimer <= diff)
-        {
-            me->MonsterTextEmote(EMOTE_HATCHES,me->GetGUID(),true);
-            DoCast(me, SPELL_SUMMON_SWARM_GUARD);
-            bGuardSpawned = true;
-        } else uiGuardSpawnTimer -= diff;
+            if (uiEnragueTimer <= diff)
+            {
+                if (me->HasAura(SPELL_ENRAGE,0))
+                    return;
 
-        if (uiEnragueTimer <= diff)
-        {
-            if (me->HasAura(SPELL_ENRAGE,0))
-                return;
+                float x, y, z, o;
+                me->GetHomePosition(x, y, z, o);
+                if (z < 24)
+                    if (!me->IsNonMeleeSpellCasted(false))
+                        DoCast(me, SPELL_ENRAGE, true);
 
-            float x, y, z, o;
-            me->GetHomePosition(x, y, z, o);
-            if (z < 24)
-                if (!me->IsNonMeleeSpellCasted(false))
-                    DoCast(me, SPELL_ENRAGE, true);
+                uiEnragueTimer = 5*IN_MILLISECONDS;
+            } else uiEnragueTimer -= diff;
 
-            uiEnragueTimer = 5*IN_MILLISECONDS;
-        } else uiEnragueTimer -= diff;
+            DoMeleeAttackIfReady();
+        }
+    };
 
-        DoMeleeAttackIfReady();
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new boss_elder_nadoxAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_elder_nadox(Creature* pCreature)
-{
-    return new boss_elder_nadoxAI(pCreature);
-}
-
 enum AddSpells
 {
     SPELL_SPRINT                                  = 56354,
     SPELL_GUARDIAN_AURA                           = 56151
 };
 
-struct mob_ahnkahar_nerubianAI : public ScriptedAI
+class mob_ahnkahar_nerubian : public CreatureScript
 {
-    mob_ahnkahar_nerubianAI(Creature *c) : ScriptedAI(c)
-    {
-        pInstance = c->GetInstanceData();
-    }
-
-    ScriptedInstance *pInstance;
-    uint32 uiSprintTimer;
+public:
+    mob_ahnkahar_nerubian() : CreatureScript("mob_ahnkahar_nerubian") { }
 
-    void Reset()
+    struct mob_ahnkahar_nerubianAI : public ScriptedAI
     {
-        if (me->GetEntry() == MOB_AHNKAHAR_GUARDIAN_ENTRY) //magic numbers are bad!
-            DoCast(me, SPELL_GUARDIAN_AURA, true);
-        uiSprintTimer = 10*IN_MILLISECONDS;
-    }
+        mob_ahnkahar_nerubianAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-    void JustDied(Unit * /*killer*/)
-    {
-        if (me->GetEntry() == MOB_AHNKAHAR_GUARDIAN_ENTRY)
-            DeadAhnkaharGuardian = true;
-    }
+        ScriptedInstance *pInstance;
+        uint32 uiSprintTimer;
 
-    void EnterCombat(Unit * /*who*/){}
+        void Reset()
+        {
+            if (me->GetEntry() == MOB_AHNKAHAR_GUARDIAN_ENTRY) //magic numbers are bad!
+                DoCast(me, SPELL_GUARDIAN_AURA, true);
+            uiSprintTimer = 10*IN_MILLISECONDS;
+        }
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
+        void JustDied(Unit * /*killer*/)
+        {
+            if (me->GetEntry() == MOB_AHNKAHAR_GUARDIAN_ENTRY)
+                DeadAhnkaharGuardian = true;
+        }
 
-        if (me->GetEntry() == MOB_AHNKAHAR_GUARDIAN_ENTRY)
-            me->RemoveAurasDueToSpell(SPELL_GUARDIAN_AURA);
+        void EnterCombat(Unit * /*who*/){}
 
-        if (pInstance)
+        void UpdateAI(const uint32 diff)
         {
-            if (pInstance->GetData(DATA_ELDER_NADOX_EVENT) != IN_PROGRESS)
+            if (!UpdateVictim())
+                return;
+
+            if (me->GetEntry() == MOB_AHNKAHAR_GUARDIAN_ENTRY)
+                me->RemoveAurasDueToSpell(SPELL_GUARDIAN_AURA);
+
+            if (pInstance)
             {
-                me->DisappearAndDie();
+                if (pInstance->GetData(DATA_ELDER_NADOX_EVENT) != IN_PROGRESS)
+                {
+                    me->DisappearAndDie();
+                }
             }
-        }
 
-        if (!UpdateVictim())
-            return;
+            if (!UpdateVictim())
+                return;
 
-        if (uiSprintTimer <= diff)
-        {
-            DoCast(me, SPELL_SPRINT);
-            uiSprintTimer = 25*IN_MILLISECONDS;
-        } else uiSprintTimer -= diff;
+            if (uiSprintTimer <= diff)
+            {
+                DoCast(me, SPELL_SPRINT);
+                uiSprintTimer = 25*IN_MILLISECONDS;
+            } else uiSprintTimer -= diff;
+
+            DoMeleeAttackIfReady();
+        }
+    };
 
-        DoMeleeAttackIfReady();
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_ahnkahar_nerubianAI(creature);
     }
 };
 
 //HACK: No, AI. Replace with proper db content?
-struct mob_nadox_eggsAI : public Scripted_NoMovementAI
+class mob_nadox_eggs : public CreatureScript
 {
-    mob_nadox_eggsAI(Creature* c) : Scripted_NoMovementAI(c)
+public:
+    mob_nadox_eggs() : CreatureScript("mob_nadox_eggs") { }
+
+    struct mob_nadox_eggsAI : public Scripted_NoMovementAI
     {
-        c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE);
-        c->UpdateAllStats();
+        mob_nadox_eggsAI(Creature* c) : Scripted_NoMovementAI(c)
+        {
+            c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE);
+            c->UpdateAllStats();
+        }
+        void Reset() {}
+        void EnterCombat(Unit* /*who*/) {}
+        void AttackStart(Unit* /*victim*/) {}
+        void MoveInLineOfSight(Unit* /*who*/) {}
+        void UpdateAI(const uint32 /*diff*/) {}
+    };
+
+    CreatureAI *GetAI(Creature* creature) const
+    {
+        return new mob_nadox_eggsAI(creature);
     }
-    void Reset() {}
-    void EnterCombat(Unit* /*who*/) {}
-    void AttackStart(Unit* /*victim*/) {}
-    void MoveInLineOfSight(Unit* /*who*/) {}
-    void UpdateAI(const uint32 /*diff*/) {}
 };
 
-CreatureAI* GetAI_mob_ahnkahar_nerubian(Creature* pCreature)
-{
-    return new mob_ahnkahar_nerubianAI(pCreature);
-}
-
-CreatureAI* GetAI_mob_nadox_eggs(Creature* _Creature)
-{
-    return new mob_nadox_eggsAI(_Creature);
-}
-
 void AddSC_boss_elder_nadox()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_elder_nadox";
-    newscript->GetAI = &GetAI_boss_elder_nadox;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "mob_ahnkahar_nerubian";
-    newscript->GetAI = &GetAI_mob_ahnkahar_nerubian;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "mob_nadox_eggs";
-    newscript->GetAI = &GetAI_mob_nadox_eggs;
-    newscript->RegisterSelf();
+    new boss_elder_nadox;
+    new mob_ahnkahar_nerubian;
+    new mob_nadox_eggs;
 }
diff --git a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_herald_volazj.cpp b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_herald_volazj.cpp
index 0e58217c584..4d7cb87a8d4 100644
--- a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_herald_volazj.cpp
+++ b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_herald_volazj.cpp
@@ -60,265 +60,266 @@ enum Achievements
     ACHIEV_QUICK_DEMISE_START_EVENT               = 20382,
 };
 
-struct boss_volazjAI : public ScriptedAI
+class boss_volazj : public CreatureScript
 {
-    boss_volazjAI(Creature* pCreature) : ScriptedAI(pCreature),Summons(me)
-    {
-        pInstance = pCreature->GetInstanceData();
-    }
-
-    ScriptedInstance *pInstance;
+public:
+    boss_volazj() : CreatureScript("boss_volazj") { }
 
-    uint32 uiMindFlayTimer;
-    uint32 uiShadowBoltVolleyTimer;
-    uint32 uiShiverTimer;
-    uint32 insanityHandled;
-    SummonList Summons;
-
-    // returns the percentage of health after taking the given damage.
-    uint32 GetHealthPct(uint32 damage)
+    struct boss_volazjAI : public ScriptedAI
     {
-        if (damage > me->GetHealth())
-            return 0;
-        return 100*(me->GetHealth()-damage)/me->GetMaxHealth();
-    }
+        boss_volazjAI(Creature* pCreature) : ScriptedAI(pCreature),Summons(me)
+        {
+            pInstance = pCreature->GetInstanceData();
+        }
 
-    void DamageTaken(Unit * /*pAttacker*/, uint32 &damage)
-    {
-        if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))
-            damage = 0;
+        ScriptedInstance *pInstance;
+
+        uint32 uiMindFlayTimer;
+        uint32 uiShadowBoltVolleyTimer;
+        uint32 uiShiverTimer;
+        uint32 insanityHandled;
+        SummonList Summons;
 
-        if ((GetHealthPct(0) >= 66 && GetHealthPct(damage) < 66)||
-            (GetHealthPct(0) >= 33 && GetHealthPct(damage) < 33))
+        // returns the percentage of health after taking the given damage.
+        uint32 GetHealthPct(uint32 damage)
         {
-            me->InterruptNonMeleeSpells(false);
-            DoCast(me, SPELL_INSANITY, false);
+            if (damage > me->GetHealth())
+                return 0;
+            return 100*(me->GetHealth()-damage)/me->GetMaxHealth();
         }
-    }
 
-    void SpellHitTarget(Unit *pTarget, const SpellEntry *spell)
-    {
-        if (spell->Id == SPELL_INSANITY)
+        void DamageTaken(Unit * /*pAttacker*/, uint32 &damage)
         {
-            // Not good target or too many players
-            if (pTarget->GetTypeId() != TYPEID_PLAYER || insanityHandled > 4)
-                return;
-            // First target - start channel visual and set self as unnattackable
-            if (!insanityHandled)
+            if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))
+                damage = 0;
+
+            if ((GetHealthPct(0) >= 66 && GetHealthPct(damage) < 66)||
+                (GetHealthPct(0) >= 33 && GetHealthPct(damage) < 33))
             {
-                // Channel visual
-                DoCast(me, INSANITY_VISUAL, true);
-                // Unattackable
-                me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-                me->SetControlled(true, UNIT_STAT_STUNNED);
+                me->InterruptNonMeleeSpells(false);
+                DoCast(me, SPELL_INSANITY, false);
             }
-            // phase mask
-            pTarget->CastSpell(pTarget, SPELL_INSANITY_TARGET+insanityHandled, true);
-            // summon twisted party members for this target
-            Map::PlayerList const &players = me->GetMap()->GetPlayers();
-            for (Map::PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
+        }
+
+        void SpellHitTarget(Unit *pTarget, const SpellEntry *spell)
+        {
+            if (spell->Id == SPELL_INSANITY)
             {
-                Player *plr = i->getSource();
-                if (!plr || !plr->isAlive())
-                    continue;
-                // Summon clone
-                if (Unit *summon = me->SummonCreature(MOB_TWISTED_VISAGE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation(),TEMPSUMMON_CORPSE_DESPAWN,0))
+                // Not good target or too many players
+                if (pTarget->GetTypeId() != TYPEID_PLAYER || insanityHandled > 4)
+                    return;
+                // First target - start channel visual and set self as unnattackable
+                if (!insanityHandled)
+                {
+                    // Channel visual
+                    DoCast(me, INSANITY_VISUAL, true);
+                    // Unattackable
+                    me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
+                    me->SetControlled(true, UNIT_STAT_STUNNED);
+                }
+                // phase mask
+                pTarget->CastSpell(pTarget, SPELL_INSANITY_TARGET+insanityHandled, true);
+                // summon twisted party members for this target
+                Map::PlayerList const &players = me->GetMap()->GetPlayers();
+                for (Map::PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
                 {
-                    // clone
-                    plr->CastSpell(summon, SPELL_CLONE_PLAYER, true);
-                    // set phase
-                    summon->SetPhaseMask((1<<(4+insanityHandled)),true);
+                    Player *plr = i->getSource();
+                    if (!plr || !plr->isAlive())
+                        continue;
+                    // Summon clone
+                    if (Unit *summon = me->SummonCreature(MOB_TWISTED_VISAGE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation(),TEMPSUMMON_CORPSE_DESPAWN,0))
+                    {
+                        // clone
+                        plr->CastSpell(summon, SPELL_CLONE_PLAYER, true);
+                        // set phase
+                        summon->SetPhaseMask((1<<(4+insanityHandled)),true);
+                    }
                 }
+                ++insanityHandled;
             }
-            ++insanityHandled;
         }
-    }
 
-    void ResetPlayersPhaseMask()
-    {
-        Map::PlayerList const &players = me->GetMap()->GetPlayers();
-        for (Map::PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
+        void ResetPlayersPhaseMask()
         {
-            Player* pPlayer = i->getSource();
-            pPlayer->RemoveAurasDueToSpell(GetSpellForPhaseMask(pPlayer->GetPhaseMask()));
+            Map::PlayerList const &players = me->GetMap()->GetPlayers();
+            for (Map::PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
+            {
+                Player* pPlayer = i->getSource();
+                pPlayer->RemoveAurasDueToSpell(GetSpellForPhaseMask(pPlayer->GetPhaseMask()));
+            }
         }
-    }
 
-    void Reset()
-    {
-        uiMindFlayTimer = 8*IN_MILLISECONDS;
-        uiShadowBoltVolleyTimer = 5*IN_MILLISECONDS;
-        uiShiverTimer = 15*IN_MILLISECONDS;
-
-        if (pInstance)
+        void Reset()
         {
-            pInstance->SetData(DATA_HERALD_VOLAZJ, NOT_STARTED);
-            pInstance->DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_QUICK_DEMISE_START_EVENT);
-        }
+            uiMindFlayTimer = 8*IN_MILLISECONDS;
+            uiShadowBoltVolleyTimer = 5*IN_MILLISECONDS;
+            uiShiverTimer = 15*IN_MILLISECONDS;
 
-        // Visible for all players in insanity
-        me->SetPhaseMask((1|16|32|64|128|256),true);
-        // Used for Insanity handling
-        insanityHandled = 0;
+            if (pInstance)
+            {
+                pInstance->SetData(DATA_HERALD_VOLAZJ, NOT_STARTED);
+                pInstance->DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_QUICK_DEMISE_START_EVENT);
+            }
 
-        ResetPlayersPhaseMask();
+            // Visible for all players in insanity
+            me->SetPhaseMask((1|16|32|64|128|256),true);
+            // Used for Insanity handling
+            insanityHandled = 0;
 
-        // Cleanup
-        Summons.DespawnAll();
-        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-    }
+            ResetPlayersPhaseMask();
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        DoScriptText(SAY_AGGRO, me);
+            // Cleanup
+            Summons.DespawnAll();
+            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
+        }
 
-        if (pInstance)
+        void EnterCombat(Unit* /*who*/)
         {
-            pInstance->SetData(DATA_HERALD_VOLAZJ, IN_PROGRESS);
-            pInstance->DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_QUICK_DEMISE_START_EVENT);
-        }
-    }
+            DoScriptText(SAY_AGGRO, me);
 
-    void JustSummoned(Creature *summon)
-    {
-        Summons.Summon(summon);
-    }
+            if (pInstance)
+            {
+                pInstance->SetData(DATA_HERALD_VOLAZJ, IN_PROGRESS);
+                pInstance->DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_QUICK_DEMISE_START_EVENT);
+            }
+        }
 
-    uint32 GetSpellForPhaseMask(uint32 phase)
-    {
-        uint32 spell = 0;
-        switch (phase)
+        void JustSummoned(Creature *summon)
         {
-            case 16:
-                spell = SPELL_INSANITY_PHASING_1;
-                break;
-            case 32:
-                spell = SPELL_INSANITY_PHASING_2;
-                break;
-            case 64:
-                spell = SPELL_INSANITY_PHASING_3;
-                break;
-            case 128:
-                spell = SPELL_INSANITY_PHASING_4;
-                break;
-            case 256:
-                spell = SPELL_INSANITY_PHASING_5;
-                break;
+            Summons.Summon(summon);
         }
-        return spell;
-    }
-
-    void SummonedCreatureDespawn(Creature *summon)
-    {
-        uint32 phase= summon->GetPhaseMask();
-        uint32 nextPhase = 0;
-        Summons.Despawn(summon);
 
-        // Check if all summons in this phase killed
-        for (SummonList::const_iterator iter = Summons.begin(); iter != Summons.end(); ++iter)
+        uint32 GetSpellForPhaseMask(uint32 phase)
         {
-            if (Creature *visage = Unit::GetCreature(*me, *iter))
+            uint32 spell = 0;
+            switch (phase)
             {
-                // Not all are dead
-                if (phase == visage->GetPhaseMask())
-                    return;
-                else
-                    nextPhase = visage->GetPhaseMask();
+                case 16:
+                    spell = SPELL_INSANITY_PHASING_1;
+                    break;
+                case 32:
+                    spell = SPELL_INSANITY_PHASING_2;
+                    break;
+                case 64:
+                    spell = SPELL_INSANITY_PHASING_3;
+                    break;
+                case 128:
+                    spell = SPELL_INSANITY_PHASING_4;
+                    break;
+                case 256:
+                    spell = SPELL_INSANITY_PHASING_5;
+                    break;
             }
+            return spell;
         }
 
-        // Roll Insanity
-        uint32 spell = GetSpellForPhaseMask(phase);
-        uint32 spell2 = GetSpellForPhaseMask(nextPhase);
-        Map* pMap = me->GetMap();
-        if (!pMap)
-            return;
-
-        Map::PlayerList const &PlayerList = pMap->GetPlayers();
-        if (!PlayerList.isEmpty())
+        void SummonedCreatureDespawn(Creature *summon)
         {
-            for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
+            uint32 phase= summon->GetPhaseMask();
+            uint32 nextPhase = 0;
+            Summons.Despawn(summon);
+
+            // Check if all summons in this phase killed
+            for (SummonList::const_iterator iter = Summons.begin(); iter != Summons.end(); ++iter)
+            {
+                if (Creature *visage = Unit::GetCreature(*me, *iter))
+                {
+                    // Not all are dead
+                    if (phase == visage->GetPhaseMask())
+                        return;
+                    else
+                        nextPhase = visage->GetPhaseMask();
+                }
+            }
+
+            // Roll Insanity
+            uint32 spell = GetSpellForPhaseMask(phase);
+            uint32 spell2 = GetSpellForPhaseMask(nextPhase);
+            Map* pMap = me->GetMap();
+            if (!pMap)
+                return;
+
+            Map::PlayerList const &PlayerList = pMap->GetPlayers();
+            if (!PlayerList.isEmpty())
             {
-                if (Player* pPlayer = i->getSource())
+                for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
                 {
-                    if (pPlayer->HasAura(spell))
+                    if (Player* pPlayer = i->getSource())
                     {
-                        pPlayer->RemoveAurasDueToSpell(spell);
-                        if (spell2) // if there is still some different mask cast spell for it
-                            pPlayer->CastSpell(pPlayer, spell2, true);
+                        if (pPlayer->HasAura(spell))
+                        {
+                            pPlayer->RemoveAurasDueToSpell(spell);
+                            if (spell2) // if there is still some different mask cast spell for it
+                                pPlayer->CastSpell(pPlayer, spell2, true);
+                        }
                     }
                 }
             }
         }
-    }
-
-    void UpdateAI(const uint32 diff)
-    {
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
 
-        if (insanityHandled)
+        void UpdateAI(const uint32 diff)
         {
-            if (!Summons.empty())
+            //Return since we have no target
+            if (!UpdateVictim())
                 return;
 
-            insanityHandled = 0;
-            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-            me->SetControlled(false, UNIT_STAT_STUNNED);
-            me->RemoveAurasDueToSpell(INSANITY_VISUAL);
-        }
+            if (insanityHandled)
+            {
+                if (!Summons.empty())
+                    return;
 
-        if (uiMindFlayTimer <= diff)
-        {
-            DoCast(me->getVictim(), SPELL_MIND_FLAY);
-            uiMindFlayTimer = 20*IN_MILLISECONDS;
-        } else uiMindFlayTimer -= diff;
+                insanityHandled = 0;
+                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
+                me->SetControlled(false, UNIT_STAT_STUNNED);
+                me->RemoveAurasDueToSpell(INSANITY_VISUAL);
+            }
 
-        if (uiShadowBoltVolleyTimer <= diff)
-        {
-            DoCast(me->getVictim(), SPELL_SHADOW_BOLT_VOLLEY);
-            uiShadowBoltVolleyTimer = 5*IN_MILLISECONDS;
-        } else uiShadowBoltVolleyTimer -= diff;
+            if (uiMindFlayTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_MIND_FLAY);
+                uiMindFlayTimer = 20*IN_MILLISECONDS;
+            } else uiMindFlayTimer -= diff;
 
-        if (uiShiverTimer <= diff)
-        {
-            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                DoCast(pTarget, SPELL_SHIVER);
-            uiShiverTimer = 15*IN_MILLISECONDS;
-        } else uiShiverTimer -= diff;
+            if (uiShadowBoltVolleyTimer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_SHADOW_BOLT_VOLLEY);
+                uiShadowBoltVolleyTimer = 5*IN_MILLISECONDS;
+            } else uiShadowBoltVolleyTimer -= diff;
 
-        DoMeleeAttackIfReady();
-    }
+            if (uiShiverTimer <= diff)
+            {
+                if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                    DoCast(pTarget, SPELL_SHIVER);
+                uiShiverTimer = 15*IN_MILLISECONDS;
+            } else uiShiverTimer -= diff;
 
-    void JustDied(Unit* /*killer*/)
-    {
-        DoScriptText(SAY_DEATH_1, me);
+            DoMeleeAttackIfReady();
+        }
 
-        if (pInstance)
-            pInstance->SetData(DATA_HERALD_VOLAZJ, DONE);
+        void JustDied(Unit* /*killer*/)
+        {
+            DoScriptText(SAY_DEATH_1, me);
 
-        Summons.DespawnAll();
-        ResetPlayersPhaseMask();
-    }
+            if (pInstance)
+                pInstance->SetData(DATA_HERALD_VOLAZJ, DONE);
+
+            Summons.DespawnAll();
+            ResetPlayersPhaseMask();
+        }
 
-    void KilledUnit(Unit * /*victim*/)
+        void KilledUnit(Unit * /*victim*/)
+        {
+            DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2,SAY_SLAY_3), me);
+        }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
     {
-        DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2,SAY_SLAY_3), me);
+        return new boss_volazjAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_volazj(Creature* pCreature)
-{
-    return new boss_volazjAI (pCreature);
-}
-
 void AddSC_boss_volazj()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_volazj";
-    newscript->GetAI = &GetAI_boss_volazj;
-    newscript->RegisterSelf();
+    new boss_volazj;
 }
diff --git a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_jedoga_shadowseeker.cpp b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_jedoga_shadowseeker.cpp
index 9fae4369acb..06f28d7d5f3 100644
--- a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_jedoga_shadowseeker.cpp
+++ b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_jedoga_shadowseeker.cpp
@@ -63,417 +63,426 @@ const Position JedogaPosition[2] =
     {372.330994f, -705.278015f, -16.179716f, 5.427970f}
 };
 
-struct boss_jedoga_shadowseekerAI : public ScriptedAI
+class boss_jedoga_shadowseeker : public CreatureScript
 {
-    boss_jedoga_shadowseekerAI(Creature* c) : ScriptedAI(c)
-    {
-        pInstance = c->GetInstanceData();
-        bFirstTime = true;
-        bPreDone = false;
-    }
-
-    ScriptedInstance* pInstance;
-
-    uint32 uiOpFerTimer;
-    uint32 uiCycloneTimer;
-    uint32 uiBoltTimer;
-    uint32 uiThunderTimer;
+public:
+    boss_jedoga_shadowseeker() : CreatureScript("boss_jedoga_shadowseeker") { }
 
-    bool bPreDone;
-    bool bOpFerok;
-    bool bOnGround;
-    bool bOpFerokFail;
-    bool bCanDown;
+    struct boss_jedoga_shadowseekerAI : public ScriptedAI
+    {
+        boss_jedoga_shadowseekerAI(Creature* c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+            bFirstTime = true;
+            bPreDone = false;
+        }
 
-    bool bFirstTime;
+        ScriptedInstance* pInstance;
 
-    void Reset()
-    {
-        uiOpFerTimer = urand(15*IN_MILLISECONDS,20*IN_MILLISECONDS);
+        uint32 uiOpFerTimer;
+        uint32 uiCycloneTimer;
+        uint32 uiBoltTimer;
+        uint32 uiThunderTimer;
 
-        uiCycloneTimer = 3*IN_MILLISECONDS;
-        uiBoltTimer = 7*IN_MILLISECONDS;
-        uiThunderTimer = 12*IN_MILLISECONDS;
+        bool bPreDone;
+        bool bOpFerok;
+        bool bOnGround;
+        bool bOpFerokFail;
+        bool bCanDown;
 
-        bOpFerok = false;
-        bOpFerokFail = false;
-        bOnGround = false;
-        bCanDown = false;
+        bool bFirstTime;
 
-        if (pInstance)
+        void Reset()
         {
-            if (!bFirstTime)
-                pInstance->SetData(DATA_JEDOGA_SHADOWSEEKER_EVENT, FAIL);
-
-            pInstance->SetData64(DATA_PL_JEDOGA_TARGET, 0);
-            pInstance->SetData64(DATA_ADD_JEDOGA_OPFER, 0);
-            pInstance->SetData(DATA_JEDOGA_RESET_INITIANDS, 0);
-        }
-        MoveUp();
+            uiOpFerTimer = urand(15*IN_MILLISECONDS,20*IN_MILLISECONDS);
 
-        bFirstTime = false;
-    }
+            uiCycloneTimer = 3*IN_MILLISECONDS;
+            uiBoltTimer = 7*IN_MILLISECONDS;
+            uiThunderTimer = 12*IN_MILLISECONDS;
 
-    void EnterCombat(Unit* who)
-    {
-        if (!pInstance || (who->GetTypeId() == TYPEID_UNIT && who->GetEntry() == NPC_JEDOGA_CONTROLLER))
-            return;
+            bOpFerok = false;
+            bOpFerokFail = false;
+            bOnGround = false;
+            bCanDown = false;
 
-        DoScriptText(TEXT_AGGRO, me);
-        me->SetInCombatWithZone();
-        pInstance->SetData(DATA_JEDOGA_SHADOWSEEKER_EVENT, IN_PROGRESS);
-    }
+            if (pInstance)
+            {
+                if (!bFirstTime)
+                    pInstance->SetData(DATA_JEDOGA_SHADOWSEEKER_EVENT, FAIL);
 
-    void AttackStart(Unit* who)
-    {
-        if (!who || (who->GetTypeId() == TYPEID_UNIT && who->GetEntry() == NPC_JEDOGA_CONTROLLER))
-            return;
+                pInstance->SetData64(DATA_PL_JEDOGA_TARGET, 0);
+                pInstance->SetData64(DATA_ADD_JEDOGA_OPFER, 0);
+                pInstance->SetData(DATA_JEDOGA_RESET_INITIANDS, 0);
+            }
+            MoveUp();
 
-        ScriptedAI::AttackStart(who);
-    }
+            bFirstTime = false;
+        }
 
-    void KilledUnit(Unit* Victim)
-    {
-        if (!Victim || Victim->GetTypeId() != TYPEID_PLAYER)
-            return;
+        void EnterCombat(Unit* who)
+        {
+            if (!pInstance || (who->GetTypeId() == TYPEID_UNIT && who->GetEntry() == NPC_JEDOGA_CONTROLLER))
+                return;
 
-        DoScriptText(RAND(TEXT_SLAY_1, TEXT_SLAY_2, TEXT_SLAY_3), me);
-    }
+            DoScriptText(TEXT_AGGRO, me);
+            me->SetInCombatWithZone();
+            pInstance->SetData(DATA_JEDOGA_SHADOWSEEKER_EVENT, IN_PROGRESS);
+        }
 
-    void JustDied(Unit* /*Killer*/)
-    {
-        DoScriptText(TEXT_DEATH, me);
-        if (pInstance)
-            pInstance->SetData(DATA_JEDOGA_SHADOWSEEKER_EVENT, DONE);
-    }
+        void AttackStart(Unit* who)
+        {
+            if (!who || (who->GetTypeId() == TYPEID_UNIT && who->GetEntry() == NPC_JEDOGA_CONTROLLER))
+                return;
 
-    void MoveInLineOfSight(Unit* who)
-    {
-        if (!pInstance || !who || (who->GetTypeId() == TYPEID_UNIT && who->GetEntry() == NPC_JEDOGA_CONTROLLER))
-            return;
+            ScriptedAI::AttackStart(who);
+        }
 
-        if (!bPreDone && who->GetTypeId() == TYPEID_PLAYER && me->GetDistance(who) < 100.0f)
+        void KilledUnit(Unit* Victim)
         {
-            DoScriptText(RAND(TEXT_PREACHING_1, TEXT_PREACHING_2, TEXT_PREACHING_3, TEXT_PREACHING_4, TEXT_PREACHING_5), me);
-            bPreDone = true;
+            if (!Victim || Victim->GetTypeId() != TYPEID_PLAYER)
+                return;
+
+            DoScriptText(RAND(TEXT_SLAY_1, TEXT_SLAY_2, TEXT_SLAY_3), me);
         }
 
-        if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) != IN_PROGRESS || !bOnGround)
-            return;
+        void JustDied(Unit* /*Killer*/)
+        {
+            DoScriptText(TEXT_DEATH, me);
+            if (pInstance)
+                pInstance->SetData(DATA_JEDOGA_SHADOWSEEKER_EVENT, DONE);
+        }
 
-        if (!me->getVictim() && who->isTargetableForAttack() && me->IsHostileTo(who) && who->isInAccessiblePlaceFor(me))
+        void MoveInLineOfSight(Unit* who)
         {
-            float attackRadius = me->GetAttackDistance(who);
-            if (me->IsWithinDistInMap(who, attackRadius) && me->IsWithinLOSInMap(who))
+            if (!pInstance || !who || (who->GetTypeId() == TYPEID_UNIT && who->GetEntry() == NPC_JEDOGA_CONTROLLER))
+                return;
+
+            if (!bPreDone && who->GetTypeId() == TYPEID_PLAYER && me->GetDistance(who) < 100.0f)
             {
-                if (!me->getVictim())
-                {
-                    who->RemoveAurasByType(SPELL_AURA_MOD_STEALTH);
-                    AttackStart(who);
-                }
-                else if (me->GetMap()->IsDungeon())
+                DoScriptText(RAND(TEXT_PREACHING_1, TEXT_PREACHING_2, TEXT_PREACHING_3, TEXT_PREACHING_4, TEXT_PREACHING_5), me);
+                bPreDone = true;
+            }
+
+            if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) != IN_PROGRESS || !bOnGround)
+                return;
+
+            if (!me->getVictim() && who->isTargetableForAttack() && me->IsHostileTo(who) && who->isInAccessiblePlaceFor(me))
+            {
+                float attackRadius = me->GetAttackDistance(who);
+                if (me->IsWithinDistInMap(who, attackRadius) && me->IsWithinLOSInMap(who))
                 {
-                    who->SetInCombatWith(me);
-                    me->AddThreat(who, 0.0f);
+                    if (!me->getVictim())
+                    {
+                        who->RemoveAurasByType(SPELL_AURA_MOD_STEALTH);
+                        AttackStart(who);
+                    }
+                    else if (me->GetMap()->IsDungeon())
+                    {
+                        who->SetInCombatWith(me);
+                        me->AddThreat(who, 0.0f);
+                    }
                 }
             }
         }
-    }
 
-    void MoveDown()
-    {
-        if (!pInstance)
-            return;
+        void MoveDown()
+        {
+            if (!pInstance)
+                return;
 
-        bOpFerokFail = false;
+            bOpFerokFail = false;
 
-        pInstance->SetData(DATA_JEDOGA_TRIGGER_SWITCH, 0);
-        me->GetMotionMaster()->MovePoint(1, JedogaPosition[1]);
-/*      me->SetUnitMovementFlags(MOVEMENTFLAG_JUMPING);
-        me->SendMonsterMove(JedogaPosition[1], MOVEFLAG_JUMP, 0);
-        me->Relocate(JedogaPosition[1][0], JedogaPosition[1][1], JedogaPosition[1][2], JedogaPosition[1][3]);
-        me->SetUnitMovementFlags(MOVEMENTFLAG_WALKING);
-*/
-        me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, false);
-        me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, false);
-        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
+            pInstance->SetData(DATA_JEDOGA_TRIGGER_SWITCH, 0);
+            me->GetMotionMaster()->MovePoint(1, JedogaPosition[1]);
+            me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, false);
+            me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, false);
+            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
 
-        me->RemoveAurasDueToSpell(SPELL_SPHERE_VISUAL);
+            me->RemoveAurasDueToSpell(SPELL_SPHERE_VISUAL);
 
-        bOnGround = true;
+            bOnGround = true;
 
-        if (UpdateVictim())
-        {
-            AttackStart(me->getVictim());
-            me->GetMotionMaster()->MoveChase(me->getVictim());
-        }
-        else
-        {
-            if (Unit* pTarget = Unit::GetUnit(*me, pInstance->GetData64(DATA_PL_JEDOGA_TARGET)))
+            if (UpdateVictim())
             {
-                AttackStart(pTarget);
-                pInstance->SetData(DATA_JEDOGA_RESET_INITIANDS, 0);
-                if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) != IN_PROGRESS)
-                    EnterCombat(pTarget);
+                AttackStart(me->getVictim());
+                me->GetMotionMaster()->MoveChase(me->getVictim());
+            }
+            else
+            {
+                if (Unit* pTarget = Unit::GetUnit(*me, pInstance->GetData64(DATA_PL_JEDOGA_TARGET)))
+                {
+                    AttackStart(pTarget);
+                    pInstance->SetData(DATA_JEDOGA_RESET_INITIANDS, 0);
+                    if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) != IN_PROGRESS)
+                        EnterCombat(pTarget);
+                }
+                else if (!me->isInCombat())
+                    EnterEvadeMode();
             }
-            else if (!me->isInCombat())
-                EnterEvadeMode();
         }
-    }
 
-    void MoveUp()
-    {
-        if (!pInstance)
-            return;
-
-        me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, true);
-        me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, true);
-        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
-
-        me->AttackStop();
-        me->RemoveAllAuras();
-        me->LoadCreaturesAddon();
-        me->GetMotionMaster()->MovePoint(0, JedogaPosition[0]);
-/*      me->SetUnitMovementFlags(MOVEMENTFLAG_JUMPING);
-        me->SendMonsterMove(JedogaPosition[0][0], JedogaPosition[0][1], JedogaPosition[0][2], 0, MOVEFLAG_JUMP, 0);
-        me->Relocate(JedogaPosition[0][0], JedogaPosition[0][1], JedogaPosition[0][2], JedogaPosition[0][3]);
-        me->SetUnitMovementFlags(MOVEMENTFLAG_LEVITATING);
-        me->GetMotionMaster()->Clear();
-        me->GetMotionMaster()->MoveIdle();
-        me->StopMoving();
-*/
-
-        pInstance->SetData(DATA_JEDOGA_TRIGGER_SWITCH, 1);
-        if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == IN_PROGRESS) OpferRufen();
-
-        bOnGround = false;
-        uiOpFerTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
-    }
+        void MoveUp()
+        {
+            if (!pInstance)
+                return;
 
-    void OpferRufen()
-    {
-        if (!pInstance)
-            return;
+            me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, true);
+            me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, true);
+            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
 
-        uint64 opfer = pInstance->GetData64(DATA_ADD_JEDOGA_INITIAND);
+            me->AttackStop();
+            me->RemoveAllAuras();
+            me->LoadCreaturesAddon();
+            me->GetMotionMaster()->MovePoint(0, JedogaPosition[0]);
 
-        if (opfer)
-        {
-            DoScriptText(RAND(TEXT_SACRIFICE_1_1, TEXT_SACRIFICE_1_2), me);
-            pInstance->SetData64(DATA_ADD_JEDOGA_OPFER, opfer);
-        } else
-            bCanDown = true;
-    }
+            pInstance->SetData(DATA_JEDOGA_TRIGGER_SWITCH, 1);
+            if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == IN_PROGRESS) OpferRufen();
 
-    void Opfern()
-    {
-        DoScriptText(RAND(TEXT_SACRIFICE_2_1, TEXT_SACRIFICE_2_2), me);
+            bOnGround = false;
+            uiOpFerTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
+        }
 
-        me->InterruptNonMeleeSpells(false);
-        DoCast(me, SPELL_GIFT_OF_THE_HERALD, false);
+        void OpferRufen()
+        {
+            if (!pInstance)
+                return;
 
-        bOpFerok = false;
-        bCanDown = true;
-    }
+            uint64 opfer = pInstance->GetData64(DATA_ADD_JEDOGA_INITIAND);
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!pInstance)
-            return;
+            if (opfer)
+            {
+                DoScriptText(RAND(TEXT_SACRIFICE_1_1, TEXT_SACRIFICE_1_2), me);
+                pInstance->SetData64(DATA_ADD_JEDOGA_OPFER, opfer);
+            } else
+                bCanDown = true;
+        }
 
-        if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) != IN_PROGRESS && pInstance->GetData(DATA_ALL_INITIAND_DEAD))
-            MoveDown();
+        void Opfern()
+        {
+            DoScriptText(RAND(TEXT_SACRIFICE_2_1, TEXT_SACRIFICE_2_2), me);
 
-        if (bOpFerok && !bOnGround && !bCanDown) Opfern();
+            me->InterruptNonMeleeSpells(false);
+            DoCast(me, SPELL_GIFT_OF_THE_HERALD, false);
 
-        if (bOpFerokFail && !bOnGround && !bCanDown)
+            bOpFerok = false;
             bCanDown = true;
-
-        if (bCanDown)
-        {
-            MoveDown();
-            bCanDown = false;
         }
 
-        if (bOnGround)
+        void UpdateAI(const uint32 diff)
         {
-            if (!UpdateVictim())
+            if (!pInstance)
                 return;
 
-            if (uiCycloneTimer <= diff)
+            if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) != IN_PROGRESS && pInstance->GetData(DATA_ALL_INITIAND_DEAD))
+                MoveDown();
+
+            if (bOpFerok && !bOnGround && !bCanDown) Opfern();
+
+            if (bOpFerokFail && !bOnGround && !bCanDown)
+                bCanDown = true;
+
+            if (bCanDown)
             {
-                DoCast(me, SPELL_CYCLONE_STRIKE, false);
-                uiCycloneTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
-            } else uiCycloneTimer -= diff;
+                MoveDown();
+                bCanDown = false;
+            }
 
-            if (uiBoltTimer <= diff)
+            if (bOnGround)
             {
-                if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                    me->CastSpell(pTarget, DUNGEON_MODE(SPELL_LIGHTNING_BOLT, SPELL_LIGHTNING_BOLT_H), false);
+                if (!UpdateVictim())
+                    return;
 
-                uiBoltTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
-            } else uiBoltTimer -= diff;
+                if (uiCycloneTimer <= diff)
+                {
+                    DoCast(me, SPELL_CYCLONE_STRIKE, false);
+                    uiCycloneTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
+                } else uiCycloneTimer -= diff;
 
-            if (uiThunderTimer <= diff)
-            {
-                if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                    me->CastSpell(pTarget, DUNGEON_MODE(SPELL_THUNDERSHOCK, SPELL_THUNDERSHOCK_H), false);
+                if (uiBoltTimer <= diff)
+                {
+                    if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                        me->CastSpell(pTarget, DUNGEON_MODE(SPELL_LIGHTNING_BOLT, SPELL_LIGHTNING_BOLT_H), false);
 
-                uiThunderTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
-            } else uiThunderTimer -= diff;
+                    uiBoltTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
+                } else uiBoltTimer -= diff;
 
-            if (uiOpFerTimer <= diff)
-                MoveUp();
-            else
-                uiOpFerTimer -= diff;
+                if (uiThunderTimer <= diff)
+                {
+                    if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                        me->CastSpell(pTarget, DUNGEON_MODE(SPELL_THUNDERSHOCK, SPELL_THUNDERSHOCK_H), false);
 
-            DoMeleeAttackIfReady();
+                    uiThunderTimer = urand(15*IN_MILLISECONDS,30*IN_MILLISECONDS);
+                } else uiThunderTimer -= diff;
+
+                if (uiOpFerTimer <= diff)
+                    MoveUp();
+                else
+                    uiOpFerTimer -= diff;
+
+                DoMeleeAttackIfReady();
+            }
         }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new boss_jedoga_shadowseekerAI(creature);
     }
 };
 
-struct mob_jedoga_initiandAI : public ScriptedAI
+class mob_jedoga_initiand : public CreatureScript
 {
-    mob_jedoga_initiandAI(Creature* c) : ScriptedAI(c)
+public:
+    mob_jedoga_initiand() : CreatureScript("mob_jedoga_initiand") { }
+
+    struct mob_jedoga_initiandAI : public ScriptedAI
     {
-        pInstance = c->GetInstanceData();
-    }
+        mob_jedoga_initiandAI(Creature* c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-    ScriptedInstance* pInstance;
+        ScriptedInstance* pInstance;
 
-    uint32 bCheckTimer;
+        uint32 bCheckTimer;
 
-    bool bWalking;
+        bool bWalking;
 
-    void Reset()
-    {
-        if (!pInstance)
-            return;
+        void Reset()
+        {
+            if (!pInstance)
+                return;
 
-        bWalking = false;
-        bCheckTimer = 2*IN_MILLISECONDS;
+            bWalking = false;
+            bCheckTimer = 2*IN_MILLISECONDS;
 
-        if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) != IN_PROGRESS)
-        {
-            me->RemoveAurasDueToSpell(SPELL_SPHERE_VISUAL);
-            me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, false);
-            me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, false);
-            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
-        }
-        else
-        {
-            DoCast(me, SPELL_SPHERE_VISUAL, false);
-            me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, true);
-            me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, true);
-            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
+            if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) != IN_PROGRESS)
+            {
+                me->RemoveAurasDueToSpell(SPELL_SPHERE_VISUAL);
+                me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, false);
+                me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, false);
+                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
+            }
+            else
+            {
+                DoCast(me, SPELL_SPHERE_VISUAL, false);
+                me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, true);
+                me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, true);
+                me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
+            }
         }
-    }
-
-    void JustDied(Unit* Killer)
-    {
-        if (!Killer || !pInstance) return;
 
-        if (bWalking)
+        void JustDied(Unit* Killer)
         {
-            Creature* boss = me->GetMap()->GetCreature(pInstance->GetData64(DATA_JEDOGA_SHADOWSEEKER));
-            if (boss && !CAST_AI(boss_jedoga_shadowseekerAI, boss->AI())->bOpFerok) CAST_AI(boss_jedoga_shadowseekerAI, boss->AI())->bOpFerokFail = true;
+            if (!Killer || !pInstance) return;
 
-            if (Killer->GetTypeId() == TYPEID_PLAYER) pInstance->SetData(DATA_INITIAND_KILLED, 1);
-            pInstance->SetData64(DATA_ADD_JEDOGA_OPFER, 0);
+            if (bWalking)
+            {
+                Creature* boss = me->GetMap()->GetCreature(pInstance->GetData64(DATA_JEDOGA_SHADOWSEEKER));
+                if (boss && !CAST_AI(boss_jedoga_shadowseeker::boss_jedoga_shadowseekerAI, boss->AI())->bOpFerok) CAST_AI(boss_jedoga_shadowseeker::boss_jedoga_shadowseekerAI, boss->AI())->bOpFerokFail = true;
 
-            bWalking = false;
-        }
-        if (Killer->GetTypeId() == TYPEID_PLAYER) pInstance->SetData64(DATA_PL_JEDOGA_TARGET, Killer->GetGUID());
-    }
+                if (Killer->GetTypeId() == TYPEID_PLAYER) pInstance->SetData(DATA_INITIAND_KILLED, 1);
+                pInstance->SetData64(DATA_ADD_JEDOGA_OPFER, 0);
 
-    void EnterCombat(Unit* who)
-    {
-        if ((pInstance && pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == IN_PROGRESS) || !who) return;
-    }
+                bWalking = false;
+            }
+            if (Killer->GetTypeId() == TYPEID_PLAYER) pInstance->SetData64(DATA_PL_JEDOGA_TARGET, Killer->GetGUID());
+        }
 
-    void AttackStart(Unit* victim)
-    {
-        if ((pInstance && pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == IN_PROGRESS) || !victim) return;
+        void EnterCombat(Unit* who)
+        {
+            if ((pInstance && pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == IN_PROGRESS) || !who) return;
+        }
 
-        ScriptedAI::AttackStart(victim);
-    }
+        void AttackStart(Unit* victim)
+        {
+            if ((pInstance && pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == IN_PROGRESS) || !victim) return;
 
-    void MoveInLineOfSight(Unit* who)
-    {
-        if ((pInstance && pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == IN_PROGRESS) || !who) return;
+            ScriptedAI::AttackStart(victim);
+        }
 
-        ScriptedAI::MoveInLineOfSight(who);
-    }
+        void MoveInLineOfSight(Unit* who)
+        {
+            if ((pInstance && pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == IN_PROGRESS) || !who) return;
 
-    void MovementInform(uint32 uiType, uint32 uiPointId)
-    {
-        if (uiType != POINT_MOTION_TYPE || !pInstance) return;
+            ScriptedAI::MoveInLineOfSight(who);
+        }
 
-        switch(uiPointId)
+        void MovementInform(uint32 uiType, uint32 uiPointId)
         {
-            case 1:
-                {
-                    Creature* boss = me->GetMap()->GetCreature(pInstance->GetData64(DATA_JEDOGA_SHADOWSEEKER));
-                    if (boss)
+            if (uiType != POINT_MOTION_TYPE || !pInstance) return;
+
+            switch(uiPointId)
+            {
+                case 1:
                     {
-                        CAST_AI(boss_jedoga_shadowseekerAI, boss->AI())->bOpFerok = true;
-                        CAST_AI(boss_jedoga_shadowseekerAI, boss->AI())->bOpFerokFail = false;
-                        me->Kill(me);
+                        Creature* boss = me->GetMap()->GetCreature(pInstance->GetData64(DATA_JEDOGA_SHADOWSEEKER));
+                        if (boss)
+                        {
+                            CAST_AI(boss_jedoga_shadowseeker::boss_jedoga_shadowseekerAI, boss->AI())->bOpFerok = true;
+                            CAST_AI(boss_jedoga_shadowseeker::boss_jedoga_shadowseekerAI, boss->AI())->bOpFerokFail = false;
+                            me->Kill(me);
+                        }
                     }
-                }
-                break;
+                    break;
+            }
         }
-    }
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (pInstance && bCheckTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            if (me->GetGUID() == pInstance->GetData64(DATA_ADD_JEDOGA_OPFER) && !bWalking)
+            if (pInstance && bCheckTimer <= diff)
             {
-                me->RemoveAurasDueToSpell(SPELL_SPHERE_VISUAL);
-                me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, false);
-                me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, false);
-                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
-
-                float distance = me->GetDistance(JedogaPosition[1]);
-
-                if (distance < 9.0f)
-                    me->SetSpeed(MOVE_WALK, 0.5f, true);
-                else if (distance < 15.0f)
-                    me->SetSpeed(MOVE_WALK, 0.75f, true);
-                else if (distance < 20.0f)
-                    me->SetSpeed(MOVE_WALK, 1.0f, true);
-
-                me->GetMotionMaster()->Clear(false);
-                me->GetMotionMaster()->MovePoint(1, JedogaPosition[1]);
-                bWalking = true;
-            }
-            if (!bWalking)
-            {
-                if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) != IN_PROGRESS && me->HasAura(SPELL_SPHERE_VISUAL))
+                if (me->GetGUID() == pInstance->GetData64(DATA_ADD_JEDOGA_OPFER) && !bWalking)
                 {
                     me->RemoveAurasDueToSpell(SPELL_SPHERE_VISUAL);
                     me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, false);
                     me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, false);
                     me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
+
+                    float distance = me->GetDistance(JedogaPosition[1]);
+
+                    if (distance < 9.0f)
+                        me->SetSpeed(MOVE_WALK, 0.5f, true);
+                    else if (distance < 15.0f)
+                        me->SetSpeed(MOVE_WALK, 0.75f, true);
+                    else if (distance < 20.0f)
+                        me->SetSpeed(MOVE_WALK, 1.0f, true);
+
+                    me->GetMotionMaster()->Clear(false);
+                    me->GetMotionMaster()->MovePoint(1, JedogaPosition[1]);
+                    bWalking = true;
                 }
-                if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == IN_PROGRESS && !me->HasAura(SPELL_SPHERE_VISUAL))
+                if (!bWalking)
                 {
-                    DoCast(me, SPELL_SPHERE_VISUAL, false);
-                    me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, true);
-                    me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, true);
-                    me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
+                    if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) != IN_PROGRESS && me->HasAura(SPELL_SPHERE_VISUAL))
+                    {
+                        me->RemoveAurasDueToSpell(SPELL_SPHERE_VISUAL);
+                        me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, false);
+                        me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, false);
+                        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
+                    }
+                    if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == IN_PROGRESS && !me->HasAura(SPELL_SPHERE_VISUAL))
+                    {
+                        DoCast(me, SPELL_SPHERE_VISUAL, false);
+                        me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, true);
+                        me->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_MAGIC, true);
+                        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
+                    }
                 }
-            }
-            bCheckTimer = 2*IN_MILLISECONDS;
-        } else bCheckTimer -= diff;
+                bCheckTimer = 2*IN_MILLISECONDS;
+            } else bCheckTimer -= diff;
+
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
 
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
+            DoMeleeAttackIfReady();
+        }
+    };
 
-        DoMeleeAttackIfReady();
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_jedoga_initiandAI(creature);
     }
 };
 
@@ -486,102 +495,83 @@ enum AufseherSpell
   SPELL_BEAM_VISUAL_JEDOGAS_AUFSEHER_2            = 56312
 };
 
-struct npc_jedogas_aufseher_triggerAI : public Scripted_NoMovementAI
+class npc_jedogas_aufseher_trigger : public CreatureScript
 {
-    npc_jedogas_aufseher_triggerAI(Creature* c) : Scripted_NoMovementAI(c)
-    {
-        pInstance = c->GetInstanceData();
-//        c->SetUInt32Value(UNIT_FIELD_DISPLAYID, 11686);
-//        c->setFaction(35);
-        bRemoved = false;
-        bRemoved2 = false;
-        bCasted = false;
-        bCasted2 = false;
-    }
+public:
+    npc_jedogas_aufseher_trigger() : CreatureScript("npc_jedogas_aufseher_trigger") { }
 
-    ScriptedInstance* pInstance;
+    struct npc_jedogas_aufseher_triggerAI : public Scripted_NoMovementAI
+    {
+        npc_jedogas_aufseher_triggerAI(Creature* c) : Scripted_NoMovementAI(c)
+        {
+            pInstance = c->GetInstanceData();
+            bRemoved = false;
+            bRemoved2 = false;
+            bCasted = false;
+            bCasted2 = false;
+        }
 
-    bool bRemoved;
-    bool bRemoved2;
-    bool bCasted;
-    bool bCasted2;
+        ScriptedInstance* pInstance;
 
-    void Reset() {}
-    void EnterCombat(Unit* /*who*/) {}
-    void AttackStart(Unit* /*victim*/) {}
-    void MoveInLineOfSight(Unit* /*who*/) {}
+        bool bRemoved;
+        bool bRemoved2;
+        bool bCasted;
+        bool bCasted2;
 
-    void UpdateAI(const uint32 /*diff*/)
-    {
-        if (!pInstance)
-            return;
+        void Reset() {}
+        void EnterCombat(Unit* /*who*/) {}
+        void AttackStart(Unit* /*victim*/) {}
+        void MoveInLineOfSight(Unit* /*who*/) {}
 
-        if (!bRemoved && me->GetPositionX() > 440.0f)
+        void UpdateAI(const uint32 /*diff*/)
         {
-            if (pInstance->GetData(DATA_PRINCE_TALDARAM_EVENT) == DONE)
-            {
-                me->InterruptNonMeleeSpells(true);
-                bRemoved = true;
+            if (!pInstance)
                 return;
-            }
-            if (!bCasted)
-            {
-                DoCast(me, SPELL_BEAM_VISUAL_JEDOGAS_AUFSEHER_1, false);
-                bCasted = true;
-            }
-        }
-        if (!bRemoved2 && me->GetPositionX() < 440.0f)
-        {
-            if (!bCasted2 && pInstance->GetData(DATA_JEDOGA_TRIGGER_SWITCH))
-            {
-                DoCast(me, SPELL_BEAM_VISUAL_JEDOGAS_AUFSEHER_2, false);
-                bCasted2 = true;
-            }
-            if (bCasted2 && !pInstance->GetData(DATA_JEDOGA_TRIGGER_SWITCH))
+
+            if (!bRemoved && me->GetPositionX() > 440.0f)
             {
-                me->InterruptNonMeleeSpells(true);
-                bCasted2 = false;
+                if (pInstance->GetData(DATA_PRINCE_TALDARAM_EVENT) == DONE)
+                {
+                    me->InterruptNonMeleeSpells(true);
+                    bRemoved = true;
+                    return;
+                }
+                if (!bCasted)
+                {
+                    DoCast(me, SPELL_BEAM_VISUAL_JEDOGAS_AUFSEHER_1, false);
+                    bCasted = true;
+                }
             }
-            if (!bRemoved2 && pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == DONE)
+            if (!bRemoved2 && me->GetPositionX() < 440.0f)
             {
-                me->InterruptNonMeleeSpells(true);
-                bRemoved2 = true;
+                if (!bCasted2 && pInstance->GetData(DATA_JEDOGA_TRIGGER_SWITCH))
+                {
+                    DoCast(me, SPELL_BEAM_VISUAL_JEDOGAS_AUFSEHER_2, false);
+                    bCasted2 = true;
+                }
+                if (bCasted2 && !pInstance->GetData(DATA_JEDOGA_TRIGGER_SWITCH))
+                {
+                    me->InterruptNonMeleeSpells(true);
+                    bCasted2 = false;
+                }
+                if (!bRemoved2 && pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) == DONE)
+                {
+                    me->InterruptNonMeleeSpells(true);
+                    bRemoved2 = true;
+                }
             }
         }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new npc_jedogas_aufseher_triggerAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_jedoga_shadowseeker(Creature* pCreature)
-{
-    return new boss_jedoga_shadowseekerAI (pCreature);
-}
-
-CreatureAI* GetAI_mob_jedoga_initiand(Creature* pCreature)
-{
-    return new mob_jedoga_initiandAI (pCreature);
-}
-
-CreatureAI* GetAI_npc_jedogas_aufseher_trigger(Creature* pCreature)
-{
-    return new npc_jedogas_aufseher_triggerAI (pCreature);
-}
-
 void AddSC_boss_jedoga_shadowseeker()
 {
-    Script* newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_jedoga_shadowseeker";
-    newscript->GetAI = &GetAI_boss_jedoga_shadowseeker;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "mob_jedoga_initiand";
-    newscript->GetAI = &GetAI_mob_jedoga_initiand;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "npc_jedogas_aufseher_trigger";
-    newscript->GetAI = &GetAI_npc_jedogas_aufseher_trigger;
-    newscript->RegisterSelf();
+    new boss_jedoga_shadowseeker;
+    new mob_jedoga_initiand;
+    new npc_jedogas_aufseher_trigger;
 }
diff --git a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_prince_taldaram.cpp b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_prince_taldaram.cpp
index 643d4fee1c5..63e99dac63f 100644
--- a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_prince_taldaram.cpp
+++ b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_prince_taldaram.cpp
@@ -72,340 +72,345 @@ enum GameObjects
     GO_SPHERE2                                    = 193094
 };
 
-struct boss_taldaramAI : public ScriptedAI
+class boss_taldaram : public CreatureScript
 {
-    boss_taldaramAI(Creature *c) : ScriptedAI(c)
+public:
+    boss_taldaram() : CreatureScript("boss_taldaram") { }
+
+    struct boss_taldaramAI : public ScriptedAI
     {
-        pInstance = c->GetInstanceData();
-        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
-        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
-    }
+        boss_taldaramAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
+            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
+        }
 
-    uint32 uiBloodthirstTimer;
-    uint32 uiVanishTimer;
-    uint32 uiWaitTimer;
-    uint32 uiEmbraceTimer;
-    uint32 uiEmbraceTakenDamage;
-    uint32 uiFlamesphereTimer;
-    uint32 uiPhaseTimer;
+        uint32 uiBloodthirstTimer;
+        uint32 uiVanishTimer;
+        uint32 uiWaitTimer;
+        uint32 uiEmbraceTimer;
+        uint32 uiEmbraceTakenDamage;
+        uint32 uiFlamesphereTimer;
+        uint32 uiPhaseTimer;
 
-    uint64 uiEmbraceTarget;
+        uint64 uiEmbraceTarget;
 
-    CombatPhase Phase;
+        CombatPhase Phase;
 
-    ScriptedInstance* pInstance;
+        ScriptedInstance* pInstance;
 
-    void Reset()
-    {
-        uiBloodthirstTimer = 10*IN_MILLISECONDS;
-        uiVanishTimer = urand(25*IN_MILLISECONDS,35*IN_MILLISECONDS);
-        uiEmbraceTimer = 20*IN_MILLISECONDS;
-        uiFlamesphereTimer = 5*IN_MILLISECONDS;
-        uiEmbraceTakenDamage = 0;
-        Phase = NORMAL;
-        uiPhaseTimer = 0;
-        uiEmbraceTarget = 0;
-        if (pInstance)
-            pInstance->SetData(DATA_PRINCE_TALDARAM_EVENT, NOT_STARTED);
-    }
+        void Reset()
+        {
+            uiBloodthirstTimer = 10*IN_MILLISECONDS;
+            uiVanishTimer = urand(25*IN_MILLISECONDS,35*IN_MILLISECONDS);
+            uiEmbraceTimer = 20*IN_MILLISECONDS;
+            uiFlamesphereTimer = 5*IN_MILLISECONDS;
+            uiEmbraceTakenDamage = 0;
+            Phase = NORMAL;
+            uiPhaseTimer = 0;
+            uiEmbraceTarget = 0;
+            if (pInstance)
+                pInstance->SetData(DATA_PRINCE_TALDARAM_EVENT, NOT_STARTED);
+        }
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        if (pInstance)
-            pInstance->SetData(DATA_PRINCE_TALDARAM_EVENT, IN_PROGRESS);
-        DoScriptText(SAY_AGGRO, me);
-    }
+        void EnterCombat(Unit* /*who*/)
+        {
+            if (pInstance)
+                pInstance->SetData(DATA_PRINCE_TALDARAM_EVENT, IN_PROGRESS);
+            DoScriptText(SAY_AGGRO, me);
+        }
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
-        if (uiPhaseTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            switch (Phase)
+            if (!UpdateVictim())
+                return;
+            if (uiPhaseTimer <= diff)
             {
-                case CASTING_FLAME_SPHERES:
+                switch (Phase)
                 {
-                    Creature* pSpheres[3];
-
-                    //DoCast(me, SPELL_FLAME_SPHERE_SUMMON_1);
-                    pSpheres[0] = DoSpawnCreature(CREATURE_FLAME_SPHERE, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
-                    Unit *pSphereTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
-                    if (pSphereTarget && pSpheres[0])
+                    case CASTING_FLAME_SPHERES:
                     {
-                        float angle,x,y;
-                        angle = pSpheres[0]->GetAngle(pSphereTarget);
-                        x = pSpheres[0]->GetPositionX() + DATA_SPHERE_DISTANCE * cos(angle);
-                        y = pSpheres[0]->GetPositionY() + DATA_SPHERE_DISTANCE * sin(angle);
-                        pSpheres[0]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[0]->GetPositionZ());
-                    }
-                    if (IsHeroic())
-                    {
-                        //DoCast(me, H_SPELL_FLAME_SPHERE_SUMMON_1);
-                        pSpheres[1] = DoSpawnCreature(H_CREATURE_FLAME_SPHERE_1, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
-                        //DoCast(me, H_SPELL_FLAME_SPHERE_SUMMON_2);
-                        pSpheres[2] = DoSpawnCreature(H_CREATURE_FLAME_SPHERE_2, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
-                        if (pSphereTarget && pSpheres[1] && pSpheres[2])
+                        Creature* pSpheres[3];
+
+                        //DoCast(me, SPELL_FLAME_SPHERE_SUMMON_1);
+                        pSpheres[0] = DoSpawnCreature(CREATURE_FLAME_SPHERE, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
+                        Unit *pSphereTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
+                        if (pSphereTarget && pSpheres[0])
                         {
                             float angle,x,y;
-                            angle = pSpheres[1]->GetAngle(pSphereTarget) + DATA_SPHERE_ANGLE_OFFSET;
-                            x = pSpheres[1]->GetPositionX() + DATA_SPHERE_DISTANCE/2 * cos(angle);
-                            y = pSpheres[1]->GetPositionY() + DATA_SPHERE_DISTANCE/2 * sin(angle);
-                            pSpheres[1]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[1]->GetPositionZ());
-                            angle = pSpheres[2]->GetAngle(pSphereTarget) - DATA_SPHERE_ANGLE_OFFSET;
-                            x = pSpheres[2]->GetPositionX() + DATA_SPHERE_DISTANCE/2 * cos(angle);
-                            y = pSpheres[2]->GetPositionY() + DATA_SPHERE_DISTANCE/2 * sin(angle);
-                            pSpheres[2]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[2]->GetPositionZ());
+                            angle = pSpheres[0]->GetAngle(pSphereTarget);
+                            x = pSpheres[0]->GetPositionX() + DATA_SPHERE_DISTANCE * cos(angle);
+                            y = pSpheres[0]->GetPositionY() + DATA_SPHERE_DISTANCE * sin(angle);
+                            pSpheres[0]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[0]->GetPositionZ());
+                        }
+                        if (IsHeroic())
+                        {
+                            //DoCast(me, H_SPELL_FLAME_SPHERE_SUMMON_1);
+                            pSpheres[1] = DoSpawnCreature(H_CREATURE_FLAME_SPHERE_1, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
+                            //DoCast(me, H_SPELL_FLAME_SPHERE_SUMMON_2);
+                            pSpheres[2] = DoSpawnCreature(H_CREATURE_FLAME_SPHERE_2, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
+                            if (pSphereTarget && pSpheres[1] && pSpheres[2])
+                            {
+                                float angle,x,y;
+                                angle = pSpheres[1]->GetAngle(pSphereTarget) + DATA_SPHERE_ANGLE_OFFSET;
+                                x = pSpheres[1]->GetPositionX() + DATA_SPHERE_DISTANCE/2 * cos(angle);
+                                y = pSpheres[1]->GetPositionY() + DATA_SPHERE_DISTANCE/2 * sin(angle);
+                                pSpheres[1]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[1]->GetPositionZ());
+                                angle = pSpheres[2]->GetAngle(pSphereTarget) - DATA_SPHERE_ANGLE_OFFSET;
+                                x = pSpheres[2]->GetPositionX() + DATA_SPHERE_DISTANCE/2 * cos(angle);
+                                y = pSpheres[2]->GetPositionY() + DATA_SPHERE_DISTANCE/2 * sin(angle);
+                                pSpheres[2]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[2]->GetPositionZ());
+                            }
                         }
-                    }
 
-                    Phase = NORMAL;
-                    uiPhaseTimer = 0;
-                    break;
-                }
-                case JUST_VANISHED:
-                    if (Unit *pEmbraceTarget = GetEmbraceTarget())
-                    {
-                        me->GetMotionMaster()->Clear();
-                        me->SetSpeed(MOVE_WALK, 2.0f, true);
-                        me->GetMotionMaster()->MoveChase(pEmbraceTarget);
+                        Phase = NORMAL;
+                        uiPhaseTimer = 0;
+                        break;
                     }
-                    Phase = VANISHED;
-                    uiPhaseTimer = 1300;
-                    break;
-                case VANISHED:
-                    if (Unit *pEmbraceTarget = GetEmbraceTarget())
-                        DoCast(pEmbraceTarget, SPELL_EMBRACE_OF_THE_VAMPYR);
-                    me->GetMotionMaster()->Clear();
-                    me->SetSpeed(MOVE_WALK, 1.0f, true);
-                    me->GetMotionMaster()->MoveChase(me->getVictim());
-                    Phase = FEEDING;
-                    uiPhaseTimer = 20*IN_MILLISECONDS;
-                    break;
-                case FEEDING:
-                    Phase = NORMAL;
-                    uiPhaseTimer = 0;
-                    uiEmbraceTarget = 0;
-                    break;
-                case NORMAL:
-                    if (uiBloodthirstTimer <= diff)
-                    {
-                        DoCast(me->getVictim(), SPELL_BLOODTHIRST);
-                        uiBloodthirstTimer = 10*IN_MILLISECONDS;
-                    } else uiBloodthirstTimer -= diff;
-
-                    if (uiFlamesphereTimer <= diff)
-                    {
-                        DoCast(me, SPELL_CONJURE_FLAME_SPHERE);
-                        Phase = CASTING_FLAME_SPHERES;
-                        uiPhaseTimer = 3*IN_MILLISECONDS + diff;
-                        uiFlamesphereTimer = 15*IN_MILLISECONDS;
-                    } else uiFlamesphereTimer -= diff;
-
-                    if (uiVanishTimer <= diff)
-                    {
-                        //Count alive players
-                        Unit *pTarget = NULL;
-                        std::list<HostileReference *> t_list = me->getThreatManager().getThreatList();
-                        std::vector<Unit *> target_list;
-                        for (std::list<HostileReference *>::const_iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
+                    case JUST_VANISHED:
+                        if (Unit *pEmbraceTarget = GetEmbraceTarget())
                         {
-                            pTarget = Unit::GetUnit(*me, (*itr)->getUnitGuid());
-                            // exclude pets & totems
-                            if (pTarget && pTarget->GetTypeId() == TYPEID_PLAYER && pTarget->isAlive())
-                                target_list.push_back(pTarget);
-                            pTarget = NULL;
+                            me->GetMotionMaster()->Clear();
+                            me->SetSpeed(MOVE_WALK, 2.0f, true);
+                            me->GetMotionMaster()->MoveChase(pEmbraceTarget);
                         }
-                        //He only vanishes if there are 3 or more alive players
-                        if (target_list.size() > 2)
+                        Phase = VANISHED;
+                        uiPhaseTimer = 1300;
+                        break;
+                    case VANISHED:
+                        if (Unit *pEmbraceTarget = GetEmbraceTarget())
+                            DoCast(pEmbraceTarget, SPELL_EMBRACE_OF_THE_VAMPYR);
+                        me->GetMotionMaster()->Clear();
+                        me->SetSpeed(MOVE_WALK, 1.0f, true);
+                        me->GetMotionMaster()->MoveChase(me->getVictim());
+                        Phase = FEEDING;
+                        uiPhaseTimer = 20*IN_MILLISECONDS;
+                        break;
+                    case FEEDING:
+                        Phase = NORMAL;
+                        uiPhaseTimer = 0;
+                        uiEmbraceTarget = 0;
+                        break;
+                    case NORMAL:
+                        if (uiBloodthirstTimer <= diff)
                         {
-                            DoScriptText(RAND(SAY_VANISH_1,SAY_VANISH_2), me);
-                            DoCast(me, SPELL_VANISH);
-                            Phase = JUST_VANISHED;
-                            uiPhaseTimer = 500;
-                            if (Unit* pEmbraceTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                                uiEmbraceTarget = pEmbraceTarget->GetGUID();
-
-                        }
-                        uiVanishTimer = urand(25*IN_MILLISECONDS,35*IN_MILLISECONDS);
-                    } else uiVanishTimer -= diff;
+                            DoCast(me->getVictim(), SPELL_BLOODTHIRST);
+                            uiBloodthirstTimer = 10*IN_MILLISECONDS;
+                        } else uiBloodthirstTimer -= diff;
 
-                    DoMeleeAttackIfReady();
-                break;
-            }
-        } else uiPhaseTimer -= diff;
-    }
-
-    void DamageTaken(Unit* /*done_by*/, uint32 &damage)
-    {
-        Unit* pEmbraceTarget = GetEmbraceTarget();
+                        if (uiFlamesphereTimer <= diff)
+                        {
+                            DoCast(me, SPELL_CONJURE_FLAME_SPHERE);
+                            Phase = CASTING_FLAME_SPHERES;
+                            uiPhaseTimer = 3*IN_MILLISECONDS + diff;
+                            uiFlamesphereTimer = 15*IN_MILLISECONDS;
+                        } else uiFlamesphereTimer -= diff;
 
-        if (Phase == FEEDING && pEmbraceTarget && pEmbraceTarget->isAlive())
-        {
-          uiEmbraceTakenDamage += damage;
-          if (uiEmbraceTakenDamage > DUNGEON_MODE(DATA_EMBRACE_DMG, H_DATA_EMBRACE_DMG))
-          {
-              Phase = NORMAL;
-              uiPhaseTimer = 0;
-              uiEmbraceTarget = 0;
-              me->CastStop();
-          }
+                        if (uiVanishTimer <= diff)
+                        {
+                            //Count alive players
+                            Unit *pTarget = NULL;
+                            std::list<HostileReference *> t_list = me->getThreatManager().getThreatList();
+                            std::vector<Unit *> target_list;
+                            for (std::list<HostileReference *>::const_iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
+                            {
+                                pTarget = Unit::GetUnit(*me, (*itr)->getUnitGuid());
+                                // exclude pets & totems
+                                if (pTarget && pTarget->GetTypeId() == TYPEID_PLAYER && pTarget->isAlive())
+                                    target_list.push_back(pTarget);
+                                pTarget = NULL;
+                            }
+                            //He only vanishes if there are 3 or more alive players
+                            if (target_list.size() > 2)
+                            {
+                                DoScriptText(RAND(SAY_VANISH_1,SAY_VANISH_2), me);
+                                DoCast(me, SPELL_VANISH);
+                                Phase = JUST_VANISHED;
+                                uiPhaseTimer = 500;
+                                if (Unit* pEmbraceTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                                    uiEmbraceTarget = pEmbraceTarget->GetGUID();
+
+                            }
+                            uiVanishTimer = urand(25*IN_MILLISECONDS,35*IN_MILLISECONDS);
+                        } else uiVanishTimer -= diff;
+
+                        DoMeleeAttackIfReady();
+                    break;
+                }
+            } else uiPhaseTimer -= diff;
         }
-    }
 
-    void JustDied(Unit* /*killer*/)
-    {
-        DoScriptText(SAY_DEATH, me);
-
-        if (pInstance)
-            pInstance->SetData(DATA_PRINCE_TALDARAM_EVENT, DONE);
-    }
+        void DamageTaken(Unit* /*done_by*/, uint32 &damage)
+        {
+            Unit* pEmbraceTarget = GetEmbraceTarget();
 
-    void KilledUnit(Unit * victim)
-    {
-        if (victim == me)
-            return;
+            if (Phase == FEEDING && pEmbraceTarget && pEmbraceTarget->isAlive())
+            {
+              uiEmbraceTakenDamage += damage;
+              if (uiEmbraceTakenDamage > DUNGEON_MODE(DATA_EMBRACE_DMG, H_DATA_EMBRACE_DMG))
+              {
+                  Phase = NORMAL;
+                  uiPhaseTimer = 0;
+                  uiEmbraceTarget = 0;
+                  me->CastStop();
+              }
+            }
+        }
 
-        Unit* pEmbraceTarget = GetEmbraceTarget();
-        if (Phase == FEEDING && pEmbraceTarget && victim == pEmbraceTarget)
+        void JustDied(Unit* /*killer*/)
         {
-            Phase = NORMAL;
-            uiPhaseTimer = 0;
-            uiEmbraceTarget = 0;
+            DoScriptText(SAY_DEATH, me);
+
+            if (pInstance)
+                pInstance->SetData(DATA_PRINCE_TALDARAM_EVENT, DONE);
         }
-        DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2), me);
-    }
 
-    bool CheckSpheres()
-    {
-        if (!pInstance)
-            return false;
+        void KilledUnit(Unit * victim)
+        {
+            if (victim == me)
+                return;
 
-        uint64 uiSphereGuids[2];
-        uiSphereGuids[0] = pInstance->GetData64(DATA_SPHERE1);
-        uiSphereGuids[1] = pInstance->GetData64(DATA_SPHERE2);
+            Unit* pEmbraceTarget = GetEmbraceTarget();
+            if (Phase == FEEDING && pEmbraceTarget && victim == pEmbraceTarget)
+            {
+                Phase = NORMAL;
+                uiPhaseTimer = 0;
+                uiEmbraceTarget = 0;
+            }
+            DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2), me);
+        }
 
-        for (uint8 i=0; i < 2; ++i)
+        bool CheckSpheres()
         {
-            GameObject *pSpheres = pInstance->instance->GetGameObject(uiSphereGuids[i]);
-            if (!pSpheres)
-                return false;
-            if (pSpheres->GetGoState() != GO_STATE_ACTIVE)
+            if (!pInstance)
                 return false;
+
+            uint64 uiSphereGuids[2];
+            uiSphereGuids[0] = pInstance->GetData64(DATA_SPHERE1);
+            uiSphereGuids[1] = pInstance->GetData64(DATA_SPHERE2);
+
+            for (uint8 i=0; i < 2; ++i)
+            {
+                GameObject *pSpheres = pInstance->instance->GetGameObject(uiSphereGuids[i]);
+                if (!pSpheres)
+                    return false;
+                if (pSpheres->GetGoState() != GO_STATE_ACTIVE)
+                    return false;
+            }
+            RemovePrison();
+            return true;
         }
-        RemovePrison();
-        return true;
-    }
 
-    Unit* GetEmbraceTarget()
-    {
-        if (!uiEmbraceTarget)
-            return NULL;
+        Unit* GetEmbraceTarget()
+        {
+            if (!uiEmbraceTarget)
+                return NULL;
 
-        return Unit::GetUnit(*me, uiEmbraceTarget);
-    }
+            return Unit::GetUnit(*me, uiEmbraceTarget);
+        }
+
+        void RemovePrison()
+        {
+            if (!pInstance)
+                return;
+            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
+            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
+            me->RemoveAurasDueToSpell(SPELL_BEAM_VISUAL);
+            me->SetUnitMovementFlags(MOVEMENTFLAG_WALKING);
+            me->SetHomePosition(me->GetPositionX(), me->GetPositionY(), DATA_GROUND_POSITION_Z, me->GetOrientation());
+            uint64 prison_GUID = pInstance->GetData64(DATA_PRINCE_TALDARAM_PLATFORM);
+            pInstance->HandleGameObject(prison_GUID,true);
+        }
+    };
 
-    void RemovePrison()
+    CreatureAI *GetAI(Creature *creature) const
     {
-        if (!pInstance)
-            return;
-        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
-        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
-        me->RemoveAurasDueToSpell(SPELL_BEAM_VISUAL);
-        me->SetUnitMovementFlags(MOVEMENTFLAG_WALKING);
-        me->SetHomePosition(me->GetPositionX(), me->GetPositionY(), DATA_GROUND_POSITION_Z, me->GetOrientation());
-        uint64 prison_GUID = pInstance->GetData64(DATA_PRINCE_TALDARAM_PLATFORM);
-        pInstance->HandleGameObject(prison_GUID,true);
+        return new boss_taldaramAI(creature);
     }
 };
 
-struct mob_taldaram_flamesphereAI : public ScriptedAI
+class mob_taldaram_flamesphere : public CreatureScript
 {
-    mob_taldaram_flamesphereAI(Creature *c) : ScriptedAI(c)
+public:
+    mob_taldaram_flamesphere() : CreatureScript("mob_taldaram_flamesphere") { }
+
+    struct mob_taldaram_flamesphereAI : public ScriptedAI
     {
-        pInstance = c->GetInstanceData();
-    }
+        mob_taldaram_flamesphereAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-    uint32 uiDespawnTimer;
-    ScriptedInstance* pInstance;
+        uint32 uiDespawnTimer;
+        ScriptedInstance* pInstance;
 
-    void Reset()
-    {
-        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-        me->AddUnitMovementFlag(MOVEMENTFLAG_FLYING);
-        me->setFaction(16);
-        me->SetFloatValue(OBJECT_FIELD_SCALE_X, 1.0f);
-        DoCast(me, SPELL_FLAME_SPHERE_VISUAL);
-        DoCast(me, SPELL_FLAME_SPHERE_SPAWN_EFFECT);
-        DoCast(me, SPELL_FLAME_SPHERE_PERIODIC);
-        uiDespawnTimer = 10*IN_MILLISECONDS;
-    }
+        void Reset()
+        {
+            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
+            me->AddUnitMovementFlag(MOVEMENTFLAG_FLYING);
+            me->setFaction(16);
+            me->SetFloatValue(OBJECT_FIELD_SCALE_X, 1.0f);
+            DoCast(me, SPELL_FLAME_SPHERE_VISUAL);
+            DoCast(me, SPELL_FLAME_SPHERE_SPAWN_EFFECT);
+            DoCast(me, SPELL_FLAME_SPHERE_PERIODIC);
+            uiDespawnTimer = 10*IN_MILLISECONDS;
+        }
 
-    void EnterCombat(Unit * /*who*/) {}
-    void MoveInLineOfSight(Unit * /*who*/) {}
+        void EnterCombat(Unit * /*who*/) {}
+        void MoveInLineOfSight(Unit * /*who*/) {}
 
-    void JustDied(Unit* /*who*/)
-    {
-        DoCast(me, SPELL_FLAME_SPHERE_DEATH_EFFECT);
-    }
+        void JustDied(Unit* /*who*/)
+        {
+            DoCast(me, SPELL_FLAME_SPHERE_DEATH_EFFECT);
+        }
 
-    void UpdateAI(const uint32 diff)
+        void UpdateAI(const uint32 diff)
+        {
+            if (uiDespawnTimer <= diff)
+                me->DisappearAndDie();
+            else
+                uiDespawnTimer -= diff;
+        }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
     {
-        if (uiDespawnTimer <= diff)
-            me->DisappearAndDie();
-        else
-            uiDespawnTimer -= diff;
+        return new mob_taldaram_flamesphereAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_taldaram(Creature* pCreature)
+class prince_taldaram_sphere : public GameObjectScript
 {
-    return new boss_taldaramAI (pCreature);
-}
+public:
+    prince_taldaram_sphere() : GameObjectScript("prince_taldaram_sphere") { }
 
-CreatureAI* GetAI_mob_taldaram_flamesphere(Creature* pCreature)
-{
-    return new mob_taldaram_flamesphereAI (pCreature);
-}
-
-bool GOHello_prince_taldaram_sphere(Player * /*pPlayer*/, GameObject *pGO)
-{
-    ScriptedInstance *pInstance = pGO->GetInstanceData();
-
-    Creature *pPrinceTaldaram = Unit::GetCreature(*pGO, pInstance ? pInstance->GetData64(DATA_PRINCE_TALDARAM) : 0);
-    if (pPrinceTaldaram && pPrinceTaldaram->isAlive())
+    bool OnGossipHello(Player * /*pPlayer*/, GameObject *pGO)
     {
-        // maybe these are hacks :(
-        pGO->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
-        pGO->SetGoState(GO_STATE_ACTIVE);
+        ScriptedInstance *pInstance = pGO->GetInstanceData();
 
-        switch(pGO->GetEntry())
+        Creature *pPrinceTaldaram = Unit::GetCreature(*pGO, pInstance ? pInstance->GetData64(DATA_PRINCE_TALDARAM) : 0);
+        if (pPrinceTaldaram && pPrinceTaldaram->isAlive())
         {
-            case GO_SPHERE1: pInstance->SetData(DATA_SPHERE1_EVENT,IN_PROGRESS); break;
-            case GO_SPHERE2: pInstance->SetData(DATA_SPHERE2_EVENT,IN_PROGRESS); break;
-        }
+            // maybe these are hacks :(
+            pGO->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
+            pGO->SetGoState(GO_STATE_ACTIVE);
 
-        CAST_AI(boss_taldaramAI, pPrinceTaldaram->AI())->CheckSpheres();
+            switch(pGO->GetEntry())
+            {
+                case GO_SPHERE1: pInstance->SetData(DATA_SPHERE1_EVENT,IN_PROGRESS); break;
+                case GO_SPHERE2: pInstance->SetData(DATA_SPHERE2_EVENT,IN_PROGRESS); break;
+            }
+
+            CAST_AI(boss_taldaram::boss_taldaramAI, pPrinceTaldaram->AI())->CheckSpheres();
+        }
+        return true;
     }
-    return true;
-}
+};
 
 void AddSC_boss_taldaram()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_taldaram";
-    newscript->GetAI = &GetAI_boss_taldaram;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "mob_taldaram_flamesphere";
-    newscript->GetAI = &GetAI_mob_taldaram_flamesphere;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "prince_taldaram_sphere";
-    newscript->pGOHello = &GOHello_prince_taldaram_sphere;
-    newscript->RegisterSelf();
+    new boss_taldaram;
+    new mob_taldaram_flamesphere;
+    new prince_taldaram_sphere;
 }
diff --git a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/instance_ahnkahet.cpp b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/instance_ahnkahet.cpp
index 7d3fa8d5fba..cb7bc940bf2 100644
--- a/src/server/scripts/Northrend/AzjolNerub/ahnkahet/instance_ahnkahet.cpp
+++ b/src/server/scripts/Northrend/AzjolNerub/ahnkahet/instance_ahnkahet.cpp
@@ -33,280 +33,282 @@ enum Achievements
     ACHIEV_VOLUNTEER_WORK                         = 2056
 };
 
-struct instance_ahnkahet : public ScriptedInstance
+class instance_ahnkahet : public InstanceMapScript
 {
-    instance_ahnkahet(Map* pMap) : ScriptedInstance(pMap) {Initialize();};
+public:
+    instance_ahnkahet() : InstanceMapScript("instance_ahnkahet") { }
 
-    uint64 Elder_Nadox;
-    uint64 Prince_Taldaram;
-    uint64 Jedoga_Shadowseeker;
-    uint64 Herald_Volazj;
-    uint64 Amanitar;
+    struct instance_ahnkahet_ScriptedInstance : public ScriptedInstance
+    {
+        instance_ahnkahet_ScriptedInstance(Map* pMap) : ScriptedInstance(pMap) {Initialize();};
 
-    uint64 Prince_TaldaramSpheres[2];
-    uint64 Prince_TaldaramPlatform;
-    uint64 Prince_TaldaramGate;
+        uint64 Elder_Nadox;
+        uint64 Prince_Taldaram;
+        uint64 Jedoga_Shadowseeker;
+        uint64 Herald_Volazj;
+        uint64 Amanitar;
 
-    std::set<uint64> InitiandGUIDs;
-    uint64 JedogaSacrifices;
-    uint64 JedogaTarget;
+        uint64 Prince_TaldaramSpheres[2];
+        uint64 Prince_TaldaramPlatform;
+        uint64 Prince_TaldaramGate;
 
-    uint32 m_auiEncounter[MAX_ENCOUNTER];
-    uint32 spheres[2];
+        std::set<uint64> InitiandGUIDs;
+        uint64 JedogaSacrifices;
+        uint64 JedogaTarget;
 
-    uint8 InitiandCnt,
-        switchtrigger,
-        initiandkilled;
+        uint32 m_auiEncounter[MAX_ENCOUNTER];
+        uint32 spheres[2];
 
-    std::string str_data;
+        uint8 InitiandCnt,
+            switchtrigger,
+            initiandkilled;
 
-    void Initialize()
-    {
-        memset(&m_auiEncounter, 0, sizeof(m_auiEncounter));
-        InitiandGUIDs.clear();
-
-        Elder_Nadox =0;
-        Prince_Taldaram =0;
-        Jedoga_Shadowseeker =0;
-        Herald_Volazj =0;
-        Amanitar =0;
-
-        spheres[0] = NOT_STARTED;
-        spheres[1] = NOT_STARTED;
-
-        InitiandCnt = 0;
-        switchtrigger = 0;
-        initiandkilled = 0;
-        JedogaSacrifices = 0;
-        JedogaTarget = 0;
-    }
-
-    bool IsEncounterInProgress() const
-    {
-        for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-            if (m_auiEncounter[i] == IN_PROGRESS) return true;
+        std::string str_data;
 
-        return false;
-    }
+        void Initialize()
+        {
+            memset(&m_auiEncounter, 0, sizeof(m_auiEncounter));
+            InitiandGUIDs.clear();
+
+            Elder_Nadox =0;
+            Prince_Taldaram =0;
+            Jedoga_Shadowseeker =0;
+            Herald_Volazj =0;
+            Amanitar =0;
+
+            spheres[0] = NOT_STARTED;
+            spheres[1] = NOT_STARTED;
+
+            InitiandCnt = 0;
+            switchtrigger = 0;
+            initiandkilled = 0;
+            JedogaSacrifices = 0;
+            JedogaTarget = 0;
+        }
 
-    void OnCreatureCreate(Creature* pCreature, bool /*add*/)
-    {
-        switch(pCreature->GetEntry())
+        bool IsEncounterInProgress() const
         {
-            case 29309: Elder_Nadox = pCreature->GetGUID();                     break;
-            case 29308: Prince_Taldaram = pCreature->GetGUID();                 break;
-            case 29310: Jedoga_Shadowseeker = pCreature->GetGUID();             break;
-            case 29311: Herald_Volazj = pCreature->GetGUID();                   break;
-            case 30258: Amanitar = pCreature->GetGUID();                        break;
-            case 30114: InitiandGUIDs.insert(pCreature->GetGUID());             break;
+            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
+                if (m_auiEncounter[i] == IN_PROGRESS) return true;
+
+            return false;
         }
-    }
 
-    void OnGameObjectCreate(GameObject* pGo, bool /*add*/)
-    {
-        switch(pGo->GetEntry())
+        void OnCreatureCreate(Creature* pCreature, bool /*add*/)
         {
-            case 193564:     Prince_TaldaramPlatform = pGo->GetGUID();
-                if (m_auiEncounter[1] == DONE) HandleGameObject(NULL,true,pGo); break;
-            case 193093:     Prince_TaldaramSpheres[0] = pGo->GetGUID();
-                if (spheres[0] == IN_PROGRESS)
-                {
-                    pGo->SetGoState(GO_STATE_ACTIVE);
-                    pGo->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
-                }
-                else pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
-                break;
-            case 193094:     Prince_TaldaramSpheres[1] = pGo->GetGUID();
-                if (spheres[1] == IN_PROGRESS)
-                {
-                    pGo->SetGoState(GO_STATE_ACTIVE);
-                    pGo->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
-                }
-                else pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
-                break;
-            case 192236:    Prince_TaldaramGate = pGo->GetGUID(); // Web gate past Prince Taldaram
-                if (m_auiEncounter[1] == DONE)HandleGameObject(NULL,true,pGo);break;
+            switch(pCreature->GetEntry())
+            {
+                case 29309: Elder_Nadox = pCreature->GetGUID();                     break;
+                case 29308: Prince_Taldaram = pCreature->GetGUID();                 break;
+                case 29310: Jedoga_Shadowseeker = pCreature->GetGUID();             break;
+                case 29311: Herald_Volazj = pCreature->GetGUID();                   break;
+                case 30258: Amanitar = pCreature->GetGUID();                        break;
+                case 30114: InitiandGUIDs.insert(pCreature->GetGUID());             break;
+            }
         }
-    }
 
-    void SetData64(uint32 idx, uint64 guid)
-    {
-        switch(idx)
+        void OnGameObjectCreate(GameObject* pGo, bool /*add*/)
         {
-            case DATA_ADD_JEDOGA_OPFER: JedogaSacrifices = guid; break;
-            case DATA_PL_JEDOGA_TARGET: JedogaTarget = guid; break;
+            switch(pGo->GetEntry())
+            {
+                case 193564:     Prince_TaldaramPlatform = pGo->GetGUID();
+                    if (m_auiEncounter[1] == DONE) HandleGameObject(NULL,true,pGo); break;
+                case 193093:     Prince_TaldaramSpheres[0] = pGo->GetGUID();
+                    if (spheres[0] == IN_PROGRESS)
+                    {
+                        pGo->SetGoState(GO_STATE_ACTIVE);
+                        pGo->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
+                    }
+                    else pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
+                    break;
+                case 193094:     Prince_TaldaramSpheres[1] = pGo->GetGUID();
+                    if (spheres[1] == IN_PROGRESS)
+                    {
+                        pGo->SetGoState(GO_STATE_ACTIVE);
+                        pGo->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
+                    }
+                    else pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_UNK1);
+                    break;
+                case 192236:    Prince_TaldaramGate = pGo->GetGUID(); // Web gate past Prince Taldaram
+                    if (m_auiEncounter[1] == DONE)HandleGameObject(NULL,true,pGo);break;
+            }
         }
-    }
 
-    uint64 GetData64(uint32 identifier)
-    {
-        switch(identifier)
+        void SetData64(uint32 idx, uint64 guid)
         {
-            case DATA_ELDER_NADOX:                return Elder_Nadox;
-            case DATA_PRINCE_TALDARAM:            return Prince_Taldaram;
-            case DATA_JEDOGA_SHADOWSEEKER:        return Jedoga_Shadowseeker;
-            case DATA_HERALD_VOLAZJ:              return Herald_Volazj;
-            case DATA_AMANITAR:                   return Amanitar;
-            case DATA_SPHERE1:                    return Prince_TaldaramSpheres[0];
-            case DATA_SPHERE2:                    return Prince_TaldaramSpheres[1];
-            case DATA_PRINCE_TALDARAM_PLATFORM:   return Prince_TaldaramPlatform;
-            case DATA_ADD_JEDOGA_INITIAND:
+            switch(idx)
             {
-                std::vector<uint64> vInitiands;
-                vInitiands.clear();
-                for (std::set<uint64>::const_iterator itr = InitiandGUIDs.begin(); itr != InitiandGUIDs.end(); ++itr)
-                {
-                    Creature* cr = instance->GetCreature(*itr);
-                    if (cr && cr->isAlive())
-                        vInitiands.push_back(*itr);
-                }
-                if (vInitiands.empty())
-                    return 0;
-                uint8 j = urand(0,vInitiands.size() -1);
-                return vInitiands[j];
+                case DATA_ADD_JEDOGA_OPFER: JedogaSacrifices = guid; break;
+                case DATA_PL_JEDOGA_TARGET: JedogaTarget = guid; break;
             }
-            case DATA_ADD_JEDOGA_OPFER: return JedogaSacrifices;
-            case DATA_PL_JEDOGA_TARGET: return JedogaTarget;
         }
-        return 0;
-    }
 
-    void SetData(uint32 type, uint32 data)
-    {
-        switch(type)
+        uint64 GetData64(uint32 identifier)
         {
-            case DATA_ELDER_NADOX_EVENT: m_auiEncounter[0] = data; break;
-            case DATA_PRINCE_TALDARAM_EVENT:
-                if (data == DONE)
-                    HandleGameObject(Prince_TaldaramGate,true);
-                m_auiEncounter[1] = data;
-                break;
-            case DATA_JEDOGA_SHADOWSEEKER_EVENT:
-                m_auiEncounter[2] = data;
-                if (data == DONE)
+            switch(identifier)
+            {
+                case DATA_ELDER_NADOX:                return Elder_Nadox;
+                case DATA_PRINCE_TALDARAM:            return Prince_Taldaram;
+                case DATA_JEDOGA_SHADOWSEEKER:        return Jedoga_Shadowseeker;
+                case DATA_HERALD_VOLAZJ:              return Herald_Volazj;
+                case DATA_AMANITAR:                   return Amanitar;
+                case DATA_SPHERE1:                    return Prince_TaldaramSpheres[0];
+                case DATA_SPHERE2:                    return Prince_TaldaramSpheres[1];
+                case DATA_PRINCE_TALDARAM_PLATFORM:   return Prince_TaldaramPlatform;
+                case DATA_ADD_JEDOGA_INITIAND:
                 {
+                    std::vector<uint64> vInitiands;
+                    vInitiands.clear();
                     for (std::set<uint64>::const_iterator itr = InitiandGUIDs.begin(); itr != InitiandGUIDs.end(); ++itr)
                     {
                         Creature* cr = instance->GetCreature(*itr);
                         if (cr && cr->isAlive())
+                            vInitiands.push_back(*itr);
+                    }
+                    if (vInitiands.empty())
+                        return 0;
+                    uint8 j = urand(0,vInitiands.size() -1);
+                    return vInitiands[j];
+                }
+                case DATA_ADD_JEDOGA_OPFER: return JedogaSacrifices;
+                case DATA_PL_JEDOGA_TARGET: return JedogaTarget;
+            }
+            return 0;
+        }
+
+        void SetData(uint32 type, uint32 data)
+        {
+            switch(type)
+            {
+                case DATA_ELDER_NADOX_EVENT: m_auiEncounter[0] = data; break;
+                case DATA_PRINCE_TALDARAM_EVENT:
+                    if (data == DONE)
+                        HandleGameObject(Prince_TaldaramGate,true);
+                    m_auiEncounter[1] = data;
+                    break;
+                case DATA_JEDOGA_SHADOWSEEKER_EVENT:
+                    m_auiEncounter[2] = data;
+                    if (data == DONE)
+                    {
+                        for (std::set<uint64>::const_iterator itr = InitiandGUIDs.begin(); itr != InitiandGUIDs.end(); ++itr)
                         {
-                            cr->SetVisibility(VISIBILITY_OFF);
-                            cr->setDeathState(JUST_DIED);
-                            cr->RemoveCorpse();
+                            Creature* cr = instance->GetCreature(*itr);
+                            if (cr && cr->isAlive())
+                            {
+                                cr->SetVisibility(VISIBILITY_OFF);
+                                cr->setDeathState(JUST_DIED);
+                                cr->RemoveCorpse();
+                            }
                         }
+                        if (!initiandkilled && instance->IsHeroic())
+                            DoCompleteAchievement(ACHIEV_VOLUNTEER_WORK);
                     }
-                    if (!initiandkilled && instance->IsHeroic())
-                        DoCompleteAchievement(ACHIEV_VOLUNTEER_WORK);
-                }
-                break;
-            case DATA_HERALD_VOLAZJ_EVENT: m_auiEncounter[3] = data; break;
-            case DATA_AMANITAR_EVENT: m_auiEncounter[4] = data; break;
-            case DATA_SPHERE1_EVENT: spheres[0] = data; break;
-            case DATA_SPHERE2_EVENT: spheres[1] = data; break;
-            case DATA_JEDOGA_TRIGGER_SWITCH: switchtrigger = data; break;
-            case DATA_INITIAND_KILLED: initiandkilled = data; break;
-            case DATA_JEDOGA_RESET_INITIANDS:
-                for (std::set<uint64>::const_iterator itr = InitiandGUIDs.begin(); itr != InitiandGUIDs.end(); ++itr)
-                {
-                    Creature* cr = instance->GetCreature(*itr);
-                    if (cr)
+                    break;
+                case DATA_HERALD_VOLAZJ_EVENT: m_auiEncounter[3] = data; break;
+                case DATA_AMANITAR_EVENT: m_auiEncounter[4] = data; break;
+                case DATA_SPHERE1_EVENT: spheres[0] = data; break;
+                case DATA_SPHERE2_EVENT: spheres[1] = data; break;
+                case DATA_JEDOGA_TRIGGER_SWITCH: switchtrigger = data; break;
+                case DATA_INITIAND_KILLED: initiandkilled = data; break;
+                case DATA_JEDOGA_RESET_INITIANDS:
+                    for (std::set<uint64>::const_iterator itr = InitiandGUIDs.begin(); itr != InitiandGUIDs.end(); ++itr)
                     {
-                        cr->Respawn();
-                        if (!cr->IsInEvadeMode()) cr->AI()->EnterEvadeMode();
+                        Creature* cr = instance->GetCreature(*itr);
+                        if (cr)
+                        {
+                            cr->Respawn();
+                            if (!cr->IsInEvadeMode()) cr->AI()->EnterEvadeMode();
+                        }
                     }
-                }
-                break;
+                    break;
+            }
+            if (data == DONE)
+                SaveToDB();
         }
-        if (data == DONE)
-            SaveToDB();
-    }
 
-    uint32 GetData(uint32 type)
-    {
-        switch(type)
+        uint32 GetData(uint32 type)
         {
-            case DATA_ELDER_NADOX_EVENT:            return m_auiEncounter[0];
-            case DATA_PRINCE_TALDARAM_EVENT:        return m_auiEncounter[1];
-            case DATA_JEDOGA_SHADOWSEEKER_EVENT:    return m_auiEncounter[2];
-            case DATA_HERALD_VOLAZJ:                return m_auiEncounter[3];
-            case DATA_AMANITAR_EVENT:                     return m_auiEncounter[4];
-            case DATA_SPHERE1_EVENT:                return spheres[0];
-            case DATA_SPHERE2_EVENT:                return spheres[1];
-            case DATA_ALL_INITIAND_DEAD:
-                for (std::set<uint64>::const_iterator itr = InitiandGUIDs.begin(); itr != InitiandGUIDs.end(); ++itr)
-                {
-                    Creature* cr = instance->GetCreature(*itr);
-                    if (!cr || (cr && cr->isAlive())) return 0;
-                }
-                return 1;
-            case DATA_JEDOGA_TRIGGER_SWITCH: return switchtrigger;
-            case DATA_INITIAND_KILLED: return initiandkilled;
+            switch(type)
+            {
+                case DATA_ELDER_NADOX_EVENT:            return m_auiEncounter[0];
+                case DATA_PRINCE_TALDARAM_EVENT:        return m_auiEncounter[1];
+                case DATA_JEDOGA_SHADOWSEEKER_EVENT:    return m_auiEncounter[2];
+                case DATA_HERALD_VOLAZJ:                return m_auiEncounter[3];
+                case DATA_AMANITAR_EVENT:                     return m_auiEncounter[4];
+                case DATA_SPHERE1_EVENT:                return spheres[0];
+                case DATA_SPHERE2_EVENT:                return spheres[1];
+                case DATA_ALL_INITIAND_DEAD:
+                    for (std::set<uint64>::const_iterator itr = InitiandGUIDs.begin(); itr != InitiandGUIDs.end(); ++itr)
+                    {
+                        Creature* cr = instance->GetCreature(*itr);
+                        if (!cr || (cr && cr->isAlive())) return 0;
+                    }
+                    return 1;
+                case DATA_JEDOGA_TRIGGER_SWITCH: return switchtrigger;
+                case DATA_INITIAND_KILLED: return initiandkilled;
+            }
+            return 0;
         }
-        return 0;
-    }
 
-    std::string GetSaveData()
-    {
-        OUT_SAVE_INST_DATA;
+        std::string GetSaveData()
+        {
+            OUT_SAVE_INST_DATA;
 
-        std::ostringstream saveStream;
-        saveStream << "A K " << m_auiEncounter[0] << " " << m_auiEncounter[1] << " "
-            << m_auiEncounter[2] << " " << m_auiEncounter[3] << " " << m_auiEncounter[4] << " "
-            << spheres[0] << " " << spheres[1];
+            std::ostringstream saveStream;
+            saveStream << "A K " << m_auiEncounter[0] << " " << m_auiEncounter[1] << " "
+                << m_auiEncounter[2] << " " << m_auiEncounter[3] << " " << m_auiEncounter[4] << " "
+                << spheres[0] << " " << spheres[1];
 
-        str_data = saveStream.str();
+            str_data = saveStream.str();
 
-        OUT_SAVE_INST_DATA_COMPLETE;
-        return str_data;
-    }
+            OUT_SAVE_INST_DATA_COMPLETE;
+            return str_data;
+        }
 
-    void Load(const char* in)
-    {
-        if (!in)
+        void Load(const char* in)
         {
-            OUT_LOAD_INST_DATA_FAIL;
-            return;
-        }
+            if (!in)
+            {
+                OUT_LOAD_INST_DATA_FAIL;
+                return;
+            }
 
-        OUT_LOAD_INST_DATA(in);
+            OUT_LOAD_INST_DATA(in);
 
-        char dataHead1, dataHead2;
-        uint16 data0, data1, data2, data3, data4, data5, data6;
+            char dataHead1, dataHead2;
+            uint16 data0, data1, data2, data3, data4, data5, data6;
 
-        std::istringstream loadStream(in);
-        loadStream >> dataHead1 >> dataHead2 >> data0 >> data1 >> data2 >> data3 >> data4 >> data5 >> data6;
+            std::istringstream loadStream(in);
+            loadStream >> dataHead1 >> dataHead2 >> data0 >> data1 >> data2 >> data3 >> data4 >> data5 >> data6;
 
-        if (dataHead1 == 'A' && dataHead2 == 'K')
-        {
-            m_auiEncounter[0] = data0;
-            m_auiEncounter[1] = data1;
-            m_auiEncounter[2] = data2;
-            m_auiEncounter[3] = data3;
-            m_auiEncounter[4] = data4;
+            if (dataHead1 == 'A' && dataHead2 == 'K')
+            {
+                m_auiEncounter[0] = data0;
+                m_auiEncounter[1] = data1;
+                m_auiEncounter[2] = data2;
+                m_auiEncounter[3] = data3;
+                m_auiEncounter[4] = data4;
 
-            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-                if (m_auiEncounter[i] == IN_PROGRESS)
-                    m_auiEncounter[i] = NOT_STARTED;
+                for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
+                    if (m_auiEncounter[i] == IN_PROGRESS)
+                        m_auiEncounter[i] = NOT_STARTED;
 
-            spheres[0] = data5;
-            spheres[1] = data6;
+                spheres[0] = data5;
+                spheres[1] = data6;
 
-        } else OUT_LOAD_INST_DATA_FAIL;
+            } else OUT_LOAD_INST_DATA_FAIL;
+
+            OUT_LOAD_INST_DATA_COMPLETE;
+        }
+    };
 
-        OUT_LOAD_INST_DATA_COMPLETE;
+    InstanceData* GetInstanceData(InstanceMap *map) const
+    {
+       return new instance_ahnkahet_ScriptedInstance(map);
     }
 };
 
-InstanceData* GetInstanceData_instance_ahnkahet(Map* pMap)
-{
-   return new instance_ahnkahet(pMap);
-}
-
 void AddSC_instance_ahnkahet()
 {
-   Script *newscript;
-   newscript = new Script;
-   newscript->Name = "instance_ahnkahet";
-   newscript->GetInstanceData = &GetInstanceData_instance_ahnkahet;
-   newscript->RegisterSelf();
+   new instance_ahnkahet;
 }
diff --git a/src/server/scripts/Northrend/DraktharonKeep/boss_dred.cpp b/src/server/scripts/Northrend/DraktharonKeep/boss_dred.cpp
index c03d3df15d8..c2234a4e4d0 100644
--- a/src/server/scripts/Northrend/DraktharonKeep/boss_dred.cpp
+++ b/src/server/scripts/Northrend/DraktharonKeep/boss_dred.cpp
@@ -46,224 +46,229 @@ enum Creatures
     NPC_RAPTOR_2                                  = 26628
 };
 
-struct boss_dredAI : public ScriptedAI
+class boss_dred : public CreatureScript
 {
-    boss_dredAI(Creature *c) : ScriptedAI(c)
-    {
-        pInstance = c->GetInstanceData();
-    }
-
-    uint32 uiBellowingRoarTimer;
-    uint32 uiGrievousBiteTimer;
-    uint32 uiManglingSlashTimer;
-    uint32 uiFearsomeRoarTimer;
-    uint32 uiPiercingSlashTimer;
-    uint32 uiRaptorCallTimer;
+public:
+    boss_dred() : CreatureScript("boss_dred") { }
 
-    ScriptedInstance* pInstance;
-
-    void Reset()
+    struct boss_dredAI : public ScriptedAI
     {
-        if (pInstance)
+        boss_dredAI(Creature *c) : ScriptedAI(c)
         {
-            pInstance->SetData(DATA_DRED_EVENT,NOT_STARTED);
-            pInstance->SetData(DATA_KING_DRED_ACHIEV, 0);
+            pInstance = c->GetInstanceData();
         }
 
-        uiBellowingRoarTimer = 33*IN_MILLISECONDS;
-        uiGrievousBiteTimer  = 20*IN_MILLISECONDS;
-        uiManglingSlashTimer = 18.5*IN_MILLISECONDS;
-        uiFearsomeRoarTimer  = urand(10*IN_MILLISECONDS,20*IN_MILLISECONDS);
-        uiPiercingSlashTimer = 17*IN_MILLISECONDS;
-        uiRaptorCallTimer    = urand(20*IN_MILLISECONDS,25*IN_MILLISECONDS);
-    }
-
-    void EnterCombat(Unit* /*who*/)
-    {
-        if (pInstance)
-            pInstance->SetData(DATA_DRED_EVENT,IN_PROGRESS);
-    }
+        uint32 uiBellowingRoarTimer;
+        uint32 uiGrievousBiteTimer;
+        uint32 uiManglingSlashTimer;
+        uint32 uiFearsomeRoarTimer;
+        uint32 uiPiercingSlashTimer;
+        uint32 uiRaptorCallTimer;
 
-    void UpdateAI(const uint32 diff)
-    {
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
+        ScriptedInstance* pInstance;
 
-        if (uiBellowingRoarTimer < diff)
+        void Reset()
         {
-            DoCastAOE(SPELL_BELLOWING_ROAR, false);
-            uiBellowingRoarTimer = 40*IN_MILLISECONDS;
-        } else uiBellowingRoarTimer -=diff;
+            if (pInstance)
+            {
+                pInstance->SetData(DATA_DRED_EVENT,NOT_STARTED);
+                pInstance->SetData(DATA_KING_DRED_ACHIEV, 0);
+            }
 
-        if (uiGrievousBiteTimer < diff)
-        {
-            DoCastVictim(SPELL_GRIEVOUS_BITE ,false);
-            uiGrievousBiteTimer = 20*IN_MILLISECONDS;
-        } else uiGrievousBiteTimer -=diff;
+            uiBellowingRoarTimer = 33*IN_MILLISECONDS;
+            uiGrievousBiteTimer  = 20*IN_MILLISECONDS;
+            uiManglingSlashTimer = 18.5*IN_MILLISECONDS;
+            uiFearsomeRoarTimer  = urand(10*IN_MILLISECONDS,20*IN_MILLISECONDS);
+            uiPiercingSlashTimer = 17*IN_MILLISECONDS;
+            uiRaptorCallTimer    = urand(20*IN_MILLISECONDS,25*IN_MILLISECONDS);
+        }
 
-        if (uiManglingSlashTimer < diff)
+        void EnterCombat(Unit* /*who*/)
         {
-            DoCastVictim(SPELL_MANGLING_SLASH,false);
-            uiManglingSlashTimer = 20*IN_MILLISECONDS;
-        } else uiManglingSlashTimer -=diff;
+            if (pInstance)
+                pInstance->SetData(DATA_DRED_EVENT,IN_PROGRESS);
+        }
 
-        if (uiFearsomeRoarTimer < diff)
+        void UpdateAI(const uint32 diff)
         {
-            DoCastAOE(SPELL_FEARSOME_ROAR,false);
-            uiFearsomeRoarTimer = urand(16*IN_MILLISECONDS,18*IN_MILLISECONDS);
-        } else uiFearsomeRoarTimer -=diff;
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
 
-        if (uiPiercingSlashTimer < diff)
-        {
-            DoCastVictim(SPELL_PIERCING_SLASH,false);
-            uiPiercingSlashTimer = 20*IN_MILLISECONDS;
-        } else uiPiercingSlashTimer -=diff;
+            if (uiBellowingRoarTimer < diff)
+            {
+                DoCastAOE(SPELL_BELLOWING_ROAR, false);
+                uiBellowingRoarTimer = 40*IN_MILLISECONDS;
+            } else uiBellowingRoarTimer -=diff;
 
-        if (uiRaptorCallTimer < diff)
-        {
-            DoCastVictim(SPELL_RAPTOR_CALL,false);
+            if (uiGrievousBiteTimer < diff)
+            {
+                DoCastVictim(SPELL_GRIEVOUS_BITE ,false);
+                uiGrievousBiteTimer = 20*IN_MILLISECONDS;
+            } else uiGrievousBiteTimer -=diff;
+
+            if (uiManglingSlashTimer < diff)
+            {
+                DoCastVictim(SPELL_MANGLING_SLASH,false);
+                uiManglingSlashTimer = 20*IN_MILLISECONDS;
+            } else uiManglingSlashTimer -=diff;
 
-            float x,y,z;
+            if (uiFearsomeRoarTimer < diff)
+            {
+                DoCastAOE(SPELL_FEARSOME_ROAR,false);
+                uiFearsomeRoarTimer = urand(16*IN_MILLISECONDS,18*IN_MILLISECONDS);
+            } else uiFearsomeRoarTimer -=diff;
 
-            me->GetClosePoint(x,y,z,me->GetObjectSize()/3,10.0f);
-            me->SummonCreature(RAND(NPC_RAPTOR_1,NPC_RAPTOR_2),x,y,z,0,TEMPSUMMON_DEAD_DESPAWN,1*IN_MILLISECONDS);
+            if (uiPiercingSlashTimer < diff)
+            {
+                DoCastVictim(SPELL_PIERCING_SLASH,false);
+                uiPiercingSlashTimer = 20*IN_MILLISECONDS;
+            } else uiPiercingSlashTimer -=diff;
 
-            uiRaptorCallTimer = urand(20*IN_MILLISECONDS,25*IN_MILLISECONDS);
-        } else uiRaptorCallTimer -=diff;
+            if (uiRaptorCallTimer < diff)
+            {
+                DoCastVictim(SPELL_RAPTOR_CALL,false);
 
-        DoMeleeAttackIfReady();
-    }
+                float x,y,z;
 
-    void JustDied(Unit* /*killer*/)
-    {
-        if (pInstance)
+                me->GetClosePoint(x,y,z,me->GetObjectSize()/3,10.0f);
+                me->SummonCreature(RAND(NPC_RAPTOR_1,NPC_RAPTOR_2),x,y,z,0,TEMPSUMMON_DEAD_DESPAWN,1*IN_MILLISECONDS);
+
+                uiRaptorCallTimer = urand(20*IN_MILLISECONDS,25*IN_MILLISECONDS);
+            } else uiRaptorCallTimer -=diff;
+
+            DoMeleeAttackIfReady();
+        }
+
+        void JustDied(Unit* /*killer*/)
         {
-            pInstance->SetData(DATA_DRED_EVENT,DONE);
+            if (pInstance)
+            {
+                pInstance->SetData(DATA_DRED_EVENT,DONE);
 
-            if (IsHeroic() && pInstance->GetData(DATA_KING_DRED_ACHIEV) == 6)
-                pInstance->DoCompleteAchievement(ACHIEV_BETTER_OFF_DRED);
+                if (IsHeroic() && pInstance->GetData(DATA_KING_DRED_ACHIEV) == 6)
+                    pInstance->DoCompleteAchievement(ACHIEV_BETTER_OFF_DRED);
+            }
         }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new boss_dredAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_dred(Creature* pCreature)
+class npc_drakkari_gutripper : public CreatureScript
 {
-    return new boss_dredAI (pCreature);
-}
+public:
+    npc_drakkari_gutripper() : CreatureScript("npc_drakkari_gutripper") { }
 
-struct npc_drakkari_gutripperAI : public ScriptedAI
-{
-    npc_drakkari_gutripperAI(Creature *c) : ScriptedAI(c)
+    struct npc_drakkari_gutripperAI : public ScriptedAI
     {
-        pInstance = c->GetInstanceData();
-    }
-
-    ScriptedInstance* pInstance;
-
-    uint32 GutRipTimer;
+        npc_drakkari_gutripperAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-    void Reset()
-    {
-        GutRipTimer = urand(10000,15000);
-    }
+        ScriptedInstance* pInstance;
 
-    void UpdateAI(const uint32 diff)
-    {
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
+        uint32 GutRipTimer;
 
-        if (GutRipTimer < diff)
+        void Reset()
         {
-            DoCastVictim(SPELL_GUT_RIP,false);
             GutRipTimer = urand(10000,15000);
-        }else GutRipTimer -=diff;
+        }
 
-        DoMeleeAttackIfReady();
-    }
+        void UpdateAI(const uint32 diff)
+        {
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
 
-    void JustDied(Unit* /*killer*/)
-    {
-        if (pInstance)
+            if (GutRipTimer < diff)
+            {
+                DoCastVictim(SPELL_GUT_RIP,false);
+                GutRipTimer = urand(10000,15000);
+            }else GutRipTimer -=diff;
+
+            DoMeleeAttackIfReady();
+        }
+
+        void JustDied(Unit* /*killer*/)
         {
-            if (IsHeroic() && pInstance->GetData(DATA_DRED_EVENT) == IN_PROGRESS && pInstance->GetData(DATA_KING_DRED_ACHIEV) < 6)
+            if (pInstance)
             {
-                pInstance->SetData(DATA_KING_DRED_ACHIEV, pInstance->GetData(DATA_KING_DRED_ACHIEV) + 1);
+                if (IsHeroic() && pInstance->GetData(DATA_DRED_EVENT) == IN_PROGRESS && pInstance->GetData(DATA_KING_DRED_ACHIEV) < 6)
+                {
+                    pInstance->SetData(DATA_KING_DRED_ACHIEV, pInstance->GetData(DATA_KING_DRED_ACHIEV) + 1);
+                }
             }
         }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new npc_drakkari_gutripperAI(creature);
     }
 };
 
-CreatureAI* GetAI_npc_drakkari_gutripper(Creature* pCreature)
+class npc_drakkari_scytheclaw : public CreatureScript
 {
-    return new npc_drakkari_gutripperAI (pCreature);
-}
+public:
+    npc_drakkari_scytheclaw() : CreatureScript("npc_drakkari_scytheclaw") { }
 
-struct npc_drakkari_scytheclawAI : public ScriptedAI
-{
-    npc_drakkari_scytheclawAI(Creature *c) : ScriptedAI(c)
+    struct npc_drakkari_scytheclawAI : public ScriptedAI
     {
-        pInstance = c->GetInstanceData();
-    }
-
-    ScriptedInstance* pInstance;
-
-    uint32 uiRendTimer;
+        npc_drakkari_scytheclawAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-    void Reset()
-    {
-        uiRendTimer = urand(10*IN_MILLISECONDS,15*IN_MILLISECONDS);
-    }
+        ScriptedInstance* pInstance;
 
-    void UpdateAI(const uint32 diff)
-    {
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
+        uint32 uiRendTimer;
 
-        if (uiRendTimer < diff)
+        void Reset()
         {
-            DoCastVictim(SPELL_REND,false);
             uiRendTimer = urand(10*IN_MILLISECONDS,15*IN_MILLISECONDS);
-        }else uiRendTimer -=diff;
+        }
 
-        DoMeleeAttackIfReady();
-    }
+        void UpdateAI(const uint32 diff)
+        {
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
 
-    void JustDied(Unit* /*killer*/)
-    {
-        if (pInstance)
+            if (uiRendTimer < diff)
+            {
+                DoCastVictim(SPELL_REND,false);
+                uiRendTimer = urand(10*IN_MILLISECONDS,15*IN_MILLISECONDS);
+            }else uiRendTimer -=diff;
+
+            DoMeleeAttackIfReady();
+        }
+
+        void JustDied(Unit* /*killer*/)
         {
-            if (IsHeroic() && pInstance->GetData(DATA_DRED_EVENT) == IN_PROGRESS && pInstance->GetData(DATA_KING_DRED_ACHIEV) < 6)
+            if (pInstance)
             {
-                pInstance->SetData(DATA_KING_DRED_ACHIEV, pInstance->GetData(DATA_KING_DRED_ACHIEV) + 1);
+                if (IsHeroic() && pInstance->GetData(DATA_DRED_EVENT) == IN_PROGRESS && pInstance->GetData(DATA_KING_DRED_ACHIEV) < 6)
+                {
+                    pInstance->SetData(DATA_KING_DRED_ACHIEV, pInstance->GetData(DATA_KING_DRED_ACHIEV) + 1);
+                }
             }
         }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new npc_drakkari_scytheclawAI(creature);
     }
 };
 
-CreatureAI* GetAI_npc_drakkari_scytheclaw(Creature* pCreature)
-{
-    return new npc_drakkari_scytheclawAI (pCreature);
-}
-
 void AddSC_boss_dred()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "npc_drakkari_gutripper";
-    newscript->GetAI = &GetAI_npc_drakkari_gutripper;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "npc_drakkari_scytheclaw";
-    newscript->GetAI = &GetAI_npc_drakkari_scytheclaw;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "boss_dred";
-    newscript->GetAI = &GetAI_boss_dred;
-    newscript->RegisterSelf();
+    new npc_drakkari_gutripper;
+    new npc_drakkari_scytheclaw;
+    new boss_dred;
 }
diff --git a/src/server/scripts/Northrend/DraktharonKeep/boss_novos.cpp b/src/server/scripts/Northrend/DraktharonKeep/boss_novos.cpp
index e8abb804417..815c60d72cf 100644
--- a/src/server/scripts/Northrend/DraktharonKeep/boss_novos.cpp
+++ b/src/server/scripts/Northrend/DraktharonKeep/boss_novos.cpp
@@ -63,157 +63,168 @@ static Position AddSpawnPoint = { -379.20, -816.76, 59.70 };
 static Position CrystalHandlerSpawnPoint = { -326.626343, -709.956604, 27.813314 };
 static Position AddDestinyPoint = { -379.314545, -772.577637, 28.58837 };
 
-struct boss_novosAI : public Scripted_NoMovementAI
+class boss_novos : public CreatureScript
 {
-    boss_novosAI(Creature *c) : Scripted_NoMovementAI(c), lSummons(me)
+public:
+    boss_novos() : CreatureScript("boss_novos") { }
+
+    struct boss_novosAI : public Scripted_NoMovementAI
     {
-        pInstance = c->GetInstanceData();
-    }
+        boss_novosAI(Creature *c) : Scripted_NoMovementAI(c), lSummons(me)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-    uint32 uiTimer;
-    uint32 uiCrystalHandlerTimer;
+        uint32 uiTimer;
+        uint32 uiCrystalHandlerTimer;
 
-    bool bAchiev;
+        bool bAchiev;
 
-    SummonList lSummons;
+        SummonList lSummons;
 
-    std::list<uint64> luiCrystals;
+        std::list<uint64> luiCrystals;
 
-    CombatPhase Phase;
+        CombatPhase Phase;
 
-    ScriptedInstance* pInstance;
+        ScriptedInstance* pInstance;
 
-    void Reset()
-    {
-        Phase = IDLE;
-        luiCrystals.clear();
-        bAchiev = true;
-        me->CastStop();
-        lSummons.DespawnAll();
-
-        if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE))
-            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
-        if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE))
-            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
-        if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))
-            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-
-        if (pInstance)
+        void Reset()
         {
-            pInstance->SetData(DATA_NOVOS_EVENT, NOT_STARTED);
-            luiCrystals.push_back(pInstance->GetData64(DATA_NOVOS_CRYSTAL_1));
-            luiCrystals.push_back(pInstance->GetData64(DATA_NOVOS_CRYSTAL_2));
-            luiCrystals.push_back(pInstance->GetData64(DATA_NOVOS_CRYSTAL_3));
-            luiCrystals.push_back(pInstance->GetData64(DATA_NOVOS_CRYSTAL_4));
-            for (std::list<uint64>::const_iterator itr = luiCrystals.begin(); itr != luiCrystals.end(); ++itr)
+            Phase = IDLE;
+            luiCrystals.clear();
+            bAchiev = true;
+            me->CastStop();
+            lSummons.DespawnAll();
+
+            if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE))
+                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
+            if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE))
+                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
+            if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))
+                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
+
+            if (pInstance)
             {
-                if (GameObject* pTemp = pInstance->instance->GetGameObject(*itr))
-                    pTemp->SetGoState(GO_STATE_READY);
+                pInstance->SetData(DATA_NOVOS_EVENT, NOT_STARTED);
+                luiCrystals.push_back(pInstance->GetData64(DATA_NOVOS_CRYSTAL_1));
+                luiCrystals.push_back(pInstance->GetData64(DATA_NOVOS_CRYSTAL_2));
+                luiCrystals.push_back(pInstance->GetData64(DATA_NOVOS_CRYSTAL_3));
+                luiCrystals.push_back(pInstance->GetData64(DATA_NOVOS_CRYSTAL_4));
+                for (std::list<uint64>::const_iterator itr = luiCrystals.begin(); itr != luiCrystals.end(); ++itr)
+                {
+                    if (GameObject* pTemp = pInstance->instance->GetGameObject(*itr))
+                        pTemp->SetGoState(GO_STATE_READY);
+                }
             }
         }
-    }
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        DoScriptText(SAY_AGGRO, me);
-        Phase = PHASE_1;
-        uiCrystalHandlerTimer = 30*IN_MILLISECONDS;
-        uiTimer = 1*IN_MILLISECONDS;
-        DoCast(SPELL_ARCANE_FIELD);
-        if (pInstance)
+        void EnterCombat(Unit* /*who*/)
         {
-            for (std::list<uint64>::const_iterator itr = luiCrystals.begin(); itr != luiCrystals.end(); ++itr)
+            DoScriptText(SAY_AGGRO, me);
+            Phase = PHASE_1;
+            uiCrystalHandlerTimer = 30*IN_MILLISECONDS;
+            uiTimer = 1*IN_MILLISECONDS;
+            DoCast(SPELL_ARCANE_FIELD);
+            if (pInstance)
             {
-                if (GameObject *pTemp = pInstance->instance->GetGameObject(*itr))
-                    pTemp->SetGoState(GO_STATE_ACTIVE);
+                for (std::list<uint64>::const_iterator itr = luiCrystals.begin(); itr != luiCrystals.end(); ++itr)
+                {
+                    if (GameObject *pTemp = pInstance->instance->GetGameObject(*itr))
+                        pTemp->SetGoState(GO_STATE_ACTIVE);
+                }
+                pInstance->SetData(DATA_NOVOS_EVENT, IN_PROGRESS);
             }
-            pInstance->SetData(DATA_NOVOS_EVENT, IN_PROGRESS);
+            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
+            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
+            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
         }
-        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
-        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
-        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-    }
 
-    void UpdateAI(const uint32 diff)
-    {
-        switch (Phase)
+        void UpdateAI(const uint32 diff)
         {
-            case PHASE_1:
-                if (uiTimer <= diff)
-                {
-                    Creature *pSummon = me->SummonCreature(RAND(CREATURE_FETID_TROLL_CORPSE,CREATURE_HULKING_CORPSE,CREATURE_RISEN_SHADOWCASTER), AddSpawnPoint, TEMPSUMMON_CORPSE_TIMED_DESPAWN,20*IN_MILLISECONDS);
-                    pSummon->GetMotionMaster()->MovePoint(0, AddDestinyPoint);
-                    //If spell is casted stops casting arcane field so no spell casting
-                    //DoCast(me, SPELL_SUMMON_MINIONS);
-                    uiTimer = 3*IN_MILLISECONDS;
-                } else uiTimer -= diff;
-                if (uiCrystalHandlerTimer <= diff)
-                {
-                    DoScriptText(SAY_NECRO_ADD, me);
-                    Creature *pCrystalHandler = me->SummonCreature(CREATURE_CRYSTAL_HANDLER, CrystalHandlerSpawnPoint, TEMPSUMMON_CORPSE_TIMED_DESPAWN,20*IN_MILLISECONDS);
-                    pCrystalHandler->GetMotionMaster()->MovePoint(0, AddDestinyPoint);
-                    uiCrystalHandlerTimer = urand(20*IN_MILLISECONDS,30*IN_MILLISECONDS);
-                } else uiCrystalHandlerTimer -= diff;
-                break;
-            case PHASE_2:
-                if (uiTimer <= diff)
-                {
-                    if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                        DoCast(pTarget, DUNGEON_MODE(RAND(SPELL_ARCANE_BLAST,SPELL_BLIZZARD,SPELL_FROSTBOLT,SPELL_WRATH_OF_MISERY),
-                                                     RAND(H_SPELL_ARCANE_BLAST,H_SPELL_BLIZZARD,H_SPELL_FROSTBOLT,H_SPELL_WRATH_OF_MISERY)));
-                    uiTimer = urand(1*IN_MILLISECONDS,3*IN_MILLISECONDS);
-                } else uiTimer -= diff;
-                break;
+            switch (Phase)
+            {
+                case PHASE_1:
+                    if (uiTimer <= diff)
+                    {
+                        Creature *pSummon = me->SummonCreature(RAND(CREATURE_FETID_TROLL_CORPSE,CREATURE_HULKING_CORPSE,CREATURE_RISEN_SHADOWCASTER), AddSpawnPoint, TEMPSUMMON_CORPSE_TIMED_DESPAWN,20*IN_MILLISECONDS);
+                        pSummon->GetMotionMaster()->MovePoint(0, AddDestinyPoint);
+                        //If spell is casted stops casting arcane field so no spell casting
+                        //DoCast(me, SPELL_SUMMON_MINIONS);
+                        uiTimer = 3*IN_MILLISECONDS;
+                    } else uiTimer -= diff;
+                    if (uiCrystalHandlerTimer <= diff)
+                    {
+                        DoScriptText(SAY_NECRO_ADD, me);
+                        Creature *pCrystalHandler = me->SummonCreature(CREATURE_CRYSTAL_HANDLER, CrystalHandlerSpawnPoint, TEMPSUMMON_CORPSE_TIMED_DESPAWN,20*IN_MILLISECONDS);
+                        pCrystalHandler->GetMotionMaster()->MovePoint(0, AddDestinyPoint);
+                        uiCrystalHandlerTimer = urand(20*IN_MILLISECONDS,30*IN_MILLISECONDS);
+                    } else uiCrystalHandlerTimer -= diff;
+                    break;
+                case PHASE_2:
+                    if (uiTimer <= diff)
+                    {
+                        if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                            DoCast(pTarget, DUNGEON_MODE(RAND(SPELL_ARCANE_BLAST,SPELL_BLIZZARD,SPELL_FROSTBOLT,SPELL_WRATH_OF_MISERY),
+                                                         RAND(H_SPELL_ARCANE_BLAST,H_SPELL_BLIZZARD,H_SPELL_FROSTBOLT,H_SPELL_WRATH_OF_MISERY)));
+                        uiTimer = urand(1*IN_MILLISECONDS,3*IN_MILLISECONDS);
+                    } else uiTimer -= diff;
+                    break;
+            }
         }
-    }
-    void JustDied(Unit* /*killer*/)
-    {
-        DoScriptText(SAY_DEATH, me);
-        if (pInstance)
+        void JustDied(Unit* /*killer*/)
         {
-            pInstance->SetData(DATA_NOVOS_EVENT, DONE);
+            DoScriptText(SAY_DEATH, me);
+            if (pInstance)
+            {
+                pInstance->SetData(DATA_NOVOS_EVENT, DONE);
 
-            if (IsHeroic() && bAchiev)
-                pInstance->DoCompleteAchievement(ACHIEV_OH_NOVOS);
+                if (IsHeroic() && bAchiev)
+                    pInstance->DoCompleteAchievement(ACHIEV_OH_NOVOS);
+            }
+            lSummons.DespawnAll();
         }
-        lSummons.DespawnAll();
-    }
 
-    void KilledUnit(Unit * victim)
-    {
-        if (victim == me)
-            return;
-        DoScriptText(SAY_KILL, me);
-    }
+        void KilledUnit(Unit * victim)
+        {
+            if (victim == me)
+                return;
+            DoScriptText(SAY_KILL, me);
+        }
 
-    void JustSummoned(Creature *summon)
-    {
-        lSummons.Summon(summon);
-    }
+        void JustSummoned(Creature *summon)
+        {
+            lSummons.Summon(summon);
+        }
 
-    void RemoveCrystal()
-    {
-        if (!luiCrystals.empty())
+        void RemoveCrystal()
         {
-            if (pInstance)
-                if (GameObject *pTemp = pInstance->instance->GetGameObject(luiCrystals.back()))
-                    pTemp->SetGoState(GO_STATE_READY);
-            luiCrystals.pop_back();
+            if (!luiCrystals.empty())
+            {
+                if (pInstance)
+                    if (GameObject *pTemp = pInstance->instance->GetGameObject(luiCrystals.back()))
+                        pTemp->SetGoState(GO_STATE_READY);
+                luiCrystals.pop_back();
+            }
+            if (luiCrystals.empty())
+            {
+                me->CastStop();
+                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
+                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
+                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
+                Phase = PHASE_2;
+                uiTimer = 1*IN_MILLISECONDS;
+            }
         }
-        if (luiCrystals.empty())
+
+        Unit* GetRandomTarget()
         {
-            me->CastStop();
-            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
-            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
-            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-            Phase = PHASE_2;
-            uiTimer = 1*IN_MILLISECONDS;
+            return SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
         }
-    }
+    };
 
-    Unit* GetRandomTarget()
+    CreatureAI *GetAI(Creature *creature) const
     {
-        return SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
+        return new boss_novosAI(creature);
     }
 };
 
@@ -223,105 +234,99 @@ enum CrystalHandlerSpells
     H_SPELL_FLASH_OF_DARKNESS                     = 59004
 };
 
-struct mob_crystal_handlerAI : public ScriptedAI
+class mob_crystal_handler : public CreatureScript
 {
-    mob_crystal_handlerAI(Creature *c) : ScriptedAI(c)
-    {
-        pInstance = c->GetInstanceData();
-    }
-
-    uint32 uiFlashOfDarknessTimer;
-
-    ScriptedInstance *pInstance;
+public:
+    mob_crystal_handler() : CreatureScript("mob_crystal_handler") { }
 
-    void Reset()
+    struct mob_crystal_handlerAI : public ScriptedAI
     {
-        uiFlashOfDarknessTimer = 5*IN_MILLISECONDS;
-    }
+        mob_crystal_handlerAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-    void JustDied(Unit* /*killer*/)
-    {
-        if (Creature* pNovos = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_NOVOS) : 0))
-            CAST_AI(boss_novosAI,pNovos->AI())->RemoveCrystal();
-    }
+        uint32 uiFlashOfDarknessTimer;
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
+        ScriptedInstance *pInstance;
 
-        if (uiFlashOfDarknessTimer <= diff)
+        void Reset()
         {
-            DoCast(me->getVictim(), DUNGEON_MODE(SPELL_FLASH_OF_DARKNESS,H_SPELL_FLASH_OF_DARKNESS));
             uiFlashOfDarknessTimer = 5*IN_MILLISECONDS;
-        } else uiFlashOfDarknessTimer -= diff;
+        }
 
-        DoMeleeAttackIfReady();
-    }
+        void JustDied(Unit* /*killer*/)
+        {
+            if (Creature* pNovos = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_NOVOS) : 0))
+                CAST_AI(boss_novos::boss_novosAI,pNovos->AI())->RemoveCrystal();
+        }
+
+        void UpdateAI(const uint32 diff)
+        {
+            if (!UpdateVictim())
+                return;
+
+            if (uiFlashOfDarknessTimer <= diff)
+            {
+                DoCast(me->getVictim(), DUNGEON_MODE(SPELL_FLASH_OF_DARKNESS,H_SPELL_FLASH_OF_DARKNESS));
+                uiFlashOfDarknessTimer = 5*IN_MILLISECONDS;
+            } else uiFlashOfDarknessTimer -= diff;
+
+            DoMeleeAttackIfReady();
+        }
 
-    void MovementInform(uint32 type, uint32 id)
+        void MovementInform(uint32 type, uint32 id)
+        {
+            if (type != POINT_MOTION_TYPE || id != 0)
+                return;
+            if (Creature *pNovos = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_NOVOS) : 0))
+                if (Unit *pTarget = CAST_AI(boss_novos::boss_novosAI, pNovos->AI())->GetRandomTarget())
+                    AttackStart(pTarget);
+        }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
     {
-        if (type != POINT_MOTION_TYPE || id != 0)
-            return;
-        if (Creature *pNovos = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_NOVOS) : 0))
-            if (Unit *pTarget = CAST_AI(boss_novosAI, pNovos->AI())->GetRandomTarget())
-                AttackStart(pTarget);
+        return new mob_crystal_handlerAI(creature);
     }
 };
 
-struct mob_novos_minionAI : public ScriptedAI
+class mob_novos_minion : public CreatureScript
 {
-    mob_novos_minionAI(Creature *c) : ScriptedAI(c)
-    {
-        pInstance = c->GetInstanceData();
-    }
-
-    ScriptedInstance *pInstance;
+public:
+    mob_novos_minion() : CreatureScript("mob_novos_minion") { }
 
-    void MovementInform(uint32 type, uint32 id)
+    struct mob_novos_minionAI : public ScriptedAI
     {
-        if (type != POINT_MOTION_TYPE || id !=0)
-            return;
-        if (Creature* pNovos = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_NOVOS) : 0))
+        mob_novos_minionAI(Creature *c) : ScriptedAI(c)
         {
-            CAST_AI(boss_novosAI, pNovos->AI())->bAchiev = false;
-            if (Unit *pTarget = CAST_AI(boss_novosAI, pNovos->AI())->GetRandomTarget())
-                AttackStart(pTarget);
+            pInstance = c->GetInstanceData();
         }
-    }
-};
 
-CreatureAI* GetAI_boss_novos(Creature* pCreature)
-{
-    return new boss_novosAI (pCreature);
-}
+        ScriptedInstance *pInstance;
 
-CreatureAI* GetAI_mob_crystal_handler(Creature* pCreature)
-{
-    return new mob_crystal_handlerAI (pCreature);
-}
+        void MovementInform(uint32 type, uint32 id)
+        {
+            if (type != POINT_MOTION_TYPE || id !=0)
+                return;
+            if (Creature* pNovos = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_NOVOS) : 0))
+            {
+                CAST_AI(boss_novos::boss_novosAI, pNovos->AI())->bAchiev = false;
+                if (Unit *pTarget = CAST_AI(boss_novos::boss_novosAI, pNovos->AI())->GetRandomTarget())
+                    AttackStart(pTarget);
+            }
+        }
+    };
 
-CreatureAI* GetAI_mob_novos_minion(Creature* pCreature)
-{
-    return new mob_novos_minionAI (pCreature);
-}
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_novos_minionAI(creature);
+    }
+};
 
 void AddSC_boss_novos()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_novos";
-    newscript->GetAI = &GetAI_boss_novos;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "mob_crystal_handler";
-    newscript->GetAI = &GetAI_mob_crystal_handler;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "mob_novos_minion";
-    newscript->GetAI = &GetAI_mob_novos_minion;
-    newscript->RegisterSelf();
+    new boss_novos;
+    new mob_crystal_handler;
+    new mob_novos_minion;
 }
diff --git a/src/server/scripts/Northrend/DraktharonKeep/boss_tharon_ja.cpp b/src/server/scripts/Northrend/DraktharonKeep/boss_tharon_ja.cpp
index 46121f49849..be211cc3560 100644
--- a/src/server/scripts/Northrend/DraktharonKeep/boss_tharon_ja.cpp
+++ b/src/server/scripts/Northrend/DraktharonKeep/boss_tharon_ja.cpp
@@ -64,196 +64,196 @@ enum CombatPhase
     GOING_SKELETAL
 };
 
-struct boss_tharon_jaAI : public ScriptedAI
+class boss_tharon_ja : public CreatureScript
 {
-    boss_tharon_jaAI(Creature *c) : ScriptedAI(c)
+public:
+    boss_tharon_ja() : CreatureScript("boss_tharon_ja") { }
+
+    struct boss_tharon_jaAI : public ScriptedAI
     {
-        pInstance = c->GetInstanceData();
-    }
+        boss_tharon_jaAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-    uint32 uiPhaseTimer;
-    uint32 uiCurseOfLifeTimer;
-    uint32 uiRainOfFireTimer;
-    uint32 uiShadowVolleyTimer;
-    uint32 uiEyeBeamTimer;
-    uint32 uiLightningBreathTimer;
-    uint32 uiPoisonCloudTimer;
+        uint32 uiPhaseTimer;
+        uint32 uiCurseOfLifeTimer;
+        uint32 uiRainOfFireTimer;
+        uint32 uiShadowVolleyTimer;
+        uint32 uiEyeBeamTimer;
+        uint32 uiLightningBreathTimer;
+        uint32 uiPoisonCloudTimer;
 
-    CombatPhase Phase;
+        CombatPhase Phase;
 
-    ScriptedInstance* pInstance;
+        ScriptedInstance* pInstance;
 
-    void Reset()
-    {
-        uiPhaseTimer = 20*IN_MILLISECONDS;
-        uiCurseOfLifeTimer = 1*IN_MILLISECONDS;
-        uiRainOfFireTimer = urand(14*IN_MILLISECONDS,18*IN_MILLISECONDS);
-        uiShadowVolleyTimer = urand(8*IN_MILLISECONDS,10*IN_MILLISECONDS);
-        Phase = SKELETAL;
-        me->SetDisplayId(me->GetNativeDisplayId());
-        if (pInstance)
-            pInstance->SetData(DATA_THARON_JA_EVENT, NOT_STARTED);
-    }
-
-    void EnterCombat(Unit* /*who*/)
-    {
-        DoScriptText(SAY_AGGRO, me);
+        void Reset()
+        {
+            uiPhaseTimer = 20*IN_MILLISECONDS;
+            uiCurseOfLifeTimer = 1*IN_MILLISECONDS;
+            uiRainOfFireTimer = urand(14*IN_MILLISECONDS,18*IN_MILLISECONDS);
+            uiShadowVolleyTimer = urand(8*IN_MILLISECONDS,10*IN_MILLISECONDS);
+            Phase = SKELETAL;
+            me->SetDisplayId(me->GetNativeDisplayId());
+            if (pInstance)
+                pInstance->SetData(DATA_THARON_JA_EVENT, NOT_STARTED);
+        }
 
-        if (pInstance)
-            pInstance->SetData(DATA_THARON_JA_EVENT, IN_PROGRESS);
-    }
+        void EnterCombat(Unit* /*who*/)
+        {
+            DoScriptText(SAY_AGGRO, me);
 
-    void UpdateAI(const uint32 diff)
-    {
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
+            if (pInstance)
+                pInstance->SetData(DATA_THARON_JA_EVENT, IN_PROGRESS);
+        }
 
-        switch (Phase)
+        void UpdateAI(const uint32 diff)
         {
-            case SKELETAL:
-                if (uiCurseOfLifeTimer < diff)
-                {
-                    if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                        DoCast(pTarget, SPELL_CURSE_OF_LIFE);
-                    uiCurseOfLifeTimer = urand(10*IN_MILLISECONDS,15*IN_MILLISECONDS);
-                } else uiCurseOfLifeTimer -= diff;
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
 
-                if (uiShadowVolleyTimer < diff)
-                {
-                    DoCastVictim(SPELL_SHADOW_VOLLEY);
-                    uiShadowVolleyTimer = urand(8*IN_MILLISECONDS,10*IN_MILLISECONDS);
-                } else uiShadowVolleyTimer -= diff;
+            switch (Phase)
+            {
+                case SKELETAL:
+                    if (uiCurseOfLifeTimer < diff)
+                    {
+                        if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                            DoCast(pTarget, SPELL_CURSE_OF_LIFE);
+                        uiCurseOfLifeTimer = urand(10*IN_MILLISECONDS,15*IN_MILLISECONDS);
+                    } else uiCurseOfLifeTimer -= diff;
+
+                    if (uiShadowVolleyTimer < diff)
+                    {
+                        DoCastVictim(SPELL_SHADOW_VOLLEY);
+                        uiShadowVolleyTimer = urand(8*IN_MILLISECONDS,10*IN_MILLISECONDS);
+                    } else uiShadowVolleyTimer -= diff;
 
-                if (uiRainOfFireTimer < diff)
-                {
-                    DoCastAOE(SPELL_RAIN_OF_FIRE);
-                    uiRainOfFireTimer = urand(14*IN_MILLISECONDS,18*IN_MILLISECONDS);
-                } else uiRainOfFireTimer -= diff;
+                    if (uiRainOfFireTimer < diff)
+                    {
+                        DoCastAOE(SPELL_RAIN_OF_FIRE);
+                        uiRainOfFireTimer = urand(14*IN_MILLISECONDS,18*IN_MILLISECONDS);
+                    } else uiRainOfFireTimer -= diff;
 
-                if (uiPhaseTimer < diff)
-                {
-                    DoCast(SPELL_DECAY_FLESH);
-                    Phase = GOING_FLESH;
-                    uiPhaseTimer = 6*IN_MILLISECONDS;
-                } else uiPhaseTimer -= diff;
+                    if (uiPhaseTimer < diff)
+                    {
+                        DoCast(SPELL_DECAY_FLESH);
+                        Phase = GOING_FLESH;
+                        uiPhaseTimer = 6*IN_MILLISECONDS;
+                    } else uiPhaseTimer -= diff;
 
-                DoMeleeAttackIfReady();
-                break;
-            case GOING_FLESH:
-                if (uiPhaseTimer < diff)
-                {
-                    DoScriptText(RAND(SAY_FLESH_1,SAY_FLESH_2),me);
-                    me->SetDisplayId(MODEL_FLESH);
-                    std::list<HostileReference*>& threatlist = me->getThreatManager().getThreatList();
-                    for (std::list<HostileReference*>::const_iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
+                    DoMeleeAttackIfReady();
+                    break;
+                case GOING_FLESH:
+                    if (uiPhaseTimer < diff)
                     {
-                        Unit *pTemp = Unit::GetUnit((*me),(*itr)->getUnitGuid());
-                        if (pTemp && pTemp->GetTypeId() == TYPEID_PLAYER)
+                        DoScriptText(RAND(SAY_FLESH_1,SAY_FLESH_2),me);
+                        me->SetDisplayId(MODEL_FLESH);
+                        std::list<HostileReference*>& threatlist = me->getThreatManager().getThreatList();
+                        for (std::list<HostileReference*>::const_iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
                         {
-                            me->AddAura(SPELL_GIFT_OF_THARON_JA,pTemp);
-                            pTemp->SetDisplayId(MODEL_SKELETON);
+                            Unit *pTemp = Unit::GetUnit((*me),(*itr)->getUnitGuid());
+                            if (pTemp && pTemp->GetTypeId() == TYPEID_PLAYER)
+                            {
+                                me->AddAura(SPELL_GIFT_OF_THARON_JA,pTemp);
+                                pTemp->SetDisplayId(MODEL_SKELETON);
+                            }
                         }
-                    }
-                    uiPhaseTimer = 20*IN_MILLISECONDS;
-                    uiLightningBreathTimer = urand(3*IN_MILLISECONDS,4*IN_MILLISECONDS);
-                    uiEyeBeamTimer = urand(4*IN_MILLISECONDS,8*IN_MILLISECONDS);
-                    uiPoisonCloudTimer = urand(6*IN_MILLISECONDS,7*IN_MILLISECONDS);
-                    Phase = FLESH;
-                } else uiPhaseTimer -= diff;
-                break;
-            case FLESH:
-                if (uiLightningBreathTimer < diff)
-                {
-                    if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                        DoCast(pTarget, SPELL_LIGHTNING_BREATH);
-                    uiLightningBreathTimer = urand(6*IN_MILLISECONDS,7*IN_MILLISECONDS);
-                } else uiLightningBreathTimer -= diff;
+                        uiPhaseTimer = 20*IN_MILLISECONDS;
+                        uiLightningBreathTimer = urand(3*IN_MILLISECONDS,4*IN_MILLISECONDS);
+                        uiEyeBeamTimer = urand(4*IN_MILLISECONDS,8*IN_MILLISECONDS);
+                        uiPoisonCloudTimer = urand(6*IN_MILLISECONDS,7*IN_MILLISECONDS);
+                        Phase = FLESH;
+                    } else uiPhaseTimer -= diff;
+                    break;
+                case FLESH:
+                    if (uiLightningBreathTimer < diff)
+                    {
+                        if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                            DoCast(pTarget, SPELL_LIGHTNING_BREATH);
+                        uiLightningBreathTimer = urand(6*IN_MILLISECONDS,7*IN_MILLISECONDS);
+                    } else uiLightningBreathTimer -= diff;
 
-                if (uiEyeBeamTimer < diff)
-                {
-                    if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                        DoCast(pTarget, SPELL_EYE_BEAM);
-                    uiEyeBeamTimer = urand(4*IN_MILLISECONDS,6*IN_MILLISECONDS);
-                } else uiEyeBeamTimer -= diff;
+                    if (uiEyeBeamTimer < diff)
+                    {
+                        if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                            DoCast(pTarget, SPELL_EYE_BEAM);
+                        uiEyeBeamTimer = urand(4*IN_MILLISECONDS,6*IN_MILLISECONDS);
+                    } else uiEyeBeamTimer -= diff;
 
-                if (uiPoisonCloudTimer < diff)
-                {
-                    DoCastAOE(SPELL_POISON_CLOUD);
-                    uiPoisonCloudTimer = urand(10*IN_MILLISECONDS,12*IN_MILLISECONDS);
-                } else uiPoisonCloudTimer -= diff;
+                    if (uiPoisonCloudTimer < diff)
+                    {
+                        DoCastAOE(SPELL_POISON_CLOUD);
+                        uiPoisonCloudTimer = urand(10*IN_MILLISECONDS,12*IN_MILLISECONDS);
+                    } else uiPoisonCloudTimer -= diff;
 
-                if (uiPhaseTimer < diff)
-                {
-                    DoCast(SPELL_RETURN_FLESH);
-                    Phase = GOING_SKELETAL;
-                    uiPhaseTimer = 6*IN_MILLISECONDS;
-                } else uiPhaseTimer -= diff;
-                DoMeleeAttackIfReady();
-                break;
-            case GOING_SKELETAL:
-                if (uiPhaseTimer < diff)
-                {
-                    DoScriptText(RAND(SAY_SKELETON_1,SAY_SKELETON_2), me);
-                    me->DeMorph();
-                    Phase = SKELETAL;
-                    uiPhaseTimer = 20*IN_MILLISECONDS;
-                    uiCurseOfLifeTimer = 1*IN_MILLISECONDS;
-                    uiRainOfFireTimer = urand(14*IN_MILLISECONDS,18*IN_MILLISECONDS);
-                    uiShadowVolleyTimer = urand(8*IN_MILLISECONDS,10*IN_MILLISECONDS);
-                    std::list<HostileReference*>& threatlist = me->getThreatManager().getThreatList();
-                    for (std::list<HostileReference*>::const_iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
+                    if (uiPhaseTimer < diff)
+                    {
+                        DoCast(SPELL_RETURN_FLESH);
+                        Phase = GOING_SKELETAL;
+                        uiPhaseTimer = 6*IN_MILLISECONDS;
+                    } else uiPhaseTimer -= diff;
+                    DoMeleeAttackIfReady();
+                    break;
+                case GOING_SKELETAL:
+                    if (uiPhaseTimer < diff)
                     {
-                        Unit *pTemp = Unit::GetUnit((*me),(*itr)->getUnitGuid());
-                        if (pTemp && pTemp->GetTypeId() == TYPEID_PLAYER)
+                        DoScriptText(RAND(SAY_SKELETON_1,SAY_SKELETON_2), me);
+                        me->DeMorph();
+                        Phase = SKELETAL;
+                        uiPhaseTimer = 20*IN_MILLISECONDS;
+                        uiCurseOfLifeTimer = 1*IN_MILLISECONDS;
+                        uiRainOfFireTimer = urand(14*IN_MILLISECONDS,18*IN_MILLISECONDS);
+                        uiShadowVolleyTimer = urand(8*IN_MILLISECONDS,10*IN_MILLISECONDS);
+                        std::list<HostileReference*>& threatlist = me->getThreatManager().getThreatList();
+                        for (std::list<HostileReference*>::const_iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
                         {
-                            if (pTemp->HasAura(SPELL_GIFT_OF_THARON_JA))
-                                pTemp->RemoveAura(SPELL_GIFT_OF_THARON_JA);
-                            pTemp->DeMorph();
+                            Unit *pTemp = Unit::GetUnit((*me),(*itr)->getUnitGuid());
+                            if (pTemp && pTemp->GetTypeId() == TYPEID_PLAYER)
+                            {
+                                if (pTemp->HasAura(SPELL_GIFT_OF_THARON_JA))
+                                    pTemp->RemoveAura(SPELL_GIFT_OF_THARON_JA);
+                                pTemp->DeMorph();
+                            }
                         }
-                    }
-                } else uiPhaseTimer -= diff;
-                break;
+                    } else uiPhaseTimer -= diff;
+                    break;
+            }
         }
-    }
-
-    void KilledUnit(Unit * /*victim*/)
-    {
-        DoScriptText(RAND(SAY_KILL_1,SAY_KILL_2),me);
-    }
 
-    void JustDied(Unit* /*killer*/)
-    {
-        DoScriptText(SAY_DEATH,me);
+        void KilledUnit(Unit * /*victim*/)
+        {
+            DoScriptText(RAND(SAY_KILL_1,SAY_KILL_2),me);
+        }
 
-        if (pInstance)
+        void JustDied(Unit* /*killer*/)
         {
-            // clean morph on players
-            Map::PlayerList const &PlayerList = pInstance->instance->GetPlayers();
+            DoScriptText(SAY_DEATH,me);
 
-            for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
-                if (Player *pPlayer = i->getSource())
-                    pPlayer->DeMorph();
-            // cast is not rewarding the achievement.
-            // DoCast(SPELL_ACHIEVEMENT_CHECK);
-            pInstance->DoUpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2, SPELL_ACHIEVEMENT_CHECK);
+            if (pInstance)
+            {
+                // clean morph on players
+                Map::PlayerList const &PlayerList = pInstance->instance->GetPlayers();
 
-            pInstance->SetData(DATA_THARON_JA_EVENT, DONE);
+                for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
+                    if (Player *pPlayer = i->getSource())
+                        pPlayer->DeMorph();
+                pInstance->DoUpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2, SPELL_ACHIEVEMENT_CHECK);
+
+                pInstance->SetData(DATA_THARON_JA_EVENT, DONE);
+            }
         }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new boss_tharon_jaAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_tharon_ja(Creature* pCreature)
-{
-    return new boss_tharon_jaAI (pCreature);
-}
 
 void AddSC_boss_tharon_ja()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_tharon_ja";
-    newscript->GetAI = &GetAI_boss_tharon_ja;
-    newscript->RegisterSelf();
+    new boss_tharon_ja;
 }
diff --git a/src/server/scripts/Northrend/DraktharonKeep/boss_trollgore.cpp b/src/server/scripts/Northrend/DraktharonKeep/boss_trollgore.cpp
index 4281ab53463..fe32748c07b 100644
--- a/src/server/scripts/Northrend/DraktharonKeep/boss_trollgore.cpp
+++ b/src/server/scripts/Northrend/DraktharonKeep/boss_trollgore.cpp
@@ -54,143 +54,144 @@ enum Creatures
 
 Position AddSpawnPoint = { -260.493011, -622.968018, 26.605301, 3.036870 };
 
-struct boss_trollgoreAI : public ScriptedAI
+class boss_trollgore : public CreatureScript
 {
-    boss_trollgoreAI(Creature *c) : ScriptedAI(c), lSummons(me)
-    {
-        pInstance = c->GetInstanceData();
-    }
-
-    uint32 uiConsumeTimer;
-    uint32 uiAuraCountTimer;
-    uint32 uiCrushTimer;
-    uint32 uiInfectedWoundTimer;
-    uint32 uiExplodeCorpseTimer;
-    uint32 uiSpawnTimer;
-
-    bool bAchiev;
-
-    SummonList lSummons;
+public:
+    boss_trollgore() : CreatureScript("boss_trollgore") { }
 
-    ScriptedInstance* pInstance;
-
-    void Reset()
+    struct boss_trollgoreAI : public ScriptedAI
     {
-        uiConsumeTimer = 15*IN_MILLISECONDS;
-        uiAuraCountTimer = 15.5*IN_MILLISECONDS;
-        uiCrushTimer = urand(1*IN_MILLISECONDS,5*IN_MILLISECONDS);
-        uiInfectedWoundTimer = urand(60*IN_MILLISECONDS,10*IN_MILLISECONDS);
-        uiExplodeCorpseTimer = 3*IN_MILLISECONDS;
-        uiSpawnTimer = urand(30*IN_MILLISECONDS,40*IN_MILLISECONDS);
+        boss_trollgoreAI(Creature *c) : ScriptedAI(c), lSummons(me)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-        bAchiev = IsHeroic();
+        uint32 uiConsumeTimer;
+        uint32 uiAuraCountTimer;
+        uint32 uiCrushTimer;
+        uint32 uiInfectedWoundTimer;
+        uint32 uiExplodeCorpseTimer;
+        uint32 uiSpawnTimer;
 
-        lSummons.DespawnAll();
+        bool bAchiev;
 
-        me->RemoveAura(DUNGEON_MODE(SPELL_CONSUME_AURA,H_SPELL_CONSUME_AURA));
+        SummonList lSummons;
 
-        if (pInstance)
-            pInstance->SetData(DATA_TROLLGORE_EVENT, NOT_STARTED);
-    }
+        ScriptedInstance* pInstance;
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        DoScriptText(SAY_AGGRO, me);
+        void Reset()
+        {
+            uiConsumeTimer = 15*IN_MILLISECONDS;
+            uiAuraCountTimer = 15.5*IN_MILLISECONDS;
+            uiCrushTimer = urand(1*IN_MILLISECONDS,5*IN_MILLISECONDS);
+            uiInfectedWoundTimer = urand(60*IN_MILLISECONDS,10*IN_MILLISECONDS);
+            uiExplodeCorpseTimer = 3*IN_MILLISECONDS;
+            uiSpawnTimer = urand(30*IN_MILLISECONDS,40*IN_MILLISECONDS);
 
-        if (pInstance)
-            pInstance->SetData(DATA_TROLLGORE_EVENT, IN_PROGRESS);
-    }
+            bAchiev = IsHeroic();
 
-    void UpdateAI(const uint32 diff)
-    {
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
+            lSummons.DespawnAll();
 
-        if (uiSpawnTimer <= diff)
-        {
-            uint32 spawnNumber = urand(2,DUNGEON_MODE(3,5));
-            for (uint8 i = 0; i < spawnNumber; ++i)
-                DoSummon(RAND(NPC_DRAKKARI_INVADER_1,NPC_DRAKKARI_INVADER_2), AddSpawnPoint, 0, TEMPSUMMON_DEAD_DESPAWN);
-            uiSpawnTimer = urand(30*IN_MILLISECONDS,40*IN_MILLISECONDS);
-        } else uiSpawnTimer -= diff;
+            me->RemoveAura(DUNGEON_MODE(SPELL_CONSUME_AURA,H_SPELL_CONSUME_AURA));
 
-        if (uiConsumeTimer <= diff)
-        {
-            DoScriptText(SAY_CONSUME, me);
-            DoCast(SPELL_CONSUME);
-            uiConsumeTimer = 15*IN_MILLISECONDS;
-        } else uiConsumeTimer -= diff;
+            if (pInstance)
+                pInstance->SetData(DATA_TROLLGORE_EVENT, NOT_STARTED);
+        }
 
-        if (bAchiev)
+        void EnterCombat(Unit* /*who*/)
         {
-            Aura *pConsumeAura = me->GetAura(DUNGEON_MODE(SPELL_CONSUME_AURA,H_SPELL_CONSUME_AURA));
-            if (pConsumeAura && pConsumeAura->GetStackAmount() > 9)
-                bAchiev = false;
+            DoScriptText(SAY_AGGRO, me);
+
+            if (pInstance)
+                pInstance->SetData(DATA_TROLLGORE_EVENT, IN_PROGRESS);
         }
 
-        if (uiCrushTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            DoCastVictim(SPELL_CRUSH);
-            uiCrushTimer = urand(10*IN_MILLISECONDS,15*IN_MILLISECONDS);
-        } else uiCrushTimer -= diff;
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
+
+            if (uiSpawnTimer <= diff)
+            {
+                uint32 spawnNumber = urand(2,DUNGEON_MODE(3,5));
+                for (uint8 i = 0; i < spawnNumber; ++i)
+                    DoSummon(RAND(NPC_DRAKKARI_INVADER_1,NPC_DRAKKARI_INVADER_2), AddSpawnPoint, 0, TEMPSUMMON_DEAD_DESPAWN);
+                uiSpawnTimer = urand(30*IN_MILLISECONDS,40*IN_MILLISECONDS);
+            } else uiSpawnTimer -= diff;
+
+            if (uiConsumeTimer <= diff)
+            {
+                DoScriptText(SAY_CONSUME, me);
+                DoCast(SPELL_CONSUME);
+                uiConsumeTimer = 15*IN_MILLISECONDS;
+            } else uiConsumeTimer -= diff;
 
-        if (uiInfectedWoundTimer <= diff)
-        {
-            DoCastVictim(SPELL_INFECTED_WOUND);
-            uiInfectedWoundTimer = urand(25*IN_MILLISECONDS,35*IN_MILLISECONDS);
-        } else uiInfectedWoundTimer -= diff;
+            if (bAchiev)
+            {
+                Aura *pConsumeAura = me->GetAura(DUNGEON_MODE(SPELL_CONSUME_AURA,H_SPELL_CONSUME_AURA));
+                if (pConsumeAura && pConsumeAura->GetStackAmount() > 9)
+                    bAchiev = false;
+            }
+
+            if (uiCrushTimer <= diff)
+            {
+                DoCastVictim(SPELL_CRUSH);
+                uiCrushTimer = urand(10*IN_MILLISECONDS,15*IN_MILLISECONDS);
+            } else uiCrushTimer -= diff;
+
+            if (uiInfectedWoundTimer <= diff)
+            {
+                DoCastVictim(SPELL_INFECTED_WOUND);
+                uiInfectedWoundTimer = urand(25*IN_MILLISECONDS,35*IN_MILLISECONDS);
+            } else uiInfectedWoundTimer -= diff;
+
+            if (uiExplodeCorpseTimer <= diff)
+            {
+                DoCast(SPELL_CORPSE_EXPLODE);
+                DoScriptText(SAY_EXPLODE, me);
+                uiExplodeCorpseTimer = urand(15*IN_MILLISECONDS,19*IN_MILLISECONDS);
+            } else uiExplodeCorpseTimer -= diff;
+
+            DoMeleeAttackIfReady();
+        }
 
-        if (uiExplodeCorpseTimer <= diff)
+        void JustDied(Unit* /*killer*/)
         {
-            DoCast(SPELL_CORPSE_EXPLODE);
-            DoScriptText(SAY_EXPLODE, me);
-            uiExplodeCorpseTimer = urand(15*IN_MILLISECONDS,19*IN_MILLISECONDS);
-        } else uiExplodeCorpseTimer -= diff;
+            DoScriptText(SAY_DEATH, me);
 
-        DoMeleeAttackIfReady();
-    }
-
-    void JustDied(Unit* /*killer*/)
-    {
-        DoScriptText(SAY_DEATH, me);
+            lSummons.DespawnAll();
 
-        lSummons.DespawnAll();
+            if (pInstance)
+            {
+                if (bAchiev)
+                    pInstance->DoCompleteAchievement(ACHIEV_CONSUMPTION_JUNCTION);
+                pInstance->SetData(DATA_TROLLGORE_EVENT, DONE);
+            }
+        }
 
-        if (pInstance)
+        void KilledUnit(Unit * victim)
         {
-            if (bAchiev)
-                pInstance->DoCompleteAchievement(ACHIEV_CONSUMPTION_JUNCTION);
-            pInstance->SetData(DATA_TROLLGORE_EVENT, DONE);
+            if (victim == me)
+                return;
+            DoScriptText(SAY_KILL, me);
         }
-    }
 
-    void KilledUnit(Unit * victim)
-    {
-        if (victim == me)
-            return;
-        DoScriptText(SAY_KILL, me);
-    }
+        void JustSummoned(Creature* summon)
+        {
+            lSummons.push_back(summon->GetGUID());
+            if (summon->AI())
+                summon->AI()->AttackStart(me);
+        }
+    };
 
-    void JustSummoned(Creature* summon)
+    CreatureAI *GetAI(Creature *creature) const
     {
-        lSummons.push_back(summon->GetGUID());
-        if (summon->AI())
-            summon->AI()->AttackStart(me);
+        return new boss_trollgoreAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_trollgore(Creature* pCreature)
-{
-    return new boss_trollgoreAI (pCreature);
-}
-
 void AddSC_boss_trollgore()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_trollgore";
-    newscript->GetAI = &GetAI_boss_trollgore;
-    newscript->RegisterSelf();
+    new boss_trollgore;
 }
diff --git a/src/server/scripts/Northrend/DraktharonKeep/instance_drak_tharon_keep.cpp b/src/server/scripts/Northrend/DraktharonKeep/instance_drak_tharon_keep.cpp
index 2c36217755d..3ac82b58b47 100644
--- a/src/server/scripts/Northrend/DraktharonKeep/instance_drak_tharon_keep.cpp
+++ b/src/server/scripts/Northrend/DraktharonKeep/instance_drak_tharon_keep.cpp
@@ -42,201 +42,203 @@ enum GameObjects
     GO_NOVOS_CRYSTAL_4                            = 189302
 };
 
-struct instance_drak_tharon : public ScriptedInstance
+class instance_drak_tharon : public InstanceMapScript
 {
-    instance_drak_tharon(Map* pMap) : ScriptedInstance(pMap) {Initialize();};
+public:
+    instance_drak_tharon() : InstanceMapScript("instance_drak_tharon") { }
 
-    uint8 uiDredAchievCounter;
-
-    uint64 uiTrollgore;
-    uint64 uiNovos;
-    uint64 uiDred;
-    uint64 uiTharonJa;
-
-    uint64 uiNovosCrystal1;
-    uint64 uiNovosCrystal2;
-    uint64 uiNovosCrystal3;
-    uint64 uiNovosCrystal4;
+    struct instance_drak_tharon_ScriptedInstance : public ScriptedInstance
+    {
+        instance_drak_tharon_ScriptedInstance(Map* pMap) : ScriptedInstance(pMap) {Initialize();};
 
-    uint8 m_auiEncounter[MAX_ENCOUNTER];
+        uint8 uiDredAchievCounter;
 
-    std::string str_data;
+        uint64 uiTrollgore;
+        uint64 uiNovos;
+        uint64 uiDred;
+        uint64 uiTharonJa;
 
-    void Initialize()
-    {
-        uiTrollgore = 0;
-        uiNovos = 0;
-        uiDred = 0;
-        uiTharonJa = 0;
-        uiNovosCrystal1 = 0;
-        uiNovosCrystal2 = 0;
-        uiNovosCrystal3 = 0;
-        uiNovosCrystal4 = 0;
-        uiDredAchievCounter = 0;
-    }
+        uint64 uiNovosCrystal1;
+        uint64 uiNovosCrystal2;
+        uint64 uiNovosCrystal3;
+        uint64 uiNovosCrystal4;
 
-    bool IsEncounterInProgress() const
-    {
-        for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-            if (m_auiEncounter[i] == IN_PROGRESS) return true;
+        uint8 m_auiEncounter[MAX_ENCOUNTER];
 
-        return false;
-    }
+        std::string str_data;
 
-    void OnGameObjectCreate(GameObject* pGo, bool /*add*/)
-    {
-        switch(pGo->GetEntry())
+        void Initialize()
         {
-            case GO_NOVOS_CRYSTAL_1:
-                uiNovosCrystal1 = pGo->GetGUID();
-                break;
-            case GO_NOVOS_CRYSTAL_2:
-                uiNovosCrystal2 = pGo->GetGUID();
-                break;
-            case GO_NOVOS_CRYSTAL_3:
-                uiNovosCrystal3 = pGo->GetGUID();
-                break;
-            case GO_NOVOS_CRYSTAL_4:
-                uiNovosCrystal4 = pGo->GetGUID();
-                break;
+            uiTrollgore = 0;
+            uiNovos = 0;
+            uiDred = 0;
+            uiTharonJa = 0;
+            uiNovosCrystal1 = 0;
+            uiNovosCrystal2 = 0;
+            uiNovosCrystal3 = 0;
+            uiNovosCrystal4 = 0;
+            uiDredAchievCounter = 0;
         }
-    }
 
-    void OnCreatureCreate(Creature* pCreature, bool /*add*/)
-    {
-        switch(pCreature->GetEntry())
+        bool IsEncounterInProgress() const
         {
-            case NPC_TROLLGORE:
-                uiTrollgore = pCreature->GetGUID();
-                break;
-            case NPC_NOVOS:
-                uiNovos = pCreature->GetGUID();
-                break;
-            case NPC_KING_DRED:
-                uiDred = pCreature->GetGUID();
-                break;
-            case NPC_THARON_JA:
-                uiTharonJa = pCreature->GetGUID();
-                break;
+            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
+                if (m_auiEncounter[i] == IN_PROGRESS) return true;
+
+            return false;
         }
-    }
 
-    uint64 GetData64(uint32 identifier)
-    {
-        switch(identifier)
+        void OnGameObjectCreate(GameObject* pGo, bool /*add*/)
         {
-            case DATA_TROLLGORE:          return uiTrollgore;
-            case DATA_NOVOS:              return uiNovos;
-            case DATA_DRED:               return uiDred;
-            case DATA_THARON_JA:          return uiTharonJa;
-            case DATA_NOVOS_CRYSTAL_1:    return uiNovosCrystal1;
-            case DATA_NOVOS_CRYSTAL_2:    return uiNovosCrystal2;
-            case DATA_NOVOS_CRYSTAL_3:    return uiNovosCrystal3;
-            case DATA_NOVOS_CRYSTAL_4:    return uiNovosCrystal4;
+            switch(pGo->GetEntry())
+            {
+                case GO_NOVOS_CRYSTAL_1:
+                    uiNovosCrystal1 = pGo->GetGUID();
+                    break;
+                case GO_NOVOS_CRYSTAL_2:
+                    uiNovosCrystal2 = pGo->GetGUID();
+                    break;
+                case GO_NOVOS_CRYSTAL_3:
+                    uiNovosCrystal3 = pGo->GetGUID();
+                    break;
+                case GO_NOVOS_CRYSTAL_4:
+                    uiNovosCrystal4 = pGo->GetGUID();
+                    break;
+            }
         }
 
-        return 0;
-    }
+        void OnCreatureCreate(Creature* pCreature, bool /*add*/)
+        {
+            switch(pCreature->GetEntry())
+            {
+                case NPC_TROLLGORE:
+                    uiTrollgore = pCreature->GetGUID();
+                    break;
+                case NPC_NOVOS:
+                    uiNovos = pCreature->GetGUID();
+                    break;
+                case NPC_KING_DRED:
+                    uiDred = pCreature->GetGUID();
+                    break;
+                case NPC_THARON_JA:
+                    uiTharonJa = pCreature->GetGUID();
+                    break;
+            }
+        }
 
-    void SetData(uint32 type, uint32 data)
-    {
-        switch(type)
+        uint64 GetData64(uint32 identifier)
         {
-            case DATA_TROLLGORE_EVENT:
-                m_auiEncounter[0] = data;
-                break;
-            case DATA_NOVOS_EVENT:
-                m_auiEncounter[1] = data;
-                break;
-            case DATA_DRED_EVENT:
-                m_auiEncounter[2] = data;
-                break;
-            case DATA_THARON_JA_EVENT:
-                m_auiEncounter[3] = data;
-                break;
-
-            case DATA_KING_DRED_ACHIEV:
-                uiDredAchievCounter = data;
-                break;
+            switch(identifier)
+            {
+                case DATA_TROLLGORE:          return uiTrollgore;
+                case DATA_NOVOS:              return uiNovos;
+                case DATA_DRED:               return uiDred;
+                case DATA_THARON_JA:          return uiTharonJa;
+                case DATA_NOVOS_CRYSTAL_1:    return uiNovosCrystal1;
+                case DATA_NOVOS_CRYSTAL_2:    return uiNovosCrystal2;
+                case DATA_NOVOS_CRYSTAL_3:    return uiNovosCrystal3;
+                case DATA_NOVOS_CRYSTAL_4:    return uiNovosCrystal4;
+            }
+
+            return 0;
         }
 
-        if (data == DONE)
+        void SetData(uint32 type, uint32 data)
         {
-            SaveToDB();
+            switch(type)
+            {
+                case DATA_TROLLGORE_EVENT:
+                    m_auiEncounter[0] = data;
+                    break;
+                case DATA_NOVOS_EVENT:
+                    m_auiEncounter[1] = data;
+                    break;
+                case DATA_DRED_EVENT:
+                    m_auiEncounter[2] = data;
+                    break;
+                case DATA_THARON_JA_EVENT:
+                    m_auiEncounter[3] = data;
+                    break;
+
+                case DATA_KING_DRED_ACHIEV:
+                    uiDredAchievCounter = data;
+                    break;
+            }
+
+            if (data == DONE)
+            {
+                SaveToDB();
+            }
         }
-    }
 
-    uint32 GetData(uint32 type)
-    {
-        switch (type)
+        uint32 GetData(uint32 type)
         {
-            case DATA_TROLLGORE_EVENT:    return m_auiEncounter[0];
-            case DATA_NOVOS_EVENT:        return m_auiEncounter[1];
-            case DATA_DRED_EVENT:         return m_auiEncounter[2];
-            case DATA_THARON_JA_EVENT:    return m_auiEncounter[3];
-            case DATA_KING_DRED_ACHIEV:   return uiDredAchievCounter;
+            switch (type)
+            {
+                case DATA_TROLLGORE_EVENT:    return m_auiEncounter[0];
+                case DATA_NOVOS_EVENT:        return m_auiEncounter[1];
+                case DATA_DRED_EVENT:         return m_auiEncounter[2];
+                case DATA_THARON_JA_EVENT:    return m_auiEncounter[3];
+                case DATA_KING_DRED_ACHIEV:   return uiDredAchievCounter;
+            }
+            return 0;
         }
-        return 0;
-    }
 
-    std::string GetSaveData()
-    {
-        OUT_SAVE_INST_DATA;
+        std::string GetSaveData()
+        {
+            OUT_SAVE_INST_DATA;
 
-        std::string str_data;
+            std::string str_data;
 
-        std::ostringstream saveStream;
-        saveStream << "D K " << m_auiEncounter[0] << " " << m_auiEncounter[1] << " "
-            << m_auiEncounter[2] << " " << m_auiEncounter[3];
+            std::ostringstream saveStream;
+            saveStream << "D K " << m_auiEncounter[0] << " " << m_auiEncounter[1] << " "
+                << m_auiEncounter[2] << " " << m_auiEncounter[3];
 
-        str_data = saveStream.str();
+            str_data = saveStream.str();
 
-        OUT_SAVE_INST_DATA_COMPLETE;
-        return str_data;
-    }
+            OUT_SAVE_INST_DATA_COMPLETE;
+            return str_data;
+        }
 
-    void Load(const char* in)
-    {
-        if (!in)
+        void Load(const char* in)
         {
-            OUT_LOAD_INST_DATA_FAIL;
-            return;
-        }
+            if (!in)
+            {
+                OUT_LOAD_INST_DATA_FAIL;
+                return;
+            }
 
-        OUT_LOAD_INST_DATA(in);
+            OUT_LOAD_INST_DATA(in);
 
-        char dataHead1, dataHead2;
-        uint16 data0,data1,data2,data3;
+            char dataHead1, dataHead2;
+            uint16 data0,data1,data2,data3;
 
-        std::istringstream loadStream(in);
-        loadStream >> dataHead1 >> dataHead2 >> data0 >> data1 >> data2 >> data3;
+            std::istringstream loadStream(in);
+            loadStream >> dataHead1 >> dataHead2 >> data0 >> data1 >> data2 >> data3;
 
-        if (dataHead1 == 'D' && dataHead2 == 'K')
-        {
-            m_auiEncounter[0] = data0;
-            m_auiEncounter[1] = data1;
-            m_auiEncounter[2] = data2;
-            m_auiEncounter[3] = data3;
+            if (dataHead1 == 'D' && dataHead2 == 'K')
+            {
+                m_auiEncounter[0] = data0;
+                m_auiEncounter[1] = data1;
+                m_auiEncounter[2] = data2;
+                m_auiEncounter[3] = data3;
 
-            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-                if (m_auiEncounter[i] == IN_PROGRESS)
-                    m_auiEncounter[i] = NOT_STARTED;
-        } else OUT_LOAD_INST_DATA_FAIL;
+                for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
+                    if (m_auiEncounter[i] == IN_PROGRESS)
+                        m_auiEncounter[i] = NOT_STARTED;
+            } else OUT_LOAD_INST_DATA_FAIL;
+
+            OUT_LOAD_INST_DATA_COMPLETE;
+        }
+    };
 
-        OUT_LOAD_INST_DATA_COMPLETE;
+    InstanceData* GetInstanceData(InstanceMap *map) const
+    {
+        return new instance_drak_tharon_ScriptedInstance(map);
     }
 };
 
-InstanceData* GetInstanceData_instance_drak_tharon(Map* pMap)
-{
-    return new instance_drak_tharon(pMap);
-}
-
 void AddSC_instance_drak_tharon()
 {
-    Script *newscript;
-    newscript = new Script;
-    newscript->Name = "instance_drak_tharon";
-    newscript->GetInstanceData = &GetInstanceData_instance_drak_tharon;
-    newscript->RegisterSelf();
+    new instance_drak_tharon;
 }
diff --git a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_bronjahm.cpp b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_bronjahm.cpp
index 6ac11c81e2d..2555d8a6985 100644
--- a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_bronjahm.cpp
+++ b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_bronjahm.cpp
@@ -62,203 +62,205 @@ enum CombatPhases
     PHASE_2
 };
 
-struct boss_bronjahmAI : public ScriptedAI
+class boss_bronjahm : public CreatureScript
 {
-    boss_bronjahmAI(Creature *c) : ScriptedAI(c)
-    {
-        pInstance = me->GetInstanceData();
-    }
-
-    ScriptedInstance* pInstance;
-    EventMap events;
-
-    CombatPhases phase;
+public:
+    boss_bronjahm() : CreatureScript("boss_bronjahm") { }
 
-    void Reset()
+    struct boss_bronjahmAI : public ScriptedAI
     {
-        phase = PHASE_1;
-        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
+        boss_bronjahmAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = me->GetInstanceData();
+        }
 
-        events.Reset();
-        events.ScheduleEvent(EVENT_SHADOW_BOLT, 2000);
-        events.ScheduleEvent(EVENT_MAGIC_BANE, urand(8000,15000));
-        events.ScheduleEvent(EVENT_CORRUPT_SOUL, urand(25000,35000));
+        ScriptedInstance* pInstance;
+        EventMap events;
 
-        if (pInstance)
-            pInstance->SetData(DATA_BRONJAHM_EVENT, NOT_STARTED);
-    }
+        CombatPhases phase;
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        DoScriptText(SAY_AGGRO, me);
+        void Reset()
+        {
+            phase = PHASE_1;
+            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
 
-        if (pInstance)
-            pInstance->SetData(DATA_BRONJAHM_EVENT, IN_PROGRESS);
-    }
+            events.Reset();
+            events.ScheduleEvent(EVENT_SHADOW_BOLT, 2000);
+            events.ScheduleEvent(EVENT_MAGIC_BANE, urand(8000,15000));
+            events.ScheduleEvent(EVENT_CORRUPT_SOUL, urand(25000,35000));
 
-    void JustDied(Unit* /*killer*/)
-    {
-        DoScriptText(SAY_DEATH, me);
+            if (pInstance)
+                pInstance->SetData(DATA_BRONJAHM_EVENT, NOT_STARTED);
+        }
 
-        if (pInstance)
-            pInstance->SetData(DATA_BRONJAHM_EVENT, DONE);
-    }
+        void EnterCombat(Unit* /*who*/)
+        {
+            DoScriptText(SAY_AGGRO, me);
 
-    void KilledUnit(Unit * /*who*/)
-    {
-        DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2), me);
-    }
+            if (pInstance)
+                pInstance->SetData(DATA_BRONJAHM_EVENT, IN_PROGRESS);
+        }
 
-    // Cast aura spell on all players farther than 10y
-    void ApplySoulStorm()
-    {
-        std::list<Unit*> targetList;
+        void JustDied(Unit* /*killer*/)
+        {
+            DoScriptText(SAY_DEATH, me);
 
-        SelectTargetList(targetList, 100, SELECT_TARGET_TOPAGGRO, -10.0f);
-        if (targetList.empty())
-            return;
+            if (pInstance)
+                pInstance->SetData(DATA_BRONJAHM_EVENT, DONE);
+        }
 
-        for (std::list<Unit *>::const_iterator itr = targetList.begin(); itr != targetList.end(); ++itr)
+        void KilledUnit(Unit * /*who*/)
         {
-            Unit* pUnit = (*itr);
-            if (pUnit && pUnit->isAlive())
-                me->CastSpell(pUnit, SPELL_SOULSTORM_AURA, true);
+            DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2), me);
         }
-    }
 
-    void UpdateAI(const uint32 diff)
-    {
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
-
-        events.Update(diff);
+        // Cast aura spell on all players farther than 10y
+        void ApplySoulStorm()
+        {
+            std::list<Unit*> targetList;
 
-        if (me->hasUnitState(UNIT_STAT_CASTING))
-            return;
+            SelectTargetList(targetList, 100, SELECT_TARGET_TOPAGGRO, -10.0f);
+            if (targetList.empty())
+                return;
 
-        if (phase == PHASE_1 && HealthBelowPct(30))
-        {
-            phase = PHASE_2;
-            DoCast(me,SPELL_TELEPORT);
-            me->GetMotionMaster()->Clear();
-            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
-            events.CancelEvent(EVENT_CORRUPT_SOUL);
-            events.ScheduleEvent(EVENT_SOUL_STORM, 1000);
-            events.ScheduleEvent(EVENT_FEAR, urand(8000,12000));
-            return;
+            for (std::list<Unit *>::const_iterator itr = targetList.begin(); itr != targetList.end(); ++itr)
+            {
+                Unit* pUnit = (*itr);
+                if (pUnit && pUnit->isAlive())
+                    me->CastSpell(pUnit, SPELL_SOULSTORM_AURA, true);
+            }
         }
 
-        while (uint32 eventId = events.ExecuteEvent())
+        void UpdateAI(const uint32 diff)
         {
-            switch(eventId)
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
+
+            events.Update(diff);
+
+            if (me->hasUnitState(UNIT_STAT_CASTING))
+                return;
+
+            if (phase == PHASE_1 && HealthBelowPct(30))
             {
-                case EVENT_CORRUPT_SOUL:
-                    if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,1))
-                    {
-                        DoScriptText(SAY_CORRUPT_SOUL, me);
-                        DoCast(pTarget,SPELL_CORRUPT_SOUL);
-                    }
-                    events.ScheduleEvent(EVENT_CORRUPT_SOUL, urand(25000,35000));
-                    break;
-                case EVENT_SOUL_STORM:
-                    DoScriptText(SAY_SOUL_STORM, me);
-                    // DoCast(me, SPELL_SOULSTORM); bug: put the aura without the limit of 10 yards.
-                    events.ScheduleEvent(EVENT_SOUL_STORM_AURA, 1000);
-                    break;
-                case EVENT_SOUL_STORM_AURA:
-                    ApplySoulStorm();
-                    events.ScheduleEvent(EVENT_SOUL_STORM_AURA, 1000);
-                    break;
-                case EVENT_FEAR:
-                    if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,1))
-                        DoCast(pTarget,SPELL_FEAR);
-                    events.ScheduleEvent(EVENT_FEAR, urand(8000,12000));
-                    break;
-                case EVENT_SHADOW_BOLT:
-                    DoCastVictim(SPELL_SHADOW_BOLT);
-                    events.ScheduleEvent(EVENT_SHADOW_BOLT, 2000);
-                    break;
-                case EVENT_MAGIC_BANE:
-                    DoCastVictim(SPELL_MAGIC_S_BANE);
-                    events.ScheduleEvent(EVENT_MAGIC_BANE, urand(8000,15000));
-                    break;
+                phase = PHASE_2;
+                DoCast(me,SPELL_TELEPORT);
+                me->GetMotionMaster()->Clear();
+                me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
+                events.CancelEvent(EVENT_CORRUPT_SOUL);
+                events.ScheduleEvent(EVENT_SOUL_STORM, 1000);
+                events.ScheduleEvent(EVENT_FEAR, urand(8000,12000));
+                return;
+            }
+
+            while (uint32 eventId = events.ExecuteEvent())
+            {
+                switch(eventId)
+                {
+                    case EVENT_CORRUPT_SOUL:
+                        if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,1))
+                        {
+                            DoScriptText(SAY_CORRUPT_SOUL, me);
+                            DoCast(pTarget,SPELL_CORRUPT_SOUL);
+                        }
+                        events.ScheduleEvent(EVENT_CORRUPT_SOUL, urand(25000,35000));
+                        break;
+                    case EVENT_SOUL_STORM:
+                        DoScriptText(SAY_SOUL_STORM, me);
+                        events.ScheduleEvent(EVENT_SOUL_STORM_AURA, 1000);
+                        break;
+                    case EVENT_SOUL_STORM_AURA:
+                        ApplySoulStorm();
+                        events.ScheduleEvent(EVENT_SOUL_STORM_AURA, 1000);
+                        break;
+                    case EVENT_FEAR:
+                        if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,1))
+                            DoCast(pTarget,SPELL_FEAR);
+                        events.ScheduleEvent(EVENT_FEAR, urand(8000,12000));
+                        break;
+                    case EVENT_SHADOW_BOLT:
+                        DoCastVictim(SPELL_SHADOW_BOLT);
+                        events.ScheduleEvent(EVENT_SHADOW_BOLT, 2000);
+                        break;
+                    case EVENT_MAGIC_BANE:
+                        DoCastVictim(SPELL_MAGIC_S_BANE);
+                        events.ScheduleEvent(EVENT_MAGIC_BANE, urand(8000,15000));
+                        break;
+                }
             }
+
+            DoMeleeAttackIfReady();
         }
+    };
 
-        DoMeleeAttackIfReady();
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new boss_bronjahmAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_bronjahm(Creature* pCreature)
+class mob_corrupted_soul_fragment : public CreatureScript
 {
-    return new boss_bronjahmAI(pCreature);
-}
+public:
+    mob_corrupted_soul_fragment() : CreatureScript("mob_corrupted_soul_fragment") { }
 
-struct mob_corrupted_soul_fragmentAI : public ScriptedAI
-{
-    mob_corrupted_soul_fragmentAI(Creature *c) : ScriptedAI(c)
+    struct mob_corrupted_soul_fragmentAI : public ScriptedAI
     {
-        pInstance = me->GetInstanceData();
-    }
+        mob_corrupted_soul_fragmentAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = me->GetInstanceData();
+        }
 
-    ScriptedInstance* pInstance;
+        ScriptedInstance* pInstance;
 
-    uint32 uiCheckTimer;
+        uint32 uiCheckTimer;
 
-    void Reset()
-    {
-        uiCheckTimer = 0; // first check is immediate
-    }
+        void Reset()
+        {
+            uiCheckTimer = 0; // first check is immediate
+        }
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (uiCheckTimer <= diff)
+        void UpdateAI(const uint32 diff)
         {
-            if (pInstance)
+            if (uiCheckTimer <= diff)
             {
-                Creature* pBronjham = Unit::GetCreature(*me, pInstance->GetData64(DATA_BRONJAHM));
-                if (pBronjham && pBronjham->isAlive())
+                if (pInstance)
                 {
-                    if (me->IsWithinMeleeRange(pBronjham))
+                    Creature* pBronjham = Unit::GetCreature(*me, pInstance->GetData64(DATA_BRONJAHM));
+                    if (pBronjham && pBronjham->isAlive())
                     {
-                        pBronjham->CastSpell(pBronjham, SPELL_CONSUME_SOUL, true);
-                        me->ForcedDespawn();
+                        if (me->IsWithinMeleeRange(pBronjham))
+                        {
+                            pBronjham->CastSpell(pBronjham, SPELL_CONSUME_SOUL, true);
+                            me->ForcedDespawn();
+                        }
+                        else
+                        {
+                            Position pos;
+                            pBronjham->GetPosition(&pos);
+                            me->GetMotionMaster()->Clear();
+                            me->GetMotionMaster()->MovePoint(0, pos);
+                        }
                     }
                     else
-                    {
-                        Position pos;
-                        pBronjham->GetPosition(&pos);
-                        me->GetMotionMaster()->Clear();
-                        me->GetMotionMaster()->MovePoint(0, pos);
-                    }
+                        me->ForcedDespawn();
                 }
-                else
-                    me->ForcedDespawn();
+                uiCheckTimer = 500;
             }
-            uiCheckTimer = 500;
+            else
+                uiCheckTimer -= diff;
         }
-        else
-            uiCheckTimer -= diff;
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_corrupted_soul_fragmentAI(creature);
     }
 };
 
-CreatureAI* GetAI_mob_corrupted_soul_fragment(Creature* pCreature)
-{
-    return new mob_corrupted_soul_fragmentAI(pCreature);
-}
-
 void AddSC_boss_bronjahm()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "boss_bronjahm";
-    newscript->GetAI = &GetAI_boss_bronjahm;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "mob_corrupted_soul_fragment";
-    newscript->GetAI = &GetAI_mob_corrupted_soul_fragment;
-    newscript->RegisterSelf();
+    new boss_bronjahm;
+    new mob_corrupted_soul_fragment;
 }
diff --git a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_devourer_of_souls.cpp b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_devourer_of_souls.cpp
index dfe07de6e00..dd6d15dc901 100644
--- a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_devourer_of_souls.cpp
+++ b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_devourer_of_souls.cpp
@@ -119,232 +119,234 @@ struct
     { 0, 0, { 0, 0, 0, 0 } }
 };
 
-struct boss_devourer_of_soulsAI : public ScriptedAI
+class boss_devourer_of_souls : public CreatureScript
 {
-    boss_devourer_of_soulsAI(Creature *c) : ScriptedAI(c)
+public:
+    boss_devourer_of_souls() : CreatureScript("boss_devourer_of_souls") { }
+
+    struct boss_devourer_of_soulsAI : public ScriptedAI
     {
-        pInstance = c->GetInstanceData();
-    }
+        boss_devourer_of_soulsAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = c->GetInstanceData();
+        }
 
-    bool bThreeFaceAchievement;
+        bool bThreeFaceAchievement;
 
-    ScriptedInstance* pInstance;
-    EventMap events;
+        ScriptedInstance* pInstance;
+        EventMap events;
 
-    // wailing soul event
-    float beamAngle;
-    float beamAngleDiff;
-    int8 wailingSoulTick;
+        // wailing soul event
+        float beamAngle;
+        float beamAngleDiff;
+        int8 wailingSoulTick;
 
-    uint64 uiMirroredSoulTarget;
+        uint64 uiMirroredSoulTarget;
 
-    void Reset()
-    {
-        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
-        me->SetDisplayId(DISPLAY_ANGER);
-        me->SetReactState(REACT_AGGRESSIVE);
+        void Reset()
+        {
+            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
+            me->SetDisplayId(DISPLAY_ANGER);
+            me->SetReactState(REACT_AGGRESSIVE);
 
-        events.Reset();
+            events.Reset();
 
-        bThreeFaceAchievement = true;
-        uiMirroredSoulTarget = 0;
+            bThreeFaceAchievement = true;
+            uiMirroredSoulTarget = 0;
 
-        if (pInstance)
-            pInstance->SetData(DATA_DEVOURER_EVENT, NOT_STARTED);
-    }
+            if (pInstance)
+                pInstance->SetData(DATA_DEVOURER_EVENT, NOT_STARTED);
+        }
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        if (pInstance)
-            pInstance->SetData(DATA_DEVOURER_EVENT, IN_PROGRESS);
+        void EnterCombat(Unit* /*who*/)
+        {
+            if (pInstance)
+                pInstance->SetData(DATA_DEVOURER_EVENT, IN_PROGRESS);
 
-        DoScriptText(RAND(SAY_FACE_ANGER_AGGRO,SAY_FACE_DESIRE_AGGRO), me);
+            DoScriptText(RAND(SAY_FACE_ANGER_AGGRO,SAY_FACE_DESIRE_AGGRO), me);
 
-        events.ScheduleEvent(EVENT_PHANTOM_BLAST, 5000);
-        events.ScheduleEvent(EVENT_MIRRORED_SOUL, 8000);
-        events.ScheduleEvent(EVENT_WELL_OF_SOULS, 30000);
-        events.ScheduleEvent(EVENT_UNLEASHED_SOULS, 20000);
-        events.ScheduleEvent(EVENT_WAILING_SOULS, urand(60000,70000));
-    }
+            events.ScheduleEvent(EVENT_PHANTOM_BLAST, 5000);
+            events.ScheduleEvent(EVENT_MIRRORED_SOUL, 8000);
+            events.ScheduleEvent(EVENT_WELL_OF_SOULS, 30000);
+            events.ScheduleEvent(EVENT_UNLEASHED_SOULS, 20000);
+            events.ScheduleEvent(EVENT_WAILING_SOULS, urand(60000,70000));
+        }
 
-    void DamageTaken(Unit * /*pDoneBy*/, uint32 &uiDamage)
-    {
-        if (uiMirroredSoulTarget && me->HasAura(SPELL_MIRRORED_SOUL))
+        void DamageTaken(Unit * /*pDoneBy*/, uint32 &uiDamage)
         {
-            if (Player *pPlayer = Unit::GetPlayer(*me, uiMirroredSoulTarget))
+            if (uiMirroredSoulTarget && me->HasAura(SPELL_MIRRORED_SOUL))
             {
-                if (Aura *pAura = pPlayer->GetAura(SPELL_MIRRORED_SOUL))
+                if (Player *pPlayer = Unit::GetPlayer(*me, uiMirroredSoulTarget))
                 {
-                    int32 mirrorDamage = (uiDamage * 45)/100;
-                    me->CastCustomSpell(pPlayer, 69034, &mirrorDamage, 0, 0, true);
-//                    me->DealDamage(pPlayer, (uiDamage * 45)/100, 0, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_SHADOW);
+                    if (Aura *pAura = pPlayer->GetAura(SPELL_MIRRORED_SOUL))
+                    {
+                        int32 mirrorDamage = (uiDamage * 45)/100;
+                        me->CastCustomSpell(pPlayer, 69034, &mirrorDamage, 0, 0, true);
+    //                    me->DealDamage(pPlayer, (uiDamage * 45)/100, 0, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_SHADOW);
+                    }
+                    else
+                        uiMirroredSoulTarget = 0;
                 }
-                else
-                    uiMirroredSoulTarget = 0;
             }
         }
-    }
 
-    void KilledUnit(Unit * /*victim*/)
-    {
-        DoScriptText(RAND(SAY_FACE_ANGER_SLAY_1,SAY_FACE_SORROW_SLAY_1,SAY_FACE_DESIRE_SLAY_1,
-            SAY_FACE_ANGER_SLAY_2,SAY_FACE_SORROW_SLAY_2,SAY_FACE_DESIRE_SLAY_2), me);
-    }
+        void KilledUnit(Unit * /*victim*/)
+        {
+            DoScriptText(RAND(SAY_FACE_ANGER_SLAY_1,SAY_FACE_SORROW_SLAY_1,SAY_FACE_DESIRE_SLAY_1,
+                SAY_FACE_ANGER_SLAY_2,SAY_FACE_SORROW_SLAY_2,SAY_FACE_DESIRE_SLAY_2), me);
+        }
 
-    void JustDied(Unit* /*killer*/)
-    {
-        Position spawnPoint = { 5618.139, 2451.873, 705.854 };
+        void JustDied(Unit* /*killer*/)
+        {
+            Position spawnPoint = { 5618.139, 2451.873, 705.854 };
 
-        DoScriptText(RAND(SAY_FACE_SORROW_DEATH,SAY_FACE_DESIRE_DEATH), me);
+            DoScriptText(RAND(SAY_FACE_SORROW_DEATH,SAY_FACE_DESIRE_DEATH), me);
 
-        if (pInstance)
-        {
-            pInstance->SetData(DATA_DEVOURER_EVENT, DONE);
+            if (pInstance)
+            {
+                pInstance->SetData(DATA_DEVOURER_EVENT, DONE);
 
-            if (bThreeFaceAchievement && IsHeroic())
-                pInstance->DoCompleteAchievement(ACHIEV_THREE_FACED);
+                if (bThreeFaceAchievement && IsHeroic())
+                    pInstance->DoCompleteAchievement(ACHIEV_THREE_FACED);
 
-            int32 entryIndex;
-            if (pInstance->GetData(DATA_TEAM_IN_INSTANCE) == TEAM_ALLIANCE)
-                entryIndex = 0;
-            else
-                entryIndex = 1;
+                int32 entryIndex;
+                if (pInstance->GetData(DATA_TEAM_IN_INSTANCE) == TEAM_ALLIANCE)
+                    entryIndex = 0;
+                else
+                    entryIndex = 1;
 
-            for (int8 i = 0; outroPositions[i].entry[entryIndex] != 0; ++i)
-            {
-                if (Creature *pSummon = me->SummonCreature(outroPositions[i].entry[entryIndex], spawnPoint, TEMPSUMMON_DEAD_DESPAWN))
+                for (int8 i = 0; outroPositions[i].entry[entryIndex] != 0; ++i)
                 {
-                    pSummon->GetMotionMaster()->MovePoint(0, outroPositions[i].movePosition);
+                    if (Creature *pSummon = me->SummonCreature(outroPositions[i].entry[entryIndex], spawnPoint, TEMPSUMMON_DEAD_DESPAWN))
+                    {
+                        pSummon->GetMotionMaster()->MovePoint(0, outroPositions[i].movePosition);
 
-                    if (pSummon->GetEntry() == NPC_JAINA_PART2)
-                        DoScriptText(SAY_JAINA_OUTRO, pSummon);
-                    else if (pSummon->GetEntry() == NPC_SYLVANAS_PART2)
-                        DoScriptText(SAY_SYLVANAS_OUTRO, pSummon);
+                        if (pSummon->GetEntry() == NPC_JAINA_PART2)
+                            DoScriptText(SAY_JAINA_OUTRO, pSummon);
+                        else if (pSummon->GetEntry() == NPC_SYLVANAS_PART2)
+                            DoScriptText(SAY_SYLVANAS_OUTRO, pSummon);
+                    }
                 }
             }
         }
-    }
 
-    void SpellHitTarget(Unit* /*pTarget*/, const SpellEntry *pSpell)
-    {
-        if (pSpell->Id == H_SPELL_PHANTOM_BLAST)
-            bThreeFaceAchievement = false;
-    }
-
-    void UpdateAI(const uint32 diff)
-    {
-        // Return since we have no target
-        if (!UpdateVictim())
-            return;
-
-        events.Update(diff);
-
-        if (me->hasUnitState(UNIT_STAT_CASTING))
-            return;
-
-        while (uint32 eventId = events.ExecuteEvent())
+        void SpellHitTarget(Unit* /*pTarget*/, const SpellEntry *pSpell)
         {
-            switch(eventId)
-            {
-                case EVENT_PHANTOM_BLAST:
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_TOPAGGRO, 0))
-                        DoCast(pTarget, SPELL_PHANTOM_BLAST);
-                    events.ScheduleEvent(EVENT_PHANTOM_BLAST, 5000);
-                    break;
-                case EVENT_MIRRORED_SOUL:
-                    if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 0, true))
-                    {
-                        uiMirroredSoulTarget = pTarget->GetGUID();
-                        DoCast(pTarget, SPELL_MIRRORED_SOUL);
-                        DoScriptText(EMOTE_MIRRORED_SOUL, me);
-                    }
-                    events.ScheduleEvent(EVENT_MIRRORED_SOUL, urand(15000,30000));
-                    break;
-                case EVENT_WELL_OF_SOULS:
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                        DoCast(pTarget, SPELL_WELL_OF_SOULS);
-                    events.ScheduleEvent(EVENT_WELL_OF_SOULS, 20000);
-                    break;
-                case EVENT_UNLEASHED_SOULS:
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                        DoCast(pTarget, SPELL_UNLEASHED_SOULS);
-                    me->SetDisplayId(DISPLAY_SORROW);
-                    DoScriptText(RAND(SAY_FACE_ANGER_UNLEASH_SOUL,SAY_FACE_SORROW_UNLEASH_SOUL,SAY_FACE_DESIRE_UNLEASH_SOUL), me);
-                    DoScriptText(EMOTE_UNLEASH_SOUL, me);
-                    events.ScheduleEvent(EVENT_UNLEASHED_SOULS, 30000);
-                    events.ScheduleEvent(EVENT_FACE_ANGER, 5000);
-                    break;
-                case EVENT_FACE_ANGER:
-                    me->SetDisplayId(DISPLAY_ANGER);
-                    break;
-
-                case EVENT_WAILING_SOULS:
-                    me->SetDisplayId(DISPLAY_DESIRE);
-                    DoScriptText(RAND(SAY_FACE_ANGER_WAILING_SOUL,SAY_FACE_DESIRE_WAILING_SOUL), me);
-                    DoScriptText(EMOTE_WAILING_SOUL, me);
-                    DoCast(me, SPELL_WAILING_SOULS_STARTING);
-
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                    {
-                        me->SetOrientation(me->GetAngle(pTarget));
-                        DoCast(me, SPELL_WAILING_SOULS_BEAM);
-                    }
-
-                    beamAngle = me->GetOrientation();
-
-                    beamAngleDiff = PI/30.0f; // PI/2 in 15 sec = PI/30 per tick
-                    if (RAND(true,false))
-                        beamAngleDiff = -beamAngleDiff;
-
-                    me->InterruptNonMeleeSpells(false);
-                    me->SetReactState(REACT_PASSIVE);
-
-                    //Remove any target
-                    me->SetUInt64Value(UNIT_FIELD_TARGET, 0);
-
-                    me->GetMotionMaster()->Clear();
-                    me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
+            if (pSpell->Id == H_SPELL_PHANTOM_BLAST)
+                bThreeFaceAchievement = false;
+        }
 
-                    wailingSoulTick = 15;
-                    events.DelayEvents(18000); // no other events during wailing souls
-                    events.ScheduleEvent(EVENT_WAILING_SOULS_TICK, 3000); // first one after 3 secs.
-                    break;
+        void UpdateAI(const uint32 diff)
+        {
+            // Return since we have no target
+            if (!UpdateVictim())
+                return;
 
-                case EVENT_WAILING_SOULS_TICK:
-                    beamAngle += beamAngleDiff;
-                    me->SetOrientation(beamAngle);
-                    me->StopMoving();
+            events.Update(diff);
 
-                    DoCast(me, SPELL_WAILING_SOULS);
+            if (me->hasUnitState(UNIT_STAT_CASTING))
+                return;
 
-                    if (--wailingSoulTick)
-                        events.ScheduleEvent(EVENT_WAILING_SOULS_TICK, 1000);
-                    else
-                    {
-                        me->SetReactState(REACT_AGGRESSIVE);
+            while (uint32 eventId = events.ExecuteEvent())
+            {
+                switch(eventId)
+                {
+                    case EVENT_PHANTOM_BLAST:
+                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_TOPAGGRO, 0))
+                            DoCast(pTarget, SPELL_PHANTOM_BLAST);
+                        events.ScheduleEvent(EVENT_PHANTOM_BLAST, 5000);
+                        break;
+                    case EVENT_MIRRORED_SOUL:
+                        if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 0, true))
+                        {
+                            uiMirroredSoulTarget = pTarget->GetGUID();
+                            DoCast(pTarget, SPELL_MIRRORED_SOUL);
+                            DoScriptText(EMOTE_MIRRORED_SOUL, me);
+                        }
+                        events.ScheduleEvent(EVENT_MIRRORED_SOUL, urand(15000,30000));
+                        break;
+                    case EVENT_WELL_OF_SOULS:
+                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                            DoCast(pTarget, SPELL_WELL_OF_SOULS);
+                        events.ScheduleEvent(EVENT_WELL_OF_SOULS, 20000);
+                        break;
+                    case EVENT_UNLEASHED_SOULS:
+                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                            DoCast(pTarget, SPELL_UNLEASHED_SOULS);
+                        me->SetDisplayId(DISPLAY_SORROW);
+                        DoScriptText(RAND(SAY_FACE_ANGER_UNLEASH_SOUL,SAY_FACE_SORROW_UNLEASH_SOUL,SAY_FACE_DESIRE_UNLEASH_SOUL), me);
+                        DoScriptText(EMOTE_UNLEASH_SOUL, me);
+                        events.ScheduleEvent(EVENT_UNLEASHED_SOULS, 30000);
+                        events.ScheduleEvent(EVENT_FACE_ANGER, 5000);
+                        break;
+                    case EVENT_FACE_ANGER:
                         me->SetDisplayId(DISPLAY_ANGER);
-                        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
-                        me->GetMotionMaster()->MoveChase(me->getVictim());
-                        events.ScheduleEvent(EVENT_WAILING_SOULS, urand(60000,70000));
-                    }
-                    break;
+                        break;
+
+                    case EVENT_WAILING_SOULS:
+                        me->SetDisplayId(DISPLAY_DESIRE);
+                        DoScriptText(RAND(SAY_FACE_ANGER_WAILING_SOUL,SAY_FACE_DESIRE_WAILING_SOUL), me);
+                        DoScriptText(EMOTE_WAILING_SOUL, me);
+                        DoCast(me, SPELL_WAILING_SOULS_STARTING);
+
+                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                        {
+                            me->SetOrientation(me->GetAngle(pTarget));
+                            DoCast(me, SPELL_WAILING_SOULS_BEAM);
+                        }
+
+                        beamAngle = me->GetOrientation();
+
+                        beamAngleDiff = PI/30.0f; // PI/2 in 15 sec = PI/30 per tick
+                        if (RAND(true,false))
+                            beamAngleDiff = -beamAngleDiff;
+
+                        me->InterruptNonMeleeSpells(false);
+                        me->SetReactState(REACT_PASSIVE);
+
+                        //Remove any target
+                        me->SetUInt64Value(UNIT_FIELD_TARGET, 0);
+
+                        me->GetMotionMaster()->Clear();
+                        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
+
+                        wailingSoulTick = 15;
+                        events.DelayEvents(18000); // no other events during wailing souls
+                        events.ScheduleEvent(EVENT_WAILING_SOULS_TICK, 3000); // first one after 3 secs.
+                        break;
+
+                    case EVENT_WAILING_SOULS_TICK:
+                        beamAngle += beamAngleDiff;
+                        me->SetOrientation(beamAngle);
+                        me->StopMoving();
+
+                        DoCast(me, SPELL_WAILING_SOULS);
+
+                        if (--wailingSoulTick)
+                            events.ScheduleEvent(EVENT_WAILING_SOULS_TICK, 1000);
+                        else
+                        {
+                            me->SetReactState(REACT_AGGRESSIVE);
+                            me->SetDisplayId(DISPLAY_ANGER);
+                            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
+                            me->GetMotionMaster()->MoveChase(me->getVictim());
+                            events.ScheduleEvent(EVENT_WAILING_SOULS, urand(60000,70000));
+                        }
+                        break;
+                }
             }
+
+            DoMeleeAttackIfReady();
         }
+    };
 
-        DoMeleeAttackIfReady();
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new boss_devourer_of_soulsAI(creature);
     }
 };
 
-CreatureAI* GetAI_boss_devourer_of_souls(Creature* pCreature)
-{
-    return new boss_devourer_of_soulsAI(pCreature);
-}
-
 void AddSC_boss_devourer_of_souls()
 {
-    Script *newscript;
-    newscript = new Script;
-    newscript->Name="boss_devourer_of_souls";
-    newscript->GetAI = &GetAI_boss_devourer_of_souls;
-    newscript->RegisterSelf();
+    new boss_devourer_of_souls;
 }
diff --git a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/forge_of_souls.cpp b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/forge_of_souls.cpp
index 0e0c22c9b10..d329f0d7858 100644
--- a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/forge_of_souls.cpp
+++ b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/forge_of_souls.cpp
@@ -147,754 +147,769 @@ enum Phase
     PHASE_INTRO,
 };
 
-struct npc_sylvanas_fosAI: public ScriptedAI
+class npc_sylvanas_fos : public CreatureScript
 {
-    npc_sylvanas_fosAI(Creature *c) : ScriptedAI(c)
+public:
+    npc_sylvanas_fos() : CreatureScript("npc_sylvanas_fos") { }
+
+    struct npc_sylvanas_fosAI : public ScriptedAI
     {
-        pInstance = me->GetInstanceData();
-        me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
-    }
+        npc_sylvanas_fosAI(Creature *c) : ScriptedAI(c)
+        {
+            pInstance = me->GetInstanceData();
+            me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
+        }
 
-    ScriptedInstance* pInstance;
+        ScriptedInstance* pInstance;
 
-    EventMap events;
-    Phase phase;
+        EventMap events;
+        Phase phase;
 
-    void Reset()
-    {
-        events.Reset();
-        phase = PHASE_NORMAL;
-    }
+        void Reset()
+        {
+            events.Reset();
+            phase = PHASE_NORMAL;
+        }
 
-    void DoAction(const int32 actionId)
-    {
-        switch(actionId)
+        void DoAction(const int32 actionId)
         {
-            case ACTION_INTRO:
+            switch(actionId)
             {
-                phase = PHASE_INTRO;
-                me->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
-                events.Reset();
-                events.ScheduleEvent(EVENT_INTRO_1, 1000);
+                case ACTION_INTRO:
+                {
+                    phase = PHASE_INTRO;
+                    me->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
+                    events.Reset();
+                    events.ScheduleEvent(EVENT_INTRO_1, 1000);
+                }
             }
         }
-    }
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (phase == PHASE_INTRO)
+        void UpdateAI(const uint32 diff)
         {
-            if (!pInstance)
-                return;
-
-            events.Update(diff);
-            switch(events.ExecuteEvent())
+            if (phase == PHASE_INTRO)
             {
-                case EVENT_INTRO_1:
-                    DoScriptText(SAY_SYLVANAS_INTRO_1, me);
-                    events.ScheduleEvent(EVENT_INTRO_2, 11500);
-                    break;
-
-                case EVENT_INTRO_2:
-                    DoScriptText(SAY_SYLVANAS_INTRO_2, me);
-                    events.ScheduleEvent(EVENT_INTRO_3, 10500);
-                    break;
-
-                case EVENT_INTRO_3:
-                    DoScriptText(SAY_SYLVANAS_INTRO_3, me);
-                    events.ScheduleEvent(EVENT_INTRO_4, 9500);
-                    break;
-
-                case EVENT_INTRO_4:
-                    DoScriptText(SAY_SYLVANAS_INTRO_4, me);
-                    events.ScheduleEvent(EVENT_INTRO_5, 10500);
-                    break;
-
-                case EVENT_INTRO_5:
-                    DoScriptText(SAY_SYLVANAS_INTRO_5, me);
-                    events.ScheduleEvent(EVENT_INTRO_6, 9500);
-                    break;
-
-                case EVENT_INTRO_6:
-                    DoScriptText(SAY_SYLVANAS_INTRO_6, me);
-                    // End of Intro
-                    phase = PHASE_NORMAL;
-                    break;
+                if (!pInstance)
+                    return;
+
+                events.Update(diff);
+                switch(events.ExecuteEvent())
+                {
+                    case EVENT_INTRO_1:
+                        DoScriptText(SAY_SYLVANAS_INTRO_1, me);
+                        events.ScheduleEvent(EVENT_INTRO_2, 11500);
+                        break;
+
+                    case EVENT_INTRO_2:
+                        DoScriptText(SAY_SYLVANAS_INTRO_2, me);
+                        events.ScheduleEvent(EVENT_INTRO_3, 10500);
+                        break;
+
+                    case EVENT_INTRO_3:
+                        DoScriptText(SAY_SYLVANAS_INTRO_3, me);
+                        events.ScheduleEvent(EVENT_INTRO_4, 9500);
+                        break;
+
+                    case EVENT_INTRO_4:
+                        DoScriptText(SAY_SYLVANAS_INTRO_4, me);
+                        events.ScheduleEvent(EVENT_INTRO_5, 10500);
+                        break;
+
+                    case EVENT_INTRO_5:
+                        DoScriptText(SAY_SYLVANAS_INTRO_5, me);
+                        events.ScheduleEvent(EVENT_INTRO_6, 9500);
+                        break;
+
+                    case EVENT_INTRO_6:
+                        DoScriptText(SAY_SYLVANAS_INTRO_6, me);
+                        // End of Intro
+                        phase = PHASE_NORMAL;
+                        break;
+                }
             }
-        }
 
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
 
-        events.Update(diff);
+            events.Update(diff);
+            DoMeleeAttackIfReady();
+        }
+    };
 
-        //if (me->hasUnitState(UNIT_STAT_CASTING))
-        //    return;
+    bool OnGossipHello(Player* pPlayer, Creature* pCreature)
+    {
+        if (pCreature->isQuestGiver())
+            pPlayer->PrepareQuestMenu(pCreature->GetGUID());
 
-        //while (uint32 eventId = events.ExecuteEvent())
-        //{
-        //    switch(eventId)
-        //    {
-        //    }
-        //}
+        if (pCreature->GetEntry() == NPC_JAINA_PART1)
+            pPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_JAINA_ITEM, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1);
+        else
+            pPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SYLVANAS_ITEM, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1);
 
-        DoMeleeAttackIfReady();
+        pPlayer->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGE, pCreature->GetGUID());
+        return true;
     }
-};
 
-struct npc_jaina_fosAI: public ScriptedAI
-{
-    npc_jaina_fosAI(Creature *c) : ScriptedAI(c)
+    bool OnGossipSelect(Player* pPlayer, Creature* pCreature, uint32 /*uiSender*/, uint32 uiAction)
     {
-        pInstance = me->GetInstanceData();
-        me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
-    }
+        switch(uiAction)
+        {
+            case GOSSIP_ACTION_INFO_DEF+1:
+                pPlayer->CLOSE_GOSSIP_MENU();
 
-    ScriptedInstance* pInstance;
+                if (pCreature->AI())
+                    pCreature->AI()->DoAction(ACTION_INTRO);
+                break;
+        }
 
-    EventMap events;
-    Phase phase;
+        return true;
+    }
 
-    void Reset()
+    CreatureAI *GetAI(Creature *creature) const
     {
-        events.Reset();
-        phase = PHASE_NORMAL;
+        return new npc_sylvanas_fosAI(creature);
     }
+};
+
+class npc_jaina_fos : public CreatureScript
+{
+public:
+    npc_jaina_fos() : CreatureScript("npc_jaina_fos") { }
 
-    void DoAction(const int32 actionId)
+    struct npc_jaina_fosAI: public ScriptedAI
     {
-        switch(actionId)
+        npc_jaina_fosAI(Creature *c) : ScriptedAI(c)
         {
-            case ACTION_INTRO:
-            {
-                phase = PHASE_INTRO;
-                me->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
-                events.Reset();
-                events.ScheduleEvent(EVENT_INTRO_1, 1000);
-            }
+            pInstance = me->GetInstanceData();
+            me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
         }
-    }
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (phase == PHASE_INTRO)
+        ScriptedInstance* pInstance;
+
+        EventMap events;
+        Phase phase;
+
+        void Reset()
         {
-            if (!pInstance)
-                return;
+            events.Reset();
+            phase = PHASE_NORMAL;
+        }
 
-            events.Update(diff);
-            switch(events.ExecuteEvent())
+        void DoAction(const int32 actionId)
+        {
+            switch(actionId)
             {
-                case EVENT_INTRO_1:
-                    DoScriptText(SAY_JAINA_INTRO_1, me);
-                    events.ScheduleEvent(EVENT_INTRO_2, 8000);
-                    break;
-
-                case EVENT_INTRO_2:
-                    DoScriptText(SAY_JAINA_INTRO_2, me);
-                    events.ScheduleEvent(EVENT_INTRO_3, 8500);
-                    break;
-
-                case EVENT_INTRO_3:
-                    DoScriptText(SAY_JAINA_INTRO_3, me);
-                    events.ScheduleEvent(EVENT_INTRO_4, 8000);
-                    break;
-
-                case EVENT_INTRO_4:
-                    DoScriptText(SAY_JAINA_INTRO_4, me);
-                    events.ScheduleEvent(EVENT_INTRO_5, 10000);
-                    break;
-
-                case EVENT_INTRO_5:
-                    DoScriptText(SAY_JAINA_INTRO_5, me);
-                    events.ScheduleEvent(EVENT_INTRO_6, 8000);
-                    break;
-
-                case EVENT_INTRO_6:
-                    DoScriptText(SAY_JAINA_INTRO_6, me);
-                    events.ScheduleEvent(EVENT_INTRO_7, 12000);
-                    break;
-
-                case EVENT_INTRO_7:
-                    DoScriptText(SAY_JAINA_INTRO_7, me);
-                    events.ScheduleEvent(EVENT_INTRO_8, 8000);
-                    break;
-
-                case EVENT_INTRO_8:
-                    DoScriptText(SAY_JAINA_INTRO_8, me);
-                    // End of Intro
-                    phase = PHASE_NORMAL;
-                    break;
+                case ACTION_INTRO:
+                {
+                    phase = PHASE_INTRO;
+                    me->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
+                    events.Reset();
+                    events.ScheduleEvent(EVENT_INTRO_1, 1000);
+                }
             }
         }
 
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
-
-        events.Update(diff);
-
-        //if (me->hasUnitState(UNIT_STAT_CASTING))
-        //    return;
-
-        //while (uint32 eventId = events.ExecuteEvent())
-        //{
-        //    switch(eventId)
-        //    {
-        //    }
-        //}
+        void UpdateAI(const uint32 diff)
+        {
+            if (phase == PHASE_INTRO)
+            {
+                if (!pInstance)
+                    return;
 
-        DoMeleeAttackIfReady();
-    }
-};
+                events.Update(diff);
+                switch(events.ExecuteEvent())
+                {
+                    case EVENT_INTRO_1:
+                        DoScriptText(SAY_JAINA_INTRO_1, me);
+                        events.ScheduleEvent(EVENT_INTRO_2, 8000);
+                        break;
+
+                    case EVENT_INTRO_2:
+                        DoScriptText(SAY_JAINA_INTRO_2, me);
+                        events.ScheduleEvent(EVENT_INTRO_3, 8500);
+                        break;
+
+                    case EVENT_INTRO_3:
+                        DoScriptText(SAY_JAINA_INTRO_3, me);
+                        events.ScheduleEvent(EVENT_INTRO_4, 8000);
+                        break;
+
+                    case EVENT_INTRO_4:
+                        DoScriptText(SAY_JAINA_INTRO_4, me);
+                        events.ScheduleEvent(EVENT_INTRO_5, 10000);
+                        break;
+
+                    case EVENT_INTRO_5:
+                        DoScriptText(SAY_JAINA_INTRO_5, me);
+                        events.ScheduleEvent(EVENT_INTRO_6, 8000);
+                        break;
+
+                    case EVENT_INTRO_6:
+                        DoScriptText(SAY_JAINA_INTRO_6, me);
+                        events.ScheduleEvent(EVENT_INTRO_7, 12000);
+                        break;
+
+                    case EVENT_INTRO_7:
+                        DoScriptText(SAY_JAINA_INTRO_7, me);
+                        events.ScheduleEvent(EVENT_INTRO_8, 8000);
+                        break;
+
+                    case EVENT_INTRO_8:
+                        DoScriptText(SAY_JAINA_INTRO_8, me);
+                        // End of Intro
+                        phase = PHASE_NORMAL;
+                        break;
+                }
+            }
 
-bool GossipHello_npc_jaina_or_slyvanas_fos(Player* pPlayer, Creature* pCreature)
-{
-    if (pCreature->isQuestGiver())
-        pPlayer->PrepareQuestMenu(pCreature->GetGUID());
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
 
-    if (pCreature->GetEntry() == NPC_JAINA_PART1)
-        pPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_JAINA_ITEM, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1);
-    else
-        pPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SYLVANAS_ITEM, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1);
+            events.Update(diff);
 
-    pPlayer->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGE, pCreature->GetGUID());
-    return true;
-}
+            DoMeleeAttackIfReady();
+        }
+    };
 
-bool GossipSelect_npc_jaina_or_slyvanas_fos(Player* pPlayer, Creature* pCreature, uint32 /*uiSender*/, uint32 uiAction)
-{
-    switch(uiAction)
+    bool OnGossipHello(Player* pPlayer, Creature* pCreature)
     {
-        case GOSSIP_ACTION_INFO_DEF+1:
-            pPlayer->CLOSE_GOSSIP_MENU();
+        if (pCreature->isQuestGiver())
+            pPlayer->PrepareQuestMenu(pCreature->GetGUID());
 
-            if (pCreature->AI())
-                pCreature->AI()->DoAction(ACTION_INTRO);
-            break;
-    }
+        if (pCreature->GetEntry() == NPC_JAINA_PART1)
+            pPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_JAINA_ITEM, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1);
+        else
+            pPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SYLVANAS_ITEM, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1);
 
-    return true;
-}
+        pPlayer->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGE, pCreature->GetGUID());
+        return true;
+    }
 
-struct mob_spiteful_apparitionAI: public ScriptedAI
-{
-    mob_spiteful_apparitionAI(Creature *c) : ScriptedAI(c)
+    bool OnGossipSelect(Player* pPlayer, Creature* pCreature, uint32 /*uiSender*/, uint32 uiAction)
     {
-    }
+        switch(uiAction)
+        {
+            case GOSSIP_ACTION_INFO_DEF+1:
+                pPlayer->CLOSE_GOSSIP_MENU();
 
-    EventMap events;
+                if (pCreature->AI())
+                    pCreature->AI()->DoAction(ACTION_INTRO);
+                break;
+        }
 
-    void Reset()
-    {
-        events.Reset();
+        return true;
     }
 
-    void EnterCombat(Unit* /*who*/)
+    CreatureAI *GetAI(Creature *creature) const
     {
-        events.ScheduleEvent(EVENT_SPITE, 8000);
-    }
-
-    void UpdateAI(const uint32 diff)
-    {
-        //Return since we have no target
-        if (!UpdateVictim())
-            return;
-
-        events.Update(diff);
-
-        if (me->hasUnitState(UNIT_STAT_CASTING))
-            return;
-
-        while (uint32 eventId = events.ExecuteEvent())
-        {
-            switch(eventId)
-            {
-                case EVENT_SPITE:
-                    DoCast(me->getVictim(), SPELL_SPITE);
-                    events.RescheduleEvent(EVENT_SPITE, 8000);
-                    return;
-            }
-        }
-
-        DoMeleeAttackIfReady();
+        return new npc_jaina_fosAI(creature);
     }
 };
 
-struct mob_spectral_wardenAI: public ScriptedAI
+class mob_spiteful_apparition : public CreatureScript
 {
-    mob_spectral_wardenAI(Creature *c) : ScriptedAI(c)
+public:
+    mob_spiteful_apparition() : CreatureScript("mob_spiteful_apparition") { }
+
+    struct mob_spiteful_apparitionAI: public ScriptedAI
     {
-    }
+        mob_spiteful_apparitionAI(Creature *c) : ScriptedAI(c)
+        {
+        }
 
-    EventMap events;
+        EventMap events;
 
-    void Reset()
-    {
-        events.Reset();
-    }
+        void Reset()
+        {
+            events.Reset();
+        }
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        events.ScheduleEvent(EVENT_VEIL_OF_SHADOWS, 5000);
-        events.ScheduleEvent(EVENT_WAIL_OF_SOULS, 10000);
-    }
+        void EnterCombat(Unit* /*who*/)
+        {
+            events.ScheduleEvent(EVENT_SPITE, 8000);
+        }
 
-    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;
 
-        while (uint32 eventId = events.ExecuteEvent())
-        {
-            switch(eventId)
+            while (uint32 eventId = events.ExecuteEvent())
             {
-                case EVENT_VEIL_OF_SHADOWS:
-                    DoCast(me->getVictim(), SPELL_VEIL_OF_SHADOWS);
-                    events.RescheduleEvent(EVENT_VEIL_OF_SHADOWS, 10000);
-                    return;
-                case EVENT_WAIL_OF_SOULS:
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                        DoCast(pTarget, SPELL_WAIL_OF_SOULS);
-                    events.RescheduleEvent(EVENT_WAIL_OF_SOULS, 5000);
-                    return;
+                switch(eventId)
+                {
+                    case EVENT_SPITE:
+                        DoCast(me->getVictim(), SPELL_SPITE);
+                        events.RescheduleEvent(EVENT_SPITE, 8000);
+                        return;
+                }
             }
+
+            DoMeleeAttackIfReady();
         }
-        DoMeleeAttackIfReady();
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_spiteful_apparitionAI(creature);
     }
 };
 
-struct mob_soulguard_watchmanAI: public ScriptedAI
+class mob_spectral_warden : public CreatureScript
 {
-    mob_soulguard_watchmanAI(Creature *c) : ScriptedAI(c)
+public:
+    mob_spectral_warden() : CreatureScript("mob_spectral_warden") { }
+
+    struct mob_spectral_wardenAI: public ScriptedAI
     {
-    }
+        mob_spectral_wardenAI(Creature *c) : ScriptedAI(c)
+        {
+        }
 
-    EventMap events;
+        EventMap events;
 
-    void Reset()
-    {
-        events.Reset();
-    }
+        void Reset()
+        {
+            events.Reset();
+        }
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        events.ScheduleEvent(EVENT_SHROUD_OF_RUNES, 1000);
-        events.ScheduleEvent(EVENT_UNHOLY_RAGE, 1000);
-    }
+        void EnterCombat(Unit* /*who*/)
+        {
+            events.ScheduleEvent(EVENT_VEIL_OF_SHADOWS, 5000);
+            events.ScheduleEvent(EVENT_WAIL_OF_SOULS, 10000);
+        }
 
-    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;
 
-        while (uint32 eventId = events.ExecuteEvent())
-        {
-            switch(eventId)
+            while (uint32 eventId = events.ExecuteEvent())
             {
-                case EVENT_SHROUD_OF_RUNES:
-                    DoCast(me, SPELL_SHROUD_OF_RUNES);
-                    events.RescheduleEvent(EVENT_SHROUD_OF_RUNES, 5000);
-                    return;
-                case EVENT_UNHOLY_RAGE:
-                    DoCast(me, SPELL_UNHOLY_RAGE);
-                    events.RescheduleEvent(EVENT_UNHOLY_RAGE, 99999);
-                    return;
+                switch(eventId)
+                {
+                    case EVENT_VEIL_OF_SHADOWS:
+                        DoCast(me->getVictim(), SPELL_VEIL_OF_SHADOWS);
+                        events.RescheduleEvent(EVENT_VEIL_OF_SHADOWS, 10000);
+                        return;
+                    case EVENT_WAIL_OF_SOULS:
+                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                            DoCast(pTarget, SPELL_WAIL_OF_SOULS);
+                        events.RescheduleEvent(EVENT_WAIL_OF_SOULS, 5000);
+                        return;
+                }
             }
+            DoMeleeAttackIfReady();
         }
-        DoMeleeAttackIfReady();
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_spectral_wardenAI(creature);
     }
 };
 
-struct mob_soulguard_reaperAI: public ScriptedAI
+class mob_soulguard_watchman : public CreatureScript
 {
-    mob_soulguard_reaperAI(Creature *c) : ScriptedAI(c)
+public:
+    mob_soulguard_watchman() : CreatureScript("mob_soulguard_watchman") { }
+
+    struct mob_soulguard_watchmanAI: public ScriptedAI
     {
-    }
+        mob_soulguard_watchmanAI(Creature *c) : ScriptedAI(c) { }
 
-    EventMap events;
+        EventMap events;
 
-    void Reset()
-    {
-        events.Reset();
-    }
+        void Reset()
+        {
+            events.Reset();
+        }
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        events.ScheduleEvent(EVENT_FROST_NOVA, 8000);
-        events.ScheduleEvent(EVENT_SHADOW_LANCE, 5000);
-    }
+        void EnterCombat(Unit* /*who*/)
+        {
+            events.ScheduleEvent(EVENT_SHROUD_OF_RUNES, 1000);
+            events.ScheduleEvent(EVENT_UNHOLY_RAGE, 1000);
+        }
 
-    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;
 
-        while (uint32 eventId = events.ExecuteEvent())
-        {
-            switch(eventId)
+            while (uint32 eventId = events.ExecuteEvent())
             {
-                case EVENT_FROST_NOVA:
-                    DoCast(me, SPELL_FROST_NOVA);
-                    events.RescheduleEvent(EVENT_FROST_NOVA, 9600);
-                    return;
-                case EVENT_SHADOW_LANCE:
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                        DoCast(pTarget, SPELL_SHADOW_LANCE);
-                    events.RescheduleEvent(EVENT_SHADOW_LANCE, 8000);
-                    return;
+                switch(eventId)
+                {
+                    case EVENT_SHROUD_OF_RUNES:
+                        DoCast(me, SPELL_SHROUD_OF_RUNES);
+                        events.RescheduleEvent(EVENT_SHROUD_OF_RUNES, 5000);
+                        return;
+                    case EVENT_UNHOLY_RAGE:
+                        DoCast(me, SPELL_UNHOLY_RAGE);
+                        events.RescheduleEvent(EVENT_UNHOLY_RAGE, 99999);
+                        return;
+                }
             }
+            DoMeleeAttackIfReady();
         }
+    };
 
-        DoMeleeAttackIfReady();
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_soulguard_watchmanAI(creature);
     }
 };
 
-struct  mob_soulguard_bonecasterAI: public ScriptedAI
+class mob_soulguard_reaper : public CreatureScript
 {
-    mob_soulguard_bonecasterAI(Creature *c) : ScriptedAI(c)
+public:
+    mob_soulguard_reaper() : CreatureScript("mob_soulguard_reaper") { }
+
+    struct mob_soulguard_reaperAI: public ScriptedAI
     {
-    }
+        mob_soulguard_reaperAI(Creature *c) : ScriptedAI(c) { }
 
-    EventMap events;
+        EventMap events;
 
-    void Reset()
-    {
-        events.Reset();
-    }
+        void Reset()
+        {
+            events.Reset();
+        }
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        events.ScheduleEvent(EVENT_BONE_VOLLEY, 6000);
-        events.ScheduleEvent(EVENT_RAISE_DEAD, 25000);
-        events.ScheduleEvent(EVENT_SHIELD_OF_BONES, 6000);
-    }
+        void EnterCombat(Unit* /*who*/)
+        {
+            events.ScheduleEvent(EVENT_FROST_NOVA, 8000);
+            events.ScheduleEvent(EVENT_SHADOW_LANCE, 5000);
+        }
 
-    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;
 
-        while (uint32 eventId = events.ExecuteEvent())
-        {
-            switch(eventId)
+            while (uint32 eventId = events.ExecuteEvent())
             {
-                case EVENT_BONE_VOLLEY:
-                    DoCastAOE(SPELL_BONE_VOLLEY);
-                    events.RescheduleEvent(EVENT_BONE_VOLLEY, 7000);
-                    return;
-                case EVENT_RAISE_DEAD:
-                    DoCast(me, SPELL_RAISE_DEAD);
-                    events.RescheduleEvent(EVENT_RAISE_DEAD, 25000);
-                    return;
-                case EVENT_SHIELD_OF_BONES:
-                    DoCast(me, SPELL_SHIELD_OF_BONES);
-                    events.RescheduleEvent(EVENT_SHIELD_OF_BONES, 8000);
-                    return;
+                switch(eventId)
+                {
+                    case EVENT_FROST_NOVA:
+                        DoCast(me, SPELL_FROST_NOVA);
+                        events.RescheduleEvent(EVENT_FROST_NOVA, 9600);
+                        return;
+                    case EVENT_SHADOW_LANCE:
+                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                            DoCast(pTarget, SPELL_SHADOW_LANCE);
+                        events.RescheduleEvent(EVENT_SHADOW_LANCE, 8000);
+                        return;
+                }
             }
+
+            DoMeleeAttackIfReady();
         }
+    };
 
-        DoMeleeAttackIfReady();
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_soulguard_reaperAI(creature);
     }
 };
 
-struct mob_soulguard_animatorAI: public ScriptedAI
+class mob_soulguard_bonecaster : public CreatureScript
 {
-    mob_soulguard_animatorAI(Creature *c) : ScriptedAI(c)
+public:
+    mob_soulguard_bonecaster() : CreatureScript("mob_soulguard_bonecaster") { }
+
+    struct mob_soulguard_bonecasterAI: public ScriptedAI
     {
-    }
+        mob_soulguard_bonecasterAI(Creature *c) : ScriptedAI(c) { }
 
-    EventMap events;
+        EventMap events;
 
-    void Reset()
-    {
-        events.Reset();
-    }
+        void Reset()
+        {
+            events.Reset();
+        }
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        events.ScheduleEvent(EVENT_RAISE_DEAD, 25000);
-        events.ScheduleEvent(EVENT_SHADOW_BOLT, 5000);
-        events.ScheduleEvent(EVENT_SOUL_SICKNESS, 8000);
-        events.ScheduleEvent(EVENT_SOUL_SIPHON, 10000);
-    }
+        void EnterCombat(Unit* /*who*/)
+        {
+            events.ScheduleEvent(EVENT_BONE_VOLLEY, 6000);
+            events.ScheduleEvent(EVENT_RAISE_DEAD, 25000);
+            events.ScheduleEvent(EVENT_SHIELD_OF_BONES, 6000);
+        }
 
-    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;
 
-        while (uint32 eventId = events.ExecuteEvent())
-        {
-            switch(eventId)
+            while (uint32 eventId = events.ExecuteEvent())
             {
-                case EVENT_RAISE_DEAD:
-                    DoCast(me, SPELL_RAISE_DEAD);
-                    events.RescheduleEvent(EVENT_RAISE_DEAD, 25000);
-                    return;
-                case EVENT_SHADOW_BOLT:
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                        DoCast(pTarget, SPELL_SHADOW_BOLT);
-                    events.RescheduleEvent(EVENT_SHADOW_BOLT, 5000);
-                    return;
-                case EVENT_SOUL_SICKNESS:
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                        DoCast(pTarget, SPELL_SOUL_SICKNESS);
-                    events.RescheduleEvent(EVENT_SOUL_SICKNESS, 10000);
-                    return;
-                case EVENT_SOUL_SIPHON:
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                        DoCast(pTarget, SPELL_SOUL_SIPHON);
-                    events.RescheduleEvent(EVENT_SOUL_SIPHON, 8000);
-                    return;
+                switch(eventId)
+                {
+                    case EVENT_BONE_VOLLEY:
+                        DoCastAOE(SPELL_BONE_VOLLEY);
+                        events.RescheduleEvent(EVENT_BONE_VOLLEY, 7000);
+                        return;
+                    case EVENT_RAISE_DEAD:
+                        DoCast(me, SPELL_RAISE_DEAD);
+                        events.RescheduleEvent(EVENT_RAISE_DEAD, 25000);
+                        return;
+                    case EVENT_SHIELD_OF_BONES:
+                        DoCast(me, SPELL_SHIELD_OF_BONES);
+                        events.RescheduleEvent(EVENT_SHIELD_OF_BONES, 8000);
+                        return;
+                }
             }
+
+            DoMeleeAttackIfReady();
         }
+    };
 
-        DoMeleeAttackIfReady();
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_soulguard_bonecasterAI(creature);
     }
 };
 
-struct mob_soulguard_adeptAI: public ScriptedAI
+class mob_soulguard_animator : public CreatureScript
 {
-    mob_soulguard_adeptAI(Creature *c) : ScriptedAI(c)
+public:
+    mob_soulguard_animator() : CreatureScript("mob_soulguard_animator") { }
+
+    struct mob_soulguard_animatorAI : public ScriptedAI
     {
-    }
+        mob_soulguard_animatorAI(Creature *c) : ScriptedAI(c)
+        {
+        }
 
-    EventMap events;
+        EventMap events;
 
-    void Reset()
-    {
-        events.Reset();
-    }
+        void Reset()
+        {
+            events.Reset();
+        }
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        events.ScheduleEvent(EVENT_RAISE_DEAD, 25000);
-        events.ScheduleEvent(EVENT_SHADOW_BOLT, 8000);
-        events.ScheduleEvent(EVENT_DRAIN_LIFE, 7000);
-        events.ScheduleEvent(EVENT_SHADOW_MEND, 35000);
-    }
+        void EnterCombat(Unit* /*who*/)
+        {
+            events.ScheduleEvent(EVENT_RAISE_DEAD, 25000);
+            events.ScheduleEvent(EVENT_SHADOW_BOLT, 5000);
+            events.ScheduleEvent(EVENT_SOUL_SICKNESS, 8000);
+            events.ScheduleEvent(EVENT_SOUL_SIPHON, 10000);
+        }
 
-    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;
 
-        while (uint32 eventId = events.ExecuteEvent())
-        {
-            switch(eventId)
+            while (uint32 eventId = events.ExecuteEvent())
             {
-                case EVENT_RAISE_DEAD:
-                    DoCast(me, SPELL_RAISE_DEAD);
-                    events.RescheduleEvent(EVENT_RAISE_DEAD, 25000);
-                    return;
-                case EVENT_SHADOW_BOLT:
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                        DoCast(pTarget, SPELL_SHADOW_BOLT);
-                    events.RescheduleEvent(EVENT_SHADOW_BOLT, 4000);
-                    return;
-                case EVENT_DRAIN_LIFE:
-                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                        DoCast(pTarget, SPELL_DRAIN_LIFE);
-                    events.RescheduleEvent(EVENT_DRAIN_LIFE, 9000);
-                    return;
-                case EVENT_SHADOW_MEND:
-                    DoCast(me, SPELL_SHADOW_MEND);
-                    events.RescheduleEvent(EVENT_SHADOW_MEND, 20000);
-                    return;
+                switch(eventId)
+                {
+                    case EVENT_RAISE_DEAD:
+                        DoCast(me, SPELL_RAISE_DEAD);
+                        events.RescheduleEvent(EVENT_RAISE_DEAD, 25000);
+                        return;
+                    case EVENT_SHADOW_BOLT:
+                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                            DoCast(pTarget, SPELL_SHADOW_BOLT);
+                        events.RescheduleEvent(EVENT_SHADOW_BOLT, 5000);
+                        return;
+                    case EVENT_SOUL_SICKNESS:
+                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                            DoCast(pTarget, SPELL_SOUL_SICKNESS);
+                        events.RescheduleEvent(EVENT_SOUL_SICKNESS, 10000);
+                        return;
+                    case EVENT_SOUL_SIPHON:
+                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                            DoCast(pTarget, SPELL_SOUL_SIPHON);
+                        events.RescheduleEvent(EVENT_SOUL_SIPHON, 8000);
+                        return;
+                }
             }
+
+            DoMeleeAttackIfReady();
         }
+    };
 
-        DoMeleeAttackIfReady();
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_soulguard_animatorAI(creature);
     }
 };
 
-struct mob_soul_horrorAI: public ScriptedAI
+class mob_soulguard_adept : public CreatureScript
 {
-    mob_soul_horrorAI(Creature *c) : ScriptedAI(c)
+public:
+    mob_soulguard_adept() : CreatureScript("mob_soulguard_adept") { }
+
+    struct mob_soulguard_adeptAI: public ScriptedAI
     {
-    }
+        mob_soulguard_adeptAI(Creature *c) : ScriptedAI(c)
+        {
+        }
 
-    EventMap events;
+        EventMap events;
 
-    void Reset()
-    {
-        events.Reset();
-    }
+        void Reset()
+        {
+            events.Reset();
+        }
 
-    void EnterCombat(Unit* /*who*/)
-    {
-        events.ScheduleEvent(EVENT_SOUL_STRIKE, 6000);
-    }
+        void EnterCombat(Unit* /*who*/)
+        {
+            events.ScheduleEvent(EVENT_RAISE_DEAD, 25000);
+            events.ScheduleEvent(EVENT_SHADOW_BOLT, 8000);
+            events.ScheduleEvent(EVENT_DRAIN_LIFE, 7000);
+            events.ScheduleEvent(EVENT_SHADOW_MEND, 35000);
+        }
 
-    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;
 
-        while (uint32 eventId = events.ExecuteEvent())
-        {
-            switch(eventId)
+            while (uint32 eventId = events.ExecuteEvent())
             {
-                case EVENT_SOUL_STRIKE:
-                    DoCast(me->getVictim(), SPELL_SOUL_STRIKE);
-                    events.RescheduleEvent(EVENT_SOUL_STRIKE, 8000);
-                    return;
+                switch(eventId)
+                {
+                    case EVENT_RAISE_DEAD:
+                        DoCast(me, SPELL_RAISE_DEAD);
+                        events.RescheduleEvent(EVENT_RAISE_DEAD, 25000);
+                        return;
+                    case EVENT_SHADOW_BOLT:
+                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                            DoCast(pTarget, SPELL_SHADOW_BOLT);
+                        events.RescheduleEvent(EVENT_SHADOW_BOLT, 4000);
+                        return;
+                    case EVENT_DRAIN_LIFE:
+                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                            DoCast(pTarget, SPELL_DRAIN_LIFE);
+                        events.RescheduleEvent(EVENT_DRAIN_LIFE, 9000);
+                        return;
+                    case EVENT_SHADOW_MEND:
+                        DoCast(me, SPELL_SHADOW_MEND);
+                        events.RescheduleEvent(EVENT_SHADOW_MEND, 20000);
+                        return;
+                }
             }
+
+            DoMeleeAttackIfReady();
         }
+    };
 
-        DoMeleeAttackIfReady();
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_soulguard_adeptAI(creature);
     }
 };
 
-CreatureAI* GetAI_npc_jaina_fosAI(Creature* pCreature)
+class mob_soul_horror : public CreatureScript
 {
-    return new npc_jaina_fosAI(pCreature);
-};
+public:
+    mob_soul_horror() : CreatureScript("mob_soul_horror") { }
 
-CreatureAI* GetAI_npc_sylvanas_fosAI(Creature* pCreature)
-{
-    return new npc_sylvanas_fosAI(pCreature);
-};
+    struct mob_soul_horrorAI : public ScriptedAI
+    {
+        mob_soul_horrorAI(Creature *c) : ScriptedAI(c) { }
 
-CreatureAI* GetAI_mob_spiteful_apparitionAI(Creature* pCreature)
-{
-    return new mob_spiteful_apparitionAI(pCreature);
-}
+        EventMap events;
 
-CreatureAI* GetAI_mob_spectral_wardenAI(Creature* pCreature)
-{
-    return new mob_spectral_wardenAI(pCreature);
-}
+        void Reset()
+        {
+            events.Reset();
+        }
 
-CreatureAI* GetAI_mob_soulguard_watchmanAI(Creature* pCreature)
-{
-    return new mob_soulguard_watchmanAI(pCreature);
-}
+        void EnterCombat(Unit* /*who*/)
+        {
+            events.ScheduleEvent(EVENT_SOUL_STRIKE, 6000);
+        }
 
-CreatureAI* GetAI_mob_soulguard_reaperAI(Creature* pCreature)
-{
-    return new mob_soulguard_reaperAI(pCreature);
-}
+        void UpdateAI(const uint32 diff)
+        {
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
 
-CreatureAI* GetAI_mob_soulguard_bonecasterAI(Creature* pCreature)
-{
-    return new mob_soulguard_bonecasterAI(pCreature);
-}
+            events.Update(diff);
 
-CreatureAI* GetAI_mob_soulguard_animatorAI(Creature* pCreature)
-{
-    return new mob_soulguard_animatorAI(pCreature);
-}
+            if (me->hasUnitState(UNIT_STAT_CASTING))
+                return;
 
-CreatureAI* GetAI_mob_soulguard_adeptAI(Creature* pCreature)
-{
-    return new mob_soulguard_adeptAI(pCreature);
-}
+            while (uint32 eventId = events.ExecuteEvent())
+            {
+                switch(eventId)
+                {
+                    case EVENT_SOUL_STRIKE:
+                        DoCast(me->getVictim(), SPELL_SOUL_STRIKE);
+                        events.RescheduleEvent(EVENT_SOUL_STRIKE, 8000);
+                        return;
+                }
+            }
 
-CreatureAI* GetAI_mob_soul_horrorAI(Creature* pCreature)
-{
-    return new mob_soul_horrorAI(pCreature);
-}
+            DoMeleeAttackIfReady();
+        }
+    };
+
+    CreatureAI *GetAI(Creature *creature) const
+    {
+        return new mob_soul_horrorAI(creature);
+    }
+};
 
 void AddSC_forge_of_souls()
 {
-    Script *newscript;
-
-    newscript = new Script;
-    newscript->Name = "npc_sylvanas_fos";
-    newscript->GetAI = &GetAI_npc_sylvanas_fosAI;
-    newscript->pGossipHello = &GossipHello_npc_jaina_or_slyvanas_fos;
-    newscript->pGossipSelect = &GossipSelect_npc_jaina_or_slyvanas_fos;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name = "npc_jaina_fos";
-    newscript->GetAI = &GetAI_npc_jaina_fosAI;
-    newscript->pGossipHello = &GossipHello_npc_jaina_or_slyvanas_fos;
-    newscript->pGossipSelect = &GossipSelect_npc_jaina_or_slyvanas_fos;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name="mob_spiteful_apparition";
-    newscript->GetAI = &GetAI_mob_spiteful_apparitionAI;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name="mob_spectral_warden";
-    newscript->GetAI = &GetAI_mob_spectral_wardenAI;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name="mob_soulguard_watchman";
-    newscript->GetAI = &GetAI_mob_soulguard_watchmanAI;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name="mob_soulguard_reaper";
-    newscript->GetAI = &GetAI_mob_soulguard_reaperAI;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name="mob_soulguard_bonecaster";
-    newscript->GetAI = &GetAI_mob_soulguard_bonecasterAI;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name="mob_soulguard_animator";
-    newscript->GetAI = &GetAI_mob_soulguard_animatorAI;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name="mob_soulguard_adept";
-    newscript->GetAI = &GetAI_mob_soulguard_adeptAI;
-    newscript->RegisterSelf();
-
-    newscript = new Script;
-    newscript->Name="mob_soul_horror";
-    newscript->GetAI = &GetAI_mob_soul_horrorAI;
-    newscript->RegisterSelf();
+    new npc_sylvanas_fos;
+    new npc_jaina_fos;
+    new mob_spiteful_apparition;
+    new mob_spectral_warden;
+    new mob_soulguard_watchman;
+    new mob_soulguard_reaper;
+    new mob_soulguard_bonecaster;
+    new mob_soulguard_animator;
+    new mob_soulguard_adept;
+    new mob_soul_horror;
 }
diff --git a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/instance_forge_of_souls.cpp b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/instance_forge_of_souls.cpp
index 074a9d40915..b1797806d89 100644
--- a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/instance_forge_of_souls.cpp
+++ b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/instance_forge_of_souls.cpp
@@ -25,145 +25,147 @@
 1- The Devourer of Souls
 */
 
-struct instance_forge_of_souls : public ScriptedInstance
+class instance_forge_of_souls : public InstanceMapScript
 {
-    instance_forge_of_souls(Map* pMap) : ScriptedInstance(pMap) {};
+public:
+    instance_forge_of_souls() : InstanceMapScript("instance_forge_of_souls") { }
 
-    uint64 uiBronjahm;
-    uint64 uiDevourer;
-
-    uint32 uiEncounter[MAX_ENCOUNTER];
-    uint32 uiTeamInInstance;
-
-    void Initialize()
+    struct instance_forge_of_souls_ScriptedInstance : public ScriptedInstance
     {
-        uiBronjahm = 0;
-        uiDevourer = 0;
+        instance_forge_of_souls_ScriptedInstance(Map* pMap) : ScriptedInstance(pMap) {};
 
-        uiTeamInInstance = 0;
+        uint64 uiBronjahm;
+        uint64 uiDevourer;
 
-        for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-            uiEncounter[i] = NOT_STARTED;
-    }
-
-    bool IsEncounterInProgress() const
-    {
-        for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-            if (uiEncounter[i] == IN_PROGRESS) return true;
+        uint32 uiEncounter[MAX_ENCOUNTER];
+        uint32 uiTeamInInstance;
 
-        return false;
-    }
+        void Initialize()
+        {
+            uiBronjahm = 0;
+            uiDevourer = 0;
 
-    void OnCreatureCreate(Creature* pCreature, bool /*add*/)
-    {
-        Map::PlayerList const &players = instance->GetPlayers();
+            uiTeamInInstance = 0;
 
-        if (!players.isEmpty())
-            if (Player* pPlayer = players.begin()->getSource())
-                uiTeamInInstance = pPlayer->GetTeam();
+            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
+                uiEncounter[i] = NOT_STARTED;
+        }
 
-        switch(pCreature->GetEntry())
+        bool IsEncounterInProgress() const
         {
-            case CREATURE_BRONJAHM:
-                uiBronjahm = pCreature->GetGUID();
-                break;
-            case CREATURE_DEVOURER:
-                uiDevourer = pCreature->GetGUID();
-                break;
+            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
+                if (uiEncounter[i] == IN_PROGRESS) return true;
+
+            return false;
         }
-    }
 
-    void SetData(uint32 type, uint32 data)
-    {
-        switch(type)
+        void OnCreatureCreate(Creature* pCreature, bool /*add*/)
         {
-            case DATA_BRONJAHM_EVENT:
-                uiEncounter[0] = data;
-                break;
-            case DATA_DEVOURER_EVENT:
-                uiEncounter[1] = data;
-                break;
+            Map::PlayerList const &players = instance->GetPlayers();
+
+            if (!players.isEmpty())
+                if (Player* pPlayer = players.begin()->getSource())
+                    uiTeamInInstance = pPlayer->GetTeam();
+
+            switch(pCreature->GetEntry())
+            {
+                case CREATURE_BRONJAHM:
+                    uiBronjahm = pCreature->GetGUID();
+                    break;
+                case CREATURE_DEVOURER:
+                    uiDevourer = pCreature->GetGUID();
+                    break;
+            }
         }
 
-        if (data == DONE)
-            SaveToDB();
-    }
-
-    uint32 GetData(uint32 type)
-    {
-        switch(type)
+        void SetData(uint32 type, uint32 data)
         {
-            case DATA_BRONJAHM_EVENT:    return uiEncounter[0];
-            case DATA_DEVOURER_EVENT:    return uiEncounter[1];
-            case DATA_TEAM_IN_INSTANCE:  return uiTeamInInstance;
+            switch(type)
+            {
+                case DATA_BRONJAHM_EVENT:
+                    uiEncounter[0] = data;
+                    break;
+                case DATA_DEVOURER_EVENT:
+                    uiEncounter[1] = data;
+                    break;
+            }
+
+            if (data == DONE)
+                SaveToDB();
         }
 
-        return 0;
-    }
-
-    uint64 GetData64(uint32 identifier)
-    {
-        switch(identifier)
+        uint32 GetData(uint32 type)
         {
-            case DATA_BRONJAHM:         return uiBronjahm;
-            case DATA_DEVOURER:         return uiBronjahm;
+            switch(type)
+            {
+                case DATA_BRONJAHM_EVENT:    return uiEncounter[0];
+                case DATA_DEVOURER_EVENT:    return uiEncounter[1];
+                case DATA_TEAM_IN_INSTANCE:  return uiTeamInInstance;
+            }
+
+            return 0;
         }
 
-        return 0;
-    }
+        uint64 GetData64(uint32 identifier)
+        {
+            switch(identifier)
+            {
+                case DATA_BRONJAHM:         return uiBronjahm;
+                case DATA_DEVOURER:         return uiBronjahm;
+            }
 
-    std::string GetSaveData()
-    {
-        OUT_SAVE_INST_DATA;
+            return 0;
+        }
 
-        std::ostringstream saveStream;
-        saveStream << "F S " << uiEncounter[0] << " " << uiEncounter[1];
+        std::string GetSaveData()
+        {
+            OUT_SAVE_INST_DATA;
 
-        OUT_SAVE_INST_DATA_COMPLETE;
-        return saveStream.str();
-    }
+            std::ostringstream saveStream;
+            saveStream << "F S " << uiEncounter[0] << " " << uiEncounter[1];
 
-    void Load(const char* in)
-    {
-        if (!in)
-        {
-            OUT_LOAD_INST_DATA_FAIL;
-            return;
+            OUT_SAVE_INST_DATA_COMPLETE;
+            return saveStream.str();
         }
 
-        OUT_LOAD_INST_DATA(in);
+        void Load(const char* in)
+        {
+            if (!in)
+            {
+                OUT_LOAD_INST_DATA_FAIL;
+                return;
+            }
 
-        char dataHead1, dataHead2;
-        uint16 data0, data1;
+            OUT_LOAD_INST_DATA(in);
 
-        std::istringstream loadStream(in);
-        loadStream >> dataHead1 >> dataHead2 >> data0 >> data1;
+            char dataHead1, dataHead2;
+            uint16 data0, data1;
 
-        if (dataHead1 == 'F' && dataHead2 == 'S')
-        {
-            uiEncounter[0] = data0;
-            uiEncounter[1] = data1;
+            std::istringstream loadStream(in);
+            loadStream >> dataHead1 >> dataHead2 >> data0 >> data1;
 
-            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-                if (uiEncounter[i] == IN_PROGRESS)
-                    uiEncounter[i] = NOT_STARTED;
+            if (dataHead1 == 'F' && dataHead2 == 'S')
+            {
+                uiEncounter[0] = data0;
+                uiEncounter[1] = data1;
+
+                for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
+                    if (uiEncounter[i] == IN_PROGRESS)
+                        uiEncounter[i] = NOT_STARTED;
 
-        } else OUT_LOAD_INST_DATA_FAIL;
+            } else OUT_LOAD_INST_DATA_FAIL;
+
+            OUT_LOAD_INST_DATA_COMPLETE;
+        }
+    };
 
-        OUT_LOAD_INST_DATA_COMPLETE;
+    InstanceData* GetInstanceData(InstanceMap *map) const
+    {
+        return new instance_forge_of_souls_ScriptedInstance(map);
     }
 };
 
-InstanceData* GetInstanceData_instance_forge_of_souls(Map* pMap)
-{
-    return new instance_forge_of_souls(pMap);
-}
-
 void AddSC_instance_forge_of_souls()
 {
-    Script *newscript;
-    newscript = new Script;
-    newscript->Name = "instance_forge_of_souls";
-    newscript->GetInstanceData = &GetInstanceData_instance_forge_of_souls;
-    newscript->RegisterSelf();
+    new instance_forge_of_souls;
 }