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