nchebrov/azerothcore-wotlk
1
0
Fork 0
mirror of https://github.com/mod-playerbots/azerothcore-wotlk.git synced 2026-01-22 05:06:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Big re-organization of repository [W.I.P]

Browse Source
This commit is contained in:
Yehonal
2016-08-11 20:25:27 +02:00
parent c62a72c0a8
commit 0f85ce1c54
3016 changed files with 1271 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
src/server/scripts/Outland/BlackTemple/black_temple.h
View File

@@ -1,80 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#ifndef BLACK_TEMPLE_H_
#define BLACK_TEMPLE_H_
enum DataTypes
{
DATA_HIGH_WARLORD_NAJENTUS = 0,
DATA_SUPREMUS = 1,
DATA_SHADE_OF_AKAMA = 2,
DATA_TERON_GOREFIEND = 3,
DATA_GURTOGG_BLOODBOIL = 4,
DATA_RELIQUARY_OF_SOULS = 5,
DATA_MOTHER_SHAHRAZ = 6,
DATA_ILLIDARI_COUNCIL = 7,
DATA_AKAMA_FINISHED = 8,
DATA_ILLIDAN_STORMRAGE = 9,
MAX_ENCOUNTERS = 10
};
enum CreatureIds
{
NPC_SHADE_OF_AKAMA = 22841,
NPC_AKAMA_SHADE = 23191,
NPC_STORM_FURY = 22848,
NPC_TERON_GOREFIEND = 22871,
NPC_VENGEFUL_SPIRIT = 23109,
NPC_SHADOWY_CONSTRUCT = 23111,
NPC_ANGERED_SOUL_FRAGMENT = 23398,
NPC_HUNGERING_SOUL_FRAGMENT = 23401,
NPC_SUFFERING_SOUL_FRAGMENT = 23399,
NPC_RELIQUARY_OF_THE_LOST = 22856,
NPC_ENSLAVED_SOUL = 23469,
NPC_GATHIOS_THE_SHATTERER = 22949,
NPC_HIGH_NETHERMANCER_ZEREVOR = 22950,
NPC_LADY_MALANDE = 22951,
NPC_VERAS_DARKSHADOW = 22952,
NPC_ILLIDARI_COUNCIL = 23426,
NPC_AKAMA = 23089,
NPC_ILLIDAN_STORMRAGE = 22917,
NPC_PARASITIC_SHADOWFIEND = 23498,
NPC_BLADE_OF_AZZINOTH = 22996,
NPC_FLAME_OF_AZZINOTH = 22997,
NPC_DRAGON_TURTLE = 22885
};
enum GameObjectIds
{
GO_NAJENTUS_GATE = 185483,
GO_SUPREMUS_GATE = 185882,
GO_SHADE_OF_AKAMA_DOOR = 185478,
GO_TERON_DOOR_1 = 185480,
GO_TERON_DOOR_2 = 186153,
GO_GURTOGG_DOOR = 185892,
GO_TEMPLE_DOOR = 185479,
GO_MOTHER_SHAHRAZ_DOOR = 185482,
GO_COUNCIL_DOOR_1 = 185481,
GO_COUNCIL_DOOR_2 = 186152,
GO_ILLIDAN_GATE = 185905,
GO_ILLIDAN_DOOR_R = 186261,
GO_ILLIDAN_DOOR_L = 186262
};
enum MiscIds
{
SPELL_CHEST_PAINS = 41356,
SPELL_WYVERN_STING = 24336,
SPELL_SHADOW_INFERNO_DAMAGE = 39646,
SPELL_CHAOTIC_CHARGE = 41033,
SPELL_DEMENTIA1 = 41406,
SPELL_DEMENTIA2 = 41409,
FACTION_ASHTONGUE = 1820
};
#endif // BLACK_TEMPLE_H_

257
src/server/scripts/Outland/BlackTemple/boss_bloodboil.cpp
View File

@@ -1,257 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "black_temple.h"
enum Says
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_SPECIAL = 2,
SAY_ENRAGE = 3,
SAY_DEATH = 4
};
enum Spells
{
SPELL_ACIDIC_WOUND = 40484,
SPELL_FEL_ACID_BREATH1 = 40508,
SPELL_FEL_ACID_BREATH2 = 40595,
SPELL_ARCING_SMASH1 = 40457,
SPELL_ARCING_SMASH2 = 40599,
SPELL_EJECT1 = 40486,
SPELL_EJECT2 = 40597,
SPELL_BEWILDERING_STRIKE = 40491,
SPELL_BLOODBOIL = 42005,
SPELL_ACID_GEYSER = 40630,
SPELL_BERSERK = 45078,
SPELL_CHARGE = 40602,
SPELL_FEL_GEYSER_SUMMON = 40569,
SPELL_FEL_GEYSER_STUN = 40591,
SPELL_FEL_GEYSER_DAMAGE = 40593,
SPELL_FEL_RAGE_SELF = 40594,
SPELL_FEL_RAGE_TARGET = 40604,
SPELL_FEL_RAGE_2 = 40616,
SPELL_FEL_RAGE_3 = 41625,
SPELL_FEL_RAGE_SIZE = 46787,
SPELL_TAUNT_GURTOGG = 40603,
SPELL_INSIGNIFICANCE = 40618
};
enum Misc
{
EVENT_SPELL_BLOOD_BOIL = 1,
EVENT_SPELL_BEWILDERING_STRIKE = 2,
EVENT_SPELL_FEL_ACID_BREATH = 3,
EVENT_SPELL_EJECT = 4,
EVENT_SPELL_ARCING_SMASH = 5,
EVENT_SPELL_CHARGE = 6,
EVENT_SPELL_BERSERK = 7,
EVENT_SPELL_FEL_GEYSER = 8,
EVENT_KILL_TALK = 9,
GROUP_DELAY = 1
};
class boss_gurtogg_bloodboil : public CreatureScript
{
public:
boss_gurtogg_bloodboil() : CreatureScript("boss_gurtogg_bloodboil") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_gurtogg_bloodboilAI>(creature);
}
struct boss_gurtogg_bloodboilAI : public BossAI
{
boss_gurtogg_bloodboilAI(Creature* creature) : BossAI(creature, DATA_GURTOGG_BLOODBOIL)
{
}
void Reset()
{
BossAI::Reset();
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
Talk(SAY_AGGRO);
me->CastSpell(me, SPELL_ACIDIC_WOUND, true);
events.ScheduleEvent(EVENT_SPELL_BLOOD_BOIL, 10000);
events.ScheduleEvent(EVENT_SPELL_BEWILDERING_STRIKE, 28000, GROUP_DELAY);
events.ScheduleEvent(EVENT_SPELL_FEL_ACID_BREATH, 38000);
events.ScheduleEvent(EVENT_SPELL_EJECT, 14000);
events.ScheduleEvent(EVENT_SPELL_ARCING_SMASH, 5000);
events.ScheduleEvent(EVENT_SPELL_FEL_GEYSER, 60000);
events.ScheduleEvent(EVENT_SPELL_BERSERK, 600000);
}
void KilledUnit(Unit* victim)
{
if (events.GetNextEventTime(EVENT_KILL_TALK) == 0)
{
Talk(SAY_SLAY);
events.ScheduleEvent(EVENT_KILL_TALK, 6000);
}
}
void JustSummoned(Creature* summon)
{
summons.Summon(summon);
summon->CastSpell(summon, SPELL_FEL_GEYSER_DAMAGE, false);
}
void JustDied(Unit* killer)
{
BossAI::JustDied(killer);
Talk(SAY_DEATH);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_BERSERK:
Talk(SAY_ENRAGE);
me->CastSpell(me, SPELL_BERSERK, true);
break;
case EVENT_SPELL_BLOOD_BOIL:
me->CastCustomSpell(SPELL_BLOODBOIL, SPELLVALUE_MAX_TARGETS, 5, me, false);
events.ScheduleEvent(EVENT_SPELL_BLOOD_BOIL, 10000);
break;
case EVENT_SPELL_BEWILDERING_STRIKE:
me->CastSpell(me->GetVictim(), SPELL_BEWILDERING_STRIKE, false);
events.ScheduleEvent(EVENT_SPELL_BEWILDERING_STRIKE, 30000, GROUP_DELAY);
break;
case EVENT_SPELL_FEL_ACID_BREATH:
me->CastSpell(me->GetVictim(), me->HasAura(SPELL_FEL_RAGE_SELF) ? SPELL_FEL_ACID_BREATH2 : SPELL_FEL_ACID_BREATH1, false);
events.ScheduleEvent(EVENT_SPELL_FEL_ACID_BREATH, 30000);
break;
case EVENT_SPELL_EJECT:
me->CastSpell(me->GetVictim(), me->HasAura(SPELL_FEL_RAGE_SELF) ? SPELL_EJECT2 : SPELL_EJECT1, false);
events.ScheduleEvent(EVENT_SPELL_EJECT, 20000);
break;
case EVENT_SPELL_ARCING_SMASH:
me->CastSpell(me->GetVictim(), me->HasAura(SPELL_FEL_RAGE_SELF) ? SPELL_ARCING_SMASH2 : SPELL_ARCING_SMASH1, false);
events.ScheduleEvent(EVENT_SPELL_ARCING_SMASH, 15000);
break;
case EVENT_SPELL_FEL_GEYSER:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 40.0f, true))
{
me->RemoveAurasByType(SPELL_AURA_MOD_TAUNT);
me->CastSpell(me, SPELL_FEL_RAGE_SELF, true);
me->CastSpell(target, SPELL_FEL_RAGE_TARGET, true);
me->CastSpell(target, SPELL_FEL_RAGE_2, true);
me->CastSpell(target, SPELL_FEL_RAGE_3, true);
me->CastSpell(target, SPELL_FEL_RAGE_SIZE, true);
target->CastSpell(me, SPELL_TAUNT_GURTOGG, true);
me->CastSpell(target, SPELL_FEL_GEYSER_SUMMON, true);
me->CastSpell(me, SPELL_FEL_GEYSER_STUN, true);
me->CastSpell(me, SPELL_INSIGNIFICANCE, true);
events.ScheduleEvent(EVENT_SPELL_CHARGE, 2000);
events.DelayEvents(30000, GROUP_DELAY);
}
events.ScheduleEvent(EVENT_SPELL_FEL_GEYSER, 90000);
break;
case EVENT_SPELL_CHARGE:
me->CastSpell(me->GetVictim(), SPELL_CHARGE, true);
break;
}
DoMeleeAttackIfReady();
EnterEvadeIfOutOfCombatArea();
}
bool CheckEvadeIfOutOfCombatArea() const
{
return me->GetHomePosition().GetExactDist2d(me) > 105.0f;
}
};
};
class spell_gurtogg_bloodboil : public SpellScriptLoader
{
public:
spell_gurtogg_bloodboil() : SpellScriptLoader("spell_gurtogg_bloodboil") { }
class spell_gurtogg_bloodboil_SpellScript : public SpellScript
{
PrepareSpellScript(spell_gurtogg_bloodboil_SpellScript);
void FilterTargets(std::list<WorldObject*>& targets)
{
if (targets.empty())
return;
targets.sort(Trinity::ObjectDistanceOrderPred(GetCaster(), false));
if (targets.size() > GetSpellValue()->MaxAffectedTargets)
{
std::list<WorldObject*>::iterator itr = targets.begin();
std::advance(itr, GetSpellValue()->MaxAffectedTargets);
targets.erase(itr, targets.end());
}
}
void Register()
{
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_gurtogg_bloodboil_SpellScript::FilterTargets, EFFECT_ALL, TARGET_UNIT_SRC_AREA_ENEMY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_gurtogg_bloodboil_SpellScript();
}
};
class spell_gurtogg_eject : public SpellScriptLoader
{
public:
spell_gurtogg_eject() : SpellScriptLoader("spell_gurtogg_eject") { }
class spell_gurtogg_eject_SpellScript : public SpellScript
{
PrepareSpellScript(spell_gurtogg_eject_SpellScript);
void HandleScriptEffect(SpellEffIndex effIndex)
{
PreventHitEffect(effIndex);
if (Unit* target = GetHitUnit())
GetCaster()->getThreatManager().modifyThreatPercent(target, -20);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_gurtogg_eject_SpellScript::HandleScriptEffect, EFFECT_2, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_gurtogg_eject_SpellScript();
}
};
void AddSC_boss_gurtogg_bloodboil()
{
new boss_gurtogg_bloodboil();
new spell_gurtogg_bloodboil();
new spell_gurtogg_eject();
}

1419
src/server/scripts/Outland/BlackTemple/boss_illidan.cpp
View File

File diff suppressed because it is too large Load Diff

368
src/server/scripts/Outland/BlackTemple/boss_mother_shahraz.cpp
View File

@@ -1,368 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "black_temple.h"
enum Says
{
SAY_TAUNT = 0,
SAY_AGGRO = 1,
SAY_SPELL = 2,
SAY_SLAY = 3,
SAY_ENRAGE = 4,
SAY_DEATH = 5,
SAY_EMOTE_FRENZY = 6
};
enum Spells
{
SPELL_PRISMATIC_AURA_SHADOW = 40880,
SPELL_PRISMATIC_AURA_FIRE = 40882,
SPELL_PRISMATIC_AURA_NATURE = 40883,
SPELL_PRISMATIC_AURA_ARCANE = 40891,
SPELL_PRISMATIC_AURA_FROST = 40896,
SPELL_PRISMATIC_AURA_HOLY = 40897,
SPELL_SABER_LASH_AURA = 40816,
SPELL_SABER_LASH = 40810,
SPELL_SILENCING_SHRIEK = 40823,
SPELL_RANDOM_PERIODIC = 40867,
SPELL_SINFUL_PERIODIC = 40862,
SPELL_SINISTER_PERIODIC = 40863,
SPELL_VILE_PERIODIC = 40865,
SPELL_WICKED_PERIODIC = 40866,
SPELL_FATAL_ATTRACTION = 40869,
SPELL_FATAL_ATTRACTION_AURA = 41001,
SPELL_FATAL_ATTRACTION_DAMAGE = 40871,
SPELL_ENRAGE = 45078,
SPELL_FRENZY = 40683,
SPELL_SABER_LASH_IMMUNITY = 43690
};
enum Misc
{
EVENT_KILL_TALK = 1,
EVENT_CHECK_HEALTH = 2,
EVENT_RANDOM_TALK = 3,
EVENT_SPELL_ENRAGE = 4,
EVENT_SPELL_PRISMATIC_AURA = 5,
EVENT_SPELL_SILENCING_SHRIEK = 6,
EVENT_SPELL_FATAL_ATTRACTION = 7,
EVENT_SPELL_SABER_LASH = 8
};
class boss_mother_shahraz : public CreatureScript
{
public:
boss_mother_shahraz() : CreatureScript("boss_mother_shahraz") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_shahrazAI>(creature);
}
struct boss_shahrazAI : public BossAI
{
boss_shahrazAI(Creature* creature) : BossAI(creature, DATA_MOTHER_SHAHRAZ)
{
}
void Reset()
{
BossAI::Reset();
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
Talk(SAY_AGGRO);
me->CastSpell(me, SPELL_SABER_LASH_AURA, true);
me->CastSpell(me, SPELL_RANDOM_PERIODIC, true);
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
events.ScheduleEvent(EVENT_RANDOM_TALK, 60000);
events.ScheduleEvent(EVENT_SPELL_PRISMATIC_AURA, 0);
events.ScheduleEvent(EVENT_SPELL_ENRAGE, 600000);
events.ScheduleEvent(EVENT_SPELL_SILENCING_SHRIEK, 30000);
events.ScheduleEvent(EVENT_SPELL_FATAL_ATTRACTION, 50000);
events.ScheduleEvent(EVENT_SPELL_SABER_LASH, 4000);
}
void KilledUnit(Unit* /*victim*/)
{
if (events.GetNextEventTime(EVENT_KILL_TALK) == 0)
{
Talk(SAY_SLAY);
events.ScheduleEvent(EVENT_KILL_TALK, 6000);
}
}
void JustDied(Unit* killer)
{
BossAI::JustDied(killer);
Talk(SAY_DEATH);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_CHECK_HEALTH:
if (HealthBelowPct(10))
{
me->CastSpell(me, SPELL_FRENZY, true);
Talk(SAY_EMOTE_FRENZY);
break;
}
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
break;
case EVENT_SPELL_ENRAGE:
me->CastSpell(me, SPELL_ENRAGE, true);
Talk(SAY_ENRAGE);
break;
case EVENT_RANDOM_TALK:
Talk(SAY_TAUNT);
events.ScheduleEvent(EVENT_RANDOM_TALK, urand(60000, 120000));
break;
case EVENT_SPELL_SABER_LASH:
me->CastSpell(me->GetVictim(), SPELL_SABER_LASH, false);
events.ScheduleEvent(EVENT_SPELL_SABER_LASH, 30000);
break;
case EVENT_SPELL_PRISMATIC_AURA:
me->CastSpell(me, RAND(SPELL_PRISMATIC_AURA_SHADOW, SPELL_PRISMATIC_AURA_FIRE, SPELL_PRISMATIC_AURA_NATURE, SPELL_PRISMATIC_AURA_ARCANE, SPELL_PRISMATIC_AURA_FROST, SPELL_PRISMATIC_AURA_HOLY), false);
events.ScheduleEvent(EVENT_SPELL_PRISMATIC_AURA, 15000);
break;
case EVENT_SPELL_SILENCING_SHRIEK:
me->CastSpell(me, SPELL_SILENCING_SHRIEK, false);
events.ScheduleEvent(EVENT_SPELL_SILENCING_SHRIEK, 30000);
break;
case EVENT_SPELL_FATAL_ATTRACTION:
Talk(SAY_SPELL);
me->CastCustomSpell(SPELL_FATAL_ATTRACTION, SPELLVALUE_MAX_TARGETS, 3, me, false);
events.ScheduleEvent(EVENT_SPELL_FATAL_ATTRACTION, 60000);
break;
}
DoMeleeAttackIfReady();
}
};
};
class spell_mother_shahraz_random_periodic : public SpellScriptLoader
{
public:
spell_mother_shahraz_random_periodic() : SpellScriptLoader("spell_mother_shahraz_random_periodic") { }
class spell_mother_shahraz_random_periodic_AuraScript : public AuraScript
{
PrepareAuraScript(spell_mother_shahraz_random_periodic_AuraScript);
void Update(AuraEffect const* effect)
{
PreventDefaultAction();
if (effect->GetTickNumber()%5 == 1)
GetUnitOwner()->CastSpell(GetUnitOwner(), RAND(SPELL_SINFUL_PERIODIC, SPELL_SINISTER_PERIODIC, SPELL_VILE_PERIODIC, SPELL_WICKED_PERIODIC), true);
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_mother_shahraz_random_periodic_AuraScript::Update, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_mother_shahraz_random_periodic_AuraScript();
}
};
class spell_mother_shahraz_beam_periodic : public SpellScriptLoader
{
public:
spell_mother_shahraz_beam_periodic() : SpellScriptLoader("spell_mother_shahraz_beam_periodic") { }
class spell_mother_shahraz_beam_periodic_AuraScript : public AuraScript
{
PrepareAuraScript(spell_mother_shahraz_beam_periodic_AuraScript);
void Update(AuraEffect const* effect)
{
PreventDefaultAction();
if (Unit* target = GetUnitOwner()->GetAI()->SelectTarget(SELECT_TARGET_RANDOM, 0))
GetUnitOwner()->CastSpell(target, GetSpellInfo()->Effects[effect->GetEffIndex()].TriggerSpell, true);
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_mother_shahraz_beam_periodic_AuraScript::Update, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_mother_shahraz_beam_periodic_AuraScript();
}
};
class spell_mother_shahraz_saber_lash : public SpellScriptLoader
{
public:
spell_mother_shahraz_saber_lash() : SpellScriptLoader("spell_mother_shahraz_saber_lash") { }
class spell_mother_shahraz_saber_lash_AuraScript : public AuraScript
{
PrepareAuraScript(spell_mother_shahraz_saber_lash_AuraScript);
bool CheckProc(ProcEventInfo& eventInfo)
{
return false;
}
void Update(AuraEffect const* effect)
{
PreventDefaultAction();
if (Unit* target = GetUnitOwner()->GetVictim())
GetUnitOwner()->CastSpell(target, GetSpellInfo()->Effects[effect->GetEffIndex()].TriggerSpell, true);
}
void Register()
{
DoCheckProc += AuraCheckProcFn(spell_mother_shahraz_saber_lash_AuraScript::CheckProc);
OnEffectPeriodic += AuraEffectPeriodicFn(spell_mother_shahraz_saber_lash_AuraScript::Update, EFFECT_1, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_mother_shahraz_saber_lash_AuraScript();
}
};
class spell_mother_shahraz_fatal_attraction : public SpellScriptLoader
{
public:
spell_mother_shahraz_fatal_attraction() : SpellScriptLoader("spell_mother_shahraz_fatal_attraction") { }
class spell_mother_shahraz_fatal_attraction_SpellScript : public SpellScript
{
PrepareSpellScript(spell_mother_shahraz_fatal_attraction_SpellScript);
void FilterTargets(std::list<WorldObject*>& targets)
{
targets.remove_if(Trinity::UnitAuraCheck(true, SPELL_SABER_LASH_IMMUNITY));
if (targets.size() <= 1)
FinishCast(SPELL_FAILED_DONT_REPORT);
}
void SetDest(SpellDestination& dest)
{
std::list<Spell::TargetInfo> const* targetsInfo = GetSpell()->GetUniqueTargetInfo();
for (std::list<Spell::TargetInfo>::const_iterator ihit = targetsInfo->begin(); ihit != targetsInfo->end(); ++ihit)
if (Unit* target = ObjectAccessor::GetUnit(*GetCaster(), ihit->targetGUID))
{
dest.Relocate(*target);
if (roll_chance_i(50))
break;
}
}
void HandleTeleportUnits(SpellEffIndex effIndex)
{
if (Unit* target = GetHitUnit())
GetCaster()->CastSpell(target, SPELL_FATAL_ATTRACTION_AURA, true);
}
void Register()
{
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_mother_shahraz_fatal_attraction_SpellScript::FilterTargets, EFFECT_ALL, TARGET_UNIT_SRC_AREA_ENEMY);
OnDestinationTargetSelect += SpellDestinationTargetSelectFn(spell_mother_shahraz_fatal_attraction_SpellScript::SetDest, EFFECT_1, TARGET_DEST_CASTER_RANDOM);
OnEffectHitTarget += SpellEffectFn(spell_mother_shahraz_fatal_attraction_SpellScript::HandleTeleportUnits, EFFECT_1, SPELL_EFFECT_TELEPORT_UNITS);
}
};
SpellScript* GetSpellScript() const
{
return new spell_mother_shahraz_fatal_attraction_SpellScript();
}
};
class spell_mother_shahraz_fatal_attraction_dummy : public SpellScriptLoader
{
public:
spell_mother_shahraz_fatal_attraction_dummy() : SpellScriptLoader("spell_mother_shahraz_fatal_attraction_dummy") { }
class spell_mother_shahraz_fatal_attraction_dummy_SpellScript : public SpellScript
{
PrepareSpellScript(spell_mother_shahraz_fatal_attraction_dummy_SpellScript);
void HandleDummy(SpellEffIndex effIndex)
{
if (Unit* target = GetHitUnit())
{
target->CastSpell(target, SPELL_FATAL_ATTRACTION_DAMAGE, true);
if (AuraEffect* aurEff = target->GetAuraEffect(SPELL_FATAL_ATTRACTION_AURA, EFFECT_1))
aurEff->SetAmount(aurEff->GetTickNumber());
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_mother_shahraz_fatal_attraction_dummy_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_mother_shahraz_fatal_attraction_dummy_SpellScript();
}
};
class spell_mother_shahraz_fatal_attraction_aura : public SpellScriptLoader
{
public:
spell_mother_shahraz_fatal_attraction_aura() : SpellScriptLoader("spell_mother_shahraz_fatal_attraction_aura") { }
class spell_mother_shahraz_fatal_attraction_aura_AuraScript : public AuraScript
{
PrepareAuraScript(spell_mother_shahraz_fatal_attraction_aura_AuraScript);
void Update(AuraEffect const* effect)
{
if (effect->GetTickNumber() > uint32(effect->GetAmount()+1))
{
PreventDefaultAction();
SetDuration(0);
}
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_mother_shahraz_fatal_attraction_aura_AuraScript::Update, EFFECT_1, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_mother_shahraz_fatal_attraction_aura_AuraScript();
}
};
void AddSC_boss_mother_shahraz()
{
new boss_mother_shahraz();
new spell_mother_shahraz_random_periodic();
new spell_mother_shahraz_beam_periodic();
new spell_mother_shahraz_saber_lash();
new spell_mother_shahraz_fatal_attraction();
new spell_mother_shahraz_fatal_attraction_dummy();
new spell_mother_shahraz_fatal_attraction_aura();
}

777
src/server/scripts/Outland/BlackTemple/boss_reliquary_of_souls.cpp
View File

@@ -1,777 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "black_temple.h"
#include "Spell.h"
enum Says
{
//Suffering
SUFF_SAY_FREED = 0,
SUFF_SAY_AGGRO = 1,
SUFF_SAY_SLAY = 2,
SUFF_SAY_RECAP = 3,
SUFF_SAY_AFTER = 4,
SUFF_SAY_ENRAGE = 5,
SUFF_EMOTE_ENRAGE = 6,
//Desire
DESI_SAY_FREED = 0,
DESI_SAY_SLAY = 1,
DESI_SAY_SPEC = 2,
DESI_SAY_RECAP = 3,
DESI_SAY_AFTER = 4,
//Anger
ANGER_SAY_FREED = 0,
ANGER_SAY_SLAY = 1,
ANGER_SAY_SPEC = 2,
ANGER_SAY_RECAP = 3,
ANGER_SAY_DEATH = 4
};
enum Spells
{
SPELL_EMERGE_VISUAL = 50142,
SPELL_SUMMON_ESSENCE_OF_SUFFERING = 41488,
SPELL_SUMMON_ESSENCE_OF_DESIRE = 41493,
SPELL_SUMMON_ESSENCE_OF_ANGER = 41496,
SPELL_SUMMON_ENSLAVED_SOUL = 41537,
// Suffering
SPELL_AURA_OF_SUFFERING = 41292,
SPELL_AURA_OF_SUFFERING_TRIGGER = 42017,
SPELL_ESSENCE_OF_SUFFERING_PASSIVE = 41296,
SPELL_ESSENCE_OF_SUFFERING_PASSIVE2 = 41623,
SPELL_FRENZY = 41305,
SPELL_SOUL_DRAIN = 41303,
// Desire
SPELL_AURA_OF_DESIRE = 41350,
SPELL_AURA_OF_DESIRE_DAMAGE = 41352,
SPELL_RUNE_SHIELD = 41431,
SPELL_DEADEN = 41410,
SPELL_SPIRIT_SHOCK = 41426,
// Anger
SPELL_AURA_OF_ANGER = 41337,
SPELL_SPITE = 41376,
SPELL_SPITE_DAMAGE = 41377,
SPELL_SOUL_SCREAM = 41545,
SPELL_SEETHE = 41364
};
enum Misc
{
ACTION_ESSENCE_OF_SUFFERING = 1,
ACTION_ESSENCE_OF_DESIRE = 2,
ACTION_ESSENCE_OF_ANGER = 3,
ACTION_ENGAGE_ESSENCE = 4,
EVENT_ESSENCE_OF_SUFFERING = 1,
EVENT_ESSENCE_OF_DESIRE = 2,
EVENT_ESSENCE_OF_ANGER = 3,
EVENT_ENGAGE_ESSENCE = 4,
EVENT_SPAWN_ENSLAVED_SOULS = 5,
EVENT_SPAWN_SOUL = 6,
EVENT_SUCK_ESSENCE = 7,
EVENT_SUFF_FRENZY = 10,
EVENT_SUFF_FRENZY_EMOTE = 11,
EVENT_SUFF_SOUL_DRAIN = 12,
EVENT_DESI_DEADEN = 20,
EVENT_DESI_SPIRIT_SHOCK = 21,
EVENT_DESI_RUNE_SHIELD = 22,
EVENT_ANGER_SPITE = 30,
EVENT_ANGER_SOUL_SCREAM = 31,
EVENT_ANGER_SEETHE = 32,
EVENT_KILL_TALK = 100,
POINT_GO_BACK = 1
};
class SuckBackEvent : public BasicEvent
{
public:
SuckBackEvent(Creature& owner, uint32 action) : BasicEvent(), _owner(owner), _action(action) { }
bool Execute(uint64 /*eventTime*/, uint32 /*diff*/)
{
if (_owner.IsSummon())
if (Unit* summoner = _owner.ToTempSummon()->GetSummoner())
{
summoner->GetAI()->DoAction(_action);
_owner.SetStandState(UNIT_STAND_STATE_SUBMERGED);
_owner.DespawnOrUnsummon(200);
}
return true;
}
private:
Creature& _owner;
uint32 _action;
};
class boss_reliquary_of_souls : public CreatureScript
{
public:
boss_reliquary_of_souls() : CreatureScript("boss_reliquary_of_souls") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_reliquary_of_soulsAI>(creature);
}
struct boss_reliquary_of_soulsAI : public BossAI
{
boss_reliquary_of_soulsAI(Creature* creature) : BossAI(creature, DATA_RELIQUARY_OF_SOULS)
{
}
void Reset()
{
BossAI::Reset();
me->SetStandState(UNIT_STAND_STATE_SLEEP);
}
void MoveInLineOfSight(Unit* who)
{
if (!who || me->getStandState() != UNIT_STAND_STATE_SLEEP || who->GetTypeId() != TYPEID_PLAYER || me->GetDistance2d(who) > 90.0f || who->ToPlayer()->IsGameMaster())
return;
me->SetInCombatWithZone();
events.ScheduleEvent(EVENT_ESSENCE_OF_SUFFERING, 5000); // ZOMG! 15000);
me->SetStandState(UNIT_STAND_STATE_STAND);
}
void DoAction(int32 param)
{
if (param == ACTION_ESSENCE_OF_SUFFERING)
{
me->SetStandState(UNIT_STAND_STATE_STAND);
events.ScheduleEvent(EVENT_SUCK_ESSENCE, 1000);
events.ScheduleEvent(EVENT_SPAWN_ENSLAVED_SOULS, 8000);
events.ScheduleEvent(EVENT_ESSENCE_OF_DESIRE, 38000);
}
else if (param == ACTION_ESSENCE_OF_DESIRE)
{
me->SetStandState(UNIT_STAND_STATE_STAND);
events.ScheduleEvent(EVENT_SUCK_ESSENCE, 1000);
events.ScheduleEvent(EVENT_SPAWN_ENSLAVED_SOULS, 8000);
events.ScheduleEvent(EVENT_ESSENCE_OF_ANGER, 38000);
}
else if (param == ACTION_ESSENCE_OF_ANGER)
{
}
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
}
void JustSummoned(Creature* summon)
{
summons.Summon(summon);
if (summon->GetEntry() == NPC_ENSLAVED_SOUL)
return;
summon->SetReactState(REACT_PASSIVE);
summon->CastSpell(summon, SPELL_EMERGE_VISUAL, true);
events.ScheduleEvent(EVENT_ENGAGE_ESSENCE, 4000);
}
void SummonedCreatureDies(Creature* summon, Unit*)
{
summons.Despawn(summon);
}
void AttackStart(Unit*) { }
void JustDied(Unit* killer)
{
summons.clear();
BossAI::JustDied(killer);
}
void UpdateAI(uint32 diff)
{
if (me->getStandState() == UNIT_STAND_STATE_SLEEP)
return;
events.Update(diff);
switch (events.ExecuteEvent())
{
case EVENT_SUCK_ESSENCE:
me->SetStandState(UNIT_STAND_STATE_STAND);
break;
case EVENT_ENGAGE_ESSENCE:
summons.DoAction(ACTION_ENGAGE_ESSENCE);
break;
case EVENT_ESSENCE_OF_SUFFERING:
me->SetStandState(UNIT_STAND_STATE_SUBMERGED);
me->CastSpell(me, SPELL_SUMMON_ESSENCE_OF_SUFFERING, false);
break;
case EVENT_ESSENCE_OF_DESIRE:
summons.DespawnAll();
me->SetStandState(UNIT_STAND_STATE_SUBMERGED);
me->CastSpell(me, SPELL_SUMMON_ESSENCE_OF_DESIRE, false);
break;
case EVENT_ESSENCE_OF_ANGER:
summons.DespawnAll();
me->SetStandState(UNIT_STAND_STATE_SUBMERGED);
me->CastSpell(me, SPELL_SUMMON_ESSENCE_OF_ANGER, false);
break;
case EVENT_SPAWN_ENSLAVED_SOULS:
events.ScheduleEvent(EVENT_SPAWN_SOUL, 0);
events.ScheduleEvent(EVENT_SPAWN_SOUL, 0);
for (uint8 i = 0; i < 16; ++i)
events.ScheduleEvent(EVENT_SPAWN_SOUL, i*1200);
break;
case EVENT_SPAWN_SOUL:
me->CastCustomSpell(SPELL_SUMMON_ENSLAVED_SOUL, SPELLVALUE_MAX_TARGETS, 1, me, false);
break;
}
EnterEvadeIfOutOfCombatArea();
}
bool CheckEvadeIfOutOfCombatArea() const
{
return !SelectTargetFromPlayerList(80.0f);
}
};
};
class boss_essence_of_suffering : public CreatureScript
{
public:
boss_essence_of_suffering() : CreatureScript("boss_essence_of_suffering") { }
CreatureAI* GetAI(Creature* creature) const
{
return new boss_essence_of_sufferingAI(creature);
}
struct boss_essence_of_sufferingAI : public ScriptedAI
{
boss_essence_of_sufferingAI(Creature* creature) : ScriptedAI(creature) { }
EventMap events;
void Reset()
{
events.Reset();
}
void DoAction(int32 param)
{
if (param == ACTION_ENGAGE_ESSENCE)
{
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_NON_ATTACKABLE);
me->SetReactState(REACT_AGGRESSIVE);
me->SetInCombatWithZone();
}
}
void MovementInform(uint32 type, uint32 id)
{
if (type != POINT_MOTION_TYPE || id != POINT_GO_BACK)
return;
me->m_Events.AddEvent(new SuckBackEvent(*me, ACTION_ESSENCE_OF_SUFFERING), me->m_Events.CalculateTime(1500));
me->SetTarget(0);
me->SetFacingTo(M_PI/2.0f);
}
void DamageTaken(Unit*, uint32& damage, DamageEffectType, SpellSchoolMask)
{
if (damage >= me->GetHealth())
{
damage = 0;
if (!me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE))
{
me->RemoveAurasDueToSpell(SPELL_ESSENCE_OF_SUFFERING_PASSIVE); // prevent fixate from triggering
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
Talk(SUFF_SAY_RECAP);
me->SetReactState(REACT_PASSIVE);
me->GetMotionMaster()->Clear();
me->GetMotionMaster()->MovePoint(POINT_GO_BACK, me->GetHomePosition(), false);
events.Reset();
}
}
}
void KilledUnit(Unit* /*victim*/)
{
if (events.GetNextEventTime(EVENT_KILL_TALK) == 0)
{
Talk(SUFF_SAY_SLAY);
events.ScheduleEvent(EVENT_KILL_TALK, 6000);
}
}
void EnterCombat(Unit* /*who*/)
{
Talk(SUFF_SAY_FREED);
me->CastSpell(me, SPELL_AURA_OF_SUFFERING, true);
me->CastSpell(me, SPELL_ESSENCE_OF_SUFFERING_PASSIVE, true);
me->CastSpell(me, SPELL_ESSENCE_OF_SUFFERING_PASSIVE2, true);
events.ScheduleEvent(EVENT_SUFF_FRENZY, 45000);
events.ScheduleEvent(EVENT_SUFF_SOUL_DRAIN, 25000);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SUFF_SOUL_DRAIN:
me->CastCustomSpell(SPELL_SOUL_DRAIN, SPELLVALUE_MAX_TARGETS, 3, me, false);
events.ScheduleEvent(EVENT_SUFF_SOUL_DRAIN, 30000);
break;
case EVENT_SUFF_FRENZY:
Talk(SUFF_SAY_ENRAGE);
Talk(SUFF_EMOTE_ENRAGE);
me->CastSpell(me, SPELL_FRENZY, false);
events.ScheduleEvent(EVENT_SUFF_FRENZY, 45000);
events.ScheduleEvent(EVENT_SUFF_FRENZY_EMOTE, 3000);
break;
case EVENT_SUFF_FRENZY_EMOTE:
Talk(SUFF_EMOTE_ENRAGE);
break;
}
DoMeleeAttackIfReady();
}
};
};
class boss_essence_of_desire : public CreatureScript
{
public:
boss_essence_of_desire() : CreatureScript("boss_essence_of_desire") { }
CreatureAI* GetAI(Creature* creature) const
{
return new boss_essence_of_desireAI(creature);
}
struct boss_essence_of_desireAI : public ScriptedAI
{
boss_essence_of_desireAI(Creature* creature) : ScriptedAI(creature) { }
EventMap events;
void Reset()
{
events.Reset();
}
void DoAction(int32 param)
{
if (param == ACTION_ENGAGE_ESSENCE)
{
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_NON_ATTACKABLE);
me->SetReactState(REACT_AGGRESSIVE);
me->SetInCombatWithZone();
}
}
void MovementInform(uint32 type, uint32 id)
{
if (type != POINT_MOTION_TYPE || id != POINT_GO_BACK)
return;
me->m_Events.AddEvent(new SuckBackEvent(*me, ACTION_ESSENCE_OF_DESIRE), me->m_Events.CalculateTime(1500));
me->SetTarget(0);
me->SetFacingTo(M_PI/2.0f);
}
void DamageTaken(Unit*, uint32& damage, DamageEffectType, SpellSchoolMask)
{
if (damage >= me->GetHealth())
{
damage = 0;
if (!me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE))
{
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
Talk(DESI_SAY_RECAP);
me->SetReactState(REACT_PASSIVE);
me->GetMotionMaster()->Clear();
me->GetMotionMaster()->MovePoint(POINT_GO_BACK, me->GetHomePosition(), false);
events.Reset();
}
}
}
void KilledUnit(Unit* /*victim*/)
{
if (events.GetNextEventTime(EVENT_KILL_TALK) == 0)
{
Talk(DESI_SAY_SLAY);
events.ScheduleEvent(EVENT_KILL_TALK, 6000);
}
}
void EnterCombat(Unit* /*who*/)
{
Talk(DESI_SAY_FREED);
me->CastSpell(me, SPELL_AURA_OF_DESIRE, true);
events.ScheduleEvent(EVENT_DESI_DEADEN, 28000);
events.ScheduleEvent(EVENT_DESI_SPIRIT_SHOCK, 20000);
events.ScheduleEvent(EVENT_DESI_RUNE_SHIELD, 13000);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_DESI_DEADEN:
if (roll_chance_i(50))
Talk(DESI_SAY_SPEC);
me->CastSpell(me->GetVictim(), SPELL_DEADEN, false);
events.ScheduleEvent(EVENT_DESI_DEADEN, 31000);
break;
case EVENT_DESI_SPIRIT_SHOCK:
me->CastSpell(me->GetVictim(), SPELL_SPIRIT_SHOCK, false);
events.ScheduleEvent(EVENT_DESI_SPIRIT_SHOCK, 12000);
break;
case EVENT_DESI_RUNE_SHIELD:
me->CastSpell(me, SPELL_RUNE_SHIELD, false);
events.ScheduleEvent(EVENT_DESI_RUNE_SHIELD, 15000);
break;
}
DoMeleeAttackIfReady();
}
};
};
class boss_essence_of_anger : public CreatureScript
{
public:
boss_essence_of_anger() : CreatureScript("boss_essence_of_anger") { }
CreatureAI* GetAI(Creature* creature) const
{
return new boss_essence_of_angerAI(creature);
}
struct boss_essence_of_angerAI : public ScriptedAI
{
boss_essence_of_angerAI(Creature* creature) : ScriptedAI(creature) { }
EventMap events;
uint64 targetGUID;
void Reset()
{
targetGUID = 0;
events.Reset();
}
void DoAction(int32 param)
{
if (param == ACTION_ENGAGE_ESSENCE)
{
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_NON_ATTACKABLE);
me->SetReactState(REACT_AGGRESSIVE);
me->SetInCombatWithZone();
}
}
void KilledUnit(Unit* /*victim*/)
{
if (events.GetNextEventTime(EVENT_KILL_TALK) == 0)
{
Talk(ANGER_SAY_SLAY);
events.ScheduleEvent(EVENT_KILL_TALK, 6000);
}
}
void JustDied(Unit* killer)
{
Talk(ANGER_SAY_DEATH);
if (me->IsSummon())
if (Unit* summoner = me->ToTempSummon()->GetSummoner())
Unit::Kill(summoner, summoner);
}
void EnterCombat(Unit* /*who*/)
{
Talk(ANGER_SAY_FREED);
me->CastSpell(me, SPELL_AURA_OF_ANGER, true);
events.ScheduleEvent(EVENT_ANGER_SPITE, 15000);
events.ScheduleEvent(EVENT_ANGER_SOUL_SCREAM, 10000);
events.ScheduleEvent(EVENT_ANGER_SEETHE, 1000);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_ANGER_SPITE:
if (roll_chance_i(30))
Talk(ANGER_SAY_SPEC);
me->CastCustomSpell(SPELL_SPITE, SPELLVALUE_MAX_TARGETS, 3, me, false);
events.ScheduleEvent(EVENT_ANGER_SPITE, 25000);
break;
case EVENT_ANGER_SOUL_SCREAM:
me->CastSpell(me->GetVictim(), SPELL_SOUL_SCREAM, false);
events.ScheduleEvent(EVENT_ANGER_SOUL_SCREAM, 10000);
break;
case EVENT_ANGER_SEETHE:
if (targetGUID && targetGUID != me->GetVictim()->GetGUID())
me->CastSpell(me, SPELL_SEETHE, false);
// victim can be lost
if (me->GetVictim())
targetGUID = me->GetVictim()->GetGUID();
events.ScheduleEvent(EVENT_ANGER_SEETHE, 1000);
break;
}
DoMeleeAttackIfReady();
}
};
};
class spell_reliquary_of_souls_aura_of_suffering : public SpellScriptLoader
{
public:
spell_reliquary_of_souls_aura_of_suffering() : SpellScriptLoader("spell_reliquary_of_souls_aura_of_suffering") { }
class spell_reliquary_of_souls_aura_of_suffering_AuraScript : public AuraScript
{
PrepareAuraScript(spell_reliquary_of_souls_aura_of_suffering_AuraScript)
void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
GetTarget()->CastSpell(GetTarget(), SPELL_AURA_OF_SUFFERING_TRIGGER, true);
}
void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
GetTarget()->RemoveAurasDueToSpell(SPELL_AURA_OF_SUFFERING_TRIGGER);
}
void Register()
{
OnEffectApply += AuraEffectApplyFn(spell_reliquary_of_souls_aura_of_suffering_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_MOD_HEALING_PCT, AURA_EFFECT_HANDLE_REAL);
OnEffectRemove += AuraEffectRemoveFn(spell_reliquary_of_souls_aura_of_suffering_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_MOD_HEALING_PCT, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_reliquary_of_souls_aura_of_suffering_AuraScript();
}
};
class spell_reliquary_of_souls_fixate : public SpellScriptLoader
{
public:
spell_reliquary_of_souls_fixate() : SpellScriptLoader("spell_reliquary_of_souls_fixate") { }
class spell_reliquary_of_souls_fixate_SpellScript : public SpellScript
{
PrepareSpellScript(spell_reliquary_of_souls_fixate_SpellScript);
void FilterTargets(std::list<WorldObject*>& targets)
{
if (targets.empty())
return;
targets.sort(Trinity::ObjectDistanceOrderPred(GetCaster()));
WorldObject* target = targets.front();
targets.clear();
targets.push_back(target);
}
void Register()
{
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_reliquary_of_souls_fixate_SpellScript::FilterTargets, EFFECT_ALL, TARGET_UNIT_SRC_AREA_ENEMY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_reliquary_of_souls_fixate_SpellScript();
}
class spell_reliquary_of_souls_fixate_AuraScript : public AuraScript
{
PrepareAuraScript(spell_reliquary_of_souls_fixate_AuraScript)
void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
if (Unit* caster = GetCaster())
caster->RemoveAurasDueToSpell(GetSpellInfo()->Effects[EFFECT_1].TriggerSpell, GetTarget()->GetGUID());
}
void Register()
{
OnEffectRemove += AuraEffectRemoveFn(spell_reliquary_of_souls_fixate_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_reliquary_of_souls_fixate_AuraScript();
}
};
class spell_reliquary_of_souls_aura_of_desire : public SpellScriptLoader
{
public:
spell_reliquary_of_souls_aura_of_desire() : SpellScriptLoader("spell_reliquary_of_souls_aura_of_desire") { }
class spell_reliquary_of_souls_aura_of_desire_AuraScript : public AuraScript
{
PrepareAuraScript(spell_reliquary_of_souls_aura_of_desire_AuraScript);
bool CheckProc(ProcEventInfo& eventInfo)
{
return eventInfo.GetActor() && eventInfo.GetActionTarget();
}
void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
{
PreventDefaultAction();
eventInfo.GetActionTarget()->CastCustomSpell(SPELL_AURA_OF_DESIRE_DAMAGE, SPELLVALUE_BASE_POINT0, eventInfo.GetDamageInfo()->GetDamage()/2, eventInfo.GetActor(), true);
}
void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/)
{
if (AuraEffect* effect = GetAura()->GetEffect(EFFECT_2))
amount = std::max<int32>(-100, -5*int32(effect->GetTickNumber()));
}
void Update(AuraEffect const* effect)
{
PreventDefaultAction();
if (AuraEffect* effect = GetAura()->GetEffect(EFFECT_1))
effect->RecalculateAmount();
}
void Register()
{
DoCheckProc += AuraCheckProcFn(spell_reliquary_of_souls_aura_of_desire_AuraScript::CheckProc);
OnEffectProc += AuraEffectProcFn(spell_reliquary_of_souls_aura_of_desire_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_MOD_HEALING_PCT);
DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_reliquary_of_souls_aura_of_desire_AuraScript::CalculateAmount, EFFECT_1, SPELL_AURA_MOD_INCREASE_ENERGY_PERCENT);
OnEffectPeriodic += AuraEffectPeriodicFn(spell_reliquary_of_souls_aura_of_desire_AuraScript::Update, EFFECT_2, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_reliquary_of_souls_aura_of_desire_AuraScript();
}
};
class spell_reliquary_of_souls_aura_of_anger : public SpellScriptLoader
{
public:
spell_reliquary_of_souls_aura_of_anger() : SpellScriptLoader("spell_reliquary_of_souls_aura_of_anger") { }
class spell_reliquary_of_souls_aura_of_anger_AuraScript : public AuraScript
{
PrepareAuraScript(spell_reliquary_of_souls_aura_of_anger_AuraScript);
void CalculateAmount(AuraEffect const* aurEff, int32& amount, bool& /*canBeRecalculated*/)
{
if (AuraEffect* effect = GetAura()->GetEffect(EFFECT_0))
amount = amount*effect->GetTickNumber();
}
void Update(AuraEffect const* effect)
{
if (AuraEffect* effect = GetAura()->GetEffect(EFFECT_0))
effect->RecalculateAmount();
if (AuraEffect* effect = GetAura()->GetEffect(EFFECT_1))
effect->RecalculateAmount();
}
void Register()
{
DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_reliquary_of_souls_aura_of_anger_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_reliquary_of_souls_aura_of_anger_AuraScript::CalculateAmount, EFFECT_1, SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
OnEffectPeriodic += AuraEffectPeriodicFn(spell_reliquary_of_souls_aura_of_anger_AuraScript::Update, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
}
};
AuraScript* GetAuraScript() const
{
return new spell_reliquary_of_souls_aura_of_anger_AuraScript();
}
};
class spell_reliquary_of_souls_spite : public SpellScriptLoader
{
public:
spell_reliquary_of_souls_spite() : SpellScriptLoader("spell_reliquary_of_souls_spite") { }
class spell_reliquary_of_souls_spite_AuraScript : public AuraScript
{
PrepareAuraScript(spell_reliquary_of_souls_spite_AuraScript)
void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
if (Unit* caster = GetCaster())
caster->CastSpell(GetTarget(), SPELL_SPITE_DAMAGE, true);
}
void Register()
{
AfterEffectRemove += AuraEffectRemoveFn(spell_reliquary_of_souls_spite_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_DAMAGE_IMMUNITY, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_reliquary_of_souls_spite_AuraScript();
}
};
void AddSC_boss_reliquary_of_souls()
{
new boss_reliquary_of_souls();
new boss_essence_of_suffering();
new boss_essence_of_desire();
new boss_essence_of_anger();
new spell_reliquary_of_souls_aura_of_suffering();
new spell_reliquary_of_souls_fixate();
new spell_reliquary_of_souls_aura_of_desire();
new spell_reliquary_of_souls_aura_of_anger();
new spell_reliquary_of_souls_spite();
}

616
src/server/scripts/Outland/BlackTemple/boss_shade_of_akama.cpp
View File

@@ -1,616 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "black_temple.h"
enum Says
{
SAY_BROKEN_FREE_0 = 0,
SAY_BROKEN_FREE_1 = 1,
SAY_BROKEN_FREE_2 = 2,
SAY_BROKEN_S1 = 0,
SAY_BROKEN_S2 = 1
};
enum Spells
{
SPELL_STEALTH = 34189,
SPELL_AKAMA_SOUL_CHANNEL = 40447,
SPELL_SHADE_SOUL_CHANNEL = 40401,
SPELL_CHAIN_LIGHTNING = 39945,
SPELL_DESTRUCTIVE_POISON = 40874,
SPELL_SHADE_OF_AKAMA_TRIGGER = 40955,
SPELL_AKAMA_SOUL_RETRIEVE = 40902,
SPELL_ASHTONGUE_WAVE_B = 42035,
SPELL_SUMMON_ASHTONGUE_SORCERER = 40476,
SPELL_SUMMON_ASHTONGUE_DEFENDER = 40474
};
enum Creatures
{
NPC_ASHTONGUE_CHANNELER = 23421,
NPC_CREATURE_GENERATOR_AKAMA = 23210,
NPC_ASHTONGUE_SORCERER = 23215,
NPC_ASHTONGUE_BROKEN = 23319
};
enum Misc
{
SUMMON_GROUP_BROKENS = 1,
POINT_START = 0,
POINT_CHANNEL_SOUL = 1,
ACTION_AKAMA_DIED = 1,
ACTION_START_ENCOUNTER = 2,
ACTION_STOP_SPAWNING = 3,
ACTION_DESPAWN_ALL = 4,
ACTION_CHANNELERS_START_CHANNEL = 5,
ACTION_KILL_CHANNELERS = 6,
ACTION_NO_SORCERERS = 7,
ACTION_SHADE_DIED = 8,
EVENT_AKAMA_START_ENCOUNTER = 1,
EVENT_AKAMA_START_CHANNEL = 2,
EVENT_SPELL_CHAIN_LIGHTNING = 4,
EVENT_SPELL_DESTRUCTIVE_POISON = 5,
EVENT_SHADE_CHECK_DISTANCE = 10,
EVENT_SHADE_RESET_ENCOUNTER = 11,
EVENT_SHADE_GATHER_NPCS = 12,
EVENT_SUMMON_WAVE_B = 20,
EVENT_SUMMON_ASHTONGUE_SORCERER = 21,
EVENT_SUMMON_ASHTONGUE_DEFENDER = 22,
EVENT_AKAMA_SCENE0 = 29,
EVENT_AKAMA_SCENE1 = 30,
EVENT_AKAMA_SCENE2 = 31,
EVENT_AKAMA_SCENE3 = 32,
EVENT_AKAMA_SCENE4 = 33,
EVENT_AKAMA_SCENE5 = 34,
EVENT_AKAMA_SCENE6 = 35,
EVENT_AKAMA_SCENE7 = 36
};
class boss_shade_of_akama : public CreatureScript
{
public:
boss_shade_of_akama() : CreatureScript("boss_shade_of_akama") { }
struct boss_shade_of_akamaAI : public BossAI
{
boss_shade_of_akamaAI(Creature* creature) : BossAI(creature, DATA_SHADE_OF_AKAMA), summonsChanneler(me), summonsGenerator(me)
{
events2.ScheduleEvent(EVENT_SHADE_GATHER_NPCS, 1000);
}
SummonList summonsChanneler;
SummonList summonsGenerator;
EventMap events2;
void ChannelersAction(int32 action)
{
for (SummonList::const_iterator i = summonsChanneler.begin(); i != summonsChanneler.end(); ++i)
if (Creature* summon = ObjectAccessor::GetCreature(*me, *i))
{
if (action == ACTION_CHANNELERS_START_CHANNEL)
{
summon->CastSpell(me, SPELL_SHADE_SOUL_CHANNEL, true);
summon->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
}
else if (action == ACTION_START_ENCOUNTER)
{
summon->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
}
else if (action == ACTION_KILL_CHANNELERS)
{
Unit::Kill(me, summon);
}
}
}
void Reset()
{
BossAI::Reset();
me->SetReactState(REACT_PASSIVE);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC|UNIT_FLAG_IMMUNE_TO_NPC|UNIT_FLAG_NOT_SELECTABLE);
me->SetWalk(true);
}
void EnterEvadeMode()
{
BossAI::EnterEvadeMode();
summonsGenerator.DoAction(ACTION_DESPAWN_ALL);
events2.ScheduleEvent(EVENT_SHADE_RESET_ENCOUNTER, 20000);
me->SetVisible(false);
ChannelersAction(ACTION_KILL_CHANNELERS);
}
void JustDied(Unit* killer)
{
BossAI::JustDied(killer);
summonsGenerator.DoAction(ACTION_DESPAWN_ALL);
summonsChanneler.DespawnAll();
me->CastSpell(me, SPELL_SHADE_OF_AKAMA_TRIGGER, true);
if (Creature* akama = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_AKAMA_SHADE)))
{
akama->SetHomePosition(*akama);
akama->AI()->DoAction(ACTION_SHADE_DIED);
}
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
}
void DoAction(int32 param)
{
if (param == ACTION_START_ENCOUNTER)
{
summonsGenerator.DoAction(ACTION_START_ENCOUNTER);
ChannelersAction(ACTION_START_ENCOUNTER);
events.ScheduleEvent(EVENT_SHADE_CHECK_DISTANCE, 1000);
}
else if (param == ACTION_AKAMA_DIED)
{
EnterEvadeMode();
}
}
void UpdateAI(uint32 diff)
{
events2.Update(diff);
switch (events2.ExecuteEvent())
{
case EVENT_SHADE_GATHER_NPCS:
{
std::list<Creature*> ChannelerList;
me->GetCreaturesWithEntryInRange(ChannelerList, 100.0f, NPC_ASHTONGUE_CHANNELER);
for (std::list<Creature*>::const_iterator itr = ChannelerList.begin(); itr != ChannelerList.end(); ++itr)
summonsChanneler.Summon(*itr);
std::list<Creature*> SpawnerList;
me->GetCreaturesWithEntryInRange(SpawnerList, 100.0f, NPC_CREATURE_GENERATOR_AKAMA);
for (std::list<Creature*>::const_iterator itr = SpawnerList.begin(); itr != SpawnerList.end(); ++itr)
summonsGenerator.Summon(*itr);
summonsChanneler.Respawn();
summonsGenerator.Respawn();
ChannelersAction(ACTION_CHANNELERS_START_CHANNEL);
if (Creature* akama = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_AKAMA_SHADE)))
akama->Respawn(true);
break;
}
case EVENT_SHADE_RESET_ENCOUNTER:
me->SetVisible(true);
summonsGenerator.Respawn();
summonsChanneler.Respawn();
ChannelersAction(ACTION_CHANNELERS_START_CHANNEL);
if (Creature* akama = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_AKAMA_SHADE)))
akama->Respawn(true);
break;
}
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SHADE_CHECK_DISTANCE:
if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() != POINT_MOTION_TYPE)
{
int32 slow = me->GetMaxNegativeAuraModifier(SPELL_AURA_MOD_DECREASE_SPEED);
if (slow > -100)
{
me->SetWalk(true);
me->GetMotionMaster()->MovePoint(POINT_START, 510.0f, 400.7993f, 112.7837f);
}
}
else
{
int32 slow = me->GetMaxNegativeAuraModifier(SPELL_AURA_MOD_DECREASE_SPEED);
if (slow < -100)
me->GetMotionMaster()->Clear();
else if (slow == 0)
{
summonsGenerator.DoAction(ACTION_NO_SORCERERS);
me->SetWalk(false);
}
}
if (me->IsWithinMeleeRange(me->GetVictim()))
{
me->SetReactState(REACT_AGGRESSIVE);
DoResetThreat();
me->GetVictim()->InterruptNonMeleeSpells(false);
me->AddThreat(me->GetVictim(), 1000000.0f);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC|UNIT_FLAG_IMMUNE_TO_NPC|UNIT_FLAG_NOT_SELECTABLE);
summonsGenerator.DoAction(ACTION_STOP_SPAWNING);
break;
}
events.ScheduleEvent(EVENT_SHADE_CHECK_DISTANCE, 1000);
break;
}
DoMeleeAttackIfReady();
EnterEvadeIfOutOfCombatArea();
}
bool CheckEvadeIfOutOfCombatArea() const
{
return !SelectTargetFromPlayerList(120.0f);
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_shade_of_akamaAI>(creature);
}
};
class npc_akama_shade : public CreatureScript
{
public:
npc_akama_shade() : CreatureScript("npc_akama_shade") { }
struct npc_akamaAI : public ScriptedAI
{
npc_akamaAI(Creature* creature) : ScriptedAI(creature), summons(me)
{
instance = creature->GetInstanceScript();
}
InstanceScript* instance;
EventMap events;
EventMap events2;
SummonList summons;
void Reset()
{
if (instance->GetBossState(DATA_SHADE_OF_AKAMA) == DONE)
{
me->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
return;
}
me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
me->CastSpell(me, SPELL_STEALTH, true);
events.Reset();
events2.Reset();
}
void MovementInform(uint32 type, uint32 point)
{
if (type != POINT_MOTION_TYPE || point != POINT_CHANNEL_SOUL)
return;
me->SetFacingTo(0.0f);
events2.ScheduleEvent(EVENT_AKAMA_SCENE1, 1000);
events2.ScheduleEvent(EVENT_AKAMA_SCENE2, 16500);
events2.ScheduleEvent(EVENT_AKAMA_SCENE3, 17500);
events2.ScheduleEvent(EVENT_AKAMA_SCENE4, 27000);
events2.ScheduleEvent(EVENT_AKAMA_SCENE5, 37000);
events2.ScheduleEvent(EVENT_AKAMA_SCENE6, 51000);
events2.ScheduleEvent(EVENT_AKAMA_SCENE7, 56000);
}
void DoAction(int32 param)
{
if (param == ACTION_SHADE_DIED)
events2.ScheduleEvent(EVENT_AKAMA_SCENE0, 1000);
}
void JustDied(Unit* /*killer*/)
{
if (Creature* shade = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_SHADE_OF_AKAMA)))
shade->AI()->DoAction(ACTION_AKAMA_DIED);
}
void EnterCombat(Unit* /*who*/)
{
events.ScheduleEvent(EVENT_SPELL_CHAIN_LIGHTNING, 2000);
events.ScheduleEvent(EVENT_SPELL_DESTRUCTIVE_POISON, 5000);
}
void JustSummoned(Creature* summon)
{
float dist = frand(30.0f, 32.0f);
summon->SetWalk(true);
summon->GetMotionMaster()->MovePoint(POINT_START, summon->GetPositionX()+dist*cos(summon->GetOrientation()), summon->GetPositionY()+dist*sin(summon->GetOrientation()), summon->GetPositionZ(), false);
summons.Summon(summon);
}
void UpdateAI(uint32 diff)
{
events2.Update(diff);
switch (events2.ExecuteEvent())
{
case EVENT_AKAMA_START_ENCOUNTER:
me->RemoveAura(SPELL_STEALTH);
me->SetWalk(true);
me->GetMotionMaster()->MovePoint(POINT_START, 517.4877f, 400.7993f, 112.7837f, false);
events2.ScheduleEvent(EVENT_AKAMA_START_CHANNEL, 11000);
break;
case EVENT_AKAMA_START_CHANNEL:
me->CastSpell(me, SPELL_AKAMA_SOUL_CHANNEL, false);
if (Creature* shade = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_SHADE_OF_AKAMA)))
{
shade->AI()->AttackStart(me);
shade->GetMotionMaster()->Clear();
shade->AI()->DoAction(ACTION_START_ENCOUNTER);
}
break;
case EVENT_AKAMA_SCENE0:
me->SetWalk(true);
me->GetMotionMaster()->MovePoint(POINT_CHANNEL_SOUL, 467.0f, 400.7993f, 118.537f);
break;
case EVENT_AKAMA_SCENE1:
me->CastSpell(me, SPELL_AKAMA_SOUL_RETRIEVE, true);
break;
case EVENT_AKAMA_SCENE2:
Talk(SAY_BROKEN_FREE_0);
break;
case EVENT_AKAMA_SCENE3:
me->SummonCreatureGroup(SUMMON_GROUP_BROKENS);
break;
case EVENT_AKAMA_SCENE4:
Talk(SAY_BROKEN_FREE_1);
break;
case EVENT_AKAMA_SCENE5:
for (SummonList::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
if (Creature* broken = ObjectAccessor::GetCreature(*me, *itr))
broken->SetStandState(UNIT_STAND_STATE_KNEEL);
Talk(SAY_BROKEN_FREE_2);
break;
case EVENT_AKAMA_SCENE6:
if (Creature* broken = summons.GetCreatureWithEntry(NPC_ASHTONGUE_BROKEN))
broken->AI()->Talk(SAY_BROKEN_S1);
break;
case EVENT_AKAMA_SCENE7:
for (SummonList::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
if (Creature* broken = ObjectAccessor::GetCreature(*me, *itr))
broken->AI()->Talk(SAY_BROKEN_S2);
break;
}
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_CHAIN_LIGHTNING:
me->CastSpell(me->GetVictim(), SPELL_CHAIN_LIGHTNING, false);
events.ScheduleEvent(EVENT_SPELL_CHAIN_LIGHTNING, urand(10000, 15000));
break;
case EVENT_SPELL_DESTRUCTIVE_POISON:
me->CastSpell(me, SPELL_DESTRUCTIVE_POISON, false);
events.ScheduleEvent(EVENT_SPELL_DESTRUCTIVE_POISON, urand(4000, 5000));
break;
}
DoMeleeAttackIfReady();
}
void sGossipSelect(Player* player, uint32 /*sender*/, uint32 action)
{
if (action == 0)
{
player->CLOSE_GOSSIP_MENU();
me->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
events2.ScheduleEvent(EVENT_AKAMA_START_ENCOUNTER, 0);
}
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<npc_akamaAI>(creature);
}
};
// ########################################################
// Creature Generator Akama
// ########################################################
class npc_creature_generator_akama : public CreatureScript
{
public:
npc_creature_generator_akama() : CreatureScript("npc_creature_generator_akama") { }
struct npc_creature_generator_akamaAI : public NullCreatureAI
{
npc_creature_generator_akamaAI(Creature* creature) : NullCreatureAI(creature), summons(me)
{
instance = creature->GetInstanceScript();
}
void Reset()
{
events.Reset();
summons.DespawnAll();
}
void JustSummoned(Creature* summon)
{
summons.Summon(summon);
if (summon->GetEntry() == NPC_ASHTONGUE_SORCERER)
{
std::list<Creature*> channelerList;
me->GetCreaturesWithEntryInRange(channelerList, 120.0f, NPC_ASHTONGUE_CHANNELER);
for (std::list<Creature*>::const_iterator itr = channelerList.begin(); itr != channelerList.end(); ++itr)
{
if ((*itr)->IsAlive() || (*itr)->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))
continue;
summon->SetInCombatWithZone();
summon->SetReactState(REACT_PASSIVE);
summon->GetMotionMaster()->MovePoint(POINT_START, **itr);
(*itr)->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
return;
}
}
summon->SetInCombatWithZone();
if (Unit* akama = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_AKAMA_SHADE)))
{
summon->AddThreat(akama, 500.0f);
summon->AI()->AttackStart(akama);
}
}
void SummonedCreatureDies(Creature* summon, Unit*)
{
summon->DespawnOrUnsummon(10000);
summons.Despawn(summon);
}
void DoAction(int32 param)
{
if (param == ACTION_STOP_SPAWNING || param == ACTION_DESPAWN_ALL)
{
events.Reset();
for (SummonList::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
{
if (Creature* summon = ObjectAccessor::GetCreature(*me, *itr))
{
if (summon->GetEntry() != NPC_ASHTONGUE_SORCERER)
continue;
summon->InterruptNonMeleeSpells(false);
summon->GetMotionMaster()->Clear();
summon->SetInCombatWithZone();
}
}
}
if (param == ACTION_DESPAWN_ALL)
summons.DespawnAll();
else if (param == ACTION_NO_SORCERERS)
events.CancelEvent(EVENT_SUMMON_ASHTONGUE_SORCERER);
else if (param == ACTION_START_ENCOUNTER)
{
events.ScheduleEvent(EVENT_SUMMON_WAVE_B, 5000);
events.ScheduleEvent(EVENT_SUMMON_ASHTONGUE_DEFENDER, 20000);
events.ScheduleEvent(EVENT_SUMMON_ASHTONGUE_SORCERER, 35000);
}
}
void UpdateAI(uint32 diff)
{
events.Update(diff);
switch (events.ExecuteEvent())
{
case EVENT_SUMMON_WAVE_B:
me->CastSpell(me, SPELL_ASHTONGUE_WAVE_B, true);
events.ScheduleEvent(EVENT_SUMMON_WAVE_B, 45000);
break;
case EVENT_SUMMON_ASHTONGUE_SORCERER: // left
me->CastSpell(me, SPELL_SUMMON_ASHTONGUE_SORCERER, true);
events.ScheduleEvent(EVENT_SUMMON_ASHTONGUE_SORCERER, 45000);
break;
case EVENT_SUMMON_ASHTONGUE_DEFENDER: // right
me->CastSpell(me, SPELL_SUMMON_ASHTONGUE_DEFENDER, true);
events.ScheduleEvent(EVENT_SUMMON_ASHTONGUE_DEFENDER, 45000);
break;
default:
break;
}
}
private:
EventMap events;
SummonList summons;
InstanceScript* instance;
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<npc_creature_generator_akamaAI>(creature);
}
};
class spell_shade_of_akama_shade_soul_channel : public SpellScriptLoader
{
public:
spell_shade_of_akama_shade_soul_channel() : SpellScriptLoader("spell_shade_of_akama_shade_soul_channel") { }
class spell_shade_of_akama_shade_soul_channel_AuraScript : public AuraScript
{
PrepareAuraScript(spell_shade_of_akama_shade_soul_channel_AuraScript)
void HandleEffectApply(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
if (Unit* caster = GetCaster())
caster->SetFacingToObject(GetTarget());
}
void HandleEffectRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
if (Aura* aura = GetTarget()->GetAura(GetSpellInfo()->Effects[EFFECT_1].TriggerSpell))
aura->ModStackAmount(-1);
}
void Register()
{
AfterEffectApply += AuraEffectApplyFn(spell_shade_of_akama_shade_soul_channel_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
AfterEffectRemove += AuraEffectRemoveFn(spell_shade_of_akama_shade_soul_channel_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_shade_of_akama_shade_soul_channel_AuraScript();
}
};
class spell_shade_of_akama_akama_soul_expel : public SpellScriptLoader
{
public:
spell_shade_of_akama_akama_soul_expel() : SpellScriptLoader("spell_shade_of_akama_akama_soul_expel") { }
class spell_shade_of_akama_akama_soul_expel_SpellScript : public SpellScript
{
PrepareSpellScript(spell_shade_of_akama_akama_soul_expel_SpellScript);
void SetDest(SpellDestination& dest)
{
// Adjust effect summon position
Position const offset = { 0.0f, 0.0f, 25.0f, 0.0f };
dest.RelocateOffset(offset);
}
void Register()
{
OnDestinationTargetSelect += SpellDestinationTargetSelectFn(spell_shade_of_akama_akama_soul_expel_SpellScript::SetDest, EFFECT_0, TARGET_DEST_CASTER_RADIUS);
}
};
SpellScript* GetSpellScript() const
{
return new spell_shade_of_akama_akama_soul_expel_SpellScript();
}
};
void AddSC_boss_shade_of_akama()
{
new boss_shade_of_akama();
new npc_akama_shade();
new npc_creature_generator_akama();
new spell_shade_of_akama_shade_soul_channel();
new spell_shade_of_akama_akama_soul_expel();
}

197
src/server/scripts/Outland/BlackTemple/boss_supremus.cpp
View File

@@ -1,197 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "black_temple.h"
enum Supremus
{
EMOTE_NEW_TARGET = 0,
EMOTE_PUNCH_GROUND = 1,
EMOTE_GROUND_CRACK = 2,
SPELL_SNARE_SELF = 41922,
SPELL_MOLTEN_PUNCH = 40126,
SPELL_HATEFUL_STRIKE = 41926,
SPELL_VOLCANIC_ERUPTION = 40276,
SPELL_VOLCANIC_ERUPTION_TRIGGER = 40117,
SPELL_BERSERK = 45078,
SPELL_CHARGE = 41581,
NPC_SUPREMUS_PUNCH_STALKER = 23095,
EVENT_SPELL_BERSERK = 1,
EVENT_SPELL_HATEFUL_STRIKE = 2,
EVENT_SPELL_MOLTEN_FLAMES = 3,
EVENT_SWITCH_PHASE = 4,
EVENT_SPELL_VOLCANIC_ERUPTION = 5,
EVENT_SWITCH_TARGET = 6,
EVENT_CHECK_DIST = 7,
EVENT_GROUP_ABILITIES = 1
};
class boss_supremus : public CreatureScript
{
public:
boss_supremus() : CreatureScript("boss_supremus") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_supremusAI>(creature);
}
struct boss_supremusAI : public BossAI
{
boss_supremusAI(Creature* creature) : BossAI(creature, DATA_SUPREMUS)
{
}
void Reset()
{
BossAI::Reset();
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
SchedulePhase(false);
events.ScheduleEvent(EVENT_SPELL_BERSERK, 900000);
events.ScheduleEvent(EVENT_SPELL_MOLTEN_FLAMES, 4000);
}
void SchedulePhase(bool run)
{
events.CancelEventGroup(EVENT_GROUP_ABILITIES);
events.ScheduleEvent(EVENT_SWITCH_PHASE, 60000);
DoResetThreat();
if (!run)
{
events.ScheduleEvent(EVENT_SPELL_HATEFUL_STRIKE, 5000, EVENT_GROUP_ABILITIES);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
me->RemoveAurasDueToSpell(SPELL_SNARE_SELF);
}
else
{
events.ScheduleEvent(EVENT_SPELL_VOLCANIC_ERUPTION, 5000, EVENT_GROUP_ABILITIES);
events.ScheduleEvent(EVENT_SWITCH_TARGET, 0, EVENT_GROUP_ABILITIES);
events.ScheduleEvent(EVENT_CHECK_DIST, 0, EVENT_GROUP_ABILITIES);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, true);
me->CastSpell(me, SPELL_SNARE_SELF, true);
}
}
void JustDied(Unit* killer)
{
BossAI::JustDied(killer);
}
void JustSummoned(Creature* summon)
{
summons.Summon(summon);
if (summon->GetEntry() == NPC_SUPREMUS_PUNCH_STALKER)
{
summon->ToTempSummon()->InitStats(20000);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
summon->GetMotionMaster()->MoveFollow(target, 0.0f, 0.0f, MOTION_SLOT_CONTROLLED);
}
else
summon->CastSpell(summon, SPELL_VOLCANIC_ERUPTION_TRIGGER, true);
}
void SummonedCreatureDespawn(Creature* summon)
{
summons.Despawn(summon);
}
Unit* FindHatefulStrikeTarget()
{
Unit* target = NULL;
ThreatContainer::StorageType const &threatlist = me->getThreatManager().getThreatList();
for (ThreatContainer::StorageType::const_iterator i = threatlist.begin(); i != threatlist.end(); ++i)
{
Unit* unit = ObjectAccessor::GetUnit(*me, (*i)->getUnitGuid());
if (unit && me->IsWithinMeleeRange(unit))
if (!target || unit->GetHealth() > target->GetHealth())
target = unit;
}
return target;
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_BERSERK:
me->CastSpell(me, SPELL_BERSERK, true);
break;
case EVENT_SPELL_HATEFUL_STRIKE:
if (Unit* target = FindHatefulStrikeTarget())
me->CastSpell(target, SPELL_HATEFUL_STRIKE, false);
events.ScheduleEvent(EVENT_SPELL_HATEFUL_STRIKE, urand(1500, 3000), EVENT_GROUP_ABILITIES);
break;
case EVENT_SPELL_MOLTEN_FLAMES:
me->CastSpell(me, SPELL_MOLTEN_PUNCH, false);
events.ScheduleEvent(EVENT_SPELL_MOLTEN_FLAMES, 20000, EVENT_GROUP_ABILITIES);
break;
case EVENT_SWITCH_PHASE:
SchedulePhase(!me->HasAura(SPELL_SNARE_SELF));
break;
case EVENT_SWITCH_TARGET:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
{
DoResetThreat();
me->AddThreat(target, 5000000.0f);
Talk(EMOTE_NEW_TARGET);
}
events.ScheduleEvent(EVENT_SWITCH_TARGET, 10000, EVENT_GROUP_ABILITIES);
break;
case EVENT_CHECK_DIST:
if (me->GetDistance(me->GetVictim()) > 40.0f)
{
Talk(EMOTE_PUNCH_GROUND);
me->CastSpell(me->GetVictim(), SPELL_CHARGE, true);
events.ScheduleEvent(EVENT_CHECK_DIST, 5000, EVENT_GROUP_ABILITIES);
break;
}
events.ScheduleEvent(EVENT_CHECK_DIST, 1, EVENT_GROUP_ABILITIES);
break;
case EVENT_SPELL_VOLCANIC_ERUPTION:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
{
me->CastSpell(target, SPELL_VOLCANIC_ERUPTION, true);
Talk(EMOTE_GROUND_CRACK);
}
events.ScheduleEvent(EVENT_SPELL_VOLCANIC_ERUPTION, urand(10000, 18000), EVENT_GROUP_ABILITIES);
break;
}
DoMeleeAttackIfReady();
EnterEvadeIfOutOfCombatArea();
}
bool CheckEvadeIfOutOfCombatArea() const
{
return me->GetPositionX() < 565 || me->GetPositionX() > 865 || me->GetPositionY() < 545 || me->GetPositionY() > 1000;
}
};
};
void AddSC_boss_supremus()
{
new boss_supremus();
}

333
src/server/scripts/Outland/BlackTemple/boss_teron_gorefiend.cpp
View File

@@ -1,333 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "black_temple.h"
enum Says
{
SAY_INTRO = 0,
SAY_AGGRO = 1,
SAY_SLAY = 2,
SAY_BLOSSOM = 3,
SAY_INCINERATE = 4,
SAY_CRUSHING = 5,
SAY_DEATH = 6
};
enum Spells
{
SPELL_INCINERATE = 40239,
SPELL_SUMMON_DOOM_BLOSSOM = 40188,
SPELL_CRUSHING_SHADOWS = 40243,
SPELL_SHADOW_OF_DEATH = 40251,
SPELL_SHADOW_OF_DEATH_REMOVE = 41999,
SPELL_SUMMON_SPIRIT = 40266,
SPELL_SUMMON_SKELETON1 = 40270,
SPELL_SUMMON_SKELETON2 = 41948,
SPELL_SUMMON_SKELETON3 = 41949,
SPELL_SUMMON_SKELETON4 = 41950,
SPELL_POSSESS_SPIRIT_IMMUNE = 40282,
SPELL_SPIRITUAL_VENGEANCE = 40268,
SPELL_BRIEF_STUN = 41421,
SPELL_SPIRIT_LANCE = 40157,
SPELL_SPIRIT_CHAINS = 40175,
SPELL_SPIRIT_VOLLEY = 40314
};
enum Misc
{
SET_DATA_INTRO = 1,
EVENT_SPELL_INCINERATE = 1,
EVENT_SPELL_DOOM_BLOSSOM = 2,
EVENT_SPELL_CRUSHING_SHADOWS = 3,
EVENT_SPELL_SHADOW_OF_DEATH = 4,
EVENT_TALK_KILL = 10
};
struct ShadowOfDeathSelector : public std::unary_function<Unit*, bool>
{
bool operator()(Unit const* target) const
{
return target && !target->HasAura(SPELL_SHADOW_OF_DEATH) && !target->HasAura(SPELL_POSSESS_SPIRIT_IMMUNE);
}
};
class boss_teron_gorefiend : public CreatureScript
{
public:
boss_teron_gorefiend() : CreatureScript("boss_teron_gorefiend") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_teron_gorefiendAI>(creature);
}
struct boss_teron_gorefiendAI : public BossAI
{
boss_teron_gorefiendAI(Creature* creature) : BossAI(creature, DATA_TERON_GOREFIEND)
{
intro = false;
}
bool intro;
void Reset()
{
BossAI::Reset();
me->CastSpell(me, SPELL_SHADOW_OF_DEATH_REMOVE, true);
}
void SetData(uint32 type, uint32 id)
{
if (type || !me->IsAlive())
return;
if (id == SET_DATA_INTRO && !intro)
{
intro = true;
Talk(SAY_INTRO);
}
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
events.ScheduleEvent(EVENT_SPELL_INCINERATE, 24000);
events.ScheduleEvent(EVENT_SPELL_DOOM_BLOSSOM, 10000);
events.ScheduleEvent(EVENT_SPELL_CRUSHING_SHADOWS, 17000);
events.ScheduleEvent(EVENT_SPELL_SHADOW_OF_DEATH, 20000);
}
void KilledUnit(Unit* victim)
{
if (events.GetNextEventTime(EVENT_TALK_KILL) == 0)
{
Talk(SAY_SLAY);
events.ScheduleEvent(EVENT_TALK_KILL, 6000);
}
}
void JustSummoned(Creature* summon)
{
summons.Summon(summon);
}
void JustDied(Unit* killer)
{
BossAI::JustDied(killer);
Talk(SAY_DEATH);
me->CastSpell(me, SPELL_SHADOW_OF_DEATH_REMOVE, true);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim() )
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_INCINERATE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
if (roll_chance_i(50))
Talk(SAY_INCINERATE);
me->CastSpell(target, SPELL_INCINERATE, false);
}
events.ScheduleEvent(EVENT_SPELL_INCINERATE, 25000);
break;
case EVENT_SPELL_DOOM_BLOSSOM:
if (roll_chance_i(50))
Talk(SAY_BLOSSOM);
me->CastSpell(me, SPELL_SUMMON_DOOM_BLOSSOM, false);
events.ScheduleEvent(EVENT_SPELL_DOOM_BLOSSOM, 40000);
break;
case EVENT_SPELL_CRUSHING_SHADOWS:
if (roll_chance_i(20))
Talk(SAY_CRUSHING);
me->CastCustomSpell(SPELL_CRUSHING_SHADOWS, SPELLVALUE_MAX_TARGETS, 5, me, false);
events.ScheduleEvent(EVENT_SPELL_CRUSHING_SHADOWS, 15000);
break;
case EVENT_SPELL_SHADOW_OF_DEATH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, ShadowOfDeathSelector()))
me->CastSpell(target, SPELL_SHADOW_OF_DEATH, false);
events.ScheduleEvent(EVENT_SPELL_SHADOW_OF_DEATH, 30000);
break;
}
DoMeleeAttackIfReady();
EnterEvadeIfOutOfCombatArea();
}
bool CheckEvadeIfOutOfCombatArea() const
{
return me->GetDistance(me->GetHomePosition()) > 100.0f;
}
};
};
class spell_teron_gorefiend_shadow_of_death : public SpellScriptLoader
{
public:
spell_teron_gorefiend_shadow_of_death() : SpellScriptLoader("spell_teron_gorefiend_shadow_of_death") { }
class spell_teron_gorefiend_shadow_of_death_AuraScript : public AuraScript
{
PrepareAuraScript(spell_teron_gorefiend_shadow_of_death_AuraScript)
void Absorb(AuraEffect* /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
{
PreventDefaultAction();
}
void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
InstanceScript* instance = GetTarget()->GetInstanceScript();
if (!GetCaster() || !instance || !instance->IsEncounterInProgress())
return;
GetTarget()->CastSpell(GetTarget(), SPELL_SUMMON_SPIRIT, true);
GetTarget()->CastSpell(GetTarget(), SPELL_POSSESS_SPIRIT_IMMUNE, true);
GetTarget()->CastSpell(GetTarget(), SPELL_SPIRITUAL_VENGEANCE, true);
GetTarget()->CastSpell(GetTarget(), SPELL_SUMMON_SKELETON1, true);
GetTarget()->CastSpell(GetTarget(), SPELL_SUMMON_SKELETON2, true);
GetTarget()->CastSpell(GetTarget(), SPELL_SUMMON_SKELETON3, true);
GetTarget()->CastSpell(GetTarget(), SPELL_SUMMON_SKELETON4, true);
}
void Register()
{
OnEffectAbsorb += AuraEffectAbsorbFn(spell_teron_gorefiend_shadow_of_death_AuraScript::Absorb, EFFECT_0);
AfterEffectRemove += AuraEffectRemoveFn(spell_teron_gorefiend_shadow_of_death_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_teron_gorefiend_shadow_of_death_AuraScript();
}
};
class spell_teron_gorefiend_spirit_lance : public SpellScriptLoader
{
public:
spell_teron_gorefiend_spirit_lance() : SpellScriptLoader("spell_teron_gorefiend_spirit_lance") { }
class spell_teron_gorefiend_spirit_lance_AuraScript : public AuraScript
{
PrepareAuraScript(spell_teron_gorefiend_spirit_lance_AuraScript);
void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/)
{
if (AuraEffect* effect = GetAura()->GetEffect(EFFECT_2))
amount -= (amount / effect->GetTotalTicks()) * effect->GetTickNumber();
}
void Update(AuraEffect const* effect)
{
PreventDefaultAction();
if (AuraEffect* effect = GetAura()->GetEffect(EFFECT_1))
effect->RecalculateAmount();
}
void Register()
{
DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_teron_gorefiend_spirit_lance_AuraScript::CalculateAmount, EFFECT_1, SPELL_AURA_MOD_DECREASE_SPEED);
OnEffectPeriodic += AuraEffectPeriodicFn(spell_teron_gorefiend_spirit_lance_AuraScript::Update, EFFECT_2, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_teron_gorefiend_spirit_lance_AuraScript();
}
};
class spell_teron_gorefiend_spiritual_vengeance : public SpellScriptLoader
{
public:
spell_teron_gorefiend_spiritual_vengeance() : SpellScriptLoader("spell_teron_gorefiend_spiritual_vengeance") { }
class spell_teron_gorefiend_spiritual_vengeance_AuraScript : public AuraScript
{
PrepareAuraScript(spell_teron_gorefiend_spiritual_vengeance_AuraScript)
void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
Unit::Kill(NULL, GetTarget());
}
void Register()
{
AfterEffectRemove += AuraEffectRemoveFn(spell_teron_gorefiend_spiritual_vengeance_AuraScript::HandleEffectRemove, EFFECT_2, SPELL_AURA_MOD_PACIFY_SILENCE, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_teron_gorefiend_spiritual_vengeance_AuraScript();
}
};
class spell_teron_gorefiend_shadowy_construct : public SpellScriptLoader
{
public:
spell_teron_gorefiend_shadowy_construct() : SpellScriptLoader("spell_teron_gorefiend_shadowy_construct") { }
class spell_teron_gorefiend_shadowy_construct_AuraScript : public AuraScript
{
PrepareAuraScript(spell_teron_gorefiend_shadowy_construct_AuraScript)
bool Load()
{
return GetUnitOwner()->GetTypeId() == TYPEID_UNIT;
}
void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
GetUnitOwner()->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_NORMAL, true);
GetUnitOwner()->ApplySpellImmune(0, IMMUNITY_ALLOW_ID, SPELL_SPIRIT_LANCE, true);
GetUnitOwner()->ApplySpellImmune(0, IMMUNITY_ALLOW_ID, SPELL_SPIRIT_CHAINS, true);
GetUnitOwner()->ApplySpellImmune(0, IMMUNITY_ALLOW_ID, SPELL_SPIRIT_VOLLEY, true);
GetUnitOwner()->ToCreature()->SetInCombatWithZone();
Map::PlayerList const& playerList = GetUnitOwner()->GetMap()->GetPlayers();
for (Map::PlayerList::const_iterator i = playerList.begin(); i != playerList.end(); ++i)
if (Player* player = i->GetSource())
{
if (GetUnitOwner()->IsValidAttackTarget(player))
GetUnitOwner()->AddThreat(player, 1000000.0f);
}
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_BRIEF_STUN, true);
}
void Register()
{
AfterEffectApply += AuraEffectApplyFn(spell_teron_gorefiend_shadowy_construct_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_teron_gorefiend_shadowy_construct_AuraScript();
}
};
void AddSC_boss_teron_gorefiend()
{
new boss_teron_gorefiend();
new spell_teron_gorefiend_shadow_of_death();
new spell_teron_gorefiend_spirit_lance();
new spell_teron_gorefiend_spiritual_vengeance();
new spell_teron_gorefiend_shadowy_construct();
}

194
src/server/scripts/Outland/BlackTemple/boss_warlord_najentus.cpp
View File

@@ -1,194 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "black_temple.h"
enum Yells
{
SAY_AGGRO = 0,
SAY_NEEDLE = 1,
SAY_SLAY = 2,
SAY_SPECIAL = 3,
SAY_ENRAGE = 4,
SAY_DEATH = 5
};
enum Spells
{
SPELL_NEEDLE_SPINE = 39992,
SPELL_NEEDLE_SPINE_DAMAGE = 39835,
SPELL_TIDAL_BURST = 39878,
SPELL_TIDAL_SHIELD = 39872,
SPELL_IMPALING_SPINE = 39837,
SPELL_SUMMON_IMPALING_SPINE = 39929,
SPELL_BERSERK = 26662
};
enum Events
{
EVENT_SPELL_BERSERK = 1,
EVENT_YELL = 2,
EVENT_SPELL_NEEDLE = 3,
EVENT_SPELL_SPINE = 4,
EVENT_SPELL_SHIELD = 5,
EVENT_KILL_SPEAK = 6
};
class boss_najentus : public CreatureScript
{
public:
boss_najentus() : CreatureScript("boss_najentus") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_najentusAI>(creature);
}
struct boss_najentusAI : public BossAI
{
boss_najentusAI(Creature* creature) : BossAI(creature, DATA_HIGH_WARLORD_NAJENTUS)
{
}
void Reset()
{
BossAI::Reset();
}
void KilledUnit(Unit* victim)
{
if (victim->GetTypeId() == TYPEID_PLAYER && events.GetNextEventTime(EVENT_KILL_SPEAK) == 0)
{
Talk(SAY_SLAY);
events.ScheduleEvent(EVENT_KILL_SPEAK, 5000);
}
}
void JustDied(Unit* killer)
{
BossAI::JustDied(killer);
Talk(SAY_DEATH);
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
Talk(SAY_AGGRO);
events.ScheduleEvent(EVENT_SPELL_BERSERK, 480000);
events.ScheduleEvent(EVENT_YELL, urand(25000, 100000));
events.RescheduleEvent(EVENT_SPELL_NEEDLE, 10000);
events.RescheduleEvent(EVENT_SPELL_SPINE, 20001);
events.RescheduleEvent(EVENT_SPELL_SHIELD, 60000);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_SHIELD:
me->CastSpell(me, SPELL_TIDAL_SHIELD, false);
events.DelayEvents(10000);
events.ScheduleEvent(EVENT_SPELL_SHIELD, 60000);
break;
case EVENT_SPELL_BERSERK:
Talk(SAY_ENRAGE);
me->CastSpell(me, SPELL_BERSERK, true);
break;
case EVENT_SPELL_NEEDLE:
me->CastCustomSpell(SPELL_NEEDLE_SPINE, SPELLVALUE_MAX_TARGETS, 3, me, false);
events.ScheduleEvent(EVENT_SPELL_NEEDLE, 15000);
break;
case EVENT_SPELL_SPINE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1))
{
me->CastSpell(target, SPELL_IMPALING_SPINE, false);
target->CastSpell(target, SPELL_SUMMON_IMPALING_SPINE, true);
Talk(SAY_NEEDLE);
}
events.ScheduleEvent(EVENT_SPELL_SPINE, 20000);
return;
case EVENT_YELL:
Talk(SAY_SPECIAL);
events.ScheduleEvent(EVENT_YELL, urand(25000, 100000));
break;
}
DoMeleeAttackIfReady();
}
};
};
class spell_najentus_needle_spine : public SpellScriptLoader
{
public:
spell_najentus_needle_spine() : SpellScriptLoader("spell_najentus_needle_spine") { }
class spell_najentus_needle_spine_SpellScript : public SpellScript
{
PrepareSpellScript(spell_najentus_needle_spine_SpellScript);
void HandleDummy(SpellEffIndex effIndex)
{
if (Unit* target = GetHitUnit())
GetCaster()->CastSpell(target, SPELL_NEEDLE_SPINE_DAMAGE, true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_najentus_needle_spine_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_najentus_needle_spine_SpellScript();
}
};
class spell_najentus_hurl_spine : public SpellScriptLoader
{
public:
spell_najentus_hurl_spine() : SpellScriptLoader("spell_najentus_hurl_spine") { }
class spell_najentus_hurl_spine_SpellScript : public SpellScript
{
PrepareSpellScript(spell_najentus_hurl_spine_SpellScript);
void HandleSchoolDamage(SpellEffIndex effIndex)
{
Unit* target = GetHitUnit();
if (target && target->HasAura(SPELL_TIDAL_SHIELD))
{
target->RemoveAurasDueToSpell(SPELL_TIDAL_SHIELD);
target->CastSpell(target, SPELL_TIDAL_BURST, true);
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_najentus_hurl_spine_SpellScript::HandleSchoolDamage, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
}
};
SpellScript* GetSpellScript() const
{
return new spell_najentus_hurl_spine_SpellScript();
}
};
void AddSC_boss_najentus()
{
new boss_najentus();
new spell_najentus_needle_spine();
new spell_najentus_hurl_spine();
}

753
src/server/scripts/Outland/BlackTemple/illidari_council.cpp
View File

@@ -1,753 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "black_temple.h"
enum Says
{
SAY_COUNCIL_AGGRO = 0,
SAY_COUNCIL_ENRAGE = 1,
SAY_COUNCIL_SPECIAL = 2,
SAY_COUNCIL_SLAY = 3,
SAY_COUNCIL_DEATH = 4
};
enum Spells
{
SPELL_EMPYREAL_BALANCE = 41499,
SPELL_BERSERK = 41924,
// Gathios the Shatterer
SPELL_BLESSING_OF_PROTECTION = 41450,
SPELL_BLESSING_OF_SPELL_WARDING = 41451,
SPELL_CONSECRATION = 41541,
SPELL_HAMMER_OF_JUSTICE = 41468,
SPELL_SEAL_OF_COMMAND = 41469,
SPELL_SEAL_OF_BLOOD = 41459,
SPELL_CHROMATIC_RESISTANCE_AURA = 41453,
SPELL_DEVOTION_AURA = 41452,
SPELL_JUDGEMENT = 41467,
// High Nethermancer Zerevor
SPELL_FLAMESTRIKE = 41481,
SPELL_BLIZZARD = 41482,
SPELL_ARCANE_BOLT = 41483,
SPELL_ARCANE_EXPLOSION = 41524,
SPELL_DAMPEN_MAGIC = 41478,
// Lady Malande
SPELL_EMPOWERED_SMITE = 41471,
SPELL_CIRCLE_OF_HEALING = 41455,
SPELL_REFLECTIVE_SHIELD = 41475,
SPELL_REFLECTIVE_SHIELD_T = 33619,
SPELL_DIVINE_WRATH = 41472,
SPELL_HEAL_VISUAL = 24171,
// Veras Darkshadow
SPELL_DEADLY_STRIKE = 41480,
SPELL_DEADLY_POISON = 41485,
SPELL_ENVENOM = 41487,
SPELL_VANISH = 41476,
SPELL_VANISH_OUT = 41479,
SPELL_VANISH_VISUAL = 24222
};
enum Misc
{
ACTION_START_ENCOUNTER = 1,
ACTION_END_ENCOUNTER = 2,
ACTION_ENRAGE = 3,
EVENT_SPELL_BLESSING = 1,
EVENT_SPELL_AURA = 2,
EVENT_SPELL_SEAL = 3,
EVENT_SPELL_HAMMER_OF_JUSTICE = 4,
EVENT_SPELL_JUDGEMENT = 5,
EVENT_SPELL_CONSECRATION = 6,
EVENT_SPELL_FLAMESTRIKE = 10,
EVENT_SPELL_BLIZZARD = 11,
EVENT_SPELL_ARCANE_BOLT = 12,
EVENT_SPELL_DAMPEN_MAGIC = 13,
EVENT_SPELL_ARCANE_EXPLOSION = 14,
EVENT_SPELL_REFLECTIVE_SHIELD = 20,
EVENT_SPELL_CIRCLE_OF_HEALING = 21,
EVENT_SPELL_DIVINE_WRATH = 22,
EVENT_SPELL_EMPOWERED_SMITE = 23,
EVENT_SPELL_VANISH = 30,
EVENT_SPELL_VANISH_OUT = 31,
EVENT_SPELL_ENRAGE = 32,
EVENT_KILL_TALK = 100
};
struct HammerOfJusticeSelector : public std::unary_function<Unit*, bool>
{
Unit const* _me;
HammerOfJusticeSelector(Unit* me) : _me(me) { }
bool operator()(Unit const* target) const
{
return target && target->GetTypeId() == TYPEID_PLAYER && _me->IsInRange(target, 10.0f, 40.0f, true);
}
};
class VerasEnvenom : public BasicEvent
{
public:
VerasEnvenom(Unit& owner, uint64 targetGUID) : _owner(owner), _targetGUID(targetGUID) { }
bool Execute(uint64 /*eventTime*/, uint32 /*updateTime*/)
{
if (Player* target = ObjectAccessor::GetPlayer(_owner, _targetGUID))
{
target->m_clientGUIDs.insert(_owner.GetGUID());
_owner.CastSpell(target, SPELL_ENVENOM, true);
target->RemoveAurasDueToSpell(SPELL_DEADLY_POISON);
target->m_clientGUIDs.erase(_owner.GetGUID());
}
return true;
}
private:
Unit& _owner;
uint64 _targetGUID;
};
class boss_illidari_council : public CreatureScript
{
public:
boss_illidari_council() : CreatureScript("boss_illidari_council") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_illidari_councilAI>(creature);
}
struct boss_illidari_councilAI : public BossAI
{
boss_illidari_councilAI(Creature* creature) : BossAI(creature, DATA_ILLIDARI_COUNCIL)
{
memset(councilGUIDs, 0, sizeof(councilGUIDs));
}
uint64 councilGUIDs[4];
void Reset()
{
BossAI::Reset();
Creature* member = NULL;
for (uint8 i = 0; i < 4; ++i)
if (member = ObjectAccessor::GetCreature(*me, councilGUIDs[i]))
member->AI()->EnterEvadeMode();
}
void AttackStart(Unit*) { }
void MoveInLineOfSight(Unit*) { }
void DoAction(int32 param)
{
if (!me->isActiveObject() && param == ACTION_START_ENCOUNTER)
{
me->setActive(true);
councilGUIDs[0] = instance->GetData64(NPC_GATHIOS_THE_SHATTERER);
councilGUIDs[1] = instance->GetData64(NPC_HIGH_NETHERMANCER_ZEREVOR);
councilGUIDs[2] = instance->GetData64(NPC_LADY_MALANDE);
councilGUIDs[3] = instance->GetData64(NPC_VERAS_DARKSHADOW);
bool spoken = false;
for (uint8 i = 0; i < 4; ++i)
{
if (Creature* member = ObjectAccessor::GetCreature(*me, councilGUIDs[i]))
{
if (!spoken && (roll_chance_i(33) || i == 3))
{
spoken = true;
member->AI()->Talk(SAY_COUNCIL_AGGRO);
}
member->SetOwnerGUID(me->GetGUID());
member->SetInCombatWithZone();
}
}
}
else if (param == ACTION_ENRAGE)
{
Creature* member = NULL;
for (uint8 i = 0; i < 4; ++i)
if (member = ObjectAccessor::GetCreature(*me, councilGUIDs[i]))
member->AI()->DoAction(ACTION_ENRAGE);
}
else if (param == ACTION_END_ENCOUNTER)
{
me->setActive(false);
Creature* member = NULL;
for (uint8 i = 0; i < 4; ++i)
if (member = ObjectAccessor::GetCreature(*me, councilGUIDs[i]))
if (member->IsAlive())
Unit::Kill(me, member);
Unit::Kill(me, me);
}
}
void UpdateAI(uint32 diff)
{
if (!me->isActiveObject())
return;
if (!SelectTargetFromPlayerList(115.0f))
{
EnterEvadeMode();
return;
}
me->CastSpell(me, SPELL_EMPYREAL_BALANCE, true);
}
};
};
struct boss_illidari_council_memberAI : public ScriptedAI
{
boss_illidari_council_memberAI(Creature* creature) : ScriptedAI(creature)
{
instance = creature->GetInstanceScript();
}
InstanceScript* instance;
EventMap events;
void Reset()
{
events.Reset();
}
void EnterEvadeMode()
{
me->SetOwnerGUID(0);
ScriptedAI::EnterEvadeMode();
}
void DoAction(int32 param)
{
if (param == ACTION_ENRAGE)
{
me->CastSpell(me, SPELL_BERSERK, true);
Talk(SAY_COUNCIL_ENRAGE);
}
}
void KilledUnit(Unit*)
{
if (events.GetNextEventTime(EVENT_KILL_TALK) == 0)
{
Talk(SAY_COUNCIL_SLAY);
events.ScheduleEvent(EVENT_KILL_TALK, 6000);
}
}
void JustDied(Unit*)
{
Talk(SAY_COUNCIL_DEATH);
if (Creature* council = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_ILLIDARI_COUNCIL)))
council->GetAI()->DoAction(ACTION_END_ENCOUNTER);
}
void EnterCombat(Unit* who)
{
if (Creature* council = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_ILLIDARI_COUNCIL)))
council->GetAI()->DoAction(ACTION_START_ENCOUNTER);
}
};
class boss_gathios_the_shatterer : public CreatureScript
{
public:
boss_gathios_the_shatterer() : CreatureScript("boss_gathios_the_shatterer") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_gathios_the_shattererAI>(creature);
}
struct boss_gathios_the_shattererAI : public boss_illidari_council_memberAI
{
boss_gathios_the_shattererAI(Creature* creature) : boss_illidari_council_memberAI(creature) { }
Creature* SelectCouncilMember()
{
if (roll_chance_i(50))
return ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_LADY_MALANDE));
if (roll_chance_i(20))
if (Creature* veras = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_VERAS_DARKSHADOW)))
if (!veras->HasAura(SPELL_VANISH))
return veras;
return ObjectAccessor::GetCreature(*me, instance->GetData64(RAND(NPC_GATHIOS_THE_SHATTERER, NPC_HIGH_NETHERMANCER_ZEREVOR)));
}
void EnterCombat(Unit* who)
{
boss_illidari_council_memberAI::EnterCombat(who);
events.ScheduleEvent(EVENT_SPELL_BLESSING, 10000);
events.ScheduleEvent(EVENT_SPELL_AURA, 0);
events.ScheduleEvent(EVENT_SPELL_SEAL, 2000);
events.ScheduleEvent(EVENT_SPELL_HAMMER_OF_JUSTICE, 6000);
events.ScheduleEvent(EVENT_SPELL_JUDGEMENT, 8000);
events.ScheduleEvent(EVENT_SPELL_CONSECRATION, 4000);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_BLESSING:
if (Unit* member = SelectCouncilMember())
me->CastSpell(member, RAND(SPELL_BLESSING_OF_SPELL_WARDING, SPELL_BLESSING_OF_PROTECTION), false);
events.ScheduleEvent(EVENT_SPELL_BLESSING, 15000);
break;
case EVENT_SPELL_AURA:
me->CastSpell(me, RAND(SPELL_DEVOTION_AURA, SPELL_CHROMATIC_RESISTANCE_AURA), false);
events.ScheduleEvent(EVENT_SPELL_AURA, 60000);
break;
case EVENT_SPELL_CONSECRATION:
if (roll_chance_i(50))
Talk(SAY_COUNCIL_SPECIAL);
me->CastSpell(me, SPELL_CONSECRATION, false);
events.ScheduleEvent(EVENT_SPELL_AURA, 30000);
break;
case EVENT_SPELL_HAMMER_OF_JUSTICE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, HammerOfJusticeSelector(me)))
{
me->CastSpell(target, SPELL_HAMMER_OF_JUSTICE, false);
events.ScheduleEvent(EVENT_SPELL_HAMMER_OF_JUSTICE, 20000);
break;
}
events.ScheduleEvent(EVENT_SPELL_HAMMER_OF_JUSTICE, 0);
break;
case EVENT_SPELL_SEAL:
me->CastSpell(me, RAND(SPELL_SEAL_OF_COMMAND, SPELL_SEAL_OF_BLOOD), false);
events.ScheduleEvent(EVENT_SPELL_SEAL, 20000);
break;
case EVENT_SPELL_JUDGEMENT:
me->CastSpell(me->GetVictim(), SPELL_JUDGEMENT, false);
events.ScheduleEvent(EVENT_SPELL_JUDGEMENT, 20000);
break;
}
DoMeleeAttackIfReady();
}
};
};
class boss_high_nethermancer_zerevor : public CreatureScript
{
public:
boss_high_nethermancer_zerevor() : CreatureScript("boss_high_nethermancer_zerevor") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_high_nethermancer_zerevorAI>(creature);
}
struct boss_high_nethermancer_zerevorAI : public boss_illidari_council_memberAI
{
boss_high_nethermancer_zerevorAI(Creature* creature) : boss_illidari_council_memberAI(creature) { }
void AttackStart(Unit* who)
{
if (who && me->Attack(who, true))
me->GetMotionMaster()->MoveChase(who, 20.0f);
}
void EnterCombat(Unit* who)
{
boss_illidari_council_memberAI::EnterCombat(who);
events.ScheduleEvent(EVENT_SPELL_FLAMESTRIKE, 25000);
events.ScheduleEvent(EVENT_SPELL_BLIZZARD, 5000);
events.ScheduleEvent(EVENT_SPELL_ARCANE_BOLT, 15000);
events.ScheduleEvent(EVENT_SPELL_DAMPEN_MAGIC, 0);
events.ScheduleEvent(EVENT_SPELL_ARCANE_EXPLOSION, 10000);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_DAMPEN_MAGIC:
me->CastSpell(me, SPELL_DAMPEN_MAGIC, false);
events.ScheduleEvent(EVENT_SPELL_DAMPEN_MAGIC, 120000);
break;
case EVENT_SPELL_ARCANE_BOLT:
me->CastSpell(me->GetVictim(), SPELL_ARCANE_BOLT, false);
events.ScheduleEvent(EVENT_SPELL_ARCANE_BOLT, 3000);
break;
case EVENT_SPELL_FLAMESTRIKE:
if (roll_chance_i(50))
Talk(SAY_COUNCIL_SPECIAL);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f))
me->CastSpell(target, SPELL_FLAMESTRIKE, false);
events.ScheduleEvent(EVENT_SPELL_FLAMESTRIKE, 40000);
break;
case EVENT_SPELL_BLIZZARD:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f))
me->CastSpell(target, SPELL_BLIZZARD, false);
events.ScheduleEvent(EVENT_SPELL_BLIZZARD, 40000);
break;
case EVENT_SPELL_ARCANE_EXPLOSION:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 10.0f))
me->CastSpell(me, SPELL_ARCANE_EXPLOSION, false);
events.ScheduleEvent(EVENT_SPELL_ARCANE_EXPLOSION, 10000);
break;
}
DoMeleeAttackIfReady();
}
};
};
class boss_lady_malande : public CreatureScript
{
public:
boss_lady_malande() : CreatureScript("boss_lady_malande") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_lady_malandeAI>(creature);
}
struct boss_lady_malandeAI : public boss_illidari_council_memberAI
{
boss_lady_malandeAI(Creature* creature) : boss_illidari_council_memberAI(creature) { }
void AttackStart(Unit* who)
{
if (who && me->Attack(who, true))
me->GetMotionMaster()->MoveChase(who, 20.0f);
}
void EnterCombat(Unit* who)
{
boss_illidari_council_memberAI::EnterCombat(who);
events.ScheduleEvent(EVENT_SPELL_REFLECTIVE_SHIELD, 10000);
events.ScheduleEvent(EVENT_SPELL_CIRCLE_OF_HEALING, 20000);
events.ScheduleEvent(EVENT_SPELL_DIVINE_WRATH, 5000);
events.ScheduleEvent(EVENT_SPELL_EMPOWERED_SMITE, 15000);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_CIRCLE_OF_HEALING:
me->CastSpell(me, SPELL_CIRCLE_OF_HEALING, false);
events.ScheduleEvent(EVENT_SPELL_CIRCLE_OF_HEALING, 20000);
break;
case EVENT_SPELL_REFLECTIVE_SHIELD:
if (roll_chance_i(50))
Talk(SAY_COUNCIL_SPECIAL);
me->CastSpell(me, SPELL_REFLECTIVE_SHIELD, false);
events.ScheduleEvent(EVENT_SPELL_REFLECTIVE_SHIELD, 40000);
break;
case EVENT_SPELL_DIVINE_WRATH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f))
me->CastSpell(target, SPELL_DIVINE_WRATH, false);
events.ScheduleEvent(EVENT_SPELL_DIVINE_WRATH, 20000);
break;
case EVENT_SPELL_EMPOWERED_SMITE:
me->CastSpell(me->GetVictim(), SPELL_EMPOWERED_SMITE, false);
events.ScheduleEvent(EVENT_SPELL_EMPOWERED_SMITE, 3000);
break;
}
}
};
};
class boss_veras_darkshadow : public CreatureScript
{
public:
boss_veras_darkshadow() : CreatureScript("boss_veras_darkshadow") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_veras_darkshadowAI>(creature);
}
struct boss_veras_darkshadowAI : public boss_illidari_council_memberAI
{
boss_veras_darkshadowAI(Creature* creature) : boss_illidari_council_memberAI(creature) { }
void EnterCombat(Unit* who)
{
me->SetCanDualWield(true);
boss_illidari_council_memberAI::EnterCombat(who);
events.ScheduleEvent(EVENT_SPELL_VANISH, 10000);
events.ScheduleEvent(EVENT_SPELL_ENRAGE, 900000);
}
void JustSummoned(Creature* summon)
{
summon->CastSpell(summon, SPELL_VANISH_VISUAL, true);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_VANISH:
if (roll_chance_i(50))
Talk(SAY_COUNCIL_SPECIAL);
me->CastSpell(me, SPELL_DEADLY_STRIKE, false);
me->CastSpell(me, SPELL_VANISH, false);
events.ScheduleEvent(EVENT_SPELL_VANISH, 60000);
events.ScheduleEvent(EVENT_SPELL_VANISH_OUT, 29000);
break;
case EVENT_SPELL_VANISH_OUT:
me->CastSpell(me, SPELL_VANISH_OUT, false);
break;
case EVENT_SPELL_ENRAGE:
DoResetThreat();
if (Creature* council = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_ILLIDARI_COUNCIL)))
council->GetAI()->DoAction(ACTION_ENRAGE);
break;
}
if (events.GetNextEventTime(EVENT_SPELL_VANISH_OUT) == 0)
DoMeleeAttackIfReady();
}
};
};
class spell_illidari_council_balance_of_power : public SpellScriptLoader
{
public:
spell_illidari_council_balance_of_power() : SpellScriptLoader("spell_illidari_council_balance_of_power") { }
class spell_illidari_council_balance_of_power_AuraScript : public AuraScript
{
PrepareAuraScript(spell_illidari_council_balance_of_power_AuraScript);
void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/)
{
// Set absorbtion amount to unlimited (no absorb)
amount = -1;
}
void Register()
{
DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_illidari_council_balance_of_power_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
}
};
AuraScript* GetAuraScript() const
{
return new spell_illidari_council_balance_of_power_AuraScript();
}
};
class spell_illidari_council_empyreal_balance : public SpellScriptLoader
{
public:
spell_illidari_council_empyreal_balance() : SpellScriptLoader("spell_illidari_council_empyreal_balance") { }
class spell_illidari_council_empyreal_balance_SpellScript : public SpellScript
{
PrepareSpellScript(spell_illidari_council_empyreal_balance_SpellScript);
bool Load()
{
_sharedHealth = 0;
_sharedHealthMax = 0;
_targetCount = 0;
return GetCaster()->GetTypeId() == TYPEID_UNIT;
}
void HandleDummy(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
if (Unit* target = GetHitUnit())
{
_targetCount++;
_sharedHealth += target->GetHealth();
_sharedHealthMax += target->GetMaxHealth();
}
}
void HandleAfterCast()
{
if (_targetCount != 4)
{
GetCaster()->ToCreature()->AI()->EnterEvadeMode();
return;
}
float pct = (_sharedHealth / _sharedHealthMax) * 100.0f;
std::list<Spell::TargetInfo> const* targetsInfo = GetSpell()->GetUniqueTargetInfo();
for (std::list<Spell::TargetInfo>::const_iterator ihit = targetsInfo->begin(); ihit != targetsInfo->end(); ++ihit)
if (Creature* target = ObjectAccessor::GetCreature(*GetCaster(), ihit->targetGUID))
{
target->LowerPlayerDamageReq(target->GetMaxHealth());
target->SetHealth(CalculatePct(target->GetMaxHealth(), pct));
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_illidari_council_empyreal_balance_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
AfterCast += SpellCastFn(spell_illidari_council_empyreal_balance_SpellScript::HandleAfterCast);
}
private:
float _sharedHealth;
float _sharedHealthMax;
uint8 _targetCount;
};
SpellScript* GetSpellScript() const
{
return new spell_illidari_council_empyreal_balance_SpellScript();
}
};
class spell_illidari_council_reflective_shield : public SpellScriptLoader
{
public:
spell_illidari_council_reflective_shield() : SpellScriptLoader("spell_illidari_council_reflective_shield") { }
class spell_illidari_council_reflective_shield_AuraScript : public AuraScript
{
PrepareAuraScript(spell_illidari_council_reflective_shield_AuraScript);
void ReflectDamage(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)
{
Unit* target = GetTarget();
if (dmgInfo.GetAttacker() == target)
return;
int32 bp = absorbAmount / 2;
target->CastCustomSpell(dmgInfo.GetAttacker(), SPELL_REFLECTIVE_SHIELD_T, &bp, NULL, NULL, true, NULL, aurEff);
}
void Register()
{
AfterEffectAbsorb += AuraEffectAbsorbFn(spell_illidari_council_reflective_shield_AuraScript::ReflectDamage, EFFECT_0);
}
};
AuraScript* GetAuraScript() const
{
return new spell_illidari_council_reflective_shield_AuraScript();
}
};
class spell_illidari_council_judgement : public SpellScriptLoader
{
public:
spell_illidari_council_judgement() : SpellScriptLoader("spell_illidari_council_judgement") { }
class spell_illidari_council_judgement_SpellScript : public SpellScript
{
PrepareSpellScript(spell_illidari_council_judgement_SpellScript);
void HandleScriptEffect(SpellEffIndex /*effIndex*/)
{
Unit::AuraEffectList const& auras = GetCaster()->GetAuraEffectsByType(SPELL_AURA_DUMMY);
for (Unit::AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
{
if ((*i)->GetSpellInfo()->GetSpellSpecific() == SPELL_SPECIFIC_SEAL && (*i)->GetEffIndex() == EFFECT_2)
if (sSpellMgr->GetSpellInfo((*i)->GetAmount()))
{
GetCaster()->CastSpell(GetHitUnit(), (*i)->GetAmount(), true);
break;
}
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_illidari_council_judgement_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_illidari_council_judgement_SpellScript();
}
};
class spell_illidari_council_deadly_strike : public SpellScriptLoader
{
public:
spell_illidari_council_deadly_strike() : SpellScriptLoader("spell_illidari_council_deadly_strike") { }
class spell_illidari_council_deadly_strike_AuraScript : public AuraScript
{
PrepareAuraScript(spell_illidari_council_deadly_strike_AuraScript);
void Update(AuraEffect const* effect)
{
PreventDefaultAction();
if (Unit* target = GetUnitOwner()->GetAI()->SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
{
GetUnitOwner()->CastSpell(target, GetSpellInfo()->Effects[effect->GetEffIndex()].TriggerSpell, true);
GetUnitOwner()->m_Events.AddEvent(new VerasEnvenom(*GetUnitOwner(), target->GetGUID()), GetUnitOwner()->m_Events.CalculateTime(urand(1500, 3500)));
}
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_illidari_council_deadly_strike_AuraScript::Update, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_illidari_council_deadly_strike_AuraScript();
}
};
void AddSC_boss_illidari_council()
{
new boss_illidari_council();
new boss_gathios_the_shatterer();
new boss_lady_malande();
new boss_veras_darkshadow();
new boss_high_nethermancer_zerevor();
new spell_illidari_council_balance_of_power();
new spell_illidari_council_empyreal_balance();
new spell_illidari_council_reflective_shield();
new spell_illidari_council_judgement();
new spell_illidari_council_deadly_strike();
}

683
src/server/scripts/Outland/BlackTemple/instance_black_temple.cpp
View File

@@ -1,683 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "InstanceScript.h"
#include "black_temple.h"
DoorData const doorData[] =
{
{ GO_NAJENTUS_GATE, DATA_HIGH_WARLORD_NAJENTUS, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_NAJENTUS_GATE, DATA_SUPREMUS, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_SUPREMUS_GATE, DATA_SUPREMUS, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_SHADE_OF_AKAMA_DOOR, DATA_SHADE_OF_AKAMA, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_TERON_DOOR_1, DATA_TERON_GOREFIEND, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_TERON_DOOR_2, DATA_TERON_GOREFIEND, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_GURTOGG_DOOR, DATA_GURTOGG_BLOODBOIL, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_TEMPLE_DOOR, DATA_GURTOGG_BLOODBOIL, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_TEMPLE_DOOR, DATA_TERON_GOREFIEND, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_TEMPLE_DOOR, DATA_RELIQUARY_OF_SOULS, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_MOTHER_SHAHRAZ_DOOR, DATA_MOTHER_SHAHRAZ, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_COUNCIL_DOOR_1, DATA_ILLIDARI_COUNCIL, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_COUNCIL_DOOR_2, DATA_ILLIDARI_COUNCIL, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_ILLIDAN_GATE, DATA_AKAMA_FINISHED, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_ILLIDAN_DOOR_L, DATA_ILLIDAN_STORMRAGE, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_ILLIDAN_DOOR_R, DATA_ILLIDAN_STORMRAGE, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ 0, 0, DOOR_TYPE_ROOM, BOUNDARY_NONE }
};
class instance_black_temple : public InstanceMapScript
{
public:
instance_black_temple() : InstanceMapScript("instance_black_temple", 564) { }
struct instance_black_temple_InstanceMapScript : public InstanceScript
{
instance_black_temple_InstanceMapScript(Map* map) : InstanceScript(map)
{
SetBossNumber(MAX_ENCOUNTERS);
LoadDoorData(doorData);
ShadeOfAkamaGUID = 0;
AkamaShadeGUID = 0;
TeronGorefiendGUID = 0;
ReliquaryGUID = 0;
ashtongueGUIDs.clear();
GathiosTheShattererGUID = 0;
HighNethermancerZerevorGUID = 0;
LadyMalandeGUID = 0;
VerasDarkshadowGUID = 0;
IllidariCouncilGUID = 0;
AkamaGUID = 0;
IllidanStormrageGUID = 0;
}
void OnCreatureCreate(Creature* creature)
{
switch (creature->GetEntry())
{
case NPC_SHADE_OF_AKAMA:
ShadeOfAkamaGUID = creature->GetGUID();
break;
case NPC_AKAMA_SHADE:
AkamaShadeGUID = creature->GetGUID();
break;
case NPC_TERON_GOREFIEND:
TeronGorefiendGUID = creature->GetGUID();
break;
case NPC_RELIQUARY_OF_THE_LOST:
ReliquaryGUID = creature->GetGUID();
break;
case NPC_GATHIOS_THE_SHATTERER:
GathiosTheShattererGUID = creature->GetGUID();
break;
case NPC_HIGH_NETHERMANCER_ZEREVOR:
HighNethermancerZerevorGUID = creature->GetGUID();
break;
case NPC_LADY_MALANDE:
LadyMalandeGUID = creature->GetGUID();
break;
case NPC_VERAS_DARKSHADOW:
VerasDarkshadowGUID = creature->GetGUID();
break;
case NPC_ILLIDARI_COUNCIL:
IllidariCouncilGUID = creature->GetGUID();
break;
case NPC_AKAMA:
AkamaGUID = creature->GetGUID();
break;
case NPC_ILLIDAN_STORMRAGE:
IllidanStormrageGUID = creature->GetGUID();
break;
case NPC_VENGEFUL_SPIRIT:
case NPC_SHADOWY_CONSTRUCT:
if (Creature* teron = instance->GetCreature(TeronGorefiendGUID))
teron->AI()->JustSummoned(creature);
break;
case NPC_ENSLAVED_SOUL:
if (Creature* reliquary = instance->GetCreature(ReliquaryGUID))
reliquary->AI()->JustSummoned(creature);
break;
case NPC_PARASITIC_SHADOWFIEND:
case NPC_BLADE_OF_AZZINOTH:
case NPC_FLAME_OF_AZZINOTH:
if (Creature* illidan = instance->GetCreature(IllidanStormrageGUID))
illidan->AI()->JustSummoned(creature);
break;
case NPC_ANGERED_SOUL_FRAGMENT:
case NPC_HUNGERING_SOUL_FRAGMENT:
case NPC_SUFFERING_SOUL_FRAGMENT:
creature->SetCorpseDelay(5);
break;
}
if (creature->GetName().find("Ashtongue") != std::string::npos || creature->GetEntry() == NPC_STORM_FURY)
{
ashtongueGUIDs.push_back(creature->GetGUID());
if (GetBossState(DATA_SHADE_OF_AKAMA) == DONE)
creature->setFaction(FACTION_ASHTONGUE);
}
}
void OnGameObjectCreate(GameObject* go)
{
switch (go->GetEntry())
{
case GO_NAJENTUS_GATE:
case GO_SUPREMUS_GATE:
case GO_SHADE_OF_AKAMA_DOOR:
case GO_TERON_DOOR_1:
case GO_TERON_DOOR_2:
case GO_GURTOGG_DOOR:
case GO_TEMPLE_DOOR:
case GO_MOTHER_SHAHRAZ_DOOR:
case GO_COUNCIL_DOOR_1:
case GO_COUNCIL_DOOR_2:
case GO_ILLIDAN_GATE:
case GO_ILLIDAN_DOOR_R:
case GO_ILLIDAN_DOOR_L:
AddDoor(go, true);
break;
}
}
void OnGameObjectRemove(GameObject* go)
{
switch (go->GetEntry())
{
case GO_NAJENTUS_GATE:
case GO_SUPREMUS_GATE:
case GO_SHADE_OF_AKAMA_DOOR:
case GO_TERON_DOOR_1:
case GO_TERON_DOOR_2:
case GO_GURTOGG_DOOR:
case GO_TEMPLE_DOOR:
case GO_MOTHER_SHAHRAZ_DOOR:
case GO_COUNCIL_DOOR_1:
case GO_COUNCIL_DOOR_2:
case GO_ILLIDAN_GATE:
case GO_ILLIDAN_DOOR_R:
case GO_ILLIDAN_DOOR_L:
AddDoor(go, false);
break;
}
}
uint64 GetData64(uint32 type) const
{
switch (type)
{
case NPC_SHADE_OF_AKAMA:
return ShadeOfAkamaGUID;
case NPC_AKAMA_SHADE:
return AkamaShadeGUID;
case NPC_GATHIOS_THE_SHATTERER:
return GathiosTheShattererGUID;
case NPC_HIGH_NETHERMANCER_ZEREVOR:
return HighNethermancerZerevorGUID;
case NPC_LADY_MALANDE:
return LadyMalandeGUID;
case NPC_VERAS_DARKSHADOW:
return VerasDarkshadowGUID;
case NPC_ILLIDARI_COUNCIL:
return IllidariCouncilGUID;
case NPC_AKAMA:
return AkamaGUID;
case NPC_ILLIDAN_STORMRAGE:
return IllidanStormrageGUID;
}
return 0;
}
bool SetBossState(uint32 type, EncounterState state)
{
if (!InstanceScript::SetBossState(type, state))
return false;
if (type == DATA_SHADE_OF_AKAMA && state == DONE)
{
for (std::list<uint64>::const_iterator itr = ashtongueGUIDs.begin(); itr != ashtongueGUIDs.end(); ++itr)
if (Creature* ashtongue = instance->GetCreature(*itr))
ashtongue->setFaction(FACTION_ASHTONGUE);
}
else if (type == DATA_ILLIDARI_COUNCIL && state == DONE)
{
if (Creature* akama = instance->GetCreature(AkamaGUID))
akama->SetVisible(true);
}
return true;
}
std::string GetSaveData()
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << "B T " << GetBossSaveData();
OUT_SAVE_INST_DATA_COMPLETE;
return saveStream.str();
}
void Load(char const* str)
{
if (!str)
{
OUT_LOAD_INST_DATA_FAIL;
return;
}
OUT_LOAD_INST_DATA(str);
char dataHead1, dataHead2;
std::istringstream loadStream(str);
loadStream >> dataHead1 >> dataHead2;
if (dataHead1 == 'B' && dataHead2 == 'T')
{
for (uint8 i = 0; i < MAX_ENCOUNTERS; ++i)
{
uint32 tmpState;
loadStream >> tmpState;
if (tmpState == IN_PROGRESS || tmpState > SPECIAL)
tmpState = NOT_STARTED;
SetBossState(i, EncounterState(tmpState));
}
}
else
OUT_LOAD_INST_DATA_FAIL;
OUT_LOAD_INST_DATA_COMPLETE;
}
protected:
uint64 ShadeOfAkamaGUID;
uint64 AkamaShadeGUID;
uint64 TeronGorefiendGUID;
uint64 ReliquaryGUID;
std::list<uint64> ashtongueGUIDs;
uint64 GathiosTheShattererGUID;
uint64 HighNethermancerZerevorGUID;
uint64 LadyMalandeGUID;
uint64 VerasDarkshadowGUID;
uint64 IllidariCouncilGUID;
uint64 AkamaGUID;
uint64 IllidanStormrageGUID;
};
InstanceScript* GetInstanceScript(InstanceMap* map) const
{
return new instance_black_temple_InstanceMapScript(map);
}
};
class spell_black_template_harpooners_mark : public SpellScriptLoader
{
public:
spell_black_template_harpooners_mark() : SpellScriptLoader("spell_black_template_harpooners_mark") { }
class spell_black_template_harpooners_mark_AuraScript : public AuraScript
{
PrepareAuraScript(spell_black_template_harpooners_mark_AuraScript)
bool Load()
{
_turtleSet.clear();
return true;
}
void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
std::list<Creature*> creatureList;
GetUnitOwner()->GetCreaturesWithEntryInRange(creatureList, 80.0f, NPC_DRAGON_TURTLE);
for (std::list<Creature*>::const_iterator itr = creatureList.begin(); itr != creatureList.end(); ++itr)
{
(*itr)->TauntApply(GetUnitOwner());
(*itr)->AddThreat(GetUnitOwner(), 10000000.0f);
_turtleSet.insert((*itr)->GetGUID());
}
}
void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
for (std::set<uint64>::const_iterator itr = _turtleSet.begin(); itr != _turtleSet.end(); ++itr)
if (Creature* turtle = ObjectAccessor::GetCreature(*GetUnitOwner(), *itr))
{
turtle->TauntFadeOut(GetUnitOwner());
turtle->AddThreat(GetUnitOwner(), -10000000.0f);
}
}
void Register()
{
OnEffectApply += AuraEffectApplyFn(spell_black_template_harpooners_mark_AuraScript::HandleEffectApply, EFFECT_1, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL);
OnEffectRemove += AuraEffectRemoveFn(spell_black_template_harpooners_mark_AuraScript::HandleEffectRemove, EFFECT_1, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL);
}
private:
std::set<uint64> _turtleSet;
};
AuraScript* GetAuraScript() const
{
return new spell_black_template_harpooners_mark_AuraScript();
}
};
class spell_black_template_free_friend : public SpellScriptLoader
{
public:
spell_black_template_free_friend() : SpellScriptLoader("spell_black_template_free_friend") { }
class spell_black_template_free_friend_SpellScript : public SpellScript
{
PrepareSpellScript(spell_black_template_free_friend_SpellScript);
void HandleScriptEffect(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
Unit* target = GetHitUnit();
if (!target)
return;
target->RemoveAurasDueToSpell(SPELL_AURA_MOD_CHARM);
target->RemoveAurasDueToSpell(SPELL_AURA_MOD_STUN);
target->RemoveAurasDueToSpell(SPELL_AURA_MOD_DECREASE_SPEED);
target->RemoveAurasDueToSpell(SPELL_AURA_MOD_ROOT);
target->RemoveAurasDueToSpell(SPELL_AURA_MOD_CONFUSE);
target->RemoveAurasDueToSpell(SPELL_AURA_MOD_FEAR);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_black_template_free_friend_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_black_template_free_friend_SpellScript();
}
};
class spell_black_temple_curse_of_the_bleakheart : public SpellScriptLoader
{
public:
spell_black_temple_curse_of_the_bleakheart() : SpellScriptLoader("spell_black_temple_curse_of_the_bleakheart") { }
class spell_black_temple_curse_of_the_bleakheart_AuraScript : public AuraScript
{
PrepareAuraScript(spell_black_temple_curse_of_the_bleakheart_AuraScript);
void CalcPeriodic(AuraEffect const* /*effect*/, bool& isPeriodic, int32& amplitude)
{
isPeriodic = true;
amplitude = 5000;
}
void Update(AuraEffect const* effect)
{
PreventDefaultAction();
if (roll_chance_i(20))
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_CHEST_PAINS, true);
}
void Register()
{
DoEffectCalcPeriodic += AuraEffectCalcPeriodicFn(spell_black_temple_curse_of_the_bleakheart_AuraScript::CalcPeriodic, EFFECT_0, SPELL_AURA_DUMMY);
OnEffectPeriodic += AuraEffectPeriodicFn(spell_black_temple_curse_of_the_bleakheart_AuraScript::Update, EFFECT_0, SPELL_AURA_DUMMY);
}
};
AuraScript* GetAuraScript() const
{
return new spell_black_temple_curse_of_the_bleakheart_AuraScript();
}
};
class spell_black_temple_skeleton_shot : public SpellScriptLoader
{
public:
spell_black_temple_skeleton_shot() : SpellScriptLoader("spell_black_temple_skeleton_shot") { }
class spell_black_temple_skeleton_shot_AuraScript : public AuraScript
{
PrepareAuraScript(spell_black_temple_skeleton_shot_AuraScript)
void HandleEffectRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_DEATH)
GetTarget()->CastSpell(GetTarget(), GetSpellInfo()->Effects[EFFECT_2].CalcValue(), true);
}
void Register()
{
AfterEffectRemove += AuraEffectRemoveFn(spell_black_temple_skeleton_shot_AuraScript::HandleEffectRemove, EFFECT_1, SPELL_AURA_PERIODIC_DAMAGE, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_black_temple_skeleton_shot_AuraScript();
}
};
class spell_black_temple_wyvern_sting : public SpellScriptLoader
{
public:
spell_black_temple_wyvern_sting() : SpellScriptLoader("spell_black_temple_wyvern_sting") { }
class spell_black_temple_wyvern_sting_AuraScript : public AuraScript
{
PrepareAuraScript(spell_black_temple_wyvern_sting_AuraScript)
void HandleEffectRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
if (Unit* caster = GetCaster())
caster->CastSpell(GetTarget(), SPELL_WYVERN_STING, true);
}
void Register()
{
AfterEffectRemove += AuraEffectRemoveFn(spell_black_temple_wyvern_sting_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_MOD_STUN, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_black_temple_wyvern_sting_AuraScript();
}
};
class spell_black_temple_charge_rage : public SpellScriptLoader
{
public:
spell_black_temple_charge_rage() : SpellScriptLoader("spell_black_temple_charge_rage") { }
class spell_black_temple_charge_rage_AuraScript : public AuraScript
{
PrepareAuraScript(spell_black_temple_charge_rage_AuraScript);
void Update(AuraEffect const* effect)
{
PreventDefaultAction();
if (Unit* target = GetUnitOwner()->SelectNearbyNoTotemTarget((Unit*)NULL, 50.0f))
GetUnitOwner()->CastSpell(target, GetSpellInfo()->Effects[effect->GetEffIndex()].TriggerSpell, true);
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_black_temple_charge_rage_AuraScript::Update, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_black_temple_charge_rage_AuraScript();
}
};
class spell_black_temple_shadow_inferno : public SpellScriptLoader
{
public:
spell_black_temple_shadow_inferno() : SpellScriptLoader("spell_black_temple_shadow_inferno") { }
class spell_black_temple_shadow_inferno_AuraScript : public AuraScript
{
PrepareAuraScript(spell_black_temple_shadow_inferno_AuraScript);
void Update(AuraEffect const* effect)
{
PreventDefaultAction();
GetUnitOwner()->CastCustomSpell(SPELL_SHADOW_INFERNO_DAMAGE, SPELLVALUE_BASE_POINT0, effect->GetAmount(), GetUnitOwner(), TRIGGERED_FULL_MASK);
GetAura()->GetEffect(effect->GetEffIndex())->SetAmount(effect->GetAmount()+500);
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_black_temple_shadow_inferno_AuraScript::Update, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_black_temple_shadow_inferno_AuraScript();
}
};
class spell_black_temple_spell_absorption : public SpellScriptLoader
{
public:
spell_black_temple_spell_absorption() : SpellScriptLoader("spell_black_temple_spell_absorption") { }
class spell_black_temple_spell_absorption_AuraScript : public AuraScript
{
PrepareAuraScript(spell_black_temple_spell_absorption_AuraScript);
void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/)
{
// Set absorbtion amount to unlimited
amount = -1;
}
void Absorb(AuraEffect* /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
{
absorbAmount = dmgInfo.GetDamage();
}
void Update(AuraEffect const* effect)
{
PreventDefaultAction();
uint32 count = GetUnitOwner()->GetAuraCount(SPELL_CHAOTIC_CHARGE);
if (count == 0)
return;
GetUnitOwner()->CastCustomSpell(GetSpellInfo()->Effects[effect->GetEffIndex()].TriggerSpell, SPELLVALUE_BASE_POINT0, effect->GetAmount()*count, GetUnitOwner(), TRIGGERED_FULL_MASK);
GetUnitOwner()->RemoveAurasDueToSpell(SPELL_CHAOTIC_CHARGE);
}
void Register()
{
DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_black_temple_spell_absorption_AuraScript::CalculateAmount, EFFECT_2, SPELL_AURA_SCHOOL_ABSORB);
OnEffectAbsorb += AuraEffectAbsorbFn(spell_black_temple_spell_absorption_AuraScript::Absorb, EFFECT_2);
OnEffectPeriodic += AuraEffectPeriodicFn(spell_black_temple_spell_absorption_AuraScript::Update, EFFECT_1, SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE);
}
};
AuraScript* GetAuraScript() const
{
return new spell_black_temple_spell_absorption_AuraScript();
}
};
class spell_black_temple_bloodbolt : public SpellScriptLoader
{
public:
spell_black_temple_bloodbolt() : SpellScriptLoader("spell_black_temple_bloodbolt") { }
class spell_black_temple_bloodbolt_SpellScript : public SpellScript
{
PrepareSpellScript(spell_black_temple_bloodbolt_SpellScript);
void HandleScriptEffect(SpellEffIndex effIndex)
{
PreventHitEffect(effIndex);
if (Unit* target = GetHitUnit())
GetCaster()->CastSpell(target, GetEffectValue(), true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_black_temple_bloodbolt_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_black_temple_bloodbolt_SpellScript();
}
};
class spell_black_temple_consuming_strikes : public SpellScriptLoader
{
public:
spell_black_temple_consuming_strikes() : SpellScriptLoader("spell_black_temple_consuming_strikes") { }
class spell_black_temple_consuming_strikes_AuraScript : public AuraScript
{
PrepareAuraScript(spell_black_temple_consuming_strikes_AuraScript);
void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
{
PreventDefaultAction();
GetTarget()->CastCustomSpell(GetSpellInfo()->Effects[EFFECT_1].CalcValue(), SPELLVALUE_BASE_POINT0, eventInfo.GetDamageInfo()->GetDamage(), GetTarget(), true);
}
void Register()
{
OnEffectProc += AuraEffectProcFn(spell_black_temple_consuming_strikes_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_black_temple_consuming_strikes_AuraScript();
}
};
class spell_black_temple_curse_of_vitality : public SpellScriptLoader
{
public:
spell_black_temple_curse_of_vitality() : SpellScriptLoader("spell_black_temple_curse_of_vitality") { }
class spell_black_temple_curse_of_vitality_AuraScript : public AuraScript
{
PrepareAuraScript(spell_black_temple_curse_of_vitality_AuraScript);
void OnPeriodic(AuraEffect const* aurEff)
{
if (GetUnitOwner()->HealthBelowPct(50))
SetDuration(0);
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_black_temple_curse_of_vitality_AuraScript::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
}
};
AuraScript* GetAuraScript() const
{
return new spell_black_temple_curse_of_vitality_AuraScript();
}
};
class spell_black_temple_dementia : public SpellScriptLoader
{
public:
spell_black_temple_dementia() : SpellScriptLoader("spell_black_temple_dementia") { }
class spell_black_temple_dementia_AuraScript : public AuraScript
{
PrepareAuraScript(spell_black_temple_dementia_AuraScript);
void OnPeriodic(AuraEffect const* aurEff)
{
if (roll_chance_i(50))
GetTarget()->CastSpell(GetTarget(), SPELL_DEMENTIA1, true);
else
GetTarget()->CastSpell(GetTarget(), SPELL_DEMENTIA2, true);
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_black_temple_dementia_AuraScript::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
}
};
AuraScript* GetAuraScript() const
{
return new spell_black_temple_dementia_AuraScript();
}
};
void AddSC_instance_black_temple()
{
new instance_black_temple();
new spell_black_template_harpooners_mark();
new spell_black_template_free_friend();
new spell_black_temple_curse_of_the_bleakheart();
new spell_black_temple_skeleton_shot();
new spell_black_temple_wyvern_sting();
new spell_black_temple_charge_rage();
new spell_black_temple_shadow_inferno();
new spell_black_temple_spell_absorption();
new spell_black_temple_bloodbolt();
new spell_black_temple_consuming_strikes();
new spell_black_temple_curse_of_vitality();
new spell_black_temple_dementia();
}