Nico/Viano-Core
1
0 Fork 0
Code Issues Pull Requests Actions 18 Packages Projects Releases Wiki Activity

Core/Spells: remove PrepareSpellScript and PrepareAuraScript macros and make Hooklist use emplace behaivior (#174)

Browse Source
This commit is contained in:
Warpten authored and GitHub committed 2020-08-28 15:40:26 +02:00
1 parent 677990a1b8
commit 2b2fc5fb8a
252 files changed
+3275 -7394
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/server/game/Spells/SpellScript.cpp
-411
View File
@@ -82,241 +82,6 @@ std::string const* _SpellScript::_GetScriptName() const
return m_scriptName;
}
_SpellScript::EffectHook::EffectHook(uint8 _effIndex)
{
// effect index must be in range <0;2>, allow use of special effindexes
ASSERT(_effIndex == EFFECT_ALL || _effIndex == EFFECT_FIRST_FOUND || _effIndex < MAX_SPELL_EFFECTS);
effIndex = _effIndex;
}
uint8 _SpellScript::EffectHook::GetAffectedEffectsMask(SpellInfo const* spellEntry)
{
uint8 mask = 0;
if ((effIndex == EFFECT_ALL) || (effIndex == EFFECT_FIRST_FOUND))
{
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if ((effIndex == EFFECT_FIRST_FOUND) && mask)
return mask;
if (CheckEffect(spellEntry, i))
mask |= (uint8)1<<i;
}
}
else
{
if (CheckEffect(spellEntry, effIndex))
mask |= (uint8)1<<effIndex;
}
return mask;
}
bool _SpellScript::EffectHook::IsEffectAffected(SpellInfo const* spellEntry, uint8 effIndexToCheck)
{
return (GetAffectedEffectsMask(spellEntry) & 1 << effIndexToCheck) != 0;
}
std::string _SpellScript::EffectHook::EffIndexToString()
{
switch (effIndex)
{
case EFFECT_ALL:
return "EFFECT_ALL";
case EFFECT_FIRST_FOUND:
return "EFFECT_FIRST_FOUND";
case EFFECT_0:
return "EFFECT_0";
case EFFECT_1:
return "EFFECT_1";
case EFFECT_2:
return "EFFECT_2";
}
return "Invalid Value";
}
bool _SpellScript::EffectNameCheck::Check(SpellInfo const* spellEntry, uint8 effIndex)
{
if (!spellEntry->Effects[effIndex].Effect && !effName)
return true;
if (!spellEntry->Effects[effIndex].Effect)
return false;
return (effName == SPELL_EFFECT_ANY) || (spellEntry->Effects[effIndex].Effect == effName);
}
std::string _SpellScript::EffectNameCheck::ToString()
{
switch (effName)
{
case SPELL_EFFECT_ANY:
return "SPELL_EFFECT_ANY";
default:
char num[10];
sprintf (num, "%u", effName);
return num;
}
}
bool _SpellScript::EffectAuraNameCheck::Check(SpellInfo const* spellEntry, uint8 effIndex)
{
if (!spellEntry->Effects[effIndex].ApplyAuraName && !effAurName)
return true;
if (!spellEntry->Effects[effIndex].ApplyAuraName)
return false;
return (effAurName == SPELL_AURA_ANY) || (spellEntry->Effects[effIndex].ApplyAuraName == effAurName);
}
std::string _SpellScript::EffectAuraNameCheck::ToString()
{
switch (effAurName)
{
case SPELL_AURA_ANY:
return "SPELL_AURA_ANY";
default:
char num[10];
sprintf (num, "%u", effAurName);
return num;
}
}
SpellScript::CastHandler::CastHandler(SpellCastFnType _pCastHandlerScript)
{
pCastHandlerScript = _pCastHandlerScript;
}
void SpellScript::CastHandler::Call(SpellScript* spellScript)
{
(spellScript->*pCastHandlerScript)();
}
SpellScript::CheckCastHandler::CheckCastHandler(SpellCheckCastFnType checkCastHandlerScript)
{
_checkCastHandlerScript = checkCastHandlerScript;
}
SpellCastResult SpellScript::CheckCastHandler::Call(SpellScript* spellScript)
{
return (spellScript->*_checkCastHandlerScript)();
}
SpellScript::EffectHandler::EffectHandler(SpellEffectFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
: _SpellScript::EffectNameCheck(_effName), _SpellScript::EffectHook(_effIndex)
{
pEffectHandlerScript = _pEffectHandlerScript;
}
std::string SpellScript::EffectHandler::ToString()
{
return "Index: " + EffIndexToString() + " Name: " +_SpellScript::EffectNameCheck::ToString();
}
bool SpellScript::EffectHandler::CheckEffect(SpellInfo const* spellEntry, uint8 effIndexToCheck)
{
return _SpellScript::EffectNameCheck::Check(spellEntry, effIndexToCheck);
}
void SpellScript::EffectHandler::Call(SpellScript* spellScript, SpellEffIndex effIndexToHandle)
{
(spellScript->*pEffectHandlerScript)(effIndexToHandle);
}
SpellScript::HitHandler::HitHandler(SpellHitFnType _pHitHandlerScript)
{
pHitHandlerScript = _pHitHandlerScript;
}
void SpellScript::HitHandler::Call(SpellScript* spellScript)
{
(spellScript->*pHitHandlerScript)();
}
SpellScript::TargetHook::TargetHook(uint8 _effectIndex, uint16 _targetType, bool _area, bool _dest)
: _SpellScript::EffectHook(_effectIndex), targetType(_targetType), area(_area), dest(_dest) { }
std::string SpellScript::TargetHook::ToString()
{
std::ostringstream oss;
oss << "Index: " << EffIndexToString() << " Target: " << targetType;
return oss.str();
}
bool SpellScript::TargetHook::CheckEffect(SpellInfo const* spellEntry, uint8 effIndexToCheck)
{
if (!targetType)
return false;
if (spellEntry->Effects[effIndexToCheck].TargetA.GetTarget() != targetType &&
spellEntry->Effects[effIndexToCheck].TargetB.GetTarget() != targetType)
return false;
SpellImplicitTargetInfo targetInfo(targetType);
switch (targetInfo.GetSelectionCategory())
{
case TARGET_SELECT_CATEGORY_CHANNEL: // SINGLE
return !area;
case TARGET_SELECT_CATEGORY_NEARBY: // BOTH
return true;
case TARGET_SELECT_CATEGORY_CONE: // AREA
case TARGET_SELECT_CATEGORY_AREA: // AREA
return area;
case TARGET_SELECT_CATEGORY_DEFAULT:
switch (targetInfo.GetObjectType())
{
case TARGET_OBJECT_TYPE_SRC: // EMPTY
return false;
case TARGET_OBJECT_TYPE_DEST: // DEST
return dest;
default:
switch (targetInfo.GetReferenceType())
{
case TARGET_REFERENCE_TYPE_CASTER: // SINGLE
return !area;
case TARGET_REFERENCE_TYPE_TARGET: // BOTH
return true;
default:
break;
}
break;
}
break;
default:
break;
}
return false;
}
SpellScript::ObjectAreaTargetSelectHandler::ObjectAreaTargetSelectHandler(SpellObjectAreaTargetSelectFnType _pObjectAreaTargetSelectHandlerScript, uint8 _effIndex, uint16 _targetType)
: TargetHook(_effIndex, _targetType, true, false)
{
pObjectAreaTargetSelectHandlerScript = _pObjectAreaTargetSelectHandlerScript;
}
void SpellScript::ObjectAreaTargetSelectHandler::Call(SpellScript* spellScript, std::list<WorldObject*>& targets)
{
(spellScript->*pObjectAreaTargetSelectHandlerScript)(targets);
}
SpellScript::ObjectTargetSelectHandler::ObjectTargetSelectHandler(SpellObjectTargetSelectFnType _pObjectTargetSelectHandlerScript, uint8 _effIndex, uint16 _targetType)
: TargetHook(_effIndex, _targetType, false, false)
{
pObjectTargetSelectHandlerScript = _pObjectTargetSelectHandlerScript;
}
void SpellScript::ObjectTargetSelectHandler::Call(SpellScript* spellScript, WorldObject*& target)
{
(spellScript->*pObjectTargetSelectHandlerScript)(target);
}
SpellScript::DestinationTargetSelectHandler::DestinationTargetSelectHandler(SpellDestinationTargetSelectFnType _DestinationTargetSelectHandlerScript, uint8 _effIndex, uint16 _targetType)
: TargetHook(_effIndex, _targetType, false, true)
{
DestinationTargetSelectHandlerScript = _DestinationTargetSelectHandlerScript;
}
void SpellScript::DestinationTargetSelectHandler::Call(SpellScript* spellScript, SpellDestination& target)
{
(spellScript->*DestinationTargetSelectHandlerScript)(target);
}
bool SpellScript::_Validate(SpellInfo const* entry)
{
for (auto itr = OnEffectLaunch.begin(); itr != OnEffectLaunch.end(); ++itr)
@@ -791,182 +556,6 @@ bool AuraScript::_Validate(SpellInfo const* entry)
return _SpellScript::_Validate(entry);
}
AuraScript::CheckAreaTargetHandler::CheckAreaTargetHandler(AuraCheckAreaTargetFnType _pHandlerScript)
{
pHandlerScript = _pHandlerScript;
}
bool AuraScript::CheckAreaTargetHandler::Call(AuraScript* auraScript, Unit* _target)
{
return (auraScript->*pHandlerScript)(_target);
}
AuraScript::AuraDispelHandler::AuraDispelHandler(AuraDispelFnType _pHandlerScript)
{
pHandlerScript = _pHandlerScript;
}
void AuraScript::AuraDispelHandler::Call(AuraScript* auraScript, DispelInfo* _dispelInfo)
{
(auraScript->*pHandlerScript)(_dispelInfo);
}
AuraScript::EffectBase::EffectBase(uint8 _effIndex, uint16 _effName)
: _SpellScript::EffectAuraNameCheck(_effName), _SpellScript::EffectHook(_effIndex) { }
bool AuraScript::EffectBase::CheckEffect(SpellInfo const* spellEntry, uint8 effIndexToCheck)
{
return _SpellScript::EffectAuraNameCheck::Check(spellEntry, effIndexToCheck);
}
std::string AuraScript::EffectBase::ToString()
{
return "Index: " + EffIndexToString() + " AuraName: " +_SpellScript::EffectAuraNameCheck::ToString();
}
AuraScript::EffectPeriodicHandler::EffectPeriodicHandler(AuraEffectPeriodicFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
: AuraScript::EffectBase(_effIndex, _effName)
{
pEffectHandlerScript = _pEffectHandlerScript;
}
void AuraScript::EffectPeriodicHandler::Call(AuraScript* auraScript, AuraEffect const* _aurEff)
{
(auraScript->*pEffectHandlerScript)(_aurEff);
}
AuraScript::EffectUpdatePeriodicHandler::EffectUpdatePeriodicHandler(AuraEffectUpdatePeriodicFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
: AuraScript::EffectBase(_effIndex, _effName)
{
pEffectHandlerScript = _pEffectHandlerScript;
}
void AuraScript::EffectUpdatePeriodicHandler::Call(AuraScript* auraScript, AuraEffect* aurEff)
{
(auraScript->*pEffectHandlerScript)(aurEff);
}
AuraScript::EffectCalcAmountHandler::EffectCalcAmountHandler(AuraEffectCalcAmountFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
: AuraScript::EffectBase(_effIndex, _effName)
{
pEffectHandlerScript = _pEffectHandlerScript;
}
void AuraScript::EffectCalcAmountHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated)
{
(auraScript->*pEffectHandlerScript)(aurEff, amount, canBeRecalculated);
}
AuraScript::EffectCalcPeriodicHandler::EffectCalcPeriodicHandler(AuraEffectCalcPeriodicFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
: AuraScript::EffectBase(_effIndex, _effName)
{
pEffectHandlerScript = _pEffectHandlerScript;
}
void AuraScript::EffectCalcPeriodicHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer)
{
(auraScript->*pEffectHandlerScript)(aurEff, isPeriodic, periodicTimer);
}
AuraScript::EffectCalcSpellModHandler::EffectCalcSpellModHandler(AuraEffectCalcSpellModFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName)
: AuraScript::EffectBase(_effIndex, _effName)
{
pEffectHandlerScript = _pEffectHandlerScript;
}
void AuraScript::EffectCalcSpellModHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, SpellModifier*& spellMod)
{
(auraScript->*pEffectHandlerScript)(aurEff, spellMod);
}
AuraScript::EffectApplyHandler::EffectApplyHandler(AuraEffectApplicationModeFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName, AuraEffectHandleModes _mode)
: AuraScript::EffectBase(_effIndex, _effName)
{
pEffectHandlerScript = _pEffectHandlerScript;
mode = _mode;
}
void AuraScript::EffectApplyHandler::Call(AuraScript* auraScript, AuraEffect const* _aurEff, AuraEffectHandleModes _mode)
{
if (_mode & mode)
(auraScript->*pEffectHandlerScript)(_aurEff, _mode);
}
AuraScript::EffectAbsorbHandler::EffectAbsorbHandler(AuraEffectAbsorbFnType _pEffectHandlerScript, uint8 _effIndex)
: AuraScript::EffectBase(_effIndex, SPELL_AURA_SCHOOL_ABSORB)
{
pEffectHandlerScript = _pEffectHandlerScript;
}
void AuraScript::EffectAbsorbHandler::Call(AuraScript* auraScript, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)
{
(auraScript->*pEffectHandlerScript)(aurEff, dmgInfo, absorbAmount);
}
AuraScript::EffectManaShieldHandler::EffectManaShieldHandler(AuraEffectAbsorbFnType _pEffectHandlerScript, uint8 _effIndex)
: AuraScript::EffectBase(_effIndex, SPELL_AURA_MANA_SHIELD)
{
pEffectHandlerScript = _pEffectHandlerScript;
}
void AuraScript::EffectManaShieldHandler::Call(AuraScript* auraScript, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)
{
(auraScript->*pEffectHandlerScript)(aurEff, dmgInfo, absorbAmount);
}
AuraScript::EffectSplitHandler::EffectSplitHandler(AuraEffectSplitFnType _pEffectHandlerScript, uint8 _effIndex)
: AuraScript::EffectBase(_effIndex, SPELL_AURA_SPLIT_DAMAGE_PCT)
{
pEffectHandlerScript = _pEffectHandlerScript;
}
void AuraScript::EffectSplitHandler::Call(AuraScript* auraScript, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& splitAmount)
{
(auraScript->*pEffectHandlerScript)(aurEff, dmgInfo, splitAmount);
}
AuraScript::CheckProcHandler::CheckProcHandler(AuraCheckProcFnType handlerScript)
{
_HandlerScript = handlerScript;
}
bool AuraScript::CheckProcHandler::Call(AuraScript* auraScript, ProcEventInfo& eventInfo)
{
return (auraScript->*_HandlerScript)(eventInfo);
}
AuraScript::CheckEffectProcHandler::CheckEffectProcHandler(AuraCheckEffectProcFnType handlerScript, uint8 effIndex, uint16 effName)
: AuraScript::EffectBase(effIndex, effName)
{
_HandlerScript = handlerScript;
}
bool AuraScript::CheckEffectProcHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, ProcEventInfo& eventInfo)
{
return (auraScript->*_HandlerScript)(aurEff, eventInfo);
}
AuraScript::AuraProcHandler::AuraProcHandler(AuraProcFnType handlerScript)
{
_HandlerScript = handlerScript;
}
void AuraScript::AuraProcHandler::Call(AuraScript* auraScript, ProcEventInfo& eventInfo)
{
(auraScript->*_HandlerScript)(eventInfo);
}
AuraScript::EffectProcHandler::EffectProcHandler(AuraEffectProcFnType effectHandlerScript, uint8 effIndex, uint16 effName)
: AuraScript::EffectBase(effIndex, effName)
{
_EffectHandlerScript = effectHandlerScript;
}
void AuraScript::EffectProcHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, ProcEventInfo& eventInfo)
{
(auraScript->*_EffectHandlerScript)(aurEff, eventInfo);
}
bool AuraScript::_Load(Aura* aura)
{
m_aura = aura;