Add braces to all for statements in src/ (excluding submodules)

src/game/BattleGround/BattleGround.cpp

@@ -1530,10 +1530,12 @@ void BattleGround::StartBattleGround()
 void BattleGround::StartTimedAchievement(AchievementCriteriaTypes type, uint32 entry)
 {
     for (BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
+    {
         if (Player* pPlayer = GetBgMap()->GetPlayer(itr->first))
         {
             pPlayer->GetAchievementMgr().StartTimedAchievementCriteria(type, entry);
         }
+    }
 }
 
 /// <summary>

src/game/BattleGround/BattleGroundAB.cpp

@@ -140,10 +140,12 @@ void BattleGroundAB::Update(uint32 diff)
             }
 
             for (uint8 team = 0; team < PVP_TEAM_COUNT; ++team)
+            {
                 if (m_Nodes[node] == team + BG_AB_NODE_TYPE_OCCUPIED)
                 {
                     ++team_points[team];
                 }
+            }
         }
 
         // Accumulate points
@@ -379,14 +381,17 @@ void BattleGroundAB::FillInitialWorldStates(WorldPacket& data, uint32& count)
 
     // Node occupied states
     for (uint8 node = 0; node < BG_AB_NODES_MAX; ++node)
+    {
         for (uint8 i = 1; i < BG_AB_NODES_MAX; ++i)
         {
             FillInitialWorldState(data, count, BG_AB_OP_NODESTATES[node] + plusArray[i], m_Nodes[node] == i);
         }
+    }
 
     // How many bases each team owns
     uint8 ally = 0, horde = 0;
     for (uint8 node = 0; node < BG_AB_NODES_MAX; ++node)
+    {
         if (m_Nodes[node] == BG_AB_NODE_STATUS_ALLY_OCCUPIED)
         {
             ++ally;
@@ -395,6 +400,7 @@ void BattleGroundAB::FillInitialWorldStates(WorldPacket& data, uint32& count)
         {
             ++horde;
         }
+    }
 
     FillInitialWorldState(data, count, BG_AB_OP_OCCUPIED_BASES_ALLY, ally);
     FillInitialWorldState(data, count, BG_AB_OP_OCCUPIED_BASES_HORDE, horde);
@@ -432,6 +438,7 @@ void BattleGroundAB::_SendNodeUpdate(uint8 node)
     // How many bases each team owns
     uint8 ally = 0, horde = 0;
     for (uint8 i = 0; i < BG_AB_NODES_MAX; ++i)
+    {
         if (m_Nodes[i] == BG_AB_NODE_STATUS_ALLY_OCCUPIED)
         {
             ++ally;
@@ -440,6 +447,7 @@ void BattleGroundAB::_SendNodeUpdate(uint8 node)
         {
             ++horde;
         }
+    }
 
     UpdateWorldState(BG_AB_OP_OCCUPIED_BASES_ALLY, ally);
     UpdateWorldState(BG_AB_OP_OCCUPIED_BASES_HORDE, horde);
@@ -692,10 +700,12 @@ WorldSafeLocsEntry const* BattleGroundAB::GetClosestGraveYard(Player* player)
     // Is there any occupied node for this team?
     std::vector<uint8> nodes;
     for (uint8 i = 0; i < BG_AB_NODES_MAX; ++i)
+    {
         if (m_Nodes[i] == teamIndex + 3)
         {
             nodes.push_back(i);
         }
+    }
 
     WorldSafeLocsEntry const* good_entry = NULL;
     // If so, select the closest node to place ghost on
@@ -765,9 +775,11 @@ void BattleGroundAB::UpdatePlayerScore(Player* source, uint32 type, uint32 value
 bool BattleGroundAB::IsAllNodesControlledByTeam(Team team) const
 {
     for (uint8 i = 0; i < BG_AB_NODES_MAX; ++i)
+    {
         if ((team == ALLIANCE && m_Nodes[i] != BG_AB_NODE_STATUS_ALLY_OCCUPIED) ||
                 (team == HORDE && m_Nodes[i] != BG_AB_NODE_STATUS_HORDE_OCCUPIED))
             return false;
+    }
 
     return true;
 }

src/game/BattleGround/BattleGroundAV.cpp

@@ -193,10 +193,12 @@ void BattleGroundAV::HandleQuestComplete(uint32 questid, Player* player)
             {
                 DEBUG_LOG("BattleGroundAV: Quest %i completed starting with unit upgrading..", questid);
                 for (BG_AV_Nodes i = BG_AV_NODES_FIRSTAID_STATION; i <= BG_AV_NODES_FROSTWOLF_HUT; ++i)
+                {
                     if (m_Nodes[i].Owner == teamIdx && m_Nodes[i].State == POINT_CONTROLLED)
                     {
                         PopulateNode(i);
                     }
+                }
             }
             break;
         case BG_AV_QUEST_A_COMMANDER1:
@@ -450,30 +452,38 @@ void BattleGroundAV::EndBattleGround(Team winner)
     uint32 mines_owned[PVP_TEAM_COUNT]     = {0, 0};
     // towers all not destroyed:
     for (BG_AV_Nodes i = BG_AV_NODES_DUNBALDAR_SOUTH; i <= BG_AV_NODES_STONEHEART_BUNKER; ++i)
+    {
         if (m_Nodes[i].State == POINT_CONTROLLED)
             if (m_Nodes[i].TotalOwner == BG_AV_TEAM_ALLIANCE)
             {
                 ++tower_survived[TEAM_INDEX_ALLIANCE];
             }
+    }
     for (BG_AV_Nodes i = BG_AV_NODES_ICEBLOOD_TOWER; i <= BG_AV_NODES_FROSTWOLF_WTOWER; ++i)
+    {
         if (m_Nodes[i].State == POINT_CONTROLLED)
             if (m_Nodes[i].TotalOwner == BG_AV_TEAM_HORDE)
             {
                 ++tower_survived[TEAM_INDEX_HORDE];
             }
+    }
 
     // graves all controlled
     for (BG_AV_Nodes i = BG_AV_NODES_FIRSTAID_STATION; i < BG_AV_NODES_MAX; ++i)
+    {
         if (m_Nodes[i].State == POINT_CONTROLLED && m_Nodes[i].Owner != BG_AV_TEAM_NEUTRAL)
         {
             ++graves_owned[m_Nodes[i].Owner];
         }
+    }
 
     for (uint8 i = 0; i < BG_AV_MAX_MINES; ++i)
+    {
         if (m_Mine_Owner[i] != BG_AV_TEAM_NEUTRAL)
         {
             ++mines_owned[m_Mine_Owner[i]];
         }
+    }
 
     // now we have the values give the honor/reputation to the teams:
     Team team[PVP_TEAM_COUNT]      = { ALLIANCE, HORDE };

src/game/BattleGround/BattleGroundEY.cpp

@@ -663,10 +663,12 @@ WorldSafeLocsEntry const* BattleGroundEY::GetClosestGraveYard(Player* player)
 bool BattleGroundEY::IsAllNodesControlledByTeam(Team team) const
 {
     for (uint8 i = 0; i < EY_NODES_MAX; ++i)
+    {
         if (m_towerOwner[i] != team)
         {
             return false;
         }
+    }
 
     return true;
 }

src/game/BattleGround/BattleGroundMgr.cpp

@@ -311,15 +311,19 @@ GroupQueueInfo* BattleGroundQueue::AddGroup(Player* leader, Group* grp, BattleGr
                 uint32 q_max_level = bracketEntry->maxLevel;
                 GroupsQueueType::const_iterator itr;
                 for (itr = m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_ALLIANCE].begin(); itr != m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_ALLIANCE].end(); ++itr)
+                {
                     if (!(*itr)->IsInvitedToBGInstanceGUID)
                     {
                         qAlliance += (*itr)->Players.size();
                     }
+                }
                 for (itr = m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_HORDE].begin(); itr != m_QueuedGroups[bracketId][BG_QUEUE_NORMAL_HORDE].end(); ++itr)
+                {
                     if (!(*itr)->IsInvitedToBGInstanceGUID)
                     {
                         qHorde += (*itr)->Players.size();
                     }
+                }
 
                 // Show queue status to player only (when joining queue)
                 if (sWorld.getConfig(CONFIG_UINT32_BATTLEGROUND_QUEUE_ANNOUNCER_JOIN) == 1)
@@ -809,15 +813,19 @@ bool BattleGroundQueue::CheckPremadeMatch(BattleGroundBracketId bracket_id, uint
         // if groups aren't invited
         GroupsQueueType::const_iterator ali_group, horde_group;
         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)
+        {
             if (!(*ali_group)->IsInvitedToBGInstanceGUID)
             {
                 break;
             }
+        }
         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)
+        {
             if (!(*horde_group)->IsInvitedToBGInstanceGUID)
             {
                 break;
             }
+        }
 
         if (ali_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_ALLIANCE].end() && horde_group != m_QueuedGroups[bracket_id][BG_QUEUE_PREMADE_HORDE].end())
         {
@@ -1125,10 +1133,12 @@ void BattleGroundQueue::Update(BattleGroundTypeId bgTypeId, BattleGroundBracketI
             }
             // invite those selection pools
             for (uint8 i = 0; i < PVP_TEAM_COUNT; ++i)
+            {
                 for (GroupsQueueType::const_iterator citr = m_SelectionPools[TEAM_INDEX_ALLIANCE + i].SelectedGroups.begin(); citr != m_SelectionPools[TEAM_INDEX_ALLIANCE + i].SelectedGroups.end(); ++citr)
                 {
                     InviteGroupToBG((*citr), bg2, (*citr)->GroupTeam);
                 }
+            }
             // start bg
             bg2->StartBattleGround();
             // clear structures
@@ -1154,10 +1164,12 @@ void BattleGroundQueue::Update(BattleGroundTypeId bgTypeId, BattleGroundBracketI
 
             // invite those selection pools
             for (uint8 i = 0; i < PVP_TEAM_COUNT; ++i)
+            {
                 for (GroupsQueueType::const_iterator citr = m_SelectionPools[TEAM_INDEX_ALLIANCE + i].SelectedGroups.begin(); citr != m_SelectionPools[TEAM_INDEX_ALLIANCE + i].SelectedGroups.end(); ++citr)
                 {
                     InviteGroupToBG((*citr), bg2, (*citr)->GroupTeam);
                 }
+            }
             // start bg
             bg2->StartBattleGround();
         }

src/game/ChatCommands/AHBotCommands.cpp

@@ -156,11 +156,13 @@ bool ChatHandler::HandleAHBotStatusCommand(char* args)
         }
 
         for (int i = 0; i < MAX_AUCTION_QUALITY; ++i)
+        {
             PSendSysMessage(fmtId, GetMangosString(ahbotQualityIds[i]),
                             statusInfo[AUCTION_HOUSE_ALLIANCE].QualityInfo[i],
                             statusInfo[AUCTION_HOUSE_HORDE].QualityInfo[i],
                             statusInfo[AUCTION_HOUSE_NEUTRAL].QualityInfo[i],
                             sAuctionBotConfig.getConfigItemQualityAmount(AuctionQuality(i)));
+        }
     }
 
     if (!m_session)
@@ -181,10 +183,12 @@ bool ChatHandler::HandleAHBotItemsAmountCommand(char* args)
 {
     uint32 qVals[MAX_AUCTION_QUALITY];
     for (int i = 0; i < MAX_AUCTION_QUALITY; ++i)
+    {
         if (!ExtractUInt32(&args, qVals[i]))
         {
             return false;
         }
+    }
 
     sAuctionBot.SetItemsAmount(qVals);
 
@@ -242,10 +246,12 @@ bool ChatHandler::HandleAHBotItemsRatioCommand(char* args)
 {
     uint32 rVal[MAX_AUCTION_HOUSE_TYPE];
     for (int i = 0; i < MAX_AUCTION_HOUSE_TYPE; ++i)
+    {
         if (!ExtractUInt32(&args, rVal[i]))
         {
             return false;
         }
+    }
 
     sAuctionBot.SetItemsRatio(rVal[0], rVal[1], rVal[2]);
 

src/game/ChatCommands/GameObjectCommands.cpp

@@ -75,10 +75,12 @@ void ChatHandler::ShowAchievementListHelper(AchievementEntry const* achEntry, Lo
                 if (AchievementMgr const* mgr = target ? &target->GetAchievementMgr() : NULL)
                     if (AchievementCriteriaEntryList const* criteriaList = sAchievementMgr.GetAchievementCriteriaByAchievement(achEntry->ID))
                         for (AchievementCriteriaEntryList::const_iterator itr = criteriaList->begin(); itr != criteriaList->end(); ++itr)
+                        {
                             if (mgr->IsCompletedCriteria(*itr, achEntry))
                             {
                                 criteriaMask[((*itr)->showOrder - 1) / 32] |= (1 << (((*itr)->showOrder - 1) % 32));
                             }
+                        }
 
                 for (int i = 0; i < 4; ++i)
                 {

src/game/ChatCommands/PoolCommands.cpp

@@ -117,19 +117,23 @@ bool ChatHandler::HandlePoolSpawnsCommand(char* args)
 
     SpawnedPoolObjects const& crSpawns = spawns.GetSpawnedCreatures();
     for (SpawnedPoolObjects::const_iterator itr = crSpawns.begin(); itr != crSpawns.end(); ++itr)
+    {
         if (!pool_id || pool_id == sPoolMgr.IsPartOfAPool<Creature>(*itr))
             if (CreatureData const* data = sObjectMgr.GetCreatureData(*itr))
                 if (CreatureInfo const* info = ObjectMgr::GetCreatureTemplate(data->id))
                     PSendSysMessage(LANG_CREATURE_LIST_CHAT, *itr, PrepareStringNpcOrGoSpawnInformation<Creature>(*itr).c_str(),
                                     *itr, info->Name, data->posX, data->posY, data->posZ, data->mapid);
+    }
 
     SpawnedPoolObjects const& goSpawns = spawns.GetSpawnedGameobjects();
     for (SpawnedPoolObjects::const_iterator itr = goSpawns.begin(); itr != goSpawns.end(); ++itr)
+    {
         if (!pool_id || pool_id == sPoolMgr.IsPartOfAPool<GameObject>(*itr))
             if (GameObjectData const* data = sObjectMgr.GetGOData(*itr))
                 if (GameObjectInfo const* info = ObjectMgr::GetGameObjectInfo(data->id))
                     PSendSysMessage(LANG_GO_LIST_CHAT, *itr, PrepareStringNpcOrGoSpawnInformation<GameObject>(*itr).c_str(),
                                     *itr, info->name, data->posX, data->posY, data->posZ, data->mapid);
+    }
 
     return true;
 }

src/game/ChatCommands/ServerCommands.cpp

@@ -268,10 +268,12 @@ bool ChatHandler::HandleServerLogFilterCommand(char* args)
     {
         SendSysMessage(LANG_LOG_FILTERS_STATE_HEADER);
         for (int i = 0; i < LOG_FILTER_COUNT; ++i)
+        {
             if (*logFilterData[i].name)
             {
                 PSendSysMessage("  %-20s = %s", logFilterData[i].name, GetOnOffStr(sLog.HasLogFilter(1 << i)));
             }
+        }
         return true;
     }
 

src/game/Object/ArenaTeam.cpp

@@ -607,10 +607,12 @@ uint8 ArenaTeam::GetSlotByType(ArenaType type)
 bool ArenaTeam::HaveMember(ObjectGuid guid) const
 {
     for (MemberList::const_iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
+    {
         if (itr->guid == guid)
         {
             return true;
         }
+    }
 
     return false;
 }

src/game/Object/ArenaTeam.h

@@ -162,21 +162,25 @@ class ArenaTeam
         ArenaTeamMember* GetMember(ObjectGuid guid)
         {
             for (MemberList::iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
+            {
                 if (itr->guid == guid)
                 {
                     return &(*itr);
                 }
+            }
 
             return NULL;
         }
 
         ArenaTeamMember* GetMember(const std::string& name)
         {
             for (MemberList::iterator itr = m_members.begin(); itr != m_members.end(); ++itr)
+            {
                 if (itr->name == name)
                 {
                     return &(*itr);
                 }
+            }
 
             return NULL;
         }