void BattlegroundQueue::BattlegroundQueueUpdate(BattlegroundBracketId bracket_id, uint8 actionMask, bool isRated, uint32 arenaRatedTeamId)
{
// if no players in queue - do nothing
if (m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].empty() &&
m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].empty() &&
m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE].empty() &&
m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_HORDE].empty())
return;
Battleground* bg_template = sBattlegroundMgr->GetBattlegroundTemplate(m_bgTypeId);
if (!bg_template)
return;
PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketById(bg_template->GetMapId(), bracket_id);
if (!bracketEntry)
return;
// battlegrounds with free slots should be populated first using players in queue
if ((actionMask & 0x01) && !BattlegroundMgr::IsArenaType(m_bgTypeId))
{
const BattlegroundContainer& bgList = sBattlegroundMgr->GetBattlegroundList();
BattlegroundNeedSet bgsToCheck;
// sort from most needing (most empty) to least needing using a std::set with functor
for (BattlegroundContainer::const_iterator itr = bgList.begin(); itr != bgList.end(); ++itr)
{
Battleground* bg = itr->second;
if (!BattlegroundMgr::IsArenaType(bg->GetBgTypeID()) && (bg->GetBgTypeID() == m_bgTypeId || m_bgTypeId == BATTLEGROUND_RB) &&
bg->HasFreeSlots() && bg->GetMinLevel() <= bracketEntry->minLevel && bg->GetMaxLevel() >= bracketEntry->maxLevel)
bgsToCheck.insert(bg);
}
// now iterate needing battlegrounds
for (BattlegroundNeedSet::iterator itr = bgsToCheck.begin(); itr != bgsToCheck.end(); ++itr)
{
Battleground* bg = *itr;
// call a function that fills whatever we can from normal queues
FillPlayersToBG(bg->GetFreeSlotsForTeam(TEAM_ALLIANCE), bg->GetFreeSlotsForTeam(TEAM_HORDE), bracket_id);
// invite players
for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
for (GroupsQueueType::const_iterator citr = m_SelectionPools[TEAM_ALLIANCE + i].SelectedGroups.begin(); citr != m_SelectionPools[TEAM_ALLIANCE + i].SelectedGroups.end(); ++citr)
BattlegroundMgr::InviteGroupToBG((*citr), bg, (*citr)->teamId);
}
}
// finished iterating through battlegrounds with free slots, maybe we need to create a new bg
if ((actionMask & 0x02) == 0)
return;
// get min and max players per team
uint32 MinPlayersPerTeam = bg_template->GetMinPlayersPerTeam();
uint32 MaxPlayersPerTeam = bg_template->GetMaxPlayersPerTeam();
if (bg_template->isArena())
{
MinPlayersPerTeam = sBattlegroundMgr->isArenaTesting() ? 1 : m_arenaType;
MaxPlayersPerTeam = m_arenaType;
}
// check if can start new premade battleground
if (bg_template->isBattleground() && m_bgTypeId != BATTLEGROUND_RB)
if (CheckPremadeMatch(bracket_id, MinPlayersPerTeam, MaxPlayersPerTeam))
{
// create new battleground
Battleground* bg = sBattlegroundMgr->CreateNewBattleground(m_bgTypeId, bracketEntry->minLevel, bracketEntry->maxLevel, 0, false);
if (!bg)
return;
// invite players
for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
for (GroupsQueueType::const_iterator citr = m_SelectionPools[TEAM_ALLIANCE + i].SelectedGroups.begin(); citr != m_SelectionPools[TEAM_ALLIANCE + i].SelectedGroups.end(); ++citr)
BattlegroundMgr::InviteGroupToBG((*citr), bg, (*citr)->teamId);
bg->StartBattleground();
// now fill the premade bg if possible (only one team for each side has been invited yet)
if (bg->HasFreeSlots())
{
// call a function that fills whatever we can from normal queues
FillPlayersToBG(bg->GetFreeSlotsForTeam(TEAM_ALLIANCE), bg->GetFreeSlotsForTeam(TEAM_HORDE), bracket_id);
// invite players
for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
for (GroupsQueueType::const_iterator citr = m_SelectionPools[TEAM_ALLIANCE + i].SelectedGroups.begin(); citr != m_SelectionPools[TEAM_ALLIANCE + i].SelectedGroups.end(); ++citr)
BattlegroundMgr::InviteGroupToBG((*citr), bg, (*citr)->teamId);
}
}
// check if can start new normal battleground or non-rated arena
if (!isRated)
{
if (CheckNormalMatch(bg_template, bracket_id, MinPlayersPerTeam, MaxPlayersPerTeam) ||
(bg_template->isArena() && CheckSkirmishForSameFaction(bracket_id, MinPlayersPerTeam)))
{
BattlegroundTypeId newBgTypeId = m_bgTypeId;
uint32 minLvl = bracketEntry->minLevel;
uint32 maxLvl = bracketEntry->maxLevel;
// for random bg use values from specific
if (m_bgTypeId == BATTLEGROUND_RB)
{
newBgTypeId = sBattlegroundMgr->RandomSystem.GetCurrentRandomBg();
Battleground* specificTemplate = sBattlegroundMgr->GetBattlegroundTemplate(newBgTypeId);
if (!specificTemplate)
return;
PvPDifficultyEntry const* specificBracket = GetBattlegroundBracketByLevel(specificTemplate->GetMapId(), sBattlegroundMgr->randomBgDifficultyEntry.minLevel);
if (!specificBracket)
return;
minLvl = specificBracket->minLevel;
maxLvl = specificBracket->maxLevel;
sBattlegroundMgr->RandomSystem.BattlegroundCreated(newBgTypeId);
}
// create new battleground
Battleground* bg = sBattlegroundMgr->CreateNewBattleground(newBgTypeId, minLvl, maxLvl, m_arenaType, false);
if (!bg)
return;
// invite players
for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
for (GroupsQueueType::const_iterator citr = m_SelectionPools[TEAM_ALLIANCE + i].SelectedGroups.begin(); citr != m_SelectionPools[TEAM_ALLIANCE + i].SelectedGroups.end(); ++citr)
BattlegroundMgr::InviteGroupToBG((*citr), bg, (*citr)->teamId);
bg->StartBattleground();
}
}
// check if can start new rated arenas (can create many in single queue update)
else if (bg_template->isArena())
{
// pussywizard: everything inside this section is mine, do NOT destroy!
const uint32 currMSTime = World::GetGameTimeMS();
const uint32 discardTime = sBattlegroundMgr->GetRatingDiscardTimer();
const uint32 maxDefaultRatingDifference = (MaxPlayersPerTeam > 2 ? 300 : 200);
const uint32 maxCountedMMR = 2500;
// we need to find 2 teams which will play next game
GroupsQueueType::iterator itr_teams[BG_TEAMS_COUNT];
bool increaseItr = true;
bool reverse1 = urand(0,1) ? true : false;
for (uint8 ii = BG_QUEUE_PREMADE_ALLIANCE; ii <= BG_QUEUE_PREMADE_HORDE; ii++)
{
uint8 i = reverse1 ? (BG_QUEUE_PREMADE_HORDE-ii) : ii;
for (GroupsQueueType::iterator itr = m_QueuedGroups[bracket_id][i].begin(); itr != m_QueuedGroups[bracket_id][i].end(); (increaseItr ? ++itr : itr))
{
increaseItr = true;
// if arenaRatedTeamId is set - look for oponents only for one team, if not - pair every possible team
if (arenaRatedTeamId != 0 && arenaRatedTeamId != (*itr)->ArenaTeamId)
continue;
if ((*itr)->IsInvitedToBGInstanceGUID)
continue;
uint32 MMR1 = std::min((*itr)->ArenaMatchmakerRating, maxCountedMMR);
GroupsQueueType::iterator oponentItr;
uint8 oponentQueue = BG_QUEUE_GROUP_TYPES_COUNT;
uint32 minOponentMMRDiff = 0xffffffff;
uint8 oponentValid = 0;
bool reverse2 = urand(0,1) ? true : false;
for (uint8 jj = BG_QUEUE_PREMADE_ALLIANCE; jj <= BG_QUEUE_PREMADE_HORDE; jj++)
{
uint8 j = reverse2 ? (BG_QUEUE_PREMADE_HORDE-jj) : jj;
bool brk = false;
for (GroupsQueueType::iterator itr2 = m_QueuedGroups[bracket_id][j].begin(); itr2 != m_QueuedGroups[bracket_id][j].end(); ++itr2)
{
if ((*itr)->ArenaTeamId == (*itr2)->ArenaTeamId)
continue;
if ((*itr2)->IsInvitedToBGInstanceGUID)
continue;
uint32 MMR2 = std::min((*itr2)->ArenaMatchmakerRating, maxCountedMMR);
uint32 MMRDiff = (MMR2>=MMR1 ? MMR2-MMR1 : MMR1-MMR2);
uint32 maxAllowedDiff = maxDefaultRatingDifference;
uint32 shorterWaitTime, longerWaitTime;
if (currMSTime-(*itr)->JoinTime <= currMSTime-(*itr2)->JoinTime)
{
shorterWaitTime = currMSTime-(*itr)->JoinTime;
longerWaitTime = currMSTime-(*itr2)->JoinTime;
}
else
{
shorterWaitTime = currMSTime-(*itr2)->JoinTime;
longerWaitTime = currMSTime-(*itr)->JoinTime;
}
if (longerWaitTime >= discardTime)
maxAllowedDiff += 150;
maxAllowedDiff += shorterWaitTime/600; // increased by 100 for each minute
// now check if this team is more appropriate than previous ones:
if (currMSTime-(*itr)->JoinTime >= 20*MINUTE*IN_MILLISECONDS && (oponentValid < 3 || MMRDiff < minOponentMMRDiff)) // after 20 minutes of waiting, pair with closest mmr, regardless the difference
{
oponentValid = 3;
minOponentMMRDiff = MMRDiff; oponentItr = itr2; oponentQueue = j;
}
else if (MMR1 >= 2000 && MMR2 >= 2000 && longerWaitTime >= 2*discardTime && (oponentValid < 2 || MMRDiff < minOponentMMRDiff)) // after 6 minutes of waiting, pair any 2000+ vs 2000+
{
oponentValid = 2;
minOponentMMRDiff = MMRDiff; oponentItr = itr2; oponentQueue = j;
}
else if (oponentValid < 2 && MMRDiff < minOponentMMRDiff)
{
if (!oponentValid)
{
minOponentMMRDiff = MMRDiff; oponentItr = itr2; oponentQueue = j;
if (MMRDiff <= maxAllowedDiff)
oponentValid = 1;
}
if ((MMR1 < 1800 || MMR2 < 1800) && MaxPlayersPerTeam == 2 && MMRDiff <= maxDefaultRatingDifference) // in 2v2 below 1800 mmr - priority for default allowed difference
{
minOponentMMRDiff = MMRDiff; oponentItr = itr2; oponentQueue = j;
brk = true;
break;
}
}
}
if (brk)
break;
}
if (oponentQueue != BG_QUEUE_GROUP_TYPES_COUNT)
{
if (oponentValid)
{
itr_teams[i] = itr;
itr_teams[i == 0 ? 1 : 0] = oponentItr;
{
GroupQueueInfo* aTeam = *itr_teams[TEAM_ALLIANCE];
GroupQueueInfo* hTeam = *itr_teams[TEAM_HORDE];
Battleground* arena = sBattlegroundMgr->CreateNewBattleground(m_bgTypeId, bracketEntry->minLevel, bracketEntry->maxLevel, m_arenaType, true);
if (!arena)
return;
aTeam->OpponentsTeamRating = hTeam->ArenaTeamRating;
hTeam->OpponentsTeamRating = aTeam->ArenaTeamRating;
aTeam->OpponentsMatchmakerRating = hTeam->ArenaMatchmakerRating;
hTeam->OpponentsMatchmakerRating = aTeam->ArenaMatchmakerRating;
// now we must move team if we changed its faction to another faction queue, because then we will spam log by errors in Queue::RemovePlayer
if (aTeam->teamId != TEAM_ALLIANCE)
{
aTeam->_groupType = BG_QUEUE_PREMADE_ALLIANCE;
m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].push_front(aTeam);
m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].erase(itr_teams[TEAM_ALLIANCE]);
increaseItr = false;
itr = m_QueuedGroups[bracket_id][i].begin();
}
if (hTeam->teamId != TEAM_HORDE)
{
hTeam->_groupType = BG_QUEUE_PREMADE_HORDE;
m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].push_front(hTeam);
m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].erase(itr_teams[TEAM_HORDE]);
increaseItr = false;
itr = m_QueuedGroups[bracket_id][i].begin();
}
arena->SetArenaMatchmakerRating(TEAM_ALLIANCE, aTeam->ArenaMatchmakerRating);
arena->SetArenaMatchmakerRating(TEAM_HORDE, hTeam->ArenaMatchmakerRating);
BattlegroundMgr::InviteGroupToBG(aTeam, arena, TEAM_ALLIANCE);
BattlegroundMgr::InviteGroupToBG(hTeam, arena, TEAM_HORDE);
arena->StartBattleground();
}
if (arenaRatedTeamId)
return;
else
continue;
}
else if (arenaRatedTeamId)
return;
}
}
}
}
}
