Scripts/Spells: Fixed Mage's Improved Flamestrike, Ice

 Shards, Shatter, Shattered Barrier, Incanter's Absorption,
 Improved Mana Gem, Improved Freeze

3 files changed, 335 insertions, 94 deletions

diff --git a/src/server/game/Entities/Unit/Unit.cpp b/src/server/game/Entities/Unit/Unit.cpp
index a78ce6be4f0..80032533954 100644
--- a/src/server/game/Entities/Unit/Unit.cpp
+++ b/src/server/game/Entities/Unit/Unit.cpp
@@ -9750,13 +9750,11 @@ bool Unit::isSpellCrit(Unit* victim, SpellInfo const* spellProto, SpellSchoolMas
                     int32 modChance = 0;
                     switch ((*i)->GetMiscValue())
                     {
-                        // Shatter
-                        case  911: modChance+= 16;
-                        case  910: modChance+= 17;
-                        case  849: modChance+= 17;
+                         // Shatter
+                        case  911:
                             if (!victim->HasAuraState(AURA_STATE_FROZEN, spellProto, this))
                                 break;
-                            crit_chance+=modChance;
+                            AddPct(crit_chance, (*i)->GetAmount()*20);
                             break;
                         case 7917: // Glyph of Shadowburn
                             if (victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
diff --git a/src/server/game/Spells/Auras/SpellAuras.cpp b/src/server/game/Spells/Auras/SpellAuras.cpp
index 190c2fcdb8c..78e4844831a 100644
--- a/src/server/game/Spells/Auras/SpellAuras.cpp
+++ b/src/server/game/Spells/Auras/SpellAuras.cpp
@@ -1286,16 +1286,6 @@ void Aura::HandleAuraSpecificMods(AuraApplication const* aurApp, Unit* caster, b
                     default:
                         break;
                 }
-                if (!caster)
-                    break;
-                // Ice barrier - dispel/absorb remove
-                if (removeMode == AURA_REMOVE_BY_ENEMY_SPELL && GetSpellInfo()->SpellFamilyFlags[1] & 0x1)
-                {
-                    // Shattered Barrier
-                    if (AuraEffect * dummy = caster->GetDummyAuraEffect(SPELLFAMILY_MAGE, 3260, 0))
-                        if (roll_chance_i(dummy->GetSpellInfo()->ProcChance))
-                            caster->CastSpell(target, 55080, true, NULL, GetEffect(0));
-                }
                 break;
             case SPELLFAMILY_WARLOCK:
                 if (!caster)
diff --git a/src/server/scripts/Spells/spell_mage.cpp b/src/server/scripts/Spells/spell_mage.cpp
index 78217cfd7cd..354cbcbd4d6 100644
--- a/src/server/scripts/Spells/spell_mage.cpp
+++ b/src/server/scripts/Spells/spell_mage.cpp
@@ -40,6 +40,26 @@ enum MageSpells
     SPELL_MAGE_SUMMON_WATER_ELEMENTAL_TEMPORARY  = 70907,
     SPELL_MAGE_GLYPH_OF_BLAST_WAVE               = 62126,
     SPELL_MAGE_CONJURE_REFRESHMENT               = 42955,
+    SPELL_MAGE_FLAMESTRIKE                       = 2120,
+    SPELL_MAGE_CHILLED_R1                        = 12484,
+    SPELL_MAGE_CHILLED_R2                        = 12485,
+    SPELL_MAGE_INCANTER_S_ABSORPTION_TRIGGERED   = 44413,
+    SPELL_MAGE_INCANTER_S_ABSORPTION_KNOCKBACK   = 86261,
+    SPELL_MAGE_IMPROVED_MANA_GEM_TRIGGERED       = 83098,
+    SPELL_MAGE_SHATTERED_BARRIER_R1              = 44745,
+    SPELL_MAGE_SHATTERED_BARRIER_R2              = 54787,
+    SPELL_MAGE_SHATTERED_BARRIER_FREEZE_R1       = 55080,
+    SPELL_MAGE_SHATTERED_BARRIER_FREEZE_R2       = 83073,
+    SPELL_MAGE_FINGERS_OF_FROST                  = 44544,
+};
+
+enum MageIcons
+{
+    ICON_MAGE_SHATTER                       = 976,
+    ICON_MAGE_IMPROVED_FLAMESTRIKE          = 37,
+    ICON_MAGE_IMPROVED_FREEZE               = 94,
+    ICON_MAGE_INCANTER_S_ABSORPTION         = 2941,
+    ICON_MAGE_IMPROVED_MANA_GEM             = 1036,
 };
 
 class spell_mage_blast_wave : public SpellScriptLoader
@@ -53,21 +73,40 @@ class spell_mage_blast_wave : public SpellScriptLoader
 
             bool Validate(SpellInfo const* /*spellEntry*/)
             {
-                if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_GLYPH_OF_BLAST_WAVE))
+                if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_FLAMESTRIKE))
                     return false;
                 return true;
             }
 
-            void HandleKnockBack(SpellEffIndex effIndex)
+            void CountTargets(std::list<WorldObject*>& targetList)
+            {
+                _targetCount = targetList.size();
+            }
+
+            void HandleImprovedFlamestrike()
             {
-                if (GetCaster()->HasAura(SPELL_MAGE_GLYPH_OF_BLAST_WAVE))
-                    PreventHitDefaultEffect(effIndex);
+                if (_targetCount >= 2)
+                    if (AuraEffect* aurEff = GetCaster()->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_MAGE, ICON_MAGE_IMPROVED_FLAMESTRIKE, EFFECT_0))
+                        if (roll_chance_i(aurEff->GetAmount()))
+                        {
+                            float x, y, z;
+                            WorldLocation const* loc = GetExplTargetDest();
+                            if (!loc)
+                                return;
+
+                            loc->GetPosition(x, y, z);
+                            GetCaster()->CastSpell(x, y, z, SPELL_MAGE_FLAMESTRIKE, true);
+                        }
             }
 
             void Register()
             {
-                OnEffectHitTarget += SpellEffectFn(spell_mage_blast_wave_SpellScript::HandleKnockBack, EFFECT_2, SPELL_EFFECT_KNOCK_BACK);
+                OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_mage_blast_wave_SpellScript::CountTargets, EFFECT_0, TARGET_UNIT_DEST_AREA_ENEMY);
+                AfterCast += SpellCastFn(spell_mage_blast_wave_SpellScript::HandleImprovedFlamestrike);
             }
+
+        private:
+            uint32 _targetCount;
         };
 
         SpellScript* GetSpellScript() const
@@ -272,77 +311,6 @@ class spell_mage_frost_warding_trigger : public SpellScriptLoader
         }
 };
 
-class spell_mage_incanters_absorbtion_base_AuraScript : public AuraScript
-{
-    public:
-        enum Spells
-        {
-            SPELL_MAGE_INCANTERS_ABSORBTION_TRIGGERED = 44413,
-            SPELL_MAGE_INCANTERS_ABSORBTION_R1 = 44394,
-        };
-
-        bool Validate(SpellInfo const* /*spellEntry*/)
-        {
-            return sSpellMgr->GetSpellInfo(SPELL_MAGE_INCANTERS_ABSORBTION_TRIGGERED)
-                && sSpellMgr->GetSpellInfo(SPELL_MAGE_INCANTERS_ABSORBTION_R1);
-        }
-
-        void Trigger(AuraEffect* aurEff, DamageInfo & /*dmgInfo*/, uint32 & absorbAmount)
-        {
-            Unit* target = GetTarget();
-
-            if (AuraEffect* talentAurEff = target->GetAuraEffectOfRankedSpell(SPELL_MAGE_INCANTERS_ABSORBTION_R1, EFFECT_0))
-            {
-                int32 bp = CalculatePct(absorbAmount, talentAurEff->GetAmount());
-                target->CastCustomSpell(target, SPELL_MAGE_INCANTERS_ABSORBTION_TRIGGERED, &bp, NULL, NULL, true, NULL, aurEff);
-            }
-        }
-};
-
-// Incanter's Absorption
-class spell_mage_incanters_absorbtion_absorb : public SpellScriptLoader
-{
-public:
-    spell_mage_incanters_absorbtion_absorb() : SpellScriptLoader("spell_mage_incanters_absorbtion_absorb") { }
-
-    class spell_mage_incanters_absorbtion_absorb_AuraScript : public spell_mage_incanters_absorbtion_base_AuraScript
-    {
-        PrepareAuraScript(spell_mage_incanters_absorbtion_absorb_AuraScript);
-
-        void Register()
-        {
-             AfterEffectAbsorb += AuraEffectAbsorbFn(spell_mage_incanters_absorbtion_absorb_AuraScript::Trigger, EFFECT_0);
-        }
-    };
-
-    AuraScript* GetAuraScript() const
-    {
-        return new spell_mage_incanters_absorbtion_absorb_AuraScript();
-    }
-};
-
-// Incanter's Absorption
-class spell_mage_incanters_absorbtion_manashield : public SpellScriptLoader
-{
-public:
-    spell_mage_incanters_absorbtion_manashield() : SpellScriptLoader("spell_mage_incanters_absorbtion_manashield") { }
-
-    class spell_mage_incanters_absorbtion_manashield_AuraScript : public spell_mage_incanters_absorbtion_base_AuraScript
-    {
-        PrepareAuraScript(spell_mage_incanters_absorbtion_manashield_AuraScript);
-
-        void Register()
-        {
-             AfterEffectManaShield += AuraEffectManaShieldFn(spell_mage_incanters_absorbtion_manashield_AuraScript::Trigger, EFFECT_0);
-        }
-    };
-
-    AuraScript* GetAuraScript() const
-    {
-        return new spell_mage_incanters_absorbtion_manashield_AuraScript();
-    }
-};
-
 class spell_mage_living_bomb : public SpellScriptLoader
 {
     public:
@@ -424,6 +392,8 @@ public:
     }
 };
 
+// 42955 Conjure Refreshment
+/// Updated 4.3.4
 struct ConjureRefreshmentData
 {
     uint32 minLevel;
@@ -480,7 +450,6 @@ class spell_mage_conjure_refreshment : public SpellScriptLoader
                 }
             }
 
-
             void Register()
             {
                 OnEffectHitTarget += SpellEffectFn(spell_mage_conjure_refreshment_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
@@ -493,6 +462,285 @@ class spell_mage_conjure_refreshment : public SpellScriptLoader
         }
 };
 
+// 42208 Blizzard
+/// Updated 4.3.4
+class spell_mage_blizzard : public SpellScriptLoader
+{
+   public:
+       spell_mage_blizzard() : SpellScriptLoader("spell_mage_blizzard") { } 
+
+       bool Validate(SpellInfo const* /*spellEntry*/)
+       {
+           if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_CHILLED_R1))
+               return false;
+           if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_CHILLED_R2))
+               return false;
+           return true;
+       }
+
+       class spell_mage_blizzard_SpellScript : public SpellScript
+       {
+           PrepareSpellScript(spell_mage_blizzard_SpellScript);
+
+           void AddChillEffect()
+           {
+               Unit* caster = GetCaster();
+               if (Unit* unitTarget = GetHitUnit())
+               {
+                   if (caster->IsScriptOverriden(GetSpellInfo(), 836))
+                       caster->CastSpell(unitTarget, SPELL_MAGE_CHILLED_R1, true);
+                   else if (caster->IsScriptOverriden(GetSpellInfo(), 988))
+                       caster->CastSpell(unitTarget, SPELL_MAGE_CHILLED_R2, true);
+               }
+           }
+
+           void Register()
+           {
+               OnEffectHitTarget += SpellEffectFn(spell_mage_blizzard_SpellScript::AddChillEffect, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
+           }
+       };
+
+       SpellScript *GetSpellScript() const
+       {
+           return new spell_mage_blizzard_SpellScript();
+       }
+};
+
+// 116 Frostbolt
+/// Updated 4.3.4
+class spell_mage_frostbolt : public SpellScriptLoader
+{
+   public:
+       spell_mage_frostbolt() : SpellScriptLoader("spell_mage_frostbolt") { } 
+
+       class spell_mage_frostbolt_SpellScript : public SpellScript
+       {
+           PrepareSpellScript(spell_mage_frostbolt_SpellScript);
+
+           void RecalculateDamage()
+           {
+               if (GetHitUnit() && GetHitUnit()->HasAuraState(AURA_STATE_FROZEN, GetSpellInfo(), GetCaster()))
+               {
+                   if (AuraEffect* aurEff = GetCaster()->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_MAGE, ICON_MAGE_SHATTER, EFFECT_1))
+                   {
+                       int32 damage = GetHitDamage();
+                       AddPct(damage, aurEff->GetAmount());
+                       SetHitDamage(damage);
+                   }
+               }
+           }
+
+           void Register()
+           {
+               OnEffectHitTarget += SpellEffectFn(spell_mage_frostbolt_SpellScript::RecalculateDamage, EFFECT_1, SPELL_EFFECT_SCHOOL_DAMAGE);
+           }
+       };
+
+       SpellScript *GetSpellScript() const
+       {
+           return new spell_mage_frostbolt_SpellScript();
+       }
+};
+
+// 11426 Ice Barrier
+/// Updated 4.3.4
+class spell_mage_ice_barrier : public SpellScriptLoader
+{
+   public:
+       spell_mage_ice_barrier() : SpellScriptLoader("spell_mage_ice_barrier") { }
+
+       class spell_mage_ice_barrier_AuraScript : public AuraScript
+       {
+           PrepareAuraScript(spell_mage_ice_barrier_AuraScript);
+
+           void AfterRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
+           {
+               if (GetTargetApplication()->GetRemoveMode() != AURA_REMOVE_BY_ENEMY_SPELL)
+                   return;
+
+               if (GetTarget()->HasAura(SPELL_MAGE_SHATTERED_BARRIER_R1))
+                   GetTarget()->CastSpell(GetTarget(), SPELL_MAGE_SHATTERED_BARRIER_FREEZE_R1, true);
+               else if (GetTarget()->HasAura(SPELL_MAGE_SHATTERED_BARRIER_R2))
+                   GetTarget()->CastSpell(GetTarget(), SPELL_MAGE_SHATTERED_BARRIER_FREEZE_R2, true);
+           }
+
+           void Register()
+           {
+                AfterEffectRemove += AuraEffectRemoveFn(spell_mage_ice_barrier_AuraScript::AfterRemove, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB, AURA_EFFECT_HANDLE_REAL);
+           }
+       };
+
+       AuraScript* GetAuraScript() const
+       {
+           return new spell_mage_ice_barrier_AuraScript();
+       }
+};
+
+// 1463 Mana Shield
+/// Updated 4.3.4
+class spell_mage_mana_shield : public SpellScriptLoader
+{
+   public:
+       spell_mage_mana_shield() : SpellScriptLoader("spell_mage_mana_shield") { }
+
+       class spell_mage_mana_shield_AuraScript : public AuraScript
+       {
+           PrepareAuraScript(spell_mage_mana_shield_AuraScript);
+
+           void HandleAbsorb(AuraEffect* aurEff, DamageInfo & /*dmgInfo*/, uint32 & absorbAmount)
+           {
+               if (AuraEffect* aurEff = GetTarget()->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_GENERIC, ICON_MAGE_INCANTER_S_ABSORPTION, EFFECT_0))
+               {
+                   int32 bp = CalculatePct(absorbAmount, aurEff->GetAmount());
+                   GetTarget()->CastCustomSpell(GetTarget(), SPELL_MAGE_INCANTER_S_ABSORPTION_TRIGGERED, &bp, NULL, NULL, true);
+               }
+           }
+
+           void AfterRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
+           {
+               if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_ENEMY_SPELL)
+                   GetTarget()->CastSpell(GetTarget(), SPELL_MAGE_INCANTER_S_ABSORPTION_KNOCKBACK, true);
+           }
+
+           void Register()
+           {
+                AfterEffectManaShield += AuraEffectManaShieldFn(spell_mage_mana_shield_AuraScript::HandleAbsorb, EFFECT_0);
+                AfterEffectRemove += AuraEffectRemoveFn(spell_mage_mana_shield_AuraScript::AfterRemove, EFFECT_0, SPELL_AURA_MANA_SHIELD, AURA_EFFECT_HANDLE_REAL);
+           }
+       };
+
+       AuraScript* GetAuraScript() const
+       {
+           return new spell_mage_mana_shield_AuraScript();
+       }
+};
+
+// 543 Mage Ward
+/// Updated 4.3.4
+class spell_mage_mage_ward : public SpellScriptLoader
+{
+   public:
+       spell_mage_mage_ward() : SpellScriptLoader("spell_mage_mage_ward") { }
+
+       class spell_mage_mage_ward_AuraScript : public AuraScript
+       {
+           PrepareAuraScript(spell_mage_mage_ward_AuraScript);
+
+           void HandleAbsorb(AuraEffect* aurEff, DamageInfo & /*dmgInfo*/, uint32 & absorbAmount)
+           {
+               if (AuraEffect* aurEff = GetTarget()->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_GENERIC, ICON_MAGE_INCANTER_S_ABSORPTION, EFFECT_0))
+               {
+                   int32 bp = CalculatePct(absorbAmount, aurEff->GetAmount());
+                   GetTarget()->CastCustomSpell(GetTarget(), SPELL_MAGE_INCANTER_S_ABSORPTION_TRIGGERED, &bp, NULL, NULL, true);
+               }
+           }
+
+           void Register()
+           {
+               AfterEffectAbsorb += AuraEffectAbsorbFn(spell_mage_mage_ward_AuraScript::HandleAbsorb, EFFECT_0);
+           }
+       };
+
+       AuraScript* GetAuraScript() const
+       {
+           return new spell_mage_mage_ward_AuraScript();
+       }
+};
+
+// 5405 Replenish Mana (Mana Gem)
+/// Updated 4.3.4
+class spell_mage_replenish_mana : public SpellScriptLoader
+{
+   public:
+       spell_mage_replenish_mana() : SpellScriptLoader("spell_mage_replenish_mana") { }
+
+       class spell_mage_replenish_mana_SpellScript : public SpellScript
+       {
+           PrepareSpellScript(spell_mage_replenish_mana_SpellScript);
+
+           bool Validate(SpellInfo const* /*spellEntry*/)
+           {
+               if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_IMPROVED_MANA_GEM_TRIGGERED))
+                   return false;
+               return true;
+           }
+
+           void HandleImprovedManaGem()
+           {
+               if (AuraEffect* aurEff = GetCaster()->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_MAGE, ICON_MAGE_IMPROVED_MANA_GEM, EFFECT_0))
+               {
+                   int32 bp = CalculatePct(GetCaster()->GetMaxPower(POWER_MANA), aurEff->GetAmount());
+                   GetCaster()->CastCustomSpell(GetCaster(), SPELL_MAGE_IMPROVED_MANA_GEM_TRIGGERED, &bp, &bp, NULL, true);
+               }
+           }
+
+           void Register()
+           {
+               AfterCast += SpellCastFn(spell_mage_replenish_mana_SpellScript::HandleImprovedManaGem);
+           }
+       };
+
+       SpellScript* GetSpellScript() const
+       {
+           return new spell_mage_replenish_mana_SpellScript();
+       }
+};
+
+// 33395 Water Elemental's Freeze
+/// Updated 4.3.4
+class spell_mage_water_elemental_freeze : public SpellScriptLoader
+{
+   public:
+       spell_mage_water_elemental_freeze() : SpellScriptLoader("spell_mage_water_elemental_freeze") { }
+
+       class spell_mage_water_elemental_freeze_SpellScript : public SpellScript
+       {
+           PrepareSpellScript(spell_mage_water_elemental_freeze_SpellScript);
+
+           bool Validate(SpellInfo const* /*spellEntry*/)
+           {
+               if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_FINGERS_OF_FROST))
+                   return false;
+               return true;
+           }
+
+           void CountTargets(std::list<WorldObject*>& targetList)
+           {
+               _didHit = !targetList.empty();
+           }
+
+           void HandleImprovedFreeze()
+           {
+               if (!_didHit)
+                   return;
+
+               Unit* owner = GetCaster()->GetOwner();
+               if (!owner)
+                   return;
+
+               if (AuraEffect* aurEff = owner->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_MAGE, ICON_MAGE_IMPROVED_FREEZE, EFFECT_0))
+               {
+                   if (roll_chance_i(aurEff->GetAmount()))
+                       owner->CastCustomSpell(SPELL_MAGE_FINGERS_OF_FROST, SPELLVALUE_AURA_STACK, 2, owner, true);
+               }
+           }
+
+           void Register()
+           {
+               OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_mage_water_elemental_freeze_SpellScript::CountTargets, EFFECT_0, TARGET_UNIT_DEST_AREA_ENEMY);
+               AfterCast += SpellCastFn(spell_mage_water_elemental_freeze_SpellScript::HandleImprovedFreeze);
+           }
+
+       private:
+           bool _didHit;
+       };
+
+       SpellScript* GetSpellScript() const
+       {
+           return new spell_mage_water_elemental_freeze_SpellScript();
+       }
+};
+
 void AddSC_mage_spell_scripts()
 {
     new spell_mage_blast_wave();
@@ -500,9 +748,14 @@ void AddSC_mage_spell_scripts()
     new spell_mage_cone_of_cold();
     new spell_mage_conjure_refreshment();
     new spell_mage_frost_warding_trigger();
-    new spell_mage_incanters_absorbtion_absorb();
-    new spell_mage_incanters_absorbtion_manashield();
     new spell_mage_polymorph_cast_visual();
     new spell_mage_summon_water_elemental();
     new spell_mage_living_bomb();
+    new spell_mage_blizzard();
+    new spell_mage_frostbolt();
+    new spell_mage_ice_barrier();
+    new spell_mage_mana_shield();
+    new spell_mage_mage_ward();
+    new spell_mage_replenish_mana();
+    new spell_mage_water_elemental_freeze();
 }