void WorldSession::HandleRequestJoinUpdates(WorldPacket& /*recvData*/)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_GROUP_REQUEST_JOIN_UPDATES ");
Group * grp = GetPlayer()->GetGroup();
if(grp)
{
WorldPacket data(SMSG_REAL_GROUP_UPDATE,13);
data << uint8(grp->GetGroupType());
data << uint32(grp->GetMembersCount());
if(grp->GetMembersCount() > 2) //group is already formed, send the latest member guid
{
Group::MemberSlotList::const_iterator lastMember = --grp->GetMemberSlots().end();
data << uint64(lastMember->guid);
}
else // group has just formed, send the other player guid
{
Group::MemberSlotList::const_iterator member = grp->GetMemberSlots().begin();
if(member->guid == GetPlayer()->GetGUID())
++member;
data << uint64(member->guid);
}
SendPacket(&data);
}
}
uint8 AoeHealValue::Calculate()
{
Group* group = bot->GetGroup();
if (!group)
return 0;
float range = 0;
if (qualifier == "low")
range = sPlayerbotAIConfig.lowHealth;
else if (qualifier == "medium")
range = sPlayerbotAIConfig.mediumHealth;
else if (qualifier == "critical")
range = sPlayerbotAIConfig.criticalHealth;
uint8 count = 0;
Group::MemberSlotList const& groupSlot = group->GetMemberSlots();
for (Group::member_citerator itr = groupSlot.begin(); itr != groupSlot.end(); itr++)
{
Player *player = sObjectMgr->GetPlayerByLowGUID(itr->guid);
if( !player || !player->IsAlive())
continue;
float percent = (static_cast<float> (player->GetHealth()) / player->GetMaxHealth()) * 100;
if (percent <= range)
count++;
}
return count;
}
static bool HandleLfgGroupInfoCommand(ChatHandler* handler, char const* args)
{
Player* playerTarget;
ObjectGuid guidTarget;
std::string nameTarget;
ObjectGuid parseGUID = ObjectGuid::Create<HighGuid::Player>(uint64(atoull(args)));
if (sObjectMgr->GetPlayerNameByGUID(parseGUID, nameTarget))
{
playerTarget = ObjectAccessor::FindPlayer(parseGUID);
guidTarget = parseGUID;
}
else if (!handler->extractPlayerTarget((char*)args, &playerTarget, &guidTarget, &nameTarget))
return false;
Group* groupTarget = NULL;
if (playerTarget)
groupTarget = playerTarget->GetGroup();
else
{
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GROUP_MEMBER);
stmt->setUInt32(0, guidTarget.GetCounter());
PreparedQueryResult resultGroup = CharacterDatabase.Query(stmt);
if (resultGroup)
groupTarget = sGroupMgr->GetGroupByDbStoreId((*resultGroup)[0].GetUInt32());
}
if (!groupTarget)
{
handler->PSendSysMessage(LANG_LFG_NOT_IN_GROUP, nameTarget.c_str());
handler->SetSentErrorMessage(true);
return false;
}
ObjectGuid guid = groupTarget->GetGUID();
std::string const& state = lfg::GetStateString(sLFGMgr->GetState(guid));
handler->PSendSysMessage(LANG_LFG_GROUP_INFO, groupTarget->isLFGGroup(),
state.c_str(), sLFGMgr->GetDungeon(guid));
Group::MemberSlotList const& members = groupTarget->GetMemberSlots();
for (Group::MemberSlotList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
{
Group::MemberSlot const& slot = *itr;
Player* p = ObjectAccessor::FindPlayer((*itr).guid);
if (p)
GetPlayerInfo(handler, p);
else
handler->PSendSysMessage("%s is offline.", slot.name.c_str());
}
return true;
}
void WorldSession::HandeSetEveryoneIsAssistant(WorldPacket& recv_data)
{
bool apply = recv_data.ReadBit();
DEBUG_LOG("WORLD: Received CMSG_SET_EVERYONE_IS_ASSISTANT from %s (%u) apply: %u",
GetPlayerName(), GetAccountId(), apply ? 1 : 0);
Group* group = _player->GetGroup();
if (!group || !group->isRaidGroup()) // Only raid groups may have assistant
return;
/** error handling **/
if (!group->IsLeader(_player->GetObjectGuid()))
return;
/********************/
for (Group::member_citerator itr = group->GetMemberSlots().begin(); itr != group->GetMemberSlots().end(); ++itr)
group->SetGroupUniqueFlag(itr->guid, GROUP_ASSIGN_ASSISTANT, apply, false);
group->SendUpdate();
}
void PlayerIsInGroup(Player* player)
{
Group * group = player->GetGroup();
Group::MemberSlotList const &members = group->GetMemberSlots();
for (Group::MemberSlotList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
{
Group::MemberSlot const &slot = *itr;
Player* player = ObjectAccessor::FindPlayer((*itr).guid);
if (player && player->GetSession())
remove_debuff_and_cooldown(player);
}
}
static bool HandlePvpfinderJoinCommand(ChatHandler* handler, const char* args)
{
handler->PSendSysMessage("%s%s|r", "|cff00ff00", "PvPFinder in Developement");
if (!handler->GetSession())
return false;
Player* player = handler->GetSession()->GetPlayer();
Group* group = player->GetGroup();
if (!group)
{
handler->PSendSysMessage("%s%s|r", "|cff0000ff", "Non sei in un gruppo!");
return false;
}
if (group->GetLeaderGUID() != player->GetGUID())
{
handler->PSendSysMessage("%s%s|r", "|cff0000ff", "Solo il leader del gruppo può joinare il PvPFinder!");
return false;
}
uint32 members = group->GetMembersCount();
if (members != 5 && members != 10 && members != 25 && members != 40)
{
handler->PSendSysMessage("%s%s|r", "|cff0000ff", "Dovete formare un gruppo da 5, 10, 25 o 40 persone per poter joinare il PvPFinder!");
return false;
}
const Group::MemberSlotList members_list = group->GetMemberSlots();
for (Group::member_citerator itr = members_list.begin(); itr!= members_list.end(); ++itr)
{
Player* member = (Unit::GetPlayer(*player, itr->guid));
if (!member)
continue;
if (member->InBattleground() || member->InBattlegroundQueue() || member->InArena())
{
handler->PSendSysMessage("%s%s|r", "|cff0000ff", "Un membro del gruppo ha coda per BG/Arena!");
return false;
}
}
return true;
} // HandleWpAddCommand
void SendMessageToGroup(Player* player, char *message)
{
if (!player)
return;
Group* group = player->GetGroup();
if (!group)
return;
const Group::MemberSlotList members = group->GetMemberSlots();
for (Group::member_citerator citr = members.begin(); citr != members.end(); ++citr)
{
Player* player = ObjectAccessor::FindPlayer(citr->guid);
if (player && player->IsInWorld())
{
std::string str = "|cFFFFFC00" + std::string(message); // make message yellow
WorldPacket data(SMSG_NOTIFICATION, (str.size()+1));
data << str;
player->GetSession()->SendPacket(&data);
}
}
}
void WorldSession::HandleBattlemasterJoinArena(WorldPacket& recv_data)
{
DEBUG_LOG("WORLD: CMSG_BATTLEMASTER_JOIN_ARENA");
// recv_data.hexlike();
uint8 arenaslot; // 2v2, 3v3 or 5v5
recv_data >> arenaslot;
// ignore if we already in BG or BG queue
if (_player->InBattleGround())
return;
ArenaType arenatype = ArenaTeam::GetTypeBySlot(arenaslot);
uint32 arenaRating = 0;
if (!IsArenaTypeValid(arenatype))
{
sLog.outError("Unknown arena slot %u at HandleBattlemasterJoinArena()", arenaslot);
return;
}
// check existence
BattleGround* bg = sBattleGroundMgr.GetBattleGroundTemplate(BATTLEGROUND_AA);
if (!bg)
{
sLog.outError("Battleground: template bg (all arenas) not found");
return;
}
BattleGroundTypeId bgTypeId = bg->GetTypeID();
BattleGroundQueueTypeId bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(bgTypeId, arenatype);
PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(bg->GetMapId(), _player->getLevel());
if (!bracketEntry)
return;
Group* grp = _player->GetGroup();
// no group found, error
if (!grp)
return;
if (grp->GetLeaderGuid() != _player->GetObjectGuid())
return;
uint32 ateamId = _player->GetArenaTeamId(arenaslot);
// check real arena team existence only here (if it was moved to group->CanJoin .. () then we would have to get it twice)
ArenaTeam* at = sObjectMgr.GetArenaTeamById(ateamId);
if (!at)
{
_player->GetSession()->SendNotInArenaTeamPacket(arenatype);
return;
}
// get the team rating for queue
arenaRating = at->GetRating();
// the arena team id must match for everyone in the group
// get the personal ratings for queue
uint32 avg_pers_rating = 0;
for (Group::member_citerator citr = grp->GetMemberSlots().begin(); citr != grp->GetMemberSlots().end(); ++citr)
{
ArenaTeamMember const* at_member = at->GetMember(citr->guid);
if (!at_member) // group member joining to arena must be in leader arena team
return;
// calc avg personal rating
avg_pers_rating += at_member->personal_rating;
}
avg_pers_rating /= grp->GetMembersCount();
// if avg personal rating is more than 150 points below the teams rating, the team will be queued against an opponent matching or similar to the average personal rating
if (avg_pers_rating + 150 < arenaRating)
arenaRating = avg_pers_rating;
BattleGroundQueue& bgQueue = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId];
uint32 avgTime = 0;
// may be Group::CanJoinBattleGroundQueue should be moved to player class...
GroupJoinBattlegroundResult err = grp->CanJoinBattleGroundQueue(bg, bgQueueTypeId, arenatype, arenatype, true, arenaslot);
if (!err)
{
DEBUG_LOG("Battleground: arena join as group start");
DEBUG_LOG("Battleground: arena team id %u, leader %s queued with rating %u for type %u", _player->GetArenaTeamId(arenaslot), _player->GetName(), arenaRating, arenatype);
GroupQueueInfo* ginfo = bgQueue.AddGroup(_player, grp, bgTypeId, bracketEntry, arenatype, true, false, arenaRating, ateamId);
avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry->GetBracketId());
}
for (GroupReference* itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
{
Player* member = itr->getSource();
if (!member)
continue;
WorldPacket data;
if (err)
{
sBattleGroundMgr.BuildBattleGroundStatusFailedPacket(&data, bg, member, 0, err);
member->GetSession()->SendPacket(&data);
continue;
}
// add to queue
uint32 queueSlot = member->AddBattleGroundQueueId(bgQueueTypeId);
// send status packet (in queue)
sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, member, queueSlot, STATUS_WAIT_QUEUE, avgTime, 0, arenatype);
member->GetSession()->SendPacket(&data);
DEBUG_LOG("Battleground: player joined queue for arena as group bg queue type %u bg type %u: GUID %u, NAME %s", bgQueueTypeId, bgTypeId, member->GetGUIDLow(), member->GetName());
}
DEBUG_LOG("Battleground: arena join as group end");
sBattleGroundMgr.ScheduleQueueUpdate(arenaRating, arenatype, bgQueueTypeId, bgTypeId, bracketEntry->GetBracketId());
}
static bool HandleGroupListCommand(ChatHandler* handler, char const* args)
{
// Get ALL the variables!
Player* playerTarget;
uint32 phase = 0;
uint64 guidTarget;
std::string nameTarget;
std::string zoneName;
const char* onlineState = "";
// Parse the guid to uint32...
uint32 parseGUID = MAKE_NEW_GUID(atol((char*)args), 0, HIGHGUID_PLAYER);
// ... and try to extract a player out of it.
if (sObjectMgr->GetPlayerNameByGUID(parseGUID, nameTarget))
{
playerTarget = sObjectMgr->GetPlayerByLowGUID(parseGUID);
guidTarget = parseGUID;
}
// If not, we return false and end right away.
else if (!handler->extractPlayerTarget((char*)args, &playerTarget, &guidTarget, &nameTarget))
return false;
// Next, we need a group. So we define a group variable.
Group* groupTarget = NULL;
// We try to extract a group from an online player.
if (playerTarget)
groupTarget = playerTarget->GetGroup();
// If not, we extract it from the SQL.
if (!groupTarget)
{
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GROUP_MEMBER);
stmt->setUInt32(0, guidTarget);
PreparedQueryResult resultGroup = CharacterDatabase.Query(stmt);
if (resultGroup)
groupTarget = sGroupMgr->GetGroupByDbStoreId((*resultGroup)[0].GetUInt32());
}
// If both fails, players simply has no party. Return false.
if (!groupTarget)
{
handler->PSendSysMessage(LANG_GROUP_NOT_IN_GROUP, nameTarget.c_str());
handler->SetSentErrorMessage(true);
return false;
}
// We get the group members after successfully detecting a group.
Group::MemberSlotList const& members = groupTarget->GetMemberSlots();
// To avoid a cluster f**k, namely trying multiple queries to simply get a group member count...
handler->PSendSysMessage(LANG_GROUP_TYPE, (groupTarget->isRaidGroup() ? "raid" : "party"), members.size());
// ... we simply move the group type and member count print after retrieving the slots and simply output it's size.
// While rather dirty codestyle-wise, it saves space (if only a little). For each member, we look several informations up.
for (Group::MemberSlotList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
{
// Define temporary variable slot to iterator.
Group::MemberSlot const& slot = *itr;
// Check for given flag and assign it to that iterator
std::string flags;
if (slot.flags & MEMBER_FLAG_ASSISTANT)
flags = "Assistant";
if (slot.flags & MEMBER_FLAG_MAINTANK)
{
if (!flags.empty())
flags.append(", ");
flags.append("MainTank");
}
if (slot.flags & MEMBER_FLAG_MAINASSIST)
{
if (!flags.empty())
flags.append(", ");
flags.append("MainAssist");
}
if (flags.empty())
flags = "None";
// Check if iterator is online. If is...
Player* p = ObjectAccessor::FindPlayer((*itr).guid);
if (p && p->IsInWorld())
{
// ... than, it prints information like "is online", where he is, etc...
onlineState = "online";
phase = (!p->IsGameMaster() ? p->GetPhaseMask() : -1);
uint32 locale = handler->GetSessionDbcLocale();
AreaTableEntry const* area = GetAreaEntryByAreaID(p->GetAreaId());
if (area)
{
AreaTableEntry const* zone = GetAreaEntryByAreaID(area->zone);
if (zone)
zoneName = zone->area_name[locale];
}
}
else
{
// ... else, everything is set to offline or neutral values.
zoneName = "<ERROR>";
onlineState = "Offline";
phase = 0;
}
// Now we can print those informations for every single member of each group!
handler->PSendSysMessage(LANG_GROUP_PLAYER_NAME_GUID, slot.name.c_str(), onlineState,
zoneName.c_str(), phase, GUID_LOPART(slot.guid), flags.c_str(),
lfg::GetRolesString(slot.roles).c_str());
}
// And finish after every iterator is done.
return true;
}
void ChatLog::BattleGroundMsg(Player *player, std::string &msg, uint32 type)
{
if (!_ChatCommon(CHAT_LOG_BATTLEGROUND, player, msg)) return;
CheckDateSwitch();
std::string log_str = "";
log_str.append("[");
log_str.append(player->GetName());
switch (type)
{
case CHAT_MSG_BATTLEGROUND:
log_str.append("]->BG:");
break;
case CHAT_MSG_BATTLEGROUND_LEADER:
log_str.append("]->BG_LEADER:");
break;
default:
log_str.append("]->BG_UNKNOWN:");
break;
}
Group *group = player->GetGroup();
if (!group)
{
log_str.append("[unknown group] ");
}
else
{
// obtain group information
log_str.append("[");
ObjectGuid gm_leader_GUID = group->GetLeaderGuid();
Player *gm_member;
gm_member = sObjectMgr.GetPlayer(gm_leader_GUID);
if (gm_member)
{
log_str.append(gm_member->GetName());
log_str.append(",");
}
Group::MemberSlotList g_members = group->GetMemberSlots();
for (Group::member_citerator itr = g_members.begin(); itr != g_members.end(); itr++)
{
if (itr->guid == gm_leader_GUID) continue;
gm_member = sObjectMgr.GetPlayer(itr->guid);
if (gm_member)
{
log_str.append(itr->name);
log_str.append(",");
}
}
log_str.erase(log_str.length() - 1);
log_str.append("] ");
}
log_str.append(msg);
log_str.append("\n");
if (screenflag[CHAT_LOG_BATTLEGROUND]) printf("%s", log_str.c_str());
if (files[CHAT_LOG_BATTLEGROUND])
{
OutTimestamp(files[CHAT_LOG_BATTLEGROUND]);
fprintf(files[CHAT_LOG_BATTLEGROUND], "%s", log_str.c_str());
fflush(files[CHAT_LOG_BATTLEGROUND]);
}
}
void ChatLog::PartyMsg(Player *player, std::string &msg)
{
if (!_ChatCommon(CHAT_LOG_PARTY, player, msg)) return;
CheckDateSwitch();
std::string log_str = "";
log_str.append("[");
log_str.append(player->GetName());
log_str.append("]->GROUP:");
Group *group = player->GetGroup();
if (!group)
{
log_str.append("[unknown group] ");
}
else
{
// obtain group information
log_str.append("[");
ObjectGuid gm_leader_GUID = group->GetLeaderGuid();
Player *gm_member;
gm_member = sObjectMgr.GetPlayer(gm_leader_GUID);
if (gm_member)
{
log_str.append(gm_member->GetName());
log_str.append(",");
}
Group::MemberSlotList g_members = group->GetMemberSlots();
for (Group::member_citerator itr = g_members.begin(); itr != g_members.end(); itr++)
{
if (itr->guid == gm_leader_GUID) continue;
gm_member = sObjectMgr.GetPlayer(itr->guid);
if (gm_member)
{
log_str.append(itr->name);
log_str.append(",");
}
}
log_str.erase(log_str.length() - 1);
log_str.append("] ");
}
log_str.append(msg);
log_str.append("\n");
if (screenflag[CHAT_LOG_PARTY]) printf("%s", log_str.c_str());
if (files[CHAT_LOG_PARTY])
{
OutTimestamp(files[CHAT_LOG_PARTY]);
fprintf(files[CHAT_LOG_PARTY], "%s", log_str.c_str());
fflush(files[CHAT_LOG_PARTY]);
}
}
void WorldSession::HandleBattlemasterJoinArena(WorldPacket& recv_data)
{
DEBUG_LOG("WORLD: CMSG_BATTLEMASTER_JOIN_ARENA");
// recv_data.hexlike();
ObjectGuid guid; // arena Battlemaster guid
uint8 arenaslot; // 2v2, 3v3 or 5v5
uint8 asGroup; // asGroup
uint8 isRated; // isRated
recv_data >> guid >> arenaslot >> asGroup >> isRated;
// ignore if we already in BG or BG queue
if (_player->InBattleGround())
return;
Creature* unit = GetPlayer()->GetMap()->GetCreature(guid);
if (!unit)
return;
if (!unit->isBattleMaster()) // it's not battle master
return;
ArenaType arenatype;
uint32 arenaRating = 0;
switch (arenaslot)
{
case 0:
arenatype = ARENA_TYPE_2v2;
break;
case 1:
arenatype = ARENA_TYPE_3v3;
break;
case 2:
arenatype = ARENA_TYPE_5v5;
break;
default:
sLog.outError("Unknown arena slot %u at HandleBattlemasterJoinArena()", arenaslot);
return;
}
// check existence
BattleGround* bg = sBattleGroundMgr.GetBattleGroundTemplate(BATTLEGROUND_AA);
if (!bg)
{
sLog.outError("Battleground: template bg (all arenas) not found");
return;
}
BattleGroundTypeId bgTypeId = bg->GetTypeID();
BattleGroundQueueTypeId bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(bgTypeId, arenatype);
BattleGroundBracketId bgBracketId = _player->GetBattleGroundBracketIdFromLevel(bgTypeId);
Group* grp = NULL;
// check queue conditions
if (!asGroup)
{
// you can't join in this way by client
if (isRated)
return;
// check if already in queue
if (_player->GetBattleGroundQueueIndex(bgQueueTypeId) < PLAYER_MAX_BATTLEGROUND_QUEUES)
// player is already in this queue
return;
// check if has free queue slots
if (!_player->HasFreeBattleGroundQueueId())
return;
}
else
{
grp = _player->GetGroup();
// no group found, error
if (!grp)
return;
uint32 err = grp->CanJoinBattleGroundQueue(bgTypeId, bgQueueTypeId, arenatype, arenatype, (bool)isRated, arenaslot);
if (err != BG_JOIN_ERR_OK)
{
SendBattleGroundOrArenaJoinError(err);
return;
}
}
uint32 ateamId = 0;
if (isRated)
{
ateamId = _player->GetArenaTeamId(arenaslot);
// check real arena team existence only here (if it was moved to group->CanJoin .. () then we would have to get it twice)
ArenaTeam* at = sObjectMgr.GetArenaTeamById(ateamId);
if (!at)
{
_player->GetSession()->SendNotInArenaTeamPacket(arenatype);
return;
}
// get the team rating for queue
arenaRating = at->GetRating();
// the arena team id must match for everyone in the group
// get the personal ratings for queue
uint32 avg_pers_rating = 0;
for (Group::member_citerator citr = grp->GetMemberSlots().begin(); citr != grp->GetMemberSlots().end(); ++citr)
{
ArenaTeamMember const* at_member = at->GetMember(citr->guid);
if (!at_member) // group member joining to arena must be in leader arena team
return;
// calc avg personal rating
avg_pers_rating += at_member->personal_rating;
}
avg_pers_rating /= grp->GetMembersCount();
// if avg personal rating is more than 150 points below the teams rating, the team will be queued against an opponent matching or similar to the average personal rating
if (avg_pers_rating + 150 < arenaRating)
arenaRating = avg_pers_rating;
}
BattleGroundQueue& bgQueue = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId];
if (asGroup)
{
DEBUG_LOG("Battleground: arena join as group start");
if (isRated)
DEBUG_LOG("Battleground: arena team id %u, leader %s queued with rating %u for type %u", _player->GetArenaTeamId(arenaslot), _player->GetName(), arenaRating, arenatype);
GroupQueueInfo* ginfo = bgQueue.AddGroup(_player, grp, bgTypeId, bgBracketId, arenatype, isRated, false, arenaRating, ateamId);
uint32 avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, _player->GetBattleGroundBracketIdFromLevel(bgTypeId));
for (GroupReference* itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
{
Player* member = itr->getSource();
if (!member)
continue;
// add to queue
uint32 queueSlot = member->AddBattleGroundQueueId(bgQueueTypeId);
// store entry point coords (same as leader entry point)
member->SetBattleGroundEntryPoint(_player);
WorldPacket data;
// send status packet (in queue)
sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, queueSlot, STATUS_WAIT_QUEUE, avgTime, 0, arenatype);
member->GetSession()->SendPacket(&data);
sBattleGroundMgr.BuildGroupJoinedBattlegroundPacket(&data, bgTypeId);
member->GetSession()->SendPacket(&data);
DEBUG_LOG("Battleground: player joined queue for arena as group bg queue type %u bg type %u: GUID %u, NAME %s", bgQueueTypeId, bgTypeId, member->GetGUIDLow(), member->GetName());
}
DEBUG_LOG("Battleground: arena join as group end");
}
else
{
GroupQueueInfo* ginfo = bgQueue.AddGroup(_player, NULL, bgTypeId, bgBracketId, arenatype, isRated, false, arenaRating, ateamId);
uint32 avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, _player->GetBattleGroundBracketIdFromLevel(bgTypeId));
uint32 queueSlot = _player->AddBattleGroundQueueId(bgQueueTypeId);
// store entry point coords
_player->SetBattleGroundEntryPoint();
WorldPacket data;
// send status packet (in queue)
sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, queueSlot, STATUS_WAIT_QUEUE, avgTime, 0, arenatype);
SendPacket(&data);
DEBUG_LOG("Battleground: player joined queue for arena, skirmish, bg queue type %u bg type %u: GUID %u, NAME %s", bgQueueTypeId, bgTypeId, _player->GetGUIDLow(), _player->GetName());
}
sBattleGroundMgr.ScheduleQueueUpdate(arenaRating, arenatype, bgQueueTypeId, bgTypeId, _player->GetBattleGroundBracketIdFromLevel(bgTypeId));
}
static bool HandleGroupListCommand(ChatHandler* handler, char const* args)
{
Player* playerTarget;
uint64 guidTarget;
std::string nameTarget;
uint32 parseGUID = MAKE_NEW_GUID(atol((char*)args), 0, HIGHGUID_PLAYER);
if (sObjectMgr->GetPlayerNameByGUID(parseGUID, nameTarget))
{
playerTarget = sObjectMgr->GetPlayerByLowGUID(parseGUID);
guidTarget = parseGUID;
}
else if (!handler->extractPlayerTarget((char*)args, &playerTarget, &guidTarget, &nameTarget))
return false;
Group* groupTarget = NULL;
if (playerTarget)
groupTarget = playerTarget->GetGroup();
if (!groupTarget)
{
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GROUP_MEMBER);
stmt->setUInt32(0, guidTarget);
PreparedQueryResult resultGroup = CharacterDatabase.Query(stmt);
if (resultGroup)
groupTarget = sGroupMgr->GetGroupByDbStoreId((*resultGroup)[0].GetUInt32());
}
if (!groupTarget)
{
handler->PSendSysMessage(LANG_GROUP_NOT_IN_GROUP, nameTarget.c_str());
handler->SetSentErrorMessage(true);
return false;
}
handler->PSendSysMessage(LANG_GROUP_TYPE, (groupTarget->isRaidGroup() ? "raid" : "party"));
Group::MemberSlotList const& members = groupTarget->GetMemberSlots();
for (Group::MemberSlotList::const_iterator itr = members.begin(); itr != members.end(); ++itr)
{
Group::MemberSlot const& slot = *itr;
std::string flags;
if (slot.flags & MEMBER_FLAG_ASSISTANT)
flags = "Assistant";
if (slot.flags & MEMBER_FLAG_MAINTANK)
{
if (!flags.empty())
flags.append(", ");
flags.append("MainTank");
}
if (slot.flags & MEMBER_FLAG_MAINASSIST)
{
if (!flags.empty())
flags.append(", ");
flags.append("MainAssist");
}
if (flags.empty())
flags = "None";
Player* p = ObjectAccessor::FindPlayer((*itr).guid);
const char* onlineState = (p && p->IsInWorld()) ? "online" : "offline";
handler->PSendSysMessage(LANG_GROUP_PLAYER_NAME_GUID, slot.name.c_str(), onlineState,
GUID_LOPART(slot.guid), flags.c_str(), lfg::GetRolesString(slot.roles).c_str());
}
return true;
}