Core/Spells: Add type safety to proc related functions - using enum arguments instead of plain integers

11 files changed, 111 insertions, 70 deletions

diff --git a/src/server/game/Entities/Unit/Unit.cpp b/src/server/game/Entities/Unit/Unit.cpp
index f49e08be4fb..c90dd86d3cb 100644
--- a/src/server/game/Entities/Unit/Unit.cpp
+++ b/src/server/game/Entities/Unit/Unit.cpp
@@ -128,13 +128,13 @@ bool DispelableAura::RollDispel() const
 
 DamageInfo::DamageInfo(Unit* attacker, Unit* victim, uint32 damage, SpellInfo const* spellInfo, SpellSchoolMask schoolMask, DamageEffectType damageType, WeaponAttackType attackType)
     : m_attacker(attacker), m_victim(victim), m_damage(damage), m_originalDamage(damage), m_spellInfo(spellInfo), m_schoolMask(schoolMask), m_damageType(damageType), m_attackType(attackType),
-    m_absorb(0), m_resist(0), m_block(0), m_hitMask(0)
+    m_absorb(0), m_resist(0), m_block(0), m_hitMask(PROC_HIT_NONE)
 {
 }
 
 DamageInfo::DamageInfo(CalcDamageInfo const& dmgInfo)
     : m_attacker(dmgInfo.Attacker), m_victim(dmgInfo.Target), m_damage(dmgInfo.Damage), m_originalDamage(dmgInfo.Damage), m_spellInfo(nullptr), m_schoolMask(SpellSchoolMask(dmgInfo.DamageSchoolMask)),
-    m_damageType(DIRECT_DAMAGE), m_attackType(dmgInfo.AttackType), m_absorb(dmgInfo.Absorb), m_resist(dmgInfo.Resist), m_block(dmgInfo.Blocked), m_hitMask(0)
+    m_damageType(DIRECT_DAMAGE), m_attackType(dmgInfo.AttackType), m_absorb(dmgInfo.Absorb), m_resist(dmgInfo.Resist), m_block(dmgInfo.Blocked), m_hitMask(PROC_HIT_NONE)
 {
     switch (dmgInfo.TargetState)
     {
@@ -185,7 +185,7 @@ DamageInfo::DamageInfo(CalcDamageInfo const& dmgInfo)
     }
 }
 
-DamageInfo::DamageInfo(SpellNonMeleeDamage const& spellNonMeleeDamage, DamageEffectType damageType, WeaponAttackType attackType, uint32 hitMask)
+DamageInfo::DamageInfo(SpellNonMeleeDamage const& spellNonMeleeDamage, DamageEffectType damageType, WeaponAttackType attackType, ProcFlagsHit hitMask)
     : m_attacker(spellNonMeleeDamage.attacker), m_victim(spellNonMeleeDamage.target), m_damage(spellNonMeleeDamage.damage), m_originalDamage(spellNonMeleeDamage.originalDamage),
     m_spellInfo(spellNonMeleeDamage.Spell), m_schoolMask(SpellSchoolMask(spellNonMeleeDamage.schoolMask)), m_damageType(damageType),
     m_attackType(attackType), m_absorb(spellNonMeleeDamage.absorb), m_resist(spellNonMeleeDamage.resist), m_block(spellNonMeleeDamage.blocked), m_hitMask(hitMask)
@@ -235,7 +235,7 @@ void DamageInfo::BlockDamage(uint32 amount)
     }
 }
 
-uint32 DamageInfo::GetHitMask() const
+ProcFlagsHit DamageInfo::GetHitMask() const
 {
     return m_hitMask;
 }
@@ -261,8 +261,8 @@ uint32 HealInfo::GetHitMask() const
 }
 
 ProcEventInfo::ProcEventInfo(Unit* actor, Unit* actionTarget, Unit* procTarget,
-                             ProcFlagsInit const& typeMask, uint32 spellTypeMask,
-                             uint32 spellPhaseMask, uint32 hitMask,
+                             ProcFlagsInit const& typeMask, ProcFlagsSpellType spellTypeMask,
+                             ProcFlagsSpellPhase spellPhaseMask, ProcFlagsHit hitMask,
                              Spell* spell, DamageInfo* damageInfo,
                              HealInfo* healInfo) :
     _actor(actor), _actionTarget(actionTarget), _procTarget(procTarget),
@@ -5181,7 +5181,9 @@ void Unit::SendSpellNonMeleeDamageLog(SpellNonMeleeDamage const* log)
     SendCombatLogMessage(&packet);
 }
 
-/*static*/ void Unit::ProcSkillsAndAuras(Unit* actor, Unit* actionTarget, ProcFlagsInit const& typeMaskActor, ProcFlagsInit const& typeMaskActionTarget, uint32 spellTypeMask, uint32 spellPhaseMask, uint32 hitMask, Spell* spell, DamageInfo* damageInfo, HealInfo* healInfo)
+/*static*/ void Unit::ProcSkillsAndAuras(Unit* actor, Unit* actionTarget, ProcFlagsInit const& typeMaskActor, ProcFlagsInit const& typeMaskActionTarget,
+                                         ProcFlagsSpellType spellTypeMask, ProcFlagsSpellPhase spellPhaseMask, ProcFlagsHit hitMask,
+                                         Spell* spell, DamageInfo* damageInfo, HealInfo* healInfo)
 {
     WeaponAttackType attType = damageInfo ? damageInfo->GetAttackType() : BASE_ATTACK;
     if (typeMaskActor && actor)
@@ -9602,9 +9604,9 @@ void Unit::SetMovedUnit(Unit* target)
     ToPlayer()->SendDirectMessage(packet.Write());
 }
 
-uint32 createProcHitMask(SpellNonMeleeDamage* damageInfo, SpellMissInfo missCondition)
+ProcFlagsHit createProcHitMask(SpellNonMeleeDamage* damageInfo, SpellMissInfo missCondition)
 {
-    uint32 hitMask = PROC_HIT_NONE;
+    ProcFlagsHit hitMask = PROC_HIT_NONE;
     // Check victim state
     if (missCondition != SPELL_MISS_NONE)
     {
@@ -9676,7 +9678,7 @@ uint32 createProcHitMask(SpellNonMeleeDamage* damageInfo, SpellMissInfo missCond
     return hitMask;
 }
 
-void Unit::ProcSkillsAndReactives(bool isVictim, Unit* procTarget, uint32 typeMask, uint32 hitMask, WeaponAttackType /*attType*/)
+void Unit::ProcSkillsAndReactives(bool isVictim, Unit* procTarget, ProcFlagsInit const& typeMask, ProcFlagsHit hitMask, WeaponAttackType /*attType*/)
 {
     // Player is loaded now - do not allow passive spell casts to proc
     if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->GetSession()->PlayerLoading())
@@ -9749,7 +9751,9 @@ void Unit::GetProcAurasTriggeredOnEvent(AuraApplicationProcContainer& aurasTrigg
     }
 }
 
-void Unit::TriggerAurasProcOnEvent(AuraApplicationList* myProcAuras, AuraApplicationList* targetProcAuras, Unit* actionTarget, ProcFlagsInit const& typeMaskActor, ProcFlagsInit const& typeMaskActionTarget, uint32 spellTypeMask, uint32 spellPhaseMask, uint32 hitMask, Spell* spell, DamageInfo* damageInfo, HealInfo* healInfo)
+void Unit::TriggerAurasProcOnEvent(AuraApplicationList* myProcAuras, AuraApplicationList* targetProcAuras, Unit* actionTarget,
+                                   ProcFlagsInit const& typeMaskActor, ProcFlagsInit const& typeMaskActionTarget, ProcFlagsSpellType spellTypeMask,
+                                   ProcFlagsSpellPhase spellPhaseMask, ProcFlagsHit hitMask, Spell* spell, DamageInfo* damageInfo, HealInfo* healInfo)
 {
     // prepare data for self trigger
     ProcEventInfo myProcEventInfo(this, actionTarget, actionTarget, typeMaskActor, spellTypeMask, spellPhaseMask, hitMask, spell, damageInfo, healInfo);
diff --git a/src/server/game/Entities/Unit/Unit.h b/src/server/game/Entities/Unit/Unit.h
index 7aa45afde80..ba24f13bd0a 100644
--- a/src/server/game/Entities/Unit/Unit.h
+++ b/src/server/game/Entities/Unit/Unit.h
@@ -98,8 +98,11 @@ class Vehicle;
 class VehicleJoinEvent;
 
 enum class PetActionFeedback : uint8;
-enum ZLiquidStatus : uint32;
 enum MovementGeneratorType : uint8;
+enum ProcFlagsHit : uint32;
+enum ProcFlagsSpellPhase : uint32;
+enum ProcFlagsSpellType : uint32;
+enum ZLiquidStatus : uint32;
 
 namespace Movement
 {
@@ -420,11 +423,11 @@ class TC_GAME_API DamageInfo
         uint32 m_absorb;
         uint32 m_resist;
         uint32 m_block;
-        uint32 m_hitMask;
+        ProcFlagsHit m_hitMask;
     public:
         DamageInfo(Unit* attacker, Unit* victim, uint32 damage, SpellInfo const* spellInfo, SpellSchoolMask schoolMask, DamageEffectType damageType, WeaponAttackType attackType);
         explicit DamageInfo(CalcDamageInfo const& dmgInfo);
-        DamageInfo(SpellNonMeleeDamage const& spellNonMeleeDamage, DamageEffectType damageType, WeaponAttackType attackType, uint32 hitMask);
+        DamageInfo(SpellNonMeleeDamage const& spellNonMeleeDamage, DamageEffectType damageType, WeaponAttackType attackType, ProcFlagsHit hitMask);
 
         void ModifyDamage(int32 amount);
         void AbsorbDamage(uint32 amount);
@@ -443,7 +446,7 @@ class TC_GAME_API DamageInfo
         uint32 GetResist() const { return m_resist; }
         uint32 GetBlock() const { return m_block; }
 
-        uint32 GetHitMask() const;
+        ProcFlagsHit GetHitMask() const;
 };
 
 class TC_GAME_API HealInfo
@@ -481,17 +484,17 @@ class TC_GAME_API ProcEventInfo
 {
     public:
         ProcEventInfo(Unit* actor, Unit* actionTarget, Unit* procTarget, ProcFlagsInit const& typeMask,
-                      uint32 spellTypeMask, uint32 spellPhaseMask, uint32 hitMask,
+                      ProcFlagsSpellType spellTypeMask, ProcFlagsSpellPhase spellPhaseMask, ProcFlagsHit hitMask,
                       Spell* spell, DamageInfo* damageInfo, HealInfo* healInfo);
 
         Unit* GetActor() { return _actor; }
         Unit* GetActionTarget() const { return _actionTarget; }
         Unit* GetProcTarget() const { return _procTarget; }
 
-        FlagsArray<int32, 2> GetTypeMask() const { return _typeMask; }
-        uint32 GetSpellTypeMask() const { return _spellTypeMask; }
-        uint32 GetSpellPhaseMask() const { return _spellPhaseMask; }
-        uint32 GetHitMask() const { return _hitMask; }
+        ProcFlagsInit GetTypeMask() const { return _typeMask; }
+        ProcFlagsSpellType GetSpellTypeMask() const { return _spellTypeMask; }
+        ProcFlagsSpellPhase GetSpellPhaseMask() const { return _spellPhaseMask; }
+        ProcFlagsHit GetHitMask() const { return _hitMask; }
 
         SpellInfo const* GetSpellInfo() const;
         SpellSchoolMask GetSchoolMask() const;
@@ -505,10 +508,10 @@ class TC_GAME_API ProcEventInfo
         Unit* const _actor;
         Unit* const _actionTarget;
         Unit* const _procTarget;
-        FlagsArray<int32, 2> _typeMask;
-        uint32 _spellTypeMask;
-        uint32 _spellPhaseMask;
-        uint32 _hitMask;
+        ProcFlagsInit _typeMask;
+        ProcFlagsSpellType _spellTypeMask;
+        ProcFlagsSpellPhase _spellPhaseMask;
+        ProcFlagsHit _hitMask;
         Spell* _spell;
         DamageInfo* _damageInfo;
         HealInfo* _healInfo;
@@ -576,7 +579,7 @@ struct SpellPeriodicAuraLogInfo
     bool   critical;
 };
 
-uint32 createProcHitMask(SpellNonMeleeDamage* damageInfo, SpellMissInfo missCondition);
+ProcFlagsHit createProcHitMask(SpellNonMeleeDamage* damageInfo, SpellMissInfo missCondition);
 
 enum CurrentSpellTypes : uint8
 {
@@ -1028,13 +1031,13 @@ class TC_GAME_API Unit : public WorldObject
         static void DealHeal(HealInfo& healInfo);
 
         static void ProcSkillsAndAuras(Unit* actor, Unit* actionTarget, ProcFlagsInit const& typeMaskActor, ProcFlagsInit const& typeMaskActionTarget,
-                                uint32 spellTypeMask, uint32 spellPhaseMask, uint32 hitMask, Spell* spell,
+                                ProcFlagsSpellType spellTypeMask, ProcFlagsSpellPhase spellPhaseMask, ProcFlagsHit hitMask, Spell* spell,
                                 DamageInfo* damageInfo, HealInfo* healInfo);
 
         void GetProcAurasTriggeredOnEvent(AuraApplicationProcContainer& aurasTriggeringProc, AuraApplicationList* procAuras, ProcEventInfo& eventInfo);
         void TriggerAurasProcOnEvent(AuraApplicationList* myProcAuras, AuraApplicationList* targetProcAuras,
                                      Unit* actionTarget, ProcFlagsInit const& typeMaskActor, ProcFlagsInit const& typeMaskActionTarget,
-                                     uint32 spellTypeMask, uint32 spellPhaseMask, uint32 hitMask, Spell* spell,
+                                     ProcFlagsSpellType spellTypeMask, ProcFlagsSpellPhase spellPhaseMask, ProcFlagsHit hitMask, Spell* spell,
                                      DamageInfo* damageInfo, HealInfo* healInfo);
         void TriggerAurasProcOnEvent(ProcEventInfo& eventInfo, AuraApplicationProcContainer& procAuras);
 
@@ -1974,7 +1977,7 @@ class TC_GAME_API Unit : public WorldObject
         float GetCombatRatingReduction(CombatRating cr) const;
         uint32 GetCombatRatingDamageReduction(CombatRating cr, float rate, float cap, uint32 damage) const;
 
-        void ProcSkillsAndReactives(bool isVictim, Unit* procTarget, uint32 typeMask, uint32 hitMask, WeaponAttackType attType);
+        void ProcSkillsAndReactives(bool isVictim, Unit* procTarget, ProcFlagsInit const& typeMask, ProcFlagsHit hitMask, WeaponAttackType attType);
 
     protected:
         void SetFeared(bool apply);
diff --git a/src/server/game/Spells/Auras/SpellAuraEffects.cpp b/src/server/game/Spells/Auras/SpellAuraEffects.cpp
index ee86422c252..814b99ebb6b 100644
--- a/src/server/game/Spells/Auras/SpellAuraEffects.cpp
+++ b/src/server/game/Spells/Auras/SpellAuraEffects.cpp
@@ -5326,7 +5326,7 @@ void AuraEffect::HandlePeriodicDamageAurasTick(Unit* target, Unit* caster) const
     // Set trigger flag
     ProcFlagsInit procAttacker = PROC_FLAG_DONE_PERIODIC;
     ProcFlagsInit procVictim   = PROC_FLAG_TAKEN_PERIODIC;
-    uint32 hitMask = damageInfo.GetHitMask();
+    ProcFlagsHit hitMask = damageInfo.GetHitMask();
     if (damage)
     {
         hitMask |= crit ? PROC_HIT_CRITICAL : PROC_HIT_NORMAL;
@@ -5422,7 +5422,7 @@ void AuraEffect::HandlePeriodicHealthLeechAuraTick(Unit* target, Unit* caster) c
     // Set trigger flag
     ProcFlagsInit procAttacker = PROC_FLAG_DONE_PERIODIC;
     ProcFlagsInit procVictim   = PROC_FLAG_TAKEN_PERIODIC;
-    uint32 hitMask = damageInfo.GetHitMask();
+    ProcFlagsHit hitMask = damageInfo.GetHitMask();
     if (damage)
     {
         hitMask |= crit ? PROC_HIT_CRITICAL : PROC_HIT_NORMAL;
@@ -5536,7 +5536,7 @@ void AuraEffect::HandlePeriodicHealAurasTick(Unit* target, Unit* caster) const
 
     ProcFlagsInit procAttacker = PROC_FLAG_DONE_PERIODIC;
     ProcFlagsInit procVictim   = PROC_FLAG_TAKEN_PERIODIC;
-    uint32 hitMask = crit ? PROC_HIT_CRITICAL : PROC_HIT_NORMAL;
+    ProcFlagsHit hitMask = crit ? PROC_HIT_CRITICAL : PROC_HIT_NORMAL;
     // ignore item heals
     if (GetBase()->GetCastItemGUID().IsEmpty())
         Unit::ProcSkillsAndAuras(caster, target, procAttacker, procVictim, PROC_SPELL_TYPE_HEAL, PROC_SPELL_PHASE_HIT, hitMask, nullptr, nullptr, &healInfo);
@@ -5698,8 +5698,8 @@ void AuraEffect::HandlePeriodicPowerBurnAuraTick(Unit* target, Unit* caster) con
     // Set trigger flag
     ProcFlagsInit procAttacker = PROC_FLAG_DONE_PERIODIC;
     ProcFlagsInit procVictim   = PROC_FLAG_TAKEN_PERIODIC;
-    uint32 hitMask      = createProcHitMask(&damageInfo, SPELL_MISS_NONE);
-    uint32 spellTypeMask = PROC_SPELL_TYPE_NO_DMG_HEAL;
+    ProcFlagsHit hitMask       = createProcHitMask(&damageInfo, SPELL_MISS_NONE);
+    ProcFlagsSpellType spellTypeMask = PROC_SPELL_TYPE_NO_DMG_HEAL;
     if (damageInfo.damage)
     {
         procVictim |= PROC_FLAG_TAKEN_DAMAGE;
diff --git a/src/server/game/Spells/Auras/SpellAuraEffects.h b/src/server/game/Spells/Auras/SpellAuraEffects.h
index ac3c151ae21..d2b05ea29ec 100644
--- a/src/server/game/Spells/Auras/SpellAuraEffects.h
+++ b/src/server/game/Spells/Auras/SpellAuraEffects.h
@@ -86,7 +86,7 @@ class TC_GAME_API AuraEffect
         bool IsPeriodic() const { return m_isPeriodic; }
         void SetPeriodic(bool isPeriodic) { m_isPeriodic = isPeriodic; }
         bool IsAffectingSpell(SpellInfo const* spell) const;
-        bool HasSpellClassMask() const { return GetSpellEffectInfo().SpellClassMask; }
+        bool HasSpellClassMask() const { return !!GetSpellEffectInfo().SpellClassMask; }
 
         void SendTickImmune(Unit* target, Unit* caster) const;
         void PeriodicTick(AuraApplication* aurApp, Unit* caster) const;
diff --git a/src/server/game/Spells/Spell.cpp b/src/server/game/Spells/Spell.cpp
index 5ac413809f6..54323f5fdcf 100644
--- a/src/server/game/Spells/Spell.cpp
+++ b/src/server/game/Spells/Spell.cpp
@@ -585,7 +585,7 @@ m_spellValue(new SpellValue(m_spellInfo, caster)), _spellEvent(nullptr)
     effectInfo = nullptr;
     m_damage = 0;
     m_healing = 0;
-    m_hitMask = 0;
+    m_hitMask = PROC_HIT_NONE;
     focusObject = nullptr;
     m_castId = ObjectGuid::Create<HighGuid::Cast>(SPELL_CAST_SOURCE_NORMAL, m_caster->GetMapId(), m_spellInfo->Id, m_caster->GetMap()->GenerateLowGuid<HighGuid::Cast>());
     m_originalCastId = originalCastId;
@@ -2225,9 +2225,9 @@ class ProcReflectDelayed : public BasicEvent
 
             ProcFlags const typeMaskActor = PROC_FLAG_NONE;
             ProcFlags 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;
+            ProcFlagsSpellType const spellTypeMask = PROC_SPELL_TYPE_DAMAGE | PROC_SPELL_TYPE_NO_DMG_HEAL;
+            ProcFlagsSpellPhase const spellPhaseMask = PROC_SPELL_PHASE_NONE;
+            ProcFlagsHit const hitMask = PROC_HIT_REFLECT;
 
             Unit::ProcSkillsAndAuras(caster, _victim, typeMaskActor, typeMaskActionTarget, spellTypeMask, spellPhaseMask, hitMask, nullptr, nullptr, nullptr);
             return true;
@@ -2597,8 +2597,8 @@ void Spell::TargetInfo::DoDamageAndTriggers(Spell* spell)
         // Fill base trigger info
         ProcFlagsInit procAttacker = spell->m_procAttacker;
         ProcFlagsInit procVictim = spell->m_procVictim;
-        uint32 procSpellType = PROC_SPELL_TYPE_NONE;
-        uint32 hitMask = PROC_HIT_NONE;
+        ProcFlagsSpellType procSpellType = PROC_SPELL_TYPE_NONE;
+        ProcFlagsHit hitMask = PROC_HIT_NONE;
 
         // Spells with this flag cannot trigger if effect is cast on self
         bool const canEffectTrigger = !spell->m_spellInfo->HasAttribute(SPELL_ATTR3_CANT_TRIGGER_PROC) && spell->unitTarget->CanProc() &&
@@ -3697,7 +3697,7 @@ void Spell::_cast(bool skipCheck)
             procAttacker = IsPositive() ? PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS : PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG;
     }
 
-    uint32 hitMask = m_hitMask;
+    ProcFlagsHit hitMask = m_hitMask;
     if (!(hitMask & PROC_HIT_CRITICAL))
         hitMask |= PROC_HIT_NORMAL;
 
diff --git a/src/server/game/Spells/Spell.h b/src/server/game/Spells/Spell.h
index d9d39f1096a..76cba756fd0 100644
--- a/src/server/game/Spells/Spell.h
+++ b/src/server/game/Spells/Spell.h
@@ -61,6 +61,7 @@ struct SummonPropertiesEntry;
 enum AuraType : uint32;
 enum CurrentSpellTypes : uint8;
 enum LootType : uint8;
+enum ProcFlagsHit : uint32;
 enum SpellTargetCheckTypes : uint8;
 enum SpellTargetObjectTypes : uint8;
 enum SpellValueMod : uint8;
@@ -714,7 +715,7 @@ class TC_GAME_API Spell
         // ******************************************
         ProcFlagsInit m_procAttacker;         // Attacker trigger flags
         ProcFlagsInit m_procVictim;           // Victim   trigger flags
-        uint32 m_hitMask;
+        ProcFlagsHit m_hitMask;
         void prepareDataForTriggerSystem();
 
         // *****************************************
diff --git a/src/server/game/Spells/SpellDefines.h b/src/server/game/Spells/SpellDefines.h
index f651339e1f8..6703e28a61a 100644
--- a/src/server/game/Spells/SpellDefines.h
+++ b/src/server/game/Spells/SpellDefines.h
@@ -489,6 +489,8 @@ struct SpellCastVisual
 
 class ProcFlagsInit : public FlagsArray<int32, 2>
 {
+    using Base = FlagsArray<int32, 2>;
+
 public:
     constexpr ProcFlagsInit(ProcFlags procFlags = {}, ProcFlags2 procFlags2 = {})
     {
@@ -507,6 +509,27 @@ public:
         _storage[1] |= int32(procFlags2);
         return *this;
     }
+
+    using Base::operator&;
+
+    constexpr ProcFlags operator&(ProcFlags procFlags) const
+    {
+        return static_cast<ProcFlags>(_storage[0] & procFlags);
+    }
+
+    constexpr ProcFlags2 operator&(ProcFlags2 procFlags2) const
+    {
+        return static_cast<ProcFlags2>(_storage[1] & procFlags2);
+    }
+
+    using Base::operator=;
+
+    constexpr ProcFlagsInit& operator=(Base const& right)
+    {
+        _storage[0] = right[0];
+        _storage[1] = right[1];
+        return *this;
+    }
 };
 
 #endif
diff --git a/src/server/game/Spells/SpellInfo.h b/src/server/game/Spells/SpellInfo.h
index 94b2d8dd0e7..a2b1070903f 100644
--- a/src/server/game/Spells/SpellInfo.h
+++ b/src/server/game/Spells/SpellInfo.h
@@ -382,7 +382,7 @@ class TC_GAME_API SpellInfo
         EnumFlag<SpellAuraInterruptFlags2> AuraInterruptFlags2 = SpellAuraInterruptFlags2::None;
         EnumFlag<SpellAuraInterruptFlags> ChannelInterruptFlags = SpellAuraInterruptFlags::None;
         EnumFlag<SpellAuraInterruptFlags2> ChannelInterruptFlags2 = SpellAuraInterruptFlags2::None;
-        FlagsArray<int32, 2> ProcFlags;
+        ProcFlagsInit ProcFlags;
         uint32 ProcChance = 0;
         uint32 ProcCharges = 0;
         uint32 ProcCooldown = 0;
diff --git a/src/server/game/Spells/SpellMgr.cpp b/src/server/game/Spells/SpellMgr.cpp
index 64533be0a58..864985a6444 100644
--- a/src/server/game/Spells/SpellMgr.cpp
+++ b/src/server/game/Spells/SpellMgr.cpp
@@ -1520,7 +1520,7 @@ void SpellMgr::LoadSpellProcs()
 
             SpellProcEntry baseProcEntry;
 
-            baseProcEntry.SchoolMask         = fields[1].GetInt8();
+            baseProcEntry.SchoolMask         = fields[1].GetUInt8();
             baseProcEntry.SpellFamilyName    = fields[2].GetUInt16();
             baseProcEntry.SpellFamilyMask[0] = fields[3].GetUInt32();
             baseProcEntry.SpellFamilyMask[1] = fields[4].GetUInt32();
@@ -1528,10 +1528,10 @@ void SpellMgr::LoadSpellProcs()
             baseProcEntry.SpellFamilyMask[3] = fields[6].GetUInt32();
             baseProcEntry.ProcFlags[0]       = fields[7].GetUInt32();
             baseProcEntry.ProcFlags[1]       = fields[8].GetUInt32();
-            baseProcEntry.SpellTypeMask      = fields[9].GetUInt32();
-            baseProcEntry.SpellPhaseMask     = fields[10].GetUInt32();
-            baseProcEntry.HitMask            = fields[11].GetUInt32();
-            baseProcEntry.AttributesMask     = fields[12].GetUInt32();
+            baseProcEntry.SpellTypeMask      = ProcFlagsSpellType(fields[9].GetUInt32());
+            baseProcEntry.SpellPhaseMask     = ProcFlagsSpellPhase(fields[10].GetUInt32());
+            baseProcEntry.HitMask            = ProcFlagsHit(fields[11].GetUInt32());
+            baseProcEntry.AttributesMask     = ProcAttributes(fields[12].GetUInt32());
             baseProcEntry.DisableEffectsMask = fields[13].GetUInt32();
             baseProcEntry.ProcsPerMinute     = fields[14].GetFloat();
             baseProcEntry.Chance             = fields[15].GetFloat();
@@ -1637,7 +1637,7 @@ void SpellMgr::LoadSpellProcs()
     // Triggered always, even from triggered spells
     bool isAlwaysTriggeredAura[TOTAL_AURAS];
     // SpellTypeMask to add to the proc
-    uint32 spellTypeMask[TOTAL_AURAS];
+    ProcFlagsSpellType spellTypeMask[TOTAL_AURAS];
 
     // List of auras that CAN trigger but may not exist in spell_proc
     // in most cases needed to drop charges
@@ -1738,7 +1738,7 @@ void SpellMgr::LoadSpellProcs()
             continue;
 
         bool addTriggerFlag = false;
-        uint32 procSpellTypeMask = PROC_SPELL_TYPE_NONE;
+        ProcFlagsSpellType procSpellTypeMask = PROC_SPELL_TYPE_NONE;
         uint32 nonProcMask = 0;
         for (SpellEffectInfo const& spellEffectInfo : spellInfo.GetEffects())
         {
@@ -1837,7 +1837,7 @@ void SpellMgr::LoadSpellProcs()
             break;
         }
 
-        procEntry.AttributesMask  = 0;
+        procEntry.AttributesMask  = PROC_ATTR_NONE;
         procEntry.DisableEffectsMask = nonProcMask;
         if (spellInfo.ProcFlags & PROC_FLAG_KILL)
             procEntry.AttributesMask |= PROC_ATTR_REQ_EXP_OR_HONOR;
diff --git a/src/server/game/Spells/SpellMgr.h b/src/server/game/Spells/SpellMgr.h
index e096ac22d87..8ee2aed0b81 100644
--- a/src/server/game/Spells/SpellMgr.h
+++ b/src/server/game/Spells/SpellMgr.h
@@ -28,6 +28,7 @@
 #include "IteratorPair.h"
 #include "RaceMask.h"
 #include "SharedDefines.h"
+#include "SpellDefines.h"
 
 #include <functional>
 #include <map>
@@ -240,7 +241,7 @@ DEFINE_ENUM_FLAG(ProcFlags2);
                                   PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS | \
                                   PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS)
 
-enum ProcFlagsSpellType
+enum ProcFlagsSpellType : uint32
 {
     PROC_SPELL_TYPE_NONE              = 0x0000000,
     PROC_SPELL_TYPE_DAMAGE            = 0x0000001, // damage type of spell
@@ -249,7 +250,9 @@ enum ProcFlagsSpellType
     PROC_SPELL_TYPE_MASK_ALL          = PROC_SPELL_TYPE_DAMAGE | PROC_SPELL_TYPE_HEAL | PROC_SPELL_TYPE_NO_DMG_HEAL
 };
 
-enum ProcFlagsSpellPhase
+DEFINE_ENUM_FLAG(ProcFlagsSpellType);
+
+enum ProcFlagsSpellPhase : uint32
 {
     PROC_SPELL_PHASE_NONE             = 0x0000000,
     PROC_SPELL_PHASE_CAST             = 0x0000001,
@@ -258,7 +261,9 @@ enum ProcFlagsSpellPhase
     PROC_SPELL_PHASE_MASK_ALL         = PROC_SPELL_PHASE_CAST | PROC_SPELL_PHASE_HIT | PROC_SPELL_PHASE_FINISH
 };
 
-enum ProcFlagsHit
+DEFINE_ENUM_FLAG(ProcFlagsSpellPhase);
+
+enum ProcFlagsHit : uint32
 {
     PROC_HIT_NONE                = 0x0000000, // no value - PROC_HIT_NORMAL | PROC_HIT_CRITICAL for TAKEN proc type, PROC_HIT_NORMAL | PROC_HIT_CRITICAL | PROC_HIT_ABSORB for DONE
     PROC_HIT_NORMAL              = 0x0000001, // non-critical hits
@@ -278,8 +283,11 @@ enum ProcFlagsHit
     PROC_HIT_MASK_ALL            = 0x0003FFF
 };
 
-enum ProcAttributes
+DEFINE_ENUM_FLAG(ProcFlagsHit);
+
+enum ProcAttributes : uint32
 {
+    PROC_ATTR_NONE                      = 0x0000000,
     PROC_ATTR_REQ_EXP_OR_HONOR          = 0x0000001, // requires proc target to give exp or honor for aura proc
     PROC_ATTR_TRIGGERED_CAN_PROC        = 0x0000002, // aura can proc even with triggered spells
     PROC_ATTR_REQ_POWER_COST            = 0x0000004, // requires triggering spell to have a power cost for aura proc
@@ -291,6 +299,8 @@ enum ProcAttributes
     PROC_ATTR_CANT_PROC_FROM_ITEM_CAST  = 0x0000100, // do not allow aura proc if proc is caused by a spell casted by item
 };
 
+DEFINE_ENUM_FLAG(ProcAttributes);
+
 #define PROC_ATTR_ALL_ALLOWED (PROC_ATTR_REQ_EXP_OR_HONOR       | \
                                PROC_ATTR_TRIGGERED_CAN_PROC     | \
                                PROC_ATTR_REQ_POWER_COST         | \
@@ -300,19 +310,19 @@ enum ProcAttributes
 
 struct SpellProcEntry
 {
-    uint32 SchoolMask;              // if nonzero - bitmask for matching proc condition based on spell's school
-    uint32 SpellFamilyName;         // if nonzero - for matching proc condition based on candidate spell's SpellFamilyName
-    flag128 SpellFamilyMask;        // if nonzero - bitmask for matching proc condition based on candidate spell's SpellFamilyFlags
-    FlagsArray<int32, 2> ProcFlags; // if nonzero - owerwrite procFlags field for given Spell.dbc entry, bitmask for matching proc condition, see enum ProcFlags
-    uint32 SpellTypeMask;           // if nonzero - bitmask for matching proc condition based on candidate spell's damage/heal effects, see enum ProcFlagsSpellType
-    uint32 SpellPhaseMask;          // if nonzero - bitmask for matching phase of a spellcast on which proc occurs, see enum ProcFlagsSpellPhase
-    uint32 HitMask;                 // if nonzero - bitmask for matching proc condition based on hit result, see enum ProcFlagsHit
-    uint32 AttributesMask;          // bitmask, see ProcAttributes
-    uint32 DisableEffectsMask;      // bitmask
-    float ProcsPerMinute;           // if nonzero - chance to proc is equal to value * aura caster's weapon speed / 60
-    float Chance;                   // if nonzero - owerwrite procChance field for given Spell.dbc entry, defines chance of proc to occur, not used if ProcsPerMinute set
-    Milliseconds Cooldown;          // if nonzero - cooldown in secs for aura proc, applied to aura
-    uint32 Charges;                 // if nonzero - owerwrite procCharges field for given Spell.dbc entry, defines how many times proc can occur before aura remove, 0 - infinite
+    uint32 SchoolMask = 0;                                      // if nonzero - bitmask for matching proc condition based on spell's school
+    uint32 SpellFamilyName = 0;                                 // if nonzero - for matching proc condition based on candidate spell's SpellFamilyName
+    flag128 SpellFamilyMask;                                    // if nonzero - bitmask for matching proc condition based on candidate spell's SpellFamilyFlags
+    ProcFlagsInit ProcFlags;                                    // if nonzero - overwrite procFlags field for given Spell.dbc entry, bitmask for matching proc condition, see enum ProcFlags
+    ProcFlagsSpellType SpellTypeMask = PROC_SPELL_TYPE_NONE;    // if nonzero - bitmask for matching proc condition based on candidate spell's damage/heal effects, see enum ProcFlagsSpellType
+    ProcFlagsSpellPhase SpellPhaseMask = PROC_SPELL_PHASE_NONE; // if nonzero - bitmask for matching phase of a spellcast on which proc occurs, see enum ProcFlagsSpellPhase
+    ProcFlagsHit HitMask = PROC_HIT_NONE;                       // if nonzero - bitmask for matching proc condition based on hit result, see enum ProcFlagsHit
+    ProcAttributes AttributesMask = PROC_ATTR_NONE;             // bitmask, see ProcAttributes
+    uint32 DisableEffectsMask = 0;                              // bitmask
+    float ProcsPerMinute = 0.0f;                                // if nonzero - chance to proc is equal to value * aura caster's weapon speed / 60
+    float Chance = 0.0f;                                        // if nonzero - owerwrite procChance field for given Spell.dbc entry, defines chance of proc to occur, not used if ProcsPerMinute set
+    Milliseconds Cooldown = 0ms;                                // if nonzero - cooldown in secs for aura proc, applied to aura
+    uint32 Charges = 0;                                         // if nonzero - overwrite procCharges field for given Spell.dbc entry, defines how many times proc can occur before aura remove, 0 - infinite
 };
 
 enum EnchantProcAttributes
@@ -638,7 +648,7 @@ struct SpellInfoLoadHelper
     std::vector<SpellLabelEntry const*> Labels;
     SpellLevelsEntry const* Levels = nullptr;
     SpellMiscEntry const* Misc = nullptr;
-    std::array<SpellPowerEntry const*, MAX_POWERS_PER_SPELL> Powers;
+    std::array<SpellPowerEntry const*, MAX_POWERS_PER_SPELL> Powers = { };
     SpellReagentsEntry const* Reagents = nullptr;
     std::vector<SpellReagentsCurrencyEntry const*> ReagentsCurrency;
     SpellScalingEntry const* Scaling = nullptr;
diff --git a/src/server/scripts/Spells/spell_rogue.cpp b/src/server/scripts/Spells/spell_rogue.cpp
index 852b1613f59..c3a9b8b995c 100644
--- a/src/server/scripts/Spells/spell_rogue.cpp
+++ b/src/server/scripts/Spells/spell_rogue.cpp
@@ -245,7 +245,7 @@ class spell_rog_deadly_poison : public SpellScriptLoader
                                 continue;
 
                             // Do not reproc deadly
-                            if (spellInfo->SpellFamilyFlags == flag128(0x10000, 0x80000, 0, 0))
+                            if (spellInfo->SpellFamilyFlags & flag128(0x10000))
                                 continue;
 
                             if (spellInfo->IsPositive())