Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-16 07:30:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

Core/Scripting: Update Scholomance Scripts

Browse Source
This commit is contained in:
Malcrom
2013-01-08 00:47:20 -03:30
parent f81f8ec41b
commit 7c5597a697
9 changed files with 496 additions and 474 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -27,94 +27,97 @@ EndScriptData */
#include "ScriptedCreature.h"
#include "scholomance.h"
enum eEnums
enum Say
{
EMOTE_FRENZY_KILL = 0,
};
enum Spells
{
SPELL_REND = 16509,
SPELL_BACKHAND = 18103,
SPELL_FRENZY = 8269
};
enum Events
{
EVENT_REND = 1,
EVENT_BACKHAND = 2,
EVENT_FRENZY = 3
};
class boss_doctor_theolen_krastinov : public CreatureScript
{
public:
boss_doctor_theolen_krastinov() : CreatureScript("boss_doctor_theolen_krastinov") { }
public: boss_doctor_theolen_krastinov() : CreatureScript("boss_doctor_theolen_krastinov") { }
CreatureAI* GetAI(Creature* creature) const
{
return new boss_theolenkrastinovAI (creature);
}
struct boss_theolenkrastinovAI : public ScriptedAI
{
boss_theolenkrastinovAI(Creature* creature) : ScriptedAI(creature) {}
uint32 m_uiRend_Timer;
uint32 m_uiBackhand_Timer;
uint32 m_uiFrenzy_Timer;
void Reset()
struct boss_theolenkrastinovAI : public BossAI
{
m_uiRend_Timer = 8000;
m_uiBackhand_Timer = 9000;
m_uiFrenzy_Timer = 1000;
}
boss_theolenkrastinovAI(Creature* creature) : BossAI(creature, DATA_DOCTORTHEOLENKRASTINOV) {}
void JustDied(Unit* /*killer*/)
{
InstanceScript* instance = me->GetInstanceScript();
if (instance)
void Reset() {}
void JustDied(Unit* /*killer*/)
{
instance->SetData(DATA_DOCTORTHEOLENKRASTINOV_DEATH, 0);
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
InstanceScript* instance = me->GetInstanceScript();
if (instance)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
instance->SetData(DATA_DOCTORTHEOLENKRASTINOV, DONE);
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
}
}
}
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
//Rend_Timer
if (m_uiRend_Timer <= uiDiff)
void EnterCombat(Unit* /*who*/)
{
DoCast(me->getVictim(), SPELL_REND);
m_uiRend_Timer = 10000;
events.ScheduleEvent(EVENT_REND, 8000);
events.ScheduleEvent(EVENT_BACKHAND, 9000);
events.ScheduleEvent(EVENT_FRENZY, 1000);
}
else
m_uiRend_Timer -= uiDiff;
//Backhand_Timer
if (m_uiBackhand_Timer <= uiDiff)
void UpdateAI(uint32 const diff)
{
DoCast(me->getVictim(), SPELL_BACKHAND);
m_uiBackhand_Timer = 10000;
}
else
m_uiBackhand_Timer -= uiDiff;
if (!UpdateVictim())
return;
//Frenzy_Timer
if (HealthBelowPct(26))
{
if (m_uiFrenzy_Timer <= uiDiff)
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
DoCast(me, SPELL_FRENZY);
Talk(EMOTE_FRENZY_KILL);
m_uiFrenzy_Timer = 120000;
switch (eventId)
{
case EVENT_REND:
DoCastVictim(SPELL_REND, true);
events.ScheduleEvent(EVENT_REND, 10000);
break;
case EVENT_BACKHAND:
DoCastVictim(SPELL_BACKHAND, true);
events.ScheduleEvent(EVENT_BACKHAND, 10000);
break;
case EVENT_FRENZY:
DoCast(me, SPELL_FRENZY, true);
Talk(EMOTE_FRENZY_KILL);
events.ScheduleEvent(EVENT_FRENZY, 120000);
break;
default:
break;
}
}
else
m_uiFrenzy_Timer -= uiDiff;
}
DoMeleeAttackIfReady();
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_theolenkrastinovAI (creature);
}
};
};

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

@@ -27,97 +27,98 @@ EndScriptData */
#include "ScriptedCreature.h"
#include "scholomance.h"
#define SPELL_CURSEOFAGONY 18671
#define SPELL_SHADOWSHOCK 20603
#define SPELL_SILENCE 15487
#define SPELL_FEAR 6215
enum Spells
{
SPELL_CURSEOFAGONY = 34794,
SPELL_SHADOWSHOCK = 34799,
SPELL_SILENCE = 34803,
SPELL_FEAR = 34803
};
enum Events
{
EVENT_CURSEOFAGONY = 1,
EVENT_SHADOWSHOCK = 2,
EVENT_SILENCE = 3,
EVENT_FEAR = 4
};
class boss_illucia_barov : public CreatureScript
{
public:
boss_illucia_barov() : CreatureScript("boss_illucia_barov") { }
public: boss_illucia_barov() : CreatureScript("boss_illucia_barov") { }
CreatureAI* GetAI(Creature* creature) const
{
return new boss_illuciabarovAI (creature);
}
struct boss_illuciabarovAI : public ScriptedAI
{
boss_illuciabarovAI(Creature* creature) : ScriptedAI(creature) {}
uint32 CurseOfAgony_Timer;
uint32 ShadowShock_Timer;
uint32 Silence_Timer;
uint32 Fear_Timer;
void Reset()
struct boss_illuciabarovAI : public BossAI
{
CurseOfAgony_Timer = 18000;
ShadowShock_Timer = 9000;
Silence_Timer = 5000;
Fear_Timer = 30000;
}
boss_illuciabarovAI(Creature* creature) : BossAI(creature,DATA_LADYILLUCIABAROV) {}
void JustDied(Unit* /*killer*/)
{
InstanceScript* instance = me->GetInstanceScript();
if (instance)
void Reset() {}
void JustDied(Unit* /*killer*/)
{
instance->SetData(DATA_LADYILLUCIABAROV_DEATH, 0);
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
InstanceScript* instance = me->GetInstanceScript();
if (instance)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
instance->SetData(DATA_LADYILLUCIABAROV, DONE);
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
}
}
}
}
void EnterCombat(Unit* /*who*/)
void EnterCombat(Unit* /*who*/)
{
events.ScheduleEvent(EVENT_CURSEOFAGONY, 18000);
events.ScheduleEvent(EVENT_SHADOWSHOCK, 9000);
events.ScheduleEvent(EVENT_SILENCE, 5000);
events.ScheduleEvent(EVENT_FEAR, 30000);
}
void UpdateAI(uint32 const diff)
{
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, 30000);
break;
case EVENT_SHADOWSHOCK:
DoCast(SelectTarget(SELECT_TARGET_RANDOM,0, 100, true),SPELL_SHADOWSHOCK,true);
events.ScheduleEvent(EVENT_SHADOWSHOCK, 12000);
break;
case EVENT_SILENCE:
DoCastVictim(SPELL_SILENCE, true);
events.ScheduleEvent(EVENT_SILENCE, 14000);
break;
case EVENT_FEAR:
DoCastVictim(SPELL_FEAR, true);
events.ScheduleEvent(EVENT_FEAR, 30000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_illuciabarovAI (creature);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
//CurseOfAgony_Timer
if (CurseOfAgony_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_CURSEOFAGONY);
CurseOfAgony_Timer = 30000;
} else CurseOfAgony_Timer -= diff;
//ShadowShock_Timer
if (ShadowShock_Timer <= diff)
{
Unit* target = NULL;
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target) DoCast(target, SPELL_SHADOWSHOCK);
ShadowShock_Timer = 12000;
} else ShadowShock_Timer -= diff;
//Silence_Timer
if (Silence_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_SILENCE);
Silence_Timer = 14000;
} else Silence_Timer -= diff;
//Fear_Timer
if (Fear_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_FEAR);
Fear_Timer = 30000;
} else Fear_Timer -= diff;
DoMeleeAttackIfReady();
}
};
};
void AddSC_boss_illuciabarov()

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

@@ -27,133 +27,133 @@ EndScriptData */
#include "ScriptedCreature.h"
#include "scholomance.h"
#define SPELL_CALLOFGRAVES 17831
#define SPELL_CORRUPTION 11672
#define SPELL_FLASHHEAL 10917
#define SPELL_RENEW 10929
#define SPELL_HEALINGTOUCH 9889
enum Spells
{
SPELL_CALLOFGRAVES = 17831,
SPELL_CORRUPTION = 11672,
SPELL_FLASHHEAL = 10917,
SPELL_RENEW = 10929,
SPELL_HEALINGTOUCH = 9889
};
enum Events
{
EVENT_CALLOFGRAVES = 1,
EVENT_CORRUPTION = 2,
EVENT_FLASHHEAL = 3,
EVENT_RENEW = 4,
EVENT_HEALINGTOUCH = 5
};
class boss_instructor_malicia : public CreatureScript
{
public:
boss_instructor_malicia() : CreatureScript("boss_instructor_malicia") { }
public: boss_instructor_malicia() : CreatureScript("boss_instructor_malicia") { }
CreatureAI* GetAI(Creature* creature) const
{
return new boss_instructormaliciaAI (creature);
}
struct boss_instructormaliciaAI : public ScriptedAI
{
boss_instructormaliciaAI(Creature* creature) : ScriptedAI(creature) {}
uint32 CallOfGraves_Timer;
uint32 Corruption_Timer;
uint32 FlashHeal_Timer;
uint32 Renew_Timer;
uint32 HealingTouch_Timer;
uint32 FlashCounter;
uint32 TouchCounter;
void Reset()
struct boss_instructormaliciaAI : public BossAI
{
CallOfGraves_Timer = 4000;
Corruption_Timer = 8000;
FlashHeal_Timer = 38000;
Renew_Timer = 32000;
HealingTouch_Timer = 45000;
FlashCounter = 0;
TouchCounter = 0;
}
boss_instructormaliciaAI(Creature* creature) : BossAI(creature, DATA_INSTRUCTORMALICIA) {}
void JustDied(Unit* /*killer*/)
{
InstanceScript* instance = me->GetInstanceScript();
if (instance)
uint32 FlashCounter;
uint32 TouchCounter;
void Reset()
{
instance->SetData(DATA_INSTRUCTORMALICIA_DEATH, 0);
FlashCounter = 0;
TouchCounter = 0;
}
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
void JustDied(Unit* /*killer*/)
{
InstanceScript* instance = me->GetInstanceScript();
if (instance)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
instance->SetData(DATA_INSTRUCTORMALICIA, DONE);
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
}
}
}
}
void EnterCombat(Unit* /*who*/)
void EnterCombat(Unit* /*who*/)
{
events.ScheduleEvent(EVENT_CALLOFGRAVES, 4000);
events.ScheduleEvent(EVENT_CORRUPTION, 8000);
events.ScheduleEvent(EVENT_RENEW, 32000);
events.ScheduleEvent(EVENT_FLASHHEAL, 38000);
events.ScheduleEvent(EVENT_HEALINGTOUCH, 45000);
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CALLOFGRAVES:
DoCastVictim(SPELL_CALLOFGRAVES, true);
events.ScheduleEvent(EVENT_CALLOFGRAVES, 65000);
break;
case EVENT_CORRUPTION:
DoCast(SelectTarget(SELECT_TARGET_RANDOM,0, 100, true),SPELL_CORRUPTION,true);
events.ScheduleEvent(EVENT_CORRUPTION, 24000);
break;
case EVENT_RENEW:
DoCast(me, SPELL_RENEW);
events.ScheduleEvent(EVENT_RENEW, 10000);
break;
case EVENT_FLASHHEAL:
//5 Flashheals will be casted
DoCast(me, SPELL_FLASHHEAL);
if (FlashCounter < 2)
{
events.ScheduleEvent(EVENT_FLASHHEAL, 5000);
++FlashCounter;
}
else
{
FlashCounter=0;
events.ScheduleEvent(EVENT_FLASHHEAL, 30000);
}
break;
case EVENT_HEALINGTOUCH:
//3 Healing Touch will be casted
DoCast(me, SPELL_HEALINGTOUCH);
if (TouchCounter < 2)
{
events.ScheduleEvent(EVENT_HEALINGTOUCH, 5500);
++TouchCounter;
}
else
{
TouchCounter=0;
events.ScheduleEvent(EVENT_HEALINGTOUCH, 30000);
}
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_instructormaliciaAI (creature);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
//CallOfGraves_Timer
if (CallOfGraves_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_CALLOFGRAVES);
CallOfGraves_Timer = 65000;
} else CallOfGraves_Timer -= diff;
//Corruption_Timer
if (Corruption_Timer <= diff)
{
Unit* target = NULL;
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target) DoCast(target, SPELL_CORRUPTION);
Corruption_Timer = 24000;
} else Corruption_Timer -= diff;
//Renew_Timer
if (Renew_Timer <= diff)
{
DoCast(me, SPELL_RENEW);
Renew_Timer = 10000;
} else Renew_Timer -= diff;
//FlashHeal_Timer
if (FlashHeal_Timer <= diff)
{
DoCast(me, SPELL_FLASHHEAL);
//5 Flashheals will be casted
if (FlashCounter < 2)
{
FlashHeal_Timer = 5000;
++FlashCounter;
}
else
{
FlashCounter=0;
FlashHeal_Timer = 30000;
}
} else FlashHeal_Timer -= diff;
//HealingTouch_Timer
if (HealingTouch_Timer <= diff)
{
DoCast(me, SPELL_HEALINGTOUCH);
//3 Healingtouchs will be casted
if (HealingTouch_Timer < 2)
{
HealingTouch_Timer = 5500;
++TouchCounter;
}
else
{
TouchCounter=0;
HealingTouch_Timer = 30000;
}
} else HealingTouch_Timer -= diff;
DoMeleeAttackIfReady();
}
};
};
void AddSC_boss_instructormalicia()

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

@@ -103,7 +103,8 @@ class boss_kirtonos_the_herald : public CreatureScript
brazier->ResetDoorOrButton();
brazier->SetGoState(GO_STATE_READY);
}
_JustDied();
if (instance)
instance->SetData(TYPE_KIRTONOS, DONE);
}
void EnterEvadeMode()
@@ -173,6 +174,7 @@ class boss_kirtonos_the_herald : public CreatureScript
me->SetWalk(true);
me->SetDisableGravity(false);
DoCast(me, SPELL_KIRTONOS_TRANSFORM);
me->SetCanFly(false);
_introTimer = 1000;
_introEvent = INTRO_5;
break;
@@ -184,7 +186,6 @@ class boss_kirtonos_the_herald : public CreatureScript
_introTimer = 5000;
_introEvent = INTRO_6;
case INTRO_6:
// I don't know how to make him not swim across screen here. Tell me and I will fix.
me->GetMotionMaster()->MovePoint(0, 314.8673f, 90.3021f, 101.6459f);
_introTimer = 0;
_introEvent = 0;
@@ -240,11 +241,13 @@ class boss_kirtonos_the_herald : public CreatureScript
{
me->RemoveAura(SPELL_KIRTONOS_TRANSFORM);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(0));
me->SetCanFly(false);
}
else
{
DoCast(me, SPELL_KIRTONOS_TRANSFORM);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(WEAPON_KIRTONOS_STAFF));
me->SetCanFly(true);
}
events.ScheduleEvent(EVENT_KIRTONOS_TRANSFORM, urand(16000, 18000));
break;

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

@@ -27,79 +27,87 @@ EndScriptData */
#include "ScriptedCreature.h"
#include "scholomance.h"
#define SPELL_IMMOLATE 20294 // Old ID was 15570
#define SPELL_VEILOFSHADOW 17820
enum Spells
{
SPELL_IMMOLATE = 20294, // Old ID was 15570
SPELL_VEILOFSHADOW = 17820
};
enum Events
{
EVENT_IMMOLATE = 1,
EVENT_VEILOFSHADOW = 2
};
class boss_lord_alexei_barov : public CreatureScript
{
public:
boss_lord_alexei_barov() : CreatureScript("boss_lord_alexei_barov") { }
public: boss_lord_alexei_barov() : CreatureScript("boss_lord_alexei_barov") { }
CreatureAI* GetAI(Creature* creature) const
{
return new boss_lordalexeibarovAI (creature);
}
struct boss_lordalexeibarovAI : public ScriptedAI
{
boss_lordalexeibarovAI(Creature* creature) : ScriptedAI(creature) {}
uint32 Immolate_Timer;
uint32 VeilofShadow_Timer;
void Reset()
struct boss_lordalexeibarovAI : public BossAI
{
Immolate_Timer = 7000;
VeilofShadow_Timer = 15000;
boss_lordalexeibarovAI(Creature* creature) : BossAI(creature, DATA_LORDALEXEIBAROV) {}
me->LoadCreaturesAddon();
}
void JustDied(Unit* /*killer*/)
{
InstanceScript* instance = me->GetInstanceScript();
if (instance)
void Reset()
{
instance->SetData(DATA_LORDALEXEIBAROV_DEATH, 0);
me->LoadCreaturesAddon();
}
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
void JustDied(Unit* /*killer*/)
{
InstanceScript* instance = me->GetInstanceScript();
if (instance)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
instance->SetData(DATA_LORDALEXEIBAROV, DONE);
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
}
}
}
}
void EnterCombat(Unit* /*who*/)
{
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
//Immolate_Timer
if (Immolate_Timer <= diff)
void EnterCombat(Unit* /*who*/)
{
Unit* target = NULL;
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target) DoCast(target, SPELL_IMMOLATE);
events.ScheduleEvent(EVENT_IMMOLATE, 7000);
events.ScheduleEvent(EVENT_VEILOFSHADOW, 15000);
}
Immolate_Timer = 12000;
} else Immolate_Timer -= diff;
//VeilofShadow_Timer
if (VeilofShadow_Timer <= diff)
void UpdateAI(uint32 const diff)
{
DoCast(me->getVictim(), SPELL_VEILOFSHADOW);
VeilofShadow_Timer = 20000;
} else VeilofShadow_Timer -= diff;
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_IMMOLATE:
DoCast(SelectTarget(SELECT_TARGET_RANDOM,0, 100, true),SPELL_IMMOLATE,true);
events.ScheduleEvent(EVENT_IMMOLATE, 12000);
break;
case EVENT_VEILOFSHADOW:
DoCastVictim(SPELL_VEILOFSHADOW, true);
events.ScheduleEvent(EVENT_VEILOFSHADOW, 20000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_lordalexeibarovAI (creature);
}
};
};
void AddSC_boss_lordalexeibarov()

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

@@ -27,94 +27,98 @@ EndScriptData */
#include "ScriptedCreature.h"
#include "scholomance.h"
#define SPELL_VOLATILEINFECTION 24928
#define SPELL_DARKPLAGUE 18270
#define SPELL_CORROSIVEACID 23313
#define SPELL_NOXIOUSCATALYST 18151
enum Spells
{
SPELL_VOLATILEINFECTION = 24928,
SPELL_DARKPLAGUE = 18270,
SPELL_CORROSIVEACID = 23313,
SPELL_NOXIOUSCATALYST = 18151
};
enum Events
{
EVENT_VOLATILEINFECTION = 1,
EVENT_DARKPLAGUE = 2,
EVENT_CORROSIVEACID = 3,
EVENT_NOXIOUSCATALYST = 4
};
class boss_lorekeeper_polkelt : public CreatureScript
{
public:
boss_lorekeeper_polkelt() : CreatureScript("boss_lorekeeper_polkelt") { }
public: boss_lorekeeper_polkelt() : CreatureScript("boss_lorekeeper_polkelt") { }
CreatureAI* GetAI(Creature* creature) const
{
return new boss_lorekeeperpolkeltAI (creature);
}
struct boss_lorekeeperpolkeltAI : public ScriptedAI
{
boss_lorekeeperpolkeltAI(Creature* creature) : ScriptedAI(creature) {}
uint32 VolatileInfection_Timer;
uint32 Darkplague_Timer;
uint32 CorrosiveAcid_Timer;
uint32 NoxiousCatalyst_Timer;
void Reset()
struct boss_lorekeeperpolkeltAI : public BossAI
{
VolatileInfection_Timer = 38000;
Darkplague_Timer = 8000;
CorrosiveAcid_Timer = 45000;
NoxiousCatalyst_Timer = 35000;
}
boss_lorekeeperpolkeltAI(Creature* creature) : BossAI(creature, DATA_LOREKEEPERPOLKELT) {}
void JustDied(Unit* /*killer*/)
{
InstanceScript* instance = me->GetInstanceScript();
if (instance)
void Reset() {}
void JustDied(Unit* /*killer*/)
{
instance->SetData(DATA_LOREKEEPERPOLKELT_DEATH, 0);
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
InstanceScript* instance = me->GetInstanceScript();
if (instance)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
instance->SetData(DATA_LOREKEEPERPOLKELT, DONE);
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
}
}
}
}
void EnterCombat(Unit* /*who*/)
void EnterCombat(Unit* /*who*/)
{
events.ScheduleEvent(EVENT_VOLATILEINFECTION, 38000);
events.ScheduleEvent(EVENT_DARKPLAGUE, 8000);
events.ScheduleEvent(EVENT_CORROSIVEACID, 45000);
events.ScheduleEvent(EVENT_NOXIOUSCATALYST, 35000);
}
void UpdateAI(uint32 const diff)
{
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, 32000);
break;
case EVENT_DARKPLAGUE:
DoCastVictim(SPELL_DARKPLAGUE, true);
events.ScheduleEvent(EVENT_DARKPLAGUE, 8000);
break;
case EVENT_CORROSIVEACID:
DoCastVictim(SPELL_CORROSIVEACID, true);
events.ScheduleEvent(EVENT_CORROSIVEACID, 25000);
break;
case EVENT_NOXIOUSCATALYST:
DoCastVictim(SPELL_NOXIOUSCATALYST, true);
events.ScheduleEvent(EVENT_NOXIOUSCATALYST, 38000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_lorekeeperpolkeltAI (creature);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
//VolatileInfection_Timer
if (VolatileInfection_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_VOLATILEINFECTION);
VolatileInfection_Timer = 32000;
} else VolatileInfection_Timer -= diff;
//Darkplague_Timer
if (Darkplague_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_DARKPLAGUE);
Darkplague_Timer = 8000;
} else Darkplague_Timer -= diff;
//CorrosiveAcid_Timer
if (CorrosiveAcid_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_CORROSIVEACID);
CorrosiveAcid_Timer = 25000;
} else CorrosiveAcid_Timer -= diff;
//NoxiousCatalyst_Timer
if (NoxiousCatalyst_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_NOXIOUSCATALYST);
NoxiousCatalyst_Timer = 38000;
} else NoxiousCatalyst_Timer -= diff;
DoMeleeAttackIfReady();
}
};
};
void AddSC_boss_lorekeeperpolkelt()

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

@@ -27,96 +27,99 @@ EndScriptData */
#include "ScriptedCreature.h"
#include "scholomance.h"
#define SPELL_TRAMPLE 15550
#define SPELL_CLEAVE 20691
#define SPELL_SUNDERINCLEAVE 25174
#define SPELL_KNOCKAWAY 10101
enum Spells
{
SPELL_TRAMPLE = 15550,
SPELL_CLEAVE = 20691,
SPELL_SUNDERINCLEAVE = 25174,
SPELL_KNOCKAWAY = 10101
};
enum Events
{
EVENT_TRAMPLE = 1,
EVENT_CLEAVE = 2,
EVENT_SUNDERINCLEAVE = 3,
EVENT_KNOCKAWAY = 4
};
class boss_the_ravenian : public CreatureScript
{
public:
boss_the_ravenian() : CreatureScript("boss_the_ravenian") { }
public: boss_the_ravenian() : CreatureScript("boss_the_ravenian") { }
CreatureAI* GetAI(Creature* creature) const
{
return new boss_theravenianAI (creature);
}
struct boss_theravenianAI : public ScriptedAI
{
boss_theravenianAI(Creature* creature) : ScriptedAI(creature) {}
uint32 Trample_Timer;
uint32 Cleave_Timer;
uint32 SunderingCleave_Timer;
uint32 KnockAway_Timer;
bool HasYelled;
void Reset()
struct boss_theravenianAI : public BossAI
{
Trample_Timer = 24000;
Cleave_Timer = 15000;
SunderingCleave_Timer = 40000;
KnockAway_Timer = 32000;
HasYelled = false;
}
boss_theravenianAI(Creature* creature) : BossAI(creature, DATA_THERAVENIAN) {}
void JustDied(Unit* /*killer*/)
{
InstanceScript* instance = me->GetInstanceScript();
if (instance)
void Reset() {}
void JustDied(Unit* /*killer*/)
{
instance->SetData(DATA_THERAVENIAN_DEATH, 0);
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
InstanceScript* instance = me->GetInstanceScript();
if (instance)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
instance->SetData(DATA_THERAVENIAN, DONE);
if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
{
instance->SetData(TYPE_GANDLING, IN_PROGRESS);
me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
}
}
}
}
void EnterCombat(Unit* /*who*/)
void EnterCombat(Unit* /*who*/)
{
events.ScheduleEvent(EVENT_TRAMPLE, 24000);
events.ScheduleEvent(EVENT_CLEAVE, 15000);
events.ScheduleEvent(EVENT_SUNDERINCLEAVE, 40000);
events.ScheduleEvent(EVENT_KNOCKAWAY, 32000);
}
void UpdateAI(uint32 const diff)
{
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, 10000);
break;
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE, true);
events.ScheduleEvent(EVENT_CLEAVE, 7000);
break;
case EVENT_SUNDERINCLEAVE:
DoCastVictim(SPELL_SUNDERINCLEAVE, true);
events.ScheduleEvent(EVENT_SUNDERINCLEAVE, 20000);
break;
case EVENT_KNOCKAWAY:
DoCastVictim(SPELL_KNOCKAWAY, true);
events.ScheduleEvent(EVENT_KNOCKAWAY, 12000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_theravenianAI (creature);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
//Trample_Timer
if (Trample_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_TRAMPLE);
Trample_Timer = 10000;
} else Trample_Timer -= diff;
//Cleave_Timer
if (Cleave_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_CLEAVE);
Cleave_Timer = 7000;
} else Cleave_Timer -= diff;
//SunderingCleave_Timer
if (SunderingCleave_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_SUNDERINCLEAVE);
SunderingCleave_Timer = 20000;
} else SunderingCleave_Timer -= diff;
//KnockAway_Timer
if (KnockAway_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_KNOCKAWAY);
KnockAway_Timer = 12000;
} else KnockAway_Timer -= diff;
DoMeleeAttackIfReady();
}
};
};
void AddSC_boss_theravenian()

12
src/server/scripts/EasternKingdoms/Scholomance/instance_scholomance.cpp
View File

@@ -93,22 +93,22 @@ public:
{
switch (type)
{
case DATA_LORDALEXEIBAROV_DEATH:
case DATA_LORDALEXEIBAROV:
IsBossDied[0] = true;
break;
case DATA_DOCTORTHEOLENKRASTINOV_DEATH:
case DATA_DOCTORTHEOLENKRASTINOV:
IsBossDied[1] = true;
break;
case DATA_THERAVENIAN_DEATH:
case DATA_THERAVENIAN:
IsBossDied[2] = true;
break;
case DATA_LOREKEEPERPOLKELT_DEATH:
case DATA_LOREKEEPERPOLKELT:
IsBossDied[3] = true;
break;
case DATA_INSTRUCTORMALICIA_DEATH:
case DATA_INSTRUCTORMALICIA:
IsBossDied[4] = true;
break;
case DATA_LADYILLUCIABAROV_DEATH:
case DATA_LADYILLUCIABAROV:
IsBossDied[5] = true;
break;
case TYPE_GANDLING:

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

@@ -24,12 +24,12 @@ uint32 const MAX_ENCOUNTER = 2;
enum DataTypes
{
TYPE_GANDLING = 1,
DATA_DOCTORTHEOLENKRASTINOV_DEATH = 2,
DATA_INSTRUCTORMALICIA_DEATH = 3,
DATA_LADYILLUCIABAROV_DEATH = 4,
DATA_LORDALEXEIBAROV_DEATH = 5,
DATA_LOREKEEPERPOLKELT_DEATH = 6,
DATA_THERAVENIAN_DEATH = 7,
DATA_DOCTORTHEOLENKRASTINOV = 2,
DATA_INSTRUCTORMALICIA = 3,
DATA_LADYILLUCIABAROV = 4,
DATA_LORDALEXEIBAROV = 5,
DATA_LOREKEEPERPOLKELT = 6,
DATA_THERAVENIAN = 7,
TYPE_KIRTONOS = 8
};