#include <LFGQueue.h>

Public Member Functions
std::string	GetDetailedMatchRoles (GuidList const &check) const

void	AddToQueue (ObjectGuid guid)

void	RemoveFromQueue (ObjectGuid guid)

void	AddQueueData (ObjectGuid guid, time_t joinTime, LfgDungeonSet const &dungeons, LfgRolesMap const &rolesMap)

void	RemoveQueueData (ObjectGuid guid)

void	UpdateWaitTimeAvg (int32 waitTime, uint32 dungeonId)

void	UpdateWaitTimeTank (int32 waitTime, uint32 dungeonId)

void	UpdateWaitTimeHealer (int32 waitTime, uint32 dungeonId)

void	UpdateWaitTimeDps (int32 waitTime, uint32 dungeonId)

void	UpdateQueueTimers (uint8 queueId, time_t currTime)

time_t	GetJoinTime (ObjectGuid guid) const

uint8	FindGroups ()

std::string	DumpQueueInfo () const

std::string	DumpCompatibleInfo (bool full=false) const

Private Member Functions
void	SetQueueUpdateData (std::string const &strGuids, LfgRolesMap const &proposalRoles)

void	AddToNewQueue (ObjectGuid guid)

void	AddToCurrentQueue (ObjectGuid guid)

void	RemoveFromNewQueue (ObjectGuid guid)

void	RemoveFromCurrentQueue (ObjectGuid guid)

void	SetCompatibles (std::string const &key, LfgCompatibility compatibles)

LfgCompatibility	GetCompatibles (std::string const &key)

void	RemoveFromCompatibles (ObjectGuid guid)

void	SetCompatibilityData (std::string const &key, LfgCompatibilityData const &compatibles)

LfgCompatibilityData *	GetCompatibilityData (std::string const &key)

void	FindBestCompatibleInQueue (LfgQueueDataContainer::iterator itrQueue)

void	UpdateBestCompatibleInQueue (LfgQueueDataContainer::iterator itrQueue, std::string const &key, LfgRolesMap const &roles)

LfgCompatibility	FindNewGroups (GuidList &check, GuidList &all)

LfgCompatibility	CheckCompatibility (GuidList check)

Private Attributes
LfgQueueDataContainer	QueueDataStore
	Queued groups. More...

LfgCompatibleContainer	CompatibleMapStore
	Compatible dungeons. More...

LfgWaitTimesContainer	waitTimesAvgStore
	Average wait time to find a group queuing as multiple roles. More...

LfgWaitTimesContainer	waitTimesTankStore
	Average wait time to find a group queuing as tank. More...

LfgWaitTimesContainer	waitTimesHealerStore
	Average wait time to find a group queuing as healer. More...

LfgWaitTimesContainer	waitTimesDpsStore
	Average wait time to find a group queuing as dps. More...

GuidList	currentQueueStore
	Ordered list. Used to find groups. More...

GuidList	newToQueueStore
	New groups to add to queue. More...

Detailed Description

Stores all data related to queue

Member Function Documentation

void lfg::LFGQueue::AddQueueData	(	ObjectGuid	guid,
		time_t	joinTime,
		LfgDungeonSet const &	dungeons,
		LfgRolesMap const &	rolesMap
	)

 {
  QueueDataStore[guid] = LfgQueueData(joinTime, dungeons, rolesMap);
  AddToQueue(guid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void lfg::LFGQueue::AddToCurrentQueue ( ObjectGuid guid )

private

 {
  currentQueueStore.push_back(guid);
 }

Here is the caller graph for this function:

void lfg::LFGQueue::AddToNewQueue ( ObjectGuid guid )

private

 {
  newToQueueStore.push_back(guid);
 }

Here is the caller graph for this function:

void lfg::LFGQueue::AddToQueue ( ObjectGuid guid )

 {
  LfgQueueDataContainer::iterator itQueue = QueueDataStore.find(guid);
  if (itQueue == QueueDataStore.end())
  {
  TC_LOG_ERROR("lfg.queue.add", "Queue data not found for [%s]", guid.ToString().c_str());
  return;
  }
 
  AddToNewQueue(guid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

LfgCompatibility lfg::LFGQueue::CheckCompatibility ( GuidList check )

private

Check compatibilities between groups. If group is Matched proposal will be created

Parameters

[in] check List of guids to check compatibilities

Returns: LfgCompatibility type of compatibility

 {
  std::string strGuids = ConcatenateGuids(check);
  LfgProposal proposal;
  LfgDungeonSet proposalDungeons;
  LfgGroupsMap proposalGroups;
  LfgRolesMap proposalRoles;
 
  // Check for correct size
  if (check.size() > MAX_GROUP_SIZE || check.empty())
  {
  TC_LOG_DEBUG("lfg.queue.match.compatibility.check", "Guids: (%s): Size wrong - Not compatibles", GetDetailedMatchRoles(check).c_str());
  return LFG_INCOMPATIBLES_WRONG_GROUP_SIZE;
  }
 
  // Check all-but-new compatiblitity
  if (check.size() > 2)
  {
  ObjectGuid frontGuid = check.front();
  check.pop_front();
 
  // Check all-but-new compatibilities (New, A, B, C, D) --> check(A, B, C, D)
  LfgCompatibility child_compatibles = CheckCompatibility(check);
  if (child_compatibles < LFG_COMPATIBLES_WITH_LESS_PLAYERS) // Group not compatible
  {
  TC_LOG_DEBUG("lfg.queue.match.compatibility.check", "Guids: (%s) child %s not compatibles", strGuids.c_str(), GetDetailedMatchRoles(check).c_str());
  SetCompatibles(strGuids, child_compatibles);
  return child_compatibles;
  }
  check.push_front(frontGuid);
  }
 
  // Check if more than one LFG group and number of players joining
  uint8 numPlayers = 0;
  uint8 numLfgGroups = 0;
  for (GuidList::const_iterator it = check.begin(); it != check.end() && numLfgGroups < 2 && numPlayers <= MAX_GROUP_SIZE; ++it)
  {
  ObjectGuid guid = *it;
  LfgQueueDataContainer::iterator itQueue = QueueDataStore.find(guid);
  if (itQueue == QueueDataStore.end())
  {
  TC_LOG_ERROR("lfg.queue.match.compatibility.check", "Guid: [%s] is not queued but listed as queued!", guid.ToString().c_str());
  RemoveFromQueue(guid);
  return LFG_COMPATIBILITY_PENDING;
  }
 
  // Store group so we don't need to call Mgr to get it later (if it's player group will be 0 otherwise would have joined as group)
  for (LfgRolesMap::const_iterator it2 = itQueue->second.roles.begin(); it2 != itQueue->second.roles.end(); ++it2)
  proposalGroups[it2->first] = itQueue->first.IsParty() ? itQueue->first : ObjectGuid::Empty;
 
  numPlayers += itQueue->second.roles.size();
 
  if (sLFGMgr->IsLfgGroup(guid))
  {
  if (!numLfgGroups)
  proposal.group = guid;
  ++numLfgGroups;
  }
  }
 
  // Group with less that MAX_GROUP_SIZE members always compatible
  if (check.size() == 1 && numPlayers != MAX_GROUP_SIZE)
  {
  TC_LOG_DEBUG("lfg.queue.match.compatibility.check", "Guids: (%s) single group. Compatibles", GetDetailedMatchRoles(check).c_str());
  LfgQueueDataContainer::iterator itQueue = QueueDataStore.find(check.front());
 
  LfgCompatibilityData data(LFG_COMPATIBLES_WITH_LESS_PLAYERS);
  data.roles = itQueue->second.roles;
  LFGMgr::CheckGroupRoles(data.roles);
 
  UpdateBestCompatibleInQueue(itQueue, strGuids, data.roles);
  SetCompatibilityData(strGuids, data);
  return LFG_COMPATIBLES_WITH_LESS_PLAYERS;
  }
 
  if (numLfgGroups > 1)
  {
  TC_LOG_DEBUG("lfg.queue.match.compatibility.check", "Guids: (%s) More than one Lfggroup (%u)", GetDetailedMatchRoles(check).c_str(), numLfgGroups);
  SetCompatibles(strGuids, LFG_INCOMPATIBLES_MULTIPLE_LFG_GROUPS);
  return LFG_INCOMPATIBLES_MULTIPLE_LFG_GROUPS;
  }
 
  if (numPlayers > MAX_GROUP_SIZE)
  {
  TC_LOG_DEBUG("lfg.queue.match.compatibility.check", "Guids: (%s) Too many players (%u)", GetDetailedMatchRoles(check).c_str(), numPlayers);
  SetCompatibles(strGuids, LFG_INCOMPATIBLES_TOO_MUCH_PLAYERS);
  return LFG_INCOMPATIBLES_TOO_MUCH_PLAYERS;
  }
 
  // If it's single group no need to check for duplicate players, ignores, bad roles or bad dungeons as it's been checked before joining
  if (check.size() > 1)
  {
  for (GuidList::const_iterator it = check.begin(); it != check.end(); ++it)
  {
  LfgRolesMap const& roles = QueueDataStore[(*it)].roles;
  for (LfgRolesMap::const_iterator itRoles = roles.begin(); itRoles != roles.end(); ++itRoles)
  {
  LfgRolesMap::const_iterator itPlayer;
  for (itPlayer = proposalRoles.begin(); itPlayer != proposalRoles.end(); ++itPlayer)
  {
  if (itRoles->first == itPlayer->first)
  TC_LOG_ERROR("lfg.queue.match.compatibility.check", "Guids: ERROR! Player multiple times in queue! [%s]", itRoles->first.ToString().c_str());
  else if (sLFGMgr->HasIgnore(itRoles->first, itPlayer->first))
  break;
  }
  if (itPlayer == proposalRoles.end())
  proposalRoles[itRoles->first] = itRoles->second;
  }
  }
 
  if (uint8 playersize = numPlayers - proposalRoles.size())
  {
  TC_LOG_DEBUG("lfg.queue.match.compatibility.check", "Guids: (%s) not compatible, %u players are ignoring each other", GetDetailedMatchRoles(check).c_str(), playersize);
  SetCompatibles(strGuids, LFG_INCOMPATIBLES_HAS_IGNORES);
  return LFG_INCOMPATIBLES_HAS_IGNORES;
  }
 
  LfgRolesMap debugRoles = proposalRoles;
  if (!LFGMgr::CheckGroupRoles(proposalRoles))
  {
  std::ostringstream o;
  for (LfgRolesMap::const_iterator it = debugRoles.begin(); it != debugRoles.end(); ++it)
  o << ", " << it->first << ": " << GetRolesString(it->second);
 
  TC_LOG_DEBUG("lfg.queue.match.compatibility.check", "Guids: (%s) Roles not compatible%s", GetDetailedMatchRoles(check).c_str(), o.str().c_str());
  SetCompatibles(strGuids, LFG_INCOMPATIBLES_NO_ROLES);
  return LFG_INCOMPATIBLES_NO_ROLES;
  }
 
  GuidList::iterator itguid = check.begin();
  proposalDungeons = QueueDataStore[*itguid].dungeons;
  std::ostringstream o;
  o << ", " << *itguid << ": (" << ConcatenateDungeons(proposalDungeons) << ")";
  for (++itguid; itguid != check.end(); ++itguid)
  {
  LfgDungeonSet temporal;
  LfgDungeonSet& dungeons = QueueDataStore[*itguid].dungeons;
  o << ", " << *itguid << ": (" << ConcatenateDungeons(dungeons) << ")";
  std::set_intersection(proposalDungeons.begin(), proposalDungeons.end(), dungeons.begin(), dungeons.end(), std::inserter(temporal, temporal.begin()));
  proposalDungeons = temporal;
  }
 
  if (proposalDungeons.empty())
  {
  TC_LOG_DEBUG("lfg.queue.match.compatibility.check", "Guids: (%s) No compatible dungeons%s", GetDetailedMatchRoles(check).c_str(), o.str().c_str());
  SetCompatibles(strGuids, LFG_INCOMPATIBLES_NO_DUNGEONS);
  return LFG_INCOMPATIBLES_NO_DUNGEONS;
  }
  }
  else
  {
  ObjectGuid gguid = *check.begin();
  const LfgQueueData &queue = QueueDataStore[gguid];
  proposalDungeons = queue.dungeons;
  proposalRoles = queue.roles;
  LFGMgr::CheckGroupRoles(proposalRoles); // assing new roles
  }
 
  // Enough players?
  if (numPlayers != MAX_GROUP_SIZE)
  {
  TC_LOG_DEBUG("lfg.queue.match.compatibility.check", "Guids: (%s) Compatibles but not enough players(%u)", GetDetailedMatchRoles(check).c_str(), numPlayers);
  LfgCompatibilityData data(LFG_COMPATIBLES_WITH_LESS_PLAYERS);
  data.roles = proposalRoles;
 
  for (GuidList::const_iterator itr = check.begin(); itr != check.end(); ++itr)
  UpdateBestCompatibleInQueue(QueueDataStore.find(*itr), strGuids, data.roles);
 
  SetCompatibilityData(strGuids, data);
  return LFG_COMPATIBLES_WITH_LESS_PLAYERS;
  }
 
  ObjectGuid gguid = *check.begin();
  proposal.queues = check;
  proposal.isNew = numLfgGroups != 1 || sLFGMgr->GetOldState(gguid) != LFG_STATE_DUNGEON;
 
  if (!sLFGMgr->AllQueued(check))
  {
  TC_LOG_DEBUG("lfg.queue.match.compatibility.check", "Guids: (%s) Group MATCH but can't create proposal!", GetDetailedMatchRoles(check).c_str());
  SetCompatibles(strGuids, LFG_COMPATIBLES_BAD_STATES);
  return LFG_COMPATIBLES_BAD_STATES;
  }
 
  // Create a new proposal
  proposal.cancelTime = time(NULL) + LFG_TIME_PROPOSAL;
  proposal.state = LFG_PROPOSAL_INITIATING;
  proposal.leader.Clear();
  proposal.dungeonId = Trinity::Containers::SelectRandomContainerElement(proposalDungeons);
 
  bool leader = false;
  for (LfgRolesMap::const_iterator itRoles = proposalRoles.begin(); itRoles != proposalRoles.end(); ++itRoles)
  {
  // Assing new leader
  if (itRoles->second & PLAYER_ROLE_LEADER)
  {
  if (!leader || !proposal.leader || urand(0, 1))
  proposal.leader = itRoles->first;
  leader = true;
  }
  else if (!leader && (!proposal.leader || urand(0, 1)))
  proposal.leader = itRoles->first;
 
  // Assing player data and roles
  LfgProposalPlayer &data = proposal.players[itRoles->first];
  data.role = itRoles->second;
  data.group = proposalGroups.find(itRoles->first)->second;
  if (!proposal.isNew && !data.group.IsEmpty() && data.group == proposal.group) // Player from existing group, autoaccept
  data.accept = LFG_ANSWER_AGREE;
  }
 
  // Mark proposal members as not queued (but not remove queue data)
  for (GuidList::const_iterator itQueue = proposal.queues.begin(); itQueue != proposal.queues.end(); ++itQueue)
  {
  ObjectGuid guid = (*itQueue);
  RemoveFromNewQueue(guid);
  RemoveFromCurrentQueue(guid);
  }
 
  sLFGMgr->AddProposal(proposal);
 
  TC_LOG_DEBUG("lfg.queue.match.compatibility.check", "Guids: (%s) MATCH! Group formed", GetDetailedMatchRoles(check).c_str());
  SetCompatibles(strGuids, LFG_COMPATIBLES_MATCH);
  return LFG_COMPATIBLES_MATCH;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string lfg::LFGQueue::DumpCompatibleInfo ( bool full = false ) const

 {
  std::ostringstream o;
  o << "Compatible Map size: " << CompatibleMapStore.size() << "\n";
  if (full)
  for (LfgCompatibleContainer::const_iterator itr = CompatibleMapStore.begin(); itr != CompatibleMapStore.end(); ++itr)
  {
  o << "(" << itr->first << "): " << GetCompatibleString(itr->second.compatibility);
  if (!itr->second.roles.empty())
  {
  o << " (";
  bool first = true;
  for (const auto& role : itr->second.roles)
  {
  if (!first)
  o << "|";
  o << role.first.ToString() << " " << GetRolesString(role.second & uint8(~PLAYER_ROLE_LEADER));
  first = false;
  }
  o << ")";
  }
  o << "\n";
  }
 
  return o.str();
 }

Here is the call graph for this function:

std::string lfg::LFGQueue::DumpQueueInfo ( ) const

 {
  uint32 players = 0;
  uint32 groups = 0;
  uint32 playersInGroup = 0;
 
  for (uint8 i = 0; i < 2; ++i)
  {
  GuidList const& queue = i ? newToQueueStore : currentQueueStore;
  for (GuidList::const_iterator it = queue.begin(); it != queue.end(); ++it)
  {
  ObjectGuid guid = *it;
  if (guid.IsParty())
  {
  groups++;
  playersInGroup += sLFGMgr->GetPlayerCount(guid);
  }
  else
  players++;
  }
  }
  std::ostringstream o;
  o << "Queued Players: " << players << " (in group: " << playersInGroup << ") Groups: " << groups << "\n";
  return o.str();
 }

Here is the call graph for this function:

void lfg::LFGQueue::FindBestCompatibleInQueue ( LfgQueueDataContainer::iterator itrQueue )

private

 {
  TC_LOG_DEBUG("lfg.queue.compatibles.find", "%s", itrQueue->first.ToString().c_str());
  std::ostringstream o;
  o << itrQueue->first;
  std::string sguid = o.str();
 
  for (LfgCompatibleContainer::const_iterator itr = CompatibleMapStore.begin(); itr != CompatibleMapStore.end(); ++itr)
  if (itr->second.compatibility == LFG_COMPATIBLES_WITH_LESS_PLAYERS &&
  std::string::npos != itr->first.find(sguid))
  {
  UpdateBestCompatibleInQueue(itrQueue, itr->first, itr->second.roles);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint8 lfg::LFGQueue::FindGroups ( )

 {
  uint8 proposals = 0;
  GuidList firstNew;
  while (!newToQueueStore.empty())
  {
  ObjectGuid frontguid = newToQueueStore.front();
  TC_LOG_DEBUG("lfg.queue.match.check.new", "Checking [%s] newToQueue(%u), currentQueue(%u)", frontguid.ToString().c_str(),
  uint32(newToQueueStore.size()), uint32(currentQueueStore.size()));
 
  firstNew.clear();
  firstNew.push_back(frontguid);
  RemoveFromNewQueue(frontguid);
 
  GuidList temporalList = currentQueueStore;
  LfgCompatibility compatibles = FindNewGroups(firstNew, temporalList);
 
  if (compatibles == LFG_COMPATIBLES_MATCH)
  ++proposals;
  else
  AddToCurrentQueue(frontguid); // Lfg group not found, add this group to the queue.
  }
  return proposals;
 }

Here is the call graph for this function:

LfgCompatibility lfg::LFGQueue::FindNewGroups	(	GuidList &	check,
		GuidList &	all
	)

private

Checks que main queue to try to form a Lfg group. Returns first match found (if any)

Parameters

[in]	check	List of guids trying to match with other groups
[in]	all	List of all other guids in main queue to match against

Returns: LfgCompatibility type of compatibility between groups

 {
  std::string strGuids = ConcatenateGuids(check);
  LfgCompatibility compatibles = GetCompatibles(strGuids);
 
  TC_LOG_DEBUG("lfg.queue.match.check", "Guids: (%s): %s - all(%s)", GetDetailedMatchRoles(check).c_str(), GetCompatibleString(compatibles), GetDetailedMatchRoles(all).c_str());
  if (compatibles == LFG_COMPATIBILITY_PENDING) // Not previously cached, calculate
  compatibles = CheckCompatibility(check);
 
  if (compatibles == LFG_COMPATIBLES_BAD_STATES && sLFGMgr->AllQueued(check))
  {
  TC_LOG_DEBUG("lfg.queue.match.check", "Guids: (%s) compatibles (cached) changed from bad states to match", GetDetailedMatchRoles(check).c_str());
  SetCompatibles(strGuids, LFG_COMPATIBLES_MATCH);
  return LFG_COMPATIBLES_MATCH;
  }
 
  if (compatibles != LFG_COMPATIBLES_WITH_LESS_PLAYERS)
  return compatibles;
 
  // Try to match with queued groups
  while (!all.empty())
  {
  check.push_back(all.front());
  all.pop_front();
  LfgCompatibility subcompatibility = FindNewGroups(check, all);
  if (subcompatibility == LFG_COMPATIBLES_MATCH)
  return LFG_COMPATIBLES_MATCH;
  check.pop_back();
  }
  return compatibles;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

LfgCompatibilityData * lfg::LFGQueue::GetCompatibilityData ( std::string const & key )

private

 {
  LfgCompatibleContainer::iterator itr = CompatibleMapStore.find(key);
  if (itr != CompatibleMapStore.end())
  return &(itr->second);
 
  return NULL;
 }

LfgCompatibility lfg::LFGQueue::GetCompatibles ( std::string const & key )

private

Get the compatibility of a group of guids

Parameters

[in] key String concatenation of guids (| used as separator)

Returns: LfgCompatibility type of compatibility

 {
  LfgCompatibleContainer::iterator itr = CompatibleMapStore.find(key);
  if (itr != CompatibleMapStore.end())
  return itr->second.compatibility;
 
  return LFG_COMPATIBILITY_PENDING;
 }

Here is the caller graph for this function:

std::string lfg::LFGQueue::GetDetailedMatchRoles ( GuidList const & check ) const

 {
  if (check.empty())
  return "";
 
  // need the guids in order to avoid duplicates
  GuidSet guids(check.begin(), check.end());
 
  std::ostringstream o;
 
  GuidSet::const_iterator it = guids.begin();
  o << it->ToString();
  LfgQueueDataContainer::const_iterator itQueue = QueueDataStore.find(*it);
  if (itQueue != QueueDataStore.end())
  {
  // skip leader flag, log only dps/tank/healer
  auto role = itQueue->second.roles.find(*it);
  if (role != itQueue->second.roles.end())
  o << ' ' << GetRolesString(itQueue->second.roles.at(*it) & uint8(~PLAYER_ROLE_LEADER));
  }
 
  for (++it; it != guids.end(); ++it)
  {
  o << '|' << it->ToString();
  itQueue = QueueDataStore.find(*it);
  if (itQueue != QueueDataStore.end())
  {
  // skip leader flag, log only dps/tank/healer
  auto role = itQueue->second.roles.find(*it);
  if (role != itQueue->second.roles.end())
  o << ' ' << GetRolesString(itQueue->second.roles.at(*it) & uint8(~PLAYER_ROLE_LEADER));
  }
  }
 
  return o.str();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

time_t lfg::LFGQueue::GetJoinTime ( ObjectGuid guid ) const

 {
  LfgQueueDataContainer::const_iterator itr = QueueDataStore.find(guid);
  if (itr != QueueDataStore.end())
  return itr->second.joinTime;
 
  return 0;
 }

Here is the caller graph for this function:

void lfg::LFGQueue::RemoveFromCompatibles ( ObjectGuid guid )

private

Remove from cached compatible dungeons any entry that contains the given guid

Parameters

[in] guid Guid to remove from compatible cache

 {
  std::stringstream out;
  out << guid;
  std::string strGuid = out.str();
 
  TC_LOG_DEBUG("lfg.queue.data.compatibles.remove", "Removing %s", guid.ToString().c_str());
  for (LfgCompatibleContainer::iterator itNext = CompatibleMapStore.begin(); itNext != CompatibleMapStore.end();)
  {
  LfgCompatibleContainer::iterator it = itNext++;
  if (std::string::npos != it->first.find(strGuid))
  CompatibleMapStore.erase(it);
  }
 }

Here is the caller graph for this function:

void lfg::LFGQueue::RemoveFromCurrentQueue ( ObjectGuid guid )

private

 {
  currentQueueStore.remove(guid);
 }

Here is the caller graph for this function:

void lfg::LFGQueue::RemoveFromNewQueue ( ObjectGuid guid )

private

 {
  newToQueueStore.remove(guid);
 }

Here is the caller graph for this function:

void lfg::LFGQueue::RemoveFromQueue ( ObjectGuid guid )

 {
  RemoveFromNewQueue(guid);
  RemoveFromCurrentQueue(guid);
  RemoveFromCompatibles(guid);
 
  std::ostringstream o;
  o << guid;
  std::string sguid = o.str();
 
  LfgQueueDataContainer::iterator itDelete = QueueDataStore.end();
  for (LfgQueueDataContainer::iterator itr = QueueDataStore.begin(); itr != QueueDataStore.end(); ++itr)
  if (itr->first != guid)
  {
  if (std::string::npos != itr->second.bestCompatible.find(sguid))
  {
  itr->second.bestCompatible.clear();
  FindBestCompatibleInQueue(itr);
  }
  }
  else
  itDelete = itr;
 
  if (itDelete != QueueDataStore.end())
  QueueDataStore.erase(itDelete);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void lfg::LFGQueue::RemoveQueueData ( ObjectGuid guid )

 {
  LfgQueueDataContainer::iterator it = QueueDataStore.find(guid);
  if (it != QueueDataStore.end())
  QueueDataStore.erase(it);
 }

void lfg::LFGQueue::SetCompatibilityData	(	std::string const &	key,
		LfgCompatibilityData const &	compatibles
	)

private

 {
  CompatibleMapStore[key] = data;
 }

Here is the caller graph for this function:

void lfg::LFGQueue::SetCompatibles	(	std::string const &	key,
		LfgCompatibility	compatibles
	)

private

Stores the compatibility of a list of guids

Parameters

[in]	key	String concatenation of guids (\| used as separator)
[in]	compatibles	type of compatibility

 {
  LfgCompatibilityData& data = CompatibleMapStore[key];
  data.compatibility = compatibles;
 }

Here is the caller graph for this function:

void lfg::LFGQueue::SetQueueUpdateData	(	std::string const &	strGuids,
		LfgRolesMap const &	proposalRoles
	)

private

void lfg::LFGQueue::UpdateBestCompatibleInQueue	(	LfgQueueDataContainer::iterator	itrQueue,
		std::string const &	key,
		LfgRolesMap const &	roles
	)

private

 {
  LfgQueueData& queueData = itrQueue->second;
 
  uint8 storedSize = queueData.bestCompatible.empty() ? 0 :
  std::count(queueData.bestCompatible.begin(), queueData.bestCompatible.end(), '|') + 1;
 
  uint8 size = std::count(key.begin(), key.end(), '|') + 1;
 
  if (size <= storedSize)
  return;
 
  TC_LOG_DEBUG("lfg.queue.compatibles.update", "Changed (%s) to (%s) as best compatible group for %s",
  queueData.bestCompatible.c_str(), key.c_str(), itrQueue->first.ToString().c_str());
 
  queueData.bestCompatible = key;
  queueData.tanks = LFG_TANKS_NEEDED;
  queueData.healers = LFG_HEALERS_NEEDED;
  queueData.dps = LFG_DPS_NEEDED;
  for (LfgRolesMap::const_iterator it = roles.begin(); it != roles.end(); ++it)
  {
  uint8 role = it->second;
  if (role & PLAYER_ROLE_TANK)
  --queueData.tanks;
  else if (role & PLAYER_ROLE_HEALER)
  --queueData.healers;
  else
  --queueData.dps;
  }
 }

Here is the caller graph for this function:

void lfg::LFGQueue::UpdateQueueTimers	(	uint8	queueId,
		time_t	currTime
	)

 {
  TC_LOG_TRACE("lfg.queue.timers.update", "Updating queue timers...");
  for (LfgQueueDataContainer::iterator itQueue = QueueDataStore.begin(); itQueue != QueueDataStore.end(); ++itQueue)
  {
  LfgQueueData& queueinfo = itQueue->second;
  uint32 dungeonId = (*queueinfo.dungeons.begin());
  uint32 queuedTime = uint32(currTime - queueinfo.joinTime);
  uint8 role = PLAYER_ROLE_NONE;
  int32 waitTime = -1;
  int32 wtTank = waitTimesTankStore[dungeonId].time;
  int32 wtHealer = waitTimesHealerStore[dungeonId].time;
  int32 wtDps = waitTimesDpsStore[dungeonId].time;
  int32 wtAvg = waitTimesAvgStore[dungeonId].time;
 
  for (LfgRolesMap::const_iterator itPlayer = queueinfo.roles.begin(); itPlayer != queueinfo.roles.end(); ++itPlayer)
  role |= itPlayer->second;
  role &= ~PLAYER_ROLE_LEADER;
 
  switch (role)
  {
  case PLAYER_ROLE_NONE: // Should not happen - just in case
  waitTime = -1;
  break;
  case PLAYER_ROLE_TANK:
  waitTime = wtTank;
  break;
  case PLAYER_ROLE_HEALER:
  waitTime = wtHealer;
  break;
  case PLAYER_ROLE_DAMAGE:
  waitTime = wtDps;
  break;
  default:
  waitTime = wtAvg;
  break;
  }
 
  if (queueinfo.bestCompatible.empty())
  FindBestCompatibleInQueue(itQueue);
 
  LfgQueueStatusData queueData(queueId, dungeonId, queueinfo.joinTime, waitTime, wtAvg, wtTank, wtHealer, wtDps, queuedTime, queueinfo.tanks, queueinfo.healers, queueinfo.dps);
  for (LfgRolesMap::const_iterator itPlayer = queueinfo.roles.begin(); itPlayer != queueinfo.roles.end(); ++itPlayer)
  {
  ObjectGuid pguid = itPlayer->first;
  LFGMgr::SendLfgQueueStatus(pguid, queueData);
  }
  }
 }

Here is the call graph for this function:

void lfg::LFGQueue::UpdateWaitTimeAvg	(	int32	waitTime,
		uint32	dungeonId
	)

 {
  LfgWaitTime &wt = waitTimesAvgStore[dungeonId];
  uint32 old_number = wt.number++;
  wt.time = int32((wt.time * old_number + waitTime) / wt.number);
 }

Here is the caller graph for this function:

void lfg::LFGQueue::UpdateWaitTimeDps	(	int32	waitTime,
		uint32	dungeonId
	)

 {
  LfgWaitTime &wt = waitTimesDpsStore[dungeonId];
  uint32 old_number = wt.number++;
  wt.time = int32((wt.time * old_number + waitTime) / wt.number);
 }

Here is the caller graph for this function:

void lfg::LFGQueue::UpdateWaitTimeHealer	(	int32	waitTime,
		uint32	dungeonId
	)

 {
  LfgWaitTime &wt = waitTimesHealerStore[dungeonId];
  uint32 old_number = wt.number++;
  wt.time = int32((wt.time * old_number + waitTime) / wt.number);
 }

Here is the caller graph for this function:

void lfg::LFGQueue::UpdateWaitTimeTank	(	int32	waitTime,
		uint32	dungeonId
	)

 {
  LfgWaitTime &wt = waitTimesTankStore[dungeonId];
  uint32 old_number = wt.number++;
  wt.time = int32((wt.time * old_number + waitTime) / wt.number);
 }

Here is the caller graph for this function:

Member Data Documentation

LfgCompatibleContainer lfg::LFGQueue::CompatibleMapStore

private

Compatible dungeons.

GuidList lfg::LFGQueue::currentQueueStore

private

Ordered list. Used to find groups.

GuidList lfg::LFGQueue::newToQueueStore

private

New groups to add to queue.

LfgQueueDataContainer lfg::LFGQueue::QueueDataStore

private

Queued groups.

LfgWaitTimesContainer lfg::LFGQueue::waitTimesAvgStore

private

Average wait time to find a group queuing as multiple roles.

LfgWaitTimesContainer lfg::LFGQueue::waitTimesDpsStore

private

Average wait time to find a group queuing as dps.

LfgWaitTimesContainer lfg::LFGQueue::waitTimesHealerStore

private

Average wait time to find a group queuing as healer.

LfgWaitTimesContainer lfg::LFGQueue::waitTimesTankStore

private

Average wait time to find a group queuing as tank.

The documentation for this class was generated from the following files:

src/server/game/DungeonFinding/LFGQueue.h
src/server/game/DungeonFinding/LFGQueue.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Function Documentation

Member Data Documentation