void LFGQueue::RemoveGroupFromQueue(uint32 groupId, GroupLeaveMethod leaveMethod)
{
Group* grp = sObjectMgr.GetGroupById(groupId);
if(!grp)
return;
QueuedGroupsMap::iterator qGroup;
qGroup = m_QueuedGroups.find(groupId);
if(qGroup != m_QueuedGroups.end())
{
if(leaveMethod == GROUP_CLIENT_LEAVE)
{
WorldPacket data;
BuildSetQueuePacket(data, 0, MEETINGSTONE_STATUS_LEAVE_QUEUE);
grp->BroadcastPacket(&data, true);
}
else
{
// Send complete information to party
WorldPacket data;
BuildCompletePacket(data);
grp->BroadcastPacket(&data, true);
// Reset UI for party
BuildSetQueuePacket(data, 0, MEETINGSTONE_STATUS_NONE);
grp->BroadcastPacket(&data, true);
}
grp->SetLFGAreaId(0);
m_QueuedGroups.erase(qGroup);
}
}
void WorldSession::HandleRolePollBegin(WorldPacket& recvData)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_ROLE_POLL_BEGIN");
uint8 unk = 0;
recvData >> unk;
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
ObjectGuid guid = GetPlayer()->GetGUID();
WorldPacket data(SMSG_ROLL_POLL_INFORM);
uint8 bitsOrder[8] = { 0, 5, 7, 6, 1, 2, 4, 3 };
data.WriteBitInOrder(guid, bitsOrder);
data.WriteByteSeq(guid[5]);
data.WriteByteSeq(guid[0]);
data.WriteByteSeq(guid[3]);
data.WriteByteSeq(guid[4]);
data.WriteByteSeq(guid[7]);
data.WriteByteSeq(guid[2]);
data << uint8(unk);
data.WriteByteSeq(guid[6]);
data.WriteByteSeq(guid[1]);
group->BroadcastPacket(&data, false, -1);
}
void WorldSession::HandleRaidReadyCheckOpcode( WorldPacket & recv_data )
{
Group *group = GetPlayer()->GetGroup();
if(!group) return;
if(recv_data.empty()) // request
{
/** error handling **/
if(!group->IsLeader(GetPlayer()->GetGUID()))
return;
/********************/
// everything's fine, do it
WorldPacket data(MSG_RAID_READY_CHECK, 0);
group->BroadcastPacket(&data, -1, GetPlayer()->GetGUID());
}
else // answer
{
uint8 state;
recv_data >> state;
/** error handling **/
/********************/
// everything's fine, do it
Player *leader = objmgr.GetPlayer(group->GetLeaderGUID());
if(leader && leader->GetSession())
{
WorldPacket data(MSG_RAID_READY_CHECK, 9);
data << GetPlayer()->GetGUID();
data << state;
leader->GetSession()->SendPacket(&data);
}
}
}
void WorldSession::HandleRaidReadyCheckOpcode(WorldPacket& recv_data)
{
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
if (recv_data.empty()) // request
{
/** error handling **/
if (!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
return;
/********************/
// everything is fine, do it
WorldPacket data(MSG_RAID_READY_CHECK, 8);
data << GetPlayer()->GetGUID();
group->BroadcastPacket(&data, false, -1);
group->OfflineReadyCheck();
}
else // answer
{
uint8 state;
recv_data >> state;
// everything is fine, do it
WorldPacket data(MSG_RAID_READY_CHECK_CONFIRM, 9);
data << GetPlayer()->GetGUID();
data << state;
group->BroadcastReadyCheck(&data);
}
}
void WorldSession::HandleRaidReadyCheckOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG(LOG_FILTER_NETWORKIO, "WORLD: Received MSG_RAID_READY_CHECK");
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
if (recvData.empty()) // request
{
/** error handling **/
if (!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
return;
/********************/
// everything's fine, do it
WorldPacket data(MSG_RAID_READY_CHECK, 8);
data << GetPlayer()->GetGUID();
group->BroadcastPacket(&data, false, -1);
group->OfflineReadyCheck();
}
else // answer
{
uint8 state;
recvData >> state;
// everything's fine, do it
WorldPacket data(MSG_RAID_READY_CHECK_CONFIRM, 9);
data << uint64(GetPlayer()->GetGUID());
data << uint8(state);
group->BroadcastReadyCheck(&data);
}
}
void WorldSession::HandleRaidReadyCheckOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_RAID_READY_CHECK");
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
ObjectGuid playerGuid = GetPlayer()->GetGUID();
/** error handling **/
if (!group->IsLeader(playerGuid) && !group->IsAssistant(playerGuid))
return;
/********************/
ObjectGuid groupGuid = group->GetGUID();
// everything's fine, do it
WorldPacket data(SMSG_RAID_READY_CHECK, 1 + 8 + 1 + 8 + 1 + 4);
data.WriteBit(playerGuid[4]);
data.WriteBit(groupGuid[1]);
data.WriteBit(groupGuid[4]);
data.WriteBit(playerGuid[6]);
data.WriteBit(groupGuid[7]);
data.WriteBit(groupGuid[6]);
data.WriteBit(playerGuid[2]);
data.WriteBit(playerGuid[0]);
data.WriteBit(playerGuid[7]);
data.WriteBit(groupGuid[0]);
data.WriteBit(groupGuid[3]);
data.WriteBit(groupGuid[5]);
data.WriteBit(playerGuid[5]);
data.WriteBit(playerGuid[3]);
data.WriteBit(playerGuid[1]);
data.WriteBit(groupGuid[2]);
data.WriteByteSeq(groupGuid[6]);
data.WriteByteSeq(groupGuid[0]);
data.WriteByteSeq(playerGuid[4]);
data.WriteByteSeq(playerGuid[7]);
data.WriteByteSeq(groupGuid[5]);
data.WriteByteSeq(groupGuid[7]);
data.WriteByteSeq(playerGuid[6]);
data.WriteByteSeq(playerGuid[3]);
data << uint8(0); // Unknown
data.WriteByteSeq(groupGuid[1]);
data.WriteByteSeq(playerGuid[2]);
data.WriteByteSeq(groupGuid[3]);
data.WriteByteSeq(playerGuid[5]);
data.WriteByteSeq(groupGuid[4]);
data.WriteByteSeq(groupGuid[2]);
data << uint32(35000); // Ready check duration (35 sec)
data.WriteByteSeq(playerGuid[1]);
data.WriteByteSeq(playerGuid[0]);
group->BroadcastPacket(&data, false, -1);
group->OfflineReadyCheck();
}
void WorldSession::HandleRaidLeaderReadyCheck(WorldPacket& recvData)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_RAID_LEADER_READY_CHECK");
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
if (!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()) && !(group->GetGroupType() & GROUPTYPE_EVERYONE_IS_ASSISTANT))
return;
uint32 readyCheckDuration = 35000;
ObjectGuid groupGUID = group->GetGUID();
ObjectGuid leaderGUID = GetPlayer()->GetGUID();
group->SetReadyCheckCount(1);
WorldPacket data(SMSG_RAID_READY_CHECK, 1 + 8 + 1 + 8 + 1 + 4);
data.WriteBit(groupGUID[4]);
data.WriteBit(groupGUID[2]);
data.WriteBit(leaderGUID[4]);
data.WriteBit(groupGUID[3]);
data.WriteBit(groupGUID[7]);
data.WriteBit(groupGUID[1]);
data.WriteBit(groupGUID[0]);
data.WriteBit(leaderGUID[6]);
data.WriteBit(leaderGUID[5]);
data.WriteBit(groupGUID[6]);
data.WriteBit(groupGUID[5]);
data.WriteBit(leaderGUID[0]);
data.WriteBit(leaderGUID[1]);
data.WriteBit(leaderGUID[2]);
data.WriteBit(leaderGUID[7]);
data.WriteBit(leaderGUID[3]);
data << uint32(readyCheckDuration);
data.WriteByteSeq(groupGUID[2]);
data.WriteByteSeq(groupGUID[7]);
data.WriteByteSeq(groupGUID[3]);
data.WriteByteSeq(leaderGUID[4]);
data.WriteByteSeq(groupGUID[1]);
data.WriteByteSeq(groupGUID[0]);
data.WriteByteSeq(leaderGUID[1]);
data.WriteByteSeq(leaderGUID[2]);
data.WriteByteSeq(leaderGUID[6]);
data.WriteByteSeq(leaderGUID[5]);
data.WriteByteSeq(groupGUID[6]);
data.WriteByteSeq(leaderGUID[0]);
data << uint8(0); // unknown
data.WriteByteSeq(leaderGUID[7]);
data.WriteByteSeq(groupGUID[4]);
data.WriteByteSeq(leaderGUID[3]);
data.WriteByteSeq(groupGUID[5]);
group->BroadcastPacket(&data, false, -1);
group->OfflineReadyCheck();
}
void WorldSession::HandleRaidReadyCheckFinishedOpcode(WorldPacket& /*recv_data*/)
{
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
if (!group->IsLeader(GetPlayer()->GetObjectGuid()) && !group->IsAssistant(GetPlayer()->GetObjectGuid()))
return;
// Broadcast finish:
WorldPacket data(MSG_RAID_READY_CHECK_FINISHED, 0);
group->BroadcastPacket(&data, true, -1);
}
// Add group or player into queue. If player has group and he's a leader then whole party will be added to queue.
void LFGQueue::AddToQueue(Player* leader, uint32 queAreaID)
{
if(!leader)
return;
if (AreaTableEntry const* areaEntry = GetAreaEntryByAreaID(queAreaID))
{
if (DisableMgr::IsDisabledFor(DISABLE_TYPE_MAP, areaEntry->mapid))
{
ChatHandler(leader->GetSession()).SendSysMessage(LANG_MAP_IS_DISABLED);
return;
}
}
Group* grp = leader->GetGroup();
//add players from group to queue list & group to group list
// Calculate what roles group need and add it to the GroupQueueList, (DONT'ADD PLAYERS!)
if (grp && grp->IsLeader(leader->GetObjectGuid()))
{
// Add group to queued groups list
LFGGroupQueueInfo& i_Group = m_QueuedGroups[grp->GetId()];
grp->CalculateLFGRoles(i_Group);
i_Group.team = leader->GetTeam();
i_Group.areaId = queAreaID;
i_Group.groupTimer = 5 * MINUTE * IN_MILLISECONDS; // Minute timer for SMSG_MEETINGSTONE_IN_PROGRESS
grp->SetLFGAreaId(queAreaID);
WorldPacket data;
BuildSetQueuePacket(data, queAreaID, MEETINGSTONE_STATUS_JOINED_QUEUE);
grp->BroadcastPacket(&data, true);
}
else if(!grp)
{
// Add player to queued players list
LFGPlayerQueueInfo& i_Player = m_QueuedPlayers[leader->GetObjectGuid()];
i_Player.roleMask = CalculateRoles((Classes)leader->getClass());
i_Player.team = leader->GetTeam();
i_Player.areaId = queAreaID;
i_Player.hasQueuePriority = false;
leader->GetSession()->SendMeetingstoneSetqueue(queAreaID, MEETINGSTONE_STATUS_JOINED_QUEUE);
}
else // Player is in group, but it's not leader
MANGOS_ASSERT(false && "LFGQueue::AddToQueue called while player is not leader and in group.");
}
void WorldSession::HandleInitiateRolePoll(WorldPackets::Party::InitiateRolePoll& packet)
{
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
ObjectGuid guid = GetPlayer()->GetGUID();
if (!group->IsLeader(guid) && !group->IsAssistant(guid))
return;
WorldPackets::Party::RolePollInform rolePollInform;
rolePollInform.From = GetPlayer()->GetGUID();
rolePollInform.PartyIndex = packet.PartyIndex;
group->BroadcastPacket(rolePollInform.Write(), true);
}
void WorldSession::HandleSetRoleOpcode(WorldPackets::Party::SetRole& packet)
{
WorldPackets::Party::RoleChangedInform roleChangedInform;
Group* group = GetPlayer()->GetGroup();
uint8 oldRole = group ? group->GetLfgRoles(packet.TargetGUID) : 0;
if (oldRole == packet.Role)
return;
roleChangedInform.PartyIndex = packet.PartyIndex;
roleChangedInform.From = GetPlayer()->GetGUID();
roleChangedInform.ChangedUnit = packet.TargetGUID;
roleChangedInform.OldRole = oldRole;
roleChangedInform.NewRole = packet.Role;
if (group)
{
group->BroadcastPacket(roleChangedInform.Write(), false);
group->SetLfgRoles(packet.TargetGUID, packet.Role);
}
else
SendPacket(roleChangedInform.Write());
}
void WorldSession::HandleRaidReadyCheckOpcode(WorldPacket& recv_data)
{
if (recv_data.empty()) // request
{
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
/** error handling **/
if (!group->IsLeader(GetPlayer()->GetObjectGuid()) &&
!group->IsAssistant(GetPlayer()->GetObjectGuid()))
return;
/********************/
// everything is fine, do it
WorldPacket data(SMSG_READY_CHECK_STARTED, 8);
data << ObjectGuid(GetPlayer()->GetObjectGuid());
group->BroadcastPacket(&data, false, -1);
group->OfflineReadyCheck();
}
else // answer
{
uint8 state;
recv_data >> state;
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
// everything is fine, do it
WorldPacket data(SMSG_READY_CHECK_COMPLETED, 9);
data << GetPlayer()->GetObjectGuid();
data << uint8(state);
group->BroadcastReadyCheck(&data);
}
}
void WorldSession::HandleGroupSetRolesOpcode(WorldPacket& recvData)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_GROUP_SET_ROLES");
ObjectGuid targetGuid; // Target GUID
uint32 newRole = 0;
uint8 unk = 0;
recvData >> unk;
recvData >> newRole;
uint8 bitOrder[8] = { 5, 3, 1, 0, 2, 6, 7, 4 };
recvData.ReadBitInOrder(targetGuid, bitOrder);
recvData.FlushBits();
uint8 byteOrder[8] = { 4, 6, 1, 3, 0, 7, 5, 2 };
recvData.ReadBytesSeq(targetGuid, byteOrder);
Player* tPlayer = ObjectAccessor::FindPlayer(targetGuid);
Group* group = GetPlayer()->GetGroup();
if (!tPlayer)
return;
if (tPlayer && group)
{
// If the target is in another group.
if (group != tPlayer->GetGroup())
return;
// If the target is in the same group but the assigner is not the target itself, neither the leader or assistant (Can only change own roles).
if (!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()) && !(group->GetGroupType() & GROUPTYPE_EVERYONE_IS_ASSISTANT))
if (GetPlayer() != tPlayer)
return;
}
ObjectGuid assignerGuid = GetPlayer()->GetGUID(); // Assigner GUID
WorldPacket data(SMSG_ROLE_CHANGED_INFORM, 1 + 8 + 1 + 8 + 4 + 1 + 4);
data.WriteBit(targetGuid[3]);
data.WriteBit(assignerGuid[3]);
data.WriteBit(assignerGuid[0]);
data.WriteBit(targetGuid[5]);
data.WriteBit(targetGuid[4]);
data.WriteBit(assignerGuid[1]);
data.WriteBit(assignerGuid[7]);
data.WriteBit(assignerGuid[4]);
data.WriteBit(targetGuid[0]);
data.WriteBit(assignerGuid[2]);
data.WriteBit(targetGuid[2]);
data.WriteBit(assignerGuid[5]);
data.WriteBit(targetGuid[6]);
data.WriteBit(targetGuid[1]);
data.WriteBit(assignerGuid[6]);
data.WriteBit(targetGuid[7]);
data.FlushBits();
data.WriteByteSeq(assignerGuid[5]);
data.WriteByteSeq(targetGuid[7]);
data.WriteByteSeq(assignerGuid[4]);
data.WriteByteSeq(targetGuid[3]);
data.WriteByteSeq(assignerGuid[1]);
data.WriteByteSeq(assignerGuid[0]);
data << uint32(newRole); // New Role
data.WriteByteSeq(assignerGuid[6]);
data << uint8(unk); // Unknown - The uint8 in the CMSG above.
data.WriteByteSeq(targetGuid[2]);
data.WriteByteSeq(targetGuid[5]);
data.WriteByteSeq(targetGuid[1]);
data.WriteByteSeq(assignerGuid[3]);
data << uint32(group ? group->getGroupMemberRole(targetGuid) : 0); // Old Role
data.WriteByteSeq(targetGuid[4]);
data.WriteByteSeq(assignerGuid[2]);
data.WriteByteSeq(targetGuid[0]);
data.WriteByteSeq(assignerGuid[7]);
data.WriteByteSeq(targetGuid[6]);
if (group)
{
group->setGroupMemberRole(targetGuid, newRole);
group->SendUpdate();
group->BroadcastPacket(&data, false);
}
else
SendPacket(&data);
}
void WorldSession::HandleMessagechatOpcode( WorldPacket & recv_data )
{
CHECK_PACKET_SIZE(recv_data,4+4+1);
uint32 type;
uint32 lang;
recv_data >> type;
recv_data >> lang;
//sLog.outDebug("CHAT: packet received. type %u, lang %u", type, lang );
// prevent talking at unknown language (cheating)
LanguageDesc const* langDesc = GetLanguageDescByID(lang);
if(!langDesc || langDesc->skill_id != 0 && !_player->HasSkill(langDesc->skill_id))
{
SendNotification("Unknown language");
return;
}
// send in universal language if player in .gmon mode (ignore spell effects)
if (_player->isGameMaster())
lang = LANG_UNIVERSAL;
else
{
// send in universal language in two side iteration allowed mode
if (sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT) || _player->isGameMaster())
lang = LANG_UNIVERSAL;
// but overwrite it by SPELL_AURA_MOD_LANGUAGE auras (only single case used)
Unit::AuraList& ModLangAuras = _player->GetAurasByType(SPELL_AURA_MOD_LANGUAGE);
if(!ModLangAuras.empty())
lang = ModLangAuras.front()->GetModifier()->m_miscvalue;
}
if (!_player->CanSpeak())
{
std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
SendNotification(LANG_WAIT_BEFORE_SPEAKING,timeStr.c_str());
return;
}
switch(type)
{
case CHAT_MSG_SAY:
case CHAT_MSG_EMOTE:
case CHAT_MSG_YELL:
{
std::string msg = "";
recv_data >> msg;
if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
break;
if(type == CHAT_MSG_SAY)
{
GetPlayer()->Say(msg, lang);
GetPlayer()->UpdateSpeakTime();
}
else if(type == CHAT_MSG_EMOTE)
{
GetPlayer()->TextEmote(msg);
GetPlayer()->UpdateSpeakTime();
}
else if(type == CHAT_MSG_YELL)
{
GetPlayer()->Yell(msg, lang);
GetPlayer()->UpdateSpeakTime();
}
} break;
case CHAT_MSG_WHISPER:
{
std::string to, msg;
recv_data >> to;
CHECK_PACKET_SIZE(recv_data,4+4+(to.size()+1)+1);
recv_data >> msg;
if(to.size() == 0)
{
WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
data<<to;
SendPacket(&data);
break;
}
normalizePlayerName(to);
Player *player = objmgr.GetPlayer(to.c_str());
uint32 tSecurity = GetSecurity();
uint32 pSecurity = player ? player->GetSession()->GetSecurity() : 0;
if(!player || tSecurity == SEC_PLAYER && pSecurity > SEC_PLAYER && !player->isAcceptWhispers())
{
WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
data<<to;
SendPacket(&data);
return;
}
if (!sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT) && tSecurity == SEC_PLAYER && pSecurity == SEC_PLAYER )
{
uint32 sidea = GetPlayer()->GetTeam();
uint32 sideb = player->GetTeam();
if( sidea != sideb )
{
WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
data<<to;
SendPacket(&data);
return;
}
}
GetPlayer()->Whisper(player->GetGUID(), msg, lang);
GetPlayer()->UpdateSpeakTime();
} break;
case CHAT_MSG_PARTY:
{
std::string msg = "";
recv_data >> msg;
if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
break;
Group *group = GetPlayer()->groupInfo.group;
if(!group)
return;
WorldPacket data;
sChatHandler.FillMessageData(&data, this, CHAT_MSG_PARTY, lang, NULL, 0, msg.c_str());
group->BroadcastPacket(&data, group->GetMemberGroup(GetPlayer()->GetGUID()));
GetPlayer()->UpdateSpeakTime();
}
break;
case CHAT_MSG_GUILD:
{
std::string msg = "";
recv_data >> msg;
if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
break;
if (GetPlayer()->GetGuildId())
{
Guild *guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
if (guild)
{
guild->BroadcastToGuild(this, msg);
GetPlayer()->UpdateSpeakTime();
}
}
break;
}
case CHAT_MSG_OFFICER:
{
std::string msg = "";
recv_data >> msg;
if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
break;
if (GetPlayer()->GetGuildId())
{
Guild *guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
if (guild)
{
guild->BroadcastToOfficers(this, msg);
GetPlayer()->UpdateSpeakTime();
}
}
break;
}
case CHAT_MSG_RAID:
{
std::string msg="";
recv_data >> msg;
if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
break;
Group *group = GetPlayer()->groupInfo.group;
if(!group || !group->isRaidGroup())
return;
WorldPacket data;
sChatHandler.FillMessageData(&data, this, CHAT_MSG_RAID, lang, "", 0, msg.c_str());
group->BroadcastPacket(&data);
GetPlayer()->UpdateSpeakTime();
} break;
case CHAT_MSG_RAID_LEADER:
{
std::string msg="";
recv_data >> msg;
if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
break;
Group *group = GetPlayer()->groupInfo.group;
if(!group || !group->isRaidGroup() || !group->IsLeader(GetPlayer()->GetGUID()))
return;
WorldPacket data;
sChatHandler.FillMessageData(&data, this, CHAT_MSG_RAID_LEADER, lang, "", 0, msg.c_str());
group->BroadcastPacket(&data);
GetPlayer()->UpdateSpeakTime();
} break;
case CHAT_MSG_RAID_WARN:
{
std::string msg="";
recv_data >> msg;
Group *group = GetPlayer()->groupInfo.group;
if(!group || !group->isRaidGroup() || !group->IsLeader(GetPlayer()->GetGUID()))
return;
WorldPacket data;
sChatHandler.FillMessageData(&data, this, CHAT_MSG_RAID_WARN, lang, "", 0, msg.c_str());
group->BroadcastPacket(&data);
GetPlayer()->UpdateSpeakTime();
} break;
case CHAT_MSG_BATTLEGROUND_CHAT:
{
std::string msg="";
recv_data >> msg;
Group *group = GetPlayer()->groupInfo.group;
if(!group || !group->isRaidGroup())
return;
WorldPacket data;
sChatHandler.FillMessageData(&data, this, CHAT_MSG_BATTLEGROUND_CHAT, lang, "", 0, msg.c_str());
group->BroadcastPacket(&data);
GetPlayer()->UpdateSpeakTime();
} break;
case CHAT_MSG_BATTLEGROUND_LEADER:
{
std::string msg="";
recv_data >> msg;
Group *group = GetPlayer()->groupInfo.group;
if(!group || !group->isRaidGroup() || !group->IsLeader(GetPlayer()->GetGUID()))
return;
WorldPacket data;
sChatHandler.FillMessageData(&data, this, CHAT_MSG_BATTLEGROUND_LEADER, lang, "", 0, msg.c_str());
group->BroadcastPacket(&data);
GetPlayer()->UpdateSpeakTime();
} break;
case CHAT_MSG_CHANNEL:
{
std::string channel = "", msg = "";
recv_data >> channel;
// recheck
CHECK_PACKET_SIZE(recv_data,4+4+(channel.size()+1)+1);
recv_data >> msg;
if(ChannelMgr* cMgr = channelMgr(_player->GetTeam()))
{
if(Channel *chn = cMgr->GetChannel(channel,_player))
{
chn->Say(_player->GetGUID(),msg.c_str(),lang);
GetPlayer()->UpdateSpeakTime();
}
}
} break;
case CHAT_MSG_AFK:
{
std::string msg;
recv_data >> msg;
_player->afkMsg = msg;
if((msg.size() == 0 || !_player->isAFK()) && !_player->isInCombat() )
{
_player->ToggleAFK();
if(_player->isAFK() && _player->isDND())
_player->ToggleDND();
}
} break;
case CHAT_MSG_DND:
{
std::string msg;
recv_data >> msg;
GetPlayer()->dndMsg = msg;
if(msg.size() == 0 || !GetPlayer()->isDND())
{
GetPlayer()->ToggleDND();
if(GetPlayer()->isDND() && GetPlayer()->isAFK())
GetPlayer()->ToggleAFK();
}
} break;
default:
sLog.outError("CHAT: unknown msg type %u, lang: %u", type, lang);
}
}
void LFGQueue::Update(uint32 diff)
{
if(m_QueuedGroups.empty() && m_QueuedPlayers.empty())
return;
// Iterate over QueuedPlayersMap to update players timers and remove offline/disconnected players.
for(QueuedPlayersMap::iterator qPlayer = m_QueuedPlayers.begin(); qPlayer != m_QueuedPlayers.end(); ++qPlayer)
{
Player* plr = sObjectMgr.GetPlayer(qPlayer->first);
// Player could have been disconnected
if(!plr ||!plr->IsInWorld())
{
m_OfflinePlayers[qPlayer->first] = qPlayer->second;
m_QueuedPlayers.erase(qPlayer);
break;
}
qPlayer->second.timeInLFG += diff;
// Update player timer and give him queue priority.
if(qPlayer->second.timeInLFG >= (30 * MINUTE * IN_MILLISECONDS))
{
qPlayer->second.hasQueuePriority = true;
}
}
if(!m_QueuedGroups.empty())
{
// Iterate over QueuedGroupsMap to fill groups with roles they're missing.
for(QueuedGroupsMap::iterator qGroup = m_QueuedGroups.begin(); qGroup != m_QueuedGroups.end(); ++qGroup)
{
Group* grp = sObjectMgr.GetGroupById(qGroup->first);
// Safe check
if(!grp)
return;
// Remove group from Queue if it's full
if(grp->IsFull())
{
RemoveGroupFromQueue(qGroup->first, GROUP_SYSTEM_LEAVE);
break;
}
// Iterate over QueuedPlayersMap to find suitable player to join group
for(QueuedPlayersMap::iterator qPlayer = m_QueuedPlayers.begin(); qPlayer != m_QueuedPlayers.end(); ++qPlayer)
{
Player* plr = sObjectMgr.GetPlayer(qPlayer->first);
// Check here that players team and areaId they're in queue are same
if(qPlayer->second.team == qGroup->second.team &&
qPlayer->second.areaId == qGroup->second.areaId)
{
// Check if player can perform tank role
if((canPerformRole(qPlayer->second.roleMask, LFG_ROLE_TANK) & qGroup->second.availableRoles) == LFG_ROLE_TANK)
{
if(FindRoleToGroup(plr, grp, LFG_ROLE_TANK))
{
break;
}
else
{
continue;
}
}
// Check if player can perform healer role
if((canPerformRole(qPlayer->second.roleMask, LFG_ROLE_HEALER) & qGroup->second.availableRoles) == LFG_ROLE_HEALER)
{
if(FindRoleToGroup(plr, grp, LFG_ROLE_HEALER))
{
break;
}
else
{
continue;
}
}
// Check if player can perform dps role
if((canPerformRole(qPlayer->second.roleMask, LFG_ROLE_DPS) & qGroup->second.availableRoles) == LFG_ROLE_DPS)
{
if(FindRoleToGroup(plr, grp, LFG_ROLE_DPS))
{
break;
}
else
{
continue;
}
}
// Check if group is full, no need to try to iterate same group if it's already full.
if(grp->IsFull())
{
RemoveGroupFromQueue(qGroup->first, GROUP_SYSTEM_LEAVE);
break;
}
}
}
// Update group timer. After each 5 minutes group will be broadcasted they're still waiting more members.
if (qGroup->second.groupTimer <= diff)
{
WorldPacket data;
BuildInProgressPacket(data);
grp->BroadcastPacket(&data, true);
qGroup->second.groupTimer = 5 * MINUTE * IN_MILLISECONDS;
}
else
{
qGroup->second.groupTimer -= diff;
}
}
}
// Pick first 2 players and form group out of them also inserting them into queue as group.
if(m_QueuedPlayers.size() > 5)
{
// Pick Leader as first target.
QueuedPlayersMap::iterator nPlayer1 = m_QueuedPlayers.begin();
if(findInArea(nPlayer1->second.areaId) > 5)
{
Group* newQueueGroup = new Group;
// Iterate of QueuedPlayersMap and pick first member to accompany leader.
for(QueuedPlayersMap::iterator nPlayer2 = m_QueuedPlayers.begin(); nPlayer2 != m_QueuedPlayers.end(); ++nPlayer2)
{
if(nPlayer1->first == nPlayer2->first)
continue;
if(nPlayer1->second.team == nPlayer2->second.team &&
nPlayer1->second.areaId == nPlayer2->second.areaId)
{
Player* leader = sObjectMgr.GetPlayer(nPlayer1->first);
Player* member = sObjectMgr.GetPlayer(nPlayer2->first);
uint32 areaId = nPlayer1->second.areaId;
if(!newQueueGroup->IsCreated())
{
if(newQueueGroup->Create(leader->GetObjectGuid(), leader->GetName()))
sObjectMgr.AddGroup(newQueueGroup);
else
return;
}
WorldPacket data;
BuildMemberAddedPacket(data, member->GetGUID());
leader->GetSession()->SendPacket(&data);
// Add member to the group. Leader is already added upon creation of group.
newQueueGroup->AddMember(member->GetObjectGuid(), member->GetName(), GROUP_LFG);
// Add this new group to GroupQueue now and remove players from PlayerQueue
RemovePlayerFromQueue(nPlayer1->first, PLAYER_SYSTEM_LEAVE);
RemovePlayerFromQueue(nPlayer2->first, PLAYER_SYSTEM_LEAVE);
AddToQueue(leader, areaId);
break;
}
}
}
}
}
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 WorldSession::HandleMessagechatOpcode( WorldPacket & recv_data )
{
CHECK_PACKET_SIZE(recv_data,4+4+1);
uint32 type;
uint32 lang;
recv_data >> type;
recv_data >> lang;
if(type >= MAX_CHAT_MSG_TYPE)
{
sLog.outError("CHAT: Wrong message type received: %u", type);
return;
}
//sLog.outDebug("CHAT: packet received. type %u, lang %u", type, lang );
// prevent talking at unknown language (cheating)
LanguageDesc const* langDesc = GetLanguageDescByID(lang);
if(!langDesc || langDesc->skill_id != 0 && !_player->HasSkill(langDesc->skill_id))
{
SendNotification("Unknown language");
return;
}
if(lang == LANG_ADDON)
{
// Disabled addon channel?
if(!sWorld.getConfig(CONFIG_ADDON_CHANNEL))
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 (_player->isGameMaster())
lang = LANG_UNIVERSAL;
else
{
// send in universal language in two side iteration allowed mode
if (sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT))
lang = LANG_UNIVERSAL;
else
{
switch(type)
{
case CHAT_MSG_PARTY:
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.getConfig(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.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD))
lang = LANG_UNIVERSAL;
break;
}
}
// but overwrite it by SPELL_AURA_MOD_LANGUAGE auras (only single case used)
Unit::AuraList const& ModLangAuras = _player->GetAurasByType(SPELL_AURA_MOD_LANGUAGE);
if(!ModLangAuras.empty())
lang = ModLangAuras.front()->GetModifier()->m_miscvalue;
}
if (!_player->CanSpeak())
{
std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
SendNotification(objmgr.GetMangosString(LANG_WAIT_BEFORE_SPEAKING, GetSessionLocaleIndex()),timeStr.c_str());
return;
}
if (type != CHAT_MSG_AFK && type != CHAT_MSG_DND)
GetPlayer()->UpdateSpeakTime();
}
switch(type)
{
case CHAT_MSG_SAY:
case CHAT_MSG_EMOTE:
case CHAT_MSG_YELL:
{
std::string msg = "";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
// strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if(msg.empty())
break;
if(type == CHAT_MSG_SAY)
GetPlayer()->Say(msg, lang);
else if(type == CHAT_MSG_EMOTE)
GetPlayer()->TextEmote(msg);
else if(type == CHAT_MSG_YELL)
GetPlayer()->Yell(msg, lang);
} break;
case CHAT_MSG_WHISPER:
{
std::string to, msg;
recv_data >> to;
CHECK_PACKET_SIZE(recv_data,4+4+(to.size()+1)+1);
recv_data >> msg;
// strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if(msg.empty())
break;
if(to.empty())
{
WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
data<<to;
SendPacket(&data);
break;
}
normalizePlayerName(to);
Player *player = objmgr.GetPlayer(to.c_str());
uint32 tSecurity = GetSecurity();
uint32 pSecurity = player ? player->GetSession()->GetSecurity() : 0;
if(!player || tSecurity == SEC_PLAYER && pSecurity > SEC_PLAYER && !player->isAcceptWhispers())
{
WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
data<<to;
SendPacket(&data);
return;
}
if (!sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT) && tSecurity == SEC_PLAYER && pSecurity == SEC_PLAYER )
{
uint32 sidea = GetPlayer()->GetTeam();
uint32 sideb = player->GetTeam();
if( sidea != sideb )
{
WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
data<<to;
SendPacket(&data);
return;
}
}
GetPlayer()->Whisper(player->GetGUID(), msg, lang);
} break;
case CHAT_MSG_PARTY:
{
std::string msg = "";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
// strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if(msg.empty())
break;
Group *group = GetPlayer()->GetGroup();
if(!group)
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_PARTY, lang, NULL, 0, msg.c_str(),NULL);
group->BroadcastPacket(&data, group->GetMemberGroup(GetPlayer()->GetGUID()));
}
break;
case CHAT_MSG_GUILD:
{
std::string msg = "";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
// strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if(msg.empty())
break;
if (GetPlayer()->GetGuildId())
{
Guild *guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
if (guild)
guild->BroadcastToGuild(this, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
}
break;
}
case CHAT_MSG_OFFICER:
{
std::string msg = "";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
// strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if(msg.empty())
break;
if (GetPlayer()->GetGuildId())
{
Guild *guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
if (guild)
guild->BroadcastToOfficers(this, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
}
break;
}
case CHAT_MSG_RAID:
{
std::string msg="";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
// strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if(msg.empty())
break;
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isRaidGroup())
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID, lang, "", 0, msg.c_str(),NULL);
group->BroadcastPacket(&data);
} break;
case CHAT_MSG_RAID_LEADER:
{
std::string msg="";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
// strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if(msg.empty())
break;
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isRaidGroup() || !group->IsLeader(GetPlayer()->GetGUID()))
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID_LEADER, lang, "", 0, msg.c_str(),NULL);
group->BroadcastPacket(&data);
} break;
case CHAT_MSG_RAID_WARNING:
{
std::string msg="";
recv_data >> msg;
// strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if(msg.empty())
break;
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isRaidGroup() || !(group->IsLeader(GetPlayer()->GetGUID()) || group->IsAssistant(GetPlayer()->GetGUID())))
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID_WARNING, lang, "", 0, msg.c_str(),NULL);
group->BroadcastPacket(&data);
} break;
case CHAT_MSG_BATTLEGROUND:
{
std::string msg="";
recv_data >> msg;
// strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if(msg.empty())
break;
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isRaidGroup())
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_BATTLEGROUND, lang, "", 0, msg.c_str(),NULL);
group->BroadcastPacket(&data);
} break;
case CHAT_MSG_BATTLEGROUND_LEADER:
{
std::string msg="";
recv_data >> msg;
// strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if(msg.empty())
break;
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isRaidGroup() || !group->IsLeader(GetPlayer()->GetGUID()))
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_BATTLEGROUND_LEADER, lang, "", 0, msg.c_str(),NULL);
group->BroadcastPacket(&data);
} break;
case CHAT_MSG_CHANNEL:
{
std::string channel = "", msg = "";
recv_data >> channel;
// recheck
CHECK_PACKET_SIZE(recv_data,4+4+(channel.size()+1)+1);
recv_data >> msg;
// strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld.getConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
if(msg.empty())
break;
if(ChannelMgr* cMgr = channelMgr(_player->GetTeam()))
{
if(Channel *chn = cMgr->GetChannel(channel,_player))
chn->Say(_player->GetGUID(),msg.c_str(),lang);
}
} break;
case CHAT_MSG_AFK:
{
std::string msg;
recv_data >> msg;
if((msg.empty() || !_player->isAFK()) && !_player->isInCombat() )
{
if(!_player->isAFK())
{
if(msg.empty())
msg = objmgr.GetMangosString(LANG_PLAYER_AFK_DEFAULT,GetSessionLocaleIndex());
_player->afkMsg = msg;
}
_player->ToggleAFK();
if(_player->isAFK() && _player->isDND())
_player->ToggleDND();
}
} break;
case CHAT_MSG_DND:
{
std::string msg;
recv_data >> msg;
if(msg.empty() || !_player->isDND())
{
if(!_player->isDND())
{
if(msg.empty())
msg = objmgr.GetMangosString(LANG_PLAYER_DND_DEFAULT,GetSessionLocaleIndex());
_player->dndMsg = msg;
}
_player->ToggleDND();
if(_player->isDND() && _player->isAFK())
_player->ToggleAFK();
}
} break;
default:
sLog.outError("CHAT: unknown message type %u, lang: %u", type, lang);
break;
}
}
void WorldSession::HandleRaidConfirmReadyCheck(WorldPacket& recvData)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_RAID_CONFIRM_READY_CHECK");
ObjectGuid guid; // currently unused
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
recvData.read_skip<uint8>();
guid[2] = recvData.ReadBit();
guid[1] = recvData.ReadBit();
guid[0] = recvData.ReadBit();
guid[3] = recvData.ReadBit();
guid[6] = recvData.ReadBit();
bool status = recvData.ReadBit();
guid[7] = recvData.ReadBit();
guid[4] = recvData.ReadBit();
guid[5] = recvData.ReadBit();
recvData.ReadByteSeq(guid[1]);
recvData.ReadByteSeq(guid[0]);
recvData.ReadByteSeq(guid[3]);
recvData.ReadByteSeq(guid[2]);
recvData.ReadByteSeq(guid[4]);
recvData.ReadByteSeq(guid[5]);
recvData.ReadByteSeq(guid[7]);
recvData.ReadByteSeq(guid[6]);
ObjectGuid playerGuid = GetPlayer()->GetGUID();
ObjectGuid groupGuid = group->GetGUID();
group->SetReadyCheckCount(group->GetReadyCheckCount() + 1);
WorldPacket data(SMSG_RAID_READY_CHECK_CONFIRM, 1 + 1 + 8 + 1 + 8);
data.WriteBit(groupGuid[4]);
data.WriteBit(playerGuid[5]);
data.WriteBit(playerGuid[3]);
data.WriteBit(status);
data.WriteBit(groupGuid[2]);
data.WriteBit(playerGuid[6]);
data.WriteBit(groupGuid[3]);
data.WriteBit(playerGuid[0]);
data.WriteBit(playerGuid[1]);
data.WriteBit(groupGuid[1]);
data.WriteBit(groupGuid[5]);
data.WriteBit(playerGuid[7]);
data.WriteBit(playerGuid[4]);
data.WriteBit(groupGuid[6]);
data.WriteBit(playerGuid[2]);
data.WriteBit(groupGuid[0]);
data.WriteBit(groupGuid[7]);
data.FlushBits();
data.WriteByteSeq(playerGuid[4]);
data.WriteByteSeq(playerGuid[2]);
data.WriteByteSeq(playerGuid[1]);
data.WriteByteSeq(groupGuid[4]);
data.WriteByteSeq(groupGuid[2]);
data.WriteByteSeq(playerGuid[0]);
data.WriteByteSeq(groupGuid[5]);
data.WriteByteSeq(groupGuid[3]);
data.WriteByteSeq(playerGuid[7]);
data.WriteByteSeq(groupGuid[6]);
data.WriteByteSeq(groupGuid[1]);
data.WriteByteSeq(playerGuid[6]);
data.WriteByteSeq(playerGuid[3]);
data.WriteByteSeq(playerGuid[5]);
data.WriteByteSeq(groupGuid[0]);
data.WriteByteSeq(groupGuid[7]);
group->BroadcastPacket(&data, true);
// Send SMSG_RAID_READY_CHECK_COMPLETED
if (group->GetReadyCheckCount() >= group->GetMembersCount())
{
ObjectGuid grpGUID = group->GetGUID();
data.Initialize(SMSG_RAID_READY_CHECK_COMPLETED, 1 + 8 + 1);
uint8 bitOrder[8] = { 4, 2, 5, 7, 1, 0, 3, 6 };
data.WriteBitInOrder(grpGUID, bitOrder);
data.WriteByteSeq(grpGUID[6]);
data.WriteByteSeq(grpGUID[0]);
data.WriteByteSeq(grpGUID[3]);
data.WriteByteSeq(grpGUID[1]);
data.WriteByteSeq(grpGUID[5]);
data << uint8(1); // or 0
data.WriteByteSeq(grpGUID[7]);
data.WriteByteSeq(grpGUID[2]);
data.WriteByteSeq(grpGUID[4]);
group->BroadcastPacket(&data, true);
}
}
void WorldSession::HandleRaidConfirmReadyCheck(WorldPacket& recvData)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_RAID_CONFIRM_READY_CHECK");
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
recvData.read_skip<uint8>(); // unk, 0x00
bool ready = recvData.ReadBit();
// ========== Unknown guid reading here - probably for group guid ? ========
ObjectGuid unknownGuid;
unknownGuid[0] = recvData.ReadBit();
unknownGuid[6] = recvData.ReadBit();
unknownGuid[5] = recvData.ReadBit();
unknownGuid[2] = recvData.ReadBit();
unknownGuid[4] = recvData.ReadBit();
unknownGuid[7] = recvData.ReadBit();
unknownGuid[3] = recvData.ReadBit();
unknownGuid[1] = recvData.ReadBit();
recvData.FlushBits();
recvData.ReadByteSeq(unknownGuid[2]);
recvData.ReadByteSeq(unknownGuid[0]);
recvData.ReadByteSeq(unknownGuid[7]);
recvData.ReadByteSeq(unknownGuid[6]);
recvData.ReadByteSeq(unknownGuid[5]);
recvData.ReadByteSeq(unknownGuid[3]);
recvData.ReadByteSeq(unknownGuid[1]);
recvData.ReadByteSeq(unknownGuid[4]);
// =========================================================================
ObjectGuid playerGuid = GetPlayer()->GetGUID();
ObjectGuid groupGuid = group->GetGUID();
// Confirmed the check, increase the count.
group->SetReadyCheckCount(group->GetReadyCheckCount() + 1);
WorldPacket data(SMSG_RAID_READY_CHECK_RESPONSE, 1 + 1 + 8 + 1 + 8);
data.WriteBit(groupGuid[0]);
data.WriteBit(groupGuid[2]);
data.WriteBit(ready);
data.WriteBit(playerGuid[7]);
data.WriteBit(playerGuid[6]);
data.WriteBit(playerGuid[2]);
data.WriteBit(groupGuid[4]);
data.WriteBit(groupGuid[3]);
data.WriteBit(groupGuid[5]);
data.WriteBit(playerGuid[3]);
data.WriteBit(groupGuid[7]);
data.WriteBit(playerGuid[5]);
data.WriteBit(groupGuid[6]);
data.WriteBit(groupGuid[1]);
data.WriteBit(playerGuid[0]);
data.WriteBit(playerGuid[1]);
data.WriteBit(playerGuid[4]);
data.FlushBits();
data.WriteByteSeq(playerGuid[1]);
data.WriteByteSeq(groupGuid[5]);
data.WriteByteSeq(playerGuid[2]);
data.WriteByteSeq(groupGuid[7]);
data.WriteByteSeq(groupGuid[0]);
data.WriteByteSeq(playerGuid[4]);
data.WriteByteSeq(playerGuid[3]);
data.WriteByteSeq(groupGuid[4]);
data.WriteByteSeq(playerGuid[7]);
data.WriteByteSeq(groupGuid[6]);
data.WriteByteSeq(playerGuid[5]);
data.WriteByteSeq(groupGuid[2]);
data.WriteByteSeq(groupGuid[1]);
data.WriteByteSeq(groupGuid[3]);
data.WriteByteSeq(playerGuid[0]);
data.WriteByteSeq(playerGuid[6]);
group->BroadcastReadyCheck(&data); // BroadcastPacket(&data, true);
// Send SMSG_RAID_READY_CHECK_COMPLETED if needed.
if (group->GetReadyCheckCount() >= group->GetMembersCount())
{
ObjectGuid grpGUID = group->GetGUID();
bool checkCompleted = true;
data.Initialize(SMSG_RAID_READY_CHECK_COMPLETED);
uint8 bitOrder[8] = { 1, 5, 6, 3, 2, 7, 0, 4 };
data.WriteBitInOrder(grpGUID, bitOrder);
data.FlushBits();
data.WriteByteSeq(grpGUID[4]);
data.WriteByteSeq(grpGUID[7]);
data << uint8(checkCompleted);
data.WriteByteSeq(grpGUID[0]);
data.WriteByteSeq(grpGUID[3]);
data.WriteByteSeq(grpGUID[6]);
data.WriteByteSeq(grpGUID[5]);
data.WriteByteSeq(grpGUID[2]);
data.WriteByteSeq(grpGUID[1]);
group->BroadcastPacket(&data, true);
}
}
void WorldSession::HandleMessagechatOpcode(WorldPacket& recv_data)
{
uint32 type;
uint32 lang;
recv_data >> type;
recv_data >> lang;
if (type >= MAX_CHAT_MSG_TYPE)
{
sLog.outError("CHAT: Wrong message type received: %u", type);
return;
}
DEBUG_LOG("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);
return;
}
if (langDesc->skill_id != 0 && !_player->HasSkill(langDesc->skill_id))
{
// also check SPELL_AURA_COMPREHEND_LANGUAGE (client offers option to speak in that language)
Unit::AuraList const& langAuras = _player->GetAurasByType(SPELL_AURA_COMPREHEND_LANGUAGE);
bool foundAura = false;
for (Unit::AuraList::const_iterator i = langAuras.begin(); i != langAuras.end(); ++i)
{
if ((*i)->GetModifier()->m_miscvalue == int32(lang))
{
foundAura = true;
break;
}
}
if (!foundAura)
{
SendNotification(LANG_NOT_LEARNED_LANGUAGE);
return;
}
}
if (lang == LANG_ADDON)
{
// Disabled addon channel?
if (!sWorld.getConfig(CONFIG_BOOL_ADDON_CHANNEL))
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 (_player->isGameMaster())
lang = LANG_UNIVERSAL;
else
{
// send in universal language in two side iteration allowed mode
if (sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_CHAT))
lang = LANG_UNIVERSAL;
else
{
switch (type)
{
case CHAT_MSG_PARTY:
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.getConfig(CONFIG_BOOL_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.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_GUILD))
lang = LANG_UNIVERSAL;
break;
}
}
// but overwrite it by SPELL_AURA_MOD_LANGUAGE auras (only single case used)
Unit::AuraList const& ModLangAuras = _player->GetAurasByType(SPELL_AURA_MOD_LANGUAGE);
if (!ModLangAuras.empty())
lang = ModLangAuras.front()->GetModifier()->m_miscvalue;
}
if (type != CHAT_MSG_AFK && type != CHAT_MSG_DND)
{
if (!_player->CanSpeak())
{
std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
SendNotification(GetMangosString(LANG_WAIT_BEFORE_SPEAKING), timeStr.c_str());
return;
}
GetPlayer()->UpdateSpeakTime();
}
}
switch (type)
{
case CHAT_MSG_SAY:
case CHAT_MSG_EMOTE:
case CHAT_MSG_YELL:
{
std::string msg;
recv_data >> msg;
if (msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()))
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if (msg.empty())
break;
if (type == CHAT_MSG_SAY)
GetPlayer()->Say(msg, lang);
else if (type == CHAT_MSG_EMOTE)
GetPlayer()->TextEmote(msg);
else if (type == CHAT_MSG_YELL)
GetPlayer()->Yell(msg, lang);
} break;
case CHAT_MSG_WHISPER:
{
std::string to, msg;
recv_data >> to;
recv_data >> msg;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if (msg.empty())
break;
if (!normalizePlayerName(to))
{
SendPlayerNotFoundNotice(to);
break;
}
Player* player = sObjectMgr.GetPlayer(to.c_str());
uint32 tSecurity = GetSecurity();
uint32 pSecurity = player ? player->GetSession()->GetSecurity() : SEC_PLAYER;
if (!player || (tSecurity == SEC_PLAYER && pSecurity > SEC_PLAYER && !player->isAcceptWhispers()))
{
SendPlayerNotFoundNotice(to);
return;
}
if (!sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_CHAT) && tSecurity == SEC_PLAYER && pSecurity == SEC_PLAYER)
{
if (GetPlayer()->GetTeam() != player->GetTeam())
{
SendWrongFactionNotice();
return;
}
}
// Playerbot mod: handle whispered command to bot
if (player->GetPlayerbotAI())
{
player->GetPlayerbotAI()->HandleCommand(msg, *GetPlayer());
GetPlayer()->m_speakTime = 0;
GetPlayer()->m_speakCount = 0;
}
else
GetPlayer()->Whisper(msg, lang, player->GetObjectGuid());
} break;
case CHAT_MSG_PARTY:
{
std::string msg;
recv_data >> msg;
if (msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()))
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if (msg.empty())
break;
// if player is in battleground, he cannot say to battleground members by /p
Group* group = GetPlayer()->GetOriginalGroup();
if (!group)
{
group = _player->GetGroup();
if (!group || group->isBGGroup())
return;
}
// Playerbot mod: broadcast message to bot members
for(GroupReference* itr = group->GetFirstMember(); itr != NULL; itr=itr->next())
{
Player* player = itr->getSource();
if (player && player->GetPlayerbotAI())
{
player->GetPlayerbotAI()->HandleCommand(msg, *GetPlayer());
GetPlayer()->m_speakTime = 0;
GetPlayer()->m_speakCount = 0;
}
}
// END Playerbot mod
WorldPacket data;
ChatHandler::FillMessageData(&data, this, type, lang, msg.c_str());
group->BroadcastPacket(&data, false, group->GetMemberGroup(GetPlayer()->GetObjectGuid()));
break;
}
case CHAT_MSG_GUILD:
{
std::string msg;
recv_data >> msg;
if (msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()))
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if (msg.empty())
break;
if (GetPlayer()->GetGuildId())
if (Guild* guild = sGuildMgr.GetGuildById(GetPlayer()->GetGuildId()))
guild->BroadcastToGuild(this, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
break;
}
case CHAT_MSG_OFFICER:
{
std::string msg;
recv_data >> msg;
if (msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()))
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if (msg.empty())
break;
if (GetPlayer()->GetGuildId())
if (Guild* guild = sGuildMgr.GetGuildById(GetPlayer()->GetGuildId()))
guild->BroadcastToOfficers(this, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
break;
}
case CHAT_MSG_RAID:
{
std::string msg;
recv_data >> msg;
if (msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()))
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if (msg.empty())
break;
// 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;
}
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID, lang, msg.c_str());
group->BroadcastPacket(&data, false);
} break;
case CHAT_MSG_RAID_LEADER:
{
std::string msg;
recv_data >> msg;
if (msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()))
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if (msg.empty())
break;
// 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(_player->GetObjectGuid()))
return;
}
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID_LEADER, lang, msg.c_str());
group->BroadcastPacket(&data, false);
} break;
case CHAT_MSG_RAID_WARNING:
{
std::string msg;
recv_data >> msg;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if (msg.empty())
break;
Group* group = GetPlayer()->GetGroup();
if (!group || !group->isRaidGroup() ||
!(group->IsLeader(GetPlayer()->GetObjectGuid()) || group->IsAssistant(GetPlayer()->GetObjectGuid())))
return;
WorldPacket data;
// in battleground, raid warning is sent only to players in battleground - code is ok
ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID_WARNING, lang, msg.c_str());
group->BroadcastPacket(&data, false);
} break;
case CHAT_MSG_BATTLEGROUND:
{
std::string msg;
recv_data >> msg;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if (msg.empty())
break;
// battleground raid is always in Player->GetGroup(), never in GetOriginalGroup()
Group* group = GetPlayer()->GetGroup();
if (!group || !group->isBGGroup())
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_BATTLEGROUND, lang, msg.c_str());
group->BroadcastPacket(&data, false);
} break;
case CHAT_MSG_BATTLEGROUND_LEADER:
{
std::string msg;
recv_data >> msg;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if (msg.empty())
break;
// battleground raid is always in Player->GetGroup(), never in GetOriginalGroup()
Group* group = GetPlayer()->GetGroup();
if (!group || !group->isBGGroup() || !group->IsLeader(GetPlayer()->GetObjectGuid()))
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_BATTLEGROUND_LEADER, lang, msg.c_str());
group->BroadcastPacket(&data, false);
} break;
case CHAT_MSG_CHANNEL:
{
std::string channel, msg;
recv_data >> channel;
recv_data >> msg;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if (msg.empty())
break;
if (ChannelMgr* cMgr = channelMgr(_player->GetTeam()))
if (Channel* chn = cMgr->GetChannel(channel, _player))
chn->Say(_player->GetObjectGuid(), msg.c_str(), lang);
} break;
case CHAT_MSG_AFK:
{
std::string msg;
recv_data >> msg;
if (!_player->isInCombat())
{
if (_player->isAFK()) // Already AFK
{
if (msg.empty())
_player->ToggleAFK(); // Remove AFK
else
_player->autoReplyMsg = msg; // Update message
}
else // New AFK mode
{
_player->autoReplyMsg = msg.empty() ? GetMangosString(LANG_PLAYER_AFK_DEFAULT) : msg;
if (_player->isDND())
_player->ToggleDND();
_player->ToggleAFK();
}
}
break;
}
case CHAT_MSG_DND:
{
std::string msg;
recv_data >> msg;
if (_player->isDND()) // Already DND
{
if (msg.empty())
_player->ToggleDND(); // Remove DND
else
_player->autoReplyMsg = msg; // Update message
}
else // New DND mode
{
_player->autoReplyMsg = msg.empty() ? GetMangosString(LANG_PLAYER_DND_DEFAULT) : msg;
if (_player->isAFK())
_player->ToggleAFK();
_player->ToggleDND();
}
break;
}
default:
sLog.outError("CHAT: unknown message type %u, lang: %u", type, lang);
break;
}
}
void WorldSession::HandleGroupSetRolesOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_GROUP_SET_ROLES");
uint32 newRole;
ObjectGuid targetGuid;
recvData.read_skip<uint8>();
recvData >> newRole;
targetGuid[2] = recvData.ReadBit();
targetGuid[0] = recvData.ReadBit();
targetGuid[7] = recvData.ReadBit();
targetGuid[4] = recvData.ReadBit();
targetGuid[1] = recvData.ReadBit();
targetGuid[3] = recvData.ReadBit();
targetGuid[6] = recvData.ReadBit();
targetGuid[5] = recvData.ReadBit();
recvData.ReadByteSeq(targetGuid[1]);
recvData.ReadByteSeq(targetGuid[5]);
recvData.ReadByteSeq(targetGuid[2]);
recvData.ReadByteSeq(targetGuid[6]);
recvData.ReadByteSeq(targetGuid[7]);
recvData.ReadByteSeq(targetGuid[0]);
recvData.ReadByteSeq(targetGuid[4]);
recvData.ReadByteSeq(targetGuid[3]);
Player* tPlayer = ObjectAccessor::FindPlayer(targetGuid);
Group* group = GetPlayer()->GetGroup();
if (!tPlayer || !group)
return;
if (group != tPlayer->GetGroup())
return;
ObjectGuid assignerGuid = GetPlayer()->GetGUID();
WorldPacket data(SMSG_GROUP_SET_ROLE, 1 + 8 + 1 + 8 + 4 + 1 + 4);
data.WriteBit(assignerGuid[1]);
data.WriteBit(targetGuid[7]);
data.WriteBit(targetGuid[6]);
data.WriteBit(targetGuid[4]);
data.WriteBit(targetGuid[1]);
data.WriteBit(targetGuid[0]);
data.WriteBit(assignerGuid[0]);
data.WriteBit(assignerGuid[7]);
data.WriteBit(targetGuid[3]);
data.WriteBit(assignerGuid[6]);
data.WriteBit(targetGuid[2]);
data.WriteBit(assignerGuid[4]);
data.WriteBit(assignerGuid[5]);
data.WriteBit(assignerGuid[2]);
data.WriteBit(targetGuid[5]);
data.WriteBit(assignerGuid[3]);
data.WriteByteSeq(assignerGuid[1]);
data.WriteByteSeq(assignerGuid[6]);
data.WriteByteSeq(assignerGuid[2]);
data.WriteByteSeq(targetGuid[3]);
data << uint32(group->GetMemberRole(targetGuid));
data.WriteByteSeq(assignerGuid[7]);
data.WriteByteSeq(targetGuid[5]);
data.WriteByteSeq(assignerGuid[3]);
data.WriteByteSeq(targetGuid[4]);
data.WriteByteSeq(targetGuid[7]);
data.WriteByteSeq(assignerGuid[5]);
data.WriteByteSeq(targetGuid[6]);
data.WriteByteSeq(targetGuid[2]);
data.WriteByteSeq(targetGuid[1]);
data.WriteByteSeq(targetGuid[0]);
data.WriteByteSeq(assignerGuid[4]);
data << uint8(0); // unknown
data.WriteByteSeq(assignerGuid[0]);
data << uint32(newRole);
group->BroadcastPacket(&data, false);
group->SetMemberRole(targetGuid, newRole);
group->SendUpdate();
}
void WorldSession::HandleRaidReadyCheckConfirmOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_RAID_READY_CHECK_CONFIRM");
ObjectGuid unknownGuid;
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
recvData.read_skip<uint8>();
bool status = recvData.ReadBit();
unknownGuid[0] = recvData.ReadBit();
unknownGuid[6] = recvData.ReadBit();
unknownGuid[5] = recvData.ReadBit();
unknownGuid[2] = recvData.ReadBit();
unknownGuid[4] = recvData.ReadBit();
unknownGuid[7] = recvData.ReadBit();
unknownGuid[3] = recvData.ReadBit();
unknownGuid[1] = recvData.ReadBit();
recvData.ReadByteSeq(unknownGuid[2]);
recvData.ReadByteSeq(unknownGuid[0]);
recvData.ReadByteSeq(unknownGuid[7]);
recvData.ReadByteSeq(unknownGuid[6]);
recvData.ReadByteSeq(unknownGuid[5]);
recvData.ReadByteSeq(unknownGuid[3]);
recvData.ReadByteSeq(unknownGuid[1]);
recvData.ReadByteSeq(unknownGuid[4]);
ObjectGuid groupGuid = group->GetGUID();
ObjectGuid playerGuid = GetPlayer()->GetGUID();
WorldPacket data(SMSG_RAID_READY_CHECK_CONFIRM, 1 + 1 + 8 + 1 + 8);
data.WriteBit(groupGuid[0]);
data.WriteBit(groupGuid[2]);
data.WriteBit(status);
data.WriteBit(playerGuid[7]);
data.WriteBit(playerGuid[6]);
data.WriteBit(playerGuid[2]);
data.WriteBit(groupGuid[4]);
data.WriteBit(groupGuid[3]);
data.WriteBit(groupGuid[5]);
data.WriteBit(playerGuid[3]);
data.WriteBit(groupGuid[7]);
data.WriteBit(playerGuid[5]);
data.WriteBit(groupGuid[6]);
data.WriteBit(groupGuid[1]);
data.WriteBit(playerGuid[0]);
data.WriteBit(playerGuid[1]);
data.WriteBit(playerGuid[4]);
data.FlushBits();
data.WriteByteSeq(playerGuid[1]);
data.WriteByteSeq(groupGuid[5]);
data.WriteByteSeq(playerGuid[2]);
data.WriteByteSeq(groupGuid[7]);
data.WriteByteSeq(groupGuid[0]);
data.WriteByteSeq(playerGuid[4]);
data.WriteByteSeq(playerGuid[3]);
data.WriteByteSeq(groupGuid[4]);
data.WriteByteSeq(playerGuid[7]);
data.WriteByteSeq(groupGuid[6]);
data.WriteByteSeq(playerGuid[5]);
data.WriteByteSeq(groupGuid[2]);
data.WriteByteSeq(groupGuid[1]);
data.WriteByteSeq(groupGuid[3]);
data.WriteByteSeq(playerGuid[0]);
data.WriteByteSeq(playerGuid[6]);
group->BroadcastPacket(&data, false, -1);
}
void WorldSession::HandleChatMessage(ChatMsg type, uint32 lang, std::string msg, std::string target /*= ""*/)
{
Player* sender = GetPlayer();
if (lang == LANG_UNIVERSAL && type != CHAT_MSG_EMOTE)
{
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);
return;
}
// prevent talking at unknown language (cheating)
LanguageDesc const* langDesc = GetLanguageDescByID(lang);
if (!langDesc)
{
SendNotification(LANG_UNKNOWN_LANGUAGE);
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);
return;
}
}
// send in universal language if player in .gm on mode (ignore spell effects)
if (sender->IsGameMaster())
lang = LANG_UNIVERSAL;
else
{
// send in universal language in two side iteration allowed mode
if (HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHAT))
lang = LANG_UNIVERSAL;
else
{
switch (type)
{
case CHAT_MSG_PARTY:
case CHAT_MSG_RAID:
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;
default:
break;
}
}
// but overwrite it by SPELL_AURA_MOD_LANGUAGE auras (only single case used)
Unit::AuraEffectList const& ModLangAuras = sender->GetAuraEffectsByType(SPELL_AURA_MOD_LANGUAGE);
if (!ModLangAuras.empty())
lang = ModLangAuras.front()->GetMiscValue();
}
if (!sender->CanSpeak())
{
std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
SendNotification(GetTrinityString(LANG_WAIT_BEFORE_SPEAKING), timeStr.c_str());
return;
}
if (sender->HasAura(GM_SILENCE_AURA) && type != CHAT_MSG_WHISPER)
{
SendNotification(GetTrinityString(LANG_GM_SILENCE), sender->GetName().c_str());
return;
}
if (msg.empty())
return;
if (ChatHandler(this).ParseCommands(msg.c_str()))
return;
// 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 (%s) sent a chatmessage with an invalid link: %s", GetPlayer()->GetName().c_str(),
GetPlayer()->GetGUID().ToString().c_str(), 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 (type == CHAT_MSG_SAY)
sender->Say(msg, Language(lang));
else if (type == CHAT_MSG_EMOTE)
sender->TextEmote(msg);
else if (type == CHAT_MSG_YELL)
sender->Yell(msg, Language(lang));
break;
}
case CHAT_MSG_WHISPER:
{
/// @todo implement cross realm whispers (someday)
ExtendedPlayerName extName = ExtractExtendedPlayerName(target);
if (!normalizePlayerName(extName.Name))
{
SendChatPlayerNotfoundNotice(target);
break;
}
Player* receiver = ObjectAccessor::FindConnectedPlayerByName(extName.Name);
if (!receiver || (lang != LANG_ADDON && !receiver->isAcceptWhispers() && receiver->GetSession()->HasPermission(rbac::RBAC_PERM_CAN_FILTER_WHISPERS) && !receiver->IsInWhisperWhiteList(sender->GetGUID())))
{
SendChatPlayerNotfoundNotice(target);
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()))
{
SendChatPlayerNotfoundNotice(target);
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, Language(lang), receiver);
break;
}
case CHAT_MSG_PARTY:
{
// 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 (group->IsLeader(GetPlayer()->GetGUID()))
type = CHAT_MSG_PARTY_LEADER;
sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
WorldPackets::Chat::Chat packet;
packet.Initialize(ChatMsg(type), Language(lang), sender, nullptr, msg);
group->BroadcastPacket(packet.Write(), 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:
{
Group* group = GetPlayer()->GetGroup();
if (!group || !group->isRaidGroup() || group->isBGGroup())
return;
if (group->IsLeader(GetPlayer()->GetGUID()))
type = CHAT_MSG_RAID_LEADER;
sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
WorldPackets::Chat::Chat packet;
packet.Initialize(ChatMsg(type), Language(lang), sender, nullptr, msg);
group->BroadcastPacket(packet.Write(), 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);
WorldPackets::Chat::Chat packet;
//in battleground, raid warning is sent only to players in battleground - code is ok
packet.Initialize(CHAT_MSG_RAID_WARNING, Language(lang), sender, NULL, msg);
group->BroadcastPacket(packet.Write(), 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 (Channel* chn = ChannelMgr::GetChannelForPlayerByNamePart(target, sender))
{
sScriptMgr->OnPlayerChat(sender, type, lang, msg, chn);
chn->Say(sender->GetGUID(), msg.c_str(), lang);
}
break;
}
case CHAT_MSG_INSTANCE_CHAT:
{
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
if (group->IsLeader(GetPlayer()->GetGUID()))
type = CHAT_MSG_INSTANCE_CHAT_LEADER;
sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
WorldPackets::Chat::Chat packet;
packet.Initialize(ChatMsg(type), Language(lang), sender, nullptr, msg);
group->BroadcastPacket(packet.Write(), false);
break;
}
default:
TC_LOG_ERROR("network", "CHAT: unknown message type %u, lang: %u", type, lang);
break;
}
}
void WorldSession::HandleMessagechatOpcode( WorldPacket & recv_data )
{
uint32 type;
uint32 lang;
recv_data >> type;
recv_data >> lang;
if(type >= MAX_CHAT_MSG_TYPE)
{
sLog.outError("CHAT: Wrong message type received: %u", type);
return;
}
//sLog.outDebug("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);
return;
}
if(langDesc->skill_id != 0 && !_player->HasSkill(langDesc->skill_id))
{
// also check SPELL_AURA_COMPREHEND_LANGUAGE (client offers option to speak in that language)
Unit::AuraList const& langAuras = _player->GetAurasByType(SPELL_AURA_COMPREHEND_LANGUAGE);
bool foundAura = false;
for(Unit::AuraList::const_iterator i = langAuras.begin();i != langAuras.end(); ++i)
{
if((*i)->GetModifier()->m_miscvalue == int32(lang))
{
foundAura = true;
break;
}
}
if(!foundAura)
{
SendNotification(LANG_NOT_LEARNED_LANGUAGE);
return;
}
}
if(lang == LANG_ADDON)
{
// Disabled addon channel?
if(!sWorld.getConfig(CONFIG_ADDON_CHANNEL))
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 (_player->isGameMaster())
lang = LANG_UNIVERSAL;
else
{
// send in universal language in two side iteration allowed mode
if (sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT))
lang = LANG_UNIVERSAL;
else
{
switch(type)
{
case CHAT_MSG_PARTY:
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.getConfig(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.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD))
lang = LANG_UNIVERSAL;
break;
}
}
// but overwrite it by SPELL_AURA_MOD_LANGUAGE auras (only single case used)
Unit::AuraList const& ModLangAuras = _player->GetAurasByType(SPELL_AURA_MOD_LANGUAGE);
if(!ModLangAuras.empty())
lang = ModLangAuras.front()->GetModifier()->m_miscvalue;
}
if (!_player->CanSpeak())
{
std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
SendNotification(GetMangosString(LANG_WAIT_BEFORE_SPEAKING),timeStr.c_str());
return;
}
if (type != CHAT_MSG_AFK && type != CHAT_MSG_DND)
GetPlayer()->UpdateSpeakTime();
}
switch(type)
{
case CHAT_MSG_SAY:
case CHAT_MSG_EMOTE:
case CHAT_MSG_YELL:
{
std::string msg = "";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if(msg.empty())
break;
if(type == CHAT_MSG_SAY)
{
//sChatLog.ChatMsg(GetPlayer(), msg, type);
GetPlayer()->Say(msg, lang);
}
else if(type == CHAT_MSG_EMOTE)
{
//sChatLog.ChatMsg(GetPlayer(), msg, type);
GetPlayer()->TextEmote(msg);
}
else if(type == CHAT_MSG_YELL)
{
//sChatLog.ChatMsg(GetPlayer(), msg, type);
GetPlayer()->Yell(msg, lang);
}
} break;
case CHAT_MSG_WHISPER:
{
std::string to, msg;
recv_data >> to;
recv_data >> msg;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if(msg.empty())
break;
//sChatLog.WhisperMsg(GetPlayer(), to, msg);
if(!normalizePlayerName(to))
{
WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
data<<to;
SendPacket(&data);
break;
}
Player *player = sObjectMgr.GetPlayer(to.c_str());
uint32 tSecurity = GetSecurity();
uint32 pSecurity = player ? player->GetSession()->GetSecurity() : SEC_PLAYER;
if (!player || (tSecurity == SEC_PLAYER && pSecurity > SEC_PLAYER && !player->isAcceptWhispers()))
{
WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
data<<to;
SendPacket(&data);
return;
}
if (!sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT) && tSecurity == SEC_PLAYER && pSecurity == SEC_PLAYER )
{
uint32 sidea = GetPlayer()->GetTeam();
uint32 sideb = player->GetTeam();
if( sidea != sideb )
{
WorldPacket data(SMSG_CHAT_PLAYER_NOT_FOUND, (to.size()+1));
data<<to;
SendPacket(&data);
return;
}
}
GetPlayer()->Whisper(msg, lang,player->GetGUID());
} break;
case CHAT_MSG_PARTY:
{
std::string msg = "";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if(msg.empty())
break;
//sChatLog.PartyMsg(GetPlayer(), msg);
Group *group = GetPlayer()->GetGroup();
if(!group)
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_PARTY, lang, NULL, 0, msg.c_str(),NULL);
group->BroadcastPacket(&data, group->GetMemberGroup(GetPlayer()->GetGUID()));
}
break;
case CHAT_MSG_GUILD:
{
std::string msg = "";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if(msg.empty())
break;
//sChatLog.GuildMsg(GetPlayer(), msg, false);
//sChatLog.GuildMsg(GetPlayer(), msg, true);
if (GetPlayer()->GetGuildId())
{
Guild *guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
if (guild)
guild->BroadcastToGuild(this, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
}
break;
}
case CHAT_MSG_OFFICER:
{
std::string msg = "";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if(msg.empty())
break;
if (GetPlayer()->GetGuildId())
{
Guild *guild = sObjectMgr.GetGuildById(GetPlayer()->GetGuildId());
if (guild)
guild->BroadcastToOfficers(this, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
}
break;
}
case CHAT_MSG_RAID:
{
std::string msg="";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if(msg.empty())
break;
//sChatLog.RaidMsg(GetPlayer(), msg, type);
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isRaidGroup())
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID, lang, "", 0, msg.c_str(),NULL);
group->BroadcastPacket(&data);
} break;
case CHAT_MSG_RAID_LEADER:
{
std::string msg="";
recv_data >> msg;
if(msg.empty())
break;
if (ChatHandler(this).ParseCommands(msg.c_str()) > 0)
break;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if(msg.empty())
break;
//sChatLog.RaidMsg(GetPlayer(), msg, type);
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isRaidGroup() || !group->IsLeader(GetPlayer()->GetGUID()))
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID_LEADER, lang, "", 0, msg.c_str(),NULL);
group->BroadcastPacket(&data);
} break;
case CHAT_MSG_RAID_WARNING:
{
std::string msg="";
recv_data >> msg;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if(msg.empty())
break;
//sChatLog.RaidMsg(GetPlayer(), msg, type);
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isRaidGroup() || !(group->IsLeader(GetPlayer()->GetGUID()) || group->IsAssistant(GetPlayer()->GetGUID())))
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_RAID_WARNING, lang, "", 0, msg.c_str(),NULL);
group->BroadcastPacket(&data);
} break;
case CHAT_MSG_BATTLEGROUND:
{
std::string msg="";
recv_data >> msg;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if(msg.empty())
break;
//sChatLog.BattleGroundMsg(GetPlayer(), msg, type);
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isRaidGroup())
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_BATTLEGROUND, lang, "", 0, msg.c_str(),NULL);
group->BroadcastPacket(&data);
} break;
case CHAT_MSG_BATTLEGROUND_LEADER:
{
std::string msg="";
recv_data >> msg;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if(msg.empty())
break;
//sChatLog.BattleGroundMsg(GetPlayer(), msg, type);
Group *group = GetPlayer()->GetGroup();
if(!group || !group->isRaidGroup() || !group->IsLeader(GetPlayer()->GetGUID()))
return;
WorldPacket data;
ChatHandler::FillMessageData(&data, this, CHAT_MSG_BATTLEGROUND_LEADER, lang, "", 0, msg.c_str(),NULL);
group->BroadcastPacket(&data);
} break;
case CHAT_MSG_CHANNEL:
{
std::string channel = "", msg = "";
recv_data >> channel;
recv_data >> msg;
if (!processChatmessageFurtherAfterSecurityChecks(msg, lang))
return;
if(msg.empty())
break;
//sChatLog.ChannelMsg(GetPlayer(), channel, msg);
if(ChannelMgr* cMgr = channelMgr(_player->GetTeam()))
{
if(Channel *chn = cMgr->GetChannel(channel,_player))
chn->Say(_player->GetGUID(),msg.c_str(),lang);
}
} break;
case CHAT_MSG_AFK:
{
std::string msg;
recv_data >> msg;
if((msg.empty() || !_player->isAFK()) && !_player->isInCombat() )
{
if(!_player->isAFK())
{
if(msg.empty())
msg = GetMangosString(LANG_PLAYER_AFK_DEFAULT);
_player->afkMsg = msg;
}
_player->ToggleAFK();
if(_player->isAFK() && _player->isDND())
_player->ToggleDND();
}
} break;
case CHAT_MSG_DND:
{
std::string msg;
recv_data >> msg;
if(msg.empty() || !_player->isDND())
{
if(!_player->isDND())
{
if(msg.empty())
msg = GetMangosString(LANG_PLAYER_DND_DEFAULT);
_player->dndMsg = msg;
}
_player->ToggleDND();
if(_player->isDND() && _player->isAFK())
_player->ToggleAFK();
}
} break;
default:
sLog.outError("CHAT: unknown message type %u, lang: %u", type, lang);
break;
}
}
void WorldSession::HandleRaidReadyCheckOpcode(WorldPacket& /*recvData*/)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_RAID_READY_CHECK");
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
ObjectGuid playerGuid = GetPlayer()->GetGUID();
/** error handling **/
if (!group->IsLeader(playerGuid) && !group->IsAssistant(playerGuid))
return;
// check is also done client side
if (group->ReadyCheckInProgress())
return;
/********************/
uint32 readyCheckDuration = 35000;
ObjectGuid groupGuid = group->GetGUID();
// everything's fine, do it
WorldPacket data(SMSG_RAID_READY_CHECK, 1 + 8 + 1 + 8 + 1 + 4);
data.WriteBit(groupGuid[4]);
data.WriteBit(groupGuid[2]);
data.WriteBit(playerGuid[4]);
data.WriteBit(groupGuid[3]);
data.WriteBit(groupGuid[7]);
data.WriteBit(groupGuid[1]);
data.WriteBit(groupGuid[0]);
data.WriteBit(playerGuid[6]);
data.WriteBit(playerGuid[5]);
data.WriteBit(groupGuid[6]);
data.WriteBit(groupGuid[5]);
data.WriteBit(playerGuid[0]);
data.WriteBit(playerGuid[1]);
data.WriteBit(playerGuid[2]);
data.WriteBit(playerGuid[7]);
data.WriteBit(playerGuid[3]);
data << uint32(readyCheckDuration);
data.WriteByteSeq(groupGuid[2]);
data.WriteByteSeq(groupGuid[7]);
data.WriteByteSeq(groupGuid[3]);
data.WriteByteSeq(playerGuid[4]);
data.WriteByteSeq(groupGuid[1]);
data.WriteByteSeq(groupGuid[0]);
data.WriteByteSeq(playerGuid[1]);
data.WriteByteSeq(playerGuid[2]);
data.WriteByteSeq(playerGuid[6]);
data.WriteByteSeq(playerGuid[5]);
data.WriteByteSeq(groupGuid[6]);
data.WriteByteSeq(playerGuid[0]);
data << uint8(0); // unknown
data.WriteByteSeq(playerGuid[7]);
data.WriteByteSeq(groupGuid[4]);
data.WriteByteSeq(playerGuid[3]);
data.WriteByteSeq(groupGuid[5]);
group->BroadcastPacket(&data, false);
group->ReadyCheck(true);
group->ReadyCheckMemberHasResponded(playerGuid);
group->OfflineReadyCheck();
// leader keeps track of ready check timer
GetPlayer()->SetReadyCheckTimer(readyCheckDuration);
}
void WorldSession::HandleMessagechatOpcode(WorldPacket & recvData)
{
uint32 type;
uint32 lang;
recvData >> type;
recvData >> lang;
if (type >= MAX_CHAT_MSG_TYPE)
{
sLog->outError("CHAT: Wrong message type received: %u", type);
recvData.rfinish();
return;
}
Player* sender = GetPlayer();
//sLog->outDebug("CHAT: packet received. type %u, lang %u", type, lang);
// pussywizard: chatting on most chat types requires 2 hours played to prevent spam/abuse
if (AccountMgr::IsPlayerAccount(GetSecurity()))
switch (type)
{
case CHAT_MSG_ADDON:
case CHAT_MSG_PARTY:
case CHAT_MSG_RAID:
case CHAT_MSG_GUILD:
case CHAT_MSG_OFFICER:
case CHAT_MSG_AFK:
case CHAT_MSG_DND:
case CHAT_MSG_RAID_LEADER:
case CHAT_MSG_RAID_WARNING:
case CHAT_MSG_BATTLEGROUND:
case CHAT_MSG_BATTLEGROUND_LEADER:
case CHAT_MSG_PARTY_LEADER:
break;
default:
if (sender->GetTotalPlayedTime() < 2*HOUR)
{
SendNotification("Speaking is allowed after playing for at least 2 hours. You may use party and guild chat.");
recvData.rfinish();
return;
}
}
// pussywizard:
switch (type)
{
case CHAT_MSG_SAY:
case CHAT_MSG_YELL:
case CHAT_MSG_EMOTE:
case CHAT_MSG_TEXT_EMOTE:
case CHAT_MSG_AFK:
case CHAT_MSG_DND:
if (sender->IsSpectator())
{
recvData.rfinish();
return;
}
}
// 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:
sLog->outError("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
{
uint32 specialMessageLimit = 0;
// send in universal language if player in .gmon mode (ignore spell effects)
if (sender->IsGameMaster())
lang = LANG_UNIVERSAL;
else
{
// send in universal language in two side iteration allowed mode
if (sWorld->getBoolConfig(CONFIG_ALLOW_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;
specialMessageLimit = 35;
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;
specialMessageLimit = 15;
break;
case CHAT_MSG_WHISPER:
if (sender->getLevel() >= 80)
specialMessageLimit = 15;
break;
}
}
// but overwrite it by SPELL_AURA_MOD_LANGUAGE auras (only single case used)
Unit::AuraEffectList const& ModLangAuras = sender->GetAuraEffectsByType(SPELL_AURA_MOD_LANGUAGE);
if (!ModLangAuras.empty())
lang = ModLangAuras.front()->GetMiscValue();
}
if (type != CHAT_MSG_AFK && type != CHAT_MSG_DND)
sender->UpdateSpeakTime(specialMessageLimit);
}
// pussywizard: optimization
/*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;
}
// Strip invisible characters for non-addon messages
if (lang != LANG_ADDON && sWorld->getBoolConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
stripLineInvisibleChars(msg);
// pussywizard:
if (lang != LANG_ADDON && msg.find("|0") != std::string::npos)
return;
if (!ignoreChecks)
{
if (msg.empty())
return;
if (ChatHandler(this).ParseCommands(msg.c_str()))
return;
if (!_player->CanSpeak())
{
std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
SendNotification(GetTrinityString(LANG_WAIT_BEFORE_SPEAKING), timeStr.c_str());
return;
}
if (lang != LANG_ADDON)
{
if (sWorld->getIntConfig(CONFIG_CHAT_STRICT_LINK_CHECKING_SEVERITY) && !ChatHandler(this).isValidChatMessage(msg.c_str()))
{
//sLog->outError("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;
}
}
}
// exploit
size_t found1 = msg.find("|Hquest");
if (found1 != std::string::npos)
{
size_t found2 = msg.find(":", found1+8);
size_t found3 = msg.find("|", found1+8);
if (found3 != std::string::npos)
{
if (found2 == std::string::npos)
return;
if (found2 > found3)
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 (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 (sender->getLevel() < sWorld->getIntConfig(CONFIG_CHAT_WHISPER_LEVEL_REQ))
{
SendNotification(GetTrinityString(LANG_WHISPER_REQ), sWorld->getIntConfig(CONFIG_CHAT_WHISPER_LEVEL_REQ));
return;
}
if (!normalizePlayerName(to))
{
SendPlayerNotFoundNotice(to);
break;
}
Player* receiver = ObjectAccessor::FindPlayerByName(to, false);
bool senderIsPlayer = AccountMgr::IsPlayerAccount(GetSecurity());
bool receiverIsPlayer = AccountMgr::IsPlayerAccount(receiver ? receiver->GetSession()->GetSecurity() : SEC_PLAYER);
if (!receiver || (senderIsPlayer && !receiverIsPlayer && !receiver->isAcceptWhispers() && !receiver->IsInWhisperWhiteList(sender->GetGUID())))
{
SendPlayerNotFoundNotice(to);
return;
}
if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT) && senderIsPlayer && receiverIsPlayer)
if (GetPlayer()->GetTeamId() != receiver->GetTeamId())
{
SendWrongFactionNotice();
return;
}
// pussywizard: optimization
/*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
if (!senderIsPlayer && !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;
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()))
{
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()))
{
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;
}
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;
}
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;
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;
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;
WorldPacket data;
ChatHandler::BuildChatPacket(data, CHAT_MSG_BATTLEGROUND_LEADER, Language(lang), sender, NULL, msg);
group->BroadcastPacket(&data, false);
}
break;
case CHAT_MSG_CHANNEL:
{
if (AccountMgr::IsPlayerAccount(GetSecurity()))
{
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->GetTeamId()))
{
if (Channel* chn = cMgr->GetChannel(channel, sender))
{
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();
}
}
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();
}
break;
}
default:
sLog->outError("CHAT: unknown message type %u, lang: %u", type, lang);
break;
}
}
void WorldSession::HandleRaidReadyCheckConfirmOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_RAID_READY_CHECK_CONFIRM");
ObjectGuid guid; // currently unused
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
if (!group->ReadyCheckInProgress())
return;
recvData.read_skip<uint8>();
guid[2] = recvData.ReadBit();
guid[1] = recvData.ReadBit();
guid[0] = recvData.ReadBit();
guid[3] = recvData.ReadBit();
guid[6] = recvData.ReadBit();
bool status = recvData.ReadBit();
guid[7] = recvData.ReadBit();
guid[4] = recvData.ReadBit();
guid[5] = recvData.ReadBit();
recvData.ReadByteSeq(guid[1]);
recvData.ReadByteSeq(guid[0]);
recvData.ReadByteSeq(guid[3]);
recvData.ReadByteSeq(guid[2]);
recvData.ReadByteSeq(guid[4]);
recvData.ReadByteSeq(guid[5]);
recvData.ReadByteSeq(guid[7]);
recvData.ReadByteSeq(guid[6]);
ObjectGuid groupGuid = group->GetGUID();
ObjectGuid playerGuid = GetPlayer()->GetGUID();
WorldPacket data(SMSG_RAID_READY_CHECK_CONFIRM, 1 + 1 + 8 + 1 + 8);
data.WriteBit(groupGuid[4]);
data.WriteBit(playerGuid[5]);
data.WriteBit(playerGuid[3]);
data.WriteBit(status);
data.WriteBit(groupGuid[2]);
data.WriteBit(playerGuid[6]);
data.WriteBit(groupGuid[3]);
data.WriteBit(playerGuid[0]);
data.WriteBit(playerGuid[1]);
data.WriteBit(groupGuid[1]);
data.WriteBit(groupGuid[5]);
data.WriteBit(playerGuid[7]);
data.WriteBit(playerGuid[4]);
data.WriteBit(groupGuid[6]);
data.WriteBit(playerGuid[2]);
data.WriteBit(groupGuid[0]);
data.WriteBit(groupGuid[7]);
data.FlushBits();
data.WriteByteSeq(playerGuid[4]);
data.WriteByteSeq(playerGuid[2]);
data.WriteByteSeq(playerGuid[1]);
data.WriteByteSeq(groupGuid[4]);
data.WriteByteSeq(groupGuid[2]);
data.WriteByteSeq(playerGuid[0]);
data.WriteByteSeq(groupGuid[5]);
data.WriteByteSeq(groupGuid[3]);
data.WriteByteSeq(playerGuid[7]);
data.WriteByteSeq(groupGuid[6]);
data.WriteByteSeq(groupGuid[1]);
data.WriteByteSeq(playerGuid[6]);
data.WriteByteSeq(playerGuid[3]);
data.WriteByteSeq(playerGuid[5]);
data.WriteByteSeq(groupGuid[0]);
data.WriteByteSeq(groupGuid[7]);
group->BroadcastPacket(&data, false);
group->ReadyCheckMemberHasResponded(playerGuid);
if (group->ReadyCheckAllResponded())
{
Player* leader = ObjectAccessor::FindPlayer(group->GetLeaderGUID());
if (leader)
leader->SetReadyCheckTimer(0);
group->ReadyCheck(false);
group->ReadyCheckResetResponded();
group->SendReadyCheckCompleted();
}
}
void WorldSession::HandleRaidLeaderReadyCheck(WorldPacket& recvData)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_RAID_LEADER_READY_CHECK");
recvData.read_skip<uint8>(); // unk, 0x00
Group* group = GetPlayer()->GetGroup();
if (!group)
return;
if (!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()) && !(group->GetGroupType() & GROUPTYPE_EVERYONE_IS_ASSISTANT))
return;
ObjectGuid groupGuid = group->GetGUID();
ObjectGuid playerGuid = GetPlayer()->GetGUID();
// For the initiator being ready.
group->SetReadyCheckCount(1);
// Everything's fine, do it.
WorldPacket data(SMSG_RAID_READY_CHECK_STARTED, 1 + 8 + 1 + 8 + 1 + 4);
data.WriteBit(playerGuid[4]);
data.WriteBit(groupGuid[1]);
data.WriteBit(groupGuid[4]);
data.WriteBit(playerGuid[6]);
data.WriteBit(groupGuid[7]);
data.WriteBit(groupGuid[6]);
data.WriteBit(playerGuid[2]);
data.WriteBit(playerGuid[0]);
data.WriteBit(playerGuid[7]);
data.WriteBit(groupGuid[0]);
data.WriteBit(groupGuid[3]);
data.WriteBit(groupGuid[5]);
data.WriteBit(playerGuid[5]);
data.WriteBit(playerGuid[3]);
data.WriteBit(playerGuid[1]);
data.WriteBit(groupGuid[2]);
data.FlushBits();
data.WriteByteSeq(groupGuid[6]);
data.WriteByteSeq(groupGuid[0]);
data.WriteByteSeq(playerGuid[4]);
data.WriteByteSeq(playerGuid[7]);
data.WriteByteSeq(groupGuid[5]);
data.WriteByteSeq(groupGuid[7]);
data.WriteByteSeq(playerGuid[6]);
data.WriteByteSeq(playerGuid[3]);
data << uint8(0); // Unknown
data.WriteByteSeq(groupGuid[1]);
data.WriteByteSeq(playerGuid[2]);
data.WriteByteSeq(groupGuid[3]);
data.WriteByteSeq(playerGuid[5]);
data.WriteByteSeq(groupGuid[4]);
data.WriteByteSeq(groupGuid[2]);
data << uint32(35000); // Ready check duration (35 sec)
data.WriteByteSeq(playerGuid[1]);
data.WriteByteSeq(playerGuid[0]);
group->BroadcastPacket(&data, false, -1);
group->OfflineReadyCheck();
}