convert Blood Furnace to new format

--HG--
branch : trunk

4 files changed, 660 insertions, 604 deletions

diff --git a/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_broggok.cpp b/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_broggok.cpp
index 3a8fcee2975..e620ec08add 100644
--- a/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_broggok.cpp
+++ b/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_broggok.cpp
@@ -37,97 +37,109 @@ enum eEnums
     SPELL_POISON            = 30914
 };
 
-struct boss_broggokAI : public ScriptedAI
+class boss_broggok : public CreatureScript
 {
-    boss_broggokAI(Creature *c) : ScriptedAI(c)
-    {
-        pInstance = c->GetInstanceData();
-    }
-
-    ScriptedInstance* pInstance;
-
-    uint32 AcidSpray_Timer;
-    uint32 PoisonSpawn_Timer;
-    uint32 PoisonBolt_Timer;
-
-    void Reset()
-    {
-        AcidSpray_Timer = 10000;
-        PoisonSpawn_Timer = 5000;
-        PoisonBolt_Timer = 7000;
-        if (pInstance)
-        {
-            pInstance->SetData(TYPE_BROGGOK_EVENT, NOT_STARTED);
-            pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR4), true);
-        }
-    }
+    public:
 
-    void EnterCombat(Unit * /*who*/)
-    {
-        DoScriptText(SAY_AGGRO, me);
-        if (pInstance)
+        boss_broggok()
+            : CreatureScript("boss_broggok")
         {
-            pInstance->SetData(TYPE_BROGGOK_EVENT, IN_PROGRESS);
-            pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR4), false);
         }
-    }
-
-    void JustSummoned(Creature *summoned)
-    {
-        summoned->setFaction(16);
-        summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
-        summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-        summoned->CastSpell(summoned,SPELL_POISON,false,0,0,me->GetGUID());
-    }
-
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
-
-        if (AcidSpray_Timer <= diff)
-        {
-            DoCast(me->getVictim(), SPELL_SLIME_SPRAY);
-            AcidSpray_Timer = 4000+rand()%8000;
-        } else AcidSpray_Timer -=diff;
 
-        if (PoisonBolt_Timer <= diff)
+        struct boss_broggokAI : public ScriptedAI
         {
-            DoCast(me->getVictim(), SPELL_POISON_BOLT);
-            PoisonBolt_Timer = 4000+rand()%8000;
-        } else PoisonBolt_Timer -=diff;
-
-        if (PoisonSpawn_Timer <= diff)
+            boss_broggokAI(Creature* pCreature) : ScriptedAI(pCreature)
+            {
+                pInstance = pCreature->GetInstanceData();
+            }
+
+            ScriptedInstance* pInstance;
+
+            uint32 AcidSpray_Timer;
+            uint32 PoisonSpawn_Timer;
+            uint32 PoisonBolt_Timer;
+
+            void Reset()
+            {
+                AcidSpray_Timer = 10000;
+                PoisonSpawn_Timer = 5000;
+                PoisonBolt_Timer = 7000;
+                if (pInstance)
+                {
+                    pInstance->SetData(TYPE_BROGGOK_EVENT, NOT_STARTED);
+                    pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR4), true);
+                }
+            }
+
+            void EnterCombat(Unit * /*who*/)
+            {
+                DoScriptText(SAY_AGGRO, me);
+                if (pInstance)
+                {
+                    pInstance->SetData(TYPE_BROGGOK_EVENT, IN_PROGRESS);
+                    pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR4), false);
+                }
+            }
+
+            void JustSummoned(Creature *summoned)
+            {
+                summoned->setFaction(16);
+                summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
+                summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
+                summoned->CastSpell(summoned,SPELL_POISON,false,0,0,me->GetGUID());
+            }
+
+            void UpdateAI(const uint32 diff)
+            {
+                if (!UpdateVictim())
+                    return;
+
+                if (AcidSpray_Timer <= diff)
+                {
+                    DoCast(me->getVictim(), SPELL_SLIME_SPRAY);
+                    AcidSpray_Timer = 4000+rand()%8000;
+                } 
+                else
+                    AcidSpray_Timer -=diff;
+
+                if (PoisonBolt_Timer <= diff)
+                {
+                    DoCast(me->getVictim(), SPELL_POISON_BOLT);
+                    PoisonBolt_Timer = 4000+rand()%8000;
+                } 
+                else 
+                    PoisonBolt_Timer -=diff;
+
+                if (PoisonSpawn_Timer <= diff)
+                {
+                    DoCast(me, SPELL_POISON_CLOUD);
+                    PoisonSpawn_Timer = 20000;
+                } 
+                else 
+                    PoisonSpawn_Timer -=diff;
+
+                DoMeleeAttackIfReady();
+            }
+
+            void JustDied(Unit* /*who*/)
+            {
+                if (pInstance)
+                {
+                    pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR4), true);
+                    pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR5), true);
+                    pInstance->SetData(TYPE_BROGGOK_EVENT, DONE);
+                }
+            }
+
+        };
+
+        CreatureAI* GetAI(Creature* Creature) const
         {
-            DoCast(me, SPELL_POISON_CLOUD);
-            PoisonSpawn_Timer = 20000;
-        } else PoisonSpawn_Timer -=diff;
-
-        DoMeleeAttackIfReady();
-    }
-
-    void JustDied(Unit* /*who*/)
-    {
-        if (pInstance)
-        {
-            pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR4), true);
-            pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR5), true);
-            pInstance->SetData(TYPE_BROGGOK_EVENT, DONE);
+            return new boss_broggokAI (Creature);
         }
-    }
-
 };
 
-CreatureAI* GetAI_boss_broggok(Creature* pCreature)
-{
-    return new boss_broggokAI (pCreature);
-}
-
 void AddSC_boss_broggok()
 {
-    Script *newscript;
-    newscript = new Script;
-    newscript->Name = "boss_broggok";
-    newscript->GetAI = &GetAI_boss_broggok;
-    newscript->RegisterSelf();
+    new boss_broggok();
 }
diff --git a/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_kelidan_the_breaker.cpp b/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_kelidan_the_breaker.cpp
index 5b705708e9b..e2674cfcb9d 100644
--- a/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_kelidan_the_breaker.cpp
+++ b/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_kelidan_the_breaker.cpp
@@ -67,192 +67,212 @@ const float ShadowmoonChannelers[5][4]=
     {316,-109,-24.6,1.257}
 };
 
-struct boss_kelidan_the_breakerAI : public ScriptedAI
+class boss_kelidan_the_breaker : public CreatureScript
 {
-    boss_kelidan_the_breakerAI(Creature *c) : ScriptedAI(c)
-    {
-        pInstance = c->GetInstanceData();
-        for (uint8 i=0; i<5; ++i)
-            Channelers[i] = 0;
-    }
-
-    ScriptedInstance* pInstance;
-
-    uint32 ShadowVolley_Timer;
-    uint32 BurningNova_Timer;
-    uint32 Firenova_Timer;
-    uint32 Corruption_Timer;
-    uint32 check_Timer;
-    bool Firenova;
-    bool addYell;
-    uint64 Channelers[5];
-
-    void Reset()
-    {
-        ShadowVolley_Timer = 1000;
-        BurningNova_Timer = 15000;
-        Corruption_Timer = 5000;
-        check_Timer = 0;
-        Firenova = false;
-        addYell = false;
-        SummonChannelers();
-        if (pInstance)
-            pInstance->SetData(TYPE_KELIDAN_THE_BREAKER_EVENT, NOT_STARTED);
-    }
-
-    void EnterCombat(Unit* who)
-    {
-        DoScriptText(SAY_WAKE, me);
-        if (me->IsNonMeleeSpellCasted(false))
-            me->InterruptNonMeleeSpells(true);
-        DoStartMovement(who);
-        if (pInstance)
-            pInstance->SetData(TYPE_KELIDAN_THE_BREAKER_EVENT, IN_PROGRESS);
-    }
-
-    void KilledUnit(Unit* /*victim*/)
-    {
-        if (rand()%2)
-            return;
-
-        DoScriptText(RAND(SAY_KILL_1,SAY_KILL_2), me);
-    }
-
-    void ChannelerEngaged(Unit* who)
-    {
-        if (who && !addYell)
-        {
-            addYell = true;
-            DoScriptText(RAND(SAY_ADD_AGGRO_1,SAY_ADD_AGGRO_2,SAY_ADD_AGGRO_3), me);
-        }
-        for (uint8 i=0; i<5; ++i)
+    public:
+
+        boss_kelidan_the_breaker()
+            : CreatureScript("boss_kelidan_the_breaker")
         {
-            Creature *channeler = Unit::GetCreature(*me, Channelers[i]);
-            if (who && channeler && !channeler->isInCombat())
-                channeler->AI()->AttackStart(who);
         }
-    }
 
-    void ChannelerDied(Unit* killer)
-    {
-        for (uint8 i=0; i<5; ++i)
+        struct boss_kelidan_the_breakerAI : public ScriptedAI
         {
-            Creature *channeler = Unit::GetCreature(*me, Channelers[i]);
-            if (channeler && channeler->isAlive())
-                return;
-        }
+            boss_kelidan_the_breakerAI(Creature* pCreature) : ScriptedAI(pCreature)
+            {
+                pInstance = pCreature->GetInstanceData();
+                for (uint8 i=0; i<5; ++i)
+                    Channelers[i] = 0;
+            }
 
-        if (killer)
-            me->AI()->AttackStart(killer);
-    }
+            ScriptedInstance* pInstance;
 
-    uint64 GetChanneled(Creature *channeler1)
-    {
-        SummonChannelers();
-        if (!channeler1) return NULL;
-        uint8 i;
-        for (i=0; i<5; ++i)
-        {
-            Creature *channeler = Unit::GetCreature(*me, Channelers[i]);
-            if (channeler && channeler->GetGUID() == channeler1->GetGUID())
-                break;
-        }
-        return Channelers[(i+2)%5];
-    }
+            uint32 ShadowVolley_Timer;
+            uint32 BurningNova_Timer;
+            uint32 Firenova_Timer;
+            uint32 Corruption_Timer;
+            uint32 check_Timer;
+            bool Firenova;
+            bool addYell;
+            uint64 Channelers[5];
 
-    void SummonChannelers()
-    {
-        for (uint8 i=0; i<5; ++i)
-        {
-            Creature *channeler = Unit::GetCreature(*me, Channelers[i]);
-            if (!channeler || channeler->isDead())
-                channeler = me->SummonCreature(ENTRY_CHANNELER,ShadowmoonChannelers[i][0],ShadowmoonChannelers[i][1],ShadowmoonChannelers[i][2],ShadowmoonChannelers[i][3],TEMPSUMMON_CORPSE_TIMED_DESPAWN,300000);
-            if (channeler)
-                Channelers[i] = channeler->GetGUID();
-            else
-                Channelers[i] = 0;
-        }
-    }
+            void Reset()
+            {
+                ShadowVolley_Timer = 1000;
+                BurningNova_Timer = 15000;
+                Corruption_Timer = 5000;
+                check_Timer = 0;
+                Firenova = false;
+                addYell = false;
+                SummonChannelers();
+                if (pInstance)
+                    pInstance->SetData(TYPE_KELIDAN_THE_BREAKER_EVENT, NOT_STARTED);
+            }
 
-    void JustDied(Unit* /*Killer*/)
-    {
-        DoScriptText(SAY_DIE, me);
+            void EnterCombat(Unit* who)
+            {
+                DoScriptText(SAY_WAKE, me);
+                if (me->IsNonMeleeSpellCasted(false))
+                    me->InterruptNonMeleeSpells(true);
+                DoStartMovement(who);
+                if (pInstance)
+                    pInstance->SetData(TYPE_KELIDAN_THE_BREAKER_EVENT, IN_PROGRESS);
+            }
 
-        if (!pInstance)
-            return;
+            void KilledUnit(Unit* /*victim*/)
+            {
+                if (rand()%2)
+                    return;
 
-        pInstance->SetData(TYPE_KELIDAN_THE_BREAKER_EVENT, DONE);
-        pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR1), true);
-        pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR6), true);
-    }
+                DoScriptText(RAND(SAY_KILL_1,SAY_KILL_2), me);
+            }
 
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-        {
-            if (check_Timer <= diff)
+            void ChannelerEngaged(Unit* who)
             {
-                if (!me->IsNonMeleeSpellCasted(false))
-                    DoCast(me, SPELL_EVOCATION);
-                check_Timer = 5000;
-            } else check_Timer -= diff;
-            return;
-        }
+                if (who && !addYell)
+                {
+                    addYell = true;
+                    DoScriptText(RAND(SAY_ADD_AGGRO_1,SAY_ADD_AGGRO_2,SAY_ADD_AGGRO_3), me);
+                }
+                for (uint8 i=0; i<5; ++i)
+                {
+                    Creature *channeler = Unit::GetCreature(*me, Channelers[i]);
+                    if (who && channeler && !channeler->isInCombat())
+                        channeler->AI()->AttackStart(who);
+                }
+            }
 
-        if (Firenova)
-        {
-            if (Firenova_Timer <= diff)
+            void ChannelerDied(Unit* killer)
             {
-                DoCast(me, SPELL_FIRE_NOVA, true);
-                Firenova = false;
-                ShadowVolley_Timer = 2000;
-            } else Firenova_Timer -=diff;
+                for (uint8 i=0; i<5; ++i)
+                {
+                    Creature *channeler = Unit::GetCreature(*me, Channelers[i]);
+                    if (channeler && channeler->isAlive())
+                        return;
+                }
+
+                if (killer)
+                    me->AI()->AttackStart(killer);
+            }
 
-            return;
-        }
+            uint64 GetChanneled(Creature *channeler1)
+            {
+                SummonChannelers();
+                if (!channeler1) return NULL;
+                uint8 i;
+                for (i=0; i<5; ++i)
+                {
+                    Creature *channeler = Unit::GetCreature(*me, Channelers[i]);
+                    if (channeler && channeler->GetGUID() == channeler1->GetGUID())
+                        break;
+                }
+                return Channelers[(i+2)%5];
+            }
 
-        if (ShadowVolley_Timer <= diff)
-        {
-            DoCast(me, SPELL_SHADOW_BOLT_VOLLEY);
-            ShadowVolley_Timer = 5000+rand()%8000;
-        } else ShadowVolley_Timer -=diff;
+            void SummonChannelers()
+            {
+                for (uint8 i=0; i<5; ++i)
+                {
+                    Creature *channeler = Unit::GetCreature(*me, Channelers[i]);
+                    if (!channeler || channeler->isDead())
+                        channeler = me->SummonCreature(ENTRY_CHANNELER,ShadowmoonChannelers[i][0],ShadowmoonChannelers[i][1],ShadowmoonChannelers[i][2],ShadowmoonChannelers[i][3],TEMPSUMMON_CORPSE_TIMED_DESPAWN,300000);
+                    if (channeler)
+                        Channelers[i] = channeler->GetGUID();
+                    else
+                        Channelers[i] = 0;
+                }
+            }
 
-        if (Corruption_Timer <= diff)
-        {
-            DoCast(me, SPELL_CORRUPTION);
-            Corruption_Timer = 30000+rand()%20000;
-        } else Corruption_Timer -=diff;
+            void JustDied(Unit* /*Killer*/)
+            {
+                DoScriptText(SAY_DIE, me);
 
-        if (BurningNova_Timer <= diff)
-        {
-            if (me->IsNonMeleeSpellCasted(false))
-                me->InterruptNonMeleeSpells(true);
+                if (!pInstance)
+                    return;
 
-            DoScriptText(SAY_NOVA, me);
+                pInstance->SetData(TYPE_KELIDAN_THE_BREAKER_EVENT, DONE);
+                pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR1), true);
+                pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR6), true);
+            }
 
-            if (SpellEntry *nova = GET_SPELL(SPELL_BURNING_NOVA))
+            void UpdateAI(const uint32 diff)
             {
-                if (Aura * aura = Aura::TryCreate(nova, me, me))
-                    aura->ApplyForTargets();
-            }
+                if (!UpdateVictim())
+                {
+                    if (check_Timer <= diff)
+                    {
+                        if (!me->IsNonMeleeSpellCasted(false))
+                            DoCast(me, SPELL_EVOCATION);
+                        check_Timer = 5000;
+                    }
+                    else
+                        check_Timer -= diff;
+                    return;
+                }
+
+                if (Firenova)
+                {
+                    if (Firenova_Timer <= diff)
+                    {
+                        DoCast(me, SPELL_FIRE_NOVA, true);
+                        Firenova = false;
+                        ShadowVolley_Timer = 2000;
+                    }
+                    else
+                        Firenova_Timer -=diff;
+
+                    return;
+                }
+
+                if (ShadowVolley_Timer <= diff)
+                {
+                    DoCast(me, SPELL_SHADOW_BOLT_VOLLEY);
+                    ShadowVolley_Timer = 5000+rand()%8000;
+                } 
+                else 
+                    ShadowVolley_Timer -=diff;
+
+                if (Corruption_Timer <= diff)
+                {
+                    DoCast(me, SPELL_CORRUPTION);
+                    Corruption_Timer = 30000+rand()%20000;
+                }
+                else 
+                    Corruption_Timer -=diff;
+
+                if (BurningNova_Timer <= diff)
+                {
+                    if (me->IsNonMeleeSpellCasted(false))
+                        me->InterruptNonMeleeSpells(true);
+
+                    DoScriptText(SAY_NOVA, me);
+
+                    if (SpellEntry *nova = GET_SPELL(SPELL_BURNING_NOVA))
+                    {
+                        if (Aura * aura = Aura::TryCreate(nova, me, me))
+                            aura->ApplyForTargets();
+                    }
 
-            if (IsHeroic())
-                DoTeleportAll(me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(),me->GetOrientation());
+                    if (IsHeroic())
+                        DoTeleportAll(me->GetPositionX(),me->GetPositionY(),me->GetPositionZ(),me->GetOrientation());
 
-            BurningNova_Timer = 20000+rand()%8000;
-            Firenova_Timer= 5000;
-            Firenova = true;
-        } else BurningNova_Timer -=diff;
+                    BurningNova_Timer = 20000+rand()%8000;
+                    Firenova_Timer= 5000;
+                    Firenova = true;
+                }
+                else
+                    BurningNova_Timer -=diff;
 
-        DoMeleeAttackIfReady();
-    }
+                DoMeleeAttackIfReady();
+            }
 
-};
+        };
 
-CreatureAI* GetAI_boss_kelidan_the_breaker(Creature* pCreature)
-{
-    return new boss_kelidan_the_breakerAI (pCreature);
-}
+        CreatureAI* GetAI(Creature* Creature) const
+        {
+            return new boss_kelidan_the_breakerAI (Creature);
+        }
+};
 
 /*######
 ## mob_shadowmoon_channeler
@@ -267,92 +287,99 @@ enum eShadowmoon
     SPELL_CHANNELING        = 39123
 };
 
-struct mob_shadowmoon_channelerAI : public ScriptedAI
+class mob_shadowmoon_channeler : public CreatureScript
 {
-    mob_shadowmoon_channelerAI(Creature *c) : ScriptedAI(c)
-    {
-    }
-
-    uint32 ShadowBolt_Timer;
-    uint32 MarkOfShadow_Timer;
-    uint32 check_Timer;
-
-    void Reset()
-    {
-        ShadowBolt_Timer = 1000+rand()%1000;
-        MarkOfShadow_Timer = 5000+rand()%2000;
-        check_Timer = 0;
-        if (me->IsNonMeleeSpellCasted(false))
-            me->InterruptNonMeleeSpells(true);
-    }
-
-    void EnterCombat(Unit* who)
-    {
-        if (Creature *Kelidan = me->FindNearestCreature(ENTRY_KELIDAN, 100))
-            CAST_AI(boss_kelidan_the_breakerAI, Kelidan->AI())->ChannelerEngaged(who);
-        if (me->IsNonMeleeSpellCasted(false))
-            me->InterruptNonMeleeSpells(true);
-        DoStartMovement(who);
-    }
-
-    void JustDied(Unit* Killer)
-    {
-       if (Creature *Kelidan = me->FindNearestCreature(ENTRY_KELIDAN, 100))
-           CAST_AI(boss_kelidan_the_breakerAI, Kelidan->AI())->ChannelerDied(Killer);
-    }
-
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
+    public:
+
+        mob_shadowmoon_channeler()
+            : CreatureScript("mob_shadowmoon_channeler")
         {
-            if (check_Timer <= diff)
-            {
-                if (!me->IsNonMeleeSpellCasted(false))
-                    if (Creature *Kelidan = me->FindNearestCreature(ENTRY_KELIDAN, 100))
-                    {
-                        uint64 channeler = CAST_AI(boss_kelidan_the_breakerAI, Kelidan->AI())->GetChanneled(me);
-                        if (Unit *channeled = Unit::GetUnit(*me, channeler))
-                            DoCast(channeled, SPELL_CHANNELING);
-                    }
-                check_Timer = 5000;
-            } else check_Timer -= diff;
-            return;
         }
 
-        if (MarkOfShadow_Timer <= diff)
+        struct mob_shadowmoon_channelerAI : public ScriptedAI
         {
-            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
-                DoCast(pTarget, SPELL_MARK_OF_SHADOW);
-            MarkOfShadow_Timer = 15000+rand()%5000;
-        } else MarkOfShadow_Timer -=diff;
+            mob_shadowmoon_channelerAI(Creature* pCreature) : ScriptedAI(pCreature)
+            {
+            }
 
-        if (ShadowBolt_Timer <= diff)
-        {
-            DoCast(me->getVictim(), SPELL_SHADOW_BOLT);
-            ShadowBolt_Timer = 5000+rand()%1000;
-        } else ShadowBolt_Timer -=diff;
+            uint32 ShadowBolt_Timer;
+            uint32 MarkOfShadow_Timer;
+            uint32 check_Timer;
 
-        DoMeleeAttackIfReady();
-    }
-};
+            void Reset()
+            {
+                ShadowBolt_Timer = 1000+rand()%1000;
+                MarkOfShadow_Timer = 5000+rand()%2000;
+                check_Timer = 0;
+                if (me->IsNonMeleeSpellCasted(false))
+                    me->InterruptNonMeleeSpells(true);
+            }
 
-CreatureAI* GetAI_mob_shadowmoon_channeler(Creature* pCreature)
-{
-    return new mob_shadowmoon_channelerAI (pCreature);
-}
+            void EnterCombat(Unit* who)
+            {
+                if (Creature *Kelidan = me->FindNearestCreature(ENTRY_KELIDAN, 100))
+                    CAST_AI(boss_kelidan_the_breaker::boss_kelidan_the_breakerAI, Kelidan->AI())->ChannelerEngaged(who);
+                if (me->IsNonMeleeSpellCasted(false))
+                    me->InterruptNonMeleeSpells(true);
+                DoStartMovement(who);
+            }
 
-void AddSC_boss_kelidan_the_breaker()
-{
-    Script *newscript;
+            void JustDied(Unit* Killer)
+            {
+               if (Creature *Kelidan = me->FindNearestCreature(ENTRY_KELIDAN, 100))
+                   CAST_AI(boss_kelidan_the_breaker::boss_kelidan_the_breakerAI, Kelidan->AI())->ChannelerDied(Killer);
+            }
 
-    newscript = new Script;
-    newscript->Name = "boss_kelidan_the_breaker";
-    newscript->GetAI = &GetAI_boss_kelidan_the_breaker;
-    newscript->RegisterSelf();
+            void UpdateAI(const uint32 diff)
+            {
+                if (!UpdateVictim())
+                {
+                    if (check_Timer <= diff)
+                    {
+                        if (!me->IsNonMeleeSpellCasted(false))
+                            if (Creature *Kelidan = me->FindNearestCreature(ENTRY_KELIDAN, 100))
+                            {
+                                uint64 channeler = CAST_AI(boss_kelidan_the_breaker::boss_kelidan_the_breakerAI, Kelidan->AI())->GetChanneled(me);
+                                if (Unit *channeled = Unit::GetUnit(*me, channeler))
+                                    DoCast(channeled, SPELL_CHANNELING);
+                            }
+                        check_Timer = 5000;
+                    } 
+                    else 
+                        check_Timer -= diff;
+                    return;
+                }
+
+                if (MarkOfShadow_Timer <= diff)
+                {
+                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
+                        DoCast(pTarget, SPELL_MARK_OF_SHADOW);
+                    MarkOfShadow_Timer = 15000+rand()%5000;
+                } 
+                else 
+                    MarkOfShadow_Timer -=diff;
+
+                if (ShadowBolt_Timer <= diff)
+                {
+                    DoCast(me->getVictim(), SPELL_SHADOW_BOLT);
+                    ShadowBolt_Timer = 5000+rand()%1000;
+                } 
+                else 
+                    ShadowBolt_Timer -=diff;
+
+                DoMeleeAttackIfReady();
+            }
+        };
 
-    newscript = new Script;
-    newscript->Name = "mob_shadowmoon_channeler";
-    newscript->GetAI = &GetAI_mob_shadowmoon_channeler;
-    newscript->RegisterSelf();
+        CreatureAI* GetAI(Creature* Creature) const
+        {
+            return new mob_shadowmoon_channelerAI (Creature);
+        }
+};
+
+void AddSC_boss_kelidan_the_breaker()
+{
+    new boss_kelidan_the_breaker();
+    new mob_shadowmoon_channeler();
 }
 
diff --git a/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_the_maker.cpp b/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_the_maker.cpp
index 1c3ad6bf3f1..74b1fb993ad 100644
--- a/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_the_maker.cpp
+++ b/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_the_maker.cpp
@@ -41,114 +41,126 @@ enum eEnums
     SPELL_DOMINATION            = 25772                     // ???
 };
 
-struct boss_the_makerAI : public ScriptedAI
+class boss_the_maker : public CreatureScript
 {
-    boss_the_makerAI(Creature *c) : ScriptedAI(c)
-    {
-        pInstance = c->GetInstanceData();
-    }
+    public:
 
-    ScriptedInstance* pInstance;
-
-    uint32 AcidSpray_Timer;
-    uint32 ExplodingBreaker_Timer;
-    uint32 Domination_Timer;
-    uint32 Knockdown_Timer;
-
-    void Reset()
-    {
-        AcidSpray_Timer = 15000;
-        ExplodingBreaker_Timer = 6000;
-        Domination_Timer = 120000;
-        Knockdown_Timer = 10000;
-
-        if (!pInstance)
-            return;
-
-        pInstance->SetData(TYPE_THE_MAKER_EVENT, NOT_STARTED);
-        pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR2), true);
-    }
-
-    void EnterCombat(Unit * /*who*/)
-    {
-        DoScriptText(RAND(SAY_AGGRO_1,SAY_AGGRO_2,SAY_AGGRO_3), me);
-
-        if (!pInstance)
-            return;
-
-        pInstance->SetData(TYPE_THE_MAKER_EVENT, IN_PROGRESS);
-        pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR2), false);
-    }
-
-    void KilledUnit(Unit* /*victim*/)
-    {
-        DoScriptText(RAND(SAY_KILL_1,SAY_KILL_2), me);
-    }
-
-    void JustDied(Unit* /*Killer*/)
-    {
-        DoScriptText(SAY_DIE, me);
-
-        if (!pInstance)
-            return;
-
-        pInstance->SetData(TYPE_THE_MAKER_EVENT, DONE);
-        pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR2), true);
-        pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR3), true);
-
-     }
-
-    void UpdateAI(const uint32 diff)
-    {
-        if (!UpdateVictim())
-            return;
-
-        if (AcidSpray_Timer <= diff)
+        boss_the_maker()
+            : CreatureScript("boss_the_maker")
         {
-            DoCast(me->getVictim(), SPELL_ACID_SPRAY);
-            AcidSpray_Timer = 15000+rand()%8000;
-        } else AcidSpray_Timer -=diff;
+        }
 
-        if (ExplodingBreaker_Timer <= diff)
+        struct boss_the_makerAI : public ScriptedAI
         {
-            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
-                DoCast(pTarget, SPELL_EXPLODING_BREAKER);
-            ExplodingBreaker_Timer = 4000+rand()%8000;
-        } else ExplodingBreaker_Timer -=diff;
-
-        /* // Disabled until Core Support for mind control
-        if (domination_timer_timer <= diff)
+            boss_the_makerAI(Creature* pCreature) : ScriptedAI(pCreature)
+            {
+                pInstance = pCreature->GetInstanceData();
+            }
+
+            ScriptedInstance* pInstance;
+
+            uint32 AcidSpray_Timer;
+            uint32 ExplodingBreaker_Timer;
+            uint32 Domination_Timer;
+            uint32 Knockdown_Timer;
+
+            void Reset()
+            {
+                AcidSpray_Timer = 15000;
+                ExplodingBreaker_Timer = 6000;
+                Domination_Timer = 120000;
+                Knockdown_Timer = 10000;
+
+                if (!pInstance)
+                    return;
+
+                pInstance->SetData(TYPE_THE_MAKER_EVENT, NOT_STARTED);
+                pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR2), true);
+            }
+
+            void EnterCombat(Unit * /*who*/)
+            {
+                DoScriptText(RAND(SAY_AGGRO_1,SAY_AGGRO_2,SAY_AGGRO_3), me);
+
+                if (!pInstance)
+                    return;
+
+                pInstance->SetData(TYPE_THE_MAKER_EVENT, IN_PROGRESS);
+                pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR2), false);
+            }
+
+            void KilledUnit(Unit* /*victim*/)
+            {
+                DoScriptText(RAND(SAY_KILL_1,SAY_KILL_2), me);
+            }
+
+            void JustDied(Unit* /*Killer*/)
+            {
+                DoScriptText(SAY_DIE, me);
+
+                if (!pInstance)
+                    return;
+
+                pInstance->SetData(TYPE_THE_MAKER_EVENT, DONE);
+                pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR2), true);
+                pInstance->HandleGameObject(pInstance->GetData64(DATA_DOOR3), true);
+
+             }
+
+            void UpdateAI(const uint32 diff)
+            {
+                if (!UpdateVictim())
+                    return;
+
+                if (AcidSpray_Timer <= diff)
+                {
+                    DoCast(me->getVictim(), SPELL_ACID_SPRAY);
+                    AcidSpray_Timer = 15000+rand()%8000;
+                }
+                else
+                    AcidSpray_Timer -=diff;
+
+                if (ExplodingBreaker_Timer <= diff)
+                {
+                    if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
+                        DoCast(pTarget, SPELL_EXPLODING_BREAKER);
+                    ExplodingBreaker_Timer = 4000+rand()%8000;
+                } 
+                else 
+                    ExplodingBreaker_Timer -=diff;
+
+                /* // Disabled until Core Support for mind control
+                if (domination_timer_timer <= diff)
+                {
+                Unit *pTarget;
+                pTarget = SelectUnit(SELECT_TARGET_RANDOM,0);
+
+                DoCast(pTarget, SPELL_DOMINATION);
+
+                domination_timer = 120000;
+                } else domination_timer -=diff;
+                */
+
+                if (Knockdown_Timer <= diff)
+                {
+                    DoCast(me->getVictim(), SPELL_KNOCKDOWN);
+                    Knockdown_Timer = 4000+rand()%8000;
+                } 
+                else 
+                    Knockdown_Timer -=diff;
+
+                DoMeleeAttackIfReady();
+            }
+        };
+
+        CreatureAI* GetAI(Creature* Creature) const
         {
-        Unit *pTarget;
-        pTarget = SelectUnit(SELECT_TARGET_RANDOM,0);
-
-        DoCast(pTarget, SPELL_DOMINATION);
-
-        domination_timer = 120000;
-        } else domination_timer -=diff;
-        */
-
-        if (Knockdown_Timer <= diff)
-        {
-            DoCast(me->getVictim(), SPELL_KNOCKDOWN);
-            Knockdown_Timer = 4000+rand()%8000;
-        } else Knockdown_Timer -=diff;
-
-        DoMeleeAttackIfReady();
-    }
+            return new boss_the_makerAI (Creature);
+        }
 };
 
-CreatureAI* GetAI_boss_the_makerAI(Creature* pCreature)
-{
-    return new boss_the_makerAI (pCreature);
-}
-
 void AddSC_boss_the_maker()
 {
-    Script *newscript;
-    newscript = new Script;
-    newscript->Name = "boss_the_maker";
-    newscript->GetAI = &GetAI_boss_the_makerAI;
-    newscript->RegisterSelf();
+    new boss_the_maker();
 }
 
diff --git a/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/instance_blood_furnace.cpp b/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/instance_blood_furnace.cpp
index 1b0f3f8aa25..97ed35abde7 100644
--- a/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/instance_blood_furnace.cpp
+++ b/src/server/scripts/Outland/HellfireCitadel/BloodFurnace/instance_blood_furnace.cpp
@@ -30,205 +30,210 @@ EndScriptData */
 #define ENTRY_SEWER2                 181766
 #define MAX_ENCOUNTER                   3
 
-struct instance_blood_furnace : public ScriptedInstance
+class instance_blood_furnace : public InstanceMapScript
 {
-    instance_blood_furnace(Map* pMap) : ScriptedInstance(pMap) {Initialize();};
-
-    uint64 The_MakerGUID;
-    uint64 BroggokGUID;
-    uint64 Kelidan_The_BreakerGUID;
-
-    uint64 Door1GUID;
-    uint64 Door2GUID;
-    uint64 Door3GUID;
-    uint64 Door4GUID;
-    uint64 Door5GUID;
-    uint64 Door6GUID;
-
-    uint64 PrisonCell1GUID;
-    uint64 PrisonCell2GUID;
-    uint64 PrisonCell3GUID;
-    uint64 PrisonCell4GUID;
-    uint64 PrisonCell5GUID;
-    uint64 PrisonCell6GUID;
-    uint64 PrisonCell7GUID;
-    uint64 PrisonCell8GUID;
-
-    uint32 m_auiEncounter[MAX_ENCOUNTER];
-    std::string str_data;
-
-    void Initialize()
-    {
-        memset(&m_auiEncounter, 0, sizeof(m_auiEncounter));
-
-        The_MakerGUID = 0;
-        BroggokGUID = 0;
-        Kelidan_The_BreakerGUID = 0;
-
-        Door1GUID = 0;
-        Door2GUID = 0;
-        Door3GUID = 0;
-        Door4GUID = 0;
-        Door5GUID = 0;
-        Door6GUID = 0;
-
-        PrisonCell1GUID = 0;
-        PrisonCell2GUID = 0;
-        PrisonCell3GUID = 0;
-        PrisonCell4GUID = 0;
-        PrisonCell5GUID = 0;
-        PrisonCell6GUID = 0;
-        PrisonCell7GUID = 0;
-        PrisonCell8GUID = 0;
-    }
-
-    void OnCreatureCreate(Creature* pCreature, bool add)
-    {
-        if (!add)
-            return;
-
-        switch(pCreature->GetEntry())
+    public:
+        instance_blood_furnace()
+            : InstanceMapScript("instance_blood_furnace")
         {
-             case 17381: The_MakerGUID = pCreature->GetGUID(); break;
-             case 17380: BroggokGUID = pCreature->GetGUID(); break;
-             case 17377: Kelidan_The_BreakerGUID = pCreature->GetGUID(); break;
         }
-    }
-
-    void OnGameObjectCreate(GameObject* pGo, bool add)
-    {
-        if (!add)
-            return;
-
-     if (pGo->GetEntry() == 181766)                //Final exit door
-         Door1GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181811)               //The Maker Front door
-         Door2GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181812)                //The Maker Rear door
-         Door3GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181822)               //Broggok Front door
-         Door4GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181819)               //Broggok Rear door
-         Door5GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181823)               //Kelidan exit door
-         Door6GUID = pGo->GetGUID();
-
-     if (pGo->GetEntry() == 181813)               //The Maker prison cell front right
-         PrisonCell1GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181814)               //The Maker prison cell back right
-         PrisonCell2GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181816)               //The Maker prison cell front left
-         PrisonCell3GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181815)               //The Maker prison cell back left
-         PrisonCell4GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181821)               //Broggok prison cell front right
-         PrisonCell5GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181818)               //Broggok prison cell back right
-         PrisonCell6GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181820)               //Broggok prison cell front left
-         PrisonCell7GUID = pGo->GetGUID();
-     if (pGo->GetEntry() == 181817)               //Broggok prison cell back left
-         PrisonCell8GUID = pGo->GetGUID();
-    }
-
-    uint64 GetData64(uint32 data)
-    {
-        switch(data)
-        {
-             case DATA_THE_MAKER:            return The_MakerGUID;
-             case DATA_BROGGOK:              return BroggokGUID;
-             case DATA_KELIDAN_THE_MAKER:    return Kelidan_The_BreakerGUID;
-             case DATA_DOOR1:                return Door1GUID;
-             case DATA_DOOR2:                return Door2GUID;
-             case DATA_DOOR3:                return Door3GUID;
-             case DATA_DOOR4:                return Door4GUID;
-             case DATA_DOOR5:                return Door5GUID;
-             case DATA_DOOR6:                return Door6GUID;
-             case DATA_PRISON_CELL1:         return PrisonCell1GUID;
-             case DATA_PRISON_CELL2:         return PrisonCell2GUID;
-             case DATA_PRISON_CELL3:         return PrisonCell3GUID;
-             case DATA_PRISON_CELL4:         return PrisonCell4GUID;
-             case DATA_PRISON_CELL5:         return PrisonCell5GUID;
-             case DATA_PRISON_CELL6:         return PrisonCell6GUID;
-             case DATA_PRISON_CELL7:         return PrisonCell7GUID;
-             case DATA_PRISON_CELL8:         return PrisonCell8GUID;
-        }
-
-        return 0;
-    }
 
-    void SetData(uint32 /*type*/, uint32 data)
-    {
-         switch(data)
-         {
-             case TYPE_THE_MAKER_EVENT:             m_auiEncounter[0] = data;     break;
-             case TYPE_BROGGOK_EVENT:               m_auiEncounter[1] = data;     break;
-             case TYPE_KELIDAN_THE_BREAKER_EVENT:   m_auiEncounter[2] = data;     break;
-         }
-
-        if (data == DONE)
+        struct instance_blood_furnace_InstanceMapScript : public ScriptedInstance
         {
-            OUT_SAVE_INST_DATA;
-
-            std::ostringstream saveStream;
-            saveStream << m_auiEncounter[0] << " " << m_auiEncounter[1] << " " << m_auiEncounter[2];
-
-            str_data = saveStream.str();
-
-            SaveToDB();
-            OUT_SAVE_INST_DATA_COMPLETE;
-        }
-    }
-
-    uint32 GetData(uint32 data)
-    {
-        switch(data)
+            instance_blood_furnace_InstanceMapScript(Map* pMap) : ScriptedInstance(pMap) {Initialize();};
+
+            uint64 The_MakerGUID;
+            uint64 BroggokGUID;
+            uint64 Kelidan_The_BreakerGUID;
+
+            uint64 Door1GUID;
+            uint64 Door2GUID;
+            uint64 Door3GUID;
+            uint64 Door4GUID;
+            uint64 Door5GUID;
+            uint64 Door6GUID;
+
+            uint64 PrisonCell1GUID;
+            uint64 PrisonCell2GUID;
+            uint64 PrisonCell3GUID;
+            uint64 PrisonCell4GUID;
+            uint64 PrisonCell5GUID;
+            uint64 PrisonCell6GUID;
+            uint64 PrisonCell7GUID;
+            uint64 PrisonCell8GUID;
+
+            uint32 m_auiEncounter[MAX_ENCOUNTER];
+            std::string str_data;
+
+            void Initialize()
+            {
+                memset(&m_auiEncounter, 0, sizeof(m_auiEncounter));
+
+                The_MakerGUID = 0;
+                BroggokGUID = 0;
+                Kelidan_The_BreakerGUID = 0;
+
+                Door1GUID = 0;
+                Door2GUID = 0;
+                Door3GUID = 0;
+                Door4GUID = 0;
+                Door5GUID = 0;
+                Door6GUID = 0;
+
+                PrisonCell1GUID = 0;
+                PrisonCell2GUID = 0;
+                PrisonCell3GUID = 0;
+                PrisonCell4GUID = 0;
+                PrisonCell5GUID = 0;
+                PrisonCell6GUID = 0;
+                PrisonCell7GUID = 0;
+                PrisonCell8GUID = 0;
+            }
+
+            void OnCreatureCreate(Creature* pCreature, bool add)
+            {
+                if (!add)
+                    return;
+
+                switch(pCreature->GetEntry())
+                {
+                     case 17381: The_MakerGUID = pCreature->GetGUID(); break;
+                     case 17380: BroggokGUID = pCreature->GetGUID(); break;
+                     case 17377: Kelidan_The_BreakerGUID = pCreature->GetGUID(); break;
+                }
+            }
+
+            void OnGameObjectCreate(GameObject* pGo, bool add)
+            {
+                if (!add)
+                    return;
+
+             if (pGo->GetEntry() == 181766)                //Final exit door
+                 Door1GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181811)               //The Maker Front door
+                 Door2GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181812)                //The Maker Rear door
+                 Door3GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181822)               //Broggok Front door
+                 Door4GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181819)               //Broggok Rear door
+                 Door5GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181823)               //Kelidan exit door
+                 Door6GUID = pGo->GetGUID();
+
+             if (pGo->GetEntry() == 181813)               //The Maker prison cell front right
+                 PrisonCell1GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181814)               //The Maker prison cell back right
+                 PrisonCell2GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181816)               //The Maker prison cell front left
+                 PrisonCell3GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181815)               //The Maker prison cell back left
+                 PrisonCell4GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181821)               //Broggok prison cell front right
+                 PrisonCell5GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181818)               //Broggok prison cell back right
+                 PrisonCell6GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181820)               //Broggok prison cell front left
+                 PrisonCell7GUID = pGo->GetGUID();
+             if (pGo->GetEntry() == 181817)               //Broggok prison cell back left
+                 PrisonCell8GUID = pGo->GetGUID();
+            }
+
+            uint64 GetData64(uint32 data)
+            {
+                switch(data)
+                {
+                     case DATA_THE_MAKER:            return The_MakerGUID;
+                     case DATA_BROGGOK:              return BroggokGUID;
+                     case DATA_KELIDAN_THE_MAKER:    return Kelidan_The_BreakerGUID;
+                     case DATA_DOOR1:                return Door1GUID;
+                     case DATA_DOOR2:                return Door2GUID;
+                     case DATA_DOOR3:                return Door3GUID;
+                     case DATA_DOOR4:                return Door4GUID;
+                     case DATA_DOOR5:                return Door5GUID;
+                     case DATA_DOOR6:                return Door6GUID;
+                     case DATA_PRISON_CELL1:         return PrisonCell1GUID;
+                     case DATA_PRISON_CELL2:         return PrisonCell2GUID;
+                     case DATA_PRISON_CELL3:         return PrisonCell3GUID;
+                     case DATA_PRISON_CELL4:         return PrisonCell4GUID;
+                     case DATA_PRISON_CELL5:         return PrisonCell5GUID;
+                     case DATA_PRISON_CELL6:         return PrisonCell6GUID;
+                     case DATA_PRISON_CELL7:         return PrisonCell7GUID;
+                     case DATA_PRISON_CELL8:         return PrisonCell8GUID;
+                }
+
+                return 0;
+            }
+
+            void SetData(uint32 /*type*/, uint32 data)
+            {
+                 switch(data)
+                 {
+                     case TYPE_THE_MAKER_EVENT:             m_auiEncounter[0] = data;     break;
+                     case TYPE_BROGGOK_EVENT:               m_auiEncounter[1] = data;     break;
+                     case TYPE_KELIDAN_THE_BREAKER_EVENT:   m_auiEncounter[2] = data;     break;
+                 }
+
+                if (data == DONE)
+                {
+                    OUT_SAVE_INST_DATA;
+
+                    std::ostringstream saveStream;
+                    saveStream << m_auiEncounter[0] << " " << m_auiEncounter[1] << " " << m_auiEncounter[2];
+
+                    str_data = saveStream.str();
+
+                    SaveToDB();
+                    OUT_SAVE_INST_DATA_COMPLETE;
+                }
+            }
+
+            uint32 GetData(uint32 data)
+            {
+                switch(data)
+                {
+                    case TYPE_THE_MAKER_EVENT:             return m_auiEncounter[0];
+                    case TYPE_BROGGOK_EVENT:               return m_auiEncounter[1];
+                    case TYPE_KELIDAN_THE_BREAKER_EVENT:   return m_auiEncounter[2];
+                }
+
+                return 0;
+            }
+
+            const char* Save()
+            {
+                return str_data.c_str();
+            }
+
+            void Load(const char* in)
+            {
+                if (!in)
+                {
+                    OUT_LOAD_INST_DATA_FAIL;
+                    return;
+                }
+
+                OUT_LOAD_INST_DATA(in);
+
+                std::istringstream loadStream(in);
+                loadStream >> m_auiEncounter[0] >> m_auiEncounter[1] >> m_auiEncounter[2];
+
+                for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
+                    if (m_auiEncounter[i] == IN_PROGRESS || m_auiEncounter[i] == FAIL)
+                        m_auiEncounter[i] = NOT_STARTED;
+
+                OUT_LOAD_INST_DATA_COMPLETE;
+            }
+        };
+
+        InstanceData* GetInstanceData(Map* pMap) const
         {
-            case TYPE_THE_MAKER_EVENT:             return m_auiEncounter[0];
-            case TYPE_BROGGOK_EVENT:               return m_auiEncounter[1];
-            case TYPE_KELIDAN_THE_BREAKER_EVENT:   return m_auiEncounter[2];
+            return new instance_blood_furnace_InstanceMapScript(pMap);
         }
-
-        return 0;
-    }
-
-    const char* Save()
-    {
-        return str_data.c_str();
-    }
-
-    void Load(const char* in)
-    {
-        if (!in)
-        {
-            OUT_LOAD_INST_DATA_FAIL;
-            return;
-        }
-
-        OUT_LOAD_INST_DATA(in);
-
-        std::istringstream loadStream(in);
-        loadStream >> m_auiEncounter[0] >> m_auiEncounter[1] >> m_auiEncounter[2];
-
-        for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-            if (m_auiEncounter[i] == IN_PROGRESS || m_auiEncounter[i] == FAIL)
-                m_auiEncounter[i] = NOT_STARTED;
-
-        OUT_LOAD_INST_DATA_COMPLETE;
-    }
 };
 
-InstanceData* GetInstanceData_instance_blood_furnace(Map* pMap)
-{
-    return new instance_blood_furnace(pMap);
-}
-
 void AddSC_instance_blood_furnace()
 {
-    Script *newscript;
-    newscript = new Script;
-    newscript->Name = "instance_blood_furnace";
-    newscript->GetInstanceData = &GetInstanceData_instance_blood_furnace;
-    newscript->RegisterSelf();
+    new instance_blood_furnace();
 }