lfg::LFGQueue Class Reference

#include "LFGQueue.h"

Public Member Functions
void	AddToQueue (ObjectGuid guid, bool failedProposal=false)
void	RemoveFromQueue (ObjectGuid guid, bool partial=false)
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 (uint32 diff)
time_t	GetJoinTime (ObjectGuid guid)
uint8	FindGroups ()

Private Member Functions
void	SetQueueUpdateData (std::string const &strGuids, LfgRolesMap const &proposalRoles)
void	AddToNewQueue (ObjectGuid guid, bool front)
void	RemoveFromNewQueue (ObjectGuid guid)
void	RemoveFromCompatibles (ObjectGuid guid)
void	AddToCompatibles (Lfg5Guids const &key)
uint32	FindBestCompatibleInQueue (LfgQueueDataContainer::iterator itrQueue)
void	UpdateBestCompatibleInQueue (LfgQueueDataContainer::iterator itrQueue, Lfg5Guids const &key)
LfgCompatibility	FindNewGroups (const ObjectGuid &newGuid)
LfgCompatibility	CheckCompatibility (Lfg5Guids const &checkWith, const ObjectGuid &newGuid, uint64 &foundMask, uint32 &foundCount, const std::set< Lfg5Guids > &currentCompatibles)

Private Attributes
uint32	m_QueueStatusTimer
LfgQueueDataContainer	QueueDataStore
LfgCompatibleContainer	CompatibleList
LfgCompatibleContainer	CompatibleTempList
LfgWaitTimesContainer	waitTimesAvgStore
LfgWaitTimesContainer	waitTimesTankStore
LfgWaitTimesContainer	waitTimesHealerStore
LfgWaitTimesContainer	waitTimesDpsStore
LfgGuidList	newToQueueStore
LfgGuidList	restoredAfterProposal

Detailed Description

Stores all data related to queue

Member Function Documentation

AddQueueData()

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

    {
        LOG_DEBUG("lfg", "JOINED AddQueueData: {}", guid.ToString());
        QueueDataStore[guid] = LfgQueueData(joinTime, dungeons, rolesMap);
        AddToQueue(guid);
    }

References AddToQueue(), LOG_DEBUG, QueueDataStore, and ObjectGuid::ToString().

Referenced by lfg::LFGMgr::JoinLfg(), and lfg::LFGMgr::UpdateRoleCheck().

AddToCompatibles()

void lfg::LFGQueue::AddToCompatibles ( Lfg5Guids const &  key )

private

    {
        LOG_DEBUG("lfg", "COMPATIBLES ADD: {}", key.toString());
        CompatibleTempList.push_back(key);
    }

References CompatibleTempList, LOG_DEBUG, and lfg::Lfg5Guids::toString().

Referenced by CheckCompatibility().

AddToNewQueue()

void lfg::LFGQueue::AddToNewQueue ( ObjectGuid  guid, bool  front  )

private

    {
        if (front)
        {
            LOG_DEBUG("lfg", "ADD AddToNewQueue at FRONT: {}", guid.ToString());
            restoredAfterProposal.push_back(guid);
            newToQueueStore.push_front(guid);
        }
        else
        {
            LOG_DEBUG("lfg", "ADD AddToNewQueue at the END: {}", guid.ToString());
            newToQueueStore.push_back(guid);
        }
    }

References LOG_DEBUG, newToQueueStore, restoredAfterProposal, and ObjectGuid::ToString().

Referenced by AddToQueue().

AddToQueue()

void lfg::LFGQueue::AddToQueue	(	ObjectGuid	guid,
		bool	failedProposal = false
	)

    {
        LOG_DEBUG("lfg", "ADD AddToQueue: {}, failed proposal: {}", guid.ToString(), failedProposal ? 1 : 0);
        LfgQueueDataContainer::iterator itQueue = QueueDataStore.find(guid);
        if (itQueue == QueueDataStore.end())
        {
            LOG_ERROR("lfg", "LFGQueue::AddToQueue: Queue data not found for [{}]", guid.ToString());
            return;
        }
        LOG_DEBUG("lfg", "AddToQueue success: {}", guid.ToString());
        AddToNewQueue(guid, failedProposal);
    }

References AddToNewQueue(), LOG_DEBUG, LOG_ERROR, QueueDataStore, and ObjectGuid::ToString().

Referenced by AddQueueData(), lfg::LFGMgr::RemoveProposal(), and UpdateQueueTimers().

CheckCompatibility()

LfgCompatibility lfg::LFGQueue::CheckCompatibility ( Lfg5Guids const &  checkWith, const ObjectGuid &  newGuid, uint64 &  foundMask, uint32 &  foundCount, const std::set< Lfg5Guids > &  currentCompatibles  )

private

    {
        LOG_DEBUG("lfg", "CHECK CheckCompatibility: {}, new guid: {}", checkWith.toString(), newGuid.ToString());
        Lfg5Guids check(checkWith, false); // here newGuid is at front
        Lfg5Guids strGuids(checkWith, false); // here guids are sorted
        check.force_insert_front(newGuid);
        strGuids.insert(newGuid);
 
        if (!currentCompatibles.empty() && currentCompatibles.find(strGuids) != currentCompatibles.end())
            return LFG_INCOMPATIBLES_TOO_MUCH_PLAYERS;
 
        LfgProposal proposal;
        LfgDungeonSet proposalDungeons;
        LfgGroupsMap proposalGroups;
        LfgRolesMap proposalRoles;
 
        // Check if more than one LFG group and number of players joining
        uint8 numPlayers = 0;
        uint8 numLfgGroups = 0;
        ObjectGuid guid;
        uint64 addToFoundMask = 0;
 
        for (uint8 i = 0; i < 5 && !(guid = check.guids[i]).IsEmpty() && numLfgGroups < 2 && numPlayers <= MAXGROUPSIZE; ++i)
        {
            LfgQueueDataContainer::iterator itQueue = QueueDataStore.find(guid);
            if (itQueue == QueueDataStore.end())
            {
                LOG_ERROR("lfg", "LFGQueue::CheckCompatibility: [{}] is not queued but listed as queued!", guid.ToString());
                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.IsGroup() ? itQueue->first : ObjectGuid::Empty;
 
            numPlayers += itQueue->second.roles.size();
 
            if (sLFGMgr->IsLfgGroup(guid))
            {
                if (!numLfgGroups)
                    proposal.group = guid;
                ++numLfgGroups;
            }
        }
 
        if (numLfgGroups > 1)
            return LFG_INCOMPATIBLES_MULTIPLE_LFG_GROUPS;
 
        // Group with less that MAXGROUPSIZE members always compatible
        if (!sLFGMgr->IsTesting() && check.size() == 1 && numPlayers < MAXGROUPSIZE)
        {
            LfgQueueDataContainer::iterator itQueue = QueueDataStore.find(check.front());
            LfgRolesMap roles = itQueue->second.roles;
            uint8 roleCheckResult = LFGMgr::CheckGroupRoles(roles);
            strGuids.addRoles(roles);
            itQueue->second.bestCompatible.clear(); // this may be left after a failed proposal (not cleared, because UpdateQueueTimers would try to generate it with every update)
            //UpdateBestCompatibleInQueue(itQueue, strGuids);
            AddToCompatibles(strGuids);
            if (roleCheckResult && roleCheckResult <= 15)
                foundMask |= ( (((uint64)1) << (roleCheckResult - 1)) | (((uint64)1) << (16 + roleCheckResult - 1)) | (((uint64)1) << (32 + roleCheckResult - 1)) | (((uint64)1) << (48 + roleCheckResult - 1)));
            return LFG_COMPATIBLES_WITH_LESS_PLAYERS;
        }
 
        if (numPlayers > MAXGROUPSIZE)
            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 (uint8 i = 0; i < 5 && check.guids[i]; ++i)
            {
                const LfgRolesMap& roles = QueueDataStore[check.guids[i]].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)
                        {
                            // pussywizard: LFG this means that this player was in two different LfgQueueData (in QueueDataStore), and at least one of them is a group guid, because we do checks so there aren't 2 same guids in current CHECK
                            //LOG_ERROR("lfg", "LFGQueue::CheckCompatibility: ERROR! Player multiple times in queue! [{}]", itRoles->first.ToString());
                            break;
                        }
                        else if (sLFGMgr->HasIgnore(itRoles->first, itPlayer->first))
                            break;
                    }
                    if (itPlayer == proposalRoles.end())
                        proposalRoles[itRoles->first] = itRoles->second;
                    else
                        break;
                }
            }
 
            if (numPlayers != proposalRoles.size())
                return LFG_INCOMPATIBLES_HAS_IGNORES;
 
            uint8 roleCheckResult = LFGMgr::CheckGroupRoles(proposalRoles);
            if (!roleCheckResult || roleCheckResult > 0xF)
                return LFG_INCOMPATIBLES_NO_ROLES;
 
            // now, every combination can occur only 4 times (explained in FindNewGroups)
            if (foundMask & (((uint64)1) << (roleCheckResult - 1)))
            {
                if (foundMask & (((uint64)1) << (16 + roleCheckResult - 1)))
                {
                    if (foundMask & (((uint64)1) << (32 + roleCheckResult - 1)))
                    {
                        if (foundMask & (((uint64)1) << (48 + roleCheckResult - 1)))
                        {
                            if (foundCount >= 10) // but only after finding at least 10 compatibles (this helps when there are few groups)
                                return LFG_INCOMPATIBLES_NO_ROLES;
                        }
                        else
                            addToFoundMask |= (((uint64)1) << (48 + roleCheckResult - 1));
                    }
                    else
                        addToFoundMask |= (((uint64)1) << (32 + roleCheckResult - 1));
                }
                else
                    addToFoundMask |= (((uint64)1) << (16 + roleCheckResult - 1));
            }
            else
                addToFoundMask |= (((uint64)1) << (roleCheckResult - 1));
 
            proposalDungeons = QueueDataStore[check.front()].dungeons;
            for (uint8 i = 1; i < 5 && check.guids[i]; ++i)
            {
                LfgDungeonSet temporal;
                LfgDungeonSet& dungeons = QueueDataStore[check.guids[i]].dungeons;
                std::set_intersection(proposalDungeons.begin(), proposalDungeons.end(), dungeons.begin(), dungeons.end(), std::inserter(temporal, temporal.begin()));
                proposalDungeons = temporal;
            }
 
            if (proposalDungeons.empty())
                return LFG_INCOMPATIBLES_NO_DUNGEONS;
        }
        else
        {
            ObjectGuid gguid = check.front();
            const LfgQueueData& queue = QueueDataStore[gguid];
            proposalDungeons = queue.dungeons;
            proposalRoles = queue.roles;
            LFGMgr::CheckGroupRoles(proposalRoles);          // assing new roles
        }
 
        // Enough players?
        if (!sLFGMgr->IsTesting() && numPlayers != MAXGROUPSIZE)
        {
            strGuids.addRoles(proposalRoles);
            for (uint8 i = 0; i < 5 && check.guids[i]; ++i)
            {
                LfgQueueDataContainer::iterator itr = QueueDataStore.find(check.guids[i]);
                if (!itr->second.bestCompatible.empty()) // update if groups don't have it empty (for empty it will be generated in UpdateQueueTimers)
                    UpdateBestCompatibleInQueue(itr, strGuids);
            }
            AddToCompatibles(strGuids);
            foundMask |= addToFoundMask;
            ++foundCount;
            return LFG_COMPATIBLES_WITH_LESS_PLAYERS;
        }
 
        proposal.queues = strGuids;
        proposal.isNew = numLfgGroups != 1;
 
        if (!sLFGMgr->AllQueued(check)) // can't create proposal
            return LFG_COMPATIBILITY_PENDING;
 
        // Create a new proposal
        proposal.cancelTime = GameTime::GetGameTime().count() + LFG_TIME_PROPOSAL;
        proposal.state = LFG_PROPOSAL_INITIATING;
        proposal.leader.Clear();
        proposal.dungeonId = Acore::Containers::SelectRandomContainerElement(proposalDungeons);
 
        uint32 completedEncounters = 0;
        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 && data.group == proposal.group) // Player from existing group, autoaccept
                data.accept = LFG_ANSWER_AGREE;
 
            if (!completedEncounters && !proposal.isNew)
            {
                if (LFGDungeonEntry const* dungeon = sLFGDungeonStore.LookupEntry(proposal.dungeonId))
                {
                    if (Player* player = ObjectAccessor::FindConnectedPlayer(itRoles->first))
                    {
                        if (player->GetMapId() == static_cast<uint32>(dungeon->MapID))
                        {
                            if (InstanceScript* instance = player->GetInstanceScript())
                            {
                                completedEncounters = instance->GetCompletedEncounterMask();
                            }
                        }
                    }
                }
            }
        }
 
        proposal.encounters = completedEncounters;
 
        for (uint8 i = 0; i < 5 && proposal.queues.guids[i]; ++i)
            RemoveFromQueue(proposal.queues.guids[i], true);
 
        sLFGMgr->AddProposal(proposal);
 
        return LFG_COMPATIBLES_MATCH;
    }

References lfg::LfgProposalPlayer::accept, lfg::Lfg5Guids::addRoles(), AddToCompatibles(), lfg::LfgProposal::cancelTime, lfg::LFGMgr::CheckGroupRoles(), ObjectGuid::Clear(), lfg::LfgProposal::dungeonId, lfg::LfgQueueData::dungeons, ObjectGuid::Empty, lfg::LfgProposal::encounters, ObjectAccessor::FindConnectedPlayer(), lfg::Lfg5Guids::force_insert_front(), lfg::Lfg5Guids::front(), GameTime::GetGameTime(), lfg::LfgProposalPlayer::group, lfg::LfgProposal::group, lfg::Lfg5Guids::guids, lfg::Lfg5Guids::insert(), lfg::LfgProposal::isNew, lfg::LfgProposal::leader, lfg::LFG_ANSWER_AGREE, lfg::LFG_COMPATIBILITY_PENDING, lfg::LFG_COMPATIBLES_MATCH, lfg::LFG_COMPATIBLES_WITH_LESS_PLAYERS, lfg::LFG_INCOMPATIBLES_HAS_IGNORES, lfg::LFG_INCOMPATIBLES_MULTIPLE_LFG_GROUPS, lfg::LFG_INCOMPATIBLES_NO_DUNGEONS, lfg::LFG_INCOMPATIBLES_NO_ROLES, lfg::LFG_INCOMPATIBLES_TOO_MUCH_PLAYERS, lfg::LFG_PROPOSAL_INITIATING, lfg::LFG_TIME_PROPOSAL, LOG_DEBUG, LOG_ERROR, MAXGROUPSIZE, lfg::PLAYER_ROLE_LEADER, lfg::LfgProposal::players, QueueDataStore, lfg::LfgProposal::queues, RemoveFromQueue(), lfg::LfgProposalPlayer::role, lfg::LfgQueueData::roles, Acore::Containers::SelectRandomContainerElement(), lfg::Lfg5Guids::size(), sLFGDungeonStore, sLFGMgr, lfg::LfgProposal::state, lfg::Lfg5Guids::toString(), ObjectGuid::ToString(), UpdateBestCompatibleInQueue(), and urand().

Referenced by FindNewGroups().

FindBestCompatibleInQueue()

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

private

    {
        uint32 numOfCompatibles = 0;
        for (LfgCompatibleContainer::const_iterator itr = CompatibleList.begin(); itr != CompatibleList.end(); ++itr)
            if (itr->hasGuid(itrQueue->first))
            {
                ++numOfCompatibles;
                UpdateBestCompatibleInQueue(itrQueue, *itr);
            }
        return numOfCompatibles;
    }

References CompatibleList, and UpdateBestCompatibleInQueue().

Referenced by UpdateQueueTimers().

FindGroups()

uint8 lfg::LFGQueue::FindGroups

(

)

    {
        LOG_DEBUG("lfg", "FIND GROUPS!");
        uint8 newGroupsProcessed = 0;
        if (!newToQueueStore.empty())
        {
            ++newGroupsProcessed;
            ObjectGuid newGuid = newToQueueStore.front();
            bool pushCompatiblesToFront = (std::find(restoredAfterProposal.begin(), restoredAfterProposal.end(), newGuid) != restoredAfterProposal.end());
            LOG_DEBUG("lfg", "newToQueueStore: {}, front: {}", newGuid.ToString(), pushCompatiblesToFront ? 1 : 0);
            RemoveFromNewQueue(newGuid);
 
            FindNewGroups(newGuid);
 
            CompatibleList.splice((pushCompatiblesToFront ? CompatibleList.begin() : CompatibleList.end()), CompatibleTempList);
            CompatibleTempList.clear();
 
            return newGroupsProcessed; // pussywizard: only one per update, shouldn't be a problem
        }
        return newGroupsProcessed;
    }

References CompatibleList, CompatibleTempList, FindNewGroups(), LOG_DEBUG, newToQueueStore, RemoveFromNewQueue(), restoredAfterProposal, and ObjectGuid::ToString().

FindNewGroups()

LfgCompatibility lfg::LFGQueue::FindNewGroups ( const ObjectGuid &  newGuid )

private

    {
        // each combination of dps+heal+tank (tank*8 + heal+4 + dps) has a value assigned 0..15
        // first 16 bits of the mask are for marking if such combination was found once, second 16 bits for marking second occurence of that combination, etc
        uint64 foundMask = 0;
        uint32 foundCount = 0;
 
        LOG_DEBUG("lfg", "FIND NEW GROUPS for: {}", newGuid.ToString());
 
        // we have to take into account that FindNewGroups is called every X minutes if number of compatibles is low!
        // build set of already present compatibles for this guid
        std::set<Lfg5Guids> currentCompatibles;
        for (Lfg5GuidsList::iterator it = CompatibleList.begin(); it != CompatibleList.end(); ++it)
            if (it->hasGuid(newGuid))
            {
                // unset roles here so they are not copied, restore after insertion
                LfgRolesMap* r = it->roles;
                it->roles = nullptr;
                currentCompatibles.insert(*it);
                it->roles = r;
            }
 
        LfgCompatibility selfCompatibility = LFG_COMPATIBILITY_PENDING;
        if (currentCompatibles.empty())
        {
            selfCompatibility = CheckCompatibility(Lfg5Guids(), newGuid, foundMask, foundCount, currentCompatibles);
            if (selfCompatibility != LFG_COMPATIBLES_WITH_LESS_PLAYERS) // group is already compatible (a party of 5 players)
                return selfCompatibility;
        }
 
        for (Lfg5GuidsList::iterator it = CompatibleList.begin(); it != CompatibleList.end(); )
        {
            Lfg5GuidsList::iterator itr = it++;
            if (itr->empty())
            {
                LOG_DEBUG("lfg", "ERASE from CompatibleList");
                CompatibleList.erase(itr);
                continue;
            }
            LfgCompatibility compatibility = CheckCompatibility(*itr, newGuid, foundMask, foundCount, currentCompatibles);
            if (compatibility == LFG_COMPATIBLES_MATCH)
                return LFG_COMPATIBLES_MATCH;
            if ((foundMask & 0x3FFF3FFF3FFF3FFF) == 0x3FFF3FFF3FFF3FFF) // each combination of dps+heal+tank already found 4 times
                break;
        }
 
        return selfCompatibility;
    }

References CheckCompatibility(), CompatibleList, lfg::LFG_COMPATIBILITY_PENDING, lfg::LFG_COMPATIBLES_MATCH, lfg::LFG_COMPATIBLES_WITH_LESS_PLAYERS, LOG_DEBUG, and ObjectGuid::ToString().

Referenced by FindGroups().

GetJoinTime()

time_t lfg::LFGQueue::GetJoinTime

(

ObjectGuid

guid

)

    {
        return QueueDataStore[guid].joinTime;
    }

References QueueDataStore.

Referenced by lfg::LFGMgr::UpdateProposal().

RemoveFromCompatibles()

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

private

    {
        LOG_DEBUG("lfg", "COMPATIBLES REMOVE for: {}", guid.ToString());
        for (LfgCompatibleContainer::iterator it = CompatibleList.begin(); it != CompatibleList.end(); ++it)
            if (it->hasGuid(guid))
            {
                LOG_DEBUG("lfg", "Removed Compatible: {}, because of: {}", it->toString(), guid.ToString());
                it->clear(); // set to 0, this will be removed while iterating in FindNewGroups
            }
        for (LfgCompatibleContainer::iterator itr = CompatibleTempList.begin(); itr != CompatibleTempList.end(); )
        {
            LfgCompatibleContainer::iterator it = itr++;
            if (it->hasGuid(guid))
            {
                LOG_DEBUG("lfg", "Erased Temp Compatible: {}, because of: {}", it->toString(), guid.ToString());
                CompatibleTempList.erase(it);
            }
        }
    }

References CompatibleList, CompatibleTempList, LOG_DEBUG, and ObjectGuid::ToString().

Referenced by RemoveFromQueue().

RemoveFromNewQueue()

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

private

    {
        LOG_DEBUG("lfg", "REMOVE RemoveFromNewQueue: {}", guid.ToString());
        newToQueueStore.remove(guid);
        restoredAfterProposal.remove(guid);
    }

References LOG_DEBUG, newToQueueStore, restoredAfterProposal, and ObjectGuid::ToString().

Referenced by FindGroups(), and RemoveFromQueue().

RemoveFromQueue()

void lfg::LFGQueue::RemoveFromQueue	(	ObjectGuid	guid,
		bool	partial = false
	)

    {
        LOG_DEBUG("lfg", "REMOVE RemoveFromQueue: {}, partial: {}", guid.ToString(), partial ? 1 : 0);
        RemoveFromNewQueue(guid);
        RemoveFromCompatibles(guid);
 
        LfgQueueDataContainer::iterator itDelete = QueueDataStore.end();
        for (LfgQueueDataContainer::iterator itr = QueueDataStore.begin(); itr != QueueDataStore.end(); ++itr)
        {
            if (itr->first != guid)
            {
                if (itr->second.bestCompatible.hasGuid(guid))
                {
                    LOG_DEBUG("lfg", "CLEAR bestCompatible: {}, because of: {}", itr->second.bestCompatible.toString(), guid.ToString());
                    itr->second.bestCompatible.clear();
                }
            }
            else
            {
                LOG_DEBUG("lfg", "CLEAR bestCompatible SELF: {}, because of: {}", itr->second.bestCompatible.toString(), guid.ToString());
                //itr->second.bestCompatible.clear(); // don't clear here, because UpdateQueueTimers will try to find with every diff update
                itDelete = itr;
            }
        }
 
        // xinef: partial
        if (!partial && itDelete != QueueDataStore.end())
        {
            LOG_DEBUG("lfg", "ERASE QueueDataStore for: {}", guid.ToString());
            LOG_DEBUG("lfg", "ERASE QueueDataStore for: {}, itDelete: {},{},{}", guid.ToString(), itDelete->second.dps, itDelete->second.healers, itDelete->second.tanks);
            QueueDataStore.erase(itDelete);
            LOG_DEBUG("lfg", "ERASE QueueDataStore for: {} SUCCESS", guid.ToString());
        }
    }

References LOG_DEBUG, QueueDataStore, RemoveFromCompatibles(), RemoveFromNewQueue(), and ObjectGuid::ToString().

Referenced by lfg::LFGMgr::AllQueued(), CheckCompatibility(), lfg::LFGMgr::JoinLfg(), lfg::LFGMgr::LeaveLfg(), and lfg::LFGMgr::RemoveProposal().

RemoveQueueData()

void lfg::LFGQueue::RemoveQueueData

(

ObjectGuid

guid

)

    {
        LOG_DEBUG("lfg", "LEFT RemoveQueueData: {}", guid.ToString());
        LfgQueueDataContainer::iterator it = QueueDataStore.find(guid);
        if (it != QueueDataStore.end())
            QueueDataStore.erase(it);
    }

References LOG_DEBUG, QueueDataStore, and ObjectGuid::ToString().

Referenced by lfg::LFGMgr::UpdateProposal().

SetQueueUpdateData()

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

private

UpdateBestCompatibleInQueue()

void lfg::LFGQueue::UpdateBestCompatibleInQueue ( LfgQueueDataContainer::iterator  itrQueue, Lfg5Guids const &  key  )

private

    {
        LOG_DEBUG("lfg", "UpdateBestCompatibleInQueue: {}", key.toString());
        LfgQueueData& queueData = itrQueue->second;
 
        uint8 storedSize = queueData.bestCompatible.size();
        uint8 size = key.size();
 
        if (size <= storedSize)
            return;
 
        queueData.bestCompatible = key;
        queueData.tanks = LFG_TANKS_NEEDED;
        queueData.healers = LFG_HEALERS_NEEDED;
        queueData.dps = LFG_DPS_NEEDED;
        for (LfgRolesMap::const_iterator it = key.roles->begin(); it != key.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;
        }
    }

References lfg::LfgQueueData::bestCompatible, lfg::LfgQueueData::dps, lfg::LfgQueueData::healers, lfg::LFG_DPS_NEEDED, lfg::LFG_HEALERS_NEEDED, lfg::LFG_TANKS_NEEDED, LOG_DEBUG, lfg::PLAYER_ROLE_HEALER, lfg::PLAYER_ROLE_TANK, lfg::Lfg5Guids::roles, lfg::Lfg5Guids::size(), lfg::LfgQueueData::tanks, and lfg::Lfg5Guids::toString().

Referenced by CheckCompatibility(), and FindBestCompatibleInQueue().

UpdateQueueTimers()

void lfg::LFGQueue::UpdateQueueTimers

(

uint32

diff

)

    {
        time_t currTime = GameTime::GetGameTime().count();
        bool sendQueueStatus = false;
 
        if (m_QueueStatusTimer > LFG_QUEUEUPDATE_INTERVAL)
        {
            m_QueueStatusTimer = 0;
            sendQueueStatus = true;
        }
        else
            m_QueueStatusTimer += diff;
 
        LOG_DEBUG("lfg", "UPDATE UpdateQueueTimers");
        for (Lfg5GuidsList::iterator it = CompatibleList.begin(); it != CompatibleList.end(); )
        {
            Lfg5GuidsList::iterator itr = it++;
            if (itr->empty())
            {
                LOG_DEBUG("lfg", "UpdateQueueTimers ERASE compatible");
                CompatibleList.erase(itr);
            }
        }
 
        if (!sendQueueStatus)
        {
            for (LfgQueueDataContainer::iterator itQueue = QueueDataStore.begin(); itQueue != QueueDataStore.end(); )
            {
                if (currTime - itQueue->second.joinTime > 2 * HOUR)
                {
                    ObjectGuid guid = itQueue->first;
                    QueueDataStore.erase(itQueue++);
                    sLFGMgr->LeaveAllLfgQueues(guid, true);
                    continue;
                }
                if (itQueue->second.bestCompatible.empty())
                {
                    uint32 numOfCompatibles = FindBestCompatibleInQueue(itQueue);
                    if (numOfCompatibles /*must be positive, because proposals don't delete QueueQueueData*/ && currTime - itQueue->second.lastRefreshTime >= 60 && numOfCompatibles < (5 - itQueue->second.bestCompatible.roles->size()) * 25)
                    {
                        itQueue->second.lastRefreshTime = currTime;
                        AddToQueue(itQueue->first, false);
                    }
                }
                ++itQueue;
            }
            return;
        }
 
        // LOG_TRACE("lfg", "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())
            {
                LOG_DEBUG("lfg", "found empty bestCompatible");
                FindBestCompatibleInQueue(itQueue);
            }
 
            LfgQueueStatusData queueData(dungeonId, 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);
            }
        }
    }

References AddToQueue(), lfg::LfgQueueData::bestCompatible, CompatibleList, lfg::LfgQueueData::dps, lfg::LfgQueueData::dungeons, lfg::Lfg5Guids::empty(), FindBestCompatibleInQueue(), GameTime::GetGameTime(), lfg::LfgQueueData::healers, HOUR, lfg::LfgQueueData::joinTime, lfg::LFG_QUEUEUPDATE_INTERVAL, LOG_DEBUG, m_QueueStatusTimer, lfg::PLAYER_ROLE_DAMAGE, lfg::PLAYER_ROLE_HEALER, lfg::PLAYER_ROLE_NONE, lfg::PLAYER_ROLE_TANK, QueueDataStore, lfg::LfgQueueData::roles, lfg::LFGMgr::SendLfgQueueStatus(), sLFGMgr, lfg::LfgQueueData::tanks, waitTimesAvgStore, waitTimesDpsStore, waitTimesHealerStore, and waitTimesTankStore.

UpdateWaitTimeAvg()

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

References lfg::LfgWaitTime::number, lfg::LfgWaitTime::time, and waitTimesAvgStore.

Referenced by lfg::LFGMgr::UpdateProposal().

UpdateWaitTimeDps()

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

References lfg::LfgWaitTime::number, lfg::LfgWaitTime::time, and waitTimesDpsStore.

Referenced by lfg::LFGMgr::UpdateProposal().

UpdateWaitTimeHealer()

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

References lfg::LfgWaitTime::number, lfg::LfgWaitTime::time, and waitTimesHealerStore.

Referenced by lfg::LFGMgr::UpdateProposal().

UpdateWaitTimeTank()

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

References lfg::LfgWaitTime::number, lfg::LfgWaitTime::time, and waitTimesTankStore.

Referenced by lfg::LFGMgr::UpdateProposal().

Member Data Documentation

CompatibleList

LfgCompatibleContainer lfg::LFGQueue::CompatibleList

private

Referenced by FindBestCompatibleInQueue(), FindGroups(), FindNewGroups(), RemoveFromCompatibles(), and UpdateQueueTimers().

CompatibleTempList

LfgCompatibleContainer lfg::LFGQueue::CompatibleTempList

private

Referenced by AddToCompatibles(), FindGroups(), and RemoveFromCompatibles().

m_QueueStatusTimer

uint32 lfg::LFGQueue::m_QueueStatusTimer

private

Referenced by UpdateQueueTimers().

newToQueueStore

LfgGuidList lfg::LFGQueue::newToQueueStore

private

Referenced by AddToNewQueue(), FindGroups(), and RemoveFromNewQueue().

QueueDataStore

LfgQueueDataContainer lfg::LFGQueue::QueueDataStore

private

Referenced by AddQueueData(), AddToQueue(), CheckCompatibility(), GetJoinTime(), RemoveFromQueue(), RemoveQueueData(), and UpdateQueueTimers().

restoredAfterProposal

LfgGuidList lfg::LFGQueue::restoredAfterProposal

private

Referenced by AddToNewQueue(), FindGroups(), and RemoveFromNewQueue().

waitTimesAvgStore

LfgWaitTimesContainer lfg::LFGQueue::waitTimesAvgStore

private

Referenced by UpdateQueueTimers(), and UpdateWaitTimeAvg().

waitTimesDpsStore

LfgWaitTimesContainer lfg::LFGQueue::waitTimesDpsStore

private

Referenced by UpdateQueueTimers(), and UpdateWaitTimeDps().

waitTimesHealerStore

LfgWaitTimesContainer lfg::LFGQueue::waitTimesHealerStore

private

Referenced by UpdateQueueTimers(), and UpdateWaitTimeHealer().

waitTimesTankStore

LfgWaitTimesContainer lfg::LFGQueue::waitTimesTankStore

private

Referenced by UpdateQueueTimers(), and UpdateWaitTimeTank().