Run clang-format

src/GuildTaskMgr.cpp

@@ -1,15 +1,17 @@
 /*
- * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it
+ * and/or modify it under version 2 of the License, or (at your option), any later version.
  */
 
 #include "GuildTaskMgr.h"
+
 #include "ChatHelper.h"
-#include "GuildMgr.h"
 #include "Group.h"
+#include "GuildMgr.h"
 #include "Mail.h"
 #include "MapMgr.h"
-#include "Playerbots.h"
 #include "PlayerbotFactory.h"
+#include "Playerbots.h"
 #include "RandomItemMgr.h"
 #include "ServerFacade.h"
 
@@ -42,13 +44,15 @@ void GuildTaskMgr::Update(Player* player, Player* guildMaster)
     if (!player->IsFriendlyTo(guildMaster))
         return;
 
-	Guild* guild = sGuildMgr->GetGuildById(guildMaster->GetGuildId());
+    Guild* guild = sGuildMgr->GetGuildById(guildMaster->GetGuildId());
 
     DenyReason reason = PLAYERBOT_DENY_NONE;
     PlayerbotSecurityLevel secLevel = masterBotAI->GetSecurity()->LevelFor(player, &reason);
-    if (secLevel == PLAYERBOT_SECURITY_DENY_ALL || (secLevel == PLAYERBOT_SECURITY_TALK && reason != PLAYERBOT_DENY_FAR))
+    if (secLevel == PLAYERBOT_SECURITY_DENY_ALL ||
+        (secLevel == PLAYERBOT_SECURITY_TALK && reason != PLAYERBOT_DENY_FAR))
     {
-        LOG_DEBUG("playerbots", "{} / {}: skipping guild task update - not enough security level, reason = {}", guild->GetName().c_str(), player->GetName().c_str(), reason);
+        LOG_DEBUG("playerbots", "{} / {}: skipping guild task update - not enough security level, reason = {}",
+                  guild->GetName().c_str(), player->GetName().c_str(), reason);
         return;
     }
 
@@ -72,14 +76,18 @@ void GuildTaskMgr::Update(Player* player, Player* guildMaster)
 
         if (task == GUILD_TASK_TYPE_NONE)
         {
-            LOG_ERROR("playerbots",  "{} / {}: error creating guild task", guild->GetName().c_str(), player->GetName().c_str());
+            LOG_ERROR("playerbots", "{} / {}: error creating guild task", guild->GetName().c_str(),
+                      player->GetName().c_str());
         }
 
         uint32 time = urand(sPlayerbotAIConfig->minGuildTaskChangeTime, sPlayerbotAIConfig->maxGuildTaskChangeTime);
         SetTaskValue(owner, guildId, "activeTask", task, time);
-        SetTaskValue(owner, guildId, "advertisement", 1, urand(sPlayerbotAIConfig->minGuildTaskAdvertisementTime, sPlayerbotAIConfig->maxGuildTaskAdvertisementTime));
+        SetTaskValue(owner, guildId, "advertisement", 1,
+                     urand(sPlayerbotAIConfig->minGuildTaskAdvertisementTime,
+                           sPlayerbotAIConfig->maxGuildTaskAdvertisementTime));
 
-        LOG_DEBUG("playerbots", "{} / {}: guild task {} is set for {} secs", guild->GetName().c_str(), player->GetName().c_str(), task, time);
+        LOG_DEBUG("playerbots", "{} / {}: guild task {} is set for {} secs", guild->GetName().c_str(),
+                  player->GetName().c_str(), task, time);
         return;
     }
 
@@ -92,11 +100,14 @@ void GuildTaskMgr::Update(Player* player, Player* guildMaster)
 
         if (SendAdvertisement(trans, owner, guildId))
         {
-            SetTaskValue(owner, guildId, "advertisement", 1, urand(sPlayerbotAIConfig->minGuildTaskAdvertisementTime, sPlayerbotAIConfig->maxGuildTaskAdvertisementTime));
+            SetTaskValue(owner, guildId, "advertisement", 1,
+                         urand(sPlayerbotAIConfig->minGuildTaskAdvertisementTime,
+                               sPlayerbotAIConfig->maxGuildTaskAdvertisementTime));
         }
         else
         {
-            LOG_DEBUG("playerbots",  "{} / {}: error sending advertisement", guild->GetName().c_str(), player->GetName().c_str());
+            LOG_DEBUG("playerbots", "{} / {}: error sending advertisement", guild->GetName().c_str(),
+                      player->GetName().c_str());
         }
     }
 
@@ -112,7 +123,8 @@ void GuildTaskMgr::Update(Player* player, Player* guildMaster)
         }
         else
         {
-            LOG_DEBUG("playerbots",  "{} / {}: error sending thanks", guild->GetName().c_str(), player->GetName().c_str());
+            LOG_DEBUG("playerbots", "{} / {}: error sending thanks", guild->GetName().c_str(),
+                      player->GetName().c_str());
         }
     }
 
@@ -128,7 +140,8 @@ void GuildTaskMgr::Update(Player* player, Player* guildMaster)
         }
         else
         {
-            LOG_DEBUG("playerbots",  "{} / {}: error sending reward", guild->GetName().c_str(), player->GetName().c_str());
+            LOG_DEBUG("playerbots", "{} / {}: error sending reward", guild->GetName().c_str(),
+                      player->GetName().c_str());
         }
     }
 
@@ -151,7 +164,7 @@ uint32 GuildTaskMgr::CreateTask(Player* owner, uint32 guildId)
 class RandomItemBySkillGuildTaskPredicate : public RandomItemPredicate
 {
 public:
-    RandomItemBySkillGuildTaskPredicate(Player* player) : RandomItemPredicate(), player(player) { }
+    RandomItemBySkillGuildTaskPredicate(Player* player) : RandomItemPredicate(), player(player) {}
 
     bool Apply(ItemTemplate const* proto) override
     {
@@ -180,16 +193,20 @@ bool GuildTaskMgr::CreateItemTask(Player* player, uint32 guildId)
     uint32 itemId = sRandomItemMgr->GetRandomItem(player->GetLevel() - 5, RANDOM_ITEM_GUILD_TASK, &predicate);
     if (!itemId)
     {
-        LOG_ERROR("playerbots",  "{} / {}: no items avaible for item task", sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str());
+        LOG_ERROR("playerbots", "{} / {}: no items avaible for item task",
+                  sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str());
         return false;
     }
 
     uint32 count = GetMaxItemTaskCount(itemId);
 
-    LOG_DEBUG("playerbots", "{} / {}: item task {} (x{})", sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str(), itemId, count);
+    LOG_DEBUG("playerbots", "{} / {}: item task {} (x{})", sGuildMgr->GetGuildById(guildId)->GetName().c_str(),
+              player->GetName().c_str(), itemId, count);
 
-    SetTaskValue(player->GetGUID().GetCounter(), guildId, "itemCount", count, sPlayerbotAIConfig->maxGuildTaskChangeTime);
-    SetTaskValue(player->GetGUID().GetCounter(), guildId, "itemTask", itemId, sPlayerbotAIConfig->maxGuildTaskChangeTime);
+    SetTaskValue(player->GetGUID().GetCounter(), guildId, "itemCount", count,
+                 sPlayerbotAIConfig->maxGuildTaskChangeTime);
+    SetTaskValue(player->GetGUID().GetCounter(), guildId, "itemTask", itemId,
+                 sPlayerbotAIConfig->maxGuildTaskChangeTime);
 
     return true;
 }
@@ -204,8 +221,10 @@ bool GuildTaskMgr::CreateKillTask(Player* player, uint32 guildId)
     std::vector<uint32> ids;
 
     uint32 level = player->GetLevel();
-    QueryResult results = WorldDatabase.Query("SELECT ct.Entry, c.map, c.position_x, c.position_y, ct.Name FROM creature_template ct "
-        "JOIN creature c ON ct.Entry = c.id1 WHERE ct.MaxLevel < {} AND ct.MinLevel > {} AND ct.Rank = {} ", level + 4, level - 3, rank);
+    QueryResult results = WorldDatabase.Query(
+        "SELECT ct.Entry, c.map, c.position_x, c.position_y, ct.Name FROM creature_template ct "
+        "JOIN creature c ON ct.Entry = c.id1 WHERE ct.MaxLevel < {} AND ct.MinLevel > {} AND ct.Rank = {} ",
+        level + 4, level - 3, rank);
     if (results)
     {
         do
@@ -231,16 +250,19 @@ bool GuildTaskMgr::CreateKillTask(Player* player, uint32 guildId)
 
     if (ids.empty())
     {
-        LOG_ERROR("playerbots",  "{} / {}: no rare creatures available for kill task", sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str());
+        LOG_ERROR("playerbots", "{} / {}: no rare creatures available for kill task",
+                  sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str());
         return false;
     }
 
     uint32 index = urand(0, ids.size() - 1);
     uint32 creatureId = ids[index];
 
-    LOG_DEBUG("playerbots", "{} / {}: kill task {}", sGuildMgr->GetGuildById(guildId)->GetName().c_str(), player->GetName().c_str(), creatureId);
+    LOG_DEBUG("playerbots", "{} / {}: kill task {}", sGuildMgr->GetGuildById(guildId)->GetName().c_str(),
+              player->GetName().c_str(), creatureId);
 
-    SetTaskValue(player->GetGUID().GetCounter(), guildId, "killTask", creatureId, sPlayerbotAIConfig->maxGuildTaskChangeTime);
+    SetTaskValue(player->GetGUID().GetCounter(), guildId, "killTask", creatureId,
+                 sPlayerbotAIConfig->maxGuildTaskChangeTime);
 
     return true;
 }
@@ -283,7 +305,8 @@ std::string const formatTime(uint32 secs)
     else if (secs < 3600 * 24)
     {
         out << secs / 3600 << " hr";
-    } else
+    }
+    else
     {
         out << secs / 3600 / 24 << " days";
     }
@@ -294,7 +317,7 @@ std::string const formatTime(uint32 secs)
 std::string const formatDateTime(uint32 secs)
 {
     time_t rawtime = time(nullptr) + secs;
-    tm* timeinfo = localtime (&rawtime);
+    tm* timeinfo = localtime(&rawtime);
 
     char buffer[256];
     strftime(buffer, sizeof(buffer), "%b %d, %H:%M", timeinfo);
@@ -318,7 +341,8 @@ std::string const GetHelloText(uint32 owner)
     return body.str();
 }
 
-bool GuildTaskMgr::SendItemAdvertisement(CharacterDatabaseTransaction& trans, uint32 itemId, uint32 owner, uint32 guildId, uint32 validIn)
+bool GuildTaskMgr::SendItemAdvertisement(CharacterDatabaseTransaction& trans, uint32 itemId, uint32 owner,
+                                         uint32 guildId, uint32 validIn)
 {
     Guild* guild = sGuildMgr->GetGuildById(guildId);
     Player* leader = ObjectAccessor::FindPlayer(guild->GetLeaderGUID());
@@ -352,7 +376,8 @@ bool GuildTaskMgr::SendItemAdvertisement(CharacterDatabaseTransaction& trans, ui
     return true;
 }
 
-bool GuildTaskMgr::SendKillAdvertisement(CharacterDatabaseTransaction& trans, uint32 creatureId, uint32 owner, uint32 guildId, uint32 validIn)
+bool GuildTaskMgr::SendKillAdvertisement(CharacterDatabaseTransaction& trans, uint32 creatureId, uint32 owner,
+                                         uint32 guildId, uint32 validIn)
 {
     Guild* guild = sGuildMgr->GetGuildById(guildId);
     Player* leader = ObjectAccessor::FindPlayer(guild->GetLeaderGUID());
@@ -361,7 +386,8 @@ bool GuildTaskMgr::SendKillAdvertisement(CharacterDatabaseTransaction& trans, ui
     if (!proto)
         return false;
 
-    QueryResult result = WorldDatabase.Query("SELECT map, position_x, position_y, position_z FROM creature WHERE id1 = {}", creatureId);
+    QueryResult result =
+        WorldDatabase.Query("SELECT map, position_x, position_y, position_z FROM creature WHERE id1 = {}", creatureId);
     if (!result)
         return false;
 
@@ -387,7 +413,8 @@ bool GuildTaskMgr::SendKillAdvertisement(CharacterDatabaseTransaction& trans, ui
 
     std::ostringstream body;
     body << GetHelloText(owner);
-    body << "As you probably know " << proto->Name << " is wanted dead for the crimes it did against our guild. If you should kill it ";
+    body << "As you probably know " << proto->Name
+         << " is wanted dead for the crimes it did against our guild. If you should kill it ";
     body << "we'd really appreciate that.\n\n";
     if (!location.empty())
         body << proto->Name << "'s the last known location was " << location << ".\n";
@@ -399,7 +426,8 @@ bool GuildTaskMgr::SendKillAdvertisement(CharacterDatabaseTransaction& trans, ui
 
     std::ostringstream subject;
     subject << "Guild Task: ";
-    if (proto->rank == CREATURE_ELITE_ELITE || proto->rank == CREATURE_ELITE_RAREELITE || proto->rank == CREATURE_ELITE_WORLDBOSS)
+    if (proto->rank == CREATURE_ELITE_ELITE || proto->rank == CREATURE_ELITE_RAREELITE ||
+        proto->rank == CREATURE_ELITE_WORLDBOSS)
         subject << "(Elite) ";
     subject << proto->Name;
     if (!location.empty())
@@ -441,9 +469,7 @@ bool GuildTaskMgr::SendThanks(CharacterDatabaseTransaction& trans, uint32 owner,
         body << guild->GetName() << "\n";
         body << leader->GetName() << "\n";
 
-        MailDraft("Thank You", body.str()).
-                AddMoney(payment).
-                SendMailTo(trans, MailReceiver(owner), MailSender(leader));
+        MailDraft("Thank You", body.str()).AddMoney(payment).SendMailTo(trans, MailReceiver(owner), MailSender(leader));
 
         Player* player = ObjectAccessor::FindPlayer(ObjectGuid::Create<HighGuid::Player>(owner));
         if (player)
@@ -501,7 +527,8 @@ bool GuildTaskMgr::IsGuildTaskItem(uint32 itemId, uint32 guildId)
 {
     uint32 value = 0;
 
-    PlayerbotsDatabasePreparedStatement* stmt = PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_VALUE);
+    PlayerbotsDatabasePreparedStatement* stmt =
+        PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_VALUE);
     stmt->SetData(0, itemId);
     stmt->SetData(1, guildId);
     stmt->SetData(2, "itemTask");
@@ -518,11 +545,13 @@ bool GuildTaskMgr::IsGuildTaskItem(uint32 itemId, uint32 guildId)
     return value;
 }
 
-std::map<uint32, uint32> GuildTaskMgr::GetTaskValues(uint32 owner, std::string const type, uint32* validIn /* = nullptr */)
+std::map<uint32, uint32> GuildTaskMgr::GetTaskValues(uint32 owner, std::string const type,
+                                                     uint32* validIn /* = nullptr */)
 {
     std::map<uint32, uint32> results;
 
-    PlayerbotsDatabasePreparedStatement* stmt = PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER);
+    PlayerbotsDatabasePreparedStatement* stmt =
+        PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER);
     stmt->SetData(0, owner);
     stmt->SetData(1, type);
     if (PreparedQueryResult result = PlayerbotsDatabase.Query(stmt))
@@ -542,14 +571,15 @@ std::map<uint32, uint32> GuildTaskMgr::GetTaskValues(uint32 owner, std::string c
         } while (result->NextRow());
     }
 
-	return std::move(results);
+    return std::move(results);
 }
 
 uint32 GuildTaskMgr::GetTaskValue(uint32 owner, uint32 guildId, std::string const type, uint32* validIn /* = nullptr */)
 {
     uint32 value = 0;
 
-    PlayerbotsDatabasePreparedStatement* stmt = PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_AND_TYPE);
+    PlayerbotsDatabasePreparedStatement* stmt =
+        PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_AND_TYPE);
     stmt->SetData(0, owner);
     stmt->SetData(1, guildId);
     stmt->SetData(2, type);
@@ -566,7 +596,7 @@ uint32 GuildTaskMgr::GetTaskValue(uint32 owner, uint32 guildId, std::string cons
             *validIn = secs;
     }
 
-	return value;
+    return value;
 }
 
 uint32 GuildTaskMgr::SetTaskValue(uint32 owner, uint32 guildId, std::string const type, uint32 value, uint32 validIn)
@@ -596,13 +626,13 @@ bool GuildTaskMgr::HandleConsoleCommand(ChatHandler* handler, char const* args)
 {
     if (!sPlayerbotAIConfig->guildTaskEnabled)
     {
-        LOG_ERROR("playerbots",  "Guild task system is currently disabled!");
+        LOG_ERROR("playerbots", "Guild task system is currently disabled!");
         return false;
     }
 
     if (!args || !*args)
     {
-        LOG_ERROR("playerbots",  "Usage: gtask stats/reset");
+        LOG_ERROR("playerbots", "Usage: gtask stats/reset");
         return false;
     }
 
@@ -627,13 +657,14 @@ bool GuildTaskMgr::HandleConsoleCommand(ChatHandler* handler, char const* args)
         ObjectGuid guid = sCharacterCache->GetCharacterGuidByName(charName);
         if (!guid)
         {
-            LOG_ERROR("playerbots",  "Player {} not found", charName.c_str());
+            LOG_ERROR("playerbots", "Player {} not found", charName.c_str());
             return false;
         }
 
         uint32 owner = guid.GetCounter();
 
-        PlayerbotsDatabasePreparedStatement* stmt = PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_ORDERED);
+        PlayerbotsDatabasePreparedStatement* stmt =
+            PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_ORDERED);
         stmt->SetData(0, owner);
         stmt->SetData(1, "activeTask");
         if (PreparedQueryResult result = PlayerbotsDatabase.Query(stmt))
@@ -731,11 +762,10 @@ bool GuildTaskMgr::HandleConsoleCommand(ChatHandler* handler, char const* args)
                 if (payment && paymentValidIn < validIn)
                     name << " payment " << ChatHelper::formatMoney(payment) << " in " << formatTime(paymentValidIn);
 
-                LOG_INFO("playerbots", "{}: {} valid in {} [{}]",
-                        charName.c_str(), name.str().c_str(), formatTime(validIn).c_str(), guild->GetName().c_str());
+                LOG_INFO("playerbots", "{}: {} valid in {} [{}]", charName.c_str(), name.str().c_str(),
+                         formatTime(validIn).c_str(), guild->GetName().c_str());
 
-            }
-            while (result->NextRow());
+            } while (result->NextRow());
         }
 
         return true;
@@ -774,13 +804,14 @@ bool GuildTaskMgr::HandleConsoleCommand(ChatHandler* handler, char const* args)
         ObjectGuid guid = sCharacterCache->GetCharacterGuidByName(charName);
         if (!guid)
         {
-            LOG_ERROR("playerbots",  "Player {} not found", charName.c_str());
+            LOG_ERROR("playerbots", "Player {} not found", charName.c_str());
             return false;
         }
 
         uint32 owner = guid.GetCounter();
 
-        PlayerbotsDatabasePreparedStatement* stmt = PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_DISTINCT);
+        PlayerbotsDatabasePreparedStatement* stmt =
+            PlayerbotsDatabase.GetPreparedStatement(PLAYERBOTS_SEL_GUILD_TASKS_BY_OWNER_DISTINCT);
         stmt->SetData(0, owner);
         if (PreparedQueryResult result = PlayerbotsDatabase.Query(stmt))
         {
@@ -818,19 +849,20 @@ bool GuildTaskMgr::CheckItemTask(uint32 itemId, uint32 obtained, Player* ownerPl
         return false;
 
     uint32 owner = ownerPlayer->GetGUID().GetCounter();
-	Guild* guild = sGuildMgr->GetGuildById(bot->GetGuildId());
-	if (!guild)
-		return false;
+    Guild* guild = sGuildMgr->GetGuildById(bot->GetGuildId());
+    if (!guild)
+        return false;
 
-	if (!sRandomPlayerbotMgr->IsRandomBot(bot))
-	    return false;
+    if (!sRandomPlayerbotMgr->IsRandomBot(bot))
+        return false;
 
     LOG_DEBUG("playerbots", "{} / {}: checking guild task", guild->GetName().c_str(), ownerPlayer->GetName().c_str());
 
     uint32 itemTask = GetTaskValue(owner, guildId, "itemTask");
     if (itemTask != itemId)
     {
-        LOG_DEBUG("playerbots", "{} / {}: item {} is not guild task item ({})", guild->GetName().c_str(), ownerPlayer->GetName().c_str(), itemId, itemTask);
+        LOG_DEBUG("playerbots", "{} / {}: item {} is not guild task item ({})", guild->GetName().c_str(),
+                  ownerPlayer->GetName().c_str(), itemId, itemTask);
 
         if (byMail)
             SendCompletionMessage(ownerPlayer, "made a mistake with");
@@ -857,7 +889,8 @@ bool GuildTaskMgr::CheckItemTask(uint32 itemId, uint32 obtained, Player* ownerPl
 
     if (obtained >= count)
     {
-        LOG_DEBUG("playerbots", "{} / {}: guild task complete", guild->GetName().c_str(), ownerPlayer->GetName().c_str());
+        LOG_DEBUG("playerbots", "{} / {}: guild task complete", guild->GetName().c_str(),
+                  ownerPlayer->GetName().c_str());
         SetTaskValue(owner, guildId, "reward", 1, rewardTime - 15);
         SetTaskValue(owner, guildId, "itemCount", 0, 0);
         SetTaskValue(owner, guildId, "thanks", 0, 0);
@@ -865,7 +898,8 @@ bool GuildTaskMgr::CheckItemTask(uint32 itemId, uint32 obtained, Player* ownerPl
     }
     else
     {
-        LOG_DEBUG("playerbots", "{} / {}: guild task progress {}/{}", guild->GetName().c_str(), ownerPlayer->GetName().c_str(), obtained, count);
+        LOG_DEBUG("playerbots", "{} / {}: guild task progress {}/{}", guild->GetName().c_str(),
+                  ownerPlayer->GetName().c_str(), obtained, count);
         SetTaskValue(owner, guildId, "itemCount", count - obtained, sPlayerbotAIConfig->maxGuildTaskChangeTime);
         SetTaskValue(owner, guildId, "thanks", 1, rewardTime - 30);
         SendCompletionMessage(ownerPlayer, "made a progress with");
@@ -904,12 +938,14 @@ bool GuildTaskMgr::Reward(CharacterDatabaseTransaction& trans, uint32 owner, uin
         if (!proto)
             return false;
 
-        body << "We wish to thank you for the " << proto->Name1 << " you provided so kindly. We really appreciate this and may this small gift bring you our thanks!\n";
+        body << "We wish to thank you for the " << proto->Name1
+             << " you provided so kindly. We really appreciate this and may this small gift bring you our thanks!\n";
         body << "\n";
         body << "Many thanks,\n";
         body << guild->GetName() << "\n";
         body << leader->GetName() << "\n";
-        rewardType = proto->Quality > ITEM_QUALITY_NORMAL ? RANDOM_ITEM_GUILD_TASK_REWARD_EQUIP_BLUE : RANDOM_ITEM_GUILD_TASK_REWARD_EQUIP_GREEN;
+        rewardType = proto->Quality > ITEM_QUALITY_NORMAL ? RANDOM_ITEM_GUILD_TASK_REWARD_EQUIP_BLUE
+                                                          : RANDOM_ITEM_GUILD_TASK_REWARD_EQUIP_GREEN;
         itemId = sRandomItemMgr->GetRandomItem(player->GetLevel() - 5, rewardType);
     }
     else if (killTask)
@@ -918,12 +954,14 @@ bool GuildTaskMgr::Reward(CharacterDatabaseTransaction& trans, uint32 owner, uin
         if (!proto)
             return false;
 
-        body << "We wish to thank you for the " << proto->Name << " you've killed recently. We really appreciate this and may this small gift bring you our thanks!\n";
+        body << "We wish to thank you for the " << proto->Name
+             << " you've killed recently. We really appreciate this and may this small gift bring you our thanks!\n";
         body << "\n";
         body << "Many thanks,\n";
         body << guild->GetName() << "\n";
         body << leader->GetName() << "\n";
-        rewardType = proto->rank == CREATURE_ELITE_RARE ? RANDOM_ITEM_GUILD_TASK_REWARD_TRADE : RANDOM_ITEM_GUILD_TASK_REWARD_TRADE_RARE;
+        rewardType = proto->rank == CREATURE_ELITE_RARE ? RANDOM_ITEM_GUILD_TASK_REWARD_TRADE
+                                                        : RANDOM_ITEM_GUILD_TASK_REWARD_TRADE_RARE;
         itemId = sRandomItemMgr->GetRandomItem(player->GetLevel(), rewardType);
         if (itemId)
         {
@@ -1032,7 +1070,8 @@ void GuildTaskMgr::CheckKillTaskInternal(Player* player, Unit* victim)
             continue;
 
         LOG_DEBUG("playerbots", "{} / {}: guild task complete", guild->GetName().c_str(), player->GetName().c_str());
-        SetTaskValue(owner, guildId, "reward", 1, urand(sPlayerbotAIConfig->minGuildTaskRewardTime, sPlayerbotAIConfig->maxGuildTaskRewardTime));
+        SetTaskValue(owner, guildId, "reward", 1,
+                     urand(sPlayerbotAIConfig->minGuildTaskRewardTime, sPlayerbotAIConfig->maxGuildTaskRewardTime));
 
         SendCompletionMessage(player, "completed");
     }
@@ -1041,7 +1080,8 @@ void GuildTaskMgr::CheckKillTaskInternal(Player* player, Unit* victim)
 void GuildTaskMgr::CleanupAdverts()
 {
     uint32 deliverTime = time(nullptr) - sPlayerbotAIConfig->minGuildTaskChangeTime;
-    QueryResult result = CharacterDatabase.Query("SELECT id, receiver FROM mail WHERE subject LIKE 'Guild Task%%' AND deliver_time <= {}", deliverTime);
+    QueryResult result = CharacterDatabase.Query(
+        "SELECT id, receiver FROM mail WHERE subject LIKE 'Guild Task%%' AND deliver_time <= {}", deliverTime);
     if (!result)
         return;
 
@@ -1059,7 +1099,8 @@ void GuildTaskMgr::CleanupAdverts()
 
     if (count > 0)
     {
-        CharacterDatabase.Execute("DELETE FROM mail WHERE subject LIKE 'Guild Task%%' AND deliver_time <= {}", deliverTime);
+        CharacterDatabase.Execute("DELETE FROM mail WHERE subject LIKE 'Guild Task%%' AND deliver_time <= {}",
+                                  deliverTime);
         LOG_INFO("playerbots", "{} old gtask adverts removed", count);
     }
 }
@@ -1067,8 +1108,12 @@ void GuildTaskMgr::CleanupAdverts()
 void GuildTaskMgr::RemoveDuplicatedAdverts()
 {
     uint32 deliverTime = time(nullptr);
-    QueryResult result = CharacterDatabase.Query("SELECT m.id, m.receiver FROM (SELECT MAX(id) AS id, subject, receiver FROM mail WHERE subject LIKE 'Guild Task%%' "
-            "AND deliver_time <= {} GROUP BY subject, receiver) q JOIN mail m ON m.subject = q.subject WHERE m.id <> q.id AND m.deliver_time <= {}", deliverTime, deliverTime);
+    QueryResult result = CharacterDatabase.Query(
+        "SELECT m.id, m.receiver FROM (SELECT MAX(id) AS id, subject, receiver FROM mail WHERE subject LIKE 'Guild "
+        "Task%%' "
+        "AND deliver_time <= {} GROUP BY subject, receiver) q JOIN mail m ON m.subject = q.subject WHERE m.id <> q.id "
+        "AND m.deliver_time <= {}",
+        deliverTime, deliverTime);
 
     if (!result)
         return;
@@ -1103,7 +1148,6 @@ void GuildTaskMgr::RemoveDuplicatedAdverts()
         DeleteMail(buffer);
         LOG_INFO("playerbots", "{} duplicated gtask adverts removed", count);
     }
-
 }
 
 void GuildTaskMgr::DeleteMail(std::vector<uint32> buffer)
@@ -1147,7 +1191,8 @@ bool GuildTaskMgr::CheckTaskTransfer(std::string const text, Player* ownerPlayer
     if (text.empty())
         return false;
 
-    LOG_DEBUG("playerbots", "{} / {}: checking guild task transfer", guild->GetName().c_str(), ownerPlayer->GetName().c_str());
+    LOG_DEBUG("playerbots", "{} / {}: checking guild task transfer", guild->GetName().c_str(),
+              ownerPlayer->GetName().c_str());
 
     uint32 account = ownerPlayer->GetSession()->GetAccountId();