josh/TCPlayerbotCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Scripts/Vault of Archavon: Cleaned and simplified scripts, fixed Toravon's Frozen Orb summon count

Browse Source 
Closes issue #2857.

--HG--
branch : trunk
This commit is contained in:
Shauren
2010-12-17 20:37:20 +01:00
parent 32d94ed52a
commit ecd2fbb2b1
6 changed files with 664 additions and 809 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/server/scripts/Northrend/VaultOfArchavon/boss_archavon.cpp
+135 -151
View File
@@ -37,110 +37,92 @@
//Yell //Yell
#define SAY_LEAP "Archavon the Stone Watcher lunges for $N!" //$N should be the target #define SAY_LEAP "Archavon the Stone Watcher lunges for $N!" //$N should be the target
#define EVENT_ROCK_SHARDS 1 //15s cd enum Events
#define EVENT_CHOKING_CLOUD 2 //30s cd {
#define EVENT_STOMP 3 //45s cd // Archavon
#define EVENT_IMPALE 4 EVENT_ROCK_SHARDS = 1, // 15s cd
#define EVENT_BERSERK 5 //300s cd EVENT_CHOKING_CLOUD = 2, // 30s cd
EVENT_STOMP = 3, // 45s cd
EVENT_IMPALE = 4,
EVENT_BERSERK = 5, // 300s cd
//mob //mob
#define EVENT_ROCK_SHOWER 5 //set = 20s cd,unkown cd EVENT_ROCK_SHOWER = 6, // set = 20s cd,unkown cd
#define EVENT_SHIELD_CRUSH 6 //set = 30s cd EVENT_SHIELD_CRUSH = 7, // set = 30s cd
#define EVENT_WHIRL 8 //set= 10s cd EVENT_WHIRL = 8, // set= 10s cd
};
class boss_archavon : public CreatureScript class boss_archavon : public CreatureScript
{ {
public: public:
boss_archavon() : CreatureScript("boss_archavon") { } boss_archavon() : CreatureScript("boss_archavon") { }
CreatureAI* GetAI(Creature* pCreature) const struct boss_archavonAI : public BossAI
{
return new boss_archavonAI (pCreature);
}
struct boss_archavonAI : public ScriptedAI
{
boss_archavonAI(Creature *c) : ScriptedAI(c)
{ {
pInstance = c->GetInstanceScript(); boss_archavonAI(Creature* creature) : BossAI(creature, DATA_ARCHAVON)
}
InstanceScript* pInstance;
EventMap events;
void Reset()
{
events.Reset();
if (pInstance)
pInstance->SetData(DATA_ARCHAVON_EVENT, NOT_STARTED);
}
void KilledUnit(Unit* /*Victim*/) {}
void JustDied(Unit* /*Killer*/)
{
if (pInstance)
pInstance->SetData(DATA_ARCHAVON_EVENT, DONE);
}
void EnterCombat(Unit * /*who*/)
{
DoZoneInCombat();
events.ScheduleEvent(EVENT_ROCK_SHARDS, 15000);
events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30000);
events.ScheduleEvent(EVENT_STOMP, 45000);
events.ScheduleEvent(EVENT_BERSERK, 300000);
if (pInstance)
pInstance->SetData(DATA_ARCHAVON_EVENT, IN_PROGRESS);
}
// Below UpdateAI may need review/debug.
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{ {
switch(eventId)
{
case EVENT_ROCK_SHARDS:
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(pTarget, SPELL_ROCK_SHARDS);
events.ScheduleEvent(EVENT_ROCK_SHARDS, 15000);
return;
case EVENT_CHOKING_CLOUD:
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(pTarget, SPELL_CRUSHING_LEAP, true); //10y~80y, ignore range
events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30000);
return;
case EVENT_STOMP:
DoCast(me->getVictim(), SPELL_STOMP);
events.ScheduleEvent(EVENT_IMPALE, 3000);
events.ScheduleEvent(EVENT_STOMP, 45000);
return;
case EVENT_IMPALE:
DoCast(me->getVictim(), SPELL_IMPALE);
return;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
DoScriptText(EMOTE_BERSERK, me);
return;
}
} }
DoMeleeAttackIfReady(); void EnterCombat(Unit * /*who*/)
} {
}; events.ScheduleEvent(EVENT_ROCK_SHARDS, 15000);
events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30000);
events.ScheduleEvent(EVENT_STOMP, 45000);
events.ScheduleEvent(EVENT_BERSERK, 300000);
_EnterCombat();
}
// Below UpdateAI may need review/debug.
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ROCK_SHARDS:
if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_ROCK_SHARDS);
events.ScheduleEvent(EVENT_ROCK_SHARDS, 15000);
break;
case EVENT_CHOKING_CLOUD:
if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_CRUSHING_LEAP, true); //10y~80y, ignore range
events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30000);
break;
case EVENT_STOMP:
DoCastVictim(SPELL_STOMP);
events.ScheduleEvent(EVENT_IMPALE, 3000);
events.ScheduleEvent(EVENT_STOMP, 45000);
break;
case EVENT_IMPALE:
DoCastVictim(SPELL_IMPALE);
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
DoScriptText(EMOTE_BERSERK, me);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_archavonAI(creature);
}
}; };
/*###### /*######
@@ -148,70 +130,72 @@ public:
######*/ ######*/
class mob_archavon_warder : public CreatureScript class mob_archavon_warder : public CreatureScript
{ {
public: public:
mob_archavon_warder() : CreatureScript("mob_archavon_warder") { } mob_archavon_warder() : CreatureScript("mob_archavon_warder") { }
CreatureAI* GetAI(Creature* pCreature) const struct mob_archavon_warderAI : public ScriptedAI //npc 32353
{
return new mob_archavon_warderAI(pCreature);
}
struct mob_archavon_warderAI : public ScriptedAI //npc 32353
{
mob_archavon_warderAI(Creature *c) : ScriptedAI(c) {}
EventMap events;
void Reset()
{ {
events.Reset(); mob_archavon_warderAI(Creature* creature) : ScriptedAI(creature)
}
void EnterCombat(Unit * /*who*/)
{
DoZoneInCombat();
events.ScheduleEvent(EVENT_ROCK_SHOWER, 2000);
events.ScheduleEvent(EVENT_SHIELD_CRUSH, 20000);
events.ScheduleEvent(EVENT_WHIRL, 7500);
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{ {
switch(eventId)
{
case EVENT_ROCK_SHOWER:
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(pTarget, SPELL_ROCK_SHOWER);
events.ScheduleEvent(EVENT_ROCK_SHARDS, 6000);
return;
}
case EVENT_SHIELD_CRUSH:
DoCast(me->getVictim(), SPELL_SHIELD_CRUSH);
events.ScheduleEvent(EVENT_SHIELD_CRUSH, 20000);
return;
case EVENT_WHIRL:
DoCast(me->getVictim(), SPELL_WHIRL);
events.ScheduleEvent(EVENT_WHIRL, 8000);
return;
}
} }
DoMeleeAttackIfReady();
EventMap events;
void Reset()
{
events.Reset();
events.ScheduleEvent(EVENT_ROCK_SHOWER, 2000);
events.ScheduleEvent(EVENT_SHIELD_CRUSH, 20000);
events.ScheduleEvent(EVENT_WHIRL, 7500);
}
void EnterCombat(Unit* /*who*/)
{
DoZoneInCombat();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ROCK_SHOWER:
if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_ROCK_SHOWER);
events.ScheduleEvent(EVENT_ROCK_SHARDS, 6000);
break;
case EVENT_SHIELD_CRUSH:
DoCastVictim(SPELL_SHIELD_CRUSH);
events.ScheduleEvent(EVENT_SHIELD_CRUSH, 20000);
break;
case EVENT_WHIRL:
DoCastVictim(SPELL_WHIRL);
events.ScheduleEvent(EVENT_WHIRL, 8000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new mob_archavon_warderAI(creature);
} }
};
}; };
void AddSC_boss_archavon() void AddSC_boss_archavon()
{ {
new boss_archavon(); new boss_archavon();
src/server/scripts/Northrend/VaultOfArchavon/boss_emalon.cpp
+183 -182
View File
@@ -19,27 +19,35 @@
#include "vault_of_archavon.h" #include "vault_of_archavon.h"
//Emalon spells //Emalon spells
enum Spells
{
SPELL_OVERCHARGE = 64218, // Cast every 45 sec on a random Tempest Minion
SPELL_BERSERK = 26662,
SPELL_SHOCK = 64363,
SPELL_OVERCHARGED = 64217,
SPELL_OVERCHARGED_BLAST = 64219, // Cast when Overcharged reaches 10 stacks. Mob dies after that
};
// cannot let SpellDifficulty handle it, no entries for these
#define SPELL_CHAIN_LIGHTNING RAID_MODE(64213, 64215) #define SPELL_CHAIN_LIGHTNING RAID_MODE(64213, 64215)
#define SPELL_LIGHTNING_NOVA RAID_MODE(64216, 65279) #define SPELL_LIGHTNING_NOVA RAID_MODE(64216, 65279)
#define SPELL_OVERCHARGE 64218 //Casted every 45 sec on a random Tempest Minion
#define SPELL_BERSERK 26662
//Tempest Minion spells enum BossEmotes
#define SPELL_SHOCK 64363 {
#define SPELL_OVERCHARGED 64217 EMOTE_OVERCHARGE = -1590000,
#define SPELL_OVERCHARGED_BLAST 64219 //Casted when Overcharged reaches 10 stacks. Mob dies after that EMOTE_MINION_RESPAWN = -1590001,
EMOTE_BERSERK = -1590002,
};
//Emotes enum Events
#define EMOTE_OVERCHARGE -1590000 {
#define EMOTE_MINION_RESPAWN -1590001 EVENT_CHAIN_LIGHTNING = 1,
#define EMOTE_BERSERK -1590002 EVENT_LIGHTNING_NOVA = 2,
EVENT_OVERCHARGE = 3,
//Events EVENT_BERSERK = 4,
#define EVENT_CHAIN_LIGHTNING 1 EVENT_SHOCK = 5,
#define EVENT_LIGHTNING_NOVA 2 };
#define EVENT_OVERCHARGE 3
#define EVENT_BERSERK 4
#define EVENT_SHOCK 5
//Creatures //Creatures
#define MOB_TEMPEST_MINION 33998 #define MOB_TEMPEST_MINION 33998
@@ -59,106 +67,107 @@ struct Position TempestMinions[MAX_TEMPEST_MINIONS] =
######*/ ######*/
class boss_emalon : public CreatureScript class boss_emalon : public CreatureScript
{ {
public: public:
boss_emalon() : CreatureScript("boss_emalon") { } boss_emalon() : CreatureScript("boss_emalon") { }
CreatureAI* GetAI(Creature *_Creature) const struct boss_emalonAI : public BossAI
{
return new boss_emalonAI (_Creature);
}
struct boss_emalonAI : public BossAI
{
boss_emalonAI(Creature *c) : BossAI(c, DATA_EMALON_EVENT)
{ {
} boss_emalonAI(Creature* creature) : BossAI(creature, DATA_EMALON)
void Reset()
{
_Reset();
for (uint8 i = 0; i < MAX_TEMPEST_MINIONS; ++i)
me->SummonCreature(MOB_TEMPEST_MINION, TempestMinions[i], TEMPSUMMON_CORPSE_DESPAWN, 0);
}
void JustSummoned(Creature *summoned)
{
BossAI::JustSummoned(summoned);
if (me->getVictim() && summoned->AI())
summoned->AI()->AttackStart(me->getVictim());
}
void EnterCombat(Unit * who)
{
if (!summons.empty())
{ {
for (std::list<uint64>::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
{
Creature *minion = Unit::GetCreature(*me, *itr);
if (minion && minion->isAlive() && !minion->getVictim() && minion->AI())
minion->AI()->AttackStart(who);
}
} }
events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 5000); void Reset()
events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40000);
events.ScheduleEvent(EVENT_BERSERK, 360000);
events.ScheduleEvent(EVENT_OVERCHARGE, 45000);
_EnterCombat();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{ {
switch(eventId) _Reset();
for (uint8 i = 0; i < MAX_TEMPEST_MINIONS; ++i)
me->SummonCreature(MOB_TEMPEST_MINION, TempestMinions[i], TEMPSUMMON_CORPSE_DESPAWN, 0);
}
void JustSummoned(Creature* summoned)
{
BossAI::JustSummoned(summoned);
// AttackStart has NULL-check for victim
if (summoned->AI())
summoned->AI()->AttackStart(me->getVictim());
}
void EnterCombat(Unit* who)
{
if (!summons.empty())
{ {
case EVENT_CHAIN_LIGHTNING: for (std::list<uint64>::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(pTarget, SPELL_CHAIN_LIGHTNING);
events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 25000);
break;
case EVENT_LIGHTNING_NOVA:
DoCastAOE(SPELL_LIGHTNING_NOVA, false);
events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40000);
break;
case EVENT_OVERCHARGE:
if (!summons.empty())
{ {
std::list<uint64>::const_iterator itr = summons.begin();
std::advance(itr, urand(0, summons.size()-1));
Creature *minion = Unit::GetCreature(*me, *itr); Creature *minion = Unit::GetCreature(*me, *itr);
if (minion && minion->isAlive()) if (minion && minion->isAlive() && !minion->getVictim() && minion->AI())
{ minion->AI()->AttackStart(who);
minion->CastSpell(me, SPELL_OVERCHARGED, true);
minion->SetFullHealth();
DoScriptText(EMOTE_OVERCHARGE, me);
events.ScheduleEvent(EVENT_OVERCHARGE, 45000);
}
} }
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
DoScriptText(EMOTE_BERSERK, me);
break;
} }
events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 5000);
events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40000);
events.ScheduleEvent(EVENT_BERSERK, 360000);
events.ScheduleEvent(EVENT_OVERCHARGE, 45000);
_EnterCombat();
} }
DoMeleeAttackIfReady(); void UpdateAI(const uint32 diff)
} {
}; if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CHAIN_LIGHTNING:
if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_CHAIN_LIGHTNING);
events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 25000);
break;
case EVENT_LIGHTNING_NOVA:
DoCastAOE(SPELL_LIGHTNING_NOVA);
events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40000);
break;
case EVENT_OVERCHARGE:
if (!summons.empty())
{
std::list<uint64>::const_iterator itr = summons.begin();
std::advance(itr, urand(0, summons.size()-1));
Creature* minion = Unit::GetCreature(*me, *itr);
if (minion && minion->isAlive())
{
minion->CastSpell(me, SPELL_OVERCHARGED, true);
minion->SetFullHealth();
DoScriptText(EMOTE_OVERCHARGE, me);
events.ScheduleEvent(EVENT_OVERCHARGE, 45000);
}
}
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
DoScriptText(EMOTE_BERSERK, me);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_emalonAI(creature);
}
}; };
/*###### /*######
@@ -166,109 +175,101 @@ public:
######*/ ######*/
class mob_tempest_minion : public CreatureScript class mob_tempest_minion : public CreatureScript
{ {
public: public:
mob_tempest_minion() : CreatureScript("mob_tempest_minion") { } mob_tempest_minion() : CreatureScript("mob_tempest_minion") { }
CreatureAI* GetAI(Creature *_Creature) const struct mob_tempest_minionAI : public ScriptedAI
{
return new mob_tempest_minionAI (_Creature);
}
struct mob_tempest_minionAI : public ScriptedAI
{
mob_tempest_minionAI(Creature *c) : ScriptedAI(c)
{ {
pInstance = c->GetInstanceScript(); mob_tempest_minionAI(Creature* creature) : ScriptedAI(creature)
}
InstanceScript* pInstance;
EventMap events;
uint32 uiOverchargedTimer;
void Reset()
{
events.Reset();
uiOverchargedTimer = 0;
}
void JustDied(Unit* /*Killer*/)
{
if (Creature *pEmalon = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_EMALON) : 0))
{ {
if (pEmalon->isAlive()) instance = creature->GetInstanceScript();
{
pEmalon->SummonCreature(MOB_TEMPEST_MINION, 0, 0, 0, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
DoScriptText(EMOTE_MINION_RESPAWN, me);
}
} }
}
void EnterCombat(Unit * who) void Reset()
{
DoZoneInCombat();
events.ScheduleEvent(EVENT_SHOCK, 20000);
if (Creature *pEmalon = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_EMALON) : 0))
{ {
if (!pEmalon->getVictim() && pEmalon->AI()) events.Reset();
pEmalon->AI()->AttackStart(who); OverchargedTimer = 0;
} }
}
void UpdateAI(const uint32 diff) void JustDied(Unit* /*Killer*/)
{
//Return since we have no target
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
if (Aura *overchargedAura = me->GetAura(SPELL_OVERCHARGED))
{ {
if (overchargedAura->GetStackAmount() < 10) if (Creature* emalon = Unit::GetCreature(*me, instance ? instance->GetData64(DATA_EMALON) : 0))
{ {
if (uiOverchargedTimer <= diff) if (emalon->isAlive())
{ {
DoCast(me, SPELL_OVERCHARGED); emalon->SummonCreature(MOB_TEMPEST_MINION, 0, 0, 0, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
uiOverchargedTimer = 2000;
} else uiOverchargedTimer -=diff;
}
else
{
if (overchargedAura->GetStackAmount() == 10)
{
DoCast(me, SPELL_OVERCHARGED_BLAST);
me->ForcedDespawn();
DoScriptText(EMOTE_MINION_RESPAWN, me); DoScriptText(EMOTE_MINION_RESPAWN, me);
} }
} }
} }
while (uint32 eventId = events.ExecuteEvent()) void EnterCombat(Unit * who)
{ {
switch(eventId) DoZoneInCombat();
events.ScheduleEvent(EVENT_SHOCK, 20000);
if (Creature *pEmalon = Unit::GetCreature(*me, instance ? instance->GetData64(DATA_EMALON) : 0))
{ {
case EVENT_SHOCK: if (!pEmalon->getVictim() && pEmalon->AI())
DoCast(me->getVictim(), SPELL_SHOCK); pEmalon->AI()->AttackStart(who);
events.ScheduleEvent(EVENT_SHOCK, 20000);
return;
} }
} }
DoMeleeAttackIfReady(); void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
if (Aura const* overchargedAura = me->GetAura(SPELL_OVERCHARGED))
{
if (overchargedAura->GetStackAmount() < 10)
{
if (OverchargedTimer <= diff)
{
DoCast(me, SPELL_OVERCHARGED);
OverchargedTimer = 2000;
}
else
OverchargedTimer -= diff;
}
else
{
if (overchargedAura->GetStackAmount() == 10)
{
DoCast(me, SPELL_OVERCHARGED_BLAST);
me->ForcedDespawn();
DoScriptText(EMOTE_MINION_RESPAWN, me);
}
}
}
if (events.ExecuteEvent() == EVENT_SHOCK)
{
DoCastVictim(SPELL_SHOCK);
events.ScheduleEvent(EVENT_SHOCK, 20000);
}
DoMeleeAttackIfReady();
}
private:
InstanceScript* instance;
EventMap events;
uint32 OverchargedTimer;
};
CreatureAI* GetAI(Creature* creature) const
{
return new mob_tempest_minionAI(creature);
} }
};
}; };
void AddSC_boss_emalon() void AddSC_boss_emalon()
{ {
new boss_emalon(); new boss_emalon();
src/server/scripts/Northrend/VaultOfArchavon/boss_koralon.cpp
+127 -154
View File
@@ -20,135 +20,105 @@
enum Events enum Events
{ {
EVENT_NONE,
// Koralon // Koralon
EVENT_BURNING_BREATH, EVENT_BURNING_BREATH = 1,
EVENT_BURNING_FURY, EVENT_BURNING_FURY = 2,
EVENT_FLAME_CINDER_A, EVENT_FLAME_CINDER_A = 3,
EVENT_METEOR_FISTS_A, EVENT_METEOR_FISTS_A = 4,
EVENT_METEOR_FISTS_B, EVENT_METEOR_FISTS_B = 5,
// Flame Warder // Flame Warder
EVENT_FW_LAVA_BIRST, EVENT_FW_LAVA_BIRST = 6,
EVENT_FW_METEOR_FISTS_A, EVENT_FW_METEOR_FISTS_A = 7,
EVENT_FW_METEOR_FISTS_B, EVENT_FW_METEOR_FISTS_B = 8,
}; };
enum Spells enum Spells
{ {
// Spells Koralon // Spells Koralon
SPELL_BURNING_BREATH = 66665, SPELL_BURNING_BREATH = 66665,
SPELL_BURNING_BREATH_H = 67328,
SPELL_BURNING_FURY = 66721, SPELL_BURNING_FURY = 66721,
SPELL_FLAME_CINDER_A = 66684, SPELL_FLAME_CINDER_A = 66684,
SPELL_FLAME_CINDER_A_H = 67332,
SPELL_FLAME_CINDER_B = 66681, // don't know the real relation to SPELL_FLAME_CINDER_A atm. SPELL_FLAME_CINDER_B = 66681, // don't know the real relation to SPELL_FLAME_CINDER_A atm.
SPELL_METEOR_FISTS_A = 66725, SPELL_METEOR_FISTS_A = 66725,
SPELL_METEOR_FISTS_A_H = 66765,
SPELL_METEOR_FISTS_B = 67333, SPELL_METEOR_FISTS_B = 67333,
SPELL_METEOR_FISTS_B_H = 68161,
// Spells Flame Warder // Spells Flame Warder
SPELL_FW_LAVA_BIRST = 66813, SPELL_FW_LAVA_BIRST = 66813,
SPELL_FW_LAVA_BIRST_H = 67330,
SPELL_FW_METEOR_FISTS_A = 66808, SPELL_FW_METEOR_FISTS_A = 66808,
SPELL_FW_METEOR_FISTS_A_H = 66809,
SPELL_FW_METEOR_FISTS_B = 67331, SPELL_FW_METEOR_FISTS_B = 67331,
SPELL_FW_METEOR_FISTS_B_H = 68160,
}; };
class boss_koralon : public CreatureScript class boss_koralon : public CreatureScript
{ {
public: public:
boss_koralon() : CreatureScript("boss_koralon") { } boss_koralon() : CreatureScript("boss_koralon") { }
CreatureAI* GetAI(Creature* pCreature) const struct boss_koralonAI : public BossAI
{
return new boss_koralonAI (pCreature);
}
struct boss_koralonAI : public ScriptedAI
{
boss_koralonAI(Creature *c) : ScriptedAI(c)
{ {
pInstance = c->GetInstanceScript(); boss_koralonAI(Creature* creature) : BossAI(creature, DATA_KORALON)
}
InstanceScript *pInstance;
EventMap events;
void Reset()
{
events.Reset();
if (pInstance)
pInstance->SetData(DATA_KORALON_EVENT, NOT_STARTED);
}
void KilledUnit(Unit* /*Victim*/) {}
void JustDied(Unit* /*Killer*/)
{
if (pInstance)
pInstance->SetData(DATA_KORALON_EVENT, DONE);
}
void EnterCombat(Unit * /*who*/)
{
DoZoneInCombat();
DoCast(me, SPELL_BURNING_FURY);
events.ScheduleEvent(EVENT_BURNING_FURY, 20000); // TODO check timer
events.ScheduleEvent(EVENT_BURNING_BREATH, 15000); // 1st after 15sec, then every 45sec
events.ScheduleEvent(EVENT_METEOR_FISTS_A, 75000); // 1st after 75sec, then every 45sec
events.ScheduleEvent(EVENT_FLAME_CINDER_A, 30000); // TODO check timer
if (pInstance)
pInstance->SetData(DATA_KORALON_EVENT, IN_PROGRESS);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{ {
switch(eventId)
{
case EVENT_BURNING_FURY:
DoCast(me, SPELL_BURNING_FURY);
events.ScheduleEvent(EVENT_BURNING_FURY, 20000);
return;
case EVENT_BURNING_BREATH:
DoCast(me, RAID_MODE(SPELL_BURNING_BREATH,SPELL_BURNING_BREATH_H));
events.ScheduleEvent(EVENT_BURNING_BREATH, 45000);
return;
case EVENT_METEOR_FISTS_A:
DoCast(me, RAID_MODE(SPELL_METEOR_FISTS_A,SPELL_METEOR_FISTS_A_H));
events.ScheduleEvent(EVENT_METEOR_FISTS_B, 1500);
return;
case EVENT_METEOR_FISTS_B:
DoCast(me, RAID_MODE(SPELL_METEOR_FISTS_B,SPELL_METEOR_FISTS_B_H));
events.ScheduleEvent(EVENT_METEOR_FISTS_A, 45000);
return;
case EVENT_FLAME_CINDER_A:
DoCast(me, RAID_MODE(SPELL_FLAME_CINDER_A,SPELL_FLAME_CINDER_A_H));
events.ScheduleEvent(EVENT_FLAME_CINDER_A, 30000);
return;
}
} }
DoMeleeAttackIfReady();
}
};
void EnterCombat(Unit* /*who*/)
{
DoCast(me, SPELL_BURNING_FURY);
events.ScheduleEvent(EVENT_BURNING_FURY, 20000); // TODO check timer
events.ScheduleEvent(EVENT_BURNING_BREATH, 15000); // 1st after 15sec, then every 45sec
events.ScheduleEvent(EVENT_METEOR_FISTS_A, 75000); // 1st after 75sec, then every 45sec
events.ScheduleEvent(EVENT_FLAME_CINDER_A, 30000); // TODO check timer
_EnterCombat();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BURNING_FURY:
DoCast(me, SPELL_BURNING_FURY);
events.ScheduleEvent(EVENT_BURNING_FURY, 20000);
break;
case EVENT_BURNING_BREATH:
DoCast(me, SPELL_BURNING_BREATH);
events.ScheduleEvent(EVENT_BURNING_BREATH, 45000);
break;
case EVENT_METEOR_FISTS_A:
DoCast(me, SPELL_METEOR_FISTS_A);
events.ScheduleEvent(EVENT_METEOR_FISTS_B, 1500);
break;
case EVENT_METEOR_FISTS_B:
DoCast(me, SPELL_METEOR_FISTS_B);
events.ScheduleEvent(EVENT_METEOR_FISTS_A, 45000);
break;
case EVENT_FLAME_CINDER_A:
DoCast(me, SPELL_FLAME_CINDER_A);
events.ScheduleEvent(EVENT_FLAME_CINDER_A, 30000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_koralonAI(creature);
}
}; };
/*###### /*######
@@ -156,66 +126,69 @@ public:
######*/ ######*/
class mob_flame_warder : public CreatureScript class mob_flame_warder : public CreatureScript
{ {
public: public:
mob_flame_warder() : CreatureScript("mob_flame_warder") { } mob_flame_warder() : CreatureScript("mob_flame_warder") { }
CreatureAI* GetAI(Creature* pCreature) const struct mob_flame_warderAI : public ScriptedAI
{
return new mob_flame_warderAI (pCreature);
}
struct mob_flame_warderAI : public ScriptedAI
{
mob_flame_warderAI(Creature *c) : ScriptedAI(c) {}
EventMap events;
void Reset()
{ {
events.Reset(); mob_flame_warderAI(Creature* creature) : ScriptedAI(creature)
}
void EnterCombat(Unit * /*who*/)
{
DoZoneInCombat();
events.ScheduleEvent(EVENT_FW_LAVA_BIRST, 5000);
events.ScheduleEvent(EVENT_FW_METEOR_FISTS_A, 10000);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{ {
switch(eventId)
{
case EVENT_FW_LAVA_BIRST:
DoCast(me->getVictim(), RAID_MODE(SPELL_FW_LAVA_BIRST,SPELL_FW_LAVA_BIRST_H));
events.ScheduleEvent(EVENT_FW_LAVA_BIRST, 15000);
return;
case EVENT_FW_METEOR_FISTS_A:
DoCast(me, RAID_MODE(SPELL_FW_METEOR_FISTS_A,SPELL_FW_METEOR_FISTS_A_H));
events.ScheduleEvent(EVENT_FW_METEOR_FISTS_B, 1500);
return;
case EVENT_FW_METEOR_FISTS_B:
DoCast(me, RAID_MODE(SPELL_FW_METEOR_FISTS_B,SPELL_FW_METEOR_FISTS_B_H));
events.ScheduleEvent(EVENT_FW_METEOR_FISTS_A, 20000);
return;
}
} }
DoMeleeAttackIfReady();
void Reset()
{
events.Reset();
}
void EnterCombat(Unit * /*who*/)
{
DoZoneInCombat();
events.ScheduleEvent(EVENT_FW_LAVA_BIRST, 5000);
events.ScheduleEvent(EVENT_FW_METEOR_FISTS_A, 10000);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_FW_LAVA_BIRST:
DoCastVictim(SPELL_FW_LAVA_BIRST);
events.ScheduleEvent(EVENT_FW_LAVA_BIRST, 15000);
break;
case EVENT_FW_METEOR_FISTS_A:
DoCast(me, SPELL_FW_METEOR_FISTS_A);
events.ScheduleEvent(EVENT_FW_METEOR_FISTS_B, 1500);
break;
case EVENT_FW_METEOR_FISTS_B:
DoCast(me, SPELL_FW_METEOR_FISTS_B);
events.ScheduleEvent(EVENT_FW_METEOR_FISTS_A, 20000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
private:
EventMap events;
};
CreatureAI* GetAI(Creature* creature) const
{
return new mob_flame_warderAI(creature);
} }
};
}; };
void AddSC_boss_koralon() void AddSC_boss_koralon()
{ {
new boss_koralon(); new boss_koralon();
src/server/scripts/Northrend/VaultOfArchavon/boss_toravon.cpp
+174 -197
View File
@@ -18,117 +18,101 @@
#include "ScriptPCH.h" #include "ScriptPCH.h"
#include "vault_of_archavon.h" #include "vault_of_archavon.h"
// Spells Toravon enum Spells
#define SPELL_FREEZING_GROUND RAID_MODE(72090,72104) // don't know cd... using 20 secs. {
#define SPELL_FROZEN_ORB RAID_MODE(72091,72095) // Toravon
#define SPELL_WHITEOUT RAID_MODE(72034,72096) // Every 38 sec. cast. (after SPELL_FROZEN_ORB) SPELL_FREEZING_GROUND = 72090, // don't know cd... using 20 secs.
#define SPELL_FROZEN_MALLET 71993 SPELL_FROZEN_ORB = 72091,
SPELL_WHITEOUT = 72034, // Every 38 sec. cast. (after SPELL_FROZEN_ORB)
SPELL_FROZEN_MALLET = 71993,
// Spells Frost Warder // Frost Warder
#define SPELL_FROST_BLAST RAID_MODE(72123,72124) // don't know cd... using 20 secs. SPELL_FROST_BLAST = 72123, // don't know cd... using 20 secs.
#define SPELL_FROZEN_MALLET_2 72122 SPELL_FROZEN_MALLET_2 = 72122,
// Spell Frozen Orb // Frozen Orb
#define SPELL_FROZEN_ORB_DMG 72081 // priodic dmg aura SPELL_FROZEN_ORB_DMG = 72081, // priodic dmg aura
#define SPELL_FROZEN_ORB_AURA 72067 // make visible SPELL_FROZEN_ORB_AURA = 72067, // make visible
// Spell Frozen Orb Stalker // Frozen Orb Stalker
#define SPELL_FROZEN_ORB_SUMMON 72093 // summon orb SPELL_FROZEN_ORB_SUMMON = 72093, // summon orb
};
// Events boss // Events boss
#define EVENT_FREEZING_GROUND 1 enum Events
#define EVENT_FROZEN_ORB 2 {
#define EVENT_WHITEOUT 3 EVENT_FREEZING_GROUND = 1,
EVENT_FROZEN_ORB = 2,
EVENT_WHITEOUT = 3,
// Events mob EVENT_FROST_BLAST = 4,
#define EVENT_FROST_BLAST 4 };
// Mob Frozen Orb // Mob Frozen Orb
#define MOB_FROZEN_ORB 38456 // 1 in 10 mode and 3 in 25 mode #define MOB_FROZEN_ORB 38456 // 1 in 10 mode and 3 in 25 mode
class boss_toravon : public CreatureScript class boss_toravon : public CreatureScript
{ {
public: public:
boss_toravon() : CreatureScript("boss_toravon") { } boss_toravon() : CreatureScript("boss_toravon") { }
CreatureAI* GetAI(Creature* pCreature) const struct boss_toravonAI : public BossAI
{
return new boss_toravonAI (pCreature);
}
struct boss_toravonAI : public ScriptedAI
{
boss_toravonAI(Creature *c) : ScriptedAI(c)
{ {
pInstance = c->GetInstanceScript(); boss_toravonAI(Creature* creature) : BossAI(creature, DATA_TORAVON)
}
InstanceScript *pInstance;
EventMap events;
void Reset()
{
events.Reset();
if (pInstance)
pInstance->SetData(DATA_TORAVON_EVENT, NOT_STARTED);
}
void KilledUnit(Unit* /*Victim*/) {}
void JustDied(Unit* /*Killer*/)
{
if (pInstance)
pInstance->SetData(DATA_TORAVON_EVENT, DONE);
}
void EnterCombat(Unit * /*who*/)
{
DoZoneInCombat();
DoCast(me, SPELL_FROZEN_MALLET);
events.ScheduleEvent(EVENT_FROZEN_ORB, 11000);
events.ScheduleEvent(EVENT_WHITEOUT, 13000);
events.ScheduleEvent(EVENT_FREEZING_GROUND, 15000);
if (pInstance)
pInstance->SetData(DATA_TORAVON_EVENT, IN_PROGRESS);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{ {
switch(eventId)
{
case EVENT_FROZEN_ORB:
DoCast(me, SPELL_FROZEN_ORB);
events.ScheduleEvent(EVENT_FROZEN_ORB, 38000);
return;
case EVENT_WHITEOUT:
DoCast(me, SPELL_WHITEOUT);
events.ScheduleEvent(EVENT_WHITEOUT, 38000);
return;
case EVENT_FREEZING_GROUND:
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(pTarget, SPELL_FREEZING_GROUND);
events.ScheduleEvent(EVENT_FREEZING_GROUND, 20000);
return;
}
} }
DoMeleeAttackIfReady();
}
};
void EnterCombat(Unit* /*who*/)
{
DoCast(me, SPELL_FROZEN_MALLET);
events.ScheduleEvent(EVENT_FROZEN_ORB, 11000);
events.ScheduleEvent(EVENT_WHITEOUT, 13000);
events.ScheduleEvent(EVENT_FREEZING_GROUND, 15000);
_EnterCombat();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_FROZEN_ORB:
me->CastCustomSpell(SPELL_FROZEN_ORB, SPELLVALUE_MAX_TARGETS, 1, me);
events.ScheduleEvent(EVENT_FROZEN_ORB, 38000);
break;
case EVENT_WHITEOUT:
DoCast(me, SPELL_WHITEOUT);
events.ScheduleEvent(EVENT_WHITEOUT, 38000);
break;
case EVENT_FREEZING_GROUND:
if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 1))
DoCast(target, SPELL_FREEZING_GROUND);
events.ScheduleEvent(EVENT_FREEZING_GROUND, 20000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_toravonAI(creature);
}
}; };
/*###### /*######
@@ -136,58 +120,56 @@ public:
######*/ ######*/
class mob_frost_warder : public CreatureScript class mob_frost_warder : public CreatureScript
{ {
public: public:
mob_frost_warder() : CreatureScript("mob_frost_warder") { } mob_frost_warder() : CreatureScript("mob_frost_warder") { }
CreatureAI* GetAI(Creature* pCreature) const struct mob_frost_warderAI : public ScriptedAI
{
return new mob_frost_warderAI (pCreature);
}
struct mob_frost_warderAI : public ScriptedAI
{
mob_frost_warderAI(Creature *c) : ScriptedAI(c) {}
EventMap events;
void Reset()
{ {
events.Reset(); mob_frost_warderAI(Creature* c) : ScriptedAI(c) {}
}
void EnterCombat(Unit * /*who*/) void Reset()
{
DoZoneInCombat();
DoCast(me, SPELL_FROZEN_MALLET_2);
events.ScheduleEvent(EVENT_FROST_BLAST, 5000);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{ {
switch(eventId) events.Reset();
{
case EVENT_FROST_BLAST:
DoCast(me->getVictim(), SPELL_FROST_BLAST);
events.ScheduleEvent(EVENT_FROST_BLAST, 20000);
return;
}
} }
DoMeleeAttackIfReady();
void EnterCombat(Unit* /*who*/)
{
DoZoneInCombat();
DoCast(me, SPELL_FROZEN_MALLET_2);
events.ScheduleEvent(EVENT_FROST_BLAST, 5000);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
if (events.ExecuteEvent() == EVENT_FROST_BLAST)
{
DoCastVictim(SPELL_FROST_BLAST);
events.ScheduleEvent(EVENT_FROST_BLAST, 20000);
}
DoMeleeAttackIfReady();
}
private:
EventMap events;
};
CreatureAI* GetAI(Creature* creature) const
{
return new mob_frost_warderAI(creature);
} }
};
}; };
/*###### /*######
## Mob Frozen Orb ## Mob Frozen Orb
######*/ ######*/
@@ -196,22 +178,16 @@ class mob_frozen_orb : public CreatureScript
public: public:
mob_frozen_orb() : CreatureScript("mob_frozen_orb") { } mob_frozen_orb() : CreatureScript("mob_frozen_orb") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new mob_frozen_orbAI (pCreature);
}
struct mob_frozen_orbAI : public ScriptedAI struct mob_frozen_orbAI : public ScriptedAI
{ {
mob_frozen_orbAI(Creature *c) : ScriptedAI(c) {} mob_frozen_orbAI(Creature* creature) : ScriptedAI(creature)
{
bool done; }
uint32 killtimer;
void Reset() void Reset()
{ {
done = false; done = false;
killtimer = 60000; // if after this time there is no victim -> destroy! killTimer = 60000; // if after this time there is no victim -> destroy!
} }
void EnterCombat(Unit * /*who*/) void EnterCombat(Unit * /*who*/)
@@ -228,17 +204,25 @@ public:
done = true; done = true;
} }
if (killtimer <= diff) if (killTimer <= diff)
{ {
if (!UpdateVictim()) if (!UpdateVictim())
me->ForcedDespawn(); me->ForcedDespawn();
killtimer = 10000; killTimer = 10000;
} }
else else
killtimer -= diff; killTimer -= diff;
} }
private:
uint32 killTimer;
bool done;
}; };
CreatureAI* GetAI(Creature* creature) const
{
return new mob_frozen_orbAI(creature);
}
}; };
/*###### /*######
@@ -246,59 +230,52 @@ public:
######*/ ######*/
class mob_frozen_orb_stalker : public CreatureScript class mob_frozen_orb_stalker : public CreatureScript
{ {
public: public:
mob_frozen_orb_stalker() : CreatureScript("mob_frozen_orb_stalker") { } mob_frozen_orb_stalker() : CreatureScript("mob_frozen_orb_stalker") { }
CreatureAI* GetAI(Creature* pCreature) const struct mob_frozen_orb_stalkerAI : public Scripted_NoMovementAI
{
return new mob_frozen_orb_stalkerAI (pCreature);
}
struct mob_frozen_orb_stalkerAI : public Scripted_NoMovementAI
{
mob_frozen_orb_stalkerAI(Creature* c) : Scripted_NoMovementAI(c)
{ {
c->SetVisible(false); mob_frozen_orb_stalkerAI(Creature* creature) : Scripted_NoMovementAI(creature)
c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_DISABLE_MOVE);
c->SetReactState(REACT_PASSIVE);
pInstance = c->GetInstanceScript();
spawned = false;
}
InstanceScript *pInstance;
bool spawned;
void UpdateAI(const uint32 /*diff*/)
{
if (spawned)
return;
spawned = true;
if (!pInstance)
return;
Unit* pToravon = me->GetCreature(*me, pInstance->GetData64(DATA_TORAVON));
if (!pToravon)
return;
uint8 num_orbs = RAID_MODE(1, 3);
for (uint8 i=0; i<num_orbs; ++i)
{ {
Position pos; c->SetVisible(false);
me->GetNearPoint(pToravon, pos.m_positionX, pos.m_positionY, pos.m_positionZ, 0.0f, 10.0f, 0.0f); c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_DISABLE_MOVE);
me->SetPosition(pos, true); c->SetReactState(REACT_PASSIVE);
DoCast(me, SPELL_FROZEN_ORB_SUMMON);
instance = c->GetInstanceScript();
spawned = false;
} }
void UpdateAI(const uint32 /*diff*/)
{
if (spawned)
return;
spawned = true;
Unit* toravon = me->GetCreature(*me, instance ? instance->GetData64(DATA_TORAVON) : 0);
if (!toravon)
return;
uint8 num_orbs = RAID_MODE(1, 3);
for (uint8 i = 0; i < num_orbs; ++i)
{
Position pos;
me->GetNearPoint(toravon, pos.m_positionX, pos.m_positionY, pos.m_positionZ, 0.0f, 10.0f, 0.0f);
me->SetPosition(pos, true);
DoCast(me, SPELL_FROZEN_ORB_SUMMON);
}
}
private:
InstanceScript* instance;
bool spawned;
};
CreatureAI* GetAI(Creature* creature) const
{
return new mob_frozen_orb_stalkerAI(creature);
} }
};
}; };
void AddSC_boss_toravon() void AddSC_boss_toravon()
{ {
new boss_toravon(); new boss_toravon();
src/server/scripts/Northrend/VaultOfArchavon/instance_vault_of_archavon.cpp
+40 -114
View File
@@ -18,8 +18,6 @@
#include "ScriptPCH.h" #include "ScriptPCH.h"
#include "vault_of_archavon.h" #include "vault_of_archavon.h"
#define ENCOUNTERS 4
/* Vault of Archavon encounters: /* Vault of Archavon encounters:
1 - Archavon the Stone Watcher event 1 - Archavon the Stone Watcher event
2 - Emalon the Storm Watcher event 2 - Emalon the Storm Watcher event
@@ -29,135 +27,63 @@
class instance_archavon : public InstanceMapScript class instance_archavon : public InstanceMapScript
{ {
public: public:
instance_archavon() : InstanceMapScript("instance_archavon", 624) { } instance_archavon() : InstanceMapScript("instance_archavon", 624) { }
InstanceScript* GetInstanceScript(InstanceMap* pMap) const struct instance_archavon_InstanceMapScript : public InstanceScript
{
return new instance_archavon_InstanceMapScript(pMap);
}
struct instance_archavon_InstanceMapScript : public InstanceScript
{
instance_archavon_InstanceMapScript(Map *Map) : InstanceScript(Map) {};
uint32 uiEncounters[ENCOUNTERS];
uint64 uiArchavon;
uint64 uiEmalon;
uint64 uiKoralon;
uint64 uiToravon;
void Initialize()
{ {
uiArchavon = 0; instance_archavon_InstanceMapScript(Map* map) : InstanceScript(map)
uiEmalon = 0;
uiKoralon = 0;
uiToravon = 0;
for (uint8 i = 0; i < ENCOUNTERS; i++)
uiEncounters[i] = NOT_STARTED;
}
bool IsEncounterInProgress() const
{
for (uint8 i = 0; i < ENCOUNTERS; i++)
if (uiEncounters[i] == IN_PROGRESS)
return true;
return false;
}
void OnCreatureCreate(Creature* creature)
{
switch(creature->GetEntry())
{ {
case CREATURE_ARCHAVON: uiArchavon = creature->GetGUID(); break; SetBossNumber(MAX_ENCOUNTER);
case CREATURE_EMALON: uiEmalon = creature->GetGUID(); break;
case CREATURE_KORALON: uiKoralon = creature->GetGUID(); break;
case CREATURE_TORAVON: uiToravon = creature->GetGUID(); break;
}
}
uint32 GetData(uint32 type)
{
switch(type)
{
case DATA_ARCHAVON_EVENT: return uiEncounters[0];
case DATA_EMALON_EVENT: return uiEncounters[1];
case DATA_KORALON_EVENT: return uiEncounters[2];
case DATA_TORAVON_EVENT: return uiEncounters[3];
}
return 0;
}
uint64 GetData64(uint32 identifier)
{
switch(identifier)
{
case DATA_ARCHAVON: return uiArchavon;
case DATA_EMALON: return uiEmalon;
case DATA_KORALON: return uiKoralon;
case DATA_TORAVON: return uiToravon;
}
return 0;
}
void SetData(uint32 type, uint32 data)
{
switch(type)
{
case DATA_ARCHAVON_EVENT: uiEncounters[0] = data; break;
case DATA_EMALON_EVENT: uiEncounters[1] = data; break;
case DATA_KORALON_EVENT: uiEncounters[2] = data; break;
case DATA_TORAVON_EVENT: uiEncounters[3] = data; break;
} }
if (data == DONE) void Initialize()
SaveToDB();
}
std::string GetSaveData()
{
OUT_SAVE_INST_DATA;
std::ostringstream stream;
stream << uiEncounters[0] << " " << uiEncounters[1] << " " << uiEncounters[2] << " " << uiEncounters[3];
char* out = new char[stream.str().length() + 1];
strcpy(out, stream.str().c_str());
if (out)
{ {
OUT_SAVE_INST_DATA_COMPLETE; EmalonGUID = 0;
return out; ToravonGUID = 0;
} }
return NULL; void OnCreatureCreate(Creature* creature)
}
void Load(const char* in)
{
if (!in)
{ {
OUT_LOAD_INST_DATA_FAIL; switch (creature->GetEntry())
return; {
case CREATURE_EMALON:
EmalonGUID = creature->GetGUID();
break;
case CREATURE_TORAVON:
ToravonGUID = creature->GetGUID();
break;
default:
break;
}
} }
OUT_LOAD_INST_DATA(in); uint64 GetData64(uint32 identifier)
{
switch (identifier)
{
case DATA_EMALON:
return EmalonGUID;
case DATA_TORAVON:
return ToravonGUID;
default:
break;
}
std::istringstream stream(in); return 0;
stream >> uiEncounters[0] >> uiEncounters[1] >> uiEncounters[2] >> uiEncounters[3]; }
for (uint8 i = 0; i < ENCOUNTERS; ++i) private:
if (uiEncounters[i] == IN_PROGRESS) uint64 EmalonGUID;
uiEncounters[i] = NOT_STARTED; uint64 ToravonGUID;
};
OUT_LOAD_INST_DATA_COMPLETE; InstanceScript* GetInstanceScript(InstanceMap* map) const
{
return new instance_archavon_InstanceMapScript(map);
} }
};
}; };
void AddSC_instance_archavon() void AddSC_instance_archavon()
{ {
new instance_archavon(); new instance_archavon();
src/server/scripts/Northrend/VaultOfArchavon/vault_of_archavon.h
+5 -11
View File
@@ -28,18 +28,12 @@ enum Creatures
enum Data enum Data
{ {
DATA_ARCHAVON_EVENT, DATA_ARCHAVON = 0,
DATA_EMALON_EVENT, DATA_EMALON = 1,
DATA_KORALON_EVENT, DATA_KORALON = 2,
DATA_TORAVON_EVENT, DATA_TORAVON = 3,
}; };
enum Data64 #define MAX_ENCOUNTER 4
{
DATA_ARCHAVON,
DATA_EMALON,
DATA_KORALON,
DATA_TORAVON,
};
#endif #endif