mirror of
https://github.com/araxiaonline/TrinityCore.git
synced 2026-06-15 04:32:35 -04:00
998 lines
37 KiB
C++
998 lines
37 KiB
C++
/*
|
|
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
* Scripts for spells with SPELLFAMILY_SHAMAN and SPELLFAMILY_GENERIC spells used by shaman players.
|
|
* Ordered alphabetically using scriptname.
|
|
* Scriptnames of files in this file should be prefixed with "spell_sha_".
|
|
*/
|
|
|
|
#include "Player.h"
|
|
#include "ScriptMgr.h"
|
|
#include "GridNotifiers.h"
|
|
#include "Unit.h"
|
|
#include "SpellScript.h"
|
|
#include "SpellAuraEffects.h"
|
|
|
|
enum ShamanSpells
|
|
{
|
|
SPELL_SHAMAN_ANCESTRAL_AWAKENING_PROC = 52752,
|
|
SPELL_SHAMAN_BIND_SIGHT = 6277,
|
|
SPELL_SHAMAN_CLEANSING_TOTEM_EFFECT = 52025,
|
|
SPELL_SHAMAN_EARTH_SHIELD_HEAL = 379,
|
|
SPELL_SHAMAN_EXHAUSTION = 57723,
|
|
SPELL_SHAMAN_FIRE_NOVA_R1 = 1535,
|
|
SPELL_SHAMAN_FIRE_NOVA_TRIGGERED_R1 = 8349,
|
|
SPELL_SHAMAN_GLYPH_OF_EARTH_SHIELD = 63279,
|
|
SPELL_SHAMAN_GLYPH_OF_HEALING_STREAM_TOTEM = 55456,
|
|
SPELL_SHAMAN_GLYPH_OF_MANA_TIDE = 55441,
|
|
SPELL_SHAMAN_GLYPH_OF_THUNDERSTORM = 62132,
|
|
SPELL_SHAMAN_ITEM_LIGHTNING_SHIELD = 23552,
|
|
SPELL_SHAMAN_ITEM_LIGHTNING_SHIELD_DAMAGE = 27635,
|
|
SPELL_SHAMAN_ITEM_MANA_SURGE = 23571,
|
|
SPELL_SHAMAN_LAVA_FLOWS_R1 = 51480,
|
|
SPELL_SHAMAN_LAVA_FLOWS_TRIGGERED_R1 = 64694,
|
|
SPELL_SHAMAN_MANA_SPRING_TOTEM_ENERGIZE = 52032,
|
|
SPELL_SHAMAN_MANA_TIDE_TOTEM = 39609,
|
|
SPELL_SHAMAN_SATED = 57724,
|
|
SPELL_SHAMAN_STORM_EARTH_AND_FIRE = 51483,
|
|
SPELL_SHAMAN_TOTEM_EARTHBIND_EARTHGRAB = 64695,
|
|
SPELL_SHAMAN_TOTEM_EARTHBIND_TOTEM = 6474,
|
|
SPELL_SHAMAN_TOTEM_EARTHEN_POWER = 59566,
|
|
SPELL_SHAMAN_TOTEM_HEALING_STREAM_HEAL = 52042
|
|
};
|
|
|
|
enum ShamanSpellIcons
|
|
{
|
|
SHAMAN_ICON_ID_RESTORATIVE_TOTEMS = 338,
|
|
SHAMAN_ICON_ID_SHAMAN_LAVA_FLOW = 3087
|
|
};
|
|
|
|
// 52759 - Ancestral Awakening (Proc)
|
|
class spell_sha_ancestral_awakening_proc : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_ancestral_awakening_proc() : SpellScriptLoader("spell_sha_ancestral_awakening_proc") { }
|
|
|
|
class spell_sha_ancestral_awakening_proc_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_ancestral_awakening_proc_SpellScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_ANCESTRAL_AWAKENING_PROC))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void FilterTargets(std::list<WorldObject*>& targets)
|
|
{
|
|
if (targets.size() < 2)
|
|
return;
|
|
|
|
targets.sort(Trinity::HealthPctOrderPred());
|
|
|
|
WorldObject* target = targets.front();
|
|
targets.clear();
|
|
targets.push_back(target);
|
|
}
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
int32 damage = GetEffectValue();
|
|
if (GetHitUnit())
|
|
GetCaster()->CastCustomSpell(GetHitUnit(), SPELL_SHAMAN_ANCESTRAL_AWAKENING_PROC, &damage, NULL, NULL, true);
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_sha_ancestral_awakening_proc_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_CASTER_AREA_RAID);
|
|
OnEffectHitTarget += SpellEffectFn(spell_sha_ancestral_awakening_proc_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_ancestral_awakening_proc_SpellScript();
|
|
}
|
|
};
|
|
|
|
// 51474 - Astral Shift
|
|
class spell_sha_astral_shift : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_astral_shift() : SpellScriptLoader("spell_sha_astral_shift") { }
|
|
|
|
class spell_sha_astral_shift_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_sha_astral_shift_AuraScript);
|
|
|
|
uint32 absorbPct;
|
|
|
|
bool Load() OVERRIDE
|
|
{
|
|
absorbPct = GetSpellInfo()->Effects[EFFECT_0].CalcValue(GetCaster());
|
|
return true;
|
|
}
|
|
|
|
void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
|
|
{
|
|
// Set absorbtion amount to unlimited
|
|
amount = -1;
|
|
}
|
|
|
|
void Absorb(AuraEffect* /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
|
|
{
|
|
// reduces all damage taken while stun, fear or silence
|
|
if (GetTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_FLEEING | UNIT_FLAG_SILENCED) || (GetTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_STUNNED) && GetTarget()->HasAuraWithMechanic(1<<MECHANIC_STUN)))
|
|
absorbAmount = CalculatePct(dmgInfo.GetDamage(), absorbPct);
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_sha_astral_shift_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
|
|
OnEffectAbsorb += AuraEffectAbsorbFn(spell_sha_astral_shift_AuraScript::Absorb, EFFECT_0);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_astral_shift_AuraScript();
|
|
}
|
|
};
|
|
|
|
// 2825 - Bloodlust
|
|
class spell_sha_bloodlust : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_bloodlust() : SpellScriptLoader("spell_sha_bloodlust") { }
|
|
|
|
class spell_sha_bloodlust_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_bloodlust_SpellScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_SATED))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void RemoveInvalidTargets(std::list<WorldObject*>& targets)
|
|
{
|
|
targets.remove_if(Trinity::UnitAuraCheck(true, SPELL_SHAMAN_SATED));
|
|
}
|
|
|
|
void ApplyDebuff()
|
|
{
|
|
if (Unit* target = GetHitUnit())
|
|
target->CastSpell(target, SPELL_SHAMAN_SATED, true);
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_sha_bloodlust_SpellScript::RemoveInvalidTargets, EFFECT_0, TARGET_UNIT_CASTER_AREA_RAID);
|
|
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_sha_bloodlust_SpellScript::RemoveInvalidTargets, EFFECT_1, TARGET_UNIT_CASTER_AREA_RAID);
|
|
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_sha_bloodlust_SpellScript::RemoveInvalidTargets, EFFECT_2, TARGET_UNIT_CASTER_AREA_RAID);
|
|
AfterHit += SpellHitFn(spell_sha_bloodlust_SpellScript::ApplyDebuff);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_bloodlust_SpellScript();
|
|
}
|
|
};
|
|
|
|
// -1064 - Chain Heal
|
|
class spell_sha_chain_heal : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_chain_heal() : SpellScriptLoader("spell_sha_chain_heal") { }
|
|
|
|
class spell_sha_chain_heal_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_chain_heal_SpellScript);
|
|
|
|
bool Load() OVERRIDE
|
|
{
|
|
firstHeal = true;
|
|
riptide = false;
|
|
return true;
|
|
}
|
|
|
|
void HandleHeal(SpellEffIndex /*effIndex*/)
|
|
{
|
|
if (firstHeal)
|
|
{
|
|
// Check if the target has Riptide
|
|
if (AuraEffect* aurEff = GetHitUnit()->GetAuraEffect(SPELL_AURA_PERIODIC_HEAL, SPELLFAMILY_SHAMAN, 0, 0, 0x10, GetCaster()->GetGUID()))
|
|
{
|
|
riptide = true;
|
|
// Consume it
|
|
GetHitUnit()->RemoveAura(aurEff->GetBase());
|
|
}
|
|
firstHeal = false;
|
|
}
|
|
// Riptide increases the Chain Heal effect by 25%
|
|
if (riptide)
|
|
SetHitHeal(GetHitHeal() * 1.25f);
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_sha_chain_heal_SpellScript::HandleHeal, EFFECT_0, SPELL_EFFECT_HEAL);
|
|
}
|
|
|
|
bool firstHeal;
|
|
bool riptide;
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_chain_heal_SpellScript();
|
|
}
|
|
};
|
|
|
|
// 8171 - Cleansing Totem (Pulse)
|
|
class spell_sha_cleansing_totem_pulse : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_cleansing_totem_pulse() : SpellScriptLoader("spell_sha_cleansing_totem_pulse") { }
|
|
|
|
class spell_sha_cleansing_totem_pulse_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_cleansing_totem_pulse_SpellScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_CLEANSING_TOTEM_EFFECT))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
int32 bp = 1;
|
|
if (GetCaster() && GetHitUnit() && GetOriginalCaster())
|
|
GetCaster()->CastCustomSpell(GetHitUnit(), SPELL_SHAMAN_CLEANSING_TOTEM_EFFECT, NULL, &bp, NULL, true, NULL, NULL, GetOriginalCaster()->GetGUID());
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_sha_cleansing_totem_pulse_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_cleansing_totem_pulse_SpellScript();
|
|
}
|
|
};
|
|
|
|
// -974 - Earth Shield
|
|
class spell_sha_earth_shield : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_earth_shield() : SpellScriptLoader("spell_sha_earth_shield") { }
|
|
|
|
class spell_sha_earth_shield_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_sha_earth_shield_AuraScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_EARTH_SHIELD_HEAL))
|
|
return false;
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_GLYPH_OF_EARTH_SHIELD))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool & /*canBeRecalculated*/)
|
|
{
|
|
if (Unit* caster = GetCaster())
|
|
{
|
|
amount = caster->SpellHealingBonusDone(GetUnitOwner(), GetSpellInfo(), amount, HEAL);
|
|
amount = GetUnitOwner()->SpellHealingBonusTaken(caster, GetSpellInfo(), amount, HEAL);
|
|
|
|
// Glyph of Earth Shield
|
|
//! WORKAROUND
|
|
//! this glyph is a proc
|
|
if (AuraEffect* glyph = caster->GetAuraEffect(SPELL_SHAMAN_GLYPH_OF_EARTH_SHIELD, EFFECT_0))
|
|
AddPct(amount, glyph->GetAmount());
|
|
}
|
|
}
|
|
|
|
bool CheckProc(ProcEventInfo& /*eventInfo*/)
|
|
{
|
|
//! HACK due to currenct proc system implementation
|
|
if (Player* player = GetTarget()->ToPlayer())
|
|
if (player->HasSpellCooldown(SPELL_SHAMAN_EARTH_SHIELD_HEAL))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/)
|
|
{
|
|
PreventDefaultAction();
|
|
|
|
GetTarget()->CastCustomSpell(SPELL_SHAMAN_EARTH_SHIELD_HEAL, SPELLVALUE_BASE_POINT0, aurEff->GetAmount(), GetTarget(), true, NULL, aurEff, GetCasterGUID());
|
|
|
|
/// @hack: due to currenct proc system implementation
|
|
if (Player* player = GetTarget()->ToPlayer())
|
|
player->AddSpellCooldown(SPELL_SHAMAN_EARTH_SHIELD_HEAL, 0, time(NULL) + 3);
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_sha_earth_shield_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_DUMMY);
|
|
DoCheckProc += AuraCheckProcFn(spell_sha_earth_shield_AuraScript::CheckProc);
|
|
OnEffectProc += AuraEffectProcFn(spell_sha_earth_shield_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_earth_shield_AuraScript();
|
|
}
|
|
};
|
|
|
|
// 6474 - Earthbind Totem - Fix Talent: Earthen Power
|
|
class spell_sha_earthbind_totem : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_earthbind_totem() : SpellScriptLoader("spell_sha_earthbind_totem") { }
|
|
|
|
class spell_sha_earthbind_totem_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_sha_earthbind_totem_AuraScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_TOTEM_EARTHBIND_TOTEM) || !sSpellMgr->GetSpellInfo(SPELL_SHAMAN_TOTEM_EARTHEN_POWER))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleEffectPeriodic(AuraEffect const* /*aurEff*/)
|
|
{
|
|
if (!GetCaster())
|
|
return;
|
|
if (Player* owner = GetCaster()->GetCharmerOrOwnerPlayerOrPlayerItself())
|
|
if (AuraEffect* aur = owner->GetDummyAuraEffect(SPELLFAMILY_SHAMAN, 2289, 0))
|
|
if (roll_chance_i(aur->GetBaseAmount()))
|
|
GetTarget()->CastSpell((Unit*)NULL, SPELL_SHAMAN_TOTEM_EARTHEN_POWER, true);
|
|
}
|
|
|
|
void Apply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
|
|
{
|
|
if (!GetCaster())
|
|
return;
|
|
Player* owner = GetCaster()->GetCharmerOrOwnerPlayerOrPlayerItself();
|
|
if (!owner)
|
|
return;
|
|
// Storm, Earth and Fire
|
|
if (AuraEffect* aurEff = owner->GetAuraEffectOfRankedSpell(SPELL_SHAMAN_STORM_EARTH_AND_FIRE, EFFECT_1))
|
|
{
|
|
if (roll_chance_i(aurEff->GetAmount()))
|
|
GetCaster()->CastSpell(GetCaster(), SPELL_SHAMAN_TOTEM_EARTHBIND_EARTHGRAB, false);
|
|
}
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnEffectPeriodic += AuraEffectPeriodicFn(spell_sha_earthbind_totem_AuraScript::HandleEffectPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
|
|
OnEffectApply += AuraEffectApplyFn(spell_sha_earthbind_totem_AuraScript::Apply, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL, AURA_EFFECT_HANDLE_REAL);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_earthbind_totem_AuraScript();
|
|
}
|
|
};
|
|
|
|
class EarthenPowerTargetSelector
|
|
{
|
|
public:
|
|
EarthenPowerTargetSelector() { }
|
|
|
|
bool operator() (WorldObject* target)
|
|
{
|
|
if (!target->ToUnit())
|
|
return true;
|
|
|
|
if (!target->ToUnit()->HasAuraWithMechanic(1 << MECHANIC_SNARE))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// 59566 - Earthen Power
|
|
class spell_sha_earthen_power : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_earthen_power() : SpellScriptLoader("spell_sha_earthen_power") { }
|
|
|
|
class spell_sha_earthen_power_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_earthen_power_SpellScript);
|
|
|
|
void FilterTargets(std::list<WorldObject*>& unitList)
|
|
{
|
|
unitList.remove_if(EarthenPowerTargetSelector());
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_sha_earthen_power_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ALLY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_earthen_power_SpellScript();
|
|
}
|
|
};
|
|
|
|
// -1535 - Fire Nova
|
|
class spell_sha_fire_nova : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_fire_nova() : SpellScriptLoader("spell_sha_fire_nova") { }
|
|
|
|
class spell_sha_fire_nova_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_fire_nova_SpellScript);
|
|
|
|
bool Validate(SpellInfo const* spellInfo) OVERRIDE
|
|
{
|
|
SpellInfo const* firstRankSpellInfo = sSpellMgr->GetSpellInfo(SPELL_SHAMAN_FIRE_NOVA_R1);
|
|
if (!firstRankSpellInfo || !spellInfo->IsRankOf(firstRankSpellInfo))
|
|
return false;
|
|
|
|
uint8 rank = spellInfo->GetRank();
|
|
if (!sSpellMgr->GetSpellWithRank(SPELL_SHAMAN_FIRE_NOVA_TRIGGERED_R1, rank, true))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
SpellCastResult CheckFireTotem()
|
|
{
|
|
// fire totem
|
|
if (!GetCaster()->m_SummonSlot[1])
|
|
{
|
|
SetCustomCastResultMessage(SPELL_CUSTOM_ERROR_MUST_HAVE_FIRE_TOTEM);
|
|
return SPELL_FAILED_CUSTOM_ERROR;
|
|
}
|
|
|
|
return SPELL_CAST_OK;
|
|
}
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
Unit* caster = GetCaster();
|
|
if (Creature* totem = caster->GetMap()->GetCreature(caster->m_SummonSlot[1]))
|
|
{
|
|
uint8 rank = GetSpellInfo()->GetRank();
|
|
if (totem->IsTotem())
|
|
caster->CastSpell(totem, sSpellMgr->GetSpellWithRank(SPELL_SHAMAN_FIRE_NOVA_TRIGGERED_R1, rank), true);
|
|
}
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnCheckCast += SpellCheckCastFn(spell_sha_fire_nova_SpellScript::CheckFireTotem);
|
|
OnEffectHitTarget += SpellEffectFn(spell_sha_fire_nova_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_fire_nova_SpellScript();
|
|
}
|
|
};
|
|
|
|
// -8050 - Flame Shock
|
|
class spell_sha_flame_shock : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_flame_shock() : SpellScriptLoader("spell_sha_flame_shock") { }
|
|
|
|
class spell_sha_flame_shock_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_sha_flame_shock_AuraScript);
|
|
|
|
bool Validate(SpellInfo const* /*spell*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_LAVA_FLOWS_R1))
|
|
return false;
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_LAVA_FLOWS_TRIGGERED_R1))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleDispel(DispelInfo* /*dispelInfo*/)
|
|
{
|
|
if (Unit* caster = GetCaster())
|
|
// Lava Flows
|
|
if (AuraEffect const* aurEff = caster->GetDummyAuraEffect(SPELLFAMILY_SHAMAN, SHAMAN_ICON_ID_SHAMAN_LAVA_FLOW, EFFECT_0))
|
|
{
|
|
if (SpellInfo const* firstRankSpellInfo = sSpellMgr->GetSpellInfo(SPELL_SHAMAN_LAVA_FLOWS_R1))
|
|
if (!aurEff->GetSpellInfo()->IsRankOf(firstRankSpellInfo))
|
|
return;
|
|
|
|
uint8 rank = aurEff->GetSpellInfo()->GetRank();
|
|
caster->CastSpell(caster, sSpellMgr->GetSpellWithRank(SPELL_SHAMAN_LAVA_FLOWS_TRIGGERED_R1, rank), true);
|
|
}
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
AfterDispel += AuraDispelFn(spell_sha_flame_shock_AuraScript::HandleDispel);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_flame_shock_AuraScript();
|
|
}
|
|
};
|
|
|
|
// 52041, 52046, 52047, 52048, 52049, 52050, 58759, 58760, 58761 - Healing Stream Totem
|
|
class spell_sha_healing_stream_totem : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_healing_stream_totem() : SpellScriptLoader("spell_sha_healing_stream_totem") { }
|
|
|
|
class spell_sha_healing_stream_totem_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_healing_stream_totem_SpellScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_GLYPH_OF_HEALING_STREAM_TOTEM) || !sSpellMgr->GetSpellInfo(SPELL_SHAMAN_TOTEM_HEALING_STREAM_HEAL))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
int32 damage = GetEffectValue();
|
|
SpellInfo const* triggeringSpell = GetTriggeringSpell();
|
|
if (Unit* target = GetHitUnit())
|
|
if (Unit* caster = GetCaster())
|
|
{
|
|
if (Unit* owner = caster->GetOwner())
|
|
{
|
|
if (triggeringSpell)
|
|
damage = int32(owner->SpellHealingBonusDone(target, triggeringSpell, damage, HEAL));
|
|
|
|
// Restorative Totems
|
|
if (AuraEffect* dummy = owner->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, SHAMAN_ICON_ID_RESTORATIVE_TOTEMS, 1))
|
|
AddPct(damage, dummy->GetAmount());
|
|
|
|
// Glyph of Healing Stream Totem
|
|
if (AuraEffect const* aurEff = owner->GetAuraEffect(SPELL_SHAMAN_GLYPH_OF_HEALING_STREAM_TOTEM, EFFECT_0))
|
|
AddPct(damage, aurEff->GetAmount());
|
|
|
|
damage = int32(target->SpellHealingBonusTaken(owner, triggeringSpell, damage, HEAL));
|
|
}
|
|
caster->CastCustomSpell(target, SPELL_SHAMAN_TOTEM_HEALING_STREAM_HEAL, &damage, 0, 0, true, 0, 0, GetOriginalCaster()->GetGUID());
|
|
}
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_sha_healing_stream_totem_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_healing_stream_totem_SpellScript();
|
|
}
|
|
};
|
|
|
|
// 32182 - Heroism
|
|
class spell_sha_heroism : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_heroism() : SpellScriptLoader("spell_sha_heroism") { }
|
|
|
|
class spell_sha_heroism_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_heroism_SpellScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_EXHAUSTION))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void RemoveInvalidTargets(std::list<WorldObject*>& targets)
|
|
{
|
|
targets.remove_if(Trinity::UnitAuraCheck(true, SPELL_SHAMAN_EXHAUSTION));
|
|
}
|
|
|
|
void ApplyDebuff()
|
|
{
|
|
if (Unit* target = GetHitUnit())
|
|
target->CastSpell(target, SPELL_SHAMAN_EXHAUSTION, true);
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_sha_heroism_SpellScript::RemoveInvalidTargets, EFFECT_0, TARGET_UNIT_CASTER_AREA_RAID);
|
|
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_sha_heroism_SpellScript::RemoveInvalidTargets, EFFECT_1, TARGET_UNIT_CASTER_AREA_RAID);
|
|
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_sha_heroism_SpellScript::RemoveInvalidTargets, EFFECT_2, TARGET_UNIT_CASTER_AREA_RAID);
|
|
AfterHit += SpellHitFn(spell_sha_heroism_SpellScript::ApplyDebuff);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_heroism_SpellScript();
|
|
}
|
|
};
|
|
|
|
// 23551 - Lightning Shield
|
|
class spell_sha_item_lightning_shield : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_item_lightning_shield() : SpellScriptLoader("spell_sha_item_lightning_shield") { }
|
|
|
|
class spell_sha_item_lightning_shield_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_sha_item_lightning_shield_AuraScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_ITEM_LIGHTNING_SHIELD))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_SHAMAN_ITEM_LIGHTNING_SHIELD, true, NULL, aurEff);
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnEffectProc += AuraEffectProcFn(spell_sha_item_lightning_shield_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_item_lightning_shield_AuraScript();
|
|
}
|
|
};
|
|
|
|
// 23552 - Lightning Shield
|
|
class spell_sha_item_lightning_shield_trigger : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_item_lightning_shield_trigger() : SpellScriptLoader("spell_sha_item_lightning_shield_trigger") { }
|
|
|
|
class spell_sha_item_lightning_shield_trigger_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_sha_item_lightning_shield_trigger_AuraScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_ITEM_MANA_SURGE))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/)
|
|
{
|
|
PreventDefaultAction();
|
|
GetTarget()->CastSpell(GetTarget(), SPELL_SHAMAN_ITEM_LIGHTNING_SHIELD_DAMAGE, true, NULL, aurEff);
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnEffectProc += AuraEffectProcFn(spell_sha_item_lightning_shield_trigger_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_item_lightning_shield_trigger_AuraScript();
|
|
}
|
|
};
|
|
|
|
// 23572 - Mana Surge
|
|
class spell_sha_item_mana_surge : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_item_mana_surge() : SpellScriptLoader("spell_sha_item_mana_surge") { }
|
|
|
|
class spell_sha_item_mana_surge_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_sha_item_mana_surge_AuraScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_ITEM_LIGHTNING_SHIELD_DAMAGE))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool CheckProc(ProcEventInfo& eventInfo)
|
|
{
|
|
return eventInfo.GetDamageInfo()->GetSpellInfo();
|
|
}
|
|
|
|
void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
int32 mana = eventInfo.GetDamageInfo()->GetSpellInfo()->CalcPowerCost(GetTarget(), eventInfo.GetSchoolMask());
|
|
int32 damage = CalculatePct(mana, 35);
|
|
|
|
GetTarget()->CastCustomSpell(SPELL_SHAMAN_ITEM_MANA_SURGE, SPELLVALUE_BASE_POINT0, damage, GetTarget(), true, NULL, aurEff);
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
DoCheckProc += AuraCheckProcFn(spell_sha_item_mana_surge_AuraScript::CheckProc);
|
|
OnEffectProc += AuraEffectProcFn(spell_sha_item_mana_surge_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_item_mana_surge_AuraScript();
|
|
}
|
|
};
|
|
|
|
// 60103 - Lava Lash
|
|
class spell_sha_lava_lash : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_lava_lash() : SpellScriptLoader("spell_sha_lava_lash") { }
|
|
|
|
class spell_sha_lava_lash_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_lava_lash_SpellScript)
|
|
|
|
bool Load() OVERRIDE
|
|
{
|
|
return GetCaster()->GetTypeId() == TYPEID_PLAYER;
|
|
}
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
if (Player* caster = GetCaster()->ToPlayer())
|
|
{
|
|
int32 damage = GetEffectValue();
|
|
int32 hitDamage = GetHitDamage();
|
|
if (caster->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND))
|
|
{
|
|
// Damage is increased by 25% if your off-hand weapon is enchanted with Flametongue.
|
|
if (caster->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, 0x200000, 0, 0))
|
|
AddPct(hitDamage, damage);
|
|
SetHitDamage(hitDamage);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_sha_lava_lash_SpellScript::HandleDummy, EFFECT_1, SPELL_EFFECT_DUMMY);
|
|
}
|
|
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_lava_lash_SpellScript();
|
|
}
|
|
};
|
|
|
|
// 52031, 52033, 52034, 52035, 52036, 58778, 58779, 58780 - Mana Spring Totem
|
|
class spell_sha_mana_spring_totem : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_mana_spring_totem() : SpellScriptLoader("spell_sha_mana_spring_totem") { }
|
|
|
|
class spell_sha_mana_spring_totem_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_mana_spring_totem_SpellScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_MANA_SPRING_TOTEM_ENERGIZE))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
int32 damage = GetEffectValue();
|
|
if (Unit* target = GetHitUnit())
|
|
if (Unit* caster = GetCaster())
|
|
if (target->getPowerType() == POWER_MANA)
|
|
caster->CastCustomSpell(target, SPELL_SHAMAN_MANA_SPRING_TOTEM_ENERGIZE, &damage, 0, 0, true, 0, 0, GetOriginalCaster()->GetGUID());
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_sha_mana_spring_totem_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
}
|
|
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_mana_spring_totem_SpellScript();
|
|
}
|
|
};
|
|
|
|
// 39610 - Mana Tide Totem
|
|
class spell_sha_mana_tide_totem : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_mana_tide_totem() : SpellScriptLoader("spell_sha_mana_tide_totem") { }
|
|
|
|
class spell_sha_mana_tide_totem_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_mana_tide_totem_SpellScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellInfo*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_GLYPH_OF_MANA_TIDE) || !sSpellMgr->GetSpellInfo(SPELL_SHAMAN_MANA_TIDE_TOTEM))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
if (Unit* caster = GetCaster())
|
|
if (Unit* unitTarget = GetHitUnit())
|
|
{
|
|
if (unitTarget->getPowerType() == POWER_MANA)
|
|
{
|
|
int32 effValue = GetEffectValue();
|
|
// Glyph of Mana Tide
|
|
if (Unit* owner = caster->GetOwner())
|
|
if (AuraEffect* dummy = owner->GetAuraEffect(SPELL_SHAMAN_GLYPH_OF_MANA_TIDE, 0))
|
|
effValue += dummy->GetAmount();
|
|
// Regenerate 6% of Total Mana Every 3 secs
|
|
int32 effBasePoints0 = int32(CalculatePct(unitTarget->GetMaxPower(POWER_MANA), effValue));
|
|
caster->CastCustomSpell(unitTarget, SPELL_SHAMAN_MANA_TIDE_TOTEM, &effBasePoints0, NULL, NULL, true, NULL, NULL, GetOriginalCaster()->GetGUID());
|
|
}
|
|
}
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_sha_mana_tide_totem_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_mana_tide_totem_SpellScript();
|
|
}
|
|
};
|
|
|
|
// 6495 - Sentry Totem
|
|
class spell_sha_sentry_totem : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_sentry_totem() : SpellScriptLoader("spell_sha_sentry_totem") { }
|
|
|
|
class spell_sha_sentry_totem_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_sha_sentry_totem_AuraScript);
|
|
|
|
bool Validate(SpellInfo const* /*spell*/) OVERRIDE
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_BIND_SIGHT))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void AfterApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
|
|
{
|
|
if (Unit* caster = GetCaster())
|
|
if (Creature* totem = caster->GetMap()->GetCreature(caster->m_SummonSlot[4]))
|
|
if (totem->IsTotem())
|
|
caster->CastSpell(totem, SPELL_SHAMAN_BIND_SIGHT, true);
|
|
}
|
|
|
|
void AfterRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
|
|
{
|
|
if (Unit* caster = GetCaster())
|
|
if (caster->GetTypeId() == TYPEID_PLAYER)
|
|
caster->ToPlayer()->StopCastingBindSight();
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
AfterEffectApply += AuraEffectApplyFn(spell_sha_sentry_totem_AuraScript::AfterApply, EFFECT_1, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
|
|
AfterEffectRemove += AuraEffectRemoveFn(spell_sha_sentry_totem_AuraScript::AfterRemove, EFFECT_1, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_sentry_totem_AuraScript();
|
|
}
|
|
};
|
|
|
|
// -51490 - Thunderstorm
|
|
class spell_sha_thunderstorm : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_sha_thunderstorm() : SpellScriptLoader("spell_sha_thunderstorm") { }
|
|
|
|
class spell_sha_thunderstorm_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_sha_thunderstorm_SpellScript);
|
|
|
|
void HandleKnockBack(SpellEffIndex effIndex)
|
|
{
|
|
// Glyph of Thunderstorm
|
|
if (GetCaster()->HasAura(SPELL_SHAMAN_GLYPH_OF_THUNDERSTORM))
|
|
PreventHitDefaultEffect(effIndex);
|
|
}
|
|
|
|
void Register() OVERRIDE
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_sha_thunderstorm_SpellScript::HandleKnockBack, EFFECT_2, SPELL_EFFECT_KNOCK_BACK);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const OVERRIDE
|
|
{
|
|
return new spell_sha_thunderstorm_SpellScript();
|
|
}
|
|
};
|
|
|
|
void AddSC_shaman_spell_scripts()
|
|
{
|
|
new spell_sha_ancestral_awakening_proc();
|
|
new spell_sha_astral_shift();
|
|
new spell_sha_bloodlust();
|
|
new spell_sha_chain_heal();
|
|
new spell_sha_cleansing_totem_pulse();
|
|
new spell_sha_earth_shield();
|
|
new spell_sha_earthbind_totem();
|
|
new spell_sha_earthen_power();
|
|
new spell_sha_fire_nova();
|
|
new spell_sha_flame_shock();
|
|
new spell_sha_healing_stream_totem();
|
|
new spell_sha_heroism();
|
|
new spell_sha_item_lightning_shield();
|
|
new spell_sha_item_lightning_shield_trigger();
|
|
new spell_sha_item_mana_surge();
|
|
new spell_sha_lava_lash();
|
|
new spell_sha_mana_spring_totem();
|
|
new spell_sha_mana_tide_totem();
|
|
new spell_sha_sentry_totem();
|
|
new spell_sha_thunderstorm();
|
|
}
|