Core/Battlefield

* Fix battle start
* cleanups and code style fixes

3 files changed, 1219 insertions, 68 deletions

diff --git a/src/server/game/Battlefield/Battlefield.cpp b/src/server/game/Battlefield/Battlefield.cpp
new file mode 100644
index 00000000000..62aebfe5173
--- /dev/null
+++ b/src/server/game/Battlefield/Battlefield.cpp
@@ -0,0 +1,1151 @@
+/*
+ * Copyright (C) 2008-2010 TrinityCore <http://www.trinitycore.org/>
+ * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Battlefield.h"
+#include "BattlefieldMgr.h"
+#include "ObjectAccessor.h"
+#include "ObjectMgr.h"
+#include "Map.h"
+#include "MapManager.h"
+#include "Group.h"
+#include "WorldPacket.h"
+#include "GridNotifiers.h"
+#include "GridNotifiersImpl.h"
+#include "GridNotifiers.h"
+#include "GridNotifiersImpl.h"
+#include "CellImpl.h"
+#include "CreatureTextMgr.h"
+
+#include "GroupMgr.h"
+
+Battlefield::Battlefield()
+{
+    m_Timer = 0;
+    m_enable = true;
+    m_BattlefieldActive = false;
+    m_DefenderTeam = TEAM_NEUTRAL;
+
+    m_TypeId = 0;
+    m_BattleId = 0;
+    m_ZoneId = 0;
+    m_MapId = 0;
+    m_MaxPlayer = 0;
+    m_MinPlayer = 0;
+    m_BattleTime = 0;
+    m_NoWarBattleTime = 0;
+    m_TimeForAcceptInvite = 20;
+    m_uiKickDontAcceptTimer = 1000;
+
+    m_uiKickAfkTimer = 1000;
+
+    m_LastResurectTimer = 30 * IN_MILLISECONDS;
+    m_StartGroupingTimer = 0;
+    m_StartGrouping = false;
+    StalkerGuid = 0;
+}
+
+Battlefield::~Battlefield()
+{
+}
+
+void Battlefield::HandlePlayerEnterZone(Player *plr, uint32 /*zone */ )
+{
+    //If battle is start, 
+    //  if it not fully > invite player to join the war
+    //  if it fully > announce to player that BF is full and kick after few second if he dont leave
+    if (IsWarTime())
+    {
+        if (m_PlayersInWar[plr->GetTeamId()].size() + m_InvitedPlayers[plr->GetTeamId()].size() < m_MaxPlayer)  //Not fully
+        {
+            InvitePlayerToWar(plr);
+        }
+        else                                                //Full
+        {
+            //TODO:Send packet for announce it to player
+            m_PlayersWillBeKick[plr->GetTeamId()][plr->GetGUID()] = time(NULL) + 10;
+            InvitePlayerToQueue(plr);
+        }
+    }
+    else
+    {
+        //If time left is <15 minutes invite player to join queue
+        if (m_Timer <= m_StartGroupingTimer)
+            InvitePlayerToQueue(plr);
+    }
+
+    //Add player in list of player in zone
+    m_players[plr->GetTeamId()].insert(plr->GetGUID());
+    OnPlayerEnterZone(plr);                                 //for scripting
+}
+
+//Called when a player leave the zone
+void Battlefield::HandlePlayerLeaveZone(Player *plr, uint32 /*zone */ )
+{
+    if (IsWarTime())
+    {
+        //if player is in war list
+        if (m_PlayersInWar[plr->GetTeamId()].find(plr->GetGUID()) != m_PlayersInWar[plr->GetTeamId()].end())
+        {
+            m_PlayersInWar[plr->GetTeamId()].erase(plr->GetGUID());
+            plr->GetSession()->SendBfLeaveMessage(m_BattleId);
+            if (Group* group = GetGroupPlayer(plr->GetGUID(), plr->GetTeamId()))       // remove from raid group if player is member
+            {
+                // I think that now is not a hack
+                if (!group->RemoveMember(plr->GetGUID()))   // group was disbanded
+                {
+                    m_Groups[plr->GetTeamId()].erase(group->GetGUID());
+                    group->SetBattlefieldGroup(NULL);
+                    sGroupMgr->RemoveGroup(group);
+                    delete group;
+                }
+            }
+            OnPlayerLeaveWar(plr);                          //For scripting
+        }
+    }
+
+    for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
+        itr->second->HandlePlayerLeave(plr);
+
+    m_InvitedPlayers[plr->GetTeamId()].erase(plr->GetGUID());
+    m_PlayersWillBeKick[plr->GetTeamId()].erase(plr->GetGUID());
+    m_players[plr->GetTeamId()].erase(plr->GetGUID());
+    SendRemoveWorldStates(plr);
+    RemovePlayerFromResurrectQueue(plr->GetGUID());
+    OnPlayerLeaveZone(plr);                                 //For scripting
+}
+
+bool Battlefield::Update(uint32 diff)
+{
+    //When global timer is end
+    if (m_Timer <= diff)
+    {
+        //Here end of battle by timer
+        if (IsWarTime())
+            EndBattle(true);
+        //Start of battle
+        else
+            StartBattle();
+    }
+    else
+        m_Timer -= diff;
+
+    //Some times before battle start invite player to queue
+    if (!m_StartGrouping && m_Timer <= m_StartGroupingTimer)
+    {
+        m_StartGrouping = true;
+        InvitePlayerInZoneToQueue();
+        OnStartGrouping();                                  // for scripting
+    }
+
+    bool objective_changed = false;
+    if (IsWarTime())
+    {
+        if (m_uiKickAfkTimer <= diff)
+        {
+            m_uiKickAfkTimer = 1000;
+            KickAfk();
+        }
+        else
+            m_uiKickAfkTimer -= diff;
+
+        //Here kick player witch dont have accept invitation to join the war when time is end (time of windows)
+        if (m_uiKickDontAcceptTimer <= diff)
+        {
+            for (int team = 0; team < 2; team++)
+                for (PlayerTimerMap::iterator itr = m_InvitedPlayers[team].begin(); itr != m_InvitedPlayers[team].end(); itr++)
+                    if ((*itr).second <= time(NULL))
+                        KickPlayerFromBf((*itr).first);
+            InvitePlayerInZoneToWar();
+            for (int team = 0; team < 2; team++)
+                for (PlayerTimerMap::iterator itr = m_PlayersWillBeKick[team].begin(); itr != m_PlayersWillBeKick[team].end(); itr++)
+                    if ((*itr).second <= time(NULL))
+                        KickPlayerFromBf((*itr).first);
+
+            m_uiKickDontAcceptTimer = 1000;
+        }
+        else
+            m_uiKickDontAcceptTimer -= diff;
+
+        for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
+            if (itr->second->Update(diff))
+                objective_changed = true;
+    }
+
+
+    if (m_LastResurectTimer <= diff)
+    {
+        for (uint8 i = 0; i < m_GraveYardList.size(); i++)
+            if (GetGraveYardById(i))
+                m_GraveYardList[i]->Resurrect();
+        m_LastResurectTimer = RESURRECTION_INTERVAL;
+    }
+    else
+        m_LastResurectTimer -= diff;
+
+    return objective_changed;
+}
+
+void Battlefield::InvitePlayerInZoneToQueue()
+{
+    for (uint8 team = 0; team < 2; ++team)
+        for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
+            if (Player* plr = sObjectMgr->GetPlayer(*itr))
+                InvitePlayerToQueue(plr);
+}
+
+void Battlefield::InvitePlayerToQueue(Player *plr)
+{
+    if (m_PlayersInQueue[plr->GetTeamId()].count(plr->GetGUID()))
+        return;
+
+    if (m_PlayersInQueue[plr->GetTeam()].size() <= m_MinPlayer || m_PlayersInQueue[plr->GetTeam() == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE].size() >= m_MinPlayer)
+        plr->GetSession()->SendBfInvitePlayerToQueue(m_BattleId);
+}
+
+void Battlefield::InvitePlayerInQueueToWar()
+{
+    for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
+    {
+        for (GuidSet::const_iterator itr = m_PlayersInQueue[team].begin(); itr != m_PlayersInQueue[team].end(); ++itr)
+        {
+            if (Player* plr = sObjectAccessor->FindPlayer(*itr))
+            {
+                if (m_PlayersInWar[plr->GetTeamId()].size() + m_InvitedPlayers[plr->GetTeamId()].size() < m_MaxPlayer)
+                    InvitePlayerToWar(plr);
+                else
+                {
+                    //Full
+                }
+            }
+        }
+        m_PlayersInQueue[team].clear();
+    }
+}
+
+void Battlefield::InvitePlayerInZoneToWar()
+{
+    for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
+        for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
+        {
+            if (Player* plr = sObjectMgr->GetPlayer(*itr))
+            {
+                if (m_PlayersInWar[plr->GetTeamId()].count(plr->GetGUID()) || m_InvitedPlayers[plr->GetTeamId()].count(plr->GetGUID()))
+                    continue;
+                if (m_PlayersInWar[plr->GetTeamId()].size() + m_InvitedPlayers[plr->GetTeamId()].size() < m_MaxPlayer)
+                    InvitePlayerToWar(plr);
+                else
+                {
+                    //full
+                    m_PlayersWillBeKick[plr->GetTeamId()][plr->GetGUID()] = time(NULL) + 10;
+                }
+            }
+        }
+}
+
+void Battlefield::InvitePlayerToWar(Player *plr)
+{
+    if (!plr)
+        return;
+
+    // TODO : needed ?
+    if (plr->isInFlight())
+        return;
+
+    if (plr->InArena() || plr->GetBattleground())
+    {
+        m_PlayersInQueue[plr->GetTeamId()].erase(plr->GetGUID());
+        return;
+    }
+
+    if (plr->getLevel() < m_MinLevel)
+    {
+        if (m_PlayersWillBeKick[plr->GetTeamId()].count(plr->GetGUID()) == 0)
+            m_PlayersWillBeKick[plr->GetTeamId()][plr->GetGUID()] = time(NULL) + 10;
+        return;
+    }
+    //Check if player is not already in war
+    if (m_PlayersInWar[plr->GetTeamId()].count(plr->GetGUID()) || m_InvitedPlayers[plr->GetTeamId()].count(plr->GetGUID()))
+        return;
+
+    m_PlayersWillBeKick[plr->GetTeamId()].erase(plr->GetGUID());
+    m_InvitedPlayers[plr->GetTeamId()][plr->GetGUID()] = time(NULL) + m_TimeForAcceptInvite;
+    plr->GetSession()->SendBfInvitePlayerToWar(m_BattleId, m_ZoneId, m_TimeForAcceptInvite);
+}
+
+void Battlefield::InitStalker(uint32 entry, float x, float y, float z, float o)
+{
+    if (Creature* creature = SpawnCreature(entry, x, y, z, o, TEAM_NEUTRAL))
+        StalkerGuid = creature->GetGUID();
+    else
+        sLog->outError("Battlefield::InitStalker: could not spawn Stalker (Creature entry %u), zone messeges will be un-available", entry);
+}
+
+void Battlefield::KickAfk()
+{
+    for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
+        for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
+            if (Player* plr = sObjectAccessor->FindPlayer(*itr))
+                if (plr->isAFK())
+                    KickPlayerFromBf(*itr);
+}
+
+void Battlefield::KickPlayerFromBf(uint64 guid)
+{
+    if (Player* plr = sObjectAccessor->FindPlayer(guid))
+        if (plr->GetZoneId() == GetZoneId())
+            plr->TeleportTo(KickPosition);
+}
+
+void Battlefield::StartBattle()
+{
+    if (m_BattlefieldActive)
+        return;
+
+    for (int team = 0; team < BG_TEAMS_COUNT; team++)
+    {
+        m_PlayersInWar[team].clear();
+        m_Groups[team].clear();
+    }
+
+    m_Timer = m_BattleTime;
+    m_BattlefieldActive = true;
+
+    InvitePlayerInZoneToWar();
+    InvitePlayerInQueueToWar();
+
+    PlaySoundToAll(BF_START);
+
+    OnBattleStart();
+}
+
+void Battlefield::EndBattle(bool endbytimer)
+{
+    m_BattlefieldActive = false;
+
+    m_StartGrouping = false;
+
+    if (!endbytimer)
+        SetDefenderTeam(GetAttackerTeam());
+
+    if (GetDefenderTeam() == TEAM_ALLIANCE)
+        PlaySoundToAll(BF_ALLIANCE_WINS);                   // alliance wins sound
+    else
+        PlaySoundToAll(BF_HORDE_WINS);                      // horde wins sound
+
+    OnBattleEnd(endbytimer);
+
+    // reset bf timer
+    m_Timer = m_NoWarBattleTime;
+    SendInitWorldStatesToAll();
+}
+
+void Battlefield::PlaySoundToAll(uint32 SoundID)
+{
+    WorldPacket data;
+    data.Initialize(SMSG_PLAY_SOUND, 4);
+    data << uint32(SoundID);
+
+    for (int team = 0; team < BG_TEAMS_COUNT; team++)
+        for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
+        {
+            if (Player* plr = sObjectMgr->GetPlayer(*itr))
+                plr->GetSession()->SendPacket(&data);
+        }
+}
+
+bool Battlefield::HasPlayer(Player *plr) const
+{
+    return m_players[plr->GetTeamId()].find(plr->GetGUID()) != m_players[plr->GetTeamId()].end();
+}
+
+// Called in WorldSession::HandleBfQueueInviteResponse
+void Battlefield::PlayerAcceptInviteToQueue(Player *plr)
+{
+    // Add player in queueVenez
+    m_PlayersInQueue[plr->GetTeamId()].insert(plr->GetGUID());
+    // Send notification
+    plr->GetSession()->SendBfQueueInviteResponce(m_BattleId, m_ZoneId);
+}
+// Called in WorldSession::HandleBfExitRequest
+void Battlefield::AskToLeaveQueue(Player *plr)
+{
+    // Remove player from queue
+    m_PlayersInQueue[plr->GetTeamId()].erase(plr->GetGUID());
+}
+
+// Called in WorldSession::HandleBfEntryInviteResponse
+void Battlefield::PlayerAcceptInviteToWar(Player *plr)
+{
+    if (!IsWarTime())
+        return;
+
+    if (AddOrSetPlayerToCorrectBfGroup(plr))
+    {
+        plr->GetSession()->SendBfEntered(m_BattleId);
+        m_PlayersInWar[plr->GetTeamId()].insert(plr->GetGUID());
+        m_InvitedPlayers[plr->GetTeamId()].erase(plr->GetGUID());
+        //Remove player AFK
+        if (plr->isAFK())
+            plr->ToggleAFK();
+
+        OnPlayerJoinWar(plr);                               //for scripting
+    }
+}
+
+void Battlefield::TeamCastSpell(TeamId team, int32 spellId)
+{
+    if (spellId > 0)
+        for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
+            if (Player* plr = sObjectMgr->GetPlayer(*itr))
+                plr->CastSpell(plr, (uint32) spellId, true);
+    else
+        for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
+            if (Player* plr = sObjectMgr->GetPlayer(*itr))
+                plr->RemoveAuraFromStack((uint32) - spellId);
+}
+
+void Battlefield::BroadcastPacketZone(WorldPacket & data) const
+{
+    for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
+        for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
+            if (Player* plr = sObjectMgr->GetPlayer(*itr))
+                plr->GetSession()->SendPacket(&data);
+}
+
+void Battlefield::BroadcastPacketQueue(WorldPacket & data) const
+{
+    for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
+        for (GuidSet::const_iterator itr = m_PlayersInQueue[team].begin(); itr != m_PlayersInQueue[team].end(); ++itr)
+            if (Player* plr = sObjectMgr->GetPlayer(*itr))
+                plr->GetSession()->SendPacket(&data);
+}
+
+void Battlefield::BroadcastPacketWar(WorldPacket & data) const
+{
+    for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
+        for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
+            if (Player* plr = sObjectMgr->GetPlayer(*itr))
+                plr->GetSession()->SendPacket(&data);
+}
+
+WorldPacket Battlefield::BuildWarningAnnPacket(std::string msg)
+{
+    WorldPacket data(SMSG_MESSAGECHAT, 200);
+
+    data << uint8(CHAT_MSG_RAID_BOSS_EMOTE);
+    data << uint32(LANG_UNIVERSAL);
+    data << uint64(0);
+    data << uint32(0);                                      // 2.1.0
+    data << uint32(1);
+    data << uint8(0);
+    data << uint64(0);
+    data << uint32(strlen(msg.c_str()) + 1);
+    data << msg.c_str();
+    data << uint8(0);
+
+    return data;
+}
+
+void Battlefield::SendWarningToAllInZone(uint32 entry)
+{
+    if (Unit* unit = sObjectAccessor->FindUnit(StalkerGuid))
+        if (Creature* stalker = unit->ToCreature())
+            // FIXME: replaced CHAT_TYPE_END with CHAT_MSG_BG_SYSTEM_NEUTRAL to fix compile, it's a guessed change :/
+            sCreatureTextMgr->SendChat(stalker, (uint8) entry, NULL, CHAT_MSG_BG_SYSTEM_NEUTRAL, LANG_ADDON, TEXT_RANGE_ZONE);
+}
+
+/*void Battlefield::SendWarningToAllInWar(int32 entry,...)
+{
+    const char *format = sObjectMgr->GetTrinityStringForDBCLocale(entry);
+    va_list ap;
+    char str [1024];
+    va_start(ap, entry);
+    vsnprintf(str,1024,format, ap);
+    va_end(ap);
+    std::string msg = (std::string)str;
+
+    WorldPacket data = BuildWarningAnnPacket(msg);
+    BroadcastPacketWar(data);
+}*/
+void Battlefield::SendWarningToPlayer(Player *plr, uint32 entry)
+{
+    if (!plr)
+        return;
+
+    if (Unit* unit = sObjectAccessor->FindUnit(StalkerGuid))
+        if (Creature* stalker = unit->ToCreature())
+            sCreatureTextMgr->SendChat(stalker, (uint8)entry, plr->GetGUID());
+}
+
+void Battlefield::SendUpdateWorldState(uint32 field, uint32 value)
+{
+    for (uint8 i = 0; i < BG_TEAMS_COUNT; ++i)
+        for (GuidSet::iterator itr = m_players[i].begin(); itr != m_players[i].end(); ++itr)
+            if (Player* plr = sObjectMgr->GetPlayer(*itr))
+                plr->SendUpdateWorldState(field, value);
+}
+
+void Battlefield::RegisterZone(uint32 zoneId)
+{
+    sBattlefieldMgr.AddZone(zoneId, this);
+}
+
+void Battlefield::HideNpc(Creature *p_Creature)
+{
+    p_Creature->CombatStop();
+    p_Creature->SetReactState(REACT_PASSIVE);
+    p_Creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
+    p_Creature->SetPhaseMask(2, true);
+    p_Creature->DisappearAndDie();
+    p_Creature->SetVisible(false);
+}
+
+void Battlefield::ShowNpc(Creature *p_Creature, bool p_Aggressive)
+{
+    p_Creature->SetPhaseMask(1, true);
+    p_Creature->SetVisible(true);
+    p_Creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
+    if (!p_Creature->isAlive())
+        p_Creature->Respawn(true);
+    if (p_Aggressive)
+        p_Creature->SetReactState(REACT_AGGRESSIVE);
+    else
+    {
+        p_Creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
+        p_Creature->SetReactState(REACT_PASSIVE);
+    }
+}
+
+//*****************************************************
+//*******************Group System**********************
+//*****************************************************
+Group *Battlefield::GetFreeBfRaid(TeamId TeamId)
+{
+    //if found free group we return it
+    for (GuidSet::const_iterator itr = m_Groups[TeamId].begin(); itr != m_Groups[TeamId].end(); ++itr)
+        if (Group* group = sGroupMgr->GetGroupByGUID(*itr))
+            if (!group->IsFull())
+                return group;
+
+    return NULL;
+}
+
+Group *Battlefield::GetGroupPlayer(uint64 guid, TeamId TeamId)
+{
+    for (GuidSet::const_iterator itr = m_Groups[TeamId].begin(); itr != m_Groups[TeamId].end(); ++itr)
+        if (Group* group = sGroupMgr->GetGroupByGUID(*itr))
+            if (group->IsMember(guid))
+                return group;
+
+    return NULL;
+}
+
+bool Battlefield::AddOrSetPlayerToCorrectBfGroup(Player *plr)
+{
+    if (!plr->IsInWorld())
+        return false;
+
+    if (Group* group = plr->GetGroup())
+        group->RemoveMember(plr->GetGUID());
+
+    Group* group = GetFreeBfRaid(plr->GetTeamId());
+    if (!group)
+    {
+        group = new Group;
+        group->SetBattlefieldGroup(this);
+        group->Create(plr);
+        sGroupMgr->AddGroup(group);
+        m_Groups[plr->GetTeamId()].insert(group->GetGUID());
+    }
+    else if (group->IsMember(plr->GetGUID()))
+    {
+        uint8 subgroup = group->GetMemberGroup(plr->GetGUID());
+        plr->SetBattlegroundOrBattlefieldRaid(group, subgroup);
+    }
+    else
+        group->AddMember(plr);
+
+    return true;
+}
+
+//***************End of Group System*******************
+
+//*****************************************************
+//***************Spirit Guide System*******************
+//*****************************************************
+//--------------------
+//-Battlefield Method-
+//--------------------
+BfGraveYard *Battlefield::GetGraveYardById(uint32 id)
+{
+    if (id < m_GraveYardList.size())
+    {
+        if (m_GraveYardList[id])
+            return m_GraveYardList[id];
+        else
+            sLog->outError("Battlefield::GetGraveYardById Id:%u not existed", id);
+    }
+    else
+        sLog->outError("Battlefield::GetGraveYardById Id:%u cant be found", id);
+
+    return NULL;
+}
+
+WorldSafeLocsEntry const *Battlefield::GetClosestGraveYard(Player *plr)
+{
+    BfGraveYard* closestGY = NULL;
+    float maxdist = -1;
+    for (uint8 i = 0; i < m_GraveYardList.size(); i++)
+    {
+        if (m_GraveYardList[i])
+        {
+            if (m_GraveYardList[i]->GetControlTeamId() != plr->GetTeamId())
+                continue;
+
+            float dist = m_GraveYardList[i]->GetDistance(plr);
+            if (dist < maxdist || maxdist < 0)
+            {
+                closestGY = m_GraveYardList[i];
+                maxdist = dist;
+            }
+        }
+    }
+
+    if (closestGY)
+        return sWorldSafeLocsStore.LookupEntry(closestGY->GetGraveYardId());
+
+    return NULL;
+}
+
+void Battlefield::AddPlayerToResurrectQueue(uint64 npc_guid, uint64 player_guid)
+{
+    for (uint8 i = 0; i < m_GraveYardList.size(); i++)
+    {
+        if (!m_GraveYardList[i])
+            continue;
+
+        if (m_GraveYardList[i]->HasNpc(npc_guid))
+        {
+            m_GraveYardList[i]->AddPlayer(player_guid);
+            break;
+        }
+    }
+}
+
+void Battlefield::RemovePlayerFromResurrectQueue(uint64 player_guid)
+{
+    for (uint8 i = 0; i < m_GraveYardList.size(); i++)
+    {
+        if (!m_GraveYardList[i])
+            continue;
+
+        if (m_GraveYardList[i]->HasPlayer(player_guid))
+        {
+            m_GraveYardList[i]->RemovePlayer(player_guid);
+            break;
+        }
+    }
+}
+
+void Battlefield::SendAreaSpiritHealerQueryOpcode(Player *pl, const uint64 &guid)
+{
+    sLog->outError("SendAreaSpiritHealerQueryOpcode");
+    WorldPacket data(SMSG_AREA_SPIRIT_HEALER_TIME, 12);
+    uint32 time = m_LastResurectTimer;  // resurrect every 30 seconds
+
+    data << guid << time;
+    ASSERT(pl && pl->GetSession());
+    pl->GetSession()->SendPacket(&data);
+}
+
+bool Battlefield::IncrementQuest(Player *player, uint32 quest, bool complete)
+{
+    if (!player)
+        return false;
+
+    Quest const* pQuest = sObjectMgr->GetQuestTemplate(quest);
+    if (!pQuest || player->GetQuestStatus(quest) == QUEST_STATUS_NONE)
+        return false;
+
+    if (complete)
+    {
+        player->CompleteQuest(quest);
+        return true;
+    }
+    else
+    {
+        for (uint8 i = 0; i < QUEST_OBJECTIVES_COUNT; ++i)
+        {
+            int32 creature = pQuest->ReqCreatureOrGOId[i];
+            if (uint32 spell_id = pQuest->ReqSpell[i])
+            {
+                player->CastedCreatureOrGO(creature, 0, spell_id);
+                return true;
+            }
+            else if (creature > 0)
+            {
+                player->KilledMonsterCredit(creature, 0);
+                return true;
+            }
+            else if (creature < 0)
+            {
+                player->CastedCreatureOrGO(creature, 0, 0);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+//--------------------
+//-BfGraveYard Method-
+//--------------------
+BfGraveYard::BfGraveYard(Battlefield *Bf)
+{
+    m_Bf = Bf;
+    m_GraveyardId = 0;
+    m_ControlTeam = TEAM_NEUTRAL;
+    m_SpiritGuide[0] = NULL;
+    m_SpiritGuide[1] = NULL;
+    m_ResurrectQueue.clear();
+}
+
+void BfGraveYard::Init(uint32 horde_entry, uint32 alliance_entry, float x, float y, float z, float o, TeamId startcontrol, uint32 gy)
+{
+    m_ControlTeam = startcontrol;
+    if (Creature* cre = m_Bf->SpawnCreature(horde_entry, x, y, z, o, TEAM_HORDE))
+    {
+        m_SpiritGuide[TEAM_HORDE] = cre;
+        m_SpiritGuide[TEAM_HORDE]->SetReactState(REACT_PASSIVE);
+        if (m_ControlTeam == TEAM_ALLIANCE)
+            m_SpiritGuide[TEAM_HORDE]->SetVisible(false);
+    }
+    else
+        sLog->outError("BfGraveYard::Init can't spawn horde spiritguide %u", horde_entry);
+
+    if (Creature* cre = m_Bf->SpawnCreature(alliance_entry, x, y, z, o, TEAM_ALLIANCE))
+    {
+        m_SpiritGuide[TEAM_ALLIANCE] = cre;
+        m_SpiritGuide[TEAM_ALLIANCE]->SetReactState(REACT_PASSIVE);
+        if (m_ControlTeam == TEAM_HORDE)
+            m_SpiritGuide[TEAM_ALLIANCE]->SetVisible(false);
+    }
+    else
+        sLog->outError("BfGraveYard::Init can't spawn alliance spiritguide %u", alliance_entry);
+
+    m_GraveyardId = gy;
+}
+
+float BfGraveYard::GetDistance(Player *plr)
+{
+    const WorldSafeLocsEntry* ws = sWorldSafeLocsStore.LookupEntry(m_GraveyardId);
+    return plr->GetDistance2d(ws->x, ws->y);
+}
+
+void BfGraveYard::AddPlayer(uint64 player_guid)
+{
+    if (!m_ResurrectQueue.count(player_guid))
+    {
+        m_ResurrectQueue.insert(player_guid);
+
+        if (Player* plr = sObjectMgr->GetPlayer(player_guid))
+            plr->CastSpell(plr, SPELL_WAITING_FOR_RESURRECT, true);
+    }
+}
+
+void BfGraveYard::RemovePlayer(uint64 player_guid)
+{
+    m_ResurrectQueue.erase(m_ResurrectQueue.find(player_guid));
+
+    if (Player* plr = sObjectMgr->GetPlayer(player_guid))
+        plr->RemoveAurasDueToSpell(SPELL_WAITING_FOR_RESURRECT);
+}
+
+void BfGraveYard::Resurrect()
+{
+    if (m_ResurrectQueue.empty())
+        return;
+
+    for (GuidSet::const_iterator itr = m_ResurrectQueue.begin(); itr != m_ResurrectQueue.end(); ++itr)
+    {
+        // Get player object from his guid
+        Player* plr = sObjectMgr->GetPlayer(*itr);
+        if (!plr)
+            continue;
+
+        // Check player isinworld and player is on good graveyard
+        if (plr->IsInWorld())
+            if (m_SpiritGuide[m_ControlTeam])
+                m_SpiritGuide[m_ControlTeam]->CastSpell(m_SpiritGuide[m_ControlTeam], SPELL_SPIRIT_HEAL, true);
+
+        // Resurect player
+        plr->CastSpell(plr, SPELL_RESURRECTION_VISUAL, true);
+        plr->ResurrectPlayer(1.0f);
+        plr->CastSpell(plr, 6962, true);
+        plr->CastSpell(plr, SPELL_SPIRIT_HEAL_MANA, true);
+
+        sObjectAccessor->ConvertCorpseForPlayer(plr->GetGUID());
+    }
+
+    m_ResurrectQueue.clear();
+}
+
+// For changing graveyard control
+void BfGraveYard::ChangeControl(TeamId team)
+{
+    // Guide switching
+    if (m_SpiritGuide[1 - team])
+        m_SpiritGuide[1 - team]->SetVisible(false);
+    if (m_SpiritGuide[team])
+        m_SpiritGuide[team]->SetVisible(true);
+
+    m_ControlTeam = team;
+    // Teleport to other graveyard, player witch were on this graveyard
+    RelocateDeadPlayers();
+}
+
+void BfGraveYard::RelocateDeadPlayers()
+{
+    WorldSafeLocsEntry const* ClosestGrave = NULL;
+    for (GuidSet::const_iterator itr = m_ResurrectQueue.begin(); itr != m_ResurrectQueue.end(); ++itr)
+    {
+        Player* plr = sObjectMgr->GetPlayer(*itr);
+        if (!plr)
+            continue;
+
+        if (ClosestGrave)
+            plr->TeleportTo(plr->GetMapId(), ClosestGrave->x, ClosestGrave->y, ClosestGrave->z, plr->GetOrientation());
+        else
+        {
+            ClosestGrave = m_Bf->GetClosestGraveYard(plr);
+            if (ClosestGrave)
+                plr->TeleportTo(plr->GetMapId(), ClosestGrave->x, ClosestGrave->y, ClosestGrave->z, plr->GetOrientation());
+        }
+    }
+}
+
+//***************End Spirit Guide system***************
+
+//*****************************************************
+//**********************Misc***************************
+//*****************************************************
+//Method for spawn creature on map
+Creature *Battlefield::SpawnCreature(uint32 entry, Position pos, TeamId team)
+{
+    return SpawnCreature(entry, pos.m_positionX, pos.m_positionY, pos.m_positionZ, pos.m_orientation, team);
+}
+
+Creature *Battlefield::SpawnCreature(uint32 entry, float x, float y, float z, float o, TeamId team)
+{
+    //Get map object
+    Map* map = const_cast < Map * >(sMapMgr->CreateBaseMap(m_MapId));
+    if (!map)
+    {
+        sLog->outError("Can't create creature entry: %u map not found", entry);
+        return 0;
+    }
+
+    //Create creature
+    Creature* pCreature = new Creature;
+    if (!pCreature->Create(sObjectMgr->GenerateLowGuid(HIGHGUID_UNIT), map, PHASEMASK_NORMAL, entry, 0, team, x, y, z, o))
+    {
+        sLog->outError("Can't create creature entry: %u", entry);
+        delete pCreature;
+        return NULL;
+    }
+
+    pCreature->SetHomePosition(x, y, z, o);
+
+    CreatureTemplate const* cinfo = sObjectMgr->GetCreatureTemplate(entry);
+    if (!cinfo)
+    {
+        sLog->outErrorDb("Battleground::AddCreature: entry %u does not exist.", entry);
+        return NULL;
+    }
+    // force using DB speeds -- do we really need this?
+    pCreature->SetSpeed(MOVE_WALK, cinfo->speed_walk);
+    pCreature->SetSpeed(MOVE_RUN, cinfo->speed_run);
+
+    // Set creature in world
+    map->Add(pCreature);
+    pCreature->setActive(true);
+
+    return pCreature;
+}
+
+// Method for spawning gameobject on map
+GameObject *Battlefield::SpawnGameObject(uint32 entry, float x, float y, float z, float o)
+{
+    // Get map object
+    Map* map = const_cast < Map * >(sMapMgr->CreateBaseMap(571));
+    if (!map)
+        return 0;
+
+    // Create gameobject
+    GameObject* go = new GameObject;
+    if (!go->Create(sObjectMgr->GenerateLowGuid(HIGHGUID_GAMEOBJECT), entry, map, PHASEMASK_NORMAL, x, y, z, o, 0, 0, 0, 0, 100, GO_STATE_READY))
+    {
+        sLog->outErrorDb("Gameobject template %u not found in database! Battleground not created!", entry);
+        sLog->outError("Cannot create gameobject template %u! Battleground not created!", entry);
+        delete go;
+        return NULL;
+    }
+
+    // Add in the world
+    map->Add(go);
+    go->setActive(true);
+    return go;
+}
+
+//*****************************************************
+//*******************CapturePoint**********************
+//*****************************************************
+
+BfCapturePoint::BfCapturePoint(Battlefield *Bf):m_Bf(Bf), m_capturePoint(NULL)
+{
+    m_team = TEAM_NEUTRAL;
+    m_value = 0;
+    m_maxValue = 0;
+    m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL;
+    m_OldState = BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL;
+    m_capturePointEntry = 0;
+    m_neutralValuePct = 0;
+    m_maxSpeed = 0;
+}
+
+bool BfCapturePoint::HandlePlayerEnter(Player *plr)
+{
+    if (m_capturePoint)
+    {
+        plr->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldState1, 1);
+        plr->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldstate2, (uint32) ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f));
+        plr->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldstate3, m_neutralValuePct);
+    }
+    return m_activePlayers[plr->GetTeamId()].insert(plr->GetGUID()).second;
+}
+
+void BfCapturePoint::HandlePlayerLeave(Player *plr)
+{
+    if (m_capturePoint)
+        plr->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldState1, 0);
+    m_activePlayers[plr->GetTeamId()].erase(plr->GetGUID());
+}
+
+void BfCapturePoint::SendChangePhase()
+{
+    if (!m_capturePoint)
+        return;
+
+    // send this too, sometimes the slider disappears, dunno why :(
+    SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldState1, 1);
+    // send these updates to only the ones in this objective
+    SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldstate2, (uint32) ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f));
+    // send this too, sometimes it resets :S
+    SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldstate3, m_neutralValuePct);
+}
+
+bool BfCapturePoint::SetCapturePointData(uint32 entry, uint32 /*map */ , float x, float y, float z, float o)
+{
+    sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Creating capture point %u", entry);
+
+    // check info existence
+    GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(entry);
+    if (!goinfo || goinfo->type != GAMEOBJECT_TYPE_CAPTURE_POINT)
+    {
+        sLog->outError("OutdoorPvP: GO %u is not capture point!", entry);
+        return false;
+    }
+    m_capturePoint = m_Bf->SpawnGameObject(entry, x, y, z, o);
+    if (m_capturePoint)
+    {
+        // get the needed values from goinfo
+        m_maxValue = goinfo->capturePoint.maxTime;
+        m_maxSpeed = m_maxValue / (goinfo->capturePoint.minTime ? goinfo->capturePoint.minTime : 60);
+        m_neutralValuePct = goinfo->capturePoint.neutralPercent;
+        m_minValue = m_maxValue * goinfo->capturePoint.neutralPercent / 100;
+        m_capturePointEntry = entry;
+        if (m_team == TEAM_ALLIANCE)
+        {
+            m_value = m_maxValue;
+            m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE;
+        }
+        else
+        {
+            m_value = -m_maxValue;
+            m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE;
+        }
+        return true;
+    }
+
+    return false;
+}
+
+bool BfCapturePoint::DelCapturePoint()
+{
+    if (m_capturePoint)
+    {
+        m_capturePoint->SetRespawnTime(0);                  // not save respawn time
+        m_capturePoint->Delete();
+        m_capturePoint = NULL;
+    }
+
+    return true;
+}
+
+bool BfCapturePoint::Update(uint32 diff)
+{
+    if (!m_capturePoint)
+        return false;
+
+    float radius = m_capturePoint->GetGOInfo()->capturePoint.radius;
+
+    for (uint8 team = 0; team < 2; ++team)
+        for (GuidSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr)
+            if (Player* plr = sObjectMgr->GetPlayer(*itr))
+                if (!m_capturePoint->IsWithinDistInMap(plr, radius) || !plr->IsOutdoorPvPActive())
+                    HandlePlayerLeave(plr);
+
+    std::list < Player * >players;
+    Trinity::AnyPlayerInObjectRangeCheck checker(m_capturePoint, radius);
+    Trinity::PlayerListSearcher < Trinity::AnyPlayerInObjectRangeCheck > searcher(m_capturePoint, players, checker);
+    m_capturePoint->VisitNearbyWorldObject(radius, searcher);
+
+    for (std::list < Player * >::iterator itr = players.begin(); itr != players.end(); ++itr)
+        if ((*itr)->IsOutdoorPvPActive())
+            if (m_activePlayers[(*itr)->GetTeamId()].insert((*itr)->GetGUID()).second)
+                HandlePlayerEnter(*itr);
+
+    // get the difference of numbers
+    float fact_diff = ((float) m_activePlayers[0].size() - (float) m_activePlayers[1].size()) * diff / BATTLEFIELD_OBJECTIVE_UPDATE_INTERVAL;
+    if (!fact_diff)
+        return false;
+
+    uint32 Challenger = 0;
+    float maxDiff = m_maxSpeed * diff;
+
+    if (fact_diff < 0)
+    {
+        // horde is in majority, but it's already horde-controlled -> no change
+        if (m_State == BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE && m_value <= -m_maxValue)
+            return false;
+
+        if (fact_diff < -maxDiff)
+            fact_diff = -maxDiff;
+
+        Challenger = HORDE;
+    }
+    else
+    {
+        // ally is in majority, but it's already ally-controlled -> no change
+        if (m_State == BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE && m_value >= m_maxValue)
+            return false;
+
+        if (fact_diff > maxDiff)
+            fact_diff = maxDiff;
+
+        Challenger = ALLIANCE;
+    }
+
+    float oldValue = m_value;
+    TeamId oldTeam = m_team;
+
+    m_OldState = m_State;
+
+    m_value += fact_diff;
+
+    if (m_value < -m_minValue)                              // red
+    {
+        if (m_value < -m_maxValue)
+            m_value = -m_maxValue;
+        m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE;
+        m_team = TEAM_HORDE;
+    }
+    else if (m_value > m_minValue)                          // blue
+    {
+        if (m_value > m_maxValue)
+            m_value = m_maxValue;
+        m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE;
+        m_team = TEAM_ALLIANCE;
+    }
+    else if (oldValue * m_value <= 0)                       // grey, go through mid point
+    {
+        // if challenger is ally, then n->a challenge
+        if (Challenger == ALLIANCE)
+            m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE;
+        // if challenger is horde, then n->h challenge
+        else if (Challenger == HORDE)
+            m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE;
+        m_team = TEAM_NEUTRAL;
+    }
+    else                                                    // grey, did not go through mid point
+    {
+        // old phase and current are on the same side, so one team challenges the other
+        if (Challenger == ALLIANCE && (m_OldState == BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE || m_OldState == BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE))
+            m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE;
+        else if (Challenger == HORDE && (m_OldState == BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE || m_OldState == BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE))
+            m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE;
+        m_team = TEAM_NEUTRAL;
+    }
+
+    if (m_value != oldValue)
+        SendChangePhase();
+
+    if (m_OldState != m_State)
+    {
+        //sLog->outError("%u->%u", m_OldState, m_State);
+        if (oldTeam != m_team)
+            ChangeTeam(oldTeam);
+        return true;
+    }
+
+    return false;
+}
+
+void BfCapturePoint::SendUpdateWorldState(uint32 field, uint32 value)
+{
+    for (uint8 team = 0; team < 2; ++team)
+        for (GuidSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr)  // send to all players present in the area
+            if (Player* plr = sObjectMgr->GetPlayer(*itr))
+                plr->SendUpdateWorldState(field, value);
+}
+
+void BfCapturePoint::SendObjectiveComplete(uint32 id, uint64 guid)
+{
+    uint8 team;
+    switch (m_State)
+    {
+        case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE:
+            team = 0;
+            break;
+        case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE:
+            team = 1;
+            break;
+        default:
+            return;
+    }
+
+    // send to all players present in the area
+    for (GuidSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr)
+        if (Player* plr = sObjectMgr->GetPlayer(*itr))
+            plr->KilledMonsterCredit(id, guid);
+}
+
+bool BfCapturePoint::IsInsideObjective(Player *plr) const
+{
+    return m_activePlayers[plr->GetTeamId()].find(plr->GetGUID()) != m_activePlayers[plr->GetTeamId()].end();
+}
diff --git a/src/server/game/Battlefield/Zones/BattlefieldWG.cpp b/src/server/game/Battlefield/Zones/BattlefieldWG.cpp
index 81e661bd02c..43bce64f5f9 100644
--- a/src/server/game/Battlefield/Zones/BattlefieldWG.cpp
+++ b/src/server/game/Battlefield/Zones/BattlefieldWG.cpp
@@ -43,12 +43,12 @@ bool BattlefieldWG::SetupBattlefield()
     m_enable = sWorld->getBoolConfig(CONFIG_WINTERGRASP_ENABLE);
     m_MinPlayer = sWorld->getIntConfig(CONFIG_WINTERGRASP_PLR_MIN);
     m_MinLevel = sWorld->getIntConfig(CONFIG_WINTERGRASP_PLR_MIN_LVL);
-    m_BattleTime = sWorld->getIntConfig(CONFIG_WINTERGRASP_BATTLETIME) * MINUTE;
-    m_NoWarBattleTime = sWorld->getIntConfig(CONFIG_WINTERGRASP_NOBATTLETIME) * MINUTE;
-    m_RestartAfterCrash = sWorld->getIntConfig(CONFIG_WINTERGRASP_RESTART_AFTER_CRASH) * MINUTE;
+    m_BattleTime = sWorld->getIntConfig(CONFIG_WINTERGRASP_BATTLETIME) * MINUTE * IN_MILLISECONDS;
+    m_NoWarBattleTime = sWorld->getIntConfig(CONFIG_WINTERGRASP_NOBATTLETIME) * MINUTE * IN_MILLISECONDS;
+    m_RestartAfterCrash = sWorld->getIntConfig(CONFIG_WINTERGRASP_RESTART_AFTER_CRASH) * MINUTE * IN_MILLISECONDS;
 
     m_TimeForAcceptInvite = 20;
-    m_StartGroupingTimer = 15 * MINUTE;
+    m_StartGroupingTimer = 15 * MINUTE * IN_MILLISECONDS;
     m_StartGrouping = false;
 
     m_tenacityStack = 0;
@@ -138,7 +138,7 @@ bool BattlefieldWG::SetupBattlefield()
     }
     // Hide keep npc
     for (GuidSet::const_iterator itr = KeepCreature[GetAttackerTeam()].begin(); itr != KeepCreature[GetAttackerTeam()].end(); ++itr)
-        if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+        if (Unit* unit = sObjectAccessor->FindUnit(*itr))
             if (Creature* creature = unit->ToCreature())
                 HideNpc(creature);
     // Spawn out of keep npc
@@ -152,7 +152,7 @@ bool BattlefieldWG::SetupBattlefield()
             OutsideCreature[TEAM_ALLIANCE].insert(creature->GetGUID());
     // Hide outside npc
     for (GuidSet::const_iterator itr = OutsideCreature[GetDefenderTeam()].begin(); itr != OutsideCreature[GetDefenderTeam()].end(); ++itr)
-        if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+        if (Unit* unit = sObjectAccessor->FindUnit(*itr))
             if (Creature* creature = unit->ToCreature())
                 HideNpc(creature);
     for (uint8 i = 0; i < WG_MAX_TURRET; i++)
@@ -221,7 +221,7 @@ bool BattlefieldWG::Update(uint32 diff)
         m_saveTimer -= diff;
 
     for (GuidSet::const_iterator itr = m_PlayersIsSpellImu.begin(); itr != m_PlayersIsSpellImu.end(); ++itr)
-        if (Player* player = sObjectMgr->GetPlayer((*itr)))
+        if (Player* player = sObjectMgr->GetPlayer(*itr))
         {
             if (player->HasAura(SPELL_SPIRITUAL_IMMUNITY))
             {
@@ -241,7 +241,7 @@ bool BattlefieldWG::Update(uint32 diff)
     {
         for (uint8 team = 0; team < 2; ++team)
             for (GuidSet::const_iterator itr = m_vehicles[team].begin(); itr != m_vehicles[team].end(); ++itr)
-                if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+                if (Unit* unit = sObjectAccessor->FindUnit(*itr))
                 {
                     if (unit->IsInWater() && !unit->HasAura(SPELL_WINTERGRASP_WATER))
                         unit->AddAura(SPELL_WINTERGRASP_WATER, unit);
@@ -253,7 +253,7 @@ bool BattlefieldWG::Update(uint32 diff)
 
     for (uint8 team = 0; team < 2; ++team)
         for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
-            if (Player* player = sObjectMgr->GetPlayer((*itr)))
+            if (Player* player = sObjectMgr->GetPlayer(*itr))
                 for (BfCapturePointMap::iterator cp_itr = m_capturePoints.begin(); cp_itr != m_capturePoints.end(); ++cp_itr)
                 {
                     if ((*cp_itr).second->GetCapturePointGo()->GetExactDist2dSq(player) < 22500.0f) // 150*150
@@ -301,7 +301,7 @@ void BattlefieldWG::OnBattleStart()
     // Update tower visibility and update faction
     for (GuidSet::const_iterator itr = CanonList.begin(); itr != CanonList.end(); ++itr)
     {
-        if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+        if (Unit* unit = sObjectAccessor->FindUnit(*itr))
         {
             if (Creature* creature = unit->ToCreature())
             {
@@ -314,7 +314,7 @@ void BattlefieldWG::OnBattleStart()
     // Rebuild all wall
     for (GameObjectBuilding::const_iterator itr = BuildingsInZone.begin(); itr != BuildingsInZone.end(); ++itr)
     {
-        if ((*itr))
+        if (*itr)
         {
             (*itr)->Rebuild();
             (*itr)->UpdateTurretAttack(false);
@@ -329,15 +329,15 @@ void BattlefieldWG::OnBattleStart()
     // Update graveyard (in no war time all graveyard is to deffender, in war time, depend of base)
     for (WorkShop::const_iterator itr = WorkShopList.begin(); itr != WorkShopList.end(); ++itr)
     {
-        if ((*itr))
+        if (*itr)
             (*itr)->UpdateGraveYardAndWorkshop();
     }
 
     for (uint8 team = 0; team < 2; ++team)
-        for (GuidSet::const_iterator p_itr = m_players[team].begin(); p_itr != m_players[team].end(); ++p_itr)
+        for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
         {
             // Kick player in orb room, TODO: offline player ?
-            if (Player* player = sObjectMgr->GetPlayer((*p_itr)))
+            if (Player* player = sObjectMgr->GetPlayer(*itr))
             {
                 float x, y, z;
                 player->GetPosition(x, y, z);
@@ -364,7 +364,7 @@ void BattlefieldWG::UpdateCounterVehicle(bool init)
 
     for (WorkShop::const_iterator itr = WorkShopList.begin(); itr != WorkShopList.end(); ++itr)
     {
-        if (BfWGWorkShopData * workshop = (*itr))
+        if (BfWGWorkShopData* workshop = *itr)
         {
             if (workshop->m_TeamControl == TEAM_ALLIANCE)
                 m_Data32[BATTLEFIELD_WG_DATA_MAX_VEHICLE_A] = m_Data32[BATTLEFIELD_WG_DATA_MAX_VEHICLE_A] + 4;
@@ -386,7 +386,7 @@ void BattlefieldWG::OnBattleEnd(bool endbytimer)
     // Remove turret
     for (GuidSet::const_iterator itr = CanonList.begin(); itr != CanonList.end(); ++itr)
     {
-        if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+        if (Unit* unit = sObjectAccessor->FindUnit(*itr))
         {
             if (Creature* creature = unit->ToCreature())
             {
@@ -403,26 +403,26 @@ void BattlefieldWG::OnBattleEnd(bool endbytimer)
         // Change all npc in keep
         for (GuidSet::const_iterator itr = KeepCreature[GetAttackerTeam()].begin(); itr != KeepCreature[GetAttackerTeam()].end(); ++itr)
         {
-            if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
                 if (Creature* creature = unit->ToCreature())
                     HideNpc(creature);
         }
         for (GuidSet::const_iterator itr = KeepCreature[GetDefenderTeam()].begin(); itr != KeepCreature[GetDefenderTeam()].end(); ++itr)
         {
-            if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
                 if (Creature* creature = unit->ToCreature())
                     ShowNpc(creature, true);
         }
         // Change all npc out of keep
         for (GuidSet::const_iterator itr = OutsideCreature[GetDefenderTeam()].begin(); itr != OutsideCreature[GetDefenderTeam()].end(); ++itr)
         {
-            if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
                 if (Creature* creature = unit->ToCreature())
                     HideNpc(creature);
         }
         for (GuidSet::const_iterator itr = OutsideCreature[GetAttackerTeam()].begin(); itr != OutsideCreature[GetAttackerTeam()].end(); ++itr)
         {
-            if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
                 if (Creature* creature = unit->ToCreature())
                     ShowNpc(creature, true);
         }
@@ -469,7 +469,7 @@ void BattlefieldWG::OnBattleEnd(bool endbytimer)
 
     for (GuidSet::const_iterator itr = m_PlayersInWar[GetDefenderTeam()].begin(); itr != m_PlayersInWar[GetDefenderTeam()].end(); ++itr)
     {
-        if (Player* player = sObjectMgr->GetPlayer((*itr)))
+        if (Player* player = sObjectMgr->GetPlayer(*itr))
         {
             player->AddAura(SPELL_ESSENCE_OF_WINTERGRASP, player);
             if (player->HasAura(SPELL_LIEUTENANT))
@@ -492,7 +492,7 @@ void BattlefieldWG::OnBattleEnd(bool endbytimer)
     }
     for (GuidSet::const_iterator itr = m_PlayersInWar[GetAttackerTeam()].begin(); itr != m_PlayersInWar[GetAttackerTeam()].end(); ++itr)
     {
-        if (Player* player = sObjectMgr->GetPlayer((*itr)))
+        if (Player* player = sObjectMgr->GetPlayer(*itr))
         {
             if (player->HasAura(SPELL_LIEUTENANT))
             {
@@ -511,7 +511,7 @@ void BattlefieldWG::OnBattleEnd(bool endbytimer)
     {
         for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
         {
-            if (Player* player = sObjectMgr->GetPlayer((*itr)))
+            if (Player* player = sObjectMgr->GetPlayer(*itr))
             {
                 player->RemoveAura(SPELL_TOWER_CONTROL);
                 player->RemoveAurasDueToSpell(SPELL_RECRUIT);
@@ -525,7 +525,7 @@ void BattlefieldWG::OnBattleEnd(bool endbytimer)
 
         for (GuidSet::const_iterator itr = m_vehicles[team].begin(); itr != m_vehicles[team].end(); ++itr)
         {
-            if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
                 if (Creature* creature = unit->ToCreature())
                     if (creature->IsVehicle())
                         creature->GetVehicleKit()->Dismiss();
@@ -539,7 +539,7 @@ void BattlefieldWG::OnBattleEnd(bool endbytimer)
         {
             for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
             {
-                if (Player* player = sObjectMgr->GetPlayer((*itr)))
+                if (Player* player = sObjectMgr->GetPlayer(*itr))
                 {
                     player->RemoveAurasDueToSpell(m_DefenderTeam == TEAM_ALLIANCE ? SPELL_HORDE_CONTROL_PHASE_SHIFT : SPELL_ALLIANCE_CONTROL_PHASE_SHIFT, player->GetGUID());
                     player->AddAura(m_DefenderTeam == TEAM_HORDE ? SPELL_HORDE_CONTROL_PHASE_SHIFT : SPELL_ALLIANCE_CONTROL_PHASE_SHIFT, player);
@@ -690,9 +690,9 @@ void BattlefieldWG::HandleKill(Player* killer, Unit* victim)
     {
         IncrementQuest(killer, WGQuest[killer->GetTeamId()][4]);
         IncrementQuest(killer, WGQuest[killer->GetTeamId()][5]);
-        for (GuidSet::const_iterator p_itr = m_PlayersInWar[killer->GetTeamId()].begin(); p_itr != m_PlayersInWar[killer->GetTeamId()].end(); ++p_itr)
+        for (GuidSet::const_iterator itr = m_PlayersInWar[killer->GetTeamId()].begin(); itr != m_PlayersInWar[killer->GetTeamId()].end(); ++itr)
         {
-            if (Player* player = sObjectAccessor->FindPlayer(*p_itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
                 if (player->GetDistance2d(killer) < 40)
                     PromotePlayer(player);
         }
@@ -701,16 +701,16 @@ void BattlefieldWG::HandleKill(Player* killer, Unit* victim)
     for (GuidSet::const_iterator itr = m_vehicles[killer->GetTeamId()? TEAM_ALLIANCE : TEAM_HORDE].begin();
          itr != m_vehicles[killer->GetTeamId()? TEAM_ALLIANCE : TEAM_HORDE].end(); ++itr)
     {
-        if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+        if (Unit* unit = sObjectAccessor->FindUnit(*itr))
         {
             if (Creature* creature = unit->ToCreature())
             {
                 if (victim->GetEntry() == creature->GetEntry() && !again)
                 {
                     again = true;
-                    for (GuidSet::const_iterator p_itr = m_PlayersInWar[killer->GetTeamId()].begin(); p_itr != m_PlayersInWar[killer->GetTeamId()].end(); ++p_itr)
+                    for (GuidSet::const_iterator iter = m_PlayersInWar[killer->GetTeamId()].begin(); iter != m_PlayersInWar[killer->GetTeamId()].end(); ++iter)
                     {
-                        if (Player* player = sObjectAccessor->FindPlayer(*p_itr))
+                        if (Player* player = sObjectAccessor->FindPlayer(*iter))
                             if (player->GetDistance2d(killer) < 40)
                                 IncrementQuest(player, WGQuest[player->GetTeamId()][0]);
                     }
@@ -721,7 +721,7 @@ void BattlefieldWG::HandleKill(Player* killer, Unit* victim)
     for (GuidSet::const_iterator itr = KeepCreature[killer->GetTeamId()? TEAM_ALLIANCE : TEAM_HORDE].begin();
          itr != KeepCreature[killer->GetTeamId()? TEAM_ALLIANCE : TEAM_HORDE].end(); ++itr)
     {
-        if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+        if (Unit* unit = sObjectAccessor->FindUnit(*itr))
         {
             if (Creature* creature = unit->ToCreature())
             {
@@ -730,9 +730,9 @@ void BattlefieldWG::HandleKill(Player* killer, Unit* victim)
                     again = true;
                     IncrementQuest(killer, WGQuest[killer->GetTeamId()][4]);
                     IncrementQuest(killer, WGQuest[killer->GetTeamId()][5]);
-                    for (GuidSet::const_iterator p_itr = m_PlayersInWar[killer->GetTeamId()].begin(); p_itr != m_PlayersInWar[killer->GetTeamId()].end(); ++p_itr)
+                    for (GuidSet::const_iterator iter = m_PlayersInWar[killer->GetTeamId()].begin(); iter != m_PlayersInWar[killer->GetTeamId()].end(); ++iter)
                     {
-                        if (Player* player = sObjectAccessor->FindPlayer(*p_itr))
+                        if (Player* player = sObjectAccessor->FindPlayer(*iter))
                             if (player->GetDistance2d(killer) < 40)
                                 PromotePlayer(player);
                     }
@@ -925,7 +925,7 @@ void BattlefieldWG::SendInitWorldStatesToAll()
     WorldPacket data = BuildInitWorldStates();
     for (uint8 team = 0; team < 2; team++)
         for (GuidSet::iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
-            if (Player* player = sObjectMgr->GetPlayer((*itr)))
+            if (Player* player = sObjectMgr->GetPlayer(*itr))
                 player->GetSession()->SendPacket(&data);
 }
 
@@ -933,9 +933,9 @@ void BattlefieldWG::BrokenWallOrTower(TeamId team)
 {
     if (team == GetDefenderTeam())
     {
-        for (GuidSet::const_iterator p_itr = m_PlayersInWar[GetAttackerTeam()].begin(); p_itr != m_PlayersInWar[GetAttackerTeam()].end(); ++p_itr)
+        for (GuidSet::const_iterator itr = m_PlayersInWar[GetAttackerTeam()].begin(); itr != m_PlayersInWar[GetAttackerTeam()].end(); ++itr)
         {
-            if (Player* player = sObjectMgr->GetPlayer((*p_itr)))
+            if (Player* player = sObjectMgr->GetPlayer(*itr))
                 IncrementQuest(player, WGQuest[player->GetTeamId()][2], true);
         }
     }
@@ -952,12 +952,12 @@ void BattlefieldWG::AddBrokenTower(TeamId team)
 
         // Remove buff stack
         for (GuidSet::const_iterator itr = m_PlayersInWar[GetAttackerTeam()].begin(); itr != m_PlayersInWar[GetAttackerTeam()].end(); ++itr)
-            if (Player* player = sObjectMgr->GetPlayer((*itr)))
+            if (Player* player = sObjectMgr->GetPlayer(*itr))
                 player->RemoveAuraFromStack(SPELL_TOWER_CONTROL);
 
         // Add buff stack
         for (GuidSet::const_iterator itr = m_PlayersInWar[GetDefenderTeam()].begin(); itr != m_PlayersInWar[GetDefenderTeam()].end(); ++itr)
-            if (Player* player = sObjectMgr->GetPlayer((*itr)))
+            if (Player* player = sObjectMgr->GetPlayer(*itr))
             {
                 player->CastSpell(player, SPELL_TOWER_CONTROL, true);
                 IncrementQuest(player, WGQuest[player->GetTeamId()][3], true);
@@ -1071,12 +1071,12 @@ void BattlefieldWG::UpdateTenacity()
     if (team != TEAM_NEUTRAL)
     {
         for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
-            if (Player* player = sObjectMgr->GetPlayer((*itr)))
+            if (Player* player = sObjectMgr->GetPlayer(*itr))
                 if (player->getLevel() >= m_MinLevel)
                     player->RemoveAurasDueToSpell(SPELL_TENACITY);
 
         for (GuidSet::const_iterator itr = m_vehicles[team].begin(); itr != m_vehicles[team].end(); ++itr)
-            if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
                 if (Creature* creature = unit->ToCreature())
                     creature->RemoveAurasDueToSpell(SPELL_TENACITY_VEHICLE);
     }
@@ -1097,20 +1097,20 @@ void BattlefieldWG::UpdateTenacity()
         buff_honor = (newStack < 5) ? 0 : buff_honor;
 
         for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
-            if (Player* player = sObjectMgr->GetPlayer((*itr)))
+            if (Player* player = sObjectMgr->GetPlayer(*itr))
                 player->SetAuraStack(SPELL_TENACITY, player, newStack);
         for (GuidSet::const_iterator itr = m_vehicles[team].begin(); itr != m_vehicles[team].end(); ++itr)
-            if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
                 if (Creature* creature = unit->ToCreature())
                     creature->SetAuraStack(SPELL_TENACITY_VEHICLE, creature, newStack);
 
         if (buff_honor != 0)
         {
             for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
-                if (Player* player = sObjectMgr->GetPlayer((*itr)))
+                if (Player* player = sObjectMgr->GetPlayer(*itr))
                     player->AddAura(buff_honor, player);
             for (GuidSet::const_iterator itr = m_vehicles[team].begin(); itr != m_vehicles[team].end(); ++itr)
-                if (Unit* unit = sObjectAccessor->FindUnit((*itr)))
+                if (Unit* unit = sObjectAccessor->FindUnit(*itr))
                     if (Creature* creature = unit->ToCreature())
                         creature->AddAura(buff_honor, creature);
         }
diff --git a/src/server/game/Battlefield/Zones/BattlefieldWG.h b/src/server/game/Battlefield/Zones/BattlefieldWG.h
index 74974041fa4..6e604ef4e69 100644
--- a/src/server/game/Battlefield/Zones/BattlefieldWG.h
+++ b/src/server/game/Battlefield/Zones/BattlefieldWG.h
@@ -1387,13 +1387,13 @@ struct BfWGGameObjectBuilding
             m_WG->SendWarningToAllInZone(m_NameId);
 
         for (GuidSet::const_iterator itr = m_CreatureTopList[m_WG->GetAttackerTeam()].begin(); itr != m_CreatureTopList[m_WG->GetAttackerTeam()].end(); ++itr)
-            if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
-                if (Creature *creature = unit->ToCreature())
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
+                if (Creature* creature = unit->ToCreature())
                     m_WG->HideNpc(creature);
 
         for (GuidSet::const_iterator itr = m_TurretTopList.begin(); itr != m_TurretTopList.end(); ++itr)
-            if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
-                if (Creature *creature = unit->ToCreature())
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
+                if (Creature* creature = unit->ToCreature())
                     m_WG->HideNpc(creature);
 
         if (m_Type == BATTLEFIELD_WG_OBJECTTYPE_KEEP_TOWER)
@@ -1607,23 +1607,23 @@ struct BfWGGameObjectBuilding
     void UpdateCreatureAndGo()
     {
         for (GuidSet::const_iterator itr = m_CreatureTopList[m_WG->GetDefenderTeam()].begin(); itr != m_CreatureTopList[m_WG->GetDefenderTeam()].end(); ++itr)
-            if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
-                if (Creature *creature = unit->ToCreature())
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
+                if (Creature* creature = unit->ToCreature())
                     m_WG->HideNpc(creature);
 
         for (GuidSet::const_iterator itr = m_CreatureTopList[m_WG->GetAttackerTeam()].begin(); itr != m_CreatureTopList[m_WG->GetAttackerTeam()].end(); ++itr)
-            if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
-                if (Creature *creature = unit->ToCreature())
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
+                if (Creature* creature = unit->ToCreature())
                     m_WG->ShowNpc(creature, true);
 
         for (GuidSet::const_iterator itr = m_CreatureBottomList[m_WG->GetDefenderTeam()].begin(); itr != m_CreatureBottomList[m_WG->GetDefenderTeam()].end(); ++itr)
-            if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
-                if (Creature *creature = unit->ToCreature())
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
+                if (Creature* creature = unit->ToCreature())
                     m_WG->HideNpc(creature);
 
         for (GuidSet::const_iterator itr = m_CreatureBottomList[m_WG->GetAttackerTeam()].begin(); itr != m_CreatureBottomList[m_WG->GetAttackerTeam()].end(); ++itr)
-            if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
-                if (Creature *creature = unit->ToCreature())
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
+                if (Creature* creature = unit->ToCreature())
                     m_WG->ShowNpc(creature, true);
 
         for (GameObjectSet::const_iterator itr = m_GameObjectList[m_WG->GetDefenderTeam()].begin(); itr != m_GameObjectList[m_WG->GetDefenderTeam()].end(); ++itr)
@@ -1637,9 +1637,9 @@ struct BfWGGameObjectBuilding
     {
         for (GuidSet::const_iterator itr = m_TurretBottomList.begin(); itr != m_TurretBottomList.end(); ++itr)
         {
-            if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
             {
-                if (Creature *creature = unit->ToCreature())
+                if (Creature* creature = unit->ToCreature())
                 {
                     if (m_Build)
                     {
@@ -1694,9 +1694,9 @@ struct BfWGGameObjectBuilding
 
         for (GuidSet::const_iterator itr = m_TurretTopList.begin(); itr != m_TurretTopList.end(); ++itr)
         {
-            if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
+            if (Unit* unit = sObjectAccessor->FindUnit(*itr))
             {
-                if (Creature *creature = unit->ToCreature())
+                if (Creature* creature = unit->ToCreature())
                 {
                     if (m_Build)
                     {
@@ -1824,14 +1824,14 @@ struct BfWGWorkShopData
                 {
                     // Show Alliance creature
                     for (GuidSet::const_iterator itr = m_CreatureOnPoint[TEAM_ALLIANCE].begin(); itr != m_CreatureOnPoint[TEAM_ALLIANCE].end(); ++itr)
-                        if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
-                            if (Creature *creature = unit->ToCreature())
+                        if (Unit* unit = sObjectAccessor->FindUnit(*itr))
+                            if (Creature* creature = unit->ToCreature())
                                 m_WG->ShowNpc(creature, creature->GetEntry() != 30499);
 
                     // Hide Horde creature
                     for (GuidSet::const_iterator itr = m_CreatureOnPoint[TEAM_HORDE].begin(); itr != m_CreatureOnPoint[TEAM_HORDE].end(); ++itr)
-                        if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
-                            if (Creature *creature = unit->ToCreature())
+                        if (Unit* unit = sObjectAccessor->FindUnit(*itr))
+                            if (Creature* creature = unit->ToCreature())
                                 m_WG->HideNpc(creature);
 
                     // Show Alliance gameobject
@@ -1863,14 +1863,14 @@ struct BfWGWorkShopData
                 {
                     // Show Horde creature
                     for (GuidSet::const_iterator itr = m_CreatureOnPoint[TEAM_HORDE].begin(); itr != m_CreatureOnPoint[TEAM_HORDE].end(); ++itr)
-                        if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
-                            if (Creature *creature = unit->ToCreature())
+                        if (Unit* unit = sObjectAccessor->FindUnit(*itr))
+                            if (Creature* creature = unit->ToCreature())
                                 m_WG->ShowNpc(creature, creature->GetEntry() != 30400);
 
                     // Hide Alliance creature
                     for (GuidSet::const_iterator itr = m_CreatureOnPoint[TEAM_ALLIANCE].begin(); itr != m_CreatureOnPoint[TEAM_ALLIANCE].end(); ++itr)
-                        if (Unit *unit = sObjectAccessor->FindUnit((*itr)))
-                            if (Creature *creature = unit->ToCreature())
+                        if (Unit* unit = sObjectAccessor->FindUnit(*itr))
+                            if (Creature* creature = unit->ToCreature())
                                 m_WG->HideNpc(creature);
 
                     // Hide Alliance gameobject