API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 25th, 2014
132
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 66.46 KB | None | 0 0
raw download clone embed print report
  1. ---------------- src/server/game/Battlegrounds/Battleground.cpp ----------------
  2. index 3b96b84..9c2ed52 100755
  3. @@ -203,6 +203,10 @@ Battleground::Battleground()
  4.      m_StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_BG_WS_START_ONE_MINUTE;
  5.      m_StartMessageIds[BG_STARTING_EVENT_THIRD]  = LANG_BG_WS_START_HALF_MINUTE;
  6.      m_StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_BG_WS_HAS_BEGUN;
  7. +
  8. +   // GuildvsGuild
  9. +   m_guildId1 = 0;
  10. +   m_guildId2 = 0;
  11.  }
  12.  
  13.  Battleground::~Battleground()
  14. @@ -806,11 +809,41 @@ void Battleground::EndBattleground(uint32 winner)
  15.              }
  16.  
  17.              plr->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_WIN_BG, 1);
  18. +           if (IsGuildvsGuild())
  19. +           {
  20. +               uint32 guildId = 0;
  21. +               guildId = plr->GetGuildId();
  22. +               QueryResult result;
  23. +                result = CharacterDatabase.PQuery("SELECT * FROM `GuildvsGuild` WHERE `id` = %u", guildId);
  24. +                if (result)
  25. +                {
  26. +                   CharacterDatabase.PExecute("UPDATE GuildvsGuild SET win = win + 1, total = total + 1 WHERE id = %u", guildId);
  27. +               }
  28. +               else
  29. +               {
  30. +                   CharacterDatabase.PExecute("INSERT INTO GuildvsGuild (id, win, total) VALUES (%u, %u, %u)", guildId, 1, 1);
  31. +               }
  32. +           }
  33.          }
  34.          else
  35.          {
  36.              if (IsRandom() || BattlegroundMgr::IsBGWeekend(GetTypeID()))
  37.                  UpdatePlayerScore(plr, SCORE_BONUS_HONOR, GetBonusHonorFromKill(loser_kills));
  38. +           if (IsGuildvsGuild())
  39. +           {
  40. +               uint32 guildId = 0;
  41. +               guildId = plr->GetGuildId();
  42. +               QueryResult result;
  43. +                result = CharacterDatabase.PQuery("SELECT * FROM `GuildvsGuild` WHERE `id` = %u", guildId);
  44. +               if (result)
  45. +                {
  46. +                   CharacterDatabase.PExecute("UPDATE GuildvsGuild SET total = total + 1 WHERE id = %u", guildId);
  47. +               }
  48. +               else
  49. +               {
  50. +                   CharacterDatabase.PExecute("INSERT INTO GuildvsGuild (id, win, total) VALUES (%u, %u, %u)", guildId, 0, 1);
  51. +               }
  52. +           }
  53.          }
  54.  
  55.          plr->ResetAllPowers();
  56. @@ -1852,3 +1884,10 @@ void Battleground::RewardXPAtKill(Player* killer, Player* victim)
  57.      if (sWorld->getBoolConfig(CONFIG_BG_XP_FOR_KILL) && killer && victim)
  58.          killer->RewardPlayerAndGroupAtKill(victim, true);
  59.  }
  60. +
  61. +bool Battleground::IsGuildvsGuild()
  62. +{
  63. +   if (m_guildId1 > 0 || m_guildId2 > 0)
  64. +       return true;
  65. +   return false;
  66. +}
  67.  
  68. ----------------- src/server/game/Battlegrounds/Battleground.h -----------------
  69. index ed9305a..96b627a 100755
  70. @@ -572,6 +572,11 @@ class Battleground
  71.          void RewardXPAtKill(Player* killer, Player* victim);
  72.          bool CanAwardArenaPoints() const { return m_LevelMin >= BG_AWARD_ARENA_POINTS_MIN_LEVEL; }
  73.  
  74. +       bool IsGuildvsGuild();
  75. +       uint32 getGuildId1() const { return m_guildId1; }
  76. +       uint32 getGuildId2() const { return m_guildId2; }
  77. +       void setGuildId1(uint32 guildId) { m_guildId1 = guildId; }
  78. +       void setGuildId2(uint32 guildId) { m_guildId2 = guildId; }
  79.      protected:
  80.          // this method is called, when BG cannot spawn its own spirit guide, or something is wrong, It correctly ends Battleground
  81.          void EndNow();
  82. @@ -669,6 +674,10 @@ class Battleground
  83.          float m_TeamStartLocZ[BG_TEAMS_COUNT];
  84.          float m_TeamStartLocO[BG_TEAMS_COUNT];
  85.          uint32 ScriptId;
  86. +
  87. +       // GuildvsGuild
  88. +       uint32 m_guildId1;
  89. +       uint32 m_guildId2;
  90.  };
  91.  #endif
  92.  
  93.  
  94. -------------- src/server/game/Battlegrounds/BattlegroundMgr.cpp --------------
  95. index 1799c50..638cb91 100755
  96. @@ -497,7 +497,7 @@ uint32 BattlegroundMgr::CreateClientVisibleInstanceId(BattlegroundTypeId bgTypeI
  97.  }
  98.  
  99.  // create a new battleground that will really be used to play
  100. -Battleground* BattlegroundMgr::CreateNewBattleground(BattlegroundTypeId bgTypeId, PvPDifficultyEntry const* bracketEntry, uint8 arenaType, bool isRated)
  101. +Battleground* BattlegroundMgr::CreateNewBattleground(BattlegroundTypeId bgTypeId, PvPDifficultyEntry const* bracketEntry, uint8 arenaType, bool isRated, uint32 guildId1, uint32 guildId2)
  102.  {
  103.      // get the template BG
  104.      Battleground *bg_template = GetBattlegroundTemplate(bgTypeId);
  105. @@ -620,6 +620,8 @@ Battleground* BattlegroundMgr::CreateNewBattleground(BattlegroundTypeId bgTypeId
  106.      bg->SetRandom(isRandom);
  107.      bg->SetTypeID(isRandom ? BATTLEGROUND_RB : bgTypeId);
  108.      bg->SetRandomTypeID(bgTypeId);
  109. +   bg->setGuildId1(guildId1);
  110. +   bg->setGuildId2(guildId2);
  111.  
  112.      return bg;
  113.  }
  114.  
  115. --------------- src/server/game/Battlegrounds/BattlegroundMgr.h ---------------
  116. index 7ff800e..53f1a57 100755
  117. @@ -59,7 +59,7 @@ class BattlegroundMgr
  118.          Battleground* GetBattleground(uint32 InstanceID, BattlegroundTypeId bgTypeId); //there must be uint32 because MAX_BATTLEGROUND_TYPE_ID means unknown
  119.  
  120.          Battleground* GetBattlegroundTemplate(BattlegroundTypeId bgTypeId);
  121. -        Battleground* CreateNewBattleground(BattlegroundTypeId bgTypeId, PvPDifficultyEntry const* bracketEntry, uint8 arenaType, bool isRated);
  122. +        Battleground* CreateNewBattleground(BattlegroundTypeId bgTypeId, PvPDifficultyEntry const* bracketEntry, uint8 arenaType, bool isRated, uint32 guildId1 = 0, uint32 guildId2 = 0);
  123.  
  124.          uint32 CreateBattleground(BattlegroundTypeId bgTypeId, bool IsArena, uint32 MinPlayersPerTeam, uint32 MaxPlayersPerTeam, uint32 LevelMin, uint32 LevelMax, char* BattlegroundName, uint32 MapID, float Team1StartLocX, float Team1StartLocY, float Team1StartLocZ, float Team1StartLocO, float Team2StartLocX, float Team2StartLocY, float Team2StartLocZ, float Team2StartLocO, uint32 scriptId);
  125.  
  126.  
  127. ------------- src/server/game/Battlegrounds/BattlegroundQueue.cpp -------------
  128. index 4b1bbed..c50ec16 100755
  129. @@ -50,9 +50,12 @@ BattlegroundQueue::~BattlegroundQueue()
  130.      {
  131.          for (uint32 j = 0; j < BG_QUEUE_GROUP_TYPES_COUNT; ++j)
  132.          {
  133. -            for (GroupsQueueType::iterator itr = m_QueuedGroups[i][j].begin(); itr!= m_QueuedGroups[i][j].end(); ++itr)
  134. -                delete (*itr);
  135. -            m_QueuedGroups[i][j].clear();
  136. +           for (uint32 k = 0; k < BG_QUEUE_GROUP_TYPES_GUILD; ++k)
  137. +           {
  138. +               for (GroupsQueueType::iterator itr = m_QueuedGroups[i][j][k].begin(); itr!= m_QueuedGroups[i][j][k].end(); ++itr)
  139. +                   delete (*itr);
  140. +               m_QueuedGroups[i][j][k].clear();
  141. +           }
  142.          }
  143.      }
  144.  }
  145. @@ -125,7 +128,7 @@ bool BattlegroundQueue::SelectionPool::AddGroup(GroupQueueInfo *ginfo, uint32 de
  146.  /*********************************************************/
  147.  
  148.  // add group or player (grp == NULL) to bg queue with the given leader and bg specifications
  149. -GroupQueueInfo * BattlegroundQueue::AddGroup(Player *leader, Group* grp, BattlegroundTypeId BgTypeId, PvPDifficultyEntry const*  bracketEntry, uint8 ArenaType, bool isRated, bool isPremade, uint32 ArenaRating, uint32 MatchmakerRating, uint32 arenateamid)
  150. +GroupQueueInfo * BattlegroundQueue::AddGroup(Player *leader, Group* grp, BattlegroundTypeId BgTypeId, PvPDifficultyEntry const*  bracketEntry, uint8 ArenaType, bool isRated, bool isPremade, uint32 ArenaRating, uint32 MatchmakerRating, uint32 arenateamid, uint32 guildId)
  151.  {
  152.      BattlegroundBracketId bracketId =  bracketEntry->GetBracketId();
  153.  
  154. @@ -143,15 +146,17 @@ GroupQueueInfo * BattlegroundQueue::AddGroup(Player *leader, Group* grp, Battleg
  155.      ginfo->ArenaMatchmakerRating     = MatchmakerRating;
  156.      ginfo->OpponentsTeamRating       = 0;
  157.      ginfo->OpponentsMatchmakerRating = 0;
  158. +   ginfo->guildId                   = guildId;
  159.  
  160.      ginfo->Players.clear();
  161.  
  162.      //compute index (if group is premade or joined a rated match) to queues
  163.      uint32 index = 0;
  164. -    if (!isRated && !isPremade)
  165. -        index += BG_TEAMS_COUNT;
  166. -    if (ginfo->Team == HORDE)
  167. -        index++;
  168. +   if (!isRated && !isPremade)
  169. +       index += BG_TEAMS_COUNT;
  170. +   if (ginfo->Team == HORDE)
  171. +       index++;
  172. +
  173.      sLog->outDebug(bg.battleground, "Adding Group to BattlegroundQueue bgTypeId : %u, bracket_id : %u, index : %u", BgTypeId, bracketId, index);
  174.  
  175.      uint32 lastOnlineTime = getMSTime();
  176. @@ -190,7 +195,12 @@ GroupQueueInfo * BattlegroundQueue::AddGroup(Player *leader, Group* grp, Battleg
  177.          }
  178.  
  179.          //add GroupInfo to m_QueuedGroups
  180. -        m_QueuedGroups[bracketId][index].push_back(ginfo);
  181. +       if (guildId > 0)
  182. +       {
  183. +           m_QueuedGroups[bracketId][index][BG_QUEUE_GUILD].push_back(ginfo);
  184. +       }
  185. +       else
  186. +           m_QueuedGroups[bracketId][index][BG_QUEUE_NOT_GUILD].push_back(ginfo);
  187.  
  188.          //announce to world, this code needs mutex
  189.          if (!isRated && !isPremade && sWorld->getBoolConfig(CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_ENABLE))
  190. @@ -204,12 +214,26 @@ GroupQueueInfo * BattlegroundQueue::AddGroup(Player *leader, Group* grp, Battleg
  191.                  uint32 q_min_level = bracketEntry->minLevel;
  192.                  uint32 q_max_level = bracketEntry->maxLevel;
  193.                  GroupsQueueType::const_iterator itr;
  194. -                for (itr = m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_ALLIANCE].begin(); itr != m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_ALLIANCE].end(); ++itr)
  195. -                    if (!(*itr)->IsInvitedToBGInstanceGUID)
  196. -                        qAlliance += (*itr)->Players.size();
  197. -                for (itr = m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_HORDE].begin(); itr != m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_HORDE].end(); ++itr)
  198. -                    if (!(*itr)->IsInvitedToBGInstanceGUID)
  199. -                        qHorde += (*itr)->Players.size();
  200. +               if (guildId > 0)
  201. +               {
  202. +                   for (itr = m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_ALLIANCE][BG_QUEUE_GUILD].begin(); itr != m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_ALLIANCE][BG_QUEUE_GUILD].end(); ++itr)
  203. +                       if (!(*itr)->IsInvitedToBGInstanceGUID)
  204. +                           qAlliance += (*itr)->Players.size();
  205. +
  206. +                   for (itr = m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_HORDE][BG_QUEUE_GUILD].begin(); itr != m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_HORDE][BG_QUEUE_GUILD].end(); ++itr)
  207. +                       if (!(*itr)->IsInvitedToBGInstanceGUID)
  208. +                           qHorde += (*itr)->Players.size();
  209. +               }
  210. +               else
  211. +               {
  212. +                   for (itr = m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_ALLIANCE][BG_QUEUE_NOT_GUILD].begin(); itr != m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_ALLIANCE][BG_QUEUE_NOT_GUILD].end(); ++itr)
  213. +                       if (!(*itr)->IsInvitedToBGInstanceGUID)
  214. +                           qAlliance += (*itr)->Players.size();
  215. +
  216. +                   for (itr = m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_HORDE][BG_QUEUE_NOT_GUILD].begin(); itr != m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_HORDE][BG_QUEUE_NOT_GUILD].end(); ++itr)
  217. +                       if (!(*itr)->IsInvitedToBGInstanceGUID)
  218. +                           qHorde += (*itr)->Players.size();
  219. +               }
  220.  
  221.                  // Show queue status to player only (when joining queue)
  222.                  if (sWorld->getBoolConfig(CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_PLAYERONLY))
  223. @@ -309,15 +333,18 @@ void BattlegroundQueue::RemovePlayer(const uint64& guid, bool decreaseInvitedCou
  224.          //they leave groupinfo so we can't use its players size to find out index
  225.          for (uint32 j = index; j < BG_QUEUE_GROUP_TYPES_COUNT; j += BG_QUEUE_NORMAL_ALLIANCE)
  226.          {
  227. -            for (group_itr_tmp = m_QueuedGroups[bracket_id_tmp][j].begin(); group_itr_tmp != m_QueuedGroups[bracket_id_tmp][j].end(); ++group_itr_tmp)
  228. -            {
  229. -                if ((*group_itr_tmp) == group)
  230. -                {
  231. -                    bracket_id = bracket_id_tmp;
  232. -                    group_itr = group_itr_tmp;
  233. -                    //we must store index to be able to erase iterator
  234. -                    index = j;
  235. -                    break;
  236. +           for (uint32 k = 0; k < BG_QUEUE_GROUP_TYPES_GUILD; ++k)
  237. +           {
  238. +               for (group_itr_tmp = m_QueuedGroups[bracket_id_tmp][j][k].begin(); group_itr_tmp != m_QueuedGroups[bracket_id_tmp][j][k].end(); ++group_itr_tmp)
  239. +               {
  240. +                   if ((*group_itr_tmp) == group)
  241. +                   {
  242. +                       bracket_id = bracket_id_tmp;
  243. +                       group_itr = group_itr_tmp;
  244. +                       //we must store index to be able to erase iterator
  245. +                       index = j;
  246. +                       break;
  247. +                   }
  248.                  }
  249.              }
  250.          }
  251. @@ -378,7 +405,10 @@ void BattlegroundQueue::RemovePlayer(const uint64& guid, bool decreaseInvitedCou
  252.      // remove group queue info if needed
  253.      if (group->Players.empty())
  254.      {
  255. -        m_QueuedGroups[bracket_id][index].erase(group_itr);
  256. +       if (group->guildId > 0)
  257. +           m_QueuedGroups[bracket_id][index][BG_QUEUE_GUILD].erase(group_itr);
  258. +       else
  259. +           m_QueuedGroups[bracket_id][index][BG_QUEUE_NOT_GUILD].erase(group_itr);
  260.          delete group;
  261.      }
  262.      // if group wasn't empty, so it wasn't deleted, and player have left a rated
  263. @@ -489,25 +519,46 @@ This function is inviting players to already running battlegrounds
  264.  Invitation type is based on config file
  265.  large groups are disadvantageous, because they will be kicked first if invitation type = 1
  266.  */
  267. -void BattlegroundQueue::FillPlayersToBG(Battleground* bg, BattlegroundBracketId bracket_id)
  268. +void BattlegroundQueue::FillPlayersToBG(Battleground* bg, BattlegroundBracketId bracket_id, bool GuildvsGuild)
  269.  {
  270.      int32 hordeFree = bg->GetFreeSlotsForTeam(HORDE);
  271.      int32 aliFree   = bg->GetFreeSlotsForTeam(ALLIANCE);
  272. -
  273. +   GroupsQueueType::const_iterator Ali_itr;
  274. +   Ali_itr = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE][BG_QUEUE_GUILD].begin();
  275. +   GroupsQueueType::const_iterator Horde_itr;
  276. +   Horde_itr = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_HORDE][BG_QUEUE_GUILD].begin();
  277.      //iterator for iterating through bg queue
  278. -    GroupsQueueType::const_iterator Ali_itr = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE].begin();
  279. -    //count of groups in queue - used to stop cycles
  280. -    uint32 aliCount = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE].size();
  281. -    //index to queue which group is current
  282. -    uint32 aliIndex = 0;
  283. -    for (; aliIndex < aliCount && m_SelectionPools[BG_TEAM_ALLIANCE].AddGroup((*Ali_itr), aliFree); aliIndex++)
  284. -        ++Ali_itr;
  285. -    //the same thing for horde
  286. -    GroupsQueueType::const_iterator Horde_itr = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_HORDE].begin();
  287. -    uint32 hordeCount = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_HORDE].size();
  288. -    uint32 hordeIndex = 0;
  289. -    for (; hordeIndex < hordeCount && m_SelectionPools[BG_TEAM_HORDE].AddGroup((*Horde_itr), hordeFree); hordeIndex++)
  290. -        ++Horde_itr;
  291. +
  292. +   if (GuildvsGuild)
  293. +   {
  294. +       for (; Ali_itr != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE][BG_QUEUE_GUILD].end(); ++Ali_itr)
  295. +       {
  296. +           if ((*Ali_itr)->guildId == bg->getGuildId1())
  297. +           {
  298. +               if (!m_SelectionPools[BG_TEAM_ALLIANCE].AddGroup((*Ali_itr), aliFree))
  299. +                   break;
  300. +           }
  301. +       }
  302. +
  303. +       for (; Horde_itr != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_HORDE][BG_QUEUE_GUILD].end(); ++Horde_itr)
  304. +       {
  305. +           if ((*Horde_itr)->guildId == bg->getGuildId2())
  306. +           {
  307. +               if (!m_SelectionPools[BG_TEAM_HORDE].AddGroup((*Horde_itr), hordeFree))
  308. +                   break;
  309. +           }
  310. +       }
  311. +   }
  312. +   else
  313. +   {
  314. +       for (; Ali_itr != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE][BG_QUEUE_NOT_GUILD].end(); ++Ali_itr)
  315. +           if (!m_SelectionPools[BG_TEAM_ALLIANCE].AddGroup((*Ali_itr), aliFree))
  316. +               break;
  317. +
  318. +       for (; Horde_itr != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_HORDE][BG_QUEUE_NOT_GUILD].end(); ++Horde_itr)
  319. +           if (!m_SelectionPools[BG_TEAM_HORDE].AddGroup((*Horde_itr), hordeFree))
  320. +               break;
  321. +   }
  322.  
  323.      //if ofc like BG queue invitation is set in config, then we are happy
  324.      if (sWorld->getIntConfig(CONFIG_BATTLEGROUND_INVITATION_TYPE) == 0)
  325. @@ -532,8 +583,23 @@ void BattlegroundQueue::FillPlayersToBG(Battleground* bg, BattlegroundBracketId
  326.              //kick alliance group, add to pool new group if needed
  327.              if (m_SelectionPools[BG_TEAM_ALLIANCE].KickGroup(diffHorde - diffAli))
  328.              {
  329. -                for (; aliIndex < aliCount && m_SelectionPools[BG_TEAM_ALLIANCE].AddGroup((*Ali_itr), (aliFree >= diffHorde) ? aliFree - diffHorde : 0); aliIndex++)
  330. -                    ++Ali_itr;
  331. +               if (GuildvsGuild)
  332. +               {
  333. +                   for (; Ali_itr != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE][BG_QUEUE_GUILD].end(); ++Ali_itr)
  334. +                   {
  335. +                       if ((*Ali_itr)->guildId == bg->getGuildId1())
  336. +                       {
  337. +                           if (!m_SelectionPools[BG_TEAM_ALLIANCE].AddGroup((*Ali_itr), (aliFree >= diffHorde) ? aliFree - diffHorde : 0))
  338. +                               break;
  339. +                       }
  340. +                   }
  341. +               }
  342. +               else
  343. +               {
  344. +                   for (; Ali_itr != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE][BG_QUEUE_NOT_GUILD].end(); ++Ali_itr)
  345. +                       if (!m_SelectionPools[BG_TEAM_ALLIANCE].AddGroup((*Ali_itr), (aliFree >= diffHorde) ? aliFree - diffHorde : 0))
  346. +                           break;
  347. +               }
  348.              }
  349.              //if ali selection is already empty, then kick horde group, but if there are less horde than ali in bg - break;
  350.              if (!m_SelectionPools[BG_TEAM_ALLIANCE].GetPlayerCount())
  351. @@ -548,8 +614,23 @@ void BattlegroundQueue::FillPlayersToBG(Battleground* bg, BattlegroundBracketId
  352.              //kick horde group, add to pool new group if needed
  353.              if (m_SelectionPools[BG_TEAM_HORDE].KickGroup(diffAli - diffHorde))
  354.              {
  355. -                for (; hordeIndex < hordeCount && m_SelectionPools[BG_TEAM_HORDE].AddGroup((*Horde_itr), (hordeFree >= diffAli) ? hordeFree - diffAli : 0); hordeIndex++)
  356. -                    ++Horde_itr;
  357. +               if (GuildvsGuild)
  358. +               {
  359. +                   for (; Horde_itr != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_HORDE][BG_QUEUE_GUILD].end(); ++Horde_itr)
  360. +                   {
  361. +                       if ((*Horde_itr)->guildId == bg->getGuildId2())
  362. +                       {
  363. +                           if (!m_SelectionPools[BG_TEAM_HORDE].AddGroup((*Horde_itr), (hordeFree >= diffAli) ? hordeFree - diffAli : 0))
  364. +                               break;
  365. +                       }
  366. +                   }
  367. +               }
  368. +               else
  369. +               {
  370. +                   for (; Horde_itr != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_HORDE][BG_QUEUE_NOT_GUILD].end(); ++Horde_itr)
  371. +                       if (!m_SelectionPools[BG_TEAM_HORDE].AddGroup((*Horde_itr), (hordeFree >= diffAli) ? hordeFree - diffAli : 0))
  372. +                           break;
  373. +               }
  374.              }
  375.              if (!m_SelectionPools[BG_TEAM_HORDE].GetPlayerCount())
  376.              {
  377. @@ -567,36 +648,98 @@ void BattlegroundQueue::FillPlayersToBG(Battleground* bg, BattlegroundBracketId
  378.  // this method checks if premade versus premade battleground is possible
  379.  // then after 30 mins (default) in queue it moves premade group to normal queue
  380.  // it tries to invite as much players as it can - to MaxPlayersPerTeam, because premade groups have more than MinPlayersPerTeam players
  381. -bool BattlegroundQueue::CheckPremadeMatch(BattlegroundBracketId bracket_id, uint32 MinPlayersPerTeam, uint32 MaxPlayersPerTeam)
  382. +bool BattlegroundQueue::CheckPremadeMatch(BattlegroundBracketId bracket_id, uint32 MinPlayersPerTeam, uint32 MaxPlayersPerTeam, bool GuildvsGuild)
  383.  {
  384. -    //check match
  385. -    if (!m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].empty() && !m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].empty())
  386. -    {
  387. -        //start premade match
  388. -        //if groups aren't invited
  389. -        GroupsQueueType::const_iterator ali_group, horde_group;
  390. -        for (ali_group = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].begin(); ali_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].end(); ++ali_group)
  391. -            if (!(*ali_group)->IsInvitedToBGInstanceGUID)
  392. -                break;
  393. -        for (horde_group = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].begin(); horde_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].end(); ++horde_group)
  394. -            if (!(*horde_group)->IsInvitedToBGInstanceGUID)
  395. -                break;
  396. -
  397. -        if (ali_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].end() && horde_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].end())
  398. -        {
  399. +   GroupsQueueType::const_iterator ali_group, horde_group;
  400. +   bool empty = true;
  401. +   bool end = true;
  402. +   uint32 guildId[BG_QUEUE_GROUP_TYPES_GUILD];
  403. +   guildId[BG_TEAM_ALLIANCE] = 0;
  404. +   guildId[BG_TEAM_HORDE] = 0;
  405. +   if (GuildvsGuild)
  406. +   {
  407. +       //check match
  408. +       if (!m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_GUILD].empty() && !m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_GUILD].empty())
  409. +       {
  410. +           empty = false;
  411. +           //start premade match
  412. +           //if groups aren't invited
  413. +           for (ali_group = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_GUILD].begin(); ali_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_GUILD].end(); ++ali_group)
  414. +               if (!(*ali_group)->IsInvitedToBGInstanceGUID)
  415. +               {
  416. +                   guildId[0] = (*ali_group)->guildId;
  417. +                   break;
  418. +               }
  419. +           for (horde_group = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_GUILD].begin(); horde_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_GUILD].end(); ++horde_group)
  420. +               if (!(*horde_group)->IsInvitedToBGInstanceGUID)
  421. +               {
  422. +                   guildId[1] = (*horde_group)->guildId;
  423. +                   break;
  424. +               }
  425. +       }
  426. +   }
  427. +   else
  428. +   {
  429. +       //check match
  430. +       if (!m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_NOT_GUILD].empty() && !m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_NOT_GUILD].empty())
  431. +       {
  432. +           empty = false;
  433. +           for (ali_group = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_NOT_GUILD].begin(); ali_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_NOT_GUILD].end(); ++ali_group)
  434. +               if (!(*ali_group)->IsInvitedToBGInstanceGUID)
  435. +                   break;
  436. +           for (horde_group = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_NOT_GUILD].begin(); horde_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_NOT_GUILD].end(); ++horde_group)
  437. +               if (!(*horde_group)->IsInvitedToBGInstanceGUID)
  438. +                   break;
  439. +       }
  440. +   }
  441. +   if (!empty)
  442. +   {
  443. +       if (GuildvsGuild)
  444. +       {
  445. +           if (ali_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_GUILD].end() && horde_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_GUILD].end())
  446. +           {
  447. +               end = false;
  448. +           }
  449. +       }
  450. +       else
  451. +       {
  452. +           if (ali_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_NOT_GUILD].end() && horde_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_NOT_GUILD].end())
  453. +           {
  454. +               end = false;
  455. +           }
  456. +       }
  457. +       if (!end)
  458. +       {
  459.              m_SelectionPools[BG_TEAM_ALLIANCE].AddGroup((*ali_group), MaxPlayersPerTeam);
  460.              m_SelectionPools[BG_TEAM_HORDE].AddGroup((*horde_group), MaxPlayersPerTeam);
  461.              //add groups/players from normal queue to size of bigger group
  462.              uint32 maxPlayers = std::min(m_SelectionPools[BG_TEAM_ALLIANCE].GetPlayerCount(), m_SelectionPools[BG_TEAM_HORDE].GetPlayerCount());
  463.              GroupsQueueType::const_iterator itr;
  464. -            for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
  465. -            {
  466. -                for (itr = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i].begin(); itr != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i].end(); ++itr)
  467. -                {
  468. -                    //if itr can join BG and player count is less that maxPlayers, then add group to selectionpool
  469. -                    if (!(*itr)->IsInvitedToBGInstanceGUID && !m_SelectionPools[i].AddGroup((*itr), maxPlayers))
  470. -                        break;
  471. -                }
  472. +           GroupsQueueType::const_iterator itr2;
  473. +           if (GuildvsGuild)
  474. +           {
  475. +               for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
  476. +               {
  477. +                   for (itr = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i][BG_QUEUE_GUILD].begin(); itr != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i][BG_QUEUE_GUILD].end(); ++itr)
  478. +                   {
  479. +                       if ((*itr)->guildId == guildId[i])
  480. +                           //if itr can join BG and player count is less that maxPlayers, then add group to selectionpool
  481. +                           if (!(*itr)->IsInvitedToBGInstanceGUID && !m_SelectionPools[i].AddGroup((*itr), maxPlayers))
  482. +                               break;
  483. +                   }
  484. +               }
  485. +           }
  486. +           else
  487. +           {
  488. +               for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
  489. +               {
  490. +                   for (itr = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i][BG_QUEUE_NOT_GUILD].begin(); itr != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i][BG_QUEUE_NOT_GUILD].end(); ++itr)
  491. +                   {
  492. +                       //if itr can join BG and player count is less that maxPlayers, then add group to selectionpool
  493. +                       if (!(*itr)->IsInvitedToBGInstanceGUID && !m_SelectionPools[i].AddGroup((*itr), maxPlayers))
  494. +                           break;
  495. +                   }
  496. +               }
  497.              }
  498.              //premade selection pools are set
  499.              return true;
  500. @@ -609,14 +752,17 @@ bool BattlegroundQueue::CheckPremadeMatch(BattlegroundBracketId bracket_id, uint
  501.      uint32 time_before = getMSTime() - sWorld->getIntConfig(CONFIG_BATTLEGROUND_PREMADE_GROUP_WAIT_FOR_MATCH);
  502.      for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
  503.      {
  504. -        if (!m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE + i].empty())
  505. -        {
  506. -            GroupsQueueType::iterator itr = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE + i].begin();
  507. -            if (!(*itr)->IsInvitedToBGInstanceGUID && ((*itr)->JoinTime < time_before || (*itr)->Players.size() < MinPlayersPerTeam))
  508. -            {
  509. -                //we must insert group to normal queue and erase pointer from premade queue
  510. -                m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i].push_front((*itr));
  511. -                m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE + i].erase(itr);
  512. +       for (uint32 j = 0; j < BG_QUEUE_GROUP_TYPES_GUILD; j++)
  513. +       {
  514. +           if (!m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE + i][j].empty())
  515. +           {
  516. +               GroupsQueueType::iterator itr = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE + i][j].begin();
  517. +               if (!(*itr)->IsInvitedToBGInstanceGUID && ((*itr)->JoinTime < time_before || (*itr)->Players.size() < MinPlayersPerTeam))
  518. +               {
  519. +                   //we must insert group to normal queue and erase pointer from premade queue
  520. +                   m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i][j].push_front((*itr));
  521. +                   m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE + i][j].erase(itr);
  522. +               }
  523.              }
  524.          }
  525.      }
  526. @@ -625,22 +771,46 @@ bool BattlegroundQueue::CheckPremadeMatch(BattlegroundBracketId bracket_id, uint
  527.  }
  528.  
  529.  // this method tries to create battleground or arena with MinPlayersPerTeam against MinPlayersPerTeam
  530. -bool BattlegroundQueue::CheckNormalMatch(Battleground* bg_template, BattlegroundBracketId bracket_id, uint32 minPlayers, uint32 maxPlayers)
  531. +bool BattlegroundQueue::CheckNormalMatch(Battleground* bg_template, BattlegroundBracketId bracket_id, uint32 minPlayers, uint32 maxPlayers, bool GuildvsGuild)
  532.  {
  533.      GroupsQueueType::const_iterator itr_team[BG_TEAMS_COUNT];
  534. -    for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
  535. -    {
  536. -        itr_team[i] = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i].begin();
  537. -        for (; itr_team[i] != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i].end(); ++(itr_team[i]))
  538. -        {
  539. -            if (!(*(itr_team[i]))->IsInvitedToBGInstanceGUID)
  540. -            {
  541. -                m_SelectionPools[i].AddGroup(*(itr_team[i]), maxPlayers);
  542. -                if (m_SelectionPools[i].GetPlayerCount() >= minPlayers)
  543. -                    break;
  544. -            }
  545. +   uint32 guildId[BG_QUEUE_GROUP_TYPES_GUILD];
  546. +   if (GuildvsGuild)
  547. +   {
  548. +       for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
  549. +       {
  550. +           guildId[i] = 0;
  551. +           itr_team[i] = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i][BG_QUEUE_GUILD].begin();
  552. +           for (; itr_team[i] != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i][BG_QUEUE_GUILD].end(); ++(itr_team[i]))
  553. +           {
  554. +               if (!(*(itr_team[i]))->IsInvitedToBGInstanceGUID)
  555. +               {
  556. +                   if (guildId[i] > 0 && guildId[i] != (*(itr_team[i]))->guildId)
  557. +                       continue;
  558. +                   guildId[i] = (*(itr_team[i]))->guildId;
  559. +                   m_SelectionPools[i].AddGroup(*(itr_team[i]), maxPlayers);
  560. +                   if (m_SelectionPools[i].GetPlayerCount() >= minPlayers)
  561. +                       break;
  562. +               }
  563. +           }
  564.          }
  565. -    }
  566. +   }
  567. +   else
  568. +   {
  569. +       for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
  570. +       {
  571. +           itr_team[i] = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i][BG_QUEUE_NOT_GUILD].begin();
  572. +           for (; itr_team[i] != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + i][BG_QUEUE_NOT_GUILD].end(); ++(itr_team[i]))
  573. +           {
  574. +               if (!(*(itr_team[i]))->IsInvitedToBGInstanceGUID)
  575. +               {
  576. +                   m_SelectionPools[i].AddGroup(*(itr_team[i]), maxPlayers);
  577. +                   if (m_SelectionPools[i].GetPlayerCount() >= minPlayers)
  578. +                       break;
  579. +               }
  580. +            }
  581. +       }
  582. +   }
  583.      //try to invite same number of players - this cycle may cause longer wait time even if there are enough players in queue, but we want ballanced bg
  584.      uint32 j = BG_TEAM_ALLIANCE;
  585.      if (m_SelectionPools[BG_TEAM_HORDE].GetPlayerCount() < m_SelectionPools[BG_TEAM_ALLIANCE].GetPlayerCount())
  586. @@ -648,23 +818,58 @@ bool BattlegroundQueue::CheckNormalMatch(Battleground* bg_template, Battleground
  587.      if (sWorld->getIntConfig(CONFIG_BATTLEGROUND_INVITATION_TYPE) != 0
  588.          && m_SelectionPools[BG_TEAM_HORDE].GetPlayerCount() >= minPlayers && m_SelectionPools[BG_TEAM_ALLIANCE].GetPlayerCount() >= minPlayers)
  589.      {
  590. -        //we will try to invite more groups to team with less players indexed by j
  591. -        ++(itr_team[j]);                                         //this will not cause a crash, because for cycle above reached break;
  592. -        for (; itr_team[j] != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + j].end(); ++(itr_team[j]))
  593. -        {
  594. -            if (!(*(itr_team[j]))->IsInvitedToBGInstanceGUID)
  595. -                if (!m_SelectionPools[j].AddGroup(*(itr_team[j]), m_SelectionPools[(j + 1) % BG_TEAMS_COUNT].GetPlayerCount()))
  596. -                    break;
  597. -        }
  598. +       if (GuildvsGuild)
  599. +       {
  600. +           //we will try to invite more groups to team with less players indexed by j
  601. +           ++(itr_team[j]);                                         //this will not cause a crash, because for cycle above reached break;
  602. +           for (; itr_team[j] != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + j][BG_QUEUE_GUILD].end(); ++(itr_team[j]))
  603. +           {
  604. +               if (!(*(itr_team[j]))->IsInvitedToBGInstanceGUID)
  605. +                   if (guildId[j] == (*(itr_team[j]))->guildId)
  606. +                       if (!m_SelectionPools[j].AddGroup(*(itr_team[j]), m_SelectionPools[(j + 1) % BG_TEAMS_COUNT].GetPlayerCount()))
  607. +                           break;
  608. +           }
  609. +       }
  610. +       else
  611. +       {
  612. +           //we will try to invite more groups to team with less players indexed by j
  613. +           ++(itr_team[j]);                                         //this will not cause a crash, because for cycle above reached break;
  614. +           for (; itr_team[j] != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + j][BG_QUEUE_NOT_GUILD].end(); ++(itr_team[j]))
  615. +           {
  616. +               if (!(*(itr_team[j]))->IsInvitedToBGInstanceGUID)
  617. +                   if (!m_SelectionPools[j].AddGroup(*(itr_team[j]), m_SelectionPools[(j + 1) % BG_TEAMS_COUNT].GetPlayerCount()))
  618. +                       break;
  619. +           }
  620. +       }
  621.          // do not allow to start bg with more than 2 players more on 1 faction
  622.          if (abs((int32)(m_SelectionPools[BG_TEAM_HORDE].GetPlayerCount() - m_SelectionPools[BG_TEAM_ALLIANCE].GetPlayerCount())) > 2)
  623.              return false;
  624.      }
  625.      //allow 1v0 if debug bg
  626. -    if (sBattlegroundMgr->isTesting() && bg_template->isBattleground() && (m_SelectionPools[BG_TEAM_ALLIANCE].GetPlayerCount() || m_SelectionPools[BG_TEAM_HORDE].GetPlayerCount()))
  627. -        return true;
  628. +    if (sBattlegroundMgr->isTesting() && bg_template->isBattleground())
  629. +   {
  630. +       uint32 i;
  631. +       if (m_SelectionPools[BG_TEAM_ALLIANCE].GetPlayerCount())
  632. +           i = BG_TEAM_ALLIANCE;
  633. +       else if (m_SelectionPools[BG_TEAM_HORDE].GetPlayerCount())
  634. +           i = BG_TEAM_HORDE;
  635. +       GroupsQueueType::const_iterator itr = m_SelectionPools[i].SelectedGroups.begin();
  636. +       if (GuildvsGuild && (*itr)->guildId > 0)
  637. +           return true;
  638. +       else if (!GuildvsGuild && (*itr)->guildId == 0)
  639. +           return true;
  640. +   }
  641.      //return true if there are enough players in selection pools - enable to work .debug bg command correctly
  642. -    return m_SelectionPools[BG_TEAM_ALLIANCE].GetPlayerCount() >= minPlayers && m_SelectionPools[BG_TEAM_HORDE].GetPlayerCount() >= minPlayers;
  643. +   if (m_SelectionPools[BG_TEAM_ALLIANCE].GetPlayerCount() >= minPlayers && m_SelectionPools[BG_TEAM_HORDE].GetPlayerCount() >= minPlayers)
  644. +   {
  645. +       GroupsQueueType::const_iterator alliance = m_SelectionPools[BG_TEAM_ALLIANCE].SelectedGroups.begin();
  646. +       GroupsQueueType::const_iterator horde = m_SelectionPools[BG_TEAM_ALLIANCE].SelectedGroups.begin();
  647. +       if (GuildvsGuild && (*alliance)->guildId > 0 && (*horde)->guildId > 0)
  648. +           return true;
  649. +       else if (!GuildvsGuild && (*alliance)->guildId == 0 && (*horde)->guildId == 0)
  650. +           return true;
  651. +   }
  652. +   return false;
  653.  }
  654.  
  655.  // this method will check if we can invite players to same faction skirmish match
  656. @@ -686,21 +891,22 @@ bool BattlegroundQueue::CheckSkirmishForSameFaction(BattlegroundBracketId bracke
  657.      //store last ginfo pointer
  658.      GroupQueueInfo* ginfo = m_SelectionPools[teamIndex].SelectedGroups.back();
  659.      //set itr_team to group that was added to selection pool latest
  660. -    GroupsQueueType::iterator itr_team = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex].begin();
  661. -    for (; itr_team != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex].end(); ++itr_team)
  662. -        if (ginfo == *itr_team)
  663. -            break;
  664. -    if (itr_team == m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex].end())
  665. -        return false;
  666. +   GroupsQueueType::iterator itr_team;
  667. +   itr_team = m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex][BG_QUEUE_NOT_GUILD].begin();
  668. +   for (; itr_team != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex][BG_QUEUE_NOT_GUILD].end(); ++itr_team)
  669. +       if (ginfo == *itr_team)
  670. +           break;
  671. +   if (itr_team == m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex][BG_QUEUE_NOT_GUILD].end())
  672. +       return false;
  673.      GroupsQueueType::iterator itr_team2 = itr_team;
  674.      ++itr_team2;
  675. -    //invite players to other selection pool
  676. -    for (; itr_team2 != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex].end(); ++itr_team2)
  677. -    {
  678. -        //if selection pool is full then break;
  679. -        if (!(*itr_team2)->IsInvitedToBGInstanceGUID && !m_SelectionPools[otherTeam].AddGroup(*itr_team2, minPlayersPerTeam))
  680. -            break;
  681. -    }
  682. +   //invite players to other selection pool
  683. +   for (; itr_team2 != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex][BG_QUEUE_NOT_GUILD].end(); ++itr_team2)
  684. +   {
  685. +       //if selection pool is full then break;
  686. +       if (!(*itr_team2)->IsInvitedToBGInstanceGUID && !m_SelectionPools[otherTeam].AddGroup(*itr_team2, minPlayersPerTeam))
  687. +           break;
  688. +   }
  689.      if (m_SelectionPools[otherTeam].GetPlayerCount() != minPlayersPerTeam)
  690.          return false;
  691.  
  692. @@ -710,15 +916,15 @@ bool BattlegroundQueue::CheckSkirmishForSameFaction(BattlegroundBracketId bracke
  693.          //set correct team
  694.          (*itr)->Team = otherTeamId;
  695.          //add team to other queue
  696. -        m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + otherTeam].push_front(*itr);
  697. +       m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + otherTeam][BG_QUEUE_NOT_GUILD].push_front(*itr);
  698.          //remove team from old queue
  699.          GroupsQueueType::iterator itr2 = itr_team;
  700.          ++itr2;
  701. -        for (; itr2 != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex].end(); ++itr2)
  702. +        for (; itr2 != m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex][BG_QUEUE_NOT_GUILD].end(); ++itr2)
  703.          {
  704.              if (*itr2 == *itr)
  705.              {
  706. -                m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex].erase(itr2);
  707. +               m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE + teamIndex][BG_QUEUE_NOT_GUILD].erase(itr2);
  708.                  break;
  709.              }
  710.          }
  711. @@ -734,10 +940,15 @@ should be called from Battleground::RemovePlayer function in some cases
  712.  void BattlegroundQueue::Update(BattlegroundTypeId bgTypeId, BattlegroundBracketId bracket_id, uint8 arenaType, bool isRated, uint32 arenaRating)
  713.  {
  714.      //if no players in queue - do nothing
  715. -    if (m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].empty() &&
  716. -        m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].empty() &&
  717. -        m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE].empty() &&
  718. -        m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_HORDE].empty())
  719. +
  720. +    if (m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_GUILD].empty() &&
  721. +        m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_GUILD].empty() &&
  722. +        m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE][BG_QUEUE_GUILD].empty() &&
  723. +        m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_HORDE][BG_QUEUE_GUILD].empty() &&
  724. +       m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_NOT_GUILD].empty() &&
  725. +        m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_NOT_GUILD].empty() &&
  726. +        m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_ALLIANCE][BG_QUEUE_NOT_GUILD].empty() &&
  727. +        m_QueuedGroups[bracket_id][BG_QUEUE_NORMAL_HORDE][BG_QUEUE_NOT_GUILD].empty())
  728.          return;
  729.  
  730.      //battleground with free slot for player should be always in the beggining of the queue
  731. @@ -759,7 +970,10 @@ void BattlegroundQueue::Update(BattlegroundTypeId bgTypeId, BattlegroundBracketI
  732.              m_SelectionPools[BG_TEAM_HORDE].Init();
  733.  
  734.              // call a function that does the job for us
  735. -            FillPlayersToBG(bg, bracket_id);
  736. +           if (bg->IsGuildvsGuild())
  737. +               FillPlayersToBG(bg, bracket_id, true);
  738. +           else
  739. +               FillPlayersToBG(bg, bracket_id, false);
  740.  
  741.              // now everything is set, invite players
  742.              for (GroupsQueueType::const_iterator citr = m_SelectionPools[BG_TEAM_ALLIANCE].SelectedGroups.begin(); citr != m_SelectionPools[BG_TEAM_ALLIANCE].SelectedGroups.end(); ++citr)
  743. @@ -851,6 +1065,49 @@ void BattlegroundQueue::Update(BattlegroundTypeId bgTypeId, BattlegroundBracketI
  744.              m_SelectionPools[BG_TEAM_ALLIANCE].Init();
  745.              m_SelectionPools[BG_TEAM_HORDE].Init();
  746.          }
  747. +       if (CheckPremadeMatch(bracket_id, MinPlayersPerTeam, MaxPlayersPerTeam, true))
  748. +        {
  749. +           uint32 guildId1 = 0;
  750. +           uint32 guildId2 = 0;
  751. +           bool check = true;
  752. +           for (GroupsQueueType::const_iterator citr = m_SelectionPools[BG_TEAM_ALLIANCE].SelectedGroups.begin(); citr != m_SelectionPools[BG_TEAM_ALLIANCE].SelectedGroups.end(); ++citr)
  753. +           {
  754. +               if (guildId1 > 0 && guildId1 != (*citr)->guildId)
  755. +               {
  756. +                   check = false;
  757. +                   break;
  758. +               }
  759. +               guildId1 = (*citr)->guildId;
  760. +           }
  761. +           for (GroupsQueueType::const_iterator citr = m_SelectionPools[BG_TEAM_HORDE].SelectedGroups.begin(); citr != m_SelectionPools[BG_TEAM_HORDE].SelectedGroups.end(); ++citr)
  762. +           {
  763. +               if (guildId2 > 0 && guildId2 != (*citr)->guildId)
  764. +               {
  765. +                   check = false;
  766. +                   break;
  767. +               }
  768. +               guildId2 = (*citr)->guildId;
  769. +           }
  770. +           if (guildId1 > 0 && guildId2 > 0 && check)
  771. +           {
  772. +               //create new battleground
  773. +               Battleground* bg2 = sBattlegroundMgr->CreateNewBattleground(bgTypeId, bracketEntry, 0, false, guildId1, guildId2);
  774. +               if (!bg2)
  775. +               {
  776. +                   TC_LOG_ERROR("BattlegroundQueue::Update - Cannot create battleground: %u", bgTypeId);
  777. +                   return;
  778. +               }
  779. +               //invite those selection pools
  780. +               for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
  781. +                   for (GroupsQueueType::const_iterator citr = m_SelectionPools[BG_TEAM_ALLIANCE + i].SelectedGroups.begin(); citr != m_SelectionPools[BG_TEAM_ALLIANCE + i].SelectedGroups.end(); ++citr)
  782. +                       InviteGroupToBG((*citr), bg2, (*citr)->Team);
  783. +               //start bg
  784. +               bg2->StartBattleground();
  785. +           }
  786. +            //clear structures
  787. +            m_SelectionPools[BG_TEAM_ALLIANCE].Init();
  788. +            m_SelectionPools[BG_TEAM_HORDE].Init();
  789. +       }
  790.      }
  791.  
  792.      // now check if there are in queues enough players to start new game of (normal battleground, or non-rated arena)
  793. @@ -874,6 +1131,50 @@ void BattlegroundQueue::Update(BattlegroundTypeId bgTypeId, BattlegroundBracketI
  794.                      InviteGroupToBG((*citr), bg2, (*citr)->Team);
  795.              // start bg
  796.              bg2->StartBattleground();
  797. +           //clear structures
  798. +            m_SelectionPools[BG_TEAM_ALLIANCE].Init();
  799. +            m_SelectionPools[BG_TEAM_HORDE].Init();
  800. +        }
  801. +       if (CheckNormalMatch(bg_template, bracket_id, MinPlayersPerTeam, MaxPlayersPerTeam, true) && bg_template->isBattleground())
  802. +        {
  803. +           uint32 guildId1 = 0;
  804. +           uint32 guildId2 = 0;
  805. +           bool check = true;
  806. +           for (GroupsQueueType::const_iterator citr = m_SelectionPools[BG_TEAM_ALLIANCE].SelectedGroups.begin(); citr != m_SelectionPools[BG_TEAM_ALLIANCE].SelectedGroups.end(); ++citr)
  807. +           {
  808. +               if (guildId1 > 0 && guildId1 != (*citr)->guildId)
  809. +               {
  810. +                   check = false;
  811. +                   break;
  812. +               }
  813. +               guildId1 = (*citr)->guildId;
  814. +           }
  815. +           for (GroupsQueueType::const_iterator citr = m_SelectionPools[BG_TEAM_HORDE].SelectedGroups.begin(); citr != m_SelectionPools[BG_TEAM_HORDE].SelectedGroups.end(); ++citr)
  816. +           {
  817. +               if (guildId2 > 0 && guildId2 != (*citr)->guildId)
  818. +               {
  819. +                   check = false;
  820. +                   break;
  821. +               }
  822. +               guildId2 = (*citr)->guildId;
  823. +           }
  824. +           if (guildId1 > 0 || guildId2 > 0 && check)
  825. +           {
  826. +               // we successfully created a pool
  827. +               Battleground* bg2 = sBattlegroundMgr->CreateNewBattleground(bgTypeId, bracketEntry, arenaType, false, guildId1, guildId2);
  828. +               if (!bg2)
  829. +               {
  830. +                   TC_LOG_ERROR("BattlegroundQueue::Update - Cannot create battleground: %u", bgTypeId);
  831. +                   return;
  832. +               }
  833. +
  834. +               // invite those selection pools
  835. +               for (uint32 i = 0; i < BG_TEAMS_COUNT; i++)
  836. +                   for (GroupsQueueType::const_iterator citr = m_SelectionPools[BG_TEAM_ALLIANCE + i].SelectedGroups.begin(); citr != m_SelectionPools[BG_TEAM_ALLIANCE + i].SelectedGroups.end(); ++citr)
  837. +                       InviteGroupToBG((*citr), bg2, (*citr)->Team);
  838. +               // start bg
  839. +               bg2->StartBattleground();
  840. +           }
  841.          }
  842.      }
  843.      else if (bg_template->isArena())
  844. @@ -881,18 +1182,18 @@ void BattlegroundQueue::Update(BattlegroundTypeId bgTypeId, BattlegroundBracketI
  845.          // found out the minimum and maximum ratings the newly added team should battle against
  846.          // arenaRating is the rating of the latest joined team, or 0
  847.          // 0 is on (automatic update call) and we must set it to team's with longest wait time
  848. +       GroupQueueInfo* front1 = NULL;
  849. +        GroupQueueInfo* front2 = NULL;
  850.          if (!arenaRating)
  851.          {
  852. -            GroupQueueInfo* front1 = NULL;
  853. -            GroupQueueInfo* front2 = NULL;
  854. -            if (!m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].empty())
  855. +            if (!m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_NOT_GUILD].empty())
  856.              {
  857. -                front1 = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].front();
  858. +                front1 = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_NOT_GUILD].front();
  859.                  arenaRating = front1->ArenaMatchmakerRating;
  860.              }
  861. -            if (!m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].empty())
  862. +            if (!m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_NOT_GUILD].empty())
  863.              {
  864. -                front2 = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].front();
  865. +                front2 = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_NOT_GUILD].front();
  866.                  arenaRating = front2->ArenaMatchmakerRating;
  867.              }
  868.              if (front1 && front2)
  869. @@ -922,8 +1223,8 @@ void BattlegroundQueue::Update(BattlegroundTypeId bgTypeId, BattlegroundBracketI
  870.          for (uint32 i = BG_QUEUE_PREMADE_ALLIANCE; i < BG_QUEUE_NORMAL_ALLIANCE; i++)
  871.          {
  872.              // take the group that joined first
  873. -            itr_team[i] = m_QueuedGroups[bracket_id][i].begin();
  874. -            for (; itr_team[i] != m_QueuedGroups[bracket_id][i].end(); ++(itr_team[i]))
  875. +            itr_team[i] = m_QueuedGroups[bracket_id][i][BG_QUEUE_NOT_GUILD].begin();
  876. +            for (; itr_team[i] != m_QueuedGroups[bracket_id][i][BG_QUEUE_NOT_GUILD].end(); ++(itr_team[i]))
  877.              {
  878.                  // if group match conditions, then add it to pool
  879.                  if (!(*itr_team[i])->IsInvitedToBGInstanceGUID
  880. @@ -944,7 +1245,7 @@ void BattlegroundQueue::Update(BattlegroundTypeId bgTypeId, BattlegroundBracketI
  881.          {
  882.              itr_team[BG_TEAM_ALLIANCE] = itr_team[BG_TEAM_HORDE];
  883.              ++itr_team[BG_TEAM_ALLIANCE];
  884. -            for (; itr_team[BG_TEAM_ALLIANCE] != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].end(); ++(itr_team[BG_TEAM_ALLIANCE]))
  885. +            for (; itr_team[BG_TEAM_ALLIANCE] != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_NOT_GUILD].end(); ++(itr_team[BG_TEAM_ALLIANCE]))
  886.              {
  887.                  if (!(*itr_team[BG_TEAM_ALLIANCE])->IsInvitedToBGInstanceGUID
  888.                      && (((*itr_team[BG_TEAM_ALLIANCE])->ArenaMatchmakerRating >= arenaMinRating && (*itr_team[BG_TEAM_ALLIANCE])->ArenaMatchmakerRating <= arenaMaxRating)
  889. @@ -960,7 +1261,7 @@ void BattlegroundQueue::Update(BattlegroundTypeId bgTypeId, BattlegroundBracketI
  890.          {
  891.              itr_team[BG_TEAM_HORDE] = itr_team[BG_TEAM_ALLIANCE];
  892.              ++itr_team[BG_TEAM_HORDE];
  893. -            for (; itr_team[BG_TEAM_HORDE] != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].end(); ++(itr_team[BG_TEAM_HORDE]))
  894. +            for (; itr_team[BG_TEAM_HORDE] != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_NOT_GUILD].end(); ++(itr_team[BG_TEAM_HORDE]))
  895.              {
  896.                  if (!(*itr_team[BG_TEAM_HORDE])->IsInvitedToBGInstanceGUID
  897.                      && (((*itr_team[BG_TEAM_HORDE])->ArenaMatchmakerRating >= arenaMinRating && (*itr_team[BG_TEAM_HORDE])->ArenaMatchmakerRating <= arenaMaxRating)
  898. @@ -992,16 +1293,16 @@ void BattlegroundQueue::Update(BattlegroundTypeId bgTypeId, BattlegroundBracketI
  899.              if ((*(itr_team[BG_TEAM_ALLIANCE]))->Team != ALLIANCE)
  900.              {
  901.                  // add to alliance queue
  902. -                m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].push_front(*(itr_team[BG_TEAM_ALLIANCE]));
  903. +                m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_NOT_GUILD].push_front(*(itr_team[BG_TEAM_ALLIANCE]));
  904.                  // erase from horde queue
  905. -                m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].erase(itr_team[BG_TEAM_ALLIANCE]);
  906. -                itr_team[BG_TEAM_ALLIANCE] = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].begin();
  907. +                m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_NOT_GUILD].erase(itr_team[BG_TEAM_ALLIANCE]);
  908. +                itr_team[BG_TEAM_ALLIANCE] = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_NOT_GUILD].begin();
  909.              }
  910.              if ((*(itr_team[BG_TEAM_HORDE]))->Team != HORDE)
  911.              {
  912. -                m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].push_front(*(itr_team[BG_TEAM_HORDE]));
  913. -                m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].erase(itr_team[BG_TEAM_HORDE]);
  914. -                itr_team[BG_TEAM_HORDE] = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].begin();
  915. +                m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_NOT_GUILD].push_front(*(itr_team[BG_TEAM_HORDE]));
  916. +                m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE][BG_QUEUE_NOT_GUILD].erase(itr_team[BG_TEAM_HORDE]);
  917. +                itr_team[BG_TEAM_HORDE] = m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE][BG_QUEUE_NOT_GUILD].begin();
  918.              }
  919.  
  920.              arena->SetArenaMatchmakerRating(ALLIANCE, (*(itr_team[BG_TEAM_ALLIANCE]))->ArenaMatchmakerRating);
  921.  
  922. -------------- src/server/game/Battlegrounds/BattlegroundQueue.h --------------
  923. index bcf366b..e7f0751 100755
  924. @@ -51,6 +51,7 @@ struct GroupQueueInfo                                       // stores informatio
  925.      uint32  ArenaMatchmakerRating;                          // if rated match, inited to the rating of the team
  926.      uint32  OpponentsTeamRating;                            // for rated arena matches
  927.      uint32  OpponentsMatchmakerRating;                      // for rated arena matches
  928. +   uint32  guildId;                                         // guildId for GuildvsGuild
  929.  };
  930.  
  931.  enum BattlegroundQueueGroupTypes
  932. @@ -58,10 +59,17 @@ enum BattlegroundQueueGroupTypes
  933.      BG_QUEUE_PREMADE_ALLIANCE   = 0,
  934.      BG_QUEUE_PREMADE_HORDE      = 1,
  935.      BG_QUEUE_NORMAL_ALLIANCE    = 2,
  936. -    BG_QUEUE_NORMAL_HORDE       = 3
  937. +    BG_QUEUE_NORMAL_HORDE       = 3,
  938.  };
  939.  #define BG_QUEUE_GROUP_TYPES_COUNT 4
  940.  
  941. +enum BattlegroundQueueGuildTypes
  942. +{
  943. +    BG_QUEUE_GUILD              = 0,
  944. +    BG_QUEUE_NOT_GUILD          = 1
  945. +};
  946. +#define BG_QUEUE_GROUP_TYPES_GUILD 2
  947. +
  948.  class Battleground;
  949.  class BattlegroundQueue
  950.  {
  951. @@ -71,11 +79,11 @@ class BattlegroundQueue
  952.  
  953.          void Update(BattlegroundTypeId bgTypeId, BattlegroundBracketId bracket_id, uint8 arenaType = 0, bool isRated = false, uint32 minRating = 0);
  954.  
  955. -        void FillPlayersToBG(Battleground* bg, BattlegroundBracketId bracket_id);
  956. -        bool CheckPremadeMatch(BattlegroundBracketId bracket_id, uint32 MinPlayersPerTeam, uint32 MaxPlayersPerTeam);
  957. -        bool CheckNormalMatch(Battleground* bg_template, BattlegroundBracketId bracket_id, uint32 minPlayers, uint32 maxPlayers);
  958. +        void FillPlayersToBG(Battleground* bg, BattlegroundBracketId bracket_id, bool GuildvsGuild);
  959. +        bool CheckPremadeMatch(BattlegroundBracketId bracket_id, uint32 MinPlayersPerTeam, uint32 MaxPlayersPerTeam, bool GuildvsGuild = false);
  960. +        bool CheckNormalMatch(Battleground* bg_template, BattlegroundBracketId bracket_id, uint32 minPlayers, uint32 maxPlayers, bool GuildvsGuild = false);
  961.          bool CheckSkirmishForSameFaction(BattlegroundBracketId bracket_id, uint32 minPlayersPerTeam);
  962. -        GroupQueueInfo * AddGroup(Player* leader, Group* group, BattlegroundTypeId bgTypeId, PvPDifficultyEntry const*  bracketEntry, uint8 ArenaType, bool isRated, bool isPremade, uint32 ArenaRating, uint32 MatchmakerRating, uint32 ArenaTeamId = 0);
  963. +        GroupQueueInfo * AddGroup(Player* leader, Group* group, BattlegroundTypeId bgTypeId, PvPDifficultyEntry const*  bracketEntry, uint8 ArenaType, bool isRated, bool isPremade, uint32 ArenaRating, uint32 MatchmakerRating, uint32 ArenaTeamId = 0, uint32 guildId = 0);
  964.          void RemovePlayer(const uint64& guid, bool decreaseInvitedCount);
  965.          bool IsPlayerInvited(const uint64& pl_guid, const uint32 bgInstanceGuid, const uint32 removeTime);
  966.          bool GetPlayerGroupInfoData(const uint64& guid, GroupQueueInfo* ginfo);
  967. @@ -97,7 +105,7 @@ class BattlegroundQueue
  968.               BG_QUEUE_NORMAL_ALLIANCE   is used for normal (or small) alliance groups or non-rated arena matches
  969.               BG_QUEUE_NORMAL_HORDE      is used for normal (or small) horde groups or non-rated arena matches
  970.          */
  971. -        GroupsQueueType m_QueuedGroups[MAX_BATTLEGROUND_BRACKETS][BG_QUEUE_GROUP_TYPES_COUNT];
  972. +        GroupsQueueType m_QueuedGroups[MAX_BATTLEGROUND_BRACKETS][BG_QUEUE_GROUP_TYPES_COUNT][BG_QUEUE_GROUP_TYPES_GUILD];
  973.  
  974.          // class to select and invite groups to bg
  975.          class SelectionPool
  976.  
  977. ------------------------ src/server/game/CMakeLists.txt ------------------------
  978. index 65ba160..07b45eb 100644
  979. @@ -30,6 +30,7 @@ file(GLOB_RECURSE sources_Globals Globals/*.cpp Globals/*.h)
  980.  file(GLOB_RECURSE sources_Grids Grids/*.cpp Grids/*.h)
  981.  file(GLOB_RECURSE sources_Groups Groups/*.cpp Groups/*.h)
  982.  file(GLOB_RECURSE sources_Guilds Guilds/*.cpp Guilds/*.h)
  983. +file(GLOB_RECURSE sources_GuildvsGuild GuildvsGuild/*.cpp GuildvsGuild/*.h)
  984.  file(GLOB_RECURSE sources_Instances Instances/*.cpp Instances/*.h)
  985.  file(GLOB_RECURSE sources_Loot Loot/*.cpp Loot/*.h)
  986.  file(GLOB_RECURSE sources_Mails Mails/*.cpp Mails/*.h)
  987. @@ -79,6 +80,7 @@ set(game_STAT_SRCS
  988.    ${sources_Grids}
  989.    ${sources_Groups}
  990.    ${sources_Guilds}
  991. +  ${sources_GuildvsGuild}
  992.    ${sources_Instances}
  993.    ${sources_Loot}
  994.    ${sources_Mails}
  995. @@ -164,6 +166,7 @@ include_directories(
  996.    ${CMAKE_CURRENT_SOURCE_DIR}/Grids
  997.    ${CMAKE_CURRENT_SOURCE_DIR}/Groups
  998.    ${CMAKE_CURRENT_SOURCE_DIR}/Guilds
  999. +  ${CMAKE_CURRENT_SOURCE_DIR}/GuildvsGuild
  1000.    ${CMAKE_CURRENT_SOURCE_DIR}/Instances
  1001.    ${CMAKE_CURRENT_SOURCE_DIR}/Loot
  1002.    ${CMAKE_CURRENT_SOURCE_DIR}/Mails
  1003.  
  1004. ------------------ src/server/game/Entities/Player/Player.cpp ------------------
  1005. index eea6159..05e95c8 100755
  1006. @@ -16577,7 +16577,14 @@ bool Player::LoadFromDB(uint32 guid, SQLQueryHolder *holder)
  1007.          if (player_at_bg && currentBg->GetStatus() != STATUS_WAIT_LEAVE)
  1008.          {
  1009.              BattlegroundQueueTypeId bgQueueTypeId = sBattlegroundMgr->BGQueueTypeId(currentBg->GetTypeID(true), currentBg->GetArenaType());
  1010. -            AddBattlegroundQueueId(bgQueueTypeId);
  1011. +            if (currentBg->IsGuildvsGuild())
  1012. +           {
  1013. +               AddBattlegroundQueueId(bgQueueTypeId, true);
  1014. +           }
  1015. +           else
  1016. +           {
  1017. +               AddBattlegroundQueueId(bgQueueTypeId, false);
  1018. +           }
  1019.  
  1020.              m_bgData.bgTypeID = currentBg->GetTypeID(true);
  1021.  
  1022. @@ -24672,3 +24679,4 @@ void Player::_SaveInstanceTimeRestrictions(SQLTransaction& trans)
  1023.          trans->Append(stmt);
  1024.      }
  1025.  }
  1026. +
  1027.  
  1028. ------------------- src/server/game/Entities/Player/Player.h -------------------
  1029. index 6ba3af8..d4c69a4 100755
  1030. @@ -2134,7 +2134,7 @@ class Player : public Unit, public GridObject<Player>
  1031.              m_bgData.bgInstanceID = val;
  1032.              m_bgData.bgTypeID = bgTypeId;
  1033.          }
  1034. -        uint32 AddBattlegroundQueueId(BattlegroundQueueTypeId val)
  1035. +        uint32 AddBattlegroundQueueId(BattlegroundQueueTypeId val, bool GuildvsGuild)
  1036.          {
  1037.              for (uint8 i=0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; ++i)
  1038.              {
  1039. @@ -2142,6 +2142,7 @@ class Player : public Unit, public GridObject<Player>
  1040.                  {
  1041.                      m_bgBattlegroundQueueID[i].bgQueueTypeId = val;
  1042.                      m_bgBattlegroundQueueID[i].invitedToInstance = 0;
  1043. +                   m_bgBattlegroundQueueID[i].GuildvsGuild = GuildvsGuild;
  1044.                      return i;
  1045.                  }
  1046.              }
  1047. @@ -2442,7 +2443,6 @@ class Player : public Unit, public GridObject<Player>
  1048.  
  1049.          float GetAverageItemLevel();
  1050.          bool isDebugAreaTriggers;
  1051. -
  1052.      protected:
  1053.          uint32 m_regenTimerCount;
  1054.          float m_powerFraction[MAX_POWERS];
  1055. @@ -2459,6 +2459,7 @@ class Player : public Unit, public GridObject<Player>
  1056.          {
  1057.              BattlegroundQueueTypeId bgQueueTypeId;
  1058.              uint32 invitedToInstance;
  1059. +           bool GuildvsGuild;
  1060.          };
  1061.  
  1062.          BgBattlegroundQueueID_Rec m_bgBattlegroundQueueID[PLAYER_MAX_BATTLEGROUND_QUEUES];
  1063.  
  1064. --------------- src/server/game/GuildvsGuild/GuildvsGuildMgr.cpp ---------------
  1065. new file mode 100644
  1066. index 0000000..ce65b1e
  1067. @@ -0,0 +1,162 @@
  1068. +#include "GuildvsGuildMgr.h"
  1069. +#include "BattlegroundMgr.h"
  1070. +#include "Chat.h"
  1071. +#include "GuildMgr.h"
  1072. +#include "DisableMgr.h"
  1073. +#include "Group.h"
  1074. +
  1075. +GuildvsGuildMgr::GuildvsGuildMgr()
  1076. +{
  1077. +}
  1078. +
  1079. +GuildvsGuildMgr::~GuildvsGuildMgr()
  1080. +{
  1081. +}
  1082. +
  1083. +void GuildvsGuildMgr::BattlegroundGuildvsGuild(BattlegroundTypeId bgTypeId, Player* player, bool isGrp)
  1084. +{
  1085. +   if (!player)
  1086. +       return;
  1087. +
  1088. +   Group * grp = NULL;
  1089. +
  1090. +   BattlegroundQueueTypeId bgQueueTypeId = BattlegroundMgr::BGQueueTypeId(bgTypeId, 0);
  1091. +   bool isPremade = false;
  1092. +
  1093. +   if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_BATTLEGROUND, bgTypeId, NULL))
  1094. +    {
  1095. +        ChatHandler(player).PSendSysMessage(LANG_BG_DISABLED);
  1096. +        return;
  1097. +    }
  1098. +
  1099. +   // get bg template
  1100. +    Battleground *bg = NULL;
  1101. +   bg = sBattlegroundMgr->GetBattlegroundTemplate(bgTypeId);
  1102. +   if (!bg)
  1103. +       return;
  1104. +
  1105. +   PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(bg->GetMapId(), player->getLevel());
  1106. +    if (!bracketEntry)
  1107. +        return;
  1108. +
  1109. +   GroupJoinBattlegroundResult err;
  1110. +
  1111. +   uint32 guildId;
  1112. +   guildId = player->GetGuildId();
  1113. +   Guild* pGuild = sGuildMgr->GetGuildById(guildId);
  1114. +   if (!pGuild)
  1115. +   {
  1116. +       ChatHandler(player).PSendSysMessage(LANG_GUILD_NOT_CREATED);
  1117. +        return;
  1118. +    }
  1119. +
  1120. +   // ignore if player is already in BG
  1121. +    if (player->InBattleground())
  1122. +        return;
  1123. +
  1124. +   if (!isGrp)
  1125. +   {
  1126. +       if (player->isUsingLfg())
  1127. +       {
  1128. +           // player is using dungeon finder or raid finder
  1129. +           WorldPacket data;
  1130. +           sBattlegroundMgr->BuildGroupJoinedBattlegroundPacket(&data, ERR_LFG_CANT_USE_BATTLEGROUND);
  1131. +           player->GetSession()->SendPacket(&data);
  1132. +           return;
  1133. +       }
  1134. +
  1135. +       // check Deserter debuff
  1136. +       if (!player->CanJoinToBattleground())
  1137. +       {
  1138. +           WorldPacket data;
  1139. +           sBattlegroundMgr->BuildGroupJoinedBattlegroundPacket(&data, ERR_GROUP_JOIN_BATTLEGROUND_DESERTERS);
  1140. +           player->GetSession()->SendPacket(&data);
  1141. +           return;
  1142. +       }
  1143. +
  1144. +       // check if already in queue
  1145. +       if (player->GetBattlegroundQueueIndex(bgQueueTypeId) < PLAYER_MAX_BATTLEGROUND_QUEUES)
  1146. +           //player is already in this queue
  1147. +           return;
  1148. +
  1149. +       // check if has free queue slots
  1150. +       if (!player->HasFreeBattlegroundQueueId())
  1151. +       {
  1152. +           WorldPacket data;
  1153. +           sBattlegroundMgr->BuildGroupJoinedBattlegroundPacket(&data, ERR_BATTLEGROUND_TOO_MANY_QUEUES);
  1154. +           player->GetSession()->SendPacket(&data);
  1155. +           return;
  1156. +       }
  1157. +       BattlegroundQueue& bgQueue = sBattlegroundMgr->m_BattlegroundQueues[bgQueueTypeId];
  1158. +       GroupQueueInfo * ginfo = bgQueue.AddGroup(player, NULL, bgTypeId, bracketEntry, 0, false, isPremade, 0, 0, 0, player->GetGuildId());
  1159. +       uint32 avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry->GetBracketId());
  1160. +       // already checked if queueSlot is valid, now just get it
  1161. +       uint32 queueSlot = player->AddBattlegroundQueueId(bgQueueTypeId, true);
  1162. +
  1163. +       WorldPacket data;
  1164. +                                                            // send status packet (in queue)
  1165. +       sBattlegroundMgr->BuildBattlegroundStatusPacket(&data, bg, queueSlot, STATUS_WAIT_QUEUE, avgTime, 0, ginfo->ArenaType);
  1166. +       player->GetSession()->SendPacket(&data);
  1167. +       TC_LOG_DEBUG(worldserver, "Battleground: player joined queue for bg queue type %u bg type %u: GUID %u, NAME %s", bgQueueTypeId, bgTypeId, player->GetGUIDLow(), player->GetName());
  1168. +   }
  1169. +   else
  1170. +   {
  1171. +       grp = player->GetGroup();
  1172. +        // no group found, error
  1173. +        if (!grp)
  1174. +            return;
  1175. +        if (grp->GetLeaderGUID() != player->GetGUID())
  1176. +            return;
  1177. +       for (GroupReference *itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
  1178. +        {
  1179. +            Player *member = itr->getSource();
  1180. +            if (!member)
  1181. +               continue;   // this should never happen
  1182. +
  1183. +           if (player->GetGuildId() != member->GetGuildId())
  1184. +           {
  1185. +               ChatHandler(member).PSendSysMessage(LANG_GUILD_NOT_CREATED);
  1186. +               return;
  1187. +           }
  1188. +       }
  1189. +       err = grp->CanJoinBattlegroundQueue(bg, bgQueueTypeId, 0, bg->GetMaxPlayersPerTeam(), false, 0);
  1190. +        isPremade = (grp->GetMembersCount() >= bg->GetMinPlayersPerTeam());
  1191. +        BattlegroundQueue& bgQueue = sBattlegroundMgr->m_BattlegroundQueues[bgQueueTypeId];
  1192. +        GroupQueueInfo * ginfo = NULL;
  1193. +        uint32 avgTime = 0;
  1194. +
  1195. +        if (err > 0)
  1196. +        {
  1197. +            TC_LOG_INFO(worldserver, "Battleground: the following players are joining as group:");
  1198. +            ginfo = bgQueue.AddGroup(player, grp, bgTypeId, bracketEntry, 0, false, isPremade, 0, 0, 0, player->GetGuildId());
  1199. +            avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry->GetBracketId());
  1200. +        }
  1201. +
  1202. +        for (GroupReference *itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
  1203. +        {
  1204. +            Player *member = itr->getSource();
  1205. +            if (!member)
  1206. +               continue;   // this should never happen
  1207. +
  1208. +            WorldPacket data;
  1209. +
  1210. +            if (err <= 0)
  1211. +            {
  1212. +                sBattlegroundMgr->BuildGroupJoinedBattlegroundPacket(&data, err);
  1213. +                member->GetSession()->SendPacket(&data);
  1214. +                continue;
  1215. +            }
  1216. +
  1217. +            // add to queue
  1218. +            uint32 queueSlot = member->AddBattlegroundQueueId(bgQueueTypeId, false);
  1219. +            // send status packet (in queue)
  1220. +            sBattlegroundMgr->BuildBattlegroundStatusPacket(&data, bg, queueSlot, STATUS_WAIT_QUEUE, avgTime, 0, ginfo->ArenaType);
  1221. +            member->GetSession()->SendPacket(&data);
  1222. +            sBattlegroundMgr->BuildGroupJoinedBattlegroundPacket(&data, err);
  1223. +            member->GetSession()->SendPacket(&data);
  1224. +            TC_LOG_INFO(worldserver, "Battleground: player joined queue for bg queue type %u bg type %u: GUID %u, NAME %s", bgQueueTypeId, bgTypeId, member->GetGUIDLow(), member->GetName());
  1225. +        }
  1226. +        TC_LOG_INFO(worldserver, "Battleground: group end");
  1227. +   }
  1228. +   sBattlegroundMgr->ScheduleQueueUpdate(0, 0, bgQueueTypeId, bgTypeId, bracketEntry->GetBracketId());
  1229. +}
  1230.  
  1231. ---------------- src/server/game/GuildvsGuild/GuildvsGuildMgr.h ----------------
  1232. new file mode 100644
  1233. index 0000000..47d9d70
  1234. @@ -0,0 +1,17 @@
  1235. +#ifndef __GUILDVSGUILD_H
  1236. +#define __GUILDVSGUILD_H
  1237. +
  1238. +class GuildvsGuildMgr
  1239. +{
  1240. +   /* Construction */
  1241. +    friend class ACE_Singleton<GuildvsGuildMgr, ACE_Null_Mutex>;
  1242. +    GuildvsGuildMgr();
  1243. +
  1244. +    public:
  1245. +        ~GuildvsGuildMgr();
  1246. +
  1247. +       void BattlegroundGuildvsGuild(BattlegroundTypeId bgTypeId, Player* player, bool isGrp);
  1248. +};
  1249. +
  1250. +#define sGuildvsGuildMgr ACE_Singleton<GuildvsGuildMgr, ACE_Null_Mutex>::instance()
  1251. +#endif
  1252. \ No newline at end of file
  1253.  
  1254. ------------------ src/server/game/Scripting/ScriptLoader.cpp ------------------
  1255. index 5149308..056c0fb 100755
  1256. @@ -24,6 +24,9 @@ void AddSC_example_gossip_codebox();
  1257.  void AddSC_example_misc();
  1258.  void AddSC_example_commandscript();
  1259.  
  1260. +//custom
  1261. +void AddSC_battlemaster_guildvsguild();
  1262. +
  1263.  // spells
  1264.  void AddSC_deathknight_spell_scripts();
  1265.  void AddSC_druid_spell_scripts();
  1266. @@ -1220,15 +1223,7 @@ void AddBattlegroundScripts()
  1267.  #endif
  1268.  }
  1269.  
  1270. -#ifdef SCRIPTS
  1271. -/* This is where custom scripts' loading functions should be declared. */
  1272. -
  1273. -#endif
  1274. -
  1275.  void AddCustomScripts()
  1276.  {
  1277. -#ifdef SCRIPTS
  1278. -    /* This is where custom scripts should be added. */
  1279. -
  1280. -#endif
  1281. +   AddSC_battlemaster_guildvsguild();
  1282.  }
  1283.  
  1284. ------- src/server/game/Server/Protocol/Handlers/BattleGroundHandler.cpp -------
  1285. index 59c4911..06e7224 100755
  1286. @@ -184,7 +184,7 @@ void WorldSession::HandleBattlemasterJoinOpcode(WorldPacket & recv_data)
  1287.          GroupQueueInfo * ginfo = bgQueue.AddGroup(_player, NULL, bgTypeId, bracketEntry, 0, false, isPremade, 0, 0);
  1288.          uint32 avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry->GetBracketId());
  1289.          // already checked if queueSlot is valid, now just get it
  1290. -        uint32 queueSlot = _player->AddBattlegroundQueueId(bgQueueTypeId);
  1291. +        uint32 queueSlot = _player->AddBattlegroundQueueId(bgQueueTypeId, false);
  1292.  
  1293.          WorldPacket data;
  1294.                                                              // send status packet (in queue)
  1295. @@ -229,7 +229,7 @@ void WorldSession::HandleBattlemasterJoinOpcode(WorldPacket & recv_data)
  1296.              }
  1297.  
  1298.              // add to queue
  1299. -            uint32 queueSlot = member->AddBattlegroundQueueId(bgQueueTypeId);
  1300. +            uint32 queueSlot = member->AddBattlegroundQueueId(bgQueueTypeId, false);
  1301.  
  1302.              // send status packet (in queue)
  1303.              sBattlegroundMgr->BuildBattlegroundStatusPacket(&data, bg, queueSlot, STATUS_WAIT_QUEUE, avgTime, 0, ginfo->ArenaType);
  1304. @@ -770,7 +770,7 @@ void WorldSession::HandleBattlemasterJoinArena(WorldPacket & recv_data)
  1305.              }
  1306.  
  1307.              // add to queue
  1308. -            uint32 queueSlot = member->AddBattlegroundQueueId(bgQueueTypeId);
  1309. +            uint32 queueSlot = member->AddBattlegroundQueueId(bgQueueTypeId, false);
  1310.  
  1311.              // send status packet (in queue)
  1312.              sBattlegroundMgr->BuildBattlegroundStatusPacket(&data, bg, queueSlot, STATUS_WAIT_QUEUE, avgTime, 0, arenatype);
  1313. @@ -784,7 +784,7 @@ void WorldSession::HandleBattlemasterJoinArena(WorldPacket & recv_data)
  1314.      {
  1315.          GroupQueueInfo * ginfo = bgQueue.AddGroup(_player, NULL, bgTypeId, bracketEntry, arenatype, isRated, false, arenaRating, matchmakerRating, ateamId);
  1316.          uint32 avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry->GetBracketId());
  1317. -        uint32 queueSlot = _player->AddBattlegroundQueueId(bgQueueTypeId);
  1318. +        uint32 queueSlot = _player->AddBattlegroundQueueId(bgQueueTypeId, false);
  1319.  
  1320.          WorldPacket data;
  1321.          // send status packet (in queue)
  1322.  
  1323. ------------------- src/server/scripts/Custom/CMakeLists.txt -------------------
  1324. index 1570ca1..412608b 100644
  1325. @@ -10,6 +10,7 @@
  1326.  
  1327.  set(scripts_STAT_SRCS
  1328.    ${scripts_STAT_SRCS}
  1329. +  Custom/GuildvsGuild.cpp
  1330.  )
  1331.  
  1332.  message("  -> Prepared: Custom")
  1333.  
  1334. ------------------ src/server/scripts/Custom/GuildvsGuild.cpp ------------------
  1335. new file mode 100644
  1336. index 0000000..f58a63c
  1337. @@ -0,0 +1,79 @@
  1338. +#include "ScriptPCH.h"
  1339. +#include "../../game/GuildvsGuild/GuildvsGuildMgr.h"
  1340. +#include <cstring>
  1341. +
  1342. +#define GOSSIP_ITEM_1       "Bassin Arathi"
  1343. +#define GOSSIP_ITEM_2       "Goulet des Chanteguerres"
  1344. +#define GOSSIP_ITEM_3       "Goulet des Chanteguerres (groupe)"
  1345. +#define GOSSIP_ITEM_4       "Goulet des Chanteguerres (groupe)"
  1346. +
  1347. +class battlemaster_guildvsguild : public CreatureScript
  1348. +{
  1349. +    public:
  1350. +
  1351. +        battlemaster_guildvsguild()
  1352. +            : CreatureScript("battlemaster_guildvsguild")
  1353. +        {
  1354. +        }
  1355. +
  1356. +        bool OnGossipHello(Player* player, Creature* creature)
  1357. +        {
  1358. +           if (player->isInCombat())
  1359. +           {
  1360. +               player->CLOSE_GOSSIP_MENU();
  1361. +               creature->MonsterWhisper("Combat!", player->GetGUID());
  1362. +               return true;
  1363. +           }
  1364. +
  1365. +           player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_1, GOSSIP_SENDER_MAIN, 1);
  1366. +           player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_2, GOSSIP_SENDER_MAIN, 2);
  1367. +           player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_3, GOSSIP_SENDER_MAIN, 3);
  1368. +           player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_4, GOSSIP_SENDER_MAIN, 4);
  1369. +
  1370. +            player->PlayerTalkClass->SendGossipMenu(DEFAULT_GOSSIP_MESSAGE, creature->GetGUID());
  1371. +            return true;
  1372. +        }
  1373. +
  1374. +        bool OnGossipSelect(Player* player, Creature* creature, uint32 /*uiSender*/, uint32 uiAction)
  1375. +        {
  1376. +           BattlegroundTypeId choice;
  1377. +           bool isGrp;
  1378. +            player->PlayerTalkClass->ClearMenus();
  1379. +           if (player->isInCombat())
  1380. +           {
  1381. +               player->CLOSE_GOSSIP_MENU();
  1382. +               creature->MonsterWhisper("Combat!", player->GetGUID());
  1383. +               return true;
  1384. +           }
  1385. +           switch (uiAction)
  1386. +           {
  1387. +               case 1:
  1388. +                   choice = BATTLEGROUND_AB;
  1389. +                   isGrp = false;
  1390. +                   break;
  1391. +               case 2:
  1392. +                   choice = BATTLEGROUND_WS;
  1393. +                   isGrp = false;
  1394. +                   break;
  1395. +               case 3:
  1396. +                   choice = BATTLEGROUND_AB;
  1397. +                   isGrp = true;
  1398. +                   break;
  1399. +               case 4:
  1400. +                   choice = BATTLEGROUND_WS;
  1401. +                   isGrp = true;
  1402. +                   break;
  1403. +               default:
  1404. +                   choice = BATTLEGROUND_TYPE_NONE;
  1405. +                   break;
  1406. +           }
  1407. +           sGuildvsGuildMgr->BattlegroundGuildvsGuild(choice, player, isGrp);
  1408. +           player->CLOSE_GOSSIP_MENU();
  1409. +           return true;
  1410. +        }
  1411. +};
  1412. +
  1413. +void AddSC_battlemaster_guildvsguild()
  1414. +{
  1415. +    new battlemaster_guildvsguild();
  1416. +}
  1417.  
  1418. ---- SQL stuff
  1419.  
  1420.  
  1421. DROP TABLE IF EXISTS `GuildvsGuild`;
  1422. CREATE TABLE `GuildvsGuild` (
  1423.   `id` int(10) unsigned NOT NULL,
  1424.   `win` int(10) unsigned NOT NULL DEFAULT '0',
  1425.   `total` bigint(20) unsigned NOT NULL DEFAULT '0',
  1426.   PRIMARY KEY (`id`)
  1427. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!