//Edit Player Faction
static bool HandleModifyFactionCommand(ChatHandler* handler, const char* args)
{
if (!*args)
return false;
char* pfactionid = handler->extractKeyFromLink((char*)args, "Hfaction");
Creature* target = handler->getSelectedCreature();
if (!target)
{
handler->SendSysMessage(LANG_SELECT_CREATURE);
handler->SetSentErrorMessage(true);
return false;
}
if (!pfactionid)
{
uint32 factionid = target->getFaction();
uint32 flag = target->GetUInt32Value(UNIT_FIELD_FLAGS);
uint32 npcflag = target->GetUInt32Value(UNIT_FIELD_NPC_FLAGS);
uint32 dyflag = target->GetUInt32Value(OBJECT_FIELD_DYNAMIC_FLAGS);
handler->PSendSysMessage(LANG_CURRENT_FACTION, target->GetGUIDLow(), factionid, flag, npcflag, dyflag);
return true;
}
uint32 factionid = atoi(pfactionid);
uint32 flag;
char *pflag = strtok(NULL, " ");
if (!pflag)
flag = target->GetUInt32Value(UNIT_FIELD_FLAGS);
else
flag = atoi(pflag);
char* pnpcflag = strtok(NULL, " ");
uint32 npcflag;
if (!pnpcflag)
npcflag = target->GetUInt32Value(UNIT_FIELD_NPC_FLAGS);
else
npcflag = atoi(pnpcflag);
char* pdyflag = strtok(NULL, " ");
uint32 dyflag;
if (!pdyflag)
dyflag = target->GetUInt32Value(OBJECT_FIELD_DYNAMIC_FLAGS);
else
dyflag = atoi(pdyflag);
if (!sFactionTemplateStore.LookupEntry(factionid))
{
handler->PSendSysMessage(LANG_WRONG_FACTION, factionid);
handler->SetSentErrorMessage(true);
return false;
}
handler->PSendSysMessage(LANG_YOU_CHANGE_FACTION, target->GetGUIDLow(), factionid, flag, npcflag, dyflag);
target->setFaction(factionid);
target->SetUInt32Value(UNIT_FIELD_FLAGS, flag);
target->SetUInt32Value(UNIT_FIELD_NPC_FLAGS, npcflag);
target->SetUInt32Value(OBJECT_FIELD_DYNAMIC_FLAGS, dyflag);
return true;
}
void UpdateAI(const uint32 diff)
{
//Sounds OOC, Kiljaeden Orders
if(!m_creature->getVictim())
{
if(m_uiKJOrdersTimer < diff)
{
switch (rand()%5)
{
case 0: DoPlaySoundToSet(m_creature, SAY_KJ_OFFCOMBAT1); break;
case 1: DoPlaySoundToSet(m_creature, SAY_KJ_OFFCOMBAT2); break;
case 2: DoPlaySoundToSet(m_creature, SAY_KJ_OFFCOMBAT3); break;
case 3: DoPlaySoundToSet(m_creature, SAY_KJ_OFFCOMBAT4); break;
case 4: DoPlaySoundToSet(m_creature, SAY_KJ_OFFCOMBAT5); break;
}
m_uiKJOrdersTimer = 30000;
}else m_uiKJOrdersTimer -= diff;
}
/*//Rebirth After Phase1
if(pInstance && pInstance->GetData(DATA_KILJAEDEN) == IN_PROGRESS)
{
m_creature->setFaction(14);
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
//pInstance->SetData(DATA_KILJAEDEN_EVENT, IN_PROGRESS);
//pInstance->SetData(DATA_DECIVER, NOT_STARTED);
}*/
if(!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
//dragon cast blue shield
for(uint8 i=0; i<4; ++i)
{
if(Unit* Dragon = m_creature->GetMap()->GetUnit(DragonGUID[i]))
if(Dragon && Dragon->HasAura(SPELL_SHIELD_OF_BLUE))
{
m_uiCancelShieldTimer = 5000;
std::list<HostileReference *> t_list = m_creature->getThreatManager().getThreatList();
for(std::list<HostileReference *>::iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
{
Unit *TargetedPlayer = m_creature->GetMap()->GetUnit((*itr)->getUnitGuid());
if (TargetedPlayer && TargetedPlayer->GetTypeId() == TYPEID_PLAYER && TargetedPlayer->IsWithinDistInMap(Dragon, 10) && !TargetedPlayer->HasAura(AURA_BLUESHIELD))
TargetedPlayer->CastSpell(TargetedPlayer,AURA_BLUESHIELD,true);
}
}
}
//stop blue shield
if(m_uiCancelShieldTimer < diff)
{
std::list<HostileReference *> t_list = m_creature->getThreatManager().getThreatList();
for(std::list<HostileReference *>::iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
{
Unit *ShieldedPlayer1 = m_creature->GetMap()->GetUnit((*itr)->getUnitGuid());
if (ShieldedPlayer1 && ShieldedPlayer1->GetTypeId() == TYPEID_PLAYER && ShieldedPlayer1->HasAura(AURA_BLUESHIELD))
{
ShieldedPlayer1->RemoveAurasDueToSpell(AURA_BLUESHIELD);
}
}
m_uiCancelShieldTimer = 300000;
}else m_uiCancelShieldTimer -= diff;
//Kalecgos and Anvena Event
if((m_uiKalecgosAnvenaTimer < diff) && m_bIsAnvena)
{
switch(m_uiKalecgosAnvenaCount)
{
case 0:
DoPlaySoundToSet(m_creature, SAY_KALECGOS_AWAKEN); m_uiKalecgosAnvenaTimer = 5000; break;
case 1:
DoPlaySoundToSet(m_creature, SAY_ANVEENA_IMPRISONED); m_uiKalecgosAnvenaTimer = 3000; break;
case 2:
DoPlaySoundToSet(m_creature, SAY_KALECGOS_LETGO); m_uiKalecgosAnvenaTimer = 6000; break;
case 5:
DoPlaySoundToSet(m_creature, SAY_ANVEENA_LOST); m_uiKalecgosAnvenaTimer = 4000; break;
case 4:
DoPlaySoundToSet(m_creature, SAY_KALECGOS_FOCUS); m_uiKalecgosAnvenaTimer = 8000; break;
case 3:
DoPlaySoundToSet(m_creature, SAY_ANVEENA_KALEC); m_uiKalecgosAnvenaTimer = 5000; break;
case 6:
DoPlaySoundToSet(m_creature, SAY_KALECGOS_FATE); m_uiKalecgosAnvenaTimer = 5000; break;
case 7:
DoPlaySoundToSet(m_creature, SAY_ANVEENA_GOODBYE);
m_creature->CastSpell(m_creature, SPELL_SACRIFICE_OF_ANVEENA, false);
m_uiKalecgosAnvenaTimer = 5000;
break;
case 9:
DoPlaySoundToSet(m_creature, SAY_KALECGOS_GOODBYE); ; m_bIsAnvena = false; break;
case 8:
DoPlaySoundToSet(m_creature, SAY_KALECGOS_ENCOURAGE); m_uiKalecgosAnvenaTimer = 14000; break;
}
++m_uiKalecgosAnvenaCount;
} m_uiKalecgosAnvenaTimer -= diff;
//Kalecgos Event working
if((m_uiKalecgosTimer < diff) && !m_bIsKalecgosSpawned)
{
DoPlaySoundToSet(m_creature, SAY_KALECGOS_JOIN);
Kalecgos = m_creature->SummonCreature(ID_KALECGOS, m_creature->GetPositionX()-25, m_creature->GetPositionY()-25, m_creature->GetPositionZ()+10, 0.686f, TEMPSUMMON_TIMED_DESPAWN, 600000);
Kalecgos->setFaction(35);
//Kalecgos need to start shhooting arcane bolt into Kiljaeden
//Dragon->AI()->AttackStart(m_creature);
m_bIsKalecgosSpawned = true;
}m_uiKalecgosTimer -= diff;
//Shield Orb At Start each phases working
/* if(m_uiShieldOrbTimer < diff && !m_bPhase5)
{
uint8 l=1;
if(m_bPhase3)
l=2;
if(m_bPhase4)
l=3;
for(uint8 k=0; k<l; ++k)
{
Creature* ShieldOrb = m_creature->SummonCreature(ID_SHIELDORB, m_creature->GetPositionX()+urand(1,15), m_creature->GetPositionY()+urand(1,15), m_creature->GetPositionZ()+15, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if(ShieldOrb)
ShieldOrb->AI()->AttackStart(m_creature->getVictim());
}
m_uiShieldOrbTimer = 50000;
}else m_uiShieldOrbTimer -= diff;*/
//Sinister Reflects Attack Spell Timer
if(m_uiSinnisterCastTimer < diff)
{
uint8 m_uiSinisterCount = 4;
/*if(m_bPhase3)
m_uiSinisterCount = 4;
if(m_bPhase4)
m_uiSinisterCount = 8;
if(m_bPhase5)
m_uiSinisterCount = 12;*/
for(uint8 i=0; i<m_uiSinisterCount; ++i)
{
if(Unit* Sinister = m_creature->GetMap()->GetUnit(m_uiSinisterGUID[i][0]))
{
if(Unit* target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0))
Sinister->CastSpell(target, m_uiSinisterGUID[i][1], true);
}
}
m_uiSinnisterCastTimer = 8000;
}else m_uiSinnisterCastTimer -= diff;
//Phase4
//armageddon
if((m_uiAramageddonTimer < diff) && m_bPhase4)
{
uint8 h=3;
if(m_bPhase5)
h=5;
if(!m_bPhase5 && m_bDarknessOfSoulsCasting)
h=0;
for(uint8 i=0; i<h; ++i)
{
if(Unit* target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0))
Creature* Armagedon = m_creature->SummonCreature(ID_ARMAGEDON, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 15000);
}
m_uiAramageddonTimer = 14000;
}else m_uiAramageddonTimer -= diff;
if((m_uiShadowSpikeEndsTimer < diff) && m_bShadowSpikeEnds && m_bPhase3)
{
if(Unit* target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0))
{
cShadowSpike = m_creature->SummonCreature(ID_SHADOWSPIKE, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 6000);
cShadowSpike->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
cShadowSpike->setFaction(14);
//target->CastSpell(target, SPELL_SHADOWSPIKE_EXP, false);
}
++m_uiSpikesCount;
if(m_uiSpikesCount > 9)
m_bShadowSpikeEnds = false;
m_uiShadowSpikeEndsTimer = 3000;
}else m_uiShadowSpikeEndsTimer -= diff;
if(m_bShadowSpikeEnds)
return;
if(m_uiDarknessExplosionTimer < diff && m_bDarknessOfSoulsCasting)
{
m_creature->CastSpell(m_creature->getVictim(), SPELL_DARKNESS_EXPLOSION, true);
m_bDarknessOfSoulsCasting = false;
m_uiDarknessExplosionTimer = 600000;
m_uiDarknessOfSoulsTimer = 45000;
if(m_bPhase5)
m_uiDarknessOfSoulsTimer = 25000;
}else m_uiDarknessExplosionTimer -= diff;
if(m_bDarknessOfSoulsCasting)
return;
// darkness of a thousand souls from phase 3 on
if(m_uiDarknessOfSoulsTimer < diff && m_bPhase3)
{
switch (rand()%3)
{
case 0: DoPlaySoundToSet(m_creature, SAY_KJ_DARKNESS1); break;
case 1: DoPlaySoundToSet(m_creature, SAY_KJ_DARKNESS2); break;
case 2: DoPlaySoundToSet(m_creature, SAY_KJ_DARKNESS3); break;
}
m_creature->CastSpell(m_creature, SPELL_DARKNESS_OF_SOULS, true);
m_bDarknessOfSoulsCasting = true;
m_uiDarknessExplosionTimer = 8500;
}else m_uiDarknessOfSoulsTimer -= diff;
// After Each Phase Dragons Are Spawned
if((m_uiOrbTimer < diff) && !m_bBoolOrb)
{
for(uint8 i=0; i<4; ++i)
DragonGUID[i] = 0;
switch (rand()%4)
{
case 0: DoPlaySoundToSet(m_creature, SAY_KALEC_ORB_READY1); break;
case 1: DoPlaySoundToSet(m_creature, SAY_KALEC_ORB_READY2); break;
case 2: DoPlaySoundToSet(m_creature, SAY_KALEC_ORB_READY3); break;
case 3: DoPlaySoundToSet(m_creature, SAY_KALEC_ORB_READY4); break;
}
uint8 m_uiMaxDragons = 1;
if(m_bPhase5)
m_uiMaxDragons = 4;
for(uint8 i=0; i<m_uiMaxDragons; ++i)
{
Creature* Dragon = m_creature->SummonCreature(ID_DRAGON, m_creature->GetPositionX()+urand(5,20), m_creature->GetPositionY()+urand(5,20), m_creature->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN, 20000);
DragonGUID[i] = Dragon->GetGUID();
}
m_bBoolOrb = true;
}else m_uiOrbTimer -= diff;
//FireBloom Damage WorkArround
if (m_uiFireBloomCheck < diff)
{
if(m_uiFireBloomCount < 10)
for(uint8 i=0; i<5; ++i)
{
if(Unit* FireTarget = m_creature->GetMap()->GetUnit(m_uiFireBloomTarget[i]))
FireTarget->CastSpell(FireTarget, SPELL_FIREBLOOM_EFF, true);
}
++m_uiFireBloomCount;
m_uiFireBloomCheck = 2000;
}else m_uiFireBloomCheck -= diff;
//Phase 3 init
if(((m_creature->GetHealth()*100 / m_creature->GetMaxHealth()) <= 85) && !m_bPhase3)
{
DoPlaySoundToSet(m_creature, SAY_KJ_PHASE3);
if(Unit* victim = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0))
if (victim && (victim->GetTypeId() == TYPEID_PLAYER))
Sinister(((Player*)victim),0,4);
m_creature->MonsterYell("entering phase 3",LANG_UNIVERSAL);
m_uiSinnisterCastTimer = 10000;
m_uiShadowSpikeTimer = 30000;
m_uiFlameDartTimer = 40000;
m_uiDarknessOfSoulsTimer = 45000;
m_bShadowSpikeEnds = false;
m_bDarknessOfSoulsCasting = false;
m_bPhase3 = true;
//DragonsTimer
m_uiOrbTimer = 35000;
m_bBoolOrb = false;
}
//phase 4 init
if(((m_creature->GetHealth()*100 / m_creature->GetMaxHealth()) <= 55) && !m_bPhase4)
{
DoPlaySoundToSet(m_creature, SAY_KJ_PHASE4);
if(Unit* victim = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0))
if (victim && (victim->GetTypeId() == TYPEID_PLAYER))
Sinister(((Player*)victim),4,8);
m_creature->MonsterYell("entering phase 4",LANG_UNIVERSAL);
m_uiAramageddonTimer = 2000; //100% ok
m_bPhase4 = true;
m_uiDarknessOfSoulsTimer = 45000;
//DragonsTimer
m_uiOrbTimer = 35000;
m_bBoolOrb = false;
}
//phase 5 init
if(((m_creature->GetHealth()*100 / m_creature->GetMaxHealth()) <= 25) && !m_bPhase5)
{
DoPlaySoundToSet(m_creature, SAY_KJ_PHASE5);
if(Unit* victim = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0))
if (victim && (victim->GetTypeId() == TYPEID_PLAYER))
Sinister(((Player*)victim),8,12);
m_creature->MonsterYell("entering phase 5",LANG_UNIVERSAL);
m_uiShadowSpikeTimer = 1000;
m_uiDarknessOfSoulsTimer = 45000;
m_bPhase5 = true;
//DragonsTimer
m_uiOrbTimer = 35000;
m_bBoolOrb = false;
//Kalecgos and Anvena Event
m_uiKalecgosAnvenaTimer = 20000;
m_bIsAnvena = true;
m_uiKalecgosAnvenaCount = 0;
Creature* Anveena = m_creature->SummonCreature(ID_ANVEENA, m_creature->GetPositionX()+urand(20,30), m_creature->GetPositionY()+urand(20,30), m_creature->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 120000);
Anveena->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
Anveena->setFaction(35);
}
//spells used from phase 3 on
if(m_bPhase3)
{
if(m_uiShadowSpikeTimer < diff)
{
DoCast(m_creature->getVictim(), SPELL_SHADOWSPIKE);
m_bShadowSpikeEnds = true;
m_uiShadowSpikeEndsTimer = 500;
m_uiSpikesCount = 0;
m_uiShadowSpikeTimer = 90000;
}else m_uiShadowSpikeTimer -= diff;
//flame dart
if(m_uiFlameDartTimer < diff )
{
DoCast(m_creature->getVictim(), SPELL_FLAMEDARTS);
m_uiFlameDartTimer = 33000;
}else m_uiFlameDartTimer -= diff;
}
//Phase2
// legion lightning all phases
if(m_uiLegionLightingTimer < diff)
{
DoCast(m_creature->getVictim(), SPELL_LEGION_LIGHTING);
m_uiLegionLightingTimer = 11000;
}else m_uiLegionLightingTimer -= diff;
// fire bloom all phases
if(m_uiFireBloomTimer < diff)
{
for(uint8 i=0; i<5; ++i)
{
Unit* target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0);
m_uiFireBloomTarget[i] = target->GetGUID();
m_uiFireBloomCount = 0;
//DoCast(target, SPELL_FIREBLOOM, true);
}
m_uiFireBloomTimer = 25000;
}else m_uiFireBloomTimer -= diff;
// soul flay all phases
if(m_uiSoulFlayTimer < diff)
{
DoCast(m_creature->getVictim(), SPELL_SOULFLAY);
m_uiSoulFlayTimer = 7000;
}else m_uiSoulFlayTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
//Only do this if we haven't spawned nef yet
if (SpawnedAdds < 42)
{
//ShadowBoltTimer
if (ShadowBoltTimer < diff)
{
Unit* target = NULL;
target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0);
if (target)
DoCastSpellIfCan(target,SPELL_SHADOWBOLT);
ShadowBoltTimer = urand(3000, 10000);
}else ShadowBoltTimer -= diff;
//FearTimer
if (FearTimer < diff)
{
Unit* target = NULL;
target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0);
if (target)
DoCastSpellIfCan(target,SPELL_FEAR);
FearTimer = urand(10000, 20000);
}else FearTimer -= diff;
//Add spawning mechanism
if (AddSpawnTimer < diff)
{
//Spawn 2 random types of creatures at the 2 locations
uint32 CreatureID;
Creature* Spawned = NULL;
Unit* target = NULL;
//1 in 3 chance it will be a chromatic
if (!urand(0, 2))
CreatureID = CREATURE_CHROMATIC_DRAKANOID;
else CreatureID = DrakType1;
++SpawnedAdds;
//Spawn creature and force it to start attacking a random target
Spawned = m_creature->SummonCreature(CreatureID,ADD_X1,ADD_Y1,ADD_Z1,5.000f,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,5000);
target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0);
if (target && Spawned)
{
Spawned->AI()->AttackStart(target);
Spawned->setFaction(103);
}
//1 in 3 chance it will be a chromatic
if (!urand(0, 2))
CreatureID = CREATURE_CHROMATIC_DRAKANOID;
else CreatureID = DrakType2;
++SpawnedAdds;
target = NULL;
Spawned = NULL;
Spawned = m_creature->SummonCreature(CreatureID,ADD_X2,ADD_Y2,ADD_Z2,5.000,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,5000);
target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0);
if (target && Spawned)
{
Spawned->AI()->AttackStart(target);
Spawned->setFaction(103);
}
//Begin phase 2 by spawning Nefarian and what not
if (SpawnedAdds >= 42)
{
//Teleport Victor Nefarius way out of the map
//MapManager::Instance().GetMap(m_creature->GetMapId(), m_creature)->CreatureRelocation(m_creature,0,0,-5000,0);
//Inturrupt any spell casting
m_creature->InterruptNonMeleeSpells(false);
//Root self
DoCastSpellIfCan(m_creature,33356);
//Make super invis
DoCastSpellIfCan(m_creature,8149);
//Teleport self to a hiding spot
m_creature->NearTeleportTo(HIDE_X, HIDE_Y, HIDE_Z, 0.0f);
//Spawn nef and have him attack a random target
Creature* Nefarian = m_creature->SummonCreature(CREATURE_NEFARIAN,NEF_X,NEF_Y,NEF_Z,0,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,120000);
target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0);
if (target && Nefarian)
{
Nefarian->AI()->AttackStart(target);
Nefarian->setFaction(103);
NefarianGUID = Nefarian->GetGUID();
}
else error_log("SD2: Blackwing Lair: Unable to spawn nefarian properly.");
}
AddSpawnTimer = 4000;
}else AddSpawnTimer -= diff;
}
else if (NefarianGUID)
{
if (NefCheckTime < diff)
{
Creature* pNefarian = m_creature->GetMap()->GetCreature(NefarianGUID);
//If nef is dead then we die to so the players get out of combat
//and cannot repeat the event
if (!pNefarian || !pNefarian->isAlive())
{
NefarianGUID = 0;
m_creature->ForcedDespawn();
}
NefCheckTime = 2000;
}else NefCheckTime -= diff;
}
}
void BattlegroundEY::EventTeamCapturedPoint(Player* player, uint32 Point)
{
if (GetStatus() != STATUS_IN_PROGRESS)
return;
uint32 Team = player->GetTeam();
SpawnBGObject(m_CapturingPointTypes[Point].DespawnNeutralObjectType, RESPAWN_ONE_DAY);
SpawnBGObject(m_CapturingPointTypes[Point].DespawnNeutralObjectType + 1, RESPAWN_ONE_DAY);
SpawnBGObject(m_CapturingPointTypes[Point].DespawnNeutralObjectType + 2, RESPAWN_ONE_DAY);
if (Team == ALLIANCE)
{
m_TeamPointsCount[TEAM_ALLIANCE]++;
SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeAlliance, RESPAWN_IMMEDIATELY);
SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeAlliance + 1, RESPAWN_IMMEDIATELY);
SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeAlliance + 2, RESPAWN_IMMEDIATELY);
}
else
{
m_TeamPointsCount[TEAM_HORDE]++;
SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeHorde, RESPAWN_IMMEDIATELY);
SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeHorde + 1, RESPAWN_IMMEDIATELY);
SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeHorde + 2, RESPAWN_IMMEDIATELY);
}
//buff isn't respawned
m_PointOwnedByTeam[Point] = Team;
m_PointState[Point] = EY_POINT_UNDER_CONTROL;
if (Team == ALLIANCE)
SendMessageToAll(m_CapturingPointTypes[Point].MessageIdAlliance, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
else
SendMessageToAll(m_CapturingPointTypes[Point].MessageIdHorde, CHAT_MSG_BG_SYSTEM_HORDE, player);
if (BgCreatures[Point])
DelCreature(Point);
WorldSafeLocsEntry const* sg = NULL;
sg = sWorldSafeLocsStore.LookupEntry(m_CapturingPointTypes[Point].GraveYardId);
if (!sg || !AddSpiritGuide(Point, sg->x, sg->y, sg->z, 3.124139f, GetTeamIndexByTeamId(Team)))
TC_LOG_ERROR("bg.battleground", "BatteGroundEY: Failed to spawn spirit guide! point: %u, team: %u, graveyard_id: %u",
Point, Team, m_CapturingPointTypes[Point].GraveYardId);
// SpawnBGCreature(Point, RESPAWN_IMMEDIATELY);
UpdatePointsIcons(Team, Point);
UpdatePointsCount(Team);
if (Point >= EY_POINTS_MAX)
return;
Creature* trigger = GetBGCreature(Point + 6, false);//0-5 spirit guides
if (!trigger)
trigger = AddCreature(WORLD_TRIGGER, Point+6, BG_EY_TriggerPositions[Point], GetTeamIndexByTeamId(Team));
//add bonus honor aura trigger creature when node is accupied
//cast bonus aura (+50% honor in 25yards)
//aura should only apply to players who have accupied the node, set correct faction for trigger
if (trigger)
{
trigger->setFaction(Team == ALLIANCE ? 84 : 83);
trigger->CastSpell(trigger, SPELL_HONORABLE_DEFENDER_25Y, false);
}
}
void UpdateAI(uint32 uiDiff)
{
if (!UpdateVictim())
return;
if (me->GetPower(POWER_ENERGY) < 0)
me->SetPower(POWER_ENERGY, 0);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
if (me->GetPower(POWER_ENERGY) == 100)
{
me->RemoveFlag(UNIT_FIELD_FLAGS, 512);
me->RemoveAura(SPELL_SELF_ROOT);
me->RemoveAura(SPELL_BLESSING_RECHARGE);
blessing = false;
}
if (m_uiSunStrikeTimer <= uiDiff && blessing == false)
{
Unit* victim = SelectTarget(SELECT_TARGET_RANDOM, 0);
if(victim)
{
DoCast(victim, SPELL_SUN_STRIKE);
me->AddAura(SPELL_SUN_STRIKE_PERIODIC, victim);
}
m_uiSunStrikeTimer = urand(11000, 14000);
}
else
m_uiSunStrikeTimer -= uiDiff;
if (m_uiWindsTimer <= uiDiff && blessing == false)
{
if(Unit* victim = SelectTarget(SELECT_TARGET_RANDOM, 0, NonTankTargetSelector(me)))
DoCast(victim, SPELL_SOLAR_WINDS);
m_uiWindsTimer = urand(9000, 15000);
}
else
m_uiWindsTimer -= uiDiff;
if (m_uiLeapTimer <= uiDiff && blessing == false)
{
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, NonTankTargetSelector(me)))
{
me->MonsterTextEmote(SAY_JUMP, NULL, true);
me->AddThreat(pTarget, 9000.0f);
DoCast(pTarget, SPELL_INFERNO_LEAP_MOB_SUMMON);
DoCast(pTarget, SPELL_INFERNO_LEAP_CAST_TIME);
leap_timer = 1500;
leap = true;
Creature* Summoned = me->FindNearestCreature(NPC_INFERNO_LEAP, 100, true);
if (Summoned)
{
Summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Summoned->SetFloatValue(OBJECT_FIELD_SCALE_X, Summoned->GetFloatValue(OBJECT_FIELD_SCALE_X)*2.5f);
Summoned->setFaction(me->getFaction());
Summoned->SetLevel(me->getLevel());
}
m_uiLeapTimer = urand(18000, 22000);
}
}
else
m_uiLeapTimer -= uiDiff;
if (leap_timer <= uiDiff && leap == true)
{
DoCastVictim(SPELL_INFERNO_LEAP);
leap = false;
} else leap_timer -= uiDiff;
if (m_uiSunOrbTimer <= uiDiff && blessing == false)
{
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, NonTankTargetSelector(me)))
DoCast(pTarget, SPELL_SUMMON_ORB);
m_uiSunOrbTimer = urand(24000, 31000);
}
else
m_uiSunOrbTimer -= uiDiff;
if (me->GetPower(POWER_ENERGY) == 0)
{
me->MonsterTextEmote(SAY_ANNOUNCE, NULL, true);
DoCast(me, SPELL_BLESSING_RECHARGE);
blessing = true;
me->SetFlag(UNIT_FIELD_FLAGS, 512);
me->AddAura(SPELL_SELF_ROOT, me);
Talk(SAY_BLESSING);
}
if(!me->HasAura(SPELL_BLESSING_RECHARGE))
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (uiPhase)
{
if (uiTimer <= uiDiff)
{
switch(uiPhase)
{
case 1:
if (Creature* pGuard = m_creature->FindNearestCreature(NPC_STORMWIND_ROYAL, 8.0f, true))
DoScriptText(SAY_GUARD_2, pGuard);
uiTimer = 3000;
uiPhase = 2;
break;
case 2:
DoGuardsDisappearAndDie();
uiTimer = 2000;
uiPhase = 3;
break;
case 3:
SetEscortPaused(false);
uiTimer = 0;
uiPhase = 0;
break;
case 4:
DoScriptText(SAY_LESCOVAR_3, m_creature);
uiTimer = 0;
uiPhase = 0;
break;
case 5:
if (pMarzon)
DoScriptText(SAY_MARZON_1, pMarzon);
uiTimer = 3000;
uiPhase = 6;
break;
case 6:
DoScriptText(SAY_LESCOVAR_4, m_creature);
if (Player* pPlayer = GetPlayerForEscort())
pPlayer->AreaExploredOrEventHappens(QUEST_THE_ATTACK);
uiTimer = 2000;
uiPhase = 7;
break;
case 7:
if (Creature* pTyrion = m_creature->FindNearestCreature(NPC_TYRION, 20.0f, true))
DoScriptText(SAY_TYRION_2, pTyrion);
if (pMarzon)
pMarzon->setFaction(14);
m_creature->setFaction(14);
uiTimer = 0;
uiPhase = 0;
break;
}
} else uiTimer -= uiDiff;
}
npc_escortAI::UpdateAI(uiDiff);
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (EventInProgress) {
Player* pWarrior = NULL;
if (PlayerGUID)
pWarrior = Unit::GetPlayer(*me, PlayerGUID);
if (!pWarrior)
return;
if (!pWarrior->isAlive() && pWarrior->GetQuestStatus(1719) == QUEST_STATUS_INCOMPLETE) {
Talk(SAY_TWIGGY_FLATHEAD_DOWN);
pWarrior->FailQuest(1719);
for (uint8 i = 0; i < 6; ++i) // unsummon challengers
{
if (AffrayChallenger[i])
{
Creature* creature = Unit::GetCreature((*me), AffrayChallenger[i]);
if (creature && creature->isAlive())
creature->DisappearAndDie();
}
}
if (BigWill) // unsummon bigWill
{
Creature* creature = Unit::GetCreature((*me), BigWill);
if (creature && creature->isAlive())
creature->DisappearAndDie();
}
Reset();
}
if (!EventGrate && EventInProgress)
{
float x, y, z;
pWarrior->GetPosition(x, y, z);
if (x >= -1684 && x <= -1674 && y >= -4334 && y <= -4324) {
pWarrior->AreaExploredOrEventHappens(1719);
Talk(SAY_TWIGGY_FLATHEAD_BEGIN, pWarrior->GetGUID());
for (uint8 i = 0; i < 6; ++i)
{
Creature* creature = me->SummonCreature(NPC_AFFRAY_CHALLENGER, AffrayChallengerLoc[i], TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 600000);
if (!creature)
continue;
creature->setFaction(35);
creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
creature->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
AffrayChallenger[i] = creature->GetGUID();
}
WaveTimer = 5000;
ChallengerChecker = 1000;
EventGrate = true;
}
}
else if (EventInProgress)
{
if (ChallengerChecker <= diff)
{
for (uint8 i = 0; i < 6; ++i)
{
if (AffrayChallenger[i])
{
Creature* creature = Unit::GetCreature((*me), AffrayChallenger[i]);
if ((!creature || (!creature->isAlive())) && !ChallengerDown[i])
{
Talk(SAY_TWIGGY_FLATHEAD_DOWN);
ChallengerDown[i] = true;
}
}
}
ChallengerChecker = 1000;
} else ChallengerChecker -= diff;
if (WaveTimer <= diff)
{
if (Wave < 6 && AffrayChallenger[Wave] && !EventBigWill)
{
Talk(SAY_TWIGGY_FLATHEAD_FRAY);
Creature* creature = Unit::GetCreature((*me), AffrayChallenger[Wave]);
if (creature && (creature->isAlive()))
{
creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
creature->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
creature->setFaction(14);
creature->AI()->AttackStart(pWarrior);
++Wave;
WaveTimer = 20000;
}
}
else if (Wave >= 6 && !EventBigWill) {
if (Creature* creature = me->SummonCreature(NPC_BIG_WILL, -1722, -4341, 6.12f, 6.26f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 480000))
{
BigWill = creature->GetGUID();
//creature->GetMotionMaster()->MovePoint(0, -1693, -4343, 4.32f);
//creature->GetMotionMaster()->MovePoint(1, -1684, -4333, 2.78f);
creature->GetMotionMaster()->MovePoint(2, -1682, -4329, 2.79f);
creature->HandleEmoteCommand(EMOTE_STATE_READY_UNARMED);
EventBigWill = true;
WaveTimer = 1000;
}
}
else if (Wave >= 6 && EventBigWill && BigWill)
{
Creature* creature = Unit::GetCreature((*me), BigWill);
if (!creature || !creature->isAlive())
{
Talk(SAY_TWIGGY_FLATHEAD_OVER);
Reset();
}
}
} else WaveTimer -= diff;
}
}
}
void UpdateAI(const uint32 diff)
{
if(!m_creature->SelectHostileTarget() || !m_creature->getVictim() )
return;
if (MovementInform_id >= 0)
{
Moving = false;
m_creature->SetLevitate(false);
switch (MovementInform_id)
{
case 0:
case 1:
case 2:
case 3:
Platforms_Move_Timer = 30000+rand()%5000;
break;
case 4:
DoCast(m_creature, SPELL_FLAME_QUILLS);
FlameQuillsDuration_Timer = 10000;
FlameQuills = true;
break;
case 5:
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_creature->SetVisibility(VISIBILITY_ON);
DoCast(m_creature, SPELL_REBIRTH);
Phase2_begin = true;
FakeDeath = false;
break;
case 6:
m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FIRE, false);
m_creature->SetFloatValue(OBJECT_FIELD_SCALE_X, DefaultSize/4.0f);
DoCast(m_creature->getVictim(), SPELL_DIVE_BOMB_VISUAL);
DiveBombCastDelay_Timer = 4000;
break;
case 7:
m_creature->SetSpeedRate(MOVE_RUN, DefaultMoveSpeedRate);
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_creature->SetUInt32Value(UNIT_FIELD_DISPLAYID, DefaultModel);
m_creature->SetVisibility(VISIBILITY_OFF); // I know, that this sequence of commands looks stupid, but without it visual effect of Rebirth
m_creature->SetVisibility(VISIBILITY_ON); // after Dive Bomb looks not perfect (Al'ar appears, and than again disappears and cast Rebirth).
DoCast(m_creature, SPELL_REBIRTH_2);
DiveBombCastDelay_Timer = 9999999;
FlameBuffetAfterDiveBomb = true;
DiveBomb_Timer = 40000+rand()%5000;
FlameBuffet_Timer = 5000;
m_creature->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
m_creature->ApplySpellImmune(0, IMMUNITY_EFFECT,SPELL_EFFECT_ATTACK_ME, false);
break;
}
m_creature->GetMotionMaster()->Clear();
m_creature->GetMotionMaster()->MoveIdle();
MovementInform_id = -1;
}
if (Charge)
{
if (ChargeDelay_Timer < diff)
{
if (Charge_target)
{
m_creature->getThreatManager().modifyThreatPercent(Charge_target, -100);
m_creature->getThreatManager().addThreat(Charge_target, Charge_target_threat);
}
Charge = false;
m_creature->SetSpeedRate(MOVE_RUN, DefaultMoveSpeedRate);
ChargeDelay_Timer = 2000;
}
else
ChargeDelay_Timer -= diff;
return;
}
if (!Phase1)
if (Enrage_Timer < diff)
{
DoCast(m_creature, SPELL_ENRAGE);
Enrage_Timer = 600000;
}else Enrage_Timer -= diff;
if (Moving)
return;
if (CorpseDisappear_Timer < diff)
{
m_creature->SetVisibility(VISIBILITY_OFF);
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
m_creature->SetHealth(m_creature->GetMaxHealth());
CreaturePointMove(5, waypoint[5][0], waypoint[5][1], waypoint[5][2]);
CorpseDisappear_Timer = 9999999;
}else CorpseDisappear_Timer -= diff;
if (FakeDeath)
return;
if (Phase2_begin)
{
m_creature->GetMotionMaster()->Clear();
m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
MeltArmor_Timer = 60000;
Charge_Timer = 7000;
DiveBomb_Timer = 40000+rand()%5000;
DiveBombCastDelay_Timer = 9999999;
FlameBuffet_Timer = 9999999;
FlamePatch_Timer = 30000;
Phase2_begin = false;
Phase1 = false;
if(pInstance)
pInstance->SetData(TYPE_ALAR, SPECIAL);
}
if (Phase1)
{
if (FlameQuills) {
if (FlameQuillsDuration_Timer < diff)
{
switch(rand()%2)
{
case 0:
cur_wp = 0;
break;
case 1:
cur_wp = 3;
break;
}
CreaturePointMove(cur_wp, waypoint[cur_wp][0], waypoint[cur_wp][1], waypoint[cur_wp][2]);
FlameQuills = false;
}else FlameQuillsDuration_Timer -= diff;
return;
}
if (Platforms_Move_Timer < diff)
{
Creature* Summoned = NULL;
Summoned = m_creature->SummonCreature(CREATURE_EMBER_OF_ALAR, waypoint[cur_wp][0], waypoint[cur_wp][1], waypoint[cur_wp][2], 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
if (Summoned)
{
Unit* target = NULL;
target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0);
if (target)
Summoned->AI()->AttackStart(target);
}
if (rand()%100 <= 20)
{
cur_wp = 4;
FlameQuills = true;
} else
{
cur_wp++;
if (cur_wp == 4)
cur_wp = 0;
}
CreaturePointMove(cur_wp, waypoint[cur_wp][0], waypoint[cur_wp][1], waypoint[cur_wp][2]);
}else Platforms_Move_Timer -= diff;
if (FlameBuffet_Timer < diff)
{
bool InMeleeRange = false;
ThreatList const& tList = m_creature->getThreatManager().getThreatList();
for (ThreatList::const_iterator itr = tList.begin();itr != tList.end(); ++itr)
{
Unit* pUnit = NULL;
pUnit = m_creature->GetMap()->GetUnit((*itr)->getUnitGuid());
if (pUnit)
if (m_creature->IsWithinDistInMap(pUnit, 5))
{
InMeleeRange = true;
m_creature->getThreatManager().addThreat(pUnit, 2.0f);
break;
}else
m_creature->getThreatManager().modifyThreatPercent(pUnit, -100);
}
if (!InMeleeRange)
DoCast(m_creature, SPELL_FLAME_BUFFET);
FlameBuffet_Timer = 1500;
}else FlameBuffet_Timer -= diff;
} else
{
if (FlameBuffetAfterDiveBomb)
{
if (FlameBuffet_Timer < diff)
{
if (m_creature->IsWithinDistInMap(m_creature->getVictim(), 5))
{
m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
FlameBuffetAfterDiveBomb = false;
FlameBuffet_Timer = 9999999;
} else
{
DoCast(m_creature, SPELL_FLAME_BUFFET);
FlameBuffet_Timer = 1500;
}
} else FlameBuffet_Timer -= diff;
} else
{
if (MeltArmor_Timer < diff)
{
DoCast(m_creature->getVictim(), SPELL_MELT_ARMOR);
MeltArmor_Timer = 60000;
}else MeltArmor_Timer -= diff;
if (Charge_Timer < diff)
{
Charge_target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 1);
if (Charge_target)
{
m_creature->SetInFront(Charge_target);
Charge_target_threat = m_creature->getThreatManager().getThreat(Charge_target);
m_creature->getThreatManager().addThreat(Charge_target, 100000000.0f);
m_creature->SetSpeedRate(MOVE_RUN, DefaultMoveSpeedRate*5.0f);
DoCast(Charge_target, SPELL_CHARGE);
ChargeDelay_Timer = 2000;
Charge = true;
}
Charge_Timer = 30000;
}else Charge_Timer -= diff;
}
if (DiveBomb_Timer < diff)
{
m_creature->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
m_creature->ApplySpellImmune(0, IMMUNITY_EFFECT,SPELL_EFFECT_ATTACK_ME, true);
CreaturePointMove(6, waypoint[4][0], waypoint[4][1], waypoint[4][2]);
DiveBomb_Timer = 40000+rand()%5000;
}else DiveBomb_Timer -= diff;
if (DiveBombCastDelay_Timer < diff)
{
m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FIRE, true);
m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_creature->SetUInt32Value(UNIT_FIELD_DISPLAYID, 11686);
Unit* target = NULL;
target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0);
DoCast(target, SPELL_DIVE_BOMB);
m_creature->SetFloatValue(OBJECT_FIELD_SCALE_X, DefaultSize);
m_creature->RemoveAurasDueToSpell(SPELL_DIVE_BOMB_VISUAL);
m_creature->SetSpeedRate(MOVE_RUN, DefaultMoveSpeedRate*2.0f);
if (target)
CreaturePointMove(7, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ());
Creature* Summoned = NULL;
for (int8 i=1; i<=2; i++)
if (target)
{
Summoned = m_creature->SummonCreature(CREATURE_EMBER_OF_ALAR, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
if (Summoned)
{
Unit* target1 = NULL;
target1 = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0);
if (target1)
Summoned->AI()->AttackStart(target1);
}
}
DiveBombCastDelay_Timer = 9999999;
}else DiveBombCastDelay_Timer -= diff;
if (FlamePatch_Timer < diff)
{
Unit* target = NULL;
target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0);
if (target)
{
Creature* Summoned = NULL;
Summoned = m_creature->SummonCreature(CREATURE_FLAME_PATCH_ALAR, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 120000);
if (Summoned)
{
Summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
Summoned->SetFloatValue(OBJECT_FIELD_SCALE_X, Summoned->GetFloatValue(OBJECT_FIELD_SCALE_X)*2.9f);
Summoned->SetUInt32Value(UNIT_FIELD_DISPLAYID, 11686);
Summoned->setFaction(m_creature->getFaction());
Summoned->SetLevel(m_creature->getLevel());
Summoned->CastSpell(Summoned, SPELL_FLAME_PATCH, false);
}
}
FlamePatch_Timer = 30000;
}else FlamePatch_Timer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!me->IsInCombat()) // sometimes IsInCombat but !incombat, faction bug?
return;
if (Berserk_Timer <= diff)
{
DoCast(me, SPELL_BERSERK, true);
Berserk_Timer = 60000;
}
else
Berserk_Timer -= diff;
if (ForceMove)
{
if (ForceTimer <= diff)
{
me->GetMotionMaster()->MovePoint(0, waypoint[cur_wp][0], waypoint[cur_wp][1], waypoint[cur_wp][2]);
ForceTimer = 5000;
}
else
ForceTimer -= diff;
}
if (WaitEvent)
{
if (WaitTimer)
{
if (WaitTimer <= diff)
{
if (AfterMoving)
{
me->GetMotionMaster()->MoveIdle();
AfterMoving = false;
}
switch (WaitEvent)
{
case WE_PLATFORM:
Platforms_Move_Timer = 30000 + rand32() % 5000;
break;
case WE_QUILL:
DoCast(me, SPELL_FLAME_QUILLS, true);
Platforms_Move_Timer = 1;
WaitTimer = 10000;
WaitEvent = WE_DUMMY;
return;
case WE_DIE:
ForceMove = false;
me->SetStandState(UNIT_STAND_STATE_DEAD);
WaitTimer = 5000;
WaitEvent = WE_REVIVE;
return;
case WE_REVIVE:
me->SetStandState(UNIT_STAND_STATE_STAND);
me->SetFullHealth();
me->SetSpeedRate(MOVE_RUN, DefaultMoveSpeedRate);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
DoZoneInCombat();
DoCast(me, SPELL_REBIRTH, true);
MeltArmor_Timer = 60000;
Charge_Timer = 7000;
DiveBomb_Timer = 40000 + rand32() % 5000;
FlamePatch_Timer = 30000;
Phase1 = false;
break;
case WE_METEOR:
me->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FIRE, false);
DoCast(me, SPELL_DIVE_BOMB_VISUAL, false);
WaitEvent = WE_DIVE;
WaitTimer = 4000;
return;
case WE_DIVE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
me->RemoveAurasDueToSpell(SPELL_DIVE_BOMB_VISUAL);
DoCast(target, SPELL_DIVE_BOMB, true);
float dist = 3.0f;
if (me->IsWithinDist3d(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 5.0f))
dist = 5.0f;
WaitTimer = 1000 + uint32(floor(dist / 80 * 1000.0f));
me->SetPosition(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0.0f);
me->StopMoving();
WaitEvent = WE_LAND;
return;
}
else
{
EnterEvadeMode();
return;
}
case WE_LAND:
WaitEvent = WE_SUMMON;
WaitTimer = 2000;
return;
case WE_SUMMON:
for (uint8 i = 0; i < 2; ++i)
DoSpawnCreature(CREATURE_EMBER_OF_ALAR, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, 10);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetDisplayId(me->GetNativeDisplayId());
DoCast(me, SPELL_REBIRTH_2, true);
break;
case WE_DUMMY:
default:
break;
}
WaitEvent = WE_NONE;
WaitTimer = 0;
}
else
WaitTimer -= diff;
}
return;
}
if (Phase1)
{
if (me->getThreatManager().getThreatList().empty())
{
EnterEvadeMode();
return;
}
if (Platforms_Move_Timer <= diff)
{
if (cur_wp == 4)
{
cur_wp = 0;
WaitEvent = WE_PLATFORM;
}
else
{
if (urand(0, 4)) // next platform
{
DoSpawnCreature(CREATURE_EMBER_OF_ALAR, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
if (cur_wp == 3)
cur_wp = 0;
else
++cur_wp;
WaitEvent = WE_PLATFORM;
}
else // flame quill
{
cur_wp = 4;
WaitEvent = WE_QUILL;
}
}
ForceMove = true;
ForceTimer = 5000;
me->GetMotionMaster()->MovePoint(0, waypoint[cur_wp][0], waypoint[cur_wp][1], waypoint[cur_wp][2]);
WaitTimer = 0;
return;
}
else
Platforms_Move_Timer -= diff;
}
else
{
if (Charge_Timer <= diff)
{
Unit* target= SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true);
if (target)
DoCast(target, SPELL_CHARGE);
Charge_Timer = 30000;
}
else
Charge_Timer -= diff;
if (MeltArmor_Timer <= diff)
{
DoCastVictim(SPELL_MELT_ARMOR);
MeltArmor_Timer = 60000;
}
else
MeltArmor_Timer -= diff;
if (DiveBomb_Timer <= diff)
{
me->AttackStop();
me->GetMotionMaster()->MovePoint(6, waypoint[4][0], waypoint[4][1], waypoint[4][2]);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, 50);
WaitEvent = WE_METEOR;
WaitTimer = 0;
DiveBomb_Timer = 40000 + rand32() % 5000;
return;
}
else
DiveBomb_Timer -= diff;
if (FlamePatch_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
Creature* Summoned = me->SummonCreature(CREATURE_FLAME_PATCH_ALAR, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 120000);
if (Summoned)
{
Summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Summoned->SetObjectScale(Summoned->GetObjectScale() * 2.5f);
Summoned->SetDisplayId(11686);
Summoned->setFaction(me->getFaction());
Summoned->SetLevel(me->getLevel());
Summoned->CastSpell(Summoned, SPELL_FLAME_PATCH, false);
}
}
FlamePatch_Timer = 30000;
}
else
FlamePatch_Timer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
if (EnfeebleResetTimer && EnfeebleResetTimer <= diff) // Let's not forget to reset that
{
EnfeebleResetHealth();
EnfeebleResetTimer = 0;
} else EnfeebleResetTimer -= diff;
if (me->HasUnitState(UNIT_STATE_STUNNED)) // While shifting to phase 2 malchezaar stuns himself
return;
if (me->GetVictim() && me->GetTarget() != me->EnsureVictim()->GetGUID())
me->SetTarget(me->EnsureVictim()->GetGUID());
if (phase == 1)
{
if (HealthBelowPct(60))
{
me->InterruptNonMeleeSpells(false);
phase = 2;
//animation
DoCast(me, SPELL_EQUIP_AXES);
//text
Talk(SAY_AXE_TOSS1);
//passive thrash aura
DoCast(me, SPELL_THRASH_AURA, true);
//models
SetEquipmentSlots(false, EQUIP_ID_AXE, EQUIP_ID_AXE, EQUIP_NO_CHANGE);
me->SetBaseAttackTime(OFF_ATTACK, (me->GetBaseAttackTime(BASE_ATTACK)*150)/100);
me->SetCanDualWield(true);
}
}
else if (phase == 2)
{
if (HealthBelowPct(30))
{
InfernalTimer = 15000;
phase = 3;
ClearWeapons();
//remove thrash
me->RemoveAurasDueToSpell(SPELL_THRASH_AURA);
Talk(SAY_AXE_TOSS2);
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
for (uint8 i = 0; i < 2; ++i)
{
Creature* axe = me->SummonCreature(MALCHEZARS_AXE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 1000);
if (axe)
{
axe->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
axe->setFaction(me->getFaction());
axes[i] = axe->GetGUID();
if (target)
{
axe->AI()->AttackStart(target);
//axe->getThreatManager().tauntApply(target); //Taunt Apply and fade out does not work properly
// So we'll use a hack to add a lot of threat to our target
axe->AddThreat(target, 10000000.0f);
}
}
}
if (ShadowNovaTimer > 35000)
ShadowNovaTimer = EnfeebleTimer + 5000;
return;
}
if (SunderArmorTimer <= diff)
{
DoCastVictim(SPELL_SUNDER_ARMOR);
SunderArmorTimer = urand(10000, 18000);
} else SunderArmorTimer -= diff;
if (Cleave_Timer <= diff)
{
DoCastVictim(SPELL_CLEAVE);
Cleave_Timer = urand(6000, 12000);
} else Cleave_Timer -= diff;
}
else
{
if (AxesTargetSwitchTimer <= diff)
{
AxesTargetSwitchTimer = urand(7500, 20000);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
{
for (uint8 i = 0; i < 2; ++i)
{
if (Unit* axe = ObjectAccessor::GetUnit(*me, axes[i]))
{
if (axe->GetVictim())
DoModifyThreatPercent(axe->GetVictim(), -100);
if (target)
axe->AddThreat(target, 1000000.0f);
//axe->getThreatManager().tauntFadeOut(axe->GetVictim());
//axe->getThreatManager().tauntApply(target);
}
}
}
} else AxesTargetSwitchTimer -= diff;
if (AmplifyDamageTimer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_AMPLIFY_DAMAGE);
AmplifyDamageTimer = urand(20000, 30000);
} else AmplifyDamageTimer -= diff;
}
//Time for global and double timers
if (InfernalTimer <= diff)
{
SummonInfernal(diff);
InfernalTimer = phase == 3 ? 14500 : 44500; // 15 secs in phase 3, 45 otherwise
} else InfernalTimer -= diff;
if (ShadowNovaTimer <= diff)
{
DoCastVictim(SPELL_SHADOWNOVA);
ShadowNovaTimer = phase == 3 ? 31000 : uint32(-1);
} else ShadowNovaTimer -= diff;
if (phase != 2)
{
if (SWPainTimer <= diff)
{
Unit* target = NULL;
if (phase == 1)
target = me->GetVictim(); // the tank
else // anyone but the tank
target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true);
if (target)
DoCast(target, SPELL_SW_PAIN);
SWPainTimer = 20000;
} else SWPainTimer -= diff;
}
if (phase != 3)
{
if (EnfeebleTimer <= diff)
{
EnfeebleHealthEffect();
EnfeebleTimer = 30000;
ShadowNovaTimer = 5000;
EnfeebleResetTimer = 9000;
} else EnfeebleTimer -= diff;
}
if (phase == 2)
DoMeleeAttacksIfReady();
else
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
if (m_uiEnfeebleResetTimer)
{
if (m_uiEnfeebleResetTimer <= uiDiff) //Let's not forget to reset that
{
EnfeebleResetHealth();
m_uiEnfeebleResetTimer=0;
}
else
m_uiEnfeebleResetTimer -= uiDiff;
}
if (m_creature->hasUnitState(UNIT_STAT_STUNNED)) //While shifting to m_uiPhase 2 m_malchezaarGuid stuns himself
return;
if (m_creature->GetTargetGuid() != m_creature->getVictim()->GetObjectGuid())
m_creature->SetTargetGuid(m_creature->getVictim()->GetObjectGuid());
if (m_uiPhase == 1)
{
if (m_creature->GetHealthPercent() < 60.0f)
{
m_creature->InterruptNonMeleeSpells(false);
m_uiPhase = 2;
//animation
DoCastSpellIfCan(m_creature, SPELL_EQUIP_AXES);
//text
DoScriptText(SAY_AXE_TOSS1, m_creature);
//passive thrash aura
m_creature->CastSpell(m_creature, SPELL_THRASH_AURA, true);
//models
SetEquipmentSlots(false, EQUIP_ID_AXE, EQUIP_ID_AXE, EQUIP_NO_CHANGE);
//damage
const CreatureInfo *cinfo = m_creature->GetCreatureInfo();
m_creature->SetBaseWeaponDamage(BASE_ATTACK, MINDAMAGE, 2*cinfo->mindmg);
m_creature->SetBaseWeaponDamage(BASE_ATTACK, MAXDAMAGE, 2*cinfo->maxdmg);
m_creature->UpdateDamagePhysical(BASE_ATTACK);
m_creature->SetBaseWeaponDamage(OFF_ATTACK, MINDAMAGE, cinfo->mindmg);
m_creature->SetBaseWeaponDamage(OFF_ATTACK, MAXDAMAGE, cinfo->maxdmg);
//Sigh, updating only works on main attack , do it manually ....
m_creature->SetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE, cinfo->mindmg);
m_creature->SetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE, cinfo->maxdmg);
m_creature->SetAttackTime(OFF_ATTACK, (m_creature->GetAttackTime(BASE_ATTACK)*150)/100);
}
}
else if (m_uiPhase == 2)
{
if (m_creature->GetHealthPercent() < 30.0f)
{
InfernalTimer = 15000;
m_uiPhase = 3;
ClearWeapons();
//remove thrash
m_creature->RemoveAurasDueToSpell(SPELL_THRASH_AURA);
DoScriptText(SAY_AXE_TOSS2, m_creature);
Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0);
for (uint32 i = 0; i < 2; ++i)
{
Creature* pAxe = m_creature->SummonCreature(MALCHEZARS_AXE, m_creature->GetPositionX(), m_creature->GetPositionY(), m_creature->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 1000);
if (pAxe)
{
pAxe->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pAxe->setFaction(m_creature->getFaction());
m_aAxeGuid[i] = pAxe->GetObjectGuid();
if (pTarget)
{
pAxe->AI()->AttackStart(pTarget);
// pAxe->getThreatManager().tauntApply(pTarget); //Taunt Apply and fade out does not work properly
// So we'll use a hack to add a lot of threat to our pTarget
pAxe->AddThreat(pTarget, 10000000.0f);
}
}
}
if (m_uiShadowNovaTimer > 35000)
m_uiShadowNovaTimer = m_uiEnfeebleTimer + 5000;
return;
}
if (SunderArmorTimer < uiDiff)
{
DoCastSpellIfCan(m_creature->getVictim(), SPELL_SUNDER_ARMOR);
SunderArmorTimer = urand(10000, 18000);
}
else
SunderArmorTimer -= uiDiff;
if (m_uiCleave_Timer < uiDiff)
{
DoCastSpellIfCan(m_creature->getVictim(), SPELL_CLEAVE);
m_uiCleave_Timer = urand(6000, 12000);
}
else
m_uiCleave_Timer -= uiDiff;
}
else
{
if (m_uiAxesTargetSwitchTimer < uiDiff)
{
m_uiAxesTargetSwitchTimer = urand(7500, 20000);
Unit *target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0);
if (target)
{
for(int i = 0; i < 2; ++i)
{
Creature *axe = m_creature->GetMap()->GetCreature(m_aAxeGuid[i]);
if (axe)
{
float threat = 1000000.0f;
if (axe->getVictim() && m_creature->getThreatManager().getThreat(axe->getVictim()))
{
threat = axe->getThreatManager().getThreat(axe->getVictim());
axe->getThreatManager().modifyThreatPercent(axe->getVictim(), -100);
}
if (target)
axe->AddThreat(target, threat);
//axe->getThreatManager().tauntFadeOut(axe->getVictim());
//axe->getThreatManager().tauntApply(target);
}
}
}
}
else
m_uiAxesTargetSwitchTimer -= uiDiff;
if (m_uiAmplifyDamageTimer < uiDiff)
{
if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
DoCastSpellIfCan(pTarget, SPELL_AMPLIFY_DAMAGE);
m_uiAmplifyDamageTimer = urand(20000, 30000);
}
else
m_uiAmplifyDamageTimer -= uiDiff;
}
//Time for global and double timers
if (InfernalTimer < uiDiff)
{
SummonInfernal();
InfernalTimer = m_uiPhase == 3 ? 14500 : 44500; //15 secs in m_uiPhase 3, 45 otherwise
}
else
InfernalTimer -= uiDiff;
if (m_uiShadowNovaTimer < uiDiff)
{
DoCastSpellIfCan(m_creature->getVictim(), SPELL_SHADOWNOVA);
m_uiShadowNovaTimer = m_uiPhase == 3 ? 31000 : -1;
}
else
m_uiShadowNovaTimer -= uiDiff;
if (m_uiPhase != 2)
{
if (m_uiSWPainTimer < uiDiff)
{
Unit* target = NULL;
if (m_uiPhase == 1)
target = m_creature->getVictim(); // the tank
else //anyone but the tank
target = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 1);
if (target)
DoCastSpellIfCan(target, SPELL_SW_PAIN);
m_uiSWPainTimer = 20000;
}
else
m_uiSWPainTimer -= uiDiff;
}
if (m_uiPhase != 3)
{
if (m_uiEnfeebleTimer < uiDiff)
{
EnfeebleHealthEffect();
m_uiEnfeebleTimer = 30000;
m_uiShadowNovaTimer = 5000;
m_uiEnfeebleResetTimer = 9000;
}
else
m_uiEnfeebleTimer -= uiDiff;
}
if (m_uiPhase==2)
DoMeleeAttacksIfReady();
else
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
ConstructTimer += diff;
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_JET:
me->MonsterTextEmote(EMOTE_JETS, 0, true);
DoCastAOE(SPELL_FLAME_JETS);
events.ScheduleEvent(EVENT_JET, urand(35000,40000));
break;
case EVENT_SLAG_POT:
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true))
{
DoScriptText(SAY_SLAG_POT, me);
SlagPotGUID = pTarget->GetGUID();
DoCast(pTarget, SPELL_GRAB);
events.DelayEvents(3000);
events.ScheduleEvent(EVENT_GRAB_POT, 500);
}
events.ScheduleEvent(EVENT_SLAG_POT, RAID_MODE(30000, 15000));
break;
case EVENT_GRAB_POT:
if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))
{
SlagPotTarget->EnterVehicle(me, 0);
events.ScheduleEvent(EVENT_CHANGE_POT, 1000);
}
break;
case EVENT_CHANGE_POT:
if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))
{
SlagPotTarget->AddAura(SPELL_SLAG_POT, SlagPotTarget);
SlagPotTarget->ChangeSeat(1);
events.ScheduleEvent(EVENT_END_POT, 10000);
}
break;
case EVENT_END_POT:
if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))
{
SlagPotTarget->ExitVehicle();
SlagPotTarget = NULL;
SlagPotGUID = NULL;
}
break;
case EVENT_SCORCH:
DoScriptText(RAND(SAY_SCORCH_1, SAY_SCORCH_2), me);
if (Unit *pTarget = me->getVictim())
me->SummonCreature(NPC_SCORCH_GROUND,pTarget->GetPositionX(),pTarget->GetPositionY(),pTarget->GetPositionZ(),0,TEMPSUMMON_TIMED_DESPAWN,45000);
DoCast(SPELL_SCORCH);
events.ScheduleEvent(EVENT_SCORCH, 25000);
break;
case EVENT_CONSTRUCT:
if (!construct_list.empty())
{
std::vector<Creature*>::iterator itr = (construct_list.begin()+rand()%construct_list.size());
Creature* pTarget = *itr;
if (pTarget)
{
DoScriptText(SAY_SUMMON, me);
DoCast(me, SPELL_STRENGHT, true);
DoCast(SPELL_ACTIVATE_CONSTRUCT);
pTarget->setFaction(16);
pTarget->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
construct_list.erase(itr);
}
}
events.ScheduleEvent(EVENT_CONSTRUCT, RAID_MODE(40000, 30000));
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
DoScriptText(SAY_BERSERK, me);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (CloseDoorTimer)
{
if (CloseDoorTimer <= diff)
{
if (pInstance)
{
pInstance->HandleGameObject(pInstance->GetData64(DATA_GO_LIBRARY_DOOR), false);
CloseDoorTimer = 0;
}
}
else CloseDoorTimer -= diff;
}
//Cooldowns for casts
if (ArcaneCooldown)
{
if (ArcaneCooldown >= diff)
ArcaneCooldown -= diff;
else ArcaneCooldown = 2000;
}
if (FireCooldown)
{
if (FireCooldown >= diff)
FireCooldown -= diff;
else FireCooldown = 2000;
}
if (FrostCooldown)
{
if (FrostCooldown >= diff)
FrostCooldown -= diff;
else FrostCooldown = 2000;
}
if (!Drinking && me->GetMaxPower(POWER_MANA) && (me->GetPower(POWER_MANA) * 100 / me->GetMaxPower(POWER_MANA)) < 20)
{
Drinking = true;
me->InterruptNonMeleeSpells(false);
DoScriptText(SAY_DRINK, me);
if (!DrinkInturrupted)
{
DoCast(me, SPELL_MASS_POLY, true);
DoCast(me, SPELL_CONJURE, false);
DoCast(me, SPELL_DRINK, false);
me->SetStandState(UNIT_STAND_STATE_SIT);
DrinkInturruptTimer = 10000;
}
}
//Drink Inturrupt
if (Drinking && DrinkInturrupted)
{
Drinking = false;
me->RemoveAurasDueToSpell(SPELL_DRINK);
me->SetStandState(UNIT_STAND_STATE_STAND);
me->SetPower(POWER_MANA, me->GetMaxPower(POWER_MANA) - 32000);
DoCast(me, SPELL_POTION, false);
}
//Drink Inturrupt Timer
if (Drinking && !DrinkInturrupted)
if (DrinkInturruptTimer >= diff)
DrinkInturruptTimer -= diff;
else
{
me->SetStandState(UNIT_STAND_STATE_STAND);
DoCast(me, SPELL_POTION, true);
DoCast(me, SPELL_AOE_PYROBLAST, false);
DrinkInturrupted = true;
Drinking = false;
}
//Don't execute any more code if we are drinking
if (Drinking)
return;
//Normal casts
if (NormalCastTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
if (!target)
return;
uint32 Spells[3];
uint8 AvailableSpells = 0;
//Check for what spells are not on cooldown
if (!ArcaneCooldown)
{
Spells[AvailableSpells] = SPELL_ARCMISSLE;
++AvailableSpells;
}
if (!FireCooldown)
{
Spells[AvailableSpells] = SPELL_FIREBALL;
++AvailableSpells;
}
if (!FrostCooldown)
{
Spells[AvailableSpells] = SPELL_FROSTBOLT;
++AvailableSpells;
}
//If no available spells wait 1 second and try again
if (AvailableSpells)
{
CurrentNormalSpell = Spells[rand() % AvailableSpells];
SetImmune(false);
DoCast(target, CurrentNormalSpell);
}
}
NormalCastTimer = 2500;
}
else NormalCastTimer -= diff;
if (SecondarySpellTimer <= diff)
{
switch (urand(0, 1))
{
case 0:
DoCast(me, SPELL_AOE_CS);
break;
case 1:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_CHAINSOFICE);
break;
}
SecondarySpellTimer = urand(5000, 20000);
}
else SecondarySpellTimer -= diff;
if (SuperCastTimer <= diff)
{
uint8 Available[2];
switch (LastSuperSpell)
{
case SUPER_AE:
Available[0] = SUPER_FLAME;
Available[1] = SUPER_BLIZZARD;
break;
case SUPER_FLAME:
Available[0] = SUPER_AE;
Available[1] = SUPER_BLIZZARD;
break;
case SUPER_BLIZZARD:
Available[0] = SUPER_FLAME;
Available[1] = SUPER_AE;
break;
}
LastSuperSpell = Available[urand(0, 1)];
SetImmune(true);
switch (LastSuperSpell)
{
case SUPER_AE:
DoScriptText(RAND(SAY_EXPLOSION1, SAY_EXPLOSION2), me);
DoCast(me, SPELL_BLINK_CENTER, true);
DoCast(me, SPELL_PLAYERPULL, true);
DoCast(me, SPELL_MASSSLOW, true);
DoCast(SPELL_AEXPLOSION);
break;
case SUPER_FLAME:
DoScriptText(RAND(SAY_FLAMEWREATH1, SAY_FLAMEWREATH2), me);
FlameWreathTimer = 20000;
FlameWreathCheckTime = 500;
FlameWreathTarget[0] = 0;
FlameWreathTarget[1] = 0;
FlameWreathTarget[2] = 0;
FlameWreathEffect();
break;
case SUPER_BLIZZARD:
DoScriptText(RAND(SAY_BLIZZARD1, SAY_BLIZZARD2), me);
Creature* Blizzard = NULL;
Blizzard = me->SummonCreature(NPC_ARAN_BLIZZARD, -11179.080f, -1905.279f, 232.008f, 2.9f, TEMPSUMMON_TIMED_DESPAWN, 25000);
if (Blizzard)
{
Blizzard->SetInCombatWithZone();
Blizzard->setFaction(me->getFaction());
me->CastSpell(Blizzard, SPELL_SUMMON_BLIZZ, false);
Blizzard->CastSpell(Blizzard, SPELL_CIRCULAR_BLIZZARD, false);
Blizzard->GetMotionMaster()->MovePath(90000, false);
}
break;
}
SuperCastTimer = urand(35000, 40000);
}
else SuperCastTimer -= diff;
if (!ElementalsSpawned && me->GetHealth() * 100 / me->GetMaxHealth() < 40)
{
ElementalsSpawned = true;
Creature* ElementalOne = NULL;
Creature* ElementalTwo = NULL;
Creature* ElementalThree = NULL;
Creature* ElementalFour = NULL;
ElementalOne = me->SummonCreature(NPC_WATER_ELEMENTAL, -11168.1f, -1939.29f, 232.092f, 1.46f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 90000);
ElementalTwo = me->SummonCreature(NPC_WATER_ELEMENTAL, -11138.2f, -1915.38f, 232.092f, 3.00f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 90000);
ElementalThree = me->SummonCreature(NPC_WATER_ELEMENTAL, -11161.7f, -1885.36f, 232.092f, 4.59f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 90000);
ElementalFour = me->SummonCreature(NPC_WATER_ELEMENTAL, -11192.4f, -1909.36f, 232.092f, 6.19f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 90000);
if (ElementalOne)
{
Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (!pTarget)
return;
DoStartNoMovement(pTarget);
ElementalOne->SetInCombatWithZone();
ElementalOne->CombatStart(pTarget);
ElementalOne->setFaction(me->getFaction());
ElementalOne->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
ElementalOne->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FROST, true);
ElementalOne->SetModifierValue(UNIT_MOD_RESISTANCE_FROST, BASE_VALUE, 0);
}
if (ElementalTwo)
{
Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (!pTarget)
return;
DoStartNoMovement(pTarget);
ElementalTwo->SetInCombatWithZone();
ElementalTwo->CombatStart(pTarget);
ElementalTwo->setFaction(me->getFaction());
ElementalTwo->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
ElementalTwo->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FROST, true);
ElementalTwo->SetModifierValue(UNIT_MOD_RESISTANCE_FROST, BASE_VALUE, 0);
}
if (ElementalThree)
{
Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (!pTarget)
return;
DoStartNoMovement(pTarget);
ElementalThree->SetInCombatWithZone();
ElementalThree->CombatStart(pTarget);
ElementalThree->setFaction(me->getFaction());
ElementalThree->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
ElementalThree->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FROST, true);
ElementalThree->SetModifierValue(UNIT_MOD_RESISTANCE_FROST, BASE_VALUE, 0);
}
if (ElementalFour)
{
Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (!pTarget)
return;
DoStartNoMovement(pTarget);
ElementalFour->SetInCombatWithZone();
ElementalFour->CombatStart(pTarget);
ElementalFour->setFaction(me->getFaction());
ElementalFour->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
ElementalFour->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FROST, true);
ElementalFour->SetModifierValue(UNIT_MOD_RESISTANCE_FROST, BASE_VALUE, 0);
}
DoScriptText(SAY_ELEMENTALS, me);
DoScriptText(SAY_TIMEOVER, me);
BerserkTimer = 60000;
}
else BerserkTimer -= diff;
//Flame Wreath check
if (FlameWreathTimer)
{
if (FlameWreathTimer >= diff)
FlameWreathTimer -= diff;
else FlameWreathTimer = 0;
if (FlameWreathCheckTime <= diff)
{
for (uint8 i = 0; i < 3; ++i)
{
if (!FlameWreathTarget[i])
continue;
Unit* unit = Unit::GetUnit(*me, FlameWreathTarget[i]);
if (unit && !unit->IsWithinDist2d(FWTargPosX[i], FWTargPosY[i], 3))
{
unit->CastSpell(unit, 20476, true, 0, 0, me->GetGUID());
unit->CastSpell(unit, 11027, true);
FlameWreathTarget[i] = 0;
}
}
FlameWreathCheckTime = 500;
}
else FlameWreathCheckTime -= diff;
}
if (ArcaneCooldown && FireCooldown && FrostCooldown)
DoMeleeAttackIfReady();
}
bool ChatHandler::HandleModifyFactionCommand(const char* args)
{
uint32 factionid;
uint32 flag;
uint32 npcflag;
uint32 dyflag;
char* pfactionid = strtok((char*)args, " ");
Creature* chr = getSelectedCreature();
if(!chr)
{
SendSysMessage(LANG_SELECT_CREATURE);
return true;
}
if(!pfactionid)
{
if(chr)
{
factionid = chr->getFaction();
flag = chr->GetUInt32Value(UNIT_FIELD_FLAGS);
npcflag = chr->GetUInt32Value(UNIT_NPC_FLAGS);
dyflag = chr->GetUInt32Value(UNIT_DYNAMIC_FLAGS);
PSendSysMessage(LANG_CURRENT_FACTION,chr->GetGUIDLow(),factionid,flag,npcflag,dyflag);
}
return true;
}
if (chr == NULL)
{
SendSysMessage(LANG_NO_CHAR_SELECTED);
return true;
}
factionid = atoi(pfactionid);
char *pflag = strtok(NULL, " ");
if (!pflag)
flag = chr->GetUInt32Value(UNIT_FIELD_FLAGS);
else
flag = atoi(pflag);
char* pnpcflag = strtok(NULL, " ");
if(!pnpcflag)
npcflag = chr->GetUInt32Value(UNIT_NPC_FLAGS);
else
npcflag = atoi(pnpcflag);
char* pdyflag = strtok(NULL, " ");
if(!pdyflag)
dyflag = chr->GetUInt32Value(UNIT_DYNAMIC_FLAGS);
else
dyflag = atoi(pdyflag);
if(!sFactionTemplateStore.LookupEntry(factionid))
{
PSendSysMessage(LANG_WRONG_FACTION, factionid);
return true;
}
PSendSysMessage(LANG_YOU_CHANGE_FACTION, chr->GetGUIDLow(),factionid,flag,npcflag,dyflag);
//sprintf((char*)buf,"%s changed your Faction to %i.", m_session->GetPlayer()->GetName(), factionid);
//FillSystemMessageData(&data, m_session, buf);
//chr->GetSession()->SendPacket(&data);
chr->setFaction(factionid);
chr->SetUInt32Value(UNIT_FIELD_FLAGS,flag);
chr->SetUInt32Value(UNIT_NPC_FLAGS,npcflag);
chr->SetUInt32Value(UNIT_DYNAMIC_FLAGS,dyflag);
return true;
}
void UpdateAI(const uint32 diff)
{
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
if (Razor_Phase_1 == 1)
{
m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_creature->GetMap()->CreatureRelocation(m_creature, -7595, -1053, 408, 0.0f);
DoCastSpellIfCan(m_creature,31366);
Razor_Phase_1 = 0;
}
if (Razor_Remove_Auras < diff)
{
Unit* target = NULL;
target = SelectUnit(SELECT_TARGET_RANDOM,0);
m_creature->AI()->AttackStart(target);
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_creature->RemoveAurasDueToSpell(31366);
Razor_Remove_Auras = 1000000;
}else Razor_Remove_Auras -= diff;
if (Razor_Phase_2 < diff)
{
//Cleave_Timer
if (Cleave_Timer < diff)
{
DoCastSpellIfCan(m_creature->getVictim(),SPELL_CLEAVE);
Cleave_Timer = urand(7000, 10000);
}else Cleave_Timer -= diff;
//WarStomp_Timer
if (WarStomp_Timer < diff)
{
DoCastSpellIfCan(m_creature->getVictim(),SPELL_WARSTOMP);
WarStomp_Timer = urand(15000, 25000);
}else WarStomp_Timer -= diff;
//FireballVolley_Timer
if (FireballVolley_Timer < diff)
{
DoCastSpellIfCan(m_creature->getVictim(),SPELL_FIREBALLVOLLEY);
FireballVolley_Timer = urand(12000, 15000);
}else FireballVolley_Timer -= diff;
//Conflagration_Timer
if (Conflagration_Timer < diff)
{
DoCastSpellIfCan(m_creature->getVictim(),SPELL_CONFLAGRATION);
Conflagration_Timer = 12000;
}else Conflagration_Timer -= diff;
// Aura Check. If the gamer is affected by confliguration we attack a random gamer.
if (m_creature->getVictim()->HasAura(SPELL_CONFLAGRATION,EFFECT_INDEX_0))
{
Unit* target = NULL;
target = SelectUnit(SELECT_TARGET_RANDOM,1);
if (target)
m_creature->TauntApply(target);
}
Razor_Phase_2 = 0;
} else Razor_Phase_2 -= diff;
if (SpawnedAdds < 42)
{
// spawn add
if (AddSpawnTimer < diff)
{
// Spawn North (40% Blackwing_Mage, 40% Blackwing_Leggionaire 20% Death_Talon_Dragonspawn)
switch(urand(0, 4))
{
case 0 :
SpawnType1 = BLACKWING_MAGE;
break;
case 1:
SpawnType1 = BLACKWING_MAGE;
break;
case 2 :
SpawnType1 = BLACKWING_LEGGIONAIRE;
break;
case 3:
SpawnType1 = BLACKWING_LEGGIONAIRE;
break;
case 4:
SpawnType1 = DEATH_TALON_DRAGONSPAWN;
break;
}
// Spawn South (40% Blackwing_Mage, 40% Blackwing_Leggionaire 20% Death_Talon_Dragonspawn)
switch(urand(0, 4))
{
case 0 :
SpawnType2 = BLACKWING_MAGE;
break;
case 1:
SpawnType2 = BLACKWING_MAGE;
break;
case 2 :
SpawnType2 = BLACKWING_LEGGIONAIRE;
break;
case 3:
SpawnType2 = BLACKWING_LEGGIONAIRE;
break;
case 4:
SpawnType2 = DEATH_TALON_DRAGONSPAWN;
break;
}
// Spawn East (40% Blackwing_Mage, 40% Blackwing_Leggionaire 20% Death_Talon_Dragonspawn)
switch(urand(0, 4))
{
case 0 :
SpawnType3 = BLACKWING_MAGE;
break;
case 1:
SpawnType3 = BLACKWING_MAGE;
break;
case 2 :
SpawnType3 = BLACKWING_LEGGIONAIRE;
break;
case 3:
SpawnType3 = BLACKWING_LEGGIONAIRE;
break;
case 4:
SpawnType3 = DEATH_TALON_DRAGONSPAWN;
break;
}
// Spawn West (40% Blackwing_Mage, 40% Blackwing_Leggionaire 20% Death_Talon_Dragonspawn)
switch(urand(0, 4))
{
case 0 :
SpawnType4 = BLACKWING_MAGE;
break;
case 1:
SpawnType4 = BLACKWING_MAGE;
break;
case 2 :
SpawnType4 = BLACKWING_LEGGIONAIRE;
break;
case 3:
SpawnType4 = BLACKWING_LEGGIONAIRE;
break;
case 4:
SpawnType4 = DEATH_TALON_DRAGONSPAWN;
break;
}
Creature* Spawned = NULL;
Unit* target = NULL;
++SpawnedAdds;
//Spawn creature and force it to start attacking a random target
Spawned = m_creature->SummonCreature(SpawnType1,SPAWN_X1,SPAWN_Y1,SPAWN_Z1,5.000,TEMPSUMMON_TIMED_DESPAWN,Despawn_Timer);
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target && Spawned)
{
Spawned->AI()->AttackStart(target);
Spawned->setFaction(103);
}
++SpawnedAdds;
//Spawn creature and force it to start attacking a random target
target = NULL;
Spawned = NULL;
Spawned = m_creature->SummonCreature(SpawnType2,SPAWN_X2,SPAWN_Y2,SPAWN_Z2,5.000,TEMPSUMMON_TIMED_DESPAWN,Despawn_Timer);
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target && Spawned)
{
Spawned->AI()->AttackStart(target);
Spawned->setFaction(103);
}
++SpawnedAdds;
//Spawn creature and force it to start attacking a random target
target = NULL;
Spawned = NULL;
Spawned = m_creature->SummonCreature(SpawnType3,SPAWN_X3,SPAWN_Y3,SPAWN_Z3,5.000,TEMPSUMMON_TIMED_DESPAWN,Despawn_Timer);
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target && Spawned)
{
Spawned->AI()->AttackStart(target);
Spawned->setFaction(103);
}
++SpawnedAdds;
//Spawn creature and force it to start attacking a random target
target = NULL;
Spawned = NULL;
Spawned = m_creature->SummonCreature(SpawnType4,SPAWN_X4,SPAWN_Y4,SPAWN_Z4,5.000,TEMPSUMMON_TIMED_DESPAWN,Despawn_Timer);
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target && Spawned)
{
Spawned->AI()->AttackStart(target);
Spawned->setFaction(103);
}
Despawn_Timer = Despawn_Timer-15000;
AddSpawnTimer = 15000;
} else AddSpawnTimer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (EventInProgress) {
Player* pWarrior = NULL;
if (PlayerGUID)
pWarrior = Unit::GetPlayer(PlayerGUID);
if (!pWarrior)
return;
if (!pWarrior->isAlive() && pWarrior->GetQuestStatus(1719) == QUEST_STATUS_INCOMPLETE) {
EventInProgress = false;
DoScriptText(SAY_TWIGGY_FLATHEAD_DOWN, me);
pWarrior->FailQuest(1719);
for (uint8 i = 0; i < 6; ++i)
{
if (AffrayChallenger[i])
{
Creature* pCreature = Unit::GetCreature((*me), AffrayChallenger[i]);
if (pCreature) {
if (pCreature->isAlive())
{
pCreature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
pCreature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pCreature->setDeathState(JUST_DIED);
}
}
}
AffrayChallenger[i] = 0;
Challenger_down[i] = false;
}
if (BigWill)
{
Creature* pCreature = Unit::GetCreature((*me), BigWill);
if (pCreature) {
if (pCreature->isAlive()) {
pCreature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
pCreature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pCreature->setDeathState(JUST_DIED);
}
}
}
BigWill = 0;
}
if (!EventGrate && EventInProgress)
{
float x,y,z;
pWarrior->GetPosition(x, y, z);
if (x >= -1684 && x <= -1674 && y >= -4334 && y <= -4324) {
pWarrior->AreaExploredOrEventHappens(1719);
DoScriptText(SAY_TWIGGY_FLATHEAD_BEGIN, me);
for (uint8 i = 0; i < 6; ++i)
{
Creature* pCreature = me->SummonCreature(NPC_AFFRAY_CHALLENGER, AffrayChallengerLoc[i][0], AffrayChallengerLoc[i][1], AffrayChallengerLoc[i][2], AffrayChallengerLoc[i][3], TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 600000);
if (!pCreature)
continue;
pCreature->setFaction(35);
pCreature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pCreature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
pCreature->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
AffrayChallenger[i] = pCreature->GetGUID();
}
Wave_Timer = 5000;
Challenger_checker = 1000;
EventGrate = true;
}
}
else if (EventInProgress)
{
if (Challenger_checker <= diff)
{
for (uint8 i = 0; i < 6; ++i)
{
if (AffrayChallenger[i])
{
Creature* pCreature = Unit::GetCreature((*me), AffrayChallenger[i]);
if ((!pCreature || (!pCreature->isAlive())) && !Challenger_down[i])
{
DoScriptText(SAY_TWIGGY_FLATHEAD_DOWN, me);
Challenger_down[i] = true;
}
}
}
Challenger_checker = 1000;
} else Challenger_checker -= diff;
if (Wave_Timer <= diff)
{
if (AffrayChallenger[Wave] && Wave < 6 && !EventBigWill)
{
DoScriptText(SAY_TWIGGY_FLATHEAD_FRAY, me);
Creature* pCreature = Unit::GetCreature((*me), AffrayChallenger[Wave]);
if (pCreature && (pCreature->isAlive()))
{
pCreature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pCreature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
pCreature->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
pCreature->setFaction(14);
pCreature->AI()->AttackStart(pWarrior);
++Wave;
Wave_Timer = 20000;
}
}
else if (Wave >= 6 && !EventBigWill) {
if (Creature* pCreature = me->SummonCreature(NPC_BIG_WILL, -1722, -4341, 6.12, 6.26, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 480000))
{
BigWill = pCreature->GetGUID();
//pCreature->GetMotionMaster()->MovePoint(0, -1693, -4343, 4.32);
//pCreature->GetMotionMaster()->MovePoint(1, -1684, -4333, 2.78);
pCreature->GetMotionMaster()->MovePoint(2, -1682, -4329, 2.79);
pCreature->HandleEmoteCommand(EMOTE_STATE_READYUNARMED);
EventBigWill = true;
Wave_Timer = 1000;
}
}
else if (Wave >= 6 && EventBigWill && BigWill)
{
Creature* pCreature = Unit::GetCreature((*me), BigWill);
if (!pCreature || !pCreature->isAlive())
{
DoScriptText(SAY_TWIGGY_FLATHEAD_OVER, me);
EventInProgress = false;
EventBigWill = false;
EventGrate = false;
PlayerGUID = 0;
Wave = 0;
}
}
} else Wave_Timer -= diff;
}
}
}
void UpdateAI(const uint32 diff)
{
//Only if not incombat check if the event is started
if (!me->isInCombat() && instance && instance->GetData(DATA_KARATHRESSEVENT))
{
Unit* target = Unit::GetUnit(*me, instance->GetData64(DATA_KARATHRESSEVENT_STARTER));
if (target)
{
AttackStart(target);
}
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (instance && !instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
//WaterBoltVolley_Timer
if (WaterBoltVolley_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_WATER_BOLT_VOLLEY);
WaterBoltVolley_Timer = 30000;
} else WaterBoltVolley_Timer -= diff;
//TidalSurge_Timer
if (TidalSurge_Timer <= diff)
{
DoCastAOE(SPELL_TIDAL_SURGE);
TidalSurge_Timer = 15000+rand()%5000;
} else TidalSurge_Timer -= diff;
//Cyclone_Timer
if (Cyclone_Timer <= diff)
{
//DoCast(me, SPELL_SUMMON_CYCLONE); // Doesn't work
Cyclone_Timer = 30000+rand()%10000;
Creature* Cyclone = me->SummonCreature(CREATURE_CYCLONE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), float(rand()%5), TEMPSUMMON_TIMED_DESPAWN, 15000);
if (Cyclone)
{
CAST_CRE(Cyclone)->SetObjectScale(3.0f);
Cyclone->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Cyclone->setFaction(me->getFaction());
Cyclone->CastSpell(Cyclone, SPELL_CYCLONE_CYCLONE, true);
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target)
{
Cyclone->AI()->AttackStart(target);
}
}
} else Cyclone_Timer -= diff;
//Heal_Timer
if (Heal_Timer <= diff)
{
// It can be cast on any of the mobs
Unit* unit = NULL;
while (unit == NULL || !unit->isAlive())
{
unit = selectAdvisorUnit();
}
if (unit && unit->isAlive())
DoCast(unit, SPELL_HEAL);
Heal_Timer = 60000;
} else Heal_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() )
return;
if(CloseDoorTimer)
{
if(CloseDoorTimer <= diff)
{
if(pInstance)
{
if(GameObject* Door = GameObject::GetGameObject(*m_creature, pInstance->GetData64(DATA_GAMEOBJECT_LIBRARY_DOOR)))
Door->SetGoState(1);
CloseDoorTimer = 0;
}
}else CloseDoorTimer -= diff;
}
//Cooldowns for casts
if (ArcaneCooldown)
{
if (ArcaneCooldown >= diff)
ArcaneCooldown -= diff;
else ArcaneCooldown = 0;
}
if (FireCooldown)
{
if (FireCooldown >= diff)
FireCooldown -= diff;
else FireCooldown = 0;
}
if (FrostCooldown)
{
if (FrostCooldown >= diff)
FrostCooldown -= diff;
else FrostCooldown = 0;
}
if(!Drinking && m_creature->GetMaxPower(POWER_MANA) && (m_creature->GetPower(POWER_MANA)*100 / m_creature->GetMaxPower(POWER_MANA)) < 20)
{
Drinking = true;
m_creature->InterruptNonMeleeSpells(false);
DoScriptText(SAY_DRINK, m_creature);
if (!DrinkInturrupted)
{
m_creature->CastSpell(m_creature, SPELL_MASS_POLY, true);
m_creature->CastSpell(m_creature, SPELL_CONJURE, false);
m_creature->CastSpell(m_creature, SPELL_DRINK, false);
//Sitting down
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_1, 1);
DrinkInturruptTimer = 10000;
}
}
//Drink Inturrupt
if (Drinking && DrinkInturrupted)
{
Drinking = false;
m_creature->RemoveAurasDueToSpell(SPELL_DRINK);
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
m_creature->SetPower(POWER_MANA, m_creature->GetMaxPower(POWER_MANA)-32000);
m_creature->CastSpell(m_creature, SPELL_POTION, false);
}
//Drink Inturrupt Timer
if (Drinking && !DrinkInturrupted)
if (DrinkInturruptTimer >= diff)
DrinkInturruptTimer -= diff;
else
{
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
m_creature->CastSpell(m_creature, SPELL_POTION, true);
m_creature->CastSpell(m_creature, SPELL_AOE_PYROBLAST, false);
DrinkInturrupted = true;
Drinking = false;
}
//Don't execute any more code if we are drinking
if (Drinking)
return;
//Normal casts
if(NormalCastTimer < diff)
{
if (!m_creature->IsNonMeleeSpellCasted(false))
{
Unit* target = NULL;
target = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (!target)
return;
uint32 Spells[3];
uint8 AvailableSpells = 0;
//Check for what spells are not on cooldown
if (!ArcaneCooldown)
{
Spells[AvailableSpells] = SPELL_ARCMISSLE;
AvailableSpells++;
}
if (!FireCooldown)
{
Spells[AvailableSpells] = SPELL_FIREBALL;
AvailableSpells++;
}
if (!FrostCooldown)
{
Spells[AvailableSpells] = SPELL_FROSTBOLT;
AvailableSpells++;
}
//If no available spells wait 1 second and try again
if (AvailableSpells)
{
CurrentNormalSpell = Spells[rand() % AvailableSpells];
DoCast(target, CurrentNormalSpell);
}
}
NormalCastTimer = 1000;
}else NormalCastTimer -= diff;
if(SecondarySpellTimer < diff)
{
switch (rand()%2)
{
case 0:
DoCast(m_creature, SPELL_AOE_CS);
break;
case 1:
if (Unit* pUnit = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(pUnit, SPELL_CHAINSOFICE);
break;
}
SecondarySpellTimer = 5000 + (rand()%15000);
}else SecondarySpellTimer -= diff;
if(SuperCastTimer < diff)
{
uint8 Available[2];
switch (LastSuperSpell)
{
case SUPER_AE:
Available[0] = SUPER_FLAME;
Available[1] = SUPER_BLIZZARD;
break;
case SUPER_FLAME:
Available[0] = SUPER_AE;
Available[1] = SUPER_BLIZZARD;
break;
case SUPER_BLIZZARD:
Available[0] = SUPER_FLAME;
Available[1] = SUPER_AE;
break;
}
LastSuperSpell = Available[rand()%2];
switch (LastSuperSpell)
{
case SUPER_AE:
if (rand()%2)
DoScriptText(SAY_EXPLOSION1, m_creature);
else
DoScriptText(SAY_EXPLOSION2, m_creature);
m_creature->CastSpell(m_creature, SPELL_BLINK_CENTER, true);
m_creature->CastSpell(m_creature, SPELL_PLAYERPULL, true);
m_creature->CastSpell(m_creature, SPELL_MASSSLOW, true);
m_creature->CastSpell(m_creature, SPELL_AEXPLOSION, false);
break;
case SUPER_FLAME:
if (rand()%2)
DoScriptText(SAY_FLAMEWREATH1, m_creature);
else
DoScriptText(SAY_FLAMEWREATH2, m_creature);
FlameWreathTimer = 20000;
FlameWreathCheckTime = 500;
FlameWreathTarget[0] = 0;
FlameWreathTarget[1] = 0;
FlameWreathTarget[2] = 0;
FlameWreathEffect();
break;
case SUPER_BLIZZARD:
if (rand()%2)
DoScriptText(SAY_BLIZZARD1, m_creature);
else
DoScriptText(SAY_BLIZZARD2, m_creature);
Creature* Spawn = NULL;
Spawn = DoSpawnCreature(CREATURE_ARAN_BLIZZARD, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN, 25000);
if (Spawn)
{
Spawn->setFaction(m_creature->getFaction());
Spawn->CastSpell(Spawn, SPELL_CIRCULAR_BLIZZARD, false);
}
break;
}
SuperCastTimer = 35000 + (rand()%5000);
}else SuperCastTimer -= diff;
if(!ElementalsSpawned && m_creature->GetHealth()*100 / m_creature->GetMaxHealth() < 40)
{
ElementalsSpawned = true;
for (uint32 i = 0; i < 4; i++)
{
Creature* pUnit = DoSpawnCreature(CREATURE_WATER_ELEMENTAL, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN, 90000);
if (pUnit)
{
pUnit->Attack(m_creature->getVictim(), true);
pUnit->setFaction(m_creature->getFaction());
}
}
DoScriptText(SAY_ELEMENTALS, m_creature);
}
if(BerserkTimer < diff)
{
for (uint32 i = 0; i < 5; i++)
{
Creature* pUnit = DoSpawnCreature(CREATURE_SHADOW_OF_ARAN, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
if (pUnit)
{
pUnit->Attack(m_creature->getVictim(), true);
pUnit->setFaction(m_creature->getFaction());
}
}
DoScriptText(SAY_TIMEOVER, m_creature);
BerserkTimer = 60000;
}else BerserkTimer -= diff;
//Flame Wreath check
if (FlameWreathTimer)
{
if (FlameWreathTimer >= diff)
FlameWreathTimer -= diff;
else FlameWreathTimer = 0;
if (FlameWreathCheckTime < diff)
{
for (uint32 i = 0; i < 3; i++)
{
if (!FlameWreathTarget[i])
continue;
Unit* pUnit = Unit::GetUnit(*m_creature, FlameWreathTarget[i]);
if (pUnit && pUnit->GetDistance2d(FWTargPosX[i], FWTargPosY[i]) > 3)
{
pUnit->CastSpell(pUnit, 20476, true, 0, 0, m_creature->GetGUID());
pUnit->CastSpell(pUnit, 11027, true);
FlameWreathTarget[i] = 0;
}
}
FlameWreathCheckTime = 500;
}else FlameWreathCheckTime -= diff;
}
if (ArcaneCooldown && FireCooldown && FrostCooldown)
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
// Summon Phase
if (Phase2Timer <= uiDiff)
{
Phase1 = false;
me->InterruptNonMeleeSpells(false);
me->SetReactState(REACT_PASSIVE);
me->AttackStop();
me->RemoveAllAuras();
// In Fase 2 evoca 3 Murloc
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM,0))
for (uint8 i = 1; i <= 3; i++)
{
me->SummonCreature(SUMMONED_MURLOC, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 60000);
}
me->AddAura(SPELL_MAGIC_BARRIER, me);
me->MonsterYell(SAY_NAGAS_SUMMON, LANG_UNIVERSAL, 0);
Phase2Timer = 90000;
} else Phase2Timer -= uiDiff;
// Normal Phase
if (Phase1Timer <= uiDiff)
{
Phase1 = true;
me->InterruptNonMeleeSpells(false);
me->SetReactState(REACT_AGGRESSIVE);
me->RemoveAurasDueToSpell(SPELL_MAGIC_BARRIER);
DoZoneInCombat();
if (me->getThreatManager().isThreatListEmpty())
EnterEvadeMode();
Phase1Timer = 90000;
} else Phase1Timer -= uiDiff;
if (Phase1)
{
// Ogni 15 sec lancia una spora velenosa ai piedi di un player random
if (SporeTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
Creature* trig = me->SummonCreature(TOXIC_SPORES_TRIGGER, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 30000);
if (trig)
{
trig->setFaction(14);
trig->CastSpell(trig, SPELL_TOXIC_SPORES,true);
}
}
SporeTimer = 15000;
} else SporeTimer -= uiDiff;
// Poison ad area ogni 10 sec
if (PoisonTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
DoCastAOE(SPELL_POISON_BOLT_VOLLEY);
PoisonTimer = 10000;
} else PoisonTimer -= uiDiff;
// Radici su un target random ogni 25 sec
if (RootTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(pTarget, SPELL_ENTANGLE);
RootTimer = 25000;
} else RootTimer -= uiDiff;
}
DoSpellAttackIfReady(SPELL_WRATH);
}
/*
Tribute Event
*/
void instance_dire_maul::GordokTributeEvent(uint32 diff)
{
if(1<2)return;
Creature* pChoRush = instance->GetCreature(m_uiChoRushGUID);
Creature* pMizzle = instance->GetCreature(m_uiMizzleGUID);
Creature* pTrigger = instance->GetCreature(m_uiTributeTriggerGUID);
Map* pMap;
pMap = pChoRush->GetMap();
Map::PlayerList const &PlayerList = pMap->GetPlayers();
if ((GetData(TYPE_KING_GORDOK) == DONE) && pMap->GetCreature(m_uiChoRushGUID)->isAlive() && !pChoRushHome)
{
pChoRush->SetFlag(UNIT_NPC_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_PASSIVE);
pChoRush->setFaction(35);
pChoRush->DeleteThreatList();
pChoRush->CombatStop();
pChoRush->SetCanAttackPlayer(false);
pChoRush->AI()->EnterEvadeMode();
pChoRushHome = true;
GossipStepGordok = 1;
Text_Timer_Event = 1000;
}
else if ((TYPE_KING_GORDOK == DONE) && pMap->GetCreature(m_uiChoRushGUID)->isDead())
{
for(Map::PlayerList::const_iterator itr = PlayerList.begin(); itr != PlayerList.end(); ++itr)
{
Player* pPlayer = itr->getSource();
if (pPlayer->IsWithinDistInMap(pTrigger, 30.0f))
pTrigger->CastSpell(pPlayer, SPELL_KING_OF_GORDOK, false);
}
}
if(pChoRushHome)
{
if (Text_Timer_Event<diff)
{
switch (GossipStepGordok)
{
case 1:
DoScriptText(ChoRush_SAY_1, pChoRush);
pChoRush->HandleEmote(EMOTE_STATE_TALK);
pChoRush->SummonCreature(NPC_MIZZLE_THE_CRAFTY, 817.666f, 478.371f, 37.3182f, 3.07057f, TEMPSUMMON_TIMED_DESPAWN, 9000000);
Text_Timer_Event = 5000;
break;
case 2:
pChoRush->HandleEmote(EMOTE_STATE_SIT);
DoScriptText(Mizzle_SAY_1, pMizzle);
pMizzle->HandleEmote(EMOTE_STATE_TALK);
Text_Timer_Event = 5000;
break;
case 3:
DoScriptText(Mizzle_SAY_2, pMizzle);
pMizzle->HandleEmote(EMOTE_STATE_TALK);
Text_Timer_Event = 8000;
break;
case 4:
for(Map::PlayerList::const_iterator itr = PlayerList.begin(); itr != PlayerList.end(); ++itr)
{
Player* pPlayer = itr->getSource();
if (pPlayer->IsWithinDistInMap(pMizzle, 50.0f))
pMizzle->CastSpell(pPlayer, SPELL_KING_OF_GORDOK, false);
}
if (pMap->GetCreature(m_uiMoldarGUID)->isAlive() && pMap->GetCreature(m_uiMizzleGUID)->isAlive() && pMap->GetCreature(m_uiFengusGUID)->isAlive())
{
pMizzle->SummonObject(pMap, GO_GORDOK_TRIBUTE, 809.899719f, 482.306366f, 37.318359f, 0.212846f);
pMizzle->HandleEmote(EMOTE_ONESHOT_APPLAUD);
}
pChoRushHome = false;
break;
}
}
else Text_Timer_Event -= diff;
}
}
void UpdateAI(uint32 diff) override
{
if (Intro && !Done)
{
if (AggroTimer <= diff)
{
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
Talk(SAY_AGGRO);
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_NONE);
Done = true;
if (AggroTargetGUID)
{
Unit* unit = ObjectAccessor::GetUnit(*me, AggroTargetGUID);
if (unit)
AttackStart(unit);
DoZoneInCombat();
}
else
{
EnterEvadeMode();
return;
}
} else AggroTimer -= diff;
}
if (!UpdateVictim() || !Done)
return;
if (SummonShadowsTimer <= diff)
{
//MindControlGhost();
for (uint8 i = 0; i < 2; ++i)
{
Creature* Shadow = NULL;
float X = CalculateRandomLocation(me->GetPositionX(), 10);
Shadow = me->SummonCreature(CREATURE_SHADOWY_CONSTRUCT, X, me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 0);
if (Shadow)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (!target)
target = me->GetVictim();
if (target)
Shadow->AI()->AttackStart(target);
}
}
SummonShadowsTimer = 60000;
} else SummonShadowsTimer -= diff;
if (SummonDoomBlossomTimer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
float X = CalculateRandomLocation(target->GetPositionX(), 20);
float Y = CalculateRandomLocation(target->GetPositionY(), 20);
float Z = target->GetPositionZ();
Z = me->GetMap()->GetHeight(me->GetPhaseMask(), X, Y, Z);
Creature* DoomBlossom = me->SummonCreature(CREATURE_DOOM_BLOSSOM, X, Y, Z, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 20000);
if (DoomBlossom)
{
DoomBlossom->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
DoomBlossom->setFaction(me->getFaction());
DoomBlossom->AddThreat(target, 1.0f);
ENSURE_AI(npc_doom_blossom::npc_doom_blossomAI, DoomBlossom->AI())->SetTeronGUID(me->GetGUID());
target->CombatStart(DoomBlossom);
SetThreatList(DoomBlossom);
SummonDoomBlossomTimer = 35000;
}
}
} else SummonDoomBlossomTimer -= diff;
if (IncinerateTimer <= diff)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (!target)
target = me->GetVictim();
if (target)
{
Talk(SAY_SPECIAL);
DoCast(target, SPELL_INCINERATE);
IncinerateTimer = urand(20, 51) * 1000;
}
} else IncinerateTimer -= diff;
if (CrushingShadowsTimer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_CRUSHING_SHADOWS);
CrushingShadowsTimer = urand(10, 26) * 1000;
} else CrushingShadowsTimer -= diff;
/*** NOTE FOR FUTURE DEV: UNCOMMENT BELOW ONLY IF MIND CONTROL IS FULLY IMPLEMENTED **/
/*if (ShadowOfDeathTimer <= diff)
{
Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 1);
if (!target)
target = me->GetVictim();
if (target && target->IsAlive() && target->GetTypeId() == TYPEID_PLAYER)
{
DoCast(target, SPELL_SHADOW_OF_DEATH);
GhostGUID = target->GetGUID();
ShadowOfDeathTimer = 30000;
SummonShadowsTimer = 53000; // Make it VERY close but slightly less so that we can check if the aura is still on the player
}
} else ShadowOfDeathTimer -= diff;*/
if (RandomYellTimer <= diff)
{
Talk(SAY_SPELL);
RandomYellTimer = urand(50, 101) * 1000;
} else RandomYellTimer -= diff;
if (!me->HasAura(SPELL_BERSERK))
{
if (EnrageTimer <= diff)
{
DoCast(me, SPELL_BERSERK);
Talk(SAY_ENRAGE);
} else EnrageTimer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (EnfeebleResetTimer && EnfeebleResetTimer <= diff) // Let's not forget to reset that
{
EnfeebleResetHealth();
EnfeebleResetTimer = 0;
} else EnfeebleResetTimer -= diff;
if (me->hasUnitState(UNIT_STAT_STUNNED)) // While shifting to phase 2 malchezaar stuns himself
return;
if (me->GetUInt64Value(UNIT_FIELD_TARGET) != me->getVictim()->GetGUID())
me->SetUInt64Value(UNIT_FIELD_TARGET, me->getVictim()->GetGUID());
if (phase == 1)
{
if ((me->GetHealth()*100) / me->GetMaxHealth() < 60)
{
me->InterruptNonMeleeSpells(false);
phase = 2;
//animation
DoCast(me, SPELL_EQUIP_AXES);
//text
DoScriptText(SAY_AXE_TOSS1, me);
//passive thrash aura
DoCast(me, SPELL_THRASH_AURA, true);
//models
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY, AXE_EQUIP_MODEL);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO, AXE_EQUIP_INFO);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY+1, AXE_EQUIP_MODEL);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO+2, AXE_EQUIP_INFO);
//damage
const CreatureTemplate *cinfo = me->GetCreatureTemplate();
me->SetBaseWeaponDamage(BASE_ATTACK, MINDAMAGE, 2*cinfo->mindmg);
me->SetBaseWeaponDamage(BASE_ATTACK, MAXDAMAGE, 2*cinfo->maxdmg);
me->UpdateDamagePhysical(BASE_ATTACK);
me->SetBaseWeaponDamage(OFF_ATTACK, MINDAMAGE, cinfo->mindmg);
me->SetBaseWeaponDamage(OFF_ATTACK, MAXDAMAGE, cinfo->maxdmg);
//Sigh, updating only works on main attack, do it manually ....
me->SetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE, cinfo->mindmg);
me->SetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE, cinfo->maxdmg);
me->SetAttackTime(OFF_ATTACK, (me->GetAttackTime(BASE_ATTACK)*150)/100);
}
}
else if (phase == 2)
{
if ((me->GetHealth()*100) / me->GetMaxHealth() < 30)
{
InfernalTimer = 15000;
phase = 3;
ClearWeapons();
//remove thrash
me->RemoveAurasDueToSpell(SPELL_THRASH_AURA);
DoScriptText(SAY_AXE_TOSS2, me);
Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
for (uint8 i = 0; i < 2; ++i)
{
Creature *axe = me->SummonCreature(MALCHEZARS_AXE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 1000);
if (axe)
{
axe->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY, AXE_EQUIP_MODEL);
axe->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO, AXE_EQUIP_INFO);
axe->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
axe->setFaction(me->getFaction());
axes[i] = axe->GetGUID();
if (pTarget)
{
axe->AI()->AttackStart(pTarget);
//axe->getThreatManager().tauntApply(pTarget); //Taunt Apply and fade out does not work properly
// So we'll use a hack to add a lot of threat to our target
axe->AddThreat(pTarget, 10000000.0f);
}
}
}
if (ShadowNovaTimer > 35000)
ShadowNovaTimer = EnfeebleTimer + 5000;
return;
}
if (SunderArmorTimer <= diff)
{
DoCast(me->getVictim(), SPELL_SUNDER_ARMOR);
SunderArmorTimer = urand(10000, 18000);
} else SunderArmorTimer -= diff;
if (Cleave_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_CLEAVE);
Cleave_Timer = urand(6000, 12000);
} else Cleave_Timer -= diff;
}
else
{
if (AxesTargetSwitchTimer <= diff)
{
AxesTargetSwitchTimer = urand(7500, 20000);
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
{
for (uint8 i = 0; i < 2; ++i)
{
if (Unit *axe = Unit::GetUnit(*me, axes[i]))
{
if (axe->getVictim())
DoModifyThreatPercent(axe->getVictim(), -100);
if (pTarget)
axe->AddThreat(pTarget, 1000000.0f);
//axe->getThreatManager().tauntFadeOut(axe->getVictim());
//axe->getThreatManager().tauntApply(pTarget);
}
}
}
} else AxesTargetSwitchTimer -= diff;
if (AmplifyDamageTimer <= diff)
{
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(pTarget, SPELL_AMPLIFY_DAMAGE);
AmplifyDamageTimer = urand(20000, 30000);
} else AmplifyDamageTimer -= diff;
}
//Time for global and double timers
if (InfernalTimer <= diff)
{
SummonInfernal(diff);
InfernalTimer = phase == 3 ? 14500 : 44500; // 15 secs in phase 3, 45 otherwise
} else InfernalTimer -= diff;
if (ShadowNovaTimer <= diff)
{
DoCast(me->getVictim(), SPELL_SHADOWNOVA);
ShadowNovaTimer = phase == 3 ? 31000 : uint32(-1);
} else ShadowNovaTimer -= diff;
if (phase != 2)
{
if (SWPainTimer <= diff)
{
Unit *pTarget = NULL;
if (phase == 1)
pTarget = me->getVictim(); // the tank
else // anyone but the tank
pTarget = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true);
if (pTarget)
DoCast(pTarget, SPELL_SW_PAIN);
SWPainTimer = 20000;
} else SWPainTimer -= diff;
}
if (phase != 3)
{
if (EnfeebleTimer <= diff)
{
EnfeebleHealthEffect();
EnfeebleTimer = 30000;
ShadowNovaTimer = 5000;
EnfeebleResetTimer = 9000;
} else EnfeebleTimer -= diff;
}
if (phase == 2)
DoMeleeAttacksIfReady();
else
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() )
return;
//Only do this if we haven't spawned nef yet
if (SpawnedAdds < 42)
{
//ShadowBoltTimer
if (ShadowBoltTimer < diff)
{
Unit* target = NULL;
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target)
DoCast(target,SPELL_SHADOWBOLT);
ShadowBoltTimer = 3000 + (rand()%7000);
}else ShadowBoltTimer -= diff;
//FearTimer
if (FearTimer < diff)
{
Unit* target = NULL;
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target)
DoCast(target,SPELL_FEAR);
FearTimer = 10000 + (rand()%10000);
}else FearTimer -= diff;
//Add spawning mechanism
if (AddSpawnTimer < diff)
{
//Spawn 2 random types of creatures at the 2 locations
uint32 CreatureID;
Creature* Spawned = NULL;
Unit* target = NULL;
//1 in 3 chance it will be a chromatic
if (rand()%3 == 0)
CreatureID = CREATURE_CHROMATIC_DRAKANOID;
else CreatureID = DrakType1;
SpawnedAdds++;
//Spawn creature and force it to start attacking a random target
Spawned = m_creature->SummonCreature(CreatureID,ADD_X1,ADD_Y1,ADD_Z1,5.000,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,5000);
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target && Spawned)
{
Spawned->AI()->AttackStart(target);
Spawned->setFaction(103);
}
//1 in 3 chance it will be a chromatic
if (rand()%3 == 0)
CreatureID = CREATURE_CHROMATIC_DRAKANOID;
else CreatureID = DrakType2;
SpawnedAdds++;
target = NULL;
Spawned = NULL;
Spawned = m_creature->SummonCreature(CreatureID,ADD_X2,ADD_Y2,ADD_Z2,5.000,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,5000);
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target && Spawned)
{
Spawned->AI()->AttackStart(target);
Spawned->setFaction(103);
}
//Begin phase 2 by spawning Nefarian and what not
if (SpawnedAdds >= 42)
{
//Teleport Victor Nefarius way out of the map
//MapManager::Instance().GetMap(m_creature->GetMapId(), m_creature)->CreatureRelocation(m_creature,0,0,-5000,0);
//Inturrupt any spell casting
m_creature->InterruptNonMeleeSpells(false);
//Root self
DoCast(m_creature,33356);
//Make super invis
DoCast(m_creature,8149);
//Teleport self to a hiding spot (this causes errors in the Trinity log but no real issues)
DoTeleportTo(HIDE_X,HIDE_Y,HIDE_Z);
m_creature->addUnitState(UNIT_STAT_FLEEING);
//Spawn nef and have him attack a random target
Creature* Nefarian = NULL;
Nefarian = m_creature->SummonCreature(CREATURE_NEFARIAN,NEF_X,NEF_Y,NEF_Z,0,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,120000);
target = NULL;
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target && Nefarian)
{
Nefarian->AI()->AttackStart(target);
Nefarian->setFaction(103);
NefarianGUID = Nefarian->GetGUID();
}
else error_log("TSCR: Blackwing Lair: Unable to spawn nefarian properly.");
}
AddSpawnTimer = 4000;
}else AddSpawnTimer -= diff;
}
else if (NefarianGUID)
{
if (NefCheckTime < diff)
{
Unit* Nefarian = NULL;
Nefarian = Unit::GetUnit((*m_creature),NefarianGUID);
//If nef is dead then we die to so the players get out of combat
//and cannot repeat the event
if (!Nefarian || !Nefarian->isAlive())
{
NefarianGUID = 0;
m_creature->Kill(m_creature);
}
NefCheckTime = 2000;
}else NefCheckTime -= diff;
}
}
void UpdateAI(const uint32 diff)
{
if (!Phase)
return;
// Reset if event is begun and we don't have a threatlist
if (Phase && m_creature->getThreatManager().getThreatList().empty())
EnterEvadeMode();
if (Phase == 1)
{
if (AnimationTimer < diff)
{
// Release the cube
m_creature->SetUInt32Value(UNIT_NPC_EMOTESTATE,374);
AnimationTimer = 8300;
}else AnimationTimer -= diff;
if (SummonEssenceTimer < diff)
{
// Ribs: open
m_creature->SetUInt32Value(UNIT_NPC_EMOTESTATE,373);
Creature* EssenceSuffering = NULL;
EssenceSuffering = m_creature->SummonCreature(23418, m_creature->GetPositionX(), m_creature->GetPositionY(), m_creature->GetPositionZ(), 1.57f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10000);
if (EssenceSuffering)
{
DoScriptText(SUFF_SAY_FREED, EssenceSuffering);
if (Unit* target = SelectUnit(SELECT_TARGET_TOPAGGRO, 0))
{
EssenceSuffering->AddThreat(target);
EssenceSuffering->AI()->AttackStart(target);
}
SufferingGUID = EssenceSuffering->GetGUID();
}
EndingPhase = false;
Phase = 2;
}else SummonEssenceTimer -= diff;
}
if (Phase == 2)
{
if (SufferingGUID)
{
Creature* EssenceSuffering = NULL;
EssenceSuffering = ((Creature*)Unit::GetUnit((*m_creature), SufferingGUID));
if (!EssenceSuffering || (!EssenceSuffering->isAlive()))
EnterEvadeMode();
if (!EndingPhase)
{
if (EssenceSuffering)
{
if (EssenceSuffering->GetHealthPercent() < 10.0f)
{
DoScriptText(SUFF_SAY_RECAP, EssenceSuffering);
MergeThreatList(EssenceSuffering);
EssenceSuffering->RemoveAllAuras();
EssenceSuffering->DeleteThreatList();
EssenceSuffering->GetMotionMaster()->MoveFollow(m_creature,0.0f,0.0f);
EssenceSuffering->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
DespawnEssenceTimer = 4000;
AnimationTimer = 2200;
EndingPhase = true;
}
}
}
if ((EndingPhase) && (EssenceSuffering) && (EssenceSuffering->isAlive()))
{
if (AnimationTimer < diff)
{
// Return
EssenceSuffering->SetUInt32Value(UNIT_NPC_EMOTESTATE,374);
AnimationTimer = 10000;
}else AnimationTimer -= diff;
if (DespawnEssenceTimer < diff)
{
DoScriptText(SUFF_SAY_AFTER, EssenceSuffering);
EssenceSuffering->DeleteThreatList();
EssenceSuffering->SetDisplayId(11686);
EssenceSuffering->setFaction(35);
m_creature->SetUInt32Value(UNIT_NPC_EMOTESTATE,0);
SummonEssenceTimer = 20000; //60000;
AnimationTimer = 18200; //58100;
SoulDeathCount = 0;
SoulCount = 0;
SummonSoulTimer = 1000;
EndingPhase = false;
Phase = 3;
SufferingGUID = 0;
}else DespawnEssenceTimer -= diff;
}
}
}
if (Phase == 3)
{
if (SoulCount < 36)
{
if (SummonSoulTimer < diff)
{
SummonSoul();
SummonSoulTimer = 500;
}else SummonSoulTimer -= diff;
}
if (SoulDeathCount >= SoulCount)
{
if (AnimationTimer < diff)
{
// Release the cube
m_creature->SetUInt32Value(UNIT_NPC_EMOTESTATE,374);
AnimationTimer = 10000;
}else AnimationTimer -= diff;
if (SummonEssenceTimer < diff)
{
// Ribs: open
m_creature->SetUInt32Value(UNIT_NPC_EMOTESTATE,373);
Creature* EssenceDesire = NULL;
EssenceDesire = m_creature->SummonCreature(23419, m_creature->GetPositionX(), m_creature->GetPositionY(), m_creature->GetPositionZ(), 1.57f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10000);
if (EssenceDesire)
{
DoScriptText(DESI_SAY_FREED, EssenceDesire);
if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
{
EssenceDesire->AddThreat(target);
EssenceDesire->AI()->AttackStart(target);
}
DesireGUID = EssenceDesire->GetGUID();
SoulDeathCount = 0;
}
Phase = 4;
}else SummonEssenceTimer -= diff;
}
}
if (Phase == 4)
{
if (DesireGUID)
{
Creature* EssenceDesire = NULL;
EssenceDesire = ((Creature*)Unit::GetUnit((*m_creature), DesireGUID));
if (!EssenceDesire || !EssenceDesire->isAlive())
EnterEvadeMode();
if (!EndingPhase && EssenceDesire)
{
if (EssenceDesire->GetHealthPercent() < 10.0f)
{
MergeThreatList(EssenceDesire);
EssenceDesire->GetMotionMaster()->MoveFollow(m_creature,0.0f,0.0f);
EssenceDesire->RemoveAllAuras();
EssenceDesire->DeleteThreatList();
DoScriptText(DESI_SAY_RECAP, EssenceDesire);
EssenceDesire->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
DespawnEssenceTimer = 4000;
AnimationTimer = 2200;
EndingPhase = true;
}
}
if (EndingPhase && EssenceDesire)
{
if (EssenceDesire->isAlive())
{
if (AnimationTimer < diff)
{
// Return
EssenceDesire->SetUInt32Value(UNIT_NPC_EMOTESTATE,374);
AnimationTimer = 10000;
}else AnimationTimer -= diff;
if (DespawnEssenceTimer < diff)
{
EssenceDesire->DeleteThreatList();
EssenceDesire->setFaction(35);
DoScriptText(DESI_SAY_AFTER, EssenceDesire);
EssenceDesire->SetDisplayId(11686);
m_creature->SetUInt32Value(UNIT_NPC_EMOTESTATE,0);
SummonEssenceTimer = 20000;
AnimationTimer = 18200;
SoulDeathCount = 0;
SoulCount = 0;
SummonSoulTimer = 1000;
EndingPhase = false;
Phase = 5;
DesireGUID = 0;
}else DespawnEssenceTimer -= diff;
}
}
}
}
if (Phase == 5)
{
if (SoulCount < 36)
{
if (SummonSoulTimer < diff)
{
SummonSoul();
SummonSoulTimer = 500;
}else SummonSoulTimer -= diff;
}
if (SoulDeathCount >= SoulCount)
{
if (AnimationTimer < diff)
{
// Release the cube
m_creature->SetUInt32Value(UNIT_NPC_EMOTESTATE,374);
AnimationTimer = 10000;
}else AnimationTimer -= diff;
if (SummonEssenceTimer < diff)
{
// Ribs: open
m_creature->SetUInt32Value(UNIT_NPC_EMOTESTATE,373);
Creature* EssenceAnger = NULL;
EssenceAnger = m_creature->SummonCreature(23420, m_creature->GetPositionX(), m_creature->GetPositionY(), m_creature->GetPositionZ(), 1.57f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 45000);
if (EssenceAnger)
{
if (Unit* target = SelectUnit(SELECT_TARGET_TOPAGGRO, 0))
{
EssenceAnger->AddThreat(target);
EssenceAnger->AI()->AttackStart(target);
}
AngerGUID = EssenceAnger->GetGUID();
DoScriptText(ANGER_SAY_FREED, EssenceAnger);
SoulDeathCount = 0;
}
Phase = 6;
}else SummonEssenceTimer -= diff;
}
}
if (Phase == 6)
{
if (AngerGUID)
{
Creature* EssenceAnger = NULL;
EssenceAnger = ((Creature*)Unit::GetUnit((*m_creature), AngerGUID));
if (!EssenceAnger)
EnterEvadeMode();
if (m_creature->isAlive() && EssenceAnger)
{
if (!EssenceAnger->isAlive())
{
AngerGUID = 0;
m_creature->DealDamage(m_creature, m_creature->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
}
}
}
}
}
