Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-24 19:06:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

Dungeon Finder: Improve Join and UpdateRoles and move queue to main class

Browse Source 
--HG--
branch : trunk
This commit is contained in:
Spp
2010-08-11 12:44:49 +02:00
parent 4b62042b28
commit ac4df5204b
2 changed files with 202 additions and 243 deletions
Download Patch File Download Diff File Expand all files Collapse all files

403
src/server/game/DungeonFinding/LFGMgr.cpp
View File

@@ -24,123 +24,39 @@
#include "ObjectMgr.h"
#include "WorldPacket.h"
/*********************************************************/
/*** LFG QUEUES ***/
/*********************************************************/
LFGQueue::LFGQueue()
{
m_LfgQueue.clear();
avgWaitTime = -1;
waitTimeTanks = -1;
waitTimeHealer = -1;
waitTimeDps = -1;
}
LFGQueue::~LFGQueue()
{
m_LfgQueue.clear();
}
void LFGQueue::AddToQueue(uint64 guid, LfgQueueInfo* pqInfo)
{
delete m_LfgQueue[guid];
m_LfgQueue[guid] = pqInfo;
// ATM will only add it to the queue... No find group implementation... yet (on purpose)
}
bool LFGQueue::RemoveFromQueue(uint64 guid)
{
if (m_LfgQueue.empty())
return false;
LfgQueueInfoMap::iterator itr = m_LfgQueue.find(guid);
if (itr == m_LfgQueue.end())
return false;
delete itr->second;
m_LfgQueue.erase(itr);
return true;
}
LfgQueueInfo* LFGQueue::GetQueueInfo(uint64 guid)
{
return m_LfgQueue[guid];
}
void LFGQueue::Update()
{
if (m_LfgQueue.empty())
return;
Player *plr;
LfgQueueInfo *queue;
time_t currTime = time(NULL);
uint32 queuedTime;
uint8 role = 0;
int32 waitTime = -1;
for (LfgQueueInfoMap::const_iterator itQueue = m_LfgQueue.begin(); itQueue != m_LfgQueue.end(); ++itQueue)
{
queue = itQueue->second;
// Update queue status
queuedTime = uint32(currTime - queue->joinTime);
for (LfgRolesMap::const_iterator itPlayer = queue->roles.begin(); itPlayer != queue->roles.end(); ++itPlayer)
{
plr = sObjectMgr.GetPlayer(itPlayer->first);
if (!plr)
continue;
role = itPlayer->second;
if (role & ROLE_TANK)
{
if (role & ROLE_HEALER || role & ROLE_DAMAGE)
waitTime = avgWaitTime;
else
waitTime = waitTimeTanks;
}
else if (role & ROLE_HEALER)
{
if (role & ROLE_DAMAGE)
waitTime = avgWaitTime;
else
waitTime = waitTimeDps;
}
plr->GetSession()->SendLfgQueueStatus(queue->dungeonId, waitTime, avgWaitTime, waitTimeTanks, waitTimeHealer, waitTimeDps, queuedTime, queue->tanks, queue->healers, queue->dps);
}
}
}
LFGMgr::LFGMgr()
{
m_QueueTimer = 0;
m_avgWaitTime = -1;
m_waitTimeTanks = -1;
m_waitTimeHealer = -1;
m_waitTimeDps = -1;
m_update = true;
}
LFGMgr::~LFGMgr()
{
// RewardList to be removed -> query quest system
// FIXME: RewardList to be removed -> query quest system
for (LfgRewardList::iterator it = m_RewardList.begin(); it != m_RewardList.end(); ++it)
delete *it;
m_RewardList.clear();
// RewardDoneList to be removed -> query quest system
// FIXME: RewardDoneList to be removed -> query quest system
for (LfgRewardList::iterator it = m_RewardDoneList.begin(); it != m_RewardDoneList.end(); ++it)
delete *it;
m_RewardDoneList.clear();
for(LFGQueueMap::iterator it = m_Queues.begin(); it != m_Queues.end(); ++it)
for (LfgQueueInfoMap::iterator it = m_QueueInfoMap.begin(); it != m_QueueInfoMap.end(); ++it)
delete it->second;
m_Queues.clear();
for (LfgDungeonMap::iterator it = m_DungeonsMap.begin(); it != m_DungeonsMap.end(); ++it)
{
it->second->clear();
delete it->second;
}
m_DungeonsMap.clear();
m_QueueInfoMap.clear();
for (LfgRoleCheckMap::iterator it = m_RoleChecks.begin(); it != m_RoleChecks.end(); ++it)
delete it->second;
m_RoleChecks.clear();
m_QueueInfoMap.clear();
m_currentQueue.clear();
m_newToQueue.clear();
}
void LFGMgr::Update(uint32 diff)
@@ -148,16 +64,7 @@ void LFGMgr::Update(uint32 diff)
if (!m_update)
return;
// Update all players status queue info
if (m_QueueTimer > LFG_QUEUEUPDATE_INTERVAL)
{
m_QueueTimer = 0;
for (LFGQueueMap::iterator it = m_Queues.begin(); it != m_Queues.end(); ++it)
it->second->Update();
}
else
m_QueueTimer += diff;
m_update = false;
time_t currTime = time(NULL);
// Remove obsolete role checks
@@ -190,6 +97,60 @@ void LFGMgr::Update(uint32 diff)
delete pRoleCheck;
m_RoleChecks.erase(itRoleCheck);
}
// Update all players status queue info
if (m_QueueTimer > LFG_QUEUEUPDATE_INTERVAL)
{
m_QueueTimer = 0;
time_t currTime = time(NULL);
int32 waitTime;
LfgQueueInfo *queue;
uint32 dungeonId;
uint32 queuedTime;
uint8 role;
for (LfgQueueInfoMap::const_iterator itQueue = m_QueueInfoMap.begin(); itQueue != m_QueueInfoMap.end(); ++itQueue)
{
queue = itQueue->second;
if (!queue)
{
if (IS_GROUP(itQueue->first))
sLog.outError("LFGMgr::Update: group (lowguid: %u) queued with null queue info!", GUID_LOPART(itQueue->first));
else
sLog.outError("LFGMgr::Update: player (lowguid: %u) queued with null queue info!", GUID_LOPART(itQueue->first));
continue;
}
dungeonId = *queue->dungeons.begin();
queuedTime = uint32(currTime - queue->joinTime);
role = ROLE_NONE;
for (LfgRolesMap::const_iterator itPlayer = queue->roles.begin(); itPlayer != queue->roles.end(); ++itPlayer)
role |= itPlayer->second;
waitTime = -1;
if (role & ROLE_TANK)
{
if (role & ROLE_HEALER || role & ROLE_DAMAGE)
waitTime = m_avgWaitTime;
else
waitTime = m_waitTimeTanks;
}
else if (role & ROLE_HEALER)
{
if (role & ROLE_DAMAGE)
waitTime = m_avgWaitTime;
else
waitTime = m_waitTimeHealer;
}
else if (role & ROLE_DAMAGE)
waitTime = m_waitTimeDps;
for (LfgRolesMap::const_iterator itPlayer = queue->roles.begin(); itPlayer != queue->roles.end(); ++itPlayer)
if (Player * plr = sObjectMgr.GetPlayer(itPlayer->first))
plr->GetSession()->SendLfgQueueStatus(dungeonId, waitTime, m_avgWaitTime, m_waitTimeTanks, m_waitTimeHealer, m_waitTimeDps, queuedTime, queue->tanks, queue->healers, queue->dps);
}
}
else
m_QueueTimer += diff;
m_update = true;
}
/// <summary>
@@ -243,13 +204,23 @@ void LFGMgr::Join(Player *plr)
{
Group *grp = plr->GetGroup();
// TODO - 2010-05-27 Anyone can init rolecheck when already in a LFD Group?
if (grp && grp->GetLeaderGUID() != plr->GetGUID())
return;
// Previous checks before joining
uint64 guid = grp ? grp->GetGUID() : plr->GetGUID();
LfgJoinResult result = LFG_JOIN_OK;
if (plr->InBattleground() || plr->InArena())
// Previous checks before joining
if (m_QueueInfoMap[guid])
{
result = LFG_JOIN_INTERNAL_ERROR;
if (grp)
sLog.outError("LFGMgr::Join: group (lowguid: %u) trying to join but is already in queue!", grp->GetLowGUID());
else
sLog.outError("LFGMgr::Join: Player (lowguid: %u) trying to join but is already in queue!", plr->GetGUIDLow());
}
else if (plr->InBattleground() || plr->InArena())
result = LFG_JOIN_USING_BG_SYSTEM;
else if (plr->HasAura(LFG_SPELL_DESERTER))
result = LFG_JOIN_DESERTER;
@@ -260,7 +231,7 @@ void LFGMgr::Join(Player *plr)
// Check if all dungeons are valid
for (LfgDungeonSet::const_iterator it = plr->GetLfgDungeons()->begin(); it != plr->GetLfgDungeons()->end(); ++it)
{
if ((m_DungeonsMap[LFG_ALL_DUNGEONS])->find(*it) == (m_DungeonsMap[LFG_ALL_DUNGEONS])->end())
if (!GetDungeonGroupType(*it))
{
result = LFG_JOIN_DUNGEON_INVALID;
break;
@@ -268,34 +239,38 @@ void LFGMgr::Join(Player *plr)
}
}
// Group checks
if (grp && result == LFG_JOIN_OK)
{
if (grp->GetMembersCount() > MAXGROUPSIZE)
result = LFG_JOIN_TOO_MUCH_MEMBERS;
else if(grp->isRaidGroup())
result = LFG_JOIN_MIXED_RAID_DUNGEON;
else
{
Player *plrg;
uint8 memberCount = 0;
for (GroupReference *itr = grp->GetFirstMember(); itr != NULL && result == LFG_JOIN_OK; itr = itr->next())
{
if (Player *plrg = itr->getSource())
plrg = itr->getSource();
if (plrg)
{
if (plrg->HasAura(LFG_SPELL_DESERTER))
result = LFG_JOIN_PARTY_DESERTER;
else if (plrg->HasAura(LFG_SPELL_COOLDOWN))
result = LFG_JOIN_PARTY_RANDOM_COOLDOWN;
++memberCount;
}
else
result = LFG_JOIN_DISCONNECTED;
}
if (memberCount != grp->GetMembersCount())
result = LFG_JOIN_DISCONNECTED;
}
}
if (result != LFG_JOIN_OK)
if (result != LFG_JOIN_OK) // Someone can't join. Clear all stuf
{
plr->GetLfgDungeons()->clear();
plr->SetLfgRoles(ROLE_NONE);
plr->GetSession()->SendLfgJoinResult(result, 0);
plr->GetSession()->SendLfgUpdateParty(LFG_UPDATETYPE_ROLECHECK_FAILED);
return;
}
@@ -317,56 +292,27 @@ void LFGMgr::Join(Player *plr)
{
plr->GetSession()->SendLfgJoinResult(LFG_JOIN_OK, 0);
plr->GetSession()->SendLfgUpdatePlayer(LFG_UPDATETYPE_JOIN_PROPOSAL);
// Add player to queue
LfgQueueInfo *pqInfo;
uint8 groupType = 0;
uint8 tanks = LFG_TANKS_NEEDED;
uint8 healers = LFG_HEALERS_NEEDED;
uint8 dps = LFG_DPS_NEEDED;
if (plr->GetLfgRoles() & ROLE_TANK)
--tanks;
else if (plr->GetLfgRoles() & ROLE_HEALER)
--healers;
else
--dps;
m_update = false;
for (LfgDungeonSet::const_iterator it = plr->GetLfgDungeons()->begin(); it != plr->GetLfgDungeons()->end(); ++it)
{
groupType = GetDungeonGroupType(*it);
pqInfo = m_Queues[groupType] ? m_Queues[groupType]->GetQueueInfo(plr->GetGUID()) : NULL;
// if exist we have already added the player with another dungeon sharing same GroupType
if (pqInfo)
continue;
pqInfo = new LfgQueueInfo();
pqInfo->dungeonId = *it;
pqInfo->joinTime = time_t(time(NULL));
pqInfo->tanks = tanks;
pqInfo->healers = healers;
pqInfo->dps = dps;
pqInfo->roles[plr->GetGUID()] = plr->GetLfgRoles();
if (!m_Queues[groupType])
m_Queues[groupType] = new LFGQueue();
m_Queues[groupType]->AddToQueue(plr->GetGUID(), pqInfo);
}
m_update = true;
LfgRolesMap roles;
roles[plr->GetGUIDLow()] = plr->GetLfgRoles();
AddToQueue(plr->GetGUID(), &roles, plr->GetLfgDungeons());
roles.clear();
}
}
/// <summary>
/// Leave the lfg queue
/// </summary>
/// <param name="plr">Player (could be NULL)</param>
/// <param name="grp">Group (could be NULL)</param>
/// <param name="Player *">Player (could be NULL)</param>
/// <param name="Group *">Group (could be NULL)</param>
void LFGMgr::Leave(Player *plr, Group *grp /* = NULL*/)
{
uint64 guid = grp ? grp->GetGUID() : plr ? plr->GetGUID() : 0;
ASSERT(guid);
// Check if player was in a rolecheck
// Remove from Role Checks
if (grp)
{
LfgRoleCheckMap::iterator itRoleCheck = m_RoleChecks.find(GUID_LOPART(grp->GetGUID()));
LfgRoleCheckMap::const_iterator itRoleCheck = m_RoleChecks.find(GUID_LOPART(guid));
if (itRoleCheck != m_RoleChecks.end())
{
UpdateRoleCheck(grp); // No player to update role = LFG_ROLECHECK_ABORTED
@@ -374,14 +320,8 @@ void LFGMgr::Leave(Player *plr, Group *grp /* = NULL*/)
}
}
// Check if player/group was in the queue
bool inQueue = false;
for (LFGQueueMap::iterator it = m_Queues.begin(); it != m_Queues.end(); ++it)
inQueue |= it->second->RemoveFromQueue(guid);
// Not in queue
if (!inQueue)
return;
// Remove from queue
RemoveFromQueue(guid);
if (grp)
{
@@ -401,33 +341,89 @@ void LFGMgr::Leave(Player *plr, Group *grp /* = NULL*/)
}
}
/// <summary>
/// Creates a QueueInfo and adds it to the queue. Tries to match a group before joining.
/// </summary>
/// <param name="uint64">Player or group guid</param>
/// <param name="LfgRolesMap *">Player roles</param>
/// <param name="LfgDungeonSet *">Selected dungeons</param>
void LFGMgr::AddToQueue(uint64 guid, LfgRolesMap *roles, LfgDungeonSet *dungeons)
{
ASSERT(roles);
ASSERT(dungeons);
LfgQueueInfo *pqInfo = new LfgQueueInfo();
pqInfo->joinTime = time_t(time(NULL));
for (LfgRolesMap::const_iterator it = roles->begin(); it != roles->end(); ++it)
{
if (pqInfo->tanks && it->second & ROLE_TANK)
--pqInfo->tanks;
else if (pqInfo->healers && it->second & ROLE_HEALER)
--pqInfo->healers;
else
--pqInfo->dps;
}
for (LfgRolesMap::const_iterator itRoles = roles->begin(); itRoles != roles->end(); ++itRoles)
pqInfo->roles[itRoles->first] = itRoles->second;
// Expand random dungeons
LfgDungeonSet *expandedDungeons = dungeons;
if (isRandomDungeon(*dungeons->begin()))
expandedDungeons = GetDungeonsByRandom(*dungeons->begin());
for (LfgDungeonSet::const_iterator it = expandedDungeons->begin(); it != expandedDungeons->end(); ++it)
pqInfo->dungeons.insert(*it);
m_QueueInfoMap[guid] = pqInfo;
m_newToQueue.push_back(guid);
}
/// <summary>
/// Removes the player/group from all queues
/// </summary>
/// <param name="uint64">Player or group guid</param>
/// <returns>bool</returns>
bool LFGMgr::RemoveFromQueue(uint64 guid)
{
m_currentQueue.remove(guid);
m_newToQueue.remove(guid);
LfgQueueInfoMap::iterator it = m_QueueInfoMap.find(guid);
if (it != m_QueueInfoMap.end())
{
delete it->second;
m_QueueInfoMap.erase(it);
return true;
}
return false;
}
/// <summary>
/// Update the Role check info with the player selected role.
/// </summary>
/// <param name="grp">Group</param>
/// <param name="plr">Player</param>
/// <param name="Group *">Group</param>
/// <param name="Player *">Player (optional, default NULL)</param>
void LFGMgr::UpdateRoleCheck(Group *grp, Player *plr /* = NULL*/)
{
ASSERT(grp);
uint32 rolecheckId = GUID_LOPART(grp->GetGUID());
uint32 rolecheckId = grp->GetLowGUID();
LfgRoleCheck *pRoleCheck = NULL;
LfgRolesMap check_roles;
LfgRoleCheckMap::iterator itRoleCheck = m_RoleChecks.find(rolecheckId);
bool newRoleCheck = itRoleCheck == m_RoleChecks.end();
if (newRoleCheck)
{
if (!grp->IsLeader(plr->GetGUID()))
if (grp->GetLeaderGUID() != plr->GetGUID())
return;
pRoleCheck = new LfgRoleCheck();
pRoleCheck->cancelTime = time_t(time(NULL)) + LFG_TIME_ROLECHECK;
pRoleCheck->result = LFG_ROLECHECK_INITIALITING;
pRoleCheck->leader = plr->GetGUID();
pRoleCheck->leader = plr->GetGUIDLow();
for (GroupReference *itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
if (Player *plrg = itr->getSource())
pRoleCheck->roles[plrg->GetGUID()] = 0;
pRoleCheck->roles[plrg->GetGUIDLow()] = 0;
for (LfgDungeonSet::const_iterator itDungeon = plr->GetLfgDungeons()->begin(); itDungeon != plr->GetLfgDungeons()->end(); ++itDungeon)
pRoleCheck->dungeons.insert(*itDungeon);
@@ -444,7 +440,7 @@ void LFGMgr::UpdateRoleCheck(Group *grp, Player *plr /* = NULL*/)
else
{
// Check if all players have selected a role
pRoleCheck->roles[plr->GetGUID()] = plr->GetLfgRoles();
pRoleCheck->roles[plr->GetGUIDLow()] = plr->GetLfgRoles();
uint8 size = 0;
for (LfgRolesMap::const_iterator itRoles = pRoleCheck->roles.begin(); itRoles != pRoleCheck->roles.end() && itRoles->second != ROLE_NONE; ++itRoles)
++size;
@@ -452,9 +448,7 @@ void LFGMgr::UpdateRoleCheck(Group *grp, Player *plr /* = NULL*/)
if (pRoleCheck->roles.size() == size)
{
// use temporal var to check roles, CheckGroupRoles modifies the roles
for (LfgRolesMap::const_iterator itRoles = pRoleCheck->roles.begin(); itRoles != pRoleCheck->roles.end(); ++itRoles)
check_roles[itRoles->first] = itRoles->second;
check_roles = pRoleCheck->roles;
if (!CheckGroupRoles(check_roles)) // Group is not posible
pRoleCheck->result = LFG_ROLECHECK_WRONG_ROLES;
else
@@ -468,7 +462,7 @@ void LFGMgr::UpdateRoleCheck(Group *grp, Player *plr /* = NULL*/)
LfgDungeonSet::const_iterator it = pRoleCheck->dungeons.begin();
LFGDungeonEntry const *dungeon = sLFGDungeonStore.LookupEntry(*it);
if (dungeon && dungeon->type == LFG_TYPE_RANDOM)
playersLockMap = GetPartyLockStatusDungeons(plr, m_DungeonsMap[*it]);
playersLockMap = GetPartyLockStatusDungeons(plr, GetDungeonsByRandom(*it));
else
playersLockMap = GetPartyLockStatusDungeons(plr, &pRoleCheck->dungeons);
}
@@ -502,12 +496,10 @@ void LFGMgr::UpdateRoleCheck(Group *grp, Player *plr /* = NULL*/)
continue;
case LFG_ROLECHECK_FINISHED:
if (!playersLockMap)
{
session->SendLfgUpdateParty(LFG_UPDATETYPE_ADDED_TO_QUEUE);
}
else
{
if (grp->IsLeader(plrg->GetGUID()))
if (grp->GetLeaderGUID() == plrg->GetGUID())
{
uint32 size = 0;
for (LfgLockStatusMap::const_iterator it = playersLockMap->begin(); it != playersLockMap->end(); ++it)
@@ -525,7 +517,7 @@ void LFGMgr::UpdateRoleCheck(Group *grp, Player *plr /* = NULL*/)
}
break;
default:
if (grp->IsLeader(plrg->GetGUID()))
if (grp->GetLeaderGUID() == plrg->GetGUID())
session->SendLfgJoinResult(LFG_JOIN_FAILED, pRoleCheck->result);
session->SendLfgUpdateParty(LFG_UPDATETYPE_ROLECHECK_FAILED);
plrg->GetLfgDungeons()->clear();
@@ -535,51 +527,12 @@ void LFGMgr::UpdateRoleCheck(Group *grp, Player *plr /* = NULL*/)
}
if (pRoleCheck->result == LFG_ROLECHECK_FINISHED)
{
// Add qroup to queue
LfgQueueInfo *pqInfo;
uint8 groupType = 0;
uint8 tanks = LFG_TANKS_NEEDED;
uint8 healers = LFG_HEALERS_NEEDED;
uint8 dps = LFG_DPS_NEEDED;
for (LfgRolesMap::const_iterator it = check_roles.begin(); it != check_roles.end(); ++it)
{
if (it->second & ROLE_TANK)
--tanks;
else if (it->second & ROLE_HEALER)
--healers;
else
--dps;
}
uint64 guid = grp->GetGUID();
m_update = false;
for (LfgDungeonSet::const_iterator it = pRoleCheck->dungeons.begin(); it != pRoleCheck->dungeons.end(); ++it)
{
groupType = GetDungeonGroupType(*it);
pqInfo = m_Queues[groupType] ? m_Queues[groupType]->GetQueueInfo(guid) : NULL;
// if exist we have already added the player with another dungeon sharing same GroupType
if (pqInfo)
continue;
pqInfo = new LfgQueueInfo();
pqInfo->dungeonId = *it;
pqInfo->joinTime = time_t(time(NULL));
pqInfo->tanks = tanks;
pqInfo->healers = healers;
pqInfo->dps = dps;
for (GroupReference *itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
{
if (Player *plrg = itr->getSource())
pqInfo->roles[plrg->GetGUID()] = plrg->GetLfgRoles();
}
if (!m_Queues[groupType])
m_Queues[groupType] = new LFGQueue();
m_Queues[groupType]->AddToQueue(guid, pqInfo);
}
m_update = true;
}
AddToQueue(grp->GetGUID(), &pRoleCheck->roles, &pRoleCheck->dungeons);
if (pRoleCheck->result != LFG_ROLECHECK_INITIALITING)
{
pRoleCheck->dungeons.clear();
pRoleCheck->roles.clear();
delete pRoleCheck;
if (!newRoleCheck)
m_RoleChecks.erase(itRoleCheck);
@@ -1079,3 +1032,17 @@ uint8 LFGMgr::GetDungeonGroupType(uint32 dungeonId)
return dungeon->grouptype;
}
/// <summary>
/// Given a Dungeon id returns if it's random
/// </summary>
/// <param name="uint32">Dungeon id</param>
/// <returns>bool</returns>
bool LFGMgr::isRandomDungeon(uint32 dungeonId)
{
LFGDungeonEntry const *dungeon = sLFGDungeonStore.LookupEntry(dungeonId);
if (!dungeon)
return false;
return dungeon->type == LFG_TYPE_RANDOM;
}

42
src/server/game/DungeonFinding/LFGMgr.h
View File

@@ -188,18 +188,20 @@ typedef std::map<uint64, LfgLockStatusSet*> LfgLockStatusMap;
typedef std::map<uint32, LfgDungeonSet*> LfgDungeonMap;
typedef std::map<uint64, int8> LfgAnswerMap;
typedef std::list<uint64> LfgGuidList;
typedef std::map<uint64, uint8> LfgRolesMap;
typedef std::set<uint64> LfgGuidSet;
// Stores player or group queue info
struct LfgQueueInfo
{
LfgQueueInfo(): tanks(LFG_TANKS_NEEDED), healers(LFG_HEALERS_NEEDED), dps(LFG_DPS_NEEDED) {};
time_t joinTime; // Player queue join time (to calculate wait times)
uint32 dungeonId; // Selected Player/Group Dungeon
LfgRolesMap roles; // Selected Player Role/s
uint8 tanks; // Tanks needed
uint8 healers; // Healers needed
uint8 dps; // Dps needed
LfgDungeonSet dungeons; // Selected Player/Group Dungeon/s
LfgRolesMap roles; // Selected Player Role/s
};
// Stores all rolecheck info of a group that wants to join LFG
@@ -215,26 +217,6 @@ struct LfgRoleCheck
typedef std::map<uint64, LfgQueueInfo*> LfgQueueInfoMap;
typedef std::map<uint32, LfgRoleCheck*> LfgRoleCheckMap;
class LFGQueue
{
public:
LFGQueue();
~LFGQueue();
void Update();
void AddToQueue(uint64 guid, LfgQueueInfo *pqInfo);
bool RemoveFromQueue(uint64 guid);
LfgQueueInfo* GetQueueInfo(uint64 guid);
private:
LfgQueueInfoMap m_LfgQueue;
int32 avgWaitTime;
int32 waitTimeTanks;
int32 waitTimeHealer;
int32 waitTimeDps;
};
typedef std::map<uint8, LFGQueue *> LFGQueueMap;
class LFGMgr
{
friend class ACE_Singleton<LFGMgr, ACE_Null_Mutex>;
@@ -258,6 +240,10 @@ class LFGMgr
void BuildPartyLockDungeonBlock(WorldPacket &data, LfgLockStatusMap *lockMap);
bool CheckGroupRoles(LfgRolesMap &groles, bool removeLeaderFlag = true);
void AddToQueue(uint64 guid, LfgRolesMap *roles, LfgDungeonSet *dungeons);
bool RemoveFromQueue(uint64 guid);
bool isRandomDungeon(uint32 dungeonId);
LfgLockStatusMap* GetPartyLockStatusDungeons(Player *plr, LfgDungeonSet *dungeons);
LfgLockStatusSet* GetPlayerLockStatusDungeons(Player *plr, LfgDungeonSet *dungeons);
LfgDungeonSet* GetRandomDungeons(uint8 level, uint8 expansion);
@@ -269,10 +255,16 @@ class LFGMgr
LfgRewardList m_RewardList;
LfgRewardList m_RewardDoneList;
LfgDungeonMap m_DungeonsMap;
LfgQueueInfoMap m_QueueInfoMap; // Queued groups
LfgGuidList m_currentQueue; // Ordered list. Used to find groups
LfgGuidList m_newToQueue; // New groups to add to queue;
LFGQueueMap m_Queues;
LfgRoleCheckMap m_RoleChecks;
uint32 m_QueueTimer;
LfgRoleCheckMap m_RoleChecks; // Current Role checks
uint32 m_QueueTimer; // used to check interval of update
int32 m_avgWaitTime;
int32 m_waitTimeTanks;
int32 m_waitTimeHealer;
int32 m_waitTimeDps;
bool m_update;
};