Core/Battlefield: plr -> player

src/server/game/Battlefield/Battlefield.cpp

@@ -63,62 +63,62 @@ Battlefield::~Battlefield()
 {
 }
 
-void Battlefield::HandlePlayerEnterZone(Player *plr, uint32 /*zone */ )
+void Battlefield::HandlePlayerEnterZone(Player *player, 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
+        if (m_PlayersInWar[player->GetTeamId()].size() + m_InvitedPlayers[player->GetTeamId()].size() < m_MaxPlayer)  //Not fully
         {
-            InvitePlayerToWar(plr);
+            InvitePlayerToWar(player);
         }
         else                                                //Full
         {
             //TODO:Send packet for announce it to player
-            m_PlayersWillBeKick[plr->GetTeamId()][plr->GetGUID()] = time(NULL) + 10;
+            m_PlayersWillBeKick[player->GetTeamId()][player->GetGUID()] = time(NULL) + 10;
-            InvitePlayerToQueue(plr);
+            InvitePlayerToQueue(player);
         }
     }
     else
     {
         //If time left is <15 minutes invite player to join queue
         if (m_Timer <= m_StartGroupingTimer)
-            InvitePlayerToQueue(plr);
+            InvitePlayerToQueue(player);
     }
 
     //Add player in list of player in zone
-    m_players[plr->GetTeamId()].insert(plr->GetGUID());
+    m_players[player->GetTeamId()].insert(player->GetGUID());
-    OnPlayerEnterZone(plr);                                 //for scripting
+    OnPlayerEnterZone(player);                                 //for scripting
 }
 
 //Called when a player leave the zone
-void Battlefield::HandlePlayerLeaveZone(Player *plr, uint32 /*zone */ )
+void Battlefield::HandlePlayerLeaveZone(Player *player, uint32 /*zone */ )
 {
     if (IsWarTime())
     {
         //if player is in war list
-        if (m_PlayersInWar[plr->GetTeamId()].find(plr->GetGUID()) != m_PlayersInWar[plr->GetTeamId()].end())
+        if (m_PlayersInWar[player->GetTeamId()].find(player->GetGUID()) != m_PlayersInWar[player->GetTeamId()].end())
         {
-            m_PlayersInWar[plr->GetTeamId()].erase(plr->GetGUID());
+            m_PlayersInWar[player->GetTeamId()].erase(player->GetGUID());
-            plr->GetSession()->SendBfLeaveMessage(m_BattleId);
+            player->GetSession()->SendBfLeaveMessage(m_BattleId);
-            if (Group* group = plr->GetGroup())       // remove from raid group if player is member
+            if (Group* group = player->GetGroup())       // remove from raid group if player is member
-                group->RemoveMember(plr->GetGUID());
+                group->RemoveMember(player->GetGUID());
 
-            OnPlayerLeaveWar(plr);                          //For scripting
+            OnPlayerLeaveWar(player);                          //For scripting
         }
     }
 
     for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
-        itr->second->HandlePlayerLeave(plr);
+        itr->second->HandlePlayerLeave(player);
 
-    m_InvitedPlayers[plr->GetTeamId()].erase(plr->GetGUID());
+    m_InvitedPlayers[player->GetTeamId()].erase(player->GetGUID());
-    m_PlayersWillBeKick[plr->GetTeamId()].erase(plr->GetGUID());
+    m_PlayersWillBeKick[player->GetTeamId()].erase(player->GetGUID());
-    m_players[plr->GetTeamId()].erase(plr->GetGUID());
+    m_players[player->GetTeamId()].erase(player->GetGUID());
-    SendRemoveWorldStates(plr);
+    SendRemoveWorldStates(player);
-    RemovePlayerFromResurrectQueue(plr->GetGUID());
+    RemovePlayerFromResurrectQueue(player->GetGUID());
-    OnPlayerLeaveZone(plr);                                 //For scripting
+    OnPlayerLeaveZone(player);                                 //For scripting
 }
 
 bool Battlefield::Update(uint32 diff)
@@ -196,17 +196,17 @@ 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 = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
-                InvitePlayerToQueue(plr);
+                InvitePlayerToQueue(player);
 }
 
-void Battlefield::InvitePlayerToQueue(Player *plr)
+void Battlefield::InvitePlayerToQueue(Player *player)
 {
-    if (m_PlayersInQueue[plr->GetTeamId()].count(plr->GetGUID()))
+    if (m_PlayersInQueue[player->GetTeamId()].count(player->GetGUID()))
         return;
 
-    if (m_PlayersInQueue[plr->GetTeam()].size() <= m_MinPlayer || m_PlayersInQueue[plr->GetTeam() == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE].size() >= m_MinPlayer)
+    if (m_PlayersInQueue[player->GetTeam()].size() <= m_MinPlayer || m_PlayersInQueue[player->GetTeam() == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE].size() >= m_MinPlayer)
-        plr->GetSession()->SendBfInvitePlayerToQueue(m_BattleId);
+        player->GetSession()->SendBfInvitePlayerToQueue(m_BattleId);
 }
 
 void Battlefield::InvitePlayerInQueueToWar()
@@ -215,10 +215,10 @@ void Battlefield::InvitePlayerInQueueToWar()
     {
         for (GuidSet::const_iterator itr = m_PlayersInQueue[team].begin(); itr != m_PlayersInQueue[team].end(); ++itr)
         {
-            if (Player* plr = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
             {
-                if (m_PlayersInWar[plr->GetTeamId()].size() + m_InvitedPlayers[plr->GetTeamId()].size() < m_MaxPlayer)
+                if (m_PlayersInWar[player->GetTeamId()].size() + m_InvitedPlayers[player->GetTeamId()].size() < m_MaxPlayer)
-                    InvitePlayerToWar(plr);
+                    InvitePlayerToWar(player);
                 else
                 {
                     //Full
@@ -234,49 +234,49 @@ 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 = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
             {
-                if (m_PlayersInWar[plr->GetTeamId()].count(plr->GetGUID()) || m_InvitedPlayers[plr->GetTeamId()].count(plr->GetGUID()))
+                if (m_PlayersInWar[player->GetTeamId()].count(player->GetGUID()) || m_InvitedPlayers[player->GetTeamId()].count(player->GetGUID()))
                     continue;
-                if (m_PlayersInWar[plr->GetTeamId()].size() + m_InvitedPlayers[plr->GetTeamId()].size() < m_MaxPlayer)
+                if (m_PlayersInWar[player->GetTeamId()].size() + m_InvitedPlayers[player->GetTeamId()].size() < m_MaxPlayer)
-                    InvitePlayerToWar(plr);
+                    InvitePlayerToWar(player);
                 else
                 {
                     //full
-                    m_PlayersWillBeKick[plr->GetTeamId()][plr->GetGUID()] = time(NULL) + 10;
+                    m_PlayersWillBeKick[player->GetTeamId()][player->GetGUID()] = time(NULL) + 10;
                 }
             }
         }
 }
 
-void Battlefield::InvitePlayerToWar(Player *plr)
+void Battlefield::InvitePlayerToWar(Player *player)
 {
-    if (!plr)
+    if (!player)
         return;
 
     // TODO : needed ?
-    if (plr->isInFlight())
+    if (player->isInFlight())
         return;
 
-    if (plr->InArena() || plr->GetBattleground())
+    if (player->InArena() || player->GetBattleground())
     {
-        m_PlayersInQueue[plr->GetTeamId()].erase(plr->GetGUID());
+        m_PlayersInQueue[player->GetTeamId()].erase(player->GetGUID());
         return;
     }
 
-    if (plr->getLevel() < m_MinLevel)
+    if (player->getLevel() < m_MinLevel)
     {
-        if (m_PlayersWillBeKick[plr->GetTeamId()].count(plr->GetGUID()) == 0)
+        if (m_PlayersWillBeKick[player->GetTeamId()].count(player->GetGUID()) == 0)
-            m_PlayersWillBeKick[plr->GetTeamId()][plr->GetGUID()] = time(NULL) + 10;
+            m_PlayersWillBeKick[player->GetTeamId()][player->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()))
+    if (m_PlayersInWar[player->GetTeamId()].count(player->GetGUID()) || m_InvitedPlayers[player->GetTeamId()].count(player->GetGUID()))
         return;
 
-    m_PlayersWillBeKick[plr->GetTeamId()].erase(plr->GetGUID());
+    m_PlayersWillBeKick[player->GetTeamId()].erase(player->GetGUID());
-    m_InvitedPlayers[plr->GetTeamId()][plr->GetGUID()] = time(NULL) + m_TimeForAcceptInvite;
+    m_InvitedPlayers[player->GetTeamId()][player->GetGUID()] = time(NULL) + m_TimeForAcceptInvite;
-    plr->GetSession()->SendBfInvitePlayerToWar(m_BattleId, m_ZoneId, m_TimeForAcceptInvite);
+    player->GetSession()->SendBfInvitePlayerToWar(m_BattleId, m_ZoneId, m_TimeForAcceptInvite);
 }
 
 void Battlefield::InitStalker(uint32 entry, float x, float y, float z, float o)
@@ -291,16 +291,16 @@ 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 (Player* player = sObjectAccessor->FindPlayer(*itr))
-                if (plr->isAFK())
+                if (player->isAFK())
                     KickPlayerFromBf(*itr);
 }
 
 void Battlefield::KickPlayerFromBf(uint64 guid)
 {
-    if (Player* plr = sObjectAccessor->FindPlayer(guid))
+    if (Player* player = sObjectAccessor->FindPlayer(guid))
-        if (plr->GetZoneId() == GetZoneId())
+        if (player->GetZoneId() == GetZoneId())
-            plr->TeleportTo(KickPosition);
+            player->TeleportTo(KickPosition);
 }
 
 void Battlefield::StartBattle()
@@ -358,47 +358,47 @@ void Battlefield::PlaySoundToAll(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 = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
-                plr->GetSession()->SendPacket(&data);
+                player->GetSession()->SendPacket(&data);
         }
 }
 
-bool Battlefield::HasPlayer(Player *plr) const
+bool Battlefield::HasPlayer(Player *player) const
 {
-    return m_players[plr->GetTeamId()].find(plr->GetGUID()) != m_players[plr->GetTeamId()].end();
+    return m_players[player->GetTeamId()].find(player->GetGUID()) != m_players[player->GetTeamId()].end();
 }
 
 // Called in WorldSession::HandleBfQueueInviteResponse
-void Battlefield::PlayerAcceptInviteToQueue(Player *plr)
+void Battlefield::PlayerAcceptInviteToQueue(Player *player)
 {
     // Add player in queueVenez
-    m_PlayersInQueue[plr->GetTeamId()].insert(plr->GetGUID());
+    m_PlayersInQueue[player->GetTeamId()].insert(player->GetGUID());
     // Send notification
-    plr->GetSession()->SendBfQueueInviteResponce(m_BattleId, m_ZoneId);
+    player->GetSession()->SendBfQueueInviteResponce(m_BattleId, m_ZoneId);
 }
 // Called in WorldSession::HandleBfExitRequest
-void Battlefield::AskToLeaveQueue(Player *plr)
+void Battlefield::AskToLeaveQueue(Player *player)
 {
     // Remove player from queue
-    m_PlayersInQueue[plr->GetTeamId()].erase(plr->GetGUID());
+    m_PlayersInQueue[player->GetTeamId()].erase(player->GetGUID());
 }
 
 // Called in WorldSession::HandleBfEntryInviteResponse
-void Battlefield::PlayerAcceptInviteToWar(Player *plr)
+void Battlefield::PlayerAcceptInviteToWar(Player *player)
 {
     if (!IsWarTime())
         return;
 
-    if (AddOrSetPlayerToCorrectBfGroup(plr))
+    if (AddOrSetPlayerToCorrectBfGroup(player))
     {
-        plr->GetSession()->SendBfEntered(m_BattleId);
+        player->GetSession()->SendBfEntered(m_BattleId);
-        m_PlayersInWar[plr->GetTeamId()].insert(plr->GetGUID());
+        m_PlayersInWar[player->GetTeamId()].insert(player->GetGUID());
-        m_InvitedPlayers[plr->GetTeamId()].erase(plr->GetGUID());
+        m_InvitedPlayers[player->GetTeamId()].erase(player->GetGUID());
         //Remove player AFK
-        if (plr->isAFK())
+        if (player->isAFK())
-            plr->ToggleAFK();
+            player->ToggleAFK();
 
-        OnPlayerJoinWar(plr);                               //for scripting
+        OnPlayerJoinWar(player);                               //for scripting
     }
 }
 
@@ -406,36 +406,36 @@ 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 = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
-                plr->CastSpell(plr, (uint32) spellId, true);
+                player->CastSpell(player, (uint32) spellId, true);
     else
         for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
-            if (Player* plr = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
-                plr->RemoveAuraFromStack((uint32) - spellId);
+                player->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 = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
-                plr->GetSession()->SendPacket(&data);
+                player->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 = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
-                plr->GetSession()->SendPacket(&data);
+                player->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 = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
-                plr->GetSession()->SendPacket(&data);
+                player->GetSession()->SendPacket(&data);
 }
 
 WorldPacket Battlefield::BuildWarningAnnPacket(std::string msg)
@@ -477,22 +477,22 @@ void Battlefield::SendWarningToAllInZone(uint32 entry)
     WorldPacket data = BuildWarningAnnPacket(msg);
     BroadcastPacketWar(data);
 }*/
-void Battlefield::SendWarningToPlayer(Player *plr, uint32 entry)
+void Battlefield::SendWarningToPlayer(Player *player, uint32 entry)
 {
-    if (!plr)
+    if (!player)
         return;
 
     if (Unit* unit = sObjectAccessor->FindUnit(StalkerGuid))
         if (Creature* stalker = unit->ToCreature())
-            sCreatureTextMgr->SendChat(stalker, (uint8)entry, plr->GetGUID());
+            sCreatureTextMgr->SendChat(stalker, (uint8)entry, player->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 = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
-                plr->SendUpdateWorldState(field, value);
+                player->SendUpdateWorldState(field, value);
 }
 
 void Battlefield::RegisterZone(uint32 zoneId)
@@ -550,30 +550,30 @@ Group *Battlefield::GetGroupPlayer(uint64 guid, TeamId TeamId)
     return NULL;
 }
 
-bool Battlefield::AddOrSetPlayerToCorrectBfGroup(Player *plr)
+bool Battlefield::AddOrSetPlayerToCorrectBfGroup(Player *player)
 {
-    if (!plr->IsInWorld())
+    if (!player->IsInWorld())
         return false;
 
-    if (Group* group = plr->GetGroup())
+    if (Group* group = player->GetGroup())
-        group->RemoveMember(plr->GetGUID());
+        group->RemoveMember(player->GetGUID());
 
-    Group* group = GetFreeBfRaid(plr->GetTeamId());
+    Group* group = GetFreeBfRaid(player->GetTeamId());
     if (!group)
     {
         group = new Group;
         group->SetBattlefieldGroup(this);
-        group->Create(plr);
+        group->Create(player);
         sGroupMgr->AddGroup(group);
-        m_Groups[plr->GetTeamId()].insert(group->GetGUID());
+        m_Groups[player->GetTeamId()].insert(group->GetGUID());
     }
-    else if (group->IsMember(plr->GetGUID()))
+    else if (group->IsMember(player->GetGUID()))
     {
-        uint8 subgroup = group->GetMemberGroup(plr->GetGUID());
+        uint8 subgroup = group->GetMemberGroup(player->GetGUID());
-        plr->SetBattlegroundOrBattlefieldRaid(group, subgroup);
+        player->SetBattlegroundOrBattlefieldRaid(group, subgroup);
     }
     else
-        group->AddMember(plr);
+        group->AddMember(player);
 
     return true;
 }
@@ -601,7 +601,7 @@ BfGraveYard *Battlefield::GetGraveYardById(uint32 id)
     return NULL;
 }
 
-WorldSafeLocsEntry const *Battlefield::GetClosestGraveYard(Player *plr)
+WorldSafeLocsEntry const *Battlefield::GetClosestGraveYard(Player *player)
 {
     BfGraveYard* closestGY = NULL;
     float maxdist = -1;
@@ -609,10 +609,10 @@ WorldSafeLocsEntry const *Battlefield::GetClosestGraveYard(Player *plr)
     {
         if (m_GraveYardList[i])
         {
-            if (m_GraveYardList[i]->GetControlTeamId() != plr->GetTeamId())
+            if (m_GraveYardList[i]->GetControlTeamId() != player->GetTeamId())
                 continue;
 
-            float dist = m_GraveYardList[i]->GetDistance(plr);
+            float dist = m_GraveYardList[i]->GetDistance(player);
             if (dist < maxdist || maxdist < 0)
             {
                 closestGY = m_GraveYardList[i];
@@ -699,10 +699,10 @@ void BfGraveYard::SetSpirit(Creature* spirit, TeamId team)
     spirit->SetReactState(REACT_PASSIVE);
 }
 
-float BfGraveYard::GetDistance(Player *plr)
+float BfGraveYard::GetDistance(Player *player)
 {
     const WorldSafeLocsEntry* ws = sWorldSafeLocsStore.LookupEntry(m_GraveyardId);
-    return plr->GetDistance2d(ws->x, ws->y);
+    return player->GetDistance2d(ws->x, ws->y);
 }
 
 void BfGraveYard::AddPlayer(uint64 player_guid)
@@ -711,8 +711,8 @@ void BfGraveYard::AddPlayer(uint64 player_guid)
     {
         m_ResurrectQueue.insert(player_guid);
 
-        if (Player* plr = sObjectAccessor->FindPlayer(player_guid))
+        if (Player* player = sObjectAccessor->FindPlayer(player_guid))
-            plr->CastSpell(plr, SPELL_WAITING_FOR_RESURRECT, true);
+            player->CastSpell(player, SPELL_WAITING_FOR_RESURRECT, true);
     }
 }
 
@@ -720,8 +720,8 @@ void BfGraveYard::RemovePlayer(uint64 player_guid)
 {
     m_ResurrectQueue.erase(m_ResurrectQueue.find(player_guid));
 
-    if (Player* plr = sObjectAccessor->FindPlayer(player_guid))
+    if (Player* player = sObjectAccessor->FindPlayer(player_guid))
-        plr->RemoveAurasDueToSpell(SPELL_WAITING_FOR_RESURRECT);
+        player->RemoveAurasDueToSpell(SPELL_WAITING_FOR_RESURRECT);
 }
 
 void BfGraveYard::Resurrect()
@@ -732,22 +732,22 @@ void BfGraveYard::Resurrect()
     for (GuidSet::const_iterator itr = m_ResurrectQueue.begin(); itr != m_ResurrectQueue.end(); ++itr)
     {
         // Get player object from his guid
-        Player* plr = sObjectAccessor->FindPlayer(*itr);
+        Player* player = sObjectAccessor->FindPlayer(*itr);
-        if (!plr)
+        if (!player)
             continue;
 
         // Check player isinworld and player is on good graveyard
-        if (plr->IsInWorld())
+        if (player->IsInWorld())
             if (Unit* spirit = sObjectAccessor->FindUnit(m_SpiritGuide[m_ControlTeam]))
                 spirit->CastSpell(spirit, SPELL_SPIRIT_HEAL, true);
 
         // Resurect player
-        plr->CastSpell(plr, SPELL_RESURRECTION_VISUAL, true);
+        player->CastSpell(player, SPELL_RESURRECTION_VISUAL, true);
-        plr->ResurrectPlayer(1.0f);
+        player->ResurrectPlayer(1.0f);
-        plr->CastSpell(plr, 6962, true);
+        player->CastSpell(player, 6962, true);
-        plr->CastSpell(plr, SPELL_SPIRIT_HEAL_MANA, true);
+        player->CastSpell(player, SPELL_SPIRIT_HEAL_MANA, true);
 
-        sObjectAccessor->ConvertCorpseForPlayer(plr->GetGUID());
+        sObjectAccessor->ConvertCorpseForPlayer(player->GetGUID());
     }
 
     m_ResurrectQueue.clear();
@@ -773,17 +773,17 @@ void BfGraveYard::RelocateDeadPlayers()
     WorldSafeLocsEntry const* ClosestGrave = NULL;
     for (GuidSet::const_iterator itr = m_ResurrectQueue.begin(); itr != m_ResurrectQueue.end(); ++itr)
     {
-        Player* plr = sObjectAccessor->FindPlayer(*itr);
+        Player* player = sObjectAccessor->FindPlayer(*itr);
-        if (!plr)
+        if (!player)
             continue;
 
         if (ClosestGrave)
-            plr->TeleportTo(plr->GetMapId(), ClosestGrave->x, ClosestGrave->y, ClosestGrave->z, plr->GetOrientation());
+            player->TeleportTo(player->GetMapId(), ClosestGrave->x, ClosestGrave->y, ClosestGrave->z, player->GetOrientation());
         else
         {
-            ClosestGrave = m_Bf->GetClosestGraveYard(plr);
+            ClosestGrave = m_Bf->GetClosestGraveYard(player);
             if (ClosestGrave)
-                plr->TeleportTo(plr->GetMapId(), ClosestGrave->x, ClosestGrave->y, ClosestGrave->z, plr->GetOrientation());
+                player->TeleportTo(player->GetMapId(), ClosestGrave->x, ClosestGrave->y, ClosestGrave->z, player->GetOrientation());
         }
     }
 }
@@ -877,22 +877,22 @@ BfCapturePoint::BfCapturePoint(Battlefield *Bf):m_Bf(Bf), m_capturePoint(NULL)
     m_maxSpeed = 0;
 }
 
-bool BfCapturePoint::HandlePlayerEnter(Player *plr)
+bool BfCapturePoint::HandlePlayerEnter(Player *player)
 {
     if (m_capturePoint)
     {
-        plr->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldState1, 1);
+        player->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));
+        player->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);
+        player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldstate3, m_neutralValuePct);
     }
-    return m_activePlayers[plr->GetTeamId()].insert(plr->GetGUID()).second;
+    return m_activePlayers[player->GetTeamId()].insert(player->GetGUID()).second;
 }
 
-void BfCapturePoint::HandlePlayerLeave(Player *plr)
+void BfCapturePoint::HandlePlayerLeave(Player *player)
 {
     if (m_capturePoint)
-        plr->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldState1, 0);
+        player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldState1, 0);
-    m_activePlayers[plr->GetTeamId()].erase(plr->GetGUID());
+    m_activePlayers[player->GetTeamId()].erase(player->GetGUID());
 }
 
 void BfCapturePoint::SendChangePhase()
@@ -965,9 +965,9 @@ bool BfCapturePoint::Update(uint32 diff)
 
     for (uint8 team = 0; team < 2; ++team)
         for (GuidSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr)
-            if (Player* plr = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
-                if (!m_capturePoint->IsWithinDistInMap(plr, radius) || !plr->IsOutdoorPvPActive())
+                if (!m_capturePoint->IsWithinDistInMap(player, radius) || !player->IsOutdoorPvPActive())
-                    HandlePlayerLeave(plr);
+                    HandlePlayerLeave(player);
 
     std::list < Player * >players;
     Trinity::AnyPlayerInObjectRangeCheck checker(m_capturePoint, radius);
@@ -1069,8 +1069,8 @@ 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 = sObjectAccessor->FindPlayer(*itr))
+            if (Player* player = sObjectAccessor->FindPlayer(*itr))
-                plr->SendUpdateWorldState(field, value);
+                player->SendUpdateWorldState(field, value);
 }
 
 void BfCapturePoint::SendObjectiveComplete(uint32 id, uint64 guid)
@@ -1090,11 +1090,11 @@ void BfCapturePoint::SendObjectiveComplete(uint32 id, uint64 guid)
 
     // 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 = sObjectAccessor->FindPlayer(*itr))
+        if (Player* player = sObjectAccessor->FindPlayer(*itr))
-            plr->KilledMonsterCredit(id, guid);
+            player->KilledMonsterCredit(id, guid);
 }
 
-bool BfCapturePoint::IsInsideObjective(Player *plr) const
+bool BfCapturePoint::IsInsideObjective(Player *player) const
 {
-    return m_activePlayers[plr->GetTeamId()].find(plr->GetGUID()) != m_activePlayers[plr->GetTeamId()].end();
+    return m_activePlayers[player->GetTeamId()].find(player->GetGUID()) != m_activePlayers[player->GetTeamId()].end();
 }

src/server/game/Battlefield/Battlefield.h

@@ -88,12 +88,12 @@ public:
     void SendObjectiveComplete(uint32 id, uint64 guid);
 
     // used when player is activated/inactivated in the area
-    virtual bool HandlePlayerEnter(Player * plr);
+    virtual bool HandlePlayerEnter(Player * player);
-    virtual void HandlePlayerLeave(Player * plr);
+    virtual void HandlePlayerLeave(Player * player);
-    //virtual void HandlePlayerActivityChanged(Player * plr);
+    //virtual void HandlePlayerActivityChanged(Player * player);
 
     // checks if player is in range of a capture credit marker
-    bool IsInsideObjective(Player * plr) const;
+    bool IsInsideObjective(Player * player) const;
 
     // returns true if the state of the objective has changed, in this case, the OutdoorPvP must send a world state ui update.
     virtual bool Update(uint32 diff);
@@ -144,7 +144,7 @@ public:
     TeamId GetControlTeamId() { return m_ControlTeam; }
 
     // use for found the nearest graveyard
-    float GetDistance(Player * plr);
+    float GetDistance(Player * player);
     void Initialize(TeamId startcontrol, uint32 gy);
     void SetSpirit(Creature* spirit, TeamId team);
     void AddPlayer(uint64 player_guid);
@@ -237,10 +237,10 @@ class Battlefield:public ZoneScript
      */
     void KickPlayerFromBf(uint64 guid);
 
-    /// Called when player (plr) enter in zone
+    /// Called when player (player) enter in zone
-    void HandlePlayerEnterZone(Player * plr, uint32 zone);
+    void HandlePlayerEnterZone(Player * player, uint32 zone);
-    /// Called when player (plr) leave the zone
+    /// Called when player (player) leave the zone
-    void HandlePlayerLeaveZone(Player * plr, uint32 zone);
+    void HandlePlayerLeaveZone(Player * player, uint32 zone);
 
     // All-purpose data storage 64 bit
     virtual uint64 GetData64(uint32 DataId) { return m_Data64[DataId]; }
@@ -258,17 +258,17 @@ class Battlefield:public ZoneScript
     // Group methods
     /**
      * \brief Find a not full battlefield group, if there is no, create one
-     * \param TeamId : Id of player team for who we search a group (plr->GetTeamId())
+     * \param TeamId : Id of player team for who we search a group (player->GetTeamId())
      */
     Group *GetFreeBfRaid(TeamId TeamId);
     /// Return battlefield group where player is.
     Group *GetGroupPlayer(uint64 guid, TeamId TeamId);
     /// Force player to join a battlefield group
-    bool AddOrSetPlayerToCorrectBfGroup(Player * plr);
+    bool AddOrSetPlayerToCorrectBfGroup(Player * player);
 
     // Graveyard methods
     // Find which graveyard the player must be teleported to to be resurrected by spiritguide
-    WorldSafeLocsEntry const *GetClosestGraveYard(Player * plr);
+    WorldSafeLocsEntry const *GetClosestGraveYard(Player * player);
 
     virtual void AddPlayerToResurrectQueue(uint64 npc_guid, uint64 player_guid);
     void RemovePlayerFromResurrectQueue(uint64 player_guid);
@@ -289,23 +289,23 @@ class Battlefield:public ZoneScript
     /// Called x minutes before battle start when player in zone are invite to join queue
     virtual void OnStartGrouping() {};
     /// Called when a player accept to join the battle
-    virtual void OnPlayerJoinWar(Player * /*plr */ ) {};
+    virtual void OnPlayerJoinWar(Player * /*player */ ) {};
     /// Called when a player leave the battle
-    virtual void OnPlayerLeaveWar(Player * /*plr */ ) {};
+    virtual void OnPlayerLeaveWar(Player * /*player */ ) {};
     /// Called when a player leave battlefield zone
-    virtual void OnPlayerLeaveZone(Player * /*plr */ ) {};
+    virtual void OnPlayerLeaveZone(Player * /*player */ ) {};
     /// Called when a player enter in battlefield zone
-    virtual void OnPlayerEnterZone(Player * /*plr */ ) {};
+    virtual void OnPlayerEnterZone(Player * /*player */ ) {};
 
     WorldPacket BuildWarningAnnPacket(std::string msg);
     void SendWarningToAllInZone(uint32 entry);
     //void SendWarningToAllInWar(int32 entry, ...); -- UNUSED
-    void SendWarningToPlayer(Player * plr, uint32 entry);
+    void SendWarningToPlayer(Player * player, uint32 entry);
 
-    void PlayerAcceptInviteToQueue(Player * plr);
+    void PlayerAcceptInviteToQueue(Player * player);
-    void PlayerAcceptInviteToWar(Player * plr);
+    void PlayerAcceptInviteToWar(Player * player);
     uint32 GetBattleId() { return m_BattleId; }
-    void AskToLeaveQueue(Player * plr);
+    void AskToLeaveQueue(Player * player);
 
     virtual void DoCompleteOrIncrementAchievement(uint32 /*achievement */ , Player * /*player */ , uint8 /*incrementNumber = 1 */ ) {};
 
@@ -329,8 +329,8 @@ class Battlefield:public ZoneScript
 
     void PlaySoundToAll(uint32 SoundID);
 
-    void InvitePlayerToQueue(Player * plr);
+    void InvitePlayerToQueue(Player * player);
-    void InvitePlayerToWar(Player * plr);
+    void InvitePlayerToWar(Player * player);
 
     void InitStalker(uint32 entry, float x, float y, float z, float o);
 
@@ -382,7 +382,7 @@ protected:
 
     void KickAfk();
     // use for switch off all worldstate for client
-    virtual void SendRemoveWorldStates(Player * /*plr */ ) {}
+    virtual void SendRemoveWorldStates(Player * /*player */ ) {}
 
     // use for send a packet for all player list
     void BroadcastPacketZone(WorldPacket & data) const;
@@ -401,7 +401,7 @@ protected:
     }
 
     void RegisterZone(uint32 zoneid);
-    bool HasPlayer(Player * plr) const;
+    bool HasPlayer(Player * player) const;
     void TeamCastSpell(TeamId team, int32 spellId);
 
 };

src/server/game/Battlefield/BattlefieldHandler.cpp

@@ -75,7 +75,7 @@ void WorldSession::SendBfQueueInviteResponce(uint32 BattleId,uint32 ZoneId, bool
 //Param1:(BattleId) the BattleId of Bf
 void WorldSession::SendBfEntered(uint32 BattleId)
 {
-//    m_PlayerInWar[plr->GetTeamId()].insert(plr->GetGUID());
+//    m_PlayerInWar[player->GetTeamId()].insert(player->GetGUID());
     WorldPacket data(SMSG_BATTLEFIELD_MGR_ENTERED, 7);
     data << uint32(BattleId);
     data << uint8(1);                                       //unk

src/server/game/Battlefield/BattlefieldMgr.cpp

@@ -0,0 +1,143 @@
+/*
+ * 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 "BattlefieldMgr.h"
+#include "Zones/BattlefieldWG.h"
+#include "ObjectMgr.h"
+#include "Player.h"
+
+BattlefieldMgr::BattlefieldMgr()
+{
+    m_UpdateTimer = 0;
+    //sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Instantiating BattlefieldMgr");
+}
+
+BattlefieldMgr::~BattlefieldMgr()
+{
+    //sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Deleting BattlefieldMgr");
+    for (BattlefieldSet::iterator itr = m_BattlefieldSet.begin(); itr != m_BattlefieldSet.end(); ++itr)
+        delete *itr;
+}
+
+void BattlefieldMgr::InitBattlefield()
+{
+    Battlefield* pBf = new BattlefieldWG;
+    // respawn, init variables
+    if (!pBf->SetupBattlefield())
+    {
+        sLog->outString();
+        sLog->outString("Battlefield : Wintergrasp init failed.");
+        delete pBf;
+    }
+    else
+    {
+        m_BattlefieldSet.push_back(pBf);
+        sLog->outString();
+        sLog->outString("Battlefield : Wintergrasp successfully initiated.");
+    }
+
+    /* For Cataclysm: Tol Barad
+       pBf = new BattlefieldTB;
+       // respawn, init variables
+       if(!pBf->SetupBattlefield())
+       {
+       sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Battlefield : Tol Barad init failed.");
+       delete pBf;
+       }
+       else
+       {
+       m_BattlefieldSet.push_back(pBf);
+       sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Battlefield : Tol Barad successfully initiated.");
+       } */
+}
+
+void BattlefieldMgr::AddZone(uint32 zoneid, Battlefield *handle)
+{
+    m_BattlefieldMap[zoneid] = handle;
+}
+
+void BattlefieldMgr::HandlePlayerEnterZone(Player * player, uint32 zoneid)
+{
+    BattlefieldMap::iterator itr = m_BattlefieldMap.find(zoneid);
+    if (itr == m_BattlefieldMap.end())
+        return;
+
+    if (itr->second->HasPlayer(player))
+        return;
+    if (itr->second->GetEnable() == false)
+        return;
+    itr->second->HandlePlayerEnterZone(player, zoneid);
+    sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Player %u entered outdoorpvp id %u", player->GetGUIDLow(), itr->second->GetTypeId());
+}
+
+void BattlefieldMgr::HandlePlayerLeaveZone(Player * player, uint32 zoneid)
+{
+    BattlefieldMap::iterator itr = m_BattlefieldMap.find(zoneid);
+    if (itr == m_BattlefieldMap.end())
+        return;
+
+    // teleport: remove once in removefromworld, once in updatezone
+    if (!itr->second->HasPlayer(player))
+        return;
+    itr->second->HandlePlayerLeaveZone(player, zoneid);
+    sLog->outDebug(LOG_FILTER_BATTLEFIELD, "Player %u left outdoorpvp id %u", player->GetGUIDLow(), itr->second->GetTypeId());
+}
+
+Battlefield *BattlefieldMgr::GetBattlefieldToZoneId(uint32 zoneid)
+{
+    BattlefieldMap::iterator itr = m_BattlefieldMap.find(zoneid);
+    if (itr == m_BattlefieldMap.end())
+    {
+        // no handle for this zone, return
+        return NULL;
+    }
+    if (itr->second->GetEnable() == false)
+        return NULL;
+    return itr->second;
+}
+
+Battlefield *BattlefieldMgr::GetBattlefieldByBattleId(uint32 battleid)
+{
+    for (BattlefieldSet::iterator itr = m_BattlefieldSet.begin(); itr != m_BattlefieldSet.end(); ++itr)
+    {
+        if ((*itr)->GetBattleId() == battleid)
+            return (*itr);
+    }
+    return NULL;
+}
+
+void BattlefieldMgr::Update(uint32 diff)
+{
+    m_UpdateTimer += diff;
+    if (m_UpdateTimer > BATTLEFIELD_OBJECTIVE_UPDATE_INTERVAL)
+    {
+        for (BattlefieldSet::iterator itr = m_BattlefieldSet.begin(); itr != m_BattlefieldSet.end(); ++itr)
+            if ((*itr)->GetEnable())
+                (*itr)->Update(m_UpdateTimer);
+        m_UpdateTimer = 0;
+    }
+}
+
+ZoneScript *BattlefieldMgr::GetZoneScript(uint32 zoneId)
+{
+    BattlefieldMap::iterator itr = m_BattlefieldMap.find(zoneId);
+    if (itr != m_BattlefieldMap.end())
+        return itr->second;
+    else
+        return NULL;
+}

src/server/game/Battlefield/BattlefieldMgr.h

@@ -40,11 +40,11 @@ class BattlefieldMgr
     // create battlefield events
     void InitBattlefield();
     // called when a player enters an battlefield area
-    void HandlePlayerEnterZone(Player * plr, uint32 areaflag);
+    void HandlePlayerEnterZone(Player * player, uint32 areaflag);
     // called when player leaves an battlefield area
-    void HandlePlayerLeaveZone(Player * plr, uint32 areaflag);
+    void HandlePlayerLeaveZone(Player * player, uint32 areaflag);
     // called when player resurrects
-    void HandlePlayerResurrects(Player * plr, uint32 areaflag);
+    void HandlePlayerResurrects(Player * player, uint32 areaflag);
     // return assigned battlefield
     Battlefield *GetBattlefieldToZoneId(uint32 zoneid);
     Battlefield *GetBattlefieldByBattleId(uint32 battleid);
@@ -59,7 +59,7 @@ class BattlefieldMgr
 
     bool CanTalkTo(Player * player, Creature * creature, GossipMenuItems gso);
 
-    void HandleDropFlag(Player * plr, uint32 spellId);
+    void HandleDropFlag(Player * player, uint32 spellId);
 
     typedef std::vector < Battlefield * >BattlefieldSet;
     typedef std::map < uint32 /* zoneid */ , Battlefield * >BattlefieldMap;

src/server/game/Battlefield/Zones/BattlefieldWG.h

@@ -315,30 +315,30 @@ class BattlefieldWG : public Battlefield
          * -Teleport if it needed
          * -Update worldstate
          * -Update tenacity
-         * \param plr: Player who accept invite
+         * \param player: Player who accept invite
          */
-        void OnPlayerJoinWar(Player *plr);
+        void OnPlayerJoinWar(Player *player);
 
         /**
          * \brief Called when player leave battle
          * -Update player aura
-         * \param plr : Player who leave battle
+         * \param player : Player who leave battle
          */
-        void OnPlayerLeaveWar(Player *plr);
+        void OnPlayerLeaveWar(Player *player);
 
         /**
          * \brief Called when player leave WG zone
-         * \param plr : Player who leave zone
+         * \param player : Player who leave zone
          */
-        void OnPlayerLeaveZone(Player *plr);
+        void OnPlayerLeaveZone(Player *player);
 
         /**
          * \brief Called when player enter in WG zone
          * -Update aura
          * -Update worldstate
-         * \param plr : Player who leave zone
+         * \param player : Player who leave zone
          */
-        void OnPlayerEnterZone(Player *plr);
+        void OnPlayerEnterZone(Player *player);
 
         /**
          * \brief Called for update battlefield data
@@ -415,13 +415,13 @@ class BattlefieldWG : public Battlefield
             m_CanClickOnOrb = allow;
         }
 
-        void RewardMarkOfHonor(Player *plr, uint32 count);
+        void RewardMarkOfHonor(Player *player, uint32 count);
 
         void UpdateVehicleCountWG();
         void UpdateCounterVehicle(bool init);
 
         WorldPacket BuildInitWorldStates();
-        void SendInitWorldStatesTo(Player * plr);
+        void SendInitWorldStatesTo(Player * player);
         void SendInitWorldStatesToAll();
 
         void HandleKill(Player *killer, Unit *victim);