nchebrov/azerothcore-wotlk
1
0
Fork 0
mirror of https://github.com/mod-playerbots/azerothcore-wotlk.git synced 2026-01-23 21:56:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Big re-organization of repository [W.I.P]

Browse Source
This commit is contained in:
Yehonal
2016-08-11 20:25:27 +02:00
parent c62a72c0a8
commit 0f85ce1c54
3016 changed files with 1271 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/server/scripts/Northrend/AzjolNerub/AzjolNerub/azjol_nerub.h
View File

@@ -1,34 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#ifndef DEF_AZJOL_NERUB_H
#define DEF_AZJOL_NERUB_H
enum ANData
{
DATA_KRIKTHIR_THE_GATEWATCHER_EVENT = 0,
DATA_HADRONOX_EVENT = 1,
DATA_ANUBARAK_EVENT = 2,
MAX_ENCOUNTERS = 3
};
enum ANIds
{
NPC_SKITTERING_SWARMER = 28735,
NPC_SKITTERING_INFECTIOR = 28736,
NPC_KRIKTHIR_THE_GATEWATCHER = 28684,
NPC_HADRONOX = 28921,
NPC_ANUB_AR_CHAMPION = 29062,
NPC_ANUB_AR_NECROMANCER = 29063,
NPC_ANUB_AR_CRYPTFIEND = 29064,
GO_KRIKTHIR_DOORS = 192395,
GO_ANUBARAK_DOORS1 = 192396,
GO_ANUBARAK_DOORS2 = 192397,
GO_ANUBARAK_DOORS3 = 192398,
SPELL_WEB_WRAP_TRIGGER = 52087
};
#endif

321
src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_anubarak.cpp
View File

@@ -1,321 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "azjol_nerub.h"
enum Spells
{
SPELL_CARRION_BEETLES = 53520,
SPELL_SUMMON_CARRION_BEETLES = 53521,
SPELL_LEECHING_SWARM = 53467,
SPELL_POUND = 53472,
SPELL_POUND_DAMAGE = 53509,
SPELL_IMPALE_PERIODIC = 53456,
SPELL_EMERGE = 53500,
SPELL_SUBMERGE = 53421,
SPELL_SELF_ROOT = 42716,
SPELL_SUMMON_DARTER = 53599,
SPELL_SUMMON_ASSASSIN = 53610,
SPELL_SUMMON_GUARDIAN = 53614,
SPELL_SUMMON_VENOMANCER = 53615,
};
enum Yells
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2,
SAY_LOCUST = 3,
SAY_SUBMERGE = 4,
SAY_INTRO = 5
};
enum Misc
{
ACHIEV_TIMED_START_EVENT = 20381,
EVENT_CHECK_HEALTH_25 = 1,
EVENT_CHECK_HEALTH_50 = 2,
EVENT_CHECK_HEALTH_75 = 3,
EVENT_CARRION_BEETELS = 4,
EVENT_LEECHING_SWARM = 5,
EVENT_IMPALE = 6,
EVENT_POUND = 7,
EVENT_CLOSE_DOORS = 8,
EVENT_EMERGE = 9,
EVENT_SUMMON_VENOMANCER = 10,
EVENT_SUMMON_DARTER = 11,
EVENT_SUMMON_GUARDIAN = 12,
EVENT_SUMMON_ASSASSINS = 13,
EVENT_ENABLE_ROTATE = 14,
EVENT_KILL_TALK = 15
};
class boss_anub_arak : public CreatureScript
{
public:
boss_anub_arak() : CreatureScript("boss_anub_arak") { }
struct boss_anub_arakAI : public BossAI
{
boss_anub_arakAI(Creature* creature) : BossAI(creature, DATA_ANUBARAK_EVENT)
{
me->m_SightDistance = 120.0f;
intro = false;
}
bool intro;
void EnterEvadeMode()
{
me->DisableRotate(false);
BossAI::EnterEvadeMode();
}
void MoveInLineOfSight(Unit* who)
{
if (!intro && who->GetTypeId() == TYPEID_PLAYER)
{
intro = true;
Talk(SAY_INTRO);
}
BossAI::MoveInLineOfSight(who);
}
void JustDied(Unit* killer)
{
Talk(SAY_DEATH);
BossAI::JustDied(killer);
}
void KilledUnit(Unit* victim)
{
if (events.GetNextEventTime(EVENT_KILL_TALK) == 0)
{
Talk(SAY_SLAY);
events.ScheduleEvent(EVENT_KILL_TALK, 6000);
}
}
void JustSummoned(Creature* summon)
{
summons.Summon(summon);
if (!summon->IsTrigger())
summon->SetInCombatWithZone();
}
void Reset()
{
BossAI::Reset();
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
instance->DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_TIMED_START_EVENT);
}
void EnterCombat(Unit* )
{
Talk(SAY_AGGRO);
instance->DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_TIMED_START_EVENT);
events.ScheduleEvent(EVENT_CARRION_BEETELS, 6500);
events.ScheduleEvent(EVENT_LEECHING_SWARM, 20000);
events.ScheduleEvent(EVENT_POUND, 15000);
events.ScheduleEvent(EVENT_CHECK_HEALTH_75, 1000);
events.ScheduleEvent(EVENT_CHECK_HEALTH_50, 1000);
events.ScheduleEvent(EVENT_CHECK_HEALTH_25, 1000);
events.ScheduleEvent(EVENT_CLOSE_DOORS, 5000);
}
void SummonHelpers(float x, float y, float z, uint32 spellId)
{
const SpellInfo* spellInfo = sSpellMgr->GetSpellInfo(spellId);
me->SummonCreature(spellInfo->Effects[EFFECT_0].MiscValue, x, y, z);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (uint32 eventId = events.ExecuteEvent())
{
case EVENT_CLOSE_DOORS:
_EnterCombat();
break;
case EVENT_CARRION_BEETELS:
me->CastSpell(me, SPELL_CARRION_BEETLES, false);
events.ScheduleEvent(EVENT_CARRION_BEETELS, 25000);
break;
case EVENT_LEECHING_SWARM:
Talk(SAY_LOCUST);
me->CastSpell(me, SPELL_LEECHING_SWARM, false);
events.ScheduleEvent(EVENT_LEECHING_SWARM, 20000);
break;
case EVENT_POUND:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 10.0f))
{
me->CastSpell(me, SPELL_SELF_ROOT, true);
me->DisableRotate(true);
me->SendMovementFlagUpdate();
events.ScheduleEvent(EVENT_ENABLE_ROTATE, 3300);
me->CastSpell(target, SPELL_POUND, false);
}
events.ScheduleEvent(EVENT_POUND, 18000);
break;
case EVENT_ENABLE_ROTATE:
me->RemoveAurasDueToSpell(SPELL_SELF_ROOT);
me->DisableRotate(false);
break;
case EVENT_CHECK_HEALTH_25:
case EVENT_CHECK_HEALTH_50:
case EVENT_CHECK_HEALTH_75:
if (me->HealthBelowPct(eventId*25))
{
Talk(SAY_SUBMERGE);
me->CastSpell(me, SPELL_IMPALE_PERIODIC, true);
me->CastSpell(me, SPELL_SUBMERGE, false);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
events.DelayEvents(46000, 0);
events.ScheduleEvent(EVENT_EMERGE, 45000);
events.ScheduleEvent(EVENT_SUMMON_ASSASSINS, 2000);
events.ScheduleEvent(EVENT_SUMMON_GUARDIAN, 4000);
events.ScheduleEvent(EVENT_SUMMON_ASSASSINS, 15000);
events.ScheduleEvent(EVENT_SUMMON_VENOMANCER, 20000);
events.ScheduleEvent(EVENT_SUMMON_DARTER, 30000);
events.ScheduleEvent(EVENT_SUMMON_ASSASSINS, 35000);
break;
}
events.ScheduleEvent(eventId, 500);
break;
case EVENT_EMERGE:
me->CastSpell(me, SPELL_EMERGE, true);
me->RemoveAura(SPELL_SUBMERGE);
me->RemoveAura(SPELL_IMPALE_PERIODIC);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
break;
case EVENT_SUMMON_ASSASSINS:
SummonHelpers(509.32f, 247.42f, 239.48f, SPELL_SUMMON_ASSASSIN);
SummonHelpers(589.51f, 240.19f, 236.0f, SPELL_SUMMON_ASSASSIN);
break;
case EVENT_SUMMON_DARTER:
SummonHelpers(509.32f, 247.42f, 239.48f, SPELL_SUMMON_DARTER);
SummonHelpers(589.51f, 240.19f, 236.0f, SPELL_SUMMON_DARTER);
break;
case EVENT_SUMMON_GUARDIAN:
SummonHelpers(550.34f, 316.00f, 234.30f, SPELL_SUMMON_GUARDIAN);
break;
case EVENT_SUMMON_VENOMANCER:
SummonHelpers(550.34f, 316.00f, 234.30f, SPELL_SUMMON_VENOMANCER);
break;
}
if (!me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_anub_arakAI(creature);
}
};
class spell_azjol_nerub_carrion_beetels : public SpellScriptLoader
{
public:
spell_azjol_nerub_carrion_beetels() : SpellScriptLoader("spell_azjol_nerub_carrion_beetels") { }
class spell_azjol_nerub_carrion_beetelsAuraScript : public AuraScript
{
PrepareAuraScript(spell_azjol_nerub_carrion_beetelsAuraScript)
void HandleEffectPeriodic(AuraEffect const* aurEff)
{
// Xinef: 2 each second
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SUMMON_CARRION_BEETLES, true);
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SUMMON_CARRION_BEETLES, true);
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_azjol_nerub_carrion_beetelsAuraScript::HandleEffectPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
}
};
AuraScript *GetAuraScript() const
{
return new spell_azjol_nerub_carrion_beetelsAuraScript();
}
};
class spell_azjol_nerub_pound : public SpellScriptLoader
{
public:
spell_azjol_nerub_pound() : SpellScriptLoader("spell_azjol_nerub_pound") { }
class spell_azjol_nerub_pound_SpellScript : public SpellScript
{
PrepareSpellScript(spell_azjol_nerub_pound_SpellScript);
void HandleApplyAura(SpellEffIndex effIndex)
{
if (Unit* unitTarget = GetHitUnit())
GetCaster()->CastSpell(unitTarget, SPELL_POUND_DAMAGE, true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_azjol_nerub_pound_SpellScript::HandleApplyAura, EFFECT_0, SPELL_EFFECT_APPLY_AURA);
}
};
SpellScript* GetSpellScript() const
{
return new spell_azjol_nerub_pound_SpellScript();
}
};
class spell_azjol_nerub_impale_summon : public SpellScriptLoader
{
public:
spell_azjol_nerub_impale_summon() : SpellScriptLoader("spell_azjol_nerub_impale_summon") { }
class spell_azjol_nerub_impale_summon_SpellScript : public SpellScript
{
PrepareSpellScript(spell_azjol_nerub_impale_summon_SpellScript);
void SetDest(SpellDestination& dest)
{
// Adjust effect summon position
float floorZ = GetCaster()->GetMap()->GetHeight(GetCaster()->GetPositionX(), GetCaster()->GetPositionY(), GetCaster()->GetPositionZ(), true);
if (floorZ > INVALID_HEIGHT)
dest._position.m_positionZ = floorZ;
}
void Register()
{
OnDestinationTargetSelect += SpellDestinationTargetSelectFn(spell_azjol_nerub_impale_summon_SpellScript::SetDest, EFFECT_0, TARGET_DEST_CASTER);
}
};
SpellScript* GetSpellScript() const
{
return new spell_azjol_nerub_impale_summon_SpellScript();
}
};
void AddSC_boss_anub_arak()
{
new boss_anub_arak();
new spell_azjol_nerub_carrion_beetels();
new spell_azjol_nerub_pound();
new spell_azjol_nerub_impale_summon();
}

402
src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_hadronox.cpp
View File

@@ -1,402 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "azjol_nerub.h"
#include "ScriptedEscortAI.h"
#include "Player.h"
enum Spells
{
SPELL_SUMMON_ANUBAR_CHAMPION = 53064,
SPELL_SUMMON_ANUBAR_CRYPT_FIEND = 53065,
SPELL_SUMMON_ANUBAR_NECROMANCER = 53066,
SPELL_WEB_FRONT_DOORS = 53177,
SPELL_WEB_SIDE_DOORS = 53185,
SPELL_ACID_CLOUD = 53400,
SPELL_LEECH_POISON = 53030,
SPELL_LEECH_POISON_HEAL = 53800,
SPELL_WEB_GRAB = 57731,
SPELL_PIERCE_ARMOR = 53418,
SPELL_SMASH = 53318,
SPELL_FRENZY = 53801
};
enum Events
{
EVENT_HADRONOX_MOVE1 = 1,
EVENT_HADRONOX_MOVE2 = 2,
EVENT_HADRONOX_MOVE3 = 3,
EVENT_HADRONOX_MOVE4 = 4,
EVENT_HADRONOX_ACID = 5,
EVENT_HADRONOX_LEECH = 6,
EVENT_HADRONOX_PIERCE = 7,
EVENT_HADRONOX_GRAB = 8,
EVENT_HADRONOX_SUMMON = 9,
EVENT_CRUSHER_SMASH = 20,
EVENT_CHECK_HEALTH = 21
};
enum Misc
{
NPC_ANUB_AR_CRUSHER = 28922,
SAY_CRUSHER_AGGRO = 0,
SAY_CRUSHER_EMOTE = 1,
SAY_HADRONOX_EMOTE = 0,
ACTION_DESPAWN_ADDS = 1,
ACTION_START_EVENT = 2
};
const Position hadronoxSteps[4] =
{
{607.9f, 512.8f, 695.3f, 0.0f},
{611.67f, 564.11f, 720.0f, 0.0f},
{576.1f, 580.0f, 727.5f, 0.0f},
{534.87f, 554.0f, 733.0f, 0.0f}
};
class boss_hadronox : public CreatureScript
{
public:
boss_hadronox() : CreatureScript("boss_hadronox") { }
struct boss_hadronoxAI : public BossAI
{
boss_hadronoxAI(Creature* creature) : BossAI(creature, DATA_HADRONOX_EVENT)
{
}
void Reset()
{
summons.DoAction(ACTION_DESPAWN_ADDS);
BossAI::Reset();
me->SummonCreature(NPC_ANUB_AR_CRUSHER, 542.9f, 519.5f, 741.24f, 2.14f);
}
void DoAction(int32 param)
{
if (param == ACTION_START_EVENT)
{
instance->SetBossState(DATA_HADRONOX_EVENT, IN_PROGRESS);
me->setActive(true);
events.ScheduleEvent(EVENT_HADRONOX_MOVE1, 20000);
events.ScheduleEvent(EVENT_HADRONOX_MOVE2, 40000);
events.ScheduleEvent(EVENT_HADRONOX_MOVE3, 60000);
events.ScheduleEvent(EVENT_HADRONOX_MOVE4, 80000);
}
}
uint32 GetData(uint32 data) const
{
if (data == me->GetEntry())
return !me->isActiveObject() || events.GetNextEventTime(EVENT_HADRONOX_MOVE4) != 0;
return 0;
}
void JustSummoned(Creature* summon)
{
summons.Summon(summon);
// Xinef: cannot use pathfinding...
if (summon->GetDistance(477.0f, 618.0f, 771.0f) < 5.0f)
summon->GetMotionMaster()->MovePath(3000012, false);
else if (summon->GetDistance(583.0f, 617.0f, 771.0f) < 5.0f)
summon->GetMotionMaster()->MovePath(3000013, false);
else if (summon->GetDistance(581.0f, 608.5f, 739.0f) < 5.0f)
summon->GetMotionMaster()->MovePath(3000014, false);
}
void KilledUnit(Unit* victim)
{
if (!me->IsAlive() || !victim->HasAura(SPELL_LEECH_POISON))
return;
me->ModifyHealth(int32(me->CountPctFromMaxHealth(10)));
}
void JustDied(Unit* killer)
{
BossAI::JustDied(killer);
}
void EnterCombat(Unit*)
{
events.RescheduleEvent(EVENT_HADRONOX_ACID, 10000);
events.RescheduleEvent(EVENT_HADRONOX_LEECH, 4000);
events.RescheduleEvent(EVENT_HADRONOX_PIERCE, 1000);
events.RescheduleEvent(EVENT_HADRONOX_GRAB, 15000);
}
bool AnyPlayerValid() const
{
Map::PlayerList const& playerList = me->GetMap()->GetPlayers();
for(Map::PlayerList::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
if (me->GetDistance(itr->GetSource()) < 130.0f && itr->GetSource()->IsAlive() && !itr->GetSource()->IsGameMaster() && me->CanCreatureAttack(itr->GetSource()) && me->_CanDetectFeignDeathOf(itr->GetSource()))
return true;
return false;
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (uint32 eventId = events.ExecuteEvent())
{
case EVENT_HADRONOX_PIERCE:
me->CastSpell(me->GetVictim(), SPELL_PIERCE_ARMOR, false);
events.ScheduleEvent(EVENT_HADRONOX_PIERCE, 8000);
break;
case EVENT_HADRONOX_ACID:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, false))
me->CastSpell(target, SPELL_ACID_CLOUD, false);
events.ScheduleEvent(EVENT_HADRONOX_ACID, 25000);
break;
case EVENT_HADRONOX_LEECH:
me->CastSpell(me, SPELL_LEECH_POISON, false);
events.ScheduleEvent(EVENT_HADRONOX_LEECH, 12000);
break;
case EVENT_HADRONOX_GRAB:
me->CastSpell(me, SPELL_WEB_GRAB, false);
events.ScheduleEvent(EVENT_HADRONOX_GRAB, 25000);
break;
case EVENT_HADRONOX_MOVE4:
me->CastSpell(me, SPELL_WEB_FRONT_DOORS, true);
case EVENT_HADRONOX_MOVE1:
case EVENT_HADRONOX_MOVE2:
case EVENT_HADRONOX_MOVE3:
Talk(SAY_HADRONOX_EMOTE);
me->GetMotionMaster()->MoveCharge(hadronoxSteps[eventId-1].GetPositionX(), hadronoxSteps[eventId-1].GetPositionY(), hadronoxSteps[eventId-1].GetPositionZ(), 10.0f, 0, NULL, true);
break;
}
DoMeleeAttackIfReady();
EnterEvadeIfOutOfCombatArea();
}
bool CheckEvadeIfOutOfCombatArea() const
{
return me->isActiveObject() && !AnyPlayerValid();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_hadronoxAI(creature);
}
};
class npc_anub_ar_crusher : public CreatureScript
{
public:
npc_anub_ar_crusher() : CreatureScript("npc_anub_ar_crusher") { }
struct npc_anub_ar_crusherAI : public ScriptedAI
{
npc_anub_ar_crusherAI(Creature *c) : ScriptedAI(c), summons(me) {}
EventMap events;
SummonList summons;
void Reset()
{
summons.DespawnAll();
events.Reset();
if (me->ToTempSummon())
if (Unit* summoner = me->ToTempSummon()->GetSummoner())
if (summoner->GetEntry() == me->GetEntry())
{
me->CastSpell(me, RAND(SPELL_SUMMON_ANUBAR_CHAMPION, SPELL_SUMMON_ANUBAR_CRYPT_FIEND, SPELL_SUMMON_ANUBAR_NECROMANCER), true);
me->CastSpell(me, RAND(SPELL_SUMMON_ANUBAR_CHAMPION, SPELL_SUMMON_ANUBAR_CRYPT_FIEND, SPELL_SUMMON_ANUBAR_NECROMANCER), true);
}
}
void JustSummoned(Creature* summon)
{
if(summon->GetEntry() != me->GetEntry())
{
summon->GetMotionMaster()->MovePoint(0, *me, false);
summon->GetMotionMaster()->MoveFollow(me, 0.1f, 0.0f + M_PI*0.3f*summons.size());
}
summons.Summon(summon);
}
void DoAction(int32 param)
{
if (param == ACTION_DESPAWN_ADDS)
{
summons.DoAction(ACTION_DESPAWN_ADDS);
summons.DespawnAll();
}
}
void EnterCombat(Unit*)
{
if (me->ToTempSummon())
if (Unit* summoner = me->ToTempSummon()->GetSummoner())
if (summoner->GetEntry() != me->GetEntry())
{
summoner->GetAI()->DoAction(ACTION_START_EVENT);
me->SummonCreature(NPC_ANUB_AR_CRUSHER, 519.58f, 573.73f, 734.30f, 4.50f);
me->SummonCreature(NPC_ANUB_AR_CRUSHER, 539.38f, 573.25f, 732.20f, 4.738f);
Talk(SAY_CRUSHER_AGGRO);
}
events.ScheduleEvent(EVENT_CRUSHER_SMASH, 8000, 0, 0);
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_CRUSHER_SMASH:
me->CastSpell(me->GetVictim(), SPELL_SMASH, false);
events.ScheduleEvent(EVENT_CRUSHER_SMASH, 15000);
break;
case EVENT_CHECK_HEALTH:
if (me->HealthBelowPct(30))
{
Talk(SAY_CRUSHER_EMOTE);
me->CastSpell(me, SPELL_FRENZY, false);
break;
}
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
break;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new npc_anub_ar_crusherAI(creature);
}
};
class spell_hadronox_summon_periodic : public SpellScriptLoader
{
public:
spell_hadronox_summon_periodic(const char* name, uint32 delay, uint32 spellEntry) : SpellScriptLoader(name), _delay(delay), _spellEntry(spellEntry) { }
class spell_hadronox_summon_periodic_AuraScript : public AuraScript
{
public:
spell_hadronox_summon_periodic_AuraScript(uint32 delay, uint32 spellEntry) : _delay(delay), _spellEntry(spellEntry) { }
PrepareAuraScript(spell_hadronox_summon_periodic_AuraScript);
void HandlePeriodic(AuraEffect const* /*aurEff*/)
{
PreventDefaultAction();
Unit* owner = GetUnitOwner();
if (InstanceScript* instance = owner->GetInstanceScript())
if (instance->GetBossState(DATA_HADRONOX_EVENT) != DONE)
{
if (!owner->HasAura(SPELL_WEB_FRONT_DOORS))
owner->CastSpell(owner, _spellEntry, true);
else if (!instance->IsEncounterInProgress())
owner->RemoveAurasDueToSpell(SPELL_WEB_FRONT_DOORS);
}
}
void OnApply(AuraEffect const* auraEffect, AuraEffectHandleModes)
{
GetAura()->GetEffect(auraEffect->GetEffIndex())->SetPeriodicTimer(_delay);
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_hadronox_summon_periodic_AuraScript::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
OnEffectApply += AuraEffectApplyFn(spell_hadronox_summon_periodic_AuraScript::OnApply, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL);
}
private:
uint32 _spellEntry;
uint32 _delay;
};
AuraScript* GetAuraScript() const
{
return new spell_hadronox_summon_periodic_AuraScript(_delay, _spellEntry);
}
private:
uint32 _spellEntry;
uint32 _delay;
};
class spell_hadronox_leech_poison : public SpellScriptLoader
{
public:
spell_hadronox_leech_poison() : SpellScriptLoader("spell_hadronox_leech_poison") { }
class spell_hadronox_leech_poison_AuraScript : public AuraScript
{
PrepareAuraScript(spell_hadronox_leech_poison_AuraScript)
void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_DEATH)
if (Unit* caster = GetCaster())
caster->CastSpell(caster, SPELL_LEECH_POISON_HEAL, true);
}
void Register()
{
AfterEffectRemove += AuraEffectRemoveFn(spell_hadronox_leech_poison_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_PERIODIC_LEECH, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_hadronox_leech_poison_AuraScript();
}
};
class achievement_hadronox_denied : public AchievementCriteriaScript
{
public:
achievement_hadronox_denied() : AchievementCriteriaScript("achievement_hadronox_denied")
{
}
bool OnCheck(Player* /*player*/, Unit* target)
{
if (!target)
return false;
return target->GetAI()->GetData(target->GetEntry());
}
};
void AddSC_boss_hadronox()
{
new boss_hadronox();
new npc_anub_ar_crusher();
new spell_hadronox_summon_periodic("spell_hadronox_summon_periodic_champion", 15000, SPELL_SUMMON_ANUBAR_CHAMPION);
new spell_hadronox_summon_periodic("spell_hadronox_summon_periodic_necromancer", 10000, SPELL_SUMMON_ANUBAR_NECROMANCER);
new spell_hadronox_summon_periodic("spell_hadronox_summon_periodic_crypt_fiend", 5000, SPELL_SUMMON_ANUBAR_CRYPT_FIEND);
new spell_hadronox_leech_poison();
new achievement_hadronox_denied();
}

239
src/server/scripts/Northrend/AzjolNerub/AzjolNerub/boss_krikthir_the_gatewatcher.cpp
View File

@@ -1,239 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "azjol_nerub.h"
enum Spells
{
SPELL_SUBBOSS_AGGRO_TRIGGER = 52343,
SPELL_SWARM = 52440,
SPELL_MIND_FLAY = 52586,
SPELL_CURSE_OF_FATIGUE = 52592,
SPELL_FRENZY = 28747
};
enum Events
{
EVENT_KRIK_START_WAVE = 1,
EVENT_KRIK_SUMMON = 2,
EVENT_KRIK_MIND_FLAY = 3,
EVENT_KRIK_CURSE = 4,
EVENT_KRIK_HEALTH_CHECK = 5,
EVENT_KRIK_ENTER_COMBAT = 6,
EVENT_KILL_TALK = 7,
EVENT_CALL_ADDS = 8,
EVENT_KRIK_CHECK_EVADE = 9
};
enum Npcs
{
NPC_WATCHER_NARJIL = 28729,
NPC_WATCHER_GASHRA = 28730,
NPC_WATCHER_SILTHIK = 28731,
NPC_WARRIOR = 28732,
NPC_SKIRMISHER = 28734,
NPC_SHADOWCASTER = 28733
};
enum Yells
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2,
SAY_SWARM = 3,
SAY_PREFIGHT = 4,
SAY_SEND_GROUP = 5
};
class boss_krik_thir : public CreatureScript
{
public:
boss_krik_thir() : CreatureScript("boss_krik_thir") { }
struct boss_krik_thirAI : public BossAI
{
boss_krik_thirAI(Creature* creature) : BossAI(creature, DATA_KRIKTHIR_THE_GATEWATCHER_EVENT)
{
_initTalk = false;
}
EventMap events2;
bool _initTalk;
void Reset()
{
BossAI::Reset();
events2.Reset();
me->SummonCreature(NPC_WATCHER_NARJIL, 511.8f, 666.493f, 776.278f, 0.977f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 30000);
me->SummonCreature(NPC_SHADOWCASTER, 518.13f, 667.0f, 775.74f, 1.0f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 30000);
me->SummonCreature(NPC_WARRIOR, 506.75f, 670.7f, 776.24f, 0.92f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 30000);
me->SummonCreature(NPC_WATCHER_GASHRA, 526.66f, 663.605f, 775.805f, 1.23f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 30000);
me->SummonCreature(NPC_SKIRMISHER, 522.23f, 668.97f, 775.66f, 1.18f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 30000);
me->SummonCreature(NPC_WARRIOR, 532.4f, 666.47f, 775.67f, 1.45f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 30000);
me->SummonCreature(NPC_WATCHER_SILTHIK, 543.826f, 665.123f, 776.245f, 1.55f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 30000);
me->SummonCreature(NPC_SKIRMISHER, 547.5f, 669.96f, 776.1f, 2.3f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 30000);
me->SummonCreature(NPC_SHADOWCASTER, 536.96f, 667.28f, 775.6f, 1.72f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 30000);
}
void MoveInLineOfSight(Unit *who)
{
if (who->GetTypeId() != TYPEID_PLAYER)
return;
if (!_initTalk)
{
_initTalk = true;
Talk(SAY_PREFIGHT);
}
if (events.Empty() && who->GetPositionZ() < 785.0f)
{
events2.ScheduleEvent(EVENT_KRIK_START_WAVE, 10000);
events2.ScheduleEvent(EVENT_KRIK_START_WAVE, 40000);
events2.ScheduleEvent(EVENT_KRIK_START_WAVE, 70000);
events2.ScheduleEvent(EVENT_KRIK_ENTER_COMBAT, 100000);
events2.ScheduleEvent(EVENT_KRIK_CHECK_EVADE, 5000);
events.ScheduleEvent(EVENT_KRIK_HEALTH_CHECK, 1000);
events.ScheduleEvent(EVENT_KRIK_MIND_FLAY, 13000);
events.ScheduleEvent(EVENT_KRIK_SUMMON, 17000);
events.ScheduleEvent(EVENT_KRIK_CURSE, 8000);
events.ScheduleEvent(EVENT_CALL_ADDS, 1000);
me->setActive(true);
}
}
uint32 GetData(uint32 data) const
{
if (data == me->GetEntry())
return summons.HasEntry(NPC_WATCHER_NARJIL) && summons.HasEntry(NPC_WATCHER_GASHRA) && summons.HasEntry(NPC_WATCHER_SILTHIK);
return 0;
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
Talk(SAY_AGGRO);
events2.Reset();
}
void JustDied(Unit* killer)
{
BossAI::JustDied(killer);
Talk(SAY_DEATH);
}
void KilledUnit(Unit* )
{
if (events.GetNextEventTime(EVENT_KILL_TALK) == 0)
{
Talk(SAY_SLAY);
events.ScheduleEvent(EVENT_KILL_TALK, 6000);
}
}
void JustSummoned(Creature* summon)
{
summon->SetNoCallAssistance(true);
summons.Summon(summon);
}
void SummonedCreatureDies(Creature* summon, Unit*)
{
summons.Despawn(summon);
}
void UpdateAI(uint32 diff)
{
events2.Update(diff);
switch (events2.ExecuteEvent())
{
case EVENT_KRIK_START_WAVE:
me->CastCustomSpell(SPELL_SUBBOSS_AGGRO_TRIGGER, SPELLVALUE_MAX_TARGETS, 1, me, true);
Talk(SAY_SEND_GROUP);
break;
case EVENT_KRIK_ENTER_COMBAT:
me->SetInCombatWithZone();
break;
case EVENT_KRIK_CHECK_EVADE:
if (!SelectTargetFromPlayerList(100.0f))
{
EnterEvadeMode();
return;
}
events2.ScheduleEvent(EVENT_KRIK_CHECK_EVADE, 5000);
break;
}
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_KRIK_HEALTH_CHECK:
if (HealthBelowPct(10))
{
events.PopEvent();
me->CastSpell(me, SPELL_FRENZY, true);
break;
}
events.ScheduleEvent(EVENT_KRIK_HEALTH_CHECK, 1000);
break;
case EVENT_KRIK_SUMMON:
Talk(SAY_SWARM);
me->CastSpell(me, SPELL_SWARM, false);
events.ScheduleEvent(EVENT_KRIK_SUMMON, 20000);
break;
case EVENT_KRIK_MIND_FLAY:
me->CastSpell(me->GetVictim(), SPELL_MIND_FLAY, false);
events.ScheduleEvent(EVENT_KRIK_MIND_FLAY, 15000);
break;
case EVENT_KRIK_CURSE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
me->CastSpell(target, SPELL_CURSE_OF_FATIGUE, true);
events.ScheduleEvent(EVENT_KRIK_CURSE, 10000);
break;
case EVENT_CALL_ADDS:
summons.DoZoneInCombat();
break;
}
DoMeleeAttackIfReady();
}
};
CreatureAI *GetAI(Creature *creature) const
{
return new boss_krik_thirAI(creature);
}
};
class achievement_watch_him_die : public AchievementCriteriaScript
{
public:
achievement_watch_him_die() : AchievementCriteriaScript("achievement_watch_him_die")
{
}
bool OnCheck(Player* /*player*/, Unit* target)
{
if (!target)
return false;
return target->GetAI()->GetData(target->GetEntry());
}
};
void AddSC_boss_krik_thir()
{
new boss_krik_thir();
new achievement_watch_him_die();
}

189
src/server/scripts/Northrend/AzjolNerub/AzjolNerub/instance_azjol_nerub.cpp
View File

@@ -1,189 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "azjol_nerub.h"
DoorData const doorData[] =
{
{ GO_KRIKTHIR_DOORS, DATA_KRIKTHIR_THE_GATEWATCHER_EVENT, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_ANUBARAK_DOORS1, DATA_ANUBARAK_EVENT, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_ANUBARAK_DOORS2, DATA_ANUBARAK_EVENT, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_ANUBARAK_DOORS3, DATA_ANUBARAK_EVENT, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ 0, 0, DOOR_TYPE_ROOM, BOUNDARY_NONE }
};
class instance_azjol_nerub : public InstanceMapScript
{
public:
instance_azjol_nerub() : InstanceMapScript("instance_azjol_nerub", 601) { }
struct instance_azjol_nerub_InstanceScript : public InstanceScript
{
instance_azjol_nerub_InstanceScript(Map* map) : InstanceScript(map)
{
SetBossNumber(MAX_ENCOUNTERS);
LoadDoorData(doorData);
_krikthirGUID = 0;
_hadronoxGUID = 0;
};
void OnCreatureCreate(Creature* creature)
{
switch (creature->GetEntry())
{
case NPC_KRIKTHIR_THE_GATEWATCHER:
_krikthirGUID = creature->GetGUID();
break;
case NPC_HADRONOX:
_hadronoxGUID = creature->GetGUID();
break;
case NPC_SKITTERING_SWARMER:
case NPC_SKITTERING_INFECTIOR:
if (Creature* krikthir = instance->GetCreature(_krikthirGUID))
krikthir->AI()->JustSummoned(creature);
break;
case NPC_ANUB_AR_CHAMPION:
case NPC_ANUB_AR_NECROMANCER:
case NPC_ANUB_AR_CRYPTFIEND:
if (Creature* hadronox = instance->GetCreature(_hadronoxGUID))
hadronox->AI()->JustSummoned(creature);
break;
}
}
void OnGameObjectCreate(GameObject* go)
{
switch (go->GetEntry())
{
case GO_KRIKTHIR_DOORS:
case GO_ANUBARAK_DOORS1:
case GO_ANUBARAK_DOORS2:
case GO_ANUBARAK_DOORS3:
AddDoor(go, true);
break;
}
}
void OnGameObjectRemove(GameObject* go)
{
switch (go->GetEntry())
{
case GO_KRIKTHIR_DOORS:
case GO_ANUBARAK_DOORS1:
case GO_ANUBARAK_DOORS2:
case GO_ANUBARAK_DOORS3:
AddDoor(go, false);
break;
}
}
bool SetBossState(uint32 id, EncounterState state)
{
return InstanceScript::SetBossState(id, state);
}
std::string GetSaveData()
{
std::ostringstream saveStream;
saveStream << "A N " << GetBossSaveData();
return saveStream.str();
}
void Load(const char* in)
{
if( !in )
return;
char dataHead1, dataHead2;
std::istringstream loadStream(in);
loadStream >> dataHead1 >> dataHead2;
if (dataHead1 == 'A' && dataHead2 == 'N')
{
for (uint8 i = 0; i < MAX_ENCOUNTERS; ++i)
{
uint32 tmpState;
loadStream >> tmpState;
if (tmpState == IN_PROGRESS || tmpState > SPECIAL)
tmpState = NOT_STARTED;
SetBossState(i, EncounterState(tmpState));
}
}
}
private:
uint64 _krikthirGUID;
uint64 _hadronoxGUID;
};
InstanceScript* GetInstanceScript(InstanceMap *map) const
{
return new instance_azjol_nerub_InstanceScript(map);
}
};
class spell_azjol_nerub_fixate : public SpellScriptLoader
{
public:
spell_azjol_nerub_fixate() : SpellScriptLoader("spell_azjol_nerub_fixate") { }
class spell_azjol_nerub_fixate_SpellScript : public SpellScript
{
PrepareSpellScript(spell_azjol_nerub_fixate_SpellScript);
void HandleScriptEffect(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
if (Unit* target = GetHitUnit())
target->CastSpell(GetCaster(), GetEffectValue(), true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_azjol_nerub_fixate_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_azjol_nerub_fixate_SpellScript();
}
};
class spell_azjol_nerub_web_wrap : public SpellScriptLoader
{
public:
spell_azjol_nerub_web_wrap() : SpellScriptLoader("spell_azjol_nerub_web_wrap") { }
class spell_azjol_nerub_web_wrap_AuraScript : public AuraScript
{
PrepareAuraScript(spell_azjol_nerub_web_wrap_AuraScript);
void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
Unit* target = GetTarget();
if (!target->HasAura(SPELL_WEB_WRAP_TRIGGER))
target->CastSpell(target, SPELL_WEB_WRAP_TRIGGER, true);
}
void Register()
{
OnEffectRemove += AuraEffectRemoveFn(spell_azjol_nerub_web_wrap_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_MOD_ROOT, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_azjol_nerub_web_wrap_AuraScript();
}
};
void AddSC_instance_azjol_nerub()
{
new instance_azjol_nerub();
new spell_azjol_nerub_fixate();
new spell_azjol_nerub_web_wrap();
}

38
src/server/scripts/Northrend/AzjolNerub/ahnkahet/ahnkahet.h
View File

@@ -1,38 +0,0 @@
#ifndef DEF_AHNKAHET_H
#define DEF_AHNKAHET_H
#define MAX_ENCOUNTER 5
enum Data64
{
DATA_ELDER_NADOX,
DATA_PRINCE_TALDARAM,
DATA_JEDOGA_SHADOWSEEKER,
DATA_HERALD_VOLAZJ,
DATA_AMANITAR,
DATA_PRINCE_TALDARAM_PLATFORM,
};
enum Data
{
DATA_ELDER_NADOX_EVENT,
DATA_PRINCE_TALDARAM_EVENT,
DATA_JEDOGA_SHADOWSEEKER_EVENT,
DATA_HERALD_VOLAZJ_EVENT,
DATA_AMANITAR_EVENT,
DATA_SPHERE_EVENT,
DATA_NADOX_ACHIEVEMENT,
DATA_JEDOGA_ACHIEVEMENT,
};
enum Npc
{
NPC_ELDER_NADOX = 29309,
NPC_PRINCE_TALDARAM = 29308,
NPC_JEDOGA_SHADOWSEEKER = 29310,
NPC_HERALD_JOLAZJ = 29311,
NPC_AMANITAR = 30258,
};
#endif

228
src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_amanitar.cpp
View File

@@ -1,228 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY XINEF, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "ahnkahet.h"
enum Spells
{
SPELL_BASH = 57094,
SPELL_ENTANGLING_ROOTS = 57095,
SPELL_MINI = 57055,
SPELL_VENOM_BOLT_VOLLEY = 57088,
SPELL_HEALTHY_MUSHROOM_POTENT_FUNGUS = 56648,
SPELL_POISONOUS_MUSHROOM_POISON_CLOUD = 57061,
SPELL_POISONOUS_MUSHROOM_VISUAL_AURA = 56741,
SPELL_HEALTHY_MUSHROOM_VISUAL_AURA = 56740,
};
enum Creatures
{
NPC_HEALTHY_MUSHROOM = 30391,
NPC_POISONOUS_MUSHROOM = 30435
};
enum Events
{
EVENT_AMANITAR_SPAWN = 1,
EVENT_AMANITAR_ROOTS = 2,
EVENT_AMANITAR_BASH = 3,
EVENT_AMANITAR_BOLT = 4,
};
class boss_amanitar : public CreatureScript
{
public:
boss_amanitar() : CreatureScript("boss_amanitar") { }
struct boss_amanitarAI : public ScriptedAI
{
boss_amanitarAI(Creature *c) : ScriptedAI(c), summons(me)
{
pInstance = c->GetInstanceScript();
me->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_NATURE, true);
}
InstanceScript* pInstance;
EventMap events;
SummonList summons;
void Reset()
{
events.Reset();
summons.DespawnAll();
me->SetMeleeDamageSchool(SPELL_SCHOOL_NATURE);
if (pInstance)
{
pInstance->SetData(DATA_AMANITAR_EVENT, NOT_STARTED);
pInstance->DoRemoveAurasDueToSpellOnPlayers(SPELL_MINI);
}
}
void JustDied(Unit* /*Killer*/)
{
summons.DespawnAll();
if (pInstance)
{
pInstance->SetData(DATA_AMANITAR_EVENT, DONE);
pInstance->DoRemoveAurasDueToSpellOnPlayers(SPELL_MINI);
}
}
void EnterCombat(Unit* /*who*/)
{
if (pInstance)
pInstance->SetData(DATA_AMANITAR_EVENT, IN_PROGRESS);
me->CastSpell(me, SPELL_MINI, false);
events.ScheduleEvent(EVENT_AMANITAR_ROOTS, urand(5000, 9000));
events.ScheduleEvent(EVENT_AMANITAR_BASH, urand(10000, 14000));
events.ScheduleEvent(EVENT_AMANITAR_BOLT, urand(15000, 20000));
events.ScheduleEvent(EVENT_AMANITAR_SPAWN, 0);
}
void JustSummoned(Creature *cr) { summons.Summon(cr); }
void SpawnAdds()
{
summons.DespawnAll();
Position center;
center.Relocate(362.6f, -870, -75);
for (uint8 i = 0; i < 25; ++i)
{
float orientation = 2*rand_norm()*M_PI;
float x = center.GetPositionX() + i*2*cos(orientation);
float y = center.GetPositionY() + i*2*sin(orientation);
me->SummonCreature(NPC_POISONOUS_MUSHROOM, x, y, me->GetMap()->GetHeight(x, y, MAX_HEIGHT));
}
for (uint8 i = 0; i < 25; ++i)
{
float orientation = 2*rand_norm()*M_PI;
float x = center.GetPositionX() + i*2*cos(orientation);
float y = center.GetPositionY() + i*2*sin(orientation);
me->SummonCreature(NPC_HEALTHY_MUSHROOM, x, y, me->GetMap()->GetHeight(x, y, MAX_HEIGHT));
}
}
void UpdateAI(uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.GetEvent())
{
case EVENT_AMANITAR_SPAWN:
{
SpawnAdds();
events.RepeatEvent(urand(35000, 40000));
break;
}
case EVENT_AMANITAR_ROOTS:
{
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
me->CastSpell(pTarget, SPELL_ENTANGLING_ROOTS, false);
events.RepeatEvent(urand(15000, 20000));
break;
}
case EVENT_AMANITAR_BASH:
{
me->CastSpell(me->GetVictim(), SPELL_BASH, false);
events.RepeatEvent(urand(15000, 20000));
break;
}
case EVENT_AMANITAR_BOLT:
{
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
me->CastSpell(pTarget, SPELL_VENOM_BOLT_VOLLEY, false);
events.RepeatEvent(urand(15000, 20000));
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI *GetAI(Creature *creature) const
{
return new boss_amanitarAI(creature);
}
};
class npc_amanitar_mushrooms : public CreatureScript
{
public:
npc_amanitar_mushrooms() : CreatureScript("npc_amanitar_mushrooms") { }
struct npc_amanitar_mushroomsAI : public ScriptedAI
{
npc_amanitar_mushroomsAI(Creature* c) : ScriptedAI(c)
{
SetCombatMovement(false);
}
uint32 Timer;
void Reset()
{
me->CastSpell(me, 31690, true);
Timer = 0;
if (me->GetEntry() == NPC_POISONOUS_MUSHROOM)
{
me->CastSpell(me, SPELL_POISONOUS_MUSHROOM_VISUAL_AURA, true);
me->CastSpell(me, SPELL_POISONOUS_MUSHROOM_POISON_CLOUD, false);
}
else
me->CastSpell(me, SPELL_HEALTHY_MUSHROOM_VISUAL_AURA, true);
}
void JustDied(Unit* killer)
{
if (!killer)
return;
if (me->GetEntry() == NPC_HEALTHY_MUSHROOM)
me->CastSpell(me, SPELL_HEALTHY_MUSHROOM_POTENT_FUNGUS, true);
}
void EnterCombat(Unit* /*who*/) {}
void AttackStart(Unit* /*victim*/) {}
void UpdateAI(uint32 diff)
{
if (me->GetEntry() == NPC_POISONOUS_MUSHROOM)
{
Timer += diff;
if (Timer >= 7000)
{
me->CastSpell(me, SPELL_POISONOUS_MUSHROOM_POISON_CLOUD, false);
Timer = 0;
}
}
}
};
CreatureAI *GetAI(Creature *creature) const
{
return new npc_amanitar_mushroomsAI(creature);
}
};
void AddSC_boss_amanitar()
{
new boss_amanitar;
new npc_amanitar_mushrooms;
}

378
src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_elder_nadox.cpp
View File

@@ -1,378 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY XINEF, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "ahnkahet.h"
#include "SpellAuras.h"
#include "SpellScript.h"
enum misc
{
// ACTIONS
ACTION_GUARDIAN_DIED = 1,
};
enum spells
{
// NADOX
SPELL_BROOD_PLAGUE = 56130,
SPELL_BROOD_PLAGUE_H = 59467,
SPELL_BROOD_RAGE_H = 59465,
SPELL_ENRAGE = 26662, // Enraged if too far away from home
//SPELL_SUMMON_SWARMERS = 56119, //2x 30178 -- 2x every 10secs, spell works fine but i need specific coords
//SPELL_SUMMON_SWARM_GUARD = 56120, //1x 30176 -- at 50%hp, spell works fine but i need specific coords
// ADDS
SPELL_SPRINT = 56354,
SPELL_GUARDIAN_AURA = 56151,
SPELL_SWARMER_AURA = 56158,
};
enum creatures
{
NPC_AHNKAHAR_SWARMER = 30178,
NPC_AHNKAHAR_GUARDIAN_ENTRY = 30176,
};
enum events
{
EVENT_CHECK_HEALTH = 1,
EVENT_CHECK_HOME = 2,
EVENT_PLAGUE = 3,
EVENT_BROOD_RAGE = 4,
EVENT_SWARMER = 5,
EVENT_SUMMON_GUARD = 6,
};
enum sounds
{
SOUND_AGGRO = 14033,
SOUND_SUMMON1 = 14034,
SOUND_SUMMON2 = 14035,
SOUND_SLAY1 = 14036,
SOUND_SLAY2 = 14037,
SOUND_SLAY3 = 14038,
SOUND_DEATH = 14039,
};
#define EMOTE_HATCHES "An Ahn'kahar Guardian hatches!"
class boss_elder_nadox : public CreatureScript
{
public:
boss_elder_nadox() : CreatureScript("boss_elder_nadox") { }
struct boss_elder_nadoxAI : public ScriptedAI
{
boss_elder_nadoxAI(Creature *c) : ScriptedAI(c), summons(me)
{
pInstance = c->GetInstanceScript();
}
EventMap events;
InstanceScript *pInstance;
SummonList summons;
void SummonHelpers(bool swarm)
{
Creature *cr;
if (swarm)
{
if (cr = me->SummonCreature(NPC_AHNKAHAR_SWARMER, 640.425f, -919.544f, 25.8701f, 2.56563f))
summons.Summon(cr);
if (cr = me->SummonCreature(NPC_AHNKAHAR_SWARMER, 655.891f, -930.445f, 25.6978f, 3.64774f))
summons.Summon(cr);
}
else
{
if (cr = me->SummonCreature(NPC_AHNKAHAR_GUARDIAN_ENTRY, 658.677f, -934.332f, 25.6978f, 3.03687f))
summons.Summon(cr);
}
}
void Reset()
{
events.Reset();
summons.DespawnAll();
if (pInstance)
{
pInstance->SetData(DATA_ELDER_NADOX_EVENT, NOT_STARTED);
pInstance->SetData(DATA_NADOX_ACHIEVEMENT, true);
}
}
void EnterCombat(Unit * /*who*/)
{
me->MonsterYell("The secrets of the deep shall remain hidden.", LANG_UNIVERSAL, 0);
me->PlayDirectSound(SOUND_AGGRO);
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
events.ScheduleEvent(EVENT_SWARMER, 10000);
events.ScheduleEvent(EVENT_CHECK_HOME, 2000);
events.ScheduleEvent(EVENT_PLAGUE, 5000+rand()%3000);
events.ScheduleEvent(EVENT_BROOD_RAGE, 5000);
if (pInstance)
pInstance->SetData(DATA_ELDER_NADOX_EVENT, IN_PROGRESS);
}
void DoAction(int32 param)
{
if (param == ACTION_GUARDIAN_DIED)
{
if (pInstance)
pInstance->SetData(DATA_NADOX_ACHIEVEMENT, false);
}
}
void KilledUnit(Unit * /*victim*/)
{
if (urand(0,1))
return;
switch (rand()%3)
{
case 0:
me->MonsterYell("Sleep now, in the cold dark.", LANG_UNIVERSAL,0);
me->PlayDirectSound(SOUND_SLAY1);
break;
case 1:
me->MonsterYell("For the Lich King!", LANG_UNIVERSAL,0);
me->PlayDirectSound(SOUND_SLAY2);
break;
case 2:
me->MonsterYell("Perhaps we will be allies soon.", LANG_UNIVERSAL,0);
me->PlayDirectSound(SOUND_SLAY3);
break;
}
}
void JustDied(Unit* /*killer*/)
{
events.Reset();
summons.DespawnAll();
me->MonsterYell("Master, is my service complete?", LANG_UNIVERSAL, 0);
me->PlayDirectSound(SOUND_DEATH);
if (pInstance)
pInstance->SetData(DATA_ELDER_NADOX_EVENT, DONE);
}
void JustSummoned(Creature* cr)
{
if (cr)
{
if (cr->GetEntry() == NPC_AHNKAHAR_GUARDIAN_ENTRY )
{
switch (rand()%2)
{
case 0:
me->MonsterYell("The young must not grow hungry...", LANG_UNIVERSAL, 0);
me->PlayDirectSound(SOUND_SUMMON1);
break;
case 1:
me->MonsterYell("Shhhad ak kereeesshh chak-k-k!", LANG_UNIVERSAL, 0);
me->PlayDirectSound(SOUND_SUMMON2);
break;
}
}
summons.Summon(cr);
}
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if( me->HasUnitState(UNIT_STATE_CASTING) )
return;
switch ( events.GetEvent() )
{
case EVENT_CHECK_HEALTH:
{
events.RepeatEvent(1000);
if (HealthBelowPct(50))
{
events.CancelEvent(EVENT_CHECK_HEALTH);
events.ScheduleEvent(EVENT_SUMMON_GUARD, 100);
}
break;
}
case EVENT_SUMMON_GUARD:
{
me->MonsterTextEmote(EMOTE_HATCHES, me, true);
SummonHelpers(false);
events.PopEvent();
break;
}
case EVENT_BROOD_RAGE:
{
if (Creature *pSwarmer = me->FindNearestCreature(NPC_AHNKAHAR_SWARMER, 40, true))
me->CastSpell(pSwarmer, SPELL_BROOD_RAGE_H, true);
events.RepeatEvent(10000);
break;
}
case EVENT_PLAGUE:
{
me->CastSpell(me->GetVictim(), DUNGEON_MODE(SPELL_BROOD_PLAGUE, SPELL_BROOD_PLAGUE_H), false);
events.RepeatEvent(12000+rand()%5000);
break;
}
case EVENT_SWARMER:
{
SummonHelpers(true);
events.RepeatEvent(10000);
break;
}
case EVENT_CHECK_HOME:
{
if (me->HasAura(SPELL_ENRAGE))
break;
if (me->GetPositionZ() < 24)
{
me->CastSpell(me, SPELL_ENRAGE, true);
events.PopEvent();
break;
}
events.RepeatEvent(2000);
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI *GetAI(Creature *creature) const
{
return new boss_elder_nadoxAI(creature);
}
};
class npc_ahnkahar_nerubian : public CreatureScript
{
public:
npc_ahnkahar_nerubian() : CreatureScript("npc_ahnkahar_nerubian") { }
struct npc_ahnkahar_nerubianAI : public ScriptedAI
{
npc_ahnkahar_nerubianAI(Creature *c) : ScriptedAI(c) { }
uint32 uiSprintTimer;
void Reset()
{
if (me->GetEntry() == NPC_AHNKAHAR_GUARDIAN_ENTRY)
me->CastSpell(me, SPELL_GUARDIAN_AURA, true);
else // Swarmers
me->CastSpell(me, SPELL_SWARMER_AURA, true);
if (me->GetEntry() == NPC_AHNKAHAR_SWARMER || me->GetEntry() == NPC_AHNKAHAR_GUARDIAN_ENTRY)
me->SetInCombatWithZone();
uiSprintTimer = 10000;
}
void JustDied(Unit * /*killer*/)
{
if (me->GetEntry() == NPC_AHNKAHAR_GUARDIAN_ENTRY)
{
if (InstanceScript *pInstance = me->GetInstanceScript())
if (Creature *nadox = ObjectAccessor::GetCreature(*me, pInstance->GetData64(DATA_ELDER_NADOX)))
nadox->AI()->DoAction(ACTION_GUARDIAN_DIED);
me->RemoveAllAuras();
}
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
if (uiSprintTimer <= diff)
{
me->CastSpell(me, SPELL_SPRINT, false);
uiSprintTimer = 15000;
}
else
uiSprintTimer -= diff;
DoMeleeAttackIfReady();
}
};
CreatureAI *GetAI(Creature *creature) const
{
return new npc_ahnkahar_nerubianAI(creature);
}
};
class spell_ahn_kahet_swarmer_aura : public SpellScriptLoader
{
public:
spell_ahn_kahet_swarmer_aura() : SpellScriptLoader("spell_ahn_kahet_swarmer_aura") { }
class spell_ahn_kahet_swarmer_aura_SpellScript : public SpellScript
{
PrepareSpellScript(spell_ahn_kahet_swarmer_aura_SpellScript)
void HandleDummy(SpellEffIndex /*effIndex*/)
{
Unit* caster = GetCaster();
std::list<Creature*> swarm, swarm2;
caster->GetCreaturesWithEntryInRange(swarm, 40.0f, 30338);
caster->GetCreaturesWithEntryInRange(swarm2, 40.0f, 30178);
int32 aliveCount = -1; // minus self
std::list<Creature*>::const_iterator itr;
for (itr = swarm.begin(); itr != swarm.end(); ++itr)
if ((*itr)->IsAlive())
aliveCount++;
for (itr = swarm2.begin(); itr != swarm2.end(); ++itr)
if ((*itr)->IsAlive())
aliveCount++;
if (Aura *aur = caster->GetAura(56281))
{
if (aliveCount > 0)
aur->SetStackAmount(aliveCount);
else
aur->Remove();
}
else if (aliveCount > 0)
{
caster->CastCustomSpell(caster, 56281, &aliveCount, &aliveCount, &aliveCount, true);
if (Aura *aur = caster->GetAura(56281))
aur->SetStackAmount(aliveCount);
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_ahn_kahet_swarmer_aura_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_ahn_kahet_swarmer_aura_SpellScript();
}
};
void AddSC_boss_elder_nadox()
{
new boss_elder_nadox();
new npc_ahnkahar_nerubian();
new spell_ahn_kahet_swarmer_aura();
}

312
src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_herald_volazj.cpp
View File

@@ -1,312 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY XINEF, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "ahnkahet.h"
#include "Player.h"
#include "SpellInfo.h"
enum Spells
{
// BASIC FIGHT
SPELL_MIND_FLAY = 57941,
SPELL_MIND_FLAY_H = 59974,
SPELL_SHADOW_BOLT_VOLLEY = 57942,
SPELL_SHADOW_BOLT_VOLLEY_H = 59975,
SPELL_SHIVER = 57949,
SPELL_SHIVER_H = 59978,
// INSANITY
SPELL_INSANITY = 57496, //Dummy
INSANITY_VISUAL = 57561,
SPELL_INSANITY_TARGET = 57508,
SPELL_CLONE_PLAYER = 57507, //casted on player during insanity
SPELL_INSANITY_PHASING_1 = 57508,
SPELL_INSANITY_PHASING_2 = 57509,
SPELL_INSANITY_PHASING_3 = 57510,
SPELL_INSANITY_PHASING_4 = 57511,
SPELL_INSANITY_PHASING_5 = 57512
};
enum Yells
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2,
SAY_PHASE = 3
};
enum Misc
{
NPC_TWISTED_VISAGE = 30625,
ACHIEV_QUICK_DEMISE_START_EVENT = 20382,
};
enum Events
{
EVENT_HERALD_MIND_FLAY = 1,
EVENT_HERALD_SHADOW = 2,
EVENT_HERALD_SHIVER = 3,
EVENT_HERALD_HEALTH = 4,
};
class boss_volazj : public CreatureScript
{
public:
boss_volazj() : CreatureScript("boss_volazj") { }
struct boss_volazjAI : public ScriptedAI
{
boss_volazjAI(Creature* pCreature) : ScriptedAI(pCreature), summons(me)
{
pInstance = pCreature->GetInstanceScript();
}
InstanceScript *pInstance;
EventMap events;
SummonList summons;
uint8 insanityTimes;
uint8 insanityHandled;
void Reset()
{
events.Reset();
summons.DespawnAll();
insanityTimes = insanityHandled = 0;
// Visible for all players in insanity
me->SetPhaseMask((1|16|32|64|128|256), true);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetControlled(false, UNIT_STATE_STUNNED);
ResetPlayersPhaseMask();
if (pInstance)
{
pInstance->SetData(DATA_HERALD_VOLAZJ, NOT_STARTED);
pInstance->DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_QUICK_DEMISE_START_EVENT);
}
}
void SpellHitTarget(Unit* pTarget, const SpellInfo *spell)
{
if (spell->Id == SPELL_INSANITY)
{
// Not good target or too many players
if (pTarget->GetTypeId() != TYPEID_PLAYER || insanityHandled > 4)
return;
// First target - start channel visual and set self as unnattackable
if (!insanityHandled)
{
me->RemoveAllAuras();
me->CastSpell(me, INSANITY_VISUAL, true);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetControlled(true, UNIT_STATE_STUNNED);
}
// phase mask
pTarget->CastSpell(pTarget, SPELL_INSANITY_TARGET+insanityHandled, true);
// summon twisted party members for this target
Map::PlayerList const &players = me->GetMap()->GetPlayers();
for (Map::PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
{
Player *plr = i->GetSource();
if (!plr || !plr->IsAlive() || pTarget->GetGUID() == plr->GetGUID())
continue;
// Summon clone
if (Unit* summon = me->SummonCreature(NPC_TWISTED_VISAGE, plr->GetPositionX(), plr->GetPositionY(), plr->GetPositionZ(), plr->GetOrientation(), TEMPSUMMON_CORPSE_DESPAWN, 0))
{
summon->AddThreat(pTarget, 0.0f);
summon->SetInCombatWith(pTarget);
pTarget->SetInCombatWith(summon);
plr->CastSpell(summon, SPELL_CLONE_PLAYER, true);
summon->SetPhaseMask(1|(1<<(4+insanityHandled)), true);
summon->SetUInt32Value(UNIT_FIELD_MINDAMAGE, plr->GetUInt32Value(UNIT_FIELD_MINDAMAGE));
summon->SetUInt32Value(UNIT_FIELD_MAXDAMAGE, plr->GetUInt32Value(UNIT_FIELD_MAXDAMAGE));
}
}
++insanityHandled;
}
}
void ResetPlayersPhaseMask()
{
Map::PlayerList const &players = me->GetMap()->GetPlayers();
for (Map::PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
{
if (Player* pPlayer = i->GetSource())
if (uint32 spellId = GetSpellForPhaseMask(pPlayer->GetPhaseMask()))
pPlayer->RemoveAurasDueToSpell(spellId);
}
}
void EnterCombat(Unit* /*who*/)
{
events.ScheduleEvent(EVENT_HERALD_MIND_FLAY, 8000);
events.ScheduleEvent(EVENT_HERALD_SHADOW, 5000);
events.ScheduleEvent(EVENT_HERALD_SHIVER, 15000);
events.ScheduleEvent(EVENT_HERALD_HEALTH, 1000);
Talk(SAY_AGGRO);
if (pInstance)
{
pInstance->SetData(DATA_HERALD_VOLAZJ, IN_PROGRESS);
pInstance->DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_QUICK_DEMISE_START_EVENT);
}
me->SetInCombatWithZone();
}
void JustSummoned(Creature *summon) { summons.Summon(summon); }
uint32 GetSpellForPhaseMask(uint32 phase)
{
uint32 spell = 0;
switch (phase)
{
case 16:
spell = SPELL_INSANITY_PHASING_1;
break;
case 32:
spell = SPELL_INSANITY_PHASING_2;
break;
case 64:
spell = SPELL_INSANITY_PHASING_3;
break;
case 128:
spell = SPELL_INSANITY_PHASING_4;
break;
case 256:
spell = SPELL_INSANITY_PHASING_5;
break;
}
return spell;
}
bool CheckPhaseMinions()
{
summons.RemoveNotExisting();
if (summons.empty())
{
ResetPlayersPhaseMask();
return true;
}
uint16 phase = 1;
for (std::list<uint64>::iterator itr = summons.begin(); itr != summons.end(); ++itr)
{
if (Creature *summon = ObjectAccessor::GetCreature(*me, *itr))
phase |= summon->GetPhaseMask();
}
Map::PlayerList const &players = me->GetMap()->GetPlayers();
for (Map::PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
{
if (Player* pPlayer = i->GetSource())
if ((pPlayer->GetPhaseMask() & phase) == 0)
pPlayer->RemoveAurasDueToSpell(GetSpellForPhaseMask(pPlayer->GetPhaseMask()));
}
return false;
}
void UpdateAI(uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
if (insanityHandled)
{
if (!CheckPhaseMinions())
return;
insanityHandled = 0;
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetControlled(false, UNIT_STATE_STUNNED);
me->RemoveAurasDueToSpell(INSANITY_VISUAL);
}
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.GetEvent())
{
case EVENT_HERALD_HEALTH:
{
if (insanityTimes == 0 && me->GetHealthPct() <= 66)
{
me->CastSpell(me, SPELL_INSANITY, false);
insanityTimes++;
}
else if (insanityTimes == 1 && me->GetHealthPct() <= 33)
{
me->CastSpell(me, SPELL_INSANITY, false);
insanityTimes++;
}
events.RepeatEvent(1000);
break;
}
case EVENT_HERALD_MIND_FLAY:
{
me->CastSpell(me->GetVictim(), IsHeroic() ? SPELL_MIND_FLAY_H : SPELL_MIND_FLAY, false);
events.RepeatEvent(20000);
break;
}
case EVENT_HERALD_SHADOW:
{
me->CastSpell(me->GetVictim(), IsHeroic() ? SPELL_SHADOW_BOLT_VOLLEY_H : SPELL_SHADOW_BOLT_VOLLEY, false);
events.RepeatEvent(5000);
break;
}
case EVENT_HERALD_SHIVER:
{
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
me->CastSpell(pTarget, IsHeroic() ? SPELL_SHIVER_H : SPELL_SHIVER, false);
events.RepeatEvent(15000);
break;
}
}
DoMeleeAttackIfReady();
}
void JustDied(Unit* /*killer*/)
{
Talk(SAY_DEATH);
if (pInstance)
pInstance->SetData(DATA_HERALD_VOLAZJ, DONE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetControlled(false, UNIT_STATE_STUNNED);
summons.DespawnAll();
ResetPlayersPhaseMask();
}
void KilledUnit(Unit * /*victim*/)
{
Talk(SAY_SLAY);
}
};
CreatureAI *GetAI(Creature *creature) const
{
return new boss_volazjAI(creature);
}
};
void AddSC_boss_volazj()
{
new boss_volazj();
}

538
src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_jedoga_shadowseeker.cpp
View File

@@ -1,538 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY XINEF, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "ahnkahet.h"
enum Yells
{
TEXT_AGGRO = 0,
TEXT_SACRIFICE_1 = 1,
TEXT_SACRIFICE_2 = 2,
TEXT_SLAY = 3,
TEXT_DEATH = 4,
TEXT_PREACHING = 5
};
enum Spells
{
// VISUALS
SPELL_PINK_SPHERE = 56075,
SPELL_WHITE_SPHERE = 56102,
SPELL_LIGHTNING_BOLTS = 56327,
SPELL_ACTIVATE_INITIATE = 56868,
SPELL_FREEZE_ANIM = 55591,
SPELL_SACRIFICE_VISUAL = 56133,
// FIGHT
SPELL_GIFT_OF_THE_HERALD = 56219,
SPELL_CYCLONE_STRIKE = 56855, // Self
SPELL_CYCLONE_STRIKE_H = 60030,
SPELL_LIGHTNING_BOLT = 56891, // 40Y
SPELL_LIGHTNING_BOLT_H = 60032, // 40Y
SPELL_THUNDERSHOCK = 56926, // 30Y
SPELL_THUNDERSHOCK_H = 60029 // 30Y
};
enum Events
{
EVENT_JEDOGA_CYCLONE = 1,
EVENT_JEDOGA_LIGHTNING_BOLT = 2,
EVENT_JEDOGA_THUNDERSHOCK = 3,
EVENT_JEDOGA_MOVE_UP = 4,
EVENT_JEDOGA_MOVE_DOWN = 5,
};
enum Misc
{
NPC_JEDOGA_CONTROLLER = 30181,
NPC_INITIATE = 30114,
ACTION_INITIATE_DIED = 1,
ACTION_ACTIVATE = 2,
ACTION_HERALD = 3,
ACTION_SACRIFICE_FAILED = 4,
POINT_DOWN = 1,
POINT_UP = 2,
POINT_UP_START = 3,
POINT_RITUAL = 4,
};
const Position JedogaPosition[2] =
{
{372.330994f, -705.278015f, 0.624178f, 5.427970f},
{372.330994f, -705.278015f, -16.179716f, 5.427970f}
};
class boss_jedoga_shadowseeker : public CreatureScript
{
public:
boss_jedoga_shadowseeker() : CreatureScript("boss_jedoga_shadowseeker") { }
struct boss_jedoga_shadowseekerAI : public ScriptedAI
{
boss_jedoga_shadowseekerAI(Creature* c) : ScriptedAI(c), summons(me)
{
pInstance = c->GetInstanceScript();
}
InstanceScript* pInstance;
EventMap events;
SummonList summons;
uint8 initiates;
uint32 introCheck;
bool isFlying;
bool startFly;
void JustSummoned(Creature *cr) { summons.Summon(cr); }
void MoveInLineOfSight(Unit *) { }
void SpawnInitiate(bool start)
{
summons.DespawnAll();
if (start)
{
me->SummonCreature(NPC_INITIATE, 362.458f, -714.166f, -16.0964f, 0.977384f);
me->SummonCreature(NPC_INITIATE, 368.781f, -713.932f, -16.0964f, 1.46608f);
me->SummonCreature(NPC_INITIATE, 364.937f, -716.11f, -16.0964f, 1.25664f);
me->SummonCreature(NPC_INITIATE, 362.02f, -719.828f, -16.0964f, 1.20428f);
me->SummonCreature(NPC_INITIATE, 368.151f, -719.763f, -16.0964f, 1.53589f);
me->SummonCreature(NPC_INITIATE, 392.276f, -695.895f, -16.0964f, 3.40339f);
me->SummonCreature(NPC_INITIATE, 387.224f, -698.006f, -16.0964f, 3.36848f);
me->SummonCreature(NPC_INITIATE, 389.626f, -702.3f, -16.0964f, 3.07178f);
me->SummonCreature(NPC_INITIATE, 383.812f, -700.41f, -16.0964f, 3.15905f);
me->SummonCreature(NPC_INITIATE, 385.693f, -694.376f, -16.0964f, 3.59538f);
me->SummonCreature(NPC_INITIATE, 379.204f, -716.697f, -16.0964f, 2.1293f);
me->SummonCreature(NPC_INITIATE, 375.4f, -711.434f, -16.0964f, 2.09439f);
me->SummonCreature(NPC_INITIATE, 382.583f, -711.713f, -16.0964f, 2.53073f);
me->SummonCreature(NPC_INITIATE, 379.049f, -712.899f, -16.0964f, 2.28638f);
me->SummonCreature(NPC_INITIATE, 378.424f, -708.388f, -16.0964f, 2.58309f);
}
else
{
me->SummonCreature(NPC_INITIATE, 394.197f, -701.164f, -16.1797f, 4.09901f);
me->SummonCreature(NPC_INITIATE, 391.003f, -697.814f, -16.1797f, 4.11079f);
me->SummonCreature(NPC_INITIATE, 386.5f, -694.973f, -16.1797f, 4.12649f);
me->SummonCreature(NPC_INITIATE, 381.762f, -692.405f, -16.1797f, 4.12257f);
me->SummonCreature(NPC_INITIATE, 377.411f, -691.198f, -16.1797f, 4.6095f);
me->SummonCreature(NPC_INITIATE, 395.122f, -686.975f, -16.1797f, 2.72063f);
me->SummonCreature(NPC_INITIATE, 398.823f, -692.51f, -16.1797f, 2.72063f);
me->SummonCreature(NPC_INITIATE, 399.819f, -698.815f, -16.1797f, 2.72455f);
me->SummonCreature(NPC_INITIATE, 395.996f, -705.291f, -16.1309f, 0.376213f);
me->SummonCreature(NPC_INITIATE, 391.505f, -710.883f, -16.0589f, 0.376213f);
me->SummonCreature(NPC_INITIATE, 387.872f, -716.186f, -16.1797f, 0.376213f);
me->SummonCreature(NPC_INITIATE, 383.276f, -722.431f, -16.1797f, 0.376213f);
me->SummonCreature(NPC_INITIATE, 377.175f, -730.652f, -16.1797f, 0.376213f);
me->SummonCreature(NPC_INITIATE, 371.625f, -735.5f, -16.1797f, 0.376213f);
me->SummonCreature(NPC_INITIATE, 364.932f, -735.808f, -16.1797f, 0.376213f);
me->SummonCreature(NPC_INITIATE, 358.966f, -733.199f, -16.1797f, 0.376213f);
me->SummonCreature(NPC_INITIATE, 376.348f, -725.037f, -16.1797f, 5.65409f);
me->SummonCreature(NPC_INITIATE, 371.435f, -723.892f, -16.1797f, 5.65409f);
me->SummonCreature(NPC_INITIATE, 366.861f, -721.702f, -16.1797f, 5.65409f);
me->SummonCreature(NPC_INITIATE, 362.343f, -718.019f, -16.1797f, 5.51665f);
me->SummonCreature(NPC_INITIATE, 358.906f, -714.357f, -16.1797f, 5.35957f);
}
}
void ActivateInitiate()
{
if (!summons.size())
return;
uint8 rnd = urand(0, summons.size()-1);
uint8 loop = 0;
for (std::list<uint64>::iterator i = summons.begin(); i != summons.end();)
{
Creature *summon = ObjectAccessor::GetCreature(*me, *i);
if (summon && summon->GetEntry() == NPC_INITIATE && loop >= rnd)
{
summon->AI()->DoAction(ACTION_ACTIVATE);
break;
}
++i;
++loop;
}
return;
}
void ScheduleEvents()
{
events.RescheduleEvent(EVENT_JEDOGA_CYCLONE, 3000);
events.RescheduleEvent(EVENT_JEDOGA_LIGHTNING_BOLT, 7000);
events.RescheduleEvent(EVENT_JEDOGA_THUNDERSHOCK, 12000);
events.RescheduleEvent(EVENT_JEDOGA_MOVE_UP, urand(20000, 25000));
}
void DoAction(int32 param)
{
if (param == ACTION_INITIATE_DIED)
{
// all killed
if (initiates++ > 13)
{
summons.DespawnAll();
MoveDown();
initiates = 0;
}
}
else if (param == ACTION_HERALD)
{
me->CastSpell(me, SPELL_GIFT_OF_THE_HERALD, true);
events.DelayEvents(1001);
events.ScheduleEvent(EVENT_JEDOGA_MOVE_DOWN, 1000);
isFlying = false;
}
else if (param == ACTION_SACRIFICE_FAILED)
{
events.DelayEvents(1001);
events.ScheduleEvent(EVENT_JEDOGA_MOVE_DOWN, 1000);
isFlying = false;
if (pInstance)
pInstance->SetData(DATA_JEDOGA_ACHIEVEMENT, false);
}
}
void Reset()
{
if (pInstance)
{
pInstance->SetData(DATA_JEDOGA_SHADOWSEEKER_EVENT, NOT_STARTED);
pInstance->SetData(DATA_JEDOGA_ACHIEVEMENT, true);
}
events.Reset();
SpawnInitiate(true);
initiates = 0;
introCheck = 1; // leave 1
isFlying = false;
startFly = false;
MoveUp(true);
me->CastSpell(me, SPELL_PINK_SPHERE, true);
me->CastSpell(me, SPELL_LIGHTNING_BOLTS, true);
me->CastSpell(me, SPELL_FREEZE_ANIM, true);
}
void EnterCombat(Unit* who)
{
if (pInstance)
pInstance->SetData(DATA_JEDOGA_SHADOWSEEKER_EVENT, IN_PROGRESS);
Talk(TEXT_AGGRO);
}
void KilledUnit(Unit* Victim)
{
if (!Victim || Victim->GetTypeId() != TYPEID_PLAYER)
return;
Talk(TEXT_SLAY);
}
void JustDied(Unit* /*Killer*/)
{
Talk(TEXT_DEATH);
if (pInstance)
pInstance->SetData(DATA_JEDOGA_SHADOWSEEKER_EVENT, DONE);
summons.DespawnAll();
}
void MoveDown()
{
me->GetMotionMaster()->MoveIdle();
me->GetMotionMaster()->MovePoint(POINT_DOWN, JedogaPosition[1]);
}
void MoveUp(bool start)
{
isFlying = true;
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE);
me->AttackStop();
me->GetMotionMaster()->Clear(true);
me->SetFacingTo(5.66f);
me->GetMotionMaster()->MovePoint((start ? POINT_UP_START : POINT_UP), JedogaPosition[0]);
me->SetDisableGravity(true);
me->CastSpell(me, SPELL_FREEZE_ANIM, true);
}
void MovementInform(uint32 Type, uint32 PointId)
{
if (Type != POINT_MOTION_TYPE)
return;
if (PointId == POINT_DOWN)
{
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE);
me->RemoveAurasDueToSpell(SPELL_PINK_SPHERE);
me->RemoveAurasDueToSpell(SPELL_LIGHTNING_BOLTS);
me->RemoveAurasDueToSpell(SPELL_FREEZE_ANIM);
isFlying = false;
me->SetInCombatWithZone();
me->SetDisableGravity(false);
if (!summons.HasEntry(NPC_INITIATE))
SpawnInitiate(false);
if (UpdateVictim())
{
me->StopMoving();
ScheduleEvents();
AttackStart(me->GetVictim());
me->GetMotionMaster()->MoveChase(me->GetVictim());
}
}
else if (PointId == POINT_UP)
ActivateInitiate();
else if (PointId == POINT_RITUAL)
startFly = true;
}
void UpdateAI(uint32 diff)
{
// Start text
if (introCheck)
{
introCheck += diff;
if (introCheck >= 2000)
{
if (SelectTargetFromPlayerList(80.0f))
{
introCheck = 0;
Talk(TEXT_PREACHING);
}
else
introCheck = 1;
}
return;
}
if (startFly)
{
startFly = false;
MoveUp(false);
}
if (isFlying && !SelectTargetFromPlayerList(80.0f))
{
EnterEvadeMode();
return;
}
if (!isFlying)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.GetEvent())
{
case EVENT_JEDOGA_CYCLONE:
{
me->CastSpell(me, IsHeroic() ? SPELL_CYCLONE_STRIKE_H : SPELL_CYCLONE_STRIKE, false);
events.RepeatEvent(urand(10000, 14000));
break;
}
case EVENT_JEDOGA_LIGHTNING_BOLT:
{
if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
me->CastSpell(pTarget, IsHeroic() ? SPELL_LIGHTNING_BOLT_H : SPELL_LIGHTNING_BOLT, false);
events.RepeatEvent(urand(11000, 15000));
break;
}
case EVENT_JEDOGA_THUNDERSHOCK:
{
if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
me->CastSpell(pTarget, IsHeroic() ? SPELL_THUNDERSHOCK_H : SPELL_THUNDERSHOCK, false);
events.RepeatEvent(urand(16000, 22000));
break;
}
case EVENT_JEDOGA_MOVE_UP:
{
events.PopEvent();
if (!summons.HasEntry(NPC_INITIATE))
break;
if (Creature *cr = me->SummonCreature(NPC_JEDOGA_CONTROLLER, 373.48f, -706.00f, -16.18f))
{
cr->CastSpell(cr, SPELL_SACRIFICE_VISUAL, true);
summons.Summon(cr);
}
Talk(TEXT_SACRIFICE_1);
isFlying = true;
me->GetMotionMaster()->Clear(true);
me->GetMotionMaster()->MovePoint(POINT_RITUAL, JedogaPosition[1]);
break;
}
case EVENT_JEDOGA_MOVE_DOWN:
{
Talk(TEXT_SACRIFICE_2);
summons.DespawnEntry(NPC_JEDOGA_CONTROLLER);
MoveDown();
events.PopEvent();
break;
}
}
DoMeleeAttackIfReady();
}
}
};
CreatureAI *GetAI(Creature *creature) const
{
return new boss_jedoga_shadowseekerAI(creature);
}
};
class npc_jedoga_initiand : public CreatureScript
{
public:
npc_jedoga_initiand() : CreatureScript("npc_jedoga_initiand") { }
struct npc_jedoga_initiandAI : public ScriptedAI
{
npc_jedoga_initiandAI(Creature* c) : ScriptedAI(c)
{
pInstance = c->GetInstanceScript();
}
InstanceScript* pInstance;
int32 Timer;
void AttackStart(Unit* who)
{
if (!Timer)
ScriptedAI::AttackStart(who);
}
void MoveInLineOfSight(Unit *who)
{
if (!Timer)
ScriptedAI::MoveInLineOfSight(who);
}
void Reset()
{
Timer = 0;
if (!pInstance)
return;
if (pInstance->GetData(DATA_JEDOGA_SHADOWSEEKER_EVENT) != IN_PROGRESS)
{
me->SetControlled(false, UNIT_STATE_STUNNED);
me->RemoveAurasDueToSpell(SPELL_WHITE_SPHERE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE);
}
else
{
me->SetOrientation(me->GetAngle(372.6f, -705.12f));
me->SendMovementFlagUpdate();
me->CastSpell(me, SPELL_WHITE_SPHERE, false);
me->SetControlled(true, UNIT_STATE_STUNNED);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE + UNIT_FLAG_NON_ATTACKABLE);
}
}
void JustDied(Unit* Killer)
{
if (!pInstance || Killer == me)
return;
Creature* boss = me->GetMap()->GetCreature(pInstance->GetData64(DATA_JEDOGA_SHADOWSEEKER));
if (boss)
{
if (Timer)
boss->AI()->DoAction(ACTION_SACRIFICE_FAILED);
else
boss->AI()->DoAction(ACTION_INITIATE_DIED);
}
}
void DoAction(int32 param)
{
if (param == ACTION_ACTIVATE)
{
Timer = 1500;
me->CastSpell(me, SPELL_ACTIVATE_INITIATE, true);
}
}
void MovementInform(uint32 Type, uint32 PointId)
{
if (Type == POINT_MOTION_TYPE && PointId == POINT_RITUAL)
{
Unit::Kill(me, me);
me->DespawnOrUnsummon(5000);
Creature* boss = me->GetMap()->GetCreature(pInstance->GetData64(DATA_JEDOGA_SHADOWSEEKER));
if (boss)
boss->AI()->DoAction(ACTION_HERALD);
}
}
void UpdateAI(uint32 diff)
{
if (Timer)
{
Timer -= diff;
if (Timer <= 0)
{
me->CombatStop();
me->SetControlled(false, UNIT_STATE_STUNNED);
me->RemoveAurasDueToSpell(SPELL_WHITE_SPHERE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE);
float distance = me->GetDistance(373.48f, -706.00f, -16.18f);
if (distance < 9.0f)
me->SetSpeed(MOVE_RUN, 0.5f, true);
else if (distance < 15.0f)
me->SetSpeed(MOVE_RUN, 0.75f, true);
else if (distance < 20.0f)
me->SetSpeed(MOVE_RUN, 1.0f, true);
me->GetMotionMaster()->Clear(false);
me->GetMotionMaster()->MovePoint(POINT_RITUAL, 373.48f, -706.00f, -16.18f);
Timer = 10000000;
}
return;
}
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
}
};
CreatureAI *GetAI(Creature *creature) const
{
return new npc_jedoga_initiandAI(creature);
}
};
void AddSC_boss_jedoga_shadowseeker()
{
new boss_jedoga_shadowseeker();
new npc_jedoga_initiand();
}

364
src/server/scripts/Northrend/AzjolNerub/ahnkahet/boss_prince_taldaram.cpp
View File

@@ -1,364 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY XINEF, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "ahnkahet.h"
#include "SpellInfo.h"
enum Spells
{
SPELL_BLOODTHIRST = 55968, //Trigger Spell + add aura
SPELL_CONJURE_FLAME_SPHERE = 55931,
SPELL_FLAME_SPHERE_SPAWN_EFFECT = 55891,
SPELL_FLAME_SPHERE_VISUAL = 55928,
SPELL_FLAME_SPHERE_PERIODIC = 55926,
SPELL_FLAME_SPHERE_PERIODIC_H = 59508,
SPELL_FLAME_SPHERE_DEATH_EFFECT = 55947,
SPELL_BEAM_VISUAL = 60342,
SPELL_EMBRACE_OF_THE_VAMPYR = 55959,
SPELL_EMBRACE_OF_THE_VAMPYR_H = 59513,
SPELL_VANISH = 55964,
CREATURE_FLAME_SPHERE = 30106,
CREATURE_FLAME_SPHERE_1 = 31686,
CREATURE_FLAME_SPHERE_2 = 31687,
};
enum Misc
{
DATA_EMBRACE_DMG = 20000,
DATA_EMBRACE_DMG_H = 40000,
DATA_SPHERE_DISTANCE = 30,
ACTION_FREE = 1,
ACTION_SPHERE = 2,
};
enum Event
{
EVENT_PRINCE_FLAME_SPHERES = 1,
EVENT_PRINCE_VANISH = 2,
EVENT_PRINCE_BLOODTHIRST = 3,
EVENT_PRINCE_VANISH_RUN = 4,
EVENT_PRINCE_RESCHEDULE = 5,
};
#define DATA_GROUND_POSITION_Z 11.4f
enum Yells
{
SAY_1 = 0,
SAY_WARNING = 1,
SAY_AGGRO = 2,
SAY_SLAY = 3,
SAY_DEATH = 4,
SAY_FEED = 5,
SAY_VANISH = 6,
};
class boss_taldaram : public CreatureScript
{
public:
boss_taldaram() : CreatureScript("boss_taldaram") { }
struct boss_taldaramAI : public ScriptedAI
{
boss_taldaramAI(Creature *c) : ScriptedAI(c), summons(me)
{
pInstance = c->GetInstanceScript();
}
InstanceScript* pInstance;
EventMap events;
SummonList summons;
uint64 vanishTarget;
uint32 vanishDamage;
void Reset()
{
if (me->GetPositionZ() > 15.0f)
me->CastSpell(me, SPELL_BEAM_VISUAL, true);
events.Reset();
summons.DespawnAll();
vanishDamage = 0;
vanishTarget = 0;
if (pInstance)
{
pInstance->SetData(DATA_PRINCE_TALDARAM_EVENT, NOT_STARTED);
// Event not started
if (pInstance->GetData(DATA_SPHERE_EVENT) == DONE)
DoAction(ACTION_FREE);
}
}
void DoAction(int32 param)
{
if (param == ACTION_FREE)
{
me->RemoveAllAuras();
me->SetUnitMovementFlags(MOVEMENTFLAG_WALKING);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
me->SetHomePosition(me->GetPositionX(), me->GetPositionY(), DATA_GROUND_POSITION_Z, me->GetOrientation());
me->UpdatePosition(me->GetPositionX(), me->GetPositionY(), DATA_GROUND_POSITION_Z, me->GetOrientation(), true);
if (pInstance)
pInstance->HandleGameObject(pInstance->GetData64(DATA_PRINCE_TALDARAM_PLATFORM), true);
}
}
void EnterCombat(Unit* /*who*/)
{
if (pInstance)
pInstance->SetData(DATA_PRINCE_TALDARAM_EVENT, IN_PROGRESS);
Talk(SAY_AGGRO);
ScheduleEvents();
me->RemoveAllAuras();
me->InterruptNonMeleeSpells(true);
}
void ScheduleEvents()
{
events.Reset();
events.ScheduleEvent(EVENT_PRINCE_FLAME_SPHERES, 10000);
events.ScheduleEvent(EVENT_PRINCE_BLOODTHIRST, 10000);
vanishTarget = 0;
vanishDamage = 0;
}
void SpellHitTarget(Unit *, const SpellInfo *spellInfo)
{
if (spellInfo->Id == SPELL_CONJURE_FLAME_SPHERE)
summons.DoAction(ACTION_SPHERE);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.GetEvent())
{
case EVENT_PRINCE_BLOODTHIRST:
{
me->CastSpell(me->GetVictim(), SPELL_BLOODTHIRST, false);
events.RepeatEvent(10000);
break;
}
case EVENT_PRINCE_FLAME_SPHERES:
{
me->CastSpell(me->GetVictim(), SPELL_CONJURE_FLAME_SPHERE, false);
events.RescheduleEvent(EVENT_PRINCE_VANISH, 14000);
Creature *cr;
if (cr = me->SummonCreature(CREATURE_FLAME_SPHERE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()+5.0f, 0.0f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS))
summons.Summon(cr);
if (me->GetMap()->IsHeroic())
{
if (cr = me->SummonCreature(CREATURE_FLAME_SPHERE_1, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()+5.0f, 0.0f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS))
summons.Summon(cr);
if (cr = me->SummonCreature(CREATURE_FLAME_SPHERE_2, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()+5.0f, 0.0f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS))
summons.Summon(cr);
}
events.RepeatEvent(15000);
break;
}
case EVENT_PRINCE_VANISH:
{
events.PopEvent();
//Count alive players
uint8 count = 0;
Unit *pTarget;
std::list<HostileReference *> t_list = me->getThreatManager().getThreatList();
for (std::list<HostileReference *>::const_iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
{
pTarget = ObjectAccessor::GetUnit(*me, (*itr)->getUnitGuid());
if (pTarget && pTarget->GetTypeId() == TYPEID_PLAYER && pTarget->IsAlive())
count++;
}
//He only vanishes if there are 3 or more alive players
if (count > 2)
{
Talk(SAY_VANISH);
me->CastSpell(me, SPELL_VANISH, false);
events.CancelEvent(EVENT_PRINCE_FLAME_SPHERES);
events.CancelEvent(EVENT_PRINCE_BLOODTHIRST);
events.ScheduleEvent(EVENT_PRINCE_VANISH_RUN, 2499);
if (Unit* pEmbraceTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
vanishTarget = pEmbraceTarget->GetGUID();
}
break;
}
case EVENT_PRINCE_VANISH_RUN:
{
if (Unit *vT = ObjectAccessor::GetUnit(*me, vanishTarget))
{
me->UpdatePosition(vT->GetPositionX(), vT->GetPositionY(), vT->GetPositionZ(), me->GetAngle(vT), true);
me->CastSpell(vT, SPELL_EMBRACE_OF_THE_VAMPYR, false);
me->RemoveAura(SPELL_VANISH);
}
events.PopEvent();
events.ScheduleEvent(EVENT_PRINCE_RESCHEDULE, 20000);
break;
}
case EVENT_PRINCE_RESCHEDULE:
{
events.PopEvent();
ScheduleEvents();
break;
}
}
if (me->IsVisible())
DoMeleeAttackIfReady();
}
void DamageTaken(Unit*, uint32 &damage, DamageEffectType, SpellSchoolMask)
{
if (vanishTarget)
{
vanishDamage += damage;
if (vanishDamage > (uint32) DUNGEON_MODE(DATA_EMBRACE_DMG, DATA_EMBRACE_DMG_H))
{
ScheduleEvents();
me->CastStop();
}
}
}
void JustDied(Unit* /*killer*/)
{
summons.DespawnAll();
Talk(SAY_DEATH);
if (pInstance)
pInstance->SetData(DATA_PRINCE_TALDARAM_EVENT, DONE);
}
void KilledUnit(Unit * victim)
{
if (urand(0,1))
return;
if (vanishTarget && victim->GetGUID() == vanishTarget)
ScheduleEvents();
Talk(SAY_SLAY);
}
};
CreatureAI *GetAI(Creature *creature) const
{
return new boss_taldaramAI(creature);
}
};
class npc_taldaram_flamesphere : public CreatureScript
{
public:
npc_taldaram_flamesphere() : CreatureScript("npc_taldaram_flamesphere") { }
struct npc_taldaram_flamesphereAI : public ScriptedAI
{
npc_taldaram_flamesphereAI(Creature *c) : ScriptedAI(c)
{
}
uint32 uiDespawnTimer;
void DoAction(int32 param)
{
if (param == ACTION_SPHERE)
{
me->CastSpell(me, me->GetMap()->IsHeroic() ? SPELL_FLAME_SPHERE_PERIODIC_H : SPELL_FLAME_SPHERE_PERIODIC, true);
float angle = rand_norm()*2*M_PI;
float x = me->GetPositionX() + DATA_SPHERE_DISTANCE * cos(angle);
float y = me->GetPositionY() + DATA_SPHERE_DISTANCE * sin(angle);
me->GetMotionMaster()->MovePoint(0, x, y, me->GetPositionZ());
}
}
void MovementInform(uint32 type, uint32 id)
{
if (id == 0)
me->DisappearAndDie();
}
void Reset()
{
me->CastSpell(me, SPELL_FLAME_SPHERE_SPAWN_EFFECT, true);
me->CastSpell(me, SPELL_FLAME_SPHERE_VISUAL, true);
uiDespawnTimer = 13*IN_MILLISECONDS;
}
void EnterCombat(Unit * /*who*/) {}
void MoveInLineOfSight(Unit * /*who*/) {}
void JustDied(Unit* /*who*/)
{
me->CastSpell(me, SPELL_FLAME_SPHERE_DEATH_EFFECT, true);
}
void UpdateAI(uint32 diff)
{
if (uiDespawnTimer <= diff)
me->DisappearAndDie();
else
uiDespawnTimer -= diff;
}
};
CreatureAI *GetAI(Creature *creature) const
{
return new npc_taldaram_flamesphereAI(creature);
}
};
class go_prince_taldaram_sphere : public GameObjectScript
{
public:
go_prince_taldaram_sphere() : GameObjectScript("go_prince_taldaram_sphere") { }
bool OnGossipHello(Player * /*pPlayer*/, GameObject *pGO)
{
InstanceScript *pInstance = pGO->GetInstanceScript();
if (!pInstance)
return false;
Creature *pPrinceTaldaram = ObjectAccessor::GetCreature(*pGO, pInstance->GetData64(DATA_PRINCE_TALDARAM));
if (pPrinceTaldaram && pPrinceTaldaram->IsAlive())
{
pGO->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
pGO->SetGoState(GO_STATE_ACTIVE);
if (pInstance->GetData(DATA_SPHERE_EVENT) == NOT_STARTED)
{
pInstance->SetData(DATA_SPHERE_EVENT, DONE);
return true;
}
pPrinceTaldaram->AI()->DoAction(ACTION_FREE);
}
return true;
}
};
void AddSC_boss_taldaram()
{
new boss_taldaram();
new npc_taldaram_flamesphere();
new go_prince_taldaram_sphere();
}

40
src/server/scripts/Northrend/AzjolNerub/ahnkahet/def_ahnkahet.h
View File

@@ -1,40 +0,0 @@
/*
* Copyright (C)
*
* 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 Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef DEF_AHNKAHET_H
#define DEF_AHNKAHET_H
#define DATA_ELDER_NADOX 1
#define DATA_PRINCE_TALDARAM 2
#define DATA_JEDOGA_SHADOWSEEKER 3
#define DATA_HERALD_VOLAZJ 4
#define DATA_AMANITAR 5
#define DATA_ELDER_NADOX_EVENT 6
#define DATA_PRINCE_TALDARAM_EVENT 7
#define DATA_JEDOGA_SHADOWSEEKER_EVENT 8
#define DATA_HERALD_VOLAZJ_EVENT 9
#define DATA_AMANITAR_EVENT 10
#define DATA_SPHERE1 11
#define DATA_SPHERE2 12
#define DATA_SPHERE1_EVENT 13
#define DATA_SPHERE2_EVENT 14
#define DATA_PRINCE_TALDARAM_PLATFORM 15
#endif

254
src/server/scripts/Northrend/AzjolNerub/ahnkahet/instance_ahnkahet.cpp
View File

@@ -1,254 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY XINEF, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "ahnkahet.h"
class instance_ahnkahet : public InstanceMapScript
{
public:
instance_ahnkahet() : InstanceMapScript("instance_ahnkahet", 619) { }
struct instance_ahnkahet_InstanceScript : public InstanceScript
{
instance_ahnkahet_InstanceScript(Map* pMap) : InstanceScript(pMap) {Initialize();};
uint64 Elder_Nadox;
uint64 Prince_Taldaram;
uint64 Jedoga_Shadowseeker;
uint64 Herald_Volazj;
uint64 Amanitar;
uint64 Prince_TaldaramPlatform;
uint64 Prince_TaldaramGate;
uint32 m_auiEncounter[MAX_ENCOUNTER];
uint32 spheres;
bool nadoxAchievement;
bool jedogaAchievement;
void Initialize()
{
memset(&m_auiEncounter, 0, sizeof(m_auiEncounter));
Elder_Nadox = 0;
Prince_Taldaram = 0;
Jedoga_Shadowseeker = 0;
Herald_Volazj = 0;
Amanitar = 0;
Prince_TaldaramPlatform = 0;
Prince_TaldaramGate = 0;
spheres = NOT_STARTED;
nadoxAchievement = false;
jedogaAchievement = false;
}
bool IsEncounterInProgress() const
{
for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
if (m_auiEncounter[i] == IN_PROGRESS) return true;
return false;
}
void OnCreatureCreate(Creature* pCreature)
{
switch(pCreature->GetEntry())
{
case NPC_ELDER_NADOX:
Elder_Nadox = pCreature->GetGUID();
break;
case NPC_PRINCE_TALDARAM:
Prince_Taldaram = pCreature->GetGUID();
break;
case NPC_JEDOGA_SHADOWSEEKER:
Jedoga_Shadowseeker = pCreature->GetGUID();
break;
case NPC_HERALD_JOLAZJ:
Herald_Volazj = pCreature->GetGUID();
break;
case NPC_AMANITAR:
Amanitar = pCreature->GetGUID();
break;
}
}
void OnGameObjectCreate(GameObject* pGo)
{
switch(pGo->GetEntry())
{
case 193564:
Prince_TaldaramPlatform = pGo->GetGUID();
if (m_auiEncounter[1] == DONE)
HandleGameObject(0,true,pGo);
break;
case 193093:
if (spheres == DONE)
{
pGo->SetGoState(GO_STATE_ACTIVE);
pGo->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
}
else
pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
break;
case 193094:
if (spheres == DONE)
{
pGo->SetGoState(GO_STATE_ACTIVE);
pGo->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
}
else
pGo->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
break;
case 192236:
Prince_TaldaramGate = pGo->GetGUID(); // Web gate past Prince Taldaram
if (m_auiEncounter[1] == DONE)
HandleGameObject(0,true,pGo);
break;
}
}
uint64 GetData64(uint32 identifier) const
{
switch(identifier)
{
case DATA_ELDER_NADOX: return Elder_Nadox;
case DATA_PRINCE_TALDARAM: return Prince_Taldaram;
case DATA_JEDOGA_SHADOWSEEKER: return Jedoga_Shadowseeker;
case DATA_HERALD_VOLAZJ: return Herald_Volazj;
case DATA_AMANITAR: return Amanitar;
case DATA_PRINCE_TALDARAM_PLATFORM: return Prince_TaldaramPlatform;
}
return 0;
}
bool CheckAchievementCriteriaMeet(uint32 criteria_id, Player const* source, Unit const* target = NULL, uint32 miscvalue1 = 0)
{
switch(criteria_id)
{
case 7317: // Respect Your Elders (2038)
return nadoxAchievement;
case 7359: // Volunteer Work (2056)
return jedogaAchievement;
}
return false;
}
void SetData(uint32 type, uint32 data)
{
switch(type)
{
case DATA_HERALD_VOLAZJ_EVENT:
case DATA_AMANITAR_EVENT:
case DATA_ELDER_NADOX_EVENT:
case DATA_JEDOGA_SHADOWSEEKER_EVENT:
m_auiEncounter[type] = data;
break;
case DATA_PRINCE_TALDARAM_EVENT:
if (data == DONE)
HandleGameObject(Prince_TaldaramGate, true);
m_auiEncounter[type] = data;
break;
case DATA_SPHERE_EVENT:
spheres = data;
break;
case DATA_NADOX_ACHIEVEMENT:
nadoxAchievement = (bool)data;
return;
case DATA_JEDOGA_ACHIEVEMENT:
jedogaAchievement = (bool)data;
return;
}
if (data == DONE)
SaveToDB();
}
uint32 GetData(uint32 type) const
{
switch(type)
{
case DATA_ELDER_NADOX_EVENT:
case DATA_PRINCE_TALDARAM_EVENT:
case DATA_JEDOGA_SHADOWSEEKER_EVENT:
case DATA_HERALD_VOLAZJ:
case DATA_AMANITAR_EVENT:
return m_auiEncounter[type];
case DATA_SPHERE_EVENT:
return spheres;
}
return 0;
}
std::string GetSaveData()
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << "A K " << m_auiEncounter[0] << ' ' << m_auiEncounter[1] << ' '
<< m_auiEncounter[2] << ' ' << m_auiEncounter[3] << ' ' << m_auiEncounter[4] << ' '
<< spheres;
OUT_SAVE_INST_DATA_COMPLETE;
return saveStream.str();
}
void Load(const char* in)
{
if (!in)
{
OUT_LOAD_INST_DATA_FAIL;
return;
}
OUT_LOAD_INST_DATA(in);
char dataHead1, dataHead2;
uint32 data0, data1, data2, data3, data4, data5;
std::istringstream loadStream(in);
loadStream >> dataHead1 >> dataHead2 >> data0 >> data1 >> data2 >> data3 >> data4 >> data5;
if (dataHead1 == 'A' && dataHead2 == 'K')
{
m_auiEncounter[0] = data0;
m_auiEncounter[1] = data1;
m_auiEncounter[2] = data2;
m_auiEncounter[3] = data3;
m_auiEncounter[4] = data4;
for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
if (m_auiEncounter[i] == IN_PROGRESS)
m_auiEncounter[i] = NOT_STARTED;
spheres = data5;
} else OUT_LOAD_INST_DATA_FAIL;
OUT_LOAD_INST_DATA_COMPLETE;
}
};
InstanceScript* GetInstanceScript(InstanceMap *map) const
{
return new instance_ahnkahet_InstanceScript(map);
}
};
void AddSC_instance_ahnkahet()
{
new instance_ahnkahet;
}