Scripts/BT: full instance rewrite

This commit is contained in:
Keader authored and Ovahlord committed 2020-11-05 17:42:33 +01:00
1 parent 398ee2dfcd
commit 3b2ef0ec45
15 files changed
+5754 -5594

No files matched your search

@@ -57,270 +57,222 @@ enum Misc
GROUP_OUT_OF_COMBAT = 1
};
// ########################################################
// Wrathbone Flayer
// ########################################################
class npc_wrathbone_flayer : public CreatureScript
struct npc_wrathbone_flayer : public ScriptedAI
{
public:
npc_wrathbone_flayer() : CreatureScript("npc_wrathbone_flayer") { }
struct npc_wrathbone_flayerAI : public ScriptedAI
npc_wrathbone_flayer(Creature* creature) : ScriptedAI(creature)
{
npc_wrathbone_flayerAI(Creature* creature) : ScriptedAI(creature)
Initialize();
_instance = creature->GetInstanceScript();
}
void Initialize()
{
_enteredCombat = false;
}
void Reset() override
{
_events.ScheduleEvent(EVENT_GET_CHANNELERS, 3s);
Initialize();
_bloodmageList.clear();
_deathshaperList.clear();
}
void JustDied(Unit* /*killer*/) override { }
void JustEngagedWith(Unit* /*who*/) override
{
_events.ScheduleEvent(EVENT_CLEAVE, 5s);
_events.ScheduleEvent(EVENT_IGNORED, 7s);
_enteredCombat = true;
}
void UpdateAI(uint32 diff) override
{
if (!_enteredCombat)
{
Initialize();
_instance = creature->GetInstanceScript();
}
void Initialize()
{
_enteredCombat = false;
}
void Reset() override
{
_events.ScheduleEvent(EVENT_GET_CHANNELERS, 3000);
Initialize();
_bloodmageList.clear();
_deathshaperList.clear();
}
void JustDied(Unit* /*killer*/) override { }
void JustEngagedWith(Unit* /*who*/) override
{
_events.ScheduleEvent(EVENT_CLEAVE, 5000);
_events.ScheduleEvent(EVENT_IGNORED, 7000);
_enteredCombat = true;
}
void UpdateAI(uint32 diff) override
{
if (!_enteredCombat)
{
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_GET_CHANNELERS:
{
std::list<Creature*> BloodMageList;
me->GetCreatureListWithEntryInGrid(BloodMageList, NPC_BLOOD_MAGE, 15.0f);
if (!BloodMageList.empty())
for (std::list<Creature*>::const_iterator itr = BloodMageList.begin(); itr != BloodMageList.end(); ++itr)
{
_bloodmageList.push_back((*itr)->GetGUID());
if ((*itr)->isDead())
(*itr)->Respawn();
}
std::list<Creature*> DeathShaperList;
me->GetCreatureListWithEntryInGrid(DeathShaperList, NPC_DEATHSHAPER, 15.0f);
if (!DeathShaperList.empty())
for (std::list<Creature*>::const_iterator itr = DeathShaperList.begin(); itr != DeathShaperList.end(); ++itr)
{
_deathshaperList.push_back((*itr)->GetGUID());
if ((*itr)->isDead())
(*itr)->Respawn();
}
_events.ScheduleEvent(EVENT_SET_CHANNELERS, 3000);
break;
}
case EVENT_SET_CHANNELERS:
{
for (ObjectGuid guid : _bloodmageList)
if (Creature* bloodmage = ObjectAccessor::GetCreature(*me, guid))
bloodmage->CastSpell((Unit*)nullptr, SPELL_SUMMON_CHANNEL);
for (ObjectGuid guid : _deathshaperList)
if (Creature* deathshaper = ObjectAccessor::GetCreature(*me, guid))
deathshaper->CastSpell((Unit*)nullptr, SPELL_SUMMON_CHANNEL);
_events.ScheduleEvent(EVENT_SET_CHANNELERS, 12000);
break;
}
default:
break;
}
}
}
if (!UpdateVictim())
return;
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE);
_events.ScheduleEvent(EVENT_CLEAVE, urand (1000, 2000));
case EVENT_GET_CHANNELERS:
{
std::list<Creature*> BloodMageList;
me->GetCreatureListWithEntryInGrid(BloodMageList, NPC_BLOOD_MAGE, 15.0f);
if (!BloodMageList.empty())
for (std::list<Creature*>::const_iterator itr = BloodMageList.begin(); itr != BloodMageList.end(); ++itr)
{
_bloodmageList.push_back((*itr)->GetGUID());
if ((*itr)->isDead())
(*itr)->Respawn();
}
std::list<Creature*> DeathShaperList;
me->GetCreatureListWithEntryInGrid(DeathShaperList, NPC_DEATHSHAPER, 15.0f);
if (!DeathShaperList.empty())
for (std::list<Creature*>::const_iterator itr = DeathShaperList.begin(); itr != DeathShaperList.end(); ++itr)
{
_deathshaperList.push_back((*itr)->GetGUID());
if ((*itr)->isDead())
(*itr)->Respawn();
}
_events.ScheduleEvent(EVENT_SET_CHANNELERS, 3s);
break;
case EVENT_IGNORED:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_IGNORED);
_events.ScheduleEvent(EVENT_IGNORED, 10000);
}
case EVENT_SET_CHANNELERS:
{
for (ObjectGuid guid : _bloodmageList)
if (Creature* bloodmage = ObjectAccessor::GetCreature(*me, guid))
bloodmage->CastSpell(nullptr, SPELL_SUMMON_CHANNEL);
for (ObjectGuid guid : _deathshaperList)
if (Creature* deathshaper = ObjectAccessor::GetCreature(*me, guid))
deathshaper->CastSpell(nullptr, SPELL_SUMMON_CHANNEL);
_events.ScheduleEvent(EVENT_SET_CHANNELERS, 12s);
break;
}
default:
break;
}
}
DoMeleeAttackIfReady();
}
private:
InstanceScript* _instance;
EventMap _events;
GuidList _bloodmageList;
GuidList _deathshaperList;
bool _enteredCombat;
};
if (!UpdateVictim())
return;
CreatureAI* GetAI(Creature* creature) const override
{
return GetBlackTempleAI<npc_wrathbone_flayerAI>(creature);
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE);
_events.ScheduleEvent(EVENT_CLEAVE, 1s, 2s);
break;
case EVENT_IGNORED:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_IGNORED);
_events.ScheduleEvent(EVENT_IGNORED, 10s);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
private:
InstanceScript* _instance;
EventMap _events;
GuidList _bloodmageList;
GuidList _deathshaperList;
bool _enteredCombat;
};
class npc_angered_soul_fragment : public CreatureScript
struct npc_angered_soul_fragment : public ScriptedAI
{
public:
npc_angered_soul_fragment() : CreatureScript("npc_angered_soul_fragment") { }
npc_angered_soul_fragment(Creature* creature) : ScriptedAI(creature) { }
struct npc_angered_soul_fragmentAI : public ScriptedAI
void Reset() override
{
npc_angered_soul_fragmentAI(Creature* creature) : ScriptedAI(creature) { }
_scheduler.CancelAll();
void Reset() override
_scheduler.Schedule(Seconds(1), GROUP_OUT_OF_COMBAT, [this](TaskContext invi)
{
_scheduler.CancelAll();
DoCastSelf(SPELL_GREATER_INVISIBILITY);
_scheduler.Schedule(Seconds(1), GROUP_OUT_OF_COMBAT, [this](TaskContext invi)
/* Workaround - On Retail creature appear and "vanish" again periodically, but i cant find packets
with UPDATE_AURA on sniffs about it */
_scheduler.Schedule(Seconds(5), Seconds(10), GROUP_OUT_OF_COMBAT, [this](TaskContext /*context*/)
{
DoCastSelf(SPELL_GREATER_INVISIBILITY);
/* Workaround - On Retail creature appear and "vanish" again periodically, but i cant find packets
with UPDATE_AURA on sniffs about it */
_scheduler.Schedule(Seconds(5), Seconds(10), GROUP_OUT_OF_COMBAT, [this](TaskContext /*context*/)
{
me->RemoveAurasDueToSpell(SPELL_GREATER_INVISIBILITY);
});
invi.Repeat(Seconds(15), Seconds(25));
me->RemoveAurasDueToSpell(SPELL_GREATER_INVISIBILITY);
});
}
void JustEngagedWith(Unit* /*who*/) override
{
me->RemoveAurasDueToSpell(SPELL_GREATER_INVISIBILITY);
_scheduler.CancelGroup(GROUP_OUT_OF_COMBAT);
_scheduler.Schedule(Seconds(1), [this](TaskContext anger)
{
Unit* target = me->GetVictim();
if (target && me->IsWithinMeleeRange(target))
DoCastSelf(SPELL_ANGER);
else
anger.Repeat(Seconds(1));
});
}
void UpdateAI(uint32 diff) override
{
_scheduler.Update(diff);
if (!UpdateVictim())
return;
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
DoMeleeAttackIfReady();
}
private:
TaskScheduler _scheduler;
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetBlackTempleAI<npc_angered_soul_fragmentAI>(creature);
invi.Repeat(Seconds(15), Seconds(25));
});
}
void JustEngagedWith(Unit* /*who*/) override
{
me->RemoveAurasDueToSpell(SPELL_GREATER_INVISIBILITY);
_scheduler.CancelGroup(GROUP_OUT_OF_COMBAT);
_scheduler.Schedule(Seconds(1), [this](TaskContext anger)
{
Unit* target = me->GetVictim();
if (target && me->IsWithinMeleeRange(target))
DoCastSelf(SPELL_ANGER);
else
anger.Repeat(Seconds(1));
});
}
void UpdateAI(uint32 diff) override
{
_scheduler.Update(diff);
if (!UpdateVictim())
return;
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
DoMeleeAttackIfReady();
}
private:
TaskScheduler _scheduler;
};
// 41986 - Anger
class spell_soul_fragment_anger : public SpellScriptLoader
class spell_soul_fragment_anger : public SpellScript
{
public:
spell_soul_fragment_anger() : SpellScriptLoader("spell_soul_fragment_anger") { }
void HandleKill()
{
if (Creature* caster = GetCaster()->ToCreature())
caster->DespawnOrUnsummon(Milliseconds(200));
}
class spell_soul_fragment_anger_SpellScript : public SpellScript
{
void HandleKill()
{
if (Creature* caster = GetCaster()->ToCreature())
caster->DespawnOrUnsummon(Milliseconds(200));
}
void Register() override
{
AfterCast.Register(&spell_soul_fragment_anger_SpellScript::HandleKill);
}
};
SpellScript* GetSpellScript() const override
{
return new spell_soul_fragment_anger_SpellScript();
}
void Register() override
{
AfterCast.Register(&spell_soul_fragment_anger::HandleKill);
}
};
// 39645 - Shadow Inferno
class spell_illidari_nightlord_shadow_inferno : public SpellScriptLoader
class spell_illidari_nightlord_shadow_inferno : public AuraScript
{
public:
spell_illidari_nightlord_shadow_inferno() : SpellScriptLoader("spell_illidari_nightlord_shadow_inferno") { }
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_SHADOW_INFERNO_DAMAGE });
}
class spell_illidari_nightlord_shadow_inferno_AuraScript : public AuraScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_SHADOW_INFERNO_DAMAGE });
}
void OnPeriodic(AuraEffect const* aurEffect)
{
PreventDefaultAction();
int32 bp = aurEffect->GetTickNumber() * aurEffect->GetAmount();
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SHADOW_INFERNO_DAMAGE, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellBP0(bp));
}
void OnPeriodic(AuraEffect const* aurEffect)
{
PreventDefaultAction();
int32 bp = aurEffect->GetTickNumber() * aurEffect->GetAmount();
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SHADOW_INFERNO_DAMAGE, CastSpellExtraArgs(true).AddSpellBP0(bp));
}
void Register() override
{
OnEffectPeriodic.Register(&spell_illidari_nightlord_shadow_inferno_AuraScript::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const override
{
return new spell_illidari_nightlord_shadow_inferno_AuraScript();
}
void Register() override
{
OnEffectPeriodic.Register(&spell_illidari_nightlord_shadow_inferno::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
void AddSC_black_temple()
{
new npc_wrathbone_flayer();
new npc_angered_soul_fragment();
new spell_soul_fragment_anger();
new spell_illidari_nightlord_shadow_inferno();
RegisterBlackTempleCreatureAI(npc_wrathbone_flayer);
RegisterBlackTempleCreatureAI(npc_angered_soul_fragment);
RegisterSpellScript(spell_soul_fragment_anger);
RegisterSpellScript(spell_illidari_nightlord_shadow_inferno);
}
@@ -55,7 +55,8 @@ enum BTDataTypes
DATA_ESSENCE_OF_ANGER = 22,
DATA_ILLIDAN_MUSIC_CONTROLLER = 23,
DATA_TERON_GOREFIEND_INTRO = 24,
DATA_AKAMA_ILLIDAN_INTRO = 25
DATA_AKAMA_ILLIDAN_INTRO = 25,
DATA_RELIQUARY_COMBAT_TRIGGER = 26
};
enum TriggerEmotes
@@ -105,7 +106,11 @@ enum BTCreatureIds
NPC_ILLIDARI_ELITE = 23226,
NPC_GLAIVE_TARGET = 23448,
NPC_GLAIVE_WORLD_TRIGGER = 22515,
NPC_DEMON_FIRE = 23069
NPC_DEMON_FIRE = 23069,
NPC_PARASITIC_SHADOWFIEND = 23498,
NPC_BLAZE = 23259,
NPC_FLAME_CRASH = 23336,
NPC_RELIQUARY_COMBAT_TRIGGER = 23417
};
enum BTGameObjectIds
@@ -130,7 +135,6 @@ enum BTGameObjectIds
enum BlackTempleMisc
{
AKAMA_FACTION_COMBAT = 1868,
AKAMA_INTRO = 1,
AKAMA_FIGHT = 2,
ACTION_ACTIVE_AKAMA_INTRO = 3,
@@ -143,4 +147,6 @@ inline AI* GetBlackTempleAI(T* obj)
return GetInstanceAI<AI>(obj, BTScriptName);
}
#define RegisterBlackTempleCreatureAI(ai_name) RegisterCreatureAIWithFactory(ai_name, GetBlackTempleAI)
#endif // BLACK_TEMPLE_H_
@@ -89,318 +89,275 @@ enum Events
EVENT_CHARGE_PLAYER
};
class boss_gurtogg_bloodboil : public CreatureScript
struct boss_gurtogg_bloodboil : public BossAI
{
public:
boss_gurtogg_bloodboil() : CreatureScript("boss_gurtogg_bloodboil") { }
struct boss_gurtogg_bloodboilAI : public BossAI
boss_gurtogg_bloodboil(Creature* creature) : BossAI(creature, DATA_GURTOGG_BLOODBOIL)
{
boss_gurtogg_bloodboilAI(Creature* creature) : BossAI(creature, DATA_GURTOGG_BLOODBOIL)
{
Initialize();
}
Initialize();
}
void Reset() override
{
_Reset();
Initialize();
events.SetPhase(PHASE_1);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
}
void Reset() override
{
_Reset();
Initialize();
events.SetPhase(PHASE_1);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
}
void Initialize()
{
_oldThreat = 0.0f;
_oldTargetGUID.Clear();
_targetGUID.Clear();
}
void Initialize()
{
_oldThreat = 0.0f;
_oldTargetGUID.Clear();
_targetGUID.Clear();
}
bool CanAIAttack(Unit const* who) const override
{
return BossAI::CanAIAttack(who) && !who->HasAura(SPELL_BEWILDERING_STRIKE);
}
bool CanAIAttack(Unit const* who) const override
{
return BossAI::CanAIAttack(who) && !who->HasAura(SPELL_BEWILDERING_STRIKE);
}
void AttackStart(Unit* who) override
void AttackStart(Unit* who) override
{
if (!CanAIAttack(who))
return;
BossAI::AttackStart(who);
}
void JustEngagedWith(Unit* who) override
{
Talk(SAY_AGGRO);
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_BERSERK, 10min);
events.ScheduleEvent(EVENT_CHANGE_PHASE, 1min);
ScheduleEvents();
}
void EnterEvadeMode(EvadeReason /*why*/) override
{
_DespawnAtEvade();
}
void ScheduleEvents()
{
if (events.IsInPhase(PHASE_1))
{
if (!CanAIAttack(who))
events.ScheduleEvent(EVENT_BLOODBOIL, Seconds(10), GROUP_PHASE_1, PHASE_1);
events.ScheduleEvent(EVENT_ARCING_SMASH, Seconds(10), GROUP_PHASE_1, PHASE_1);
events.ScheduleEvent(EVENT_FEL_ACID_BREATH, Seconds(25), GROUP_PHASE_1, PHASE_1);
events.ScheduleEvent(EVENT_EJECT, Seconds(35), GROUP_PHASE_1, PHASE_1);
events.ScheduleEvent(EVENT_BEWILDERING_STRIKE, Seconds(47), GROUP_PHASE_1, PHASE_1);
}
else if (events.IsInPhase(PHASE_2))
{
events.ScheduleEvent(EVENT_START_PHASE_2, Milliseconds(100), GROUP_PHASE_2, PHASE_2);
events.ScheduleEvent(EVENT_EJECT_2, Seconds(14), GROUP_PHASE_2, PHASE_2);
events.ScheduleEvent(EVENT_FEL_ACID_BREATH_2, Seconds(16), GROUP_PHASE_2, PHASE_2);
events.ScheduleEvent(EVENT_ARCING_SMASH_2, Seconds(8), GROUP_PHASE_2, PHASE_2);
}
}
void KilledUnit(Unit* victim) override
{
if (victim->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void JustDied(Unit* /*killer*/) override
{
_JustDied();
DoPlaySoundToSet(me, SOUND_ID_DEATH);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BLOODBOIL:
DoCast(SPELL_BLOODBOIL);
events.Repeat(Seconds(10));
break;
case EVENT_ARCING_SMASH:
DoCastVictim(SPELL_ARCING_SMASH);
events.Repeat(Seconds(10));
break;
case EVENT_FEL_ACID_BREATH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, me->GetCombatReach()))
DoCast(target, SPELL_FEL_ACID_BREATH);
events.Repeat(Seconds(25), Seconds(30));
break;
case EVENT_EJECT:
Talk(SAY_SPECIAL);
DoCastVictim(SPELL_EJECT);
break;
case EVENT_BEWILDERING_STRIKE:
DoCastVictim(SPELL_BEWILDERING_STRIKE);
break;
case EVENT_CHANGE_PHASE:
ChangePhase();
break;
case EVENT_START_PHASE_2:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1))
{
if (Unit* oldTarget = me->GetVictim())
{
_oldTargetGUID = oldTarget->GetGUID();
_oldThreat = GetThreat(oldTarget);
}
_targetGUID = target->GetGUID();
DoCastSelf(SPELL_FEL_RAGE_SELF, true);
DoCast(target, SPELL_FEL_RAGE_TARGET, true);
DoCast(target, SPELL_FEL_RAGE_2, true);
DoCast(target, SPELL_FEL_RAGE_3, true);
DoCast(target, SPELL_FEL_GEYSER, true);
DoCast(target, SPELL_FEL_RAGE_TARGET_2, true);
target->CastSpell(target, SPELL_FEL_RAGE_P, true);
target->CastSpell(target, SPELL_TAUNT_GURTOGG, true);
DoCastAOE(SPELL_INSIGNIFIGANCE, true);
events.ScheduleEvent(EVENT_CHARGE_PLAYER, Seconds(2), GROUP_PHASE_2, PHASE_2);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, true);
}
else // If no other targets are found, reset phase 1
{
events.SetPhase(PHASE_1);
events.CancelEventGroup(GROUP_PHASE_2);
ScheduleEvents();
events.RescheduleEvent(EVENT_CHANGE_PHASE, Seconds(60));
}
break;
case EVENT_CHARGE_PLAYER:
if (Unit* target = ObjectAccessor::GetUnit(*me, _targetGUID))
DoCast(target, SPELL_CHARGE);
break;
case EVENT_EJECT_2:
DoCastVictim(SPELL_EJECT_2);
break;
case EVENT_FEL_ACID_BREATH_2:
DoCastVictim(SPELL_FEL_ACID_BREATH_2);
break;
case EVENT_ARCING_SMASH_2:
DoCastVictim(SPELL_ARCING_SMASH_2);
events.Repeat(Seconds(13));
break;
case EVENT_BERSERK:
DoCast(SPELL_BERSERK);
roll_chance_i(50) ? Talk(SAY_ENRAGE) : DoPlaySoundToSet(me, SOUND_ID_ENRAGE);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
BossAI::AttackStart(who);
}
void JustEngagedWith(Unit* who) override
DoMeleeAttackIfReady();
}
void ChangePhase()
{
if (events.IsInPhase(PHASE_1))
{
BossAI::JustEngagedWith(who);
Talk(SAY_AGGRO);
events.ScheduleEvent(EVENT_BERSERK, Minutes(10));
events.ScheduleEvent(EVENT_CHANGE_PHASE, Seconds(60));
events.SetPhase(PHASE_2);
events.CancelEventGroup(GROUP_PHASE_1);
events.ScheduleEvent(EVENT_CHANGE_PHASE, 30s);
ScheduleEvents();
}
void EnterEvadeMode(EvadeReason /*why*/) override
else if (events.IsInPhase(PHASE_2))
{
_DespawnAtEvade();
}
events.SetPhase(PHASE_1);
events.CancelEventGroup(GROUP_PHASE_2);
events.ScheduleEvent(EVENT_CHANGE_PHASE, 1min);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
ScheduleEvents();
void ScheduleEvents()
{
if (events.IsInPhase(PHASE_1))
{
events.ScheduleEvent(EVENT_BLOODBOIL, Seconds(10), GROUP_PHASE_1, PHASE_1);
events.ScheduleEvent(EVENT_ARCING_SMASH, Seconds(10), GROUP_PHASE_1, PHASE_1);
events.ScheduleEvent(EVENT_FEL_ACID_BREATH, Seconds(25), GROUP_PHASE_1, PHASE_1);
events.ScheduleEvent(EVENT_EJECT, Seconds(35), GROUP_PHASE_1, PHASE_1);
events.ScheduleEvent(EVENT_BEWILDERING_STRIKE, Seconds(47), GROUP_PHASE_1, PHASE_1);
}
else if (events.IsInPhase(PHASE_2))
{
events.ScheduleEvent(EVENT_START_PHASE_2, Milliseconds(100), GROUP_PHASE_2, PHASE_2);
events.ScheduleEvent(EVENT_EJECT_2, Seconds(14), GROUP_PHASE_2, PHASE_2);
events.ScheduleEvent(EVENT_FEL_ACID_BREATH_2, Seconds(16), GROUP_PHASE_2, PHASE_2);
events.ScheduleEvent(EVENT_ARCING_SMASH_2, Seconds(8), GROUP_PHASE_2, PHASE_2);
}
}
void KilledUnit(Unit* victim) override
{
if (victim->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void JustDied(Unit* /*killer*/) override
{
_JustDied();
DoPlaySoundToSet(me, SOUND_ID_DEATH);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
// Attack the stored target
if (Unit* oldTarget = ObjectAccessor::GetUnit(*me, _oldTargetGUID))
if (Unit* currentTarget = ObjectAccessor::GetUnit(*me, _targetGUID))
{
case EVENT_BLOODBOIL:
DoCast(SPELL_BLOODBOIL);
events.Repeat(Seconds(10));
break;
case EVENT_ARCING_SMASH:
DoCastVictim(SPELL_ARCING_SMASH);
events.Repeat(Seconds(10));
break;
case EVENT_FEL_ACID_BREATH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, me->GetCombatReach()))
DoCast(target, SPELL_FEL_ACID_BREATH);
events.Repeat(Seconds(25), Seconds(30));
break;
case EVENT_EJECT:
Talk(SAY_SPECIAL);
DoCastVictim(SPELL_EJECT);
break;
case EVENT_BEWILDERING_STRIKE:
DoCastVictim(SPELL_BEWILDERING_STRIKE);
break;
case EVENT_CHANGE_PHASE:
ChangePhase();
break;
case EVENT_START_PHASE_2:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1))
{
if (Unit* oldTarget = me->GetVictim())
{
_oldTargetGUID = oldTarget->GetGUID();
_oldThreat = GetThreat(oldTarget);
}
_targetGUID = target->GetGUID();
DoCastSelf(SPELL_FEL_RAGE_SELF, true);
DoCast(target, SPELL_FEL_RAGE_TARGET, true);
DoCast(target, SPELL_FEL_RAGE_2, true);
DoCast(target, SPELL_FEL_RAGE_3, true);
DoCast(target, SPELL_FEL_GEYSER, true);
DoCast(target, SPELL_FEL_RAGE_TARGET_2, true);
target->CastSpell(target, SPELL_FEL_RAGE_P, true);
target->CastSpell(target, SPELL_TAUNT_GURTOGG, true);
DoCastAOE(SPELL_INSIGNIFIGANCE, true);
events.ScheduleEvent(EVENT_CHARGE_PLAYER, Seconds(2), GROUP_PHASE_2, PHASE_2);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, true);
}
else // If no other targets are found, reset phase 1
{
events.SetPhase(PHASE_1);
events.CancelEventGroup(GROUP_PHASE_2);
ScheduleEvents();
events.RescheduleEvent(EVENT_CHANGE_PHASE, Seconds(60));
}
break;
case EVENT_CHARGE_PLAYER:
if (Unit* target = ObjectAccessor::GetUnit(*me, _targetGUID))
DoCast(target, SPELL_CHARGE);
break;
case EVENT_EJECT_2:
DoCastVictim(SPELL_EJECT_2);
break;
case EVENT_FEL_ACID_BREATH_2:
DoCastVictim(SPELL_FEL_ACID_BREATH_2);
break;
case EVENT_ARCING_SMASH_2:
DoCastVictim(SPELL_ARCING_SMASH_2);
events.Repeat(Seconds(13));
break;
case EVENT_BERSERK:
DoCast(SPELL_BERSERK);
roll_chance_i(50) ? Talk(SAY_ENRAGE) : DoPlaySoundToSet(me, SOUND_ID_ENRAGE);
break;
default:
break;
ModifyThreatByPercent(currentTarget, -100);
AttackStart(oldTarget);
AddThreat(oldTarget, _oldThreat);
Initialize();
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void ChangePhase()
{
if (events.IsInPhase(PHASE_1))
{
events.SetPhase(PHASE_2);
events.CancelEventGroup(GROUP_PHASE_1);
events.ScheduleEvent(EVENT_CHANGE_PHASE, Seconds(30));
ScheduleEvents();
}
else if (events.IsInPhase(PHASE_2))
{
events.SetPhase(PHASE_1);
events.CancelEventGroup(GROUP_PHASE_2);
events.ScheduleEvent(EVENT_CHANGE_PHASE, Seconds(60));
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
ScheduleEvents();
// Attack the stored target
if (Unit* oldTarget = ObjectAccessor::GetUnit(*me, _oldTargetGUID))
if (Unit* currentTarget = ObjectAccessor::GetUnit(*me, _targetGUID))
{
ModifyThreatByPercent(currentTarget, -100);
AttackStart(oldTarget);
AddThreat(oldTarget, _oldThreat);
Initialize();
}
}
}
private:
ObjectGuid _targetGUID;
ObjectGuid _oldTargetGUID;
float _oldThreat;
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetBlackTempleAI<boss_gurtogg_bloodboilAI>(creature);
}
private:
ObjectGuid _targetGUID;
ObjectGuid _oldTargetGUID;
float _oldThreat;
};
class npc_fel_geyser : public CreatureScript
struct npc_fel_geyser : public PassiveAI
{
public:
npc_fel_geyser() : CreatureScript("npc_fel_geyser") { }
npc_fel_geyser(Creature* creature) : PassiveAI(creature) { }
struct npc_fel_geyserAI : public PassiveAI
void Reset() override
{
npc_fel_geyserAI(Creature* creature) : PassiveAI(creature) { }
void Reset() override
{
DoCastSelf(SPELL_FEL_GEYSER_2, true);
DoCastSelf(SPELL_BIRTH, true);
}
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetBlackTempleAI<npc_fel_geyserAI>(creature);
DoCastSelf(SPELL_FEL_GEYSER_2, true);
DoCastSelf(SPELL_BIRTH, true);
}
};
// 42005 - Bloodboil
class spell_gurtogg_bloodboil_bloodboil : public SpellScriptLoader
class spell_gurtogg_bloodboil_bloodboil : public SpellScript
{
public:
spell_gurtogg_bloodboil_bloodboil() : SpellScriptLoader("spell_gurtogg_bloodboil_bloodboil") { }
void FilterTargets(std::list<WorldObject*>& targets)
{
if (targets.size() <= 5)
return;
class spell_gurtogg_bloodboil_bloodboil_SpellScript : public SpellScript
{
void FilterTargets(std::list<WorldObject*>& targets)
{
if (targets.size() <= 5)
return;
// Sort the list of players
targets.sort(Trinity::ObjectDistanceOrderPred(GetCaster(), false));
// Resize so we only get top 5
targets.resize(5);
}
// Sort the list of players
targets.sort(Trinity::ObjectDistanceOrderPred(GetCaster(), false));
// Resize so we only get top 5
targets.resize(5);
}
void Register() override
{
OnObjectAreaTargetSelect.Register(&spell_gurtogg_bloodboil_bloodboil_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
}
};
SpellScript* GetSpellScript() const override
{
return new spell_gurtogg_bloodboil_bloodboil_SpellScript();
}
void Register() override
{
OnObjectAreaTargetSelect.Register(&spell_gurtogg_bloodboil_bloodboil::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
}
};
// 40618 - Insignificance
class spell_gurtogg_bloodboil_insignificance : public SpellScriptLoader
class spell_gurtogg_bloodboil_insignificance : public SpellScript
{
public:
spell_gurtogg_bloodboil_insignificance() : SpellScriptLoader("spell_gurtogg_bloodboil_insignificance") { }
class spell_gurtogg_bloodboil_insignificance_SpellScript : public SpellScript
bool Validate(SpellInfo const* /*spell*/) override
{
bool Validate(SpellInfo const* /*spell*/) override
{
return ValidateSpellInfo({ SPELL_FEL_RAGE_TARGET });
}
return ValidateSpellInfo({ SPELL_FEL_RAGE_TARGET });
}
void FilterTargets(std::list<WorldObject*>& targets)
{
targets.remove_if(Trinity::UnitAuraCheck(true, SPELL_FEL_RAGE_TARGET));
}
void Register() override
{
OnObjectAreaTargetSelect.Register(&spell_gurtogg_bloodboil_insignificance_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
}
};
SpellScript* GetSpellScript() const override
void FilterTargets(std::list<WorldObject*>& targets)
{
return new spell_gurtogg_bloodboil_insignificance_SpellScript();
targets.remove_if(Trinity::UnitAuraCheck(true, SPELL_FEL_RAGE_TARGET));
}
void Register() override
{
OnObjectAreaTargetSelect.Register(&spell_gurtogg_bloodboil_insignificance::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
}
};
void AddSC_boss_gurtogg_bloodboil()
{
new boss_gurtogg_bloodboil();
new npc_fel_geyser();
new spell_gurtogg_bloodboil_bloodboil();
new spell_gurtogg_bloodboil_insignificance();
RegisterBlackTempleCreatureAI(boss_gurtogg_bloodboil);
RegisterBlackTempleCreatureAI(npc_fel_geyser);
RegisterSpellScript(spell_gurtogg_bloodboil_bloodboil);
RegisterSpellScript(spell_gurtogg_bloodboil_insignificance);
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -17,11 +17,11 @@
#include "ScriptMgr.h"
#include "black_temple.h"
#include "GridNotifiers.h"
#include "ScriptedCreature.h"
#include "SpellAuraEffects.h"
#include "black_temple.h"
#include "SpellScript.h"
#include "SpellAuraEffects.h"
#include "GridNotifiers.h"
enum Texts
{
@@ -40,7 +40,7 @@ enum Spells
SPELL_FATAL_ATTRACTION_DAMAGE = 40871,
SPELL_SILENCING_SHRIEK = 40823,
SPELL_SABER_LASH_IMMUNITY = 43690,
SPELL_FATAL_ATTACTION_TELEPORT = 40869,
SPELL_FATAL_ATTRACTION_TELEPORT = 40869,
SPELL_BERSERK = 45078,
SPELL_FATAL_ATTRACTION = 41001,
SPELL_SINISTER_PERIODIC = 40863,
@@ -96,296 +96,223 @@ uint32 const PrismaticAuras[6]=
SPELL_PRISMATIC_AURA_HOLY
};
Position const TeleportPoint[7]=
struct boss_mother_shahraz : public BossAI
{
{ 959.996f, 212.576f, 193.843f },
{ 932.537f, 231.813f, 193.838f },
{ 958.675f, 254.767f, 193.822f },
{ 946.955f, 201.316f, 192.535f },
{ 944.294f, 149.676f, 197.551f },
{ 930.548f, 284.888f, 193.367f },
{ 965.997f, 278.398f, 195.777f }
};
boss_mother_shahraz(Creature* creature) : BossAI(creature, DATA_MOTHER_SHAHRAZ), _enraged(false) { }
class boss_mother_shahraz : public CreatureScript
{
public:
boss_mother_shahraz() : CreatureScript("boss_mother_shahraz") { }
struct boss_shahrazAI : public BossAI
void Reset() override
{
boss_shahrazAI(Creature* creature) : BossAI(creature, DATA_MOTHER_SHAHRAZ), _enraged(false) { }
void Reset() override
{
_Reset();
_enraged = false;
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
Talk(SAY_AGGRO);
events.ScheduleEvent(EVENT_SILENCING_SHRIEK, Seconds(22));
events.ScheduleEvent(EVENT_PRISMATIC_SHIELD, Seconds(15));
events.ScheduleEvent(EVENT_FATAL_ATTRACTION, Seconds(35));
events.ScheduleEvent(EVENT_RANDOM_BEAM, Seconds(6));
events.ScheduleEvent(EVENT_BERSERK, Minutes(10));
events.ScheduleEvent(EVENT_TAUNT, Seconds(35));
}
void KilledUnit(Unit* victim) override
{
if (victim->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void JustDied(Unit* /*killer*/) override
{
_JustDied();
Talk(SAY_DEATH);
}
void EnterEvadeMode(EvadeReason /*why*/) override
{
_DespawnAtEvade();
}
void DamageTaken(Unit* /*attacker*/, uint32 &damage) override
{
if (!_enraged && me->HealthBelowPctDamaged(10, damage))
{
_enraged = true;
DoCastSelf(SPELL_RANDOM_PERIODIC, true);
Talk(EMOTE_ENRAGE, me);
Talk(SAY_ENRAGE);
}
}
void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_RANDOM_BEAM:
DoCastSelf(BeamTriggers[urand(0, 3)]);
events.Repeat(Seconds(30));
break;
case EVENT_PRISMATIC_SHIELD:
DoCastSelf(PrismaticAuras[urand(0, 5)]);
events.Repeat(Seconds(15));
break;
case EVENT_FATAL_ATTRACTION:
Talk(SAY_SPELL);
DoCastSelf(SPELL_FATAL_ATTACTION_TELEPORT, { SPELLVALUE_MAX_TARGETS, 3 });
events.Repeat(Seconds(30));
break;
case EVENT_SILENCING_SHRIEK:
DoCastVictim(SPELL_SILENCING_SHRIEK);
events.Repeat(Seconds(18), Seconds(30));
break;
case EVENT_TAUNT:
Talk(SAY_TAUNT);
events.Repeat(Seconds(30), Seconds(40));
break;
case EVENT_BERSERK:
Talk(EMOTE_BERSERK, me);
DoCastSelf(SPELL_BERSERK);
break;
default:
break;
}
}
private:
bool _enraged;
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetBlackTempleAI<boss_shahrazAI>(creature);
_Reset();
_enraged = false;
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
Talk(SAY_AGGRO);
events.ScheduleEvent(EVENT_SILENCING_SHRIEK, 22s);
events.ScheduleEvent(EVENT_PRISMATIC_SHIELD, 15s);
events.ScheduleEvent(EVENT_FATAL_ATTRACTION, 35s);
events.ScheduleEvent(EVENT_RANDOM_BEAM, 6s);
events.ScheduleEvent(EVENT_BERSERK, 10min);
events.ScheduleEvent(EVENT_TAUNT, 35s);
}
void KilledUnit(Unit* victim) override
{
if (victim->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void JustDied(Unit* /*killer*/) override
{
_JustDied();
Talk(SAY_DEATH);
}
void EnterEvadeMode(EvadeReason /*why*/) override
{
_DespawnAtEvade();
}
void DamageTaken(Unit* /*attacker*/, uint32 &damage) override
{
if (!_enraged && me->HealthBelowPctDamaged(10, damage))
{
_enraged = true;
DoCastSelf(SPELL_RANDOM_PERIODIC, true);
Talk(EMOTE_ENRAGE, me);
Talk(SAY_ENRAGE);
}
}
void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_RANDOM_BEAM:
DoCastSelf(BeamTriggers[urand(0, 3)]);
events.Repeat(Seconds(30));
break;
case EVENT_PRISMATIC_SHIELD:
DoCastSelf(PrismaticAuras[urand(0, 5)]);
events.Repeat(Seconds(15));
break;
case EVENT_FATAL_ATTRACTION:
Talk(SAY_SPELL);
DoCastSelf(SPELL_FATAL_ATTRACTION_TELEPORT, { SPELLVALUE_MAX_TARGETS, 3 });
events.Repeat(Seconds(30));
break;
case EVENT_SILENCING_SHRIEK:
DoCastVictim(SPELL_SILENCING_SHRIEK);
events.Repeat(Seconds(18), Seconds(30));
break;
case EVENT_TAUNT:
Talk(SAY_TAUNT);
events.Repeat(Seconds(30), Seconds(40));
break;
case EVENT_BERSERK:
Talk(EMOTE_BERSERK, me);
DoCastSelf(SPELL_BERSERK);
break;
default:
break;
}
}
private:
bool _enraged;
};
// 40869 - Fatal Attraction
class spell_mother_shahraz_fatal_attraction : public SpellScriptLoader
class spell_mother_shahraz_fatal_attraction : public SpellScript
{
public:
spell_mother_shahraz_fatal_attraction() : SpellScriptLoader("spell_mother_shahraz_fatal_attraction") { }
class spell_mother_shahraz_fatal_attraction_SpellScript : public SpellScript
bool Validate(SpellInfo const* /*spell*/) override
{
return ValidateSpellInfo(
{
bool Validate(SpellInfo const* /*spell*/) override
{
return ValidateSpellInfo({ SPELL_SABER_LASH_IMMUNITY, SPELL_FATAL_ATTRACTION });
}
SPELL_SABER_LASH_IMMUNITY,
SPELL_FATAL_ATTRACTION
});
}
void FilterTargets(std::list<WorldObject*>& targets)
{
targets.remove_if(Trinity::UnitAuraCheck(true, SPELL_SABER_LASH_IMMUNITY));
}
void FilterTargets(std::list<WorldObject*>& targets)
{
targets.remove_if(Trinity::UnitAuraCheck(true, SPELL_SABER_LASH_IMMUNITY));
}
void SetDest(SpellDestination& dest)
{
dest.Relocate(TeleportPoint[urand(0, 6)]);
}
void SetDest(SpellDestination& dest)
{
dest.Relocate(GetCaster()->GetRandomNearPosition(50.0f));
}
void HandleTeleport(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(GetHitUnit(), SPELL_FATAL_ATTRACTION, true);
}
void HandleTeleport(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(GetHitUnit(), SPELL_FATAL_ATTRACTION, true);
}
void Register() override
{
OnObjectAreaTargetSelect.Register(&spell_mother_shahraz_fatal_attraction_SpellScript::FilterTargets, EFFECT_ALL, TARGET_UNIT_SRC_AREA_ENEMY);
OnDestinationTargetSelect.Register(&spell_mother_shahraz_fatal_attraction_SpellScript::SetDest, EFFECT_1, TARGET_DEST_CASTER_RANDOM);
OnEffectHitTarget.Register(&spell_mother_shahraz_fatal_attraction_SpellScript::HandleTeleport, EFFECT_1, SPELL_EFFECT_TELEPORT_UNITS);
}
};
SpellScript* GetSpellScript() const override
{
return new spell_mother_shahraz_fatal_attraction_SpellScript();
}
void Register() override
{
OnObjectAreaTargetSelect.Register(&spell_mother_shahraz_fatal_attraction::FilterTargets, EFFECT_ALL, TARGET_UNIT_SRC_AREA_ENEMY);
OnDestinationTargetSelect.Register(&spell_mother_shahraz_fatal_attraction::SetDest, EFFECT_1, TARGET_DEST_CASTER_RANDOM);
OnEffectHitTarget.Register(&spell_mother_shahraz_fatal_attraction::HandleTeleport, EFFECT_1, SPELL_EFFECT_TELEPORT_UNITS);
}
};
// 40870 - Fatal Attraction Dummy Visual
class spell_mother_shahraz_fatal_attraction_link : public SpellScriptLoader
class spell_mother_shahraz_fatal_attraction_link : public SpellScript
{
public:
spell_mother_shahraz_fatal_attraction_link() : SpellScriptLoader("spell_mother_shahraz_fatal_attraction_link") { }
bool Validate(SpellInfo const* /*spell*/) override
{
return ValidateSpellInfo({ SPELL_FATAL_ATTRACTION_DAMAGE });
}
class spell_mother_shahraz_fatal_attraction_link_SpellScript : public SpellScript
{
bool Validate(SpellInfo const* /*spell*/) override
{
return ValidateSpellInfo({ SPELL_FATAL_ATTRACTION_DAMAGE });
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(GetCaster(), SPELL_FATAL_ATTRACTION_DAMAGE, true);
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(GetCaster(), SPELL_FATAL_ATTRACTION_DAMAGE, true);
}
void Register() override
{
OnEffectHitTarget.Register(&spell_mother_shahraz_fatal_attraction_link_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const override
{
return new spell_mother_shahraz_fatal_attraction_link_SpellScript();
}
void Register() override
{
OnEffectHitTarget.Register(&spell_mother_shahraz_fatal_attraction_link::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
// 40816 - Saber Lash
class spell_mother_shahraz_saber_lash : public SpellScriptLoader
class spell_mother_shahraz_saber_lash : public AuraScript
{
public:
spell_mother_shahraz_saber_lash() : SpellScriptLoader("spell_mother_shahraz_saber_lash") { }
bool Validate(SpellInfo const* spellInfo) override
{
return ValidateSpellInfo({ spellInfo->Effects[EFFECT_1].TriggerSpell });
}
class spell_mother_shahraz_saber_lash_AuraScript : public AuraScript
{
bool Validate(SpellInfo const* spellInfo) override
{
return ValidateSpellInfo({ spellInfo->Effects[EFFECT_1].TriggerSpell });
}
void OnTrigger(AuraEffect const* aurEff)
{
PreventDefaultAction();
void OnTrigger(AuraEffect const* aurEff)
{
PreventDefaultAction();
uint32 triggerSpell = GetSpellInfo()->Effects[aurEff->GetEffIndex()].TriggerSpell;
if (Unit* target = GetUnitOwner()->GetAI()->SelectTarget(SELECT_TARGET_RANDOM, 0))
GetUnitOwner()->CastSpell(target, triggerSpell, true);
}
uint32 triggerSpell = GetSpellInfo()->Effects[aurEff->GetEffIndex()].TriggerSpell;
if (Unit* target = GetUnitOwner()->GetAI()->SelectTarget(SELECT_TARGET_RANDOM, 0))
GetUnitOwner()->CastSpell(target, triggerSpell, true);
}
void Register() override
{
OnEffectPeriodic.Register(&spell_mother_shahraz_saber_lash_AuraScript::OnTrigger, EFFECT_1, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const override
{
return new spell_mother_shahraz_saber_lash_AuraScript();
}
void Register() override
{
OnEffectPeriodic.Register(&spell_mother_shahraz_saber_lash::OnTrigger, EFFECT_1, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
/* 40863 - Sinister Periodic
40865 - Vile Periodic
40866 - Wicked Periodic
40862 - Sinful Periodic */
class spell_mother_shahraz_generic_periodic : public SpellScriptLoader
class spell_mother_shahraz_generic_periodic : public AuraScript
{
public:
spell_mother_shahraz_generic_periodic() : SpellScriptLoader("spell_mother_shahraz_generic_periodic") { }
bool Validate(SpellInfo const* spellInfo) override
{
return ValidateSpellInfo({ spellInfo->Effects[EFFECT_0].TriggerSpell });
}
class spell_mother_shahraz_generic_periodic_AuraScript : public AuraScript
{
bool Validate(SpellInfo const* spellInfo) override
{
return ValidateSpellInfo({ spellInfo->Effects[EFFECT_0].TriggerSpell });
}
void OnTrigger(AuraEffect const* aurEff)
{
PreventDefaultAction();
void OnTrigger(AuraEffect const* aurEff)
{
PreventDefaultAction();
uint32 triggerSpell = GetSpellInfo()->Effects[aurEff->GetEffIndex()].TriggerSpell;
if (Unit* target = GetUnitOwner()->GetAI()->SelectTarget(SELECT_TARGET_RANDOM, 0))
GetUnitOwner()->CastSpell(target, triggerSpell, true);
}
uint32 triggerSpell = GetSpellInfo()->Effects[aurEff->GetEffIndex()].TriggerSpell;
if (Unit* target = GetUnitOwner()->GetAI()->SelectTarget(SELECT_TARGET_RANDOM, 0))
GetUnitOwner()->CastSpell(target, triggerSpell, true);
}
void Register() override
{
OnEffectPeriodic.Register(&spell_mother_shahraz_generic_periodic_AuraScript::OnTrigger, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const override
{
return new spell_mother_shahraz_generic_periodic_AuraScript();
}
void Register() override
{
OnEffectPeriodic.Register(&spell_mother_shahraz_generic_periodic::OnTrigger, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
// 40867 - Random Periodic
class spell_mother_shahraz_random_periodic : public SpellScriptLoader
class spell_mother_shahraz_random_periodic : public AuraScript
{
public:
spell_mother_shahraz_random_periodic() : SpellScriptLoader("spell_mother_shahraz_random_periodic") { }
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo(RandomBeam);
}
class spell_mother_shahraz_random_periodic_AuraScript : public AuraScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo(RandomBeam);
}
void OnPeriodic(AuraEffect const* /*aurEffect*/)
{
PreventDefaultAction();
GetUnitOwner()->CastSpell(GetUnitOwner(), RandomBeam[urand(0, 3)], true);
}
void OnPeriodic(AuraEffect const* /*aurEffect*/)
{
PreventDefaultAction();
GetUnitOwner()->CastSpell(GetUnitOwner(), RandomBeam[urand(0, 3)], true);
}
void Register() override
{
OnEffectPeriodic.Register(&spell_mother_shahraz_random_periodic_AuraScript::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const override
{
return new spell_mother_shahraz_random_periodic_AuraScript();
}
void Register() override
{
OnEffectPeriodic.Register(&spell_mother_shahraz_random_periodic::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
void AddSC_boss_mother_shahraz()
{
new boss_mother_shahraz();
new spell_mother_shahraz_fatal_attraction();
new spell_mother_shahraz_fatal_attraction_link();
new spell_mother_shahraz_saber_lash();
new spell_mother_shahraz_generic_periodic();
new spell_mother_shahraz_random_periodic();
RegisterBlackTempleCreatureAI(boss_mother_shahraz);
RegisterSpellScript(spell_mother_shahraz_fatal_attraction);
RegisterSpellScript(spell_mother_shahraz_fatal_attraction_link);
RegisterSpellScript(spell_mother_shahraz_saber_lash);
RegisterSpellScript(spell_mother_shahraz_generic_periodic);
RegisterSpellScript(spell_mother_shahraz_random_periodic);
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -63,200 +63,165 @@ enum Actions
{
ACTION_DISABLE_VULCANO = 1
};
class boss_supremus : public CreatureScript
struct boss_supremus : public BossAI
{
public:
boss_supremus() : CreatureScript("boss_supremus") { }
boss_supremus(Creature* creature) : BossAI(creature, DATA_SUPREMUS) { }
struct boss_supremusAI : public BossAI
void Reset() override
{
boss_supremusAI(Creature* creature) : BossAI(creature, DATA_SUPREMUS) { }
_Reset();
events.SetPhase(PHASE_INITIAL);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
}
void Reset() override
void EnterEvadeMode(EvadeReason /*why*/) override
{
summons.DespawnAll();
_DespawnAtEvade();
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
ChangePhase();
events.ScheduleEvent(EVENT_BERSERK, 15min);
events.ScheduleEvent(EVENT_FLAME, 20s);
}
void ChangePhase()
{
if (events.IsInPhase(PHASE_INITIAL) || events.IsInPhase(PHASE_CHASE))
{
_Reset();
events.SetPhase(PHASE_INITIAL);
events.SetPhase(PHASE_STRIKE);
DummyEntryCheckPredicate pred;
summons.DoAction(ACTION_DISABLE_VULCANO, pred);
events.ScheduleEvent(EVENT_HATEFUL_STRIKE, Seconds(2), 0, PHASE_STRIKE);
me->RemoveAurasDueToSpell(SPELL_SNARE_SELF);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
}
void EnterEvadeMode(EvadeReason /*why*/) override
else
{
summons.DespawnAll();
_DespawnAtEvade();
events.SetPhase(PHASE_CHASE);
events.ScheduleEvent(EVENT_VOLCANO, Seconds(5), 0, PHASE_CHASE);
events.ScheduleEvent(EVENT_SWITCH_TARGET, Seconds(10), 0, PHASE_CHASE);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, true);
DoCast(SPELL_SNARE_SELF);
}
ResetThreatList();
DoZoneInCombat();
events.ScheduleEvent(EVENT_SWITCH_PHASE, 1min);
}
void JustEngagedWith(Unit* who) override
Unit* CalculateHatefulStrikeTarget()
{
uint32 health = 0;
Unit* target = nullptr;
for (auto* ref : me->GetThreatManager().GetUnsortedThreatList())
{
BossAI::JustEngagedWith(who);
ChangePhase();
events.ScheduleEvent(EVENT_BERSERK, Minutes(15));
events.ScheduleEvent(EVENT_FLAME, Seconds(20));
}
void ChangePhase()
{
if (events.IsInPhase(PHASE_INITIAL) || events.IsInPhase(PHASE_CHASE))
Unit* unit = ref->GetVictim();
if (me->IsWithinMeleeRange(unit))
{
events.SetPhase(PHASE_STRIKE);
DummyEntryCheckPredicate pred;
summons.DoAction(ACTION_DISABLE_VULCANO, pred);
events.ScheduleEvent(EVENT_HATEFUL_STRIKE, Seconds(2), 0, PHASE_STRIKE);
me->RemoveAurasDueToSpell(SPELL_SNARE_SELF);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
}
else
{
events.SetPhase(PHASE_CHASE);
events.ScheduleEvent(EVENT_VOLCANO, Seconds(5), 0, PHASE_CHASE);
events.ScheduleEvent(EVENT_SWITCH_TARGET, Seconds(10), 0, PHASE_CHASE);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, true);
DoCast(SPELL_SNARE_SELF);
}
ResetThreatList();
DoZoneInCombat();
events.ScheduleEvent(EVENT_SWITCH_PHASE, Seconds(60));
}
Unit* CalculateHatefulStrikeTarget()
{
uint32 health = 0;
Unit* target = nullptr;
for (auto* ref : me->GetThreatManager().GetUnsortedThreatList())
{
Unit* unit = ref->GetVictim();
if (me->IsWithinMeleeRange(unit))
if (unit->GetHealth() > health)
{
if (unit->GetHealth() > health)
{
health = unit->GetHealth();
target = unit;
}
health = unit->GetHealth();
target = unit;
}
}
return target;
}
void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_BERSERK:
DoCastSelf(SPELL_BERSERK, true);
break;
case EVENT_FLAME:
DoCast(SPELL_MOLTEN_PUNCH);
events.Repeat(Seconds(15), Seconds(20));
break;
case EVENT_HATEFUL_STRIKE:
if (Unit* target = CalculateHatefulStrikeTarget())
DoCast(target, SPELL_HATEFUL_STRIKE);
events.Repeat(Seconds(5));
break;
case EVENT_SWITCH_TARGET:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100.0f, true))
{
ResetThreatList();
AddThreat(target, 1000000.0f);
DoCast(target, SPELL_CHARGE);
Talk(EMOTE_NEW_TARGET);
}
events.Repeat(Seconds(10));
break;
case EVENT_VOLCANO:
DoCastAOE(SPELL_VOLCANIC_SUMMON, true);
Talk(EMOTE_GROUND_CRACK);
events.Repeat(Seconds(10));
break;
case EVENT_SWITCH_PHASE:
ChangePhase();
break;
default:
break;
}
}
return target;
}
};
CreatureAI* GetAI(Creature* creature) const override
void ExecuteEvent(uint32 eventId) override
{
return GetBlackTempleAI<boss_supremusAI>(creature);
switch (eventId)
{
case EVENT_BERSERK:
DoCastSelf(SPELL_BERSERK, true);
break;
case EVENT_FLAME:
DoCast(SPELL_MOLTEN_PUNCH);
events.Repeat(Seconds(15), Seconds(20));
break;
case EVENT_HATEFUL_STRIKE:
if (Unit* target = CalculateHatefulStrikeTarget())
DoCast(target, SPELL_HATEFUL_STRIKE);
events.Repeat(Seconds(5));
break;
case EVENT_SWITCH_TARGET:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100.0f, true))
{
ResetThreatList();
AddThreat(target, 1000000.0f);
DoCast(target, SPELL_CHARGE);
Talk(EMOTE_NEW_TARGET);
}
events.Repeat(Seconds(10));
break;
case EVENT_VOLCANO:
DoCastAOE(SPELL_VOLCANIC_SUMMON, true);
Talk(EMOTE_GROUND_CRACK);
events.Repeat(Seconds(10));
break;
case EVENT_SWITCH_PHASE:
ChangePhase();
break;
default:
break;
}
}
};
class npc_molten_flame : public CreatureScript
struct npc_molten_flame : public NullCreatureAI
{
public:
npc_molten_flame() : CreatureScript("npc_molten_flame") { }
npc_molten_flame(Creature* creature) : NullCreatureAI(creature) { }
struct npc_molten_flameAI : public NullCreatureAI
void InitializeAI() override
{
npc_molten_flameAI(Creature* creature) : NullCreatureAI(creature) { }
void InitializeAI() override
{
float x, y, z;
me->GetNearPoint(me, x, y, z, 100.0f, frand(0.f, 2.f * float(M_PI)));
me->GetMotionMaster()->MovePoint(0, x, y, z);
DoCastSelf(SPELL_MOLTEN_FLAME, true);
}
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetBlackTempleAI<npc_molten_flameAI>(creature);
float x, y, z;
me->GetNearPoint(me, x, y, z, 100.0f, frand(0.f, 2.f * float(M_PI)));
me->GetMotionMaster()->MovePoint(0, x, y, z);
DoCastSelf(SPELL_MOLTEN_FLAME, true);
}
};
class npc_volcano : public CreatureScript
struct npc_volcano : public NullCreatureAI
{
public:
npc_volcano() : CreatureScript("npc_volcano") { }
npc_volcano(Creature* creature) : NullCreatureAI(creature) { }
struct npc_volcanoAI : public NullCreatureAI
void Reset() override
{
npc_volcanoAI(Creature* creature) : NullCreatureAI(creature) { }
void Reset() override
_scheduler.Schedule(Seconds(3), [this](TaskContext /*context*/)
{
_scheduler.Schedule(Seconds(3), [this](TaskContext /*context*/)
{
DoCastSelf(SPELL_VOLCANIC_ERUPTION);
});
}
void DoAction(int32 action) override
{
if (action == ACTION_DISABLE_VULCANO)
{
me->RemoveAurasDueToSpell(SPELL_VOLCANIC_ERUPTION);
me->RemoveAurasDueToSpell(SPELL_VOLCANIC_GEYSER);
}
}
void UpdateAI(uint32 diff) override
{
_scheduler.Update(diff);
}
private:
TaskScheduler _scheduler;
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetBlackTempleAI<npc_volcanoAI>(creature);
DoCastSelf(SPELL_VOLCANIC_ERUPTION);
});
}
void DoAction(int32 action) override
{
if (action == ACTION_DISABLE_VULCANO)
{
me->RemoveAurasDueToSpell(SPELL_VOLCANIC_ERUPTION);
me->RemoveAurasDueToSpell(SPELL_VOLCANIC_GEYSER);
}
}
void UpdateAI(uint32 diff) override
{
_scheduler.Update(diff);
}
private:
TaskScheduler _scheduler;
};
void AddSC_boss_supremus()
{
new boss_supremus();
new npc_molten_flame();
new npc_volcano();
RegisterBlackTempleCreatureAI(boss_supremus);
RegisterBlackTempleCreatureAI(npc_molten_flame);
RegisterBlackTempleCreatureAI(npc_volcano);
}
@@ -69,14 +69,13 @@ enum Spells
SPELL_SPIRIT_VOLLEY = 40314,
SPELL_SPIRIT_SHIELD = 40322,
SPELL_SPIRIT_LANCE = 40157
};
enum Npcs
{
NPC_DOOM_BLOSSOM = 23123,
NPC_SHADOWY_CONSTRUCT = 23111,
NPC_VENGEFUL_SPIRIT = 23109 //Npc controlled by player
NPC_DOOM_BLOSSOM = 23123,
NPC_SHADOWY_CONSTRUCT = 23111,
NPC_VENGEFUL_SPIRIT = 23109 //Npc controlled by player
};
enum Events
@@ -108,263 +107,316 @@ uint32 const SkeletronSpells[4] =
SPELL_SUMMON_SKELETRON_4
};
class boss_teron_gorefiend : public CreatureScript
struct boss_teron_gorefiend : public BossAI
{
public:
boss_teron_gorefiend() : CreatureScript("boss_teron_gorefiend") { }
boss_teron_gorefiend(Creature* creature) : BossAI(creature, DATA_TERON_GOREFIEND) { }
struct boss_teron_gorefiendAI : public BossAI
void Reset() override
{
boss_teron_gorefiendAI(Creature* creature) : BossAI(creature, DATA_TERON_GOREFIEND) { }
void Reset() override
_Reset();
if (instance->GetData(DATA_TERON_GOREFIEND_INTRO))
{
_Reset();
if (instance->GetData(DATA_TERON_GOREFIEND_INTRO))
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
me->SetReactState(REACT_PASSIVE);
}
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
Talk(SAY_AGGRO);
events.SetPhase(PHASE_COMBAT);
events.ScheduleEvent(EVENT_ENRAGE, 10min);
events.ScheduleEvent(EVENT_INCINERATE, 12s);
events.ScheduleEvent(EVENT_SUMMON_DOOM_BLOSSOM, 8s);
events.ScheduleEvent(EVENT_SHADOW_DEATH, 8s);
events.ScheduleEvent(EVENT_CRUSHING_SHADOWS, 18s);
}
void EnterEvadeMode(EvadeReason /*why*/) override
{
DoCast(SPELL_SHADOW_OF_DEATH_REMOVE);
summons.DespawnAll();
_DespawnAtEvade();
}
void DoAction(int32 action) override
{
if (action == ACTION_START_INTRO && me->IsAlive())
{
instance->SetData(DATA_TERON_GOREFIEND_INTRO, 0);
Talk(SAY_INTRO);
events.SetPhase(PHASE_INTRO);
events.ScheduleEvent(EVENT_FINISH_INTRO, 20s);
}
}
void KilledUnit(Unit* victim) override
{
if (victim->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void JustDied(Unit* /*killer*/) override
{
Talk(SAY_DEATH);
DoCast(SPELL_SHADOW_OF_DEATH_REMOVE);
_JustDied();
}
void UpdateAI(uint32 diff) override
{
if (!events.IsInPhase(PHASE_INTRO) && !UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
me->SetReactState(REACT_PASSIVE);
case EVENT_ENRAGE:
DoCast(SPELL_BERSERK);
break;
case EVENT_INCINERATE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_INCINERATE);
Talk(SAY_INCINERATE);
events.Repeat(Seconds(12), Seconds(20));
break;
case EVENT_SUMMON_DOOM_BLOSSOM:
DoCastSelf(SPELL_SUMMON_DOOM_BLOSSOM, true);
Talk(SAY_BLOSSOM);
events.Repeat(Seconds(30), Seconds(40));
break;
case EVENT_SHADOW_DEATH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100.0f, true, true, -SPELL_SPIRITUAL_VENGEANCE))
DoCast(target, SPELL_SHADOW_OF_DEATH);
events.Repeat(Seconds(30), Seconds(35));
break;
case EVENT_CRUSHING_SHADOWS:
DoCastSelf(SPELL_CRUSHING_SHADOWS, { SPELLVALUE_MAX_TARGETS, 5 });
Talk(SAY_CRUSHING);
events.Repeat(Seconds(18), Seconds(30));
break;
case EVENT_FINISH_INTRO:
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE);
me->SetReactState(REACT_AGGRESSIVE);
break;
default:
break;
}
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
Talk(SAY_AGGRO);
events.SetPhase(PHASE_COMBAT);
events.ScheduleEvent(EVENT_ENRAGE, Minutes(10));
events.ScheduleEvent(EVENT_INCINERATE, Seconds(12));
events.ScheduleEvent(EVENT_SUMMON_DOOM_BLOSSOM, Seconds(8));
events.ScheduleEvent(EVENT_SHADOW_DEATH, Seconds(8));
events.ScheduleEvent(EVENT_CRUSHING_SHADOWS, Seconds(18));
}
void EnterEvadeMode(EvadeReason /*why*/) override
{
DoCast(SPELL_SHADOW_OF_DEATH_REMOVE);
summons.DespawnAll();
_DespawnAtEvade();
}
void DoAction(int32 action) override
{
if (action == ACTION_START_INTRO && me->IsAlive())
{
instance->SetData(DATA_TERON_GOREFIEND_INTRO, 0);
Talk(SAY_INTRO);
events.SetPhase(PHASE_INTRO);
events.ScheduleEvent(EVENT_FINISH_INTRO, Seconds(20));
}
}
void KilledUnit(Unit* victim) override
{
if (victim->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void JustDied(Unit* /*killer*/) override
{
Talk(SAY_DEATH);
DoCast(SPELL_SHADOW_OF_DEATH_REMOVE);
_JustDied();
}
void UpdateAI(uint32 diff) override
{
if (!events.IsInPhase(PHASE_INTRO) && !UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ENRAGE:
DoCast(SPELL_BERSERK);
break;
case EVENT_INCINERATE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_INCINERATE);
Talk(SAY_INCINERATE);
events.Repeat(Seconds(12), Seconds(20));
break;
case EVENT_SUMMON_DOOM_BLOSSOM:
DoCastSelf(SPELL_SUMMON_DOOM_BLOSSOM, true);
Talk(SAY_BLOSSOM);
events.Repeat(Seconds(30), Seconds(40));
break;
case EVENT_SHADOW_DEATH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100.0f, true, true, -SPELL_SPIRITUAL_VENGEANCE))
DoCast(target, SPELL_SHADOW_OF_DEATH);
events.Repeat(Seconds(30), Seconds(35));
break;
case EVENT_CRUSHING_SHADOWS:
DoCastSelf(SPELL_CRUSHING_SHADOWS, { SPELLVALUE_MAX_TARGETS, 5 });
Talk(SAY_CRUSHING);
events.Repeat(Seconds(18), Seconds(30));
break;
case EVENT_FINISH_INTRO:
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE);
me->SetReactState(REACT_AGGRESSIVE);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetBlackTempleAI<boss_teron_gorefiendAI>(creature);
DoMeleeAttackIfReady();
}
};
class npc_doom_blossom : public CreatureScript
struct npc_doom_blossom : public NullCreatureAI
{
public:
npc_doom_blossom() : CreatureScript("npc_doom_blossom") { }
npc_doom_blossom(Creature* creature) : NullCreatureAI(creature), _instance(me->GetInstanceScript()) { }
struct npc_doom_blossomAI : public NullCreatureAI
void Reset() override
{
npc_doom_blossomAI(Creature* creature) : NullCreatureAI(creature), _instance(me->GetInstanceScript()) { }
/* Workaround - Until SMSG_SET_PLAY_HOVER_ANIM be implemented */
Position pos;
pos.Relocate(me);
pos.m_positionZ += 8.0f;
me->GetMotionMaster()->MoveTakeoff(0, pos);
void Reset() override
DoCast(SPELL_SUMMON_BLOSSOM_MOVE_TARGET);
_scheduler.CancelAll();
DoZoneInCombat();
_scheduler.Schedule(Seconds(12), [this](TaskContext shadowBolt)
{
/* Workaround - Until SMSG_SET_PLAY_HOVER_ANIM be implemented */
Position pos;
pos.Relocate(me);
pos.m_positionZ += 8.0f;
me->GetMotionMaster()->MoveTakeoff(0, pos);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_SHADOWBOLT);
DoCast(SPELL_SUMMON_BLOSSOM_MOVE_TARGET);
_scheduler.CancelAll();
me->SetInCombatWithZone();
_scheduler.Schedule(Seconds(12), [this](TaskContext shadowBolt)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_SHADOWBOLT);
shadowBolt.Repeat(Seconds(2));
});
}
void UpdateAI(uint32 diff) override
{
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
_scheduler.Update(diff);
}
private:
TaskScheduler _scheduler;
InstanceScript* _instance;
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetBlackTempleAI<npc_doom_blossomAI>(creature);
shadowBolt.Repeat(Seconds(2));
});
}
void UpdateAI(uint32 diff) override
{
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
_scheduler.Update(diff);
}
private:
TaskScheduler _scheduler;
InstanceScript* _instance;
};
class npc_shadowy_construct : public CreatureScript
struct npc_shadowy_construct : public ScriptedAI
{
public:
npc_shadowy_construct() : CreatureScript("npc_shadowy_construct") { }
struct npc_shadowy_constructAI : public ScriptedAI
npc_shadowy_construct(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript())
{
npc_shadowy_constructAI(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript())
//This creature must be immune everything, except spells of Vengeful Spirit.
creature->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, true);
creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_MAGIC, true);
}
void Reset() override
{
if (_instance->GetBossState(DATA_TERON_GOREFIEND) != IN_PROGRESS)
{
//This creature must be immune everything, except spells of Vengeful Spirit.
creature->ApplySpellImmune(0, IMMUNITY_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, true);
creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_MAGIC, true);
me->DespawnOrUnsummon();
return;
}
void Reset() override
targetGUID.Clear();
_scheduler.CancelAll();
_scheduler.Schedule(Seconds(12), [this](TaskContext atrophy)
{
if (_instance->GetBossState(DATA_TERON_GOREFIEND) != IN_PROGRESS)
DoCastVictim(SPELL_ATROPHY);
atrophy.Repeat(Seconds(10), Seconds(12));
});
_scheduler.Schedule(Milliseconds(200), [this](TaskContext checkPlayer)
{
if (Unit* target = ObjectAccessor::GetUnit(*me, targetGUID))
{
me->DespawnOrUnsummon();
return;
}
targetGUID.Clear();
_scheduler.CancelAll();
_scheduler.Schedule(Seconds(12), [this](TaskContext atrophy)
{
DoCastVictim(SPELL_ATROPHY);
atrophy.Repeat(Seconds(10), Seconds(12));
});
_scheduler.Schedule(Milliseconds(200), [this](TaskContext checkPlayer)
{
if (Unit* target = ObjectAccessor::GetUnit(*me, targetGUID))
{
if (!target->IsAlive() || !me->CanCreatureAttack(target))
SelectNewTarget();
}
else
if (!target->IsAlive() || !me->CanCreatureAttack(target))
SelectNewTarget();
}
else
SelectNewTarget();
checkPlayer.Repeat(Seconds(1));
});
checkPlayer.Repeat(Seconds(1));
});
if (Creature* teron = _instance->GetCreature(DATA_TERON_GOREFIEND))
teron->AI()->JustSummoned(me);
if (Creature* teron = _instance->GetCreature(DATA_TERON_GOREFIEND))
teron->AI()->JustSummoned(me);
SelectNewTarget();
}
SelectNewTarget();
}
void UpdateAI(uint32 diff) override
void UpdateAI(uint32 diff) override
{
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
_scheduler.Update(diff, [this]
{
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
DoMeleeAttackIfReady();
});
}
_scheduler.Update(diff, [this]
{
DoMeleeAttackIfReady();
});
}
void SelectNewTarget()
void SelectNewTarget()
{
if (Creature* teron = _instance->GetCreature(DATA_TERON_GOREFIEND))
{
if (Creature* teron = _instance->GetCreature(DATA_TERON_GOREFIEND))
{
Unit* target = teron->AI()->SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true, true, -SPELL_SPIRITUAL_VENGEANCE);
// He should target Vengeful Spirits only if has no other player available
if (!target)
target = teron->AI()->SelectTarget(SELECT_TARGET_RANDOM, 0);
Unit* target = teron->AI()->SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true, true, -SPELL_SPIRITUAL_VENGEANCE);
// He should target Vengeful Spirits only if has no other player available
if (!target)
target = teron->AI()->SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target)
{
ResetThreatList();
AttackStart(target);
AddThreat(target, 1000000.0f);
targetGUID = target->GetGUID();
}
if (target)
{
ResetThreatList();
AttackStart(target);
AddThreat(target, 1000000.0f);
targetGUID = target->GetGUID();
}
}
}
private:
TaskScheduler _scheduler;
InstanceScript* _instance;
ObjectGuid targetGUID;
};
private:
TaskScheduler _scheduler;
InstanceScript* _instance;
ObjectGuid targetGUID;
};
CreatureAI* GetAI(Creature* creature) const override
// 40251 - Shadow of Death
class spell_teron_gorefiend_shadow_of_death : public AuraScript
{
bool Validate(SpellInfo const* /*spell*/) override
{
return GetBlackTempleAI<npc_shadowy_constructAI>(creature);
return ValidateSpellInfo(
{
SPELL_SUMMON_SPIRIT,
SPELL_POSSESS_SPIRIT_IMMUNE,
SPELL_SPIRITUAL_VENGEANCE,
SPELL_SUMMON_SKELETRON_1,
SPELL_SUMMON_SKELETRON_2,
SPELL_SUMMON_SKELETRON_3,
SPELL_SUMMON_SKELETRON_4
});
}
void Absorb(AuraEffect* /*aurEff*/, DamageInfo& /*dmgInfo*/, uint32& /*absorbAmount*/)
{
PreventDefaultAction();
}
void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
if (GetTargetApplication()->GetRemoveMode().HasFlag(AuraRemoveFlags::Expired))
{
Unit* target = GetTarget();
target->CastSpell(target, SPELL_SUMMON_SPIRIT, true);
for (uint8 i = 0; i < 4; ++i)
target->CastSpell(target, SkeletronSpells[i], true);
target->CastSpell(target, SPELL_POSSESS_SPIRIT_IMMUNE, true);
target->CastSpell(target, SPELL_SPIRITUAL_VENGEANCE, true);
}
}
void Register() override
{
OnEffectAbsorb.Register(&spell_teron_gorefiend_shadow_of_death::Absorb, EFFECT_0);
AfterEffectRemove.Register(&spell_teron_gorefiend_shadow_of_death::OnRemove, EFFECT_1, SPELL_AURA_OVERRIDE_CLASS_SCRIPTS, AURA_EFFECT_HANDLE_REAL);
}
};
// 40268 - Spiritual Vengeance
class spell_teron_gorefiend_spiritual_vengeance : public AuraScript
{
void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
GetTarget()->KillSelf();
}
void Register() override
{
AfterEffectRemove.Register(&spell_teron_gorefiend_spiritual_vengeance::OnRemove, EFFECT_0, SPELL_AURA_MOD_POSSESS, AURA_EFFECT_HANDLE_REAL);
}
};
// 41999 - Shadow of Death Remove
class spell_teron_gorefiend_shadow_of_death_remove : public SpellScript
{
bool Validate(SpellInfo const* /*spell*/) override
{
return ValidateSpellInfo(
{
SPELL_SHADOW_OF_DEATH,
SPELL_POSSESS_SPIRIT_IMMUNE,
SPELL_SPIRITUAL_VENGEANCE
});
}
void RemoveAuras()
{
Unit* target = GetHitUnit();
target->RemoveAurasDueToSpell(SPELL_POSSESS_SPIRIT_IMMUNE);
target->RemoveAurasDueToSpell(SPELL_SPIRITUAL_VENGEANCE);
target->RemoveAurasDueToSpell(SPELL_SHADOW_OF_DEATH);
}
void Register() override
{
OnHit.Register(&spell_teron_gorefiend_shadow_of_death_remove::RemoveAuras);
}
};
@@ -383,131 +435,13 @@ public:
}
};
// 40251 - Shadow of Death
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
{
bool Validate(SpellInfo const* /*spell*/) override
{
return ValidateSpellInfo(
{
SPELL_SUMMON_SPIRIT,
SPELL_POSSESS_SPIRIT_IMMUNE,
SPELL_SPIRITUAL_VENGEANCE,
SPELL_SUMMON_SKELETRON_1,
SPELL_SUMMON_SKELETRON_2,
SPELL_SUMMON_SKELETRON_3,
SPELL_SUMMON_SKELETRON_4
});
}
void Absorb(AuraEffect* /*aurEff*/, DamageInfo& /*dmgInfo*/, uint32& /*absorbAmount*/)
{
PreventDefaultAction();
}
void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
if (GetTargetApplication()->GetRemoveMode().HasFlag(AuraRemoveFlags::Expired))
{
Unit* target = GetTarget();
target->CastSpell(target, SPELL_SUMMON_SPIRIT, true);
for (uint8 i = 0; i < 4; ++i)
target->CastSpell(target, SkeletronSpells[i], true);
target->CastSpell(target, SPELL_POSSESS_SPIRIT_IMMUNE, true);
target->CastSpell(target, SPELL_SPIRITUAL_VENGEANCE, true);
}
}
void Register() override
{
OnEffectAbsorb.Register(&spell_teron_gorefiend_shadow_of_death_AuraScript::Absorb, EFFECT_0);
AfterEffectRemove.Register(&spell_teron_gorefiend_shadow_of_death_AuraScript::OnRemove, EFFECT_1, SPELL_AURA_OVERRIDE_CLASS_SCRIPTS, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const override
{
return new spell_teron_gorefiend_shadow_of_death_AuraScript();
}
};
// 40268 - Spiritual Vengeance
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
{
void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
GetTarget()->KillSelf();
}
void Register() override
{
AfterEffectRemove.Register(&spell_teron_gorefiend_spiritual_vengeance_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_MOD_POSSESS, AURA_EFFECT_HANDLE_REAL);
AfterEffectRemove.Register(&spell_teron_gorefiend_spiritual_vengeance_AuraScript::OnRemove, EFFECT_2, SPELL_AURA_MOD_PACIFY_SILENCE, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const override
{
return new spell_teron_gorefiend_spiritual_vengeance_AuraScript();
}
};
// 41999 - Shadow of Death Remove
class spell_teron_gorefiend_shadow_of_death_remove : public SpellScriptLoader
{
public:
spell_teron_gorefiend_shadow_of_death_remove() : SpellScriptLoader("spell_teron_gorefiend_shadow_of_death_remove") { }
class spell_teron_gorefiend_shadow_of_death_remove_SpellScript : public SpellScript
{
bool Validate(SpellInfo const* /*spell*/) override
{
return ValidateSpellInfo({ SPELL_SHADOW_OF_DEATH, SPELL_POSSESS_SPIRIT_IMMUNE, SPELL_SPIRITUAL_VENGEANCE });
return false;
return true;
}
void RemoveAuras()
{
Unit* target = GetHitUnit();
target->RemoveAurasDueToSpell(SPELL_POSSESS_SPIRIT_IMMUNE);
target->RemoveAurasDueToSpell(SPELL_SPIRITUAL_VENGEANCE);
target->RemoveAurasDueToSpell(SPELL_SHADOW_OF_DEATH);
}
void Register() override
{
OnHit.Register(&spell_teron_gorefiend_shadow_of_death_remove_SpellScript::RemoveAuras);
}
};
SpellScript* GetSpellScript() const override
{
return new spell_teron_gorefiend_shadow_of_death_remove_SpellScript();
}
};
void AddSC_boss_teron_gorefiend()
{
new boss_teron_gorefiend();
new npc_doom_blossom();
new npc_shadowy_construct();
RegisterBlackTempleCreatureAI(boss_teron_gorefiend);
RegisterBlackTempleCreatureAI(npc_doom_blossom);
RegisterBlackTempleCreatureAI(npc_shadowy_construct);
RegisterSpellScript(spell_teron_gorefiend_shadow_of_death);
RegisterSpellScript(spell_teron_gorefiend_spiritual_vengeance);
RegisterSpellScript(spell_teron_gorefiend_shadow_of_death_remove);
new at_teron_gorefiend_entrance();
new spell_teron_gorefiend_shadow_of_death();
new spell_teron_gorefiend_spiritual_vengeance();
new spell_teron_gorefiend_shadow_of_death_remove();
}
@@ -28,218 +28,205 @@
enum Texts
{
SAY_AGGRO = 0,
SAY_NEEDLE = 1,
SAY_SLAY = 2,
SAY_SPECIAL = 3,
SAY_ENRAGE = 4,
SAY_DEATH = 5
SAY_AGGRO = 0,
SAY_NEEDLE = 1,
SAY_SLAY = 2,
SAY_SPECIAL = 3,
SAY_ENRAGE = 4,
SAY_DEATH = 5
};
enum Spells
{
SPELL_NEEDLE_SPINE_TARGETING = 39992,
SPELL_NEEDLE_SPINE = 39835,
SPELL_TIDAL_BURST = 39878,
SPELL_TIDAL_SHIELD = 39872,
SPELL_IMPALING_SPINE = 39837,
SPELL_CREATE_NAJENTUS_SPINE = 39956,
SPELL_HURL_SPINE = 39948,
SPELL_BERSERK = 26662
SPELL_NEEDLE_SPINE_TARGETING = 39992,
SPELL_NEEDLE_SPINE = 39835,
SPELL_TIDAL_BURST = 39878,
SPELL_TIDAL_SHIELD = 39872,
SPELL_IMPALING_SPINE = 39837,
SPELL_CREATE_NAJENTUS_SPINE = 39956,
SPELL_HURL_SPINE = 39948,
SPELL_BERSERK = 26662
};
enum Events
{
EVENT_BERSERK = 1,
EVENT_YELL = 2,
EVENT_NEEDLE = 3,
EVENT_SPINE = 4,
EVENT_SHIELD = 5
EVENT_BERSERK = 1,
EVENT_YELL = 2,
EVENT_NEEDLE = 3,
EVENT_SPINE = 4,
EVENT_SHIELD = 5
};
class boss_najentus : public CreatureScript
enum Misc
{
public:
boss_najentus() : CreatureScript("boss_najentus") { }
DATA_REMOVE_IMPALING_SPINE = 1,
ACTION_RESET_IMPALING_TARGET = 2
};
struct boss_najentusAI : public BossAI
struct boss_najentus : public BossAI
{
boss_najentus(Creature* creature) : BossAI(creature, DATA_HIGH_WARLORD_NAJENTUS) { }
void Reset() override
{
boss_najentusAI(Creature* creature) : BossAI(creature, DATA_HIGH_WARLORD_NAJENTUS) { }
void Reset() override
{
_Reset();
SpineTargetGUID.Clear();
}
void EnterEvadeMode(EvadeReason /*why*/) override
{
_DespawnAtEvade();
}
void KilledUnit(Unit* victim) override
{
if (victim->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void JustDied(Unit* /*killer*/) override
{
_JustDied();
Talk(SAY_DEATH);
}
void SpellHit(Unit* /*caster*/, SpellInfo const* spell) override
{
if (spell->Id == SPELL_HURL_SPINE && me->HasAura(SPELL_TIDAL_SHIELD))
{
me->RemoveAurasDueToSpell(SPELL_TIDAL_SHIELD);
DoCastSelf(SPELL_TIDAL_BURST, true);
events.RescheduleEvent(EVENT_SPINE, Seconds(2));
}
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
Talk(SAY_AGGRO);
events.ScheduleEvent(EVENT_NEEDLE, Seconds(2));
events.ScheduleEvent(EVENT_SHIELD, Seconds(60));
events.ScheduleEvent(EVENT_SPINE, Seconds(30));
events.ScheduleEvent(EVENT_BERSERK, Seconds(480));
events.ScheduleEvent(EVENT_YELL, Seconds(45), Seconds(100));
}
bool RemoveImpalingSpine()
{
if (!SpineTargetGUID)
return false;
Unit* target = ObjectAccessor::GetUnit(*me, SpineTargetGUID);
if (target && target->HasAura(SPELL_IMPALING_SPINE))
target->RemoveAurasDueToSpell(SPELL_IMPALING_SPINE);
SpineTargetGUID.Clear();
return true;
}
void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_SHIELD:
DoCastSelf(SPELL_TIDAL_SHIELD, true);
events.RescheduleEvent(EVENT_SPINE, Seconds(50));
events.Repeat(Seconds(55), Seconds(60));
break;
case EVENT_BERSERK:
Talk(SAY_ENRAGE);
DoCastSelf(SPELL_BERSERK, true);
break;
case EVENT_SPINE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 200.0f, true))
{
DoCast(target, SPELL_IMPALING_SPINE, true);
SpineTargetGUID = target->GetGUID();
//must let target summon, otherwise you cannot click the spine
target->SummonGameObject(GO_NAJENTUS_SPINE, *target, QuaternionData(), 30);
Talk(SAY_NEEDLE);
}
events.Repeat(Seconds(20), Seconds(25));
break;
case EVENT_NEEDLE:
DoCastSelf(SPELL_NEEDLE_SPINE_TARGETING, true);
events.Repeat(Seconds(2));
break;
case EVENT_YELL:
Talk(SAY_SPECIAL);
events.Repeat(Seconds(25), Seconds(100));
break;
default:
break;
}
}
private:
ObjectGuid SpineTargetGUID;
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetBlackTempleAI<boss_najentusAI>(creature);
_Reset();
_spineTargetGUID.Clear();
}
void EnterEvadeMode(EvadeReason /*why*/) override
{
_EnterEvadeMode();
_DespawnAtEvade();
}
void KilledUnit(Unit* victim) override
{
if (victim->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void JustDied(Unit* /*killer*/) override
{
_JustDied();
Talk(SAY_DEATH);
}
void SpellHit(Unit* /*caster*/, SpellInfo const* spellInfo) override
{
if (spellInfo->Id == SPELL_HURL_SPINE && me->HasAura(SPELL_TIDAL_SHIELD))
{
me->RemoveAurasDueToSpell(SPELL_TIDAL_SHIELD);
DoCastSelf(SPELL_TIDAL_BURST, true);
events.RescheduleEvent(EVENT_SPINE, Seconds(2));
}
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
Talk(SAY_AGGRO);
events.ScheduleEvent(EVENT_NEEDLE, 2s);
events.ScheduleEvent(EVENT_SHIELD, 1min);
events.ScheduleEvent(EVENT_SPINE, 30s);
events.ScheduleEvent(EVENT_BERSERK, 480s);
events.ScheduleEvent(EVENT_YELL, 45s, 100s);
}
uint32 GetData(uint32 data) const override
{
if (data == DATA_REMOVE_IMPALING_SPINE)
return RemoveImpalingSpine() ? 1 : 0;
return 0;
}
void DoAction(int32 actionId) override
{
if (actionId == ACTION_RESET_IMPALING_TARGET)
_spineTargetGUID.Clear();
}
bool RemoveImpalingSpine() const
{
if (!_spineTargetGUID)
return false;
Unit* target = ObjectAccessor::GetUnit(*me, _spineTargetGUID);
if (target && target->HasAura(SPELL_IMPALING_SPINE))
target->RemoveAurasDueToSpell(SPELL_IMPALING_SPINE);
return true;
}
void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_SHIELD:
DoCastSelf(SPELL_TIDAL_SHIELD, true);
events.RescheduleEvent(EVENT_SPINE, Seconds(50));
events.Repeat(Seconds(55), Seconds(60));
break;
case EVENT_BERSERK:
Talk(SAY_ENRAGE);
DoCastSelf(SPELL_BERSERK, true);
break;
case EVENT_SPINE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 200.0f, true))
{
DoCast(target, SPELL_IMPALING_SPINE, true);
_spineTargetGUID = target->GetGUID();
//must let target summon, otherwise you cannot click the spine
target->SummonGameObject(GO_NAJENTUS_SPINE, target->GetPosition(), QuaternionData(), 30 * IN_MILLISECONDS);
Talk(SAY_NEEDLE);
}
events.Repeat(Seconds(20), Seconds(25));
break;
case EVENT_NEEDLE:
DoCastSelf(SPELL_NEEDLE_SPINE_TARGETING, true);
events.Repeat(Seconds(2));
break;
case EVENT_YELL:
Talk(SAY_SPECIAL);
events.Repeat(Seconds(25), Seconds(100));
break;
default:
break;
}
}
private:
ObjectGuid _spineTargetGUID;
};
class go_najentus_spine : public GameObjectScript
struct go_najentus_spine : public GameObjectAI
{
public:
go_najentus_spine() : GameObjectScript("go_najentus_spine") { }
go_najentus_spine(GameObject* go) : GameObjectAI(go), _instance(go->GetInstanceScript()) { }
struct go_najentus_spineAI : public GameObjectAI
{
go_najentus_spineAI(GameObject* go) : GameObjectAI(go), instance(go->GetInstanceScript()) { }
bool GossipHello(Player* player) override
{
if (!_instance)
return false;
InstanceScript* instance;
bool GossipHello(Player* player) override
if (Creature* najentus = _instance->GetCreature(DATA_HIGH_WARLORD_NAJENTUS))
if (najentus->AI()->GetData(DATA_REMOVE_IMPALING_SPINE))
{
if (Creature* najentus = instance->GetCreature(DATA_HIGH_WARLORD_NAJENTUS))
{
if (ENSURE_AI(boss_najentus::boss_najentusAI, najentus->AI())->RemoveImpalingSpine())
{
me->CastSpell(player, SPELL_CREATE_NAJENTUS_SPINE, true);
me->Delete();
}
}
return true;
najentus->AI()->DoAction(ACTION_RESET_IMPALING_TARGET);
me->CastSpell(player, SPELL_CREATE_NAJENTUS_SPINE, true);
me->Delete();
}
};
GameObjectAI* GetAI(GameObject* go) const override
{
return GetBlackTempleAI<go_najentus_spineAI>(go);
}
return true;
}
private:
InstanceScript* _instance;
};
// 39992 - Needle Spine Targeting
class spell_najentus_needle_spine : public SpellScriptLoader
class spell_najentus_needle_spine : public SpellScript
{
public:
spell_najentus_needle_spine() : SpellScriptLoader("spell_najentus_needle_spine") { }
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_NEEDLE_SPINE });
}
class spell_najentus_needle_spine_SpellScript : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_NEEDLE_SPINE });
}
void FilterTargets(std::list<WorldObject*>& targets)
{
targets.remove_if(Trinity::UnitAuraCheck(true, SPELL_IMPALING_SPINE));
}
void FilterTargets(std::list<WorldObject*>& targets)
{
targets.remove_if(Trinity::UnitAuraCheck(true, SPELL_IMPALING_SPINE));
}
void HandleScript(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(GetHitUnit(), SPELL_NEEDLE_SPINE, true);
}
void HandleScript(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(GetHitUnit(), SPELL_NEEDLE_SPINE, true);
}
void Register() override
{
OnObjectAreaTargetSelect.Register(&spell_najentus_needle_spine_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
OnEffectHitTarget.Register(&spell_najentus_needle_spine_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const override
{
return new spell_najentus_needle_spine_SpellScript();
}
void Register() override
{
OnObjectAreaTargetSelect.Register(&spell_najentus_needle_spine::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
OnEffectHitTarget.Register(&spell_najentus_needle_spine::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
void AddSC_boss_najentus()
{
new boss_najentus();
new go_najentus_spine();
new spell_najentus_needle_spine();
RegisterBlackTempleCreatureAI(boss_najentus);
RegisterGameObjectAI(go_najentus_spine);
RegisterSpellScript(spell_najentus_needle_spine);
}
@@ -76,6 +76,7 @@ ObjectData const creatureData[] =
{ NPC_BLOOD_ELF_COUNCIL_VOICE, DATA_BLOOD_ELF_COUNCIL_VOICE },
{ NPC_BLACK_TEMPLE_TRIGGER, DATA_BLACK_TEMPLE_TRIGGER },
{ NPC_MAIEV_SHADOWSONG, DATA_MAIEV },
{ NPC_RELIQUARY_COMBAT_TRIGGER, DATA_RELIQUARY_COMBAT_TRIGGER },
{ 0, 0 } // END
};