mirror of
https://github.com/araxiaonline/TrinityCore.git
synced 2026-06-15 12:42:43 -04:00
55ce180f28
- Logging System is asyncronous to improve performance.
- Each msg and Logger has a Log Type and Log Level assigned. Each msg is assigned the Logger of same Log Type or "root" Logger is selected if there is no Logger configured for the given Log Type
- Loggers have a list of Appenders to send the msg to. The Msg in the Logger is not sent to Appenders if the msg LogLevel is lower than Logger LogLevel.
- There are three (at the moment) types of Appenders: Console, File or DB (this is WIP, not working ATM). Msg is not written to the resource if msg LogLevel is lower than Appender LogLevel.
- Appender and Console Log levels can be changed while server is active with command '.set loglevel (a/l) name level'
Explanation of use with Sample config:
Appender.Console.Type=1 (1 = Console)
Appender.Console.Level=2 (2 = Debug)
Appender.Server.Type=2 (2 = File)
Appender.Server.Level=3 (3 = Info)
Appender.Server.File=Server.log
Appender.SQL.Type=2 (2 = File)
Appender.SQL.Level=1 (1 = Trace)
Appender.SQL.File=sql.log
Appenders=Console Server (NOTE: SQL has not been included here... that will make core ignore the config for "SQL" as it's not in this list)
Logger.root.Type=0 (0 = Default - if it's not created by config, server will create it with LogLevel = DISABLED)
Logger.root.Level=5 (5 = Error)
Logger.root.Appenders=Console
Logger.SQL.Type=26 (26 = SQL)
Logger.SQL.Level=3 (2 = Debug)
Logger.SQL.Appenders=Console Server SQL
Logger.SomeRandomName.Type=24 (24 = Guild)
Logger.SomeRandomName.Level=5 (5 = Error)
Loggers=root SQL SomeRandomName
* At loading Appender SQL will be ignored, as it's not present on "Appenders"
* sLog->outDebug(LOG_FILTER_GUILD, "Some log msg related to Guilds")
- Msg is sent to Logger of Type LOG_FILTER_GUILD (24). Logger with name SomeRandomName is found but it's LogLevel = 5 and Msg LogLevel=2... Msg is not logged
* sLog->outError(LOG_FILTER_GUILD, "Some error log msg related to Guilds")
- Msg is sent to Logger of Type LOG_FILTER_GUILD (24). Logger with name SomeRandomeName is found with proper LogLevel but Logger does not have any Appenders assigned to that logger... Msg is not logged
* sLog->outDebug(LOG_FILTER_SQL, "Some msg related to SQLs")
- Msg is sent to Logger SQL (matches type), as it matches LogLevel the msg is sent to Appenders Console, Server and SQL
- Appender Console has lower Log Level: Msg is logged to Console
- Appender Server has higher Log Level: Msg is not logged to file
- Appender SQL has lower Log Level: Msg is logged to file sql.log
* sLog->outDebug(LOG_FILTER_BATTLEGROUND, "Some msg related to Battelgrounds")
- Msg is sent to Logger root (Type 0) as no Logger was found with Type LOG_FILTER_BATTLEGROUND (13). As Logger has higher LogLevel msg is not sent to any appender
* sLog->outError(LOG_FILTER_BATTLEGROUND, "Some error msg related to Battelgrounds")
- Msg is sent to Logger root (Type 0) as no Logger was found with Type LOG_FILTER_BATTLEGROUND (13). Msg has lower LogLevel and is sent to Appender Console
- Appender Console has lower LogLevel: Msg is logged to Console
690 lines
26 KiB
C++
690 lines
26 KiB
C++
/*
|
|
* Copyright (C) 2008-2012 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_WARLOCK and SPELLFAMILY_GENERIC spells used by warlock players.
|
|
* Ordered alphabetically using scriptname.
|
|
* Scriptnames of files in this file should be prefixed with "spell_warl_".
|
|
*/
|
|
|
|
#include "ScriptMgr.h"
|
|
#include "SpellScript.h"
|
|
#include "SpellAuraEffects.h"
|
|
|
|
enum WarlockSpells
|
|
{
|
|
WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS = 54435,
|
|
WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER = 54443,
|
|
WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD = 54508,
|
|
WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER = 54509,
|
|
WARLOCK_DEMONIC_EMPOWERMENT_IMP = 54444,
|
|
WARLOCK_IMPROVED_HEALTHSTONE_R1 = 18692,
|
|
WARLOCK_IMPROVED_HEALTHSTONE_R2 = 18693,
|
|
WARLOCK_DEMONIC_CIRCLE_SUMMON = 48018,
|
|
WARLOCK_DEMONIC_CIRCLE_TELEPORT = 48020,
|
|
WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST = 62388,
|
|
WARLOCK_HAUNT = 48181,
|
|
WARLOCK_HAUNT_HEAL = 48210,
|
|
WARLOCK_UNSTABLE_AFFLICTION_DISPEL = 31117,
|
|
WARLOCK_CURSE_OF_DOOM_EFFECT = 18662,
|
|
};
|
|
|
|
class spell_warl_banish : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_banish() : SpellScriptLoader("spell_warl_banish") { }
|
|
|
|
class spell_warl_banish_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_warl_banish_SpellScript);
|
|
|
|
bool Load()
|
|
{
|
|
_removed = false;
|
|
return true;
|
|
}
|
|
|
|
void HandleBanish()
|
|
{
|
|
if (Unit* target = GetHitUnit())
|
|
{
|
|
if (target->GetAuraEffect(SPELL_AURA_SCHOOL_IMMUNITY, SPELLFAMILY_WARLOCK, 0, 0x08000000, 0))
|
|
{
|
|
//No need to remove old aura since its removed due to not stack by current Banish aura
|
|
PreventHitDefaultEffect(EFFECT_0);
|
|
PreventHitDefaultEffect(EFFECT_1);
|
|
PreventHitDefaultEffect(EFFECT_2);
|
|
_removed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void RemoveAura()
|
|
{
|
|
if (_removed)
|
|
PreventHitAura();
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
BeforeHit += SpellHitFn(spell_warl_banish_SpellScript::HandleBanish);
|
|
AfterHit += SpellHitFn(spell_warl_banish_SpellScript::RemoveAura);
|
|
}
|
|
|
|
bool _removed;
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_warl_banish_SpellScript();
|
|
}
|
|
};
|
|
|
|
// 47193 Demonic Empowerment
|
|
class spell_warl_demonic_empowerment : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_demonic_empowerment() : SpellScriptLoader("spell_warl_demonic_empowerment") { }
|
|
|
|
class spell_warl_demonic_empowerment_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_warl_demonic_empowerment_SpellScript);
|
|
|
|
bool Validate(SpellInfo const* /*spellEntry*/)
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_IMP))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleScriptEffect(SpellEffIndex /*effIndex*/)
|
|
{
|
|
if (Creature* targetCreature = GetHitCreature())
|
|
{
|
|
if (targetCreature->isPet())
|
|
{
|
|
CreatureTemplate const* ci = sObjectMgr->GetCreatureTemplate(targetCreature->GetEntry());
|
|
switch (ci->family)
|
|
{
|
|
case CREATURE_FAMILY_SUCCUBUS:
|
|
targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS, true);
|
|
break;
|
|
case CREATURE_FAMILY_VOIDWALKER:
|
|
{
|
|
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER);
|
|
int32 hp = int32(targetCreature->CountPctFromMaxHealth(GetCaster()->CalculateSpellDamage(targetCreature, spellInfo, 0)));
|
|
targetCreature->CastCustomSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER, &hp, NULL, NULL, true);
|
|
//unitTarget->CastSpell(unitTarget, 54441, true);
|
|
break;
|
|
}
|
|
case CREATURE_FAMILY_FELGUARD:
|
|
targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD, true);
|
|
break;
|
|
case CREATURE_FAMILY_FELHUNTER:
|
|
targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER, true);
|
|
break;
|
|
case CREATURE_FAMILY_IMP:
|
|
targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_IMP, true);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_warl_demonic_empowerment_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_warl_demonic_empowerment_SpellScript();
|
|
}
|
|
};
|
|
|
|
// 6201 Create Healthstone (and ranks)
|
|
class spell_warl_create_healthstone : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_create_healthstone() : SpellScriptLoader("spell_warl_create_healthstone") { }
|
|
|
|
class spell_warl_create_healthstone_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_warl_create_healthstone_SpellScript);
|
|
|
|
static uint32 const iTypes[8][3];
|
|
|
|
bool Validate(SpellInfo const* /*spellEntry*/)
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(WARLOCK_IMPROVED_HEALTHSTONE_R1) || !sSpellMgr->GetSpellInfo(WARLOCK_IMPROVED_HEALTHSTONE_R2))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
SpellCastResult CheckCast()
|
|
{
|
|
if (Player* caster = GetCaster()->ToPlayer())
|
|
{
|
|
uint8 spellRank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id);
|
|
ItemPosCountVec dest;
|
|
InventoryResult msg = caster->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, iTypes[spellRank - 1][0], 1, NULL);
|
|
if (msg != EQUIP_ERR_OK)
|
|
return SPELL_FAILED_TOO_MANY_OF_ITEM;
|
|
}
|
|
return SPELL_CAST_OK;
|
|
}
|
|
|
|
void HandleScriptEffect(SpellEffIndex effIndex)
|
|
{
|
|
if (Unit* unitTarget = GetHitUnit())
|
|
{
|
|
uint32 rank = 0;
|
|
// Improved Healthstone
|
|
if (AuraEffect const* aurEff = unitTarget->GetDummyAuraEffect(SPELLFAMILY_WARLOCK, 284, 0))
|
|
{
|
|
switch (aurEff->GetId())
|
|
{
|
|
case WARLOCK_IMPROVED_HEALTHSTONE_R1: rank = 1; break;
|
|
case WARLOCK_IMPROVED_HEALTHSTONE_R2: rank = 2; break;
|
|
default:
|
|
sLog->outError(LOG_FILTER_SPELLS_AURAS, "Unknown rank of Improved Healthstone id: %d", aurEff->GetId());
|
|
break;
|
|
}
|
|
}
|
|
uint8 spellRank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id);
|
|
if (spellRank > 0 && spellRank <= 8)
|
|
CreateItem(effIndex, iTypes[spellRank - 1][rank]);
|
|
}
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_warl_create_healthstone_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
|
|
OnCheckCast += SpellCheckCastFn(spell_warl_create_healthstone_SpellScript::CheckCast);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_warl_create_healthstone_SpellScript();
|
|
}
|
|
};
|
|
|
|
uint32 const spell_warl_create_healthstone::spell_warl_create_healthstone_SpellScript::iTypes[8][3] = {
|
|
{ 5512, 19004, 19005}, // Minor Healthstone
|
|
{ 5511, 19006, 19007}, // Lesser Healthstone
|
|
{ 5509, 19008, 19009}, // Healthstone
|
|
{ 5510, 19010, 19011}, // Greater Healthstone
|
|
{ 9421, 19012, 19013}, // Major Healthstone
|
|
{22103, 22104, 22105}, // Master Healthstone
|
|
{36889, 36890, 36891}, // Demonic Healthstone
|
|
{36892, 36893, 36894} // Fel Healthstone
|
|
};
|
|
|
|
// 47422 Everlasting Affliction
|
|
class spell_warl_everlasting_affliction : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_everlasting_affliction() : SpellScriptLoader("spell_warl_everlasting_affliction") { }
|
|
|
|
class spell_warl_everlasting_affliction_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_warl_everlasting_affliction_SpellScript);
|
|
|
|
void HandleScriptEffect(SpellEffIndex /*effIndex*/)
|
|
{
|
|
if (Unit* unitTarget = GetHitUnit())
|
|
// Refresh corruption on target
|
|
if (AuraEffect* aur = unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_WARLOCK, 0x2, 0, 0, GetCaster()->GetGUID()))
|
|
aur->GetBase()->RefreshDuration();
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_warl_everlasting_affliction_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_warl_everlasting_affliction_SpellScript();
|
|
}
|
|
};
|
|
|
|
// 18541 Ritual of Doom Effect
|
|
class spell_warl_ritual_of_doom_effect : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_ritual_of_doom_effect() : SpellScriptLoader("spell_warl_ritual_of_doom_effect") { }
|
|
|
|
class spell_warl_ritual_of_doom_effect_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_warl_ritual_of_doom_effect_SpellScript);
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
Unit* caster = GetCaster();
|
|
caster->CastSpell(caster, GetEffectValue(), true);
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnEffectHit += SpellEffectFn(spell_warl_ritual_of_doom_effect_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_warl_ritual_of_doom_effect_SpellScript();
|
|
}
|
|
};
|
|
|
|
class spell_warl_seed_of_corruption : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_seed_of_corruption() : SpellScriptLoader("spell_warl_seed_of_corruption") { }
|
|
|
|
class spell_warl_seed_of_corruption_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_warl_seed_of_corruption_SpellScript);
|
|
|
|
void FilterTargets(std::list<WorldObject*>& targets)
|
|
{
|
|
if (GetExplTargetUnit())
|
|
targets.remove(GetExplTargetUnit());
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warl_seed_of_corruption_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_DEST_AREA_ENEMY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_warl_seed_of_corruption_SpellScript();
|
|
}
|
|
};
|
|
|
|
enum Soulshatter
|
|
{
|
|
SPELL_SOULSHATTER = 32835,
|
|
};
|
|
|
|
class spell_warl_soulshatter : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_soulshatter() : SpellScriptLoader("spell_warl_soulshatter") { }
|
|
|
|
class spell_warl_soulshatter_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_warl_soulshatter_SpellScript);
|
|
|
|
bool Validate(SpellInfo const* /*spell*/)
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_SOULSHATTER))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
Unit* caster = GetCaster();
|
|
if (Unit* target = GetHitUnit())
|
|
{
|
|
if (target->CanHaveThreatList() && target->getThreatManager().getThreat(caster) > 0.0f)
|
|
caster->CastSpell(target, SPELL_SOULSHATTER, true);
|
|
}
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_warl_soulshatter_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_warl_soulshatter_SpellScript();
|
|
}
|
|
};
|
|
|
|
enum LifeTap
|
|
{
|
|
SPELL_LIFE_TAP_ENERGIZE = 31818,
|
|
SPELL_LIFE_TAP_ENERGIZE_2 = 32553,
|
|
ICON_ID_IMPROVED_LIFE_TAP = 208,
|
|
ICON_ID_MANA_FEED = 1982,
|
|
};
|
|
|
|
class spell_warl_life_tap : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_life_tap() : SpellScriptLoader("spell_warl_life_tap") { }
|
|
|
|
class spell_warl_life_tap_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_warl_life_tap_SpellScript);
|
|
|
|
bool Load()
|
|
{
|
|
return GetCaster()->GetTypeId() == TYPEID_PLAYER;
|
|
}
|
|
|
|
bool Validate(SpellInfo const* /*spell*/)
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_LIFE_TAP_ENERGIZE) || !sSpellMgr->GetSpellInfo(SPELL_LIFE_TAP_ENERGIZE_2))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
Player* caster = GetCaster()->ToPlayer();
|
|
if (Unit* target = GetHitUnit())
|
|
{
|
|
int32 damage = GetEffectValue();
|
|
int32 mana = int32(damage + (caster->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS+SPELL_SCHOOL_SHADOW) * 0.5f));
|
|
|
|
// Shouldn't Appear in Combat Log
|
|
target->ModifyHealth(-damage);
|
|
|
|
// Improved Life Tap mod
|
|
if (AuraEffect const* aurEff = caster->GetDummyAuraEffect(SPELLFAMILY_WARLOCK, ICON_ID_IMPROVED_LIFE_TAP, 0))
|
|
AddPctN(mana, aurEff->GetAmount());
|
|
|
|
caster->CastCustomSpell(target, SPELL_LIFE_TAP_ENERGIZE, &mana, NULL, NULL, false);
|
|
|
|
// Mana Feed
|
|
int32 manaFeedVal = 0;
|
|
if (AuraEffect const* aurEff = caster->GetAuraEffect(SPELL_AURA_ADD_FLAT_MODIFIER, SPELLFAMILY_WARLOCK, ICON_ID_MANA_FEED, 0))
|
|
manaFeedVal = aurEff->GetAmount();
|
|
|
|
if (manaFeedVal > 0)
|
|
{
|
|
ApplyPctN(manaFeedVal, mana);
|
|
caster->CastCustomSpell(caster, SPELL_LIFE_TAP_ENERGIZE_2, &manaFeedVal, NULL, NULL, true, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
SpellCastResult CheckCast()
|
|
{
|
|
if ((int32(GetCaster()->GetHealth()) > int32(GetSpellInfo()->Effects[EFFECT_0].CalcValue() + (6.3875 * GetSpellInfo()->BaseLevel))))
|
|
return SPELL_CAST_OK;
|
|
return SPELL_FAILED_FIZZLE;
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_warl_life_tap_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
OnCheckCast += SpellCheckCastFn(spell_warl_life_tap_SpellScript::CheckCast);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_warl_life_tap_SpellScript();
|
|
}
|
|
};
|
|
|
|
class spell_warl_demonic_circle_summon : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_demonic_circle_summon() : SpellScriptLoader("spell_warl_demonic_circle_summon") { }
|
|
|
|
class spell_warl_demonic_circle_summon_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_warl_demonic_circle_summon_AuraScript);
|
|
|
|
void HandleRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes mode)
|
|
{
|
|
// If effect is removed by expire remove the summoned demonic circle too.
|
|
if (!(mode & AURA_EFFECT_HANDLE_REAPPLY))
|
|
GetTarget()->RemoveGameObject(GetId(), true);
|
|
|
|
GetTarget()->RemoveAura(WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST);
|
|
}
|
|
|
|
void HandleDummyTick(AuraEffect const* /*aurEff*/)
|
|
{
|
|
if (GameObject* circle = GetTarget()->GetGameObject(GetId()))
|
|
{
|
|
// Here we check if player is in demonic circle teleport range, if so add
|
|
// WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST; allowing him to cast the WARLOCK_DEMONIC_CIRCLE_TELEPORT.
|
|
// If not in range remove the WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST.
|
|
|
|
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_CIRCLE_TELEPORT);
|
|
|
|
if (GetTarget()->IsWithinDist(circle, spellInfo->GetMaxRange(true)))
|
|
{
|
|
if (!GetTarget()->HasAura(WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST))
|
|
GetTarget()->CastSpell(GetTarget(), WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST, true);
|
|
}
|
|
else
|
|
GetTarget()->RemoveAura(WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST);
|
|
}
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnEffectRemove += AuraEffectApplyFn(spell_warl_demonic_circle_summon_AuraScript::HandleRemove, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
|
|
OnEffectPeriodic += AuraEffectPeriodicFn(spell_warl_demonic_circle_summon_AuraScript::HandleDummyTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const
|
|
{
|
|
return new spell_warl_demonic_circle_summon_AuraScript();
|
|
}
|
|
};
|
|
|
|
class spell_warl_demonic_circle_teleport : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_demonic_circle_teleport() : SpellScriptLoader("spell_warl_demonic_circle_teleport") { }
|
|
|
|
class spell_warl_demonic_circle_teleport_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_warl_demonic_circle_teleport_AuraScript);
|
|
|
|
void HandleTeleport(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
|
|
{
|
|
if (Player* player = GetTarget()->ToPlayer())
|
|
{
|
|
if (GameObject* circle = player->GetGameObject(WARLOCK_DEMONIC_CIRCLE_SUMMON))
|
|
{
|
|
player->NearTeleportTo(circle->GetPositionX(), circle->GetPositionY(), circle->GetPositionZ(), circle->GetOrientation());
|
|
player->RemoveMovementImpairingAuras();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnEffectApply += AuraEffectApplyFn(spell_warl_demonic_circle_teleport_AuraScript::HandleTeleport, EFFECT_0, SPELL_AURA_MECHANIC_IMMUNITY, AURA_EFFECT_HANDLE_REAL);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const
|
|
{
|
|
return new spell_warl_demonic_circle_teleport_AuraScript();
|
|
}
|
|
};
|
|
|
|
class spell_warl_haunt : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_haunt() : SpellScriptLoader("spell_warl_haunt") { }
|
|
|
|
class spell_warl_haunt_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_warl_haunt_SpellScript);
|
|
|
|
void HandleOnHit()
|
|
{
|
|
if (Aura* aura = GetHitAura())
|
|
if (AuraEffect* aurEff = aura->GetEffect(EFFECT_1))
|
|
aurEff->SetAmount(CalculatePctN(aurEff->GetAmount(), GetHitDamage()));
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnHit += SpellHitFn(spell_warl_haunt_SpellScript::HandleOnHit);
|
|
}
|
|
};
|
|
|
|
class spell_warl_haunt_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_warl_haunt_AuraScript);
|
|
|
|
bool Validate(SpellInfo const* /*spell*/)
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(WARLOCK_HAUNT_HEAL))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
|
|
{
|
|
if (Unit* caster = GetCaster())
|
|
{
|
|
int32 amount = aurEff->GetAmount();
|
|
GetTarget()->CastCustomSpell(caster, WARLOCK_HAUNT_HEAL, &amount, NULL, NULL, true, NULL, aurEff, GetCasterGUID());
|
|
}
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnEffectRemove += AuraEffectApplyFn(spell_warl_haunt_AuraScript::HandleRemove, EFFECT_1, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_warl_haunt_SpellScript();
|
|
}
|
|
|
|
AuraScript* GetAuraScript() const
|
|
{
|
|
return new spell_warl_haunt_AuraScript();
|
|
}
|
|
};
|
|
|
|
class spell_warl_unstable_affliction : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_unstable_affliction() : SpellScriptLoader("spell_warl_unstable_affliction") { }
|
|
|
|
class spell_warl_unstable_affliction_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_warl_unstable_affliction_AuraScript);
|
|
|
|
bool Validate(SpellInfo const* /*spell*/)
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(WARLOCK_UNSTABLE_AFFLICTION_DISPEL))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleDispel(DispelInfo* dispelInfo)
|
|
{
|
|
if (Unit* caster = GetCaster())
|
|
if (AuraEffect const* aurEff = GetEffect(EFFECT_0))
|
|
{
|
|
int32 damage = aurEff->GetAmount() * 9;
|
|
// backfire damage and silence
|
|
caster->CastCustomSpell(dispelInfo->GetDispeller(), WARLOCK_UNSTABLE_AFFLICTION_DISPEL, &damage, NULL, NULL, true, NULL, aurEff);
|
|
}
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
AfterDispel += AuraDispelFn(spell_warl_unstable_affliction_AuraScript::HandleDispel);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const
|
|
{
|
|
return new spell_warl_unstable_affliction_AuraScript();
|
|
}
|
|
};
|
|
|
|
class spell_warl_curse_of_doom : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_warl_curse_of_doom() : SpellScriptLoader("spell_warl_curse_of_doom") { }
|
|
|
|
class spell_warl_curse_of_doom_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_warl_curse_of_doom_AuraScript);
|
|
|
|
bool Validate(SpellInfo const* /*spell*/)
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(WARLOCK_CURSE_OF_DOOM_EFFECT))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool Load()
|
|
{
|
|
return GetCaster() && GetCaster()->GetTypeId() == TYPEID_PLAYER;
|
|
}
|
|
|
|
void OnRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
|
|
{
|
|
if (!GetCaster())
|
|
return;
|
|
|
|
AuraRemoveMode removeMode = GetTargetApplication()->GetRemoveMode();
|
|
if (removeMode != AURA_REMOVE_BY_DEATH || !IsExpired())
|
|
return;
|
|
|
|
if (GetCaster()->ToPlayer()->isHonorOrXPTarget(GetTarget()))
|
|
GetCaster()->CastSpell(GetTarget(), WARLOCK_CURSE_OF_DOOM_EFFECT, true, NULL, aurEff);
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
AfterEffectRemove += AuraEffectRemoveFn(spell_warl_curse_of_doom_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE, AURA_EFFECT_HANDLE_REAL);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const
|
|
{
|
|
return new spell_warl_curse_of_doom_AuraScript();
|
|
}
|
|
};
|
|
|
|
void AddSC_warlock_spell_scripts()
|
|
{
|
|
new spell_warl_banish();
|
|
new spell_warl_demonic_empowerment();
|
|
new spell_warl_create_healthstone();
|
|
new spell_warl_everlasting_affliction();
|
|
new spell_warl_ritual_of_doom_effect();
|
|
new spell_warl_seed_of_corruption();
|
|
new spell_warl_soulshatter();
|
|
new spell_warl_life_tap();
|
|
new spell_warl_demonic_circle_summon();
|
|
new spell_warl_demonic_circle_teleport();
|
|
new spell_warl_haunt();
|
|
new spell_warl_unstable_affliction();
|
|
new spell_warl_curse_of_doom();
|
|
}
|