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

537
src/server/scripts/EasternKingdoms/SunwellPlateau/boss_brutallus.cpp
View File

@@ -1,537 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "sunwell_plateau.h"
enum Quotes
{
YELL_INTRO = 0,
YELL_INTRO_BREAK_ICE = 1,
YELL_INTRO_CHARGE = 2,
YELL_INTRO_KILL_MADRIGOSA = 3,
YELL_INTRO_TAUNT = 4,
YELL_AGGRO = 5,
YELL_KILL = 6,
YELL_LOVE = 7,
YELL_BERSERK = 8,
YELL_DEATH = 9,
};
enum Spells
{
SPELL_METEOR_SLASH = 45150,
SPELL_BURN_DAMAGE = 46394,
SPELL_BURN = 45141,
SPELL_STOMP = 45185,
SPELL_BERSERK = 26662,
SPELL_DUAL_WIELD = 42459,
SPELL_SUMMON_BRUTALLUS_DEATH_CLOUD = 45884
};
enum Misc
{
EVENT_SPELL_SLASH = 1,
EVENT_SPELL_STOMP = 2,
EVENT_SPELL_BURN = 3,
EVENT_SPELL_BERSERK = 4,
ACTION_START_EVENT = 1,
ACTION_SPAWN_FELMYST = 2
};
class boss_brutallus : public CreatureScript
{
public:
boss_brutallus() : CreatureScript("boss_brutallus") { }
struct boss_brutallusAI : public BossAI
{
boss_brutallusAI(Creature* creature) : BossAI(creature, DATA_BRUTALLUS) { }
void Reset()
{
BossAI::Reset();
me->CastSpell(me, SPELL_DUAL_WIELD, true);
}
void DamageTaken(Unit* who, uint32& damage, DamageEffectType, SpellSchoolMask)
{
if (me->GetReactState() == REACT_PASSIVE && (!who || who->GetEntry() != NPC_MADRIGOSA))
{
if (who)
Unit::Kill(me, who);
damage = 0;
}
}
void EnterCombat(Unit* who)
{
if (who->GetEntry() == NPC_MADRIGOSA)
return;
Talk(YELL_AGGRO);
BossAI::EnterCombat(who);
events.ScheduleEvent(EVENT_SPELL_SLASH, 11000);
events.ScheduleEvent(EVENT_SPELL_STOMP, 30000);
events.ScheduleEvent(EVENT_SPELL_BURN, 45000);
events.ScheduleEvent(EVENT_SPELL_BERSERK, 360000);
}
void KilledUnit(Unit* victim)
{
if (victim->GetTypeId() == TYPEID_PLAYER && roll_chance_i(50))
Talk(YELL_KILL);
}
void JustDied(Unit* killer)
{
BossAI::JustDied(killer);
Talk(YELL_DEATH);
me->CastSpell(me, SPELL_SUMMON_BRUTALLUS_DEATH_CLOUD, true);
if (Creature* madrigosa = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_MADRIGOSA)))
madrigosa->AI()->DoAction(ACTION_SPAWN_FELMYST);
}
void AttackStart(Unit* who)
{
if (who->GetEntry() == NPC_MADRIGOSA)
return;
BossAI::AttackStart(who);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_SLASH:
me->CastSpell(me->GetVictim(), SPELL_METEOR_SLASH, false);
events.ScheduleEvent(EVENT_SPELL_SLASH, 10000);
break;
case EVENT_SPELL_STOMP:
me->CastSpell(me->GetVictim(), SPELL_STOMP, false);
Talk(YELL_LOVE);
events.ScheduleEvent(EVENT_SPELL_STOMP, 30000);
break;
case EVENT_SPELL_BURN:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true, -SPELL_BURN_DAMAGE))
me->CastSpell(target, SPELL_BURN, false);
events.ScheduleEvent(EVENT_SPELL_BURN, 60000);
break;
case EVENT_SPELL_BERSERK:
me->CastSpell(me, SPELL_BERSERK, true);
Talk(YELL_BERSERK);
break;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_brutallusAI>(creature);
}
};
enum eMadrigosa
{
EVENT_MAD_1 = 1,
EVENT_MAD_2 = 2,
EVENT_MAD_2_1 = 200,
EVENT_MAD_3 = 3,
EVENT_MAD_4 = 4,
EVENT_MAD_5 = 5,
EVENT_MAD_6 = 6,
EVENT_MAD_7 = 7,
EVENT_MAD_8 = 8,
EVENT_MAD_9 = 9,
EVENT_MAD_10 = 10,
EVENT_MAD_11 = 11,
EVENT_MAD_12 = 12,
EVENT_MAD_13 = 13,
EVENT_MAD_14 = 14,
EVENT_MAD_15 = 15,
EVENT_MAD_16 = 16,
EVENT_MAD_17 = 17,
EVENT_MAD_18 = 18,
EVENT_MAD_19 = 19,
EVENT_MAD_20 = 20,
EVENT_MAD_21 = 21,
EVENT_SPAWN_FELMYST = 30,
SAY_MAD_1 = 0,
SAY_MAD_2 = 1,
SAY_MAD_3 = 2,
SAY_MAD_4 = 3,
SAY_MAD_5 = 4,
SPELL_MADRIGOSA_FREEZE = 46609,
SPELL_MADRIGOSA_FROST_BREATH = 45065,
SPELL_MADRIGOSA_FROST_BLAST = 44872,
SPELL_MADRIGOSA_FROSTBOLT = 44843,
SPELL_MADRIGOSA_ENCAPSULATE = 44883,
SPELL_BRUTALLUS_CHARGE = 44884,
SPELL_BRUTALLUS_FEL_FIREBALL = 44844,
SPELL_BRUTALLUS_FLAME_RING = 44874,
SPELL_BRUTALLUS_BREAK_ICE = 46637,
};
class npc_madrigosa : public CreatureScript
{
public:
npc_madrigosa() : CreatureScript("npc_madrigosa") { }
struct npc_madrigosaAI : public NullCreatureAI
{
npc_madrigosaAI(Creature* creature) : NullCreatureAI(creature)
{
instance = creature->GetInstanceScript();
bool appear = instance->GetBossState(DATA_BRUTALLUS) != DONE && instance->GetBossState(DATA_MADRIGOSA) == DONE;
creature->SetVisible(appear);
creature->SetStandState(UNIT_STAND_STATE_DEAD);
creature->SetFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_DEAD);
}
EventMap events;
InstanceScript* instance;
void DoAction(int32 param)
{
if (param == ACTION_START_EVENT)
{
me->SetDisableGravity(true);
me->SetStandState(UNIT_STAND_STATE_STAND);
me->RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_DEAD);
me->NearTeleportTo(1570.97f, 725.51f, 79.77f, 3.82f);
events.ScheduleEvent(EVENT_MAD_1, 2000);
}
else if (param == ACTION_SPAWN_FELMYST)
events.ScheduleEvent(EVENT_SPAWN_FELMYST, 60000);
}
void UpdateAI(uint32 diff)
{
events.Update(diff);
switch (events.ExecuteEvent())
{
case EVENT_MAD_1:
me->SetVisible(true);
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
{
me->SetTarget(brutallus->GetGUID());
brutallus->SetReactState(REACT_PASSIVE);
brutallus->setActive(true);
}
me->GetMotionMaster()->MovePoint(1, 1477.94f, 643.22f, 21.21f);
me->AddUnitState(UNIT_STATE_NO_ENVIRONMENT_UPD);
events.ScheduleEvent(EVENT_MAD_2, 6000);
break;
case EVENT_MAD_2:
Talk(SAY_MAD_1);
me->CastSpell(me, SPELL_MADRIGOSA_FREEZE, false);
events.ScheduleEvent(EVENT_MAD_2_1, 1000);
break;
case EVENT_MAD_2_1:
me->HandleEmoteCommand(EMOTE_ONESHOT_LAND);
me->SetDisableGravity(false);
me->CastSpell(me, SPELL_MADRIGOSA_FROST_BREATH, false);
events.ScheduleEvent(EVENT_MAD_3, 7000);
break;
case EVENT_MAD_3:
Talk(SAY_MAD_2);
events.ScheduleEvent(EVENT_MAD_4, 7000);
break;
case EVENT_MAD_4:
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
brutallus->AI()->Talk(YELL_INTRO);
events.ScheduleEvent(EVENT_MAD_5, 5000);
break;
case EVENT_MAD_5:
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
{
brutallus->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_ATTACK1H);
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_ATTACK1H);
}
events.ScheduleEvent(EVENT_MAD_6, 10000);
break;
case EVENT_MAD_6:
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
{
brutallus->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_NONE);
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_NONE);
}
me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
me->SetDisableGravity(true);
events.ScheduleEvent(EVENT_MAD_7, 4000);
break;
case EVENT_MAD_7:
Talk(SAY_MAD_3);
me->CastSpell(me, SPELL_MADRIGOSA_FROST_BLAST, false);
events.ScheduleEvent(EVENT_MAD_8, 3000);
events.ScheduleEvent(EVENT_MAD_8, 5000);
events.ScheduleEvent(EVENT_MAD_8, 6500);
events.ScheduleEvent(EVENT_MAD_8, 7500);
events.ScheduleEvent(EVENT_MAD_8, 8500);
events.ScheduleEvent(EVENT_MAD_8, 9500);
events.ScheduleEvent(EVENT_MAD_9, 11000);
events.ScheduleEvent(EVENT_MAD_8, 12000);
events.ScheduleEvent(EVENT_MAD_8, 14000);
break;
case EVENT_MAD_8:
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
me->CastSpell(brutallus, SPELL_MADRIGOSA_FROSTBOLT, false);
break;
case EVENT_MAD_9:
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
{
brutallus->CastSpell(brutallus, SPELL_BRUTALLUS_FLAME_RING, true);
brutallus->RemoveAllAuras();
brutallus->CastSpell(brutallus, SPELL_BRUTALLUS_FEL_FIREBALL, false);
brutallus->AI()->Talk(YELL_INTRO_BREAK_ICE);
}
events.ScheduleEvent(EVENT_MAD_11, 6000);
break;
//case EVENT_MAD_10:
case EVENT_MAD_11:
me->SetDisableGravity(false);
me->HandleEmoteCommand(EMOTE_ONESHOT_LAND);
events.ScheduleEvent(EVENT_MAD_13, 2500);
break;
case EVENT_MAD_13:
Talk(SAY_MAD_4);
me->RemoveAllAuras();
me->CastSpell(me, SPELL_MADRIGOSA_ENCAPSULATE, false);
events.ScheduleEvent(EVENT_MAD_14, 2000);
break;
case EVENT_MAD_14:
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
{
brutallus->SetDisableGravity(true);
brutallus->GetMotionMaster()->MovePoint(0, brutallus->GetPositionX(), brutallus->GetPositionY()-30.0f, brutallus->GetPositionZ()+15.0f, false, true);
}
events.ScheduleEvent(EVENT_MAD_15, 10000);
break;
case EVENT_MAD_15:
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
{
brutallus->RemoveAllAuras();
brutallus->SetDisableGravity(false);
brutallus->GetMotionMaster()->MoveFall();
brutallus->AI()->Talk(YELL_INTRO_CHARGE);
}
events.ScheduleEvent(EVENT_MAD_16, 1400);
break;
case EVENT_MAD_16:
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
brutallus->CastSpell(me, SPELL_BRUTALLUS_CHARGE, true);
events.ScheduleEvent(EVENT_MAD_17, 1200);
break;
case EVENT_MAD_17:
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
brutallus->HandleEmoteCommand(EMOTE_ONESHOT_ATTACK1H);
events.ScheduleEvent(EVENT_MAD_18, 500);
break;
case EVENT_MAD_18:
Talk(SAY_MAD_5);
me->SetFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_DEAD);
me->SetStandState(UNIT_STAND_STATE_DEAD);
events.ScheduleEvent(EVENT_MAD_19, 6000);
break;
case EVENT_MAD_19:
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
brutallus->AI()->Talk(YELL_INTRO_KILL_MADRIGOSA);
events.ScheduleEvent(EVENT_MAD_20, 7000);
break;
case EVENT_MAD_20:
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
me->setFaction(35);
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
{
brutallus->AI()->Talk(YELL_INTRO_TAUNT);
brutallus->CastSpell(brutallus, SPELL_BRUTALLUS_BREAK_ICE, false);
}
events.ScheduleEvent(EVENT_MAD_21, 4000);
break;
case EVENT_MAD_21:
if (Creature* brutallus = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_BRUTALLUS)))
{
brutallus->SetReactState(REACT_AGGRESSIVE);
brutallus->SetHealth(brutallus->GetMaxHealth());
brutallus->AI()->EnterEvadeMode();
brutallus->setActive(false);
}
break;
case EVENT_SPAWN_FELMYST:
me->DespawnOrUnsummon(1);
if (Creature* felmyst = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_FELMYST)))
felmyst->AI()->DoAction(ACTION_START_EVENT);
break;
}
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<npc_madrigosaAI>(creature);
}
};
class spell_madrigosa_activate_barrier : public SpellScriptLoader
{
public:
spell_madrigosa_activate_barrier() : SpellScriptLoader("spell_madrigosa_activate_barrier") { }
class spell_madrigosa_activate_barrier_SpellScript : public SpellScript
{
PrepareSpellScript(spell_madrigosa_activate_barrier_SpellScript);
void HandleActivateObject(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
if (GameObject* go = GetHitGObj())
{
go->SetGoState(GO_STATE_READY);
if (Map* map = go->GetMap())
{
Map::PlayerList const &PlayerList = map->GetPlayers();
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
if (i->GetSource())
{
UpdateData data;
WorldPacket pkt;
go->BuildValuesUpdateBlockForPlayer(&data, i->GetSource());
data.BuildPacket(&pkt);
i->GetSource()->GetSession()->SendPacket(&pkt);
}
}
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_madrigosa_activate_barrier_SpellScript::HandleActivateObject, EFFECT_0, SPELL_EFFECT_ACTIVATE_OBJECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_madrigosa_activate_barrier_SpellScript();
}
};
class spell_madrigosa_deactivate_barrier : public SpellScriptLoader
{
public:
spell_madrigosa_deactivate_barrier() : SpellScriptLoader("spell_madrigosa_deactivate_barrier") { }
class spell_madrigosa_deactivate_barrier_SpellScript : public SpellScript
{
PrepareSpellScript(spell_madrigosa_deactivate_barrier_SpellScript);
void HandleActivateObject(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
if (GameObject* go = GetHitGObj())
{
go->SetGoState(GO_STATE_ACTIVE);
if (Map* map = go->GetMap())
{
Map::PlayerList const &PlayerList = map->GetPlayers();
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
if (i->GetSource())
{
UpdateData data;
WorldPacket pkt;
go->BuildValuesUpdateBlockForPlayer(&data, i->GetSource());
data.BuildPacket(&pkt);
i->GetSource()->GetSession()->SendPacket(&pkt);
}
}
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_madrigosa_deactivate_barrier_SpellScript::HandleActivateObject, EFFECT_0, SPELL_EFFECT_ACTIVATE_OBJECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_madrigosa_deactivate_barrier_SpellScript();
}
};
class spell_brutallus_burn : public SpellScriptLoader
{
public:
spell_brutallus_burn() : SpellScriptLoader("spell_brutallus_burn") { }
class spell_brutallus_burn_SpellScript : public SpellScript
{
PrepareSpellScript(spell_brutallus_burn_SpellScript);
void HandleScriptEffect(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
if (Unit* target = GetHitUnit())
if (!target->HasAura(SPELL_BURN_DAMAGE))
target->CastSpell(target, SPELL_BURN_DAMAGE, true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_brutallus_burn_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_brutallus_burn_SpellScript();
}
};
class AreaTrigger_at_sunwell_madrigosa : public AreaTriggerScript
{
public:
AreaTrigger_at_sunwell_madrigosa() : AreaTriggerScript("at_sunwell_madrigosa") {}
bool OnTrigger(Player* player, AreaTriggerEntry const* /*trigger*/)
{
if (InstanceScript* instance = player->GetInstanceScript())
if (instance->GetBossState(DATA_MADRIGOSA) != DONE)
{
instance->SetBossState(DATA_MADRIGOSA, NOT_STARTED);
instance->SetBossState(DATA_MADRIGOSA, DONE);
if (Creature* creature = ObjectAccessor::GetCreature(*player, instance->GetData64(NPC_MADRIGOSA)))
creature->AI()->DoAction(ACTION_START_EVENT);
}
return true;
}
};
void AddSC_boss_brutallus()
{
new boss_brutallus();
new npc_madrigosa();
new spell_madrigosa_activate_barrier();
new spell_madrigosa_deactivate_barrier();
new spell_brutallus_burn();
new AreaTrigger_at_sunwell_madrigosa();
}

514
src/server/scripts/EasternKingdoms/SunwellPlateau/boss_eredar_twins.cpp
View File

@@ -1,514 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "sunwell_plateau.h"
#include "SpellInfo.h"
enum Quotes
{
YELL_INTRO_SAC = 0,
YELL_SAC_DEAD = 4,
EMOTE_SHADOW_NOVA = 5,
YELL_ENRAGE = 6,
YELL_SISTER_ALYTHESS_DEAD = 7,
YELL_SAC_KILL = 8,
YELL_SHADOW_NOVA = 9,
YELL_INTRO_ALY = 0,
EMOTE_CONFLAGRATION = 4,
YELL_ALY_KILL = 5,
YELL_ALY_DEAD = 6,
YELL_SISTER_SACROLASH_DEAD = 7,
YELL_CANFLAGRATION = 8,
YELL_BERSERK = 9
};
enum Spells
{
//Shared spells
SPELL_ENRAGE = 46587,
SPELL_EMPOWER = 45366,
SPELL_DARK_FLAME = 45345,
//Lady Sacrolash spells
SPELL_SHADOWFORM = 45455,
SPELL_DARK_TOUCHED = 45347,
SPELL_SHADOW_BLADES = 45248,
SPELL_SHADOW_NOVA = 45329,
SPELL_CONFOUNDING_BLOW = 45256,
//Grand Warlock Alythess spells
SPELL_FIREFORM = 45457,
SPELL_FLAME_TOUCHED = 45348,
SPELL_PYROGENICS = 45230,
SPELL_CONFLAGRATION = 45342,
SPELL_FLAME_SEAR = 46771,
SPELL_BLAZE = 45235,
SPELL_BLAZE_SUMMON = 45236
};
enum Misc
{
ACTION_SISTER_DIED = 1,
EVENT_SPELL_SHADOW_BLADES = 1,
EVENT_SPELL_SHADOW_NOVA = 2,
EVENT_SPELL_CONFOUNDING_BLOW= 3,
EVENT_SHADOW_IMAGE = 4,
EVENT_SPELL_ENRAGE = 5,
EVENT_SPELL_CONFLAGRATION = 6,
EVENT_SPELL_BLAZE = 7,
EVENT_SPELL_PYROGENICS = 8,
EVENT_SPELL_FLAME_SEAR = 9
};
class boss_sacrolash : public CreatureScript
{
public:
boss_sacrolash() : CreatureScript("boss_sacrolash") { }
struct boss_sacrolashAI : public BossAI
{
boss_sacrolashAI(Creature* creature) : BossAI(creature, DATA_EREDAR_TWINS) {}
bool sisterDied;
void Reset()
{
me->CastSpell(me, SPELL_SHADOWFORM, true);
sisterDied = false;
BossAI::Reset();
me->SetLootMode(0);
}
void DoAction(int32 param)
{
if (param == ACTION_SISTER_DIED)
{
me->ResetLootMode();
sisterDied = true;
Talk(YELL_SISTER_ALYTHESS_DEAD);
me->CastSpell(me, SPELL_EMPOWER, true);
uint32 timer = events.GetNextEventTime(EVENT_SPELL_SHADOW_NOVA);
events.CancelEvent(EVENT_SPELL_SHADOW_NOVA);
events.ScheduleEvent(EVENT_SPELL_CONFLAGRATION, timer-events.GetTimer());
}
}
void EnterEvadeMode()
{
BossAI::EnterEvadeMode();
if (Creature* alythess = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_GRAND_WARLOCK_ALYTHESS)))
{
if (!alythess->IsAlive())
alythess->Respawn(true);
else if (!alythess->IsInEvadeMode())
alythess->AI()->EnterEvadeMode();
}
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
if (Creature* alythess = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_GRAND_WARLOCK_ALYTHESS)))
if (alythess->IsAlive() && !alythess->IsInCombat())
alythess->AI()->AttackStart(who);
events.ScheduleEvent(EVENT_SPELL_SHADOW_BLADES, 10000);
events.ScheduleEvent(EVENT_SPELL_SHADOW_NOVA, 36000);
events.ScheduleEvent(EVENT_SPELL_CONFOUNDING_BLOW, 25000);
events.ScheduleEvent(EVENT_SHADOW_IMAGE, 20000);
events.ScheduleEvent(EVENT_SPELL_ENRAGE, 360000);
}
void KilledUnit(Unit* victim)
{
if (victim->GetTypeId() == TYPEID_PLAYER && urand(0,1))
Talk(YELL_SAC_KILL);
}
void JustDied(Unit* /*killer*/)
{
events.Reset();
summons.DespawnAll();
if (sisterDied)
{
Talk(YELL_SAC_DEAD);
instance->SetBossState(DATA_EREDAR_TWINS, DONE);
}
else if (Creature* alythess = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_GRAND_WARLOCK_ALYTHESS)))
alythess->AI()->DoAction(ACTION_SISTER_DIED);
}
void JustSummoned(Creature* summon)
{
summons.Summon(summon);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f, true))
{
summon->AI()->AttackStart(target);
summon->AddThreat(target, 10000000);
}
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_ENRAGE:
Talk(YELL_ENRAGE);
me->CastSpell(me, SPELL_ENRAGE, true);
break;
case EVENT_SPELL_CONFOUNDING_BLOW:
me->CastSpell(me->GetVictim(), SPELL_CONFOUNDING_BLOW, false);
events.ScheduleEvent(EVENT_SPELL_CONFOUNDING_BLOW, urand(20000, 25000));
break;
case EVENT_SPELL_SHADOW_BLADES:
me->CastSpell(me, SPELL_SHADOW_BLADES, false);
events.ScheduleEvent(EVENT_SPELL_SHADOW_BLADES, 10000);
break;
case EVENT_SPELL_SHADOW_NOVA:
{
Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO, 1, 100.0f);
if (!target)
target = me->GetVictim();
Talk(EMOTE_SHADOW_NOVA, target);
Talk(YELL_SHADOW_NOVA);
me->CastSpell(target, SPELL_SHADOW_NOVA, false);
events.ScheduleEvent(EVENT_SPELL_SHADOW_NOVA, urand(30000, 35000));
break;
}
case EVENT_SHADOW_IMAGE:
me->SummonCreature(NPC_SHADOW_IMAGE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation(), TEMPSUMMON_TIMED_DESPAWN, 12000);
events.ScheduleEvent(EVENT_SHADOW_IMAGE, 6000);
break;
case EVENT_SPELL_CONFLAGRATION:
{
Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO, 1, 100.0f);
if (!target)
target = me->GetVictim();
me->CastSpell(target, SPELL_CONFLAGRATION, false);
events.ScheduleEvent(EVENT_SPELL_CONFLAGRATION, urand(30000, 35000));
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_sacrolashAI>(creature);
};
};
class boss_alythess : public CreatureScript
{
public:
boss_alythess() : CreatureScript("boss_alythess") { }
struct boss_alythessAI : public BossAI
{
boss_alythessAI(Creature* creature) : BossAI(creature, DATA_EREDAR_TWINS) { }
bool sisterDied;
void Reset()
{
me->CastSpell(me, SPELL_FIREFORM, true);
sisterDied = false;
BossAI::Reset();
me->SetLootMode(0);
}
void DoAction(int32 param)
{
if (param == ACTION_SISTER_DIED)
{
me->ResetLootMode();
sisterDied = true;
Talk(YELL_SISTER_SACROLASH_DEAD);
me->CastSpell(me, SPELL_EMPOWER, true);
uint32 timer = events.GetNextEventTime(EVENT_SPELL_CONFLAGRATION);
events.CancelEvent(EVENT_SPELL_CONFLAGRATION);
events.ScheduleEvent(EVENT_SPELL_SHADOW_NOVA, timer-events.GetTimer());
}
}
void EnterEvadeMode()
{
BossAI::EnterEvadeMode();
if (Creature* scorlash = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_LADY_SACROLASH)))
{
if (!scorlash->IsAlive())
scorlash->Respawn(true);
else if (!scorlash->IsInEvadeMode())
scorlash->AI()->EnterEvadeMode();
}
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
if (Creature* scorlash = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_LADY_SACROLASH)))
if (scorlash->IsAlive() && !scorlash->IsInCombat())
scorlash->AI()->AttackStart(who);
events.ScheduleEvent(EVENT_SPELL_BLAZE, 100);
events.ScheduleEvent(EVENT_SPELL_PYROGENICS, 15000);
events.ScheduleEvent(EVENT_SPELL_FLAME_SEAR, 20000);
events.ScheduleEvent(EVENT_SPELL_CONFLAGRATION, 30000);
events.ScheduleEvent(EVENT_SPELL_ENRAGE, 360000);
}
void KilledUnit(Unit* victim)
{
if (victim->GetTypeId() == TYPEID_PLAYER && urand(0,1))
Talk(YELL_SAC_KILL);
}
void JustDied(Unit* /*killer*/)
{
events.Reset();
summons.DespawnAll();
if (sisterDied)
{
Talk(YELL_SAC_DEAD);
instance->SetBossState(DATA_EREDAR_TWINS, DONE);
}
else if (Creature* scorlash = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_LADY_SACROLASH)))
scorlash->AI()->DoAction(ACTION_SISTER_DIED);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_ENRAGE:
Talk(YELL_BERSERK);
me->CastSpell(me, SPELL_ENRAGE, true);
break;
case EVENT_SPELL_PYROGENICS:
me->CastSpell(me, SPELL_PYROGENICS, false);
events.ScheduleEvent(EVENT_SPELL_PYROGENICS, 15000);
break;
case EVENT_SPELL_FLAME_SEAR:
me->CastCustomSpell(SPELL_FLAME_SEAR, SPELLVALUE_MAX_TARGETS, 5, me, TRIGGERED_NONE);
events.ScheduleEvent(EVENT_SPELL_FLAME_SEAR, 15000);
break;
case EVENT_SPELL_BLAZE:
me->CastSpell(me->GetVictim(), SPELL_BLAZE, false);
events.ScheduleEvent(EVENT_SPELL_BLAZE, 3800);
break;
case EVENT_SPELL_SHADOW_NOVA:
{
Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO, 1, 100.0f);
if (!target)
target = me->GetVictim();
me->CastSpell(target, SPELL_SHADOW_NOVA, false);
events.ScheduleEvent(EVENT_SPELL_SHADOW_NOVA, urand(30000, 35000));
break;
}
case EVENT_SPELL_CONFLAGRATION:
{
Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO, 1, 100.0f);
if (!target)
target = me->GetVictim();
Talk(EMOTE_CONFLAGRATION, target);
Talk(YELL_CANFLAGRATION);
me->CastSpell(target, SPELL_CONFLAGRATION, false);
events.ScheduleEvent(EVENT_SPELL_CONFLAGRATION, urand(30000, 35000));
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_alythessAI>(creature);
};
};
class spell_eredar_twins_apply_dark_touched : public SpellScriptLoader
{
public:
spell_eredar_twins_apply_dark_touched() : SpellScriptLoader("spell_eredar_twins_apply_dark_touched") { }
class spell_eredar_twins_apply_dark_touched_SpellScript : public SpellScript
{
PrepareSpellScript(spell_eredar_twins_apply_dark_touched_SpellScript);
void HandleApplyTouch()
{
if (Player* target = GetHitPlayer())
target->CastSpell(target, SPELL_DARK_TOUCHED, true);
}
void Register()
{
AfterHit += SpellHitFn(spell_eredar_twins_apply_dark_touched_SpellScript::HandleApplyTouch);
}
};
SpellScript* GetSpellScript() const
{
return new spell_eredar_twins_apply_dark_touched_SpellScript();
}
};
class spell_eredar_twins_apply_flame_touched : public SpellScriptLoader
{
public:
spell_eredar_twins_apply_flame_touched() : SpellScriptLoader("spell_eredar_twins_apply_flame_touched") { }
class spell_eredar_twins_apply_flame_touched_SpellScript : public SpellScript
{
PrepareSpellScript(spell_eredar_twins_apply_flame_touched_SpellScript);
void HandleApplyTouch()
{
if (Player* target = GetHitPlayer())
target->CastSpell(target, SPELL_FLAME_TOUCHED, true);
}
void Register()
{
AfterHit += SpellHitFn(spell_eredar_twins_apply_flame_touched_SpellScript::HandleApplyTouch);
}
};
SpellScript* GetSpellScript() const
{
return new spell_eredar_twins_apply_flame_touched_SpellScript();
}
};
class spell_eredar_twins_handle_touch : public SpellScriptLoader
{
public:
spell_eredar_twins_handle_touch() : SpellScriptLoader("spell_eredar_twins_handle_touch") { }
class spell_eredar_twins_handle_touch_SpellScript : public SpellScript
{
PrepareSpellScript(spell_eredar_twins_handle_touch_SpellScript);
SpellCastResult CheckCast()
{
if (GetCaster()->HasAura(SPELL_DARK_FLAME))
return SPELL_FAILED_DONT_REPORT;
if (GetSpellInfo()->Id == SPELL_DARK_TOUCHED)
{
if (GetCaster()->HasAura(SPELL_FLAME_TOUCHED))
{
GetCaster()->RemoveAurasDueToSpell(SPELL_FLAME_TOUCHED);
GetCaster()->CastSpell(GetCaster(), SPELL_DARK_FLAME, true);
return SPELL_FAILED_DONT_REPORT;
}
}
else // if (m_spellInfo->Id == SPELL_FLAME_TOUCHED)
{
if (GetCaster()->HasAura(SPELL_DARK_TOUCHED))
{
GetCaster()->RemoveAurasDueToSpell(SPELL_DARK_TOUCHED);
GetCaster()->CastSpell(GetCaster(), SPELL_DARK_FLAME, true);
return SPELL_FAILED_DONT_REPORT;
}
}
return SPELL_CAST_OK;
}
void Register()
{
OnCheckCast += SpellCheckCastFn(spell_eredar_twins_handle_touch_SpellScript::CheckCast);
}
};
SpellScript* GetSpellScript() const
{
return new spell_eredar_twins_handle_touch_SpellScript();
}
};
class spell_eredar_twins_blaze : public SpellScriptLoader
{
public:
spell_eredar_twins_blaze() : SpellScriptLoader("spell_eredar_twins_blaze") { }
class spell_eredar_twins_blaze_SpellScript : public SpellScript
{
PrepareSpellScript(spell_eredar_twins_blaze_SpellScript);
void HandleScript(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
if (Unit* target = GetHitUnit())
target->CastSpell(target, SPELL_BLAZE_SUMMON, true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_eredar_twins_blaze_SpellScript::HandleScript, EFFECT_1, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_eredar_twins_blaze_SpellScript();
}
};
class AreaTrigger_at_sunwell_eredar_twins : public AreaTriggerScript
{
public:
AreaTrigger_at_sunwell_eredar_twins() : AreaTriggerScript("at_sunwell_eredar_twins") {}
bool OnTrigger(Player* player, AreaTriggerEntry const* /*trigger*/)
{
if (InstanceScript* instance = player->GetInstanceScript())
if (instance->GetBossState(DATA_EREDAR_TWINS_INTRO) != DONE)
{
instance->SetBossState(DATA_EREDAR_TWINS_INTRO, DONE);
if (Creature* creature = ObjectAccessor::GetCreature(*player, instance->GetData64(NPC_LADY_SACROLASH)))
creature->AI()->Talk(YELL_INTRO_SAC);
if (Creature* creature = ObjectAccessor::GetCreature(*player, instance->GetData64(NPC_GRAND_WARLOCK_ALYTHESS)))
creature->AI()->Talk(YELL_INTRO_ALY);
}
return true;
}
};
void AddSC_boss_eredar_twins()
{
new boss_sacrolash();
new boss_alythess();
new spell_eredar_twins_apply_dark_touched();
new spell_eredar_twins_apply_flame_touched();
new spell_eredar_twins_handle_touch();
new spell_eredar_twins_blaze();
new AreaTrigger_at_sunwell_eredar_twins();
}

575
src/server/scripts/EasternKingdoms/SunwellPlateau/boss_felmyst.cpp
View File

@@ -1,575 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "GridNotifiers.h"
#include "GridNotifiersImpl.h"
#include "Cell.h"
#include "CellImpl.h"
#include "sunwell_plateau.h"
enum Yells
{
YELL_BIRTH = 0,
YELL_KILL = 1,
YELL_BREATH = 2,
YELL_TAKEOFF = 3,
YELL_BERSERK = 4,
YELL_DEATH = 5,
EMOTE_BREATH = 6
};
enum Spells
{
//Aura
SPELL_NOXIOUS_FUMES = 47002,
//Land phase
SPELL_BERSERK = 45078,
SPELL_CLEAVE = 19983,
SPELL_CORROSION = 45866,
SPELL_GAS_NOVA = 45855,
SPELL_ENCAPSULATE_CHANNEL = 45661,
//Flight phase
SPELL_SUMMON_DEMONIC_VAPOR = 45391,
SPELL_DEMONIC_VAPOR_SPAWN_TRIGGER = 45388, // Triggers visual beam
SPELL_DEMONIC_VAPOR_PERIODIC = 45411, // Spawns cloud and deals damage
SPELL_DEMONIC_VAPOR_TRAIL_PERIODIC = 45399, // periodic of cloud
SPELL_DEMONIC_VAPOR = 45402, // cloud dot
SPELL_SUMMON_BLAZING_DEAD = 45400, // spawns skeletons
SPELL_FELMYST_SPEED_BURST = 45495, // speed burst and breath animation
SPELL_FOG_OF_CORRUPTION = 45582, // trigger cast
SPELL_FOG_OF_CORRUPTION_CHARM = 45717, // charm 1
SPELL_FOG_OF_CORRUPTION_CHARM2 = 45726, // charm 2
};
enum Misc
{
// Land
EVENT_SPELL_BERSERK = 1,
EVENT_SPELL_CLEAVE = 2,
EVENT_SPELL_CORROSION = 3,
EVENT_SPELL_GAS_NOVA = 4,
EVENT_SPELL_ENCAPSULATE = 5,
EVENT_FLIGHT = 6,
EVENT_LAND = 7,
EVENT_RESTORE_COMBAT = 8,
EVENT_RESTORE_COMBAT2 = 9,
// Air
EVENT_FLIGHT_SEQ = 100,
EVENT_FLIGHT_VAPOR = 101,
EVENT_FLIGHT_MOVE_UP = 102,
EVENT_LAND_FIGHT = 103,
EVENT_FLIGHT_EMOTE = 104,
EVENT_FLIGHT_BREATH1 = 105,
EVENT_FLIGHT_BREATH2 = 106,
EVENT_FLIGHT_FLYOVER1 = 107,
EVENT_FLIGHT_FLYOVER2 = 108,
EVENT_CORRUPT_TRIGGERS = 109,
// Intro
EVENT_INTRO_1 = 20,
EVENT_INTRO_2 = 21,
EVENT_INTRO_3 = 22,
EVENT_INTRO_4 = 23,
// Misc
ACTION_START_EVENT = 1,
POINT_GROUND = 1,
POINT_AIR = 2,
POINT_AIR_BREATH_START1 = 3,
POINT_AIR_BREATH_END1 = 4,
POINT_AIR_BREATH_START2 = 5,
POINT_AIR_BREATH_END2 = 6,
POINT_MISC = 7,
NPC_FOG_TRIGGER = 23472
};
class CorruptTriggers : public BasicEvent
{
public:
CorruptTriggers(Unit* caster) : _caster(caster)
{
}
bool Execute(uint64 /*execTime*/, uint32 /*diff*/)
{
std::list<Creature*> cList;
_caster->GetCreaturesWithEntryInRange(cList, 70.0f, NPC_FOG_TRIGGER);
for (std::list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); ++itr)
if (_caster->GetExactDist2d(*itr) <= 11.0f)
(*itr)->CastSpell(*itr, SPELL_FOG_OF_CORRUPTION, true);
return true;
}
private:
Unit* _caster;
};
class boss_felmyst : public CreatureScript
{
public:
boss_felmyst() : CreatureScript("boss_felmyst") { }
struct boss_felmystAI : public BossAI
{
boss_felmystAI(Creature* creature) : BossAI(creature, DATA_FELMYST)
{
bool appear = instance->GetBossState(DATA_BRUTALLUS) == DONE;
creature->SetVisible(appear);
creature->SetStandState(UNIT_STAND_STATE_SLEEP);
creature->SetReactState(REACT_PASSIVE);
}
EventMap events2;
void DoAction(int32 param)
{
if (param == ACTION_START_EVENT)
{
me->SetVisible(true);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
events2.ScheduleEvent(EVENT_INTRO_1, 3000);
}
}
void Reset()
{
BossAI::Reset();
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
me->SetReactState(REACT_PASSIVE);
me->SetDisableGravity(false);
events2.Reset();
instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_FOG_OF_CORRUPTION_CHARM);
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
if (events.Empty() && events2.Empty())
events2.ScheduleEvent(EVENT_INTRO_2, 3000);
}
void KilledUnit(Unit* victim)
{
if (victim->GetTypeId() == TYPEID_PLAYER && roll_chance_i(50))
Talk(YELL_KILL);
}
void JustDied(Unit* killer)
{
BossAI::JustDied(killer);
Talk(YELL_DEATH);
instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_FOG_OF_CORRUPTION_CHARM);
// Summon Kalecgos (human form of kalecgos fight)
me->SummonCreature(NPC_KALEC, 1526.28f, 700.10f, 60.0f, 4.33f);
}
void MovementInform(uint32 type, uint32 point)
{
if (type != POINT_MOTION_TYPE)
return;
if (point == POINT_GROUND)
{
me->HandleEmoteCommand(EMOTE_ONESHOT_LAND);
me->SetDisableGravity(false);
me->SendMovementFlagUpdate();
events.ScheduleEvent(EVENT_RESTORE_COMBAT, 0);
events.ScheduleEvent(EVENT_RESTORE_COMBAT2, 1);
events.ScheduleEvent(EVENT_SPELL_CLEAVE, 7500, 1);
events.ScheduleEvent(EVENT_SPELL_CORROSION, 12000, 1);
events.ScheduleEvent(EVENT_SPELL_GAS_NOVA, 18000, 1);
events.ScheduleEvent(EVENT_SPELL_ENCAPSULATE, 25000, 1);
events.ScheduleEvent(EVENT_FLIGHT, 60000, 1);
}
else if (point == POINT_AIR_BREATH_START1)
{
me->SetTarget(0);
me->SetFacingTo(4.71f);
events.ScheduleEvent(EVENT_FLIGHT_EMOTE, 2000);
events.ScheduleEvent(EVENT_CORRUPT_TRIGGERS, 5000);
events.ScheduleEvent(EVENT_FLIGHT_FLYOVER1, 5000);
}
else if (point == POINT_AIR_BREATH_END1)
{
me->RemoveAurasDueToSpell(SPELL_FELMYST_SPEED_BURST);
me->SetFacingTo(1.57f);
if (events.GetNextEventTime(EVENT_FLIGHT_BREATH1) != 0)
events.ScheduleEvent(EVENT_FLIGHT_BREATH2, 2000);
}
else if (point == POINT_AIR_BREATH_START2)
{
me->SetTarget(0);
me->SetFacingTo(1.57f);
events.ScheduleEvent(EVENT_FLIGHT_EMOTE, 2000);
events.ScheduleEvent(EVENT_CORRUPT_TRIGGERS, 5000);
events.ScheduleEvent(EVENT_FLIGHT_FLYOVER2, 5000);
}
else if (point == POINT_AIR_BREATH_END2)
{
me->RemoveAurasDueToSpell(SPELL_FELMYST_SPEED_BURST);
me->SetFacingTo(4.71f);
}
}
void JustSummoned(Creature* summon)
{
summons.Summon(summon);
}
void UpdateAI(uint32 diff)
{
events2.Update(diff);
switch (events2.ExecuteEvent())
{
case EVENT_INTRO_1:
me->SetStandState(UNIT_STAND_STATE_STAND);
events2.ScheduleEvent(EVENT_INTRO_2, 4000);
break;
case EVENT_INTRO_2:
Talk(YELL_BIRTH);
me->SetDisableGravity(true);
me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
me->SendMovementFlagUpdate();
events2.ScheduleEvent(EVENT_INTRO_3, 1500);
break;
case EVENT_INTRO_3:
me->GetMotionMaster()->MovePoint(POINT_AIR, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()+10.0f, false, true);
events2.ScheduleEvent(EVENT_INTRO_4, 2000);
break;
case EVENT_INTRO_4:
events.ScheduleEvent(EVENT_LAND, 3000, 1);
events.ScheduleEvent(EVENT_SPELL_BERSERK, 600000);
me->SetInCombatWithZone();
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
me->CastSpell(me, SPELL_NOXIOUS_FUMES, true);
me->GetMotionMaster()->MovePoint(POINT_MISC, 1472.18f, 603.38f, 34.0f, false, true);
break;
}
if (!events2.Empty())
return;
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch(events.ExecuteEvent())
{
case EVENT_RESTORE_COMBAT:
me->SetReactState(REACT_AGGRESSIVE);
break;
case EVENT_RESTORE_COMBAT2:
me->SetTarget(me->GetVictim()->GetGUID());
me->GetMotionMaster()->MoveChase(me->GetVictim());
break;
case EVENT_LAND:
me->GetMotionMaster()->MovePoint(POINT_GROUND, me->GetPositionX(), me->GetPositionY(), me->GetMap()->GetHeight(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()), false, true);
break;
case EVENT_SPELL_BERSERK:
Talk(YELL_BERSERK);
me->CastSpell(me, SPELL_BERSERK, true);
break;
case EVENT_SPELL_CLEAVE:
me->CastSpell(me->GetVictim(), SPELL_CLEAVE, false);
events.ScheduleEvent(EVENT_SPELL_CLEAVE, 7500, 1);
break;
case EVENT_SPELL_CORROSION:
me->CastSpell(me->GetVictim(), SPELL_CORROSION, false);
events.ScheduleEvent(EVENT_SPELL_CORROSION, 20000, 1);
break;
case EVENT_SPELL_GAS_NOVA:
DoCast(me, SPELL_GAS_NOVA, false);
events.ScheduleEvent(EVENT_SPELL_GAS_NOVA, 20000, 1);
break;
case EVENT_SPELL_ENCAPSULATE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f, true))
me->CastSpell(target, SPELL_ENCAPSULATE_CHANNEL, false);
events.ScheduleEvent(EVENT_SPELL_ENCAPSULATE, 25000, 1);
break;
case EVENT_FLIGHT:
events.CancelEventGroup(1);
events.ScheduleEvent(EVENT_FLIGHT_SEQ, 1000);
me->SetReactState(REACT_PASSIVE);
me->StopMoving();
me->GetMotionMaster()->Clear();
break;
case EVENT_FLIGHT_SEQ:
Talk(YELL_TAKEOFF);
me->SetTarget(0);
me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
me->SetDisableGravity(true);
me->SendMovementFlagUpdate();
events.ScheduleEvent(EVENT_FLIGHT_MOVE_UP, 2000);
events.ScheduleEvent(EVENT_FLIGHT_VAPOR, 8000);
events.ScheduleEvent(EVENT_FLIGHT_VAPOR, 21000);
events.ScheduleEvent(EVENT_FLIGHT_BREATH1, 35000);
events.ScheduleEvent(EVENT_FLIGHT_BREATH1, 72000);
events.ScheduleEvent(EVENT_LAND_FIGHT, 86000);
break;
case EVENT_FLIGHT_MOVE_UP:
me->GetMotionMaster()->MovePoint(POINT_AIR, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()+15.0f, false, true);
break;
case EVENT_FLIGHT_VAPOR:
me->CastSpell(me, SPELL_SUMMON_DEMONIC_VAPOR, true);
break;
case EVENT_FLIGHT_BREATH1:
{
Position pos = {1447.0f + urand(0, 2)*25.0f, 705.0f, 50.0f, 4.71f};
me->GetMotionMaster()->MovePoint(POINT_AIR_BREATH_START1, pos, false, true);
break;
}
case EVENT_FLIGHT_BREATH2:
{
Position pos = {1447.0f + urand(0, 2)*25.0f, 515.0f, 50.0f, 1.57f};
me->GetMotionMaster()->MovePoint(POINT_AIR_BREATH_START2, pos, false, true);
break;
}
case EVENT_FLIGHT_EMOTE:
Talk(EMOTE_BREATH);
break;
case EVENT_CORRUPT_TRIGGERS:
me->m_Events.AddEvent(new CorruptTriggers(me), me->m_Events.CalculateTime(0));
me->m_Events.AddEvent(new CorruptTriggers(me), me->m_Events.CalculateTime(500));
me->m_Events.AddEvent(new CorruptTriggers(me), me->m_Events.CalculateTime(1000));
me->m_Events.AddEvent(new CorruptTriggers(me), me->m_Events.CalculateTime(1500));
me->m_Events.AddEvent(new CorruptTriggers(me), me->m_Events.CalculateTime(2000));
me->m_Events.AddEvent(new CorruptTriggers(me), me->m_Events.CalculateTime(2500));
me->m_Events.AddEvent(new CorruptTriggers(me), me->m_Events.CalculateTime(3000));
me->m_Events.AddEvent(new CorruptTriggers(me), me->m_Events.CalculateTime(3500));
me->m_Events.AddEvent(new CorruptTriggers(me), me->m_Events.CalculateTime(4000));
break;
case EVENT_FLIGHT_FLYOVER1:
me->CastSpell(me, SPELL_FELMYST_SPEED_BURST, true);
me->GetMotionMaster()->MovePoint(POINT_AIR_BREATH_END1, me->GetPositionX(), me->GetPositionY()-200.0f, me->GetPositionZ()+5.0f, false, true);
break;
case EVENT_FLIGHT_FLYOVER2:
me->CastSpell(me, SPELL_FELMYST_SPEED_BURST, true);
me->GetMotionMaster()->MovePoint(POINT_AIR_BREATH_END2, me->GetPositionX(), me->GetPositionY()+200.0f, me->GetPositionZ()+5.0f, false, true);
break;
case EVENT_LAND_FIGHT:
me->GetMotionMaster()->MovePoint(POINT_GROUND, 1500.0f, 552.8f, 26.52f, false, true);
break;
}
if (!me->HasUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY))
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_felmystAI>(creature);
}
};
class npc_demonic_vapor : public CreatureScript
{
public:
npc_demonic_vapor() : CreatureScript("npc_demonic_vapor") { }
CreatureAI* GetAI(Creature* creature) const
{
return new npc_demonic_vaporAI(creature);
}
struct npc_demonic_vaporAI : public NullCreatureAI
{
npc_demonic_vaporAI(Creature* creature) : NullCreatureAI(creature) { }
void Reset()
{
me->CastSpell(me, SPELL_DEMONIC_VAPOR_SPAWN_TRIGGER, true);
me->CastSpell(me, SPELL_DEMONIC_VAPOR_PERIODIC, true);
}
void UpdateAI(uint32 diff)
{
if (me->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_CONTROLLED) == NULL_MOTION_TYPE)
{
Map::PlayerList const& players = me->GetMap()->GetPlayers();
for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
if (me->GetDistance2d(itr->GetSource()) < 20.0f && itr->GetSource()->IsAlive())
{
me->GetMotionMaster()->MoveFollow(itr->GetSource(), 0.0f, 0.0f, MOTION_SLOT_CONTROLLED);
break;
}
}
}
};
};
class npc_demonic_vapor_trail : public CreatureScript
{
public:
npc_demonic_vapor_trail() : CreatureScript("npc_demonic_vapor_trail") { }
CreatureAI* GetAI(Creature* creature) const
{
return new npc_demonic_vapor_trailAI(creature);
}
struct npc_demonic_vapor_trailAI : public NullCreatureAI
{
npc_demonic_vapor_trailAI(Creature* creature) : NullCreatureAI(creature)
{
timer = 1;
}
uint32 timer;
void Reset()
{
me->CastSpell(me, SPELL_DEMONIC_VAPOR_TRAIL_PERIODIC, true);
}
void SpellHitTarget(Unit* , const SpellInfo* spellInfo)
{
if (spellInfo->Id == SPELL_DEMONIC_VAPOR)
me->CastSpell(me, SPELL_SUMMON_BLAZING_DEAD, true);
}
void UpdateAI(uint32 diff)
{
if (timer)
{
timer += diff;
if (timer >= 6000)
{
timer = 0;
me->CastSpell(me, SPELL_SUMMON_BLAZING_DEAD, true);
}
}
}
void JustSummoned(Creature* summon)
{
summon->SetInCombatWithZone();
summon->AI()->AttackStart(summon->AI()->SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f));
}
};
};
class spell_felmyst_fog_of_corruption : public SpellScriptLoader
{
public:
spell_felmyst_fog_of_corruption() : SpellScriptLoader("spell_felmyst_fog_of_corruption") { }
class spell_felmyst_fog_of_corruption_SpellScript : public SpellScript
{
PrepareSpellScript(spell_felmyst_fog_of_corruption_SpellScript);
void HandleScriptEffect(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
if (Unit* target = GetHitUnit())
target->CastSpell(GetCaster(), SPELL_FOG_OF_CORRUPTION_CHARM, true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_felmyst_fog_of_corruption_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_felmyst_fog_of_corruption_SpellScript();
}
};
class spell_felmyst_fog_of_corruption_charm : public SpellScriptLoader
{
public:
spell_felmyst_fog_of_corruption_charm() : SpellScriptLoader("spell_felmyst_fog_of_corruption_charm") { }
class spell_felmyst_fog_of_corruption_charm_AuraScript : public AuraScript
{
PrepareAuraScript(spell_felmyst_fog_of_corruption_charm_AuraScript);
void HandleApply(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
GetTarget()->CastSpell(GetTarget(), SPELL_FOG_OF_CORRUPTION_CHARM2, true);
}
void HandleRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
GetTarget()->RemoveAurasDueToSpell(SPELL_FOG_OF_CORRUPTION_CHARM2);
Unit::Kill(GetCaster(), GetTarget(), false);
}
void Register()
{
OnEffectApply += AuraEffectApplyFn(spell_felmyst_fog_of_corruption_charm_AuraScript::HandleApply, EFFECT_0, SPELL_AURA_AOE_CHARM, AURA_EFFECT_HANDLE_REAL);
OnEffectRemove += AuraEffectRemoveFn(spell_felmyst_fog_of_corruption_charm_AuraScript::HandleRemove, EFFECT_0, SPELL_AURA_AOE_CHARM, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_felmyst_fog_of_corruption_charm_AuraScript();
}
};
class DoorsGuidCheck
{
public:
bool operator()(WorldObject* object) const
{
if (object->GetTypeId() != TYPEID_UNIT)
return true;
Creature* cr = object->ToCreature();
return cr->GetDBTableGUIDLow() != 54780 && cr->GetDBTableGUIDLow() != 54787 && cr->GetDBTableGUIDLow() != 54801;
}
};
class spell_felmyst_open_brutallus_back_doors : public SpellScriptLoader
{
public:
spell_felmyst_open_brutallus_back_doors() : SpellScriptLoader("spell_felmyst_open_brutallus_back_doors") { }
class spell_felmyst_open_brutallus_back_doors_SpellScript : public SpellScript
{
PrepareSpellScript(spell_felmyst_open_brutallus_back_doors_SpellScript);
void FilterTargets(std::list<WorldObject*>& unitList)
{
unitList.remove_if(DoorsGuidCheck());
}
void Register()
{
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_felmyst_open_brutallus_back_doors_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_felmyst_open_brutallus_back_doors_SpellScript();
}
};
void AddSC_boss_felmyst()
{
new boss_felmyst();
new npc_demonic_vapor();
new npc_demonic_vapor_trail();
new spell_felmyst_fog_of_corruption();
new spell_felmyst_fog_of_corruption_charm();
new spell_felmyst_open_brutallus_back_doors();
}

764
src/server/scripts/EasternKingdoms/SunwellPlateau/boss_kalecgos.cpp
View File

@@ -1,764 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "sunwell_plateau.h"
#include "Player.h"
#include "WorldSession.h"
enum Yells
{
SAY_SATH_AGGRO = 0,
SAY_SATH_SLAY = 1,
SAY_SATH_DEATH = 2,
SAY_SATH_SPELL1 = 3,
SAY_SATH_SPELL2 = 4,
SAY_EVIL_AGGRO = 0,
SAY_EVIL_SLAY = 1,
SAY_GOOD_PLRWIN = 2,
SAY_EVIL_ENRAGE = 3,
SAY_SATH_ENRAGE_ME = 4,
SAY_KALEC_ENRAGE_SATH = 5,
SAY_GOOD_AGGRO = 0,
SAY_GOOD_NEAR_DEATH = 1,
SAY_GOOD_NEAR_DEATH2 = 2,
SAY_GOOD_MADRIGOSA = 3
};
enum Spells
{
SPELL_SPECTRAL_EXHAUSTION = 44867,
SPELL_SPECTRAL_BLAST = 44869,
SPELL_SPECTRAL_BLAST_PORTAL = 44866,
SPELL_SPECTRAL_BLAST_AA = 46648,
SPELL_TELEPORT_SPECTRAL = 46019,
SPELL_TELEPORT_NORMAL_REALM = 46020,
SPELL_SPECTRAL_REALM = 46021,
SPELL_SPECTRAL_INVISIBILITY = 44801,
SPELL_DEMONIC_VISUAL = 44800,
SPELL_ARCANE_BUFFET = 45018,
SPELL_FROST_BREATH = 44799,
SPELL_TAIL_LASH = 45122,
SPELL_BANISH = 44836,
SPELL_TRANSFORM_KALEC = 44670,
SPELL_CRAZED_RAGE = 44807,
SPELL_CORRUPTION_STRIKE = 45029,
SPELL_CURSE_OF_BOUNDLESS_AGONY = 45032,
SPELL_CURSE_OF_BOUNDLESS_AGONY_PLR = 45034,
SPELL_SHADOW_BOLT = 45031,
SPELL_HEROIC_STRIKE = 45026,
SPELL_REVITALIZE = 45027
};
enum SWPActions
{
ACTION_ENRAGE = 1,
ACTION_BANISH = 2,
ACTION_SATH_BANISH = 3,
ACTION_KALEC_DIED = 4,
ACTION_ENRAGE_OTHER = 5,
};
enum kalEvents
{
EVENT_ARCANE_BUFFET = 1,
EVENT_FROST_BREATH = 2,
EVENT_WILD_MAGIC = 3,
EVENT_TAIL_LASH = 4,
EVENT_SPECTRAL_BLAST = 5,
EVENT_CHECK_HEALTH = 6,
EVENT_CHECK_HEALTH2 = 7,
EVENT_CHECK_POS = 8,
EVENT_SPAWN_SPECTRALS = 9,
EVENT_SPELL_REVITALIZE = 10,
EVENT_SPELL_HEROIC_STRIKE = 11,
EVENT_SHADOW_BOLT = 12,
EVENT_AGONY_CURSE = 13,
EVENT_CORRUPTION_STRIKE = 14,
EVENT_TALK_GOOD_1 = 20,
EVENT_TALK_GOOD_2 = 21,
EVENT_TALK_GOOD_3 = 22,
EVENT_TALK_GOOD_4 = 23,
EVENT_TALK_GOOD_5 = 24,
EVENT_TALK_BAD_1 = 25,
EVENT_TALK_BAD_2 = 26,
EVENT_TALK_BAD_3 = 27
};
#define DRAGON_REALM_Z 53.079f
class boss_kalecgos : public CreatureScript
{
public:
boss_kalecgos() : CreatureScript("boss_kalecgos") { }
struct boss_kalecgosAI : public BossAI
{
boss_kalecgosAI(Creature* creature) : BossAI(creature, DATA_KALECGOS)
{
}
bool sathBanished;
EventMap events2;
bool CanAIAttack(Unit const* target) const
{
return target->GetPositionZ() > 50.0f;
}
void JustReachedHome()
{
BossAI::JustReachedHome();
me->SetVisible(true);
}
void Reset()
{
BossAI::Reset();
me->SetHealth(me->GetMaxHealth());
me->SetStandState(UNIT_STAND_STATE_SLEEP);
me->SetDisableGravity(false);
me->SetReactState(REACT_AGGRESSIVE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE + UNIT_FLAG_NOT_SELECTABLE);
events2.Reset();
sathBanished = false;
ClearPlayerAuras();
}
void ClearPlayerAuras() const
{
instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_CURSE_OF_BOUNDLESS_AGONY);
instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_CURSE_OF_BOUNDLESS_AGONY_PLR);
instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_SPECTRAL_REALM);
}
void DoAction(int32 param)
{
if (param == ACTION_ENRAGE || param == ACTION_ENRAGE_OTHER)
{
Talk(param == ACTION_ENRAGE ? SAY_KALEC_ENRAGE_SATH : SAY_SATH_ENRAGE_ME);
me->CastSpell(me, SPELL_CRAZED_RAGE, true);
events.CancelEvent(EVENT_CHECK_HEALTH);
return;
}
else if (param == ACTION_BANISH)
{
me->CastSpell(me, SPELL_BANISH, true);
events.Reset();
}
else if (param == ACTION_SATH_BANISH)
sathBanished = true;
else if (param == ACTION_KALEC_DIED)
{
events.Reset();
events2.ScheduleEvent(EVENT_TALK_BAD_1, 0);
ClearPlayerAuras();
return;
}
if (me->HasAura(SPELL_BANISH) && sathBanished)
{
events.Reset();
events2.ScheduleEvent(EVENT_TALK_GOOD_1, 1000);
ClearPlayerAuras();
if (Creature* Sath = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_SATHROVARR)))
{
Sath->RemoveAllAuras();
Sath->GetMotionMaster()->MovementExpired();
Sath->SetReactState(REACT_PASSIVE);
Sath->NearTeleportTo(1696.20f, 915.0f, DRAGON_REALM_Z, Sath->GetOrientation());
}
}
}
void JustDied(Unit* who)
{
BossAI::JustDied(who);
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
events.ScheduleEvent(EVENT_ARCANE_BUFFET, 6000);
events.ScheduleEvent(EVENT_FROST_BREATH, 15000);
events.ScheduleEvent(EVENT_WILD_MAGIC, 10000);
events.ScheduleEvent(EVENT_TAIL_LASH, 25000);
events.ScheduleEvent(EVENT_SPECTRAL_BLAST, 20000);
events.ScheduleEvent(EVENT_CHECK_POS, 5000);
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
events.ScheduleEvent(EVENT_CHECK_HEALTH2, 1000);
events.ScheduleEvent(EVENT_SPAWN_SPECTRALS, 16000);
me->SetStandState(UNIT_STAND_STATE_STAND);
Talk(SAY_EVIL_AGGRO);
}
void DamageTaken(Unit* attacker, uint32& damage, DamageEffectType, SpellSchoolMask)
{
if (damage >= me->GetHealth() && attacker != me)
damage = 0;
}
void KilledUnit(Unit* victim)
{
if (victim->GetTypeId() == TYPEID_PLAYER && roll_chance_i(50))
Talk(SAY_EVIL_SLAY);
}
void UpdateAI(uint32 diff)
{
events2.Update(diff);
switch (events2.ExecuteEvent())
{
case EVENT_TALK_GOOD_1:
me->SetRegeneratingHealth(false);
me->RemoveAllAuras();
me->SetReactState(REACT_PASSIVE);
me->CombatStop();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
me->setFaction(35);
events2.ScheduleEvent(EVENT_TALK_GOOD_2, 1000);
break;
case EVENT_TALK_GOOD_2:
if (Creature* Sath = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_SATHROVARR)))
{
summons.Despawn(Sath);
Unit::Kill(me, Sath);
}
events2.ScheduleEvent(EVENT_TALK_GOOD_3, 8000);
break;
case EVENT_TALK_GOOD_3:
Talk(SAY_GOOD_PLRWIN);
events2.ScheduleEvent(EVENT_TALK_GOOD_4, 10000);
break;
case EVENT_TALK_GOOD_4:
me->SetDisableGravity(true);
me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
events2.ScheduleEvent(EVENT_TALK_GOOD_5, 10000);
break;
case EVENT_TALK_GOOD_5:
me->SetVisible(false);
Unit::Kill(me, me);
break;
case EVENT_TALK_BAD_1:
me->SetReactState(REACT_PASSIVE);
me->CombatStop();
me->RemoveAllAuras();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
Talk(SAY_EVIL_ENRAGE);
events2.ScheduleEvent(EVENT_TALK_BAD_2, 3000);
break;
case EVENT_TALK_BAD_2:
me->SetDisableGravity(true);
me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
events2.ScheduleEvent(EVENT_TALK_BAD_3, 15000);
break;
case EVENT_TALK_BAD_3:
me->SetVisible(false);
EnterEvadeMode();
break;
}
if (!events2.Empty())
return;
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPAWN_SPECTRALS:
me->SummonCreature(NPC_KALEC, 1702.21f, 931.7f, -74.56f, 5.07f, TEMPSUMMON_MANUAL_DESPAWN);
me->SummonCreature(NPC_SATHROVARR, 1704.62f, 927.78f, -73.9f, 2.0f, TEMPSUMMON_MANUAL_DESPAWN);
break;
case EVENT_ARCANE_BUFFET:
me->CastSpell(me, SPELL_ARCANE_BUFFET, false);
events.ScheduleEvent(EVENT_ARCANE_BUFFET, 8000);
break;
case EVENT_FROST_BREATH:
me->CastSpell(me->GetVictim(), SPELL_FROST_BREATH, false);
events.ScheduleEvent(EVENT_FROST_BREATH, 15000);
break;
case EVENT_TAIL_LASH:
me->CastSpell(me->GetVictim(), SPELL_TAIL_LASH, false);
events.ScheduleEvent(EVENT_TAIL_LASH, 15000);
break;
case EVENT_WILD_MAGIC:
me->CastCustomSpell(RAND(44978, 45001, 45002, 45004, 45006, 45010), SPELLVALUE_MAX_TARGETS, 1, me, false);
events.ScheduleEvent(EVENT_WILD_MAGIC, 20000);
break;
case EVENT_SPECTRAL_BLAST:
me->CastSpell(me, SPELL_SPECTRAL_BLAST, false);
events.ScheduleEvent(EVENT_SPECTRAL_BLAST, urand(15000, 25000));
break;
case EVENT_CHECK_POS:
if (me->GetDistance(me->GetHomePosition()) > 50.0f)
{
EnterEvadeMode();
return;
}
events.ScheduleEvent(EVENT_CHECK_POS, 5000);
break;
case EVENT_CHECK_HEALTH:
if (me->HealthBelowPct(10))
{
if (Creature* Sath = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_SATHROVARR)))
Sath->AI()->DoAction(ACTION_ENRAGE_OTHER);
DoAction(ACTION_ENRAGE);
break;
}
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
break;
case EVENT_CHECK_HEALTH2:
if (me->HealthBelowPct(1))
{
DoAction(ACTION_BANISH);
break;
}
events.ScheduleEvent(EVENT_CHECK_HEALTH2, 1000);
break;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_kalecgosAI>(creature);
}
};
enum Kalec
{
SPELL_OPEN_BRUTALLUS_BACK_DOOR = 46650,
MODEL_KALECGOS_DRAGON = 23487,
EVENT_KALEC_SCENE_1 = 101,
EVENT_KALEC_SCENE_2 = 102,
EVENT_KALEC_SCENE_3 = 103
};
class boss_kalec : public CreatureScript
{
public:
boss_kalec() : CreatureScript("boss_kalec") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_kalecAI>(creature);
}
struct boss_kalecAI : public ScriptedAI
{
boss_kalecAI(Creature* creature) : ScriptedAI(creature) { }
EventMap events;
EventMap events2;
void Reset()
{
events.Reset();
events2.Reset();
if (me->GetPositionY() < 750.0f)
{
me->SetSpeed(MOVE_RUN, 2.4f);
me->SetDisplayId(MODEL_KALECGOS_DRAGON);
me->SetDisableGravity(true);
me->GetMotionMaster()->MovePoint(0, 1483.30f, 657.99f, 28.0f, false, true);
events2.ScheduleEvent(EVENT_KALEC_SCENE_1, 9000);
events2.ScheduleEvent(EVENT_KALEC_SCENE_2, 16000);
events2.ScheduleEvent(EVENT_KALEC_SCENE_3, 22000);
}
else
me->CastSpell(me, SPELL_SPECTRAL_INVISIBILITY, true);
}
void DamageTaken(Unit* who, uint32& damage, DamageEffectType, SpellSchoolMask)
{
if (!who || who->GetEntry() != NPC_SATHROVARR)
damage = 0;
}
void EnterCombat(Unit*)
{
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
events.ScheduleEvent(EVENT_CHECK_HEALTH2, 1000);
events.ScheduleEvent(EVENT_SPELL_REVITALIZE, 5000);
events.ScheduleEvent(EVENT_SPELL_HEROIC_STRIKE, 3000);
Talk(SAY_GOOD_AGGRO);
}
void JustDied(Unit*)
{
if (InstanceScript* instance = me->GetInstanceScript())
if (Creature* kalecgos = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_KALECGOS)))
kalecgos->AI()->DoAction(ACTION_KALEC_DIED);
}
void UpdateAI(uint32 diff)
{
events2.Update(diff);
switch (events2.ExecuteEvent())
{
case EVENT_KALEC_SCENE_1:
Talk(SAY_GOOD_MADRIGOSA);
me->GetMotionMaster()->MovePoint(0, 1509.0f, 560.0f, 30.0f, false, true);
break;
case EVENT_KALEC_SCENE_2:
me->CastSpell(me, SPELL_OPEN_BRUTALLUS_BACK_DOOR, true);
me->GetInstanceScript()->SetBossState(DATA_FELMYST_DOORS, NOT_STARTED);
me->GetInstanceScript()->SetBossState(DATA_FELMYST_DOORS, DONE);
break;
case EVENT_KALEC_SCENE_3:
me->GetMotionMaster()->MovePoint(0, 1400.0f, 630.0f, 90.0f, false, true);
me->DespawnOrUnsummon(6000);
break;
}
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_CHECK_HEALTH:
if (me->HealthBelowPct(50))
{
Talk(SAY_GOOD_NEAR_DEATH);
break;
}
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
break;
case EVENT_CHECK_HEALTH2:
if (me->HealthBelowPct(10))
{
Talk(SAY_GOOD_NEAR_DEATH2);
break;
}
events.ScheduleEvent(EVENT_CHECK_HEALTH2, 1000);
break;
case EVENT_SPELL_REVITALIZE:
me->CastSpell(me, SPELL_REVITALIZE, false);
events.ScheduleEvent(EVENT_SPELL_REVITALIZE, 10000);
break;
case EVENT_SPELL_HEROIC_STRIKE:
me->CastSpell(me->GetVictim(), SPELL_HEROIC_STRIKE, false);
events.ScheduleEvent(EVENT_SPELL_HEROIC_STRIKE, 5000);
break;
}
DoMeleeAttackIfReady();
}
};
};
class boss_sathrovarr : public CreatureScript
{
public:
boss_sathrovarr() : CreatureScript("boss_sathrovarr") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_sathrovarrAI>(creature);
}
struct boss_sathrovarrAI : public ScriptedAI
{
boss_sathrovarrAI(Creature* creature) : ScriptedAI(creature)
{
instance = creature->GetInstanceScript();
}
InstanceScript* instance;
EventMap events;
bool CanAIAttack(Unit const* target) const
{
return target->GetPositionZ() < 50.0f;
}
void Reset()
{
events.Reset();
me->CastSpell(me, SPELL_DEMONIC_VISUAL, true);
me->CastSpell(me, SPELL_SPECTRAL_INVISIBILITY, true);
events.ScheduleEvent(EVENT_SHADOW_BOLT, 7000);
events.ScheduleEvent(EVENT_AGONY_CURSE, 20000);
events.ScheduleEvent(EVENT_CORRUPTION_STRIKE, 13000);
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
events.ScheduleEvent(EVENT_CHECK_HEALTH2, 1000);
}
void EnterCombat(Unit* /*who*/)
{
Talk(SAY_SATH_AGGRO);
}
void DamageTaken(Unit* who, uint32& damage, DamageEffectType, SpellSchoolMask)
{
if (damage >= me->GetHealth() && who != me)
damage = 0;
}
void KilledUnit(Unit* target)
{
if (target->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SATH_SLAY);
}
void JustDied(Unit* /*killer*/)
{
Talk(SAY_SATH_DEATH);
}
void DoAction(int32 param)
{
if (param == ACTION_ENRAGE || param == ACTION_ENRAGE_OTHER)
{
me->CastSpell(me, SPELL_CRAZED_RAGE, true);
events.CancelEvent(EVENT_CHECK_HEALTH);
}
else if (param == ACTION_BANISH)
{
me->CastSpell(me, SPELL_BANISH, true);
events.Reset();
}
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SHADOW_BOLT:
if (roll_chance_i(20))
Talk(SAY_SATH_SPELL1);
me->CastSpell(me->GetVictim(), SPELL_SHADOW_BOLT, false);
events.ScheduleEvent(EVENT_SHADOW_BOLT, 9000);
break;
case EVENT_AGONY_CURSE:
me->CastCustomSpell(SPELL_CURSE_OF_BOUNDLESS_AGONY, SPELLVALUE_MAX_TARGETS, 1, me, false);
events.ScheduleEvent(EVENT_AGONY_CURSE, 30000);
break;
case EVENT_CORRUPTION_STRIKE:
if (roll_chance_i(20))
Talk(SAY_SATH_SPELL2);
me->CastSpell(me->GetVictim(), SPELL_CORRUPTION_STRIKE, false);
events.ScheduleEvent(EVENT_CORRUPTION_STRIKE, 9000);
break;
case EVENT_CHECK_HEALTH:
if (me->HealthBelowPct(10))
{
if (InstanceScript* instance = me->GetInstanceScript())
if (Creature* kalecgos = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_KALECGOS)))
kalecgos->AI()->DoAction(ACTION_ENRAGE_OTHER);
DoAction(ACTION_ENRAGE);
break;
}
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
break;
case EVENT_CHECK_HEALTH2:
if (me->HealthBelowPct(1))
{
if (Creature* kalecgos = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_KALECGOS)))
kalecgos->AI()->DoAction(ACTION_SATH_BANISH);
DoAction(ACTION_BANISH);
break;
}
events.ScheduleEvent(EVENT_CHECK_HEALTH2, 1000);
break;
}
DoMeleeAttackIfReady();
}
};
};
class SpectralBlastCheck
{
public:
SpectralBlastCheck(Unit* victim) : _victim(victim) { }
bool operator()(WorldObject* unit)
{
return unit->GetPositionZ() < 50.0f || unit->ToUnit()->HasAura(SPELL_SPECTRAL_EXHAUSTION) || unit->GetGUID() == _victim->GetGUID();
}
private:
Unit* _victim;
};
class spell_kalecgos_spectral_blast_dummy : public SpellScriptLoader
{
public:
spell_kalecgos_spectral_blast_dummy() : SpellScriptLoader("spell_kalecgos_spectral_blast_dummy") { }
class spell_kalecgos_spectral_blast_dummy_SpellScript : public SpellScript
{
PrepareSpellScript(spell_kalecgos_spectral_blast_dummy_SpellScript);
void FilterTargets(std::list<WorldObject*>& targets)
{
targets.remove_if(SpectralBlastCheck(GetCaster()->GetVictim()));
Trinity::Containers::RandomResizeList(targets, 1);
}
void HandleDummy(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
if (Unit* target = GetHitUnit())
{
target->CastSpell(target, SPELL_SPECTRAL_BLAST_PORTAL, true);
target->CastSpell(target, SPELL_SPECTRAL_BLAST_AA, true);
target->CastSpell(target, SPELL_TELEPORT_SPECTRAL, true);
}
}
void Register()
{
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_kalecgos_spectral_blast_dummy_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
OnEffectHitTarget += SpellEffectFn(spell_kalecgos_spectral_blast_dummy_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_kalecgos_spectral_blast_dummy_SpellScript();
}
};
class spell_kalecgos_curse_of_boundless_agony : public SpellScriptLoader
{
public:
spell_kalecgos_curse_of_boundless_agony() : SpellScriptLoader("spell_kalecgos_curse_of_boundless_agony") { }
class spell_kalecgos_curse_of_boundless_agony_AuraScript : public AuraScript
{
PrepareAuraScript(spell_kalecgos_curse_of_boundless_agony_AuraScript);
void OnRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
if (InstanceScript* instance = GetUnitOwner()->GetInstanceScript())
if (instance->IsEncounterInProgress())
GetUnitOwner()->CastCustomSpell(SPELL_CURSE_OF_BOUNDLESS_AGONY_PLR, SPELLVALUE_MAX_TARGETS, 1, GetUnitOwner(), true);
}
void OnPeriodic(AuraEffect const* aurEff)
{
if (aurEff->GetTickNumber() > 1 && aurEff->GetTickNumber()%5 == 1)
GetAura()->GetEffect(aurEff->GetEffIndex())->SetAmount(aurEff->GetAmount()*2);
}
void Register()
{
AfterEffectRemove += AuraEffectRemoveFn(spell_kalecgos_curse_of_boundless_agony_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE, AURA_EFFECT_HANDLE_REAL);
OnEffectPeriodic += AuraEffectPeriodicFn(spell_kalecgos_curse_of_boundless_agony_AuraScript::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
}
};
AuraScript* GetAuraScript() const
{
return new spell_kalecgos_curse_of_boundless_agony_AuraScript();
}
};
class spell_kalecgos_spectral_realm_dummy : public SpellScriptLoader
{
public:
spell_kalecgos_spectral_realm_dummy() : SpellScriptLoader("spell_kalecgos_spectral_realm_dummy") { }
class spell_kalecgos_spectral_realm_dummy_SpellScript : public SpellScript
{
PrepareSpellScript(spell_kalecgos_spectral_realm_dummy_SpellScript);
SpellCastResult CheckCast()
{
if (GetCaster()->HasAura(SPELL_SPECTRAL_EXHAUSTION))
return SPELL_FAILED_CASTER_AURASTATE;
return SPELL_CAST_OK;
}
void HandleScriptEffect(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
GetCaster()->CastSpell(GetCaster(), SPELL_TELEPORT_SPECTRAL, true);
}
void Register()
{
OnCheckCast += SpellCheckCastFn(spell_kalecgos_spectral_realm_dummy_SpellScript::CheckCast);
OnEffectHitTarget += SpellEffectFn(spell_kalecgos_spectral_realm_dummy_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_kalecgos_spectral_realm_dummy_SpellScript();
}
};
class spell_kalecgos_spectral_realm : public SpellScriptLoader
{
public:
spell_kalecgos_spectral_realm() : SpellScriptLoader("spell_kalecgos_spectral_realm") { }
class spell_kalecgos_spectral_realm_AuraScript : public AuraScript
{
PrepareAuraScript(spell_kalecgos_spectral_realm_AuraScript);
void OnRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SPECTRAL_EXHAUSTION, true);
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_TELEPORT_NORMAL_REALM, true);
}
void Register()
{
OnEffectRemove += AuraEffectRemoveFn(spell_kalecgos_spectral_realm_AuraScript::OnRemove, EFFECT_1, SPELL_AURA_MOD_INVISIBILITY, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_kalecgos_spectral_realm_AuraScript();
}
};
void AddSC_boss_kalecgos()
{
new boss_kalecgos();
new boss_sathrovarr();
new boss_kalec();
new spell_kalecgos_spectral_blast_dummy();
new spell_kalecgos_curse_of_boundless_agony();
new spell_kalecgos_spectral_realm_dummy();
new spell_kalecgos_spectral_realm();
}

1333
src/server/scripts/EasternKingdoms/SunwellPlateau/boss_kiljaeden.cpp
View File

File diff suppressed because it is too large Load Diff

506
src/server/scripts/EasternKingdoms/SunwellPlateau/boss_muru.cpp
View File

@@ -1,506 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "sunwell_plateau.h"
#include "Player.h"
#include "SpellInfo.h"
enum Spells
{
SPELL_ENRAGE = 26662,
SPELL_NEGATIVE_ENERGY = 46009,
SPELL_SUMMON_BLOOD_ELVES_PERIODIC = 46041,
SPELL_OPEN_PORTAL_PERIODIC = 45994,
SPELL_DARKNESS_PERIODIC = 45998,
SPELL_SUMMON_BERSERKER1 = 46037,
SPELL_SUMMON_FURY_MAGE1 = 46038,
SPELL_SUMMON_FURY_MAGE2 = 46039,
SPELL_SUMMON_BERSERKER2 = 46040,
SPELL_SUMMON_DARK_FIEND = 46000, // till 46007
SPELL_OPEN_ALL_PORTALS = 46177,
SPELL_SUMMON_ENTROPIUS = 46217,
// Entropius's spells
SPELL_ENTROPIUS_COSMETIC_SPAWN = 46223,
SPELL_NEGATIVE_ENERGY_PERIODIC = 46284,
SPELL_NEGATIVE_ENERGY_CHAIN = 46285,
SPELL_BLACK_HOLE = 46282,
SPELL_DARKNESS = 46268,
SPELL_SUMMON_DARK_FIEND_ENTROPIUS = 46263,
//Black Hole Spells
SPELL_BLACK_HOLE_SUMMON_VISUAL = 46242,
SPELL_BLACK_HOLE_SUMMON_VISUAL2 = 46248,
SPELL_BLACK_HOLE_VISUAL2 = 46235,
SPELL_BLACK_HOLE_PASSIVE = 46228,
SPELL_BLACK_HOLE_EFFECT = 46230
};
enum Misc
{
EVENT_SPELL_ENRAGE = 1,
EVENT_SUMMON_ENTROPIUS = 2,
EVENT_SET_INVISIBLE = 3,
EVENT_SPAWN_BLACK_HOLE = 4,
EVENT_SPAWN_DARKNESS = 5,
EVENT_START_BLACK_HOLE = 6,
EVENT_SWITCH_BLACK_HOLE_TARGET = 7,
EVENT_ENTROPIUS_AURAS = 8,
EVENT_ENTROPIUS_COMBAT = 9,
EVENT_SINGULARITY_DEATH = 10,
DATA_ENRAGE_TIMER = 1,
DATA_NEGATIVE_ENERGY_TARGETS = 2
};
class boss_muru : public CreatureScript
{
public:
boss_muru() : CreatureScript("boss_muru") { }
struct boss_muruAI : public BossAI
{
boss_muruAI(Creature* creature) : BossAI(creature, DATA_MURU) { }
void Reset()
{
BossAI::Reset();
me->SetReactState(REACT_AGGRESSIVE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetVisible(true);
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
me->CastSpell(me, SPELL_NEGATIVE_ENERGY, true);
me->CastSpell(me, SPELL_SUMMON_BLOOD_ELVES_PERIODIC, true);
me->CastSpell(me, SPELL_OPEN_PORTAL_PERIODIC, true);
me->CastSpell(me, SPELL_DARKNESS_PERIODIC, true);
events.ScheduleEvent(EVENT_SPELL_ENRAGE, 600000);
}
void DamageTaken(Unit*, uint32 &damage, DamageEffectType, SpellSchoolMask)
{
if (damage >= me->GetHealth())
{
damage = 0;
if (!me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))
{
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->RemoveAllAuras();
me->CastSpell(me, SPELL_OPEN_ALL_PORTALS, true);
events.ScheduleEvent(EVENT_SUMMON_ENTROPIUS, 7000);
}
}
}
void JustSummoned(Creature* summon)
{
if (summon->GetEntry() == NPC_ENTROPIUS)
summon->AI()->SetData(DATA_ENRAGE_TIMER, events.GetNextEventTime(EVENT_SPELL_ENRAGE));
else
{
if (!summon->IsTrigger())
summon->SetInCombatWithZone();
summons.Summon(summon);
}
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_ENRAGE:
me->CastSpell(me, SPELL_ENRAGE, true);
break;
case EVENT_SUMMON_ENTROPIUS:
me->CastSpell(me, SPELL_SUMMON_ENTROPIUS, false);
events.ScheduleEvent(EVENT_SET_INVISIBLE, 1000);
break;
case EVENT_SET_INVISIBLE:
me->SetVisible(false);
break;
}
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_muruAI>(creature);
}
};
class boss_entropius : public CreatureScript
{
public:
boss_entropius() : CreatureScript("boss_entropius") { }
struct boss_entropiusAI : public ScriptedAI
{
boss_entropiusAI(Creature* creature) : ScriptedAI(creature) { }
EventMap events;
EventMap events2;
void Reset()
{
events.Reset();
events2.Reset();
events2.ScheduleEvent(EVENT_ENTROPIUS_AURAS, 0);
events2.ScheduleEvent(EVENT_ENTROPIUS_COMBAT, 3000);
me->SetReactState(REACT_PASSIVE);
}
void EnterEvadeMode()
{
if (InstanceScript* instance = me->GetInstanceScript())
if (Creature* muru = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_MURU)))
if (!muru->IsInEvadeMode())
muru->AI()->EnterEvadeMode();
me->DespawnOrUnsummon();
}
void EnterCombat(Unit* /*who*/)
{
events.ScheduleEvent(EVENT_SPAWN_BLACK_HOLE, 15000);
events.ScheduleEvent(EVENT_SPAWN_DARKNESS, 10000);
}
void SetData(uint32 type, uint32 data)
{
if (type == DATA_ENRAGE_TIMER)
events.ScheduleEvent(EVENT_SPELL_ENRAGE, data);
}
uint32 GetData(uint32 type) const
{
if (type == DATA_NEGATIVE_ENERGY_TARGETS)
return 1 + uint32(events.GetTimer() / 12000);
return 0;
}
void JustDied(Unit* /*killer*/)
{
if (InstanceScript* instance = me->GetInstanceScript())
if (Creature* muru = ObjectAccessor::GetCreature(*me, instance->GetData64(NPC_MURU)))
Unit::Kill(muru, muru);
}
void UpdateAI(uint32 diff)
{
events2.Update(diff);
switch (events2.ExecuteEvent())
{
case EVENT_ENTROPIUS_AURAS:
me->CastSpell(me, SPELL_ENTROPIUS_COSMETIC_SPAWN, false);
me->CastSpell(me, SPELL_NEGATIVE_ENERGY_PERIODIC, true);
break;
case EVENT_ENTROPIUS_COMBAT:
me->SetReactState(REACT_AGGRESSIVE);
me->SetInCombatWithZone();
AttackStart(SelectTargetFromPlayerList(50.0f));
break;
}
if (!events2.Empty())
return;
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_ENRAGE:
me->CastSpell(me, SPELL_ENRAGE, true);
break;
case EVENT_SPAWN_DARKNESS:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f, true))
me->CastSpell(target, SPELL_DARKNESS, true);
events.ScheduleEvent(EVENT_SPAWN_DARKNESS, 15000);
break;
case EVENT_SPAWN_BLACK_HOLE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f, true))
me->CastSpell(target, SPELL_BLACK_HOLE, true);
events.ScheduleEvent(EVENT_SPAWN_BLACK_HOLE, 15000);
break;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_entropiusAI>(creature);
}
};
class npc_singularity : public CreatureScript
{
public:
npc_singularity() : CreatureScript("npc_singularity") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<npc_singularityAI>(creature);
}
struct npc_singularityAI : public NullCreatureAI
{
npc_singularityAI(Creature* creature) : NullCreatureAI(creature)
{
}
EventMap events;
void Reset()
{
me->DespawnOrUnsummon(18000);
me->CastSpell(me, SPELL_BLACK_HOLE_SUMMON_VISUAL, true);
me->CastSpell(me, SPELL_BLACK_HOLE_SUMMON_VISUAL2, true);
events.ScheduleEvent(EVENT_START_BLACK_HOLE, 3500);
events.ScheduleEvent(EVENT_SWITCH_BLACK_HOLE_TARGET, 5000);
events.ScheduleEvent(EVENT_SINGULARITY_DEATH, 17000);
}
void UpdateAI(uint32 diff)
{
events.Update(diff);
switch (events.ExecuteEvent())
{
case EVENT_SINGULARITY_DEATH:
Unit::Kill(me, me);
break;
case EVENT_START_BLACK_HOLE:
me->RemoveAurasDueToSpell(SPELL_BLACK_HOLE_SUMMON_VISUAL2);
me->CastSpell(me, SPELL_BLACK_HOLE_VISUAL2, true);
me->CastSpell(me, SPELL_BLACK_HOLE_PASSIVE, true);
break;
case EVENT_SWITCH_BLACK_HOLE_TARGET:
{
Map::PlayerList const& players = me->GetMap()->GetPlayers();
for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
if (Player* player = itr->GetSource())
if (me->GetDistance2d(player) < 15.0f && player->GetPositionZ() < 72.0f && player->IsAlive() && !player->HasAura(SPELL_BLACK_HOLE_EFFECT))
{
me->GetMotionMaster()->MovePoint(0, player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), false, true);
events.ScheduleEvent(EVENT_SWITCH_BLACK_HOLE_TARGET, 5000);
return;
}
events.ScheduleEvent(EVENT_SWITCH_BLACK_HOLE_TARGET, 500);
break;
}
}
}
};
};
class spell_muru_summon_blood_elves_periodic : public SpellScriptLoader
{
public:
spell_muru_summon_blood_elves_periodic() : SpellScriptLoader("spell_muru_summon_blood_elves_periodic") { }
class spell_muru_summon_blood_elves_periodic_AuraScript : public AuraScript
{
PrepareAuraScript(spell_muru_summon_blood_elves_periodic_AuraScript);
void HandleApply(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
// first tick after 10 seconds
GetAura()->GetEffect(aurEff->GetEffIndex())->SetPeriodicTimer(10000);
}
void OnPeriodic(AuraEffect const* aurEff)
{
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SUMMON_FURY_MAGE1, true);
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SUMMON_FURY_MAGE2, true);
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SUMMON_BERSERKER1, true);
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SUMMON_BERSERKER2, true);
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SUMMON_BERSERKER1, true);
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SUMMON_BERSERKER2, true);
}
void Register()
{
OnEffectApply += AuraEffectApplyFn(spell_muru_summon_blood_elves_periodic_AuraScript::HandleApply, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL);
OnEffectPeriodic += AuraEffectPeriodicFn(spell_muru_summon_blood_elves_periodic_AuraScript::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
}
};
AuraScript* GetAuraScript() const
{
return new spell_muru_summon_blood_elves_periodic_AuraScript();
}
};
class spell_muru_darkness : public SpellScriptLoader
{
public:
spell_muru_darkness() : SpellScriptLoader("spell_muru_darkness") { }
class spell_muru_darkness_AuraScript : public AuraScript
{
PrepareAuraScript(spell_muru_darkness_AuraScript);
void OnPeriodic(AuraEffect const* aurEff)
{
if (aurEff->GetTickNumber() == 3)
for (uint8 i = 0; i < 8; ++i)
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SUMMON_DARK_FIEND+i, true);
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_muru_darkness_AuraScript::OnPeriodic, EFFECT_2, SPELL_AURA_PERIODIC_DUMMY);
}
};
AuraScript* GetAuraScript() const
{
return new spell_muru_darkness_AuraScript();
}
};
class spell_entropius_negative_energy : public SpellScriptLoader
{
public:
spell_entropius_negative_energy() : SpellScriptLoader("spell_entropius_negative_energy") { }
class spell_entropius_negative_energy_SpellScript : public SpellScript
{
PrepareSpellScript(spell_entropius_negative_energy_SpellScript);
bool Load()
{
return GetCaster()->GetTypeId() == TYPEID_UNIT;
}
void FilterTargets(std::list<WorldObject*>& targets)
{
Trinity::Containers::RandomResizeList(targets, GetCaster()->GetAI()->GetData(DATA_NEGATIVE_ENERGY_TARGETS));
}
void HandleScriptEffect(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
if (Unit* target = GetHitUnit())
GetCaster()->CastSpell(target, SPELL_NEGATIVE_ENERGY_CHAIN, true);
}
void Register()
{
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_entropius_negative_energy_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
OnEffectHitTarget += SpellEffectFn(spell_entropius_negative_energy_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_entropius_negative_energy_SpellScript();
}
};
class spell_entropius_void_zone_visual : public SpellScriptLoader
{
public:
spell_entropius_void_zone_visual() : SpellScriptLoader("spell_entropius_void_zone_visual") { }
class spell_entropius_void_zone_visual_AuraScript : public AuraScript
{
PrepareAuraScript(spell_entropius_void_zone_visual_AuraScript);
void HandleApply(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
SetDuration(3000);
}
void HandleRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SUMMON_DARK_FIEND_ENTROPIUS, true);
}
void Register()
{
OnEffectApply += AuraEffectApplyFn(spell_entropius_void_zone_visual_AuraScript::HandleApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
OnEffectRemove += AuraEffectRemoveFn(spell_entropius_void_zone_visual_AuraScript::HandleApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_entropius_void_zone_visual_AuraScript();
}
};
class spell_entropius_black_hole_effect : public SpellScriptLoader
{
public:
spell_entropius_black_hole_effect() : SpellScriptLoader("spell_entropius_black_hole_effect") { }
class spell_entropius_black_hole_effect_SpellScript : public SpellScript
{
PrepareSpellScript(spell_entropius_black_hole_effect_SpellScript);
void HandlePull(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
Unit* target = GetHitUnit();
if (!target)
return;
Position pos;
if (target->GetDistance(GetCaster()) < 5.0f)
{
float o = frand(0, 2*M_PI);
pos.Relocate(GetCaster()->GetPositionX() + 4.0f*cos(o), GetCaster()->GetPositionY() + 4.0f*sin(o), GetCaster()->GetPositionZ()+frand(10.0f, 15.0f));
}
else
pos.Relocate(GetCaster()->GetPositionX(), GetCaster()->GetPositionY(), GetCaster()->GetPositionZ()+1.0f);
float speedXY = float(GetSpellInfo()->Effects[effIndex].MiscValue) * 0.1f;
float speedZ = target->GetDistance(pos) / speedXY * 0.5f * Movement::gravity;
target->GetMotionMaster()->MoveJump(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), speedXY, speedZ);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_entropius_black_hole_effect_SpellScript::HandlePull, EFFECT_0, SPELL_EFFECT_PULL_TOWARDS_DEST);
}
};
SpellScript* GetSpellScript() const
{
return new spell_entropius_black_hole_effect_SpellScript();
}
};
void AddSC_boss_muru()
{
new boss_muru();
new boss_entropius();
new npc_singularity();
new spell_muru_summon_blood_elves_periodic();
new spell_muru_darkness();
new spell_entropius_negative_energy();
new spell_entropius_void_zone_visual();
new spell_entropius_black_hole_effect();
}

349
src/server/scripts/EasternKingdoms/SunwellPlateau/instance_sunwell_plateau.cpp
View File

@@ -1,349 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "InstanceScript.h"
#include "Player.h"
#include "sunwell_plateau.h"
DoorData const doorData[] =
{
{ GO_FIRE_BARRIER, DATA_FELMYST_DOORS, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_MURUS_GATE_1, DATA_MURU, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_MURUS_GATE_2, DATA_MURU, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_BOSS_COLLISION_1, DATA_KALECGOS, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_BOSS_COLLISION_2, DATA_KALECGOS, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_FORCE_FIELD, DATA_KALECGOS, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ 0, 0, DOOR_TYPE_ROOM, BOUNDARY_NONE } // END
};
class instance_sunwell_plateau : public InstanceMapScript
{
public:
instance_sunwell_plateau() : InstanceMapScript("instance_sunwell_plateau", 580) { }
struct instance_sunwell_plateau_InstanceMapScript : public InstanceScript
{
instance_sunwell_plateau_InstanceMapScript(Map* map) : InstanceScript(map)
{
SetBossNumber(MAX_ENCOUNTERS);
LoadDoorData(doorData);
KalecgosDragonGUID = 0;
SathrovarrGUID = 0;
BrutallusGUID = 0;
MadrigosaGUID = 0;
FelmystGUID = 0;
AlythessGUID = 0;
SacrolashGUID = 0;
MuruGUID = 0;
KilJaedenGUID = 0;
KilJaedenControllerGUID = 0;
AnveenaGUID = 0;
KalecgosKjGUID = 0;
IceBarrierGUID = 0;
memset(&blueFlightOrbGUID, 0, sizeof(blueFlightOrbGUID));
}
void OnPlayerEnter(Player* player)
{
instance->LoadGrid(1477.94f, 643.22f);
instance->LoadGrid(1641.45f, 988.08f);
if (GameObject* gobj = instance->GetGameObject(IceBarrierGUID))
gobj->SendUpdateToPlayer(player);
}
Player const* GetPlayerInMap() const
{
Map::PlayerList const& players = instance->GetPlayers();
if (!players.isEmpty())
{
for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* player = itr->GetSource();
if (player && !player->HasAura(45839, 0))
return player;
}
}
//else
// TC_LOG_DEBUG("scripts", "Instance Sunwell Plateau: GetPlayerInMap, but PlayerList is empty!");
return NULL;
}
void OnCreatureCreate(Creature* creature)
{
if (creature->GetDBTableGUIDLow() > 0 || !IS_PLAYER_GUID(creature->GetOwnerGUID()))
creature->CastSpell(creature, SPELL_SUNWELL_RADIANCE, true);
switch (creature->GetEntry())
{
case NPC_KALECGOS:
KalecgosDragonGUID = creature->GetGUID();
break;
case NPC_SATHROVARR:
SathrovarrGUID = creature->GetGUID();
break;
case NPC_BRUTALLUS:
BrutallusGUID = creature->GetGUID();
break;
case NPC_MADRIGOSA:
MadrigosaGUID = creature->GetGUID();
break;
case NPC_FELMYST:
FelmystGUID = creature->GetGUID();
break;
case NPC_GRAND_WARLOCK_ALYTHESS:
AlythessGUID = creature->GetGUID();
break;
case NPC_LADY_SACROLASH:
SacrolashGUID = creature->GetGUID();
break;
case NPC_MURU:
MuruGUID = creature->GetGUID();
break;
case NPC_KILJAEDEN:
KilJaedenGUID = creature->GetGUID();
break;
case NPC_KILJAEDEN_CONTROLLER:
KilJaedenControllerGUID = creature->GetGUID();
break;
case NPC_ANVEENA:
AnveenaGUID = creature->GetGUID();
break;
case NPC_KALECGOS_KJ:
KalecgosKjGUID = creature->GetGUID();
break;
// Xinef: Felmyst encounter
case NPC_DEMONIC_VAPOR_TRAIL:
case NPC_UNYIELDING_DEAD:
if (Creature* felmyst = instance->GetCreature(FelmystGUID))
felmyst->AI()->JustSummoned(creature);
break;
// Xinef: M'uru encounter
case NPC_DARKNESS:
case NPC_VOID_SENTINEL:
case NPC_VOID_SPAWN:
if (Creature* muru = instance->GetCreature(MuruGUID))
muru->AI()->JustSummoned(creature);
break;
// Xinef: Kil'jaeden encounter
case NPC_FELFIRE_PORTAL:
case NPC_VOLATILE_FELFIRE_FIEND:
case NPC_SHIELD_ORB:
case NPC_SINISTER_REFLECTION:
if (Creature* kiljaedenC = instance->GetCreature(KilJaedenControllerGUID))
kiljaedenC->AI()->JustSummoned(creature);
break;
default:
break;
}
}
void OnGameObjectCreate(GameObject* go)
{
switch (go->GetEntry())
{
case GO_FORCE_FIELD:
case GO_BOSS_COLLISION_1:
case GO_BOSS_COLLISION_2:
case GO_FIRE_BARRIER:
case GO_MURUS_GATE_1:
case GO_MURUS_GATE_2:
AddDoor(go, true);
break;
case GO_ICE_BARRIER:
IceBarrierGUID = go->GetGUID();
go->setActive(true);
break;
case GO_ORB_OF_THE_BLUE_DRAGONFLIGHT1:
blueFlightOrbGUID[0] = go->GetGUID();
break;
case GO_ORB_OF_THE_BLUE_DRAGONFLIGHT2:
blueFlightOrbGUID[1] = go->GetGUID();
break;
case GO_ORB_OF_THE_BLUE_DRAGONFLIGHT3:
blueFlightOrbGUID[2] = go->GetGUID();
break;
case GO_ORB_OF_THE_BLUE_DRAGONFLIGHT4:
blueFlightOrbGUID[3] = go->GetGUID();
break;
default:
break;
}
}
void OnGameObjectRemove(GameObject* go)
{
switch (go->GetEntry())
{
case GO_FIRE_BARRIER:
case GO_MURUS_GATE_1:
case GO_MURUS_GATE_2:
case GO_BOSS_COLLISION_1:
case GO_BOSS_COLLISION_2:
case GO_FORCE_FIELD:
AddDoor(go, false);
break;
default:
break;
}
}
uint64 GetData64(uint32 id) const
{
switch (id)
{
case NPC_KALECGOS:
return KalecgosDragonGUID;
case NPC_SATHROVARR:
return SathrovarrGUID;
case NPC_BRUTALLUS:
return BrutallusGUID;
case NPC_MADRIGOSA:
return MadrigosaGUID;
case NPC_FELMYST:
return FelmystGUID;
case NPC_GRAND_WARLOCK_ALYTHESS:
return AlythessGUID;
case NPC_LADY_SACROLASH:
return SacrolashGUID;
case NPC_MURU:
return MuruGUID;
case NPC_ANVEENA:
return AnveenaGUID;
case NPC_KALECGOS_KJ:
return KalecgosKjGUID;
case NPC_KILJAEDEN_CONTROLLER:
return KilJaedenControllerGUID;
case NPC_KILJAEDEN:
return KilJaedenGUID;
// Orbs
case DATA_ORB_OF_THE_BLUE_DRAGONFLIGHT_1:
case DATA_ORB_OF_THE_BLUE_DRAGONFLIGHT_2:
case DATA_ORB_OF_THE_BLUE_DRAGONFLIGHT_3:
case DATA_ORB_OF_THE_BLUE_DRAGONFLIGHT_4:
return blueFlightOrbGUID[id-DATA_ORB_OF_THE_BLUE_DRAGONFLIGHT_1];
}
return 0;
}
std::string GetSaveData()
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << "S P " << 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 == 'S' && dataHead2 == 'P')
{
for (uint32 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 KalecgosDragonGUID;
uint64 SathrovarrGUID;
uint64 BrutallusGUID;
uint64 MadrigosaGUID;
uint64 FelmystGUID;
uint64 AlythessGUID;
uint64 SacrolashGUID;
uint64 MuruGUID;
uint64 KilJaedenGUID;
uint64 KilJaedenControllerGUID;
uint64 AnveenaGUID;
uint64 KalecgosKjGUID;
uint64 IceBarrierGUID;
uint64 blueFlightOrbGUID[4];
};
InstanceScript* GetInstanceScript(InstanceMap* map) const
{
return new instance_sunwell_plateau_InstanceMapScript(map);
}
};
enum cataclysmBreath
{
SPELL_CORROSIVE_POISON = 46293,
SPELL_FEVERED_FATIGUE = 46294,
SPELL_HEX = 46295,
SPELL_NECROTIC_POISON = 46296,
SPELL_PIERCING_SHADOW = 46297,
SPELL_SHRINK = 46298,
SPELL_WAVERING_WILL = 46299,
SPELL_WITHERED_TOUCH = 46300
};
class spell_cataclysm_breath : public SpellScriptLoader
{
public:
spell_cataclysm_breath() : SpellScriptLoader("spell_cataclysm_breath") { }
class spell_cataclysm_breath_SpellScript : public SpellScript
{
PrepareSpellScript(spell_cataclysm_breath_SpellScript);
void HandleAfterCast()
{
if (Unit* target = GetExplTargetUnit())
for (uint8 i = 0; i < 4; ++i)
GetCaster()->CastSpell(target, RAND(SPELL_CORROSIVE_POISON, SPELL_FEVERED_FATIGUE, SPELL_HEX, SPELL_NECROTIC_POISON, SPELL_PIERCING_SHADOW, SPELL_SHRINK, SPELL_WAVERING_WILL, SPELL_WITHERED_TOUCH), true);
}
void Register()
{
AfterCast += SpellCastFn(spell_cataclysm_breath_SpellScript::HandleAfterCast);
}
};
SpellScript* GetSpellScript() const
{
return new spell_cataclysm_breath_SpellScript();
}
};
void AddSC_instance_sunwell_plateau()
{
new instance_sunwell_plateau();
new spell_cataclysm_breath();
}

84
src/server/scripts/EasternKingdoms/SunwellPlateau/sunwell_plateau.h
View File

@@ -1,84 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#ifndef SUNWELL_PLATEAU_H
#define SUNWELL_PLATEAU_H
enum DataTypes
{
DATA_KALECGOS = 0,
DATA_MADRIGOSA = 1,
DATA_BRUTALLUS = 2,
DATA_FELMYST = 3,
DATA_FELMYST_DOORS = 4,
DATA_EREDAR_TWINS_INTRO = 5,
DATA_EREDAR_TWINS = 6,
DATA_MURU = 7,
DATA_KILJAEDEN = 8,
MAX_ENCOUNTERS = 9,
// GameObject GUIDs
DATA_ORB_OF_THE_BLUE_DRAGONFLIGHT_1 = 10,
DATA_ORB_OF_THE_BLUE_DRAGONFLIGHT_2 = 11,
DATA_ORB_OF_THE_BLUE_DRAGONFLIGHT_3 = 12,
DATA_ORB_OF_THE_BLUE_DRAGONFLIGHT_4 = 13
};
enum CreatureIds
{
NPC_KALECGOS = 24850,
NPC_KALEC = 24891,
NPC_SATHROVARR = 24892,
NPC_BRUTALLUS = 24882,
NPC_MADRIGOSA = 24895,
NPC_FELMYST = 25038,
NPC_DEMONIC_VAPOR_TRAIL = 25267,
NPC_UNYIELDING_DEAD = 25268,
NPC_GRAND_WARLOCK_ALYTHESS = 25166,
NPC_LADY_SACROLASH = 25165,
NPC_SHADOW_IMAGE = 25214,
NPC_MURU = 25741,
NPC_ENTROPIUS = 25840,
NPC_DARKNESS = 25879,
NPC_VOID_SENTINEL = 25772,
NPC_VOID_SPAWN = 25824,
NPC_KILJAEDEN_CONTROLLER = 25608,
NPC_KILJAEDEN = 25315,
NPC_ANVEENA = 26046,
NPC_KALECGOS_KJ = 25319,
NPC_HAND_OF_THE_DECEIVER = 25588,
NPC_FELFIRE_PORTAL = 25603,
NPC_VOLATILE_FELFIRE_FIEND = 25598,
NPC_SHIELD_ORB = 25502,
NPC_SINISTER_REFLECTION = 25708,
NPC_ARMAGEDDON_TARGET = 25735,
};
enum GameObjectIds
{
GO_FORCE_FIELD = 188421,
GO_BOSS_COLLISION_1 = 188523,
GO_BOSS_COLLISION_2 = 188524,
GO_FIRE_BARRIER = 188075,
GO_MURUS_GATE_1 = 187990,
GO_MURUS_GATE_2 = 188118,
GO_ICE_BARRIER = 188119,
GO_ORB_OF_THE_BLUE_DRAGONFLIGHT1 = 187869,
GO_ORB_OF_THE_BLUE_DRAGONFLIGHT2 = 188114,
GO_ORB_OF_THE_BLUE_DRAGONFLIGHT3 = 188115,
GO_ORB_OF_THE_BLUE_DRAGONFLIGHT4 = 188116
};
enum SpellIds
{
SPELL_SUNWELL_RADIANCE = 45769,
};
#endif // SUNWELL_PLATEAU_H