Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-19 08:55:32 +01:00
Code Issues 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

286
src/server/scripts/Northrend/VaultOfArchavon/boss_archavon.cpp
View File

@@ -37,110 +37,92 @@
//Yell
#define SAY_LEAP "Archavon the Stone Watcher lunges for $N!" //$N should be the target
#define EVENT_ROCK_SHARDS 1 //15s cd
#define EVENT_CHOKING_CLOUD 2 //30s cd
#define EVENT_STOMP 3 //45s cd
#define EVENT_IMPALE 4
#define EVENT_BERSERK 5 //300s cd
enum Events
{
// Archavon
EVENT_ROCK_SHARDS = 1, // 15s cd
EVENT_CHOKING_CLOUD = 2, // 30s cd
EVENT_STOMP = 3, // 45s cd
EVENT_IMPALE = 4,
EVENT_BERSERK = 5, // 300s cd
//mob
#define EVENT_ROCK_SHOWER 5 //set = 20s cd,unkown cd
#define EVENT_SHIELD_CRUSH 6 //set = 30s cd
#define EVENT_WHIRL 8 //set= 10s cd
//mob
EVENT_ROCK_SHOWER = 6, // set = 20s cd,unkown cd
EVENT_SHIELD_CRUSH = 7, // set = 30s cd
EVENT_WHIRL = 8, // set= 10s cd
};
class boss_archavon : public CreatureScript
{
public:
boss_archavon() : CreatureScript("boss_archavon") { }
public:
boss_archavon() : CreatureScript("boss_archavon") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_archavonAI (pCreature);
}
struct boss_archavonAI : public ScriptedAI
{
boss_archavonAI(Creature *c) : ScriptedAI(c)
struct boss_archavonAI : public BossAI
{
pInstance = c->GetInstanceScript();
}
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())
boss_archavonAI(Creature* creature) : BossAI(creature, DATA_ARCHAVON)
{
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
{
public:
mob_archavon_warder() : CreatureScript("mob_archavon_warder") { }
public:
mob_archavon_warder() : CreatureScript("mob_archavon_warder") { }
CreatureAI* GetAI(Creature* pCreature) const
{
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()
struct mob_archavon_warderAI : public ScriptedAI //npc 32353
{
events.Reset();
}
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())
mob_archavon_warderAI(Creature* creature) : ScriptedAI(creature)
{
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()
{
new boss_archavon();

365
src/server/scripts/Northrend/VaultOfArchavon/boss_emalon.cpp
View File

@@ -19,27 +19,35 @@
#include "vault_of_archavon.h"
//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_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
#define SPELL_SHOCK 64363
#define SPELL_OVERCHARGED 64217
#define SPELL_OVERCHARGED_BLAST 64219 //Casted when Overcharged reaches 10 stacks. Mob dies after that
enum BossEmotes
{
EMOTE_OVERCHARGE = -1590000,
EMOTE_MINION_RESPAWN = -1590001,
EMOTE_BERSERK = -1590002,
};
//Emotes
#define EMOTE_OVERCHARGE -1590000
#define EMOTE_MINION_RESPAWN -1590001
#define EMOTE_BERSERK -1590002
//Events
#define EVENT_CHAIN_LIGHTNING 1
#define EVENT_LIGHTNING_NOVA 2
#define EVENT_OVERCHARGE 3
#define EVENT_BERSERK 4
#define EVENT_SHOCK 5
enum Events
{
EVENT_CHAIN_LIGHTNING = 1,
EVENT_LIGHTNING_NOVA = 2,
EVENT_OVERCHARGE = 3,
EVENT_BERSERK = 4,
EVENT_SHOCK = 5,
};
//Creatures
#define MOB_TEMPEST_MINION 33998
@@ -59,106 +67,107 @@ struct Position TempestMinions[MAX_TEMPEST_MINIONS] =
######*/
class boss_emalon : public CreatureScript
{
public:
boss_emalon() : CreatureScript("boss_emalon") { }
public:
boss_emalon() : CreatureScript("boss_emalon") { }
CreatureAI* GetAI(Creature *_Creature) const
{
return new boss_emalonAI (_Creature);
}
struct boss_emalonAI : public BossAI
{
boss_emalonAI(Creature *c) : BossAI(c, DATA_EMALON_EVENT)
struct boss_emalonAI : public BossAI
{
}
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())
boss_emalonAI(Creature* creature) : BossAI(creature, DATA_EMALON)
{
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);
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())
void Reset()
{
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:
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())
for (std::list<uint64>::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
{
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);
}
if (minion && minion->isAlive() && !minion->getVictim() && minion->AI())
minion->AI()->AttackStart(who);
}
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
{
public:
mob_tempest_minion() : CreatureScript("mob_tempest_minion") { }
public:
mob_tempest_minion() : CreatureScript("mob_tempest_minion") { }
CreatureAI* GetAI(Creature *_Creature) const
{
return new mob_tempest_minionAI (_Creature);
}
struct mob_tempest_minionAI : public ScriptedAI
{
mob_tempest_minionAI(Creature *c) : ScriptedAI(c)
struct mob_tempest_minionAI : public ScriptedAI
{
pInstance = c->GetInstanceScript();
}
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))
mob_tempest_minionAI(Creature* creature) : ScriptedAI(creature)
{
if (pEmalon->isAlive())
{
pEmalon->SummonCreature(MOB_TEMPEST_MINION, 0, 0, 0, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
DoScriptText(EMOTE_MINION_RESPAWN, me);
}
instance = creature->GetInstanceScript();
}
}
void EnterCombat(Unit * who)
{
DoZoneInCombat();
events.ScheduleEvent(EVENT_SHOCK, 20000);
if (Creature *pEmalon = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_EMALON) : 0))
void Reset()
{
if (!pEmalon->getVictim() && pEmalon->AI())
pEmalon->AI()->AttackStart(who);
events.Reset();
OverchargedTimer = 0;
}
}
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 *overchargedAura = me->GetAura(SPELL_OVERCHARGED))
void JustDied(Unit* /*Killer*/)
{
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);
uiOverchargedTimer = 2000;
} else uiOverchargedTimer -=diff;
}
else
{
if (overchargedAura->GetStackAmount() == 10)
{
DoCast(me, SPELL_OVERCHARGED_BLAST);
me->ForcedDespawn();
emalon->SummonCreature(MOB_TEMPEST_MINION, 0, 0, 0, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
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:
DoCast(me->getVictim(), SPELL_SHOCK);
events.ScheduleEvent(EVENT_SHOCK, 20000);
return;
if (!pEmalon->getVictim() && pEmalon->AI())
pEmalon->AI()->AttackStart(who);
}
}
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()
{
new boss_emalon();

281
src/server/scripts/Northrend/VaultOfArchavon/boss_koralon.cpp
View File

@@ -20,135 +20,105 @@
enum Events
{
EVENT_NONE,
// Koralon
EVENT_BURNING_BREATH,
EVENT_BURNING_FURY,
EVENT_FLAME_CINDER_A,
EVENT_METEOR_FISTS_A,
EVENT_METEOR_FISTS_B,
EVENT_BURNING_BREATH = 1,
EVENT_BURNING_FURY = 2,
EVENT_FLAME_CINDER_A = 3,
EVENT_METEOR_FISTS_A = 4,
EVENT_METEOR_FISTS_B = 5,
// Flame Warder
EVENT_FW_LAVA_BIRST,
EVENT_FW_METEOR_FISTS_A,
EVENT_FW_METEOR_FISTS_B,
EVENT_FW_LAVA_BIRST = 6,
EVENT_FW_METEOR_FISTS_A = 7,
EVENT_FW_METEOR_FISTS_B = 8,
};
enum Spells
{
// Spells Koralon
SPELL_BURNING_BREATH = 66665,
SPELL_BURNING_BREATH_H = 67328,
SPELL_BURNING_FURY = 66721,
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_METEOR_FISTS_A = 66725,
SPELL_METEOR_FISTS_A_H = 66765,
SPELL_METEOR_FISTS_B = 67333,
SPELL_METEOR_FISTS_B_H = 68161,
// Spells Flame Warder
SPELL_FW_LAVA_BIRST = 66813,
SPELL_FW_LAVA_BIRST_H = 67330,
SPELL_FW_METEOR_FISTS_A = 66808,
SPELL_FW_METEOR_FISTS_A_H = 66809,
SPELL_FW_METEOR_FISTS_B = 67331,
SPELL_FW_METEOR_FISTS_B_H = 68160,
};
class boss_koralon : public CreatureScript
{
public:
boss_koralon() : CreatureScript("boss_koralon") { }
public:
boss_koralon() : CreatureScript("boss_koralon") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_koralonAI (pCreature);
}
struct boss_koralonAI : public ScriptedAI
{
boss_koralonAI(Creature *c) : ScriptedAI(c)
struct boss_koralonAI : public BossAI
{
pInstance = c->GetInstanceScript();
}
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())
boss_koralonAI(Creature* creature) : BossAI(creature, DATA_KORALON)
{
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
{
public:
mob_flame_warder() : CreatureScript("mob_flame_warder") { }
public:
mob_flame_warder() : CreatureScript("mob_flame_warder") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new mob_flame_warderAI (pCreature);
}
struct mob_flame_warderAI : public ScriptedAI
{
mob_flame_warderAI(Creature *c) : ScriptedAI(c) {}
EventMap events;
void Reset()
struct mob_flame_warderAI : public ScriptedAI
{
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())
mob_flame_warderAI(Creature* creature) : ScriptedAI(creature)
{
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()
{
new boss_koralon();

371
src/server/scripts/Northrend/VaultOfArchavon/boss_toravon.cpp
View File

@@ -18,117 +18,101 @@
#include "ScriptPCH.h"
#include "vault_of_archavon.h"
// Spells Toravon
#define SPELL_FREEZING_GROUND RAID_MODE(72090,72104) // don't know cd... using 20 secs.
#define SPELL_FROZEN_ORB RAID_MODE(72091,72095)
#define SPELL_WHITEOUT RAID_MODE(72034,72096) // Every 38 sec. cast. (after SPELL_FROZEN_ORB)
#define SPELL_FROZEN_MALLET 71993
enum Spells
{
// Toravon
SPELL_FREEZING_GROUND = 72090, // don't know cd... using 20 secs.
SPELL_FROZEN_ORB = 72091,
SPELL_WHITEOUT = 72034, // Every 38 sec. cast. (after SPELL_FROZEN_ORB)
SPELL_FROZEN_MALLET = 71993,
// Spells Frost Warder
#define SPELL_FROST_BLAST RAID_MODE(72123,72124) // don't know cd... using 20 secs.
#define SPELL_FROZEN_MALLET_2 72122
// Frost Warder
SPELL_FROST_BLAST = 72123, // don't know cd... using 20 secs.
SPELL_FROZEN_MALLET_2 = 72122,
// Spell Frozen Orb
#define SPELL_FROZEN_ORB_DMG 72081 // priodic dmg aura
#define SPELL_FROZEN_ORB_AURA 72067 // make visible
// Frozen Orb
SPELL_FROZEN_ORB_DMG = 72081, // priodic dmg aura
SPELL_FROZEN_ORB_AURA = 72067, // make visible
// Spell Frozen Orb Stalker
#define SPELL_FROZEN_ORB_SUMMON 72093 // summon orb
// Frozen Orb Stalker
SPELL_FROZEN_ORB_SUMMON = 72093, // summon orb
};
// Events boss
#define EVENT_FREEZING_GROUND 1
#define EVENT_FROZEN_ORB 2
#define EVENT_WHITEOUT 3
enum Events
{
EVENT_FREEZING_GROUND = 1,
EVENT_FROZEN_ORB = 2,
EVENT_WHITEOUT = 3,
// Events mob
#define EVENT_FROST_BLAST 4
EVENT_FROST_BLAST = 4,
};
// Mob Frozen Orb
#define MOB_FROZEN_ORB 38456 // 1 in 10 mode and 3 in 25 mode
class boss_toravon : public CreatureScript
{
public:
boss_toravon() : CreatureScript("boss_toravon") { }
public:
boss_toravon() : CreatureScript("boss_toravon") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_toravonAI (pCreature);
}
struct boss_toravonAI : public ScriptedAI
{
boss_toravonAI(Creature *c) : ScriptedAI(c)
struct boss_toravonAI : public BossAI
{
pInstance = c->GetInstanceScript();
}
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())
boss_toravonAI(Creature* creature) : BossAI(creature, DATA_TORAVON)
{
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
{
public:
mob_frost_warder() : CreatureScript("mob_frost_warder") { }
public:
mob_frost_warder() : CreatureScript("mob_frost_warder") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new mob_frost_warderAI (pCreature);
}
struct mob_frost_warderAI : public ScriptedAI
{
mob_frost_warderAI(Creature *c) : ScriptedAI(c) {}
EventMap events;
void Reset()
struct mob_frost_warderAI : public ScriptedAI
{
events.Reset();
}
mob_frost_warderAI(Creature* c) : ScriptedAI(c) {}
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);
while (uint32 eventId = events.ExecuteEvent())
void Reset()
{
switch(eventId)
{
case EVENT_FROST_BLAST:
DoCast(me->getVictim(), SPELL_FROST_BLAST);
events.ScheduleEvent(EVENT_FROST_BLAST, 20000);
return;
}
events.Reset();
}
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
######*/
@@ -196,22 +178,16 @@ class mob_frozen_orb : public CreatureScript
public:
mob_frozen_orb() : CreatureScript("mob_frozen_orb") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new mob_frozen_orbAI (pCreature);
}
struct mob_frozen_orbAI : public ScriptedAI
{
mob_frozen_orbAI(Creature *c) : ScriptedAI(c) {}
bool done;
uint32 killtimer;
mob_frozen_orbAI(Creature* creature) : ScriptedAI(creature)
{
}
void Reset()
{
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*/)
@@ -228,17 +204,25 @@ public:
done = true;
}
if (killtimer <= diff)
if (killTimer <= diff)
{
if (!UpdateVictim())
me->ForcedDespawn();
killtimer = 10000;
killTimer = 10000;
}
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
{
public:
mob_frozen_orb_stalker() : CreatureScript("mob_frozen_orb_stalker") { }
public:
mob_frozen_orb_stalker() : CreatureScript("mob_frozen_orb_stalker") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new mob_frozen_orb_stalkerAI (pCreature);
}
struct mob_frozen_orb_stalkerAI : public Scripted_NoMovementAI
{
mob_frozen_orb_stalkerAI(Creature* c) : Scripted_NoMovementAI(c)
struct mob_frozen_orb_stalkerAI : public Scripted_NoMovementAI
{
c->SetVisible(false);
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)
mob_frozen_orb_stalkerAI(Creature* creature) : Scripted_NoMovementAI(creature)
{
Position pos;
me->GetNearPoint(pToravon, 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);
c->SetVisible(false);
c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_DISABLE_MOVE);
c->SetReactState(REACT_PASSIVE);
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()
{
new boss_toravon();

154
src/server/scripts/Northrend/VaultOfArchavon/instance_vault_of_archavon.cpp
View File

@@ -18,8 +18,6 @@
#include "ScriptPCH.h"
#include "vault_of_archavon.h"
#define ENCOUNTERS 4
/* Vault of Archavon encounters:
1 - Archavon the Stone Watcher event
2 - Emalon the Storm Watcher event
@@ -29,135 +27,63 @@
class instance_archavon : public InstanceMapScript
{
public:
instance_archavon() : InstanceMapScript("instance_archavon", 624) { }
public:
instance_archavon() : InstanceMapScript("instance_archavon", 624) { }
InstanceScript* GetInstanceScript(InstanceMap* pMap) const
{
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()
struct instance_archavon_InstanceMapScript : public InstanceScript
{
uiArchavon = 0;
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())
instance_archavon_InstanceMapScript(Map* map) : InstanceScript(map)
{
case CREATURE_ARCHAVON: uiArchavon = creature->GetGUID(); break;
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;
SetBossNumber(MAX_ENCOUNTER);
}
if (data == DONE)
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)
void Initialize()
{
OUT_SAVE_INST_DATA_COMPLETE;
return out;
EmalonGUID = 0;
ToravonGUID = 0;
}
return NULL;
}
void Load(const char* in)
{
if (!in)
void OnCreatureCreate(Creature* creature)
{
OUT_LOAD_INST_DATA_FAIL;
return;
switch (creature->GetEntry())
{
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);
stream >> uiEncounters[0] >> uiEncounters[1] >> uiEncounters[2] >> uiEncounters[3];
return 0;
}
for (uint8 i = 0; i < ENCOUNTERS; ++i)
if (uiEncounters[i] == IN_PROGRESS)
uiEncounters[i] = NOT_STARTED;
private:
uint64 EmalonGUID;
uint64 ToravonGUID;
};
OUT_LOAD_INST_DATA_COMPLETE;
InstanceScript* GetInstanceScript(InstanceMap* map) const
{
return new instance_archavon_InstanceMapScript(map);
}
};
};
void AddSC_instance_archavon()
{
new instance_archavon();

16
src/server/scripts/Northrend/VaultOfArchavon/vault_of_archavon.h
View File

@@ -28,18 +28,12 @@ enum Creatures
enum Data
{
DATA_ARCHAVON_EVENT,
DATA_EMALON_EVENT,
DATA_KORALON_EVENT,
DATA_TORAVON_EVENT,
DATA_ARCHAVON = 0,
DATA_EMALON = 1,
DATA_KORALON = 2,
DATA_TORAVON = 3,
};
enum Data64
{
DATA_ARCHAVON,
DATA_EMALON,
DATA_KORALON,
DATA_TORAVON,
};
#define MAX_ENCOUNTER 4
#endif