void CorpseRemoved(uint32 &)
{
// TODO: would be better to cast a dummy spell
if (!pMap || !pMap->IsBattleGround())
return;
Map::PlayerList const &PlayerList = pMap->GetPlayers();
for(Map::PlayerList::const_iterator itr = PlayerList.begin(); itr != PlayerList.end(); ++itr)
{
Player* pPlayer = itr->getSource();
if (!pPlayer || !pPlayer->IsWithinDistInMap(m_creature, 25.0f) || !pPlayer->HasAura(SPELL_WAITING_TO_RESURRECT1))
continue;
// repop player again - now this node won't be counted and another node is searched
pPlayer->RepopAtGraveyard();
}
}
Player const* GetPlayerInMap() const
{
Map::PlayerList const& players = instance->GetPlayers();
if (!players.isEmpty())
{
for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* player = itr->getSource();
if (player && !player->HasAura(45839, 0))
return player;
}
}
else
sLog->outDebug(LOG_FILTER_TSCR, "Instance Sunwell Plateau: GetPlayerInMap, but PlayerList is empty!");
return NULL;
}
Player const* GetPlayerInMap() const
{
Map::PlayerList const& players = instance->GetPlayers();
if (!players.isEmpty())
{
for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* player = itr->GetSource();
if (player && !player->HasAura(45839))
return player;
}
}
else
TC_LOG_DEBUG("scripts", "Instance Sunwell Plateau: GetPlayerInMap, but PlayerList is empty!");
return NULL;
}
void instance_sunwell_plateau::DoEjectSpectralRealmPlayers()
{
if (m_lSpectralRealmList.empty())
return;
Map::PlayerList const& players = instance->GetPlayers();
for(Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* pPlayer = itr->getSource();
if (pPlayer && !pPlayer->HasAura(SPELL_SPECTRAL_REALM))
{
m_lSpectralRealmList.remove(pPlayer->GetObjectGuid());
pPlayer->CastSpell(pPlayer, SPELL_SPECTRAL_REALM_RETURN, true);
}
}
}
bool ChatHandler::HandleHoverCommand(const char* args, WorldSession * m_session)
{
Player * Plr = m_session->GetPlayer();
bool flag;
if(Plr->HasAura(11010))
flag = false;
else
flag = true;
Plr->SetHover(flag);
if( flag )
RedSystemMessage(m_session, "Hober enabled.");
else
RedSystemMessage(m_session, "Hover disabled.");
return true;
}
void BattlegroundDS::PostUpdateImpl(uint32 diff)
{
if (getWaterFallTimer() < diff)
{
if (isWaterFallActive())
{
setWaterFallTimer(urand(BG_DS_WATERFALL_TIMER_MIN, BG_DS_WATERFALL_TIMER_MAX));
for (uint32 i = BG_DS_OBJECT_WATER_1; i <= BG_DS_OBJECT_WATER_2; ++i)
SpawnBGObject(i, getWaterFallTimer());
setWaterFallActive(false);
}
else
{
setWaterFallTimer(BG_DS_WATERFALL_DURATION);
for (uint32 i = BG_DS_OBJECT_WATER_1; i <= BG_DS_OBJECT_WATER_2; ++i)
SpawnBGObject(i, RESPAWN_IMMEDIATELY);
setWaterFallActive(true);
}
}
else
setWaterFallTimer(getWaterFallTimer() - diff);
if (GetStatus() == STATUS_IN_PROGRESS)
{
if(m_knockback < diff && m_knockbackCheck)
{
for(BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); itr++)
{
Player * plr = sObjectMgr->GetPlayerByLowGUID(itr->first);
if(plr)
{
if (plr->GetTeam() == ALLIANCE && plr->GetDistance2d(1214, 765) <= 50 && plr->GetPositionZ() > 10)
KnockBackPlayer(plr, 6.15f, 50.00f, 7.00f);
if (plr->GetTeam() == HORDE && plr->GetDistance2d(1369, 817) <= 50 && plr->GetPositionZ() > 10)
KnockBackPlayer(plr, 3.10f, 50.00f, 7.00f);
if(plr->HasAura(SPELL_DEMONIC_CIRCLE))
plr->RemoveAurasDueToSpell(SPELL_DEMONIC_CIRCLE);
}
}
m_knockbackCheck = false;
} else m_knockback -= diff;
}
}
void MoveInLineOfSight(Unit* who)
{
if (!who || !who->IsInWorld() || who->GetZoneId() != 4395)
return;
if (!me->IsWithinDist(who, 65.0f, false))
return;
Player* player = who->GetCharmerOrOwnerPlayerOrPlayerItself();
// If player has Disguise aura for quest A Meeting With The Magister or An Audience With The Arcanist, do not teleport it away but let it pass
if (!player || player->isGameMaster() || player->IsBeingTeleported() || player->HasAura(70973) || player->HasAura(70971))
return;
switch (me->GetEntry())
{
case 29254:
if (player->GetTeam() == HORDE) // Horde unit found in Alliance area
{
if (GetClosestCreatureWithEntry(me, NPC_APPLEBOUGH_A, 32.0f))
{
if (me->isInBackInMap(who, 12.0f)) // In my line of sight, "outdoors", and behind me
DoCast(who, SPELL_TRESPASSER_A); // Teleport the Horde unit out
}
else // In my line of sight, and "indoors"
DoCast(who, SPELL_TRESPASSER_A); // Teleport the Horde unit out
}
break;
case 29255:
if (player->GetTeam() == ALLIANCE) // Alliance unit found in Horde area
{
if (GetClosestCreatureWithEntry(me, NPC_SWEETBERRY_H, 32.0f))
{
if (me->isInBackInMap(who, 12.0f)) // In my line of sight, "outdoors", and behind me
DoCast(who, SPELL_TRESPASSER_H); // Teleport the Alliance unit out
}
else // In my line of sight, and "indoors"
DoCast(who, SPELL_TRESPASSER_H); // Teleport the Alliance unit out
}
break;
}
me->SetOrientation(me->GetHomePosition().GetOrientation());
return;
}
void MindControlGhost()
{
/************************************************************************/
/** NOTE FOR FUTURE DEVELOPER: PROPERLY IMPLEMENT THE GHOST PORTION *****/
/** ONLY AFTER MaNGOS FULLY IMPLEMENTS MIND CONTROL ABILITIES *****/
/** THE CURRENT CODE IN THIS FUNCTION IS ONLY THE BEGINNING OF *****/
/** WHAT IS FULLY NECESSARY FOR GOREFIEND TO BE 100% COMPLETE *****/
/************************************************************************/
Player* pGhost = NULL;
if (m_ghostGuid)
pGhost = m_creature->GetMap()->GetPlayer(m_ghostGuid);
if (pGhost && pGhost->isAlive() && pGhost->HasAura(SPELL_SHADOW_OF_DEATH, EFFECT_INDEX_0))
{
/*float x,y,z;
pGhost->GetPosition(x,y,z);
Creature* control = m_creature->SummonCreature(CREATURE_GHOST, x, y, z, 0, TEMPSUMMON_TIMED_DESAWN, 30000);
if (control)
{
((Player*)pGhost)->Possess(control);
pGhost->DealDamage(pGhost, pGhost->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL,
false);
}*/
for(uint8 i = 0; i < 4; ++i)
{
float fX = CalculateRandomLocation(pGhost->GetPositionX(), 10);
float fY = CalculateRandomLocation(pGhost->GetPositionY(), 10);
if (Creature* pConstruct = m_creature->SummonCreature(NPC_SHADOWY_CONSTRUCT, fX, fY, pGhost->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 45000))
{
pConstruct->CastSpell(pConstruct, SPELL_PASSIVE_SHADOWFORM, true);
SetThreatList(pConstruct); // Use same function as Doom Blossom to set Threat List.
if (mob_shadowy_constructAI* pConstructAI = dynamic_cast<mob_shadowy_constructAI*>(pConstruct->AI()))
pConstructAI->m_ghostGuid = m_ghostGuid;
Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 1);
pConstruct->GetMotionMaster()->MoveChase(pTarget ? pTarget : m_creature->getVictim());
}
}
}
}
void MoveInLineOfSight(Unit* pWho) override
{
FollowerAI::MoveInLineOfSight(pWho);
if (!m_creature->HasAura(SPELL_SUBDUED) || m_creature->getVictim())
return;
if (pWho->GetEntry() == NPC_COLDARRA_DRAKE_HUNT_INVISMAN && m_creature->IsWithinDistInMap(pWho, 20.0f))
{
Player* pPlayer = GetLeaderForFollower();
if (!pPlayer || !pPlayer->HasAura(SPELL_DRAKE_HATCHLING_SUBDUED))
return;
pWho->CastSpell(pPlayer, SPELL_STRIP_AURAS, true);
// give kill credit, mark the follow as completed and start the final event
pPlayer->KilledMonsterCredit(NPC_COLDARRA_DRAKE_HUNT_INVISMAN);
pPlayer->CastSpell(m_creature, SPELL_DRAKE_TURN_IN, true);
SetFollowComplete(true);
}
}
void EjectPlayers()
{
if (SpectralRealmList.empty())
return;
Map::PlayerList const& players = instance->GetPlayers();
for(Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* plr = itr->getSource();
// only choose players without spectral exhaustion debuff that are in demon realm
if (plr && !plr->HasAura(SPELL_SPECTRAL_EXHAUSTION) && plr->GetPositionZ() < DEMON_REALM_Z+3)
{
SpectralRealmList.remove(plr->GetGUID());
EjectPlayer(plr);
}
}
//SpectralRealmList.clear();
}
void EjectPlayers()
{
if (SpectralRealmList.empty())
return;
Map::PlayerList const& players = instance->GetPlayers();
for(Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* plr = itr->getSource();
if (plr && !plr->HasAura(SPELL_SPECTRAL_REALM))
{
SpectralRealmList.remove(plr->GetGUID());
EjectPlayer(plr);
}
}
//SpectralRealmList.clear();
}
bool IsWipe()
{
Map::PlayerList const& PlayerList = instance->GetPlayers();
if (PlayerList.isEmpty())
return true;
for (Map::PlayerList::const_iterator Itr = PlayerList.begin(); Itr != PlayerList.end(); ++Itr)
{
Player* player = Itr->getSource();
if (!player)
continue;
if (player->isAlive() && !player->isGameMaster() && !player->HasAura(115877)) // Aura 115877 = Totaly Petrified
return false;
}
return true;
}
bool GOUse_go_gauntlet_gate(Player* pPlayer, GameObject* pGo)
{
ScriptedInstance* pInstance = (ScriptedInstance*)pGo->GetInstanceData();
if (!pInstance)
{
return false;
}
if (pInstance->GetData(TYPE_BARON_RUN) != NOT_STARTED)
{
return false;
}
if (Group* pGroup = pPlayer->GetGroup())
{
for (GroupReference* itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
{
Player* pGroupie = itr->getSource();
if (!pGroupie)
{
continue;
}
if (!pGroupie->HasAura(SPELL_BARON_ULTIMATUM))
{
pGroupie->CastSpell(pGroupie, SPELL_BARON_ULTIMATUM, true);
}
}
}
else
{
if (!pPlayer->HasAura(SPELL_BARON_ULTIMATUM))
{
pPlayer->CastSpell(pPlayer, SPELL_BARON_ULTIMATUM, true);
}
}
pInstance->SetData(TYPE_BARON_RUN, IN_PROGRESS);
return false;
}
void EjectPlayers()
{
if (SpectralRealmList.empty())
return;
Map::PlayerList const& players = instance->GetPlayers();
for(Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* plr = itr->getSource();
if (!plr)
continue;
if (std::find(SpectralRealmList.begin(),SpectralRealmList.end(),plr->GetGUID())!=SpectralRealmList.end() &&
!plr->HasAura(SPELL_SPECTRAL_REALM, 0))
{
EjectPlayer(plr);
}
}
SpectralRealmList.clear();
}
void JustDied(Unit* /*victim*/)
{
DoScriptText(SAY_DEATH, me);
_JustDied();
if (instance)
{
// Rubble and Roll
if (RubbleCount > 4)
instance->DoCompleteAchievement(ACHIEVEMENT_RUBBLE_AND_ROLL);
// With Open Arms
if (RubbleCount == 0)
instance->DoCompleteAchievement(ACHIEVEMENT_WITH_OPEN_ARMS);
// Remove Stone Grip from players
Map::PlayerList const &players = instance->instance->GetPlayers();
for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* pPlayer = itr->getSource();
if (!pPlayer)
continue;
if (pPlayer->HasAura(SPELL_STONE_GRIP_STUN))
{
pPlayer->RemoveAurasDueToSpell(RAID_MODE(64290, 64292));
pPlayer->RemoveAurasDueToSpell(SPELL_STONE_GRIP_STUN);
pPlayer->GetMotionMaster()->MoveJump(1767.80f, -18.38f, 448.808f, 10, 10);
}
}
}
// Hack to disable corpse fall
me->GetMotionMaster()->MoveTargetedHome();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->setFaction(35);
// Chest spawn
me->SummonGameObject(RAID_MODE(CACHE_OF_LIVING_STONE_10, CACHE_OF_LIVING_STONE_25),1836.52f,-36.11f,448.81f,0.56f,0,0,1,1,604800);
}
void JustDied(Unit* Killer)
{
Map *map = m_creature->GetMap();
if(!map->IsDungeon()) return;
Map::PlayerList const &players = map->GetPlayers();
if(players.getSize()==0)
return;
for(Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* plr = itr->getSource();
if (!plr->GetSession() || !plr->isAlive())
continue;
if (plr->HasAura(SCALDING_WATER,0))
plr->RemoveAurasDueToSpell(SCALDING_WATER);
}
if (pInstance)
pInstance->SetData(DATA_THELURKERBELOWEVENT, DONE);
}
void UpdateAI(const uint32 uiDiff)
{
if (!pMap || !pMap->IsBattleGround())
return;
if (!m_creature->GetCurrentSpell(CURRENT_CHANNELED_SPELL))
m_creature->CastSpell(m_creature, SPELL_SPIRIT_HEAL_CHANNEL1, false);
if (m_uiCastSpellResurrectTimer < uiDiff)
{
Map::PlayerList const &PlayerList = pMap->GetPlayers();
for (Map::PlayerList::const_iterator itr = PlayerList.begin(); itr != PlayerList.end(); ++itr)
{
Player* pPlayer = itr->getSource();
if (pPlayer && pPlayer->IsWithinDistInMap(m_creature, 25.0f) && !pPlayer->HasAura(SPELL_WAITING_TO_RESURRECT1))
m_creature->CastSpell(pPlayer, SPELL_WAITING_TO_RESURRECT1, true);
}
m_uiCastSpellResurrectTimer = 5000;
}
else
m_uiCastSpellResurrectTimer -= uiDiff;
}
void CorpseRemoved(uint32&) override
{
// TODO: would be better to cast a dummy spell
Map* pMap = m_creature->GetMap();
if (!pMap || !pMap->IsBattleGround())
return;
std::list<Player*> nearPlayers;
MaNGOS::AnyPlayerInObjectRangeCheck rangeChecker(m_creature, 20.0f);
MaNGOS::PlayerListSearcher<MaNGOS::AnyPlayerInObjectRangeCheck> searcher(nearPlayers, rangeChecker);
Cell::VisitGridObjects(m_creature, searcher, 20.0f);
for (auto& i : nearPlayers)
{
Player* pPlayer = i;
if (!pPlayer || !pPlayer->HasAura(SPELL_WAITING_TO_RESURRECT))
continue;
// repop player again - now this node won't be counted and another node is searched
pPlayer->RepopAtGraveyard();
}
}
// apply a team buff for the specific zone
void WorldPvP::DoProcessTeamBuff(Team uiTeam, uint32 uiSpellId, bool bRemove)
{
for (ObjectGuidSet::iterator itr = m_sZonePlayers.begin(); itr != m_sZonePlayers.end(); ++itr)
{
if (!(*itr))
continue;
Player* pPlayer = sObjectMgr.GetPlayer(*itr);
if (!pPlayer)
continue;
if (pPlayer->GetTeam() == uiTeam)
{
if (!bRemove)
pPlayer->CastSpell(pPlayer, uiSpellId, true);
else
{
if (pPlayer->HasAura(uiSpellId))
pPlayer->RemoveAurasDueToSpell(uiSpellId);
}
}
}
}
bool Execute(uint32 i, Spell* pSpell)
{
if(pSpell->p_caster == NULL || pSpell->GetUnitTarget() == NULL)
return true;
Player* Caster = pSpell->p_caster;
Unit* Target = pSpell->GetUnitTarget();
uint32 rage = Caster->GetPower(POWER_TYPE_RAGE);
if(Caster->HasAura(58367)) // Glyph of Execution: Your Execute ability deals damage as if you had 10 additional rage.
rage += 10;
uint32 toadd = 0;
int32 dmg = 0;
uint32 multiple[] =
{
0,
3,
6,
9,
12,
15,
18,
21,
30,
38,
};
if(rage >= 30)
toadd = (multiple[pSpell->GetProto()->RankNumber] * 30);
else
toadd = (multiple[pSpell->GetProto()->RankNumber] * rage);
dmg = pSpell->CalculateEffect(i, pSpell->GetUnitTarget());
dmg += Caster->GetAttackPower() / 5;
dmg += toadd;
Caster->Strike(Target, 0, pSpell->GetProto(), 0, 0, dmg, false, false);
return true;
}
//Enable\Disable Invisible mode
static bool HandleGMVisibleCommand(ChatHandler* handler, char const* args)
{
if (!*args)
{
handler->PSendSysMessage(LANG_YOU_ARE, handler->GetSession()->GetPlayer()->isGMVisible() ? handler->GetTrinityString(LANG_VISIBLE) : handler->GetTrinityString(LANG_INVISIBLE));
return true;
}
const uint32 VISUAL_AURA = 37800;
std::string param = (char*)args;
Player* player = handler->GetSession()->GetPlayer();
if (param == "on")
{
if (player->HasAura(VISUAL_AURA, 0))
player->RemoveAurasDueToSpell(VISUAL_AURA);
player->SetGMVisible(true);
handler->GetSession()->SendNotification(LANG_INVISIBLE_VISIBLE);
return true;
}
if (param == "off")
{
handler->GetSession()->SendNotification(LANG_INVISIBLE_INVISIBLE);
player->SetGMVisible(false);
player->AddAura(VISUAL_AURA, player);
return true;
}
handler->SendSysMessage(LANG_USE_BOL);
handler->SetSentErrorMessage(true);
return false;
}
void UpdateAI(const uint32 diff)
{
npc_escortAI::UpdateAI(diff);
if (PlayerGUID)
{
Player* AuraPlayer = Unit::GetPlayer(*me,PlayerGUID);
if (!AuraPlayer)
{
me->DisappearAndDie();
return;
}
else
{
if (AuraPlayer->isDead())
{
AuraPlayer->FailQuest(QUEST_A_FALL_FROM_GRACE);
me->DisappearAndDie();
return;
}
if (EndSequence)
{
if (EndSequenceTimer <= diff)
{
EndSequenceTimer = 12000;
if (EndSayCount == 6)
{
me->GetMotionMaster()->MoveJump(HighAbbotLandgrenJumpPos[0][0][0], HighAbbotLandgrenJumpPos[0][0][1], HighAbbotLandgrenJumpPos[0][0][2], 0.5f, 8.0f);
EndSequenceTimer = 2000;
}
if (EndSayCount == 7)
{
me->MonsterSay(HighAbbotText[6], LANG_UNIVERSAL, 0);
EndSequenceTimer = 2000;
}
if (EndSayCount == 8)
{
AuraPlayer->KilledMonsterCredit(27444, 0);
if (AuraPlayer->HasAura(SPELL_SCARLET_RAVEN_PRIEST_IMAGE_FEMALE))
AuraPlayer->RemoveAura(SPELL_SCARLET_RAVEN_PRIEST_IMAGE_FEMALE);
if (AuraPlayer->HasAura(SPELL_SCARLET_RAVEN_PRIEST_IMAGE_MALE))
AuraPlayer->RemoveAura(SPELL_SCARLET_RAVEN_PRIEST_IMAGE_MALE);
EndSequence = false;
}
if (EndSayCount < 6)
me->MonsterSay(HighAbbotText[EndSayCount], LANG_UNIVERSAL, PlayerGUID);
EndSayCount++;
} else
EndSequenceTimer -= diff;
}
if (!EventStarted && me->GetEntry() == NPC_HIGH_ABBOT_LANDGREN_ESCORTEE_ENTRY)
{
Start(false, false, PlayerGUID, 0, false);
EventStarted = true;
}
if (CheckPlayerDist)
if (AuraPlayer->GetDistance(2827.796f, -420.191f, 118.196f) < 4)
StartMove();
if (AuraCheckTimer <= diff) {
if (AuraPlayer && AuraPlayer->GetQuestStatus(QUEST_A_FALL_FROM_GRACE) == QUEST_STATUS_INCOMPLETE && AuraPlayer->getQuestStatusMap()[QUEST_A_FALL_FROM_GRACE].m_creatureOrGOcount[0] == 1 && !AuraPlayer->HasAura(SPELL_SCARLET_RAVEN_PRIEST_IMAGE_MALE) && !AuraPlayer->HasAura(SPELL_SCARLET_RAVEN_PRIEST_IMAGE_FEMALE)) {
switch(AuraPlayer->getGender())
{
case GENDER_FEMALE:
AuraPlayer->CastSpell(AuraPlayer, SPELL_SCARLET_RAVEN_PRIEST_IMAGE_FEMALE, false);
break;
case GENDER_MALE:
AuraPlayer->CastSpell(AuraPlayer, SPELL_SCARLET_RAVEN_PRIEST_IMAGE_MALE, false);
break;
}
}
AuraCheckTimer = 300;
} else
AuraCheckTimer -= diff;
if (me->GetEntry() != NPC_HIGH_ABBOT_LANDGREN_ESCORTEE_ENTRY)
{
if (BodyGuardStart && AuraPlayer->GetQuestStatus(QUEST_A_FALL_FROM_GRACE) == QUEST_STATUS_INCOMPLETE && AuraPlayer->getQuestStatusMap()[QUEST_A_FALL_FROM_GRACE].m_creatureOrGOcount[0] == 1) {
if (Creature* tmp = me->FindNearestCreature(NPC_DEVOUT_BODYGUARD, Range, true))
{
if (BodyGuardMoveTimer <= diff)
{
CAST_AI(npc_devout_bodyguard::npc_devout_bodyguardAI, tmp->AI())->StartMove();
BodyGuardMoveTimer = 6000;
Range = 4.0f;
if (GuardCount == 1)
BodyGuardStart = false;
GuardCount++;
} else
BodyGuardMoveTimer -= diff;
}
}
}
}
}
}
void WorldSession::HandleSendMail(WorldPacket& recvData)
{
ObjectGuid mailbox;
uint64 money, COD;
std::string receiver, subject, body;
uint32 bodyLength, subjectLength, receiverLength;
uint32 unk1, unk2;
recvData >> COD >> money; // money and cod
recvData >> unk1;
recvData >> unk2; // Stationery?
subjectLength = recvData.ReadBits(9);
mailbox[7] = recvData.ReadBit();
mailbox[5] = recvData.ReadBit();
mailbox[0] = recvData.ReadBit();
bodyLength = recvData.ReadBits(12);
mailbox[2] = recvData.ReadBit();
receiverLength = recvData.ReadBits(7);
mailbox[1] = recvData.ReadBit();
uint8 items_count = recvData.ReadBits(5); // attached items count
if (items_count > MAX_MAIL_ITEMS) // client limit
{
GetPlayer()->SendMailResult(0, MAIL_SEND, MAIL_ERR_TOO_MANY_ATTACHMENTS);
recvData.rfinish(); // set to end to avoid warnings spam
return;
}
mailbox[6] = recvData.ReadBit();
ObjectGuid itemGUIDs[MAX_MAIL_ITEMS];
uint8 bitOrder[8] = {3, 7, 0, 2, 6, 5, 1, 4};
for (uint8 i = 0; i < items_count; ++i)
recvData.ReadBitInOrder(itemGUIDs[i], bitOrder);
mailbox[4] = recvData.ReadBit();
mailbox[3] = recvData.ReadBit();
recvData.FlushBits();
recvData.ReadByteSeq(mailbox[7]);
for (uint8 i = 0; i < items_count; ++i)
{
recvData.ReadByteSeq(itemGUIDs[i][3]);
recvData.ReadByteSeq(itemGUIDs[i][1]);
recvData.ReadByteSeq(itemGUIDs[i][0]);
recvData.ReadByteSeq(itemGUIDs[i][7]);
recvData.ReadByteSeq(itemGUIDs[i][6]);
recvData.read_skip<uint8>(); // item slot in mail, not used
recvData.ReadByteSeq(itemGUIDs[i][4]);
recvData.ReadByteSeq(itemGUIDs[i][5]);
recvData.ReadByteSeq(itemGUIDs[i][2]);
}
recvData.ReadByteSeq(mailbox[3]);
body = recvData.ReadString(bodyLength);
recvData.ReadByteSeq(mailbox[5]);
recvData.ReadByteSeq(mailbox[4]);
subject = recvData.ReadString(subjectLength);
recvData.ReadByteSeq(mailbox[1]);
receiver = recvData.ReadString(receiverLength);
recvData.ReadByteSeq(mailbox[6]);
recvData.ReadByteSeq(mailbox[2]);
recvData.ReadByteSeq(mailbox[0]);
// packet read complete, now do check
if (!GetPlayer()->GetGameObjectIfCanInteractWith(mailbox, GAMEOBJECT_TYPE_MAILBOX))
return;
if (receiver.empty())
return;
Player* player = _player;
if (player->getLevel() < sWorld->getIntConfig(CONFIG_MAIL_LEVEL_REQ))
{
SendNotification(GetTrinityString(LANG_MAIL_SENDER_REQ), sWorld->getIntConfig(CONFIG_MAIL_LEVEL_REQ));
return;
}
uint64 rc = 0;
if (normalizePlayerName(receiver))
rc = sObjectMgr->GetPlayerGUIDByName(receiver);
if (!rc)
{
sLog->outInfo(LOG_FILTER_NETWORKIO, "Player %u is sending mail to %s (GUID: not existed!) with subject %s and body %s includes %u items, " UI64FMTD " copper and " UI64FMTD " COD copper with unk1 = %u, unk2 = %u",
player->GetGUIDLow(), receiver.c_str(), subject.c_str(), body.c_str(), items_count, money, COD, unk1, unk2);
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_RECIPIENT_NOT_FOUND);
return;
}
sLog->outInfo(LOG_FILTER_NETWORKIO, "Player %u is sending mail to %s (GUID: %u) with subject %s and body %s includes %u items, " UI64FMTD " copper and " UI64FMTD " COD copper with unk1 = %u, unk2 = %u", player->GetGUIDLow(), receiver.c_str(), GUID_LOPART(rc), subject.c_str(), body.c_str(), items_count, money, COD, unk1, unk2);
if (player->GetGUID() == rc)
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_CANNOT_SEND_TO_SELF);
return;
}
uint32 cost = items_count ? 30 * items_count : 30; // price hardcoded in client
uint64 reqmoney = cost + money;
if (!player->HasEnoughMoney(reqmoney) && !player->isGameMaster())
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_NOT_ENOUGH_MONEY);
return;
}
Player* receive = ObjectAccessor::FindPlayer(rc);
uint32 rc_team = 0;
uint8 mails_count = 0; //do not allow to send to one player more than 100 mails
if (receive)
{
rc_team = receive->GetTeam();
mails_count = receive->GetMailSize();
}
//do not allow to have more than 100 mails in mailbox.. mails count is in opcode uint8!!! - so max can be 255..
if (mails_count > 100)
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_RECIPIENT_CAP_REACHED);
return;
}
// test the receiver's Faction... or all items are account bound
bool accountBound = items_count ? true : false;
for (uint8 i = 0; i < items_count; ++i)
{
Item* item = player->GetItemByGuid(itemGUIDs[i]);
if (item)
{
ItemTemplate const* itemProto = item->GetTemplate();
if (!itemProto || !(itemProto->Flags & ITEM_PROTO_FLAG_BIND_TO_ACCOUNT))
{
accountBound = false;
break;
}
}
}
// We have remove mysql query for check team of offline players
// On pandashan, it's will work anyway because of interfaction
/*if (!accountBound && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_MAIL) && player->GetTeam() != rc_team && AccountMgr::IsPlayerAccount(GetSecurity()))
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_NOT_YOUR_TEAM);
return;
}*/
uint32 rc_account = receive
? receive->GetSession()->GetAccountId()
: sObjectMgr->GetPlayerAccountIdByGUID(rc);
Item* items[MAX_MAIL_ITEMS];
for (uint8 i = 0; i < items_count; ++i)
{
if (!itemGUIDs[i])
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_MAIL_ATTACHMENT_INVALID);
return;
}
Item* item = player->GetItemByGuid(itemGUIDs[i]);
// prevent sending bag with items (cheat: can be placed in bag after adding equipped empty bag to mail)
if (!item)
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_MAIL_ATTACHMENT_INVALID);
return;
}
if (!item->CanBeTraded(true))
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_MAIL_BOUND_ITEM);
return;
}
if (item->IsBoundAccountWide() && item->IsSoulBound() && player->GetSession()->GetAccountId() != rc_account)
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_NOT_SAME_ACCOUNT);
return;
}
if (item->GetTemplate()->Flags & ITEM_PROTO_FLAG_CONJURED || item->GetUInt32Value(ITEM_FIELD_DURATION))
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_MAIL_BOUND_ITEM);
return;
}
if (COD && item->HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAG_WRAPPED))
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_CANT_SEND_WRAPPED_COD);
return;
}
if (item->IsNotEmptyBag())
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_DESTROY_NONEMPTY_BAG);
return;
}
items[i] = item;
}
// Check for spamming
if (!UpdateAntispamCount())
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_INTERNAL_ERROR);
SendNotification(GetTrinityString(LANG_ANTISPAM_ERROR));
return;
}
// Check for special symbols
if (!checkMailText(subject) || !checkMailText(body))
{
player->SendMailResult(0, MAIL_SEND, MAIL_ERR_INTERNAL_ERROR);
return;
}
player->SendMailResult(0, MAIL_SEND, MAIL_OK);
player->ModifyMoney(-int64(reqmoney));
player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_MAIL, cost);
bool needItemDelay = false;
MailDraft draft(subject, body);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
if (items_count > 0 || money > 0)
{
if (items_count > 0)
{
for (uint8 i = 0; i < items_count; ++i)
{
Item* item = items[i];
if (!AccountMgr::IsPlayerAccount(GetSecurity()) && sWorld->getBoolConfig(CONFIG_GM_LOG_TRADE))
{
sLog->outCommand(GetAccountId(), "", GetPlayer()->GetGUIDLow(), GetPlayer()->GetName(),
rc_account, "", 0, receiver.c_str(),
"GM %s (Account: %u) mail item: %s (Entry: %u Count: %u) to player: %s (Account: %u)",
GetPlayerName().c_str(), GetAccountId(), item->GetTemplate()->Name1.c_str(), item->GetEntry(), item->GetCount(), receiver.c_str(), rc_account);
}
item->SetNotRefundable(GetPlayer()); // makes the item no longer refundable
player->MoveItemFromInventory(items[i]->GetBagSlot(), item->GetSlot(), true);
item->DeleteFromInventoryDB(trans); // deletes item from character's inventory
item->SetOwnerGUID(rc);
item->SaveToDB(trans); // recursive and not have transaction guard into self, item not in inventory and can be save standalone
draft.AddItem(item);
}
// if item send to character at another account, then apply item delivery delay
needItemDelay = player->GetSession()->GetAccountId() != rc_account;
}
if (money > 0 && !AccountMgr::IsPlayerAccount(GetSecurity()) && sWorld->getBoolConfig(CONFIG_GM_LOG_TRADE))
{
//TODO: charcter guid
sLog->outCommand(GetAccountId(), "", GetPlayer()->GetGUIDLow(), GetPlayer()->GetName(),
rc_account, "", 0, receiver.c_str(),
"GM %s (Account: %u) mail money: %u to player: %s (Account: %u)",
GetPlayerName().c_str(), GetAccountId(), money, receiver.c_str(), rc_account);
}
}
// Guild Mail
if (receive && receive->GetGuildId() && player->GetGuildId())
if (player->HasAura(83951) && (player->GetGuildId() == receive->GetGuildId()))
needItemDelay = false;
// If theres is an item, there is a one hour delivery delay if sent to another account's character.
uint32 deliver_delay = needItemDelay ? sWorld->getIntConfig(CONFIG_MAIL_DELIVERY_DELAY) : 0;
// will delete item or place to receiver mail list
draft
.AddMoney(money)
.AddCOD(COD)
.SendMailTo(trans, MailReceiver(receive, GUID_LOPART(rc)), MailSender(player), body.empty() ? MAIL_CHECK_MASK_COPIED : MAIL_CHECK_MASK_HAS_BODY, deliver_delay);
player->SaveInventoryAndGoldToDB(trans);
CharacterDatabase.CommitTransaction(trans);
}
static bool HandleSpectateCommand(ChatHandler* handler, char const* args)
{
Player* target;
ObjectGuid target_guid;
std::string target_name;
if (!handler->extractPlayerTarget((char*)args, &target, &target_guid, &target_name))
return false;
Player* player = handler->GetSession()->GetPlayer();
if (target == player || target_guid == player->GetGUID())
{
handler->PSendSysMessage("Вы не можете смотреть на себя.");
handler->SetSentErrorMessage(true);
return false;
}
if (player->IsInCombat())
{
handler->PSendSysMessage("Вы находитесь в Бою.");
handler->SetSentErrorMessage(true);
return false;
}
if (!target)
{
handler->PSendSysMessage("Цель не существует.");
handler->SetSentErrorMessage(true);
return false;
}
if (player->IsMounted())
{
handler->PSendSysMessage("Не можете смотреть сидя верхом.");
handler->SetSentErrorMessage(true);
return false;
}
if (target && (target->HasAura(ARENA_PREPARATION) || target->HasAura(ARENA_PREPARATION_2)))
{
handler->PSendSysMessage("Не могу этого сделать. Арена не началась.");
handler->SetSentErrorMessage(true);
return false;
}
if (player->GetPet())
{
handler->PSendSysMessage("Вы должны скрыть своего питомца.");
handler->SetSentErrorMessage(true);
return false;
}
if (player->GetMap()->IsBattlegroundOrArena() && !player->isSpectator())
{
handler->PSendSysMessage("Вы уже находитесь на поле битвы или арене.");
handler->SetSentErrorMessage(true);
return false;
}
Map* map = target->GetMap();
if (!map->IsBattleArena())
{
handler->PSendSysMessage("Игрок не на арене.");
handler->SetSentErrorMessage(true);
return false;
}
if (player->GetMap()->IsBattleground())
{
handler->PSendSysMessage("Не могу сделать это, в то время как вы находитесь на поле боя.");
handler->SetSentErrorMessage(true);
return false;
}
// all's well, set bg id
// when porting out from the bg, it will be reset to 0
player->SetBattlegroundId(target->GetBattlegroundId(), target->GetBattlegroundTypeId());
// remember current position as entry point for return at bg end teleportation
if (!player->GetMap()->IsBattlegroundOrArena())
player->SetBattlegroundEntryPoint();
if (target->isSpectator())
{
handler->PSendSysMessage("Не могу сделать этого. Ваша цель - зритель.");
handler->SetSentErrorMessage(true);
return false;
}
// stop flight if need
if (player->IsInFlight())
{
player->GetMotionMaster()->MovementExpired();
player->CleanupAfterTaxiFlight();
}
// save only in non-flight case
else
player->SaveRecallPosition();
// search for two teams
Battleground *bGround = target->GetBattleground();
if (bGround->isRated())
{
uint32 slot = bGround->GetArenaType() - 2;
if (bGround->GetArenaType() > 3)
slot = 2;
uint32 firstTeamID = target->GetArenaTeamId(slot);
uint32 secondTeamID = 0;
Player *firstTeamMember = target;
Player *secondTeamMember = NULL;
for (Battleground::BattlegroundPlayerMap::const_iterator itr = bGround->GetPlayers().begin(); itr != bGround->GetPlayers().end(); ++itr)
if (Player* tmpPlayer = ObjectAccessor::FindPlayer(itr->first))
{
if (tmpPlayer->isSpectator())
continue;
uint32 tmpID = tmpPlayer->GetArenaTeamId(slot);
if (tmpID != firstTeamID && tmpID > 0)
{
secondTeamID = tmpID;
secondTeamMember = tmpPlayer;
break;
}
}
if (firstTeamID > 0 && secondTeamID > 0 && secondTeamMember)
{
ArenaTeam *firstTeam = sArenaTeamMgr->GetArenaTeamById(firstTeamID);
ArenaTeam *secondTeam = sArenaTeamMgr->GetArenaTeamById(secondTeamID);
if (firstTeam && secondTeam)
{
handler->PSendSysMessage("Вы вошли на Арену.");
handler->PSendSysMessage("Команды:");
handler->PSendSysMessage("%s - %s", firstTeam->GetName().c_str(), secondTeam->GetName().c_str());
handler->PSendSysMessage("%u(%u) - %u(%u)", firstTeam->GetRating(), firstTeam->GetAverageMMR(firstTeamMember->GetGroup()),
secondTeam->GetRating(), secondTeam->GetAverageMMR(secondTeamMember->GetGroup()));
}
}
}
// to point to see at target with same orientation
float x, y, z;
target->GetContactPoint(player, x, y, z);
player->TeleportTo(target->GetMapId(), x, y, z, player->GetAngle(target), TELE_TO_GM_MODE);
player->SetPhaseMask(target->GetPhaseMask(), true);
player->SetSpectate(true);
target->GetBattleground()->AddSpectator(player->GetGUID());
return true;
}
void PlayerbotWarlockAI::DoNonCombatActions()
{
SpellSequence = SPELL_CURSES;
PlayerbotAI *ai = GetAI();
Player * m_bot = GetPlayerBot();
if (!ai || !m_bot)
return;
Pet *pet = m_bot->GetPet();
// Initialize pet spells
if (pet && pet->GetEntry() != m_lastDemon)
{
switch (pet->GetEntry())
{
case DEMON_IMP:
{
BLOOD_PACT = ai->initPetSpell(BLOOD_PACT_ICON);
FIREBOLT = ai->initPetSpell(FIREBOLT_ICON);
FIRE_SHIELD = ai->initPetSpell(FIRE_SHIELD_ICON);
break;
}
case DEMON_VOIDWALKER:
{
CONSUME_SHADOWS = ai->initPetSpell(CONSUME_SHADOWS_ICON);
SACRIFICE = ai->initPetSpell(SACRIFICE_ICON);
SUFFERING = ai->initPetSpell(SUFFERING_ICON);
TORMENT = ai->initPetSpell(TORMENT_ICON);
break;
}
case DEMON_SUCCUBUS:
{
LASH_OF_PAIN = ai->initPetSpell(LASH_OF_PAIN_ICON);
SEDUCTION = ai->initPetSpell(SEDUCTION_ICON);
SOOTHING_KISS = ai->initPetSpell(SOOTHING_KISS_ICON);
break;
}
case DEMON_FELHUNTER:
{
DEVOUR_MAGIC = ai->initPetSpell(DEVOUR_MAGIC_ICON);
FEL_INTELLIGENCE = ai->initPetSpell(FEL_INTELLIGENCE_ICON);
SHADOW_BITE = ai->initPetSpell(SHADOW_BITE_ICON);
SPELL_LOCK = ai->initPetSpell(SPELL_LOCK_ICON);
break;
}
case DEMON_FELGUARD:
{
ANGUISH = ai->initPetSpell(ANGUISH_ICON);
CLEAVE = ai->initPetSpell(CLEAVE_ICON);
INTERCEPT = ai->initPetSpell(INTERCEPT_ICON);
break;
}
}
m_lastDemon = pet->GetEntry();
if (!m_isTempImp)
m_demonOfChoice = pet->GetEntry();
}
// Destroy extra soul shards
uint8 shardCount = m_bot->GetItemCount(SOUL_SHARD, false, NULL);
uint8 freeSpace = ai->GetFreeBagSpace();
if (shardCount > MAX_SHARD_COUNT || (freeSpace == 0 && shardCount > 1))
m_bot->DestroyItemCount(SOUL_SHARD, shardCount > MAX_SHARD_COUNT ? shardCount - MAX_SHARD_COUNT : 1, true, false);
// buff myself DEMON_SKIN, DEMON_ARMOR, FEL_ARMOR
if (FEL_ARMOR)
{
if (ai->SelfBuff(FEL_ARMOR))
return;
}
else if (DEMON_ARMOR)
{
if (ai->SelfBuff(DEMON_ARMOR))
return;
}
else if (DEMON_SKIN)
if (ai->SelfBuff(DEMON_SKIN))
return;
// healthstone creation
if (CREATE_HEALTHSTONE && shardCount > 0)
{
Item* const healthStone = ai->FindConsumable(HEALTHSTONE_DISPLAYID);
if (!healthStone && ai->CastSpell(CREATE_HEALTHSTONE))
return;
}
// soulstone creation and use
if (CREATE_SOULSTONE)
{
Item* soulStone = ai->FindConsumable(SOULSTONE_DISPLAYID);
if (!soulStone)
{
if (shardCount > 0 && !m_bot->HasSpellCooldown(CREATE_SOULSTONE) && ai->CastSpell(CREATE_SOULSTONE))
return;
}
else
{
uint32 soulStoneSpell = soulStone->GetProto()->Spells[0].SpellId;
Player * master = GetMaster();
if (!master->HasAura(soulStoneSpell) && !m_bot->HasSpellCooldown(soulStoneSpell))
{
ai->UseItem(soulStone, master);
return;
}
}
}
// firestone creation and use
Item* const weapon = m_bot->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
if (weapon && weapon->GetEnchantmentId(TEMP_ENCHANTMENT_SLOT) == 0)
{
Item* const stone = ai->FindConsumable(FIRESTONE_DISPLAYID);
if (!stone)
{
if (CREATE_FIRESTONE && shardCount > 0 && ai->CastSpell(CREATE_FIRESTONE))
return;
}
else
{
ai->UseItem(stone, EQUIPMENT_SLOT_MAINHAND);
return;
}
}
if (m_bot->getStandState() != UNIT_STAND_STATE_STAND)
m_bot->SetStandState(UNIT_STAND_STATE_STAND);
// mana check
if (pet && DARK_PACT && pet->GetPower(POWER_MANA) > 0 && ai->GetManaPercent() <= 50)
if (ai->CastSpell(DARK_PACT, *m_bot))
return;
if (LIFE_TAP && ai->GetManaPercent() <= 50 && ai->GetHealthPercent() > 50)
if (ai->CastSpell(LIFE_TAP, *m_bot))
return;
if (ai->GetManaPercent() < 25)
{
Item* pItem = ai->FindDrink();
if (pItem)
{
ai->TellMaster("I could use a drink.");
ai->UseItem(pItem);
return;
}
}
// hp check
if (ai->GetHealthPercent() < 30)
{
Item* pItem = ai->FindFood();
if (pItem)
{
ai->TellMaster("I could use some food.");
ai->UseItem(pItem);
return;
}
}
if (ai->GetHealthPercent() < 50 && !m_bot->HasAura(RECENTLY_BANDAGED))
{
Item* fItem = ai->FindBandage();
if (fItem)
{
ai->TellMaster("I could use first aid.");
ai->UseItem(fItem);
return;
}
}
//Heal Voidwalker
if (pet && pet->GetEntry() == DEMON_VOIDWALKER && CONSUME_SHADOWS && pet->GetHealthPercent() < 75 && !pet->HasAura(CONSUME_SHADOWS))
ai->CastPetSpell(CONSUME_SHADOWS);
// Summon demon
if (!pet || m_isTempImp)
{
uint32 summonSpellId;
if (m_demonOfChoice != DEMON_IMP && shardCount > 0)
{
switch (m_demonOfChoice)
{
case DEMON_VOIDWALKER:
summonSpellId = SUMMON_VOIDWALKER;
break;
case DEMON_FELGUARD:
summonSpellId = SUMMON_FELGUARD;
break;
case DEMON_FELHUNTER:
summonSpellId = SUMMON_FELHUNTER;
break;
case DEMON_SUCCUBUS:
summonSpellId = SUMMON_SUCCUBUS;
break;
default:
summonSpellId = 0;
}
if (ai->CastSpell(summonSpellId))
{
ai->TellMaster("Summoning favorite demon...");
m_isTempImp = false;
return;
}
}
else if (!pet && SUMMON_IMP && ai->CastSpell(SUMMON_IMP))
{
if (m_demonOfChoice != DEMON_IMP)
m_isTempImp = true;
ai->TellMaster("Summoning Imp...");
return;
}
}
// Soul link demon
if (pet && SOUL_LINK && !m_bot->HasAura(SOUL_LINK_AURA) && ai->CastSpell(SOUL_LINK, *m_bot))
return;
// Check demon buffs
if (pet && pet->GetEntry() == DEMON_IMP && BLOOD_PACT && !m_bot->HasAura(BLOOD_PACT) && ai->CastPetSpell(BLOOD_PACT))
return;
if (pet && pet->GetEntry() == DEMON_FELHUNTER && FEL_INTELLIGENCE && !m_bot->HasAura(FEL_INTELLIGENCE) && ai->CastPetSpell(FEL_INTELLIGENCE))
return;
} // end DoNonCombatActions
void UpdatePortals() // Here we handle the beams' behavior
{
for(int j=0; j<3; ++j) // j = color
{
if(Creature *portal = Unit::GetCreature(*m_creature, PortalGUID[j]))
{
// the one who's been cast upon before
Unit *current = Unit::GetUnit(*portal, BeamTarget[j]);
// temporary store for the best suitable beam reciever
Unit *target = m_creature;
if(Map* map = m_creature->GetMap())
{
Map::PlayerList const& players = map->GetPlayers();
// get the best suitable target
for(Map::PlayerList::const_iterator i = players.begin(); i!=players.end(); ++i)
{
Player* p = i->getSource();
if(p && p->isAlive() // alive
&& (!target || target->GetExactDistance2d(portal->GetPositionX(), portal->GetPositionY()) > p->GetExactDistance2d(portal->GetPositionX(), portal->GetPositionY())) // closer than current best
&& !p->HasAura(PlayerDebuff[j],0) // not exhausted
&& !p->HasAura(PlayerBuff[(j+1)%3],0) // not on another beam
&& !p->HasAura(PlayerBuff[(j+2)%3],0)
&& p->isBetween(m_creature, portal)) // on the beam
target = p;
}
}
// buff the target
if(target->GetTypeId() == TYPEID_PLAYER)
target->AddAura(PlayerBuff[j], target);
else
target->AddAura(NetherBuff[j], target);
// cast visual beam on the chosen target if switched
// simple target switching isn't working -> using BeamerGUID to cast (workaround)
if(!current || target != current)
{
BeamTarget[j] = target->GetGUID();
// remove currently beaming portal
if(Creature *beamer = Unit::GetCreature(*portal, BeamerGUID[j]))
{
beamer->CastSpell(target, PortalBeam[j], false);
beamer->SetVisibility(VISIBILITY_OFF);
beamer->DealDamage(beamer, beamer->GetMaxHealth());
beamer->RemoveFromWorld();
BeamerGUID[j] = 0;
}
// create new one and start beaming on the target
if(Creature *beamer = portal->SummonCreature(PortalID[j],portal->GetPositionX(),portal->GetPositionY(),portal->GetPositionZ(),portal->GetOrientation(),TEMPSUMMON_TIMED_DESPAWN,60000))
{
beamer->CastSpell(target, PortalBeam[j], false);
BeamerGUID[j] = beamer->GetGUID();
}
}
// aggro target if Red Beam
if(j == RED_PORTAL && m_creature->getVictim() != target && target->GetTypeId() == TYPEID_PLAYER)
m_creature->getThreatManager().addThreat(target, 100000.0f+DoGetThreat(m_creature->getVictim()));
}
}
}
void WorldSession::HandleMessagechatOpcode(WorldPacket& recvData)
{
uint32 type;
uint32 lang;
recvData >> type;
recvData >> lang;
if (sWorld->getBoolConfig(BATTLEGROUND_CROSSFACTION_ENABLED) && lang != LANG_ADDON)
{
switch (type)
{
case CHAT_MSG_BATTLEGROUND:
case CHAT_MSG_BATTLEGROUND_LEADER:
lang = LANG_UNIVERSAL;
default:
break;
}
}
if (type >= MAX_CHAT_MSG_TYPE)
{
TC_LOG_ERROR("network", "CHAT: Wrong message type received: %u", type);
recvData.rfinish();
return;
}
if (lang == LANG_UNIVERSAL && type != CHAT_MSG_AFK && type != CHAT_MSG_DND)
{
TC_LOG_ERROR("network", "CMSG_MESSAGECHAT: Possible hacking-attempt: %s tried to send a message in universal language", GetPlayerInfo().c_str());
SendNotification(LANG_UNKNOWN_LANGUAGE);
recvData.rfinish();
return;
}
Player* sender = GetPlayer();
//TC_LOG_DEBUG("CHAT: packet received. type %u, lang %u", type, lang);
// prevent talking at unknown language (cheating)
LanguageDesc const* langDesc = GetLanguageDescByID(lang);
if (!langDesc)
{
SendNotification(LANG_UNKNOWN_LANGUAGE);
recvData.rfinish();
return;
}
if (langDesc->skill_id != 0 && !sender->HasSkill(langDesc->skill_id))
{
// also check SPELL_AURA_COMPREHEND_LANGUAGE (client offers option to speak in that language)
Unit::AuraEffectList const& langAuras = sender->GetAuraEffectsByType(SPELL_AURA_COMPREHEND_LANGUAGE);
bool foundAura = false;
for (Unit::AuraEffectList::const_iterator i = langAuras.begin(); i != langAuras.end(); ++i)
{
if ((*i)->GetMiscValue() == int32(lang))
{
foundAura = true;
break;
}
}
if (!foundAura)
{
SendNotification(LANG_NOT_LEARNED_LANGUAGE);
recvData.rfinish();
return;
}
}
if (lang == LANG_ADDON)
{
// LANG_ADDON is only valid for the following message types
switch (type)
{
case CHAT_MSG_PARTY:
case CHAT_MSG_RAID:
case CHAT_MSG_GUILD:
case CHAT_MSG_BATTLEGROUND:
case CHAT_MSG_WHISPER:
// check if addon messages are disabled
if (!sWorld->getBoolConfig(CONFIG_ADDON_CHANNEL))
{
recvData.rfinish();
return;
}
break;
default:
TC_LOG_ERROR("network", "Player %s (GUID: %u) sent a chatmessage with an invalid language/message type combination",
GetPlayer()->GetName().c_str(), GetPlayer()->GetGUIDLow());
recvData.rfinish();
return;
}
}
// LANG_ADDON should not be changed nor be affected by flood control
else
{
// send in universal language if player in .gmon mode (ignore spell effects)
if (sender->IsGameMaster())
lang = LANG_UNIVERSAL;
else
{
Unit::AuraEffectList const& ModLangAuras = sender->GetAuraEffectsByType(SPELL_AURA_MOD_LANGUAGE);
if (!ModLangAuras.empty())
lang = ModLangAuras.front()->GetMiscValue();
else if (HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHAT))
lang = LANG_UNIVERSAL;
else
{
switch (type)
{
case CHAT_MSG_PARTY:
case CHAT_MSG_PARTY_LEADER:
case CHAT_MSG_RAID:
case CHAT_MSG_RAID_LEADER:
case CHAT_MSG_RAID_WARNING:
// allow two side chat at group channel if two side group allowed
if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP))
lang = LANG_UNIVERSAL;
break;
case CHAT_MSG_GUILD:
case CHAT_MSG_OFFICER:
// allow two side chat at guild channel if two side guild allowed
if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD))
lang = LANG_UNIVERSAL;
break;
}
}
}
if (!sender->CanSpeak())
{
std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
SendNotification(GetTrinityString(LANG_WAIT_BEFORE_SPEAKING), timeStr.c_str());
recvData.rfinish(); // Prevent warnings
return;
}
if (type != CHAT_MSG_AFK && type != CHAT_MSG_DND)
sender->UpdateSpeakTime();
}
if (sender->HasAura(1852) && type != CHAT_MSG_WHISPER)
{
SendNotification(GetTrinityString(LANG_GM_SILENCE), sender->GetName().c_str());
recvData.rfinish();
return;
}
std::string to, channel, msg;
bool ignoreChecks = false;
switch (type)
{
case CHAT_MSG_SAY:
case CHAT_MSG_EMOTE:
case CHAT_MSG_YELL:
case CHAT_MSG_PARTY:
case CHAT_MSG_PARTY_LEADER:
case CHAT_MSG_GUILD:
case CHAT_MSG_OFFICER:
case CHAT_MSG_RAID:
case CHAT_MSG_RAID_LEADER:
case CHAT_MSG_RAID_WARNING:
case CHAT_MSG_BATTLEGROUND:
case CHAT_MSG_BATTLEGROUND_LEADER:
recvData >> msg;
break;
case CHAT_MSG_WHISPER:
recvData >> to;
recvData >> msg;
break;
case CHAT_MSG_CHANNEL:
recvData >> channel;
recvData >> msg;
break;
case CHAT_MSG_AFK:
case CHAT_MSG_DND:
recvData >> msg;
ignoreChecks = true;
break;
}
if (!ignoreChecks)
{
if (msg.empty())
return;
if (ChatHandler(this).ParseCommands(msg.c_str()))
return;
if (lang != LANG_ADDON)
{
// Strip invisible characters for non-addon messages
if (sWorld->getBoolConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if (sWorld->getIntConfig(CONFIG_CHAT_STRICT_LINK_CHECKING_SEVERITY) && !ChatHandler(this).isValidChatMessage(msg.c_str()))
{
TC_LOG_ERROR("network", "Player %s (GUID: %u) sent a chatmessage with an invalid link: %s", GetPlayer()->GetName().c_str(),
GetPlayer()->GetGUIDLow(), msg.c_str());
if (sWorld->getIntConfig(CONFIG_CHAT_STRICT_LINK_CHECKING_KICK))
KickPlayer();
return;
}
}
}
switch (type)
{
case CHAT_MSG_SAY:
case CHAT_MSG_EMOTE:
case CHAT_MSG_YELL:
{
// Prevent cheating
if (!sender->IsAlive())
return;
if (sender->getLevel() < sWorld->getIntConfig(CONFIG_CHAT_SAY_LEVEL_REQ))
{
SendNotification(GetTrinityString(LANG_SAY_REQ), sWorld->getIntConfig(CONFIG_CHAT_SAY_LEVEL_REQ));
return;
}
if (!GetPlayer()->IsGameMaster())
if (GetPlayer()->SendBattleGroundChat(type, msg))
return;
if (type == CHAT_MSG_SAY)
sender->Say(msg, lang);
else if (type == CHAT_MSG_EMOTE)
sender->TextEmote(msg);
else if (type == CHAT_MSG_YELL)
sender->Yell(msg, lang);
} break;
case CHAT_MSG_WHISPER:
{
if (!normalizePlayerName(to))
{
SendPlayerNotFoundNotice(to);
break;
}
Player* receiver = sObjectAccessor->FindPlayerByName(to);
if (!receiver || (lang != LANG_ADDON && !receiver->isAcceptWhispers() && receiver->GetSession()->HasPermission(rbac::RBAC_PERM_CAN_FILTER_WHISPERS) && !receiver->IsInWhisperWhiteList(sender->GetGUID())))
{
SendPlayerNotFoundNotice(to);
return;
}
if (!sender->IsGameMaster() && sender->getLevel() < sWorld->getIntConfig(CONFIG_CHAT_WHISPER_LEVEL_REQ) && !receiver->IsInWhisperWhiteList(sender->GetGUID()))
{
SendNotification(GetTrinityString(LANG_WHISPER_REQ), sWorld->getIntConfig(CONFIG_CHAT_WHISPER_LEVEL_REQ));
return;
}
if (GetPlayer()->GetTeam() != receiver->GetTeam() && !HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHAT) && !receiver->IsInWhisperWhiteList(sender->GetGUID()))
{
SendWrongFactionNotice();
return;
}
if (GetPlayer()->HasAura(1852) && !receiver->IsGameMaster())
{
SendNotification(GetTrinityString(LANG_GM_SILENCE), GetPlayer()->GetName().c_str());
return;
}
// If player is a Gamemaster and doesn't accept whisper, we auto-whitelist every player that the Gamemaster is talking to
// We also do that if a player is under the required level for whispers.
if (receiver->getLevel() < sWorld->getIntConfig(CONFIG_CHAT_WHISPER_LEVEL_REQ) ||
(HasPermission(rbac::RBAC_PERM_CAN_FILTER_WHISPERS) && !sender->isAcceptWhispers() && !sender->IsInWhisperWhiteList(receiver->GetGUID())))
sender->AddWhisperWhiteList(receiver->GetGUID());
GetPlayer()->Whisper(msg, lang, receiver->GetGUID());
} break;
case CHAT_MSG_PARTY:
case CHAT_MSG_PARTY_LEADER:
{
// if player is in battleground, he cannot say to battleground members by /p
Group* group = GetPlayer()->GetOriginalGroup();
if (!group)
{
group = sender->GetGroup();
if (!group || group->isBGGroup())
return;
}
if (type == CHAT_MSG_PARTY_LEADER && !group->IsLeader(sender->GetGUID()))
return;
sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
WorldPacket data;
ChatHandler::BuildChatPacket(data, ChatMsg(type), Language(lang), sender, NULL, msg);
group->BroadcastPacket(&data, false, group->GetMemberGroup(GetPlayer()->GetGUID()));
} break;
case CHAT_MSG_GUILD:
{
if (GetPlayer()->GetGuildId())
{
if (Guild* guild = sGuildMgr->GetGuildById(GetPlayer()->GetGuildId()))
{
sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, guild);
guild->BroadcastToGuild(this, false, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
}
}
} break;
case CHAT_MSG_OFFICER:
{
if (GetPlayer()->GetGuildId())
{
if (Guild* guild = sGuildMgr->GetGuildById(GetPlayer()->GetGuildId()))
{
sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, guild);
guild->BroadcastToGuild(this, true, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
}
}
} break;
case CHAT_MSG_RAID:
{
// if player is in battleground, he cannot say to battleground members by /ra
Group* group = GetPlayer()->GetOriginalGroup();
if (!group)
{
group = GetPlayer()->GetGroup();
if (!group || group->isBGGroup() || !group->isRaidGroup())
return;
}
sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
WorldPacket data;
ChatHandler::BuildChatPacket(data, CHAT_MSG_RAID, Language(lang), sender, NULL, msg);
group->BroadcastPacket(&data, false);
} break;
case CHAT_MSG_RAID_LEADER:
{
// if player is in battleground, he cannot say to battleground members by /ra
Group* group = GetPlayer()->GetOriginalGroup();
if (!group)
{
group = GetPlayer()->GetGroup();
if (!group || group->isBGGroup() || !group->isRaidGroup() || !group->IsLeader(sender->GetGUID()))
return;
}
sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
WorldPacket data;
ChatHandler::BuildChatPacket(data, CHAT_MSG_RAID_LEADER, Language(lang), sender, NULL, msg);
group->BroadcastPacket(&data, false);
} break;
case CHAT_MSG_RAID_WARNING:
{
Group* group = GetPlayer()->GetGroup();
if (!group || !group->isRaidGroup() || !(group->IsLeader(GetPlayer()->GetGUID()) || group->IsAssistant(GetPlayer()->GetGUID())) || group->isBGGroup())
return;
sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
WorldPacket data;
//in battleground, raid warning is sent only to players in battleground - code is ok
ChatHandler::BuildChatPacket(data, CHAT_MSG_RAID_WARNING, Language(lang), sender, NULL, msg);
group->BroadcastPacket(&data, false);
} break;
case CHAT_MSG_BATTLEGROUND:
{
//battleground raid is always in Player->GetGroup(), never in GetOriginalGroup()
Group* group = GetPlayer()->GetGroup();
if (!group || !group->isBGGroup())
return;
sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
WorldPacket data;
ChatHandler::BuildChatPacket(data, CHAT_MSG_BATTLEGROUND, Language(lang), sender, NULL, msg);
group->BroadcastPacket(&data, false);
} break;
case CHAT_MSG_BATTLEGROUND_LEADER:
{
// battleground raid is always in Player->GetGroup(), never in GetOriginalGroup()
Group* group = GetPlayer()->GetGroup();
if (!group || !group->isBGGroup() || !group->IsLeader(GetPlayer()->GetGUID()))
return;
sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
WorldPacket data;
ChatHandler::BuildChatPacket(data, CHAT_MSG_BATTLEGROUND_LEADER, Language(lang), sender, NULL, msg);;
group->BroadcastPacket(&data, false);
} break;
case CHAT_MSG_CHANNEL:
{
if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHAT_CHANNEL_REQ))
{
if (sender->getLevel() < sWorld->getIntConfig(CONFIG_CHAT_CHANNEL_LEVEL_REQ))
{
SendNotification(GetTrinityString(LANG_CHANNEL_REQ), sWorld->getIntConfig(CONFIG_CHAT_CHANNEL_LEVEL_REQ));
return;
}
}
if (ChannelMgr* cMgr = ChannelMgr::forTeam(sender->GetTeam()))
{
if (Channel* chn = cMgr->GetChannel(channel, sender))
{
sScriptMgr->OnPlayerChat(sender, type, lang, msg, chn);
chn->Say(sender->GetGUID(), msg.c_str(), lang);
}
}
} break;
case CHAT_MSG_AFK:
{
if (!sender->IsInCombat())
{
if (sender->isAFK()) // Already AFK
{
if (msg.empty())
sender->ToggleAFK(); // Remove AFK
else
sender->autoReplyMsg = msg; // Update message
}
else // New AFK mode
{
sender->autoReplyMsg = msg.empty() ? GetTrinityString(LANG_PLAYER_AFK_DEFAULT) : msg;
if (sender->isDND())
sender->ToggleDND();
sender->ToggleAFK();
}
sScriptMgr->OnPlayerChat(sender, type, lang, msg);
}
break;
}
case CHAT_MSG_DND:
{
if (sender->isDND()) // Already DND
{
if (msg.empty())
sender->ToggleDND(); // Remove DND
else
sender->autoReplyMsg = msg; // Update message
}
else // New DND mode
{
sender->autoReplyMsg = msg.empty() ? GetTrinityString(LANG_PLAYER_DND_DEFAULT) : msg;
if (sender->isAFK())
sender->ToggleAFK();
sender->ToggleDND();
}
sScriptMgr->OnPlayerChat(sender, type, lang, msg);
break;
}
default:
TC_LOG_ERROR("network", "CHAT: unknown message type %u, lang: %u", type, lang);
break;
}
}
void PlayerbotPriestAI::DoNonCombatActions()
{
Player * m_bot = GetPlayerBot();
if (!m_bot)
return;
SpellSequence = SPELL_HOLY;
// buff myself
if (FORTITUDE > 0)
(!m_bot->HasAura(FORTITUDE, 0) && GetAI()->CastSpell (FORTITUDE, *m_bot));
if (INNER_FIRE > 0)
(!m_bot->HasAura(INNER_FIRE, 0) && GetAI()->CastSpell (INNER_FIRE, *m_bot));
if (TOUCH_OF_WEAKNESS > 0)
(m_bot->getRace()==5 /* undead */ && GetAI()->CastSpell (TOUCH_OF_WEAKNESS, *m_bot));
// buff master
if (FORTITUDE > 0)
(!GetMaster()->HasAura(FORTITUDE,0) && GetAI()->CastSpell (FORTITUDE, *(GetMaster())) );
// mana check
if (m_bot->getStandState() != UNIT_STAND_STATE_STAND)
m_bot->SetStandState(UNIT_STAND_STATE_STAND);
Item* pItem = GetAI()->FindDrink();
if (pItem != NULL && GetAI()->GetManaPercent() < 30)
{
GetAI()->TellMaster("I could use a drink.");
GetAI()->UseItem(*pItem);
GetAI()->SetIgnoreUpdateTime(30);
return;
}
// hp check
if (m_bot->getStandState() != UNIT_STAND_STATE_STAND)
m_bot->SetStandState(UNIT_STAND_STATE_STAND);
pItem = GetAI()->FindFood();
if (pItem != NULL && GetAI()->GetHealthPercent() < 30)
{
GetAI()->TellMaster("I could use some food.");
GetAI()->UseItem(*pItem);
GetAI()->SetIgnoreUpdateTime(30);
return;
}
//(!GetMaster()->HasAura(FORTITUDE,0) && GetAI()->CastSpell (FORTITUDE, *(GetMaster())) );
// buff and heal master's group
if (GetMaster()->GetGroup())
{
Group::MemberSlotList const& groupSlot = GetMaster()->GetGroup()->GetMemberSlots();
for (Group::member_citerator itr = groupSlot.begin(); itr != groupSlot.end(); itr++)
{
Player *tPlayer = objmgr.GetPlayer(uint64 (itr->guid));
if( !tPlayer )
continue;
// first rezz em
if ( !tPlayer->isAlive() && !tPlayer->IsPlayerbot() )
{
std::string msg = "rezzing ";
msg += tPlayer->GetName();
GetPlayerBot()->Say(msg, LANG_UNIVERSAL);
GetAI()->CastSpell(REZZ, *tPlayer);
// rez is only 10 sec, but give time for lag
GetAI()->SetIgnoreUpdateTime(17);
}
else if( tPlayer->isAlive() )
{
// buff and heal
(!tPlayer->HasAura(FORTITUDE,0) && GetAI()->CastSpell (FORTITUDE, *tPlayer));
(HealTarget(*tPlayer, tPlayer->GetHealth()*100 / tPlayer->GetMaxHealth()));
}
}
}
} // end DoNonCombatActions
void BattleGroundWS::Update(uint32 diff)
{
BattleGround::Update(diff);
if (GetStatus() == STATUS_IN_PROGRESS)
{
if (m_FlagState[BG_TEAM_ALLIANCE] == BG_WS_FLAG_STATE_WAIT_RESPAWN)
{
m_FlagsTimer[BG_TEAM_ALLIANCE] -= diff;
if (m_FlagsTimer[BG_TEAM_ALLIANCE] < 0)
{
m_FlagsTimer[BG_TEAM_ALLIANCE] = 0;
RespawnFlag(ALLIANCE, true);
}
}
if (m_FlagState[BG_TEAM_ALLIANCE] == BG_WS_FLAG_STATE_ON_GROUND)
{
m_FlagsDropTimer[BG_TEAM_ALLIANCE] -= diff;
if (m_FlagsDropTimer[BG_TEAM_ALLIANCE] < 0)
{
m_FlagsDropTimer[BG_TEAM_ALLIANCE] = 0;
RespawnFlagAfterDrop(ALLIANCE);
}
}
if (m_FlagState[BG_TEAM_HORDE] == BG_WS_FLAG_STATE_WAIT_RESPAWN)
{
m_FlagsTimer[BG_TEAM_HORDE] -= diff;
if (m_FlagsTimer[BG_TEAM_HORDE] < 0)
{
m_FlagsTimer[BG_TEAM_HORDE] = 0;
RespawnFlag(HORDE, true);
}
}
if (m_FlagState[BG_TEAM_HORDE] == BG_WS_FLAG_STATE_ON_GROUND)
{
m_FlagsDropTimer[BG_TEAM_HORDE] -= diff;
if (m_FlagsDropTimer[BG_TEAM_HORDE] < 0)
{
m_FlagsDropTimer[BG_TEAM_HORDE] = 0;
RespawnFlagAfterDrop(HORDE);
}
}
if (m_FlagState[BG_TEAM_ALLIANCE] >= BG_WS_FLAG_STATE_ON_PLAYER && m_FlagState[BG_TEAM_HORDE] >= BG_WS_FLAG_STATE_ON_PLAYER)
{
if (m_FocusedAssault < BG_WS_FIVE_MINUTES)
{
for(uint8 i = 0; i < BG_TEAMS_COUNT; i++)
{
Player* carrier = sObjectMgr.GetPlayer(m_FlagKeepers[i]);
if (!carrier)
continue;
if ((!carrier->HasAura(BG_WS_SPELL_FOCUSED_ASSAULT) && !carrier->HasAura(BG_WS_SPELL_BRUTAL_ASSAULT)) ||
(m_FocusedAssaultExtra && m_FocusedAssault < diff))
carrier->CastSpell(carrier, (m_FocusedAssault < diff) ? BG_WS_SPELL_BRUTAL_ASSAULT : BG_WS_SPELL_FOCUSED_ASSAULT, true);
}
if (m_FocusedAssault < BG_WS_FIVE_MINUTES && m_FocusedAssaultExtra)
m_FocusedAssaultExtra = false;
}else m_FocusedAssault -= diff;
}else
{
m_FocusedAssault = BG_WS_CARRIER_DEBUFF;
m_FocusedAssaultExtra = true;
}
if (m_EndTimer > 0)
if (m_EndTimer <= diff)
{
uint32 allianceScore = GetTeamScore(ALLIANCE);
uint32 hordeScore = GetTeamScore(HORDE);
if (allianceScore > hordeScore)
EndBattleGround(ALLIANCE);
else if (allianceScore < hordeScore)
EndBattleGround(HORDE);
else
{
// if 0 => tie
EndBattleGround(m_LastCapturedFlagTeam);
}
}
else
{
uint32 minutesLeftPrev = GetRemainingTimeInMinutes();
m_EndTimer -= diff;
uint32 minutesLeft = GetRemainingTimeInMinutes();
if (minutesLeft != minutesLeftPrev)
UpdateWorldState(BG_WS_TIME_REMAINING, minutesLeft);
}
}
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BERSERK:
Talk(EMOTE_BERSERK_RAID);
Talk(SAY_BERSERK);
DoCast(me, SPELL_BERSERK);
break;
case EVENT_VAMPIRIC_BITE:
{
std::list<Player*> targets;
SelectRandomTarget(false, &targets);
if (!targets.empty())
{
Unit* target = targets.front();
DoCast(target, SPELL_VAMPIRIC_BITE);
DoCastAOE(SPELL_VAMPIRIC_BITE_DUMMY, true);
Talk(SAY_VAMPIRIC_BITE);
_vampires.insert(target->GetGUID());
target->CastSpell(target, SPELL_PRESENCE_OF_THE_DARKFALLEN, TRIGGERED_FULL_MASK);
target->CastSpell(target, SPELL_PRESENCE_OF_THE_DARKFALLEN_2, TRIGGERED_FULL_MASK);
}
break;
}
case EVENT_BLOOD_MIRROR:
{
// victim can be NULL when this is processed in the same update tick as EVENT_AIR_PHASE
if (me->GetVictim())
{
Player* newOfftank = SelectRandomTarget(true);
if (newOfftank)
{
if (_offtankGUID != newOfftank->GetGUID())
{
_offtankGUID = newOfftank->GetGUID();
// both spells have SPELL_ATTR5_SINGLE_TARGET_SPELL, no manual removal needed
newOfftank->CastSpell(me->GetVictim(), SPELL_BLOOD_MIRROR_DAMAGE, true);
me->EnsureVictim()->CastSpell(newOfftank, SPELL_BLOOD_MIRROR_DUMMY, true);
DoCastVictim(SPELL_BLOOD_MIRROR_VISUAL);
if (Is25ManRaid() && newOfftank->GetQuestStatus(QUEST_BLOOD_INFUSION) == QUEST_STATUS_INCOMPLETE &&
newOfftank->HasAura(SPELL_UNSATED_CRAVING) && !newOfftank->HasAura(SPELL_THIRST_QUENCHED) &&
!newOfftank->HasAura(SPELL_GUSHING_WOUND))
newOfftank->CastSpell(newOfftank, SPELL_GUSHING_WOUND, TRIGGERED_FULL_MASK);
}
}
else
_offtankGUID.Clear();
}
events.ScheduleEvent(EVENT_BLOOD_MIRROR, 2500, EVENT_GROUP_CANCELLABLE);
break;
}
case EVENT_DELIRIOUS_SLASH:
if (_offtankGUID && !me->HasByteFlag(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_ALWAYS_STAND | UNIT_BYTE1_FLAG_HOVER))
if (Player* _offtank = ObjectAccessor::GetPlayer(*me, _offtankGUID))
DoCast(_offtank, SPELL_DELIRIOUS_SLASH);
events.ScheduleEvent(EVENT_DELIRIOUS_SLASH, urand(20000, 24000), EVENT_GROUP_NORMAL);
break;
case EVENT_PACT_OF_THE_DARKFALLEN:
{
std::list<Player*> targets;
SelectRandomTarget(false, &targets);
Trinity::Containers::RandomResizeList(targets, Is25ManRaid() ? 3 : 2);
if (targets.size() > 1)
{
Talk(SAY_PACT_OF_THE_DARKFALLEN);
for (std::list<Player*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_PACT_OF_THE_DARKFALLEN);
}
events.ScheduleEvent(EVENT_PACT_OF_THE_DARKFALLEN, 30500, EVENT_GROUP_NORMAL);
break;
}
case EVENT_SWARMING_SHADOWS:
if (Player* target = SelectRandomTarget(false))
{
Talk(EMOTE_SWARMING_SHADOWS, target);
Talk(SAY_SWARMING_SHADOWS);
DoCast(target, SPELL_SWARMING_SHADOWS);
}
events.ScheduleEvent(EVENT_SWARMING_SHADOWS, 30500, EVENT_GROUP_NORMAL);
break;
case EVENT_TWILIGHT_BLOODBOLT:
{
std::list<Player*> targets;
SelectRandomTarget(false, &targets);
Trinity::Containers::RandomResizeList<Player*>(targets, uint32(Is25ManRaid() ? 4 : 2));
for (std::list<Player*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_TWILIGHT_BLOODBOLT);
DoCast(me, SPELL_TWILIGHT_BLOODBOLT_TARGET);
events.ScheduleEvent(EVENT_TWILIGHT_BLOODBOLT, urand(10000, 15000), EVENT_GROUP_NORMAL);
break;
}
case EVENT_AIR_PHASE:
DoStopAttack();
me->SetReactState(REACT_PASSIVE);
events.DelayEvents(10000, EVENT_GROUP_NORMAL);
events.CancelEventGroup(EVENT_GROUP_CANCELLABLE);
me->GetMotionMaster()->MovePoint(POINT_CENTER, centerPos);
break;
case EVENT_AIR_START_FLYING:
me->SetDisableGravity(true);
me->SetByteFlag(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_ALWAYS_STAND);
me->GetMotionMaster()->MovePoint(POINT_AIR, airPos);
break;
case EVENT_AIR_FLY_DOWN:
me->GetMotionMaster()->MovePoint(POINT_GROUND, centerPos);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
