diff options
Diffstat (limited to 'src/server')
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); } |