Scripts/Forge of Souls: Revisited Bronjahm script, removed ugly hacks and fixed spells properly

--HG--
branch : trunk

10 files changed, 391 insertions, 301 deletions

diff --git a/sql/base/world_database.sql b/sql/base/world_database.sql
index 01119ed3c4e..a15c71f8cef 100644
--- a/sql/base/world_database.sql
+++ b/sql/base/world_database.sql
@@ -18156,6 +18156,8 @@ INSERT INTO `spell_linked_spell` (`spell_trigger`,`spell_effect`,`type`,`comment
 ( 67623,-67620, 1, 'Remove Paralytic Toxin when hit by Burning Bite'),
 (-66683, 68667, 0, 'Icehowl - Surge of Adrenaline'),
 (-67661, 68667, 0, 'Icehowl - Surge of Adrenaline'),
+-- Forge of Souls
+(-68839, 68846, 0, 'Bronjahm: Corrupt Soul Summon'),
 -- Icecrown Citadel
 (-69674, 69706, 0, 'Rotface: Mutated Infection Summon'),
 (-71224, 69706, 0, 'Rotface: Mutated Infection Summon'),
@@ -26784,6 +26786,13 @@ INSERT INTO `spell_script_names` (`spell_id`,`ScriptName`) VALUES
 ( 72752, 'spell_pvp_trinket_wotf_shared_cd'),
 ( 72757, 'spell_pvp_trinket_wotf_shared_cd'),
 -- instances
+-- Forge of Souls
+( 68793, 'spell_bronjahm_magic_bane'),
+( 69050, 'spell_bronjahm_magic_bane'),
+( 68861, 'spell_bronjahm_consume_soul'),
+( 69008, 'spell_bronjahm_soulstorm_channel'),
+( 68870, 'spell_bronjahm_soulstorm_visual'),
+-- Icecrown Citadel
 ( 69057, 'spell_marrowgar_bone_spike_graveyard'),
 ( 69140, 'spell_marrowgar_coldflame'),
 ( 72705, 'spell_marrowgar_coldflame'),
@@ -26861,6 +26870,7 @@ INSERT INTO `spell_script_names` (`spell_id`,`ScriptName`) VALUES
 ( 72457, 'spell_putricide_regurgitated_ooze'),
 ( 72875, 'spell_putricide_regurgitated_ooze'),
 ( 72876, 'spell_putricide_regurgitated_ooze'),
+-- Ulduar
 ( 62717, 'spell_ignis_slag_pot'),
 ( 63477, 'spell_ignis_slag_pot'),
 -- quest
diff --git a/sql/updates/10246_world_spell_linked_spell.sql b/sql/updates/10246_world_spell_linked_spell.sql
new file mode 100644
index 00000000000..46cfa0d936d
--- /dev/null
+++ b/sql/updates/10246_world_spell_linked_spell.sql
@@ -0,0 +1,3 @@
+DELETE FROM `spell_linked_spell` WHERE `spell_trigger`=-68839;
+INSERT INTO `spell_linked_spell` (`spell_trigger`,`spell_effect`,`type`,`comment`) VALUES
+(-68839,68846,0, 'Bronjahm: Corrupt Soul Summon');
diff --git a/sql/updates/10246_world_spell_script_names.sql b/sql/updates/10246_world_spell_script_names.sql
new file mode 100644
index 00000000000..1b049bb9ea6
--- /dev/null
+++ b/sql/updates/10246_world_spell_script_names.sql
@@ -0,0 +1,10 @@
+DELETE FROM `spell_script_names` WHERE `spell_id` IN (68793,69050) AND `ScriptName`='spell_bronjahm_magic_bane';
+DELETE FROM `spell_script_names` WHERE `spell_id`=68861 AND `ScriptName`='spell_bronjahm_consume_soul';
+DELETE FROM `spell_script_names` WHERE `spell_id`=69008 AND `ScriptName`='spell_bronjahm_soulstorm_channel';
+DELETE FROM `spell_script_names` WHERE `spell_id`=68870 AND `ScriptName`='spell_bronjahm_soulstorm_visual';
+INSERT INTO `spell_script_names` (`spell_id`, `ScriptName`) VALUES
+(68793,'spell_bronjahm_magic_bane'),
+(69050,'spell_bronjahm_magic_bane'),
+(68861,'spell_bronjahm_consume_soul'),
+(69008,'spell_bronjahm_soulstorm_channel'),
+(68870,'spell_bronjahm_soulstorm_visual');
diff --git a/src/server/game/Spells/Auras/SpellAuraEffects.cpp b/src/server/game/Spells/Auras/SpellAuraEffects.cpp
index 87baad480a7..a629ba995ff 100755
--- a/src/server/game/Spells/Auras/SpellAuraEffects.cpp
+++ b/src/server/game/Spells/Auras/SpellAuraEffects.cpp
@@ -5792,9 +5792,6 @@ void AuraEffect::HandleAuraDummy(AuraApplication const * aurApp, uint8 mode, boo
                             if (aurApp->GetRemoveMode() == AURA_REMOVE_BY_EXPIRE)
                                 target->CastSpell(target, 58601, true);
                             break;
-                        case 68839: // Corrupt Soul
-                            target->CastSpell(target, 68846, true, NULL, this, GetCasterGUID());
-                            break;
                     }
                     break;
                 case SPELLFAMILY_MAGE:
diff --git a/src/server/game/Spells/Auras/SpellAuras.cpp b/src/server/game/Spells/Auras/SpellAuras.cpp
index 92492f5b4c7..700ebcce95c 100755
--- a/src/server/game/Spells/Auras/SpellAuras.cpp
+++ b/src/server/game/Spells/Auras/SpellAuras.cpp
@@ -1098,7 +1098,7 @@ void Aura::HandleAuraSpecificMods(AuraApplication const * aurApp, Unit * caster,
                             if (*itr < 0)
                                 target->RemoveAurasDueToSpell(-(*itr));
                             else if (removeMode != AURA_REMOVE_BY_DEFAULT)
-                                target->CastSpell(target, *itr, true, 0, 0, GetCasterGUID());
+                                target->CastSpell(target, *itr, true, NULL, NULL, GetCasterGUID());
                         }
                 }
                 if (customAttr & SPELL_ATTR_CU_LINK_AURA)
diff --git a/src/server/game/Spells/Spell.cpp b/src/server/game/Spells/Spell.cpp
index 5ff52cf5e28..4b6dd2c90ad 100755
--- a/src/server/game/Spells/Spell.cpp
+++ b/src/server/game/Spells/Spell.cpp
@@ -2776,7 +2776,7 @@ void Spell::SelectEffectTargets(uint32 i, uint32 cur)
                     case 72444:
                     case 72445:
                     case 72446:
-                        for (std::list<Unit*>::iterator itr = unitList.begin() ; itr != unitList.end();)
+                        for (std::list<Unit*>::iterator itr = unitList.begin(); itr != unitList.end();)
                         {
                             if (!(*itr)->HasAura(72293))
                                 itr = unitList.erase(itr);
@@ -2795,6 +2795,17 @@ void Spell::SelectEffectTargets(uint32 i, uint32 cur)
                         if (unitList.empty())
                             return;
                         break;
+                    case 68921: case 69049:                 // Soulstorm
+                        for (std::list<Unit*>::iterator itr = unitList.begin(); itr != unitList.end();)
+                        {
+                            Position pos;
+                            (*itr)->GetPosition(&pos);
+                            if (m_caster->GetExactDist2d(&pos) <= 10.0f)
+                                itr = unitList.erase(itr);
+                            else
+                                ++itr;
+                        }
+                        break;
                 }
                 // Death Pact
                 if (m_spellInfo->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT && m_spellInfo->SpellFamilyFlags[0] & 0x00080000)
diff --git a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_bronjahm.cpp b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_bronjahm.cpp
index 375340efc38..3af09d54552 100644
--- a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_bronjahm.cpp
+++ b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/boss_bronjahm.cpp
@@ -16,253 +16,341 @@
  */
 
 #include "ScriptPCH.h"
+#include "SpellAuraEffects.h"
 #include "forge_of_souls.h"
 
-/*
- * TODO:
- * - Fix Soul Storm spell and remove work around.
- */
-
 enum Yells
 {
-    SAY_AGGRO                                     = -1632001,
-    SAY_SLAY_1                                    = -1632002,
-    SAY_SLAY_2                                    = -1632003,
-    SAY_DEATH                                     = -1632004,
-    SAY_SOUL_STORM                                = -1632005,
-    SAY_CORRUPT_SOUL                              = -1632006,
+    SAY_AGGRO           = -1632001,
+    SAY_SLAY_1          = -1632002,
+    SAY_SLAY_2          = -1632003,
+    SAY_DEATH           = -1632004,
+    SAY_SOUL_STORM      = -1632005,
+    SAY_CORRUPT_SOUL    = -1632006,
 };
 
 enum Spells
 {
-    SPELL_MAGIC_S_BANE                            = 68793,
-    SPELL_CORRUPT_SOUL                            = 68839,
-    SPELL_CONSUME_SOUL                            = 68858,
-    SPELL_TELEPORT                                = 68988,
-    SPELL_FEAR                                    = 68950,
-    SPELL_SOULSTORM                               = 68872,
-    SPELL_SOULSTORM_AURA                          = 68921,
-    SPELL_SHADOW_BOLT                             = 70043,
+    SPELL_MAGIC_S_BANE          = 68793,
+    SPELL_SHADOW_BOLT           = 70043,
+    SPELL_CORRUPT_SOUL          = 68839,
+    SPELL_CONSUME_SOUL          = 68861,
+    SPELL_TELEPORT              = 68988,
+    SPELL_FEAR                  = 68950,
+    SPELL_SOULSTORM             = 68872,
+    SPELL_SOULSTORM_CHANNEL     = 69008,    // pre-fight
+    SPELL_SOULSTORM_VISUAL      = 68870,    // pre-cast soulstorm
 };
 
 enum Events
 {
-    EVENT_NONE,
-    EVENT_SHADOW_BOLT,
-    EVENT_MAGIC_BANE,
-    EVENT_CORRUPT_SOUL,
-    EVENT_SOUL_STORM,
-    EVENT_SOUL_STORM_AURA,
-    EVENT_FEAR,
+    EVENT_MAGIC_BANE    = 1,
+    EVENT_SHADOW_BOLT   = 2,
+    EVENT_CORRUPT_SOUL  = 3,
+    EVENT_SOULSTORM     = 4,
+    EVENT_FEAR          = 5,
 };
 
 enum CombatPhases
 {
-    PHASE_1,
-    PHASE_2
+    PHASE_1 = 1,
+    PHASE_2 = 2
 };
 
 class boss_bronjahm : public CreatureScript
 {
-public:
-    boss_bronjahm() : CreatureScript("boss_bronjahm") { }
+    public:
+        boss_bronjahm() : CreatureScript("boss_bronjahm") { }
 
-    struct boss_bronjahmAI : public ScriptedAI
-    {
-        boss_bronjahmAI(Creature *c) : ScriptedAI(c)
+        struct boss_bronjahmAI : public BossAI
         {
-            pInstance = me->GetInstanceScript();
-        }
+            boss_bronjahmAI(Creature* pCreature) : BossAI(pCreature, DATA_BRONJAHM)
+            {
+                // disable AI outside of instance
+                if (!instance)
+                    me->IsAIEnabled = false;
+            }
 
-        InstanceScript* pInstance;
-        EventMap events;
+            void Reset()
+            {
+                events.Reset();
+                events.SetPhase(PHASE_1);
+                events.ScheduleEvent(EVENT_SHADOW_BOLT, 2000);
+                events.ScheduleEvent(EVENT_MAGIC_BANE, urand(8000, 15000));
+                events.ScheduleEvent(EVENT_CORRUPT_SOUL, urand(25000, 35000), 0, PHASE_1);
 
-        CombatPhases phase;
+                me->CastSpell(me, SPELL_SOULSTORM_CHANNEL, true);
 
-        void Reset()
-        {
-            phase = PHASE_1;
-            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
+                instance->SetBossState(DATA_BRONJAHM, NOT_STARTED);
+            }
 
-            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 EnterCombat(Unit* /*who*/)
+            {
+                DoScriptText(SAY_AGGRO, me);
+                me->RemoveAurasDueToSpell(SPELL_SOULSTORM_CHANNEL);
 
-            if (pInstance)
-                pInstance->SetData(DATA_BRONJAHM_EVENT, NOT_STARTED);
-        }
+                instance->SetBossState(DATA_BRONJAHM, IN_PROGRESS);
+            }
 
-        void EnterCombat(Unit* /*who*/)
-        {
-            DoScriptText(SAY_AGGRO, me);
+            void JustDied(Unit* /*killer*/)
+            {
+                DoScriptText(SAY_DEATH, me);
 
-            if (pInstance)
-                pInstance->SetData(DATA_BRONJAHM_EVENT, IN_PROGRESS);
-        }
+                instance->SetBossState(DATA_BRONJAHM, DONE);
+            }
 
-        void JustDied(Unit* /*killer*/)
-        {
-            DoScriptText(SAY_DEATH, me);
+            void KilledUnit(Unit * who)
+            {
+                if (who->GetTypeId() == TYPEID_PLAYER)
+                    DoScriptText(RAND(SAY_SLAY_1, SAY_SLAY_2), me);
+            }
 
-            if (pInstance)
-                pInstance->SetData(DATA_BRONJAHM_EVENT, DONE);
-        }
+            void DamageTaken(Unit* /*attacker*/, uint32& damage)
+            {
+                if (events.GetPhaseMask() & (1 << PHASE_1) && !HealthAbovePct(30))
+                {
+                    events.SetPhase(PHASE_2);
+                    DoCast(me, SPELL_TELEPORT);
+                    events.ScheduleEvent(EVENT_FEAR, urand(12000, 16000), 0, PHASE_2);
+                    events.ScheduleEvent(EVENT_SOULSTORM, 700, 0, PHASE_2);
+                }
+            }
 
-        void KilledUnit(Unit * /*who*/)
-        {
-            DoScriptText(RAND(SAY_SLAY_1,SAY_SLAY_2), me);
-        }
+            void JustSummoned(Creature* summon)
+            {
+                summons.Summon(summon);
+                summon->SetReactState(REACT_PASSIVE);
+                summon->GetMotionMaster()->Clear();
+                summon->GetMotionMaster()->MoveFollow(me, me->GetObjectSize(), 0.0f);
+            }
 
-        // Cast aura spell on all players farther than 10y
-        void ApplySoulStorm()
-        {
-            std::list<Unit*> targetList;
+            void UpdateAI(const uint32 diff)
+            {
+                if (!UpdateVictim())
+                    return;
 
-            SelectTargetList(targetList, 100, SELECT_TARGET_TOPAGGRO, -10.0f);
-            if (targetList.empty())
-                return;
+                events.Update(diff);
 
-            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);
+                if (me->hasUnitState(UNIT_STAT_CASTING))
+                    return;
+
+                while (uint32 eventId = events.ExecuteEvent())
+                {
+                    switch(eventId)
+                    {
+                        case EVENT_MAGIC_BANE:
+                            DoCastVictim(SPELL_MAGIC_S_BANE);
+                            events.ScheduleEvent(EVENT_MAGIC_BANE, urand(8000, 15000));
+                            break;
+                        case EVENT_SHADOW_BOLT:
+                            if (!me->IsWithinMeleeRange(me->getVictim()))
+                                DoCastVictim(SPELL_SHADOW_BOLT);
+                            events.ScheduleEvent(EVENT_SHADOW_BOLT, 2000);
+                            break;
+                        case EVENT_CORRUPT_SOUL:
+                            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true))
+                            {
+                                DoScriptText(SAY_CORRUPT_SOUL, me);
+                                DoCast(target, SPELL_CORRUPT_SOUL);
+                            }
+                            events.ScheduleEvent(EVENT_CORRUPT_SOUL, urand(25000, 35000), 0, PHASE_1);
+                            break;
+                        case EVENT_SOULSTORM:
+                            DoScriptText(SAY_SOUL_STORM, me);
+                            me->CastSpell(me, SPELL_SOULSTORM_VISUAL, true);
+                            me->CastSpell(me, SPELL_SOULSTORM, false);
+                            break;
+                        case EVENT_FEAR:
+                            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true))
+                                me->CastCustomSpell(SPELL_FEAR, SPELLVALUE_MAX_TARGETS, 1, target, false);
+                            events.ScheduleEvent(EVENT_FEAR, urand(8000, 12000), 0, PHASE_2);
+                            break;
+                        default:
+                            break;
+                    }
+                }
+
+                DoMeleeAttackIfReady();
             }
-        }
+        };
 
-        void UpdateAI(const uint32 diff)
+        CreatureAI *GetAI(Creature* pCreature) const
         {
-            //Return since we have no target
-            if (!UpdateVictim())
-                return;
+            return new boss_bronjahmAI(pCreature);
+        }
+};
 
-            events.Update(diff);
+class mob_corrupted_soul_fragment : public CreatureScript
+{
+public:
+    mob_corrupted_soul_fragment() : CreatureScript("mob_corrupted_soul_fragment") { }
 
-            if (me->hasUnitState(UNIT_STAT_CASTING))
-                return;
+    struct mob_corrupted_soul_fragmentAI : public ScriptedAI
+    {
+        mob_corrupted_soul_fragmentAI(Creature* pCreature) : ScriptedAI(pCreature)
+        {
+            instance = me->GetInstanceScript();
+        }
 
-            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.CancelEvent(EVENT_SHADOW_BOLT);
-                events.ScheduleEvent(EVENT_SOUL_STORM, 1000);
-                events.ScheduleEvent(EVENT_FEAR, urand(8000,12000));
+        void MovementInform(uint32 type, uint32 id)
+        {
+            if (type != TARGETED_MOTION_TYPE)
                 return;
-            }
 
-            while (uint32 eventId = events.ExecuteEvent())
+            uint64 BronjahmGUID = 0;
+            if (instance)
             {
-                switch(eventId)
+                if (TempSummon* summ = me->ToTempSummon())
                 {
-                    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:
-                        if (!me->IsWithinMeleeRange(me->getVictim()))
-                            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;
+                    BronjahmGUID = instance->GetData64(DATA_BRONJAHM);
+                    if (GUID_LOPART(BronjahmGUID) != id)
+                        return;
+
+                    if (Creature* bronjahm = ObjectAccessor::GetCreature(*me, BronjahmGUID))
+                        me->CastSpell(bronjahm, SPELL_CONSUME_SOUL, true);
+
+                    summ->GetMotionMaster()->MoveIdle();
+                    summ->UnSummon();
                 }
             }
-
-            DoMeleeAttackIfReady();
         }
+
+    private:
+        InstanceScript* instance;
     };
 
-    CreatureAI *GetAI(Creature *creature) const
+    CreatureAI *GetAI(Creature* pCreature) const
     {
-        return new boss_bronjahmAI(creature);
+        return new mob_corrupted_soul_fragmentAI(pCreature);
     }
 };
 
-class mob_corrupted_soul_fragment : public CreatureScript
+class spell_bronjahm_magic_bane : public SpellScriptLoader
 {
-public:
-    mob_corrupted_soul_fragment() : CreatureScript("mob_corrupted_soul_fragment") { }
+    public:
+        spell_bronjahm_magic_bane() :  SpellScriptLoader("spell_bronjahm_magic_bane") { }
 
-    struct mob_corrupted_soul_fragmentAI : public ScriptedAI
-    {
-        mob_corrupted_soul_fragmentAI(Creature *c) : ScriptedAI(c)
+        class spell_bronjahm_magic_bane_SpellScript : public SpellScript
+        {
+            PrepareSpellScript(spell_bronjahm_magic_bane_SpellScript);
+
+            void RecalculateDamage()
+            {
+                if (GetHitUnit()->getPowerType() != POWER_MANA)
+                    return;
+
+                const int32 maxDamage = GetCaster()->GetMap()->GetSpawnMode() == 1 ? 15000 : 10000;
+                int32 newDamage = GetHitDamage();
+                newDamage += GetHitUnit()->GetMaxPower(POWER_MANA)/2;
+                newDamage = std::min<int32>(maxDamage, newDamage);
+
+                SetHitDamage(newDamage);
+            }
+
+            void Register()
+            {
+                OnHit += SpellHitFn(spell_bronjahm_magic_bane_SpellScript::RecalculateDamage);
+            }
+        };
+
+        SpellScript* GetSpellScript() const
         {
-            pInstance = me->GetInstanceScript();
+            return new spell_bronjahm_magic_bane_SpellScript();
         }
+};
+
+class spell_bronjahm_consume_soul : public SpellScriptLoader
+{
+    public:
+        spell_bronjahm_consume_soul() :  SpellScriptLoader("spell_bronjahm_consume_soul") { }
 
-        InstanceScript* pInstance;
+        class spell_bronjahm_consume_soul_SpellScript : public SpellScript
+        {
+            PrepareSpellScript(spell_bronjahm_consume_soul_SpellScript);
 
-        uint32 uiCheckTimer;
+            void HandleScript(SpellEffIndex effIndex)
+            {
+                PreventHitDefaultEffect(effIndex);
+                GetHitUnit()->CastSpell(GetHitUnit(), GetEffectValue(), true);
+            }
 
-        void Reset()
+            void Register()
+            {
+                OnEffect += SpellEffectFn(spell_bronjahm_consume_soul_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
+            }
+        };
+
+        SpellScript* GetSpellScript() const
         {
-            uiCheckTimer = 0; // first check is immediate
+            return new spell_bronjahm_consume_soul_SpellScript();
         }
+};
 
-        void UpdateAI(const uint32 diff)
+class spell_bronjahm_soulstorm_channel : public SpellScriptLoader
+{
+    public:
+        spell_bronjahm_soulstorm_channel() : SpellScriptLoader("spell_bronjahm_soulstorm_channel") { }
+
+        class spell_bronjahm_soulstorm_channel_AuraScript : public AuraScript
         {
-            if (uiCheckTimer <= diff)
+            PrepareAuraScript(spell_bronjahm_soulstorm_channel_AuraScript);
+
+            void HandlePeriodicTick(AuraEffect const* /*aurEff*/, AuraApplication const* aurApp)
             {
-                if (pInstance)
-                {
-                    Creature* pBronjham = Unit::GetCreature(*me, pInstance->GetData64(DATA_BRONJAHM));
-                    if (pBronjham && pBronjham->isAlive())
-                    {
-                        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
-                        me->ForcedDespawn();
-                }
-                uiCheckTimer = 500;
+                PreventDefaultAction();
+                for (uint32 i = 68904; i <= 68907; ++i)
+                    aurApp->GetTarget()->CastSpell(aurApp->GetTarget(), i, true);
             }
-            else
-                uiCheckTimer -= diff;
+
+            void Register()
+            {
+                OnEffectPeriodic += AuraEffectPeriodicFn(spell_bronjahm_soulstorm_channel_AuraScript::HandlePeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
+            }
+        };
+
+        AuraScript* GetAuraScript() const
+        {
+            return new spell_bronjahm_soulstorm_channel_AuraScript();
         }
-    };
+};
 
-    CreatureAI *GetAI(Creature *creature) const
-    {
-        return new mob_corrupted_soul_fragmentAI(creature);
-    }
+class spell_bronjahm_soulstorm_visual : public SpellScriptLoader
+{
+    public:
+        spell_bronjahm_soulstorm_visual() : SpellScriptLoader("spell_bronjahm_soulstorm_visual") { }
+
+        class spell_bronjahm_soulstorm_visual_AuraScript : public AuraScript
+        {
+            PrepareAuraScript(spell_bronjahm_soulstorm_visual_AuraScript);
+
+            void HandlePeriodicTick(AuraEffect const* aurEff, AuraApplication const* aurApp)
+            {
+                PreventDefaultAction();
+                if (aurEff->GetTickNumber()%5)
+                    return;
+                aurApp->GetTarget()->CastSpell(aurApp->GetTarget(), 68886, true);
+                for (uint32 i = 68896; i <= 68898; ++i)
+                    aurApp->GetTarget()->CastSpell(aurApp->GetTarget(), i, true);
+            }
+
+            void Register()
+            {
+                OnEffectPeriodic += AuraEffectPeriodicFn(spell_bronjahm_soulstorm_visual_AuraScript::HandlePeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
+            }
+        };
+
+        AuraScript* GetAuraScript() const
+        {
+            return new spell_bronjahm_soulstorm_visual_AuraScript();
+        }
 };
 
 void AddSC_boss_bronjahm()
 {
-    new boss_bronjahm;
-    new mob_corrupted_soul_fragment;
+    new boss_bronjahm();
+    new mob_corrupted_soul_fragment();
+    new spell_bronjahm_magic_bane();
+    new spell_bronjahm_consume_soul();
+    new spell_bronjahm_soulstorm_channel();
+    new spell_bronjahm_soulstorm_visual();
 }
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 fc1ce735924..656efc35640 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
@@ -122,9 +122,9 @@ class boss_devourer_of_souls : public CreatureScript
 public:
     boss_devourer_of_souls() : CreatureScript("boss_devourer_of_souls") { }
 
-    struct boss_devourer_of_soulsAI : public ScriptedAI
+    struct boss_devourer_of_soulsAI : public BossAI
     {
-        boss_devourer_of_soulsAI(Creature *c) : ScriptedAI(c)
+        boss_devourer_of_soulsAI(Creature *c) : BossAI(c, DATA_DEVOURER_EVENT)
         {
             pInstance = c->GetInstanceScript();
         }
@@ -132,7 +132,6 @@ public:
         bool bThreeFaceAchievement;
 
         InstanceScript* pInstance;
-        EventMap events;
 
         // wailing soul event
         float beamAngle;
diff --git a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/forge_of_souls.h b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/forge_of_souls.h
index df2c682eaa1..c0b9fcaceba 100644
--- a/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/forge_of_souls.h
+++ b/src/server/scripts/Northrend/FrozenHalls/ForgeOfSouls/forge_of_souls.h
@@ -20,9 +20,8 @@
 
 enum Data
 {
-    DATA_BRONJAHM_EVENT,
-    DATA_DEVOURER_EVENT,
-    DATA_TEAM_IN_INSTANCE,
+    DATA_DEVOURER_EVENT     = 1,
+    DATA_TEAM_IN_INSTANCE   = 2,
 };
 
 enum Data64
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 4a082bd161c..19719396600 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
@@ -27,145 +27,118 @@
 
 class instance_forge_of_souls : public InstanceMapScript
 {
-public:
-    instance_forge_of_souls() : InstanceMapScript("instance_forge_of_souls", 632) { }
+    public:
+        instance_forge_of_souls() : InstanceMapScript("instance_forge_of_souls", 632) { }
 
-    struct instance_forge_of_souls_InstanceScript : public InstanceScript
-    {
-        instance_forge_of_souls_InstanceScript(Map* pMap) : InstanceScript(pMap) {};
-
-        uint64 uiBronjahm;
-        uint64 uiDevourer;
-
-        uint32 uiEncounter[MAX_ENCOUNTER];
-        uint32 uiTeamInInstance;
-
-        void Initialize()
-        {
-            uiBronjahm = 0;
-            uiDevourer = 0;
-
-            uiTeamInInstance = 0;
-
-            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-                uiEncounter[i] = NOT_STARTED;
-        }
-
-        bool IsEncounterInProgress() const
+        struct instance_forge_of_souls_InstanceScript : public InstanceScript
         {
-            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-                if (uiEncounter[i] == IN_PROGRESS) return true;
-
-            return false;
-        }
-
-        void OnCreatureCreate(Creature* pCreature, bool /*add*/)
-        {
-            Map::PlayerList const &players = instance->GetPlayers();
-
-            if (!players.isEmpty())
-                if (Player* pPlayer = players.begin()->getSource())
-                    uiTeamInInstance = pPlayer->GetTeamId();
-
-            switch(pCreature->GetEntry())
+            instance_forge_of_souls_InstanceScript(Map* pMap) : InstanceScript(pMap)
             {
-                case CREATURE_BRONJAHM:
-                    uiBronjahm = pCreature->GetGUID();
-                    break;
-                case CREATURE_DEVOURER:
-                    uiDevourer = pCreature->GetGUID();
-                    break;
-            }
-        }
+                SetBossNumber(MAX_ENCOUNTER);
+                uiBronjahm = 0;
+                uiDevourer = 0;
 
-        void SetData(uint32 type, uint32 data)
-        {
-            switch(type)
-            {
-                case DATA_BRONJAHM_EVENT:
-                    uiEncounter[0] = data;
-                    break;
-                case DATA_DEVOURER_EVENT:
-                    uiEncounter[1] = data;
-                    break;
+                uiTeamInInstance = 0;
             }
 
-            if (data == DONE)
-                SaveToDB();
-        }
-
-        uint32 GetData(uint32 type)
-        {
-            switch(type)
+            void OnCreatureCreate(Creature* pCreature, bool /*add*/)
             {
-                case DATA_BRONJAHM_EVENT:    return uiEncounter[0];
-                case DATA_DEVOURER_EVENT:    return uiEncounter[1];
-                case DATA_TEAM_IN_INSTANCE:  return uiTeamInInstance;
+                Map::PlayerList const &players = instance->GetPlayers();
+
+                if (!players.isEmpty())
+                    if (Player* pPlayer = players.begin()->getSource())
+                        uiTeamInInstance = pPlayer->GetTeamId();
+
+                switch(pCreature->GetEntry())
+                {
+                    case CREATURE_BRONJAHM:
+                        uiBronjahm = pCreature->GetGUID();
+                        break;
+                    case CREATURE_DEVOURER:
+                        uiDevourer = pCreature->GetGUID();
+                        break;
+                }
             }
 
-            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_TEAM_IN_INSTANCE:
+                        return uiTeamInInstance;
+                    default:
+                        break;
+                }
+
+                return 0;
             }
 
-            return 0;
-        }
-
-        std::string GetSaveData()
-        {
-            OUT_SAVE_INST_DATA;
-
-            std::ostringstream saveStream;
-            saveStream << "F S " << uiEncounter[0] << " " << uiEncounter[1];
-
-            OUT_SAVE_INST_DATA_COMPLETE;
-            return saveStream.str();
-        }
-
-        void Load(const char* in)
-        {
-            if (!in)
+            uint64 GetData64(uint32 identifier)
             {
-                OUT_LOAD_INST_DATA_FAIL;
-                return;
+                switch(identifier)
+                {
+                    case DATA_BRONJAHM:         return uiBronjahm;
+                    case DATA_DEVOURER:         return uiBronjahm;
+                }
+
+                return 0;
             }
 
-            OUT_LOAD_INST_DATA(in);
+            std::string GetSaveData()
+            {
+                OUT_SAVE_INST_DATA;
 
-            char dataHead1, dataHead2;
-            uint16 data0, data1;
+                std::ostringstream saveStream;
+                saveStream << "F S " << GetBossSaveData();
 
-            std::istringstream loadStream(in);
-            loadStream >> dataHead1 >> dataHead2 >> data0 >> data1;
+                OUT_SAVE_INST_DATA_COMPLETE;
+                return saveStream.str();
+            }
 
-            if (dataHead1 == 'F' && dataHead2 == 'S')
+            void Load(const char* in)
             {
-                uiEncounter[0] = data0;
-                uiEncounter[1] = data1;
+                if (!in)
+                {
+                    OUT_LOAD_INST_DATA_FAIL;
+                    return;
+                }
+
+                OUT_LOAD_INST_DATA(in);
+
+                char dataHead1, dataHead2;
+
+                std::istringstream loadStream(in);
+                loadStream >> dataHead1 >> dataHead2;
+
+                if (dataHead1 == 'F' && dataHead2 == 'S')
+                {
+                    for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
+                    {
+                        uint32 tmpState;
+                        loadStream >> tmpState;
+                        if (tmpState == IN_PROGRESS || tmpState > SPECIAL)
+                            tmpState = NOT_STARTED;
+                        SetBossState(i, EncounterState(tmpState));
+                    }
+                } else OUT_LOAD_INST_DATA_FAIL;
+
+                OUT_LOAD_INST_DATA_COMPLETE;
+            }
 
-                for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-                    if (uiEncounter[i] == IN_PROGRESS)
-                        uiEncounter[i] = NOT_STARTED;
+        private:
+            uint64 uiBronjahm;
+            uint64 uiDevourer;
 
-            } else OUT_LOAD_INST_DATA_FAIL;
+            uint32 uiTeamInInstance;
+        };
 
-            OUT_LOAD_INST_DATA_COMPLETE;
+        InstanceScript* GetInstanceScript(InstanceMap *map) const
+        {
+            return new instance_forge_of_souls_InstanceScript(map);
         }
-    };
-
-    InstanceScript* GetInstanceScript(InstanceMap *map) const
-    {
-        return new instance_forge_of_souls_InstanceScript(map);
-    }
 };
 
 void AddSC_instance_forge_of_souls()
 {
-    new instance_forge_of_souls;
+    new instance_forge_of_souls();
 }