Core/Misc: Move (or delete) constructors and destructors to .cpp files (avoids compiling them in every file that includes them)

1 files changed, 171 insertions, 55 deletions

diff --git a/src/server/game/Spells/SpellScript.cpp b/src/server/game/Spells/SpellScript.cpp
index 0029986471a..65adc36a019 100644
--- a/src/server/game/Spells/SpellScript.cpp
+++ b/src/server/game/Spells/SpellScript.cpp
@@ -35,6 +35,12 @@ bool _SpellScript::_Validate(SpellInfo const* entry)
     return true;
 }
 
+_SpellScript::_SpellScript(): m_currentScriptState(SPELL_SCRIPT_STATE_NONE), m_scriptName(nullptr), m_scriptSpellId(0)
+{
+}
+
+_SpellScript::~_SpellScript() = default;
+
 bool _SpellScript::_ValidateSpellInfo(uint32 spellId)
 {
     if (!sSpellMgr->GetSpellInfo(spellId, DIFFICULTY_NONE))
@@ -84,6 +90,10 @@ _SpellScript::EffectHook::EffectHook(uint8 _effIndex)
     effIndex = _effIndex;
 }
 
+_SpellScript::EffectHook::EffectHook(EffectHook&& right) noexcept = default;
+_SpellScript::EffectHook& _SpellScript::EffectHook::operator=(EffectHook&& right) noexcept = default;
+_SpellScript::EffectHook::~EffectHook() = default;
+
 uint32 _SpellScript::EffectHook::GetAffectedEffectsMask(SpellInfo const* spellEntry) const
 {
     uint32 mask = 0;
@@ -121,6 +131,14 @@ std::string _SpellScript::EffectHook::EffIndexToString() const
     return "Invalid Value";
 }
 
+_SpellScript::EffectNameCheck::EffectNameCheck(uint16 _effName) : effName(_effName)
+{
+}
+
+_SpellScript::EffectNameCheck::EffectNameCheck(EffectNameCheck&& right) noexcept = default;
+_SpellScript::EffectNameCheck& _SpellScript::EffectNameCheck::operator=(EffectNameCheck&& right) noexcept = default;
+_SpellScript::EffectNameCheck::~EffectNameCheck() = default;
+
 bool _SpellScript::EffectNameCheck::Check(SpellInfo const* spellEntry, uint8 effIndex) const
 {
     if (spellEntry->GetEffects().size() <= effIndex)
@@ -146,6 +164,14 @@ std::string _SpellScript::EffectNameCheck::ToString() const
     }
 }
 
+_SpellScript::EffectAuraNameCheck::EffectAuraNameCheck(uint16 _effAurName) : effAurName(_effAurName)
+{
+}
+
+_SpellScript::EffectAuraNameCheck::EffectAuraNameCheck(EffectAuraNameCheck&& right) noexcept = default;
+_SpellScript::EffectAuraNameCheck& _SpellScript::EffectAuraNameCheck::operator=(EffectAuraNameCheck&& right) noexcept = default;
+_SpellScript::EffectAuraNameCheck::~EffectAuraNameCheck() = default;
+
 bool _SpellScript::EffectAuraNameCheck::Check(SpellInfo const* spellEntry, uint8 effIndex) const
 {
     if (spellEntry->GetEffects().size() <= effIndex)
@@ -171,42 +197,55 @@ std::string _SpellScript::EffectAuraNameCheck::ToString() const
     }
 }
 
-SpellScript::CastHandler::CastHandler(SpellCastFnType _pCastHandlerScript)
+SpellScript::CastHandler::CastHandler(SpellCastFnType _pCastHandlerScript) : pCastHandlerScript(_pCastHandlerScript)
 {
-    pCastHandlerScript = _pCastHandlerScript;
 }
 
+SpellScript::CastHandler::CastHandler(CastHandler&& right) noexcept = default;
+SpellScript::CastHandler& SpellScript::CastHandler::operator=(CastHandler&& right) noexcept = default;
+SpellScript::CastHandler::~CastHandler() = default;
+
 void SpellScript::CastHandler::Call(SpellScript* spellScript)
 {
     (spellScript->*pCastHandlerScript)();
 }
 
-SpellScript::CheckCastHandler::CheckCastHandler(SpellCheckCastFnType checkCastHandlerScript)
+SpellScript::CheckCastHandler::CheckCastHandler(SpellCheckCastFnType checkCastHandlerScript) : _checkCastHandlerScript(checkCastHandlerScript)
 {
-    _checkCastHandlerScript = checkCastHandlerScript;
 }
 
+SpellScript::CheckCastHandler::CheckCastHandler(CheckCastHandler&& right) noexcept = default;
+SpellScript::CheckCastHandler& SpellScript::CheckCastHandler::operator=(CheckCastHandler&& right) noexcept = default;
+SpellScript::CheckCastHandler::~CheckCastHandler() = default;
+
 SpellCastResult SpellScript::CheckCastHandler::Call(SpellScript* spellScript)
 {
     return (spellScript->*_checkCastHandlerScript)();
 }
 
-SpellScript::OnCalculateResistAbsorbHandler::OnCalculateResistAbsorbHandler(SpellOnResistAbsorbCalculateFnType onResistAbsorbCalculateHandlerScript)
+SpellScript::OnCalculateResistAbsorbHandler::OnCalculateResistAbsorbHandler(SpellOnResistAbsorbCalculateFnType onResistAbsorbCalculateHandlerScript) :
+    pOnCalculateResistAbsorbHandlerScript(onResistAbsorbCalculateHandlerScript)
 {
-    pOnCalculateResistAbsorbHandlerScript = onResistAbsorbCalculateHandlerScript;
 }
 
+SpellScript::OnCalculateResistAbsorbHandler::OnCalculateResistAbsorbHandler(OnCalculateResistAbsorbHandler&& right) noexcept = default;
+SpellScript::OnCalculateResistAbsorbHandler& SpellScript::OnCalculateResistAbsorbHandler::operator=(OnCalculateResistAbsorbHandler&& right) noexcept = default;
+SpellScript::OnCalculateResistAbsorbHandler::~OnCalculateResistAbsorbHandler() = default;
+
 void SpellScript::OnCalculateResistAbsorbHandler::Call(SpellScript* spellScript, DamageInfo const& damageInfo, uint32& resistAmount, int32& absorbAmount)
 {
     return (spellScript->*pOnCalculateResistAbsorbHandlerScript)(damageInfo, resistAmount, absorbAmount);
 }
 
 SpellScript::EffectHandler::EffectHandler(SpellEffectFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
-    : _SpellScript::EffectNameCheck(_effName), _SpellScript::EffectHook(_effIndex)
+    : _SpellScript::EffectNameCheck(_effName), _SpellScript::EffectHook(_effIndex), pEffectHandlerScript(_pEffectHandlerScript)
 {
-    pEffectHandlerScript = _pEffectHandlerScript;
 }
 
+SpellScript::EffectHandler::EffectHandler(EffectHandler&& right) noexcept = default;
+SpellScript::EffectHandler& SpellScript::EffectHandler::operator=(EffectHandler&& right) noexcept = default;
+SpellScript::EffectHandler::~EffectHandler() = default;
+
 std::string SpellScript::EffectHandler::ToString() const
 {
     return "Index: " + EffIndexToString() + " Name: " +_SpellScript::EffectNameCheck::ToString();
@@ -222,31 +261,41 @@ void SpellScript::EffectHandler::Call(SpellScript* spellScript, SpellEffIndex ef
     (spellScript->*pEffectHandlerScript)(effIndexToHandle);
 }
 
-SpellScript::BeforeHitHandler::BeforeHitHandler(SpellBeforeHitFnType pBeforeHitHandlerScript)
+SpellScript::BeforeHitHandler::BeforeHitHandler(SpellBeforeHitFnType pBeforeHitHandlerScript) : _pBeforeHitHandlerScript(pBeforeHitHandlerScript)
 {
-    _pBeforeHitHandlerScript = pBeforeHitHandlerScript;
 }
 
+SpellScript::BeforeHitHandler::BeforeHitHandler(BeforeHitHandler&& right) noexcept = default;
+SpellScript::BeforeHitHandler& SpellScript::BeforeHitHandler::operator=(BeforeHitHandler&& right) noexcept = default;
+SpellScript::BeforeHitHandler::~BeforeHitHandler() = default;
+
 void SpellScript::BeforeHitHandler::Call(SpellScript* spellScript, SpellMissInfo missInfo)
 {
     (spellScript->*_pBeforeHitHandlerScript)(missInfo);
 }
 
-SpellScript::HitHandler::HitHandler(SpellHitFnType _pHitHandlerScript)
+SpellScript::HitHandler::HitHandler(SpellHitFnType _pHitHandlerScript) : pHitHandlerScript(_pHitHandlerScript)
 {
-    pHitHandlerScript = _pHitHandlerScript;
 }
 
+SpellScript::HitHandler::HitHandler(HitHandler&& right) noexcept = default;
+SpellScript::HitHandler& SpellScript::HitHandler::operator=(HitHandler&& right) noexcept = default;
+SpellScript::HitHandler::~HitHandler() = default;
+
 void SpellScript::HitHandler::Call(SpellScript* spellScript)
 {
     (spellScript->*pHitHandlerScript)();
 }
 
-SpellScript::OnCalcCritChanceHandler::OnCalcCritChanceHandler(SpellOnCalcCritChanceFnType onCalcCritChanceHandlerScript)
+SpellScript::OnCalcCritChanceHandler::OnCalcCritChanceHandler(SpellOnCalcCritChanceFnType onCalcCritChanceHandlerScript) : _onCalcCritChanceHandlerScript(
+    onCalcCritChanceHandlerScript)
 {
-    _onCalcCritChanceHandlerScript = onCalcCritChanceHandlerScript;
 }
 
+SpellScript::OnCalcCritChanceHandler::OnCalcCritChanceHandler(OnCalcCritChanceHandler&& right) noexcept = default;
+SpellScript::OnCalcCritChanceHandler& SpellScript::OnCalcCritChanceHandler::operator=(OnCalcCritChanceHandler&& right) noexcept = default;
+SpellScript::OnCalcCritChanceHandler::~OnCalcCritChanceHandler() = default;
+
 void SpellScript::OnCalcCritChanceHandler::Call(SpellScript* spellScript, Unit const* victim, float& critChance) const
 {
     (spellScript->*_onCalcCritChanceHandlerScript)(victim, critChance);
@@ -255,6 +304,10 @@ void SpellScript::OnCalcCritChanceHandler::Call(SpellScript* spellScript, Unit c
 SpellScript::TargetHook::TargetHook(uint8 _effectIndex, uint16 _targetType, bool _area, bool _dest)
     : _SpellScript::EffectHook(_effectIndex), targetType(_targetType), area(_area), dest(_dest) { }
 
+SpellScript::TargetHook::TargetHook(TargetHook&& right) noexcept = default;
+SpellScript::TargetHook& SpellScript::TargetHook::operator=(TargetHook&& right) noexcept = default;
+SpellScript::TargetHook::~TargetHook() = default;
+
 std::string SpellScript::TargetHook::ToString() const
 {
     std::ostringstream oss;
@@ -317,33 +370,42 @@ bool SpellScript::TargetHook::CheckEffect(SpellInfo const* spellEntry, uint8 eff
 }
 
 SpellScript::ObjectAreaTargetSelectHandler::ObjectAreaTargetSelectHandler(SpellObjectAreaTargetSelectFnType _pObjectAreaTargetSelectHandlerScript, uint8 _effIndex, uint16 _targetType)
-    : TargetHook(_effIndex, _targetType, true, false)
+    : TargetHook(_effIndex, _targetType, true, false), pObjectAreaTargetSelectHandlerScript(_pObjectAreaTargetSelectHandlerScript)
 {
-    pObjectAreaTargetSelectHandlerScript = _pObjectAreaTargetSelectHandlerScript;
 }
 
+SpellScript::ObjectAreaTargetSelectHandler::ObjectAreaTargetSelectHandler(ObjectAreaTargetSelectHandler&& right) noexcept = default;
+SpellScript::ObjectAreaTargetSelectHandler& SpellScript::ObjectAreaTargetSelectHandler::operator=(ObjectAreaTargetSelectHandler&& right) noexcept = default;
+SpellScript::ObjectAreaTargetSelectHandler::~ObjectAreaTargetSelectHandler() = default;
+
 void SpellScript::ObjectAreaTargetSelectHandler::Call(SpellScript* spellScript, std::list<WorldObject*>& targets)
 {
     (spellScript->*pObjectAreaTargetSelectHandlerScript)(targets);
 }
 
 SpellScript::ObjectTargetSelectHandler::ObjectTargetSelectHandler(SpellObjectTargetSelectFnType _pObjectTargetSelectHandlerScript, uint8 _effIndex, uint16 _targetType)
-    : TargetHook(_effIndex, _targetType, false, false)
+    : TargetHook(_effIndex, _targetType, false, false), pObjectTargetSelectHandlerScript(_pObjectTargetSelectHandlerScript)
 {
-    pObjectTargetSelectHandlerScript = _pObjectTargetSelectHandlerScript;
 }
 
+SpellScript::ObjectTargetSelectHandler::ObjectTargetSelectHandler(ObjectTargetSelectHandler&& right) noexcept = default;
+SpellScript::ObjectTargetSelectHandler& SpellScript::ObjectTargetSelectHandler::operator=(ObjectTargetSelectHandler&& right) noexcept = default;
+SpellScript::ObjectTargetSelectHandler::~ObjectTargetSelectHandler() = default;
+
 void SpellScript::ObjectTargetSelectHandler::Call(SpellScript* spellScript, WorldObject*& target)
 {
     (spellScript->*pObjectTargetSelectHandlerScript)(target);
 }
 
 SpellScript::DestinationTargetSelectHandler::DestinationTargetSelectHandler(SpellDestinationTargetSelectFnType _DestinationTargetSelectHandlerScript, uint8 _effIndex, uint16 _targetType)
-    : TargetHook(_effIndex, _targetType, false, true)
+    : TargetHook(_effIndex, _targetType, false, true), DestinationTargetSelectHandlerScript(_DestinationTargetSelectHandlerScript)
 {
-    DestinationTargetSelectHandlerScript = _DestinationTargetSelectHandlerScript;
 }
 
+SpellScript::DestinationTargetSelectHandler::DestinationTargetSelectHandler(DestinationTargetSelectHandler&& right) noexcept = default;
+SpellScript::DestinationTargetSelectHandler& SpellScript::DestinationTargetSelectHandler::operator=(DestinationTargetSelectHandler&& right) noexcept = default;
+SpellScript::DestinationTargetSelectHandler::~DestinationTargetSelectHandler() = default;
+
 void SpellScript::DestinationTargetSelectHandler::Call(SpellScript* spellScript, SpellDestination& target)
 {
     (spellScript->*DestinationTargetSelectHandlerScript)(target);
@@ -928,21 +990,27 @@ bool AuraScript::_Validate(SpellInfo const* entry)
     return _SpellScript::_Validate(entry);
 }
 
-AuraScript::CheckAreaTargetHandler::CheckAreaTargetHandler(AuraCheckAreaTargetFnType _pHandlerScript)
+AuraScript::CheckAreaTargetHandler::CheckAreaTargetHandler(AuraCheckAreaTargetFnType _pHandlerScript) : pHandlerScript(_pHandlerScript)
 {
-    pHandlerScript = _pHandlerScript;
 }
 
+AuraScript::CheckAreaTargetHandler::CheckAreaTargetHandler(CheckAreaTargetHandler&& right) noexcept = default;
+AuraScript::CheckAreaTargetHandler& AuraScript::CheckAreaTargetHandler::operator=(CheckAreaTargetHandler&& right) noexcept = default;
+AuraScript::CheckAreaTargetHandler::~CheckAreaTargetHandler() = default;
+
 bool AuraScript::CheckAreaTargetHandler::Call(AuraScript* auraScript, Unit* _target)
 {
     return (auraScript->*pHandlerScript)(_target);
 }
 
-AuraScript::AuraDispelHandler::AuraDispelHandler(AuraDispelFnType _pHandlerScript)
+AuraScript::AuraDispelHandler::AuraDispelHandler(AuraDispelFnType _pHandlerScript) : pHandlerScript(_pHandlerScript)
 {
-    pHandlerScript = _pHandlerScript;
 }
 
+AuraScript::AuraDispelHandler::AuraDispelHandler(AuraDispelHandler&& right) noexcept = default;
+AuraScript::AuraDispelHandler& AuraScript::AuraDispelHandler::operator=(AuraDispelHandler&& right) noexcept = default;
+AuraScript::AuraDispelHandler::~AuraDispelHandler() = default;
+
 void AuraScript::AuraDispelHandler::Call(AuraScript* auraScript, DispelInfo* _dispelInfo)
 {
     (auraScript->*pHandlerScript)(_dispelInfo);
@@ -951,6 +1019,10 @@ void AuraScript::AuraDispelHandler::Call(AuraScript* auraScript, DispelInfo* _di
 AuraScript::EffectBase::EffectBase(uint8 _effIndex, uint16 _effName)
     : _SpellScript::EffectAuraNameCheck(_effName), _SpellScript::EffectHook(_effIndex) { }
 
+AuraScript::EffectBase::EffectBase(EffectBase&& right) noexcept = default;
+AuraScript::EffectBase& AuraScript::EffectBase::operator=(EffectBase&& right) noexcept = default;
+AuraScript::EffectBase::~EffectBase() = default;
+
 bool AuraScript::EffectBase::CheckEffect(SpellInfo const* spellEntry, uint8 effIndexToCheck) const
 {
     return _SpellScript::EffectAuraNameCheck::Check(spellEntry, effIndexToCheck);
@@ -962,78 +1034,98 @@ std::string AuraScript::EffectBase::ToString() const
 }
 
 AuraScript::EffectPeriodicHandler::EffectPeriodicHandler(AuraEffectPeriodicFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
-    : AuraScript::EffectBase(_effIndex, _effName)
+    : AuraScript::EffectBase(_effIndex, _effName), pEffectHandlerScript(_pEffectHandlerScript)
 {
-    pEffectHandlerScript = _pEffectHandlerScript;
 }
 
+AuraScript::EffectPeriodicHandler::EffectPeriodicHandler(EffectPeriodicHandler&& right) noexcept = default;
+AuraScript::EffectPeriodicHandler& AuraScript::EffectPeriodicHandler::operator=(EffectPeriodicHandler&& right) noexcept = default;
+AuraScript::EffectPeriodicHandler::~EffectPeriodicHandler() = default;
+
 void AuraScript::EffectPeriodicHandler::Call(AuraScript* auraScript, AuraEffect const* _aurEff)
 {
     (auraScript->*pEffectHandlerScript)(_aurEff);
 }
 
 AuraScript::EffectUpdatePeriodicHandler::EffectUpdatePeriodicHandler(AuraEffectUpdatePeriodicFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
-    : AuraScript::EffectBase(_effIndex, _effName)
+    : AuraScript::EffectBase(_effIndex, _effName), pEffectHandlerScript(_pEffectHandlerScript)
 {
-    pEffectHandlerScript = _pEffectHandlerScript;
 }
 
+AuraScript::EffectUpdatePeriodicHandler::EffectUpdatePeriodicHandler(EffectUpdatePeriodicHandler&& right) noexcept = default;
+AuraScript::EffectUpdatePeriodicHandler& AuraScript::EffectUpdatePeriodicHandler::operator=(EffectUpdatePeriodicHandler&& right) noexcept = default;
+AuraScript::EffectUpdatePeriodicHandler::~EffectUpdatePeriodicHandler() = default;
+
 void AuraScript::EffectUpdatePeriodicHandler::Call(AuraScript* auraScript, AuraEffect* aurEff)
 {
     (auraScript->*pEffectHandlerScript)(aurEff);
 }
 
 AuraScript::EffectCalcAmountHandler::EffectCalcAmountHandler(AuraEffectCalcAmountFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
-    : AuraScript::EffectBase(_effIndex, _effName)
+    : AuraScript::EffectBase(_effIndex, _effName), pEffectHandlerScript(_pEffectHandlerScript)
 {
-    pEffectHandlerScript = _pEffectHandlerScript;
 }
 
+AuraScript::EffectCalcAmountHandler::EffectCalcAmountHandler(EffectCalcAmountHandler&& right) noexcept = default;
+AuraScript::EffectCalcAmountHandler& AuraScript::EffectCalcAmountHandler::operator=(EffectCalcAmountHandler&& right) noexcept = default;
+AuraScript::EffectCalcAmountHandler::~EffectCalcAmountHandler() = default;
+
 void AuraScript::EffectCalcAmountHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated)
 {
     (auraScript->*pEffectHandlerScript)(aurEff, amount, canBeRecalculated);
 }
 
 AuraScript::EffectCalcPeriodicHandler::EffectCalcPeriodicHandler(AuraEffectCalcPeriodicFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
-    : AuraScript::EffectBase(_effIndex, _effName)
+    : AuraScript::EffectBase(_effIndex, _effName), pEffectHandlerScript(_pEffectHandlerScript)
 {
-    pEffectHandlerScript = _pEffectHandlerScript;
 }
 
+AuraScript::EffectCalcPeriodicHandler::EffectCalcPeriodicHandler(EffectCalcPeriodicHandler&& right) noexcept = default;
+AuraScript::EffectCalcPeriodicHandler& AuraScript::EffectCalcPeriodicHandler::operator=(EffectCalcPeriodicHandler&& right) noexcept = default;
+AuraScript::EffectCalcPeriodicHandler::~EffectCalcPeriodicHandler() = default;
+
 void AuraScript::EffectCalcPeriodicHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer)
 {
     (auraScript->*pEffectHandlerScript)(aurEff, isPeriodic, periodicTimer);
 }
 
 AuraScript::EffectCalcSpellModHandler::EffectCalcSpellModHandler(AuraEffectCalcSpellModFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
-    : AuraScript::EffectBase(_effIndex, _effName)
+    : AuraScript::EffectBase(_effIndex, _effName), pEffectHandlerScript(_pEffectHandlerScript)
 {
-    pEffectHandlerScript = _pEffectHandlerScript;
 }
 
+AuraScript::EffectCalcSpellModHandler::EffectCalcSpellModHandler(EffectCalcSpellModHandler&& right) noexcept = default;
+AuraScript::EffectCalcSpellModHandler& AuraScript::EffectCalcSpellModHandler::operator=(EffectCalcSpellModHandler&& right) noexcept = default;
+AuraScript::EffectCalcSpellModHandler::~EffectCalcSpellModHandler() = default;
+
 void AuraScript::EffectCalcSpellModHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, SpellModifier*& spellMod)
 {
     (auraScript->*pEffectHandlerScript)(aurEff, spellMod);
 }
 
 AuraScript::EffectCalcCritChanceHandler::EffectCalcCritChanceHandler(AuraEffectCalcCritChanceFnType effectHandlerScript, uint8 effIndex, uint16 effName)
-    : AuraScript::EffectBase(effIndex, effName)
+    : AuraScript::EffectBase(effIndex, effName), _effectHandlerScript(effectHandlerScript)
 {
-    _effectHandlerScript = effectHandlerScript;
 }
 
+AuraScript::EffectCalcCritChanceHandler::EffectCalcCritChanceHandler(EffectCalcCritChanceHandler&& right) noexcept = default;
+AuraScript::EffectCalcCritChanceHandler& AuraScript::EffectCalcCritChanceHandler::operator=(EffectCalcCritChanceHandler&& right) noexcept = default;
+AuraScript::EffectCalcCritChanceHandler::~EffectCalcCritChanceHandler() = default;
+
 void AuraScript::EffectCalcCritChanceHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, Unit const* victim, float& critChance) const
 {
     (auraScript->*_effectHandlerScript)(aurEff, victim, critChance);
 }
 
 AuraScript::EffectApplyHandler::EffectApplyHandler(AuraEffectApplicationModeFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName, AuraEffectHandleModes _mode)
-    : AuraScript::EffectBase(_effIndex, _effName)
+    : AuraScript::EffectBase(_effIndex, _effName), pEffectHandlerScript(_pEffectHandlerScript), mode(_mode)
 {
-    pEffectHandlerScript = _pEffectHandlerScript;
-    mode = _mode;
 }
 
+AuraScript::EffectApplyHandler::EffectApplyHandler(EffectApplyHandler&& right) noexcept = default;
+AuraScript::EffectApplyHandler& AuraScript::EffectApplyHandler::operator=(EffectApplyHandler&& right) noexcept = default;
+AuraScript::EffectApplyHandler::~EffectApplyHandler() = default;
+
 void AuraScript::EffectApplyHandler::Call(AuraScript* auraScript, AuraEffect const* _aurEff, AuraEffectHandleModes _mode)
 {
     if (_mode & mode)
@@ -1041,85 +1133,109 @@ void AuraScript::EffectApplyHandler::Call(AuraScript* auraScript, AuraEffect con
 }
 
 AuraScript::EffectAbsorbHandler::EffectAbsorbHandler(AuraEffectAbsorbFnType _pEffectHandlerScript, uint8 _effIndex, bool overKill)
-    : AuraScript::EffectBase(_effIndex, overKill ? SPELL_AURA_SCHOOL_ABSORB_OVERKILL : SPELL_AURA_SCHOOL_ABSORB)
+    : AuraScript::EffectBase(_effIndex, overKill ? SPELL_AURA_SCHOOL_ABSORB_OVERKILL : SPELL_AURA_SCHOOL_ABSORB), pEffectHandlerScript(_pEffectHandlerScript)
 {
-    pEffectHandlerScript = _pEffectHandlerScript;
 }
 
+AuraScript::EffectAbsorbHandler::EffectAbsorbHandler(EffectAbsorbHandler&& right) noexcept = default;
+AuraScript::EffectAbsorbHandler& AuraScript::EffectAbsorbHandler::operator=(EffectAbsorbHandler&& right) noexcept = default;
+AuraScript::EffectAbsorbHandler::~EffectAbsorbHandler() = default;
+
 void AuraScript::EffectAbsorbHandler::Call(AuraScript* auraScript, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)
 {
     (auraScript->*pEffectHandlerScript)(aurEff, dmgInfo, absorbAmount);
 }
 
 AuraScript::EffectManaShieldHandler::EffectManaShieldHandler(AuraEffectAbsorbFnType _pEffectHandlerScript, uint8 _effIndex)
-    : AuraScript::EffectBase(_effIndex, SPELL_AURA_MANA_SHIELD)
+    : AuraScript::EffectBase(_effIndex, SPELL_AURA_MANA_SHIELD), pEffectHandlerScript(_pEffectHandlerScript)
 {
-    pEffectHandlerScript = _pEffectHandlerScript;
 }
 
+AuraScript::EffectManaShieldHandler::EffectManaShieldHandler(EffectManaShieldHandler&& right) noexcept = default;
+AuraScript::EffectManaShieldHandler& AuraScript::EffectManaShieldHandler::operator=(EffectManaShieldHandler&& right) noexcept = default;
+AuraScript::EffectManaShieldHandler::~EffectManaShieldHandler() = default;
+
 void AuraScript::EffectManaShieldHandler::Call(AuraScript* auraScript, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)
 {
     (auraScript->*pEffectHandlerScript)(aurEff, dmgInfo, absorbAmount);
 }
 
 AuraScript::EffectSplitHandler::EffectSplitHandler(AuraEffectSplitFnType _pEffectHandlerScript, uint8 _effIndex)
-    : AuraScript::EffectBase(_effIndex, SPELL_AURA_SPLIT_DAMAGE_PCT)
+    : AuraScript::EffectBase(_effIndex, SPELL_AURA_SPLIT_DAMAGE_PCT), pEffectHandlerScript(_pEffectHandlerScript)
 {
-    pEffectHandlerScript = _pEffectHandlerScript;
 }
 
+AuraScript::EffectSplitHandler::EffectSplitHandler(EffectSplitHandler&& right) noexcept = default;
+AuraScript::EffectSplitHandler& AuraScript::EffectSplitHandler::operator=(EffectSplitHandler&& right) noexcept = default;
+AuraScript::EffectSplitHandler::~EffectSplitHandler() = default;
+
 void AuraScript::EffectSplitHandler::Call(AuraScript* auraScript, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& splitAmount)
 {
     (auraScript->*pEffectHandlerScript)(aurEff, dmgInfo, splitAmount);
 }
 
-AuraScript::CheckProcHandler::CheckProcHandler(AuraCheckProcFnType handlerScript)
+AuraScript::CheckProcHandler::CheckProcHandler(AuraCheckProcFnType handlerScript) : _HandlerScript(handlerScript)
 {
-    _HandlerScript = handlerScript;
 }
 
+AuraScript::CheckProcHandler::CheckProcHandler(CheckProcHandler&& right) noexcept = default;
+AuraScript::CheckProcHandler& AuraScript::CheckProcHandler::operator=(CheckProcHandler&& right) noexcept = default;
+AuraScript::CheckProcHandler::~CheckProcHandler() = default;
+
 bool AuraScript::CheckProcHandler::Call(AuraScript* auraScript, ProcEventInfo& eventInfo)
 {
     return (auraScript->*_HandlerScript)(eventInfo);
 }
 
 AuraScript::CheckEffectProcHandler::CheckEffectProcHandler(AuraCheckEffectProcFnType handlerScript, uint8 effIndex, uint16 effName)
-    : AuraScript::EffectBase(effIndex, effName)
+    : AuraScript::EffectBase(effIndex, effName), _HandlerScript(handlerScript)
 {
-    _HandlerScript = handlerScript;
 }
 
+AuraScript::CheckEffectProcHandler::CheckEffectProcHandler(CheckEffectProcHandler&& right) noexcept = default;
+AuraScript::CheckEffectProcHandler& AuraScript::CheckEffectProcHandler::operator=(CheckEffectProcHandler&& right) noexcept = default;
+AuraScript::CheckEffectProcHandler::~CheckEffectProcHandler() = default;
+
 bool AuraScript::CheckEffectProcHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, ProcEventInfo& eventInfo)
 {
     return (auraScript->*_HandlerScript)(aurEff, eventInfo);
 }
 
-AuraScript::AuraProcHandler::AuraProcHandler(AuraProcFnType handlerScript)
+AuraScript::AuraProcHandler::AuraProcHandler(AuraProcFnType handlerScript) : _HandlerScript(handlerScript)
 {
-    _HandlerScript = handlerScript;
 }
 
+AuraScript::AuraProcHandler::AuraProcHandler(AuraProcHandler&& right) noexcept = default;
+AuraScript::AuraProcHandler& AuraScript::AuraProcHandler::operator=(AuraProcHandler&& right) noexcept = default;
+AuraScript::AuraProcHandler::~AuraProcHandler() = default;
+
 void AuraScript::AuraProcHandler::Call(AuraScript* auraScript, ProcEventInfo& eventInfo)
 {
     (auraScript->*_HandlerScript)(eventInfo);
 }
 
 AuraScript::EffectProcHandler::EffectProcHandler(AuraEffectProcFnType effectHandlerScript, uint8 effIndex, uint16 effName)
-    : AuraScript::EffectBase(effIndex, effName)
+    : AuraScript::EffectBase(effIndex, effName), _EffectHandlerScript(effectHandlerScript)
 {
-    _EffectHandlerScript = effectHandlerScript;
 }
 
+AuraScript::EffectProcHandler::EffectProcHandler(EffectProcHandler&& right) noexcept = default;
+AuraScript::EffectProcHandler& AuraScript::EffectProcHandler::operator=(EffectProcHandler&& right) noexcept = default;
+AuraScript::EffectProcHandler::~EffectProcHandler() = default;
+
 void AuraScript::EffectProcHandler::Call(AuraScript* auraScript, AuraEffect* aurEff, ProcEventInfo& eventInfo)
 {
     (auraScript->*_EffectHandlerScript)(aurEff, eventInfo);
 }
 
-AuraScript::EnterLeaveCombatHandler::EnterLeaveCombatHandler(AuraEnterLeaveCombatFnType handlerScript)
+AuraScript::EnterLeaveCombatHandler::EnterLeaveCombatHandler(AuraEnterLeaveCombatFnType handlerScript) : _handlerScript(handlerScript)
 {
-    _handlerScript = handlerScript;
 }
 
+AuraScript::EnterLeaveCombatHandler::EnterLeaveCombatHandler(EnterLeaveCombatHandler&& right) noexcept = default;
+AuraScript::EnterLeaveCombatHandler& AuraScript::EnterLeaveCombatHandler::operator=(EnterLeaveCombatHandler&& right) noexcept = default;
+AuraScript::EnterLeaveCombatHandler::~EnterLeaveCombatHandler() = default;
+
 void AuraScript::EnterLeaveCombatHandler::Call(AuraScript* auraScript, bool isNowInCombat) const
 {
     (auraScript->*_handlerScript)(isNowInCombat);