feat(Core/Scripts): Optimize UnitScript (#18722)

* Add files via upload

* Add files via upload

* Add files via upload

* Add files via upload

* Add files via upload

* Update UnitScript.h

2 files changed, 82 insertions, 157 deletions

diff --git a/src/server/game/Scripting/ScriptDefines/UnitScript.cpp b/src/server/game/Scripting/ScriptDefines/UnitScript.cpp
index f493b5166a..a2921264da 100644
--- a/src/server/game/Scripting/ScriptDefines/UnitScript.cpp
+++ b/src/server/game/Scripting/ScriptDefines/UnitScript.cpp
@@ -19,250 +19,147 @@
 #include "ScriptMgr.h"
 #include "ScriptMgrMacros.h"
 
-uint32 ScriptMgr::DealDamage(Unit* AttackerUnit, Unit* pVictim, uint32 damage, DamageEffectType damagetype)
-{
-    if (ScriptRegistry<UnitScript>::ScriptPointerList.empty())
-    {
-        return damage;
-    }
-
-    for (auto const& [scriptID, script] : ScriptRegistry<UnitScript>::ScriptPointerList)
-    {
-        auto const& dmg = script->DealDamage(AttackerUnit, pVictim, damage, damagetype);
-        if (dmg != damage)
-        {
-            return damage;
-        }
-    }
-
-    return damage;
-}
-
 void ScriptMgr::OnHeal(Unit* healer, Unit* reciever, uint32& gain)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->OnHeal(healer, reciever, gain);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_HEAL, script->OnHeal(healer, reciever, gain));
 }
 
 void ScriptMgr::OnDamage(Unit* attacker, Unit* victim, uint32& damage)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->OnDamage(attacker, victim, damage);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_DAMAGE, script->OnDamage(attacker, victim, damage));
 }
 
 void ScriptMgr::ModifyPeriodicDamageAurasTick(Unit* target, Unit* attacker, uint32& damage, SpellInfo const* spellInfo)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->ModifyPeriodicDamageAurasTick(target, attacker, damage, spellInfo);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_MODIFY_PERIODIC_DAMAGE_AURAS_TICK, script->ModifyPeriodicDamageAurasTick(target, attacker, damage, spellInfo));
 }
 
 void ScriptMgr::ModifyMeleeDamage(Unit* target, Unit* attacker, uint32& damage)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->ModifyMeleeDamage(target, attacker, damage);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_MODIFY_MELEE_DAMAGE, script->ModifyMeleeDamage(target, attacker, damage));
 }
 
 void ScriptMgr::ModifySpellDamageTaken(Unit* target, Unit* attacker, int32& damage, SpellInfo const* spellInfo)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->ModifySpellDamageTaken(target, attacker, damage, spellInfo);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_MODIFY_SPELL_DAMAGE_TAKEN, script->ModifySpellDamageTaken(target, attacker, damage, spellInfo));
 }
 
 void ScriptMgr::ModifyHealReceived(Unit* target, Unit* healer, uint32& heal, SpellInfo const* spellInfo)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_MODIFY_HEAL_RECEIVED, script->ModifyHealReceived(target, healer, heal, spellInfo));
+}
+
+uint32 ScriptMgr::DealDamage(Unit* AttackerUnit, Unit* pVictim, uint32 damage, DamageEffectType damagetype)
+{
+    if (ScriptRegistry<UnitScript>::ScriptPointerList.empty())
     {
-        script->ModifyHealReceived(target, healer, heal, spellInfo);
-    });
+        return damage;
+    }
+
+    for (auto const& [scriptID, script] : ScriptRegistry<UnitScript>::ScriptPointerList)
+    {
+        auto const& dmg = script->DealDamage(AttackerUnit, pVictim, damage, damagetype);
+        if (dmg != damage)
+        {
+            return damage;
+        }
+    }
+
+    return damage;
 }
 
 void ScriptMgr::OnBeforeRollMeleeOutcomeAgainst(Unit const* attacker, Unit const* victim, WeaponAttackType attType, int32& attackerMaxSkillValueForLevel, int32& victimMaxSkillValueForLevel, int32& attackerWeaponSkill, int32& victimDefenseSkill, int32& crit_chance, int32& miss_chance, int32& dodge_chance, int32& parry_chance, int32& block_chance)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->OnBeforeRollMeleeOutcomeAgainst(attacker, victim, attType, attackerMaxSkillValueForLevel, victimMaxSkillValueForLevel, attackerWeaponSkill, victimDefenseSkill, crit_chance, miss_chance, dodge_chance, parry_chance, block_chance);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_BEFORE_ROLL_MELEE_OUTCOME_AGAINST, script->OnBeforeRollMeleeOutcomeAgainst(attacker, victim, attType, attackerMaxSkillValueForLevel, victimMaxSkillValueForLevel, attackerWeaponSkill, victimDefenseSkill, crit_chance, miss_chance, dodge_chance, parry_chance, block_chance));
+}
+
+void ScriptMgr::OnAuraApply(Unit* unit, Aura* aura)
+{
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_AURA_APPLY, script->OnAuraApply(unit, aura));
 }
 
 void ScriptMgr::OnAuraRemove(Unit* unit, AuraApplication* aurApp, AuraRemoveMode mode)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->OnAuraRemove(unit, aurApp, mode);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_AURA_REMOVE, script->OnAuraRemove(unit, aurApp, mode));
 }
 
 bool ScriptMgr::IfNormalReaction(Unit const* unit, Unit const* target, ReputationRank& repRank)
 {
-    auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
-    {
-        return !script->IfNormalReaction(unit, target, repRank);
-    });
-
-    if (ret && *ret)
-    {
-        return false;
-    }
-
-    return true;
+    CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_IF_NORMAL_REACTION, !script->IfNormalReaction(unit, target, repRank));
 }
 
 bool ScriptMgr::IsNeedModSpellDamagePercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto)
 {
-    auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
-    {
-        return !script->IsNeedModSpellDamagePercent(unit, auraEff, doneTotalMod, spellProto);
-    });
-
-    if (ret && *ret)
-    {
-        return false;
-    }
-
-    return true;
+    CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_IS_NEEDMOD_SPELL_DAMAGE_PERCENT, !script->IsNeedModSpellDamagePercent(unit, auraEff, doneTotalMod, spellProto));
 }
 
 bool ScriptMgr::IsNeedModMeleeDamagePercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto)
 {
-    auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
-    {
-        return !script->IsNeedModMeleeDamagePercent(unit, auraEff, doneTotalMod, spellProto);
-    });
-
-    if (ret && *ret)
-    {
-        return false;
-    }
-
-    return true;
+    CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_IS_NEEDMOD_MELEE_DAMAGE_PERCENT, !script->IsNeedModMeleeDamagePercent(unit, auraEff, doneTotalMod, spellProto));
 }
 
 bool ScriptMgr::IsNeedModHealPercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto)
 {
-    auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
-    {
-        return !script->IsNeedModHealPercent(unit, auraEff, doneTotalMod, spellProto);
-    });
-
-    if (ret && *ret)
-    {
-        return false;
-    }
-
-    return true;
+    CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_IS_NEEDMOD_HEAL_PERCENT, !script->IsNeedModHealPercent(unit, auraEff, doneTotalMod, spellProto));
 }
 
 bool ScriptMgr::CanSetPhaseMask(Unit const* unit, uint32 newPhaseMask, bool update)
 {
-    auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
-    {
-        return !script->CanSetPhaseMask(unit, newPhaseMask, update);
-    });
-
-    if (ret && *ret)
-    {
-        return false;
-    }
-
-    return true;
+    CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_CAN_SET_PHASE_MASK, !script->CanSetPhaseMask(unit, newPhaseMask, update));
 }
 
 bool ScriptMgr::IsCustomBuildValuesUpdate(Unit const* unit, uint8 updateType, ByteBuffer& fieldBuffer, Player const* target, uint16 index)
 {
-    auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
-    {
-        return script->IsCustomBuildValuesUpdate(unit, updateType, fieldBuffer, target, index);
-    });
-
-    if (ret && *ret)
-    {
-        return true;
-    }
-
-    return false;
+    CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_IS_CUSTOM_BUILD_VALUES_UPDATE, script->IsCustomBuildValuesUpdate(unit, updateType, fieldBuffer, target, index));
 }
 
 bool ScriptMgr::ShouldTrackValuesUpdatePosByIndex(Unit const* unit, uint8 updateType, uint16 index)
 {
-    auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script) { return script->ShouldTrackValuesUpdatePosByIndex(unit, updateType, index); });
-
-    if (ret && *ret)
-        return true;
-
-    return false;
+    CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_SHOULD_TRACK_VALUES_UPDATE_POS_BY_INDEX, script->ShouldTrackValuesUpdatePosByIndex(unit, updateType, index));
 }
 
 void ScriptMgr::OnPatchValuesUpdate(Unit const* unit, ByteBuffer& valuesUpdateBuf, BuildValuesCachePosPointers& posPointers, Player* target)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->OnPatchValuesUpdate(unit, valuesUpdateBuf, posPointers, target);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_PATCH_VALUES_UPDATE, script->OnPatchValuesUpdate(unit, valuesUpdateBuf, posPointers, target));
 }
 
 void ScriptMgr::OnUnitUpdate(Unit* unit, uint32 diff)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->OnUnitUpdate(unit, diff);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_UNIT_UPDATE, script->OnUnitUpdate(unit, diff));
 }
 
 void ScriptMgr::OnDisplayIdChange(Unit* unit, uint32 displayId)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->OnDisplayIdChange(unit, displayId);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_DISPLAYID_CHANGE, script->OnDisplayIdChange(unit, displayId));
 }
 
 void ScriptMgr::OnUnitEnterEvadeMode(Unit* unit, uint8 evadeReason)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->OnUnitEnterEvadeMode(unit, evadeReason);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_UNIT_ENTER_EVADE_MODE, script->OnUnitEnterEvadeMode(unit, evadeReason));
 }
 
 void ScriptMgr::OnUnitEnterCombat(Unit* unit, Unit* victim)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->OnUnitEnterCombat(unit, victim);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_UNIT_ENTER_COMBAT, script->OnUnitEnterCombat(unit, victim));
 }
 
 void ScriptMgr::OnUnitDeath(Unit* unit, Unit* killer)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
-    {
-        script->OnUnitDeath(unit, killer);
-    });
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_UNIT_DEATH, script->OnUnitDeath(unit, killer));
 }
 
-void ScriptMgr::OnAuraApply(Unit* unit, Aura* aura)
+UnitScript::UnitScript(const char* name, bool addToScripts, std::vector<uint16> enabledHooks)
+    : ScriptObject(name, UNITHOOK_END)
 {
-    ExecuteScript<UnitScript>([&](UnitScript* script)
+    if (addToScripts)
     {
-        script->OnAuraApply(unit, aura);
-    });
-}
+        // If empty - enable all available hooks.
+        if (enabledHooks.empty())
+            for (uint16 i = 0; i < UNITHOOK_END; ++i)
+                enabledHooks.emplace_back(i);
 
-UnitScript::UnitScript(const char* name, bool addToScripts) :
-    ScriptObject(name)
-{
-    if (addToScripts)
-        ScriptRegistry<UnitScript>::AddScript(this);
+        ScriptRegistry<UnitScript>::AddScript(this, std::move(enabledHooks));
+    }
 }
 
 template class AC_GAME_API ScriptRegistry<UnitScript>;
diff --git a/src/server/game/Scripting/ScriptDefines/UnitScript.h b/src/server/game/Scripting/ScriptDefines/UnitScript.h
index f0341909ca..27354ec6fa 100644
--- a/src/server/game/Scripting/ScriptDefines/UnitScript.h
+++ b/src/server/game/Scripting/ScriptDefines/UnitScript.h
@@ -19,6 +19,34 @@
 #define SCRIPT_OBJECT_UNIT_SCRIPT_H_
 
 #include "ScriptObject.h"
+#include <vector>
+
+enum UnitHook
+{
+    UNITHOOK_ON_HEAL,
+    UNITHOOK_ON_DAMAGE,
+    UNITHOOK_MODIFY_PERIODIC_DAMAGE_AURAS_TICK,
+    UNITHOOK_MODIFY_MELEE_DAMAGE,
+    UNITHOOK_MODIFY_SPELL_DAMAGE_TAKEN,
+    UNITHOOK_MODIFY_HEAL_RECEIVED,
+    UNITHOOK_ON_BEFORE_ROLL_MELEE_OUTCOME_AGAINST,
+    UNITHOOK_ON_AURA_APPLY,
+    UNITHOOK_ON_AURA_REMOVE,
+    UNITHOOK_IF_NORMAL_REACTION,
+    UNITHOOK_IS_NEEDMOD_SPELL_DAMAGE_PERCENT,
+    UNITHOOK_IS_NEEDMOD_MELEE_DAMAGE_PERCENT,
+    UNITHOOK_IS_NEEDMOD_HEAL_PERCENT,
+    UNITHOOK_CAN_SET_PHASE_MASK,
+    UNITHOOK_IS_CUSTOM_BUILD_VALUES_UPDATE,
+    UNITHOOK_SHOULD_TRACK_VALUES_UPDATE_POS_BY_INDEX,
+    UNITHOOK_ON_PATCH_VALUES_UPDATE,
+    UNITHOOK_ON_UNIT_UPDATE,
+    UNITHOOK_ON_DISPLAYID_CHANGE,
+    UNITHOOK_ON_UNIT_ENTER_EVADE_MODE,
+    UNITHOOK_ON_UNIT_ENTER_COMBAT,
+    UNITHOOK_ON_UNIT_DEATH,
+    UNITHOOK_END
+};
 
 enum ReputationRank : uint8;
 class ByteBuffer;
@@ -27,7 +55,7 @@ struct BuildValuesCachePosPointers;
 class UnitScript : public ScriptObject
 {
 protected:
-    UnitScript(const char* name, bool addToScripts = true);
+    UnitScript(const char* name, bool addToScripts = true, std::vector<uint16> enabledHooks = std::vector<uint16>());
 
 public:
     // Called when a unit deals healing to another unit