Scripts/Spells: Refactor spell script internals to fix -Wcast-function-type-mismatch warning

18 files changed, 495 insertions, 968 deletions

diff --git a/src/server/game/Spells/SpellScript.h b/src/server/game/Spells/SpellScript.h
index 8a85e7e2a03..77c5c512fc7 100644
--- a/src/server/game/Spells/SpellScript.h
+++ b/src/server/game/Spells/SpellScript.h
@@ -134,9 +134,46 @@ protected:
         using type = Class;
     };
 
+    template<typename Return, typename Class, typename... Args>
+    struct GetScriptClass<Return(*)(Class&, Args...)>
+    {
+        using type = std::remove_const_t<Class>;
+    };
+
     template<typename ScriptFunc>
     using GetScriptClass_t = typename GetScriptClass<ScriptFunc>::type;
 
+    template <typename Ret, typename BaseClass, typename... Args>
+    struct ScriptFuncInvoker
+    {
+        union SizeAndAlignment
+        {
+            Ret(BaseClass::* Member)(Args...);
+            Ret(* Static)(BaseClass&, Args...);
+        };
+
+        static constexpr std::size_t Size = sizeof(SizeAndAlignment);
+        static constexpr std::size_t Alignment = alignof(SizeAndAlignment);
+
+        struct alignas(Alignment) StorageType : std::array<std::byte, Size> { };
+
+        template <typename ScriptFunc>
+        struct Impl
+        {
+            using ScriptClass = GetScriptClass_t<ScriptFunc>;
+
+            static Ret Invoke(BaseClass& script, Args... args, StorageType callImpl)
+            {
+                return std::invoke(reinterpret_cast<Impl const*>(callImpl.data())->Func, static_cast<ScriptClass&>(script), args...);
+            }
+
+            ScriptFunc Func;
+        };
+
+        StorageType ImplStorage;
+        Ret(* Thunk)(BaseClass&, Args..., StorageType);
+    };
+
     uint8 m_currentScriptState;
     std::string_view m_scriptName;
     uint32 m_scriptSpellId;
@@ -257,91 +294,68 @@ class TC_GAME_API SpellScript : public SpellScriptBase
 {
     // internal use classes & functions
     // DO NOT OVERRIDE THESE IN SCRIPTS
+    template <typename Ret, typename... Args>
+    using ScriptFuncInvoker = SpellScriptBase::ScriptFuncInvoker<Ret, SpellScript, Args...>;
+
 public:
     class CastHandler final
     {
     public:
-        using SpellCastFnType = void(SpellScript::*)();
-
-        using SafeWrapperType = void(*)(SpellScript* spellScript, SpellCastFnType callImpl);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<void>;
 
         template<typename ScriptFunc>
         explicit CastHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(SpellCastFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(SpellCastFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass>,
-                "CastHandler signature must be \"void HandleCast()\"");
+            static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&>,
+                R""(CastHandler signature must be "void HandleCast()")"");
 
-            _callImpl = reinterpret_cast<SpellCastFnType>(handler);
-            _safeWrapper = [](SpellScript* spellScript, SpellCastFnType callImpl) -> void
-            {
-                return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl))();
-            };
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(SpellScript* spellScript) const
         {
-            return _safeWrapper(spellScript, _callImpl);
+            return _invoker.Thunk(*spellScript, _invoker.ImplStorage);
         }
     private:
-        SpellCastFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class CheckCastHandler final
     {
     public:
-        union SpellCheckCastFnType
-        {
-            SpellCastResult(SpellScript::* Member)();
-            SpellCastResult(*Static)();
-        };
-
-        using SafeWrapperType = SpellCastResult(*)(SpellScript* spellScript, SpellCheckCastFnType callImpl);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<SpellCastResult>;
 
         template<typename ScriptFunc>
         explicit CheckCastHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(SpellCheckCastFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(SpellCheckCastFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<SpellCastResult, ScriptFunc, ScriptClass>,
-                    "CheckCastHandler signature must be \"SpellCastResult CheckCast()\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(SpellCheckCastFnType::Member)>(handler) };
-                _safeWrapper = [](SpellScript* spellScript, SpellCheckCastFnType callImpl) -> SpellCastResult
-                {
-                    return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))();
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<SpellCastResult, ScriptFunc, ScriptClass&>,
+                    R""(CheckCastHandler signature must be "SpellCastResult CheckCast()")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<SpellCastResult, ScriptFunc>,
-                   "CheckCastHandler signature must be \"static SpellCastResult CheckCast()\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(SpellCheckCastFnType::Static)>(handler) };
-                _safeWrapper = [](SpellScript* /*spellScript*/, SpellCheckCastFnType callImpl) -> SpellCastResult
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)();
-                };
-            }
+                static_assert(std::is_invocable_r_v<SpellCastResult, ScriptFunc, SpellScript&>,
+                    R""(CheckCastHandler signature must be "static SpellCastResult CheckCast(your_script_class& script, SpellScript&)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         SpellCastResult Call(SpellScript* spellScript) const
         {
-            return _safeWrapper(spellScript, _callImpl);
+            return _invoker.Thunk(*spellScript, _invoker.ImplStorage);
         }
     private:
-        SpellCheckCastFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class TC_GAME_API EffectBase : public EffectHook
@@ -362,9 +376,7 @@ public:
     class EffectHandler final : public EffectBase
     {
     public:
-        using SpellEffectFnType = void(SpellScript::*)(SpellEffIndex effIndex);
-
-        using SafeWrapperType = void(*)(SpellScript* spellScript, SpellEffIndex effIndex, SpellEffectFnType callImpl);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<void, SpellEffIndex>;
 
         template<typename ScriptFunc>
         explicit EffectHandler(ScriptFunc handler, uint8 effIndex, uint16 effName)
@@ -372,146 +384,110 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(SpellEffectFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(SpellEffectFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, SpellEffIndex>,
-                "EffectHandler signature must be \"void HandleEffect(SpellEffIndex effIndex)\"");
+            static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, SpellEffIndex>,
+                R""(EffectHandler signature must be "void HandleEffect(SpellEffIndex effIndex)")"");
 
-            _callImpl = reinterpret_cast<SpellEffectFnType>(handler);
-            _safeWrapper = [](SpellScript* spellScript, SpellEffIndex effIndex, SpellEffectFnType callImpl) -> void
-            {
-                return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl))(effIndex);
-            };
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(SpellScript* spellScript, SpellEffIndex effIndex) const
         {
-            return _safeWrapper(spellScript, effIndex, _callImpl);
+            return _invoker.Thunk(*spellScript, effIndex, _invoker.ImplStorage);
         }
     private:
-        SpellEffectFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class BeforeHitHandler final
     {
     public:
-        using SpellBeforeHitFnType = void(SpellScript::*)(SpellMissInfo missInfo);
-
-        using SafeWrapperType = void(*)(SpellScript* spellScript, SpellMissInfo missInfo, SpellBeforeHitFnType callImpl);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<void, SpellMissInfo>;
 
         template<typename ScriptFunc>
         explicit BeforeHitHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(SpellBeforeHitFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(SpellBeforeHitFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, SpellMissInfo>,
-                "BeforeHitHandler signature must be \"void HandleBeforeHit(SpellMissInfo missInfo)\"");
+            static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, SpellMissInfo>,
+                R""(BeforeHitHandler signature must be "void HandleBeforeHit(SpellMissInfo missInfo)")"");
 
-            _callImpl = reinterpret_cast<SpellBeforeHitFnType>(handler);
-            _safeWrapper = [](SpellScript* spellScript, SpellMissInfo missInfo, SpellBeforeHitFnType callImpl) -> void
-            {
-                return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl))(missInfo);
-            };
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(SpellScript* spellScript, SpellMissInfo missInfo) const
         {
-            return _safeWrapper(spellScript, missInfo, _callImpl);
+            return _invoker.Thunk(*spellScript, missInfo, _invoker.ImplStorage);
         }
     private:
-        SpellBeforeHitFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class HitHandler final
     {
     public:
-        using SpellHitFnType = void(SpellScript::*)();
-
-        using SafeWrapperType = void(*)(SpellScript* spellScript, SpellHitFnType callImpl);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<void>;
 
         template<typename ScriptFunc>
         explicit HitHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(SpellHitFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(SpellHitFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass>,
-                "HitHandler signature must be \"void HandleHit()\"");
+            static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&>,
+                R""(HitHandler signature must be "void HandleHit()")"");
 
-            _callImpl = reinterpret_cast<SpellHitFnType>(handler);
-            _safeWrapper = [](SpellScript* spellScript, SpellHitFnType callImpl) -> void
-            {
-                return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl))();
-            };
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(SpellScript* spellScript) const
         {
-            return _safeWrapper(spellScript, _callImpl);
+            return _invoker.Thunk(*spellScript, _invoker.ImplStorage);
         }
     private:
-        SpellHitFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class OnCalcCritChanceHandler final
     {
     public:
-        union SpellOnCalcCritChanceFnType
-        {
-            void(SpellScript::* Member)(Unit const* victim, float& critChance);
-            void(*Static)(Unit const* victim, float& critChance);
-        };
-
-        using SafeWrapperType = void(*)(SpellScript* spellScript, Unit const* victim, float& critChance, SpellOnCalcCritChanceFnType callImpl);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<void, Unit const*, float&>;
 
         template<typename ScriptFunc>
         explicit OnCalcCritChanceHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(SpellOnCalcCritChanceFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(SpellOnCalcCritChanceFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, Unit const*, float&>,
-                    "OnCalcCritChanceHandler signature must be \"void CalcCritChance(Unit const* victim, float& critChance)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(SpellOnCalcCritChanceFnType::Member)>(handler) };
-                _safeWrapper = [](SpellScript* spellScript, Unit const* victim, float& critChance, SpellOnCalcCritChanceFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(victim, critChance);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, Unit const*, float&>,
+                    R""(OnCalcCritChanceHandler signature must be "void CalcCritChance(Unit const* victim, float& critChance)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, Unit const*, float&>,
-                    "OnCalcCritChanceHandler signature must be \"static void CalcCritChance(Unit const* victim, float& critChance)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(SpellOnCalcCritChanceFnType::Static)>(handler) };
-                _safeWrapper = [](SpellScript* /*spellScript*/, Unit const* victim, float& critChance, SpellOnCalcCritChanceFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(victim, critChance);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, Unit const*, float&>,
+                    R""(OnCalcCritChanceHandler signature must be "static void CalcCritChance(your_script_class& script, Unit const* victim, float& critChance)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(SpellScript* spellScript, Unit const* victim, float& critChance) const
         {
-            return _safeWrapper(spellScript, victim, critChance, _callImpl);
+            return _invoker.Thunk(*spellScript, victim, critChance, _invoker.ImplStorage);
         }
     private:
-        SpellOnCalcCritChanceFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class TC_GAME_API TargetHook : public EffectHook
@@ -535,13 +511,7 @@ public:
     class ObjectAreaTargetSelectHandler final : public TargetHook
     {
     public:
-        union SpellObjectAreaTargetSelectFnType
-        {
-            void(SpellScript::* Member)(std::list<WorldObject*>& targets);
-            void(*Static)(std::list<WorldObject*>& targets);
-        };
-
-        using SafeWrapperType = void(*)(SpellScript* spellScript, std::list<WorldObject*>& targets, SpellObjectAreaTargetSelectFnType callImpl);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<void, std::list<WorldObject*>&>;
 
         template<typename ScriptFunc>
         explicit ObjectAreaTargetSelectHandler(ScriptFunc handler, uint8 effIndex, uint16 targetType)
@@ -549,57 +519,37 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(SpellObjectAreaTargetSelectFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(SpellObjectAreaTargetSelectFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, std::list<WorldObject*>&>,
-                    "ObjectAreaTargetSelectHandler signature must be \"void SetTargets(std::list<WorldObject*>& targets)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(SpellObjectAreaTargetSelectFnType::Member)>(handler) };
-                _safeWrapper = [](SpellScript* spellScript, std::list<WorldObject*>& targets, SpellObjectAreaTargetSelectFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(targets);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, std::list<WorldObject*>&>,
+                    R""(ObjectAreaTargetSelectHandler signature must be "void SetTargets(std::list<WorldObject*>& targets)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, std::list<WorldObject*>&>,
-                    "ObjectAreaTargetSelectHandler signature must be \"static void SetTargets(std::list<WorldObject*>& targets)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(SpellObjectAreaTargetSelectFnType::Static)>(handler) };
-                _safeWrapper = [](SpellScript* /*spellScript*/, std::list<WorldObject*>& targets, SpellObjectAreaTargetSelectFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(targets);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, std::list<WorldObject*>&>,
+                    R""(ObjectAreaTargetSelectHandler signature must be "static void SetTargets(your_script_class& script, std::list<WorldObject*>& targets)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(SpellScript* spellScript, std::list<WorldObject*>& targets) const
         {
-            return _safeWrapper(spellScript, targets, _callImpl);
+            return _invoker.Thunk(*spellScript, targets, _invoker.ImplStorage);
         }
 
         bool HasSameTargetFunctionAs(ObjectAreaTargetSelectHandler const& other) const
         {
-            return _callImpl.Member == other._callImpl.Member || _callImpl.Static == other._callImpl.Static;
+            return _invoker.ImplStorage == other._invoker.ImplStorage;
         }
     private:
-        SpellObjectAreaTargetSelectFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class ObjectTargetSelectHandler final : public TargetHook
     {
     public:
-        union SpellObjectTargetSelectFnType
-        {
-            void(SpellScript::* Member)(WorldObject*& target);
-            void(*Static)(WorldObject*& target);
-        };
-
-        using SafeWrapperType = void(*)(SpellScript* spellScript, WorldObject*& target, SpellObjectTargetSelectFnType callImpl);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<void, WorldObject*&>;
 
         template<typename ScriptFunc>
         explicit ObjectTargetSelectHandler(ScriptFunc handler, uint8 effIndex, uint16 targetType)
@@ -607,57 +557,37 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(SpellObjectTargetSelectFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(SpellObjectTargetSelectFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, WorldObject*&>,
-                    "ObjectTargetSelectHandler signature must be \"void SetTarget(WorldObject*& target)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(SpellObjectTargetSelectFnType::Member)>(handler) };
-                _safeWrapper = [](SpellScript* spellScript, WorldObject*& target, SpellObjectTargetSelectFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(target);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, WorldObject*&>,
+                    R""(ObjectTargetSelectHandler signature must be "void SetTarget(WorldObject*& target)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, WorldObject*&>,
-                    "ObjectTargetSelectHandler signature must be \"static void SetTarget(WorldObject*& target)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(SpellObjectTargetSelectFnType::Static)>(handler) };
-                _safeWrapper = [](SpellScript* /*spellScript*/, WorldObject*& target, SpellObjectTargetSelectFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(target);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, WorldObject*&>,
+                    R""(ObjectTargetSelectHandler signature must be "static void SetTarget(your_script_class& script, WorldObject*& target)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(SpellScript* spellScript, WorldObject*& target) const
         {
-            return _safeWrapper(spellScript, target, _callImpl);
+            return _invoker.Thunk(*spellScript, target, _invoker.ImplStorage);
         }
 
         bool HasSameTargetFunctionAs(ObjectTargetSelectHandler const& other) const
         {
-            return _callImpl.Member == other._callImpl.Member || _callImpl.Static == other._callImpl.Static;
+            return _invoker.ImplStorage == other._invoker.ImplStorage;
         }
     private:
-        SpellObjectTargetSelectFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class DestinationTargetSelectHandler final : public TargetHook
     {
     public:
-        union SpellDestinationTargetSelectFnType
-        {
-            void(SpellScript::* Member)(SpellDestination& target);
-            void(*Static)(SpellDestination& target);
-        };
-
-        using SafeWrapperType = void(*)(SpellScript* spellScript, SpellDestination& target, SpellDestinationTargetSelectFnType callImpl);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<void, SpellDestination&>;
 
         template<typename ScriptFunc>
         explicit DestinationTargetSelectHandler(ScriptFunc handler, uint8 effIndex, uint16 targetType)
@@ -665,178 +595,118 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(SpellDestinationTargetSelectFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(SpellDestinationTargetSelectFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, SpellDestination&>,
-                    "DestinationTargetSelectHandler signature must be \"void SetTarget(SpellDestination& target)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(SpellDestinationTargetSelectFnType::Member)>(handler) };
-                _safeWrapper = [](SpellScript* spellScript, SpellDestination& target, SpellDestinationTargetSelectFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(target);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, SpellDestination&>,
+                    R""(DestinationTargetSelectHandler signature must be "void SetTarget(SpellDestination& target)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, SpellDestination&>,
-                    "DestinationTargetSelectHandler signature must be \"static void SetTarget(SpellDestination& target)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(SpellDestinationTargetSelectFnType::Static)>(handler) };
-                _safeWrapper = [](SpellScript* /*spellScript*/, SpellDestination& target, SpellDestinationTargetSelectFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(target);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, SpellDestination&>,
+                    R""(DestinationTargetSelectHandler signature must be "static void SetTarget(your_script_class& script, SpellDestination& target)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(SpellScript* spellScript, SpellDestination& target) const
         {
-            return _safeWrapper(spellScript, target, _callImpl);
+            return _invoker.Thunk(*spellScript, target, _invoker.ImplStorage);
         }
     private:
-        SpellDestinationTargetSelectFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class DamageAndHealingCalcHandler final
     {
     public:
-        union DamageAndHealingCalcFnType
-        {
-            void(SpellScript::* Member)(SpellEffectInfo const& spellEffectInfo, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod);
-            void(*Static)(SpellEffectInfo const& spellEffectInfo, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod);
-        };
-
-        using SafeWrapperType = void(*)(SpellScript* spellScript, SpellEffectInfo const& spellEffectInfo, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod, DamageAndHealingCalcFnType callImpl);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<void, SpellEffectInfo const&, Unit*, int32&, int32&, float&>;
 
         template<typename ScriptFunc>
         explicit DamageAndHealingCalcHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(DamageAndHealingCalcFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(DamageAndHealingCalcFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, SpellEffectInfo const&, Unit*, int32&, int32&, float&>,
-                    "DamageAndHealingCalcHandler signature must be \"void CalcDamage(SpellEffectInfo const& spellEffectInfo, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(DamageAndHealingCalcFnType::Member)>(handler) };
-                _safeWrapper = [](SpellScript* spellScript, SpellEffectInfo const& spellEffectInfo, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod, DamageAndHealingCalcFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(spellEffectInfo, victim, damageOrHealing, flatMod, pctMod);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, SpellEffectInfo const&, Unit*, int32&, int32&, float&>,
+                    R""(DamageAndHealingCalcHandler signature must be "void CalcDamage(SpellEffectInfo const& spellEffectInfo, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, SpellEffectInfo const&, Unit*, int32&, int32&, float&>,
-                    "DamageAndHealingCalcHandler signature must be \"static void CalcDamage(SpellEffectInfo const& spellEffectInfo, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(DamageAndHealingCalcFnType::Static)>(handler) };
-                _safeWrapper = [](SpellScript* /*spellScript*/, SpellEffectInfo const& spellEffectInfo, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod, DamageAndHealingCalcFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(spellEffectInfo, victim, damageOrHealing, flatMod, pctMod);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, SpellEffectInfo const&, Unit*, int32&, int32&, float&>,
+                    R""(DamageAndHealingCalcHandler signature must be "static void CalcDamage(your_script_class& script, SpellEffectInfo const& spellEffectInfo, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(SpellScript* spellScript, SpellEffectInfo const& spellEffectInfo, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod) const
         {
-            return _safeWrapper(spellScript, spellEffectInfo, victim, damageOrHealing, flatMod, pctMod, _callImpl);
+            return _invoker.Thunk(*spellScript, spellEffectInfo, victim, damageOrHealing, flatMod, pctMod, _invoker.ImplStorage);
         }
     private:
-        DamageAndHealingCalcFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class OnCalculateResistAbsorbHandler final
     {
     public:
-        union SpellOnResistAbsorbCalculateFnType
-        {
-            void(SpellScript::* Member)(DamageInfo const& damageInfo, uint32& resistAmount, int32& absorbAmount);
-            void(*Static)(DamageInfo const& damageInfo, uint32& resistAmount, int32& absorbAmount);
-        };
-
-        using SafeWrapperType = void(*)(SpellScript* spellScript, DamageInfo const& damageInfo, uint32& resistAmount, int32& absorbAmount, SpellOnResistAbsorbCalculateFnType callImpl);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<void, DamageInfo const&, uint32&, int32&>;
 
         template<typename ScriptFunc>
         explicit OnCalculateResistAbsorbHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(SpellOnResistAbsorbCalculateFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(SpellOnResistAbsorbCalculateFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, DamageInfo const&, uint32&, int32&>,
-                    "OnCalculateResistAbsorbHandler signature must be \"void CalcAbsorbResist(DamageInfo const& damageInfo, uint32& resistAmount, int32& absorbAmount)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(SpellOnResistAbsorbCalculateFnType::Member)>(handler) };
-                _safeWrapper = [](SpellScript* spellScript, DamageInfo const& damageInfo, uint32& resistAmount, int32& absorbAmount, SpellOnResistAbsorbCalculateFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(damageInfo, resistAmount, absorbAmount);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, DamageInfo const&, uint32&, int32&>,
+                    R""(OnCalculateResistAbsorbHandler signature must be "void CalcAbsorbResist(DamageInfo const& damageInfo, uint32& resistAmount, int32& absorbAmount)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, DamageInfo const&, uint32&, int32&>,
-                    "OnCalculateResistAbsorbHandler signature must be \"static void CalcAbsorbResist(DamageInfo const& damageInfo, uint32& resistAmount, int32& absorbAmount)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(SpellOnResistAbsorbCalculateFnType::Static)>(handler) };
-                _safeWrapper = [](SpellScript* /*spellScript*/, DamageInfo const& damageInfo, uint32& resistAmount, int32& absorbAmount, SpellOnResistAbsorbCalculateFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(damageInfo, resistAmount, absorbAmount);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, DamageInfo const&, uint32&, int32&>,
+                    R""(OnCalculateResistAbsorbHandler signature must be "static void CalcAbsorbResist(your_script_class& script, DamageInfo const& damageInfo, uint32& resistAmount, int32& absorbAmount)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(SpellScript* spellScript, DamageInfo const& damageInfo, uint32& resistAmount, int32& absorbAmount) const
         {
-            return _safeWrapper(spellScript, damageInfo, resistAmount, absorbAmount, _callImpl);
+            return _invoker.Thunk(*spellScript, damageInfo, resistAmount, absorbAmount, _invoker.ImplStorage);
         }
     private:
-        SpellOnResistAbsorbCalculateFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class EmpowerStageCompletedHandler final
     {
     public:
-        using EmpowerStageFnType = void(SpellScript::*)(int32);
-
-        using SafeWrapperType = void(*)(SpellScript* spellScript, EmpowerStageFnType callImpl, int32 completedStagesCount);
+        using ScriptFuncInvoker = SpellScript::ScriptFuncInvoker<void, int32>;
 
         template<typename ScriptFunc>
         explicit EmpowerStageCompletedHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(EmpowerStageFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(EmpowerStageFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, int32>,
-                "EmpowerStageCompleted/EmpowerCompleted signature must be \"void HandleEmpowerStageCompleted(int32 completedStagesCount)\"");
+            static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, int32>,
+                R""(EmpowerStageCompleted/EmpowerCompleted signature must be "void HandleEmpowerStageCompleted(int32 completedStagesCount)")"");
 
-            _callImpl = reinterpret_cast<EmpowerStageFnType>(handler);
-            _safeWrapper = [](SpellScript* spellScript, EmpowerStageFnType callImpl, int32 completedStagesCount) -> void
-            {
-                return (static_cast<ScriptClass*>(spellScript)->*reinterpret_cast<ScriptFunc>(callImpl))(completedStagesCount);
-            };
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(SpellScript* spellScript, int32 completedStagesCount) const
         {
-            return _safeWrapper(spellScript, _callImpl, completedStagesCount);
+            return _invoker.Thunk(*spellScript, completedStagesCount, _invoker.ImplStorage);
         }
     private:
-        EmpowerStageFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
      // left for custom compatibility only, DO NOT USE
@@ -1136,161 +1006,104 @@ class TC_GAME_API AuraScript : public SpellScriptBase
 {
     // internal use classes & functions
     // DO NOT OVERRIDE THESE IN SCRIPTS
+    template <typename Ret, typename... Args>
+    using ScriptFuncInvoker = SpellScriptBase::ScriptFuncInvoker<Ret, AuraScript, Args...>;
+
 public:
     class CheckAreaTargetHandler final
     {
     public:
-        union AuraCheckAreaTargetFnType
-        {
-            bool(AuraScript::* Member)(Unit* target);
-            bool(*Static)(Unit* target);
-        };
-
-        using SafeWrapperType = bool(*)(AuraScript* auraScript, Unit* target, AuraCheckAreaTargetFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<bool, Unit*>;
 
         template<typename ScriptFunc>
         explicit CheckAreaTargetHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraCheckAreaTargetFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraCheckAreaTargetFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<bool, ScriptFunc, ScriptClass, Unit*>,
-                    "CheckAreaTargetHandler signature must be \"bool CheckTarget(Unit* target)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraCheckAreaTargetFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, Unit* target, AuraCheckAreaTargetFnType callImpl) -> bool
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(target);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<bool, ScriptFunc, ScriptClass&, Unit*>,
+                    R""(CheckAreaTargetHandler signature must be "bool CheckTarget(Unit* target)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<bool, ScriptFunc, Unit*>,
-                    "CheckAreaTargetHandler signature must be \"static bool CheckTarget(Unit* target)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraCheckAreaTargetFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, Unit* target, AuraCheckAreaTargetFnType callImpl) -> bool
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(target);
-                };
-            }
+                static_assert(std::is_invocable_r_v<bool, ScriptFunc, ScriptClass&, Unit*>,
+                    R""(CheckAreaTargetHandler signature must be "static bool CheckTarget(your_script_class& script, Unit* target)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         bool Call(AuraScript* auraScript, Unit* target) const
         {
-            return _safeWrapper(auraScript, target, _callImpl);
+            return _invoker.Thunk(*auraScript, target, _invoker.ImplStorage);
         }
     private:
-        AuraCheckAreaTargetFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class AuraDispelHandler final
     {
     public:
-        union AuraDispelFnType
-        {
-            void(AuraScript::* Member)(DispelInfo* dispelInfo);
-            void(*Static)(DispelInfo* dispelInfo);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, DispelInfo* dispelInfo, AuraDispelFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, DispelInfo*>;
 
         template<typename ScriptFunc>
         explicit AuraDispelHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraDispelFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraDispelFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, DispelInfo*>,
-                    "AuraDispelHandler signature must be \"void HandleDispel(DispelInfo* dispelInfo)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraDispelFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, DispelInfo* dispelInfo, AuraDispelFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(dispelInfo);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, DispelInfo*>,
+                    R""(AuraDispelHandler signature must be "void HandleDispel(DispelInfo* dispelInfo)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, DispelInfo*>,
-                    "AuraDispelHandler signature must be \"static void HandleDispel(DispelInfo* dispelInfo)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraDispelFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, DispelInfo* dispelInfo, AuraDispelFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(dispelInfo);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, DispelInfo*>,
+                    R""(AuraDispelHandler signature must be "static void HandleDispel(your_script_class& script, DispelInfo* dispelInfo)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, DispelInfo* dispelInfo) const
         {
-            return _safeWrapper(auraScript, dispelInfo, _callImpl);
+            return _invoker.Thunk(*auraScript, dispelInfo, _invoker.ImplStorage);
         }
     private:
-        AuraDispelFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class AuraHeartbeatHandler final
     {
     public:
-        union AuraHeartbeatFnType
-        {
-            void(AuraScript::* Member)();
-            void(*Static)();
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, AuraHeartbeatFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void>;
 
         template<typename ScriptFunc>
         explicit AuraHeartbeatHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraHeartbeatFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraHeartbeatFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
                 static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass>,
-                    "AuraHeartbeat signature must be \"void HandleHeartbeat()\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraHeartbeatFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraHeartbeatFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))();
-                };
-            }
+                    R""(AuraHeartbeatHandler signature must be "void HandleHeartbeat()")"");
             else
-            {
                 static_assert(std::is_invocable_r_v<void, ScriptFunc>,
-                    "AuraHeartbeatHandler signature must be \"static void HandleHeartbeat()\"");
+                    R""(AuraHeartbeatHandler signature must be "static void HandleHeartbeat(your_script_class& script)")"");
 
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraHeartbeatFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraHeartbeatFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)();
-                };
-            }
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript) const
         {
-            return _safeWrapper(auraScript, _callImpl);
+            return _invoker.Thunk(*auraScript, _invoker.ImplStorage);
         }
     private:
-        AuraHeartbeatFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class TC_GAME_API EffectBase : public EffectHook
@@ -1311,13 +1124,7 @@ public:
     class EffectPeriodicHandler final : public EffectBase
     {
     public:
-        union AuraEffectPeriodicFnType
-        {
-            void(AuraScript::* Member)(AuraEffect const* aurEff);
-            void(*Static)(AuraEffect const* aurEff);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, AuraEffect const* aurEff, AuraEffectPeriodicFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, AuraEffect const*>;
 
         template<typename ScriptFunc>
         explicit EffectPeriodicHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType)
@@ -1325,52 +1132,32 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEffectPeriodicFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEffectPeriodicFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, AuraEffect const*>,
-                    "EffectPeriodicHandler signature must be \"void HandlePeriodic(AuraEffect const* aurEff)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraEffectPeriodicFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect const* aurEff, AuraEffectPeriodicFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*>,
+                    R""(EffectPeriodicHandler signature must be "void HandlePeriodic(AuraEffect const* aurEff)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, AuraEffect const*>,
-                    "EffectPeriodicHandler signature must be \"static void HandlePeriodic(AuraEffect const* aurEff)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraEffectPeriodicFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect const* aurEff, AuraEffectPeriodicFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*>,
+                    R""(EffectPeriodicHandler signature must be "static void HandlePeriodic(your_script_class& script, AuraEffect const* aurEff)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, AuraEffect const* aurEff) const
         {
-            return _safeWrapper(auraScript, aurEff, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, _invoker.ImplStorage);
         }
     private:
-        AuraEffectPeriodicFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class EffectUpdatePeriodicHandler final : public EffectBase
     {
     public:
-        union AuraEffectUpdatePeriodicFnType
-        {
-            void(AuraScript::* Member)(AuraEffect* aurEff);
-            void(*Static)(AuraEffect* aurEff);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, AuraEffect* aurEff, AuraEffectUpdatePeriodicFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, AuraEffect*>;
 
         template<typename ScriptFunc>
         explicit EffectUpdatePeriodicHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType)
@@ -1378,52 +1165,32 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEffectUpdatePeriodicFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEffectUpdatePeriodicFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, AuraEffect*>,
-                    "EffectUpdatePeriodicHandler signature must be \"void HandleUpdatePeriodic(AuraEffect* aurEff)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraEffectUpdatePeriodicFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect* aurEff, AuraEffectUpdatePeriodicFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect*>,
+                    R""(EffectUpdatePeriodicHandler signature must be "void HandleUpdatePeriodic(AuraEffect* aurEff)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, AuraEffect*>,
-                    "EffectUpdatePeriodicHandler signature must be \"static void HandleUpdatePeriodic(AuraEffect* aurEff)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraEffectUpdatePeriodicFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect* aurEff, AuraEffectUpdatePeriodicFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect*>,
+                    R""(EffectUpdatePeriodicHandler signature must be "static void HandleUpdatePeriodic(your_script_class& script, AuraEffect* aurEff)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, AuraEffect* aurEff) const
         {
-            return _safeWrapper(auraScript, aurEff, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, _invoker.ImplStorage);
         }
     private:
-        AuraEffectUpdatePeriodicFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class EffectCalcAmountHandler final : public EffectBase
     {
     public:
-        union AuraEffectCalcAmountFnType
-        {
-            void(AuraScript::* Member)(AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated);
-            void(*Static)(AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated, AuraEffectCalcAmountFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, AuraEffect const*, int32&, bool&>;
 
         template<typename ScriptFunc>
         explicit EffectCalcAmountHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType)
@@ -1431,52 +1198,32 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEffectCalcAmountFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEffectCalcAmountFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, AuraEffect const*, int32&, bool&>,
-                    "EffectCalcAmountHandler signature must be \"void CalcAmount(AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraEffectCalcAmountFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated, AuraEffectCalcAmountFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff, amount, canBeRecalculated);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, int32&, bool&>,
+                    R""(EffectCalcAmountHandler signature must be "void CalcAmount(AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, AuraEffect const*, int32&, bool&>,
-                    "EffectCalcAmountHandler signature must be \"static void CalcAmount(AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraEffectCalcAmountFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated, AuraEffectCalcAmountFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff, amount, canBeRecalculated);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, int32&, bool&>,
+                    R""(EffectCalcAmountHandler signature must be "static void CalcAmount(your_script_class& script, AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated) const
         {
-            return _safeWrapper(auraScript, aurEff, amount, canBeRecalculated, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, amount, canBeRecalculated, _invoker.ImplStorage);
         }
     private:
-        AuraEffectCalcAmountFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class EffectCalcPeriodicHandler final : public EffectBase
     {
     public:
-        union AuraEffectCalcPeriodicFnType
-        {
-            void(AuraScript::* Member)(AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer);
-            void(*Static)(AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer, AuraEffectCalcPeriodicFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, AuraEffect const*, bool&, int32&>;
 
         template<typename ScriptFunc>
         explicit EffectCalcPeriodicHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType)
@@ -1484,52 +1231,32 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEffectCalcPeriodicFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEffectCalcPeriodicFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, AuraEffect const*, bool&, int32&>,
-                    "EffectCalcPeriodicHandler signature must be \"void CalcPeriodic(AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraEffectCalcPeriodicFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer, AuraEffectCalcPeriodicFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff, isPeriodic, periodicTimer);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, bool&, int32&>,
+                    R""(EffectCalcPeriodicHandler signature must be "void CalcPeriodic(AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, AuraEffect const*, bool&, int32&>,
-                    "EffectCalcPeriodicHandler signature must be \"static void CalcPeriodic(AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraEffectCalcPeriodicFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer, AuraEffectCalcPeriodicFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff, isPeriodic, periodicTimer);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, bool&, int32&>,
+                    R""(EffectCalcPeriodicHandler signature must be "static void CalcPeriodic(your_script_class& script, AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer) const
         {
-            return _safeWrapper(auraScript, aurEff, isPeriodic, periodicTimer, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, isPeriodic, periodicTimer, _invoker.ImplStorage);
         }
     private:
-        AuraEffectCalcPeriodicFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class EffectCalcSpellModHandler final : public EffectBase
     {
     public:
-        union AuraEffectCalcSpellModFnType
-        {
-            void(AuraScript::* Member)(AuraEffect const* aurEff, SpellModifier*& spellMod);
-            void(*Static)(AuraEffect const* aurEff, SpellModifier*& spellMod);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, AuraEffect const* aurEff, SpellModifier*& spellMod, AuraEffectCalcSpellModFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, AuraEffect const*, SpellModifier*&>;
 
         template<typename ScriptFunc>
         explicit EffectCalcSpellModHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType)
@@ -1537,52 +1264,32 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEffectCalcSpellModFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEffectCalcSpellModFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, AuraEffect const*, SpellModifier*&>,
-                    "EffectCalcSpellModHandler signature must be \"void CalcSpellMod(AuraEffect const* aurEff, SpellModifier*& spellMod)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraEffectCalcSpellModFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect const* aurEff, SpellModifier*& spellMod, AuraEffectCalcSpellModFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff, spellMod);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, SpellModifier*&>,
+                    R""(EffectCalcSpellModHandler signature must be "void CalcSpellMod(AuraEffect const* aurEff, SpellModifier*& spellMod)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, AuraEffect const*, SpellModifier*&>,
-                    "EffectCalcSpellModHandler signature must be \"static void CalcSpellMod(AuraEffect const* aurEff, SpellModifier*& spellMod)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraEffectCalcSpellModFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect const* aurEff, SpellModifier*& spellMod, AuraEffectCalcSpellModFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff, spellMod);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, SpellModifier*&>,
+                    R""(EffectCalcSpellModHandler signature must be "static void CalcSpellMod(your_script_class& script, AuraEffect const* aurEff, SpellModifier*& spellMod)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, AuraEffect const* aurEff, SpellModifier*& spellMod) const
         {
-            return _safeWrapper(auraScript, aurEff, spellMod, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, spellMod, _invoker.ImplStorage);
         }
     private:
-        AuraEffectCalcSpellModFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class EffectCalcCritChanceHandler final : public EffectBase
     {
     public:
-        union AuraEffectCalcCritChanceFnType
-        {
-            void(AuraScript::* Member)(AuraEffect const* aurEff, Unit const* victim, float& critChance);
-            void(*Static)(AuraEffect const* aurEff, Unit const* victim, float& critChance);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, AuraEffect const* aurEff, Unit const* victim, float& critChance, AuraEffectCalcCritChanceFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, AuraEffect const*, Unit const*, float&>;
 
         template<typename ScriptFunc>
         explicit EffectCalcCritChanceHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType)
@@ -1590,52 +1297,32 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEffectCalcCritChanceFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEffectCalcCritChanceFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, AuraEffect const*, Unit const*, float&>,
-                    "EffectCalcCritChanceHandler signature must be \"void CalcCritChance(AuraEffect const* aurEff, Unit const* victim, float& critChance)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraEffectCalcCritChanceFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect const* aurEff, Unit const* victim, float& critChance, AuraEffectCalcCritChanceFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff, victim, critChance);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, Unit const*, float&>,
+                    R""(EffectCalcCritChanceHandler signature must be "void CalcCritChance(AuraEffect const* aurEff, Unit const* victim, float& critChance)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, AuraEffect const*, Unit const*, float&>,
-                    "EffectCalcCritChanceHandler signature must be \"static void CalcCritChance(AuraEffect const* aurEff, Unit const* victim, float& critChance)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraEffectCalcCritChanceFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect const* aurEff, Unit const* victim, float& critChance, AuraEffectCalcCritChanceFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff, victim, critChance);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, Unit const*, float&>,
+                    R""(EffectCalcCritChanceHandler signature must be "static void CalcCritChance(your_script_class& script, AuraEffect const* aurEff, Unit const* victim, float& critChance)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, AuraEffect const* aurEff, Unit const* victim, float& critChance) const
         {
-            return _safeWrapper(auraScript, aurEff, victim, critChance, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, victim, critChance, _invoker.ImplStorage);
         }
     private:
-        AuraEffectCalcCritChanceFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class EffectCalcDamageAndHealingHandler final : public EffectBase
     {
     public:
-        union AuraEffectDamageAndHealingCalcFnType
-        {
-            void(AuraScript::* Member)(AuraEffect const* aurEff, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod);
-            void(*Static)(AuraEffect const* aurEff, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, AuraEffect const* aurEff, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod, AuraEffectDamageAndHealingCalcFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, AuraEffect const*, Unit*, int32&, int32&, float&>;
 
         template<typename ScriptFunc>
         explicit EffectCalcDamageAndHealingHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType)
@@ -1643,52 +1330,32 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEffectDamageAndHealingCalcFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEffectDamageAndHealingCalcFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, AuraEffect const*, Unit*, int32&, int32&, float&>,
-                    "EffectCalcDamageAndHealingHandler signature must be \"void CalcDamageAndHealing(AuraEffect const* aurEff, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraEffectDamageAndHealingCalcFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect const* aurEff, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod, AuraEffectDamageAndHealingCalcFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff, victim, damageOrHealing, flatMod, pctMod);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, Unit*, int32&, int32&, float&>,
+                    R""(EffectCalcDamageAndHealingHandler signature must be "void CalcDamageAndHealing(AuraEffect const* aurEff, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, AuraEffect const*, Unit*, int32&, int32&, float&>,
-                    "EffectCalcDamageAndHealingHandler signature must be \"static void CalcDamageAndHealing(AuraEffect const* aurEff, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraEffectDamageAndHealingCalcFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect const* aurEff, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod, AuraEffectDamageAndHealingCalcFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff, victim, damageOrHealing, flatMod, pctMod);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, Unit*, int32&, int32&, float&>,
+                    R""(EffectCalcDamageAndHealingHandler signature must be "static void CalcDamageAndHealing(your_script_class& script, AuraEffect const* aurEff, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, AuraEffect const* aurEff, Unit* victim, int32& damageOrHealing, int32& flatMod, float& pctMod) const
         {
-            return _safeWrapper(auraScript, aurEff, victim, damageOrHealing, flatMod, pctMod, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, victim, damageOrHealing, flatMod, pctMod, _invoker.ImplStorage);
         }
     private:
-        AuraEffectDamageAndHealingCalcFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class EffectApplyHandler final : public EffectBase
     {
     public:
-        union AuraEffectApplicationModeFnType
-        {
-            void(AuraScript::* Member)(AuraEffect const* aurEff, AuraEffectHandleModes mode);
-            void(*Static)(AuraEffect const* aurEff, AuraEffectHandleModes mode);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, AuraEffect const* aurEff, AuraEffectHandleModes mode, AuraEffectApplicationModeFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, AuraEffect const*, AuraEffectHandleModes>;
 
         template<typename ScriptFunc>
         explicit EffectApplyHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType, AuraEffectHandleModes mode)
@@ -1696,31 +1363,18 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEffectApplicationModeFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEffectApplicationModeFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, AuraEffect const*, AuraEffectHandleModes>,
-                    "EffectApplyHandler signature must be \"void HandleApplyOrRemove(AuraEffect const* aurEff, AuraEffectHandleModes mode)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraEffectApplicationModeFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect const* aurEff, AuraEffectHandleModes mode, AuraEffectApplicationModeFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff, mode);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, AuraEffectHandleModes>,
+                    R""(EffectApplyHandler signature must be "void HandleApplyOrRemove(AuraEffect const* aurEff, AuraEffectHandleModes mode)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, AuraEffect const*, AuraEffectHandleModes>,
-                    "EffectApplyHandler signature must be \"static void HandleApplyOrRemove(AuraEffect const* aurEff, AuraEffectHandleModes mode)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraEffectApplicationModeFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect const* aurEff, AuraEffectHandleModes mode, AuraEffectApplicationModeFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff, mode);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect const*, AuraEffectHandleModes>,
+                    R""(EffectApplyHandler signature must be "static void HandleApplyOrRemove(your_script_class& script, AuraEffect const* aurEff, AuraEffectHandleModes mode)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, AuraEffect const* aurEff, AuraEffectHandleModes mode) const
@@ -1728,24 +1382,17 @@ public:
             if (!(_mode & mode))
                 return;
 
-            return _safeWrapper(auraScript, aurEff, mode, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, mode, _invoker.ImplStorage);
         }
     private:
-        AuraEffectApplicationModeFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
         AuraEffectHandleModes _mode;
     };
 
     class EffectAbsorbHandler final : public EffectBase
     {
     public:
-        union AuraEffectAbsorbFnType
-        {
-            void(AuraScript::* Member)(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount);
-            void(*Static)(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount, AuraEffectAbsorbFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, AuraEffect*, DamageInfo&, uint32&>;
 
         template<typename ScriptFunc>
         explicit EffectAbsorbHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType)
@@ -1753,52 +1400,32 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEffectAbsorbFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEffectAbsorbFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, AuraEffect*, DamageInfo&, uint32&>,
-                    "EffectAbsorbHandler signature must be \"void HandleAbsorb(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraEffectAbsorbFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount, AuraEffectAbsorbFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff, dmgInfo, absorbAmount);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect*, DamageInfo&, uint32&>,
+                    R""(EffectAbsorbHandler signature must be "void HandleAbsorb(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, AuraEffect*, DamageInfo&, uint32&>,
-                    "EffectAbsorbHandler signature must be \"static void HandleAbsorb(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraEffectAbsorbFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount, AuraEffectAbsorbFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff, dmgInfo, absorbAmount);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect*, DamageInfo&, uint32&>,
+                    R""(EffectAbsorbHandler signature must be "static void HandleAbsorb(your_script_class& script, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount) const
         {
-            return _safeWrapper(auraScript, aurEff, dmgInfo, absorbAmount, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, dmgInfo, absorbAmount, _invoker.ImplStorage);
         }
     private:
-        AuraEffectAbsorbFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class EffectAbsorbHealHandler final : public EffectBase
     {
     public:
-        union AuraEffectAbsorbHealFnType
-        {
-            void(AuraScript::* Member)(AuraEffect* aurEff, HealInfo& healInfo, uint32& absorbAmount);
-            void(*Static)(AuraEffect* aurEff, HealInfo& healInfo, uint32& absorbAmount);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, AuraEffect* aurEff, HealInfo& healInfo, uint32& absorbAmount, AuraEffectAbsorbHealFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, AuraEffect*, HealInfo&, uint32&>;
 
         template<typename ScriptFunc>
         explicit EffectAbsorbHealHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType)
@@ -1806,104 +1433,64 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEffectAbsorbHealFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEffectAbsorbHealFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, AuraEffect*, HealInfo&, uint32&>,
-                    "EffectAbsorbHealHandler signature must be \"void HandleAbsorb(AuraEffect* aurEff, HealInfo& healInfo, uint32& absorbAmount)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraEffectAbsorbHealFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect* aurEff, HealInfo& healInfo, uint32& absorbAmount, AuraEffectAbsorbHealFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff, healInfo, absorbAmount);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect*, HealInfo&, uint32&>,
+                    R""(EffectAbsorbHealHandler signature must be "void HandleAbsorb(AuraEffect* aurEff, HealInfo& healInfo, uint32& absorbAmount)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, AuraEffect*, HealInfo&, uint32&>,
-                    "EffectAbsorbHealHandler signature must be \"static void HandleAbsorb(AuraEffect* aurEff, HealInfo& healInfo, uint32& absorbAmount)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraEffectAbsorbHealFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect* aurEff, HealInfo& healInfo, uint32& absorbAmount, AuraEffectAbsorbHealFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff, healInfo, absorbAmount);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect*, HealInfo&, uint32&>,
+                    R""(EffectAbsorbHealHandler signature must be "static void HandleAbsorb(your_script_class& script, AuraEffect* aurEff, HealInfo& healInfo, uint32& absorbAmount)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, AuraEffect* aurEff, HealInfo& healInfo, uint32& absorbAmount) const
         {
-            return _safeWrapper(auraScript, aurEff, healInfo, absorbAmount, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, healInfo, absorbAmount, _invoker.ImplStorage);
         }
     private:
-        AuraEffectAbsorbHealFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class CheckProcHandler final
     {
     public:
-        union AuraCheckProcFnType
-        {
-            bool(AuraScript::* Member)(ProcEventInfo& eventInfo);
-            bool(*Static)(ProcEventInfo& eventInfo);
-        };
-
-        using SafeWrapperType = bool(*)(AuraScript* auraScript, ProcEventInfo& eventInfo, AuraCheckProcFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<bool, ProcEventInfo&>;
 
         template<typename ScriptFunc>
         explicit CheckProcHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraCheckProcFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraCheckProcFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<bool, ScriptFunc, ScriptClass, ProcEventInfo&>,
-                    "CheckProcHandler signature must be \"bool CheckProc(ProcEventInfo& eventInfo)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraCheckProcFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, ProcEventInfo& eventInfo, AuraCheckProcFnType callImpl) -> bool
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(eventInfo);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<bool, ScriptFunc, ScriptClass&, ProcEventInfo&>,
+                    R""(CheckProcHandler signature must be "bool CheckProc(ProcEventInfo& eventInfo)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<bool, ScriptFunc, ProcEventInfo&>,
-                    "CheckProcHandler signature must be \"static bool CheckProc(ProcEventInfo& eventInfo)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraCheckProcFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, ProcEventInfo& eventInfo, AuraCheckProcFnType callImpl) -> bool
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(eventInfo);
-                };
-            }
+                static_assert(std::is_invocable_r_v<bool, ScriptFunc, ScriptClass&, ProcEventInfo&>,
+                    R""(CheckProcHandler signature must be "static bool CheckProc(your_script_class& script, ProcEventInfo& eventInfo)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         bool Call(AuraScript* auraScript, ProcEventInfo& eventInfo) const
         {
-            return _safeWrapper(auraScript, eventInfo, _callImpl);
+            return _invoker.Thunk(*auraScript, eventInfo, _invoker.ImplStorage);
         }
     private:
-        AuraCheckProcFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class CheckEffectProcHandler final : public EffectBase
     {
     public:
-        union AuraCheckEffectProcFnType
-        {
-            bool(AuraScript::* Member)(AuraEffect const* aurEff, ProcEventInfo& eventInfo);
-            bool(*Static)(AuraEffect const* aurEff, ProcEventInfo& eventInfo);
-        };
-
-        using SafeWrapperType = bool(*)(AuraScript* auraScript, AuraEffect const* aurEff, ProcEventInfo& eventInfo, AuraCheckEffectProcFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<bool, AuraEffect const*, ProcEventInfo&>;
 
         template<typename ScriptFunc>
         explicit CheckEffectProcHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType)
@@ -1911,104 +1498,64 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraCheckEffectProcFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraCheckEffectProcFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<bool, ScriptFunc, ScriptClass, AuraEffect const*, ProcEventInfo&>,
-                    "CheckEffectProcHandler signature must be \"bool CheckProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraCheckEffectProcFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect const* aurEff, ProcEventInfo& eventInfo, AuraCheckEffectProcFnType callImpl) -> bool
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff, eventInfo);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<bool, ScriptFunc, ScriptClass&, AuraEffect const*, ProcEventInfo&>,
+                    R""(CheckEffectProcHandler signature must be "bool CheckProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<bool, ScriptFunc, AuraEffect const*, ProcEventInfo&>,
-                    "CheckEffectProcHandler signature must be \"static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraCheckEffectProcFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect const* aurEff, ProcEventInfo& eventInfo, AuraCheckEffectProcFnType callImpl) -> bool
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff, eventInfo);
-                };
-            }
+                static_assert(std::is_invocable_r_v<bool, ScriptFunc, ScriptClass&, AuraEffect const*, ProcEventInfo&>,
+                    R""(CheckEffectProcHandler signature must be "static bool CheckProc(your_script_class& script, AuraEffect const* aurEff, ProcEventInfo& eventInfo)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         bool Call(AuraScript* auraScript, AuraEffect const* aurEff, ProcEventInfo& eventInfo) const
         {
-            return _safeWrapper(auraScript, aurEff, eventInfo, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, eventInfo, _invoker.ImplStorage);
         }
     private:
-        AuraCheckEffectProcFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class AuraProcHandler final
     {
     public:
-        union AuraProcFnType
-        {
-            void(AuraScript::* Member)(ProcEventInfo& eventInfo);
-            void(*Static)(ProcEventInfo& eventInfo);
-        };
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, ProcEventInfo& eventInfo, AuraProcFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, ProcEventInfo&>;
 
         template<typename ScriptFunc>
         explicit AuraProcHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraProcFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraProcFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, ProcEventInfo&>,
-                    "AuraProcHandler signature must be \"void HandleProc(ProcEventInfo& eventInfo)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraProcFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, ProcEventInfo& eventInfo, AuraProcFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(eventInfo);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, ProcEventInfo&>,
+                    R""(AuraProcHandler signature must be "void HandleProc(ProcEventInfo& eventInfo)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ProcEventInfo&>,
-                    "AuraProcHandler signature must be \"static void HandleProc(ProcEventInfo& eventInfo)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraProcFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, ProcEventInfo& eventInfo, AuraProcFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(eventInfo);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, ProcEventInfo&>,
+                    R""(AuraProcHandler signature must be "static void HandleProc(your_script_class& script, ProcEventInfo& eventInfo)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, ProcEventInfo& eventInfo) const
         {
-            return _safeWrapper(auraScript, eventInfo, _callImpl);
+            return _invoker.Thunk(*auraScript, eventInfo, _invoker.ImplStorage);
         }
     private:
-        AuraProcFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class EffectProcHandler final : public EffectBase
     {
     public:
-        union AuraEffectProcFnType
-        {
-            void(AuraScript::* Member)(AuraEffect* aurEff, ProcEventInfo& eventInfo);
-            void(*Static)(AuraEffect* aurEff, ProcEventInfo& eventInfo);
-        };
-
-        using SafeWrapperType = void (*)(AuraScript* auraScript, AuraEffect* aurEff, ProcEventInfo& eventInfo, AuraEffectProcFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, AuraEffect*, ProcEventInfo&>;
 
         template<typename ScriptFunc>
         explicit EffectProcHandler(ScriptFunc handler, uint8 effIndex, uint16 auraType)
@@ -2016,74 +1563,54 @@ public:
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEffectProcFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEffectProcFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
-            if constexpr (!std::is_void_v<ScriptClass>)
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, AuraEffect*, ProcEventInfo&>,
-                    "EffectProcHandler signature must be \"void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)\"");
-
-                _callImpl = { .Member = reinterpret_cast<decltype(AuraEffectProcFnType::Member)>(handler) };
-                _safeWrapper = [](AuraScript* auraScript, AuraEffect* aurEff, ProcEventInfo& eventInfo, AuraEffectProcFnType callImpl) -> void
-                {
-                    return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl.Member))(aurEff, eventInfo);
-                };
-            }
+            if constexpr (std::is_member_function_pointer_v<ScriptFunc>)
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect*, ProcEventInfo&>,
+                    R""(EffectProcHandler signature must be "void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)")"");
             else
-            {
-                static_assert(std::is_invocable_r_v<void, ScriptFunc, AuraEffect*, ProcEventInfo&>,
-                    "EffectProcHandler signature must be \"static void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)\"");
-
-                _callImpl = { .Static = reinterpret_cast<decltype(AuraEffectProcFnType::Static)>(handler) };
-                _safeWrapper = [](AuraScript* /*auraScript*/, AuraEffect* aurEff, ProcEventInfo& eventInfo, AuraEffectProcFnType callImpl) -> void
-                {
-                    return reinterpret_cast<ScriptFunc>(callImpl.Static)(aurEff, eventInfo);
-                };
-            }
+                static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass&, AuraEffect*, ProcEventInfo&>,
+                    R""(EffectProcHandler signature must be "static void HandleProc(your_script_class& script, AuraEffect* aurEff, ProcEventInfo& eventInfo)")"");
+
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, AuraEffect* aurEff, ProcEventInfo& eventInfo) const
         {
-            return _safeWrapper(auraScript, aurEff, eventInfo, _callImpl);
+            return _invoker.Thunk(*auraScript, aurEff, eventInfo, _invoker.ImplStorage);
         }
     private:
-        AuraEffectProcFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
     class EnterLeaveCombatHandler final
     {
     public:
-        using AuraEnterLeaveCombatFnType = void(AuraScript::*)(bool isNowInCombat);
-
-        using SafeWrapperType = void(*)(AuraScript* auraScript, bool isNowInCombat, AuraEnterLeaveCombatFnType callImpl);
+        using ScriptFuncInvoker = AuraScript::ScriptFuncInvoker<void, bool>;
 
         template<typename ScriptFunc>
         explicit EnterLeaveCombatHandler(ScriptFunc handler)
         {
             using ScriptClass = GetScriptClass_t<ScriptFunc>;
 
-            static_assert(sizeof(AuraEnterLeaveCombatFnType) >= sizeof(ScriptFunc));
-            static_assert(alignof(AuraEnterLeaveCombatFnType) >= alignof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Size >= sizeof(ScriptFunc));
+            static_assert(ScriptFuncInvoker::Alignment >= alignof(ScriptFunc));
 
             static_assert(std::is_invocable_r_v<void, ScriptFunc, ScriptClass, bool>,
-                "EnterLeaveCombatHandler signature must be \"void HandleEnterLeaveCombat(bool isNowInCombat)\"");
+                R""(EnterLeaveCombatHandler signature must be "void HandleEnterLeaveCombat(bool isNowInCombat)")"");
 
-            _callImpl = reinterpret_cast<AuraEnterLeaveCombatFnType>(handler);
-            _safeWrapper = [](AuraScript* auraScript, bool isNowInCombat, AuraEnterLeaveCombatFnType callImpl) -> void
-            {
-                return (static_cast<ScriptClass*>(auraScript)->*reinterpret_cast<ScriptFunc>(callImpl))(isNowInCombat);
-            };
+            new (_invoker.ImplStorage.data()) ScriptFuncInvoker::Impl<ScriptFunc>{ .Func = handler };
+            _invoker.Thunk = &ScriptFuncInvoker::Impl<ScriptFunc>::Invoke;
         }
 
         void Call(AuraScript* auraScript, bool isNowInCombat) const
         {
-            return _safeWrapper(auraScript, isNowInCombat, _callImpl);
+            return _invoker.Thunk(*auraScript, isNowInCombat, _invoker.ImplStorage);
         }
     private:
-        AuraEnterLeaveCombatFnType _callImpl;
-        SafeWrapperType _safeWrapper;
+        ScriptFuncInvoker _invoker;
     };
 
      // left for custom compatibility only, DO NOT USE
diff --git a/src/server/scripts/Kalimdor/RuinsOfAhnQiraj/boss_rajaxx.cpp b/src/server/scripts/Kalimdor/RuinsOfAhnQiraj/boss_rajaxx.cpp
index 19a7e0ea1fa..831a26b0abb 100644
--- a/src/server/scripts/Kalimdor/RuinsOfAhnQiraj/boss_rajaxx.cpp
+++ b/src/server/scripts/Kalimdor/RuinsOfAhnQiraj/boss_rajaxx.cpp
@@ -124,7 +124,7 @@ class boss_rajaxx : public CreatureScript
 // 25599 - Thundercrash
 class spell_rajaxx_thundercrash : public SpellScript
 {
-    static void HandleDamageCalc(SpellEffectInfo const& /*spellEffectInfo*/, Unit const* victim, int32& damage, int32& /*flatMod*/, float& /*pctMod*/)
+    static void HandleDamageCalc(SpellScript const&, SpellEffectInfo const& /*spellEffectInfo*/, Unit const* victim, int32& damage, int32& /*flatMod*/, float& /*pctMod*/)
     {
         damage = victim->CountPctFromCurHealth(50);
     }
diff --git a/src/server/scripts/KhazAlgar/TheStoneVault/boss_edna.cpp b/src/server/scripts/KhazAlgar/TheStoneVault/boss_edna.cpp
index b4e139cc3ca..dd087c8ffc1 100644
--- a/src/server/scripts/KhazAlgar/TheStoneVault/boss_edna.cpp
+++ b/src/server/scripts/KhazAlgar/TheStoneVault/boss_edna.cpp
@@ -383,7 +383,7 @@ class spell_edna_skarden_spawn_rp_periodic : public AuraScript
 // 451728 - Skarden Spawn RP
 class spell_edna_skarden_spawn_rp : public SpellScript
 {
-    static void SetDest(SpellDestination& dest)
+    static void SetDest(SpellScript const&, SpellDestination& dest)
     {
         dest.Relocate(Trinity::Containers::SelectRandomContainerElement(SkardenSpawnPositions));
     }
diff --git a/src/server/scripts/Northrend/IcecrownCitadel/icecrown_citadel.cpp b/src/server/scripts/Northrend/IcecrownCitadel/icecrown_citadel.cpp
index 527afb2c3c3..bac72097dcd 100644
--- a/src/server/scripts/Northrend/IcecrownCitadel/icecrown_citadel.cpp
+++ b/src/server/scripts/Northrend/IcecrownCitadel/icecrown_citadel.cpp
@@ -1458,9 +1458,9 @@ class spell_icc_harvest_blight_specimen : public SpellScript
 // 72585 - Soul Missile
 class spell_icc_soul_missile : public SpellScript
 {
-    static void RelocateDest(SpellDestination& dest)
+    static void RelocateDest(SpellScript const&, SpellDestination& dest)
     {
-        static Position const offset = { 0.0f, 0.0f, 200.0f, 0.0f };
+        static constexpr Position offset = { 0.0f, 0.0f, 200.0f, 0.0f };
         dest.RelocateOffset(offset);
     }
 
diff --git a/src/server/scripts/Spells/spell_dk.cpp b/src/server/scripts/Spells/spell_dk.cpp
index 9b309265233..ff2babcf667 100644
--- a/src/server/scripts/Spells/spell_dk.cpp
+++ b/src/server/scripts/Spells/spell_dk.cpp
@@ -369,12 +369,12 @@ class spell_dk_crimson_scourge : public AuraScript
         return ValidateSpellInfo({ SPELL_DK_BLOOD_PLAGUE, SPELL_DK_CRIMSON_SCOURGE_BUFF, SPELL_DK_DEATH_AND_DECAY });
     }
 
-    static bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& procInfo)
+    static bool CheckProc(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& procInfo)
     {
         return procInfo.GetProcTarget()->HasAura(SPELL_DK_BLOOD_PLAGUE, procInfo.GetActor()->GetGUID());
     }
 
-    static void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
+    static void HandleProc(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
     {
         Unit* actor = eventInfo.GetActor();
         actor->GetSpellHistory()->RestoreCharge(sSpellMgr->AssertSpellInfo(SPELL_DK_DEATH_AND_DECAY, DIFFICULTY_NONE)->ChargeCategoryId);
diff --git a/src/server/scripts/Spells/spell_druid.cpp b/src/server/scripts/Spells/spell_druid.cpp
index 4faf42597ba..5c3fe103d10 100644
--- a/src/server/scripts/Spells/spell_druid.cpp
+++ b/src/server/scripts/Spells/spell_druid.cpp
@@ -1327,7 +1327,7 @@ class spell_dru_luxuriant_soil : public AuraScript
         return ValidateSpellInfo({ SPELL_DRUID_REJUVENATION });
     }
 
-    static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo const& /*eventInfo*/)
+    static bool CheckProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& /*eventInfo*/)
     {
         return roll_chance_i(aurEff->GetAmount());
     }
@@ -1537,12 +1537,12 @@ class spell_dru_power_of_the_archdruid : public AuraScript
         return ValidateSpellEffect({ { SPELL_DRUID_POWER_OF_THE_ARCHDRUID, EFFECT_0 } });
     }
 
-    static bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetActor()->HasAuraEffect(SPELL_DRUID_POWER_OF_THE_ARCHDRUID, EFFECT_0);
     }
 
-    static void HandleProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static void HandleProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         Unit* druid = eventInfo.GetActor();
         Unit const* procTarget = eventInfo.GetActionTarget();
diff --git a/src/server/scripts/Spells/spell_evoker.cpp b/src/server/scripts/Spells/spell_evoker.cpp
index ad52d985292..48c8229c6cc 100644
--- a/src/server/scripts/Spells/spell_evoker.cpp
+++ b/src/server/scripts/Spells/spell_evoker.cpp
@@ -166,12 +166,12 @@ class spell_evo_burnout : public AuraScript
         return ValidateSpellInfo({ SPELL_EVOKER_BURNOUT });
     }
 
-    static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo const& /*eventInfo*/)
+    static bool CheckProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& /*eventInfo*/)
     {
         return roll_chance_i(aurEff->GetAmount());
     }
 
-    static void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
+    static void HandleProc(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
     {
         eventInfo.GetActor()->CastSpell(eventInfo.GetActor(), SPELL_EVOKER_BURNOUT, TRIGGERED_IGNORE_CAST_IN_PROGRESS | TRIGGERED_DONT_REPORT_CAST_ERROR);
     }
@@ -634,7 +634,7 @@ class spell_evo_ruby_embers : public SpellScript
         return !GetCaster()->HasAura(SPELL_EVOKER_RUBY_EMBERS);
     }
 
-    static void PreventPeriodic(WorldObject*& target)
+    static void PreventPeriodic(SpellScript const&, WorldObject*& target)
     {
         target = nullptr;
     }
diff --git a/src/server/scripts/Spells/spell_generic.cpp b/src/server/scripts/Spells/spell_generic.cpp
index c49c9752eb2..70c17d516e3 100644
--- a/src/server/scripts/Spells/spell_generic.cpp
+++ b/src/server/scripts/Spells/spell_generic.cpp
@@ -5578,7 +5578,7 @@ class spell_gen_no_npc_damage_below_override : public AuraScript
 public:
     spell_gen_no_npc_damage_below_override(float healthPct) : _healthPct(healthPct) {}
 
-    static void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/)
+    static void CalculateAmount(AuraScript const&, AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/)
     {
         amount = -1;
     }
diff --git a/src/server/scripts/Spells/spell_hunter.cpp b/src/server/scripts/Spells/spell_hunter.cpp
index 062ac2d5d62..1c547c9a16b 100644
--- a/src/server/scripts/Spells/spell_hunter.cpp
+++ b/src/server/scripts/Spells/spell_hunter.cpp
@@ -175,7 +175,7 @@ class spell_hun_aspect_of_the_fox : public SpellScript
         return !GetCaster()->HasAura(SPELL_HUNTER_ASPECT_OF_THE_FOX);
     }
 
-    static void HandleCastWhileWalking(WorldObject*& target)
+    static void HandleCastWhileWalking(SpellScript const&, WorldObject*& target)
     {
         target = nullptr;
     }
@@ -214,7 +214,7 @@ class spell_hun_aspect_of_the_turtle : public AuraScript
 // 204089 - Bullseye
 class spell_hun_bullseye : public AuraScript
 {
-    static bool CheckEffectProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static bool CheckEffectProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetActionTarget()->HealthBelowPct(aurEff->GetAmount());
     }
@@ -537,12 +537,12 @@ class spell_hun_manhunter : public AuraScript
         return ValidateSpellInfo({ SPELL_HUNTER_GREVIOUS_INJURY });
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetProcTarget()->IsPlayer();
     }
 
-    static void HandleEffectProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static void HandleEffectProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         eventInfo.GetActor()->CastSpell(eventInfo.GetActionTarget(), SPELL_HUNTER_GREVIOUS_INJURY, CastSpellExtraArgsInit{
             .TriggerFlags = TRIGGERED_IGNORE_CAST_IN_PROGRESS | TRIGGERED_DONT_REPORT_CAST_ERROR,
@@ -917,7 +917,7 @@ class spell_hun_scouts_instincts : public SpellScript
         return !GetCaster()->HasAura(SPELL_HUNTER_SCOUTS_INSTINCTS);
     }
 
-    static void HandleMinSpeed(WorldObject*& target)
+    static void HandleMinSpeed(SpellScript const&, WorldObject*& target)
     {
         target = nullptr;
     }
diff --git a/src/server/scripts/Spells/spell_mage.cpp b/src/server/scripts/Spells/spell_mage.cpp
index fbdde709d96..4c187c7b58a 100644
--- a/src/server/scripts/Spells/spell_mage.cpp
+++ b/src/server/scripts/Spells/spell_mage.cpp
@@ -769,7 +769,7 @@ class spell_mage_firestarter_dots : public AuraScript
 // 108853 - Fire Blast
 class spell_mage_fire_blast : public SpellScript
 {
-    void CalcCritChance(Unit const* /*victim*/, float& critChance) const
+    void CalcCritChance(Unit const* /*victim*/, float& critChance)
     {
         critChance = 100.0f;
     }
@@ -1196,7 +1196,7 @@ class spell_mage_improved_scorch : public AuraScript
         return ValidateSpellInfo({ SPELL_MAGE_IMPROVED_SCORCH });
     }
 
-    static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetProcTarget()->HealthBelowPct(aurEff->GetAmount());
     }
@@ -1387,7 +1387,7 @@ class spell_mage_molten_fury : public AuraScript
         return ValidateSpellInfo({ SPELL_MAGE_MOLTEN_FURY });
     }
 
-    static void HandleEffectProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static void HandleEffectProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         if (!eventInfo.GetActionTarget()->HealthAbovePct(aurEff->GetAmount()))
             eventInfo.GetActor()->CastSpell(eventInfo.GetActionTarget(), SPELL_MAGE_MOLTEN_FURY, CastSpellExtraArgsInit{
diff --git a/src/server/scripts/Spells/spell_monk.cpp b/src/server/scripts/Spells/spell_monk.cpp
index 8bccb2cdc29..a29af634d31 100644
--- a/src/server/scripts/Spells/spell_monk.cpp
+++ b/src/server/scripts/Spells/spell_monk.cpp
@@ -347,7 +347,7 @@ class spell_monk_pressure_points : public SpellScript
         return !GetCaster()->HasAura(SPELL_MONK_PRESSURE_POINTS);
     }
 
-    static void PreventDispel(WorldObject*& target)
+    static void PreventDispel(SpellScript const&, WorldObject*& target)
     {
         target = nullptr;
     }
diff --git a/src/server/scripts/Spells/spell_paladin.cpp b/src/server/scripts/Spells/spell_paladin.cpp
index 4d636726700..f5e35fddc24 100644
--- a/src/server/scripts/Spells/spell_paladin.cpp
+++ b/src/server/scripts/Spells/spell_paladin.cpp
@@ -154,7 +154,7 @@ class spell_pal_a_just_reward : public AuraScript
         return ValidateSpellInfo({ SPELL_PALADIN_A_JUST_REWARD_HEAL });
     }
 
-    static void HandleEffectProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static void HandleEffectProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         eventInfo.GetActor()->CastSpell(eventInfo.GetActionTarget(), SPELL_PALADIN_A_JUST_REWARD_HEAL, CastSpellExtraArgsInit{
             .TriggerFlags = TRIGGERED_IGNORE_CAST_IN_PROGRESS | TRIGGERED_DONT_REPORT_CAST_ERROR,
@@ -342,7 +342,7 @@ class spell_pal_blade_of_vengeance : public SpellScript
         return !GetCaster()->HasAura(SPELL_PALADIN_BLADE_OF_VENGEANCE);
     }
 
-    static void PreventProc(WorldObject*& target)
+    static void PreventProc(SpellScript const&, WorldObject*& target)
     {
         target = nullptr;
     }
diff --git a/src/server/scripts/Spells/spell_priest.cpp b/src/server/scripts/Spells/spell_priest.cpp
index 1a989519ef2..a094b243e1d 100644
--- a/src/server/scripts/Spells/spell_priest.cpp
+++ b/src/server/scripts/Spells/spell_priest.cpp
@@ -395,7 +395,7 @@ class spell_pri_atonement : public AuraScript
             && ValidateSpellEffect({ { spellInfo->Id, EFFECT_1 }, { SPELL_PRIEST_SINS_OF_THE_MANY, EFFECT_2 } });
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetDamageInfo() != nullptr;
     }
@@ -848,7 +848,7 @@ Optional<uint32> GetSpellToCast(uint32 spellId)
     return {};
 }
 
-void Trigger(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+void Trigger(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
 {
     Unit* target = eventInfo.GetActor();
     if (!target)
@@ -879,7 +879,7 @@ class spell_pri_divine_image : public AuraScript
         });
     }
 
-    static void HandleProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static void HandleProc(AuraScript const& script, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         Unit* target = eventInfo.GetActor();
         if (!target)
@@ -905,7 +905,7 @@ class spell_pri_divine_image : public AuraScript
                 .SetTriggerFlags(TRIGGERED_IGNORE_CAST_IN_PROGRESS | TRIGGERED_DISALLOW_PROC_EVENTS | TRIGGERED_DONT_REPORT_CAST_ERROR));
 
             // Note: Divine Image triggers a cast immediately based on the Holy Word cast.
-            DivineImageHelpers::Trigger(aurEff, eventInfo);
+            DivineImageHelpers::Trigger(script, aurEff, eventInfo);
         }
 
         target->CastSpell(target, SPELL_PRIEST_DIVINE_IMAGE_EMPOWER_STACK, CastSpellExtraArgs()
@@ -959,7 +959,7 @@ class spell_pri_divine_image_spell_triggered : public AuraScript
         });
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         return DivineImageHelpers::GetSummon(eventInfo.GetActor()) != nullptr;
     }
@@ -1184,7 +1184,7 @@ class spell_pri_epiphany : public AuraScript
         return ValidateSpellInfo({ SPELL_PRIEST_PRAYER_OF_MENDING, SPELL_PRIEST_EPIPHANY_HIGHLIGHT });
     }
 
-    static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/)
+    static bool CheckProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/)
     {
         return roll_chance_i(aurEff->GetAmount());
     }
@@ -1209,7 +1209,7 @@ class spell_pri_epiphany : public AuraScript
 // 415676 - Essence Devourer (Heal)
 class spell_pri_essence_devourer_heal : public SpellScript
 {
-    static void FilterTargets(std::list<WorldObject*>& targets)
+    static void FilterTargets(SpellScript const&, std::list<WorldObject*>& targets)
     {
         Trinity::SelectRandomInjuredTargets(targets, 1, true);
     }
@@ -1311,7 +1311,7 @@ class spell_pri_guardian_spirit : public AuraScript
         return true;
     }
 
-    static void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
+    static void CalculateAmount(AuraScript const&, AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
     {
         // Set absorbtion amount to unlimited
         amount = -1;
@@ -1347,12 +1347,12 @@ class spell_pri_heavens_wrath : public AuraScript
         return ValidateSpellInfo({ SPELL_PRIEST_ULTIMATE_PENITENCE });
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         return !(eventInfo.GetSpellInfo()->Id == SPELL_PRIEST_ULTIMATE_PENITENCE_DAMAGE || eventInfo.GetSpellInfo()->Id == SPELL_PRIEST_ULTIMATE_PENITENCE_HEAL);
     }
 
-    static void HandleEffectProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static void HandleEffectProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         Unit* caster = eventInfo.GetActor();
         if (!caster)
@@ -1413,12 +1413,12 @@ class spell_pri_holy_mending : public AuraScript
         return ValidateSpellInfo({ SPELL_PRIEST_RENEW, SPELL_PRIEST_HOLY_MENDING_HEAL });
     }
 
-    static bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& procInfo)
+    static bool CheckProc(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& procInfo)
     {
         return procInfo.GetProcTarget()->HasAura(SPELL_PRIEST_RENEW, procInfo.GetActor()->GetGUID());
     }
 
-    static void HandleProc(AuraEffect* aurEff, ProcEventInfo const& eventInfo)
+    static void HandleProc(AuraScript const&, AuraEffect* aurEff, ProcEventInfo const& eventInfo)
     {
         eventInfo.GetActor()->CastSpell(eventInfo.GetProcTarget(), SPELL_PRIEST_HOLY_MENDING_HEAL, CastSpellExtraArgs(aurEff));
     }
@@ -1810,7 +1810,7 @@ class spell_pri_painful_punishment : public AuraScript
         });
     }
 
-    static void HandleEffectProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static void HandleEffectProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         Unit* caster = eventInfo.GetActor();
         Unit* target = eventInfo.GetActionTarget();
@@ -1986,7 +1986,7 @@ class spell_pri_power_leech_passive : public AuraScript
         });
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetDamageInfo() != nullptr;
     }
@@ -2296,12 +2296,12 @@ class spell_pri_divine_aegis : public AuraScript
         return ValidateSpellEffect({ { SPELL_PRIEST_DIVINE_AEGIS_ABSORB, EFFECT_0 } });
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetHealInfo() != nullptr;
     }
 
-    static void HandleProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static void HandleProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         Unit* caster = eventInfo.GetActor();
         if (!caster)
@@ -2497,7 +2497,7 @@ class spell_pri_prayer_of_mending : public SpellScript
 // 155793 - Prayer of Mending (Jump)
 class spell_pri_prayer_of_mending_jump : public spell_pri_prayer_of_mending_SpellScriptBase
 {
-    static void FilterTargets(std::list<WorldObject*>& targets)
+    static void FilterTargets(SpellScript const&, std::list<WorldObject*>& targets)
     {
         Trinity::SelectRandomInjuredTargets(targets, 1, true);
     }
@@ -2544,7 +2544,7 @@ class spell_pri_holy_10_1_class_set_2pc : public AuraScript
             && ValidateSpellEffect({ { SPELL_PRIEST_PRAYER_OF_MENDING, EFFECT_0 } });
     }
 
-    static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/)
+    static bool CheckProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/)
     {
         return roll_chance_i(aurEff->GetAmount());
     }
@@ -2573,7 +2573,7 @@ class spell_pri_holy_10_1_class_set_2pc_chooser : public spell_pri_prayer_of_men
         return ValidateSpellInfo({ SPELL_PRIEST_PRAYER_OF_MENDING_AURA });
     }
 
-    static void FilterTargets(std::list<WorldObject*>& targets)
+    static void FilterTargets(SpellScript const&, std::list<WorldObject*>& targets)
     {
         Trinity::SelectRandomInjuredTargets(targets, 1, true);
     }
@@ -3080,7 +3080,7 @@ class spell_pri_shadow_mend_periodic_damage : public AuraScript
         GetTarget()->CastSpell(GetTarget(), SPELL_PRIEST_SHADOW_MEND_DAMAGE, args);
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetDamageInfo() != nullptr;
     }
@@ -3161,7 +3161,7 @@ class spell_pri_surge_of_light : public AuraScript
         });
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         if (eventInfo.GetSpellInfo()->Id == SPELL_PRIEST_SMITE)
             return true;
@@ -3213,7 +3213,7 @@ class spell_pri_t5_heal_2p_bonus : public AuraScript
         return ValidateSpellInfo({ SPELL_PRIEST_ITEM_EFFICIENCY });
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         if (HealInfo* healInfo = eventInfo.GetHealInfo())
             if (Unit* healTarget = healInfo->GetTarget())
@@ -3342,13 +3342,13 @@ class spell_pri_train_of_thought : public AuraScript
         });
     }
 
-    static bool CheckEffect0(AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
+    static bool CheckEffect0(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
     {
         // Renew & Flash Heal
         return eventInfo.GetSpellInfo()->IsAffected(SPELLFAMILY_PRIEST, { 0x840 });
     }
 
-    static bool CheckEffect1(AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
+    static bool CheckEffect1(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
     {
         // Smite
         return eventInfo.GetSpellInfo()->IsAffected(SPELLFAMILY_PRIEST, { 0x80 });
@@ -3377,7 +3377,7 @@ class spell_pri_train_of_thought : public AuraScript
 // 265259 - Twist of Fate (Discipline)
 class spell_pri_twist_of_fate : public AuraScript
 {
-    static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetProcTarget()->GetHealthPct() < aurEff->GetAmount();
     }
@@ -3449,7 +3449,7 @@ class spell_pri_vampiric_embrace : public AuraScript
         return ValidateSpellInfo({ SPELL_PRIEST_VAMPIRIC_EMBRACE_HEAL });
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         // Not proc from Mind Sear
         return !(eventInfo.GetDamageInfo()->GetSpellInfo()->SpellFamilyFlags[1] & 0x80000);
diff --git a/src/server/scripts/Spells/spell_rogue.cpp b/src/server/scripts/Spells/spell_rogue.cpp
index 87a6e64d13f..1aa8a755efa 100644
--- a/src/server/scripts/Spells/spell_rogue.cpp
+++ b/src/server/scripts/Spells/spell_rogue.cpp
@@ -396,7 +396,7 @@ class spell_rog_deepening_shadows : public AuraScript
         return ValidateSpellInfo({ SPELL_ROGUE_SHADOW_DANCE });
     }
 
-    static bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& procEvent)
+    static bool CheckProc(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& procEvent)
     {
         if (Spell const* procSpell = procEvent.GetProcSpell())
             return procSpell->GetPowerTypeCostAmount(POWER_COMBO_POINTS) > 0;
diff --git a/src/server/scripts/Spells/spell_shaman.cpp b/src/server/scripts/Spells/spell_shaman.cpp
index 4f6821c8347..991ad4a0ed1 100644
--- a/src/server/scripts/Spells/spell_shaman.cpp
+++ b/src/server/scripts/Spells/spell_shaman.cpp
@@ -224,7 +224,7 @@ class spell_sha_aftershock : public AuraScript
         return ValidateSpellInfo({ SPELL_SHAMAN_AFTERSHOCK_ENERGIZE });
     }
 
-    static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         if (Spell const* procSpell = eventInfo.GetProcSpell())
             if (Optional<int32> cost = procSpell->GetPowerTypeCostAmount(POWER_MAELSTROM))
@@ -233,7 +233,7 @@ class spell_sha_aftershock : public AuraScript
         return false;
     }
 
-    static void HandleEffectProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static void HandleEffectProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         Spell const* procSpell = eventInfo.GetProcSpell();
         eventInfo.GetActor()->CastSpell(eventInfo.GetActor(), SPELL_SHAMAN_AFTERSHOCK_ENERGIZE, CastSpellExtraArgsInit{
@@ -259,7 +259,7 @@ class spell_sha_ancestral_guidance : public AuraScript
         return ValidateSpellInfo({ SPELL_SHAMAN_ANCESTRAL_GUIDANCE_HEAL });
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         if (eventInfo.GetSpellInfo() && eventInfo.GetSpellInfo()->Id == SPELL_SHAMAN_ANCESTRAL_GUIDANCE_HEAL)
             return false;
@@ -299,7 +299,7 @@ class spell_sha_ancestral_guidance_heal : public SpellScript
         return ValidateSpellInfo({ SPELL_SHAMAN_ANCESTRAL_GUIDANCE });
     }
 
-    static void ResizeTargets(std::list<WorldObject*>& targets)
+    static void ResizeTargets(SpellScript const&, std::list<WorldObject*>& targets)
     {
         Trinity::SelectRandomInjuredTargets(targets, 3, true);
     }
@@ -318,7 +318,7 @@ class spell_sha_arctic_snowstorm : public AuraScript
         return ValidateSpellInfo({ SPELL_SHAMAN_ARCTIC_SNOWSTORM_AREATRIGGER });
     }
 
-    static void HandleEffectProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
+    static void HandleEffectProc(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
     {
         eventInfo.GetActor()->CastSpell(eventInfo.GetActionTarget(), SPELL_SHAMAN_ARCTIC_SNOWSTORM_AREATRIGGER,
             CastSpellExtraArgsInit{ .TriggerFlags = TRIGGERED_IGNORE_CAST_IN_PROGRESS | TRIGGERED_DONT_REPORT_CAST_ERROR });
@@ -369,7 +369,7 @@ class spell_sha_ascendance_restoration : public AuraScript
         return ValidateSpellInfo({ SPELL_SHAMAN_RESTORATIVE_MISTS });
     }
 
-    static bool CheckProc(ProcEventInfo const& procInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& procInfo)
     {
         return procInfo.GetHealInfo() && procInfo.GetHealInfo()->GetOriginalHeal() && procInfo.GetSpellInfo()->Id != SPELL_SHAMAN_RESTORATIVE_MISTS_INITIAL;
     }
@@ -723,7 +723,7 @@ class spell_sha_downpour : public SpellScript
         return ValidateSpellEffect({ { spellInfo->Id, EFFECT_1 } });
     }
 
-    static void FilterTargets(std::list<WorldObject*>& targets)
+    static void FilterTargets(SpellScript const&, std::list<WorldObject*>& targets)
     {
         Trinity::SelectRandomInjuredTargets(targets, 6, true);
     }
@@ -815,7 +815,7 @@ class spell_sha_earthen_rage_passive : public AuraScript
         return ValidateSpellInfo({ SPELL_SHAMAN_EARTHEN_RAGE_PERIODIC, SPELL_SHAMAN_EARTHEN_RAGE_DAMAGE });
     }
 
-    static bool CheckProc(ProcEventInfo const& procInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& procInfo)
     {
         return procInfo.GetSpellInfo() && procInfo.GetSpellInfo()->Id != SPELL_SHAMAN_EARTHEN_RAGE_DAMAGE;
     }
@@ -1314,7 +1314,7 @@ class spell_sha_healing_rain : public SpellScript
 // 73921 - Healing Rain
 class spell_sha_healing_rain_target_limit : public SpellScript
 {
-    static void SelectTargets(std::list<WorldObject*>& targets)
+    static void SelectTargets(SpellScript const&, std::list<WorldObject*>& targets)
     {
         Trinity::SelectRandomInjuredTargets(targets, 6, true);
     }
@@ -1328,7 +1328,7 @@ class spell_sha_healing_rain_target_limit : public SpellScript
 // 52042 - Healing Stream Totem
 class spell_sha_healing_stream_totem_heal : public SpellScript
 {
-    static void SelectTargets(std::list<WorldObject*>& targets)
+    static void SelectTargets(SpellScript const&, std::list<WorldObject*>& targets)
     {
         Trinity::SelectRandomInjuredTargets(targets, 1, true);
     }
@@ -1342,7 +1342,7 @@ class spell_sha_healing_stream_totem_heal : public SpellScript
 // 201900 - Hot Hand
 class spell_sha_hot_hand : public AuraScript
 {
-    static bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetActor()->HasAura(SPELL_SHAMAN_FLAMETONGUE_WEAPON_AURA);
     }
@@ -1473,7 +1473,7 @@ class spell_sha_item_mana_surge : public AuraScript
         return ValidateSpellInfo({ SPELL_SHAMAN_ITEM_MANA_SURGE });
     }
 
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetProcSpell() != nullptr;
     }
@@ -1808,7 +1808,7 @@ class spell_sha_liquid_magma_totem : public SpellScript
             GetCaster()->CastSpell(hitUnit, SPELL_SHAMAN_LIQUID_MAGMA_HIT, CastSpellExtraArgsInit{ .TriggerFlags = TRIGGERED_FULL_MASK });
     }
 
-    static void HandleTargetSelect(std::list<WorldObject*>& targets)
+    static void HandleTargetSelect(SpellScript const&, std::list<WorldObject*>& targets)
     {
         // choose one random target from targets
         if (targets.size() > 1)
@@ -2017,7 +2017,7 @@ class spell_sha_mastery_elemental_overload : public AuraScript
         });
     }
 
-    static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         SpellInfo const* spellInfo = eventInfo.GetSpellInfo();
         if (!spellInfo || !eventInfo.GetProcSpell())
@@ -2176,7 +2176,7 @@ class spell_sha_molten_thunder_sundering : public SpellScript
         return GetCaster()->HasAura(SPELL_SHAMAN_MOLTEN_THUNDER_TALENT);
     }
 
-    static void RemoveIncapacitateEffect(std::list<WorldObject*>& targets)
+    static void RemoveIncapacitateEffect(SpellScript const&, std::list<WorldObject*>& targets)
     {
         targets.clear();
     }
@@ -2229,13 +2229,13 @@ class spell_sha_natures_guardian : public AuraScript
         return ValidateSpellInfo({ SPELL_SHAMAN_NATURES_GUARDIAN_COOLDOWN });
     }
 
-    static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         return eventInfo.GetActionTarget()->HealthBelowPct(aurEff->GetAmount())
             && !eventInfo.GetActionTarget()->HasAura(SPELL_SHAMAN_NATURES_GUARDIAN_COOLDOWN);
     }
 
-    static void StartCooldown(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static void StartCooldown(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         Unit* shaman = eventInfo.GetActionTarget();
         shaman->CastSpell(shaman, SPELL_SHAMAN_NATURES_GUARDIAN_COOLDOWN, CastSpellExtraArgsInit{
@@ -2591,7 +2591,7 @@ class spell_sha_stormsurge : public AuraScript
         return ValidateSpellInfo({ SPELL_SHAMAN_STORMSURGE_PROC });
     }
 
-    static void HandleProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static void HandleProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         eventInfo.GetActor()->CastSpell(eventInfo.GetActor(), SPELL_SHAMAN_STORMSURGE_PROC, CastSpellExtraArgsInit{
             .TriggerFlags = TRIGGERED_IGNORE_CAST_IN_PROGRESS | TRIGGERED_DONT_REPORT_CAST_ERROR,
@@ -2618,7 +2618,7 @@ class spell_sha_stormweaver : public SpellScript
         return GetCaster()->HasAura(SPELL_SHAMAN_STORMWEAVER_PVP_TALENT);
     }
 
-    static void PreventAffectingHealingSpells(WorldObject*& target)
+    static void PreventAffectingHealingSpells(SpellScript const&, WorldObject*& target)
     {
         target = nullptr;
     }
@@ -3013,7 +3013,7 @@ class spell_sha_unlimited_power : public AuraScript
         return ValidateSpellInfo({ SPELL_SHAMAN_UNLIMITED_POWER_BUFF });
     }
 
-    static void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& procInfo)
+    static void HandleProc(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& procInfo)
     {
         Unit* caster = procInfo.GetActor();
         if (Aura* aura = caster->GetAura(SPELL_SHAMAN_UNLIMITED_POWER_BUFF))
@@ -3142,7 +3142,7 @@ class spell_sha_voltaic_blaze : public SpellScript
 // 470058 - Voltaic Blaze
 class spell_sha_voltaic_blaze_aura : public AuraScript
 {
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         // 470057 - Voltaic Blaze does not have any unique SpellFamilyFlags, check by id
         return eventInfo.GetSpellInfo()->Id == SPELL_SHAMAN_VOLTAIC_BLAZE_DAMAGE;
@@ -3157,12 +3157,12 @@ class spell_sha_voltaic_blaze_aura : public AuraScript
 // 470053 - Voltaic Blaze
 class spell_sha_voltaic_blaze_talent : public AuraScript
 {
-    static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo const& /*eventInfo*/)
+    static bool CheckProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& /*eventInfo*/)
     {
         return roll_chance_i(aurEff->GetAmount());
     }
 
-    static void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
+    static void HandleProc(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
     {
         eventInfo.GetActor()->CastSpell(eventInfo.GetActor(), SPELL_SHAMAN_VOLTAIC_BLAZE_OVERRIDE);
     }
diff --git a/src/server/scripts/Spells/spell_warrior.cpp b/src/server/scripts/Spells/spell_warrior.cpp
index a8b9d2ca995..7fefae22b25 100644
--- a/src/server/scripts/Spells/spell_warrior.cpp
+++ b/src/server/scripts/Spells/spell_warrior.cpp
@@ -118,7 +118,7 @@ static void ApplyWhirlwindCleaveAura(Player* caster, Difficulty difficulty, Spel
 // 392536 - Ashen Juggernaut
 class spell_warr_ashen_juggernaut : public AuraScript
 {
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         // should only proc on primary target
         return eventInfo.GetActionTarget() == eventInfo.GetProcSpell()->m_targets.GetUnitTarget();
@@ -423,7 +423,7 @@ class spell_warr_devastator : public AuraScript
 // 184361 - Enrage
 class spell_warr_enrage_proc : public AuraScript
 {
-    static bool CheckRampageProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
+    static bool CheckRampageProc(AuraScript const&, AuraEffect const* /*aurEff*/, ProcEventInfo const& eventInfo)
     {
         SpellInfo const* spellInfo = eventInfo.GetSpellInfo();
         if (!spellInfo || !spellInfo->IsAffected(SPELLFAMILY_WARRIOR, { 0x0, 0x0, 0x0, 0x8000000 }))  // Rampage
@@ -432,7 +432,7 @@ class spell_warr_enrage_proc : public AuraScript
         return true;
     }
 
-    static bool CheckBloodthirstProc(AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
+    static bool CheckBloodthirstProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& eventInfo)
     {
         SpellInfo const* spellInfo = eventInfo.GetSpellInfo();
         if (!spellInfo || !spellInfo->IsAffected(SPELLFAMILY_WARRIOR, { 0x0, 0x400 }))  // Bloodthirst/Bloodbath
@@ -462,7 +462,7 @@ class spell_warr_enrage_proc : public AuraScript
 // 260798 - Execute (Arms, Protection)
 class spell_warr_execute_damage : public SpellScript
 {
-    static void CalculateExecuteDamage(SpellEffectInfo const& /*spellEffectInfo*/, Unit const* /*victim*/, int32 const& /*damageOrHealing*/, int32 const& /*flatMod*/, float& pctMod)
+    static void CalculateExecuteDamage(SpellScript const&, SpellEffectInfo const& /*spellEffectInfo*/, Unit const* /*victim*/, int32 const& /*damageOrHealing*/, int32 const& /*flatMod*/, float& pctMod)
     {
         // tooltip has 2 multiplier hardcoded in it $damage=${2.0*$260798s1}
         pctMod *= 2.0f;
@@ -490,7 +490,7 @@ class spell_warr_frenzied_enrage : public SpellScript
         return !GetCaster()->HasAura(SPELL_WARRIOR_FRENZIED_ENRAGE);
     }
 
-    static void HandleFrenziedEnrage(WorldObject*& target)
+    static void HandleFrenziedEnrage(SpellScript const&, WorldObject*& target)
     {
         target = nullptr;
     }
@@ -575,7 +575,7 @@ class spell_warr_powerful_enrage : public SpellScript
         return !GetCaster()->HasAura(SPELL_WARRIOR_POWERFUL_ENRAGE);
     }
 
-    static void HandlePowerfulEnrage(WorldObject*& target)
+    static void HandlePowerfulEnrage(SpellScript const&, WorldObject*& target)
     {
         target = nullptr;
     }
@@ -776,7 +776,7 @@ class spell_warr_intimidating_shout : public SpellScript
         unitList.remove(GetExplTargetWorldObject());
     }
 
-    static void ClearTargets(std::list<WorldObject*>& unitList)
+    static void ClearTargets(SpellScript const&, std::list<WorldObject*>& unitList)
     {
         // This is used in effect 3, which is an AOE Root effect.
         // This doesn't seem to be a thing anymore, so we clear the targets list here.
@@ -1113,7 +1113,7 @@ class spell_warr_strategist : public AuraScript
             && ValidateSpellEffect({ { SPELL_WARRIOR_STRATEGIST, EFFECT_0 } });
     }
 
-    static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo const& /*procEvent*/)
+    static bool CheckProc(AuraScript const&, AuraEffect const* aurEff, ProcEventInfo const& /*procEvent*/)
     {
         return roll_chance_i(aurEff->GetAmount());
     }
@@ -1135,7 +1135,7 @@ class spell_warr_strategist : public AuraScript
 // 280776 - Sudden Death
 class spell_warr_sudden_death : public AuraScript
 {
-    static bool CheckProc(ProcEventInfo const& eventInfo)
+    static bool CheckProc(AuraScript const&, ProcEventInfo const& eventInfo)
     {
         // should only proc on primary target
         return eventInfo.GetActionTarget() == eventInfo.GetProcSpell()->m_targets.GetUnitTarget();
diff --git a/src/server/scripts/Zandalar/AtalDazar/boss_priestess_alun_za.cpp b/src/server/scripts/Zandalar/AtalDazar/boss_priestess_alun_za.cpp
index dae46d11fdc..24153b4f79e 100644
--- a/src/server/scripts/Zandalar/AtalDazar/boss_priestess_alun_za.cpp
+++ b/src/server/scripts/Zandalar/AtalDazar/boss_priestess_alun_za.cpp
@@ -385,7 +385,7 @@ private:
 // 258388 - Ritual
 class spell_priestess_alun_za_ritual : public SpellScript
 {
-    static void SetDest(SpellDestination& dest)
+    static void SetDest(SpellScript const&, SpellDestination& dest)
     {
         dest.Relocate(Trinity::Containers::SelectRandomContainerElement(RitualPosition));
     }
@@ -421,7 +421,7 @@ class spell_priestess_alun_za_agitate : public SpellScript
         });
     }
 
-    static void SelectTarget(std::list<WorldObject*>& targets)
+    static void SelectTarget(SpellScript const&, std::list<WorldObject*>& targets)
     {
         targets.resize(1);
     }
@@ -479,7 +479,7 @@ class spell_priestess_alun_za_molten_gold_selector : public SpellScript
 // 255592 - Tainted Blood
 class spell_priestess_alun_za_tainted_blood : public SpellScript
 {
-    static void FilterTargets(std::list<WorldObject*>& targets)
+    static void FilterTargets(SpellScript const&, std::list<WorldObject*>& targets)
     {
         Trinity::Containers::RandomResize(targets, 1);
     }
@@ -607,7 +607,7 @@ class spell_priestess_alun_za_transfusion_damage : public SpellScript
 // 259209 - Summon Spirit of Gold
 class spell_priestess_alun_za_spirit_of_gold : public SpellScript
 {
-    static void SetDest(SpellDestination& dest)
+    static void SetDest(SpellScript const&, SpellDestination& dest)
     {
         dest.Relocate(SpiritOfGoldSpawnPosition);
     }
diff --git a/src/server/scripts/Zandalar/Underrot/boss_sporecaller_zancha.cpp b/src/server/scripts/Zandalar/Underrot/boss_sporecaller_zancha.cpp
index 76b068b1e6c..6c446d6582a 100644
--- a/src/server/scripts/Zandalar/Underrot/boss_sporecaller_zancha.cpp
+++ b/src/server/scripts/Zandalar/Underrot/boss_sporecaller_zancha.cpp
@@ -474,7 +474,7 @@ class spell_sporecaller_zancha_boundless_rot : public SpellScript
 {
     static constexpr Position CenterPosition = { 1032.9444f, 1058.2899f, 33.330894f };
 
-    static void SetDest(SpellDestination& dest)
+    static void SetDest(SpellScript const&, SpellDestination& dest)
     {
         dest.Relocate(CenterPosition);
     }