Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-24 19:06:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

Scripts/Scholomance: Modernize scripts (#30920)

Browse Source
This commit is contained in:
offl
2025-05-17 13:44:24 +03:00
committed by GitHub
parent b3698c4870
commit 763dc107bb
14 changed files with 1076 additions and 1315 deletions
Download Patch File Download Diff File Expand all files Collapse all files

462
src/server/scripts/EasternKingdoms/Scholomance/boss_darkmaster_gandling.cpp
View File

@@ -15,13 +15,6 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
Name: Boss_Darkmaster_Gandling
%Complete: 90
Comment: Doors Not yet reopening.
Category: Scholomance
*/
#include "ScriptMgr.h"
#include "GameObject.h"
#include "InstanceScript.h"
@@ -33,115 +26,106 @@ Category: Scholomance
#include "SpellScript.h"
#include "TemporarySummon.h"
enum Says
enum GandlingTexts
{
YELL_SUMMONED = 0
SAY_SUMMONED = 0
};
enum Spells
enum GandlingSpells
{
SPELL_ARCANEMISSILES = 15790,
SPELL_SHADOWSHIELD = 12040,
SPELL_ARCANE_MISSILES = 15790,
SPELL_SHADOW_SHIELD = 12040,
SPELL_CURSE = 18702,
SPELL_SHADOW_PORTAL = 17950
};
enum Events
enum GandlingEvents
{
EVENT_ARCANEMISSILES = 1,
EVENT_SHADOWSHIELD = 2,
EVENT_CURSE = 3,
EVENT_SHADOW_PORTAL = 4
EVENT_ARCANE_MISSILES = 1,
EVENT_SHADOW_SHIELD,
EVENT_CURSE,
EVENT_SHADOW_PORTAL
};
class boss_darkmaster_gandling : public CreatureScript
// 1853 - Darkmaster Gandling
struct boss_darkmaster_gandling : public BossAI
{
public: boss_darkmaster_gandling() : CreatureScript("boss_darkmaster_gandling") { }
boss_darkmaster_gandling(Creature* creature) : BossAI(creature, DATA_DARKMASTER_GANDLING) { }
struct boss_darkmaster_gandlingAI : public BossAI
void Reset() override
{
_Reset();
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
gate->SetGoState(GO_STATE_ACTIVE);
}
void JustDied(Unit* /*killer*/) override
{
_JustDied();
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
gate->SetGoState(GO_STATE_ACTIVE);
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_ARCANE_MISSILES, 4500ms);
events.ScheduleEvent(EVENT_SHADOW_SHIELD, 12s);
events.ScheduleEvent(EVENT_CURSE, 2s);
events.ScheduleEvent(EVENT_SHADOW_PORTAL, 15s);
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
gate->SetGoState(GO_STATE_READY);
}
void IsSummonedBy(WorldObject* /*summoner*/) override
{
Talk(SAY_SUMMONED);
me->GetMotionMaster()->MoveRandom(5);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
boss_darkmaster_gandlingAI(Creature* creature) : BossAI(creature, DATA_DARKMASTER_GANDLING) { }
void Reset() override
switch (eventId)
{
_Reset();
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
gate->SetGoState(GO_STATE_ACTIVE);
}
void JustDied(Unit* /*killer*/) override
{
_JustDied();
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
gate->SetGoState(GO_STATE_ACTIVE);
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_ARCANEMISSILES, 4500ms);
events.ScheduleEvent(EVENT_SHADOWSHIELD, 12s);
events.ScheduleEvent(EVENT_CURSE, 2s);
events.ScheduleEvent(EVENT_SHADOW_PORTAL, 15s);
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
gate->SetGoState(GO_STATE_READY);
}
void IsSummonedBy(WorldObject* /*summoner*/) override
{
Talk(YELL_SUMMONED);
me->GetMotionMaster()->MoveRandom(5);
}
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_ARCANE_MISSILES:
DoCastVictim(SPELL_ARCANE_MISSILES);
events.Repeat(8s);
break;
case EVENT_SHADOW_SHIELD:
DoCastSelf(SPELL_SHADOW_SHIELD);
events.Repeat(14s, 28s);
break;
case EVENT_CURSE:
DoCastVictim(SPELL_CURSE);
events.Repeat(15s, 27s);
break;
case EVENT_SHADOW_PORTAL:
if (HealthAbovePct(3))
{
case EVENT_ARCANEMISSILES:
DoCastVictim(SPELL_ARCANEMISSILES, true);
events.ScheduleEvent(EVENT_ARCANEMISSILES, 8s);
break;
case EVENT_SHADOWSHIELD:
DoCast(me, SPELL_SHADOWSHIELD);
events.ScheduleEvent(EVENT_SHADOWSHIELD, 14s, 28s);
break;
case EVENT_CURSE:
DoCastVictim(SPELL_CURSE, true);
events.ScheduleEvent(EVENT_CURSE, 15s, 27s);
break;
case EVENT_SHADOW_PORTAL:
if (HealthAbovePct(3))
{
DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_SHADOW_PORTAL, true);
events.ScheduleEvent(EVENT_SHADOW_PORTAL, 17s, 27s);
}
DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_SHADOW_PORTAL);
events.Repeat(17s, 27s);
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_darkmaster_gandlingAI>(creature);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
// Script for Shadow Portal spell 17950
enum Rooms
{
ROOM_HALL_OF_SECRETS = 0,
@@ -163,82 +147,71 @@ enum SPSpells
};
// 17950 - Shadow Portal
class spell_shadow_portal : public SpellScriptLoader
class spell_shadow_portal : public SpellScript
{
public:
spell_shadow_portal() : SpellScriptLoader("spell_shadow_portal") { }
PrepareSpellScript(spell_shadow_portal);
class spell_shadow_portal_SpellScript : public SpellScript
bool Load() override
{
_instance = GetCaster()->GetInstanceScript();
return InstanceHasScript(GetCaster(), ScholomanceScriptName);
}
void HandleCast(SpellEffIndex /*effIndex*/)
{
Unit* caster = GetCaster();
uint8 attempts = 0;
uint32 spellId = 0;
while (!spellId)
{
PrepareSpellScript(spell_shadow_portal_SpellScript);
if (attempts++ >= 6) break;
bool Load() override
switch (urand(0, 5))
{
_instance = GetCaster()->GetInstanceScript();
return InstanceHasScript(GetCaster(), ScholomanceScriptName);
case ROOM_HALL_OF_SECRETS:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_RAVENIAN)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_HALLOFSECRETS;
break;
case ROOM_HALL_OF_THE_DAMNED:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_THEOLEN)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_HALLOFTHEDAMNED;
break;
case ROOM_THE_COVEN:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_MALICIA)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_THECOVEN;
break;
case ROOM_THE_SHADOW_VAULT:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_ILLUCIA)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_THESHADOWVAULT;
break;
case ROOM_BAROV_FAMILY_VAULT:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_BAROV)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_BAROVFAMILYVAULT;
break;
case ROOM_VAULT_OF_THE_RAVENIAN:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_POLKELT)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_VAULTOFTHERAVENIAN;
break;
}
void HandleCast(SpellEffIndex /*effIndex*/)
{
Unit* caster = GetCaster();
uint8 attempts = 0;
uint32 spellId = 0;
while (!spellId)
{
if (attempts++ >= 6) break;
switch (urand(0, 5))
{
case ROOM_HALL_OF_SECRETS:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_RAVENIAN)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_HALLOFSECRETS;
break;
case ROOM_HALL_OF_THE_DAMNED:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_THEOLEN)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_HALLOFTHEDAMNED;
break;
case ROOM_THE_COVEN:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_MALICIA)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_THECOVEN;
break;
case ROOM_THE_SHADOW_VAULT:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_ILLUCIA)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_THESHADOWVAULT;
break;
case ROOM_BAROV_FAMILY_VAULT:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_BAROV)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_BAROVFAMILYVAULT;
break;
case ROOM_VAULT_OF_THE_RAVENIAN:
if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_POLKELT)))
if (go->GetGoState() == GO_STATE_ACTIVE)
spellId = SPELL_SHADOW_PORTAL_VAULTOFTHERAVENIAN;
break;
}
if (spellId)
GetHitUnit()->CastSpell(GetHitUnit(), spellId);
}
}
void Register() override
{
OnEffectHitTarget += SpellEffectFn(spell_shadow_portal_SpellScript::HandleCast, EFFECT_0, SPELL_EFFECT_DUMMY);
}
InstanceScript* _instance = nullptr;
};
SpellScript* GetSpellScript() const override
{
return new spell_shadow_portal_SpellScript();
if (spellId)
GetHitUnit()->CastSpell(GetHitUnit(), spellId);
}
}
void Register() override
{
OnEffectHitTarget += SpellEffectFn(spell_shadow_portal::HandleCast, EFFECT_0, SPELL_EFFECT_DUMMY);
}
InstanceScript* _instance = nullptr;
};
// Script for Shadow Portal spells 17863, 17939, 17943, 17944, 17946, 17948
@@ -282,100 +255,89 @@ enum ScriptEventId
};
// 17863, 17939, 17943, 17944, 17946, 17948 - Shadow Portal
class spell_shadow_portal_rooms : public SpellScriptLoader
class spell_shadow_portal_rooms : public SpellScript
{
public:
spell_shadow_portal_rooms() : SpellScriptLoader("spell_shadow_portal_rooms") { }
PrepareSpellScript(spell_shadow_portal_rooms);
class spell_shadow_portal_rooms_SpellScript : public SpellScript
bool Load() override
{
_instance = GetCaster()->GetInstanceScript();
return InstanceHasScript(GetCaster(), ScholomanceScriptName);
}
void HandleSendEvent(SpellEffIndex /*effIndex*/)
{
// If only one player in threat list fail spell
Unit* caster = GetCaster();
int8 pos_to_summon = 0;
int8 phase_to_set = 0;
int32 gate_to_close = 0;
switch (GetEffectInfo().MiscValue)
{
PrepareSpellScript(spell_shadow_portal_rooms_SpellScript);
bool Load() override
{
_instance = GetCaster()->GetInstanceScript();
return InstanceHasScript(GetCaster(), ScholomanceScriptName);
}
void HandleSendEvent(SpellEffIndex /*effIndex*/)
{
// If only one player in threat list fail spell
Unit* caster = GetCaster();
int8 pos_to_summon = 0;
int8 phase_to_set = 0;
int32 gate_to_close = 0;
switch (GetEffectInfo().MiscValue)
{
case SPELL_EVENT_HALLOFSECRETS:
pos_to_summon = 0; // Not yet spawned
phase_to_set = 1;
gate_to_close = GO_GATE_RAVENIAN;
break;
case SPELL_EVENT_HALLOFTHEDAMNED:
pos_to_summon = 0;
phase_to_set = 2;
gate_to_close = GO_GATE_THEOLEN;
break;
case SPELL_EVENT_THECOVEN:
pos_to_summon = 3;
phase_to_set = 3;
gate_to_close = GO_GATE_MALICIA;
break;
case SPELL_EVENT_THESHADOWVAULT:
pos_to_summon = 6;
phase_to_set = 4;
gate_to_close = GO_GATE_ILLUCIA;
break;
case SPELL_EVENT_BAROVFAMILYVAULT:
pos_to_summon = 9;
phase_to_set = 5;
gate_to_close = GO_GATE_BAROV;
break;
case SPELL_EVENT_VAULTOFTHERAVENIAN:
pos_to_summon = 0; // Not yet spawned
phase_to_set = 6;
gate_to_close = GO_GATE_POLKELT;
break;
default:
break;
}
if (gate_to_close)
{
for (uint8 i = 0; i < 3; ++i)
{
if (Creature* Summoned = caster->SummonCreature(NPC_RISEN_GUARDIAN, SummonPos[pos_to_summon++], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 2min))
{
Summoned->GetMotionMaster()->MoveRandom(5);
Summoned->AI()->SetData(0, phase_to_set);
}
}
if (GameObject* gate = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(gate_to_close)))
gate->SetGoState(GO_STATE_READY);
}
}
void Register() override
{
OnEffectHit += SpellEffectFn(spell_shadow_portal_rooms_SpellScript::HandleSendEvent, EFFECT_1, SPELL_EFFECT_SEND_EVENT);
}
InstanceScript* _instance = nullptr;
};
SpellScript* GetSpellScript() const override
{
return new spell_shadow_portal_rooms_SpellScript();
case SPELL_EVENT_HALLOFSECRETS:
pos_to_summon = 0; // Not yet spawned
phase_to_set = 1;
gate_to_close = GO_GATE_RAVENIAN;
break;
case SPELL_EVENT_HALLOFTHEDAMNED:
pos_to_summon = 0;
phase_to_set = 2;
gate_to_close = GO_GATE_THEOLEN;
break;
case SPELL_EVENT_THECOVEN:
pos_to_summon = 3;
phase_to_set = 3;
gate_to_close = GO_GATE_MALICIA;
break;
case SPELL_EVENT_THESHADOWVAULT:
pos_to_summon = 6;
phase_to_set = 4;
gate_to_close = GO_GATE_ILLUCIA;
break;
case SPELL_EVENT_BAROVFAMILYVAULT:
pos_to_summon = 9;
phase_to_set = 5;
gate_to_close = GO_GATE_BAROV;
break;
case SPELL_EVENT_VAULTOFTHERAVENIAN:
pos_to_summon = 0; // Not yet spawned
phase_to_set = 6;
gate_to_close = GO_GATE_POLKELT;
break;
default:
break;
}
if (gate_to_close)
{
for (uint8 i = 0; i < 3; ++i)
{
if (Creature* Summoned = caster->SummonCreature(NPC_RISEN_GUARDIAN, SummonPos[pos_to_summon++], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 2min))
{
Summoned->GetMotionMaster()->MoveRandom(5);
Summoned->AI()->SetData(0, phase_to_set);
}
}
if (GameObject* gate = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(gate_to_close)))
gate->SetGoState(GO_STATE_READY);
}
}
void Register() override
{
OnEffectHit += SpellEffectFn(spell_shadow_portal_rooms::HandleSendEvent, EFFECT_1, SPELL_EFFECT_SEND_EVENT);
}
InstanceScript* _instance = nullptr;
};
void AddSC_boss_darkmaster_gandling()
{
new boss_darkmaster_gandling();
new spell_shadow_portal();
new spell_shadow_portal_rooms();
RegisterScholomanceCreatureAI(boss_darkmaster_gandling);
RegisterSpellScript(spell_shadow_portal);
RegisterSpellScript(spell_shadow_portal_rooms);
}

46
src/server/scripts/EasternKingdoms/Scholomance/boss_death_knight_darkreaver.cpp
View File

@@ -15,49 +15,35 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/* ScriptData
SDName: Boss_Death_knight_darkreaver
SD%Complete: 100
SDComment:
SDCategory: Scholomance
EndScriptData */
#include "ScriptMgr.h"
#include "scholomance.h"
#include "ScriptedCreature.h"
class boss_death_knight_darkreaver : public CreatureScript
enum DarkreaverSpells
{
public:
boss_death_knight_darkreaver() : CreatureScript("boss_death_knight_darkreaver") { }
SUMMON_FALLEN_CHARGER = 23261
};
CreatureAI* GetAI(Creature* creature) const override
// 14516 - Death Knight Darkreaver
struct boss_death_knight_darkreaver : public ScriptedAI
{
boss_death_knight_darkreaver(Creature* creature) : ScriptedAI(creature) { }
void Reset() override
{
return GetScholomanceAI<boss_death_knight_darkreaverAI>(creature);
}
struct boss_death_knight_darkreaverAI : public ScriptedAI
void JustDied(Unit* /*killer*/) override
{
boss_death_knight_darkreaverAI(Creature* creature) : ScriptedAI(creature) { }
void Reset() override
{
}
void DamageTaken(Unit* /*done_by*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
{
if (me->GetHealth() <= damage)
DoCast(me, 23261, true); //Summon Darkreaver's Fallen Charger
}
void JustEngagedWith(Unit* /*who*/) override
{
}
};
DoCastSelf(SUMMON_FALLEN_CHARGER, true);
}
void JustEngagedWith(Unit* /*who*/) override
{
}
};
void AddSC_boss_death_knight_darkreaver()
{
new boss_death_knight_darkreaver();
RegisterScholomanceCreatureAI(boss_death_knight_darkreaver);
}

117
src/server/scripts/EasternKingdoms/Scholomance/boss_doctor_theolen_krastinov.cpp
View File

@@ -15,99 +15,82 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
Name: Boss_Doctor_Theolen_Krastinov
%Complete: 100
Comment:
Category: Scholomance
*/
#include "ScriptMgr.h"
#include "scholomance.h"
#include "ScriptedCreature.h"
enum Say
enum TheolenTexts
{
EMOTE_FRENZY_KILL = 0,
EMOTE_FRENZY_KILL = 0
};
enum Spells
enum TheolenSpells
{
SPELL_REND = 16509,
SPELL_BACKHAND = 18103,
SPELL_FRENZY = 8269
};
enum Events
enum TheolenEvents
{
EVENT_REND = 1,
EVENT_BACKHAND = 2,
EVENT_FRENZY = 3
EVENT_REND = 1,
EVENT_BACKHAND,
EVENT_FRENZY
};
class boss_doctor_theolen_krastinov : public CreatureScript
// 11261 - Doctor Theolen Krastinov
struct boss_doctor_theolen_krastinov : public BossAI
{
public: boss_doctor_theolen_krastinov() : CreatureScript("boss_doctor_theolen_krastinov") { }
boss_doctor_theolen_krastinov(Creature* creature) : BossAI(creature, DATA_DOCTOR_THEOLEN_KRASTINOV) { }
struct boss_theolenkrastinovAI : public BossAI
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_REND, 8s);
events.ScheduleEvent(EVENT_BACKHAND, 9s);
events.ScheduleEvent(EVENT_FRENZY, 1s);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
boss_theolenkrastinovAI(Creature* creature) : BossAI(creature, DATA_DOCTOR_THEOLEN_KRASTINOV) { }
void JustEngagedWith(Unit* who) override
switch (eventId)
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_REND, 8s);
events.ScheduleEvent(EVENT_BACKHAND, 9s);
events.ScheduleEvent(EVENT_FRENZY, 1s);
case EVENT_REND:
DoCastVictim(SPELL_REND);
events.Repeat(10s);
break;
case EVENT_BACKHAND:
DoCastVictim(SPELL_BACKHAND);
events.Repeat(10s);
break;
case EVENT_FRENZY:
DoCastSelf(SPELL_FRENZY);
Talk(EMOTE_FRENZY_KILL);
events.Repeat(120s);
break;
default:
break;
}
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_REND:
DoCastVictim(SPELL_REND, true);
events.ScheduleEvent(EVENT_REND, 10s);
break;
case EVENT_BACKHAND:
DoCastVictim(SPELL_BACKHAND, true);
events.ScheduleEvent(EVENT_BACKHAND, 10s);
break;
case EVENT_FRENZY:
DoCast(me, SPELL_FRENZY, true);
Talk(EMOTE_FRENZY_KILL);
events.ScheduleEvent(EVENT_FRENZY, 120s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_theolenkrastinovAI>(creature);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
void AddSC_boss_theolenkrastinov()
{
new boss_doctor_theolen_krastinov();
RegisterScholomanceCreatureAI(boss_doctor_theolen_krastinov);
}

128
src/server/scripts/EasternKingdoms/Scholomance/boss_illucia_barov.cpp
View File

@@ -15,100 +15,84 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
Name: Boss_Illucia_Barov
%Complete: 100
Comment:
Category: Scholomance
*/
#include "ScriptMgr.h"
#include "scholomance.h"
#include "ScriptedCreature.h"
enum Spells
enum IlluciaSpells
{
SPELL_CURSEOFAGONY = 18671,
SPELL_CURSE_OF_AGONY = 18671,
SPELL_DOMINATE = 7645, // UNUSED YET added for documentation
SPELL_FEAR = 12542,
SPELL_SHADOWSHOCK = 17234,
SPELL_SHADOW_SHOCK = 17234,
SPELL_SILENCE = 12528
};
enum Events
enum IlluciaEvents
{
EVENT_CURSEOFAGONY = 1,
EVENT_SHADOWSHOCK = 2,
EVENT_SILENCE = 3,
EVENT_FEAR = 4
EVENT_CURSE_OF_AGONY = 1,
EVENT_SHADOW_SHOCK,
EVENT_SILENCE,
EVENT_FEAR
};
class boss_illucia_barov : public CreatureScript
// 10502 - Lady Illucia Barov
struct boss_illucia_barov : public BossAI
{
public: boss_illucia_barov() : CreatureScript("boss_illucia_barov") { }
boss_illucia_barov(Creature* creature) : BossAI(creature, DATA_LADY_ILLUCIA_BAROV) { }
struct boss_illuciabarovAI : public BossAI
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_CURSE_OF_AGONY, 18s);
events.ScheduleEvent(EVENT_SHADOW_SHOCK, 9s);
events.ScheduleEvent(EVENT_SILENCE, 5s);
events.ScheduleEvent(EVENT_FEAR, 30s);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
boss_illuciabarovAI(Creature* creature) : BossAI(creature, DATA_LADY_ILLUCIA_BAROV) { }
void JustEngagedWith(Unit* who) override
switch (eventId)
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_CURSEOFAGONY, 18s);
events.ScheduleEvent(EVENT_SHADOWSHOCK, 9s);
events.ScheduleEvent(EVENT_SILENCE, 5s);
events.ScheduleEvent(EVENT_FEAR, 30s);
case EVENT_CURSE_OF_AGONY:
DoCastVictim(SPELL_CURSE_OF_AGONY);
events.Repeat(30s);
break;
case EVENT_SHADOW_SHOCK:
DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_SHADOW_SHOCK);
events.Repeat(12s);
break;
case EVENT_SILENCE:
DoCastSelf(SPELL_SILENCE);
events.Repeat(14s);
break;
case EVENT_FEAR:
DoCastVictim(SPELL_FEAR);
events.Repeat(30s);
break;
default:
break;
}
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_CURSEOFAGONY:
DoCastVictim(SPELL_CURSEOFAGONY, true);
events.ScheduleEvent(EVENT_CURSEOFAGONY, 30s);
break;
case EVENT_SHADOWSHOCK:
DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_SHADOWSHOCK, true);
events.ScheduleEvent(EVENT_SHADOWSHOCK, 12s);
break;
case EVENT_SILENCE:
DoCastVictim(SPELL_SILENCE, true);
events.ScheduleEvent(EVENT_SILENCE, 14s);
break;
case EVENT_FEAR:
DoCastVictim(SPELL_FEAR, true);
events.ScheduleEvent(EVENT_FEAR, 30s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_illuciabarovAI>(creature);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
void AddSC_boss_illuciabarov()
{
new boss_illucia_barov();
RegisterScholomanceCreatureAI(boss_illucia_barov);
}

213
src/server/scripts/EasternKingdoms/Scholomance/boss_instructor_malicia.cpp
View File

@@ -15,145 +15,128 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/* ScriptData
SDName: Boss_instructormalicia
SD%Complete: 100
SDComment:
SDCategory: Scholomance
EndScriptData */
#include "ScriptMgr.h"
#include "scholomance.h"
#include "ScriptedCreature.h"
enum Spells
enum MaliciaSpells
{
SPELL_CALLOFGRAVES = 17831,
SPELL_CALL_OF_GRAVES = 17831,
SPELL_CORRUPTION = 11672,
SPELL_FLASHHEAL = 10917,
SPELL_FLASH_HEAL = 10917,
SPELL_RENEW = 10929,
SPELL_HEALINGTOUCH = 9889
SPELL_HEALING_TOUCH = 9889
};
enum Events
enum MaliciaEvents
{
EVENT_CALLOFGRAVES = 1,
EVENT_CORRUPTION = 2,
EVENT_FLASHHEAL = 3,
EVENT_RENEW = 4,
EVENT_HEALINGTOUCH = 5
EVENT_CALL_OF_GRAVES = 1,
EVENT_CORRUPTION,
EVENT_FLASH_HEAL,
EVENT_RENEW,
EVENT_HEALING_TOUCH
};
class boss_instructor_malicia : public CreatureScript
// 10505 - Instructor Malicia
struct boss_instructor_malicia : public BossAI
{
public: boss_instructor_malicia() : CreatureScript("boss_instructor_malicia") { }
boss_instructor_malicia(Creature* creature) : BossAI(creature, DATA_INSTRUCTOR_MALICIA)
{
Initialize();
}
struct boss_instructormaliciaAI : public BossAI
void Initialize()
{
FlashCounter = 0;
TouchCounter = 0;
}
uint32 FlashCounter;
uint32 TouchCounter;
void Reset() override
{
_Reset();
Initialize();
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_CALL_OF_GRAVES, 4s);
events.ScheduleEvent(EVENT_CORRUPTION, 8s);
events.ScheduleEvent(EVENT_RENEW, 32s);
events.ScheduleEvent(EVENT_FLASH_HEAL, 38s);
events.ScheduleEvent(EVENT_HEALING_TOUCH, 45s);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
boss_instructormaliciaAI(Creature* creature) : BossAI(creature, DATA_INSTRUCTOR_MALICIA)
switch (eventId)
{
Initialize();
}
void Initialize()
{
FlashCounter = 0;
TouchCounter = 0;
}
uint32 FlashCounter;
uint32 TouchCounter;
void Reset() override
{
_Reset();
Initialize();
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_CALLOFGRAVES, 4s);
events.ScheduleEvent(EVENT_CORRUPTION, 8s);
events.ScheduleEvent(EVENT_RENEW, 32s);
events.ScheduleEvent(EVENT_FLASHHEAL, 38s);
events.ScheduleEvent(EVENT_HEALINGTOUCH, 45s);
}
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_CALL_OF_GRAVES:
DoCastSelf(SPELL_CALL_OF_GRAVES);
events.Repeat(65s);
break;
case EVENT_CORRUPTION:
DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_CORRUPTION);
events.Repeat(24s);
break;
case EVENT_RENEW:
DoCastSelf(SPELL_RENEW);
events.Repeat(10s);
break;
case EVENT_FLASH_HEAL:
// 5 Flash Heal will be cast
DoCastSelf(SPELL_FLASH_HEAL);
if (FlashCounter < 2)
{
case EVENT_CALLOFGRAVES:
DoCastVictim(SPELL_CALLOFGRAVES, true);
events.ScheduleEvent(EVENT_CALLOFGRAVES, 65s);
break;
case EVENT_CORRUPTION:
DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_CORRUPTION, true);
events.ScheduleEvent(EVENT_CORRUPTION, 24s);
break;
case EVENT_RENEW:
DoCast(me, SPELL_RENEW);
events.ScheduleEvent(EVENT_RENEW, 10s);
break;
case EVENT_FLASHHEAL:
//5 Flashheals will be cast
DoCast(me, SPELL_FLASHHEAL);
if (FlashCounter < 2)
{
events.ScheduleEvent(EVENT_FLASHHEAL, 5s);
++FlashCounter;
}
else
{
FlashCounter=0;
events.ScheduleEvent(EVENT_FLASHHEAL, 30s);
}
break;
case EVENT_HEALINGTOUCH:
//3 Healing Touch will be cast
DoCast(me, SPELL_HEALINGTOUCH);
if (TouchCounter < 2)
{
events.ScheduleEvent(EVENT_HEALINGTOUCH, 5500ms);
++TouchCounter;
}
else
{
TouchCounter=0;
events.ScheduleEvent(EVENT_HEALINGTOUCH, 30s);
}
break;
default:
break;
events.ScheduleEvent(EVENT_FLASH_HEAL, 5s);
++FlashCounter;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
else
{
FlashCounter=0;
events.ScheduleEvent(EVENT_FLASH_HEAL, 30s);
}
break;
case EVENT_HEALING_TOUCH:
// 3 Healing Touch will be cast
DoCastSelf(SPELL_HEALING_TOUCH);
if (TouchCounter < 2)
{
events.ScheduleEvent(EVENT_HEALING_TOUCH, 5500ms);
++TouchCounter;
}
else
{
TouchCounter=0;
events.ScheduleEvent(EVENT_HEALING_TOUCH, 30s);
}
break;
default:
break;
}
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_instructormaliciaAI>(creature);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
void AddSC_boss_instructormalicia()
{
new boss_instructor_malicia();
RegisterScholomanceCreatureAI(boss_instructor_malicia);
}

146
src/server/scripts/EasternKingdoms/Scholomance/boss_jandice_barov.cpp
View File

@@ -19,14 +19,14 @@
#include "scholomance.h"
#include "ScriptedCreature.h"
enum Spells
enum JandiceSpells
{
SPELL_CURSE_OF_BLOOD = 24673,
SPELL_ILLUSION = 17773,
SPELL_DROP_JOURNAL = 26096
};
enum Events
enum JandiceEvents
{
EVENT_CURSE_OF_BLOOD = 1,
EVENT_ILLUSION,
@@ -34,95 +34,85 @@ enum Events
EVENT_SET_VISIBILITY
};
class boss_jandice_barov : public CreatureScript
// 10503 - Jandice Barov
struct boss_jandice_barov : public ScriptedAI
{
public:
boss_jandice_barov() : CreatureScript("boss_jandice_barov") { }
boss_jandice_barov(Creature* creature) : ScriptedAI(creature), _summons(me) { }
struct boss_jandicebarovAI : public ScriptedAI
void Reset() override
{
boss_jandicebarovAI(Creature* creature) : ScriptedAI(creature), Summons(me) { }
_events.Reset();
_summons.DespawnAll();
}
void Reset() override
void JustSummoned(Creature* summoned) override
{
// Illusions should attack a random target.
if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
summoned->AI()->AttackStart(target);
_summons.Summon(summoned);
}
void JustEngagedWith(Unit* /*who*/) override
{
_events.ScheduleEvent(EVENT_CURSE_OF_BLOOD, 15s);
_events.ScheduleEvent(EVENT_ILLUSION, 30s);
}
void JustDied(Unit* /*killer*/) override
{
_summons.DespawnAll();
DoCastSelf(SPELL_DROP_JOURNAL, true);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = _events.ExecuteEvent())
{
events.Reset();
Summons.DespawnAll();
}
void JustSummoned(Creature* summoned) override
{
// Illusions should attack a random target.
if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
summoned->AI()->AttackStart(target);
Summons.Summon(summoned);
}
void JustEngagedWith(Unit* /*who*/) override
{
events.ScheduleEvent(EVENT_CURSE_OF_BLOOD, 15s);
events.ScheduleEvent(EVENT_ILLUSION, 30s);
}
void JustDied(Unit* /*killer*/) override
{
Summons.DespawnAll();
DoCastSelf(SPELL_DROP_JOURNAL, true);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
switch (eventId)
{
case EVENT_CURSE_OF_BLOOD:
DoCastVictim(SPELL_CURSE_OF_BLOOD);
_events.Repeat(30s);
break;
case EVENT_ILLUSION:
DoCast(SPELL_ILLUSION);
me->SetUnitFlag(UNIT_FLAG_UNINTERACTIBLE);
me->SetDisplayId(11686); // Invisible Model
ModifyThreatByPercent(me->GetVictim(), -99);
_events.ScheduleEvent(EVENT_SET_VISIBILITY, 3s);
_events.Repeat(25s);
break;
case EVENT_SET_VISIBILITY:
me->RemoveUnitFlag(UNIT_FLAG_UNINTERACTIBLE);
me->SetDisplayId(11073); // Jandice Model
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CURSE_OF_BLOOD:
DoCastVictim(SPELL_CURSE_OF_BLOOD);
events.ScheduleEvent(EVENT_CURSE_OF_BLOOD, 30s);
break;
case EVENT_ILLUSION:
DoCast(SPELL_ILLUSION);
me->SetUnitFlag(UNIT_FLAG_UNINTERACTIBLE);
me->SetDisplayId(11686); // Invisible Model
ModifyThreatByPercent(me->GetVictim(), -99);
events.ScheduleEvent(EVENT_SET_VISIBILITY, 3s);
events.ScheduleEvent(EVENT_ILLUSION, 25s);
break;
case EVENT_SET_VISIBILITY:
me->RemoveUnitFlag(UNIT_FLAG_UNINTERACTIBLE);
me->SetDisplayId(11073); //Jandice Model
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
private:
EventMap events;
SummonList Summons;
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_jandicebarovAI>(creature);
DoMeleeAttackIfReady();
}
private:
EventMap _events;
SummonList _summons;
};
void AddSC_boss_jandicebarov()
{
new boss_jandice_barov();
RegisterScholomanceCreatureAI(boss_jandice_barov);
}

400
src/server/scripts/EasternKingdoms/Scholomance/boss_kirtonos_the_herald.cpp
View File

@@ -26,12 +26,12 @@
#include "scholomance.h"
#include "ScriptedCreature.h"
enum Says
enum KirtonosTexts
{
EMOTE_SUMMONED = 0
};
enum Spells
enum KirtonosSpells
{
SPELL_SWOOP = 18144,
SPELL_WING_FLAP = 12882,
@@ -43,7 +43,7 @@ enum Spells
SPELL_DOMINATE_MIND = 14515
};
enum Events
enum KirtonosEvents
{
INTRO_1 = 1,
INTRO_2 = 2,
@@ -61,7 +61,7 @@ enum Events
EVENT_KIRTONOS_TRANSFORM = 14
};
enum Misc
enum KirtonosMisc
{
WEAPON_KIRTONOS_STAFF = 11365,
POINT_KIRTONOS_LAND = 13,
@@ -74,197 +74,184 @@ Position const PosMove[2] =
{ 314.8673f, 90.30210f, 101.6459f, 0.0f }
};
class boss_kirtonos_the_herald : public CreatureScript
// 10506 - Kirtonos the Herald
struct boss_kirtonos_the_herald : public BossAI
{
public: boss_kirtonos_the_herald() : CreatureScript("boss_kirtonos_the_herald") { }
boss_kirtonos_the_herald(Creature* creature) : BossAI(creature, DATA_KIRTONOS) { }
struct boss_kirtonos_the_heraldAI : public BossAI
void Reset() override
{
_Reset();
}
void JustEngagedWith(Unit* who) override
{
events.ScheduleEvent(EVENT_SWOOP, 8s, 8s);
events.ScheduleEvent(EVENT_WING_FLAP, 15s, 15s);
events.ScheduleEvent(EVENT_PIERCE_ARMOR, 18s, 18s);
events.ScheduleEvent(EVENT_DISARM, 22s, 22s);
events.ScheduleEvent(EVENT_SHADOW_BOLT, 42s, 42s);
events.ScheduleEvent(EVENT_CURSE_OF_TONGUES, 53s, 53s);
events.ScheduleEvent(EVENT_DOMINATE_MIND, 34s, 48s);
events.ScheduleEvent(EVENT_KIRTONOS_TRANSFORM, 20s, 20s);
BossAI::JustEngagedWith(who);
}
void JustDied(Unit* /*killer*/) override
{
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
gate->SetGoState(GO_STATE_ACTIVE);
if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
{
boss_kirtonos_the_heraldAI(Creature* creature) : BossAI(creature, DATA_KIRTONOS) { }
void Reset() override
{
_Reset();
}
void JustEngagedWith(Unit* who) override
{
events.ScheduleEvent(EVENT_SWOOP, 8s, 8s);
events.ScheduleEvent(EVENT_WING_FLAP, 15s, 15s);
events.ScheduleEvent(EVENT_PIERCE_ARMOR, 18s, 18s);
events.ScheduleEvent(EVENT_DISARM, 22s, 22s);
events.ScheduleEvent(EVENT_SHADOW_BOLT, 42s, 42s);
events.ScheduleEvent(EVENT_CURSE_OF_TONGUES, 53s, 53s);
events.ScheduleEvent(EVENT_DOMINATE_MIND, 34s, 48s);
events.ScheduleEvent(EVENT_KIRTONOS_TRANSFORM, 20s, 20s);
BossAI::JustEngagedWith(who);
}
void JustDied(Unit* /*killer*/) override
{
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
gate->SetGoState(GO_STATE_ACTIVE);
if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
{
brazier->ResetDoorOrButton();
brazier->SetGoState(GO_STATE_READY);
}
_JustDied();
}
void EnterEvadeMode(EvadeReason /*why*/) override
{
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
gate->SetGoState(GO_STATE_ACTIVE);
if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
{
brazier->ResetDoorOrButton();
brazier->SetGoState(GO_STATE_READY);
}
me->DespawnOrUnsummon(5s);
}
void IsSummonedBy(WorldObject* /*summoner*/) override
{
events.ScheduleEvent(INTRO_1, 500ms);
me->SetDisableGravity(true);
me->SetReactState(REACT_PASSIVE);
me->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_UNINTERACTIBLE);
Talk(EMOTE_SUMMONED);
}
void JustSummoned(Creature* summon) override
{
BossAI::JustSummoned(summon);
}
void MovementInform(uint32 type, uint32 id) override
{
if (type == WAYPOINT_MOTION_TYPE && id == POINT_KIRTONOS_LAND)
events.ScheduleEvent(INTRO_2, 1500ms);
}
void UpdateAI(uint32 diff) override
{
events.Update(diff);
if (!UpdateVictim())
{
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case INTRO_1:
me->GetMotionMaster()->MovePath(KIRTONOS_PATH, false);
break;
case INTRO_2:
me->GetMotionMaster()->MovePoint(0, PosMove[0]);
events.ScheduleEvent(INTRO_3, 1s);
break;
case INTRO_3:
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
gate->SetGoState(GO_STATE_READY);
me->SetFacingTo(0.01745329f);
events.ScheduleEvent(INTRO_4, 3s);
break;
case INTRO_4:
if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
brazier->SetGoState(GO_STATE_READY);
me->SetWalk(true);
me->SetDisableGravity(false);
DoCast(me, SPELL_KIRTONOS_TRANSFORM);
me->SetCanFly(false);
events.ScheduleEvent(INTRO_5, 1s);
break;
case INTRO_5:
me->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
me->SetVirtualItem(0, uint32(WEAPON_KIRTONOS_STAFF));
me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_UNINTERACTIBLE);
me->SetReactState(REACT_AGGRESSIVE);
events.ScheduleEvent(INTRO_6, 5s);
break;
case INTRO_6:
me->GetMotionMaster()->MovePoint(0, PosMove[1]);
break;
default:
break;
}
}
return;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SWOOP:
DoCast(me, SPELL_SWOOP);
events.ScheduleEvent(EVENT_SWOOP, 15s);
break;
case EVENT_WING_FLAP:
DoCast(me, SPELL_WING_FLAP);
events.ScheduleEvent(EVENT_WING_FLAP, 13s);
break;
case EVENT_PIERCE_ARMOR:
DoCastVictim(SPELL_PIERCE_ARMOR, true);
events.ScheduleEvent(EVENT_PIERCE_ARMOR, 12s);
break;
case EVENT_DISARM:
DoCastVictim(SPELL_DISARM, true);
events.ScheduleEvent(EVENT_DISARM, 11s);
break;
case EVENT_SHADOW_BOLT:
DoCastVictim(SPELL_SHADOW_BOLT, true);
events.ScheduleEvent(EVENT_SHADOW_BOLT, 42s);
break;
case EVENT_CURSE_OF_TONGUES:
DoCastVictim(SPELL_CURSE_OF_TONGUES, true);
events.ScheduleEvent(EVENT_CURSE_OF_TONGUES, 35s);
break;
case EVENT_DOMINATE_MIND:
DoCastVictim(SPELL_DOMINATE_MIND, true);
events.ScheduleEvent(EVENT_DOMINATE_MIND, 44s, 48s);
break;
case EVENT_KIRTONOS_TRANSFORM:
if (me->HasAura(SPELL_KIRTONOS_TRANSFORM))
{
me->RemoveAura(SPELL_KIRTONOS_TRANSFORM);
me->SetVirtualItem(0, uint32(0));
me->SetCanFly(false);
}
else
{
DoCast(me, SPELL_KIRTONOS_TRANSFORM);
me->SetVirtualItem(0, uint32(WEAPON_KIRTONOS_STAFF));
me->SetCanFly(true);
}
events.ScheduleEvent(EVENT_KIRTONOS_TRANSFORM, 16s, 18s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_kirtonos_the_heraldAI>(creature);
brazier->ResetDoorOrButton();
brazier->SetGoState(GO_STATE_READY);
}
};
_JustDied();
}
/*######
## go_brazier_of_the_herald
######*/
void EnterEvadeMode(EvadeReason /*why*/) override
{
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
gate->SetGoState(GO_STATE_ACTIVE);
if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
{
brazier->ResetDoorOrButton();
brazier->SetGoState(GO_STATE_READY);
}
me->DespawnOrUnsummon(5s);
}
void IsSummonedBy(WorldObject* /*summoner*/) override
{
events.ScheduleEvent(INTRO_1, 500ms);
me->SetDisableGravity(true);
me->SetReactState(REACT_PASSIVE);
me->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_UNINTERACTIBLE);
Talk(EMOTE_SUMMONED);
}
void JustSummoned(Creature* summon) override
{
BossAI::JustSummoned(summon);
}
void MovementInform(uint32 type, uint32 id) override
{
if (type == WAYPOINT_MOTION_TYPE && id == POINT_KIRTONOS_LAND)
events.ScheduleEvent(INTRO_2, 1500ms);
}
void UpdateAI(uint32 diff) override
{
events.Update(diff);
if (!UpdateVictim())
{
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case INTRO_1:
me->GetMotionMaster()->MovePath(KIRTONOS_PATH, false);
break;
case INTRO_2:
me->GetMotionMaster()->MovePoint(0, PosMove[0]);
events.ScheduleEvent(INTRO_3, 1s);
break;
case INTRO_3:
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
gate->SetGoState(GO_STATE_READY);
me->SetFacingTo(0.01745329f);
events.ScheduleEvent(INTRO_4, 3s);
break;
case INTRO_4:
if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
brazier->SetGoState(GO_STATE_READY);
me->SetWalk(true);
me->SetDisableGravity(false);
DoCast(me, SPELL_KIRTONOS_TRANSFORM);
me->SetCanFly(false);
events.ScheduleEvent(INTRO_5, 1s);
break;
case INTRO_5:
me->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
me->SetVirtualItem(0, uint32(WEAPON_KIRTONOS_STAFF));
me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_UNINTERACTIBLE);
me->SetReactState(REACT_AGGRESSIVE);
events.ScheduleEvent(INTRO_6, 5s);
break;
case INTRO_6:
me->GetMotionMaster()->MovePoint(0, PosMove[1]);
break;
default:
break;
}
}
return;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SWOOP:
DoCastVictim(SPELL_SWOOP);
events.Repeat(15s);
break;
case EVENT_WING_FLAP:
DoCastSelf(SPELL_WING_FLAP);
events.Repeat(13s);
break;
case EVENT_PIERCE_ARMOR:
DoCastVictim(SPELL_PIERCE_ARMOR);
events.Repeat(12s);
break;
case EVENT_DISARM:
DoCastVictim(SPELL_DISARM);
events.Repeat(11s);
break;
case EVENT_SHADOW_BOLT:
DoCastVictim(SPELL_SHADOW_BOLT);
events.Repeat(42s);
break;
case EVENT_CURSE_OF_TONGUES:
DoCastVictim(SPELL_CURSE_OF_TONGUES);
events.Repeat(35s);
break;
case EVENT_DOMINATE_MIND:
DoCastVictim(SPELL_DOMINATE_MIND);
events.Repeat(44s, 48s);
break;
case EVENT_KIRTONOS_TRANSFORM:
if (me->HasAura(SPELL_KIRTONOS_TRANSFORM))
{
me->RemoveAura(SPELL_KIRTONOS_TRANSFORM);
me->SetVirtualItem(0, uint32(0));
me->SetCanFly(false);
}
else
{
DoCast(me, SPELL_KIRTONOS_TRANSFORM);
me->SetVirtualItem(0, uint32(WEAPON_KIRTONOS_STAFF));
me->SetCanFly(true);
}
events.Repeat(16s, 18s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
enum Brazier_Of_The_Herald
{
@@ -277,32 +264,21 @@ Position const PosSummon[1] =
{ 315.028f, 70.53845f, 102.1496f, 0.3859715f }
};
class go_brazier_of_the_herald : public GameObjectScript
struct go_brazier_of_the_herald : public GameObjectAI
{
public:
go_brazier_of_the_herald() : GameObjectScript("go_brazier_of_the_herald") { }
go_brazier_of_the_herald(GameObject* go) : GameObjectAI(go) { }
struct go_brazier_of_the_heraldAI : public GameObjectAI
{
go_brazier_of_the_heraldAI(GameObject* go) : GameObjectAI(go) { }
bool OnGossipHello(Player* player) override
{
me->UseDoorOrButton();
me->PlayDirectSound(SOUND_SCREECH, 0);
player->SummonCreature(NPC_KIRTONOS, PosSummon[0], TEMPSUMMON_DEAD_DESPAWN, 15min);
return true;
}
};
GameObjectAI* GetAI(GameObject* go) const override
{
return GetScholomanceAI<go_brazier_of_the_heraldAI>(go);
}
bool OnGossipHello(Player* player) override
{
me->UseDoorOrButton();
me->PlayDirectSound(SOUND_SCREECH, 0);
player->SummonCreature(NPC_KIRTONOS, PosSummon[0], TEMPSUMMON_DEAD_DESPAWN, 15min);
return true;
}
};
void AddSC_boss_kirtonos_the_herald()
{
new boss_kirtonos_the_herald();
new go_brazier_of_the_herald;
RegisterScholomanceCreatureAI(boss_kirtonos_the_herald);
RegisterScholomanceGameObjectAI(go_brazier_of_the_herald);
}

242
src/server/scripts/EasternKingdoms/Scholomance/boss_kormok.cpp
View File

@@ -20,201 +20,167 @@
#include "ScriptedCreature.h"
#include "SpellScript.h"
enum Spells
enum KormokSpells
{
SPELL_SHADOWBOLT_VOLLEY = 20741,
SPELL_BONE_SHIELD = 27688,
SPELL_SUMMON_BONE_MAGES = 27695,
SPELL_SUMMON_BONE_MAGE_FRONT_LEFT = 27696,
SPELL_SUMMON_BONE_MAGE_FRONT_RIGHT = 27697,
SPELL_SUMMON_BONE_MAGE_BACK_RIGHT = 27698,
SPELL_SUMMON_BONE_MAGE_BACK_LEFT = 27699,
SPELL_SUMMON_BONE_MINIONS = 27687
SPELL_SUMMON_BONE_MINIONS = 27687,
SPELL_SUMMON_BONE_MINION_FRONT = 27690,
SPELL_SUMMON_BONE_MINION_BACK = 27691,
SPELL_SUMMON_BONE_MINION_LEFT = 27692,
SPELL_SUMMON_BONE_MINION_RIGHT = 27693
};
enum Events
enum KormokEvents
{
EVENT_SHADOWBOLT_VOLLEY = 1,
EVENT_BONE_SHIELD,
EVENT_SUMMON_MAGES,
EVENT_SUMMON_MINIONS
};
class boss_kormok : public CreatureScript
// 16118 - Kormok
struct boss_kormok : public ScriptedAI
{
public:
boss_kormok() : CreatureScript("boss_kormok") { }
boss_kormok(Creature* creature) : ScriptedAI(creature) { }
struct boss_kormokAI : public ScriptedAI
void Reset() override
{
boss_kormokAI(Creature* creature) : ScriptedAI(creature)
{
Initialize();
}
_events.Reset();
}
void Initialize()
{
Mages = false;
}
void JustEngagedWith(Unit* /*who*/) override
{
_events.ScheduleEvent(EVENT_SHADOWBOLT_VOLLEY, 10s);
_events.ScheduleEvent(EVENT_BONE_SHIELD, 2s);
_events.ScheduleEvent(EVENT_SUMMON_MAGES, 10s, 15s);
_events.ScheduleEvent(EVENT_SUMMON_MINIONS, 5s, 10s);
}
void Reset() override
{
Initialize();
events.Reset();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
void JustEngagedWith(Unit* /*who*/) override
{
events.ScheduleEvent(EVENT_SHADOWBOLT_VOLLEY, 10s);
events.ScheduleEvent(EVENT_BONE_SHIELD, 2s);
events.ScheduleEvent(EVENT_SUMMON_MINIONS, 15s);
}
_events.Update(diff);
void JustSummoned(Creature* summoned) override
{
summoned->AI()->AttackStart(me->GetVictim());
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
while (uint32 eventId = _events.ExecuteEvent())
{
if (me->HealthBelowPctDamaged(25, damage) && !Mages)
switch (eventId)
{
DoCast(SPELL_SUMMON_BONE_MAGES);
Mages = true;
case EVENT_SHADOWBOLT_VOLLEY:
DoCastSelf(SPELL_SHADOWBOLT_VOLLEY);
_events.Repeat(15s);
break;
case EVENT_BONE_SHIELD:
DoCastSelf(SPELL_BONE_SHIELD);
_events.Repeat(45s);
break;
case EVENT_SUMMON_MAGES:
DoCastSelf(SPELL_SUMMON_BONE_MAGES);
_events.Repeat(10s, 15s);
break;
case EVENT_SUMMON_MINIONS:
DoCastSelf(SPELL_SUMMON_BONE_MINIONS);
_events.Repeat(20s, 25s);
break;
default:
break;
}
}
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_SHADOWBOLT_VOLLEY:
DoCastVictim(SPELL_SHADOWBOLT_VOLLEY);
events.ScheduleEvent(EVENT_SHADOWBOLT_VOLLEY, 15s);
break;
case EVENT_BONE_SHIELD:
DoCastVictim(SPELL_BONE_SHIELD);
events.ScheduleEvent(EVENT_BONE_SHIELD, 45s);
break;
case EVENT_SUMMON_MINIONS:
DoCast(SPELL_SUMMON_BONE_MINIONS);
events.ScheduleEvent(EVENT_SUMMON_MINIONS, 12s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
private:
EventMap events;
bool Mages;
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_kormokAI>(creature);
DoMeleeAttackIfReady();
}
};
uint32 const SummonMageSpells[4] =
{
SPELL_SUMMON_BONE_MAGE_FRONT_LEFT,
SPELL_SUMMON_BONE_MAGE_FRONT_RIGHT,
SPELL_SUMMON_BONE_MAGE_BACK_RIGHT,
SPELL_SUMMON_BONE_MAGE_BACK_LEFT,
private:
EventMap _events;
};
// 27695 - Summon Bone Mages
class spell_kormok_summon_bone_mages : SpellScriptLoader
class spell_kormok_summon_bone_mages : public SpellScript
{
public:
spell_kormok_summon_bone_mages() : SpellScriptLoader("spell_kormok_summon_bone_mages") { }
PrepareSpellScript(spell_kormok_summon_bone_mages);
class spell_kormok_summon_bone_magesSpellScript : public SpellScript
bool Validate(SpellInfo const* /*spell*/) override
{
return ValidateSpellInfo(
{
PrepareSpellScript(spell_kormok_summon_bone_magesSpellScript);
SPELL_SUMMON_BONE_MAGE_FRONT_LEFT,
SPELL_SUMMON_BONE_MAGE_FRONT_RIGHT,
SPELL_SUMMON_BONE_MAGE_BACK_RIGHT,
SPELL_SUMMON_BONE_MAGE_BACK_LEFT
});
}
bool Validate(SpellInfo const* /*spell*/) override
{
return ValidateSpellInfo(SummonMageSpells);
}
void HandleScript(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
for (uint32 i = 0; i < 2; ++i)
GetCaster()->CastSpell(GetCaster(), SummonMageSpells[urand(0, 3)], true);
}
void Register() override
{
OnEffectHitTarget += SpellEffectFn(spell_kormok_summon_bone_magesSpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const override
void HandleScript(SpellEffIndex /*effIndex*/)
{
Unit* caster = GetCaster();
switch (urand(0, 1))
{
return new spell_kormok_summon_bone_magesSpellScript();
case 0:
caster->CastSpell(caster, SPELL_SUMMON_BONE_MAGE_FRONT_LEFT);
caster->CastSpell(caster, SPELL_SUMMON_BONE_MAGE_FRONT_RIGHT);
break;
case 1:
caster->CastSpell(caster, SPELL_SUMMON_BONE_MAGE_BACK_RIGHT);
caster->CastSpell(caster, SPELL_SUMMON_BONE_MAGE_BACK_LEFT);
break;
}
}
void Register() override
{
OnEffectHit += SpellEffectFn(spell_kormok_summon_bone_mages::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
// 27687 - Summon Bone Minions
class spell_kormok_summon_bone_minions : SpellScriptLoader
class spell_kormok_summon_bone_minions : public SpellScript
{
public:
spell_kormok_summon_bone_minions() : SpellScriptLoader("spell_kormok_summon_bone_minions") { }
PrepareSpellScript(spell_kormok_summon_bone_minions);
class spell_kormok_summon_bone_minionsSpellScript : public SpellScript
bool Validate(SpellInfo const* /*spell*/) override
{
PrepareSpellScript(spell_kormok_summon_bone_minionsSpellScript);
bool Validate(SpellInfo const* /*spell*/) override
return ValidateSpellInfo(
{
return ValidateSpellInfo({ SPELL_SUMMON_BONE_MINIONS });
}
SPELL_SUMMON_BONE_MINION_FRONT,
SPELL_SUMMON_BONE_MINION_BACK,
SPELL_SUMMON_BONE_MINION_LEFT,
SPELL_SUMMON_BONE_MINION_RIGHT
});
}
void HandleScript(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
// Possible spells to handle this not found.
for (uint32 i = 0; i < 4; ++i)
GetCaster()->SummonCreature(NPC_BONE_MINION, GetCaster()->GetPositionX() + float(irand(-7, 7)), GetCaster()->GetPositionY() + float(irand(-7, 7)), GetCaster()->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 2min);
}
void Register() override
{
OnEffectHitTarget += SpellEffectFn(spell_kormok_summon_bone_minionsSpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const override
void HandleScript(SpellEffIndex /*effIndex*/)
{
return new spell_kormok_summon_bone_minionsSpellScript();
Unit* caster = GetCaster();
caster->CastSpell(caster, SPELL_SUMMON_BONE_MINION_FRONT);
caster->CastSpell(caster, SPELL_SUMMON_BONE_MINION_BACK);
caster->CastSpell(caster, SPELL_SUMMON_BONE_MINION_LEFT);
caster->CastSpell(caster, SPELL_SUMMON_BONE_MINION_RIGHT);
}
void Register() override
{
OnEffectHit += SpellEffectFn(spell_kormok_summon_bone_minions::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
void AddSC_boss_kormok()
{
new boss_kormok();
new spell_kormok_summon_bone_mages();
new spell_kormok_summon_bone_minions();
RegisterScholomanceCreatureAI(boss_kormok);
RegisterSpellScript(spell_kormok_summon_bone_mages);
RegisterSpellScript(spell_kormok_summon_bone_minions);
}

118
src/server/scripts/EasternKingdoms/Scholomance/boss_lord_alexei_barov.cpp
View File

@@ -15,94 +15,78 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/* ScriptData
SDName: Boss_Lord_Alexei_Barov
SD%Complete: 100
SDComment: aura applied/defined in database
SDCategory: Scholomance
EndScriptData */
#include "scholomance.h"
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
enum Spells
enum AlexeiSpells
{
SPELL_IMMOLATE = 20294,
SPELL_VEILOFSHADOW = 17820,
SPELL_VEIL_OF_SHADOW = 17820,
SPELL_UNHOLY_AURA = 17467
};
enum Events
enum AlexeiEvents
{
EVENT_IMMOLATE = 1,
EVENT_VEILOFSHADOW = 2
EVENT_IMMOLATE = 1,
EVENT_VEIL_OF_SHADOW
};
class boss_lord_alexei_barov : public CreatureScript
// 10504 - Lord Alexei Barov
struct boss_lord_alexei_barov : public BossAI
{
public: boss_lord_alexei_barov() : CreatureScript("boss_lord_alexei_barov") { }
boss_lord_alexei_barov(Creature* creature) : BossAI(creature, DATA_LORD_ALEXEI_BAROV) { }
struct boss_lordalexeibarovAI : public BossAI
void Reset() override
{
_Reset();
if (!me->HasAura(SPELL_UNHOLY_AURA))
DoCastSelf(SPELL_UNHOLY_AURA);
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_IMMOLATE, 7s);
events.ScheduleEvent(EVENT_VEIL_OF_SHADOW, 15s);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
boss_lordalexeibarovAI(Creature* creature) : BossAI(creature, DATA_LORD_ALEXEI_BAROV) { }
void Reset() override
switch (eventId)
{
_Reset();
if (!me->HasAura(SPELL_UNHOLY_AURA))
DoCast(me, SPELL_UNHOLY_AURA);
case EVENT_IMMOLATE:
DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_IMMOLATE);
events.Repeat(12s);
break;
case EVENT_VEIL_OF_SHADOW:
DoCastVictim(SPELL_VEIL_OF_SHADOW);
events.Repeat(20s);
break;
default:
break;
}
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_IMMOLATE, 7s);
events.ScheduleEvent(EVENT_VEILOFSHADOW, 15s);
}
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_IMMOLATE:
DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_IMMOLATE, true);
events.ScheduleEvent(EVENT_IMMOLATE, 12s);
break;
case EVENT_VEILOFSHADOW:
DoCastVictim(SPELL_VEILOFSHADOW, true);
events.ScheduleEvent(EVENT_VEILOFSHADOW, 20s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_lordalexeibarovAI>(creature);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
void AddSC_boss_lordalexeibarov()
{
new boss_lord_alexei_barov();
RegisterScholomanceCreatureAI(boss_lord_alexei_barov);
}

132
src/server/scripts/EasternKingdoms/Scholomance/boss_lorekeeper_polkelt.cpp
View File

@@ -15,99 +15,83 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
Name: Boss_Lorekeeper_Polkelt
%Complete: 100
Comment:
Category: Scholomance
*/
#include "scholomance.h"
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
enum Spells
enum PolkeltSpells
{
SPELL_VOLATILEINFECTION = 24928,
SPELL_DARKPLAGUE = 18270,
SPELL_CORROSIVEACID = 23313,
SPELL_NOXIOUSCATALYST = 18151
SPELL_VOLATILE_INFECTION = 24928,
SPELL_DARK_PLAGUE = 18270,
SPELL_CORROSIVE_ACID = 23313,
SPELL_NOXIOUS_CATALYST = 18151
};
enum Events
enum PolkeltEvents
{
EVENT_VOLATILEINFECTION = 1,
EVENT_DARKPLAGUE = 2,
EVENT_CORROSIVEACID = 3,
EVENT_NOXIOUSCATALYST = 4
EVENT_VOLATILE_INFECTION = 1,
EVENT_DARK_PLAGUE,
EVENT_CORROSIVE_ACID,
EVENT_NOXIOUS_CATALYST
};
class boss_lorekeeper_polkelt : public CreatureScript
// 10901 - Lorekeeper Polkelt
struct boss_lorekeeper_polkelt : public BossAI
{
public: boss_lorekeeper_polkelt() : CreatureScript("boss_lorekeeper_polkelt") { }
boss_lorekeeper_polkelt(Creature* creature) : BossAI(creature, DATA_LOREKEEPER_POLKELT) { }
struct boss_lorekeeperpolkeltAI : public BossAI
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_VOLATILE_INFECTION, 38s);
events.ScheduleEvent(EVENT_DARK_PLAGUE, 8s);
events.ScheduleEvent(EVENT_CORROSIVE_ACID, 45s);
events.ScheduleEvent(EVENT_NOXIOUS_CATALYST, 35s);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
boss_lorekeeperpolkeltAI(Creature* creature) : BossAI(creature, DATA_LOREKEEPER_POLKELT) { }
void JustEngagedWith(Unit* who) override
switch (eventId)
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_VOLATILEINFECTION, 38s);
events.ScheduleEvent(EVENT_DARKPLAGUE, 8s);
events.ScheduleEvent(EVENT_CORROSIVEACID, 45s);
events.ScheduleEvent(EVENT_NOXIOUSCATALYST, 35s);
case EVENT_VOLATILE_INFECTION:
DoCastVictim(SPELL_VOLATILE_INFECTION);
events.Repeat(32s);
break;
case EVENT_DARK_PLAGUE:
DoCastVictim(SPELL_DARK_PLAGUE);
events.Repeat(8s);
break;
case EVENT_CORROSIVE_ACID:
DoCastSelf(SPELL_CORROSIVE_ACID);
events.Repeat(25s);
break;
case EVENT_NOXIOUS_CATALYST:
DoCastVictim(SPELL_NOXIOUS_CATALYST);
events.Repeat(38s);
break;
default:
break;
}
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_VOLATILEINFECTION:
DoCastVictim(SPELL_VOLATILEINFECTION, true);
events.ScheduleEvent(EVENT_VOLATILEINFECTION, 32s);
break;
case EVENT_DARKPLAGUE:
DoCastVictim(SPELL_DARKPLAGUE, true);
events.ScheduleEvent(EVENT_DARKPLAGUE, 8s);
break;
case EVENT_CORROSIVEACID:
DoCastVictim(SPELL_CORROSIVEACID, true);
events.ScheduleEvent(EVENT_CORROSIVEACID, 25s);
break;
case EVENT_NOXIOUSCATALYST:
DoCastVictim(SPELL_NOXIOUSCATALYST, true);
events.ScheduleEvent(EVENT_NOXIOUSCATALYST, 38s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_lorekeeperpolkeltAI>(creature);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
void AddSC_boss_lorekeeperpolkelt()
{
new boss_lorekeeper_polkelt();
RegisterScholomanceCreatureAI(boss_lorekeeper_polkelt);
}

140
src/server/scripts/EasternKingdoms/Scholomance/boss_ras_frostwhisper.cpp
View File

@@ -19,17 +19,17 @@
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
enum Spells
enum RasSpells
{
SPELL_FROSTBOLT = 21369,
SPELL_ICE_ARMOR = 18100, // This is actually a buff he gives himself
SPELL_FREEZE = 18763,
SPELL_FEAR = 26070,
SPELL_CHILL_NOVA = 18099,
SPELL_FROSTVOLLEY = 8398
SPELL_FROSTBOLT_VOLLEY = 8398
};
enum Events
enum RasEvents
{
EVENT_FROSTBOLT = 1,
EVENT_ICE_ARMOR,
@@ -39,91 +39,81 @@ enum Events
EVENT_FROSTVOLLEY
};
class boss_boss_ras_frostwhisper : public CreatureScript
// 10508 - Ras Frostwhisper
struct boss_boss_ras_frostwhisper : public ScriptedAI
{
public:
boss_boss_ras_frostwhisper() : CreatureScript("boss_boss_ras_frostwhisper") { }
boss_boss_ras_frostwhisper(Creature* creature) : ScriptedAI(creature) { }
struct boss_rasfrostAI : public ScriptedAI
void Reset() override
{
boss_rasfrostAI(Creature* creature) : ScriptedAI(creature) { }
_events.Reset();
DoCastSelf(SPELL_ICE_ARMOR);
}
void Reset() override
void JustEngagedWith(Unit* /*who*/) override
{
_events.ScheduleEvent(EVENT_ICE_ARMOR, 2s);
_events.ScheduleEvent(EVENT_FROSTBOLT, 8s);
_events.ScheduleEvent(EVENT_CHILL_NOVA, 12s);
_events.ScheduleEvent(EVENT_FREEZE, 18s);
_events.ScheduleEvent(EVENT_FEAR, 45s);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = _events.ExecuteEvent())
{
events.Reset();
DoCast(me, SPELL_ICE_ARMOR);
}
void JustEngagedWith(Unit* /*who*/) override
{
events.ScheduleEvent(EVENT_ICE_ARMOR, 2s);
events.ScheduleEvent(EVENT_FROSTBOLT, 8s);
events.ScheduleEvent(EVENT_CHILL_NOVA, 12s);
events.ScheduleEvent(EVENT_FREEZE, 18s);
events.ScheduleEvent(EVENT_FEAR, 45s);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
switch (eventId)
{
case EVENT_ICE_ARMOR:
DoCastSelf(SPELL_ICE_ARMOR);
_events.Repeat(3min);
break;
case EVENT_FROSTBOLT:
if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 40.0f, true))
DoCast(target, SPELL_FROSTBOLT);
_events.Repeat(8s);
break;
case EVENT_FREEZE:
DoCastVictim(SPELL_FREEZE);
_events.Repeat(24s);
break;
case EVENT_FEAR:
DoCastSelf(SPELL_FEAR);
_events.Repeat(30s);
break;
case EVENT_CHILL_NOVA:
DoCastSelf(SPELL_CHILL_NOVA);
_events.Repeat(14s);
break;
case EVENT_FROSTVOLLEY:
DoCastVictim(SPELL_FROSTBOLT_VOLLEY);
_events.Repeat(15s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ICE_ARMOR:
DoCast(me, SPELL_ICE_ARMOR);
events.ScheduleEvent(EVENT_ICE_ARMOR, 3min);
break;
case EVENT_FROSTBOLT:
if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 40.0f, true))
DoCast(target, SPELL_FROSTBOLT);
events.ScheduleEvent(EVENT_FROSTBOLT, 8s);
break;
case EVENT_FREEZE:
DoCastVictim(SPELL_FREEZE);
events.ScheduleEvent(EVENT_FREEZE, 24s);
break;
case EVENT_FEAR:
DoCastVictim(SPELL_FEAR);
events.ScheduleEvent(EVENT_FEAR, 30s);
break;
case EVENT_CHILL_NOVA:
DoCastVictim(SPELL_CHILL_NOVA);
events.ScheduleEvent(EVENT_CHILL_NOVA, 14s);
break;
case EVENT_FROSTVOLLEY:
DoCastVictim(SPELL_FROSTVOLLEY);
events.ScheduleEvent(EVENT_FROSTVOLLEY, 15s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
private:
EventMap events;
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_rasfrostAI>(creature);
DoMeleeAttackIfReady();
}
private:
EventMap _events;
};
void AddSC_boss_rasfrost()
{
new boss_boss_ras_frostwhisper();
RegisterScholomanceCreatureAI(boss_boss_ras_frostwhisper);
}

128
src/server/scripts/EasternKingdoms/Scholomance/boss_the_ravenian.cpp
View File

@@ -15,99 +15,83 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
Name: Boss_the_ravenian
%Complete: 100
Comment:
Category: Scholomance
*/
#include "scholomance.h"
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
enum Spells
enum RavenianSpells
{
SPELL_TRAMPLE = 15550,
SPELL_CLEAVE = 20691,
SPELL_SUNDERINCLEAVE = 25174,
SPELL_KNOCKAWAY = 10101
SPELL_SUNDERING_CLEAVE = 25174,
SPELL_KNOCK_AWAY = 10101
};
enum Events
enum RavenianEvents
{
EVENT_TRAMPLE = 1,
EVENT_CLEAVE = 2,
EVENT_SUNDERINCLEAVE = 3,
EVENT_KNOCKAWAY = 4
EVENT_TRAMPLE = 1,
EVENT_CLEAVE,
EVENT_SUNDERING_CLEAVE,
EVENT_KNOCK_AWAY
};
class boss_the_ravenian : public CreatureScript
// 10507 - The Ravenian
struct boss_the_ravenian : public BossAI
{
public: boss_the_ravenian() : CreatureScript("boss_the_ravenian") { }
boss_the_ravenian(Creature* creature) : BossAI(creature, DATA_THE_RAVENIAN) { }
struct boss_theravenianAI : public BossAI
void JustEngagedWith(Unit* who) override
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_TRAMPLE, 24s);
events.ScheduleEvent(EVENT_CLEAVE, 15s);
events.ScheduleEvent(EVENT_SUNDERING_CLEAVE, 40s);
events.ScheduleEvent(EVENT_KNOCK_AWAY, 32s);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
boss_theravenianAI(Creature* creature) : BossAI(creature, DATA_THE_RAVENIAN) { }
void JustEngagedWith(Unit* who) override
switch (eventId)
{
BossAI::JustEngagedWith(who);
events.ScheduleEvent(EVENT_TRAMPLE, 24s);
events.ScheduleEvent(EVENT_CLEAVE, 15s);
events.ScheduleEvent(EVENT_SUNDERINCLEAVE, 40s);
events.ScheduleEvent(EVENT_KNOCKAWAY, 32s);
case EVENT_TRAMPLE:
DoCastSelf(SPELL_TRAMPLE);
events.Repeat(10s);
break;
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE);
events.Repeat(7s);
break;
case EVENT_SUNDERING_CLEAVE:
DoCastVictim(SPELL_SUNDERING_CLEAVE);
events.Repeat(20s);
break;
case EVENT_KNOCK_AWAY:
DoCastVictim(SPELL_KNOCK_AWAY);
events.Repeat(12s);
break;
default:
break;
}
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_TRAMPLE:
DoCastVictim(SPELL_TRAMPLE, true);
events.ScheduleEvent(EVENT_TRAMPLE, 10s);
break;
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE, true);
events.ScheduleEvent(EVENT_CLEAVE, 7s);
break;
case EVENT_SUNDERINCLEAVE:
DoCastVictim(SPELL_SUNDERINCLEAVE, true);
events.ScheduleEvent(EVENT_SUNDERINCLEAVE, 20s);
break;
case EVENT_KNOCKAWAY:
DoCastVictim(SPELL_KNOCKAWAY, true);
events.ScheduleEvent(EVENT_KNOCKAWAY, 12s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_theravenianAI>(creature);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
};
void AddSC_boss_theravenian()
{
new boss_the_ravenian();
RegisterScholomanceCreatureAI(boss_the_ravenian);
}

116
src/server/scripts/EasternKingdoms/Scholomance/boss_vectus.cpp
View File

@@ -19,12 +19,12 @@
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
enum Emotes
enum VectusTexts
{
EMOTE_FRENZY = 0
};
enum Spells
enum VectusSpells
{
SPELL_FLAMESTRIKE = 18399,
SPELL_BLAST_WAVE = 16046,
@@ -32,92 +32,78 @@ enum Spells
SPELL_FRENZY = 8269 // 28371
};
enum Events
enum VectusEvents
{
EVENT_FIRE_SHIELD = 1,
EVENT_BLAST_WAVE,
EVENT_FRENZY
};
class boss_vectus : public CreatureScript
// 10432 - Vectus
struct boss_vectus : public ScriptedAI
{
public:
boss_vectus() : CreatureScript("boss_vectus") { }
boss_vectus(Creature* creature) : ScriptedAI(creature) { }
struct boss_vectusAI : public ScriptedAI
void Reset() override
{
boss_vectusAI(Creature* creature) : ScriptedAI(creature) { }
_events.Reset();
}
void Reset() override
{
events.Reset();
}
void JustEngagedWith(Unit* /*who*/) override
{
_events.ScheduleEvent(EVENT_FIRE_SHIELD, 2s);
_events.ScheduleEvent(EVENT_BLAST_WAVE, 14s);
}
void JustEngagedWith(Unit* /*who*/) override
{
events.ScheduleEvent(EVENT_FIRE_SHIELD, 2s);
events.ScheduleEvent(EVENT_BLAST_WAVE, 14s);
}
void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
{
if (!me->HasAura(SPELL_FRENZY) && me->HealthBelowPctDamaged(25, damage))
_events.ScheduleEvent(EVENT_FRENZY, 0s);
}
void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = _events.ExecuteEvent())
{
if (me->HealthBelowPctDamaged(25, damage))
switch (eventId)
{
DoCast(me, SPELL_FRENZY);
Talk(EMOTE_FRENZY);
events.ScheduleEvent(EVENT_FRENZY, 24s);
case EVENT_FIRE_SHIELD:
DoCastSelf(SPELL_FIRE_SHIELD);
_events.Repeat(90s);
break;
case EVENT_BLAST_WAVE:
DoCastSelf(SPELL_BLAST_WAVE);
_events.Repeat(12s);
break;
case EVENT_FRENZY:
DoCastSelf(SPELL_FRENZY);
Talk(EMOTE_FRENZY);
_events.Repeat(24s);
break;
default:
break;
}
}
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_FIRE_SHIELD:
DoCast(me, SPELL_FIRE_SHIELD);
events.ScheduleEvent(EVENT_FIRE_SHIELD, 90s);
break;
case EVENT_BLAST_WAVE:
DoCast(me, SPELL_BLAST_WAVE);
events.ScheduleEvent(EVENT_BLAST_WAVE, 12s);
break;
case EVENT_FRENZY:
DoCast(me, SPELL_FRENZY);
Talk(EMOTE_FRENZY);
events.ScheduleEvent(EVENT_FRENZY, 24s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
private:
EventMap events;
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetScholomanceAI<boss_vectusAI>(creature);
DoMeleeAttackIfReady();
}
private:
EventMap _events;
};
void AddSC_boss_vectus()
{
new boss_vectus();
RegisterScholomanceCreatureAI(boss_vectus);
}

3
src/server/scripts/EasternKingdoms/Scholomance/scholomance.h
View File

@@ -62,4 +62,7 @@ inline AI* GetScholomanceAI(T* obj)
return GetInstanceAI<AI>(obj, ScholomanceScriptName);
}
#define RegisterScholomanceCreatureAI(ai_name) RegisterCreatureAIWithFactory(ai_name, GetScholomanceAI)
#define RegisterScholomanceGameObjectAI(ai_name) RegisterGameObjectAIWithFactory(ai_name, GetScholomanceAI)
#endif