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

Scripts/Blackrock Depths: Converted to eventmap+minor coding style changes

Browse Source 
Closes #11730
This commit is contained in:
aletuna
2014-06-07 19:02:39 +02:00
committed by joschiwald
parent 6c31c33f66
commit 1b3149b07f
10 changed files with 758 additions and 660 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_ambassador_flamelash.cpp
View File

@@ -1,6 +1,5 @@
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2006-2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
@@ -24,64 +23,74 @@ enum Spells
SPELL_FIREBLAST = 15573
};
enum Events
{
EVENT_FIREBLAST = 1,
EVENT_SUMMON_SPIRITS = 2
};
class boss_ambassador_flamelash : public CreatureScript
{
public:
boss_ambassador_flamelash() : CreatureScript("boss_ambassador_flamelash") { }
public:
boss_ambassador_flamelash() : CreatureScript("boss_ambassador_flamelash") { }
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_ambassador_flamelashAI(creature);
}
struct boss_ambassador_flamelashAI : public ScriptedAI
{
boss_ambassador_flamelashAI(Creature* creature) : ScriptedAI(creature) { }
uint32 FireBlast_Timer;
uint32 Spirit_Timer;
void Reset() override
struct boss_ambassador_flamelashAI : public ScriptedAI
{
FireBlast_Timer = 2000;
Spirit_Timer = 24000;
}
boss_ambassador_flamelashAI(Creature* creature) : ScriptedAI(creature) { }
void EnterCombat(Unit* /*who*/) override { }
void SummonSpirits(Unit* victim)
{
if (Creature* Spirit = DoSpawnCreature(9178, float(irand(-9, 9)), float(irand(-9, 9)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 60000))
Spirit->AI()->AttackStart(victim);
}
void UpdateAI(uint32 diff) override
{
//Return since we have no target
if (!UpdateVictim())
return;
//FireBlast_Timer
if (FireBlast_Timer <= diff)
void Reset() override
{
DoCastVictim(SPELL_FIREBLAST);
FireBlast_Timer = 7000;
} else FireBlast_Timer -= diff;
_events.Reset();
}
//Spirit_Timer
if (Spirit_Timer <= diff)
void EnterCombat(Unit* /*who*/) override
{
SummonSpirits(me->GetVictim());
SummonSpirits(me->GetVictim());
SummonSpirits(me->GetVictim());
SummonSpirits(me->GetVictim());
_events.ScheduleEvent(EVENT_FIREBLAST, 2000);
_events.ScheduleEvent(EVENT_SUMMON_SPIRITS, 24000);
}
Spirit_Timer = 30000;
} else Spirit_Timer -= diff;
void SummonSpirit(Unit* victim)
{
if (Creature* spirit = DoSpawnCreature(9178, frand(-9, 9), frand(-9, 9), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 60000))
spirit->AI()->AttackStart(victim);
}
DoMeleeAttackIfReady();
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_FIREBLAST:
DoCastVictim(SPELL_FIREBLAST);
_events.ScheduleEvent(EVENT_FIREBLAST, 7000);
break;
case EVENT_SUMMON_SPIRITS:
for (uint32 i = 0; i < 4; ++i)
SummonSpirit(me->GetVictim());
_events.ScheduleEvent(EVENT_SUMMON_SPIRITS, 30000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
private:
EventMap _events;
};
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_ambassador_flamelashAI(creature);
}
};
};
void AddSC_boss_ambassador_flamelash()

153
src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_anubshiah.cpp
View File

@@ -1,6 +1,5 @@
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2006-2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
@@ -21,90 +20,94 @@
enum Spells
{
SPELL_SHADOWBOLT = 17228,
SPELL_CURSEOFTONGUES = 15470,
SPELL_CURSEOFWEAKNESS = 17227,
SPELL_DEMONARMOR = 11735,
SPELL_ENVELOPINGWEB = 15471
SPELL_SHADOWBOLT = 17228,
SPELL_CURSEOFTONGUES = 15470,
SPELL_CURSEOFWEAKNESS = 17227,
SPELL_DEMONARMOR = 11735,
SPELL_ENVELOPINGWEB = 15471
};
enum Events
{
EVENT_SHADOWBOLT = 1,
EVENT_CURSE_OF_TONGUES = 2,
EVENT_CURSE_OF_WEAKNESS = 3,
EVENT_DEMON_ARMOR = 4,
EVENT_ENVELOPING_WEB = 5
};
class boss_anubshiah : public CreatureScript
{
public:
boss_anubshiah() : CreatureScript("boss_anubshiah") { }
public:
boss_anubshiah() : CreatureScript("boss_anubshiah") { }
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_anubshiahAI(creature);
}
struct boss_anubshiahAI : public ScriptedAI
{
boss_anubshiahAI(Creature* creature) : ScriptedAI(creature) { }
uint32 ShadowBolt_Timer;
uint32 CurseOfTongues_Timer;
uint32 CurseOfWeakness_Timer;
uint32 DemonArmor_Timer;
uint32 EnvelopingWeb_Timer;
void Reset() override
struct boss_anubshiahAI : public ScriptedAI
{
ShadowBolt_Timer = 7000;
CurseOfTongues_Timer = 24000;
CurseOfWeakness_Timer = 12000;
DemonArmor_Timer = 3000;
EnvelopingWeb_Timer = 16000;
}
boss_anubshiahAI(Creature* creature) : ScriptedAI(creature) { }
void EnterCombat(Unit* /*who*/) override { }
void Reset() override
{
_events.Reset();
}
void UpdateAI(uint32 diff) override
void EnterCombat(Unit* /*who*/) override
{
_events.ScheduleEvent(EVENT_SHADOWBOLT, 7000);
_events.ScheduleEvent(EVENT_CURSE_OF_TONGUES, 24000);
_events.ScheduleEvent(EVENT_CURSE_OF_WEAKNESS, 12000);
_events.ScheduleEvent(EVENT_DEMON_ARMOR, 3000);
_events.ScheduleEvent(EVENT_ENVELOPING_WEB, 16000);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SHADOWBOLT:
DoCast(me, SPELL_SHADOWBOLT);
_events.ScheduleEvent(EVENT_SHADOWBOLT, 7000);
break;
case EVENT_CURSE_OF_TONGUES:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_CURSEOFTONGUES);
_events.ScheduleEvent(EVENT_CURSE_OF_TONGUES, 18000);
break;
case EVENT_CURSE_OF_WEAKNESS:
DoCastVictim(SPELL_CURSEOFWEAKNESS);
_events.ScheduleEvent(EVENT_CURSE_OF_WEAKNESS, 45000);
break;
case EVENT_DEMON_ARMOR:
DoCast(me, SPELL_DEMONARMOR);
_events.ScheduleEvent(EVENT_DEMON_ARMOR, 300000);
break;
case EVENT_ENVELOPING_WEB:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_ENVELOPINGWEB);
_events.ScheduleEvent(EVENT_ENVELOPING_WEB, 12000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
private:
EventMap _events;
};
CreatureAI* GetAI(Creature* creature) const override
{
//Return since we have no target
if (!UpdateVictim())
return;
//ShadowBolt_Timer
if (ShadowBolt_Timer <= diff)
{
DoCastVictim(SPELL_SHADOWBOLT);
ShadowBolt_Timer = 7000;
} else ShadowBolt_Timer -= diff;
//CurseOfTongues_Timer
if (CurseOfTongues_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_CURSEOFTONGUES);
CurseOfTongues_Timer = 18000;
} else CurseOfTongues_Timer -= diff;
//CurseOfWeakness_Timer
if (CurseOfWeakness_Timer <= diff)
{
DoCastVictim(SPELL_CURSEOFWEAKNESS);
CurseOfWeakness_Timer = 45000;
} else CurseOfWeakness_Timer -= diff;
//DemonArmor_Timer
if (DemonArmor_Timer <= diff)
{
DoCast(me, SPELL_DEMONARMOR);
DemonArmor_Timer = 300000;
} else DemonArmor_Timer -= diff;
//EnvelopingWeb_Timer
if (EnvelopingWeb_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_ENVELOPINGWEB);
EnvelopingWeb_Timer = 12000;
} else EnvelopingWeb_Timer -= diff;
DoMeleeAttackIfReady();
return new boss_anubshiahAI(creature);
}
};
};
void AddSC_boss_anubshiah()

149
src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_emperor_dagran_thaurissan.cpp
View File

@@ -1,6 +1,5 @@
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2006-2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
@@ -32,89 +31,89 @@ enum Spells
SPELL_AVATAROFFLAME = 15636
};
enum Events
{
EVENT_HANDOFTHAURISSAN = 1,
EVENT_AVATAROFFLAME = 2
};
class boss_emperor_dagran_thaurissan : public CreatureScript
{
public:
boss_emperor_dagran_thaurissan() : CreatureScript("boss_emperor_dagran_thaurissan") { }
public:
boss_emperor_dagran_thaurissan() : CreatureScript("boss_emperor_dagran_thaurissan") { }
CreatureAI* GetAI(Creature* creature) const override
{
return GetInstanceAI<boss_draganthaurissanAI>(creature);
}
struct boss_draganthaurissanAI : public ScriptedAI
{
boss_draganthaurissanAI(Creature* creature) : ScriptedAI(creature)
struct boss_draganthaurissanAI : public ScriptedAI
{
instance = me->GetInstanceScript();
}
InstanceScript* instance;
uint32 HandOfThaurissan_Timer;
uint32 AvatarOfFlame_Timer;
//uint32 Counter;
void Reset() override
{
HandOfThaurissan_Timer = 4000;
AvatarOfFlame_Timer = 25000;
//Counter= 0;
}
void EnterCombat(Unit* /*who*/) override
{
Talk(SAY_AGGRO);
me->CallForHelp(VISIBLE_RANGE);
}
void KilledUnit(Unit* /*victim*/) override
{
Talk(SAY_SLAY);
}
void JustDied(Unit* /*killer*/) override
{
if (Creature* Moira = ObjectAccessor::GetCreature(*me, instance->GetData64(DATA_MOIRA)))
boss_draganthaurissanAI(Creature* creature) : ScriptedAI(creature)
{
Moira->AI()->EnterEvadeMode();
Moira->setFaction(35);
_instance = me->GetInstanceScript();
}
}
void UpdateAI(uint32 diff) override
void Reset() override
{
_events.Reset();
}
void EnterCombat(Unit* /*who*/) override
{
Talk(SAY_AGGRO);
me->CallForHelp(VISIBLE_RANGE);
_events.ScheduleEvent(EVENT_HANDOFTHAURISSAN, 4000);
_events.ScheduleEvent(EVENT_AVATAROFFLAME, 25000);
}
void KilledUnit(Unit* who) override
{
if (who->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void JustDied(Unit* /*killer*/) override
{
if (Creature* moira = ObjectAccessor::GetCreature(*me, _instance->GetData64(DATA_MOIRA)))
{
moira->AI()->EnterEvadeMode();
moira->setFaction(35);
}
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_HANDOFTHAURISSAN:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_HANDOFTHAURISSAN);
_events.ScheduleEvent(EVENT_HANDOFTHAURISSAN, 5000);
break;
case EVENT_AVATAROFFLAME:
DoCastVictim(SPELL_AVATAROFFLAME);
_events.ScheduleEvent(EVENT_AVATAROFFLAME, 18000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
private:
InstanceScript* _instance;
EventMap _events;
};
CreatureAI* GetAI(Creature* creature) const override
{
//Return since we have no target
if (!UpdateVictim())
return;
if (HandOfThaurissan_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_HANDOFTHAURISSAN);
//3 Hands of Thaurissan will be cast
//if (Counter < 3)
//{
// HandOfThaurissan_Timer = 1000;
// ++Counter;
//}
//else
//{
HandOfThaurissan_Timer = 5000;
//Counter = 0;
//}
} else HandOfThaurissan_Timer -= diff;
//AvatarOfFlame_Timer
if (AvatarOfFlame_Timer <= diff)
{
DoCastVictim(SPELL_AVATAROFFLAME);
AvatarOfFlame_Timer = 18000;
} else AvatarOfFlame_Timer -= diff;
DoMeleeAttackIfReady();
return GetInstanceAI<boss_draganthaurissanAI>(creature);
}
};
};
void AddSC_boss_draganthaurissan()

169
src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_general_angerforge.cpp
View File

@@ -1,6 +1,5 @@
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2006-2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
@@ -26,101 +25,113 @@ enum Spells
SPELL_CLEAVE = 20691
};
enum Events
{
EVENT_MIGHTYBLOW = 1,
EVENT_HAMSTRING = 2,
EVENT_CLEAVE = 3,
EVENT_MEDIC = 4,
EVENT_ADDS = 5
};
enum Phases
{
PHASE_ONE = 1,
PHASE_TWO = 2
};
class boss_general_angerforge : public CreatureScript
{
public:
boss_general_angerforge() : CreatureScript("boss_general_angerforge") { }
public:
boss_general_angerforge() : CreatureScript("boss_general_angerforge") { }
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_general_angerforgeAI(creature);
}
struct boss_general_angerforgeAI : public ScriptedAI
{
boss_general_angerforgeAI(Creature* creature) : ScriptedAI(creature) { }
uint32 MightyBlow_Timer;
uint32 HamString_Timer;
uint32 Cleave_Timer;
uint32 Adds_Timer;
bool Medics;
void Reset() override
struct boss_general_angerforgeAI : public ScriptedAI
{
MightyBlow_Timer = 8000;
HamString_Timer = 12000;
Cleave_Timer = 16000;
Adds_Timer = 0;
Medics = false;
}
boss_general_angerforgeAI(Creature* creature) : ScriptedAI(creature) { }
void EnterCombat(Unit* /*who*/) override { }
void SummonAdds(Unit* victim)
{
if (Creature* SummonedAdd = DoSpawnCreature(8901, float(irand(-14, 14)), float(irand(-14, 14)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 120000))
SummonedAdd->AI()->AttackStart(victim);
}
void SummonMedics(Unit* victim)
{
if (Creature* SummonedMedic = DoSpawnCreature(8894, float(irand(-9, 9)), float(irand(-9, 9)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 120000))
SummonedMedic->AI()->AttackStart(victim);
}
void UpdateAI(uint32 diff) override
{
//Return since we have no target
if (!UpdateVictim())
return;
//MightyBlow_Timer
if (MightyBlow_Timer <= diff)
void Reset() override
{
DoCastVictim(SPELL_MIGHTYBLOW);
MightyBlow_Timer = 18000;
} else MightyBlow_Timer -= diff;
_events.Reset();
}
//HamString_Timer
if (HamString_Timer <= diff)
void EnterCombat(Unit* /*who*/) override
{
DoCastVictim(SPELL_HAMSTRING);
HamString_Timer = 15000;
} else HamString_Timer -= diff;
_events.SetPhase(PHASE_ONE);
_events.ScheduleEvent(EVENT_MIGHTYBLOW, 8000);
_events.ScheduleEvent(EVENT_HAMSTRING, 12000);
_events.ScheduleEvent(EVENT_CLEAVE, 16000);
}
//Cleave_Timer
if (Cleave_Timer <= diff)
void DamageTaken(Unit* /*attacker*/, uint32& damage) override
{
DoCastVictim(SPELL_CLEAVE);
Cleave_Timer = 9000;
} else Cleave_Timer -= diff;
//Adds_Timer
if (HealthBelowPct(21))
{
if (Adds_Timer <= diff)
if (me->HealthBelowPctDamaged(20, damage) && _events.IsInPhase(PHASE_ONE))
{
// summon 3 Adds every 25s
SummonAdds(me->GetVictim());
SummonAdds(me->GetVictim());
SummonAdds(me->GetVictim());
Adds_Timer = 25000;
} else Adds_Timer -= diff;
_events.SetPhase(PHASE_TWO);
_events.ScheduleEvent(EVENT_MEDIC, 0, 0, PHASE_TWO);
_events.ScheduleEvent(EVENT_ADDS, 0, 0, PHASE_TWO);
}
}
//Summon Medics
if (!Medics && HealthBelowPct(21))
void SummonAdd(Unit* victim)
{
SummonMedics(me->GetVictim());
SummonMedics(me->GetVictim());
Medics = true;
if (Creature* SummonedAdd = DoSpawnCreature(8901, float(irand(-14, 14)), float(irand(-14, 14)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 120000))
SummonedAdd->AI()->AttackStart(victim);
}
DoMeleeAttackIfReady();
void SummonMedic(Unit* victim)
{
if (Creature* SummonedMedic = DoSpawnCreature(8894, float(irand(-9, 9)), float(irand(-9, 9)), 0, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 120000))
SummonedMedic->AI()->AttackStart(victim);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_MIGHTYBLOW:
DoCastVictim(SPELL_MIGHTYBLOW);
_events.ScheduleEvent(EVENT_MIGHTYBLOW, 18000);
break;
case EVENT_HAMSTRING:
DoCastVictim(SPELL_HAMSTRING);
_events.ScheduleEvent(EVENT_HAMSTRING, 15000);
break;
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE);
_events.ScheduleEvent(EVENT_CLEAVE, 9000);
break;
case EVENT_MEDIC:
for (uint8 i = 0; i < 2; ++i)
SummonMedic(me->GetVictim());
break;
case EVENT_ADDS:
for (uint8 i = 0; i < 3; ++i)
SummonAdd(me->GetVictim());
_events.ScheduleEvent(EVENT_ADDS, 25000, 0, PHASE_TWO);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
private:
EventMap _events;
};
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_general_angerforgeAI(creature);
}
};
};
void AddSC_boss_general_angerforge()

92
src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_gorosh_the_dervish.cpp
View File

@@ -1,6 +1,5 @@
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2006-2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
@@ -25,56 +24,67 @@ enum Spells
SPELL_MORTALSTRIKE = 24573
};
enum Events
{
EVENT_WHIRLWIND = 1,
EVENT_MORTALSTRIKE = 2
};
class boss_gorosh_the_dervish : public CreatureScript
{
public:
boss_gorosh_the_dervish() : CreatureScript("boss_gorosh_the_dervish") { }
public:
boss_gorosh_the_dervish() : CreatureScript("boss_gorosh_the_dervish") { }
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_gorosh_the_dervishAI(creature);
}
struct boss_gorosh_the_dervishAI : public ScriptedAI
{
boss_gorosh_the_dervishAI(Creature* creature) : ScriptedAI(creature) { }
uint32 WhirlWind_Timer;
uint32 MortalStrike_Timer;
void Reset() override
struct boss_gorosh_the_dervishAI : public ScriptedAI
{
WhirlWind_Timer = 12000;
MortalStrike_Timer = 22000;
}
boss_gorosh_the_dervishAI(Creature* creature) : ScriptedAI(creature) { }
void EnterCombat(Unit* /*who*/) override
{
}
void UpdateAI(uint32 diff) override
{
//Return since we have no target
if (!UpdateVictim())
return;
//WhirlWind_Timer
if (WhirlWind_Timer <= diff)
void Reset() override
{
DoCast(me, SPELL_WHIRLWIND);
WhirlWind_Timer = 15000;
} else WhirlWind_Timer -= diff;
_events.Reset();
}
//MortalStrike_Timer
if (MortalStrike_Timer <= diff)
void EnterCombat(Unit* /*who*/) override
{
DoCastVictim(SPELL_MORTALSTRIKE);
MortalStrike_Timer = 15000;
} else MortalStrike_Timer -= diff;
_events.ScheduleEvent(EVENT_WHIRLWIND, 12000);
_events.ScheduleEvent(EVENT_MORTALSTRIKE, 22000);
}
DoMeleeAttackIfReady();
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_WHIRLWIND:
DoCast(me, SPELL_WHIRLWIND);
_events.ScheduleEvent(EVENT_WHIRLWIND, 15000);
break;
case EVENT_MORTALSTRIKE:
DoCastVictim(SPELL_MORTALSTRIKE);
_events.ScheduleEvent(EVENT_MORTALSTRIKE, 15000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
private:
EventMap _events;
};
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_gorosh_the_dervishAI(creature);
}
};
};
void AddSC_boss_gorosh_the_dervish()

113
src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_grizzle.cpp
View File

@@ -1,6 +1,5 @@
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2006-2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
@@ -26,59 +25,83 @@ enum Grizzle
EMOTE_FRENZY_KILL = 0
};
enum Events
{
EVENT_GROUNDTREMOR = 1,
EVENT_FRENZY = 2
};
enum Phases
{
PHASE_ONE = 1,
PHASE_TWO = 2
};
class boss_grizzle : public CreatureScript
{
public:
boss_grizzle() : CreatureScript("boss_grizzle") { }
public:
boss_grizzle() : CreatureScript("boss_grizzle") { }
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_grizzleAI(creature);
}
struct boss_grizzleAI : public ScriptedAI
{
boss_grizzleAI(Creature* creature) : ScriptedAI(creature) { }
uint32 GroundTremor_Timer;
uint32 Frenzy_Timer;
void Reset() override
struct boss_grizzleAI : public ScriptedAI
{
GroundTremor_Timer = 12000;
Frenzy_Timer =0;
}
boss_grizzleAI(Creature* creature) : ScriptedAI(creature) { }
void EnterCombat(Unit* /*who*/) override { }
void UpdateAI(uint32 diff) override
{
//Return since we have no target
if (!UpdateVictim())
return;
//GroundTremor_Timer
if (GroundTremor_Timer <= diff)
void Reset() override
{
DoCastVictim(SPELL_GROUNDTREMOR);
GroundTremor_Timer = 8000;
} else GroundTremor_Timer -= diff;
//Frenzy_Timer
if (HealthBelowPct(51))
{
if (Frenzy_Timer <= diff)
{
DoCast(me, SPELL_FRENZY);
Talk(EMOTE_FRENZY_KILL);
Frenzy_Timer = 15000;
} else Frenzy_Timer -= diff;
_events.Reset();
}
DoMeleeAttackIfReady();
void EnterCombat(Unit* /*who*/) override
{
_events.SetPhase(PHASE_ONE);
_events.ScheduleEvent(EVENT_GROUNDTREMOR, 12000);
}
void DamageTaken(Unit* /*attacker*/, uint32& damage) override
{
if (me->HealthBelowPctDamaged(50, damage) && _events.IsInPhase(PHASE_ONE))
{
_events.SetPhase(PHASE_TWO);
_events.ScheduleEvent(EVENT_FRENZY, 0, 0, PHASE_TWO);
}
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_GROUNDTREMOR:
DoCastVictim(SPELL_GROUNDTREMOR);
_events.ScheduleEvent(EVENT_GROUNDTREMOR, 8000);
break;
case EVENT_FRENZY:
DoCast(me, SPELL_FRENZY);
Talk(EMOTE_FRENZY_KILL);
_events.ScheduleEvent(EVENT_FRENZY, 15000, 0, PHASE_TWO);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
private:
EventMap _events;
};
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_grizzleAI(creature);
}
};
};
void AddSC_boss_grizzle()

128
src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_high_interrogator_gerstahn.cpp
View File

@@ -1,6 +1,5 @@
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2006-2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
@@ -27,74 +26,81 @@ enum Spells
SPELL_SHADOWSHIELD = 22417
};
enum Events
{
EVENT_SHADOW_WORD_PAIN = 1,
EVENT_MANABURN = 2,
EVENT_PSYCHIC_SCREAM = 3,
EVENT_SHADOWSHIELD = 4
};
class boss_high_interrogator_gerstahn : public CreatureScript
{
public:
boss_high_interrogator_gerstahn() : CreatureScript("boss_high_interrogator_gerstahn") { }
public:
boss_high_interrogator_gerstahn() : CreatureScript("boss_high_interrogator_gerstahn") { }
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_high_interrogator_gerstahnAI(creature);
}
struct boss_high_interrogator_gerstahnAI : public ScriptedAI
{
boss_high_interrogator_gerstahnAI(Creature* creature) : ScriptedAI(creature) { }
uint32 ShadowWordPain_Timer;
uint32 ManaBurn_Timer;
uint32 PsychicScream_Timer;
uint32 ShadowShield_Timer;
void Reset() override
struct boss_high_interrogator_gerstahnAI : public ScriptedAI
{
ShadowWordPain_Timer = 4000;
ManaBurn_Timer = 14000;
PsychicScream_Timer = 32000;
ShadowShield_Timer = 8000;
}
boss_high_interrogator_gerstahnAI(Creature* creature) : ScriptedAI(creature) { }
void EnterCombat(Unit* /*who*/) override { }
void Reset() override
{
_events.Reset();
}
void UpdateAI(uint32 diff) override
void EnterCombat(Unit* /*who*/) override
{
_events.ScheduleEvent(EVENT_SHADOW_WORD_PAIN, 4000);
_events.ScheduleEvent(EVENT_MANABURN, 14000);
_events.ScheduleEvent(EVENT_PSYCHIC_SCREAM, 32000);
_events.ScheduleEvent(EVENT_SHADOWSHIELD, 8000);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SHADOW_WORD_PAIN:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
DoCast(target, SPELL_SHADOWWORDPAIN);
_events.ScheduleEvent(EVENT_SHADOW_WORD_PAIN, 7000);
break;
case EVENT_PSYCHIC_SCREAM:
DoCastVictim(SPELL_PSYCHICSCREAM);
_events.ScheduleEvent(EVENT_PSYCHIC_SCREAM, 30000);
break;
case EVENT_MANABURN:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
DoCast(target, SPELL_MANABURN);
_events.ScheduleEvent(EVENT_MANABURN, 10000);
break;
case EVENT_SHADOWSHIELD:
DoCast(me, SPELL_SHADOWSHIELD);
_events.ScheduleEvent(EVENT_SHADOWSHIELD, 25000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
private:
EventMap _events;
};
CreatureAI* GetAI(Creature* creature) const override
{
//Return since we have no target
if (!UpdateVictim())
return;
//ShadowWordPain_Timer
if (ShadowWordPain_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_SHADOWWORDPAIN);
ShadowWordPain_Timer = 7000;
} else ShadowWordPain_Timer -= diff;
//ManaBurn_Timer
if (ManaBurn_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_MANABURN);
ManaBurn_Timer = 10000;
} else ManaBurn_Timer -= diff;
//PsychicScream_Timer
if (PsychicScream_Timer <= diff)
{
DoCastVictim(SPELL_PSYCHICSCREAM);
PsychicScream_Timer = 30000;
} else PsychicScream_Timer -= diff;
//ShadowShield_Timer
if (ShadowShield_Timer <= diff)
{
DoCast(me, SPELL_SHADOWSHIELD);
ShadowShield_Timer = 25000;
} else ShadowShield_Timer -= diff;
DoMeleeAttackIfReady();
return new boss_high_interrogator_gerstahnAI(creature);
}
};
};
void AddSC_boss_high_interrogator_gerstahn()

124
src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_magmus.cpp
View File

@@ -1,6 +1,5 @@
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2006-2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
@@ -18,75 +17,96 @@
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "blackrock_depths.h"
enum Spells
{
SPELL_FIERYBURST = 13900,
SPELL_WARSTOMP = 24375
SPELL_FIERYBURST = 13900,
SPELL_WARSTOMP = 24375
};
enum Misc
enum Events
{
DATA_THRONE_DOOR = 24 // not id or guid of doors but number of enum in blackrock_depths.h
EVENT_FIERY_BURST = 1,
EVENT_WARSTOMP = 2
};
enum Phases
{
PHASE_ONE = 1,
PHASE_TWO = 2
};
class boss_magmus : public CreatureScript
{
public:
boss_magmus() : CreatureScript("boss_magmus") { }
public:
boss_magmus() : CreatureScript("boss_magmus") { }
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_magmusAI(creature);
}
struct boss_magmusAI : public ScriptedAI
{
boss_magmusAI(Creature* creature) : ScriptedAI(creature) { }
uint32 FieryBurst_Timer;
uint32 WarStomp_Timer;
void Reset() override
struct boss_magmusAI : public ScriptedAI
{
FieryBurst_Timer = 5000;
WarStomp_Timer =0;
}
boss_magmusAI(Creature* creature) : ScriptedAI(creature) { }
void EnterCombat(Unit* /*who*/) override { }
void UpdateAI(uint32 diff) override
{
//Return since we have no target
if (!UpdateVictim())
return;
//FieryBurst_Timer
if (FieryBurst_Timer <= diff)
void Reset() override
{
DoCastVictim(SPELL_FIERYBURST);
FieryBurst_Timer = 6000;
} else FieryBurst_Timer -= diff;
//WarStomp_Timer
if (HealthBelowPct(51))
{
if (WarStomp_Timer <= diff)
{
DoCastVictim(SPELL_WARSTOMP);
WarStomp_Timer = 8000;
} else WarStomp_Timer -= diff;
_events.Reset();
}
DoMeleeAttackIfReady();
}
// When he die open door to last chamber
void JustDied(Unit* killer) override
void EnterCombat(Unit* /*who*/) override
{
_events.SetPhase(PHASE_ONE);
_events.ScheduleEvent(EVENT_FIERY_BURST, 5000);
}
void DamageTaken(Unit* /*attacker*/, uint32& damage) override
{
if (me->HealthBelowPctDamaged(50, damage) && _events.IsInPhase(PHASE_ONE))
{
_events.SetPhase(PHASE_TWO);
_events.ScheduleEvent(EVENT_WARSTOMP, 0, 0, PHASE_TWO);
}
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_FIERY_BURST:
DoCastVictim(SPELL_FIERYBURST);
_events.ScheduleEvent(EVENT_FIERY_BURST, 6000);
break;
case EVENT_WARSTOMP:
DoCastVictim(SPELL_WARSTOMP);
_events.ScheduleEvent(EVENT_WARSTOMP, 8000, 0, PHASE_TWO);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void JustDied(Unit* /*killer*/) override
{
if (InstanceScript* instance = me->GetInstanceScript())
instance->HandleGameObject(instance->GetData64(DATA_THRONE_DOOR), true);
}
private:
EventMap _events;
};
CreatureAI* GetAI(Creature* creature) const override
{
if (InstanceScript* instance = killer->GetInstanceScript())
instance->HandleGameObject(instance->GetData64(DATA_THRONE_DOOR), true);
return new boss_magmusAI(creature);
}
};
};
void AddSC_boss_magmus()

109
src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_moira_bronzebeard.cpp
View File

@@ -1,6 +1,5 @@
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2006-2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
@@ -29,63 +28,73 @@ enum Spells
SPELL_SMITE = 10934
};
enum Events
{
EVENT_MINDBLAST = 1,
EVENT_SHADOW_WORD_PAIN = 2,
EVENT_SMITE = 3,
EVENT_HEAL = 4 // not used atm
};
class boss_moira_bronzebeard : public CreatureScript
{
public:
boss_moira_bronzebeard() : CreatureScript("boss_moira_bronzebeard") { }
public:
boss_moira_bronzebeard() : CreatureScript("boss_moira_bronzebeard") { }
CreatureAI* GetAI(Creature* creature) const override
{
return new boss_moira_bronzebeardAI(creature);
}
struct boss_moira_bronzebeardAI : public ScriptedAI
{
boss_moira_bronzebeardAI(Creature* creature) : ScriptedAI(creature) { }
uint32 Heal_Timer;
uint32 MindBlast_Timer;
uint32 ShadowWordPain_Timer;
uint32 Smite_Timer;
void Reset() override
struct boss_moira_bronzebeardAI : public ScriptedAI
{
Heal_Timer = 12000; //These times are probably wrong
MindBlast_Timer = 16000;
ShadowWordPain_Timer = 2000;
Smite_Timer = 8000;
}
boss_moira_bronzebeardAI(Creature* creature) : ScriptedAI(creature) { }
void EnterCombat(Unit* /*who*/) override { }
void Reset() override
{
_events.Reset();
}
void UpdateAI(uint32 diff) override
void EnterCombat(Unit* /*who*/) override
{
//_events.ScheduleEvent(EVENT_HEAL, 12000); // not used atm // These times are probably wrong
_events.ScheduleEvent(EVENT_MINDBLAST, 16000);
_events.ScheduleEvent(EVENT_SHADOW_WORD_PAIN, 2000);
_events.ScheduleEvent(EVENT_SMITE, 8000);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_MINDBLAST:
DoCastVictim(SPELL_MINDBLAST);
_events.ScheduleEvent(EVENT_MINDBLAST, 14000);
break;
case EVENT_SHADOW_WORD_PAIN:
DoCastVictim(SPELL_SHADOWWORDPAIN);
_events.ScheduleEvent(EVENT_SHADOW_WORD_PAIN, 18000);
break;
case EVENT_SMITE:
DoCastVictim(SPELL_SMITE);
_events.ScheduleEvent(EVENT_SMITE, 10000);
break;
default:
break;
}
}
}
private:
EventMap _events;
};
CreatureAI* GetAI(Creature* creature) const override
{
//Return since we have no target
if (!UpdateVictim())
return;
//MindBlast_Timer
if (MindBlast_Timer <= diff)
{
DoCastVictim(SPELL_MINDBLAST);
MindBlast_Timer = 14000;
} else MindBlast_Timer -= diff;
//ShadowWordPain_Timer
if (ShadowWordPain_Timer <= diff)
{
DoCastVictim(SPELL_SHADOWWORDPAIN);
ShadowWordPain_Timer = 18000;
} else ShadowWordPain_Timer -= diff;
//Smite_Timer
if (Smite_Timer <= diff)
{
DoCastVictim(SPELL_SMITE);
Smite_Timer = 10000;
} else Smite_Timer -= diff;
return new boss_moira_bronzebeardAI(creature);
}
};
};
void AddSC_boss_moira_bronzebeard()

276
src/server/scripts/EasternKingdoms/BlackrockMountain/BlackrockDepths/boss_tomb_of_seven.cpp
View File

@@ -24,18 +24,24 @@
enum Spells
{
SPELL_SMELT_DARK_IRON = 14891,
SPELL_LEARN_SMELT = 14894,
SPELL_SMELT_DARK_IRON = 14891,
SPELL_LEARN_SMELT = 14894,
};
enum Quests
{
QUEST_SPECTRAL_CHALICE = 4083
QUEST_SPECTRAL_CHALICE = 4083
};
enum Misc
{
DATA_SKILLPOINT_MIN = 230
DATA_SKILLPOINT_MIN = 230
};
enum Phases
{
PHASE_ONE = 1,
PHASE_TWO = 2
};
#define GOSSIP_ITEM_TEACH_1 "Teach me the art of smelting dark iron"
@@ -99,149 +105,151 @@ enum DoomrelSpells
SPELL_SUMMON_VOIDWALKERS = 15092
};
enum DoomrelEvents
{
EVENT_SHADOW_BOLT_VOLLEY = 1,
EVENT_IMMOLATE = 2,
EVENT_CURSE_OF_WEAKNESS = 3,
EVENT_DEMONARMOR = 4,
EVENT_SUMMON_VOIDWALKERS = 5
};
#define GOSSIP_ITEM_CHALLENGE "Your bondage is at an end, Doom'rel. I challenge you!"
#define GOSSIP_SELECT_DOOMREL "[PH] Continue..."
class boss_doomrel : public CreatureScript
{
public:
boss_doomrel() : CreatureScript("boss_doomrel") { }
public:
boss_doomrel() : CreatureScript("boss_doomrel") { }
bool OnGossipSelect(Player* player, Creature* creature, uint32 /*sender*/, uint32 action) override
{
player->PlayerTalkClass->ClearMenus();
switch (action)
bool OnGossipSelect(Player* player, Creature* creature, uint32 /*sender*/, uint32 action) override
{
case GOSSIP_ACTION_INFO_DEF+1:
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_DOOMREL, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
player->SEND_GOSSIP_MENU(2605, creature->GetGUID());
break;
case GOSSIP_ACTION_INFO_DEF+2:
player->CLOSE_GOSSIP_MENU();
//start event here
creature->setFaction(FACTION_HOSTILE);
creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
creature->AI()->AttackStart(player);
InstanceScript* instance = creature->GetInstanceScript();
if (instance)
instance->SetData64(DATA_EVENSTARTER, player->GetGUID());
break;
}
return true;
}
bool OnGossipHello(Player* player, Creature* creature) override
{
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_CHALLENGE, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
player->SEND_GOSSIP_MENU(2601, creature->GetGUID());
return true;
}
CreatureAI* GetAI(Creature* creature) const override
{
return GetInstanceAI<boss_doomrelAI>(creature);
}
struct boss_doomrelAI : public ScriptedAI
{
boss_doomrelAI(Creature* creature) : ScriptedAI(creature)
{
instance = creature->GetInstanceScript();
}
InstanceScript* instance;
uint32 ShadowVolley_Timer;
uint32 Immolate_Timer;
uint32 CurseOfWeakness_Timer;
uint32 DemonArmor_Timer;
bool Voidwalkers;
void Reset() override
{
ShadowVolley_Timer = 10000;
Immolate_Timer = 18000;
CurseOfWeakness_Timer = 5000;
DemonArmor_Timer = 16000;
Voidwalkers = false;
me->setFaction(FACTION_FRIEND);
// was set before event start, so set again
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
if (instance->GetData(DATA_GHOSTKILL) >= 7)
me->SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
else
me->SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
}
void EnterCombat(Unit* /*who*/) override
{
}
void EnterEvadeMode() override
{
me->RemoveAllAuras();
me->DeleteThreatList();
me->CombatStop(true);
me->LoadCreaturesAddon();
if (me->IsAlive())
me->GetMotionMaster()->MoveTargetedHome();
me->SetLootRecipient(NULL);
instance->SetData64(DATA_EVENSTARTER, 0);
}
void JustDied(Unit* /*killer*/) override
{
instance->SetData(DATA_GHOSTKILL, 1);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
//ShadowVolley_Timer
if (ShadowVolley_Timer <= diff)
player->PlayerTalkClass->ClearMenus();
switch (action)
{
DoCastVictim(SPELL_SHADOWBOLTVOLLEY);
ShadowVolley_Timer = 12000;
} else ShadowVolley_Timer -= diff;
case GOSSIP_ACTION_INFO_DEF+1:
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_DOOMREL, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
player->SEND_GOSSIP_MENU(2605, creature->GetGUID());
break;
case GOSSIP_ACTION_INFO_DEF+2:
player->CLOSE_GOSSIP_MENU();
//start event here
creature->setFaction(FACTION_HOSTILE);
creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
creature->AI()->AttackStart(player);
InstanceScript* instance = creature->GetInstanceScript();
if (instance)
instance->SetData64(DATA_EVENSTARTER, player->GetGUID());
break;
}
return true;
}
//Immolate_Timer
if (Immolate_Timer <= diff)
bool OnGossipHello(Player* player, Creature* creature) override
{
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_CHALLENGE, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
player->SEND_GOSSIP_MENU(2601, creature->GetGUID());
return true;
}
struct boss_doomrelAI : public ScriptedAI
{
boss_doomrelAI(Creature* creature) : ScriptedAI(creature)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_IMMOLATE);
Immolate_Timer = 25000;
} else Immolate_Timer -= diff;
//CurseOfWeakness_Timer
if (CurseOfWeakness_Timer <= diff)
{
DoCastVictim(SPELL_CURSEOFWEAKNESS);
CurseOfWeakness_Timer = 45000;
} else CurseOfWeakness_Timer -= diff;
//DemonArmor_Timer
if (DemonArmor_Timer <= diff)
{
DoCast(me, SPELL_DEMONARMOR);
DemonArmor_Timer = 300000;
} else DemonArmor_Timer -= diff;
//Summon Voidwalkers
if (!Voidwalkers && HealthBelowPct(51))
{
DoCastVictim(SPELL_SUMMON_VOIDWALKERS, true);
Voidwalkers = true;
_instance = creature->GetInstanceScript();
}
DoMeleeAttackIfReady();
void Reset() override
{
_voidwalkers = false;
me->setFaction(FACTION_FRIEND);
// was set before event start, so set again
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
if (_instance->GetData(DATA_GHOSTKILL) >= 7)
me->SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
else
me->SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
}
void EnterCombat(Unit* /*who*/) override
{
_events.ScheduleEvent(EVENT_SHADOW_BOLT_VOLLEY, 10000);
_events.ScheduleEvent(EVENT_IMMOLATE, 18000);
_events.ScheduleEvent(EVENT_CURSE_OF_WEAKNESS, 5000);
_events.ScheduleEvent(EVENT_DEMONARMOR, 16000);
}
void DamageTaken(Unit* /*attacker*/, uint32& /*damage*/) override
{
if (!_voidwalkers && !HealthAbovePct(50))
{
DoCastVictim(SPELL_SUMMON_VOIDWALKERS, true);
_voidwalkers = true;
}
}
void EnterEvadeMode() override
{
ScriptedAI::EnterEvadeMode();
_instance->SetData64(DATA_EVENSTARTER, 0);
}
void JustDied(Unit* /*killer*/) override
{
_instance->SetData(DATA_GHOSTKILL, 1);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SHADOW_BOLT_VOLLEY:
DoCastVictim(SPELL_SHADOWBOLTVOLLEY);
_events.ScheduleEvent(EVENT_SHADOW_BOLT_VOLLEY, 12000);
break;
case EVENT_IMMOLATE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
DoCast(target, SPELL_IMMOLATE);
_events.ScheduleEvent(EVENT_IMMOLATE, 25000);
break;
case EVENT_CURSE_OF_WEAKNESS:
DoCastVictim(SPELL_CURSEOFWEAKNESS);
_events.ScheduleEvent(EVENT_CURSE_OF_WEAKNESS, 45000);
break;
case EVENT_DEMONARMOR:
DoCast(me, SPELL_DEMONARMOR);
_events.ScheduleEvent(EVENT_DEMONARMOR, 300000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
private:
InstanceScript* _instance;
EventMap _events;
bool _voidwalkers;
};
CreatureAI* GetAI(Creature* creature) const override
{
return GetInstanceAI<boss_doomrelAI>(creature);
}
};
};
void AddSC_boss_tomb_of_seven()