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; }