fix: Qaston revert (#13320)

* Revert "fix(Core/QAston): fixed shields oneshotting (#13271)" This reverts commit e05f61d1b3. * Revert "fix(Core): Crash (#13292)" This reverts commit a818bcf3e2. * Revert "fix: Crash (#13241)" This reverts commit be423a91b5. * delete sql * Revert "refactor(Core/Spells): Implement QAston Proc System (#11079)" This reverts commit cbd3fd0967. * add sql revert * fix sql * remove update from world.updates
2026-01-17 02:50:29 +00:00 · 2022-10-05 16:53:20 -03:00
parent e189caeb76
commit ad4ce0895f
55 changed files with 8995 additions and 9257 deletions
--- a/src/server/game/Spells/Spell.cpp
+++ b/src/server/game/Spells/Spell.cpp
@@ -640,7 +640,7 @@ Spell::Spell(Unit* caster, SpellInfo const* info, TriggerCastFlags triggerFlags,
    m_healing = 0;
    m_procAttacker = 0;
    m_procVictim = 0;
-    m_hitMask = 0;
+    m_procEx = 0;
    focusObject = nullptr;
    m_cast_count = 0;
    m_glyphIndex = 0;
@@ -1811,7 +1811,7 @@ void Spell::SelectImplicitChainTargets(SpellEffIndex effIndex, SpellImplicitTarg
 {
    uint32 maxTargets = m_spellInfo->Effects[effIndex].ChainTarget;
    if (Player* modOwner = m_caster->GetSpellModOwner())
-        modOwner->ApplySpellMod<SPELLMOD_JUMP_TARGETS>(m_spellInfo->Id, maxTargets, this);
+        modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_JUMP_TARGETS, maxTargets, this);

    if (maxTargets > 1)
    {
@@ -2273,11 +2273,12 @@ void Spell::SearchChainTargets(std::list<WorldObject*>& targets, uint32 chainTar
    }
 }

-void Spell::prepareDataForTriggerSystem()
+void Spell::prepareDataForTriggerSystem(AuraEffect const* /*triggeredByAura*/)
 {
    //==========================================================================================
    // Now fill data for trigger system, need know:
-    // Create base triggers flags for Attacker and Victim (m_procAttacker, m_procVictim and m_hitMask)
+    // can spell trigger another or not (m_canTrigger)
+    // Create base triggers flags for Attacker and Victim (m_procAttacker, m_procVictim and m_procEx)
    //==========================================================================================

    m_procVictim = m_procAttacker = 0;
@@ -2316,6 +2317,7 @@ void Spell::prepareDataForTriggerSystem()
            // For other spells trigger procflags are set in Spell::DoAllEffectOnTarget
            // Because spell positivity is dependant on target
    }
+    m_procEx = PROC_EX_NONE;

    // Hunter trap spells - activation proc for Lock and Load, Entrapment and Misdirection
    if (m_spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER &&
@@ -2324,18 +2326,31 @@ void Spell::prepareDataForTriggerSystem()
             m_spellInfo->SpellFamilyFlags[2] & 0x00064000))          // Explosive and Immolation Trap
    {
        m_procAttacker |= PROC_FLAG_DONE_TRAP_ACTIVATION;
-
-        // also fill up other flags (DoAllEffectOnTarget only fills up flag if both are not set)
-        m_procAttacker |= PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG;
-        m_procVictim |= PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG;
    }

+    /* Effects which are result of aura proc from triggered spell cannot proc
+        to prevent chain proc of these spells */
+
    // Hellfire Effect - trigger as DOT
    if (m_spellInfo->SpellFamilyName == SPELLFAMILY_WARLOCK && m_spellInfo->SpellFamilyFlags[0] & 0x00000040)
    {
        m_procAttacker = PROC_FLAG_DONE_PERIODIC;
        m_procVictim   = PROC_FLAG_TAKEN_PERIODIC;
    }
+
+    // Ranged autorepeat attack is set as triggered spell - ignore it
+    if (!(m_procAttacker & PROC_FLAG_DONE_RANGED_AUTO_ATTACK))
+    {
+        if (_triggeredCastFlags & TRIGGERED_DISALLOW_PROC_EVENTS &&
+                (m_spellInfo->HasAttribute(SPELL_ATTR2_ACTIVE_THREAT) ||
+                 m_spellInfo->HasAttribute(SPELL_ATTR3_NOT_A_PROC)))
+            m_procEx |= PROC_EX_INTERNAL_CANT_PROC;
+        else if (_triggeredCastFlags & TRIGGERED_DISALLOW_PROC_EVENTS)
+            m_procEx |= PROC_EX_INTERNAL_TRIGGERED;
+    }
+    // Totem casts require spellfamilymask defined in spell_proc_event to proc
+    if (m_originalCaster && m_caster != m_originalCaster && m_caster->GetTypeId() == TYPEID_UNIT && m_caster->ToCreature()->IsTotem() && m_caster->IsControlledByPlayer())
+        m_procEx |= PROC_EX_INTERNAL_REQ_FAMILY;
 }

 void Spell::CleanupTargetList()
@@ -2347,32 +2362,6 @@ void Spell::CleanupTargetList()
    m_delayTrajectory = 0;
 }

-class ProcReflectDelayed : public BasicEvent
-{
-public:
-    ProcReflectDelayed(Unit* owner, ObjectGuid casterGuid) : _victim(owner), _casterGuid(casterGuid) { }
-
-    bool Execute(uint64 /*e_time*/, uint32 /*p_time*/) override
-    {
-        Unit* caster = ObjectAccessor::GetUnit(*_victim, _casterGuid);
-        if (!caster)
-            return true;
-
-        uint32 const typeMaskActor = PROC_FLAG_NONE;
-        uint32 const typeMaskActionTarget = PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG | PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG;
-        uint32 const spellTypeMask = PROC_SPELL_TYPE_DAMAGE | PROC_SPELL_TYPE_NO_DMG_HEAL;
-        uint32 const spellPhaseMask = PROC_SPELL_PHASE_NONE;
-        uint32 const hitMask = PROC_HIT_REFLECT;
-
-        caster->ProcSkillsAndAuras(_victim, typeMaskActor, typeMaskActionTarget, spellTypeMask, spellPhaseMask, hitMask, nullptr, nullptr, nullptr);
-        return true;
-    }
-
-private:
-    Unit* _victim;
-    ObjectGuid _casterGuid;
-};
-
 void Spell::AddUnitTarget(Unit* target, uint32 effectMask, bool checkIfValid /*= true*/, bool implicit /*= true*/)
 {
    for (uint32 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
@@ -2384,8 +2373,11 @@ void Spell::AddUnitTarget(Unit* target, uint32 effectMask, bool checkIfValid /*=
        return;

    if (checkIfValid)
-        if (m_spellInfo->CheckTarget(m_caster, target, implicit) != SPELL_CAST_OK) // skip stealth checks for AOE
+    {
+        SpellCastResult res = m_spellInfo->CheckTarget(m_caster, target, implicit);
+        if (res != SPELL_CAST_OK)
            return;
+    }

    // Check for effect immune skip if immuned
    for (uint32 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
@@ -2456,22 +2448,23 @@ void Spell::AddUnitTarget(Unit* target, uint32 effectMask, bool checkIfValid /*=
        targetInfo.timeDelay = (uint64) floor(dist / m_spellInfo->Speed * 1000.0f);

        // Calculate minimum incoming time
-        if (!m_delayMoment || m_delayMoment > targetInfo.timeDelay)
+        if (m_delayMoment == 0 || m_delayMoment > targetInfo.timeDelay)
            m_delayMoment = targetInfo.timeDelay;
    }
    else
-        targetInfo.timeDelay = 0ULL;
+        targetInfo.timeDelay = 0LL;

    // If target reflect spell back to caster
    if (targetInfo.missCondition == SPELL_MISS_REFLECT)
    {
        // Calculate reflected spell result on caster
-        targetInfo.reflectResult = m_caster->SpellHitResult(m_caster, m_spellInfo, false); // can't reflect twice
+        targetInfo.reflectResult = m_caster->SpellHitResult(m_caster, m_spellInfo, m_canReflect);

-        // Proc spell reflect aura when missile hits the original target
-        target->m_Events.AddEvent(new ProcReflectDelayed(target, m_originalCasterGUID), target->m_Events.CalculateTime(targetInfo.timeDelay));
+        if (targetInfo.reflectResult == SPELL_MISS_REFLECT)     // Impossible reflect again, so simply deflect spell
+            targetInfo.reflectResult = SPELL_MISS_PARRY;

        // Increase time interval for reflected spells by 1.5
+        m_caster->m_Events.AddEvent(new ReflectEvent(m_caster, targetInfo.targetGUID, m_spellInfo), m_caster->m_Events.CalculateTime(targetInfo.timeDelay));
        targetInfo.timeDelay += targetInfo.timeDelay >> 1;

        m_spellFlags |= SPELL_FLAG_REFLECTED;
@@ -2552,7 +2545,7 @@ void Spell::AddGOTarget(GameObject* go, uint32 effectMask)
        if (dist < 5.0f)
            dist = 5.0f;
        target.timeDelay = uint64(floor(dist / m_spellInfo->Speed * 1000.0f));
-        if (!m_delayMoment || m_delayMoment > target.timeDelay)
+        if (m_delayMoment == 0 || m_delayMoment > target.timeDelay)
            m_delayMoment = target.timeDelay;
    }
    else
@@ -2667,8 +2660,8 @@ void Spell::DoAllEffectOnTarget(TargetInfo* target)
    PrepareScriptHitHandlers();
    CallScriptBeforeHitHandlers(missInfo);

-    // Spells with this flag cannot trigger if effect is casted on self
-    bool const canEffectTrigger = !m_spellInfo->HasAttribute(SPELL_ATTR3_SUPRESS_CASTER_PROCS) && unitTarget->CanProc() && (CanExecuteTriggersOnHit(mask) || missInfo == SPELL_MISS_IMMUNE2);
+    //Spells with this flag cannot trigger if effect is casted on self
+    bool canEffectTrigger = !m_spellInfo->HasAttribute(SPELL_ATTR3_SUPRESS_CASTER_PROCS) && unitTarget->CanProc() && (CanExecuteTriggersOnHit(mask) || missInfo == SPELL_MISS_IMMUNE2);
    bool reflectedSpell = missInfo == SPELL_MISS_REFLECT;
    Unit* spellHitTarget = nullptr;

@@ -2706,14 +2699,18 @@ void Spell::DoAllEffectOnTarget(TargetInfo* target)
    if (missInfo != SPELL_MISS_NONE && m_needComboPoints && m_targets.GetUnitTargetGUID() == target->targetGUID)
    {
        m_needComboPoints = false;
+        // Restore spell mods for a miss/dodge/parry Cold Blood
+        // TODO: check how broad this rule should be
+        if (m_caster->GetTypeId() == TYPEID_PLAYER && (missInfo == SPELL_MISS_MISS || missInfo == SPELL_MISS_DODGE || missInfo == SPELL_MISS_PARRY))
+            m_caster->ToPlayer()->RestoreSpellMods(this, 14177);
    }

    // Fill base trigger info
    uint32 procAttacker = m_procAttacker;
    uint32 procVictim   = m_procVictim;
-    uint32 hitMask = m_hitMask;
+    uint32 procEx = m_procEx;

-    // Trigger info was not filled in Spell::prepareDataForTriggerSystem - we do it now
+    // Trigger info was not filled in spell::preparedatafortriggersystem - we do it now
    if (canEffectTrigger && !procAttacker && !procVictim)
    {
        bool positive = true;
@@ -2769,11 +2766,11 @@ void Spell::DoAllEffectOnTarget(TargetInfo* target)

        if (crit)
        {
-            hitMask |= PROC_HIT_CRITICAL;
+            procEx |= PROC_EX_CRITICAL_HIT;
            addhealth = Unit::SpellCriticalHealingBonus(caster, m_spellInfo, addhealth, nullptr);
        }
        else
-            hitMask |= PROC_HIT_NORMAL;
+            procEx |= PROC_EX_NORMAL_HIT;

        HealInfo healInfo(caster, unitTarget, addhealth, m_spellInfo, m_spellInfo->GetSchoolMask());

@@ -2781,20 +2778,27 @@ void Spell::DoAllEffectOnTarget(TargetInfo* target)
        if (GetSpellValue()->ForcedCritResult)
        {
            crit = true;
-            hitMask |= PROC_HIT_CRITICAL;
+            procEx |= PROC_EX_CRITICAL_HIT;
        }

        int32 gain = caster->HealBySpell(healInfo, crit);
        unitTarget->getHostileRefMgr().threatAssist(caster, float(gain) * 0.5f, m_spellInfo);
        m_healing = gain;

-        // Do triggers for unit
+        // Xinef: if heal acutally healed something, add no overheal flag
+        if (m_healing)
+            procEx |= PROC_EX_NO_OVERHEAL;
+
+        // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
        if (canEffectTrigger)
-            caster->ProcSkillsAndAuras(unitTarget, procAttacker, procVictim, PROC_SPELL_TYPE_HEAL, PROC_SPELL_PHASE_HIT, hitMask, this, nullptr, &healInfo);
+            Unit::ProcDamageAndSpell(caster, unitTarget, procAttacker, procVictim, procEx, addhealth, m_attackType, m_spellInfo, m_triggeredByAuraSpell.spellInfo,
+                m_triggeredByAuraSpell.effectIndex, this, nullptr, &healInfo);
    }
    // Do damage and triggers
    else if (m_damage > 0)
    {
+        caster->SetLastDamagedTargetGuid(unitTarget->GetGUID());
+
        // Fill base damage struct (unitTarget - is real spell target)
        SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo, m_spellSchoolMask);

@@ -2854,7 +2858,7 @@ void Spell::DoAllEffectOnTarget(TargetInfo* target)
        if (reflectedSpell)
            effectUnit->SendSpellNonMeleeReflectLog(&damageInfo, effectUnit);

-        hitMask |= createProcHitMask(&damageInfo, missInfo);
+        procEx |= createProcExtendMask(&damageInfo, missInfo);
        procVictim |= PROC_FLAG_TAKEN_DAMAGE;

        caster->DealSpellDamage(&damageInfo, true, this);
@@ -2862,15 +2866,16 @@ void Spell::DoAllEffectOnTarget(TargetInfo* target)
        // do procs after damage, eg healing effects
        // no need to check if target is alive, done in procdamageandspell

-        // Do triggers for unit
+        // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
        if (canEffectTrigger)
        {
-            DamageInfo dmgInfo(damageInfo, SPELL_DIRECT_DAMAGE, m_attackType, hitMask);
-            caster->ProcSkillsAndAuras(unitTarget, procAttacker, procVictim, PROC_SPELL_TYPE_DAMAGE, PROC_SPELL_PHASE_HIT, hitMask, this, &dmgInfo, nullptr);
+            DamageInfo dmgInfo(damageInfo, SPELL_DIRECT_DAMAGE);
+            Unit::ProcDamageAndSpell(caster, unitTarget, procAttacker, procVictim, procEx, damageInfo.damage, m_attackType, m_spellInfo, m_triggeredByAuraSpell.spellInfo,
+                m_triggeredByAuraSpell.effectIndex, this, &dmgInfo);

            if (caster->GetTypeId() == TYPEID_PLAYER && m_spellInfo->HasAttribute(SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT) == 0 &&
                    m_spellInfo->HasAttribute(SPELL_ATTR4_SUPRESS_WEAPON_PROCS) == 0 && (m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MELEE || m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_RANGED))
-                caster->ToPlayer()->CastItemCombatSpell(dmgInfo);
+                caster->ToPlayer()->CastItemCombatSpell(unitTarget, m_attackType, procVictim, procEx);
        }

        m_damage = damageInfo.damage;
@@ -2880,16 +2885,19 @@ void Spell::DoAllEffectOnTarget(TargetInfo* target)
    {
        // Fill base damage struct (unitTarget - is real spell target)
        SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo, m_spellSchoolMask);
-        hitMask |= createProcHitMask(&damageInfo, missInfo);
-        // Do triggers for unit
+        procEx |= createProcExtendMask(&damageInfo, missInfo);
+        // Do triggers for unit (reflect triggers passed on hit phase for correct drop charge)
        if (canEffectTrigger)
        {
-            DamageInfo spellNoDamageInfo(damageInfo, NODAMAGE, m_attackType, hitMask);
-            caster->ProcSkillsAndAuras(unitTarget, procAttacker, procVictim, PROC_SPELL_TYPE_NO_DMG_HEAL, PROC_SPELL_PHASE_HIT, hitMask, this, &spellNoDamageInfo, nullptr);
+            DamageInfo dmgInfo(damageInfo, NODAMAGE);
+            Unit::ProcDamageAndSpell(caster, unitTarget, procAttacker, procVictim, procEx, 0, m_attackType, m_spellInfo, m_triggeredByAuraSpell.spellInfo,
+                m_triggeredByAuraSpell.effectIndex, this, &dmgInfo);

-            if (caster->GetTypeId() == TYPEID_PLAYER && !m_spellInfo->HasAttribute(SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT) &&
-                !m_spellInfo->HasAttribute(SPELL_ATTR4_SUPRESS_WEAPON_PROCS) && (m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MELEE || m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_RANGED))
-                caster->ToPlayer()->CastItemCombatSpell(spellNoDamageInfo);
+            // Xinef: eg. rogue poisons can proc off cheap shot, etc. so this block should be here also
+            // Xinef: ofc count only spells that HIT the target, little hack used to fool the system
+            if ((procEx & PROC_EX_NORMAL_HIT || procEx & PROC_EX_CRITICAL_HIT) && caster->GetTypeId() == TYPEID_PLAYER && m_spellInfo->HasAttribute(SPELL_ATTR0_CANCELS_AUTO_ATTACK_COMBAT) == 0 &&
+                    m_spellInfo->HasAttribute(SPELL_ATTR4_SUPRESS_WEAPON_PROCS) == 0 && (m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MELEE || m_spellInfo->DmgClass == SPELL_DAMAGE_CLASS_RANGED))
+                caster->ToPlayer()->CastItemCombatSpell(unitTarget, m_attackType, procVictim | PROC_FLAG_TAKEN_DAMAGE, procEx);
        }

        // Failed Pickpocket, reveal rogue
@@ -3113,6 +3121,10 @@ SpellMissInfo Spell::DoSpellHitOnUnit(Unit* unit, uint32 effectMask, bool scaleA
            m_spellAura = Aura::TryRefreshStackOrCreate(aurSpellInfo, effectMask, unit, m_originalCaster,
                          (aurSpellInfo == m_spellInfo) ? &m_spellValue->EffectBasePoints[0] : &basePoints[0], m_CastItem, ObjectGuid::Empty, &refresh, refreshPeriodic);

+            // xinef: if aura was not refreshed, add proc ex
+            if (!refresh)
+                m_procEx |= PROC_EX_NO_AURA_REFRESH;
+
            if (m_spellAura)
            {
                // Set aura stack amount to desired value
@@ -3241,8 +3253,8 @@ void Spell::DoTriggersOnSpellHit(Unit* unit, uint8 effMask)
    // info confirmed with retail sniffs of permafrost and shadow weaving
    if (!m_hitTriggerSpells.empty())
    {
-        int32 _duration = 0;
-        for (auto i = m_hitTriggerSpells.begin(); i != m_hitTriggerSpells.end(); ++i)
+        int _duration = 0;
+        for (HitTriggerSpellList::const_iterator i = m_hitTriggerSpells.begin(); i != m_hitTriggerSpells.end(); ++i)
        {
            if (CanExecuteTriggersOnHit(effMask, i->triggeredByAura) && roll_chance_i(i->chance))
            {
@@ -3358,7 +3370,7 @@ bool Spell::UpdateChanneledTargetList()
                }

        if (Player* modOwner = m_caster->GetSpellModOwner())
-            modOwner->ApplySpellMod<SPELLMOD_RANGE>(m_spellInfo->Id, range, this);
+            modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RANGE, range, this);

        // xinef: add little tolerance level
        range += std::min(3.0f, range * 0.1f); // 10% but no more than 3yd
@@ -3521,7 +3533,7 @@ SpellCastResult Spell::prepare(SpellCastTargets const* targets, AuraEffect const
    }

    // Prepare data for triggers
-    prepareDataForTriggerSystem();
+    prepareDataForTriggerSystem(triggeredByAura);

    // calculate cast time (calculated after first CheckCast check to prevent charge counting for first CheckCast fail)
    m_casttime = (_triggeredCastFlags & TRIGGERED_CAST_DIRECTLY) ? 0 : m_spellInfo->CalcCastTime(m_caster, this);
@@ -3705,6 +3717,10 @@ void Spell::cancel(bool bySelf)
            if (m_caster->GetTypeId() == TYPEID_PLAYER && m_caster->ToPlayer()->NeedSendSpectatorData())
                ArenaSpectator::SendCommand_Spell(m_caster->FindMap(), m_caster->GetGUID(), "SPE", m_spellInfo->Id, bySelf ? 99998 : 99999);

+            // spell is canceled-take mods and clear list
+            if (Player* player = m_caster->GetSpellModOwner())
+                player->RemoveSpellMods(this);
+
            m_appliedMods.clear();
            break;
        default:
@@ -3929,14 +3945,26 @@ void Spell::_cast(bool skipCheck)
            }
        }

-        uint32 hitMask = m_hitMask;
+        uint32 procEx = PROC_EX_NORMAL_HIT;

-        if (!(hitMask & PROC_HIT_CRITICAL))
+        for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
        {
-            hitMask |= PROC_HIT_NORMAL;
+            if (ihit->missCondition != SPELL_MISS_NONE)
+            {
+                continue;
+            }
+
+            if (!ihit->crit)
+            {
+                continue;
+            }
+
+            procEx |= PROC_EX_CRITICAL_HIT;
+            break;
        }

-        m_originalCaster->ProcSkillsAndAuras(m_originalCaster, procAttacker, PROC_FLAG_NONE, PROC_SPELL_TYPE_MASK_ALL, PROC_SPELL_PHASE_CAST, hitMask, this, nullptr, nullptr);
+        Unit::ProcDamageAndSpell(m_originalCaster, m_originalCaster, procAttacker, PROC_FLAG_NONE, procEx, 1, BASE_ATTACK, m_spellInfo, m_triggeredByAuraSpell.spellInfo,
+            m_triggeredByAuraSpell.effectIndex, this, nullptr, nullptr, PROC_SPELL_PHASE_CAST);
    }

    if (modOwner)
@@ -3957,6 +3985,11 @@ void Spell::_cast(bool skipCheck)
        if (m_caster->HasUnitState(UNIT_STATE_CASTING) && !m_caster->IsNonMeleeSpellCast(false, false, true))
            m_caster->ClearUnitState(UNIT_STATE_CASTING);

+        // remove all applied mods at this point
+        // dont allow user to use them twice in case spell did not reach current target
+        if (modOwner)
+            modOwner->RemoveSpellMods(this);
+
        // Xinef: why do we keep focus after spell is sent to air?
        // Xinef: Because of this, in the middle of some animation after setting targetguid to 0 etc
        // Xinef: we get focused to it out of nowhere...
@@ -4049,7 +4082,7 @@ void Spell::handle_immediate()
            // First mod_duration then haste - see Missile Barrage
            // Apply duration mod
            if (Player* modOwner = m_caster->GetSpellModOwner())
-                modOwner->ApplySpellMod<SPELLMOD_DURATION>(m_spellInfo->Id, duration);
+                modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_DURATION, duration);

            // Apply haste mods
            if (m_caster->HasAuraTypeWithAffectMask(SPELL_AURA_PERIODIC_HASTE, m_spellInfo) || m_spellInfo->HasAttribute(SPELL_ATTR5_SPELL_HASTE_AFFECTS_PERIODIC))
@@ -4073,14 +4106,8 @@ void Spell::handle_immediate()
    // process immediate effects (items, ground, etc.) also initialize some variables
    _handle_immediate_phase();

-    // consider spell hit for some spells without target, so they may proc on finish phase correctly
-    if (m_UniqueTargetInfo.empty())
-        m_hitMask = PROC_HIT_NORMAL;
-    else
-    {
-        for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
-            DoAllEffectOnTarget(&(*ihit));
-    }
+    for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
+        DoAllEffectOnTarget(&(*ihit));

    for (std::list<GOTargetInfo>::iterator ihit = m_UniqueGOTargetInfo.begin(); ihit != m_UniqueGOTargetInfo.end(); ++ihit)
        DoAllEffectOnTarget(&(*ihit));
@@ -4227,8 +4254,10 @@ void Spell::_handle_finish_phase()
        m_caster->AddComboPoints(m_comboTarget, m_comboPointGain);
    }

-    if (m_caster->m_extraAttacks && GetSpellInfo()->HasEffect(SPELL_EFFECT_ADD_EXTRA_ATTACKS))
-        m_caster->HandleProcExtraAttackFor(m_caster->GetVictim());
+    if (m_spellInfo->HasEffect(SPELL_EFFECT_ADD_EXTRA_ATTACKS))
+    {
+        m_caster->SetLastExtraAttackSpell(m_spellInfo->Id);
+    }

    if (!IsAutoRepeat() && !IsNextMeleeSwingSpell())
        if (m_caster->GetCharmerOrOwnerPlayerOrPlayerItself())
@@ -4257,13 +4286,25 @@ void Spell::_handle_finish_phase()
            }
        }

-        uint32 hitMask = m_hitMask;
-        if (!(hitMask & PROC_HIT_CRITICAL))
+        uint32 procEx = PROC_EX_NORMAL_HIT;
+        for (std::list<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit)
        {
-            hitMask |= PROC_HIT_NORMAL;
+            if (ihit->missCondition != SPELL_MISS_NONE)
+            {
+                continue;
+            }
+
+            if (!ihit->crit)
+            {
+                continue;
+            }
+
+            procEx |= PROC_EX_CRITICAL_HIT;
+            break;
        }

-        m_originalCaster->ProcSkillsAndAuras(m_originalCaster, procAttacker, PROC_FLAG_NONE, PROC_SPELL_TYPE_MASK_ALL, PROC_SPELL_PHASE_FINISH, hitMask, this, nullptr, nullptr);
+        Unit::ProcDamageAndSpell(m_originalCaster, m_originalCaster, procAttacker, PROC_FLAG_NONE, procEx, 1, BASE_ATTACK, m_spellInfo, m_triggeredByAuraSpell.spellInfo,
+            m_triggeredByAuraSpell.effectIndex, this, nullptr, nullptr, PROC_SPELL_PHASE_FINISH);
    }
 }

@@ -4453,6 +4494,11 @@ void Spell::finish(bool ok)
    if (m_caster->GetTypeId() == TYPEID_PLAYER && !m_triggeredByAuraSpell)
        m_caster->ToPlayer()->UpdatePotionCooldown(this);

+    // Take mods after trigger spell (needed for 14177 to affect 48664)
+    // mods are taken only on succesfull cast and independantly from targets of the spell
+    if (Player* player = m_caster->GetSpellModOwner())
+        player->RemoveSpellMods(this);
+
    // xinef: clear reactive auras states after spell cast
    if (m_spellInfo->CasterAuraState == AURA_STATE_DEFENSE || m_spellInfo->CasterAuraState == AURA_STATE_HUNTER_PARRY)
        m_caster->ModifyAuraState(AuraStateType(m_spellInfo->CasterAuraState), false);
@@ -5237,7 +5283,7 @@ void Spell::TakePower()
                            hit = false;
                            //lower spell cost on fail (by talent aura)
                            if (Player* modOwner = m_caster->ToPlayer()->GetSpellModOwner())
-                                modOwner->ApplySpellMod<SPELLMOD_SPELL_COST_REFUND_ON_FAIL>(m_spellInfo->Id, m_powerCost, this);
+                                modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_SPELL_COST_REFUND_ON_FAIL, m_powerCost, this);
                        }
                        break;
                    }
@@ -5338,7 +5384,7 @@ SpellCastResult Spell::CheckRuneCost(uint32 RuneCostID)
    {
        runeCost[i] = src->RuneCost[i];
        if (Player* modOwner = m_caster->GetSpellModOwner())
-            modOwner->ApplySpellMod<SPELLMOD_COST>(m_spellInfo->Id, runeCost[i], this);
+            modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_COST, runeCost[i], this);
    }

    runeCost[RUNE_DEATH] = MAX_RUNES;                       // calculated later
@@ -5378,7 +5424,7 @@ void Spell::TakeRunePower(bool didHit)
    {
        runeCost[i] = runeCostData->RuneCost[i];
        if (Player* modOwner = m_caster->GetSpellModOwner())
-            modOwner->ApplySpellMod<SPELLMOD_COST>(m_spellInfo->Id, runeCost[i], this);
+            modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_COST, runeCost[i], this);
    }

    runeCost[RUNE_DEATH] = 0;                               // calculated later
@@ -5775,11 +5821,7 @@ SpellCastResult Spell::CheckCast(bool strict)
        // Xinef: do not check explicit target for triggered spell casted on self with targetflag enemy
        if (!m_triggeredByAuraSpell || m_targets.GetUnitTarget() != m_caster || !(m_spellInfo->GetExplicitTargetMask() & TARGET_FLAG_UNIT_ENEMY))
        {
-            Unit* caster = m_caster;
-            if (m_originalCaster && m_caster->GetEntry() != WORLD_TRIGGER) // Do a simplified check for gameobject casts
-                caster = m_originalCaster;
-
-            SpellCastResult castResult = m_spellInfo->CheckExplicitTarget(caster, m_targets.GetObjectTarget(), m_targets.GetItemTarget());
+            SpellCastResult castResult = m_spellInfo->CheckExplicitTarget((m_originalCaster && m_caster->GetEntry() != WORLD_TRIGGER) ? m_originalCaster : m_caster, m_targets.GetObjectTarget(), m_targets.GetItemTarget());
            if (castResult != SPELL_CAST_OK)
                return castResult;
        }
@@ -5787,7 +5829,7 @@ SpellCastResult Spell::CheckCast(bool strict)

    if (Unit* target = m_targets.GetUnitTarget())
    {
-        SpellCastResult castResult = m_spellInfo->CheckTarget(m_caster, target, m_caster->GetEntry() == WORLD_TRIGGER); // skip stealth checks for GO casts
+        SpellCastResult castResult = m_spellInfo->CheckTarget(m_caster, target, false);
        if (castResult != SPELL_CAST_OK)
            return castResult;

@@ -6983,7 +7025,7 @@ SpellCastResult Spell::CheckRange(bool strict)
        range_type = SPELL_RANGE_RANGED;

    if (Player* modOwner = m_caster->GetSpellModOwner())
-        modOwner->ApplySpellMod<SPELLMOD_RANGE>(m_spellInfo->Id, max_range, this);
+        modOwner->ApplySpellMod(m_spellInfo->Id, SPELLMOD_RANGE, max_range, this);

    // xinef: dont check max_range to strictly after cast
    if (range_type != SPELL_RANGE_MELEE && !strict)
@@ -7697,7 +7739,7 @@ void Spell::Delayed() // only called in DealDamage()
    //check pushback reduce
    int32 delaytime = 500;                                  // spellcasting delay is normally 500ms
    int32 delayReduce = 100;                                // must be initialized to 100 for percent modifiers
-    m_caster->ToPlayer()->ApplySpellMod<SPELLMOD_NOT_LOSE_CASTING_TIME>(m_spellInfo->Id, delayReduce, this);
+    m_caster->ToPlayer()->ApplySpellMod(m_spellInfo->Id, SPELLMOD_NOT_LOSE_CASTING_TIME, delayReduce, this);
    delayReduce += m_caster->GetTotalAuraModifier(SPELL_AURA_REDUCE_PUSHBACK) - 100;
    if (delayReduce >= 100)
        return;
@@ -7735,7 +7777,7 @@ void Spell::DelayedChannel()

    int32 delaytime = CalculatePct(duration, 25); // channeling delay is normally 25% of its time per hit
    int32 delayReduce = 100;                                    // must be initialized to 100 for percent modifiers
-    m_caster->ToPlayer()->ApplySpellMod<SPELLMOD_NOT_LOSE_CASTING_TIME>(m_spellInfo->Id, delayReduce, this);
+    m_caster->ToPlayer()->ApplySpellMod(m_spellInfo->Id, SPELLMOD_NOT_LOSE_CASTING_TIME, delayReduce, this);
    delayReduce += m_caster->GetTotalAuraModifier(SPELL_AURA_REDUCE_PUSHBACK) - 100;
    if (delayReduce >= 100)
        return;
@@ -8115,6 +8157,14 @@ bool SpellEvent::IsDeletable() const
    return m_Spell->IsDeletable();
 }

+bool ReflectEvent::Execute(uint64  /*e_time*/, uint32  /*p_time*/)
+{
+    Unit* target = ObjectAccessor::GetUnit(*_caster, _targetGUID);
+    if (target && _caster->IsInMap(target))
+        Unit::ProcDamageAndSpell(_caster, target, PROC_FLAG_NONE, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_EX_REFLECT, 1, BASE_ATTACK, _spellInfo);
+    return true;
+}
+
 bool Spell::IsValidDeadOrAliveTarget(Unit const* target) const
 {
    if (target->IsAlive())
@@ -8690,24 +8740,26 @@ void Spell::PrepareTriggersExecutedOnHit()
    // save auras which were present on spell caster on cast, to prevent triggered auras from affecting caster
    // and to correctly calculate proc chance when combopoints are present
    Unit::AuraEffectList const& targetTriggers = m_caster->GetAuraEffectsByType(SPELL_AURA_ADD_TARGET_TRIGGER);
-    for (AuraEffect const* aurEff : targetTriggers)
+    for (Unit::AuraEffectList::const_iterator i = targetTriggers.begin(); i != targetTriggers.end(); ++i)
    {
-        if (!aurEff->IsAffectedOnSpell(m_spellInfo))
+        if (!(*i)->IsAffectedOnSpell(m_spellInfo))
            continue;
-
-        SpellInfo const* auraSpellInfo = aurEff->GetSpellInfo();
-        uint32 auraSpellIdx = aurEff->GetEffIndex();
+        SpellInfo const* auraSpellInfo = (*i)->GetSpellInfo();
+        uint32 auraSpellIdx = (*i)->GetEffIndex();
        if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(auraSpellInfo->Effects[auraSpellIdx].TriggerSpell))
        {
            // calculate the chance using spell base amount, because aura amount is not updated on combo-points change
            // this possibly needs fixing
-            int32 auraBaseAmount = aurEff->GetBaseAmount();
+            int32 auraBaseAmount = (*i)->GetBaseAmount();
            // proc chance is stored in effect amount
            int32 chance = m_caster->CalculateSpellDamage(nullptr, auraSpellInfo, auraSpellIdx, &auraBaseAmount);
-            chance *= aurEff->GetBase()->GetStackAmount();
-
            // build trigger and add to the list
-            m_hitTriggerSpells.emplace_back(spellInfo, auraSpellInfo, chance);
+            HitTriggerSpell spellTriggerInfo;
+            spellTriggerInfo.triggeredSpell = spellInfo;
+            spellTriggerInfo.triggeredByAura = auraSpellInfo;
+            spellTriggerInfo.triggeredByEffIdx = (*i)->GetEffIndex();
+            spellTriggerInfo.chance = chance * (*i)->GetBase()->GetStackAmount();
+            m_hitTriggerSpells.push_back(spellTriggerInfo);
        }
    }
 }
@@ -8752,8 +8804,8 @@ void Spell::TriggerGlobalCooldown()
    if (m_spellInfo->StartRecoveryTime >= MIN_GCD && m_spellInfo->StartRecoveryTime <= MAX_GCD)
    {
        // gcd modifier auras are applied only to own spells and only players have such mods
-        if (Player* modOwner = m_caster->GetSpellModOwner())
-            modOwner->ApplySpellMod<SPELLMOD_GLOBAL_COOLDOWN>(m_spellInfo->Id, gcd, this);
+        if (m_caster->GetTypeId() == TYPEID_PLAYER)
+            m_caster->ToPlayer()->ApplySpellMod(m_spellInfo->Id, SPELLMOD_GLOBAL_COOLDOWN, gcd, this);

        // Apply haste rating
        if (m_spellInfo->StartRecoveryCategory == 133 && m_spellInfo->StartRecoveryTime == 1500 && m_spellInfo->DmgClass != SPELL_DAMAGE_CLASS_MELEE &&
@@ -8762,7 +8814,10 @@ void Spell::TriggerGlobalCooldown()
            gcd = int32(float(gcd) * m_caster->GetFloatValue(UNIT_MOD_CAST_SPEED));
        }

-        RoundToInterval<int32>(gcd, MIN_GCD, MAX_GCD);
+        if (gcd < MIN_GCD)
+            gcd = MIN_GCD;
+        else if (gcd > MAX_GCD)
+            gcd = MAX_GCD;
    }

    // Only players or controlled units have global cooldown